@sorenllm/opencode-forge 0.18.1 → 0.20.0

package/README.md

@@ -70,7 +70,7 @@ tool layer (verified against the host's `tools` filter):
 | | **forge family** — `forge` + your forge.json `forge-*` workers | **everyone else** — native `build` / `plan` / `general` / `explore` and your own agents |
 | --- | --- | --- |
 | exec surface | `forge_shell` / `forge_jobs` only; builtin `shell`/`bash` hidden (unconditional, probe-independent; covers user-defined `agent.forge` entries too) | builtin `shell`/`bash`, fully native |
-| forge tools (`plan_*`, `goal_*`, `crew_*`, `forge_shell`, `forge_jobs`) | `forge` sees all; `forge-*` workers only `forge_shell` + `forge_jobs` | none visible |
+| forge tools (`plan_*`, `goal_*`, `crew_*`, `forge_shell`, `forge_jobs`, `forge_grep`, `forge_glob`) | `forge` sees all; `forge-*` workers only `forge_shell` + `forge_jobs` + the search pair (`forge_grep`/`forge_glob`) | none visible |
 | dispatching `forge-*` via `task` | allowed | refused at the tool layer |
 | writing `.opencode/plan/` / `.opencode/goal/` | allowed (state machine governs) | refused at the tool layer (reads stay open) |
 | forge system prompts (job guidance, plan/goal notices) | injected | never injected — zero forge text |
@@ -152,6 +152,10 @@ the plugin never writes them):
       "watchdog": {
         "mode": "kill",              // "kill" (default) | "dry-run" | "off" — forge-family sessions only
         "stallMs": 600000            // stall threshold, min 60000
+      },
+      "search": {
+        "rgPath": ""                 // optional explicit ripgrep binary path for forge_grep/forge_glob;
+                                     // default resolution: this override (when it exists) → rg on PATH
       }
     }]
   ]
