@getpipher/armory-fleet 0.15.0 → 0.16.0

package/README.md

@@ -326,7 +326,15 @@ 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)
 

package/package.json

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

@@ -293,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.
@@ -366,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),
@@ -383,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/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/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 };
       }