From 739914753f0699d67f98555cbde087508f5620e0 Mon Sep 17 00:00:00 2001 From: ayushcodes10 Date: Thu, 17 Sep 2026 15:42:11 +0530 Subject: [PATCH 1/7] Name the subagent capability requirement, not just its default type Step B2 and B3 named the literal agent type general purpose as the only acceptable choice for the extraction subagent. On a host whose dispatch policy is restricted, an org policy hook or a curated persona registry that refuses that exact type, the skill could not be followed as written, and every diagnostic pointed the user back at the one type their host would not permit. The instructions now state what actually matters, that the subagent needs Write and Bash access to build its chunk file on disk, keep general purpose as the default, and tell such a host to dispatch any permitted type that has both tools instead. Applied to the shared dispatch fragment for both bash and PowerShell hosts, the Step B3 re run diagnostics in the core fragment and the devin monolith, and the Kilo specific rule. Co-Authored-By: Claude Sonnet 5 --- tools/skillgen/fragments/core/core.md | 4 ++-- tools/skillgen/fragments/core/devin.md | 4 ++-- .../dispatch/agent-tool-disk-powershell.md | 2 +- .../fragments/dispatch/agent-tool-disk.md | 2 +- tools/skillgen/fragments/extra/kilo-rules.md | 2 +- tools/skillgen/gen.py | 18 ++++++++++++++++++ 6 files changed, 25 insertions(+), 7 deletions(-) diff --git a/tools/skillgen/fragments/core/core.md b/tools/skillgen/fragments/core/core.md index c527a12563..5e07b55bb9 100644 --- a/tools/skillgen/fragments/core/core.md +++ b/tools/skillgen/fragments/core/core.md @@ -216,10 +216,10 @@ Load files from `graphify-out/.graphify_uncached.txt`. Split into chunks of 20-2 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 the file is missing, the subagent was likely dispatched as a read-only type (e.g. Explore) — print a warning: "chunk N missing from disk — subagent may have been dispatched without Write and Bash access. Re-run with a subagent type that has both." 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. +If more than half the chunks failed or are missing, stop and tell the user to re-run using a subagent type that has Write and Bash access (`general-purpose` by default; any host-permitted type with those two tools otherwise). 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 diff --git a/tools/skillgen/fragments/core/devin.md b/tools/skillgen/fragments/core/devin.md index f9be846cbf..7276a7023b 100644 --- a/tools/skillgen/fragments/core/devin.md +++ b/tools/skillgen/fragments/core/devin.md @@ -331,10 +331,10 @@ FILE_LIST Wait for all subagents. For each result: - Check that `graphify-out/.graphify_chunk_N.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 — 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 the file is missing, the subagent was likely dispatched as a read-only type — print a warning: "chunk N missing from disk — subagent may have been dispatched without Write and Bash access. Re-run with a subagent type that has both." 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. +If more than half the chunks failed or are missing, stop and tell the user to re-run using a subagent type that has Write and Bash access (`general-purpose` by default; any host-permitted type with those two tools otherwise). After each subagent call completes, write its result to `graphify-out/.graphify_chunk_N.json`. **After each subagent call completes, read the real token counts from the subagent tool result's `usage` field and write them back into the chunk JSON before merging** — the chunk JSON itself always has placeholder zeros. Then merge: diff --git a/tools/skillgen/fragments/dispatch/agent-tool-disk-powershell.md b/tools/skillgen/fragments/dispatch/agent-tool-disk-powershell.md index 54f2f54e3d..d7e524d060 100644 --- a/tools/skillgen/fragments/dispatch/agent-tool-disk-powershell.md +++ b/tools/skillgen/fragments/dispatch/agent-tool-disk-powershell.md @@ -2,7 +2,7 @@ Call the Agent tool multiple times IN THE SAME RESPONSE - one call per chunk. This is the only way they run in parallel. If you make one Agent call, wait, then make another, you are doing it sequentially and defeating the purpose. -**IMPORTANT - subagent type:** Always use `subagent_type="general-purpose"`. Do NOT use `Explore` - it is read-only and cannot write chunk files to disk, which silently drops extraction results. General-purpose has Write and Bash access which the subagent needs. +**IMPORTANT - subagent type:** the extraction subagent MUST have Write and Bash access - it builds the chunk file on disk itself. Default to `subagent_type="general-purpose"`. Do NOT use `Explore` - it is read-only and cannot write chunk files to disk, which silently drops extraction results. If this host's dispatch policy restricts or refuses `general-purpose` (an org policy hook, a curated persona registry), dispatch any available type that lists Write and Bash access instead - that is a host policy constraint, not a graphify requirement. Never downgrade to a read-only type to satisfy a policy; that trades a loud failure for a silent one. Concrete example for 3 chunks: ``` diff --git a/tools/skillgen/fragments/dispatch/agent-tool-disk.md b/tools/skillgen/fragments/dispatch/agent-tool-disk.md index 9e07ca5db3..4e7fadf7ec 100644 --- a/tools/skillgen/fragments/dispatch/agent-tool-disk.md +++ b/tools/skillgen/fragments/dispatch/agent-tool-disk.md @@ -2,7 +2,7 @@ Call the Agent tool multiple times IN THE SAME RESPONSE - one call per chunk. This is the only way they run in parallel. If you make one Agent call, wait, then make another, you are doing it sequentially and defeating the purpose. -**IMPORTANT - subagent type:** Always use `subagent_type="general-purpose"`. Do NOT use `Explore` - it is read-only and cannot write chunk files to disk, which silently drops extraction results. General-purpose has Write and Bash access which the subagent needs. +**IMPORTANT - subagent type:** the extraction subagent MUST have Write and Bash access - it builds the chunk file on disk itself. Default to `subagent_type="general-purpose"`. Do NOT use `Explore` - it is read-only and cannot write chunk files to disk, which silently drops extraction results. If this host's dispatch policy restricts or refuses `general-purpose` (an org policy hook, a curated persona registry), dispatch any available type that lists Write and Bash access instead - that is a host policy constraint, not a graphify requirement. Never downgrade to a read-only type to satisfy a policy; that trades a loud failure for a silent one. Concrete example for 3 chunks: ``` diff --git a/tools/skillgen/fragments/extra/kilo-rules.md b/tools/skillgen/fragments/extra/kilo-rules.md index c42881efe0..603ed73314 100644 --- a/tools/skillgen/fragments/extra/kilo-rules.md +++ b/tools/skillgen/fragments/extra/kilo-rules.md @@ -2,7 +2,7 @@ - Use the native `Task` tool for semantic extraction fan-out. - Launch all chunk tasks in the same response so they run in parallel. -- Always use `subagent_type="general"` for extraction chunks. +- Default to `subagent_type="general"` for extraction chunks; it needs Write and Bash access, so if a dispatch policy restricts `general`, use any permitted type with both tools instead. - After modifying code files during the session, run `graphify update .`. --- diff --git a/tools/skillgen/gen.py b/tools/skillgen/gen.py index 09e19ede00..e7989292f6 100644 --- a/tools/skillgen/gen.py +++ b/tools/skillgen/gen.py @@ -1142,6 +1142,23 @@ def _is_community_label_export_fix_line(line: str) -> bool: ) +def _is_subagent_capability_wording_fix_line(line: str) -> bool: + """Whether a line is part of the #2525 subagent-capability rewording. + + Step B3's diagnostics named the literal agent type "general-purpose" + rather than the capability that matters (Write and Bash access), so a + host whose dispatch policy restricts or refuses that exact type had no + escape and every diagnostic pointed back at the one type it could not + use. Reworded to name the capability, with general-purpose kept as the + default. Both old and new forms match here. + """ + return ( + "general-purpose" in line + or "Write and Bash access" in line + or "dispatched without Write and Bash access" in line + ) + + # Every line that may differ between a rendered monolith and its pristine v8 # baseline. Each predicate documents one sanctioned change-class; a blank line is # allowed because the multi-line fix blocks insert spacing. Anything else failing @@ -1157,6 +1174,7 @@ def _is_community_label_export_fix_line(line: str) -> bool: _is_manifest_root_fix_line, _is_manifest_stamp_fix_line, _is_sensitive_reporting_fix_line, + _is_subagent_capability_wording_fix_line, _is_no_api_key_fix_line, _is_shebang_allowlist_fix_line, _is_obsidian_usage_comment_line, From cca0e351602bd1b11e330c1c0e4a1c079d404d7b Mon Sep 17 00:00:00 2001 From: ayushcodes10 Date: Thu, 17 Sep 2026 15:42:16 +0530 Subject: [PATCH 2/7] Regenerate skill artifacts for the subagent capability wording fix Co-Authored-By: Claude Sonnet 5 --- graphify/skill-agents.md | 4 ++-- graphify/skill-amp.md | 4 ++-- graphify/skill-claw.md | 6 +++--- graphify/skill-codex.md | 4 ++-- graphify/skill-copilot.md | 6 +++--- graphify/skill-devin.md | 4 ++-- graphify/skill-droid.md | 4 ++-- graphify/skill-kilo.md | 8 ++++---- graphify/skill-kiro.md | 6 +++--- graphify/skill-opencode.md | 4 ++-- graphify/skill-pi.md | 6 +++--- graphify/skill-trae.md | 4 ++-- graphify/skill-vscode.md | 4 ++-- graphify/skill-windows.md | 6 +++--- graphify/skill.md | 6 +++--- tools/skillgen/expected/graphify__skill-agents.md | 4 ++-- tools/skillgen/expected/graphify__skill-amp.md | 4 ++-- tools/skillgen/expected/graphify__skill-claw.md | 6 +++--- tools/skillgen/expected/graphify__skill-codex.md | 4 ++-- tools/skillgen/expected/graphify__skill-copilot.md | 6 +++--- tools/skillgen/expected/graphify__skill-devin.md | 4 ++-- tools/skillgen/expected/graphify__skill-droid.md | 4 ++-- tools/skillgen/expected/graphify__skill-kilo.md | 8 ++++---- tools/skillgen/expected/graphify__skill-kiro.md | 6 +++--- tools/skillgen/expected/graphify__skill-opencode.md | 4 ++-- tools/skillgen/expected/graphify__skill-pi.md | 6 +++--- tools/skillgen/expected/graphify__skill-trae.md | 4 ++-- tools/skillgen/expected/graphify__skill-vscode.md | 4 ++-- tools/skillgen/expected/graphify__skill-windows.md | 6 +++--- tools/skillgen/expected/graphify__skill.md | 6 +++--- 30 files changed, 76 insertions(+), 76 deletions(-) diff --git a/graphify/skill-agents.md b/graphify/skill-agents.md index 190827d9ac..30539649cf 100644 --- a/graphify/skill-agents.md +++ b/graphify/skill-agents.md @@ -278,10 +278,10 @@ See `references/extraction-spec.md` for the exact subagent prompt (JSON schema, 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 the file is missing, the subagent was likely dispatched as a read-only type (e.g. Explore) — print a warning: "chunk N missing from disk — subagent may have been dispatched without Write and Bash access. Re-run with a subagent type that has both." 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. +If more than half the chunks failed or are missing, stop and tell the user to re-run using a subagent type that has Write and Bash access (`general-purpose` by default; any host-permitted type with those two tools otherwise). 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 diff --git a/graphify/skill-amp.md b/graphify/skill-amp.md index 190827d9ac..30539649cf 100644 --- a/graphify/skill-amp.md +++ b/graphify/skill-amp.md @@ -278,10 +278,10 @@ See `references/extraction-spec.md` for the exact subagent prompt (JSON schema, 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 the file is missing, the subagent was likely dispatched as a read-only type (e.g. Explore) — print a warning: "chunk N missing from disk — subagent may have been dispatched without Write and Bash access. Re-run with a subagent type that has both." 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. +If more than half the chunks failed or are missing, stop and tell the user to re-run using a subagent type that has Write and Bash access (`general-purpose` by default; any host-permitted type with those two tools otherwise). 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 diff --git a/graphify/skill-claw.md b/graphify/skill-claw.md index abd2811d23..985298feeb 100644 --- a/graphify/skill-claw.md +++ b/graphify/skill-claw.md @@ -254,7 +254,7 @@ Load files from `graphify-out/.graphify_uncached.txt`. Split into chunks of 20-2 Call the Agent tool multiple times IN THE SAME RESPONSE - one call per chunk. This is the only way they run in parallel. If you make one Agent call, wait, then make another, you are doing it sequentially and defeating the purpose. -**IMPORTANT - subagent type:** Always use `subagent_type="general-purpose"`. Do NOT use `Explore` - it is read-only and cannot write chunk files to disk, which silently drops extraction results. General-purpose has Write and Bash access which the subagent needs. +**IMPORTANT - subagent type:** the extraction subagent MUST have Write and Bash access - it builds the chunk file on disk itself. Default to `subagent_type="general-purpose"`. Do NOT use `Explore` - it is read-only and cannot write chunk files to disk, which silently drops extraction results. If this host's dispatch policy restricts or refuses `general-purpose` (an org policy hook, a curated persona registry), dispatch any available type that lists Write and Bash access instead - that is a host policy constraint, not a graphify requirement. Never downgrade to a read-only type to satisfy a policy; that trades a loud failure for a silent one. Concrete example for 3 chunks: ``` @@ -281,10 +281,10 @@ See `references/extraction-spec.md` for the exact subagent prompt (JSON schema, 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 the file is missing, the subagent was likely dispatched as a read-only type (e.g. Explore) — print a warning: "chunk N missing from disk — subagent may have been dispatched without Write and Bash access. Re-run with a subagent type that has both." 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. +If more than half the chunks failed or are missing, stop and tell the user to re-run using a subagent type that has Write and Bash access (`general-purpose` by default; any host-permitted type with those two tools otherwise). 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 diff --git a/graphify/skill-codex.md b/graphify/skill-codex.md index af3f723c78..49b2f2abe6 100644 --- a/graphify/skill-codex.md +++ b/graphify/skill-codex.md @@ -278,10 +278,10 @@ See `references/extraction-spec.md` for the compact subagent prompt (rules, node 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 the file is missing, the subagent was likely dispatched as a read-only type (e.g. Explore) — print a warning: "chunk N missing from disk — subagent may have been dispatched without Write and Bash access. Re-run with a subagent type that has both." 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. +If more than half the chunks failed or are missing, stop and tell the user to re-run using a subagent type that has Write and Bash access (`general-purpose` by default; any host-permitted type with those two tools otherwise). 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 diff --git a/graphify/skill-copilot.md b/graphify/skill-copilot.md index abd2811d23..985298feeb 100644 --- a/graphify/skill-copilot.md +++ b/graphify/skill-copilot.md @@ -254,7 +254,7 @@ Load files from `graphify-out/.graphify_uncached.txt`. Split into chunks of 20-2 Call the Agent tool multiple times IN THE SAME RESPONSE - one call per chunk. This is the only way they run in parallel. If you make one Agent call, wait, then make another, you are doing it sequentially and defeating the purpose. -**IMPORTANT - subagent type:** Always use `subagent_type="general-purpose"`. Do NOT use `Explore` - it is read-only and cannot write chunk files to disk, which silently drops extraction results. General-purpose has Write and Bash access which the subagent needs. +**IMPORTANT - subagent type:** the extraction subagent MUST have Write and Bash access - it builds the chunk file on disk itself. Default to `subagent_type="general-purpose"`. Do NOT use `Explore` - it is read-only and cannot write chunk files to disk, which silently drops extraction results. If this host's dispatch policy restricts or refuses `general-purpose` (an org policy hook, a curated persona registry), dispatch any available type that lists Write and Bash access instead - that is a host policy constraint, not a graphify requirement. Never downgrade to a read-only type to satisfy a policy; that trades a loud failure for a silent one. Concrete example for 3 chunks: ``` @@ -281,10 +281,10 @@ See `references/extraction-spec.md` for the exact subagent prompt (JSON schema, 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 the file is missing, the subagent was likely dispatched as a read-only type (e.g. Explore) — print a warning: "chunk N missing from disk — subagent may have been dispatched without Write and Bash access. Re-run with a subagent type that has both." 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. +If more than half the chunks failed or are missing, stop and tell the user to re-run using a subagent type that has Write and Bash access (`general-purpose` by default; any host-permitted type with those two tools otherwise). 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 diff --git a/graphify/skill-devin.md b/graphify/skill-devin.md index f9be846cbf..7276a7023b 100644 --- a/graphify/skill-devin.md +++ b/graphify/skill-devin.md @@ -331,10 +331,10 @@ FILE_LIST Wait for all subagents. For each result: - Check that `graphify-out/.graphify_chunk_N.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 — 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 the file is missing, the subagent was likely dispatched as a read-only type — print a warning: "chunk N missing from disk — subagent may have been dispatched without Write and Bash access. Re-run with a subagent type that has both." 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. +If more than half the chunks failed or are missing, stop and tell the user to re-run using a subagent type that has Write and Bash access (`general-purpose` by default; any host-permitted type with those two tools otherwise). After each subagent call completes, write its result to `graphify-out/.graphify_chunk_N.json`. **After each subagent call completes, read the real token counts from the subagent tool result's `usage` field and write them back into the chunk JSON before merging** — the chunk JSON itself always has placeholder zeros. Then merge: diff --git a/graphify/skill-droid.md b/graphify/skill-droid.md index fd148d485d..9e41362a53 100644 --- a/graphify/skill-droid.md +++ b/graphify/skill-droid.md @@ -278,10 +278,10 @@ See `references/extraction-spec.md` for the exact subagent prompt (JSON schema, 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 the file is missing, the subagent was likely dispatched as a read-only type (e.g. Explore) — print a warning: "chunk N missing from disk — subagent may have been dispatched without Write and Bash access. Re-run with a subagent type that has both." 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. +If more than half the chunks failed or are missing, stop and tell the user to re-run using a subagent type that has Write and Bash access (`general-purpose` by default; any host-permitted type with those two tools otherwise). 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 diff --git a/graphify/skill-kilo.md b/graphify/skill-kilo.md index 3e70b050a4..87adbb16b1 100644 --- a/graphify/skill-kilo.md +++ b/graphify/skill-kilo.md @@ -254,7 +254,7 @@ Load files from `graphify-out/.graphify_uncached.txt`. Split into chunks of 20-2 Call the Agent tool multiple times IN THE SAME RESPONSE - one call per chunk. This is the only way they run in parallel. If you make one Agent call, wait, then make another, you are doing it sequentially and defeating the purpose. -**IMPORTANT - subagent type:** Always use `subagent_type="general-purpose"`. Do NOT use `Explore` - it is read-only and cannot write chunk files to disk, which silently drops extraction results. General-purpose has Write and Bash access which the subagent needs. +**IMPORTANT - subagent type:** the extraction subagent MUST have Write and Bash access - it builds the chunk file on disk itself. Default to `subagent_type="general-purpose"`. Do NOT use `Explore` - it is read-only and cannot write chunk files to disk, which silently drops extraction results. If this host's dispatch policy restricts or refuses `general-purpose` (an org policy hook, a curated persona registry), dispatch any available type that lists Write and Bash access instead - that is a host policy constraint, not a graphify requirement. Never downgrade to a read-only type to satisfy a policy; that trades a loud failure for a silent one. Concrete example for 3 chunks: ``` @@ -281,10 +281,10 @@ See `references/extraction-spec.md` for the exact subagent prompt (JSON schema, 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 the file is missing, the subagent was likely dispatched as a read-only type (e.g. Explore) — print a warning: "chunk N missing from disk — subagent may have been dispatched without Write and Bash access. Re-run with a subagent type that has both." 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. +If more than half the chunks failed or are missing, stop and tell the user to re-run using a subagent type that has Write and Bash access (`general-purpose` by default; any host-permitted type with those two tools otherwise). 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 @@ -708,7 +708,7 @@ When the user asks to install the post-commit auto-rebuild hook or wire graphify - Use the native `Task` tool for semantic extraction fan-out. - Launch all chunk tasks in the same response so they run in parallel. -- Always use `subagent_type="general"` for extraction chunks. +- Default to `subagent_type="general"` for extraction chunks; it needs Write and Bash access, so if a dispatch policy restricts `general`, use any permitted type with both tools instead. - After modifying code files during the session, run `graphify update .`. --- diff --git a/graphify/skill-kiro.md b/graphify/skill-kiro.md index abd2811d23..985298feeb 100644 --- a/graphify/skill-kiro.md +++ b/graphify/skill-kiro.md @@ -254,7 +254,7 @@ Load files from `graphify-out/.graphify_uncached.txt`. Split into chunks of 20-2 Call the Agent tool multiple times IN THE SAME RESPONSE - one call per chunk. This is the only way they run in parallel. If you make one Agent call, wait, then make another, you are doing it sequentially and defeating the purpose. -**IMPORTANT - subagent type:** Always use `subagent_type="general-purpose"`. Do NOT use `Explore` - it is read-only and cannot write chunk files to disk, which silently drops extraction results. General-purpose has Write and Bash access which the subagent needs. +**IMPORTANT - subagent type:** the extraction subagent MUST have Write and Bash access - it builds the chunk file on disk itself. Default to `subagent_type="general-purpose"`. Do NOT use `Explore` - it is read-only and cannot write chunk files to disk, which silently drops extraction results. If this host's dispatch policy restricts or refuses `general-purpose` (an org policy hook, a curated persona registry), dispatch any available type that lists Write and Bash access instead - that is a host policy constraint, not a graphify requirement. Never downgrade to a read-only type to satisfy a policy; that trades a loud failure for a silent one. Concrete example for 3 chunks: ``` @@ -281,10 +281,10 @@ See `references/extraction-spec.md` for the exact subagent prompt (JSON schema, 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 the file is missing, the subagent was likely dispatched as a read-only type (e.g. Explore) — print a warning: "chunk N missing from disk — subagent may have been dispatched without Write and Bash access. Re-run with a subagent type that has both." 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. +If more than half the chunks failed or are missing, stop and tell the user to re-run using a subagent type that has Write and Bash access (`general-purpose` by default; any host-permitted type with those two tools otherwise). 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 diff --git a/graphify/skill-opencode.md b/graphify/skill-opencode.md index 91ced60675..17af9359e3 100644 --- a/graphify/skill-opencode.md +++ b/graphify/skill-opencode.md @@ -273,10 +273,10 @@ See `references/extraction-spec.md` for the exact subagent prompt (JSON schema, 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 the file is missing, the subagent was likely dispatched as a read-only type (e.g. Explore) — print a warning: "chunk N missing from disk — subagent may have been dispatched without Write and Bash access. Re-run with a subagent type that has both." 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. +If more than half the chunks failed or are missing, stop and tell the user to re-run using a subagent type that has Write and Bash access (`general-purpose` by default; any host-permitted type with those two tools otherwise). 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 diff --git a/graphify/skill-pi.md b/graphify/skill-pi.md index abd2811d23..985298feeb 100644 --- a/graphify/skill-pi.md +++ b/graphify/skill-pi.md @@ -254,7 +254,7 @@ Load files from `graphify-out/.graphify_uncached.txt`. Split into chunks of 20-2 Call the Agent tool multiple times IN THE SAME RESPONSE - one call per chunk. This is the only way they run in parallel. If you make one Agent call, wait, then make another, you are doing it sequentially and defeating the purpose. -**IMPORTANT - subagent type:** Always use `subagent_type="general-purpose"`. Do NOT use `Explore` - it is read-only and cannot write chunk files to disk, which silently drops extraction results. General-purpose has Write and Bash access which the subagent needs. +**IMPORTANT - subagent type:** the extraction subagent MUST have Write and Bash access - it builds the chunk file on disk itself. Default to `subagent_type="general-purpose"`. Do NOT use `Explore` - it is read-only and cannot write chunk files to disk, which silently drops extraction results. If this host's dispatch policy restricts or refuses `general-purpose` (an org policy hook, a curated persona registry), dispatch any available type that lists Write and Bash access instead - that is a host policy constraint, not a graphify requirement. Never downgrade to a read-only type to satisfy a policy; that trades a loud failure for a silent one. Concrete example for 3 chunks: ``` @@ -281,10 +281,10 @@ See `references/extraction-spec.md` for the exact subagent prompt (JSON schema, 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 the file is missing, the subagent was likely dispatched as a read-only type (e.g. Explore) — print a warning: "chunk N missing from disk — subagent may have been dispatched without Write and Bash access. Re-run with a subagent type that has both." 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. +If more than half the chunks failed or are missing, stop and tell the user to re-run using a subagent type that has Write and Bash access (`general-purpose` by default; any host-permitted type with those two tools otherwise). 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 diff --git a/graphify/skill-trae.md b/graphify/skill-trae.md index 050667bc20..c23e445180 100644 --- a/graphify/skill-trae.md +++ b/graphify/skill-trae.md @@ -279,10 +279,10 @@ See `references/extraction-spec.md` for the exact subagent prompt (JSON schema, 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 the file is missing, the subagent was likely dispatched as a read-only type (e.g. Explore) — print a warning: "chunk N missing from disk — subagent may have been dispatched without Write and Bash access. Re-run with a subagent type that has both." 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. +If more than half the chunks failed or are missing, stop and tell the user to re-run using a subagent type that has Write and Bash access (`general-purpose` by default; any host-permitted type with those two tools otherwise). 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 diff --git a/graphify/skill-vscode.md b/graphify/skill-vscode.md index 20c7c0835c..b56e38f743 100644 --- a/graphify/skill-vscode.md +++ b/graphify/skill-vscode.md @@ -277,10 +277,10 @@ See `references/extraction-spec.md` for the exact subagent prompt (JSON schema, 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 the file is missing, the subagent was likely dispatched as a read-only type (e.g. Explore) — print a warning: "chunk N missing from disk — subagent may have been dispatched without Write and Bash access. Re-run with a subagent type that has both." 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. +If more than half the chunks failed or are missing, stop and tell the user to re-run using a subagent type that has Write and Bash access (`general-purpose` by default; any host-permitted type with those two tools otherwise). 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 diff --git a/graphify/skill-windows.md b/graphify/skill-windows.md index 764c1914d9..7630a6369f 100644 --- a/graphify/skill-windows.md +++ b/graphify/skill-windows.md @@ -281,7 +281,7 @@ Load files from `graphify-out/.graphify_uncached.txt`. Split into chunks of 20-2 Call the Agent tool multiple times IN THE SAME RESPONSE - one call per chunk. This is the only way they run in parallel. If you make one Agent call, wait, then make another, you are doing it sequentially and defeating the purpose. -**IMPORTANT - subagent type:** Always use `subagent_type="general-purpose"`. Do NOT use `Explore` - it is read-only and cannot write chunk files to disk, which silently drops extraction results. General-purpose has Write and Bash access which the subagent needs. +**IMPORTANT - subagent type:** the extraction subagent MUST have Write and Bash access - it builds the chunk file on disk itself. Default to `subagent_type="general-purpose"`. Do NOT use `Explore` - it is read-only and cannot write chunk files to disk, which silently drops extraction results. If this host's dispatch policy restricts or refuses `general-purpose` (an org policy hook, a curated persona registry), dispatch any available type that lists Write and Bash access instead - that is a host policy constraint, not a graphify requirement. Never downgrade to a read-only type to satisfy a policy; that trades a loud failure for a silent one. Concrete example for 3 chunks: ``` @@ -308,10 +308,10 @@ See `references/extraction-spec.md` for the exact subagent prompt (JSON schema, 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 the file is missing, the subagent was likely dispatched as a read-only type (e.g. Explore) — print a warning: "chunk N missing from disk — subagent may have been dispatched without Write and Bash access. Re-run with a subagent type that has both." 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. +If more than half the chunks failed or are missing, stop and tell the user to re-run using a subagent type that has Write and Bash access (`general-purpose` by default; any host-permitted type with those two tools otherwise). 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: ```powershell diff --git a/graphify/skill.md b/graphify/skill.md index abd2811d23..985298feeb 100644 --- a/graphify/skill.md +++ b/graphify/skill.md @@ -254,7 +254,7 @@ Load files from `graphify-out/.graphify_uncached.txt`. Split into chunks of 20-2 Call the Agent tool multiple times IN THE SAME RESPONSE - one call per chunk. This is the only way they run in parallel. If you make one Agent call, wait, then make another, you are doing it sequentially and defeating the purpose. -**IMPORTANT - subagent type:** Always use `subagent_type="general-purpose"`. Do NOT use `Explore` - it is read-only and cannot write chunk files to disk, which silently drops extraction results. General-purpose has Write and Bash access which the subagent needs. +**IMPORTANT - subagent type:** the extraction subagent MUST have Write and Bash access - it builds the chunk file on disk itself. Default to `subagent_type="general-purpose"`. Do NOT use `Explore` - it is read-only and cannot write chunk files to disk, which silently drops extraction results. If this host's dispatch policy restricts or refuses `general-purpose` (an org policy hook, a curated persona registry), dispatch any available type that lists Write and Bash access instead - that is a host policy constraint, not a graphify requirement. Never downgrade to a read-only type to satisfy a policy; that trades a loud failure for a silent one. Concrete example for 3 chunks: ``` @@ -281,10 +281,10 @@ See `references/extraction-spec.md` for the exact subagent prompt (JSON schema, 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 the file is missing, the subagent was likely dispatched as a read-only type (e.g. Explore) — print a warning: "chunk N missing from disk — subagent may have been dispatched without Write and Bash access. Re-run with a subagent type that has both." 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. +If more than half the chunks failed or are missing, stop and tell the user to re-run using a subagent type that has Write and Bash access (`general-purpose` by default; any host-permitted type with those two tools otherwise). 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 diff --git a/tools/skillgen/expected/graphify__skill-agents.md b/tools/skillgen/expected/graphify__skill-agents.md index 190827d9ac..30539649cf 100644 --- a/tools/skillgen/expected/graphify__skill-agents.md +++ b/tools/skillgen/expected/graphify__skill-agents.md @@ -278,10 +278,10 @@ See `references/extraction-spec.md` for the exact subagent prompt (JSON schema, 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 the file is missing, the subagent was likely dispatched as a read-only type (e.g. Explore) — print a warning: "chunk N missing from disk — subagent may have been dispatched without Write and Bash access. Re-run with a subagent type that has both." 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. +If more than half the chunks failed or are missing, stop and tell the user to re-run using a subagent type that has Write and Bash access (`general-purpose` by default; any host-permitted type with those two tools otherwise). 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 diff --git a/tools/skillgen/expected/graphify__skill-amp.md b/tools/skillgen/expected/graphify__skill-amp.md index 190827d9ac..30539649cf 100644 --- a/tools/skillgen/expected/graphify__skill-amp.md +++ b/tools/skillgen/expected/graphify__skill-amp.md @@ -278,10 +278,10 @@ See `references/extraction-spec.md` for the exact subagent prompt (JSON schema, 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 the file is missing, the subagent was likely dispatched as a read-only type (e.g. Explore) — print a warning: "chunk N missing from disk — subagent may have been dispatched without Write and Bash access. Re-run with a subagent type that has both." 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. +If more than half the chunks failed or are missing, stop and tell the user to re-run using a subagent type that has Write and Bash access (`general-purpose` by default; any host-permitted type with those two tools otherwise). 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 diff --git a/tools/skillgen/expected/graphify__skill-claw.md b/tools/skillgen/expected/graphify__skill-claw.md index abd2811d23..985298feeb 100644 --- a/tools/skillgen/expected/graphify__skill-claw.md +++ b/tools/skillgen/expected/graphify__skill-claw.md @@ -254,7 +254,7 @@ Load files from `graphify-out/.graphify_uncached.txt`. Split into chunks of 20-2 Call the Agent tool multiple times IN THE SAME RESPONSE - one call per chunk. This is the only way they run in parallel. If you make one Agent call, wait, then make another, you are doing it sequentially and defeating the purpose. -**IMPORTANT - subagent type:** Always use `subagent_type="general-purpose"`. Do NOT use `Explore` - it is read-only and cannot write chunk files to disk, which silently drops extraction results. General-purpose has Write and Bash access which the subagent needs. +**IMPORTANT - subagent type:** the extraction subagent MUST have Write and Bash access - it builds the chunk file on disk itself. Default to `subagent_type="general-purpose"`. Do NOT use `Explore` - it is read-only and cannot write chunk files to disk, which silently drops extraction results. If this host's dispatch policy restricts or refuses `general-purpose` (an org policy hook, a curated persona registry), dispatch any available type that lists Write and Bash access instead - that is a host policy constraint, not a graphify requirement. Never downgrade to a read-only type to satisfy a policy; that trades a loud failure for a silent one. Concrete example for 3 chunks: ``` @@ -281,10 +281,10 @@ See `references/extraction-spec.md` for the exact subagent prompt (JSON schema, 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 the file is missing, the subagent was likely dispatched as a read-only type (e.g. Explore) — print a warning: "chunk N missing from disk — subagent may have been dispatched without Write and Bash access. Re-run with a subagent type that has both." 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. +If more than half the chunks failed or are missing, stop and tell the user to re-run using a subagent type that has Write and Bash access (`general-purpose` by default; any host-permitted type with those two tools otherwise). 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 diff --git a/tools/skillgen/expected/graphify__skill-codex.md b/tools/skillgen/expected/graphify__skill-codex.md index af3f723c78..49b2f2abe6 100644 --- a/tools/skillgen/expected/graphify__skill-codex.md +++ b/tools/skillgen/expected/graphify__skill-codex.md @@ -278,10 +278,10 @@ See `references/extraction-spec.md` for the compact subagent prompt (rules, node 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 the file is missing, the subagent was likely dispatched as a read-only type (e.g. Explore) — print a warning: "chunk N missing from disk — subagent may have been dispatched without Write and Bash access. Re-run with a subagent type that has both." 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. +If more than half the chunks failed or are missing, stop and tell the user to re-run using a subagent type that has Write and Bash access (`general-purpose` by default; any host-permitted type with those two tools otherwise). 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 diff --git a/tools/skillgen/expected/graphify__skill-copilot.md b/tools/skillgen/expected/graphify__skill-copilot.md index abd2811d23..985298feeb 100644 --- a/tools/skillgen/expected/graphify__skill-copilot.md +++ b/tools/skillgen/expected/graphify__skill-copilot.md @@ -254,7 +254,7 @@ Load files from `graphify-out/.graphify_uncached.txt`. Split into chunks of 20-2 Call the Agent tool multiple times IN THE SAME RESPONSE - one call per chunk. This is the only way they run in parallel. If you make one Agent call, wait, then make another, you are doing it sequentially and defeating the purpose. -**IMPORTANT - subagent type:** Always use `subagent_type="general-purpose"`. Do NOT use `Explore` - it is read-only and cannot write chunk files to disk, which silently drops extraction results. General-purpose has Write and Bash access which the subagent needs. +**IMPORTANT - subagent type:** the extraction subagent MUST have Write and Bash access - it builds the chunk file on disk itself. Default to `subagent_type="general-purpose"`. Do NOT use `Explore` - it is read-only and cannot write chunk files to disk, which silently drops extraction results. If this host's dispatch policy restricts or refuses `general-purpose` (an org policy hook, a curated persona registry), dispatch any available type that lists Write and Bash access instead - that is a host policy constraint, not a graphify requirement. Never downgrade to a read-only type to satisfy a policy; that trades a loud failure for a silent one. Concrete example for 3 chunks: ``` @@ -281,10 +281,10 @@ See `references/extraction-spec.md` for the exact subagent prompt (JSON schema, 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 the file is missing, the subagent was likely dispatched as a read-only type (e.g. Explore) — print a warning: "chunk N missing from disk — subagent may have been dispatched without Write and Bash access. Re-run with a subagent type that has both." 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. +If more than half the chunks failed or are missing, stop and tell the user to re-run using a subagent type that has Write and Bash access (`general-purpose` by default; any host-permitted type with those two tools otherwise). 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 diff --git a/tools/skillgen/expected/graphify__skill-devin.md b/tools/skillgen/expected/graphify__skill-devin.md index f9be846cbf..7276a7023b 100644 --- a/tools/skillgen/expected/graphify__skill-devin.md +++ b/tools/skillgen/expected/graphify__skill-devin.md @@ -331,10 +331,10 @@ FILE_LIST Wait for all subagents. For each result: - Check that `graphify-out/.graphify_chunk_N.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 — 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 the file is missing, the subagent was likely dispatched as a read-only type — print a warning: "chunk N missing from disk — subagent may have been dispatched without Write and Bash access. Re-run with a subagent type that has both." 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. +If more than half the chunks failed or are missing, stop and tell the user to re-run using a subagent type that has Write and Bash access (`general-purpose` by default; any host-permitted type with those two tools otherwise). After each subagent call completes, write its result to `graphify-out/.graphify_chunk_N.json`. **After each subagent call completes, read the real token counts from the subagent tool result's `usage` field and write them back into the chunk JSON before merging** — the chunk JSON itself always has placeholder zeros. Then merge: diff --git a/tools/skillgen/expected/graphify__skill-droid.md b/tools/skillgen/expected/graphify__skill-droid.md index fd148d485d..9e41362a53 100644 --- a/tools/skillgen/expected/graphify__skill-droid.md +++ b/tools/skillgen/expected/graphify__skill-droid.md @@ -278,10 +278,10 @@ See `references/extraction-spec.md` for the exact subagent prompt (JSON schema, 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 the file is missing, the subagent was likely dispatched as a read-only type (e.g. Explore) — print a warning: "chunk N missing from disk — subagent may have been dispatched without Write and Bash access. Re-run with a subagent type that has both." 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. +If more than half the chunks failed or are missing, stop and tell the user to re-run using a subagent type that has Write and Bash access (`general-purpose` by default; any host-permitted type with those two tools otherwise). 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 diff --git a/tools/skillgen/expected/graphify__skill-kilo.md b/tools/skillgen/expected/graphify__skill-kilo.md index 3e70b050a4..87adbb16b1 100644 --- a/tools/skillgen/expected/graphify__skill-kilo.md +++ b/tools/skillgen/expected/graphify__skill-kilo.md @@ -254,7 +254,7 @@ Load files from `graphify-out/.graphify_uncached.txt`. Split into chunks of 20-2 Call the Agent tool multiple times IN THE SAME RESPONSE - one call per chunk. This is the only way they run in parallel. If you make one Agent call, wait, then make another, you are doing it sequentially and defeating the purpose. -**IMPORTANT - subagent type:** Always use `subagent_type="general-purpose"`. Do NOT use `Explore` - it is read-only and cannot write chunk files to disk, which silently drops extraction results. General-purpose has Write and Bash access which the subagent needs. +**IMPORTANT - subagent type:** the extraction subagent MUST have Write and Bash access - it builds the chunk file on disk itself. Default to `subagent_type="general-purpose"`. Do NOT use `Explore` - it is read-only and cannot write chunk files to disk, which silently drops extraction results. If this host's dispatch policy restricts or refuses `general-purpose` (an org policy hook, a curated persona registry), dispatch any available type that lists Write and Bash access instead - that is a host policy constraint, not a graphify requirement. Never downgrade to a read-only type to satisfy a policy; that trades a loud failure for a silent one. Concrete example for 3 chunks: ``` @@ -281,10 +281,10 @@ See `references/extraction-spec.md` for the exact subagent prompt (JSON schema, 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 the file is missing, the subagent was likely dispatched as a read-only type (e.g. Explore) — print a warning: "chunk N missing from disk — subagent may have been dispatched without Write and Bash access. Re-run with a subagent type that has both." 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. +If more than half the chunks failed or are missing, stop and tell the user to re-run using a subagent type that has Write and Bash access (`general-purpose` by default; any host-permitted type with those two tools otherwise). 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 @@ -708,7 +708,7 @@ When the user asks to install the post-commit auto-rebuild hook or wire graphify - Use the native `Task` tool for semantic extraction fan-out. - Launch all chunk tasks in the same response so they run in parallel. -- Always use `subagent_type="general"` for extraction chunks. +- Default to `subagent_type="general"` for extraction chunks; it needs Write and Bash access, so if a dispatch policy restricts `general`, use any permitted type with both tools instead. - After modifying code files during the session, run `graphify update .`. --- diff --git a/tools/skillgen/expected/graphify__skill-kiro.md b/tools/skillgen/expected/graphify__skill-kiro.md index abd2811d23..985298feeb 100644 --- a/tools/skillgen/expected/graphify__skill-kiro.md +++ b/tools/skillgen/expected/graphify__skill-kiro.md @@ -254,7 +254,7 @@ Load files from `graphify-out/.graphify_uncached.txt`. Split into chunks of 20-2 Call the Agent tool multiple times IN THE SAME RESPONSE - one call per chunk. This is the only way they run in parallel. If you make one Agent call, wait, then make another, you are doing it sequentially and defeating the purpose. -**IMPORTANT - subagent type:** Always use `subagent_type="general-purpose"`. Do NOT use `Explore` - it is read-only and cannot write chunk files to disk, which silently drops extraction results. General-purpose has Write and Bash access which the subagent needs. +**IMPORTANT - subagent type:** the extraction subagent MUST have Write and Bash access - it builds the chunk file on disk itself. Default to `subagent_type="general-purpose"`. Do NOT use `Explore` - it is read-only and cannot write chunk files to disk, which silently drops extraction results. If this host's dispatch policy restricts or refuses `general-purpose` (an org policy hook, a curated persona registry), dispatch any available type that lists Write and Bash access instead - that is a host policy constraint, not a graphify requirement. Never downgrade to a read-only type to satisfy a policy; that trades a loud failure for a silent one. Concrete example for 3 chunks: ``` @@ -281,10 +281,10 @@ See `references/extraction-spec.md` for the exact subagent prompt (JSON schema, 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 the file is missing, the subagent was likely dispatched as a read-only type (e.g. Explore) — print a warning: "chunk N missing from disk — subagent may have been dispatched without Write and Bash access. Re-run with a subagent type that has both." 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. +If more than half the chunks failed or are missing, stop and tell the user to re-run using a subagent type that has Write and Bash access (`general-purpose` by default; any host-permitted type with those two tools otherwise). 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 diff --git a/tools/skillgen/expected/graphify__skill-opencode.md b/tools/skillgen/expected/graphify__skill-opencode.md index 91ced60675..17af9359e3 100644 --- a/tools/skillgen/expected/graphify__skill-opencode.md +++ b/tools/skillgen/expected/graphify__skill-opencode.md @@ -273,10 +273,10 @@ See `references/extraction-spec.md` for the exact subagent prompt (JSON schema, 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 the file is missing, the subagent was likely dispatched as a read-only type (e.g. Explore) — print a warning: "chunk N missing from disk — subagent may have been dispatched without Write and Bash access. Re-run with a subagent type that has both." 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. +If more than half the chunks failed or are missing, stop and tell the user to re-run using a subagent type that has Write and Bash access (`general-purpose` by default; any host-permitted type with those two tools otherwise). 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 diff --git a/tools/skillgen/expected/graphify__skill-pi.md b/tools/skillgen/expected/graphify__skill-pi.md index abd2811d23..985298feeb 100644 --- a/tools/skillgen/expected/graphify__skill-pi.md +++ b/tools/skillgen/expected/graphify__skill-pi.md @@ -254,7 +254,7 @@ Load files from `graphify-out/.graphify_uncached.txt`. Split into chunks of 20-2 Call the Agent tool multiple times IN THE SAME RESPONSE - one call per chunk. This is the only way they run in parallel. If you make one Agent call, wait, then make another, you are doing it sequentially and defeating the purpose. -**IMPORTANT - subagent type:** Always use `subagent_type="general-purpose"`. Do NOT use `Explore` - it is read-only and cannot write chunk files to disk, which silently drops extraction results. General-purpose has Write and Bash access which the subagent needs. +**IMPORTANT - subagent type:** the extraction subagent MUST have Write and Bash access - it builds the chunk file on disk itself. Default to `subagent_type="general-purpose"`. Do NOT use `Explore` - it is read-only and cannot write chunk files to disk, which silently drops extraction results. If this host's dispatch policy restricts or refuses `general-purpose` (an org policy hook, a curated persona registry), dispatch any available type that lists Write and Bash access instead - that is a host policy constraint, not a graphify requirement. Never downgrade to a read-only type to satisfy a policy; that trades a loud failure for a silent one. Concrete example for 3 chunks: ``` @@ -281,10 +281,10 @@ See `references/extraction-spec.md` for the exact subagent prompt (JSON schema, 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 the file is missing, the subagent was likely dispatched as a read-only type (e.g. Explore) — print a warning: "chunk N missing from disk — subagent may have been dispatched without Write and Bash access. Re-run with a subagent type that has both." 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. +If more than half the chunks failed or are missing, stop and tell the user to re-run using a subagent type that has Write and Bash access (`general-purpose` by default; any host-permitted type with those two tools otherwise). 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 diff --git a/tools/skillgen/expected/graphify__skill-trae.md b/tools/skillgen/expected/graphify__skill-trae.md index 050667bc20..c23e445180 100644 --- a/tools/skillgen/expected/graphify__skill-trae.md +++ b/tools/skillgen/expected/graphify__skill-trae.md @@ -279,10 +279,10 @@ See `references/extraction-spec.md` for the exact subagent prompt (JSON schema, 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 the file is missing, the subagent was likely dispatched as a read-only type (e.g. Explore) — print a warning: "chunk N missing from disk — subagent may have been dispatched without Write and Bash access. Re-run with a subagent type that has both." 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. +If more than half the chunks failed or are missing, stop and tell the user to re-run using a subagent type that has Write and Bash access (`general-purpose` by default; any host-permitted type with those two tools otherwise). 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 diff --git a/tools/skillgen/expected/graphify__skill-vscode.md b/tools/skillgen/expected/graphify__skill-vscode.md index 20c7c0835c..b56e38f743 100644 --- a/tools/skillgen/expected/graphify__skill-vscode.md +++ b/tools/skillgen/expected/graphify__skill-vscode.md @@ -277,10 +277,10 @@ See `references/extraction-spec.md` for the exact subagent prompt (JSON schema, 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 the file is missing, the subagent was likely dispatched as a read-only type (e.g. Explore) — print a warning: "chunk N missing from disk — subagent may have been dispatched without Write and Bash access. Re-run with a subagent type that has both." 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. +If more than half the chunks failed or are missing, stop and tell the user to re-run using a subagent type that has Write and Bash access (`general-purpose` by default; any host-permitted type with those two tools otherwise). 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 diff --git a/tools/skillgen/expected/graphify__skill-windows.md b/tools/skillgen/expected/graphify__skill-windows.md index 764c1914d9..7630a6369f 100644 --- a/tools/skillgen/expected/graphify__skill-windows.md +++ b/tools/skillgen/expected/graphify__skill-windows.md @@ -281,7 +281,7 @@ Load files from `graphify-out/.graphify_uncached.txt`. Split into chunks of 20-2 Call the Agent tool multiple times IN THE SAME RESPONSE - one call per chunk. This is the only way they run in parallel. If you make one Agent call, wait, then make another, you are doing it sequentially and defeating the purpose. -**IMPORTANT - subagent type:** Always use `subagent_type="general-purpose"`. Do NOT use `Explore` - it is read-only and cannot write chunk files to disk, which silently drops extraction results. General-purpose has Write and Bash access which the subagent needs. +**IMPORTANT - subagent type:** the extraction subagent MUST have Write and Bash access - it builds the chunk file on disk itself. Default to `subagent_type="general-purpose"`. Do NOT use `Explore` - it is read-only and cannot write chunk files to disk, which silently drops extraction results. If this host's dispatch policy restricts or refuses `general-purpose` (an org policy hook, a curated persona registry), dispatch any available type that lists Write and Bash access instead - that is a host policy constraint, not a graphify requirement. Never downgrade to a read-only type to satisfy a policy; that trades a loud failure for a silent one. Concrete example for 3 chunks: ``` @@ -308,10 +308,10 @@ See `references/extraction-spec.md` for the exact subagent prompt (JSON schema, 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 the file is missing, the subagent was likely dispatched as a read-only type (e.g. Explore) — print a warning: "chunk N missing from disk — subagent may have been dispatched without Write and Bash access. Re-run with a subagent type that has both." 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. +If more than half the chunks failed or are missing, stop and tell the user to re-run using a subagent type that has Write and Bash access (`general-purpose` by default; any host-permitted type with those two tools otherwise). 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: ```powershell diff --git a/tools/skillgen/expected/graphify__skill.md b/tools/skillgen/expected/graphify__skill.md index abd2811d23..985298feeb 100644 --- a/tools/skillgen/expected/graphify__skill.md +++ b/tools/skillgen/expected/graphify__skill.md @@ -254,7 +254,7 @@ Load files from `graphify-out/.graphify_uncached.txt`. Split into chunks of 20-2 Call the Agent tool multiple times IN THE SAME RESPONSE - one call per chunk. This is the only way they run in parallel. If you make one Agent call, wait, then make another, you are doing it sequentially and defeating the purpose. -**IMPORTANT - subagent type:** Always use `subagent_type="general-purpose"`. Do NOT use `Explore` - it is read-only and cannot write chunk files to disk, which silently drops extraction results. General-purpose has Write and Bash access which the subagent needs. +**IMPORTANT - subagent type:** the extraction subagent MUST have Write and Bash access - it builds the chunk file on disk itself. Default to `subagent_type="general-purpose"`. Do NOT use `Explore` - it is read-only and cannot write chunk files to disk, which silently drops extraction results. If this host's dispatch policy restricts or refuses `general-purpose` (an org policy hook, a curated persona registry), dispatch any available type that lists Write and Bash access instead - that is a host policy constraint, not a graphify requirement. Never downgrade to a read-only type to satisfy a policy; that trades a loud failure for a silent one. Concrete example for 3 chunks: ``` @@ -281,10 +281,10 @@ See `references/extraction-spec.md` for the exact subagent prompt (JSON schema, 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 the file is missing, the subagent was likely dispatched as a read-only type (e.g. Explore) — print a warning: "chunk N missing from disk — subagent may have been dispatched without Write and Bash access. Re-run with a subagent type that has both." 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. +If more than half the chunks failed or are missing, stop and tell the user to re-run using a subagent type that has Write and Bash access (`general-purpose` by default; any host-permitted type with those two tools otherwise). 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 From b3abe9acbf3d3dcc0d62386e9c2775aacd9bc40d Mon Sep 17 00:00:00 2001 From: ayushcodes10 Date: Thu, 17 Sep 2026 15:42:16 +0530 Subject: [PATCH 3/7] Add a regression test for the subagent capability wording Asserts every host carrying the shared dispatch slot or Step B3 diagnostics states the Write and Bash requirement plus the escape hatch for a host whose dispatch policy is restricted, not just the literal general purpose type name. Co-Authored-By: Claude Sonnet 5 --- tests/test_install.py | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/tests/test_install.py b/tests/test_install.py index 72d4e4dd26..697626edb8 100644 --- a/tests/test_install.py +++ b/tests/test_install.py @@ -446,6 +446,24 @@ def test_kilo_skill_avoids_double_quoted_python_c_fstring_dict_keys(): assert not re.search(r"print\(f'.*\[[\"'][^\"']+[\"']\]", skill) +def test_subagent_dispatch_names_the_capability_not_just_the_type(): + """#2525: a host whose dispatch policy restricts the literal + "general-purpose" agent type must have an escape hatch. Every host that + carries the shared Agent-tool dispatch slot or Step B3 diagnostics must + state the underlying requirement (Write and Bash access) and name + general-purpose only as the default, not the sole option. + """ + import graphify + + for name in ("skill.md", "skill-claw.md", "skill-kilo.md"): + skill = (Path(graphify.__file__).parent / name).read_text() + assert "Write and Bash access" in skill, f"{name}: missing the capability requirement" + assert "host policy constraint, not a graphify requirement" in skill or \ + "use any permitted type with both tools instead" in skill, ( + f"{name}: missing the policy-restricted-host escape hatch" + ) + + def test_claw_skill_uses_agent_tool_dispatch(): """OpenClaw rides the shared Agent-tool disk-collect dispatch. From c9660829d23f7fc32950d63316942c93df61444b Mon Sep 17 00:00:00 2001 From: ayushcodes10 Date: Thu, 17 Sep 2026 15:42:16 +0530 Subject: [PATCH 4/7] Add changelog entry for issue 2525 Co-Authored-By: Claude Sonnet 5 --- CHANGELOG.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 5a0daf515f..b6b69df1fc 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,6 +4,8 @@ Full release notes with details on each version: [GitHub Releases](https://githu ## 0.9.63 (2026-09-16) +- Fix: the `/graphify` skill's extraction-subagent dispatch instructions named the literal agent type `general-purpose` as the only acceptable choice, so a host whose dispatch policy restricts or refuses that exact type (an org policy hook, a curated persona registry) could not follow the skill as written, and every diagnostic pointed back at the one type the host would not permit. The instructions now state the actual requirement — Write and Bash access, since the subagent builds its chunk file on disk — keep `general-purpose` as the default, and tell a policy-restricted host to dispatch any permitted type with both tools instead (#2525, thanks @maxhawk1). + - Feature: Elixir `alias`/`import`/`require`/`use` targets now resolve onto the module's `defmodule` node across files, so the internal module dependency graph is no longer dropped as dangling. Only top-level modules are indexed (a nested `defmodule`, labeled with its bare inner name, cannot capture an unrelated `use ` from another file), and a same-file reference is left unresolved so it cannot clobber the structural `contains` edge (#3603, thanks @ayushcodes10). - Feature: a Rust `self.method()` call now resolves to a method defined on the same type in another file (the common split-`impl`-block layout), pooling methods across every `impl` of one type and refusing to link when two unrelated types share a bare name (#3602, thanks @ayushcodes10). - Feature: a Ruby member call `obj.foo` on a known-type receiver now resolves to a method `foo` inherited from a superclass, including across files, using the same conservative promotion as the implicit-self resolver — a single owning class, matching method kind, and one unambiguous ancestry chain, or it stays dangling (#3585, thanks @oleksii-tumanov). From 4417ad96a3e7106d035b029700b9fc8254b57606 Mon Sep 17 00:00:00 2001 From: ayushcodes10 Date: Thu, 17 Sep 2026 21:15:19 +0530 Subject: [PATCH 5/7] Tighten the subagent capability wording predicate to exact lines A reviewer pointed out the sanctioned diff predicate for this fix matched any line containing the bare substring general purpose or Write and Bash access, which also matches unrelated, unchanged lines such as the dispatch fragments' own worked example showing the subagent type set to general purpose as example syntax. That weakens the round trip check's ability to catch real corruption of those lines, since it would treat such corruption as sanctioned too. Now matches only a phrase unique to each of the two actually changed lines' old and new forms. Co-Authored-By: Claude Sonnet 5 --- tools/skillgen/gen.py | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/tools/skillgen/gen.py b/tools/skillgen/gen.py index e7989292f6..0f66f7a2a4 100644 --- a/tools/skillgen/gen.py +++ b/tools/skillgen/gen.py @@ -1150,12 +1150,20 @@ def _is_subagent_capability_wording_fix_line(line: str) -> bool: host whose dispatch policy restricts or refuses that exact type had no escape and every diagnostic pointed back at the one type it could not use. Reworded to name the capability, with general-purpose kept as the - default. Both old and new forms match here. + default. + + Matches only the two changed lines' old and new forms by a phrase + unique to each, not a bare "general-purpose"/"Write and Bash access" + substring — a loose substring also matches unrelated, unchanged lines + (e.g. the dispatch fragments' own `subagent_type="general-purpose"` + worked example), which would silently stop the round-trip check from + catching real corruption of those lines. """ return ( - "general-purpose" in line - or "Write and Bash access" in line + "Re-run with general-purpose agent." in line + or 'ensure `subagent_type="general-purpose"` is used' in line or "dispatched without Write and Bash access" in line + or "re-run using a subagent type that has Write and Bash access" in line ) From 380b0fc0f2e9caa4026888c43655e46bd43fbc61 Mon Sep 17 00:00:00 2001 From: ayushcodes10 Date: Thu, 17 Sep 2026 21:15:22 +0530 Subject: [PATCH 6/7] Add a regression test for the tightened wording predicate Covers both changed lines' old and new forms (must match) and the unrelated worked example line the reviewer flagged (must not). Co-Authored-By: Claude Sonnet 5 --- tests/test_skillgen.py | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/tests/test_skillgen.py b/tests/test_skillgen.py index ab6f94474c..da7ad5b500 100644 --- a/tests/test_skillgen.py +++ b/tests/test_skillgen.py @@ -615,6 +615,32 @@ def test_monoliths_change_only_sanctioned_lines(): assert UNIFIED_DESCRIPTION in rendered +def test_subagent_capability_wording_predicate_does_not_overmatch(): + """Review finding on #2525: a bare "general-purpose"/"Write and Bash + access" substring check also matches unrelated, unchanged lines (the + dispatch fragments' own worked example showing `subagent_type= + "general-purpose"` as example syntax), which would silently stop the + round trip check from catching real corruption of those lines. The + predicate must match only the two changed lines' actual old and new + forms, not any line that merely mentions either phrase.""" + f = gen._is_subagent_capability_wording_fix_line + assert f('- If the file is missing, the subagent was likely dispatched as read-only — ' + 'print a warning: "chunk N missing from disk — subagent may have been ' + 'read-only. Re-run with general-purpose agent." Do not silently skip.') + assert f('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.') + assert f('- If the file is missing, the subagent was likely dispatched as a read-only ' + 'type — print a warning: "chunk N missing from disk — subagent may have ' + 'been dispatched without Write and Bash access. Re-run with a subagent ' + 'type that has both." Do not silently skip.') + assert f('If more than half the chunks failed or are missing, stop and tell the user ' + 'to re-run using a subagent type that has Write and Bash access ' + '(`general-purpose` by default; any host-permitted type with those two ' + 'tools otherwise).') + assert not f('Task(subagent_type="general-purpose", prompt="...")') + assert not f('subagent_type="general-purpose"') + + def test_monoliths_carry_the_1392_runbook_fixes(): """The four #1392 data-loss/correctness fixes are present in both monoliths. From 971a49e2cbe6e20a865e6dc1a3911626f74446c3 Mon Sep 17 00:00:00 2001 From: ayushcodes10 Date: Thu, 17 Sep 2026 21:15:22 +0530 Subject: [PATCH 7/7] Update changelog entry for issue 2525 review finding Co-Authored-By: Claude Sonnet 5 --- CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index b6b69df1fc..d108260e93 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,7 +4,7 @@ Full release notes with details on each version: [GitHub Releases](https://githu ## 0.9.63 (2026-09-16) -- Fix: the `/graphify` skill's extraction-subagent dispatch instructions named the literal agent type `general-purpose` as the only acceptable choice, so a host whose dispatch policy restricts or refuses that exact type (an org policy hook, a curated persona registry) could not follow the skill as written, and every diagnostic pointed back at the one type the host would not permit. The instructions now state the actual requirement — Write and Bash access, since the subagent builds its chunk file on disk — keep `general-purpose` as the default, and tell a policy-restricted host to dispatch any permitted type with both tools instead (#2525, thanks @maxhawk1). +- Fix: the `/graphify` skill's extraction-subagent dispatch instructions named the literal agent type `general-purpose` as the only acceptable choice, so a host whose dispatch policy restricts or refuses that exact type (an org policy hook, a curated persona registry) could not follow the skill as written, and every diagnostic pointed back at the one type the host would not permit. The instructions now state the actual requirement — Write and Bash access, since the subagent builds its chunk file on disk — keep `general-purpose` as the default, and tell a policy-restricted host to dispatch any permitted type with both tools instead. The internal guard that checks the devin monolith stays in sync with this wording now matches only the two changed lines' exact old and new forms, not a bare substring that also matched an unrelated worked example line (#2525, thanks @maxhawk1). - Feature: Elixir `alias`/`import`/`require`/`use` targets now resolve onto the module's `defmodule` node across files, so the internal module dependency graph is no longer dropped as dangling. Only top-level modules are indexed (a nested `defmodule`, labeled with its bare inner name, cannot capture an unrelated `use ` from another file), and a same-file reference is left unresolved so it cannot clobber the structural `contains` edge (#3603, thanks @ayushcodes10). - Feature: a Rust `self.method()` call now resolves to a method defined on the same type in another file (the common split-`impl`-block layout), pooling methods across every `impl` of one type and refusing to link when two unrelated types share a bare name (#3602, thanks @ayushcodes10).