@@ -412,6 +416,45 @@ These are runtime debris, not data — with ONE caveat: **if you uninstall with
 /F /T`, or just reboot); deleting the directory afterwards is safe and
 complete.
 
+## Search tools (`forge_grep` / `forge_glob`)
+
+rg-backed search for the forge family — same interface and output format as
+the builtin `grep`/`glob` pair, but **`follow` and `hidden` default to TRUE**:
+workspace content behind symlinks/junctions and inside dot-directories (which
+the builtin pair silently misses) is in scope by default. `**/.git/**` is
+ always excluded. The builtin pair stays visible — the forge family is
+instructed to prefer `forge_grep`/`forge_glob` first and use builtin
+`grep`/`glob` as fallback only; the standing worker mandate reads:
+
+> Run every search through the forge_grep/forge_glob tools first — the
+> builtin grep/glob tools are fallback only. forge_grep/forge_glob see
+> through symlinks/junctions and dot-directories because follow and hidden
+> are on by default.
+
+- **Params**: `pattern` (required); `path` (optional — defaults to the session
+  worktree; a file path targets that file); `include` (forge_grep file
+  filter); `follow` / `hidden` (optional booleans, both default `true`).
+- **Output parity**: `Found N matches` with `path: Line n:` blocks
+  (forge_glob: a plain path list) — the same shapes as the builtin pair.
+  Results truncate at 100 with a truncation notice advising a narrower
+  path or pattern.
+- **Follow dedupe**: a file reachable through its real path AND a link path
+  reports ONCE (lexicographically first path kept); when any dedupe occurred
+  the output ends with a `+N duplicate paths merged` line.
+- **Outside-workspace links**: followed, with the resolved target disclosed
+  in the result.
+- **Readonly by construction**: ripgrep is spawned directly with a fixed
+  argument vector — no shell, no redirection surface. The tools carry no
+  permission ask-gate and are not subject to the readonly exec seal, so
+  explicit-readonly workers search without friction.
+
+**ripgrep dependency.** No binary is bundled. rg is resolved as:
+`search.rgPath` config override (when it exists on disk) → `rg` on PATH →
+fail-soft guidance error (never a crash):
+
+> install ripgrep (or set search.rgPath in forge config to an existing rg
+> binary), or fall back to the builtin grep/glob tools for this search
+
 ## Forge subagents (static worker agents in forge.json)
 
 Forge subagents are **static, user-authored worker agents**: each forge.json
@@ -523,6 +566,11 @@ out of a materialized id.
   // dispatches are blocked until the field is added). Invalid values
   // degrade to a warning + the directory-derived namespace.
   // "pool": "aa",
+  // OPTIONAL pool-level shared prompt segment — written ONCE at the top of
+  // the file, inherited by EVERY agent this file materializes (project
+  // conventions, repo layout, standing rules). A plain string, no
+  // interpolation. See "Pool-level shared prompt segment" below.
+  // "shared": "Project X conventions: use bun; cite file:line evidence.",
   "agents": {
     // PINNED worker: model + thoughtLevel form an ATOMIC PAIR — set BOTH
     "research": {
@@ -569,6 +617,26 @@ A rejected entry costs only itself — its siblings materialize normally.
   Findings surface in the plugin diagnostics log.
 - **`depths` is deprecated**: the array is ignored with a warning finding.
   Pin ONE `thoughtLevel` per agent instead.
+- **Pool-level `shared` prompt segment**: an optional top-level `"shared"`
+  string — the pool's common base, written once and inherited by EVERY agent
+  the file materializes (no per-agent opt-out; an agent that must escape it
+  gets its own pool file). The layering contract is a strict prepend: the
+  materialized role prompt = `shared` + a blank line + the EXISTING
+  three-layer chain (explicit `prompt` > built-in `research`/`review`
+  defaults > generic one-liner), byte-for-byte unchanged beneath it —
+  `shared` never suppresses and never overrides anything, and an explicit
+  per-agent prompt keeps its priority over role defaults. Validation is
+  field-level fail-soft: a non-string or whitespace-only `shared` records
+  exactly ONE warn finding (`shared-invalid`, naming the file) and is
+  ignored — every agent of the pool still materializes with the unshared
+  chain. Scope is PER FILE: agents from two different pool files each get
+  their OWN file's `shared` (no cross-pool bleed), and the GLOBAL fallback
+  file's `shared` inherits to its family normally — the rule that ignores
+  the global file's `pool` namespace field does not extend to `shared`
+  (content is not namespace). Hot-apply rides the existing mtime cache:
+  editing `shared` re-materializes at the next config hook exactly like any
+  pool edit. With no `shared` declared anywhere, materialized prompts are
+  byte-identical to the pre-`shared` build.
 - Each agent materializes as `forge-<ns>-<id>` — a subagent-mode agent
    visible in the task tool's vocabulary (never hidden), whose description
    names its **pool provenance** (namespace + origin forge.json path +
@@ -576,8 +644,10 @@ A rejected entry costs only itself — its siblings materialize normally.
    layer), carrying the pinned `model`
   (pinned workers) or NO model key at all (Auto workers — the description
   says "inherits the parent session's model" instead of naming a brain),
-  the worker discipline (workspace-relative paths only, verbatim reporting
-  of tool refusals, evidence-bearing conclusions) around its role prompt,
+   the worker discipline (workspace-relative paths only, verbatim reporting
+   of tool refusals, evidence-bearing conclusions, search through
+   `forge_grep`/`forge_glob` first with builtin `grep`/`glob` as fallback
+   only) around its role prompt,
    and a deny-style permission: an ABSENT `shape` defaults to WRITE (open
    permissions — the compatibility-preserving default for existing pools);
    an explicit `shape: "readonly"` denies
@@ -675,7 +745,7 @@ Covered WRITE-CLASS indicators:
 | `mutating-cmdlet` | `Set-Content`, `Out-File`, `New-Item`, `Remove-Item`, `Move-Item`, `Copy-Item`, `Add-Content`, `Clear-Content` |
 | `git-mutation` | `git add/commit/push/reset/checkout/rebase/merge/clean/rm` |
 | `pkg-mutation` | `npm publish`, `npm install` (incl. `npm i`/`ci`/`add`), `bun add`/`install`, `pip`/`pip3 install` |
-| `workspace-write` | output-target flags (`--out`, `--output`, `--out-file`/`--outfile`/`--outFile`, `--dest`, `--destination`, `-o`) whose parsed value is a workspace-relative path, or an absolute path under the session workspace |
+| `workspace-write` | output-target flags (`--out`, `--output`, `--out-file`/`--outfile`/`--outFile`, `--dest`, `--destination`, `-o`) whose parsed value is a workspace-relative path, or an absolute path under the session workspace — the short `-o` counts only when the head binary is a known `-o` writer (`gcc`, `g++`, `cc`, `c++`, `clang`, `clang++`, `ld`, `rustc`, `go`, `curl`, `sort`, `psql`, `dotnet`); on every other binary it flows |
 
 **Honest positioning — this is belt-in-depth, NOT a sandbox.** A command
 that fails to classify is treated as READ-CLASS (fail-open on the channel,
@@ -684,7 +754,9 @@ the same posture as every refusal belt). The known bypass surface, verbatim:
 no redirect is indirection the classifier does not model), **`Start-Process`
 writers** (spawning a writer process is explicitly out of scope), and
 **encoded payloads** (`powershell -EncodedPayload …`, base64 blobs) are NOT
-covered; they flow on the readonly channel. The seal narrows the exec hole
+covered; they flow on the readonly channel. The short `-o` on a writer
+binary outside the known set flows (fail-open, disclosed). The seal narrows
+the exec hole
 from "completely open" to "explicitly constructed indirection" — a true OS
 level seal (write-time redirection, shadow copies, containers, win32+POSIX
 dual implementations) was evaluated and rejected as a disproportionate
@@ -789,22 +861,52 @@ requires a plan. The flow:
      (arm=true) folding the declared subtasks into criteria/checks; the arm
      dialog is the user's gate;
    - **standby** — no call; the crew waits until armed or abandoned.
-3. **Execute in waves** (armed crews only) of parallel native `task` calls
-   (results return in-turn; the next wave launches only after the previous
-   wave's results). GUI / computer-use subtasks are mutually exclusive within
-   a wave (the desktop is a singleton; non-GUI subtasks still parallelize
-   freely), and GUI walkthroughs use the `computer` tool rather than DIY
-   shell screenshot pipelines.
-4. **Missing role?** Run the subtask through a native task call anyway and
-   tell the user — suggest configuring the missing role.
-5. **Verify** each subtask against its acceptance-evidence statement;
-   retry a failure at most once.
-6. **Close** with `crew_close` — a hard, ask-gated gate cross-checking the
-   report against the DECLARED plan: every declared subtask needs a
-   PASS/FAIL verdict with evidence; an undeclared subtask in the report
-   refuses the close (fold discoveries into an existing verdict, or discard
-   and re-crew); a FAIL needs both failure reports.
-7. **Re-shard exit**: `crew_close {abandon: true, reason}` abandons the crew
+ 3. **Execute in waves** (armed crews only) of parallel native `task` calls
+    (results return in-turn; the next wave launches only after the previous
+    wave's results). GUI / computer-use subtasks are mutually exclusive within
+    a wave (the desktop is a singleton; non-GUI subtasks still parallelize
+    freely), and GUI walkthroughs use the `computer` tool rather than DIY
+    shell screenshot pipelines.
+ 4. **Auto-advance on idle** (armed crews only): when the session goes idle
+    between waves and no live active goal governs it, the plugin's
+    idle-continuation engine sends a `[forge:crew-continue]` brief (objective
+    + declared subtask titles + wave discipline) after the shared debounce —
+    waves advance autonomously until `crew_close`. A PENDING crew is never
+    auto-continued (that pause is the user's decision seam), a goal-governed
+    session belongs to the goal engine exclusively, and a non-forge speaker is
+    never continued. The engine keeps its OWN activity counter (task
+    dispatches and write-family calls count); after 3 consecutive
+    activity-free continuation turns it STOPS with one bounded console
+    disclosure — the crew itself stays registered (no auto-abandon, no
+    auto-close; nudge, close, or re-shard), and repeated transport failures
+    stop it the same way. A fresh `crew_begin` clears the stall; no disk
+    state is added (the crew record is unchanged).
+ 5. **Missing role?** Run the subtask through a native task call anyway and
+    tell the user — suggest configuring the missing role.
+ 6. **Native fallback lane** (crew-native-fallback): when the pool offers no
+    forge worker fitting a subtask, or `forge-*` dispatch is blocked by a
+    degraded (non-compliant) pool file, the armed crew dispatches the subtask
+    through the NATIVE task channel (e.g. the `general` subagent) with the
+    SAME relay contract as a forge dispatch — the change/artifact path for
+    authoritative guides, the scoped task prompt, and the evidence demands.
+    The fallback is recorded, never silent: the crew record's wave notes name
+    it, and the subtask's `crew_close` evidence statement says it ran native
+    (free text — the close gate's cross-check is unchanged; titles, verdicts
+    and evidence statements govern exactly as before, no new field). The
+    mid-crew compliance refusal names this exit while the pool is repaired —
+    the belt gates `forge-*` dispatch only. No guard changed: the
+    registration pre-flight still refuses a non-compliant pool outright
+    (D3), cross-pool refusals keep their copy, the pending belt stands, and
+    native targets were never refused for forge-family sessions and still
+    are not.
+ 7. **Verify** each subtask against its acceptance-evidence statement;
+    retry a failure at most once.
+ 8. **Close** with `crew_close` — a hard, ask-gated gate cross-checking the
+    report against the DECLARED plan: every declared subtask needs a
+    PASS/FAIL verdict with evidence; an undeclared subtask in the report
+    refuses the close (fold discoveries into an existing verdict, or discard
+    and re-crew); a FAIL needs both failure reports.
+ 9. **Re-shard exit**: `crew_close {abandon: true, reason}` abandons the crew
    — ask-gated like the close, no verdict requirements, usable from PENDING
    (standby cancel) and EXECUTING (wrong decomposition) alike. The session is
    immediately free for a fresh `crew_begin` with the corrected plan.

package/dist/index.js

@@ -12334,9 +12334,9 @@ function tool(input) {
 }
 tool.schema = exports_external;
 // plugin.ts
-import { execFileSync as execFileSync3 } from "node:child_process";
+import { execFileSync as execFileSync3, spawn as spawn6 } from "node:child_process";
 import { appendFileSync, existsSync as existsSync3, mkdirSync as mkdirSync5, readdirSync as readdirSync4, readFileSync as readFileSync8, realpathSync, statSync as statSync5, writeFileSync as writeFileSync5 } from "node:fs";
-import { basename as basename2, dirname as dirname4, isAbsolute, join as join6, relative } from "node:path";
+import { basename as basename2, dirname as dirname4, isAbsolute as isAbsolute2, join as join6, relative as relative2 } from "node:path";
 import { tmpdir as tmpdir3, homedir } from "node:os";
 
 // src/plan-file.ts
@@ -15029,6 +15029,7 @@ var WORKER_MANDATES = [
   "Mandates (non-negotiable):",
   "- Use workspace-relative paths ONLY. Never write to or read from absolute paths outside this workspace; the workspace root is where you were started, not the filesystem root.",
   "- Run every shell command through the forge_shell tool (the builtin shell is not part of your toolset by design). Long-running or non-exiting commands: forge_shell with run_in_background, then collect results via forge_jobs poll before yielding.",
+  "- Run every search through the forge_grep/forge_glob tools first — the builtin grep/glob tools are fallback only. forge_grep/forge_glob see through symlinks/junctions and dot-directories because follow and hidden are on by default.",
   "- If any tool call is refused or denied, report the refusal VERBATIM in your final answer and stop that line of work. Never improvise a workaround around a permission denial.",
   "- End with conclusions backed by evidence references (file:line, command output, or the exact file/content you produced)."
 ].join(`
@@ -15047,10 +15048,11 @@ var ROLE_PROMPTS = {
   research: "You are a research worker: search, read, and run read-only checks to answer the assigned question. Report findings as a compact brief with sources and file:line evidence; state plainly what could not be verified.",
   review: "You are a review worker: read the diff or files under review, run read-only checks/tests, and report findings as a prioritized list, each with file:line evidence and a concrete fix suggestion. End with a single-line verdict."
 };
-function rolePromptFor(agentId, def) {
-  if (def?.prompt && def.prompt.trim().length > 0)
-    return def.prompt;
-  return ROLE_PROMPTS[agentId] ?? `You are a ${agentId} worker. Execute the assigned task exactly as scoped.`;
+function rolePromptFor(agentId, def, shared) {
+  const chain = def?.prompt && def.prompt.trim().length > 0 ? def.prompt : ROLE_PROMPTS[agentId] ?? `You are a ${agentId} worker. Execute the assigned task exactly as scoped.`;
+  return shared === undefined ? chain : `${shared}
+
+${chain}`;
 }
 function poolProvenanceLine(provenance) {
   if ("global" in provenance) {
@@ -15064,7 +15066,7 @@ function agentDescriptionFor(agentId, def, provenance) {
   const base = `forge subagent "${agentId}" (${shape}, ${brain}) — dispatch via the task tool with subagent_type "forge-${agentId}".`;
   return provenance === undefined ? base : `${base} ${poolProvenanceLine(provenance)}`;
 }
-function forgeAgentDef(agentId, def, provenance) {
+function forgeAgentDef(agentId, def, provenance, sharedSeg) {
   const permission = { task: "deny" };
   const shape = def.shape ?? "write";
   if (shape === "readonly") {
@@ -15079,7 +15081,7 @@ function forgeAgentDef(agentId, def, provenance) {
     prompt: materializeAgentPrompt({
       agent: agentId,
       shape,
-      role: rolePromptFor(agentId, def)
+      role: rolePromptFor(agentId, def, sharedSeg)
     }),
     permission,
     tools: { shell: false, bash: false }
@@ -15141,12 +15143,27 @@ var WRITE_TARGET_FLAGS = [
   "--destination",
   "-o"
 ];
+var O_FLAG_WRITER_BINARIES = [
+  "gcc",
+  "g++",
+  "cc",
+  "c++",
+  "clang",
+  "clang++",
+  "ld",
+  "rustc",
+  "go",
+  "curl",
+  "sort",
+  "psql",
+  "dotnet"
+];
 var EXEC_SEAL_INDICATORS = [
   { id: REDIRECT_INDICATOR, covers: "`>` `>>` and fd forms (`2>` `*>`) — bash and the PowerShell family share the operators" },
   { id: "mutating-cmdlet", covers: MUTATING_CMDLETS.join(", ") },
   { id: "git-mutation", covers: `git ${GIT_MUTATING_SUBCOMMANDS.join("/")}` },
   { id: "pkg-mutation", covers: PKG_MUTATING_COMMANDS.join(", ") + " (with common aliases: npm i/ci/add, bun install, pip3 install)" },
-  { id: "workspace-write", covers: `output-target flags ${WRITE_TARGET_FLAGS.join(" ")} whose parsed value is a workspace-relative path (or an absolute path under the provided workspaceRoot)` }
+  { id: "workspace-write", covers: `output-target flags ${WRITE_TARGET_FLAGS.join(" ")} whose parsed value is a workspace-relative path (or an absolute path under the provided workspaceRoot); the short -o counts only when the head binary is a known -o writer (${O_FLAG_WRITER_BINARIES.join(", ")})` }
 ];
 function stripQuoted(cmd) {
   let out = "";
@@ -15165,6 +15182,57 @@ function stripQuoted(cmd) {
   }
   return out;
 }
+function tokenizeCommand(cmd) {
+  const tokens = [];
+  let text = "";
+  let quoted = false;
+  let mode = null;
+  let sawAny = false;
+  const flush = () => {
+    if (sawAny)
+      tokens.push({ text, quoted });
+    text = "";
+    quoted = false;
+    sawAny = false;
+  };
+  for (const ch of cmd) {
+    if (mode) {
+      if (ch === mode) {
+        mode = null;
+        continue;
+      }
+      text += ch;
+      sawAny = true;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      mode = ch;
+      quoted = true;
+      sawAny = true;
+      continue;
+    }
+    if (ch === " " || ch === "\t" || ch === "\r" || ch === `
+`) {
+      flush();
+      continue;
+    }
+    text += ch;
+    sawAny = true;
+  }
+  flush();
+  return tokens;
+}
+function resolveHeadBinary(tokens) {
+  let i = tokens.length > 0 && !tokens[0].quoted && tokens[0].text === "&" ? 1 : 0;
+  const head = tokens[i];
+  if (!head)
+    return "";
+  const parts = head.text.split(/[\\/]/);
+  let bin = parts[parts.length - 1].toLowerCase();
+  if (bin.endsWith(".exe"))
+    bin = bin.slice(0, -4);
+  return bin;
+}
 function redirectMatch(cmd) {
   const bare = stripQuoted(cmd).replace(/\r?\n/g, " ");
   const m = /(?:^|[^>&])>{1,2}(?!&)[^\s;&|]*/.exec(bare);
