@getpipher/armory-fleet 0.12.4 → 0.13.0

package/README.md

@@ -308,6 +308,14 @@ Every workflow run is **journaled** (`workflows/journal.ts`) and **resumable**.
 
 ---
 
+## Migration (v0.13.0 — SPEC-6-5 cwd isolation)
+
+- **`cwd` param on the `subagent` tool** (default = the session cwd, backward-compat). Pass it to scope a child's working dir + context (AGENTS.md cascade, skills, memory) to a dispatch target outside the session cwd — the #20 confabulation fix. Cross-cwd dispatches surface a `↗<basename>` glyph in the fleet widget + a spawn-time notify.
+- **`userMemory` default flip:** the global cross-project user memory scope (`/__armory-fleet-user__`) is no longer hydrated by default. If you populated that dir + relied on it, add `userMemory: true` to the agent frontmatter (only meaningful with `memoryHydrate: true`). TS consumers constructing `AgentDef` literals must now include `userMemory: boolean` (required field; use `false` for the old default behavior).
+- **Lifecycle `cwd` field:** lifecycles accept an optional `cwd` frontmatter field to pin a target repo; absent → the entry-point cwd (the panel's chosen cwd, or the dispatching `subagent` tool's cwd/session cwd). When present, it overrides the entry-point cwd for all phases.
+- **Panel Run-action:** a 3rd `cwd` input step (task → name → cwd), prefilled with the session cwd; Enter accepts, Escape cancels.
+- **Deferred:** bg/scheduled + worktree cwd-isolation (the `cwd` param is honored by foreground dispatches only for now) — tracked in #62.
+
 ## Roadmap
 
 armory-fleet follows a PRD → SPEC-N (brainstorm → spec → plan → implementation) pipeline. **16/16 phases done through v0.12.0.**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpipher/armory-fleet",
-  "version": "0.12.4",
+  "version": "0.13.0",
   "private": false,
   "description": "The armory suite's subagent orchestrator for the pi coding agent — a cross-harness, superpowers-native fleet where every agent is armory-native from birth.",
   "license": "MIT",

package/src/backend/claude-factory.ts

