@getpipher/armory-fleet 0.14.0 → 0.16.0

package/README.md

@@ -123,22 +123,22 @@ export const meta = {
 }
 
 phase('Plan')
-const plan = await agent('Plan this feature: ' + args.task, { tier: 'low' })
+const plan = await agent('Plan this feature: ' + args.task, { tier: 'economy' })
 
 phase('Implement')
-const impl = await agent(`Implement the plan:\n${plan}`, { tier: 'medium' })
+const impl = await agent(`Implement the plan:\n${plan}`, { tier: 'standard' })
 
 phase('Review')
 const angles = ['security', 'performance', 'correctness']
 const reviews = await parallel(
-  angles.map((a) => () => agent(`Review the implementation for ${a} issues.`, { tier: 'low' })),
+  angles.map((a) => () => agent(`Review the implementation for ${a} issues.`, { tier: 'economy' })),
 )
 
 // gate: revise the synthesis until it passes a validator
 const synthesis = await gate(
   async (_feedback, n) => n === 0
-    ? agent(`Synthesize ${reviews.length} reviews.`, { tier: 'low' })
-    : agent('Revise synthesis per feedback.', { tier: 'low' }),
+    ? agent(`Synthesize ${reviews.length} reviews.`, { tier: 'economy' })
+    : agent('Revise synthesis per feedback.', { tier: 'economy' }),
   (v) => typeof v === 'string' && v.length > 200 ? { ok: true } : { ok: false, feedback: 'more detail' },
   { attempts: 3 },
 )
@@ -236,9 +236,21 @@ Composite helpers (`src/workflows/helpers/`) — usable from any workflow:
 
 | Tier | Models | Cost cap | Context floor |
 |---|---|---|---|
-| `economy` | `Ollama/minimax-m3:cloud` | — | — |
-| `standard` | `Ollama/glm-5.2:cloud`, `Ollama/minimax-m3:cloud` | — | — |
-| `frontier` | `anthropic/claude-sonnet-4`, `Ollama/glm-5.2:cloud` | $5 | 200k ctx |
+| `economy` | `inherit` | — | — |
+| `standard` | `inherit` | — | — |
+| `frontier` | `inherit` | — | 200k ctx |
+
+The shipped defaults use the **`inherit` sentinel** — each tier resolves to your **active session model**, so tier routing works on any provider out of the box. To route across models, override a tier by name with a concrete `provider/id` chain in `~/.pi/agent/fleet/tiers.json` (global) or `<project>/.pi/fleet/tiers.json` (project):
+
+```json
+[
+  { "name": "economy",  "models": ["Ollama/minimax-m3:cloud"] },
+  { "name": "standard", "models": ["Ollama/glm-5.2:cloud", "inherit"] },
+  { "name": "frontier", "models": ["anthropic/claude-sonnet-4"], "costCap": 5, "contextFloor": 200000 }
+]
+```
+
+Models are an ordered fallback chain (primary first; a spawn retries the next candidate if model creation is rejected); the `inherit` sentinel (case-insensitive) may appear anywhere in the chain as a provider-agnostic fallback and always resolves to the session model without catalog or floor checks. `contextFloor` skips catalog models below the window size; `costCap` aborts a run whose live cost exceeds the cap (a no-op on flat subscriptions). Tier routing applies to pi-backend agents — `backend: "claude"` agents receive the resolved string via `--model` and the claude CLI expects its own model names, so route those by `model:` instead.
 
 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.
 
@@ -314,7 +326,24 @@ Every workflow run is **journaled** (`workflows/journal.ts`) and **resumable**.
 - **`userMemory` default flip:** the global cross-project user memory scope (`/__armory-fleet-user__`) is no longer hydrated by default. If you populated that dir + relied on it, add `userMemory: true` to the agent frontmatter (only meaningful with `memoryHydrate: true`). TS consumers constructing `AgentDef` literals must now include `userMemory: boolean` (required field; use `false` for the old default behavior).
 - **Lifecycle `cwd` field:** lifecycles accept an optional `cwd` frontmatter field to pin a target repo; absent → the entry-point cwd (the panel's chosen cwd, or the dispatching `subagent` tool's cwd/session cwd). When present, it overrides the entry-point cwd for all phases.
 - **Panel Run-action:** a 3rd `cwd` input step (task → name → cwd), prefilled with the session cwd; Enter accepts, Escape cancels.