@@ -15213,25 +15281,33 @@ function insideWorkspace(value, workspaceRoot) {
   return norm(value).startsWith(`${norm(workspaceRoot)}/`) || norm(value) === norm(workspaceRoot);
 }
 function workspaceWriteMatch(cmd, workspaceRoot) {
-  const tokens = stripQuoted(cmd).split(/\s+/).filter(Boolean);
+  const tokens = tokenizeCommand(cmd);
+  const headBinary = resolveHeadBinary(tokens);
+  const headIsWriter = O_FLAG_WRITER_BINARIES.includes(headBinary);
   for (let i = 0;i < tokens.length; i++) {
     const tok = tokens[i];
+    if (tok.quoted)
+      continue;
     let flag = "";
-    let value;
-    const eq = tok.indexOf("=");
-    if (eq > 0 && tok.startsWith("--")) {
-      flag = tok.slice(0, eq);
-      value = tok.slice(eq + 1);
-    } else if (WRITE_TARGET_FLAGS.includes(tok)) {
-      flag = tok;
-      value = tokens[i + 1];
-    }
-    if (!flag || value === undefined)
+    let valueText;
+    const text = tok.text;
+    const eq = text.indexOf("=");
+    if (eq > 0 && text.startsWith("--")) {
+      flag = text.slice(0, eq);
+      valueText = text.slice(eq + 1);
+    } else if (WRITE_TARGET_FLAGS.includes(text)) {
+      if (text === "-o" && !headIsWriter)
+        continue;
+      flag = text;
+      const next = tokens[i + 1];
+      valueText = next?.text;
+    }
+    if (!flag || valueText === undefined)
       continue;
-    if (value.startsWith("-"))
+    if (valueText.startsWith("-"))
       continue;
-    if (pathLike(value) && insideWorkspace(value, workspaceRoot)) {
-      return { detail: `${flag} ${value}` };
+    if (pathLike(valueText) && insideWorkspace(valueText, workspaceRoot)) {
+      return { detail: `${flag} ${valueText}` };
     }
   }
   return null;
@@ -15856,6 +15932,7 @@ function createPoolResolver(deps) {
       parsed = {
         agents: {},
         declaredPool: null,
+        shared: null,
         findings: [
           {
             level: "error",
@@ -15865,11 +15942,20 @@ function createPoolResolver(deps) {
         ]
       };
     } else if (doc2.config !== undefined && !isRecord(doc2.config)) {
-      parsed = { agents: {}, declaredPool: null, findings: [{ level: "error", code: "config-not-object", message: `${path}: top level must be an object — this pool contributes no agents` }] };
+      parsed = { agents: {}, declaredPool: null, shared: null, findings: [{ level: "error", code: "config-not-object", message: `${path}: top level must be an object — this pool contributes no agents` }] };
     } else {
       const top = doc2.config === undefined ? undefined : doc2.config;
       const validated = validateAgentSet(top === undefined ? undefined : top.agents);
-      parsed = { agents: validated.agents, declaredPool: top === undefined ? null : top.pool, findings: validated.findings };
+      const sharedRaw = top === undefined ? undefined : top.shared;
+      let shared = null;
+      if (sharedRaw !== undefined && sharedRaw !== null) {
+        if (typeof sharedRaw === "string" && sharedRaw.trim().length > 0) {
+          shared = sharedRaw.trim();
+        } else {
+          validated.findings.push({ level: "warn", code: "shared-invalid", message: `${path}: the top-level "shared" field must be a non-empty string — ignored` });
+        }
+      }
+      parsed = { agents: validated.agents, declaredPool: top === undefined ? null : top.pool, shared, findings: validated.findings };
     }
     fileCache.set(path, { mtimeMs: st.mtimeMs, size: st.size, parsed });
     return parsed;
@@ -15924,7 +16010,7 @@ function createPoolResolver(deps) {
             }
           }
         }
-        families.push({ file: file2, parsed, ns: "", declaredPool });
+        families.push({ file: file2, parsed, ns: "", declaredPool, shared: parsed?.shared ?? null });
       }
       const allDeclared = new Set;
       for (const f of families)
@@ -15957,10 +16043,10 @@ function createPoolResolver(deps) {
             findings.push({ level: "error", code: "materialized-id-collision", message: `materialized agent forge-${matId} from ${f.file} collides with the one from ${existing.file} — the earlier pool in resolution order wins, this agent is skipped` });
             continue;
           }
-          agents[matId] = { materializedId: matId, def: own[rawId], ns: f.ns, file: f.file };
+          agents[matId] = { materializedId: matId, def: own[rawId], ns: f.ns, file: f.file, shared: f.shared };
           ids.push(matId);
         }
