@getpipher/armory-fleet 0.5.1 → 0.5.2

package/package.json

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

@@ -170,6 +170,13 @@ export default async function (pi: ExtensionAPI): Promise<void> {
   const asyncRunLifecycle: AsyncRunnerDeps["runLifecycle"] = async (task, lifecycleName, opts) => {
     const { runLifecycle } = await import("./lifecycle/run-lifecycle.ts");
     const { spawnSubagent } = await import("./engine/spawnSubagent.ts");
+    // SPEC-5a §8.1 (Q4=A): bg runs must NOT compete with the foreground single-slot lock.
+    // The ConcurrencyPool gates bg-RUN concurrency (N-slot); within a run the lifecycle loop
+    // serializes phases, so a fresh per-run lock just satisfies spawnSubagent's tryAcquire API
+    // without ever contending (foreground holds deps.lock; bg holds its own). Without this, a
+    // foreground subagent holding deps.lock made every bg run's first-phase spawn fail fast
+    // (tryAcquire → "concurrency lock unexpectedly unavailable" → 6ms run:aborted).
+    const bgLock = createSingleSlotLock();
     const lifecycleFullDeps: LifecycleRunDeps = {
       ...deps.lifecycleDeps,
       genRunId: () => opts.runId,   // override: use the async runner's runId
@@ -178,7 +185,7 @@ export default async function (pi: ExtensionAPI): Promise<void> {
       spawn: async (o) => spawnSubagent({
         agent: o.agent, task: o.task, lifecycleTodoId: o.lifecycleTodoId, model: o.model,
         skillsOverride: o.skills, backendOverride: o.backend,
-        registry: deps.registry, todoSync: deps.todoSync, runRegistry: deps.runRegistry, lock: deps.lock,
+        registry: deps.registry, todoSync: deps.todoSync, runRegistry: deps.runRegistry, lock: bgLock,
         backendRegistry: deps.backendRegistry, parentModel: deps.parentModel, parentCwd: opts.worktreePath,  // child runs in the worktree
       }),
     };

package/src/lifecycle/run-lifecycle.ts

@@ -203,7 +203,13 @@ export async function runLifecycle(task: string, lifecycleName: string, opts: Li
         // A failed phase that's aborted = lifecycle failed (the work failed); a healthy phase
         // aborted at a checkpoint = user-aborted (§12).
         const status: LifecycleStatus = phaseRec.status === "failed" ? "failed" : "aborted";
-        return doneResult(runId, startedAt, status, lifecycleName, task, lifecycleBackend, opts.mode, phaseRecords, todoId);
+        // SPEC-5a fix: surface the failed phase's summary as the lifecycle error so the async
+        // runner's run:aborted journal event + notify show the real cause (spawnRes.error etc.),
+        // not just the bare status. Guard on non-empty summary so an empty summary still falls
+        // back to the status in the async runner (res.error ?? res.status). A healthy phase
+        // aborted at a checkpoint has no error.
+        const error = phaseRec.status === "failed" && phaseRec.summary ? phaseRec.summary : undefined;
+        return doneResult(runId, startedAt, status, lifecycleName, task, lifecycleBackend, opts.mode, phaseRecords, todoId, error);
       }
       // decision.action === "revise"
       reviseCount++;

package/src/worktree/diff-service.ts

@@ -8,6 +8,13 @@ export interface PhaseArtifacts {
   summary: string;
 }
 
+/** SPEC-5a robustness: the error variant when the worktree git state is corrupted (e.g. child
+ *  ran rm -rf .git). runLifecycle treats this as a failed phase (clean abort) instead of an
+ *  unhandled throw. Matches the artifactDiscovery union in run-lifecycle.ts. */
+export interface PhaseArtifactsError {
+  error: string;
+}
+
 function sh(cmd: string, cwd: string): string {
   return execSync(cmd, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).toString();
 }
@@ -22,11 +29,19 @@ export class DiffService {
    *
    * @param childFinalText  the child's final text, truncated to MAX_SUMMARY chars as the prose summary.
    */
-  diffPhase(worktreePath: string, baseRef: string, childFinalText = ""): PhaseArtifacts {
-    const tracked = sh(`git diff --name-only ${baseRef} --`, worktreePath)
-      .split("\n")
-      .filter(Boolean);
-    const status = sh("git status --porcelain", worktreePath);
+  diffPhase(worktreePath: string, baseRef: string, childFinalText = ""): PhaseArtifacts | PhaseArtifactsError {
+    // SPEC-5a robustness: a child can corrupt its worktree's git state (e.g. rm -rf .git,
+    // git init over the worktree link). Catch git failures + return {error} so runLifecycle
+    // treats it as a failed phase (clean abort with surfaced cause) instead of an unhandled
+    // throw crashing the async runner. Empty diff (no changes) is NOT an error — returns paths: [].
+    let tracked: string[] = [];
+    let status = "";
+    try {
+      tracked = sh(`git diff --name-only ${baseRef} --`, worktreePath).split("\n").filter(Boolean);
+      status = sh("git status --porcelain", worktreePath);
+    } catch (e) {
+      return { error: `worktree diff failed: ${(e as Error).message.split("\n").filter(Boolean).pop() ?? (e as Error).message}` };
+    }
     const untracked = status
       .split("\n")
       .filter((l) => l.startsWith("?? "))