-- **Deferred:** bg/scheduled + worktree cwd-isolation (the `cwd` param is honored by foreground dispatches only for now) — tracked in #62.
+- **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)
+
+The #62 tail of SPEC-6-5: `subagent({ cwd })` now scopes **background and scheduled** runs too, not just foreground —
+
+- **bg/scheduled cwd** — in-place bg runs pass the dispatch cwd as the lifecycle entry cwd (full context scoping: cascade, skills, memory); schedules persist the pinned cwd and honor it on every fire.
+- **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.
+
+## Provider-agnostic tiers (v0.15.0)
+
+Small-backlog batch (issues #57/#63/#64/#65):
+
+- **Tier `inherit` sentinel (#64)** — builtin tiers no longer hardcode a provider: `economy`/`standard`/`frontier` now resolve to your **active session model** out of the box (frontier keeps its 200k context floor; the $5 cost cap moved to the override example — a no-op on flat subs). Override by name in `tiers.json` with concrete `provider/id` chains for real multi-model routing; `inherit` can appear mid-chain as a provider-agnostic fallback. See [Cost-aware tiers](#cost-aware-tiers).
+- **Self-correcting model errors (#57)** — dispatching with a model the runtime doesn't have now lists the session's available (authed) models in the error, so the orchestrating model can pick a valid one on the retry instead of guessing.
+- **Panel Escape semantics documented + dead code removed (#63)** — Escape always cancels the active panel flow; defaults are accepted via Enter-on-blank. (Also fixed: ctrl+c could trigger the never-documented "escape accepts default" callbacks.)
+- **README example tier names fixed (#65)** — the `ship-feature` example now uses real tier names (`economy`/`standard`).
 
 ## Dogfood reliability (v0.14.0)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpipher/armory-fleet",
-  "version": "0.14.0",
+  "version": "0.16.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/index.ts

@@ -109,6 +109,26 @@ async function buildDefaultBackendRegistry(modelRuntime: ModelRuntime): Promise<
   return reg;
 }
 
+/**
+ * Format the runtime's available models for the #57 self-correcting error message:
+ * dedup `provider/id` pairs, cap the list (min 1 — a non-empty input always lists
+ * something), actionable hint when empty.
+ */
+export function formatAvailableModels(models: readonly { provider: string; id: string }[], cap = 12): string {
+  const effectiveCap = Math.max(1, cap);
+  const seen = new Set<string>();
+  const list: string[] = [];
+  for (const m of models) {
+    const ref = `${m.provider}/${m.id}`;
+    if (seen.has(ref)) continue;
+    seen.add(ref);
+    if (list.length < effectiveCap) list.push(ref);
+  }
+  if (list.length === 0) return "(none — check provider auth / models.json)";
+  const omitted = seen.size - list.length;
+  return list.join(", ") + (omitted > 0 ? ` … +${omitted} more` : "");
+}
+
 export function createChildSessionFactory(modelRuntime: ModelRuntime, memoryPort: MemoryHydratePort, resumeStore: ResumeStore): ChildSessionFactory {
   return {
     async create(opts) {
@@ -119,7 +139,13 @@ export function createChildSessionFactory(modelRuntime: ModelRuntime, memoryPort
         const provider = opts.model.slice(0, slash);
         const id = opts.model.slice(slash + 1);
         model = modelRuntime.getModel(provider, id);
-        if (!model) throw new Error(`agent model '${opts.model}' not found in runtime (provider '${provider}', id '${id}')`);
+        // #57: name what IS usable so the orchestrating model can self-correct on retry.
+        if (!model) {
+          throw new Error(
+            `agent model '${opts.model}' not found in runtime (provider '${provider}', id '${id}'). ` +
+            `Available: ${formatAvailableModels(modelRuntime.getAvailableSnapshot())} — pick one of these for the model param`,
+          );
+        }
       }
       // Fleet CustomResourceLoader: noExtensions + composed systemPromptOverride (rolePrompt + memory + base) + scoped skills.
       const loader = buildChildLoader({ cwd: opts.cwd, agent: opts.agent, memoryPort });
@@ -267,10 +293,14 @@ export default async function (pi: ExtensionAPI): Promise<void> {
         registry: deps.registry, todoSync: deps.todoSync, runRegistry: deps.runRegistry, lock: bgLock,
         backendRegistry: deps.backendRegistry, parentModel: deps.parentModel,
         parentCwd: isolated ? opts.worktreePath! : deps.parentCwd,
+        // #62: in-place bg runs honor the lifecycle cwd resolution (lifecycle.cwd ?? entryCwd);
+        // isolated runs pin the phase cwd to the worktree. parentCwd stays the SESSION cwd for
+        // 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),
     };
-    const res = await runLifecycle(task, lifecycleName, { deps: lifecycleFullDeps, mode: opts.mode, worktreePath: opts.worktreePath, baseRef: "HEAD", onCheckpoint: async (p) => p.status === "failed" ? { action: "abort" } : { action: "continue" } });
+    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;
   };
   // asyncRunnerDeps + scheduler are built per-session (need the session cwd); wired on session_start.
@@ -340,8 +370,13 @@ export default async function (pi: ExtensionAPI): Promise<void> {
           ctx.ui.notify(`reconciled ${reconciled.length} interrupted fleet run${reconciled.length > 1 ? "s" : ""} (marked aborted; linked TODOs reverted to open)`, "info");
         }
       });
+    const sessionWorktree = new WorktreeService({ rootDir: ctx.cwd });
     deps.asyncRunner = {
-      worktree: new WorktreeService({ rootDir: ctx.cwd }),
+      worktree: sessionWorktree,
+      // #62: cross-cwd bg dispatches get a per-dispatch worktree service rooted at the dispatch
+      // cwd, so isolation:'worktree' creates the worktree from the CHILD's repo (the session
+      // 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")),
       pool: new ConcurrencyPool(3),
@@ -357,7 +392,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 });
+        runBackground(spec.task, { deps: deps.asyncRunner, lifecycle: spec.lifecycle ?? "default", mode: spec.auto ? "auto" : "checkpointed", isolation: spec.isolation, cwd: spec.cwd });
       },
     });
     deps.scheduler.start();

