diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5a0daf515f..d108260e93 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. 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 <Name>` 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).
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/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.
 
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.
 
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
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..0f66f7a2a4 100644
--- a/tools/skillgen/gen.py
+++ b/tools/skillgen/gen.py
@@ -1142,6 +1142,31 @@ 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.
+
+    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 (
+        "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
+    )
+
+
 # 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 +1182,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,