@getpipher/armory-fleet 1.0.0 → 1.1.1

package/README.md

@@ -254,6 +254,20 @@ Models are an ordered fallback chain (primary first; a spawn retries the next ca
 
 Live cost $ and context % are tracked per run and surfaced in the Tiers view. Override per-run with `model`, or let the tier registry route based on the task class.
 
+### Fleet settings (v1.1.0)
+
+`~/.pi/agent/fleet/settings.json` (global) and `<project>/.pi/fleet/settings.json` (project — wins per-field) hold fleet-wide defaults that aren't env-shaped. Currently one field:
+
+```json
+{
+  "defaultSubagentThinking": "high"
+}
+```
+
+`defaultSubagentThinking` (#78) sets the thinking level for **every subagent whose frontmatter does not pin `thinkingLevel`** — so a controller can think at `max` while the fleet runs at `high`, without replacing builtin agents (agent-frontmatter overrides still win; per-dispatch overrides are not exposed yet). Valid values: `off | minimal | low | medium | high | xhigh | max`. On flat subscriptions (z.ai/GLM coding plans, Ollama) this is the quota lever — thinking tokens on every cheap subagent call are pure waste.
+
+Invalid values and unknown keys produce a startup warning naming the file, the field, and the bad value — never a silent no-op. Absent files are normal.
+
 ### Operational runtime
 
 `src/runtime/` — the async/scheduling spine:
@@ -350,9 +364,20 @@ monotonic, one space per source store):
 
 Emit `{ id, verb, params }`, get exactly one reply `{ id, ok, data }` or
 `{ id, ok: false, error: { code, message } }`. Verbs: `spawn` (returns `{ runId }`
-immediately; result arrives via `fleet:run:ended`), `status`, `observe` (replay dump —
-subscribe to the broadcast channels + dedupe by `(channel, runId, seq)` for the live tail),
-`steer`, `abort`.
+immediately; result arrives via `fleet:run:ended`), `schedule` (#83 — returns
+`{ scheduleId, nextFire }`; schedules run lifecycles, not single delegates), `status`,
+`observe` (replay dump — subscribe to the broadcast channels + dedupe by
+`(channel, runId, seq)` for the live tail), `steer`, `abort`.
+
+`spawn` params: `agent`, `task`, `background?`, `lifecycle?` (named lifecycle — with
+`background: true` routes through the bg runner; without it runs as a detached
+foreground-semantics lifecycle), `modelFallback?` (per-request retry-once on a retryable
+provider failure — the retry mints a fresh runId and relinks the primary's todo), `cwd?`,
+`isolation?`, `maxTurns?`, `model?`, `skills?`, `readOnly?`, `track?`, `todoId?`.
+
+`schedule` params: `task`, `expression` (cron or interval), `lifecycle?`, `auto?`,
+`isolation?`, `cwd?` — no `agent`: the scheduler runs lifecycles only. Registration emits
+no run events; on fire, the normal `fleet:*` stream flows with `mode: "scheduled"`.
 
 Error codes: `E-CONTROL-DISABLED`, `E-RUN-NOT-FOUND`, `E-RUN-FINISHED`, `E-BAD-VERB`,
 `E-BAD-PARAMS`, `E-STEER-UNSUPPORTED`, `E-INTERNAL`.
@@ -381,7 +406,7 @@ export function fleetRpc(pi: { events: { emit(c: string, d: unknown): void; on(c
 
 ### Control gate
 
-`spawn`/`steer`/`abort` are on by default. Set `ARMORY_FLEET_RPC_CONTROL=0` (or `false`) to
+`spawn`/`steer`/`abort`/`schedule` are on by default. Set `ARMORY_FLEET_RPC_CONTROL=0` (or `false`) to
 reject them with `E-CONTROL-DISABLED`; read-only `observe`/`status` stay available. Honest
 threat model: in-process extensions already have full system access through pi itself — the
 switch guards accidents, not adversaries.
@@ -400,6 +425,14 @@ The #62 tail of SPEC-6-5: `subagent({ cwd })` now scopes **background and schedu
 - **Per-dispatch worktrees** — `isolation: 'worktree'` / `'auto'` resolve against the **dispatch cwd's repo**, not the session's; cross-cwd worktrees land in `<child-cwd>/.pi/fleet/worktrees/` and are cleaned up via the same service.
 - **bg lifecycle parity** — the bg adapter now honors the lifecycle cwd chain (`lifecycle.cwd` → dispatch `cwd`), which also fixes a pre-existing mismatch where bg isolated runs spawned phases in the session cwd but committed in the worktree.
 
+## RPC parity + fleet settings (v1.1.0)
+
+Post-v1.0 batch (issues #78/#83):
+
+- **`fleet.defaultSubagentThinking` (#78)** — a fleet-dir settings home (`~/.pi/agent/fleet/settings.json` global, `<project>/.pi/fleet/settings.json` project override) whose first field sets the thinking level for every subagent that doesn't pin its own — the quota lever for flat subscriptions. See [Fleet settings](#fleet-settings-v110).
+- **RPC spawn parity (#83)** — `spawn` gains `lifecycle` (bg routing, or a detached foreground-semantics lifecycle run) and `modelFallback` (per-request retry-once; the retry mints a fresh runId and relinks the primary's todo).
+- **New `schedule` verb (#83)** — `{ task, expression, lifecycle?, auto?, isolation?, cwd? }` → `{ scheduleId, nextFire }`. Schedules run lifecycles only, so `spawn`'s uniform `{ runId }` reply stays unbranched; the frozen surface needed zero renames and zero new error codes.
+
 ## Provider-agnostic tiers (v0.15.0)
 
 Small-backlog batch (issues #57/#63/#64/#65):

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpipher/armory-fleet",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "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/engine/retry-fallback.ts

@@ -31,3 +31,17 @@ export function withModelFallbackRetry(spawn: SpawnFn, fallback: string | undefi
     return first;
   };
 }
+
+/** #83 D3: the RPC foreground-semantics detached spawn's retry — mirrors the tool's direct-path
+ *  contract (retry ONCE, retryable failures only, DISTINCT fallback model) but the retry runs
+ *  WITHOUT the pre-minted runId: the primary already journaled run:started/ended under it, so
+ *  the retry must mint a fresh id (a reused id would double-emit run:started). `todoId` links
+ *  the retry to the primary's armory-todo task (same relink contract as the tool). */
+export async function retryForegroundOnce(
+  primary: SpawnResult,
+  fallback: string | undefined,
+  spawn: (o: { model: string; todoId?: string }) => Promise<SpawnResult>,
+): Promise<SpawnResult> {
+  if (!fallback || primary.status !== "failed" || !primary.retryable || fallback === primary.model) return primary;
+  return spawn({ model: fallback, todoId: primary.todoId ?? undefined });
+}

package/src/engine/session-rejection.ts

@@ -0,0 +1,23 @@
+// src/engine/session-rejection.ts
+// #84: typed rejections for the live-session control path (steer/abort). The RPC verbs
+// previously classified failures by fragile message-substring matching; the handles now
+// throw this class and the verbs match on `reason` first. Message TEXT is unchanged at
+// the existing throw sites — string matching survives as a back-compat fallback for
+// third-party ChildSession implementations that bubble bare Errors.
+export type SessionRejectionReason =
+  | "steer-unsupported"   // the backend has no steer (e.g. claude children)
+  | "already-processing"  // the session is mid-turn and cannot take the steer now
+  | "already-aborted";    // the session was already stopped
+
+export class SessionRejectionError extends Error {
+  readonly reason: SessionRejectionReason;
+  constructor(reason: SessionRejectionReason, message: string) {
+    super(message);
+    this.name = "SessionRejectionError";
+    this.reason = reason;
+  }
+}
+
+export function isSessionRejection(e: unknown): e is SessionRejectionError {
+  return e instanceof SessionRejectionError;
+}

package/src/engine/spawnSubagent.ts

@@ -7,6 +7,7 @@ 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 { SessionRejectionError } from "./session-rejection.ts";
 import type { ForegroundLock } from "./concurrency-lock.ts";
 import type { RunLog } from "../runtime/run-log.ts";
 import { buildToolEvent } from "../runtime/run-log.ts";
@@ -83,7 +84,7 @@ export interface LiveSessionHandle {
  *  `supportsSteer` is derived from whether the backend implemented the optional `steer`. */
 export function toLiveHandle(session: ChildSession): LiveSessionHandle {
   return {
-    steer: (text) => session.steer ? session.steer(text) : Promise.reject(new Error("steer not supported on this backend")),
+    steer: (text) => session.steer ? session.steer(text) : Promise.reject(new SessionRejectionError("steer-unsupported", "steer not supported on this backend")),
     abort: () => session.abort(),
     subscribe: (h) => session.subscribe(h),
     get isStreaming() { return session.isStreaming ?? false; },
@@ -158,6 +159,10 @@ export interface SpawnOptions {
   modelRegistry?: ModelRegistryLike;
   /** SPEC-6-3: workflow adapter tier override — replaces agent.tier before model resolution. */
   tierOverride?: string;
+  /** #78: fleet-wide default thinking level (`fleet.defaultSubagentThinking` settings field).
+   *  Applied only when the agent frontmatter does NOT pin `thinkingLevel` — precedence:
+   *  agent.thinkingLevel > opts.defaultThinkingLevel > backend/session default. */
+  defaultThinkingLevel?: ThinkingLevel;
   /** #31: when true, the caller asserts this dispatch will NOT mutate the working directory
    *  (review/audit/research). Read-only dispatches bypass the foreground single-slot lock so
    *  multiple readOnly dispatches — and/or a readOnly dispatch alongside a write dispatch — can
@@ -201,7 +206,7 @@ export interface SpawnResult {
 /** #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[] {
+export function extractTouchedFiles(toolName: string, args: unknown): string[] {
   if (!args || typeof args !== "object") return [];
   const a = args as Record<string, unknown>;
   // Case-insensitive: pi tools are lowercase ("edit"), claude's are capitalized ("Edit").
@@ -219,19 +224,41 @@ function extractTouchedFiles(toolName: string, args: unknown): string[] {
     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 tok = m[1] ? shapeToken(m[1]) : undefined;
+      if (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);
+      const tok = m[1] ? shapeToken(m[1]) : undefined;
+      if (tok) out.push(tok);
     }
     return out;
   }
   return [];
 }
 
+/** #87: decide whether a redirect/tee capture is plausibly a file path. The bare `/[/.]/`
+ *  test false-positived on `>` characters inside quoted strings/heredocs/code text
+ *  ("cache.load(name,,", "[...active],,") and swallowed trailing punctuation from code-y
+ *  commands ("/tmp/out.txt),"). Now: strip wrapping quotes, trim trailing punctuation,
+ *  then require a real path shape (contains `/`, or a dotted filename, or a leading-dot
+ *  file like .gitignore). */
+function shapeToken(raw: string): string | undefined {
+  let tok = raw.trim().replace(/^["']+/, "");
+  // trailing junk can interleave ("'/tmp/x.txt',") — strip quotes+punct until stable
+  let prev: string;
+  do {
+    prev = tok;
+    tok = tok.replace(/["',;)\]}]+$/g, "");
+  } while (tok !== prev);
+  if (!tok) return undefined;
+  if (/^\/dev\/(null|stdout|stderr|stdin|tty|zero)$/.test(tok)) return undefined; // pseudo-devices, not touched files
+  if (tok.includes("/")) return tok;
+  if (/^\.[A-Za-z0-9._-]+$/.test(tok)) return tok;            // .gitignore and friends
+  if (/^[A-Za-z0-9._-]+\.[A-Za-z0-9]+$/.test(tok)) return tok; // name.ext
+  return undefined;
+}
+
 export async function spawnSubagent(opts: SpawnOptions): Promise<SpawnResult> {
   const track = opts.track ?? true;
   const maxTurns = opts.maxTurns ?? DEFAULT_MAX_TURNS;
@@ -324,7 +351,10 @@ export async function spawnSubagent(opts: SpawnOptions): Promise<SpawnResult> {
       priorStatus = link.priorStatus;
       opts.runRegistry.update(runId, { todoId });
     } catch (e) {
-      return await finishRun(opts, runId, startedAt, "failed", "", todoId, priorStatus, (e as Error).message, agentDef.name, model);
+      return await finishRun({
+      opts, runId, startedAt, status: "failed", finalText: "", todoId, priorStatus,
+      error: (e as Error).message, agentName: agentDef.name, model,
+    });
     }
 
     // SPEC-6-1: fallback retry loop — try candidates[0], on rejection retry candidates[1], etc.
@@ -335,7 +365,8 @@ export async function spawnSubagent(opts: SpawnOptions): Promise<SpawnResult> {
         const result = await backend.factory.create({
           cwd: childCwd,
           model: cand,
-          thinkingLevel: childAgent.thinkingLevel,
+          // #78: agent frontmatter wins; the fleet-wide default fills the gap.
+          thinkingLevel: childAgent.thinkingLevel ?? opts.defaultThinkingLevel,
           tools,
           rolePrompt: childAgent.rolePrompt,
           skills: childAgent.skills ?? [],
@@ -349,7 +380,10 @@ export async function spawnSubagent(opts: SpawnOptions): Promise<SpawnResult> {
       } catch (e) { lastErr = e as Error; }
     }
     if (!session) {
-      return await finishRun(opts, runId, startedAt, "failed", "", todoId, priorStatus, `backend create failed: ${lastErr?.message ?? "unknown"}`, agentDef.name, model, 0, 0, 0);
+      return await finishRun({
+      opts, runId, startedAt, status: "failed", finalText: "", todoId, priorStatus,
+      error: `backend create failed: ${lastErr?.message ?? "unknown"}`, agentName: agentDef.name, model,
+    });
     }
 
     // SPEC-5b-4: retain a narrow live-session handle on the run record so the panel can
@@ -554,7 +588,12 @@ 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, filesTouchedList, reachedSummary, toolCallCount);
+    return await finishRun({
+      opts, runId, startedAt, status, finalText, todoId, priorStatus, error,
+      agentName: agentDef.name, model, tokenTotal, costTotal, contextTokens,
+      retryable: modelError ? true : undefined, filesTouched: filesTouchedList,
+      reachedSummary, toolCallCount,
+    });
   } 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).
@@ -572,13 +611,34 @@ function fail(runId: string, startedAt: number, message: string, agent: string):
 /** SPEC-6-2: guard against double-finishRun (abort-then-complete). */
 const finalizedRunIds = new Set<string>();
 
-async function finishRun(
-  opts: SpawnOptions, runId: string, startedAt: number,
-  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, toolCallCount = 0,
-): Promise<SpawnResult> {
+/** #NIT: options object — was 17 positional params (3 call sites, error-prone at the tail). */
+interface FinishRunArgs {
+  opts: SpawnOptions;
+  runId: string;
+  startedAt: number;
+  status: FleetRunStatus;
+  finalText: string;
+  todoId: string | null;
+  priorStatus?: string;
+  error?: string;
+  agentName: string;
+  model: string;
+  tokenTotal?: number;
+  costTotal?: number;
+  contextTokens?: number;
+  retryable?: boolean;
+  filesTouched?: string[];
+  reachedSummary?: boolean;
+  toolCallCount?: number;
+}
+
+async function finishRun(a: FinishRunArgs): Promise<SpawnResult> {
+  const { opts, runId, startedAt, status, finalText, todoId, priorStatus, error, agentName, model } = a;
+  const tokenTotal = a.tokenTotal ?? 0;
+  const costTotal = a.costTotal ?? 0;
+  const contextTokens = a.contextTokens ?? 0;
+  const toolCallCount = a.toolCallCount ?? 0;
+  const { retryable, filesTouched, reachedSummary } = a;
   if (finalizedRunIds.has(runId)) {
     // Already finalized — return the existing registry record's result without re-appending.
     const existing = opts.runRegistry.get(runId);

package/src/index.ts

@@ -8,10 +8,11 @@ import {
   getAgentDir,
 } from "@earendil-works/pi-coding-agent";
 import type { Model } from "@earendil-works/pi-ai";
-import { createSubagentTool, resolveDispatchCwd, type SubagentToolDeps } from "./tools/subagent.ts";
+import { createSubagentTool, mergeLifecycleSkills, resolveDispatchCwd, 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 { SessionRejectionError } from "./engine/session-rejection.ts";
 import { createSingleSlotLock, createForegroundLock } from "./engine/concurrency-lock.ts";
 import { ArmoryTodoAdapter } from "./todo-sync/adapter.ts";
 import { ArmoryMemoryAdapter } from "./memory-hydrate/adapter.ts";
@@ -52,6 +53,7 @@ import { FleetWidgetController } from "./panel/fleet-widget.ts";
 import { TierRegistry, mergeTiers } from "./tiers/tier-registry.ts";
 import { BUILTIN_TIERS } from "./tiers/builtin.ts";
 import { TierStore } from "./tiers/tier-store.ts";
+import { FleetSettingsStore } from "./settings/fleet-settings.ts";
 import { splitModel } from "./tiers/resolve.ts";
 import { WorkflowJournal } from "./workflows/journal.ts";
 import { discoverWorkflows, WorkflowRegistry, type WorkflowDef } from "./workflows/registry.ts";
@@ -82,7 +84,8 @@ function wrapPiSession(inner: ChildSession, backendSessionId: string): ChildSess
       return inner.subscribe(handler);
     },
     // SPEC-5b-4: forward the native SDK steer + isStreaming to the real pi session.
-    steer: (t) => inner.steer ? inner.steer(t) : Promise.reject(new Error("pi session has no steer")),
+    // #84: typed rejection (message text unchanged — back-compat with string matching).
+    steer: (t) => inner.steer ? inner.steer(t) : Promise.reject(new SessionRejectionError("steer-unsupported", "pi session has no steer")),
     get isStreaming() { return inner.isStreaming ?? false; },
   };
 }
@@ -304,7 +307,8 @@ export default async function (pi: ExtensionAPI): Promise<void> {
         // in-place runs so the cross-cwd surfacing (↗ glyph + sessionCwd audit) still fires.
         cwd: isolated ? opts.worktreePath : o.cwd,
         runLog: deps.runLog, tierRegistry: deps.tierRegistry, modelRegistry: deps.modelRegistry,
-      }), deps.defaultModelFallback),
+        defaultThinkingLevel: deps.defaultSubagentThinking,
+      }), opts.modelFallback ?? deps.defaultModelFallback),
     };
     const res = await runLifecycle(task, lifecycleName, { deps: lifecycleFullDeps, mode: opts.mode, worktreePath: opts.worktreePath, baseRef: "HEAD", entryCwd: opts.entryCwd, onCheckpoint: async (p) => p.status === "failed" ? { action: "abort" } : { action: "continue" } });
     return res as unknown as import("./runtime/async-runner.ts").FakeLifecycleResult;
@@ -429,33 +433,84 @@ export default async function (pi: ExtensionAPI): Promise<void> {
       journal: fleetJournal,
       parentCwd: ctx.cwd,
       hasAsyncRunner: true,
+      // #83 D4: schedule registration — scheduler.register + nextFire lookup. Throws (invalid
+      // expression) propagate to the verb, which maps them to E-BAD-PARAMS.
+      schedule: (spec) => {
+        if (!deps.scheduler) throw new Error("scheduling not configured in this session (scheduler missing)");
+        const id = deps.scheduler.register({
+          task: String(spec.task),
+          expression: String(spec.expression),
+          ...(typeof spec.lifecycle === "string" ? { lifecycle: spec.lifecycle } : {}),
+          ...(typeof spec.auto === "boolean" ? { auto: spec.auto } : {}),
+          ...(spec.isolation === "worktree" || spec.isolation === "none" || spec.isolation === "auto" ? { isolation: spec.isolation } : {}),
+          ...(typeof spec.cwd === "string" ? { cwd: spec.cwd } : {}),
+        });
+        const entry = deps.scheduler.list().find((s) => s.id === id);
+        return { scheduleId: id, nextFire: entry?.nextFire?.toISOString() ?? null };
+      },
       spawn: (params: Record<string, unknown>, runId: string) => {
         // Detached fire-and-forget: NEVER throws — spawnSubagent journals its own fail path
         // (run:ended + todo revert), so the caller's pre-minted runId always resolves to events.
         void (async () => {
           const requestedCwd = typeof params.cwd === "string" ? params.cwd : undefined;
           const { cwd: resolvedCwd } = resolveDispatchCwd(requestedCwd, ctx.cwd);
+          // #83: lifecycle + per-request modelFallback params (validated by the verb; re-narrowed here).
+          const rpcLifecycle = typeof params.lifecycle === "string" && params.lifecycle ? params.lifecycle : "default";
+          const rpcFallback = typeof params.modelFallback === "string" && params.modelFallback ? params.modelFallback : undefined;
           if (params.background === true) {
             // RPC background: routed through the async runner (pool slot + isolation + origin),
             // identical to the tool's runBackground path (spec §3.2). Ghost-runId prevention:
             // a synchronous pre-flight failure journals run:ended failed under the caller's id.
             const handle = runBackground(String(params.task), {
               deps: deps.asyncRunner!,
-              lifecycle: "default",
+              lifecycle: rpcLifecycle,
               mode: "auto",
               isolation: params.isolation as "worktree" | "none" | "auto" | undefined,
               cwd: resolvedCwd ?? ctx.cwd,
               origin: "background",
               runId,
+              ...(rpcFallback ? { modelFallback: rpcFallback } : {}),
             });
             if (handle.status === "failed") {
               deps.runLog?.append(runId, { type: "run:ended", runId, status: "failed", endedAt: Date.now(), tokenTotal: 0, error: handle.error });
             }
             return;
           }
+          if (params.lifecycle !== undefined) {
+            // #83 D2: lifecycle WITHOUT background = detached foreground-semantics lifecycle run
+            // (tool parity: mode "auto", failed-phase checkpoint aborts, session lock on the phase
+            // spawn, pre-minted runId via the genRunId override — same pattern as asyncRunLifecycle).
+            const { runLifecycle } = await import("./lifecycle/run-lifecycle.ts");
+            const { spawnSubagent } = await import("./engine/spawnSubagent.ts");
+            const { withModelFallbackRetry } = await import("./engine/retry-fallback.ts");
+            const lifecycleFullDeps = {
+              ...deps.lifecycleDeps,
+              genRunId: () => runId,
+              spawn: withModelFallbackRetry(async (o) => spawnSubagent({
+                agent: o.agent, task: o.task, lifecycleTodoId: o.lifecycleTodoId, model: o.model,
+                skillsOverride: mergeLifecycleSkills(o.skills, Array.isArray(params.skills) ? params.skills as string[] : undefined),
+                backendOverride: o.backend,
+                registry: deps.registry, todoSync: deps.todoSync, runRegistry: deps.runRegistry, lock: deps.lock,
+                backendRegistry: deps.backendRegistry, parentModel: deps.parentModel, parentCwd: ctx.cwd,
+                runLog: deps.runLog, signal: undefined,
+                tierRegistry: deps.tierRegistry, modelRegistry: deps.modelRegistry,
+                defaultThinkingLevel: deps.defaultSubagentThinking,
+                maxTurns: typeof params.maxTurns === "number" ? params.maxTurns : undefined,
+                readOnly: params.readOnly === true,
+                cwd: o.cwd ?? resolvedCwd,
+              }), rpcFallback ?? deps.defaultModelFallback),
+            };
+            const res = await runLifecycle(String(params.task), rpcLifecycle, {
+              deps: lifecycleFullDeps, mode: "auto", entryCwd: resolvedCwd,
+              onCheckpoint: async (p) => p.status === "failed" ? { action: "abort" } : { action: "continue" },
+            });
+            deps.lifecycleRuns.set(res.runId, res);  // panel Lifecycle-view visibility (workflow-lambda precedent)
+            return;
+          }
           // Foreground-semantics detached spawn (no mode — "foreground" is the truth).
           const { spawnSubagent } = await import("./engine/spawnSubagent.ts");
-          await spawnSubagent({
+          const { retryForegroundOnce } = await import("./engine/retry-fallback.ts");
+          const primary = await spawnSubagent({
             agent: params.agent as string,
             task: params.task as string,
             todoId: typeof params.todoId === "string" ? params.todoId : undefined,
@@ -476,7 +531,33 @@ export default async function (pi: ExtensionAPI): Promise<void> {
             modelRegistry: deps.modelRegistry,
             cwd: resolvedCwd ?? ctx.cwd,
             runId,
+            defaultThinkingLevel: deps.defaultSubagentThinking,
           });
+          // #83 D3: per-request fallback retry — the retry mints a FRESH runId (the primary's
+          // pre-minted id stays retired; a reuse would double-emit run:started) and relinks the
+          // primary's todo, exactly like the tool's direct path.
+          await retryForegroundOnce(primary, rpcFallback, (o) => spawnSubagent({
+            agent: params.agent as string,
+            task: params.task as string,
+            todoId: o.todoId,
+            track: params.track === true,
+            model: o.model,
+            readOnly: params.readOnly === true,
+            skillsOverride: Array.isArray(params.skills) ? params.skills as string[] : undefined,
+            registry: deps.registry,
+            todoSync: deps.todoSync,
+            runRegistry: deps.runRegistry,
+            lock: deps.lock,
+            backendRegistry: deps.backendRegistry,
+            parentModel: deps.parentModel,
+            parentCwd: ctx.cwd,
+            runLog: deps.runLog,
+            maxTurns: typeof params.maxTurns === "number" ? params.maxTurns : undefined,
+            tierRegistry: deps.tierRegistry,
+            modelRegistry: deps.modelRegistry,
+            cwd: resolvedCwd ?? ctx.cwd,
+            defaultThinkingLevel: deps.defaultSubagentThinking,
+          }));
         })().catch(() => {});
       },
     });
@@ -521,6 +602,16 @@ export default async function (pi: ExtensionAPI): Promise<void> {
     deps.reloadTiers = reloadTiers;
     reloadTiers();  // build the real merged registry (replaces the builtin-only placeholder)
 
+    // #78: fleet-dir settings.json (global + project, project wins) — currently carries
+    // `defaultSubagentThinking`. Warnings are surfaced, never swallowed silently.
+    const fleetSettingsStore = new FleetSettingsStore({
+      projectPath: join(dir, "settings.json"),
+      globalPath: join(process.env.HOME ?? "", ".pi", "agent", "fleet", "settings.json"),
+    });
+    const fleetSettings = fleetSettingsStore.load();
+    for (const w of fleetSettings.warnings) ctx.ui.notify(w, "warning");
+    deps.defaultSubagentThinking = fleetSettings.settings.defaultSubagentThinking;
+
     // SPEC-6-3: workflow journal + registry + runner + fleet tool wiring.
     const workflowJournal = new WorkflowJournal(join(dir, "workflows"));
     wfRegistry = new WorkflowRegistry(discoverWorkflows({
@@ -543,6 +634,7 @@ export default async function (pi: ExtensionAPI): Promise<void> {
       runLog: deps.runLog,
       tierRegistry: deps.tierRegistry,
       modelRegistry: deps.modelRegistry,
+      defaultThinkingLevel: deps.defaultSubagentThinking,
       lifecycleDeps: deps.lifecycleDeps,
       spawnSubagentFn: async (opts) => { const { spawnSubagent } = await import("./engine/spawnSubagent.ts"); return spawnSubagent(opts); },
       runLifecycleFn: async (task, name, lcOpts) => { const { runLifecycle } = await import("./lifecycle/run-lifecycle.ts"); return runLifecycle(task, name, lcOpts); },
@@ -677,6 +769,7 @@ export default async function (pi: ExtensionAPI): Promise<void> {
           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
+          defaultThinkingLevel: deps.defaultSubagentThinking,
         }), deps.defaultModelFallback),
       };
       const res = await runLifecycle(parsed.task, lcName, { deps: lifecycleFullDeps, mode: parsed.auto ? "auto" : "checkpointed", onCheckpoint });

package/src/panel/fleet-panel.ts

@@ -9,7 +9,7 @@ import {
   matchesKey,
   type SelectItem,
 } from "@earendil-works/pi-tui";
-import type { AgentDef } from "../registry/frontmatter.ts";
+import type { AgentDef, ThinkingLevel } from "../registry/frontmatter.ts";
 import { agentsRow, agentInfo, backendsRow, backendInfo, lifecycleRow, lifecyclePhaseTimeline, scheduleRow } from "./rows.ts";
 import { buildFleetItems } from "./fleet-items.ts";
 import { runsRow, runTimelineRow } from "./runs-rows.ts";
@@ -46,6 +46,9 @@ export interface FleetPanelDeps {
   backendRegistry: BackendRegistry;   // SPEC-3: replaces childFactory
   parentModel: { provider: string; id: string };
   parentCwd: string;
+  /** #78: fleet-wide default thinking level (settings.json `defaultSubagentThinking`).
+   *  Threads to every panel-driven spawn (Run/Resume/Fork + lifecycle-view phases). */
+  defaultSubagentThinking?: ThinkingLevel;
   /** SPEC-4: lifecycle registry + active/recent run records + deps to drive checkpoints. */
   lifecycleRegistry: Map<string, LifecycleDef>;
   lifecycleRuns: Map<string, LifecycleRunRecord>;
@@ -483,6 +486,7 @@ export class FleetPanel extends Container {
       backendRegistry: this.deps.backendRegistry,
       parentModel: this.deps.parentModel, parentCwd: this.deps.parentCwd,
       runLog: this.deps.runLog,
+      defaultThinkingLevel: this.deps.defaultSubagentThinking,
       // live Fleet row during the run (SPEC-1 §4c) — re-render on each turn_end
       onEvent: (e) => {
         if (e.type === "turn_end") {
@@ -1117,6 +1121,7 @@ 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,
+      defaultThinkingLevel: this.deps.defaultSubagentThinking,
       onEvent: (e) => { if (e.type === "turn_end") { this.list = this.buildList(); this.renderShell(); } },
     });
     this.list = this.buildList();
@@ -1156,6 +1161,7 @@ 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,
+      defaultThinkingLevel: this.deps.defaultSubagentThinking,
       onEvent: (e) => { if (e.type === "turn_end") { this.list = this.buildList(); this.renderShell(); } },
     });
     this.list = this.buildList();
@@ -1228,6 +1234,7 @@ 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,
+          defaultThinkingLevel: this.deps.defaultSubagentThinking,
           cwd: o.cwd,
         });
       },

package/src/panel/rows.ts

@@ -1,4 +1,5 @@
 // src/panel/rows.ts
+import { basename } from "node:path";
 import type { AgentDef } from "../registry/frontmatter.ts";
 import type { FleetRunStatus } from "../todo-sync/port.ts";
 import type { RunRecord } from "../engine/run-registry.ts";
@@ -140,6 +141,8 @@ export interface ScheduleRow {
   task: string;
   nextFire: Date | null;
   paused: boolean;
+  /** #62: pinned dispatch cwd — rendered as a ↗ basename so cross-cwd schedules are visible. */
+  cwd?: string;
 }
 
 export function scheduleRow(s: ScheduleRow): string {
@@ -147,7 +150,8 @@ export function scheduleRow(s: ScheduleRow): string {
   const next = s.nextFire ? `next: ${s.nextFire.toLocaleString()}` : "paused";
   const task = s.task.length > 24 ? s.task.slice(0, 23) + "…" : s.task;
   const lc = s.lifecycle ?? "default";
-  return `${icon}  ${s.expression}  ${lc}  "${task}"  ${next}  ${s.id}`;
+  const cwd = s.cwd ? `  ↗${basename(s.cwd)}` : "";
+  return `${icon}  ${s.expression}  ${lc}  "${task}"${cwd}  ${next}  ${s.id}`;
 }
 
 const LC_GLYPH: Record<LifecycleStatus, string> = {

package/src/panel/runs-rows.ts

@@ -16,9 +16,13 @@ export function runsRow(r: RunMeta, getModelContextWindow?: (model: string) => n
   const maxCtx = getModelContextWindow?.(r.model);
   const ctx = (r.contextTokens != null && maxCtx != null && maxCtx > 0) ? `  ${Math.round(r.contextTokens / maxCtx * 100)}%` : "";
   const cost = r.costTotal ? `  $${r.costTotal.toFixed(4)}` : "";
+  // #59/#60/#61 NIT: the journal fields v0.14.0 added to run:ended, now visible in the list.
+  const err = r.error ? `  ✗"${r.error.length > 60 ? r.error.slice(0, 59) + "…" : r.error}"` : "";
+  const tools = r.toolCallCount != null ? `  ·${r.toolCallCount}t` : "";
+  const files = r.filesTouched?.length ? `  ✎${r.filesTouched.length}` : "";
   const summary = r.resultSummary ? `  "${r.resultSummary}"` : "";
   const prov = r.resumedFrom ? `  ← resumed:${r.resumedFrom}` : r.forkedFrom ? `  ← forked:${r.forkedFrom}` : "";
-  return `${STATUS_GLYPH[r.status]} ${r.runId}  ${r.agent}  ${r.status}  ${dur}${tok}${ctx}${cost}${summary}${prov}`;
+  return `${STATUS_GLYPH[r.status]} ${r.runId}  ${r.agent}  ${r.status}  ${dur}${tok}${ctx}${cost}${tools}${files}${err}${summary}${prov}`;
 }
 
 export function runTimelineRow(e: MessageEvent | ToolEvent): string {

package/src/panel/widget-rows.ts

@@ -119,7 +119,13 @@ function widgetLine(r: WidgetRun, now: number): string {
   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)}` : "";
+  // #62 NIT: isolated runs pin cwd to <child-cwd>/.pi/fleet/worktrees/<runId> — the basename
+  // was the cryptic run-id. Strip the worktrees suffix so the glyph names the TARGET repo dir.
+  const displayCwd = (cwd: string): string => {
+    const wt = cwd.indexOf("/.pi/fleet/worktrees/");
+    return wt > 0 ? basename(cwd.slice(0, wt)) : basename(cwd);
+  };
+  const crossCwd = (r.cwd && r.sessionCwd && r.cwd !== r.sessionCwd) ? `  ↗${displayCwd(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)

package/src/rpc/rpc-server.ts

@@ -7,6 +7,7 @@ import type { RunRegistry, RunRecord } from "../engine/run-registry.ts";
 import type { RunLog } from "../runtime/run-log.ts";
 import type { RunJournal } from "../runtime/run-journal.ts";
 import { resolveDispatchCwd } from "../tools/subagent.ts";
+import { isSessionRejection } from "../engine/session-rejection.ts";
 
 export type RpcErrorCode =
   | "E-CONTROL-DISABLED" | "E-RUN-NOT-FOUND" | "E-RUN-FINISHED" | "E-BAD-VERB"
@@ -40,6 +41,9 @@ export interface RpcServerDeps {
    *  Never throws — runtime failures land via the registry + RunLog journal (spawnSubagent's own
    *  fail path journals run:ended), so the caller's { runId } always resolves to a real run. */
   spawn: (params: Record<string, unknown>, runId: string) => void;
+  /** #83: schedule registration (scheduler.register under the hood). Throws on an invalid
+   *  expression (surfaced as E-BAD-PARAMS); absent = scheduling not configured in this session. */
+  schedule?: (spec: Record<string, unknown>) => { scheduleId: string; nextFire: string | null };
 }
 
 const LIST_CAP = 25;
@@ -84,14 +88,15 @@ export class RpcServer {
       case "spawn": return gated ? this.spawnVerb(id, params) : this.controlDisabled(id);
       case "steer": return gated ? this.steerVerb(id, params) : this.controlDisabled(id);
       case "abort": return gated ? this.abortVerb(id, params) : this.controlDisabled(id);
+      case "schedule": return gated ? this.scheduleVerb(id, params) : this.controlDisabled(id);
       case "observe": return this.observeVerb(id, params);
       case "status": return this.statusVerb(id, params);
-      default: return this.err(id, "E-BAD-VERB", `unknown verb '${verb}' (known: spawn, steer, observe, abort, status)`);
+      default: return this.err(id, "E-BAD-VERB", `unknown verb '${verb}' (known: spawn, steer, observe, abort, status, schedule)`);
     }
   }
 
   private controlDisabled(id: string): RpcReply {
-    return this.err(id, "E-CONTROL-DISABLED", "fleet rpc control is disabled (ARMORY_FLEET_RPC_CONTROL is set to off; remove it or set it to 1 to enable spawn/steer/abort)");
+    return this.err(id, "E-CONTROL-DISABLED", "fleet rpc control is disabled (ARMORY_FLEET_RPC_CONTROL is set to off; remove it or set it to 1 to enable spawn/steer/abort/schedule)");
   }
 
   private err(id: string, code: RpcErrorCode, message: string): RpcReply {
@@ -107,9 +112,9 @@ export class RpcServer {
     if (!p) return this.err(id, "E-BAD-PARAMS", "spawn requires params: { agent, task, ... }");
     if (typeof p.agent !== "string" || !p.agent) return this.err(id, "E-BAD-PARAMS", "params.agent must be a non-empty string");
     if (typeof p.task !== "string" || !p.task) return this.err(id, "E-BAD-PARAMS", "params.task must be a non-empty string");
-    if (p.lifecycle !== undefined) return this.err(id, "E-BAD-PARAMS", "params.lifecycle is not supported over RPC spawn yet (single-delegate + background only — spec §7)");
-    if (p.schedule !== undefined) return this.err(id, "E-BAD-PARAMS", "params.schedule is not supported over RPC spawn yet");
-    if (p.modelFallback !== undefined) return this.err(id, "E-BAD-PARAMS", "params.modelFallback is not supported over RPC spawn yet");
+    if (p.lifecycle !== undefined && (typeof p.lifecycle !== "string" || !p.lifecycle)) return this.err(id, "E-BAD-PARAMS", "params.lifecycle must be a non-empty string when set (#83)");
+    if (p.schedule !== undefined) return this.err(id, "E-BAD-PARAMS", "params.schedule is not a spawn param — schedules run lifecycles, not single delegates; use the 'schedule' verb (#83)");
+    if (p.modelFallback !== undefined && (typeof p.modelFallback !== "string" || !p.modelFallback)) return this.err(id, "E-BAD-PARAMS", "params.modelFallback must be a non-empty string when set (#83)");
     if (p.cwd !== undefined && (typeof p.cwd !== "string" || p.cwd === "")) return this.err(id, "E-BAD-PARAMS", "params.cwd must be a non-empty string when set");
     if (p.cwd !== undefined) {
       const { error } = resolveDispatchCwd(p.cwd, this.deps.parentCwd);
@@ -135,6 +140,42 @@ export class RpcServer {
     return { id, ok: true, data: { runId } };
   }
 
+  /** #83 D4: register a recurring lifecycle run. Reply shape { scheduleId, nextFire } — schedules
+   *  are NOT runs, so no runId (spawn's uniform { runId } contract stays unbranched). */
+  private scheduleVerb(id: string, params: unknown): RpcReply {
+    const p = this.obj(params);
+    if (!p) return this.err(id, "E-BAD-PARAMS", "schedule requires params: { task, expression, ... }");
+    if (typeof p.task !== "string" || !p.task) return this.err(id, "E-BAD-PARAMS", "params.task must be a non-empty string");
+    if (typeof p.expression !== "string" || !p.expression) return this.err(id, "E-BAD-PARAMS", "params.expression must be a non-empty string (cron or interval, e.g. '*/5 * * * *' or '30m')");
+    if (p.lifecycle !== undefined && (typeof p.lifecycle !== "string" || !p.lifecycle)) return this.err(id, "E-BAD-PARAMS", "params.lifecycle must be a non-empty string when set");
+    if (p.auto !== undefined && typeof p.auto !== "boolean") return this.err(id, "E-BAD-PARAMS", "params.auto must be a boolean");
+    if (p.isolation !== undefined && p.isolation !== "worktree" && p.isolation !== "none" && p.isolation !== "auto") {
+      return this.err(id, "E-BAD-PARAMS", "params.isolation must be 'worktree' | 'none' | 'auto'");
+    }
+    if (p.cwd !== undefined && (typeof p.cwd !== "string" || p.cwd === "")) return this.err(id, "E-BAD-PARAMS", "params.cwd must be a non-empty string when set");
+    let cwd: string | undefined;
+    if (p.cwd !== undefined) {
+      const resolved = resolveDispatchCwd(p.cwd, this.deps.parentCwd);
+      if (resolved.error) return this.err(id, "E-BAD-PARAMS", resolved.error);
+      cwd = resolved.cwd;
+    }
+    if (!this.deps.schedule) {
+      return this.err(id, "E-BAD-PARAMS", "scheduling not configured in this session (scheduler missing)");
+    }
+    try {
+      const out = this.deps.schedule({
+        task: p.task, expression: p.expression,
+        ...(p.lifecycle !== undefined ? { lifecycle: p.lifecycle } : {}),
+        ...(p.auto !== undefined ? { auto: p.auto } : {}),
+        ...(p.isolation !== undefined ? { isolation: p.isolation } : {}),
+        ...(cwd !== undefined ? { cwd } : {}),
+      });
+      return { id, ok: true, data: { scheduleId: out.scheduleId, nextFire: out.nextFire } };
+    } catch (e) {
+      return this.err(id, "E-BAD-PARAMS", (e as Error).message || "schedule registration failed");
+    }
+  }
+
   private statusVerb(id: string, params: unknown): RpcReply {
     const p = this.obj(params) ?? {};
     if (p.runId !== undefined) {
@@ -143,8 +184,12 @@ export class RpcServer {
       if (!rec) return this.err(id, "E-RUN-NOT-FOUND", `no live run '${p.runId}' in the registry (finished runs older than the session are not listed)`);
       return { id, ok: true, data: { runs: [summarize(rec)] } };
     }
-    const runs = this.deps.runRegistry.list().slice(0, LIST_CAP).map(summarize);
-    return { id, ok: true, data: { runs } };
+    const runs = this.deps.runRegistry.list();
+    const capped = runs.slice(0, LIST_CAP).map(summarize);
+    // #84: surface the omitted count so RPC consumers know the list is partial. Absent
+    // when everything fit (additive field — consumers check presence, not falseness).
+    const truncated = runs.length - capped.length;
+    return { id, ok: true, data: truncated > 0 ? { runs: capped, truncated } : { runs: capped } };
   }
 
   private observeVerb(id: string, params: unknown): RpcReply {
@@ -211,6 +256,9 @@ export class RpcServer {
     try {
       await session.steer(p.message);
     } catch (e) {
+      // #84: typed rejections match by reason; string matching survives as a back-compat
+      // fallback for third-party ChildSession implementations that bubble bare Errors.
+      if (isSessionRejection(e) && e.reason === "steer-unsupported") return this.err(id, "E-STEER-UNSUPPORTED", e.message);
       const msg = (e as Error).message ?? "steer failed";
       if (msg.includes("not supported")) return this.err(id, "E-STEER-UNSUPPORTED", msg);
       return this.err(id, "E-INTERNAL", `steer failed: ${msg}`);
@@ -229,6 +277,8 @@ export class RpcServer {
     try {
       await session.abort();
     } catch (e) {
+      // #84: typed first (reason-based), string fallback for bare-Error handles.
+      if (isSessionRejection(e) && (e.reason === "already-aborted" || e.reason === "already-processing")) return this.err(id, "E-RUN-FINISHED", e.message);
       const msg = (e as Error).message ?? "abort failed";
       if (msg.includes("already")) return this.err(id, "E-RUN-FINISHED", msg);
       return this.err(id, "E-INTERNAL", `abort failed: ${msg}`);

package/src/runtime/async-runner.ts

@@ -31,6 +31,9 @@ export interface RunLifecycleOpts {
   /** #62: the dispatch target cwd for in-place runs (isolated runs pass the worktree path).
    *  Flows into runLifecycle's SPEC-6-5 cwd resolution (lifecycle.cwd ?? entryCwd). */
   entryCwd?: string;
+  /** #83: per-run fallback model for the phase-spawn retry wrapper (wins over the host's
+   *  global default). Undefined = use the host default (back-compat). */
+  modelFallback?: string;
 }
 
 export type RunLifecycleFn = (task: string, lifecycleName: string, opts: RunLifecycleOpts) => Promise<FakeLifecycleResult>;
@@ -66,6 +69,9 @@ export interface RunBackgroundOpts {
   runId?: string;
   /** v0.11.1: edit isolation for background runs. Default "auto" (worktree when cwd is a git repo, in-place otherwise). */
   isolation?: Isolation;
+  /** #83: per-run fallback model — forwarded to the runLifecycle adapter so its phase-spawn
+   *  retry wrapper prefers this over the host's global default. Undefined = host default. */
+  modelFallback?: string;
   /** #62: the dispatch target cwd (undefined = session cwd, back-compat). Scopes the run:
    *  isolation routing + worktree creation resolve against THIS cwd (via deps.worktreeFor),
    *  and in-place runs pass it as the lifecycle entryCwd. */
@@ -120,7 +126,7 @@ function runBackgroundInPlace(runId: string, task: string, opts: RunBackgroundOp
       deps.journal.append(runId, ev0);
       emitProgress(deps, runId, { status: "running", phase: "", phaseIndex: 0, phaseTotal: 0, lifecycle: opts.lifecycle, mode: opts.mode, task });
 
-      const res = await deps.runLifecycle(task, opts.lifecycle, { runId, worktreePath: isolated?.worktreePath, branch: isolated?.branch, mode: opts.mode, entryCwd: isolated ? isolated.worktreePath : opts.cwd, fleetMode: opts.origin ?? "background" });
+      const res = await deps.runLifecycle(task, opts.lifecycle, { runId, worktreePath: isolated?.worktreePath, branch: isolated?.branch, mode: opts.mode, entryCwd: isolated ? isolated.worktreePath : opts.cwd, fleetMode: opts.origin ?? "background", ...(opts.modelFallback ? { modelFallback: opts.modelFallback } : {}) });
 
       if (res.status === "completed") {
         if (isolated) {

package/src/runtime/run-log.ts

@@ -61,6 +61,12 @@ export interface RunMeta {
   cwd?: string;
   /** SPEC-6-5: the session cwd the dispatch originated from (= parentCwd). */
   sessionCwd?: string;
+  /** #59 NIT: the failure reason on failed runs (from run:ended). */
+  error?: string;
+  /** #61 NIT: executed-tool count (the zero-work signal). */
+  toolCallCount?: number;
+  /** #60 NIT: file paths the run mutated. */
+  filesTouched?: string[];
 }
 
 const ARGS_LIMIT = 200;
@@ -145,6 +151,8 @@ export class RunLog {
         meta.resultSummary = ended.resultSummary; meta.tokenTotal = ended.tokenTotal;
         meta.resumedFrom = ended.resumedFrom; meta.forkedFrom = ended.forkedFrom;
         meta.costTotal = ended.costTotal; meta.contextTokens = ended.contextTokens;
+        // #59/#60/#61 NIT: surface the newer journal fields to the Runs tab too.
+        meta.error = ended.error; meta.toolCallCount = ended.toolCallCount; meta.filesTouched = ended.filesTouched;
       }
       out.push(meta);
     }

package/src/settings/fleet-settings.ts

@@ -0,0 +1,103 @@
+// src/settings/fleet-settings.ts
+// #78: fleet-dir settings.json — the settings home for fleet-wide defaults that
+// aren't env-shaped (sibling of tiers.json in the same global+project scheme).
+//
+// Locations:
+//   global:  ~/.pi/agent/fleet/settings.json
+//   project: <cwd>/.pi/fleet/settings.json   (project wins per-field)
+//
+// Design rules:
+// - Absent files are normal (empty settings, no warning).
+// - Present-but-invalid content produces ACTIONABLE warnings (file + field + bad
+//   value) and drops the field — never a silent swallow (the TierStore ENOENT
+//   lesson: silent loaders make wrong docs doubly dangerous).
+// - The schema is intentionally small and additive; unknown keys warn so typos
+//   surface instead of no-oping.
+import { readFileSync } from "node:fs";
+import type { ThinkingLevel } from "../registry/frontmatter.ts";
+
+const THINKING_LEVELS: readonly ThinkingLevel[] = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+
+export function isThinkingLevel(v: unknown): v is ThinkingLevel {
+  return typeof v === "string" && (THINKING_LEVELS as readonly string[]).includes(v);
+}
+
+/** Fleet-wide defaults. Intentionally additive — new fields land here. */
+export interface FleetSettings {
+  /** #78: applied to every subagent whose frontmatter does NOT pin `thinkingLevel`.
+   *  Precedence: agent.thinkingLevel > this > the backend/session default. */
+  defaultSubagentThinking?: ThinkingLevel;
+}
+
+export interface FleetSettingsResult {
+  settings: FleetSettings;
+  /** Actionable, source-labeled warnings (never empty-string; always name the file). */
+  warnings: string[];
+}
+
+/** Parse one settings file's content. `label` names the file in warnings. */
+export function parseFleetSettings(json: string, label = "settings.json"): FleetSettingsResult {
+  const warnings: string[] = [];
+  let raw: unknown;
+  try {
+    raw = JSON.parse(json);
+  } catch (e) {
+    return { settings: {}, warnings: [`${label}: invalid JSON (${(e as Error).message}) — fleet settings from this file ignored`] };
+  }
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    return { settings: {}, warnings: [`${label}: expected a JSON object, got ${raw === null ? "null" : Array.isArray(raw) ? "array" : typeof raw} — fleet settings from this file ignored`] };
+  }
+  const obj = raw as Record<string, unknown>;
+  const settings: FleetSettings = {};
+
+  const thinking = obj["defaultSubagentThinking"];
+  if (thinking !== undefined) {
+    if (isThinkingLevel(thinking)) {
+      settings.defaultSubagentThinking = thinking;
+    } else {
+      warnings.push(`${label}: defaultSubagentThinking must be one of ${THINKING_LEVELS.join("|")}, got ${JSON.stringify(thinking)} — ignored`);
+    }
+  }
+
+  const known = new Set(["defaultSubagentThinking"]);
+  const unknownKeys = Object.keys(obj).filter((k) => !known.has(k));
+  if (unknownKeys.length > 0) {
+    warnings.push(`${label}: unknown setting${unknownKeys.length > 1 ? "s" : ""} ${unknownKeys.map((k) => `"${k}"`).join(", ")} — ignored (valid: ${[...known].join(", ")})`);
+  }
+
+  return { settings, warnings };
+}
+
+export interface FleetSettingsStoreOpts {
+  projectPath: string;
+  globalPath: string;
+}
+
+/** Global+project fleet settings (project wins per-field), mirroring TierStore's scheme. */
+export class FleetSettingsStore {
+  constructor(private readonly opts: FleetSettingsStoreOpts) {}
+
+  private readOne(path: string, label: string): FleetSettingsResult {
+    let content: string;
+    try {
+      content = readFileSync(path, "utf8");
+    } catch (e) {
+      // ENOENT = the normal absent-file state, never a warning. Any OTHER read failure
+      // (EACCES, EISDIR, …) on a path that was expected to be readable must surface —
+      // silent swallows make misconfiguration invisible (the TierStore lesson).
+      const code = (e as NodeJS.ErrnoException).code;
+      if (code === "ENOENT") return { settings: {}, warnings: [] };
+      return { settings: {}, warnings: [`${label}: unreadable (${code ?? (e as Error).message}) — fleet settings from this file ignored`] };
+    }
+    return parseFleetSettings(content, label);
+  }
+
+  load(): FleetSettingsResult {
+    const global = this.readOne(this.opts.globalPath, this.opts.globalPath);
+    const project = this.readOne(this.opts.projectPath, this.opts.projectPath);
+    return {
+      settings: { ...global.settings, ...project.settings },
+      warnings: [...global.warnings, ...project.warnings],
+    };
+  }
+}

package/src/tools/subagent.ts

@@ -2,7 +2,7 @@
 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 { AgentDef, ThinkingLevel } from "../registry/frontmatter.ts";
 import type { TodoSyncPort } from "../todo-sync/port.ts";
 import type { RunRegistry } from "../engine/run-registry.ts";
 import type { ForegroundLock } from "../engine/concurrency-lock.ts";
@@ -96,6 +96,10 @@ export interface SubagentToolDeps {
    *  Per-dispatch `modelFallback` (when passed) takes precedence. Applies to the direct foreground
    *  path, the foreground lifecycle spawn, and the background/scheduled spawn. */
   defaultModelFallback?: string;
+  /** #78: fleet-wide default thinking level for subagents (settings.json `defaultSubagentThinking`).
+   *  Applied when the agent frontmatter does NOT pin `thinkingLevel`. Threads to every spawn
+   *  path (direct, lifecycle phase, fallback retry) exactly like `defaultModelFallback`. */
+  defaultSubagentThinking?: ThinkingLevel;
   /** 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;
 }
@@ -155,6 +159,7 @@ export function createSubagentTool(deps: SubagentToolDeps) {
             backendRegistry: deps.backendRegistry, parentModel: deps.parentModel, parentCwd: deps.parentCwd, runLog: deps.runLog, signal,
             maxTurns: params.maxTurns,
             tierRegistry: deps.tierRegistry, modelRegistry: deps.modelRegistry,
+            defaultThinkingLevel: deps.defaultSubagentThinking,
             readOnly: params.readOnly,
             cwd: o.cwd,
           }), params.modelFallback ?? deps.defaultModelFallback, signal),
@@ -192,6 +197,7 @@ export function createSubagentTool(deps: SubagentToolDeps) {
         signal,
         maxTurns: params.maxTurns,
         tierRegistry: deps.tierRegistry, modelRegistry: deps.modelRegistry,
+        defaultThinkingLevel: deps.defaultSubagentThinking,
         cwd: resolvedCwd,
       });
       // #39: auto-retry on a retryable provider rate-limit / auth failure (stopReason "error").
@@ -227,6 +233,7 @@ export function createSubagentTool(deps: SubagentToolDeps) {
           signal,
           maxTurns: params.maxTurns,
           tierRegistry: deps.tierRegistry, modelRegistry: deps.modelRegistry,
+          defaultThinkingLevel: deps.defaultSubagentThinking,
           cwd: resolvedCwd,
         });
         retriedWithModel = fallback;

package/src/workflows/runtime/adapters.ts

@@ -22,6 +22,8 @@ export interface WorkflowAdapterBase {
   runLog?: unknown
   tierRegistry?: unknown
   modelRegistry?: unknown
+  /** #78: fleet-wide default thinking level, threaded into every workflow child spawn. */
+  defaultThinkingLevel?: SpawnOptions["defaultThinkingLevel"]
   lifecycleDeps: unknown
   spawnSubagentFn: (opts: SpawnOptions) => Promise<SpawnResult>
   runLifecycleFn: (task: string, name: string, opts: LifecycleRunOpts) => Promise<LifecycleRunResult>
@@ -69,6 +71,7 @@ export function createWorkflowAdapters(
     ...(base.runLog ? { runLog: base.runLog as SpawnOptions["runLog"] } : {}),
     ...(base.tierRegistry ? { tierRegistry: base.tierRegistry as SpawnOptions["tierRegistry"] } : {}),
     ...(base.modelRegistry ? { modelRegistry: base.modelRegistry as SpawnOptions["modelRegistry"] } : {}),
+    ...(base.defaultThinkingLevel ? { defaultThinkingLevel: base.defaultThinkingLevel } : {}),
   })
 
   const combineSignal = (timeoutMs?: number): AbortSignal => {