@getpipher/armory-fleet 1.0.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:
@@ -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.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

@@ -158,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
@@ -335,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 ?? [],

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, 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";
@@ -52,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";
@@ -304,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;
@@ -429,33 +431,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 +529,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 +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({
@@ -543,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); },
@@ -677,6 +767,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/rpc/rpc-server.ts

@@ -40,6 +40,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 +87,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 +111,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 +139,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) {

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/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 => {