@getpipher/armory-fleet 0.16.0 → 1.1.0

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:
@@ -328,7 +342,82 @@ Every workflow run is **journaled** (`workflows/journal.ts`) and **resumable**.
 - **Panel Run-action:** a 3rd `cwd` input step (task → name → cwd), prefilled with the session cwd; Enter accepts, Escape cancels.
 - **bg/scheduled + worktree cwd-isolation (#62):** the `cwd` param now scopes background and scheduled runs too — in-place bg runs pass it as the lifecycle entry cwd, and `isolation: 'worktree'`/`'auto'` resolve isolation (and create the worktree) against the **dispatch cwd's** repo, not the session's. Cross-cwd bg worktrees land in `<child-cwd>/.pi/fleet/worktrees/`.
 
-## Cross-cwd everywhere (v0.16.0)
+## Event bus + RPC (v1.0)
+
+armory-fleet publishes every run on pi's cross-extension event bus and answers an RPC verb
+set — so your own extensions can spawn, steer, observe, and abort subagents programmatically.
+
+### Event stream (broadcast, `pi.events`)
+
+Two tiers, every event enveloped as `{ runId, seq, ts, ...payload }` (`seq` = per-run
+monotonic, one space per source store):
+
+| Channel | Payload |
+|---|---|
+| `fleet:run:started` | `{ agent, model?, cwd?, sessionCwd?, mode: foreground\|background\|scheduled\|workflow, task }` |
+| `fleet:phase:started` / `completed` / `failed` | `{ phase, … }` (lifecycle runs) |
+| `fleet:run:ended` | `{ status: completed\|failed\|aborted, result?, error?, filesTouched?, toolCallCount?, durationMs? }` |
+| `fleet:child:message` | `{ role, text }` (journal excerpts) |
+| `fleet:child:tool` | `{ toolName, args, result, isError }` (one per completed tool call) |
+
+### RPC (`fleet:rpc` → `fleet:rpc:result`)
+
+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`), `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`.
+
+### Client helper (~15 lines)
+
+```ts
+type FleetReply = { id: string; ok: true; data: any } | { id: string; ok: false; error: { code: string; message: string } };
+let n = 0;
+export function fleetRpc(pi: { events: { emit(c: string, d: unknown): void; on(c: string, h: (d: unknown) => void): () => void } }) {
+  return <T = any>(verb: string, params?: Record<string, unknown>): Promise<T> => {
+    const id = `fleet-${Date.now().toString(36)}-${++n}`;
+    return new Promise<T>((resolve, reject) => {
+      const unsub = pi.events.on("fleet:rpc:result", (raw) => {
+        const r = raw as FleetReply;
+        if (r.id !== id) return;
+        unsub();
+        r.ok ? resolve(r.data as T) : reject(new Error(`${r.error.code}: ${r.error.message}`));
+      });
+      pi.events.emit("fleet:rpc", { id, verb, params });
+    });
+  };
+}
+// const rpc = fleetRpc(pi); const { runId } = await rpc("spawn", { agent: "scout", task: "look" });
+```
+
+### Control gate
+
+`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.
+
+### Live conversation viewer
+
+`/fleet` → Runs → open a **running** run: the timeline overlay streams the child's
+conversation as it happens (tail-follows; scroll up to read, back to the bottom to re-pin).
+Finished runs replay from the journal exactly as before.
+
+
 
 The #62 tail of SPEC-6-5: `subagent({ cwd })` now scopes **background and scheduled** runs too, not just foreground —
 
@@ -336,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": "0.16.0",
+  "version": "1.1.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/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/spawnSubagent.ts

@@ -132,6 +132,10 @@ export interface SpawnOptions {
   visionPort?: VisionPort;
   signal?: AbortSignal;
   onEvent?: (e: ChildSessionEvent) => void;
+  /** SPEC-6-4: pre-minted runId (RPC spawn replies before the detached spawn resolves). Absent → mint. */
+  runId?: string;
+  /** SPEC-6-4: dispatch origin for RunMetaEvent.mode. Default "foreground". */
+  mode?: "foreground" | "background" | "scheduled" | "workflow";
   /** SPEC-4: when set, this spawn is a lifecycle phase child. It links to this lifecycle todo
    *  (not creates a new one) and finishRun skips mark-done/revert — the lifecycle engine owns
    *  the lifecycle todo's status + progress block. */
@@ -154,6 +158,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
@@ -241,13 +249,13 @@ export async function spawnSubagent(opts: SpawnOptions): Promise<SpawnResult> {
   const readOnly = opts.readOnly ?? false;
   let runId: string;
   if (readOnly) {
-    runId = genRunId();
+    runId = opts.runId ?? genRunId();
   } else {
     // #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();
+    runId = opts.runId ?? genRunId();
     const acq = await opts.lock.acquire(runId);
     if (!acq.ok) {
       const hint = opts.lock.cap === 1
@@ -331,7 +339,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 ?? [],
@@ -401,7 +410,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: childCwd, sessionCwd: 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, mode: opts.mode ?? "foreground", pid: (session as { proc?: { pid?: number } }).proc?.pid });
         } catch { /* best-effort */ }
       } else if (e.type === "turn_start") {
         turnIdx++;

package/src/index.ts

@@ -8,7 +8,7 @@ import {
   getAgentDir,
 } from "@earendil-works/pi-coding-agent";
 import type { Model } from "@earendil-works/pi-ai";
-import { createSubagentTool, 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";
@@ -40,6 +40,8 @@ import { ResultsInbox } from "./runtime/results-inbox.ts";
 import { runBackground, type AsyncRunnerDeps } from "./runtime/async-runner.ts";
 import { scanResumeCandidates } from "./runtime/resume.ts";
 import { RunLog } from "./runtime/run-log.ts";
+import { FleetEventBus } from "./rpc/event-bus.ts";
+import { RpcServer } from "./rpc/rpc-server.ts";
 import { reconcileRuns } from "./runtime/reconcile.ts";
 import { Scheduler } from "./scheduling/scheduler.ts";
 import { createFleetResultsTool } from "./tools/fleet-results.ts";
@@ -50,6 +52,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";
@@ -263,6 +266,9 @@ export default async function (pi: ExtensionAPI): Promise<void> {
   // SPEC-5b-2: the live widget (above editor) controller.
   // Display-only, independent of the /fleet panel; constructed per-session in session_start.
   let fleetWidget: FleetWidgetController | null = null;
+  // SPEC-6-4: hoisted so session_shutdown can dispose the bus + unsubscribe fleet:rpc.
+  let fleetBus: FleetEventBus | null = null;
+  let unsubscribeRpc: (() => void) | null = null;
   // SPEC-6-3: hoisted so /fleet command handler + session_shutdown can reach them.
   let wfController: WorkflowController | null = null;
   let wfStore: WorkflowRunStore | null = null;
@@ -289,6 +295,7 @@ export default async function (pi: ExtensionAPI): Promise<void> {
       ...(isolated ? { artifactDiscovery: ({ finalText, cwd, baseRef }: { finalText: string; cwd: string; baseRef: string }) => (deps.asyncRunner as AsyncRunnerDeps).diff.diffPhase(cwd, baseRef, finalText) } : {}),
       spawn: withModelFallbackRetry(async (o) => spawnSubagent({
         agent: o.agent, task: o.task, lifecycleTodoId: o.lifecycleTodoId, model: o.model,
+        mode: opts.fleetMode ?? "background",
         skillsOverride: o.skills, backendOverride: o.backend,
         registry: deps.registry, todoSync: deps.todoSync, runRegistry: deps.runRegistry, lock: bgLock,
         backendRegistry: deps.backendRegistry, parentModel: deps.parentModel,
@@ -298,7 +305,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;
@@ -359,6 +367,9 @@ export default async function (pi: ExtensionAPI): Promise<void> {
     // SPEC-5b-1: per-session RunLog at .pi/fleet/conversations/ (separate from the
     // SPEC-5a phase journal at .pi/fleet/runs/ — different granularity, no filename collision).
     deps.runLog = new RunLog(join(dir, "conversations"));
+    // SPEC-6-4: ONE shared RunJournal per session — the FleetEventBus subscribes to THIS
+    // instance, so every journal append (phases AND bookends) reaches the bus exactly once.
+    const fleetJournal = new RunJournal(join(dir, "runs"));
     // v0.10.2: pass the in-memory RunRegistry so reconcile syncs it too — otherwise orphaned
     // (process-gone) runs keep status:"running" in memory and the live widget shows a stale ▶ forever.
     // #22 bg-watchdog: pass todoSync so a process-gone run's linked TODO is reverted to open
@@ -378,7 +389,7 @@ export default async function (pi: ExtensionAPI): Promise<void> {
       // service would create it from the session's repo — the #62 gap). Same-cwd → shared.
       worktreeFor: (cwd: string) => (cwd === ctx.cwd ? sessionWorktree : new WorktreeService({ rootDir: cwd })),
       diff: new DiffService(),
-      journal: new RunJournal(join(dir, "runs")),
+      journal: fleetJournal,
       pool: new ConcurrencyPool(3),
       inbox: resultsInbox,
       runLifecycle: asyncRunLifecycle,
@@ -392,7 +403,7 @@ export default async function (pi: ExtensionAPI): Promise<void> {
       lockPath: join(dir, "schedules.lock"),
       onFire: (spec) => {
         if (!deps.asyncRunner) return;
-        runBackground(spec.task, { deps: deps.asyncRunner, lifecycle: spec.lifecycle ?? "default", mode: spec.auto ? "auto" : "checkpointed", isolation: spec.isolation, cwd: spec.cwd });
+        runBackground(spec.task, { deps: deps.asyncRunner, lifecycle: spec.lifecycle ?? "default", mode: spec.auto ? "auto" : "checkpointed", isolation: spec.isolation, cwd: spec.cwd, origin: "scheduled" });
       },
     });
     deps.scheduler.start();
@@ -400,6 +411,159 @@ export default async function (pi: ExtensionAPI): Promise<void> {
     if (cands.length > 0) {
       ctx.ui.notify(`${cands.length} interrupted fleet run${cands.length > 1 ? "s" : ""} — open /fleet to resume`, "info");
     }
+    // SPEC-6-4: defensive re-entrancy — a re-entered session_start must dispose the old
+    // bus/listener BEFORE constructing new ones (dispose-after-construction kills the fresh
+    // bus at birth and orphans the previous session's subscriptions).
+    fleetBus?.dispose();
+    fleetBus = null;
+    unsubscribeRpc?.();
+    unsubscribeRpc = null;
+    // SPEC-6-4: FleetEventBus — store appends → public fleet:* events on pi.events.
+    fleetBus = new FleetEventBus({
+      runLog: deps.runLog,
+      journal: fleetJournal,
+      emit: (channel, payload) => { pi.events.emit(channel, payload); },
+    });
+    // SPEC-6-4: fleet:rpc request surface — replies on fleet:rpc:result (null replies dropped).
+    const rpcServer = new RpcServer({
+      runRegistry: deps.runRegistry,
+      runLog: deps.runLog,
+      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: 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");
+          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,
+            track: params.track === true,
+            model: typeof params.model === "string" ? params.model : undefined,
+            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,
+            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(() => {});
+      },
+    });
+    unsubscribeRpc = pi.events.on("fleet:rpc", (data: unknown) => {
+      void rpcServer.handle(data).then((reply) => {
+        if (reply) pi.events.emit("fleet:rpc:result", reply);
+      });
+    });
     // SPEC-5b-2: live widget (above editor). Display-only, independent
     // of the /fleet panel. getTheme is a live getter (EditorTheme gotcha). Disposed on session end.
     const getModelContextWindow = (m: string): number | undefined => {
@@ -436,6 +600,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({
@@ -458,6 +632,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); },
@@ -501,6 +676,11 @@ export default async function (pi: ExtensionAPI): Promise<void> {
   });
 
   pi.on("session_shutdown", () => {
+    // SPEC-6-4: dispose the event bus + unsubscribe fleet:rpc before the other resets.
+    fleetBus?.dispose();
+    fleetBus = null;
+    unsubscribeRpc?.();
+    unsubscribeRpc = null;
     if (fleetWidget) { fleetWidget.dispose(); fleetWidget = null; }
     // SPEC-6-3: abort in-flight workflow children via the session-wide adapter signal.
     // Terminal runs are not re-journaled — only non-terminal spawns observe the abort.
@@ -582,10 +762,12 @@ export default async function (pi: ExtensionAPI): Promise<void> {
         ...deps.lifecycleDeps,
         spawn: withModelFallbackRetry(async (o) => spawnSubagent({
           agent: o.agent, task: o.task, lifecycleTodoId: o.lifecycleTodoId, model: o.model,
+          mode: "workflow",
             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
+          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,13 +9,14 @@ 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";
 import { messageBody, toolBody, messageHeader, toolHeader } from "./conversation-rows.ts";
 import { buildRunsIndex } from "./runs-index.ts";
 import type { RunLog, RunMeta, RunLogEvent, MessageEvent, ToolEvent } from "../runtime/run-log.ts";
+import { LiveTimelineState } from "./live-timeline.ts";
 import type { Scheduler, Schedule } from "../scheduling/scheduler.ts";
 import type { BgRunsStore } from "./bg-runs-store.ts";
 import { spawnSubagent, type SpawnResult } from "../engine/spawnSubagent.ts";
@@ -45,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>;
@@ -132,6 +136,43 @@ export class FleetPanel extends Container {
    * so the panel re-renders the moment a (fore- or back-ground) run mutates, without a keypress. */
   private readonly unsubs: (() => void)[] = [];
   private closed = false;   // SPEC-5a proper-fix: guard against double-close calling onDone twice
+  // SPEC-6-4: live mode for the timeline overlay (running runs stream; finished runs replay).
+  private liveUnsub: (() => void) | null = null;
+  private liveState: LiveTimelineState | null = null;
+
+  private renderedTimelineCount(): number {
+    return (this.runTimeline ?? []).filter((e) => e.type === "message" || e.type === "tool").length;
+  }
+
+  /** SPEC-6-4: release the live subscription (overlay close / different run / panel close). */
+  private releaseLiveTimeline(): void {
+    this.liveUnsub?.();
+    this.liveUnsub = null;
+    this.liveState = null;
+  }
+
+  /** SPEC-6-4: shared timeline-open (Runs view + gate evidence). Hydrates replay; LIVE when the
+   *  run is still running — subscribes to appends and tail-follows via LiveTimelineState. */
+  private openRunTimeline(runId: string): void {
+    const runLog = this.deps.runLog;
+    if (!runLog) return;
+    const meta = buildRunsIndex(runLog.dir).find((r) => r.runId === runId) ?? null;
+    this.selectedRun = meta;
+    this.runTimeline = runLog.replay(runId);
+    this.releaseLiveTimeline();
+    if (meta?.status === "running") {
+      this.liveState = new LiveTimelineState();
+      this.liveState.index = Math.max(0, this.renderedTimelineCount() - 1);
+      this.liveUnsub = runLog.subscribe((rid, ev) => {
+        if (rid !== runId || (ev.type !== "message" && ev.type !== "tool")) return;
+        this.runTimeline = [...(this.runTimeline ?? []), ev];
+        const idx = this.liveState?.append(this.renderedTimelineCount());
+        this.selectedEventIndex = idx ?? null;
+        this.renderShell();
+      });
+    }
+    this.renderShell();
+  }
   // SPEC-6-3: Workflows view — inline Run prompt input state
   private wfRunMode = false;
   private wfPromptInput: Input | null = null;
@@ -205,6 +246,8 @@ export class FleetPanel extends Container {
     this.closed = true;
     for (const u of this.unsubs) u();
     this.unsubs.length = 0;
+    // SPEC-6-4: the live timeline subscription dies with the panel.
+    this.releaseLiveTimeline();
     this.onDone(intent ?? null);
   }
 
@@ -324,7 +367,7 @@ export class FleetPanel extends Container {
           this.selectedEventIndex = null;
         }
         // esc → back to Runs list (replaces the v0.6.0 panel-level escape catch).
-        tl.onCancel = () => { this.selectedRun = null; this.runTimeline = null; this.timelineList = null; this.renderShell(); };
+        tl.onCancel = () => { this.releaseLiveTimeline(); this.selectedRun = null; this.runTimeline = null; this.timelineList = null; this.renderShell(); };
         this.timelineList = tl;
         this.addChild(tl);
       }
@@ -443,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") {
@@ -512,8 +556,7 @@ export class FleetPanel extends Container {
           .flatMap((p) => p.gateResults ?? [])
           .find((gr) => gr.runId);
         if (agentGate?.runId && this.deps.runLog) {
-          this.selectedRun = buildRunsIndex(this.deps.runLog.dir).find((r) => r.runId === agentGate.runId) ?? null;
-          this.runTimeline = this.deps.runLog.replay(agentGate.runId);
+          this.openRunTimeline(agentGate.runId);
           this.selectedLifecycle = null;
           this.view = "runs";
           this.renderShell();
@@ -555,8 +598,17 @@ export class FleetPanel extends Container {
       return;
     }
     if (this.selectedRun) {
-      // SPEC-5b-3: forward to the timeline SelectList (arrows scroll; enter via onSelect opens the
-      // overlay; esc via onCancel returns to the Runs list). v0.6.0 swallowed all non-escape keys.
+      // SPEC-6-4: in live mode the panel owns up/down (tail-follow cursor) — intercepted before
+      // the SelectList forward; everything else forwards as before. Finished runs: replay path.
+      if (this.liveState && (matchesKey(data, "up") || matchesKey(data, "down"))) {
+        const total = this.renderedTimelineCount();
+        const key = matchesKey(data, "up") ? "up" : "down";
+        if (this.liveState.onKey(key, total)) {
+          this.selectedEventIndex = this.liveState.index;
+          this.renderShell();
+        }
+        return;
+      }
       this.timelineList?.handleInput(data);
       this.invalidate();
       return;
@@ -645,9 +697,7 @@ export class FleetPanel extends Container {
       if (matchesKey(data, "enter") || matchesKey(data, "i")) {
         const sel = this.list.getSelectedItem();
         if (sel) {
-          this.selectedRun = buildRunsIndex(this.deps.runLog.dir).find((r) => r.runId === sel.value) ?? null;
-          this.runTimeline = this.deps.runLog.replay(sel.value);
-          this.renderShell();
+          this.openRunTimeline(sel.value);
         }
         return;
       }
@@ -1071,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();
@@ -1110,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();
@@ -1182,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,
         });
       },