package/src/panel/fleet-panel.ts

@@ -425,10 +425,8 @@ export class FleetPanel extends Container {
       this.linkInput.onSubmit = (todoIdRaw: string) => {
         void this.executeRun(agentName, task.trim(), todoIdRaw.trim() || undefined);
       };
-      this.linkInput.onEscape = () => { void this.executeRun(agentName, task.trim(), undefined); };
       this.renderShell();
     };
-    this.taskInput.onEscape = () => this.cancelRun();
     this.runMode = true;
     this.renderShell();
   }
@@ -492,6 +490,12 @@ export class FleetPanel extends Container {
   }
 
   handleInput(data: string): void {
+    // Escape policy (#63): every modal branch below intercepts Escape BEFORE the active Input
+    // sees it, so pi-tui's Input.onEscape never fires in this panel — Escape always cancels
+    // the active flow. Defaults are accepted via Enter-on-blank ("blank=default" prompts).
+    // Caveat: ctrl+c also matches pi-tui's tui.select.cancel but is NOT intercepted here —
+    // it forwards to the Input, which ignores control characters (silent no-op). An onEscape
+    // callback re-added later would fire on ctrl+c but never on Escape — do not re-add.
     if (this.infoAgent) {
       if (matchesKey(data, "escape")) { this.infoAgent = null; this.renderShell(); }
       return;
@@ -811,13 +815,13 @@ export class FleetPanel extends Container {
           this.pendingCheckpoint = null;
           this.renderShell();
         };
-        this.lcReviseInput.onEscape = () => { this.lcRevising = false; this.lcReviseInput = null; this.renderShell(); };
         this.renderShell();
         return;
       }
     }
     if (this.lcRevising && this.lcReviseInput) {
-      if (matchesKey(data, "escape")) { this.lcRevising = false; this.lcReviseInput = null; this.renderShell(); return; }
+      // Escape never reaches here — the panel-level intercept above resolves the pending
+      // checkpoint as abort + closes the panel first (#63). Only printable input forwards.
       this.lcReviseInput.handleInput(data);
       this.invalidate();
       return;
@@ -842,13 +846,10 @@ export class FleetPanel extends Container {
           const lcName = name.trim() || "default";
           this.executeScheduleAdd(task.trim(), expr.trim(), lcName);
         };
-        this.schedNameInput.onEscape = () => { this.executeScheduleAdd(task.trim(), expr.trim(), "default"); };
         this.renderShell();
       };
