# Semantic extraction: subagent prompt, coverage check and merge (Step B2 prompt + Step B3) Moved out of SKILL.md so it is read only when documents, papers or images need extraction. Subagent prompt template: See `references/extraction-spec.md` for the exact subagent prompt (JSON schema, node-ID rules, confidence rubric, frontmatter, hyperedge, and vision rules). Load it only here, only when at least one chunk holds a doc, paper, or image; a pure-code corpus has skipped Part B and never reads it. Pass each subagent that prompt verbatim with FILE_LIST, CHUNK_NUM, TOTAL_CHUNKS, DEEP_MODE, and CHUNK_PATH substituted, and have it write the result to CHUNK_PATH. **Step B3 - Collect, cache, and merge** Wait for all subagents. For each result: - Check that `graphify-out/.graphify_chunk_NN.json` exists on disk — this is the success signal - If the file exists and contains valid JSON with `nodes` and `edges`, include it and save to cache - If the file is missing, the subagent was likely dispatched as read-only (Explore type) — print a warning: "chunk N missing from disk — subagent may have been read-only. Re-run with general-purpose agent." Do not silently skip. - If a subagent failed or returned invalid JSON, print a warning and skip that chunk - do not abort If more than half the chunks failed or are missing, stop and tell the user to re-run and ensure `subagent_type="general-purpose"` is used. **Step B3.5 - Verify each reported file was actually read to its end** A subagent that only read the first Read call's worth of a long file still writes a well-formed chunk, so "chunk file exists and parses" is not evidence of coverage. Compare each file's self-reported `coverage` against its real length: ```bash $(cat graphify-out/.graphify_python) -c " import json, glob from pathlib import Path INPUT_PATH = Path('graphify-out/.graphify_root').read_text(encoding=\"utf-8-sig\").strip() covered = {} for c in sorted(glob.glob('graphify-out/.graphify_chunk_*.json')): d = json.loads(Path(c).read_text(encoding=\"utf-8\")) for src, n in (d.get('coverage') or {}).items(): covered[src] = max(covered.get(src, 0), int(n)) partial = [] for src, n in sorted(covered.items()): p = Path(src) if not p.is_absolute(): p = Path(INPUT_PATH) / src if not p.is_file(): continue total = sum(1 for _ in p.open(encoding='utf-8', errors='replace')) if total and n < total: partial.append((src, n, total)) Path('graphify-out/.graphify_partial.txt').write_text('\n'.join(s for s, _, _ in partial), encoding=\"utf-8\") if partial: print(f'WARNING: {len(partial)} file(s) were only partly read. They are cached as partial and retried on the next --update:') for src, n, total in partial: print(f' {src}: read {n} of {total} lines') else: print('Coverage OK - every file a subagent reported was read to its last line') " ``` Tell the user which files came up short and what was lost (the line counts are printed above). The nodes already extracted for those files are kept - they are still true - but the file is cached as partial and left unstamped in the manifest below, so the next `--update` re-dispatches it and replace-on-re-extract swaps the partial node set for a complete one. This is the same mechanism the library path uses for a truncated LLM response (#933, #1950), so both paths now recover instead of silently keeping a half-read file forever. A file a subagent did not report at all is not counted as partial - there is nothing to compare against - which is why the prompt rule in `references/extraction-spec.md` asks for the count in the first place. Merge all chunk files into `.graphify_semantic_new.json`. **After each Agent call completes, read the real token counts from the Agent tool result's `usage` field and write them back into the chunk JSON before merging** — the chunk JSON itself always has placeholder zeros. Then run: ```bash $(cat graphify-out/.graphify_python) -c " import json, glob from pathlib import Path chunks = sorted(glob.glob('graphify-out/.graphify_chunk_*.json')) all_nodes, all_edges, all_hyperedges = [], [], [] total_in, total_out = 0, 0 for c in chunks: d = json.loads(Path(c).read_text(encoding=\"utf-8\")) all_nodes += d.get('nodes', []) all_edges += d.get('edges', []) all_hyperedges += d.get('hyperedges', []) total_in += d.get('input_tokens', 0) total_out += d.get('output_tokens', 0) Path('graphify-out/.graphify_semantic_new.json').write_text(json.dumps({ 'nodes': all_nodes, 'edges': all_edges, 'hyperedges': all_hyperedges, 'input_tokens': total_in, 'output_tokens': total_out, }, indent=2, ensure_ascii=False), encoding=\"utf-8\") print(f'Merged {len(chunks)} chunks: {total_in:,} in / {total_out:,} out tokens') " ``` Save new results to cache. Pass the same SPEC_PATH as Step B0 — it stamps each entry with the prompt that produced it, and a write under a different prompt than the read lands where the next run won't look (#1939): ```bash $(cat graphify-out/.graphify_python) -c " import json from graphify.cache import save_semantic_cache from pathlib import Path new = json.loads(Path('graphify-out/.graphify_semantic_new.json').read_text(encoding=\"utf-8\")) if Path('graphify-out/.graphify_semantic_new.json').exists() else {'nodes':[],'edges':[],'hyperedges':[]} uncached = [line for line in Path('graphify-out/.graphify_uncached.txt').read_text(encoding=\"utf-8\").splitlines() if line] # A partly-read file is cached with partial: True, which load_cached treats as a MISS, # so the next --update re-dispatches it instead of serving a truncated extraction forever # (#2225). Same contract the library path uses for a truncated LLM response (#933/#1950). partial = [line for line in Path('graphify-out/.graphify_partial.txt').read_text(encoding=\"utf-8\").splitlines() if line] if Path('graphify-out/.graphify_partial.txt').exists() else [] INPUT_PATH = Path('graphify-out/.graphify_root').read_text(encoding=\"utf-8-sig\").strip() saved = save_semantic_cache(new.get('nodes', []), new.get('edges', []), new.get('hyperedges', []), root=INPUT_PATH, allowed_source_files=uncached, prompt_file='SPEC_PATH', partial_source_files=partial) note = f' ({len(partial)} left partial for retry)' if partial else '' print(f'Cached {saved} files' + note) " ``` Merge cached + new results into `graphify-out/.graphify_semantic.json`: ```bash $(cat graphify-out/.graphify_python) -c " import json from pathlib import Path cached = json.loads(Path('graphify-out/.graphify_cached.json').read_text(encoding=\"utf-8\")) if Path('graphify-out/.graphify_cached.json').exists() else {'nodes':[],'edges':[],'hyperedges':[]} new = json.loads(Path('graphify-out/.graphify_semantic_new.json').read_text(encoding=\"utf-8\")) if Path('graphify-out/.graphify_semantic_new.json').exists() else {'nodes':[],'edges':[],'hyperedges':[]} all_nodes = cached['nodes'] + new.get('nodes', []) all_edges = cached['edges'] + new.get('edges', []) all_hyperedges = cached.get('hyperedges', []) + new.get('hyperedges', []) seen = set() deduped = [] for n in all_nodes: if n['id'] not in seen: seen.add(n['id']) deduped.append(n) merged = { 'nodes': deduped, 'edges': all_edges, 'hyperedges': all_hyperedges, 'input_tokens': new.get('input_tokens', 0), 'output_tokens': new.get('output_tokens', 0), } Path('graphify-out/.graphify_semantic.json').write_text(json.dumps(merged, indent=2, ensure_ascii=False), encoding=\"utf-8\") print(f'Extraction complete - {len(deduped)} nodes, {len(all_edges)} edges ({len(cached[\"nodes\"])} from cache, {len(new.get(\"nodes\",[]))} new)') " ``` Clean up temp files: `rm -f graphify-out/.graphify_cached.json graphify-out/.graphify_uncached.txt graphify-out/.graphify_semantic_new.json`