-        origins.push({ file: f.file, ns: f.ns, declaredPool: f.declaredPool, materializedIds: ids });
+        origins.push({ file: f.file, ns: f.ns, declaredPool: f.declaredPool, shared: f.shared, materializedIds: ids });
       }
       return { families: origins, agents, findings };
     }
@@ -15974,6 +16060,202 @@ function parentDirLabel(filePath) {
   return i < 0 ? s : s.slice(0, i);
 }
 
+// src/search-core.ts
+import { join as winJoin } from "node:path";
+import { join as posixJoin } from "node:path/posix";
+import { relative, isAbsolute } from "node:path";
+import { existsSync as fsExistsSync } from "node:fs";
+var GIT_EXCLUSION_GLOB = "--glob=!**/.git/**";
+function buildRgArgv(params) {
+  const { kind, pattern, path, include } = params;
+  const follow = params.follow !== false;
+  const hidden = params.hidden !== false;
+  const argv = ["--no-config", "--json"];
+  if (hidden)
+    argv.push("--hidden");
+  if (follow)
+    argv.push("--follow");
+  argv.push(GIT_EXCLUSION_GLOB);
+  if (typeof include === "string" && include.length > 0) {
+    argv.push(`--glob=${include}`);
+  }
+  argv.push("--");
+  argv.push(pattern);
+  if (typeof path === "string" && path.length > 0)
+    argv.push(path);
+  return argv;
+}
+function buildRgFilesArgv(params) {
+  const follow = params.follow !== false;
+  const hidden = params.hidden !== false;
+  const argv = ["--no-config", "--files"];
+  if (hidden)
+    argv.push("--hidden");
+  if (follow)
+    argv.push("--follow");
+  argv.push(`--glob=${params.pattern}`);
+  argv.push(GIT_EXCLUSION_GLOB);
+  if (typeof params.path === "string" && params.path.length > 0)
+    argv.push(params.path);
+  return argv;
+}
+function parseRgFilesList(stdout) {
+  if (typeof stdout !== "string" || stdout.length === 0)
+    return [];
+  return stdout.split(/\r?\n/).filter((l) => l.length > 0).map((p) => ({ path: p, line: 0, text: "" }));
+}
+var MAX_STREAM_LINE_LENGTH = 1048576;
+function parseRgJsonStream(stdout) {
+  const out = { records: [], garbageLines: 0, oversizedLines: 0 };
+  if (typeof stdout !== "string" || stdout.length === 0)
+    return out;
+  const lines = stdout.split(/\r?\n/);
+  for (const raw of lines) {
+    if (raw.length === 0)
+      continue;
+    if (raw.length > MAX_STREAM_LINE_LENGTH) {
+      out.oversizedLines++;
+      continue;
+    }
+    let ev;
+    try {
+      ev = JSON.parse(raw);
+    } catch {
+      out.garbageLines++;
+      continue;
+    }
+    if (ev === null || typeof ev !== "object" || ev.type !== "match")
+      continue;
+    const data = ev.data;
+    if (data === null || typeof data !== "object")
+      continue;
+    const pathText = data?.path?.text;
+    const lineNumber = data?.line_number;
+    const lineText = data?.lines?.text;
+    if (typeof pathText !== "string" || typeof lineNumber !== "number" || typeof lineText !== "string")
+      continue;
+    out.records.push({ path: pathText, line: lineNumber, text: lineText });
+  }
+  return out;
+}
+function createMemoizedResolver(resolve2) {
+  const cache = new Map;
+  return (p) => {
+    const hit = cache.get(p);
+    if (hit !== undefined)
+      return hit;
+    const v = resolve2(p);
+    cache.set(p, v);
+    return v;
+  };
+}
+function isOutsideWorktree(resolved, root) {
+  const norm = (s) => s.replaceAll("\\", "/").replace(/\/+$/, "").toLowerCase();
+  const r = norm(root);
+  const v = norm(resolved);
+  if (v === r)
+    return false;
+  const rel = relative(r, v);
+  return rel.startsWith("..") || isAbsolute(rel);
+}
+function dedupeFollowMatches(records, opts) {
+  if (!opts.follow)
+    return { records: [...records], mergedDuplicates: 0, outsideTargets: [] };
+  const resolve2 = createMemoizedResolver(opts.resolvePath);
+  const seen = new Map;
+  const outside = new Set;
+  let merged = 0;
+  for (const rec of records) {
+    const real = resolve2(rec.path);
+    if (isOutsideWorktree(real, opts.worktreeRoot))
+      outside.add(real);
+    const bucket = seen.get(real);
+    if (bucket === undefined) {
+      seen.set(real, [rec]);
+      continue;
+    }
+    const sameLine = bucket.find((k) => k.line === rec.line);
+    if (sameLine !== undefined) {
+      merged++;
+      if (rec.path < sameLine.path)
+        sameLine.path = rec.path;
+      continue;
+    }
+    if (rec.path < bucket[0].path)
+      bucket[0].path = rec.path;
+    bucket.push(rec);
+  }
+  const kept = [];
+  for (const bucket of seen.values()) {
+    const firstPath = bucket.reduce((m, r) => r.path < m ? r.path : m, bucket[0].path);
+    for (const r of bucket)
+      kept.push({ ...r, path: firstPath });
+  }
+  kept.sort((a, b) => a.path === b.path ? a.line - b.line : a.path < b.path ? -1 : 1);
+  return { records: kept, mergedDuplicates: merged, outsideTargets: [...outside].sort() };
+}
+var RG_MISSING_REMEDIES = "install ripgrep (or set search.rgPath in forge config to an existing rg binary), or fall back to the builtin grep/glob tools for this search";
+function resolveRgBinary(config2, seams) {
+  const platform = seams?.platform ?? process.platform;
+  const sep2 = seams?.pathSep ?? (platform === "win32" ? ";" : ":");
+  const exists = seams?.existsSync ?? fsExistsSync;
+  const pathEnv = seams?.pathEnv ?? (process.env.PATH ?? "");
+  if (typeof config2?.rgPath === "string" && config2.rgPath.length > 0 && exists(config2.rgPath)) {
+    return { ok: true, binary: config2.rgPath, source: "config" };
+  }
+  const exe = platform === "win32" ? "rg.exe" : "rg";
+  const join6 = platform === "win32" ? winJoin : posixJoin;
+  for (const dir of pathEnv.split(sep2)) {
+    if (dir.length === 0)
+      continue;
+    const candidate = join6(dir, exe);
+    if (exists(candidate))
+      return { ok: true, binary: candidate, source: "path" };
+  }
+  return {
+    ok: false,
+    error: `ripgrep (rg) not found — ${RG_MISSING_REMEDIES}`
+  };
+}
+var MAX_RESULTS = 100;
+function formatSearchOutput(records, opts) {
+  const lines = [];
+  const total = records.length;
+  if (total === 0) {
+    lines.push("No files found");
+  } else if (opts.kind === "glob") {
+    const unique = [];
+    const seen = new Set;
+    for (const r of records) {
+      if (!seen.has(r.path)) {
+        seen.add(r.path);
+        unique.push(r.path);
+      }
+    }
+    for (const p of unique.slice(0, MAX_RESULTS))
+      lines.push(p);
+    if (unique.length > MAX_RESULTS) {
+      lines.push(`(truncated at ${MAX_RESULTS} results — narrow the path or pattern)`);
+    }
+  } else {
+    lines.push(`Found ${total} matches`);
+    const shown = records.slice(0, MAX_RESULTS);
+    for (const r of shown)
+      lines.push(`${r.path}: Line ${r.line}: ${r.text.replace(/\r?\n$/, "")}`);
+    if (total > MAX_RESULTS) {
+      lines.push(`(truncated at ${MAX_RESULTS} results of ${total} — narrow the path or pattern)`);
+    }
+  }
+  for (const t of opts.outsideTargets ?? []) {
+    lines.push(`outside-workspace target searched via link: ${t}`);
+  }
+  const merged = opts.mergedDuplicates ?? 0;
+  if (merged > 0)
+    lines.push(`+${merged} duplicate paths merged`);
+  return lines.join(`
+`);
+}
+
 // plugin.ts
 var FORGE_AGENT = "forge";
 var FORGE_STATE_TOOLS = [
@@ -15992,7 +16274,8 @@ var FORGE_STATE_TOOLS = [
   "crew_close"
 ];
 var FORGE_EXEC_TOOLS = ["forge_shell", "forge_jobs"];
-var FORGE_ALL_TOOLS = [...FORGE_STATE_TOOLS, ...FORGE_EXEC_TOOLS];
+var FORGE_SEARCH_TOOLS = ["forge_grep", "forge_glob"];
+var FORGE_ALL_TOOLS = [...FORGE_STATE_TOOLS, ...FORGE_EXEC_TOOLS, ...FORGE_SEARCH_TOOLS];
 var FORGE_TOOL_SET = new Set(FORGE_ALL_TOOLS);
 var FORGE_STATE_TOOL_SET = new Set(FORGE_STATE_TOOLS);
 var NATIVE_PARTITION_FALLBACKS = ["build", "plan", "general", "explore"];
@@ -16165,6 +16448,8 @@ function crewPoolComplianceRefusal(anchor) {
   const suggested = fam?.ns ?? sanitizeNamespace(basename2(dirname4(dirname4(poolFile))));
   return `[forge:crew] Pool compliance refused: this session's workspace pool file (${poolFile}) is non-compliant — ${verdict.violation}. ` + `Minimal fix: add or repair the top-level "pool": "${suggested}" field (a [a-z0-9-] string, 1-24 chars — REQUIRED for crew-governed dispatch). ` + `The gate lifts hot-apply: the next resolve after the repair admits registration/dispatch; no host restart.`;
 }
+var CREW_NATIVE_FALLBACK_RULE = "Native fallback: when the pool offers no forge worker fitting a subtask (or forge-* dispatch is blocked by a degraded pool), dispatch the native general subagent with the same relay contract (artifact path, scoped prompt, evidence demands) and RECORD the fallback (wave notes + the subtask's close evidence says it ran native).";
+var CREW_COMPLIANCE_NATIVE_EXIT = " Native exit: while the pool is being repaired, the affected subtask may dispatch through the NATIVE task channel with the same relay contract — this compliance belt gates forge-* dispatch only, never the crew's existence.";
 var crews = new Map;
 function crewRecordPathFor(worktree, objective) {
   const dir = join6(worktree, ".opencode", "crew");
@@ -16214,7 +16499,7 @@ function crewPendingChoiceLines() {
   return [
     "[forge:crew] The crew is PENDING — execution has NOT started. Present the execution-mode choice to the user and END YOUR TURN (every task dispatch is refused while the crew pends):",
     `RELAY FIRST: tell the user the crew record path (it leads this output) alongside this choice — the record is on disk from the registration moment, and the user must hear it.`,
-    `  1. supervised waves NOW — when the user says go, call crew_begin {execution: "waves"} and run the wave discipline;`,
+    `  1. supervised waves NOW — when the user says go, call crew_begin {execution: "waves"} and run the wave discipline; waves auto-advance on session idle until crew_close (the engine stops after a stall — nudge or re-shard);`,
     `  2. convert to a goal contract — call crew_begin {execution: "goal"} (the crew ends as a conversion record; no extra dialog here), then draft goal_write with arm=true folding the declared subtasks into criteria/checks — the arm dialog is the user's gate;`,
     `  3. standby — no call; the crew waits until armed or abandoned.`
   ];
@@ -16424,7 +16709,7 @@ function resolveActivePlan(state) {
   return { path, doc: ranked[0].doc };
 }
 function relFrom(worktree, path) {
-  const rel = relative(worktree, path);
+  const rel = relative2(worktree, path);
   return rel && !rel.startsWith("..") ? rel.replaceAll("\\", "/") : path;
 }
 var planWriteTool = tool({
@@ -16912,7 +17197,7 @@ var forgeShellTool = tool({
       }
     }
     const { registry: registry2, fence } = ensureJobLifecycle();
-    const cwd = args.workdir ? isAbsolute(args.workdir) ? args.workdir : join6(state.worktree, args.workdir) : state.worktree;
+    const cwd = args.workdir ? isAbsolute2(args.workdir) ? args.workdir : join6(state.worktree, args.workdir) : state.worktree;
     const started = startJob(jobManager, {
       cmd: args.command,
       cwd,
@@ -17066,6 +17351,107 @@ ${p.newOutput || "(none in this window)"}`,
     };
   }
 });
+var searchRgPathOverride;
+var FORGE_SEARCH_PREFERENCE_LINE = "Prefer forge_grep/forge_glob over the builtin grep/glob — follow and hidden are on by default (symlinks/junctions and dot-directories are in scope; the builtin pair is blind to both).";
+var FORGE_GREP_DESCRIPTION = [
+  "Fast content search (rg --json under the hood) that sees through symlinks/junctions and dot-directories where the builtin pair is blind. Readonly by construction: the pattern and path are passed to ripgrep as single literal arguments — no shell exists, so shell metacharacters can neither redirect output nor alter execution.",
+  "Output matches the builtin grep's format: `Found N matches` header + `path: Line n: content` blocks, truncated at 100 results with a notice. With follow on (default), a file reachable through multiple paths reports once and the output ends with a `+N duplicate paths merged` line; links whose targets lie outside the workspace are followed and the resolved outside target is disclosed.",
+  FORGE_SEARCH_PREFERENCE_LINE
+].join(`
+`);
+var FORGE_GLOB_DESCRIPTION = [
+  "Fast file-pattern search (rg --files under the hood, the file pattern rides rg's --glob filter) that lists matching paths — including EMPTY files — and paths behind symlinks/junctions and inside dot-directories where the builtin glob is blind. Readonly by construction — no shell ever exists.",
+  "Output matches the builtin glob's format: a plain unique path list (`No files found` when empty), truncated at 100 results with a notice. With follow on (default), duplicate link-path hits merge and the output ends with a `+N duplicate paths merged` line.",
+  FORGE_SEARCH_PREFERENCE_LINE
+].join(`
+`);
+function reportedPathResolver(worktree) {
+  return (p) => {
+    try {
+      return realpathSync.native(isAbsolute2(p) ? p : join6(worktree, p)).toString();
+    } catch {
+      return p;
+    }
+  };
+}
+async function runRgSearch(kind, args, context) {
+  const resolution = resolveRgBinary(searchRgPathOverride !== undefined ? { rgPath: searchRgPathOverride } : undefined);
+  if (!resolution.ok)
+    return { title: "ripgrep not found", output: resolution.error };
+  const state = ensureSession(context.sessionID, worktreeFor(context));
+  const follow = args.follow !== false;
+  const hidden = args.hidden !== false;
+  const targetPath = typeof args.path === "string" && args.path.length > 0 ? isAbsolute2(args.path) ? args.path : join6(state.worktree, args.path) : undefined;
+  const searchPath = targetPath ?? ".";
+  const argv = kind === "glob" ? buildRgFilesArgv({ pattern: args.pattern, path: searchPath, follow, hidden }) : buildRgArgv({ kind, pattern: args.pattern, include: args.include, path: searchPath, follow, hidden });
+  context.metadata?.({ title: `forge_${kind}: ${args.pattern.slice(0, 60)}` });
+  const child = spawn6(resolution.binary, argv, { cwd: state.worktree, shell: false, windowsHide: true, stdio: ["ignore", "pipe", "pipe"] });
+  let stdout = "";
+  let stderr = "";
+  let spawnError;
+  child.on("error", (err) => {
+    spawnError = err;
+  });
+  child.stdout?.on("data", (d) => {
+    stdout += d.toString("utf8");
+  });
+  child.stderr?.on("data", (d) => {
+    stderr += d.toString("utf8");
+  });
+  const code = await new Promise((resolve2) => {
+    child.on("close", (c) => resolve2(c));
+  });
+  if (spawnError !== undefined) {
+    return { title: "rg spawn failed", output: `[forge:search] Failed to run ripgrep (${resolution.binary}): ${spawnError.message}` };
+  }
+  if (code !== null && code > 1) {
+    return { title: `rg exit ${code}`, output: [`[forge:search] ripgrep exited ${code}:`, stderr.trim() || "(no stderr)", "Narrow the path or fix the pattern (rg treats it as a regular expression)."].join(`
+`) };
+  }
+  const stripDotPrefix = (p) => p.replace(/^\.(?:\\|\/)/, "");
+  const rawRecords = kind === "glob" ? parseRgFilesList(stdout) : parseRgJsonStream(stdout).records;
+  const records = rawRecords.map((r) => ({ ...r, path: stripDotPrefix(r.path) }));
+  const deduped = dedupeFollowMatches(records, {
+    worktreeRoot: state.worktree,
+    resolvePath: reportedPathResolver(state.worktree),
+    follow
+  });
+  return {
+    title: `${deduped.records.length} result${deduped.records.length === 1 ? "" : "s"}`,
+    output: formatSearchOutput(deduped.records, {
+      kind,
+      mergedDuplicates: deduped.mergedDuplicates,
+      outsideTargets: deduped.outsideTargets
+    })
+  };
+}
+var forgeGrepTool = tool({
+  description: FORGE_GREP_DESCRIPTION,
+  args: {
+    pattern: tool.schema.string().describe("The regular expression to search for (passed to ripgrep verbatim as a single literal argument)"),
+    path: tool.schema.string().optional().describe("Optional target file or directory (workspace-relative, or absolute). Defaults to the session worktree"),
+    include: tool.schema.string().optional().describe('File filter glob (e.g. "*.ts") — only matching files are searched'),
+    follow: tool.schema.boolean().optional().describe("Follow symlinks/junctions during traversal (default TRUE — diverges from the builtin pair by design)"),
+    hidden: tool.schema.boolean().optional().describe("Search dot-directories (default TRUE — diverges from the builtin pair by design)")
+  },
+  execute: async (args, context) => {
+    noteToolAgent(context);
+    return runRgSearch("grep", { pattern: args.pattern, path: args.path, include: args.include, follow: args.follow, hidden: args.hidden }, context);
+  }
+});
+var forgeGlobTool = tool({
+  description: FORGE_GLOB_DESCRIPTION,
+  args: {
+    pattern: tool.schema.string().describe(`The file-pattern glob to list (e.g. "**/*.ts") — rides ripgrep's --glob filter verbatim`),
+    path: tool.schema.string().optional().describe("Optional target directory (workspace-relative, or absolute). Defaults to the session worktree"),
+    follow: tool.schema.boolean().optional().describe("Follow symlinks/junctions during traversal (default TRUE — diverges from the builtin pair by design)"),
+    hidden: tool.schema.boolean().optional().describe("List dot-directories' files (default TRUE — diverges from the builtin pair by design)")
+  },
+  execute: async (args, context) => {
+    noteToolAgent(context);
+    return runRgSearch("glob", { pattern: args.pattern, path: args.path, follow: args.follow, hidden: args.hidden }, context);
+  }
+});
 var CREW_INIT_TEMPLATE = [
   '(forge crew orchestration. Argument: "$ARGUMENTS")',
   "",
@@ -17106,8 +17492,8 @@ function crewOrchestrationTemplate(resolution) {
     "You are entering CREW ORCHESTRATION discipline for this session (single subject: do not switch agents). The macro contract above the crew may come from an approved plan, a spec change, or inline text — the discipline is identical in all three cases and never requires a plan. Follow it exactly:",
     "",
     '1. REGISTER: call `crew_begin` with the objective AND the declared subtask plan (subtasks[]: one {title} per subtask, optionally naming the intended forge-* agent). When the macro contract descends from a plan artifact, pass its path as the optional `lineage` argument (e.g. lineage: ".opencode/plan/2026-10-01-my-plan.md") — the descent is recorded as a first-class line in the crew record header; lineage is never inferred. Reconnaissance BEFORE registration is free (task calls included). If crew_begin refuses (a crew is already active here, or a plan draft is active), STOP and tell the user why — never start a second crew. A wrong plan is fixed by abandoning and re-crewing (crew_close {abandon: true, reason}), never by improvising outside the declared plan.',
-    `2. THE PAUSE: registration enters a PENDING crew — execution has NOT started. STOP and present the user the three execution-mode choices (supervised waves now / convert to a goal contract / standby), then END YOUR TURN. Arm per the user's choice: waves → crew_begin {execution: "waves"}; conversion → crew_begin {execution: "goal"} followed by goal_write (arm=true — its dialog is the user's gate) folding the declared subtasks into criteria/checks; standby → no call. EXCEPTION: while a live active goal governs this session, register with execution: "waves" in the SAME call — the crew is born armed (the goal contract already authorized orchestration) and crew_close / abandon stay ask-free under that goal.`,
-    "3. WAVES, NEVER FLOODS (armed crews only): execute subtasks in waves of parallel native `task` calls (subagent_type = the matching forge-* agent; a wave's results return within the calling turn). Launch the next wave ONLY after the previous wave's results are in. GUI / computer-use subtasks are mutually exclusive within a wave (the desktop is a singleton resource — at most ONE in flight; non-GUI subtasks still parallelize freely), and GUI walkthroughs use the `computer` tool rather than DIY shell screenshot pipelines.",
+    `2. THE PAUSE: registration enters a PENDING crew — execution has NOT started. STOP and present the user the three execution-mode choices (supervised waves now / convert to a goal contract / standby), then END YOUR TURN. Arm per the user's choice: waves → crew_begin {execution: "waves"} (waves then auto-advance on session idle until crew_close — the engine stops after a stall, nudge or re-shard); conversion → crew_begin {execution: "goal"} followed by goal_write (arm=true — its dialog is the user's gate) folding the declared subtasks into criteria/checks; standby → no call. EXCEPTION: while a live active goal governs this session, register with execution: "waves" in the SAME call — the crew is born armed (the goal contract already authorized orchestration) and crew_close / abandon stay ask-free under that goal.`,
+    "3. WAVES, NEVER FLOODS (armed crews only): execute subtasks in waves of parallel native `task` calls (subagent_type = the matching forge-* agent; a wave's results return within the calling turn). Launch the next wave ONLY after the previous wave's results are in. GUI / computer-use subtasks are mutually exclusive within a wave (the desktop is a singleton resource — at most ONE in flight; non-GUI subtasks still parallelize freely), and GUI walkthroughs use the `computer` tool rather than DIY shell screenshot pipelines. Native fallback: when the pool offers no forge worker fitting a subtask (or forge-* dispatch is blocked by a degraded pool), dispatch the native general subagent with the same relay contract (artifact path, scoped prompt, evidence demands) and RECORD the fallback (wave notes + the subtask's close evidence says it ran native).",
     "4. CONTRACT RELAY (lineage-descended crews): when the macro contract descends from an on-disk artifact (the lineage names a plan artifact, a spec change directory, or a goal contract), every subtask's dispatch prompt MUST explicitly carry that artifact's path — or the exact slice the subtask works from (a delta file path, a quoted criteria section) — so the dispatched worker reads the contract itself, never your paraphrase of it. A large artifact is relayed by its exact slice; it is NEVER dropped for being too long to inline. Every close-report evidence statement MUST name the contract (or slice) the subtask worked against.",
     "5. MISSING ROLE: when a subtask needs a role no configured forge-* agent matches, run that subtask through a native task call anyway AND tell the user about the gap — suggest configuring the missing role in forge.json.",
     "6. VERIFY: judge each subtask strictly against its acceptance-evidence statement from the task result text. A result that does not meet the statement is a failure even if the worker sounded confident.",
@@ -17201,9 +17587,11 @@ var crewBeginTool = tool({
         title: `crew armed: ${crew.objective.slice(0, 60)}`,
         output: [
           `[forge:crew] Crew ARMED for supervised waves: ${crew.objective}`,
+          `Waves auto-advance on session idle until crew_close (the engine stops after a stall — nudge or re-shard).`,
           `Declared plan (${crew.subtasks.length}):`,
           ...crew.subtasks.map((s, i) => `  ${i + 1}. ${s.title}${s.agent ? ` → ${s.agent}` : ""}`),
-          "Proceed with the wave discipline: waves of parallel native task calls (next wave after the previous results) → per-subtask evidence verdicts → at most one retry → crew_close with the full report covering every declared subtask."
+          "Proceed with the wave discipline: waves of parallel native task calls (next wave after the previous results) → per-subtask evidence verdicts → at most one retry → crew_close with the full report covering every declared subtask.",
+          CREW_NATIVE_FALLBACK_RULE
         ].join(`
 `)
       };
@@ -17255,6 +17643,7 @@ var crewBeginTool = tool({
         recordNote = "Crew record could not be written (fail-soft; the crew still runs).";
       }
     }
+    crewEngineForgetSession(context.sessionID);
     crews.set(context.sessionID, { objective: objectiveText, startedAt: nowIso(), subtasks, mode: governed ? "executing" : "pending", recordPath });
     appendCrewRecord(recordPath, governed ? "registered (born armed under a governing goal)" : "registered (pending)", subtasks.map((s, i) => `${i + 1}. ${s.title}${s.agent ? ` → ${s.agent}` : ""}`));
     let disclosure = "";
@@ -17292,7 +17681,7 @@ var crewBeginTool = tool({
       ...disclosure ? [disclosure] : []
     ];
     if (governed) {
-      lines.push("Goal-delegated orchestration: the governing goal contract already authorized this crew — run the wave discipline NOW (crew gates stay internal to the loop; crew_close and abandon are ask-free under this goal), and re-shard via crew_close {abandon: true, reason} + a fresh one-call crew_begin when the decomposition proves wrong.", "Wave discipline: waves of parallel native task calls (next wave after the previous results) → per-subtask evidence verdicts → at most one retry → crew_close with the full report covering every declared subtask.");
+      lines.push("Goal-delegated orchestration: the governing goal contract already authorized this crew — run the wave discipline NOW (crew gates stay internal to the loop; crew_close and abandon are ask-free under this goal), and re-shard via crew_close {abandon: true, reason} + a fresh one-call crew_begin when the decomposition proves wrong.", "This crew is driven by the goal engine's own continuations (no separate crew briefs); standalone waves auto-advance on session idle until crew_close (the engine stops after a stall — nudge or re-shard).", "Wave discipline: waves of parallel native task calls (next wave after the previous results) → per-subtask evidence verdicts → at most one retry → crew_close with the full report covering every declared subtask.", CREW_NATIVE_FALLBACK_RULE);
     } else {
       lines.push(...crewPendingChoiceLines());
     }
@@ -17383,6 +17772,8 @@ function forgeTools() {
     tools.forge_shell = forgeShellTool;
     tools.forge_jobs = forgeJobsTool;
   }
+  tools.forge_grep = forgeGrepTool;
+  tools.forge_glob = forgeGlobTool;
   if (!forgeDisabled) {
     tools.crew_begin = crewBeginTool;
     tools.crew_close = crewCloseTool;
@@ -17430,6 +17821,91 @@ function engineForgetAll() {
   for (const id of [...idleTimers.keys()])
     engineForgetSession(id);
 }
+var CREW_NO_PROGRESS_LIMIT = 3;
+var crewPendingTurn = new Set;
+var crewTurnActivity = new Map;
+var crewNoProgress = new Map;
+var crewStalled = new Set;
+function crewEngineForgetSession(sessionID) {
+  crewPendingTurn.delete(sessionID);
+  crewTurnActivity.delete(sessionID);
+  crewNoProgress.delete(sessionID);
+  crewStalled.delete(sessionID);
+}
+function crewContinueBrief(crew) {
+  return [
+    `[forge:crew-continue] The crew "${crew.objective}" is armed (waves) — continue the wave discipline.`,
+    `Declared plan (every subtask needs a verdict at close):`,
+    ...crew.subtasks.map((s, i) => `${i + 1}. ${s.title}`),
+    `Next: dispatch the next wave (parallel task calls — forge-* workers from this session's pool, or the native general subagent when no forge worker fits), collect per-subtask evidence verdicts, at most one retry per subtask, then crew_close with the full report. Stalled or wrong decomposition? crew_close {abandon: true, reason} to re-shard.`
+  ].join(`
+`);
+}
+async function continueCrewIfEligible(client, state, sessionID) {
+  const crew = crews.get(sessionID);
+  if (!crew || crew.mode !== "executing") {
+    goalProbe(`crew skip: no executing crew session=${sessionID}`);
+    return;
+  }
+  if (crewStalled.has(sessionID)) {
+    goalProbe(`crew skip: stalled session=${sessionID}`);
+    return;
+  }
+  if (!sessionIsForgeFamily(sessionID)) {
+    goalProbe(`crew skip: agent switched to non-forge before send session=${sessionID}`);
+    return;
+  }
+  if (crewPendingTurn.has(sessionID)) {
+    crewPendingTurn.delete(sessionID);
+    const act = crewTurnActivity.get(sessionID);
+    if (act && (act.dispatches > 0 || act.writes > 0)) {
+      crewNoProgress.delete(sessionID);
+    } else {
+      const n = (crewNoProgress.get(sessionID) ?? 0) + 1;
+      crewNoProgress.set(sessionID, n);
+      goalProbe(`crew no-progress session=${sessionID} streak=${n}`);
+      if (n >= CREW_NO_PROGRESS_LIMIT) {
+        crewStalled.add(sessionID);
+        crewTurnActivity.delete(sessionID);
+        console.warn(`[forge:crew-continue] stalled: crew "${crew.objective.slice(0, 80)}" produced ${n} activity-free continuation turns — the engine stops continuing it (the crew stays registered; nudge the session, crew_close the report, or crew_close {abandon: true, reason} to re-shard).`);
+        return;
+      }
+    }
+  }
+  if (typeof client.session.status === "function") {
+    try {
+      const st = await client.session.status({ path: { id: sessionID } });
+      const t = st?.[sessionID]?.type;
+      if (t && t !== "idle") {
+        goalProbe(`crew skip: session busy again session=${sessionID} status=${t}`);
+        return;
+      }
+    } catch (err) {
+      goalProbe(`crew skip: status check failed session=${sessionID} err=${String(err)}`);
+      return;
+    }
+  }
+  try {
+    await client.session.prompt({
+      path: { id: sessionID },
+      body: { parts: [{ type: "text", text: crewContinueBrief(crew) }] }
+    });
+    transportFails.delete(sessionID);
+    crewPendingTurn.add(sessionID);
+    crewTurnActivity.set(sessionID, { dispatches: 0, writes: 0 });
+    goalProbe(`crew continued session=${sessionID} objective="${crew.objective.slice(0, 60)}"`);
+  } catch (err) {
+    const n = (transportFails.get(sessionID) ?? 0) + 1;
+    transportFails.set(sessionID, n);
+    goalProbe(`crew transport failure session=${sessionID} count=${n} err=${String(err)}`);
+    if (n >= TRANSPORT_FAILURE_LIMIT) {
+      crewStalled.add(sessionID);
+      crewPendingTurn.delete(sessionID);
+      crewTurnActivity.delete(sessionID);
+      console.warn(`[forge:crew-continue] stopped: ${n} consecutive delivery failures for crew "${crew.objective.slice(0, 80)}" — the engine stops continuing it (the crew stays registered; nudge the session or crew_close when back).`);
+    }
+  }
+}
 function goalBriefText(state, goal) {
   const d = goal.doc;
   return [
@@ -17442,7 +17918,7 @@ ${d.checks.map((c, i) => `${i + 1}. ${c.kind === "shell" ? `shell \`${c.cmd}\``
 `)}`,
     d.constraints.trim() ? `Constraints: ${d.constraints.trim()}` : "",
     `Budget: ${d.turnsUsed}/${d.maxTurns} turns used. Work the criteria now; call goal_check when you believe they hold, then goal_complete (it re-runs every check itself and asks the user). If genuinely blocked, call goal_pause with the blocker — do not spin.`,
-    `Crew layer: you own it under this goal — when parallel decomposition serves a criterion, register crews with crew_begin {objective, subtasks, execution: "waves"} in ONE call (born armed; no pause mid-loop), dispatch forge-* waves, and re-shard a wrong decomposition via crew_close {abandon: true, reason} plus a fresh registration. Crew gates stay internal to this loop.`,
+    `Crew layer: you own it under this goal — when parallel decomposition serves a criterion, register crews with crew_begin {objective, subtasks, execution: "waves"} in ONE call (born armed; no pause mid-loop), dispatch forge-* waves, and re-shard a wrong decomposition via crew_close {abandon: true, reason} plus a fresh registration. Crew gates stay internal to this loop (your goal turns drive the crew — no separate crew idle briefs fire under this goal; standalone waves auto-advance on session idle until crew_close).`,
     `Goal file: ${relFrom(state.worktree, goal.path)}`
   ].filter((s) => s.length > 0).join(`
 `);
@@ -17516,12 +17992,9 @@ async function continueIfEligible(client, sessionID) {
       }
     }
     const goal = resolveLiveGoal(state);
-    if (!goal || goal.doc.status !== "active") {
-      goalProbe(`skip: no live active goal session=${sessionID}`);
-      return;
-    }
-    if (!goal.doc.session || goal.doc.session !== sessionID) {
-      goalProbe(`skip: not goal owner session=${sessionID} owner=${goal.doc.session || "(none)"}`);
+    if (!goal || goal.doc.status !== "active" || !goal.doc.session || goal.doc.session !== sessionID) {
+      goalProbe(`no live active goal owned by session=${sessionID} — crew branch`);
+      await continueCrewIfEligible(client, state, sessionID);
       return;
     }
     if (!sessionIsForgeFamily(sessionID)) {
@@ -17628,6 +18101,8 @@ var server = async (input, options) => {
   jobsKeepBuiltinShell = jobsOpts?.keepBuiltinShell === true;
   if (jobsOpts?.survive === "never" || jobsOpts?.survive === "always" || jobsOpts?.survive === "deny")
     jobsSurviveMode = jobsOpts.survive;
+  const searchOpts = options?.search;
+  searchRgPathOverride = typeof searchOpts?.rgPath === "string" && searchOpts.rgPath.trim().length > 0 ? searchOpts.rgPath : undefined;
   const wdOpts = options?.watchdog;
   const wdFallbacks = [];
   const wdMode = parseMode(wdOpts?.mode);
@@ -17742,7 +18217,7 @@ var server = async (input, options) => {
         if (agentSection[id] !== undefined)
           continue;
         const provenance = foldPath(agent.file) === foldPath(globalMaterializationPath) ? { global: true } : { ns: agent.ns, file: agent.file };
-        const entry = forgeAgentDef(matId, agent.def, provenance);
+        const entry = forgeAgentDef(matId, agent.def, provenance, agent.shared ?? undefined);
         agentSection[id] = entry;
         materializedSnapshot[id] = entry;
       }
@@ -17859,7 +18334,7 @@ var server = async (input, options) => {
             if (anchor) {
               const complianceRefusal = crewPoolComplianceRefusal(anchor);
               if (complianceRefusal)
-                throw new Error(complianceRefusal);
+                throw new Error(complianceRefusal + CREW_COMPLIANCE_NATIVE_EXIT);
             }
           }
         }
@@ -17872,7 +18347,7 @@ var server = async (input, options) => {
           if (raw) {
             const state = stateForBan(input2.sessionID);
             const base = state?.worktree ?? hostWorktree ?? "";
-            const abs = (isAbsolute(raw) ? raw : join6(base, raw)).replaceAll("\\", "/").toLowerCase();
+            const abs = (isAbsolute2(raw) ? raw : join6(base, raw)).replaceAll("\\", "/").toLowerCase();
             if (abs.includes("/.opencode/plan/") || abs.includes("/.opencode/goal/")) {
               throw new Error(`[forge:partition] Write refused: "${raw}" is inside the forge state directories (.opencode/plan, .opencode/goal), which belong to the forge agent in this workspace.`);
             }
@@ -18077,6 +18552,8 @@ var server = async (input, options) => {
           sealFindings.delete(info.id);
           sealUnknownNotes.delete(info.id);
           poolGateUnknownNotes.delete(info.id);
+          crews.delete(info.id);
+          crewEngineForgetSession(info.id);
         }
       }
     },
@@ -18109,12 +18586,19 @@ var server = async (input, options) => {
       if (typeof input2.tool !== "string")
         return;
       const act = turnActivity.get(input2.sessionID);
-      if (!act)
-        return;
-      if (isWriteTool(input2.tool) || input2.tool === "plan_tick")
-        act.writes++;
-      if (input2.tool === "goal_check")
-        act.checks++;
+      if (act) {
+        if (isWriteTool(input2.tool) || input2.tool === "plan_tick")
+          act.writes++;
+        if (input2.tool === "goal_check")
+          act.checks++;
+      }
+      const crewAct = crewTurnActivity.get(input2.sessionID);
+      if (crewAct) {
+        if (input2.tool === "task")
+          crewAct.dispatches++;
+        if (isWriteTool(input2.tool))
+          crewAct.writes++;
+      }
     },
     "experimental.chat.system.transform": async (input2, output) => {
       if (!input2.sessionID)
@@ -18203,7 +18687,7 @@ async function v2Setup(ctx) {
           if (draft.get(id) !== undefined)
             continue;
           const provenance = foldPath(agent.file) === foldPath(v2GlobalPath) ? { global: true } : { ns: agent.ns, file: agent.file };
-          const v1def = forgeAgentDef(matId, agent.def, provenance);
+          const v1def = forgeAgentDef(matId, agent.def, provenance, agent.shared ?? undefined);
           draft.update(id, (agentDraft) => {
             agentDraft.description = v1def.description;
             agentDraft.system = v1def.prompt;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sorenllm/opencode-forge",
-  "version": "0.18.1",
+  "version": "0.20.0",
   "description": "Single general-purpose forge agent for opencode: static worker subagents defined in forge.json (pinned model + thoughtLevel pair, or an Auto worker inheriting the parent model; dispatched through the native task tool — TUI-visible), a plan harness (file-backed plans with approve/close confirmation gates and a hard draft write-ban), a goal harness (autonomous, host-verified objectives), a /crew orchestration command (declared-plan waves with an evidence-checked close gate), a job supervisor (forge_shell with exit-bound completion, idle/success early return, background jobs with poll/log/kill/handoff), and a builtin-shell hang watchdog.",
   "type": "module",
   "main": "./dist/index.js",