-      this.schedExprInput.onEscape = () => this.cancelScheduleAdd();
       this.renderShell();
     };
-    this.schedTaskInput.onEscape = () => this.cancelScheduleAdd();
     this.schedRunMode = true;
     this.renderShell();
   }
@@ -892,7 +893,6 @@ export class FleetPanel extends Container {
       if (!followUp.trim()) { this.cancelResume(); return; }
       void this.executeResume(run, followUp.trim());
     };
-    this.resumeInput.onEscape = () => this.cancelResume();
     this.resumeMode = true;
     this.renderShell();
   }
@@ -916,7 +916,6 @@ export class FleetPanel extends Container {
       if (!text.trim()) { this.cancelSteer(); return; }
       void this.executeSteer(run.runId, text.trim());
     };
-    this.steerInput.onEscape = () => this.cancelSteer();
     this.steerMode = true;
     this.renderShell();
   }
@@ -969,7 +968,6 @@ export class FleetPanel extends Container {
     }
     this.tiersInput = new Input();
     this.tiersInput.onSubmit = (value: string) => { void this.executeTiersEdit(value, phase); };
-    this.tiersInput.onEscape = () => this.cancelTiersEdit();
     this.tiersEditPhase = phase;
     this.renderShell();
   }
@@ -995,7 +993,6 @@ export class FleetPanel extends Container {
       }
       this.cancelWorkflowRun();
     };
-    this.wfPromptInput.onEscape = () => this.cancelWorkflowRun();
     this.wfRunMode = true;
     this.renderShell();
   }
@@ -1097,10 +1094,8 @@ export class FleetPanel extends Container {
       this.linkInput.onSubmit = (todoIdRaw: string) => {
         void this.executeFork(run.agent, finalTask, todoIdRaw.trim() || undefined, run.runId);
       };
-      this.linkInput.onEscape = () => { void this.executeFork(run.agent, finalTask, undefined, run.runId); };
       this.renderShell();
     };
-    this.taskInput.onEscape = () => this.cancelRun();
     this.runMode = true;
     this.renderShell();
   }
@@ -1134,19 +1129,16 @@ export class FleetPanel extends Container {
         const lcName = name.trim() || "default";
         this.lcPhase = "cwd";
         this.lcCwdInput = new Input();
-        // SPEC-6-5: 3rd input step — the dispatch cwd. Prefilled with the session cwd; Enter
-        //  accepts it, Escape accepts the default (mirrors the name step's Escape-accepts-default).
+        // SPEC-6-5: 3rd input step — the dispatch cwd. Enter accepts the session cwd (blank)
+        // or a typed path; Escape cancels the run (panel-level intercept — #63).
         this.lcCwdInput.onSubmit = (cwd: string) => {
           const picked = cwd.trim() || this.deps.parentCwd;
           void this.executeLifecycleRun(task.trim(), lcName, picked);
         };
-        this.lcCwdInput.onEscape = () => { void this.executeLifecycleRun(task.trim(), lcName, this.deps.parentCwd); };
         this.renderShell();
       };
-      this.lcNameInput.onEscape = () => { void this.executeLifecycleRun(task.trim(), "default", this.deps.parentCwd); };
       this.renderShell();
     };
-    this.lcTaskInput.onEscape = () => this.cancelLifecycleRun();
     this.lcRunMode = true;
     this.renderShell();
   }

package/src/runtime/async-runner.ts