@@ -22,7 +22,7 @@ export function createClaudeChildFactory(
       if (!detector?.schemaOk) {
         throw new Error(`claude backend unavailable: ${detector?.note ?? "schema not ok"}`);
       }
-      const memoryBlock = opts.agent.memoryHydrate ? opts.memoryPort.renderScopes(memoryScopesFor(opts.cwd)) : "";
+      const memoryBlock = opts.agent.memoryHydrate ? opts.memoryPort.renderScopes(memoryScopesFor(opts.cwd, { includeUser: opts.agent.userMemory ?? false })) : "";
       const sys = memoryBlock ? `${opts.rolePrompt}\n\n${memoryBlock}` : opts.rolePrompt;
       const resumeId = resumeStore.get("claude", opts.agent.sessionKey);
 

package/src/engine/child-loader.ts

@@ -3,7 +3,9 @@
 // noExtensions (deterministic child, no host-extension leakage), composed
 // systemPromptOverride (rolePrompt + memoryBlock + base), scoped skills.
 import { DefaultResourceLoader, getAgentDir } from "@earendil-works/pi-coding-agent";
-import { dirname } from "node:path";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+import { existsSync as fsExistsSync } from "node:fs";
 import type { AgentDef } from "../registry/frontmatter.ts";
 import type { MemoryHydratePort } from "../memory-hydrate/port.ts";
 
@@ -39,9 +41,30 @@ export function composeChildPrompt(args: { rolePrompt: string; memoryBlock: stri
   return [args.rolePrompt, args.memoryBlock, args.base].filter((s) => s && s.trim().length > 0).join("\n\n");
 }
 
-/** Build the three memory scopes for a child: project=cwd, local=parent dir, user=sentinel. */
-export function memoryScopesFor(cwd: string): { project: string; local: string; user: string } {
-  return { project: cwd, local: dirname(cwd) || cwd, user: USER_PSEUDO_CWD };
+/** Build the memory scopes for a child: project=cwd, local=parent dir; user only when opted in.
+ *  #20/SPEC-6-5: the user pseudo-scope (`/__armory-fleet-user__`) is a cross-project bleed by
+ *  construction — omit it unless the agent declares `userMemory: true`. */
+export function memoryScopesFor(cwd: string, opts?: { includeUser?: boolean }): { project: string; local: string; user?: string } {
+  return { project: cwd, local: dirname(cwd) || cwd, ...(opts?.includeUser ? { user: USER_PSEUDO_CWD } : {}) };
+}
+
+/** #40: resolve extra skill dirs to scan for the child, beyond the default `~/.pi/agent/skills`.
+ *
+ *  The parent's pi package-manager scans `~/.agents/skills` (user) + `<cwd>/.agents/skills`
+ *  (project) and feeds them to the loader via `extendResources` — that's how cross-harness skills
+ *  like firecrawl (which live in `~/.agents/skills`, NOT `~/.pi/agent/skills`) reach the parent.
+ *  The child's bare `DefaultResourceLoader` skips that, so a `skills: ["firecrawl-scrape"]` opt-in
+ *  can't resolve. We restore the parent's skill surface by passing these dirs as `additionalSkillPaths`.
+ *
+ *  Returns absolute paths only for dirs that exist (no hard dependency on the `~/.agents` layout —
+ *  machines without it get []). Inject `homedir`/`cwd`/`existsSync` for testability. */
+export function resolveAdditionalSkillPaths(opts: { homedir?: string; cwd: string; existsSync?: (p: string) => boolean }): string[] {
+  const home = opts.homedir ?? homedir();
+  const exists = opts.existsSync ?? ((p: string) => { try { return fsExistsSync(p); } catch { return false; } });
+  const candidates = [join(home, ".agents", "skills"), join(opts.cwd, ".agents", "skills")];
+  const out: string[] = [];
+  for (const p of candidates) if (!out.includes(p) && exists(p)) out.push(p);
+  return out;
 }
 
 export interface ChildLoaderOpts {
@@ -52,12 +75,15 @@ export interface ChildLoaderOpts {
 
 /** Build the fleet CustomResourceLoader for a child session. */
 export function buildChildLoader(opts: ChildLoaderOpts): DefaultResourceLoader {
-  const scopes = memoryScopesFor(opts.cwd);
+  const scopes = memoryScopesFor(opts.cwd, { includeUser: opts.agent.userMemory ?? false });
   const memoryBlock = opts.agent.memoryHydrate ? opts.memoryPort.renderScopes(scopes) : "";
   return new DefaultResourceLoader({
     cwd: opts.cwd,
     agentDir: getAgentDir(),
     noExtensions: true,
+    // #40: scan the shared `~/.agents/skills` + `<cwd>/.agents/skills` dirs so cross-harness skills
+    //  (firecrawl, etc.) are discoverable by a caller's `skills` opt-in, matching the parent surface.
+    additionalSkillPaths: resolveAdditionalSkillPaths({ cwd: opts.cwd }),
     systemPromptOverride: (base) =>
       composeChildPrompt({ rolePrompt: opts.agent.rolePrompt, memoryBlock, base: base ?? "" }),
     skillsOverride: (cur) => resolveChildSkills(opts.agent, cur),

package/src/engine/concurrency-lock.ts

@@ -1,29 +1,81 @@
 // src/engine/concurrency-lock.ts
-export interface SingleSlotLock {
-  /** true if acquired; false if busy (call .current() for the running id). */
-  tryAcquire(id: string): boolean;
-  release(): void;
-  current(): string | null;
+// #31 tail: the foreground concurrency lock. A cap-based semaphore shared across all
+// foreground subagent dispatches (serializes writes to prevent in-place edit conflicts).
+//
+// - cap=1 (default, backward-compat): FAIL-FAST. A 2nd dispatch while one is running is
+//   rejected with `{ ok: false, busy }` so the orchestrator gets an actionable error (the
+//   held runId is named) instead of blocking. This preserves the pre-#31 behavior exactly.
+// - cap>1 (opt-in via ARMORY_FLEET_FOREGROUND_CONCURRENCY): QUEUE. Up to `cap` write
+//   dispatches run in parallel; the (cap+1)th WAITS for a slot (not rejected).
+//
+// #31 design note: concurrency is SESSION-LEVEL (env/settings), NOT a per-dispatch param.
+// A shared lock serializes across dispatches, so a per-dispatch `concurrency` param can't
+// re-size it per-call (two dispatches requesting different caps have no consistent global
+// cap). The cap is fixed at init. The subagent tool's promptGuidelines surface this to the
+// orchestrator so it understands the behavior + how to change it.
+//
+// readOnly dispatches bypass the lock entirely (#41) — they assert no cwd mutation.
+
+export type AcquireResult =
+  | { ok: true }
+  | { ok: false; busy: string[] };
+
+export interface ForegroundLock {
+  /** The configured cap (1 = fail-fast; >1 = queue). */
+  readonly cap: number;
+  /** Acquire a slot for `runId`. At cap=1: fail-fast if busy (returns the held runIds).
+   *  At cap>1: waits (queues) if at cap, then acquires. */
+  acquire(runId: string): Promise<AcquireResult>;
+  /** Release a held slot. No-op if `runId` isn't held (guard against double-release). */
+  release(runId: string): void;
+  /** RunIds currently holding a slot (for diagnostics + error messages). */
+  holders(): string[];
 }
 
-export class SingleSlotLockImpl implements SingleSlotLock {
-  private holding: string | null = null;
-  tryAcquire(id: string): boolean {
-    if (this.holding !== null) return false;
-    this.holding = id;
-    return true;
-  }
-  release(): void {
-    this.holding = null;
+export class ForegroundLockImpl implements ForegroundLock {
+  private active: string[] = [];
+  private waiters: Array<() => void> = [];
+  constructor(readonly cap = 1) {}
+
+  acquire(runId: string): Promise<AcquireResult> {
+    if (this.active.length >= this.cap) {
+      if (this.cap === 1) {
+        // Backward-compat: fail-fast at cap=1. The orchestrator gets the held runId + the cap
+        // + the env hint, so it can wait/abort or raise the cap.
+        return Promise.resolve({ ok: false, busy: [...this.active] });
+      }
+      // cap>1: queue — resolve when a slot frees (FIFO).
+      return new Promise<AcquireResult>((resolve) => {
+        this.waiters.push(() => { this.active.push(runId); resolve({ ok: true }); });
+      });
+    }
+    this.active.push(runId);
+    return Promise.resolve({ ok: true });
   }
-  current(): string | null {
-    return this.holding;
+
+  release(runId: string): void {
+    const i = this.active.indexOf(runId);
+    if (i < 0) return;   // no-op if not held (don't wake a waiter without freeing a slot)
+    this.active.splice(i, 1);
+    const next = this.waiters.shift();
+    if (next) next();
   }
+
+  holders(): string[] { return [...this.active]; }
 }
 
-/** Alias so tests can `new SingleSlotLock()`. */
-export const SingleSlotLock = SingleSlotLockImpl;
+/** Configurable foreground lock. cap from `ARMORY_FLEET_FOREGROUND_CONCURRENCY` (default 1). */
+export function createForegroundLock(cap = 1): ForegroundLock {
+  return new ForegroundLockImpl(cap);
+}
 
-export function createSingleSlotLock(): SingleSlotLock {
-  return new SingleSlotLock();
+/** Backward-compat factory: a cap=1 fail-fast lock. Existing call sites pass this to
+ *  spawnSubagent; it now returns a ForegroundLock(1) with the same cap=1 semantics. */
+export function createSingleSlotLock(): ForegroundLock {
+  return new ForegroundLockImpl(1);
 }
+
+/** @deprecated alias kept for call sites that construct `new SingleSlotLock()` or type
+ *  `lock: SingleSlotLock` (workflow adapters, fleet-panel). Same as ForegroundLock(1). */
+export type SingleSlotLock = ForegroundLock;
+export const SingleSlotLock = ForegroundLockImpl;

package/src/engine/retry-fallback.ts

@@ -0,0 +1,26 @@
+// src/engine/retry-fallback.ts
+// #39 tail: a reusable retry wrapper for the lifecycle + background spawn sites, where the
+// direct-foreground path's inline retry (subagent.ts) doesn't reach. Mirrors that path's
+// contract: retry ONCE, only on a retryable provider rate-limit / auth failure (stopReason
+// "error" → SpawnResult.retryable), only with a DISTINCT fallback model, only when not aborted.
+// Non-retryable failures (turn budget, agent-not-found, EMPTY_RESULT, abort, lock busy) pass
+// through unchanged. Lifecycle/bg retries are transparent — the retry's SpawnResult (with
+// model = fallback) wins; the direct-foreground path separately surfaces `retriedWithModel`
+// in the tool details, which lifecycle/bg don't need.
+import type { SpawnResult } from "./spawnSubagent.ts";
+import type { SpawnFn } from "../lifecycle/run-lifecycle.ts";
+
+/** Wrap a lifecycle/bg SpawnFn so a retryable failure retries once on `fallback`. `fallback`
+ *  being undefined returns the spawn unchanged (no global default + no per-dispatch param → no
+ *  retry). `signal` optional — background/panel sites have no AbortSignal; the direct path checks
+ *  abort inline. */
+export function withModelFallbackRetry(spawn: SpawnFn, fallback: string | undefined, signal?: AbortSignal): SpawnFn {
+  if (!fallback) return spawn;
+  return async (opts) => {
+    const first = await spawn(opts);
+    if (first.status === "failed" && first.retryable && fallback !== first.model && !signal?.aborted) {
+      return spawn({ ...opts, model: fallback });
+    }
+    return first;
+  };
+}

package/src/engine/run-registry.ts

@@ -28,10 +28,19 @@ export interface RunRecord {
   costTotal?: number;
   /** SPEC-6-1: latest context tokens (calcContextTokens(usage)) — live snapshot. */
   contextTokens?: number;
+  /** #32: context-token snapshot at the end of turn 1 (the armory substrate baseline).
+   *  Set once on the first assistant message_end; live-only (not journaled). The widget
+   *  compares current contextTokens against this to label the tok/ctx% segment as
+   *  "substrate" (flat across turns) vs "work" (growing) — see src/panel/widget-rows.ts. */
+  substrateBaseline?: number;
   /** SPEC-6-1: the tier name this run used (for Tiers-view "used by" + per-tier spend). */
   tier?: string;
   /** SPEC-6-2: the cwd this run belongs to (widget cross-cwd filter + reconcile ownership). */
   cwd: string;
+  /** SPEC-6-5: the session cwd the dispatch originated from (live; = parentCwd). Set at spawn.
+   *  Lets the widget compute cross-cwd (`cwd !== sessionCwd`) for the ↗ glyph without re-reading
+   *  the journal. Live-only counterpart to RunMetaEvent.sessionCwd. */
+  sessionCwd?: string;
   /** SPEC-6-2: the backend (probe dispatch: pi→handle, claude→pid). */
   backend: BackendId;
   /** SPEC-6-2: claude-backend child PID (cross-process liveness probe). */

package/src/engine/spawnSubagent.ts

@@ -5,8 +5,9 @@ import type { MemoryHydratePort } from "../memory-hydrate/port.ts";
 import type { VisionPort } from "../vision/port.ts";
 import type { BackendRegistry } from "../backend/port.ts";
 import { genRunId, RunRegistry } from "./run-registry.ts";
+import type { RunRecord } from "./run-registry.ts";
 import { createTurnBudget, DEFAULT_MAX_TURNS } from "./turn-budget.ts";
-import type { SingleSlotLock } from "./concurrency-lock.ts";
+import type { ForegroundLock } from "./concurrency-lock.ts";
 import type { RunLog } from "../runtime/run-log.ts";
 import { buildToolEvent } from "../runtime/run-log.ts";
 import { resolveAgentModel, type ModelRegistryLike } from "../tiers/resolve.ts";
@@ -112,10 +113,14 @@ export interface SpawnOptions {
   registry: Map<string, AgentDef>;
   todoSync: TodoSyncPort;
   runRegistry: RunRegistry;
-  lock: SingleSlotLock;
+  lock: ForegroundLock;
   backendRegistry: BackendRegistry;   // SPEC-3: replaces childFactory — engine looks up by agentDef.backend
   parentModel: { provider: string; id: string };
   parentCwd: string;
+  /** SPEC-6-5: the dispatch target's working directory. Default = parentCwd (the session cwd, backward-compat).
+   *  When set, all child-scoped sites use this cwd (factory.create, RunRecord.cwd, run:meta cwd);
+   *  session-scoped audit (`sessionCwd`) keeps parentCwd. */
+  cwd?: string;
   memoryPort?: MemoryHydratePort;
   visionPort?: VisionPort;
   signal?: AbortSignal;
@@ -168,12 +173,54 @@ export interface SpawnResult {
    *  when this is set. Non-retryable failures (turn budget, agent-not-found, EMPTY_RESULT,
    *  abort, lock busy) leave this unset. */
   retryable?: boolean;
+  /** #49: file paths the child mutated before the run ended (edit/write `path`; bash
+   *  redirections/tee best-effort), deduped + sorted. Lets the controller re-inspect only
+   *  what changed after a turn-budget cut, instead of the whole repo. Populated on every
+   *  run (completed runs too); most useful on the turn-budget branch. */
+  filesTouched?: string[];
+  /** #49: did the child emit a trailing assistant message after its last tool (a summary),
+   *  or was it cut mid-tool-work? Surfaced on turn-budget exhaustion so the controller knows
+   *  whether finalText is a partial summary or a mid-thought. Undefined for non-turn-budget paths. */
+  reachedSummary?: boolean;
+}
+
+/** #49: extract file paths a tool event touched, for the structured partial-result report.
+ *  edit/write carry a `path` arg reliably; bash is best-effort (redirections `>`/`>>` + `tee` to a
+ *  path-like token). Reads are NOT mutations and are excluded. */
+function extractTouchedFiles(toolName: string, args: unknown): string[] {
+  if (!args || typeof args !== "object") return [];
+  const a = args as Record<string, unknown>;
+  if (toolName === "edit" || toolName === "write") {
+    const p = typeof a.path === "string" ? a.path : typeof a.file_path === "string" ? a.file_path : undefined;
+    return p ? [p] : [];
+  }
+  if (toolName === "bash") {
+    const cmd = typeof a.command === "string" ? a.command : undefined;
+    if (!cmd) return [];
+    const out: string[] = [];
+    // `> path` / `>> path` / `tee path` — only tokens that look like a path (contain `/` or `.`)
+    // to avoid false positives on bare words ("echo done", "exit 0").
+    const redir = />>?\s+([^\s|;&<>]+)/g;
+    let m: RegExpExecArray | null;
+    while ((m = redir.exec(cmd)) !== null) {
+      const tok = m[1];
+      if (tok && /[/.]/.test(tok)) out.push(tok);
+    }
+    const tee = /\btee\s+(?:-a\s+)?([^\s|;&<>]+)/g;
+    while ((m = tee.exec(cmd)) !== null) {
+      const tok = m[1];
+      if (tok && /[/.]/.test(tok)) out.push(tok);
+    }
+    return out;
+  }
+  return [];
 }
 
 export async function spawnSubagent(opts: SpawnOptions): Promise<SpawnResult> {
   const track = opts.track ?? true;
   const maxTurns = opts.maxTurns ?? DEFAULT_MAX_TURNS;
   const startedAt = Date.now();
+  const childCwd = opts.cwd ?? opts.parentCwd;
 
   // #31: read-only dispatches (review/audit/research) bypass the foreground single-slot lock —
   // the caller asserts no cwd mutation, so the in-place edit-conflict guard doesn't apply and
@@ -184,15 +231,17 @@ export async function spawnSubagent(opts: SpawnOptions): Promise<SpawnResult> {
   if (readOnly) {
     runId = genRunId();
   } else {
-    // concurrency=1 (SPEC-1 §9.2) — peek before generating a runId so a rejected
-    // call doesn't mint a discarded id; the held id is named in the message.
-    const busyId = opts.lock.current();
-    if (busyId !== null) {
-      return fail("", startedAt, `a subagent is already running (concurrency=1 in v0.1); wait for ${busyId} to finish or abort it first`, opts.agent);
-    }
+    // #31 tail: foreground concurrency lock. cap=1 (default) is FAIL-FAST (backward-compat — a
+    // 2nd dispatch is rejected with the held runId + the cap + the env hint); cap>1 (opt-in via
+    // ARMORY_FLEET_FOREGROUND_CONCURRENCY) QUEUES — up to `cap` writes run in parallel, the rest wait.
+    // The cap is session-level (a shared lock can't be re-sized per dispatch); see concurrency-lock.ts.
     runId = genRunId();
-    if (!opts.lock.tryAcquire(runId)) {
-      return fail("", startedAt, "concurrency lock unexpectedly unavailable", opts.agent);
+    const acq = await opts.lock.acquire(runId);
+    if (!acq.ok) {
+      const hint = opts.lock.cap === 1
+        ? ` (foreground concurrency=1; ${acq.busy.join(", ")} is running — wait for it to finish or abort it, or raise ARMORY_FLEET_FOREGROUND_CONCURRENCY to allow parallel write dispatches)`
+        : ` (foreground concurrency=${opts.lock.cap}; all ${opts.lock.cap} slots held by ${acq.busy.join(", ")}); wait for one to finish or raise ARMORY_FLEET_FOREGROUND_CONCURRENCY)`;
+      return fail("", startedAt, `a subagent is already running${hint}`, opts.agent);
     }
   }
 
@@ -244,7 +293,7 @@ export async function spawnSubagent(opts: SpawnOptions): Promise<SpawnResult> {
       runId, agent: agentDef.name, model, task: opts.task, track,
       todoId: null, status: "running", startedAt,
       tier: tier?.name, costTotal: 0, contextTokens: 0,
-      cwd: opts.parentCwd, backend: backendId,
+      cwd: childCwd, sessionCwd: opts.parentCwd, backend: backendId,
     });
 
     // todo-sync (before) — only when both caller tracks AND agent allows todoSync
@@ -268,7 +317,7 @@ export async function spawnSubagent(opts: SpawnOptions): Promise<SpawnResult> {
     for (const cand of candidates) {
       try {
         const result = await backend.factory.create({
-          cwd: opts.parentCwd,
+          cwd: childCwd,
           model: cand,
           thinkingLevel: childAgent.thinkingLevel,
           tools,
@@ -302,10 +351,18 @@ export async function spawnSubagent(opts: SpawnOptions): Promise<SpawnResult> {
     let costTotal = 0;
     let contextTokens = 0;
     let turnIdx = -1;
+    // #32: substrate baseline — the turn-1 context-token snapshot (armory substrate overhead).
+    // Captured once on the first assistant message_end (turnIdx === 0); threaded to the RunRecord
+    // so the widget can classify the tok/ctx% segment as "substrate" (flat) vs "work" (growing).
+    let substrateBaseline: number | undefined;
     // #26/#22: declared before subscribe() because some child sessions emit events
     // synchronously inside subscribe() (temporal-dead-zone guard).
     let modelError: string | undefined;   // model-call failure surfaced via stopReason "error"
     let sawAssistantMessage = false;      // #22: did the child emit any assistant message_end at all?
+    // #49: structured partial-result tracking — what the child mutated, and whether it emitted
+    // a trailing assistant message after its last tool (a summary) vs being cut mid-tool-work.
+    const filesTouched = new Set<string>();
+    let sawAssistantAfterLastTool = true;   // no tools yet = trivially "reached a summary"
 
     // #23: liveness — classify events into a short, content-free class string for the widget.
     // Names the tool (safe — tool name is not args/result) so the operator sees "what's happening"
@@ -326,7 +383,7 @@ export async function spawnSubagent(opts: SpawnOptions): Promise<SpawnResult> {
       if (e.type === "session_init" && e.backendSessionId) {
         opts.runRegistry.update(runId, { backendSessionId: e.backendSessionId, sessionKey: agentDef.sessionKey });
         try {
-          opts.runLog?.append(runId, { type: "run:meta", runId, agent: agentDef.name, model, task: opts.task, startedAt, track, todoId, backendSessionId: e.backendSessionId, sessionKey: agentDef.sessionKey, cwd: opts.parentCwd, pid: (session as { proc?: { pid?: number } }).proc?.pid });
+          opts.runLog?.append(runId, { type: "run:meta", runId, agent: agentDef.name, model, task: opts.task, startedAt, track, todoId, backendSessionId: e.backendSessionId, sessionKey: agentDef.sessionKey, cwd: childCwd, sessionCwd: opts.parentCwd, pid: (session as { proc?: { pid?: number } }).proc?.pid });
         } catch { /* best-effort */ }
       } else if (e.type === "turn_start") {
         turnIdx++;
@@ -334,6 +391,7 @@ export async function spawnSubagent(opts: SpawnOptions): Promise<SpawnResult> {
         if (budget.consume()) void session.abort();
       } else if (e.type === "message_end" && e.message?.role === "assistant") {
         sawAssistantMessage = true;
+        sawAssistantAfterLastTool = true;   // #49: a trailing assistant message = (so far) reached a summary
         const text = e.message.content?.map((c) => (c.type === "text" ? c.text ?? "" : "")).join("") ?? "";
         // #26/#22: a model-call failure (401, provider down, rate limit) surfaces as
         // stopReason "error". The SDK retries internally; if it still ends with an error
@@ -355,7 +413,15 @@ export async function spawnSubagent(opts: SpawnOptions): Promise<SpawnResult> {
         const cost = u?.cost?.total ?? 0;
         costTotal += cost;
         contextTokens = calcContextTokens(u ?? {});
-        opts.runRegistry.update(runId, { costTotal, contextTokens, tokenTotal });
+        // #32: capture the substrate baseline at the end of turn 1 (the first assistant
+        // message_end). The turn-1 context is dominated by the armory substrate (system prompt +
+        // skills + memory); subsequent turns barely grow it unless real work adds tool results.
+        const patch: Partial<RunRecord> = { costTotal, contextTokens, tokenTotal };
+        if (substrateBaseline === undefined && turnIdx === 0 && contextTokens > 0) {
+          substrateBaseline = contextTokens;
+          patch.substrateBaseline = substrateBaseline;
+        }
+        opts.runRegistry.update(runId, patch);
         try {
           opts.runLog?.append(runId, { type: "message", role: "assistant", text, usage: { total: turnTokens, input: u?.input, output: u?.output, cacheRead: u?.cacheRead, cacheWrite: u?.cacheWrite, cost: u?.cost }, turnIndex: turnIdx });
         } catch { /* best-effort */ }
@@ -365,6 +431,9 @@ export async function spawnSubagent(opts: SpawnOptions): Promise<SpawnResult> {
           void session.abort();
         }
       } else if (e.type === "tool_execution_end") {
+        // #49: track mutated files for the structured partial-result report.
+        sawAssistantAfterLastTool = false;   // cut mid-tool-work unless a message follows
+        for (const f of extractTouchedFiles((e as { toolName?: string }).toolName ?? "", (e as { args?: unknown }).args)) filesTouched.add(f);
         try {
           opts.runLog?.append(runId, buildToolEvent((e as any).toolName, (e as any).args, (e as any).result, (e as any).isError ?? false, turnIdx));
         } catch { /* best-effort */ }
@@ -394,6 +463,8 @@ export async function spawnSubagent(opts: SpawnOptions): Promise<SpawnResult> {
 
     let status: FleetRunStatus;
     let error: string | undefined;
+    const filesTouchedList = [...filesTouched].sort();   // #49: deduped + sorted
+    let reachedSummary: boolean | undefined;            // #49: only set on the turn-budget branch
     if (aborted) {
       status = "aborted";
       // #23: distinguish TODO-status reversion from filesystem rollback. A foreground run is in-place
@@ -415,7 +486,14 @@ export async function spawnSubagent(opts: SpawnOptions): Promise<SpawnResult> {
         ? finalText.slice(0, PARTIAL_WINDOW) + "\n…(partial truncated — see run log for full output)"
         : finalText;
       status = "failed";
-      error = `hit turn budget (${maxTurns}) mid-task; partial result:\n${partial}`;
+      // #49: surface WHAT was modified + whether the partial is a summary or a mid-thought, so the
+      // controller can re-inspect only the touched files instead of the whole repo, and knows
+      // whether to trust finalText as a partial summary.
+      reachedSummary = sawAssistantAfterLastTool;
+      const filesLine = filesTouchedList.length
+        ? `\n\nFiles modified before the cut: ${filesTouchedList.join(", ")}`
+        : "\n\nFiles modified before the cut: (none detected)";
+      error = `hit turn budget (${maxTurns}) mid-task; partial result:\n${partial}${filesLine}\nReached summary: ${reachedSummary ? "yes" : "no (cut mid-tool-work)"}`;
     } else if (runError) {
       status = "failed";
       error = runError;
@@ -446,11 +524,11 @@ export async function spawnSubagent(opts: SpawnOptions): Promise<SpawnResult> {
       status = "completed";
     }
 
-    return await finishRun(opts, runId, startedAt, status, finalText, todoId, priorStatus, error, agentDef.name, model, tokenTotal, costTotal, contextTokens, modelError ? true : undefined);
+    return await finishRun(opts, runId, startedAt, status, finalText, todoId, priorStatus, error, agentDef.name, model, tokenTotal, costTotal, contextTokens, modelError ? true : undefined, filesTouchedList, reachedSummary);
   } finally {
     // #31: a readOnly dispatch never acquired the lock — don't release what it didn't take
     // (releasing a lock held by another concurrent write dispatch would corrupt serialization).
-    if (!readOnly) opts.lock.release();
+    if (!readOnly) opts.lock.release(runId);
   }
 }
 
@@ -469,6 +547,7 @@ async function finishRun(
   status: FleetRunStatus, finalText: string, todoId: string | null, priorStatus: string | undefined,
   error: string | undefined, agentName: string, model: string, tokenTotal = 0, costTotal = 0, contextTokens = 0,
   retryable?: boolean,
+  filesTouched?: string[], reachedSummary?: boolean,
 ): Promise<SpawnResult> {
   if (finalizedRunIds.has(runId)) {
     // Already finalized — return the existing registry record's result without re-appending.
@@ -478,6 +557,7 @@ async function finishRun(
       runId, todoId, agent: agentName, model,
       durationMs: existing?.endedAt ? existing.endedAt - startedAt : Date.now() - startedAt,
       tokenTotal, costTotal, contextTokens, error, retryable,
+      filesTouched, reachedSummary,
     };
   }
   finalizedRunIds.add(runId);
@@ -512,5 +592,6 @@ async function finishRun(
   return {
     status, finalText, runId, todoId, agent: agentName, model,
     durationMs: endedAt - startedAt, tokenTotal, costTotal, contextTokens, error, retryable,
+    filesTouched, reachedSummary,
   };
 }

package/src/index.ts

@@ -12,11 +12,12 @@ import { createSubagentTool, type SubagentToolDeps } from "./tools/subagent.ts";
 // SPEC-6-3: /fleet uses openWorkflowPanelLoop (Task 12) instead of the raw openFleetPanel factory.
 import { discoverAgents } from "./registry/discovery.ts";
 import { RunRegistry } from "./engine/run-registry.ts";
-import { createSingleSlotLock } from "./engine/concurrency-lock.ts";
+import { createSingleSlotLock, createForegroundLock } from "./engine/concurrency-lock.ts";
 import { ArmoryTodoAdapter } from "./todo-sync/adapter.ts";
 import { ArmoryMemoryAdapter } from "./memory-hydrate/adapter.ts";
 import { ArmoryVisionAdapter } from "./vision/adapter.ts";
 import { buildChildLoader } from "./engine/child-loader.ts";
+import { withModelFallbackRetry } from "./engine/retry-fallback.ts";
 import { createDescribeImageTool } from "./vision/describe-image-tool.ts";
 import type { MemoryHydratePort } from "./memory-hydrate/port.ts";
 import type { VisionPort } from "./vision/port.ts";
@@ -152,12 +153,23 @@ export function createChildSessionFactory(modelRuntime: ModelRuntime, memoryPort
   };
 }
 
+/** #31 tail: parse the foreground-concurrency cap from `ARMORY_FLEET_FOREGROUND_CONCURRENCY`.
+ *  Default 1 (fail-fast, backward-compat). >1 enables a queueing pool (up to N parallel write
+ *  dispatches). Clamped to [1, 64]; invalid/empty → 1. */
+function parseForegroundConcurrency(): number {
+  const raw = process.env.ARMORY_FLEET_FOREGROUND_CONCURRENCY;
+  if (!raw) return 1;
+  const n = Number.parseInt(raw, 10);
+  if (!Number.isFinite(n) || n < 1) return 1;
+  return Math.min(n, 64);
+}
+
 export default async function (pi: ExtensionAPI): Promise<void> {
   const modelRuntime = await ModelRuntime.create();
   const deps: SubagentToolDeps = {
     registry: new Map(),
     runRegistry: new RunRegistry(),
-    lock: createSingleSlotLock(),
+    lock: createForegroundLock(parseForegroundConcurrency()),
     todoSync: new ArmoryTodoAdapter(),
     backendRegistry: await buildDefaultBackendRegistry(modelRuntime),
     parentModel: { provider: "", id: "" },
@@ -189,6 +201,17 @@ export default async function (pi: ExtensionAPI): Promise<void> {
   // Builtin-only placeholder tier registry so spawn works before session_start rebuilds with merged tiers.
   deps.tierRegistry = new TierRegistry({ tiers: BUILTIN_TIERS, agents: deps.registry });
 
+  // #39 tail: global default fallback model (env-driven for now; a settings.json field is a follow-up).
+  // A retryable provider failure (stopReason "error") retries once on this model even without a
+  // per-dispatch `modelFallback`. Per the AGENTS.md "Ollama primary + OpenRouter fallback" pattern.
+  deps.defaultModelFallback = process.env.ARMORY_FLEET_MODEL_FALLBACK || undefined;
+  // SPEC-6-5: cross-cwd dispatch notify hook (wired per-session in session_start below).
+  // Placeholder; the real wiring happens in session_start where ctx is in scope.
+
+  // #31 tail: foreground concurrency is SESSION-LEVEL (a shared lock can't be re-sized per
+  // dispatch). cap=1 (default) is fail-fast (backward-compat); cap>1 enables a queueing pool so
+  // up to `cap` write dispatches run in parallel. readOnly dispatches bypass the lock (#41).
+
   // SPEC-6-2: gate registry + builtin gate registration.
   const gateRegistry = new GateRegistry();
   registerBuiltinGates(gateRegistry);
@@ -234,14 +257,14 @@ export default async function (pi: ExtensionAPI): Promise<void> {
       ...deps.lifecycleDeps,
       genRunId: () => opts.runId,   // override: use the async runner's runId
       ...(isolated ? { artifactDiscovery: ({ finalText, cwd, baseRef }: { finalText: string; cwd: string; baseRef: string }) => (deps.asyncRunner as AsyncRunnerDeps).diff.diffPhase(cwd, baseRef, finalText) } : {}),
-      spawn: async (o) => spawnSubagent({
+      spawn: withModelFallbackRetry(async (o) => spawnSubagent({
         agent: o.agent, task: o.task, lifecycleTodoId: o.lifecycleTodoId, model: o.model,
         skillsOverride: o.skills, backendOverride: o.backend,
         registry: deps.registry, todoSync: deps.todoSync, runRegistry: deps.runRegistry, lock: bgLock,
         backendRegistry: deps.backendRegistry, parentModel: deps.parentModel,
         parentCwd: isolated ? opts.worktreePath! : deps.parentCwd,
         runLog: deps.runLog, tierRegistry: deps.tierRegistry, modelRegistry: deps.modelRegistry,
-      }),
+      }), deps.defaultModelFallback),
     };
     const res = await runLifecycle(task, lifecycleName, { deps: lifecycleFullDeps, mode: opts.mode, worktreePath: opts.worktreePath, baseRef: "HEAD", onCheckpoint: async (p) => p.status === "failed" ? { action: "abort" } : { action: "continue" } });
     return res as unknown as import("./runtime/async-runner.ts").FakeLifecycleResult;
@@ -287,6 +310,7 @@ export default async function (pi: ExtensionAPI): Promise<void> {
     const m = ctx.model;
     deps.parentModel = m ? { provider: m.provider, id: m.id } : { provider: "", id: "" };
     deps.parentCwd = ctx.cwd;
+    deps.onNotify = (m, k) => ctx.ui.notify(m, k ?? "info");
     // SPEC-5a: build the per-session async runner + scheduler, start firing, scan for interrupted runs.
     const dir = fleetDir(ctx.cwd);
     // SPEC-5b-1: per-session RunLog at .pi/fleet/conversations/ (separate from the
@@ -508,13 +532,13 @@ export default async function (pi: ExtensionAPI): Promise<void> {
           };
       const lifecycleFullDeps: import("./lifecycle/run-lifecycle.ts").LifecycleRunDeps = {
         ...deps.lifecycleDeps,
-        spawn: async (o) => spawnSubagent({
+        spawn: withModelFallbackRetry(async (o) => spawnSubagent({
           agent: o.agent, task: o.task, lifecycleTodoId: o.lifecycleTodoId, model: o.model,
             skillsOverride: o.skills, backendOverride: o.backend,
           registry: deps.registry, todoSync: deps.todoSync, runRegistry: deps.runRegistry, lock: deps.lock,
           backendRegistry: deps.backendRegistry, parentModel: deps.parentModel, parentCwd: deps.parentCwd,
           tierRegistry: deps.tierRegistry, modelRegistry: deps.modelRegistry,  // SPEC-6-1
-        }),
+        }), deps.defaultModelFallback),
       };
       const res = await runLifecycle(parsed.task, lcName, { deps: lifecycleFullDeps, mode: parsed.auto ? "auto" : "checkpointed", onCheckpoint });
       deps.lifecycleRuns.set(res.runId, res);

package/src/lifecycle/lifecycle-types.ts

@@ -34,6 +34,10 @@ export interface LifecycleDef {
   description: string;
   /** Lifecycle-wide default backend; absent → "pi". */
   backend: BackendId;
+  /** SPEC-6-5: pin this lifecycle to a target working directory. Absent → the entry-point cwd
+   *  (the panel's chosen cwd, or the dispatching `subagent` tool's cwd/session cwd). When present,
+   *  overrides the entry-point cwd for all phases. */
+  cwd?: string;
   phases: PhaseDef[];
   source: AgentSource;
   filePath: string;

package/src/lifecycle/registry.ts

@@ -38,6 +38,7 @@ export function parseLifecycleFile(content: string, filePath: string, source: Ag
     throw new LifecycleParseError(`${filePath}: invalid backend '${rawBackend}' (must be 'pi' | 'claude')`);
   }
   const backend = rawBackend as BackendId;
+  const cwd = typeof raw.cwd === "string" && raw.cwd.trim() ? raw.cwd.trim() : undefined;
 
   if (!Array.isArray(raw.phases) || raw.phases.length === 0) {
     throw new LifecycleParseError(`${filePath}: phases must be a non-empty array`);
@@ -100,7 +101,7 @@ export function parseLifecycleFile(content: string, filePath: string, source: Ag
   // The terminal phase never checkpoints after it (the lifecycle is done) — §5.4.
   if (phases.length > 0) phases[phases.length - 1]!.checkpoint = false;
 
-  return { name, description, backend, phases, source, filePath };
+  return { name, description, backend, phases, source, filePath, ...(cwd ? { cwd } : {}) };
 }
 
 /** Split the markdown body into a map of phase-name → prompt-template, by `## <name>` H2 headings. */

package/src/lifecycle/run-lifecycle.ts

@@ -25,6 +25,8 @@ export interface PhaseSpawnOpts {
   skills: string[];
   /** The resolved backend for this phase (phase.backend → lifecycle.backend → "pi"). */
   backend: BackendId;
+  /** SPEC-6-5: the resolved lifecycle cwd (lifecycle.cwd ?? entryCwd) the phase child runs in. */
+  cwd?: string;
   model?: string;
 }
 export type SpawnFn = (opts: PhaseSpawnOpts) => Promise<SpawnResult>;
@@ -57,6 +59,9 @@ export interface LifecycleRunOpts {
   worktreePath?: string;
   /** SPEC-5a: the base ref to diff against (default "HEAD"). */
   baseRef?: string;
+  /** SPEC-6-5: the entry-point cwd (the panel's chosen cwd, or the dispatching subagent tool's
+   *  cwd/session cwd). The lifecycle's `cwd` field, if present, overrides this. */
+  entryCwd?: string;
 }
 
 export interface LifecycleRunResult {
@@ -86,6 +91,8 @@ export async function runLifecycle(task: string, lifecycleName: string, opts: Li
     const available = [...deps.registry.keys()].sort().join(", ");
     return failResult("", startedAt, `lifecycle '${lifecycleName}' not found; available: ${available}`, lifecycleName, task, opts.mode, [], null);
   }
+  // SPEC-6-5: lifecycle cwd field overrides the entry-point cwd (entryCwd).
+  const lifecycleCwd = lifecycle.cwd ?? opts.entryCwd;
 
   const runId = deps.genRunId();
   const lifecycleBackend = lifecycle.backend;
@@ -151,7 +158,7 @@ export async function runLifecycle(task: string, lifecycleName: string, opts: Li
       // phase's skills (Q1=B) and routes to the phase's backend (Q4=C) — not the agent's defaults.
       let spawnRes: import("../engine/spawnSubagent.ts").SpawnResult;
       try {
-        spawnRes = await deps.spawn({ agent: agentName, task: prompt, lifecycleTodoId: todoId, skills, backend });
+        spawnRes = await deps.spawn({ agent: agentName, task: prompt, lifecycleTodoId: todoId, skills, backend, cwd: lifecycleCwd });
       } catch (e) {
         // spawn should return a failed result, not throw — but guard anyway so a throwing spawn
         // can't orphan the lifecycle (treat as a phase failure).

package/src/memory-hydrate/adapter.ts

@@ -5,7 +5,7 @@ import type { MemoryHydratePort, MemoryScopes } from "./port.ts";
 export class ArmoryMemoryAdapter implements MemoryHydratePort {
   renderScopes(scopes: MemoryScopes): string {
     return [scopes.project, scopes.local, scopes.user]
-      .filter((cwd) => listMemory(cwd).length > 0)   // skip empty scopes cleanly (no placeholder to render)
+      .filter((cwd): cwd is string => cwd != null && listMemory(cwd).length > 0)   // skip empty scopes cleanly (no placeholder to render)
       .map((cwd) => renderMemoryBlock(cwd))           // armory-memory's existing cwd-keyed primitive
       .join("\n\n");                                   // → "" when all three empty
   }

package/src/memory-hydrate/port.ts

@@ -4,8 +4,9 @@ export interface MemoryScopes {
   project: string;
   /** Immediate parent directory of the project cwd (workspace/org level). */
   local: string;
-  /** Fixed pseudo-cwd for global cross-project user memory. */
-  user: string;
+  /** Optional — only present when the agent opted in via `userMemory: true` (SPEC-6-5).
+   *  The user scope is a cross-project memory bleed by construction; omitted unless explicitly enabled. */
+  user?: string;
 }
 export interface MemoryHydratePort {
   /** Render the three-scope memory block (project → local → user), concatenated. Empty string when all scopes empty. */

package/src/panel/fleet-panel.ts

@@ -96,7 +96,8 @@ export class FleetPanel extends Container {
   private lcRunMode = false;
   private lcTaskInput: Input | null = null;
   private lcNameInput: Input | null = null;
-  private lcPhase: "task" | "name" = "task";
+  private lcCwdInput: Input | null = null;
+  private lcPhase: "task" | "name" | "cwd" = "task";
   // SPEC-4: pending checkpoint (interactive Continue/Revise/Abort)
   private pendingCheckpoint: { phase: PhaseRecord; resolve: (d: CheckpointDecision) => void } | null = null;
   private lcReviseInput: Input | null = null;
@@ -359,10 +360,10 @@ export class FleetPanel extends Container {
       this.addChild(new Text(this.theme.fg("accent", prompt), 0, 0));
       this.addChild(this.schedPhase === "task" ? this.schedTaskInput! : this.schedPhase === "expr" ? this.schedExprInput! : this.schedNameInput!);
       this.addChild(new Text(this.theme.fg("dim", "  enter submit • esc cancel"), 0, 0));
-    } else if (this.lcRunMode && (this.lcTaskInput || this.lcNameInput)) {
-      const prompt = this.lcPhase === "task" ? "  task> " : "  lifecycle name (blank=default)> ";
+    } else if (this.lcRunMode && (this.lcTaskInput || this.lcNameInput || this.lcCwdInput)) {
+      const prompt = this.lcPhase === "task" ? "  task> " : this.lcPhase === "name" ? "  lifecycle name (blank=default)> " : "  cwd (blank=session cwd)> ";
       this.addChild(new Text(this.theme.fg("accent", prompt), 0, 0));
-      this.addChild(this.lcPhase === "task" ? this.lcTaskInput! : this.lcNameInput!);
+      this.addChild(this.lcPhase === "task" ? this.lcTaskInput! : this.lcPhase === "name" ? this.lcNameInput! : this.lcCwdInput!);
       this.addChild(new Text(this.theme.fg("dim", "  enter submit • esc cancel"), 0, 0));
     } else if (this.pendingCheckpoint && !this.lcRevising) {
       const pc = this.pendingCheckpoint;
@@ -586,9 +587,9 @@ export class FleetPanel extends Container {
       this.invalidate();
       return;
     }
-    if (this.lcRunMode && (this.lcTaskInput || this.lcNameInput)) {
+    if (this.lcRunMode && (this.lcTaskInput || this.lcNameInput || this.lcCwdInput)) {
       if (matchesKey(data, "escape")) { this.cancelLifecycleRun(); return; }
-      (this.lcPhase === "task" ? this.lcTaskInput! : this.lcNameInput!).handleInput(data);
+      (this.lcPhase === "task" ? this.lcTaskInput! : this.lcPhase === "name" ? this.lcNameInput! : this.lcCwdInput!).handleInput(data);
       this.invalidate();
       return;
     }
@@ -1131,9 +1132,18 @@ export class FleetPanel extends Container {
       this.lcNameInput = new Input();
       this.lcNameInput.onSubmit = (name: string) => {
         const lcName = name.trim() || "default";
-        void this.executeLifecycleRun(task.trim(), lcName);
+        this.lcPhase = "cwd";
+        this.lcCwdInput = new Input();
+        // SPEC-6-5: 3rd input step — the dispatch cwd. Prefilled with the session cwd; Enter
+        //  accepts it, Escape accepts the default (mirrors the name step's Escape-accepts-default).
+        this.lcCwdInput.onSubmit = (cwd: string) => {
+          const picked = cwd.trim() || this.deps.parentCwd;
+          void this.executeLifecycleRun(task.trim(), lcName, picked);
+        };
+        this.lcCwdInput.onEscape = () => { void this.executeLifecycleRun(task.trim(), lcName, this.deps.parentCwd); };
+        this.renderShell();
       };
-      this.lcNameInput.onEscape = () => { void this.executeLifecycleRun(task.trim(), "default"); };
+      this.lcNameInput.onEscape = () => { void this.executeLifecycleRun(task.trim(), "default", this.deps.parentCwd); };
       this.renderShell();
     };
     this.lcTaskInput.onEscape = () => this.cancelLifecycleRun();
@@ -1145,18 +1155,27 @@ export class FleetPanel extends Container {
     this.lcRunMode = false;
     this.lcTaskInput = null;
     this.lcNameInput = null;
+    this.lcCwdInput = null;
     this.renderShell();
   }
 
-  private async executeLifecycleRun(task: string, lifecycleName: string): Promise<void> {
+  private async executeLifecycleRun(task: string, lifecycleName: string, cwd: string): Promise<void> {
     this.lcRunMode = false;
     this.lcTaskInput = null;
     this.lcNameInput = null;
+    this.lcCwdInput = null;
     this.renderShell();
     if (!this.deps.lifecycleRegistry.has(lifecycleName)) {
       this.onNotify(`lifecycle '${lifecycleName}' not found; available: ${[...this.deps.lifecycleRegistry.keys()].sort().join(", ")}`, "error");
       return;
     }
+    // SPEC-6-5: validate the chosen cwd (exists + is a dir) before spawning; surface cross-cwd.
+    const { resolveDispatchCwd } = await import("../tools/subagent.ts");
+    const { cwd: resolvedCwd, error: cwdErr } = resolveDispatchCwd(cwd, this.deps.parentCwd);
+    if (cwdErr) { this.onNotify(cwdErr, "error"); return; }
+    if (resolvedCwd && resolvedCwd !== this.deps.parentCwd) {
+      this.onNotify("scoped to " + resolvedCwd + " (≠ session " + this.deps.parentCwd + ")", "info");
+    }
     const onCheckpoint: CheckpointFn = (phase) => new Promise<CheckpointDecision>((resolve) => {
       this.pendingCheckpoint = { phase, resolve };
       this.renderShell();
@@ -1171,10 +1190,11 @@ export class FleetPanel extends Container {
           registry: this.deps.registry, todoSync: this.deps.todoSync, runRegistry: this.deps.runRegistry, lock: this.deps.lock,
           backendRegistry: this.deps.backendRegistry, parentModel: this.deps.parentModel, parentCwd: this.deps.parentCwd,
           runLog: this.deps.runLog,
+          cwd: o.cwd,
         });
       },
     };
-    const res = await runLifecycle(task, lifecycleName, { deps: lifecycleFullDeps, mode: "checkpointed", onCheckpoint });
+    const res = await runLifecycle(task, lifecycleName, { deps: lifecycleFullDeps, mode: "checkpointed", onCheckpoint, entryCwd: resolvedCwd });
     this.pendingCheckpoint = null;
     // record the run so the Lifecycle view shows it
     this.deps.lifecycleRuns.set(res.runId, res);

package/src/panel/widget-rows.ts

@@ -8,6 +8,7 @@
 // list below editor" intent was never achievable via pi widgets (editor keeps keyboard focus).
 // `/fleet` is the navigable action surface; this one above-editor widget is the glance surface.
 import { fmtDuration, fmtTokens } from "./rows.ts";
+import { basename } from "node:path";
 import type { RunRecord } from "../engine/run-registry.ts";
 import type { BgRunStatus } from "./rows.ts";
 
@@ -16,6 +17,11 @@ import type { BgRunStatus } from "./rows.ts";
 export const LIVENESS_THRESHOLD_MS = 30_000;
 /** #23: a run whose last event is older than this is flagged stale ("are events still arriving?"). */
 export const STALE_THRESHOLD_MS = 60_000;
+/** #32: once past turn 1, if contextTokens has grown by less than this fraction of the
+ *  turn-1 substrate baseline, the tok/ctx% segment is labeled "substrate" (flat overhead)
+ *  rather than "work" (growing from tool results). 5% — the dogfood evidence showed ~0.2%/turn
+ *  growth on a substrate-dominated run vs tens-of-K (multi-%) once real tool output lands. */
+export const SUBSTRATE_GROWTH_THRESHOLD = 0.05;
 
 export interface WidgetRun {
   runId: string;
@@ -34,6 +40,10 @@ export interface WidgetRun {
   task?: string;
   /** SPEC-6-1: latest context-token snapshot (for ctx% segment). */
   contextTokens?: number;
+  /** #32: context-token baseline at end of turn 1 (armory substrate overhead). When the
+   *  current contextTokens has grown little beyond this baseline across turns, the tok/ctx%
+   *  segment is labeled "substrate" (flat overhead) vs "work" (growing from tool results). */
+  substrateBaseline?: number;
   /** SPEC-6-1: max context window for the resolved model (set by controller — Task 7). */
   maxContext?: number;
   /** SPEC-6-1: cumulative $ (for the $ segment). */
@@ -46,6 +56,10 @@ export interface WidgetRun {
   lastEventClass?: string;
   /** #23: liveness — timestamp (ms) of the last event ("events still arriving?"). */
   lastEventAt?: number;
+  /** SPEC-6-5: the run's (child) cwd — from RunRecord.cwd. */
+  cwd?: string;
+  /** SPEC-6-5: the session cwd (parentCwd) — from RunRecord.sessionCwd. When cwd !== sessionCwd the widget shows a ↗ glyph. */
+  sessionCwd?: string;
 }
 
 export function toWidgetRun(r: RunRecord): WidgetRun {
@@ -53,8 +67,9 @@ export function toWidgetRun(r: RunRecord): WidgetRun {
     runId: r.runId, agent: r.agent, status: r.status,
     startedAt: r.startedAt, endedAt: r.endedAt, tokenTotal: r.tokenTotal,
     kind: "fg",
-    task: r.task, costTotal: r.costTotal, contextTokens: r.contextTokens,
+    task: r.task, costTotal: r.costTotal, contextTokens: r.contextTokens, substrateBaseline: r.substrateBaseline,
     turnCount: r.turnCount, turnMax: r.turnMax, lastEventClass: r.lastEventClass, lastEventAt: r.lastEventAt,
+    cwd: r.cwd, sessionCwd: r.sessionCwd,
   };
 }
 
@@ -102,6 +117,9 @@ function widgetLine(r: WidgetRun, now: number): string {
 
   // fg: task excerpt as primary label (fallback to runId if no task)
   const label = r.task ? `"${r.task.slice(0, 40)}"` : r.runId;
+  // SPEC-6-5: cross-cwd glyph — when the run's cwd differs from the session cwd, mark it so the
+  // operator sees "this run is scoped to a different project" at a glance. Same-cwd → no glyph.
+  const crossCwd = (r.cwd && r.sessionCwd && r.cwd !== r.sessionCwd) ? `  ↗${basename(r.cwd)}` : "";
   const agentSeg = r.agent && r.agent !== "general-purpose" ? `  · ${r.agent}` : "";
   // #23: liveness — only after LIVENESS_THRESHOLD_MS, to keep short runs concise (per acceptance).
   // turn N/max + last-event class (no prompt content, no args/results — only the tool name)
@@ -114,7 +132,17 @@ function widgetLine(r: WidgetRun, now: number): string {
     const stale = (r.lastEventAt != null && now - r.lastEventAt > STALE_THRESHOLD_MS) ? "  ⏰stale" : "";
     liveness = `${turn}${ev}${stale}`;
   }
-  return `${glyph} ${label}${agentSeg}${dur}${liveness}${tok}${ctx}${cost}`;
+  // #32: substrate vs work — once past turn 1, classify the tok/ctx% segment. The armory substrate
+  // (system prompt + skills + memory) dominates turn-1 context; on substrate-dominated runs the
+  // ctx% barely moves across turns and reads as "frozen". Label it "substrate" (flat overhead) so
+  // that's distinguishable from "work" (context growing from tool results). Needs ≥2 turns of
+  // data (a baseline + a current snapshot); before that there's nothing to compare.
+  let substrate = "";
+  if ((r.turnCount ?? 0) >= 2 && r.substrateBaseline != null && r.contextTokens != null && r.substrateBaseline > 0) {
+    const growth = (r.contextTokens - r.substrateBaseline) / r.substrateBaseline;
+    substrate = growth <= SUBSTRATE_GROWTH_THRESHOLD ? "  substrate" : "  work";
+  }
+  return `${glyph} ${label}${crossCwd}${agentSeg}${dur}${liveness}${tok}${ctx}${substrate}${cost}`;
 }
 
 /** Above-editor widget: one line per active run, cap 5, overflow → "+N more in /fleet".

package/src/registry/frontmatter.ts

@@ -16,6 +16,10 @@ export interface AgentDef {
   todoSync: boolean;
   memoryHydrate: boolean;
   vision: boolean;
+  /** #20/SPEC-6-5: opt in to the global cross-project user memory scope (`/__armory-fleet-user__`).
+   *  Default false — the user scope is a cross-project bleed by construction; hydrate it only when
+   *  an agent explicitly declares `userMemory: true`. Only meaningful when `memoryHydrate: true`. */
+  userMemory: boolean;
   /** Cross-harness backend routing (SPEC-3). Invalid value → FrontmatterError. */
   backend: "pi" | "claude";
   /** Stable id for backend-native resume (SPEC-3). Defaults to name. */
@@ -57,6 +61,7 @@ export function parseAgentFile(content: string, filePath: string, source: AgentS
   const todoSync = raw.todoSync === undefined ? true : Boolean(raw.todoSync);
   const memoryHydrate = raw.memoryHydrate === undefined ? true : Boolean(raw.memoryHydrate);
   const vision = raw.vision === undefined ? true : Boolean(raw.vision);
+  const userMemory = raw.userMemory === undefined ? false : Boolean(raw.userMemory);
 
   const rawBackend = typeof raw.backend === "string" ? raw.backend.trim() : "pi";
   if (rawBackend !== "pi" && rawBackend !== "claude") {
@@ -77,6 +82,7 @@ export function parseAgentFile(content: string, filePath: string, source: AgentS
     todoSync,
     memoryHydrate,
     vision,
+    userMemory,
     backend,
     sessionKey,
     source,

package/src/runtime/run-log.ts

@@ -15,6 +15,8 @@ export interface RunMetaEvent {
   pid?: number;
   /** SPEC-6-2: the cwd this run belongs to. */
   cwd?: string;
+  /** SPEC-6-5: the session cwd the dispatch originated from (= parentCwd). */
+  sessionCwd?: string;
 }
 export interface MessageEvent {
   type: "message"; role: string; text: string;
@@ -49,6 +51,8 @@ export interface RunMeta {
   pid?: number;
   /** SPEC-6-2: the cwd this run belongs to. */
   cwd?: string;
+  /** SPEC-6-5: the session cwd the dispatch originated from (= parentCwd). */
+  sessionCwd?: string;
 }
 
 const ARGS_LIMIT = 200;
@@ -104,7 +108,7 @@ export class RunLog {
           if (!meta) {
             meta = { runId: e.runId, agent: e.agent, model: e.model, task: e.task, startedAt: e.startedAt,
               track: e.track, todoId: e.todoId, backendSessionId: e.backendSessionId, sessionKey: e.sessionKey,
-              status: "running", tokenTotal: 0, pid: e.pid, cwd: e.cwd };
+              status: "running", tokenTotal: 0, pid: e.pid, cwd: e.cwd, sessionCwd: e.sessionCwd };
           } else {
             // latest binding wins
             if (e.backendSessionId) meta.backendSessionId = e.backendSessionId;

package/src/tools/subagent.ts

@@ -1,9 +1,11 @@
 // src/tools/subagent.ts
+import { resolve } from "node:path";
+import { statSync } from "node:fs";
 import { Type, type Static } from "typebox";
 import type { AgentDef } from "../registry/frontmatter.ts";
 import type { TodoSyncPort } from "../todo-sync/port.ts";
 import type { RunRegistry } from "../engine/run-registry.ts";
-import type { SingleSlotLock } from "../engine/concurrency-lock.ts";
+import type { ForegroundLock } from "../engine/concurrency-lock.ts";
 import type { SpawnResult } from "../engine/spawnSubagent.ts";
 import { spawnSubagent } from "../engine/spawnSubagent.ts";
 import type { BackendRegistry } from "../backend/port.ts";
@@ -32,6 +34,7 @@ export const subagentParams = Type.Object({
   readOnly: Type.Optional(Type.Boolean({ description: 'Default false. Pass true ONLY for dispatches that will NOT mutate the working directory (review/audit, or research that writes no scratch files). A readOnly dispatch bypasses the foreground single-slot lock so multiple readOnly dispatches — and/or a readOnly alongside a write dispatch — can run in parallel. The caller is responsible for the assertion: mislabeling a dispatch that edits as readOnly risks in-place edit conflicts. Has no effect on background/scheduled runs (they use their own locks).' })),
   skills: Type.Optional(Type.Array(Type.String(), { description: 'Skills to load for this dispatch (opt-in). By default a dispatch loads NO skills (#32 — lean substrate; previously an agent with no skills field loaded ALL ~42 installed skills, ~570K tokens / ~59% of context). Pass skill names from the installed arsenal (e.g. ["executing-plans", "test-driven-development"]) to opt in. For a direct dispatch, this replaces the agent\'s frontmatter skills (pass [] to load zero). For a lifecycle dispatch, this is ADDITIVE — the phase\'s designed skill bundle always loads and these are merged on top (a caller cannot strip a phase\'s required skills).' })),
   modelFallback: Type.Optional(Type.String({ description: 'Model to retry with if the primary dispatch fails with a retryable provider rate-limit / auth failure (stopReason "error"). The fleet retries ONCE on this model and relinks the same tracked todo. Surface the model that served the retry in the result details (retriedWithModel). Per the AGENTS.md "Ollama primary + OpenRouter fallback" pattern. No effect on non-retryable failures (turn budget, agent-not-found, abort). Direct foreground dispatches only — background/scheduled/lifecycle retries are a follow-up.' })),
+  cwd: Type.Optional(Type.String({ description: 'The dispatch target\'s working directory. Default: the session cwd (backward-compat). Scoped to this path: the child\'s working dir, context-file cascade, skill discovery, and memory scopes. Accepts paths OUTSIDE the session cwd (a sibling repo) — that\'s the #20 fix. Relative paths resolve against the session cwd.' })),
 });
 
 export type SubagentInput = Static<typeof subagentParams>;
@@ -44,10 +47,23 @@ export function mergeLifecycleSkills(phaseSkills: string[] | undefined, callerSk
   return [...new Set([...(phaseSkills ?? []), ...(callerSkills ?? [])])];
 }
 
+/** SPEC-6-5: validate + resolve a dispatch cwd. Returns { cwd } on success or { error } on failure. */
+export function resolveDispatchCwd(raw: string | undefined, parentCwd: string): { cwd?: string; error?: string } {
+  if (raw === undefined || raw === "") return { cwd: undefined };   // default → parentCwd (handled by spawnSubagent)
+  const abs = resolve(parentCwd, raw);
+  try {
+    const st = statSync(abs);
+    if (!st.isDirectory()) return { error: `cwd is not a directory: ${abs}` };
+    return { cwd: abs };
+  } catch {
+    return { error: `cwd does not exist: ${abs}` };
+  }
+}
+
 export interface SubagentToolDeps {
   registry: Map<string, AgentDef>;
   runRegistry: RunRegistry;
-  lock: SingleSlotLock;
+  lock: ForegroundLock;
   todoSync: TodoSyncPort;
   backendRegistry: BackendRegistry;   // SPEC-3: replaces childFactory
   parentModel: { provider: string; id: string };
@@ -74,6 +90,14 @@ export interface SubagentToolDeps {
   reloadTiers?: () => void;
   /** SPEC-6-1: model contextWindow resolver for Runs-tab ctx% (Surface C). Optional — ctx% hidden when absent. */
   getModelContextWindow?: (model: string) => number | undefined;
+  /** #39 tail: a global default fallback model so a retryable provider failure (stopReason "error")
+   *  retries once even without a per-dispatch `modelFallback` param. Wired from the
+   *  `ARMORY_FLEET_MODEL_FALLBACK` env var in index.ts; a settings.json field is a follow-up.
+   *  Per-dispatch `modelFallback` (when passed) takes precedence. Applies to the direct foreground
+   *  path, the foreground lifecycle spawn, and the background/scheduled spawn. */
+  defaultModelFallback?: string;
+  /** SPEC-6-5: notify hook for cross-cwd dispatch surfacing. Wired from ctx.ui.notify in index.ts. */
+  onNotify?: (message: string, kind?: "info" | "warning" | "error") => void;
 }
 
 /** Build the pi.registerTool definition. Thin wrapper over spawnSubagent. */
@@ -90,9 +114,17 @@ export function createSubagentTool(deps: SubagentToolDeps) {
       "Pass readOnly:true for dispatches that will NOT edit the working directory (review/audit, or research that writes no scratch files). It bypasses the foreground single-slot lock so multiple readOnly dispatches can run in parallel. Only use it when you are certain the child won't mutate cwd — mislabeling risks edit conflicts.",
       "By default a dispatch loads NO skills (lean substrate). If the task needs a skill (e.g. test-driven-development for a TDD task, executing-plans for a plan-execution task), pass its name in the `skills` array to opt in — loading all skills by default wastes ~59% of the context window.",
       "Pass `modelFallback` so a transient provider rate-limit / auth failure (stopReason 'error') auto-retries once on the fallback model instead of failing the dispatch. Per the AGENTS.md 'Ollama primary + OpenRouter fallback' pattern — don't let infra limits break a dispatch chain.",
+      "For web tasks, dispatch with the firecrawl skill the child needs (e.g. skills: [\"firecrawl-scrape\"] / [\"firecrawl-search\"]) — children now discover skills from `~/.agents/skills` + `~/.pi/agent/skills`, matching your surface. Curl stays the right call for raw HTTP probes, smoke tests, and plain JSON/text APIs where JS rendering isn't needed (per the AGENTS.md firecrawl-first/curl-fallback preference).",
+      "Foreground concurrency is SESSION-LEVEL, not per-dispatch: write dispatches serialize through one shared lock sized by ARMORY_FLEET_FOREGROUND_CONCURRENCY. At the default (1) a 2nd write dispatch is rejected fail-fast (the error names the held runId) — dispatch sequentially (await each) or use readOnly:true for parallel read-only work. Raise the env cap only if you accept parallel in-place edits (conflict risk).",
     ],
     parameters: subagentParams,
     async execute(_toolCallId: string, params: SubagentInput, signal: AbortSignal, _onUpdate: unknown, _ctx: any) {
+      // SPEC-6-5: validate + resolve the dispatch cwd before any routing.
+      const { cwd: resolvedCwd, error: cwdErr } = resolveDispatchCwd(params.cwd, deps.parentCwd);
+      if (cwdErr) return { isError: true, content: [{ type: "text" as const, text: cwdErr }] };
+      if (resolvedCwd && resolvedCwd !== deps.parentCwd) {
+        deps.onNotify?.(`scoped to ${resolvedCwd} (≠ session ${deps.parentCwd})`, "info");
+      }
       // SPEC-5a: background + schedule routing (Q1/Q2/Q5).
       if (params.background && params.schedule) {
         return { isError: true, content: [{ type: "text" as const, text: "A scheduled run is inherently background — pass only one of `background` or `schedule`, not both." }] };
@@ -111,9 +143,12 @@ export function createSubagentTool(deps: SubagentToolDeps) {
       }
       if (params.lifecycle) {
         const { runLifecycle } = await import("../lifecycle/run-lifecycle.ts");
+        const { withModelFallbackRetry } = await import("../engine/retry-fallback.ts");
         const lifecycleFullDeps: LifecycleRunDeps = {
           ...deps.lifecycleDeps,
-          spawn: async (o) => spawnSubagent({
+          // #39 tail: wrap the phase spawn so a retryable provider failure retries once on the
+          // fallback (per-dispatch `modelFallback` param OR the global `defaultModelFallback` dep).
+          spawn: withModelFallbackRetry(async (o) => spawnSubagent({
             agent: o.agent, task: o.task, lifecycleTodoId: o.lifecycleTodoId, model: o.model,
             skillsOverride: mergeLifecycleSkills(o.skills, params.skills), backendOverride: o.backend,
             registry: deps.registry, todoSync: deps.todoSync, runRegistry: deps.runRegistry, lock: deps.lock,
@@ -121,10 +156,12 @@ export function createSubagentTool(deps: SubagentToolDeps) {
             maxTurns: params.maxTurns,
             tierRegistry: deps.tierRegistry, modelRegistry: deps.modelRegistry,
             readOnly: params.readOnly,
-          }),
+            cwd: o.cwd,
+          }), params.modelFallback ?? deps.defaultModelFallback, signal),
         };
         const res = await runLifecycle(params.task, params.lifecycle, {
           deps: lifecycleFullDeps, mode: "auto",
+          entryCwd: resolvedCwd,
           onCheckpoint: async (phase) => phase.status === "failed" ? { action: "abort" } : { action: "continue" },
         });
         const isError = res.status === "failed" || res.status === "aborted";
@@ -155,24 +192,28 @@ export function createSubagentTool(deps: SubagentToolDeps) {
         signal,
         maxTurns: params.maxTurns,
         tierRegistry: deps.tierRegistry, modelRegistry: deps.modelRegistry,
+        cwd: resolvedCwd,
       });
       // #39: auto-retry on a retryable provider rate-limit / auth failure (stopReason "error").
       // The primary run reverted its linked todo to open (finishRun -> markRunTodoReverted), so the
       // retry relinks the SAME todoId to continue the tracked task. Retry ONCE, only on the direct
       // foreground path, only if a distinct fallback model was provided. The retry's runId differs
       // from the primary's (each spawnSubagent call mints its own); details.retriedWithModel marks it.
+      // #39 tail: the fallback comes from the per-dispatch `modelFallback` param OR the global
+      // `defaultModelFallback` dep (wired from ARMORY_FLEET_MODEL_FALLBACK) — per-dispatch wins.
+      const fallback = params.modelFallback ?? deps.defaultModelFallback;
       let retriedWithModel: string | undefined;
       let finalRes = res;
       if (
-        res.status === "failed" && res.retryable && params.modelFallback &&
-        params.modelFallback !== res.model && !signal.aborted
+        res.status === "failed" && res.retryable && fallback &&
+        fallback !== res.model && !signal.aborted
       ) {
         finalRes = await spawnSubagent({
           agent: params.agent,
           task: params.task,
           todoId: res.todoId ?? undefined,
           track: params.track,
-          model: params.modelFallback,
+          model: fallback,
           readOnly: params.readOnly,
           skillsOverride: params.skills,
           registry: deps.registry,
@@ -186,8 +227,9 @@ export function createSubagentTool(deps: SubagentToolDeps) {
           signal,
           maxTurns: params.maxTurns,
           tierRegistry: deps.tierRegistry, modelRegistry: deps.modelRegistry,
+          cwd: resolvedCwd,
         });
-        retriedWithModel = params.modelFallback;
+        retriedWithModel = fallback;
       }
       const isError = finalRes.status === "failed" || finalRes.status === "aborted";
       return {
@@ -196,6 +238,7 @@ export function createSubagentTool(deps: SubagentToolDeps) {
           runId: finalRes.runId, todoId: finalRes.todoId, agent: finalRes.agent, model: finalRes.model,
           status: finalRes.status, durationMs: finalRes.durationMs, tokenTotal: finalRes.tokenTotal,
           retriedWithModel,
+          filesTouched: finalRes.filesTouched, reachedSummary: finalRes.reachedSummary,
         },
         isError,
       };