@@ -26,6 +26,9 @@ export interface RunLifecycleOpts {
   worktreePath?: string;
   branch?: string;
   mode: "auto" | "checkpointed";
+  /** #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;
 }
 
 export type RunLifecycleFn = (task: string, lifecycleName: string, opts: RunLifecycleOpts) => Promise<FakeLifecycleResult>;
@@ -43,6 +46,11 @@ export interface AsyncRunnerDeps {
   onProgress?: (runId: string, status: import("../panel/rows.ts").BgRunStatus) => void;
   /** SPEC-6-2: the RunRegistry so emitProgress can read the run's actual backend. */
   runRegistry?: import("../engine/run-registry.ts").RunRegistry;
+  /** #62: per-dispatch worktree service for cross-cwd bg runs (rootDir = the dispatch cwd).
+   *  Consulted whenever a bg dispatch carries a `cwd`; absent → deps.worktree (session-scoped,
+   *  pre-#62 behavior). index.ts wires it so a cross-cwd worktree is created from the CHILD's
+   *  repo, not the session's. */
+  worktreeFor?: (cwd: string) => WorktreeService;
 }
 
 export interface RunBackgroundOpts {
@@ -51,6 +59,10 @@ export interface RunBackgroundOpts {
   mode: "auto" | "checkpointed";
   /** v0.11.1: edit isolation for background runs. Default "auto" (worktree when cwd is a git repo, in-place otherwise). */
   isolation?: Isolation;
+  /** #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. */
+  cwd?: string;
 }
 
 /** The success shape (back-compat: existing external refs to RunBackgroundHandle still typecheck). */
@@ -82,9 +94,16 @@ function sh(cmd: string, cwd: string): void {
   execSync(cmd, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
 }
 
+/** #62: the worktree service for a dispatch — per-dispatch (rootDir = the dispatch cwd) when
+ *  deps.worktreeFor is wired, else the session-scoped deps.worktree (back-compat). */
+function worktreeFor(deps: AsyncRunnerDeps, cwd?: string): WorktreeService {
+  if (!cwd) return deps.worktree;
+  return deps.worktreeFor?.(cwd) ?? deps.worktree;
+}
+
 /** The git-agnostic core: pool slot → journal → runLifecycle in ctx.cwd (or a worktree, when `isolated` is set) → inbox + notify.
  *  Fire-and-forget. When `isolated` is present, journals the worktree field, commits on completion, and removes the worktree. */
-function runBackgroundInPlace(runId: string, task: string, opts: RunBackgroundOpts, isolated?: { worktreePath: string; branch: string }): void {
+function runBackgroundInPlace(runId: string, task: string, opts: RunBackgroundOpts, isolated?: { worktreePath: string; branch: string }, worktree: WorktreeService = opts.deps.worktree): void {
   const { deps } = opts;
   void deps.pool.withSlot(async () => {
     try {
@@ -94,7 +113,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 });
+      const res = await deps.runLifecycle(task, opts.lifecycle, { runId, worktreePath: isolated?.worktreePath, branch: isolated?.branch, mode: opts.mode, entryCwd: isolated ? isolated.worktreePath : opts.cwd });
 
       if (res.status === "completed") {
         if (isolated) {
@@ -116,17 +135,17 @@ function runBackgroundInPlace(runId: string, task: string, opts: RunBackgroundOp
         };
         deps.inbox.push(result);
         deps.notify(`fleet run ${runId} completed`, "info");
-        if (isolated) deps.worktree.removeWorktree(runId);
+        if (isolated) worktree.removeWorktree(runId);
       } else {
         deps.journal.append(runId, { type: "run:aborted", runId, reason: res.error ?? res.status, ts: Date.now() });
-        if (isolated) deps.worktree.remove(runId);
+        if (isolated) worktree.remove(runId);
         emitProgress(deps, runId, { status: "failed", phase: "", phaseIndex: 0, phaseTotal: res.phases.length, lifecycle: opts.lifecycle, mode: opts.mode, task });
         deps.notify(`fleet run ${runId} ${res.status}: ${res.error ?? ""}`, "warning");
       }
     } catch (e) {
       const msg = (e as Error).message;
       deps.journal.append(runId, { type: "run:aborted", runId, reason: msg, ts: Date.now() });
-      if (isolated) deps.worktree.remove(runId);
+      if (isolated) worktree.remove(runId);
       deps.notify(`fleet run ${runId} failed: ${msg}`, "error");
       emitProgress(deps, runId, { status: "failed", phase: "", phaseIndex: 0, phaseTotal: 0, lifecycle: opts.lifecycle, mode: opts.mode, task });
     }
@@ -135,34 +154,34 @@ function runBackgroundInPlace(runId: string, task: string, opts: RunBackgroundOp
 
 /** The worktree wrapper: SYNCHRONOUS pre-flight + worktree create, then core-with-isolation. */
 function runBackgroundIsolated(task: string, opts: RunBackgroundOpts): RunBackgroundResult {
-  const { deps } = opts;
-  if (!deps.worktree.isGitRepo()) {
+  const worktree = worktreeFor(opts.deps, opts.cwd);
+  if (!worktree.isGitRepo()) {
     return { status: "failed", error: "isolation: 'worktree' requires a git repo; cwd is not one — use isolation: 'none' or run in a git repo" };
   }
-  const runId = deps.genRunId();
+  const runId = opts.deps.genRunId();
   const baseRef = "HEAD";
   let wt: { path: string; branch: string };
   try {
-    wt = deps.worktree.create(runId, baseRef);
+    wt = worktree.create(runId, baseRef);
   } catch (e) {
     return { status: "failed", error: (e as Error).message };
   }
-  runBackgroundInPlace(runId, task, opts, { worktreePath: wt.path, branch: wt.branch });
+  runBackgroundInPlace(runId, task, opts, { worktreePath: wt.path, branch: wt.branch }, worktree);
   return { runId, status: "background" };
 }
 
-/** The auto router: isolated when cwd is a git repo, in-place + one per-session notify when not. */
+/** The auto router: isolated when the DISPATCH cwd is a git repo, in-place + one per-session notify when not. */
 function runBackgroundAuto(task: string, opts: RunBackgroundOpts): RunBackgroundResult {
-  const { deps } = opts;
-  if (deps.worktree.isGitRepo()) {
+  const worktree = worktreeFor(opts.deps, opts.cwd);
+  if (worktree.isGitRepo()) {
     return runBackgroundIsolated(task, opts);
   }
   if (!inPlaceFallbackWarned) {
     inPlaceFallbackWarned = true;
-    deps.notify("background run in-place (no worktree isolation — parallel edits may conflict)", "warning");
+    opts.deps.notify("background run in-place (no worktree isolation — parallel edits may conflict)", "warning");
   }
-  const runId = deps.genRunId();
-  runBackgroundInPlace(runId, task, opts);
+  const runId = opts.deps.genRunId();
+  runBackgroundInPlace(runId, task, opts, undefined, worktreeFor(opts.deps, opts.cwd));
   return { runId, status: "background" };
 }
 
@@ -172,7 +191,7 @@ export function runBackground(task: string, opts: RunBackgroundOpts): RunBackgro
   if (isolation === "worktree") return runBackgroundIsolated(task, opts);
   if (isolation === "none") {
     const runId = opts.deps.genRunId();
-    runBackgroundInPlace(runId, task, opts);
+    runBackgroundInPlace(runId, task, opts, undefined, worktreeFor(opts.deps, opts.cwd));
     return { runId, status: "background" };
   }
   return runBackgroundAuto(task, opts);

package/src/scheduling/scheduler.ts

@@ -13,6 +13,8 @@ export interface ScheduleSpec {
   auto?: boolean;
   /** v0.11.1: edit isolation for the background run on fire. Default "auto". */
   isolation?: "worktree" | "none" | "auto";
+  /** #62: the dispatch target cwd (undefined = session cwd). Threaded to runBackground on fire. */
+  cwd?: string;
 }
 
 export interface Schedule extends ScheduleSpec {
@@ -74,6 +76,7 @@ export class Scheduler {
       lifecycle: spec.lifecycle ?? "default",
       auto: spec.auto ?? true,
       isolation: spec.isolation,
+      ...(spec.cwd ? { cwd: spec.cwd } : {}),
       paused: false,
     };
     this.schedules.set(id, { spec: stored, expr, timer: null });
@@ -90,6 +93,7 @@ export class Scheduler {
       lifecycle: e.spec.lifecycle,
       auto: e.spec.auto,
       isolation: e.spec.isolation,
+      ...(e.spec.cwd ? { cwd: e.spec.cwd } : {}),
       paused: e.spec.paused,
       nextFire: e.spec.paused ? null : e.expr.nextFire(new Date()),
     }));

package/src/tiers/builtin.ts

@@ -1,8 +1,17 @@
 import type { Tier } from "./tier-registry.ts";
 
-/** Shipped default tiers (Q10). Overridable via global/project tiers.json. */
+/**
+ * Shipped default tiers (Q10). Overridable via global/project tiers.json.
+ *
+ * Provider-agnostic since #64: the `inherit` sentinel resolves to the parent/active
+ * session model, so zero-config fleets work on ANY provider. Users who want real
+ * multi-model cost routing override these by name with concrete `provider/id`
+ * chains (`inherit` may also appear mid-chain as a fallback). `contextFloor`
+ * guards concrete candidates; `costCap` is a per-run $ abort (configure where
+ * meaningful — it is a no-op on flat subscriptions).
+ */
 export const BUILTIN_TIERS: Tier[] = [
-  { name: "economy",  models: ["Ollama/minimax-m3:cloud"] },
-  { name: "standard", models: ["Ollama/glm-5.2:cloud", "Ollama/minimax-m3:cloud"] },
-  { name: "frontier", models: ["anthropic/claude-sonnet-4", "Ollama/glm-5.2:cloud"], costCap: 5, contextFloor: 200000 },
-];
+  { name: "economy",  models: ["inherit"] },
+  { name: "standard", models: ["inherit"] },
+  { name: "frontier", models: ["inherit"], contextFloor: 200000 },
+];

package/src/tiers/resolve.ts

@@ -34,6 +34,20 @@ export function resolveAgentModel(
     if (!tier) return { error: `tier '${agent.tier}' not found; available: ${tiers.list().map((t) => t.name).join(", ")}` };
     const candidates: string[] = [];
     for (const m of tier.models) {
+      if (m.trim().toLowerCase() === "inherit") {
+        // #64: "inherit" = use the parent/active model — always eligible, no catalog or
+        // contextFloor check (the session model is presumed appropriate; the floor guards
+        // concrete candidates). Participates in the chain: eligible concrete models listed
+        // before it win; after them it acts as the provider-agnostic fallback.
+        // Sentinel is case-insensitive/trimmed; concrete model strings stay verbatim.
+        // Empty parentModel (dispatch before a session model exists) is NOT pushed — a
+        // pure-inherit tier then falls to the descriptive no-eligible-model error below.
+        if (parentModel.provider || parentModel.id) {
+          const parent = `${parentModel.provider}/${parentModel.id}`;
+          if (!candidates.includes(parent)) candidates.push(parent);
+        }
+        continue;
+      }
       const { provider, id } = splitModel(m, parentModel.provider);
       const model = modelRegistry.find(provider, id);
       if (!model) continue;                                              // not in catalog → skip

package/src/tools/subagent.ts

@@ -131,13 +131,13 @@ export function createSubagentTool(deps: SubagentToolDeps) {
       }
       if (params.schedule) {
         if (!deps.scheduler) return { isError: true, content: [{ type: "text" as const, text: "scheduling not configured (scheduler missing)" }] };
-        const id = deps.scheduler.register({ task: params.task, expression: params.schedule, lifecycle: params.lifecycle ?? "default", auto: params.auto ?? true, isolation: params.isolation });
+        const id = deps.scheduler.register({ task: params.task, expression: params.schedule, lifecycle: params.lifecycle ?? "default", auto: params.auto ?? true, isolation: params.isolation, cwd: resolvedCwd });
         const entry = deps.scheduler.list().find((s) => s.id === id);
         return { content: [{ type: "text" as const, text: `scheduled: ${id} · next fire: ${entry?.nextFire?.toISOString() ?? "(paused)"}` }], details: { scheduleId: id, nextFire: entry?.nextFire ?? null } };
       }
       if (params.background) {
         if (!deps.asyncRunner) return { isError: true, content: [{ type: "text" as const, text: "background runs not configured (asyncRunner missing)" }] };
-        const handle = runBackground(params.task, { deps: deps.asyncRunner, lifecycle: params.lifecycle ?? "default", mode: "auto", isolation: params.isolation });
+        const handle = runBackground(params.task, { deps: deps.asyncRunner, lifecycle: params.lifecycle ?? "default", mode: "auto", isolation: params.isolation, cwd: resolvedCwd });
         if (handle.status === "failed") return { isError: true, content: [{ type: "text" as const, text: handle.error }] };
         return { content: [{ type: "text" as const, text: `background run: ${handle.runId}` }], details: handle };
       }