@getpipher/armory-fleet 1.1.0 → 1.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpipher/armory-fleet",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "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/session-rejection.ts

@@ -0,0 +1,23 @@
+// src/engine/session-rejection.ts
+// #84: typed rejections for the live-session control path (steer/abort). The RPC verbs
+// previously classified failures by fragile message-substring matching; the handles now
+// throw this class and the verbs match on `reason` first. Message TEXT is unchanged at
+// the existing throw sites — string matching survives as a back-compat fallback for
+// third-party ChildSession implementations that bubble bare Errors.
+export type SessionRejectionReason =
+  | "steer-unsupported"   // the backend has no steer (e.g. claude children)
+  | "already-processing"  // the session is mid-turn and cannot take the steer now
+  | "already-aborted";    // the session was already stopped
+
+export class SessionRejectionError extends Error {
+  readonly reason: SessionRejectionReason;
+  constructor(reason: SessionRejectionReason, message: string) {
+    super(message);
+    this.name = "SessionRejectionError";
+    this.reason = reason;
+  }
+}
+
+export function isSessionRejection(e: unknown): e is SessionRejectionError {
+  return e instanceof SessionRejectionError;
+}

package/src/engine/spawnSubagent.ts

@@ -7,6 +7,7 @@ import type { BackendRegistry } from "../backend/port.ts";
 import { genRunId, RunRegistry } from "./run-registry.ts";
 import type { RunRecord } from "./run-registry.ts";
 import { createTurnBudget, DEFAULT_MAX_TURNS } from "./turn-budget.ts";
+import { SessionRejectionError } from "./session-rejection.ts";
 import type { ForegroundLock } from "./concurrency-lock.ts";
 import type { RunLog } from "../runtime/run-log.ts";
 import { buildToolEvent } from "../runtime/run-log.ts";
@@ -83,7 +84,7 @@ export interface LiveSessionHandle {
  *  `supportsSteer` is derived from whether the backend implemented the optional `steer`. */
 export function toLiveHandle(session: ChildSession): LiveSessionHandle {
   return {
-    steer: (text) => session.steer ? session.steer(text) : Promise.reject(new Error("steer not supported on this backend")),
+    steer: (text) => session.steer ? session.steer(text) : Promise.reject(new SessionRejectionError("steer-unsupported", "steer not supported on this backend")),
     abort: () => session.abort(),
     subscribe: (h) => session.subscribe(h),
     get isStreaming() { return session.isStreaming ?? false; },
@@ -205,7 +206,7 @@ export interface SpawnResult {
 /** #49: extract file paths a tool event touched, for the structured partial-result report.
  *  edit/write carry a `path` arg reliably; bash is best-effort (redirections `>`/`>>` + `tee` to a
  *  path-like token). Reads are NOT mutations and are excluded. */
-function extractTouchedFiles(toolName: string, args: unknown): string[] {
+export function extractTouchedFiles(toolName: string, args: unknown): string[] {
   if (!args || typeof args !== "object") return [];
   const a = args as Record<string, unknown>;
   // Case-insensitive: pi tools are lowercase ("edit"), claude's are capitalized ("Edit").
@@ -223,19 +224,41 @@ function extractTouchedFiles(toolName: string, args: unknown): string[] {
     const redir = />>?\s+([^\s|;&<>]+)/g;
     let m: RegExpExecArray | null;
     while ((m = redir.exec(cmd)) !== null) {
-      const tok = m[1];
-      if (tok && /[/.]/.test(tok)) out.push(tok);
+      const tok = m[1] ? shapeToken(m[1]) : undefined;
+      if (tok) out.push(tok);
     }
     const tee = /\btee\s+(?:-a\s+)?([^\s|;&<>]+)/g;
     while ((m = tee.exec(cmd)) !== null) {
-      const tok = m[1];
-      if (tok && /[/.]/.test(tok)) out.push(tok);
+      const tok = m[1] ? shapeToken(m[1]) : undefined;
+      if (tok) out.push(tok);
     }
     return out;
   }
   return [];
 }
 
+/** #87: decide whether a redirect/tee capture is plausibly a file path. The bare `/[/.]/`
+ *  test false-positived on `>` characters inside quoted strings/heredocs/code text
+ *  ("cache.load(name,,", "[...active],,") and swallowed trailing punctuation from code-y
+ *  commands ("/tmp/out.txt),"). Now: strip wrapping quotes, trim trailing punctuation,
+ *  then require a real path shape (contains `/`, or a dotted filename, or a leading-dot
+ *  file like .gitignore). */
+function shapeToken(raw: string): string | undefined {
+  let tok = raw.trim().replace(/^["']+/, "");
+  // trailing junk can interleave ("'/tmp/x.txt',") — strip quotes+punct until stable
+  let prev: string;
+  do {
+    prev = tok;
+    tok = tok.replace(/["',;)\]}]+$/g, "");
+  } while (tok !== prev);
+  if (!tok) return undefined;
+  if (/^\/dev\/(null|stdout|stderr|stdin|tty|zero)$/.test(tok)) return undefined; // pseudo-devices, not touched files
+  if (tok.includes("/")) return tok;
+  if (/^\.[A-Za-z0-9._-]+$/.test(tok)) return tok;            // .gitignore and friends
+  if (/^[A-Za-z0-9._-]+\.[A-Za-z0-9]+$/.test(tok)) return tok; // name.ext
+  return undefined;
+}
+
 export async function spawnSubagent(opts: SpawnOptions): Promise<SpawnResult> {
   const track = opts.track ?? true;
   const maxTurns = opts.maxTurns ?? DEFAULT_MAX_TURNS;
@@ -328,7 +351,10 @@ export async function spawnSubagent(opts: SpawnOptions): Promise<SpawnResult> {
       priorStatus = link.priorStatus;
       opts.runRegistry.update(runId, { todoId });
     } catch (e) {
-      return await finishRun(opts, runId, startedAt, "failed", "", todoId, priorStatus, (e as Error).message, agentDef.name, model);
+      return await finishRun({
+      opts, runId, startedAt, status: "failed", finalText: "", todoId, priorStatus,
+      error: (e as Error).message, agentName: agentDef.name, model,
+    });
     }
 
     // SPEC-6-1: fallback retry loop — try candidates[0], on rejection retry candidates[1], etc.
@@ -354,7 +380,10 @@ export async function spawnSubagent(opts: SpawnOptions): Promise<SpawnResult> {
       } catch (e) { lastErr = e as Error; }
     }
     if (!session) {
-      return await finishRun(opts, runId, startedAt, "failed", "", todoId, priorStatus, `backend create failed: ${lastErr?.message ?? "unknown"}`, agentDef.name, model, 0, 0, 0);
+      return await finishRun({
+      opts, runId, startedAt, status: "failed", finalText: "", todoId, priorStatus,
+      error: `backend create failed: ${lastErr?.message ?? "unknown"}`, agentName: agentDef.name, model,
+    });
     }
 
     // SPEC-5b-4: retain a narrow live-session handle on the run record so the panel can
@@ -559,7 +588,12 @@ export async function spawnSubagent(opts: SpawnOptions): Promise<SpawnResult> {
       status = "completed";
     }
 
-    return await finishRun(opts, runId, startedAt, status, finalText, todoId, priorStatus, error, agentDef.name, model, tokenTotal, costTotal, contextTokens, modelError ? true : undefined, filesTouchedList, reachedSummary, toolCallCount);
+    return await finishRun({
+      opts, runId, startedAt, status, finalText, todoId, priorStatus, error,
+      agentName: agentDef.name, model, tokenTotal, costTotal, contextTokens,
+      retryable: modelError ? true : undefined, filesTouched: filesTouchedList,
+      reachedSummary, toolCallCount,
+    });
   } finally {
     // #31: a readOnly dispatch never acquired the lock — don't release what it didn't take
     // (releasing a lock held by another concurrent write dispatch would corrupt serialization).
@@ -577,13 +611,34 @@ function fail(runId: string, startedAt: number, message: string, agent: string):
 /** SPEC-6-2: guard against double-finishRun (abort-then-complete). */
 const finalizedRunIds = new Set<string>();
 
-async function finishRun(
-  opts: SpawnOptions, runId: string, startedAt: number,
-  status: FleetRunStatus, finalText: string, todoId: string | null, priorStatus: string | undefined,
-  error: string | undefined, agentName: string, model: string, tokenTotal = 0, costTotal = 0, contextTokens = 0,
-  retryable?: boolean,
-  filesTouched?: string[], reachedSummary?: boolean, toolCallCount = 0,
-): Promise<SpawnResult> {
+/** #NIT: options object — was 17 positional params (3 call sites, error-prone at the tail). */
+interface FinishRunArgs {
+  opts: SpawnOptions;
+  runId: string;
+  startedAt: number;
+  status: FleetRunStatus;
+  finalText: string;
+  todoId: string | null;
+  priorStatus?: string;
+  error?: string;
+  agentName: string;
+  model: string;
+  tokenTotal?: number;
+  costTotal?: number;
+  contextTokens?: number;
+  retryable?: boolean;
+  filesTouched?: string[];
+  reachedSummary?: boolean;
+  toolCallCount?: number;
+}
+
+async function finishRun(a: FinishRunArgs): Promise<SpawnResult> {
+  const { opts, runId, startedAt, status, finalText, todoId, priorStatus, error, agentName, model } = a;
+  const tokenTotal = a.tokenTotal ?? 0;
+  const costTotal = a.costTotal ?? 0;
+  const contextTokens = a.contextTokens ?? 0;
+  const toolCallCount = a.toolCallCount ?? 0;
+  const { retryable, filesTouched, reachedSummary } = a;
   if (finalizedRunIds.has(runId)) {
     // Already finalized — return the existing registry record's result without re-appending.
     const existing = opts.runRegistry.get(runId);

package/src/index.ts

@@ -12,6 +12,7 @@ import { createSubagentTool, mergeLifecycleSkills, resolveDispatchCwd, type Suba
 // 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";
+import { SessionRejectionError } from "./engine/session-rejection.ts";
 import { createSingleSlotLock, createForegroundLock } from "./engine/concurrency-lock.ts";
 import { ArmoryTodoAdapter } from "./todo-sync/adapter.ts";
 import { ArmoryMemoryAdapter } from "./memory-hydrate/adapter.ts";
@@ -83,7 +84,8 @@ function wrapPiSession(inner: ChildSession, backendSessionId: string): ChildSess
       return inner.subscribe(handler);
     },
     // SPEC-5b-4: forward the native SDK steer + isStreaming to the real pi session.
-    steer: (t) => inner.steer ? inner.steer(t) : Promise.reject(new Error("pi session has no steer")),
+    // #84: typed rejection (message text unchanged — back-compat with string matching).
+    steer: (t) => inner.steer ? inner.steer(t) : Promise.reject(new SessionRejectionError("steer-unsupported", "pi session has no steer")),
     get isStreaming() { return inner.isStreaming ?? false; },
   };
 }

package/src/panel/rows.ts

@@ -1,4 +1,5 @@
 // src/panel/rows.ts
+import { basename } from "node:path";
 import type { AgentDef } from "../registry/frontmatter.ts";
 import type { FleetRunStatus } from "../todo-sync/port.ts";
 import type { RunRecord } from "../engine/run-registry.ts";
@@ -140,6 +141,8 @@ export interface ScheduleRow {
   task: string;
   nextFire: Date | null;
   paused: boolean;
+  /** #62: pinned dispatch cwd — rendered as a ↗ basename so cross-cwd schedules are visible. */
+  cwd?: string;
 }
 
 export function scheduleRow(s: ScheduleRow): string {
@@ -147,7 +150,8 @@ export function scheduleRow(s: ScheduleRow): string {
   const next = s.nextFire ? `next: ${s.nextFire.toLocaleString()}` : "paused";
   const task = s.task.length > 24 ? s.task.slice(0, 23) + "…" : s.task;
   const lc = s.lifecycle ?? "default";
-  return `${icon}  ${s.expression}  ${lc}  "${task}"  ${next}  ${s.id}`;
+  const cwd = s.cwd ? `  ↗${basename(s.cwd)}` : "";
+  return `${icon}  ${s.expression}  ${lc}  "${task}"${cwd}  ${next}  ${s.id}`;
 }
 
 const LC_GLYPH: Record<LifecycleStatus, string> = {

package/src/panel/runs-rows.ts

@@ -16,9 +16,13 @@ export function runsRow(r: RunMeta, getModelContextWindow?: (model: string) => n
   const maxCtx = getModelContextWindow?.(r.model);
   const ctx = (r.contextTokens != null && maxCtx != null && maxCtx > 0) ? `  ${Math.round(r.contextTokens / maxCtx * 100)}%` : "";
   const cost = r.costTotal ? `  $${r.costTotal.toFixed(4)}` : "";
+  // #59/#60/#61 NIT: the journal fields v0.14.0 added to run:ended, now visible in the list.
+  const err = r.error ? `  ✗"${r.error.length > 60 ? r.error.slice(0, 59) + "…" : r.error}"` : "";
+  const tools = r.toolCallCount != null ? `  ·${r.toolCallCount}t` : "";
+  const files = r.filesTouched?.length ? `  ✎${r.filesTouched.length}` : "";
   const summary = r.resultSummary ? `  "${r.resultSummary}"` : "";
   const prov = r.resumedFrom ? `  ← resumed:${r.resumedFrom}` : r.forkedFrom ? `  ← forked:${r.forkedFrom}` : "";
-  return `${STATUS_GLYPH[r.status]} ${r.runId}  ${r.agent}  ${r.status}  ${dur}${tok}${ctx}${cost}${summary}${prov}`;
+  return `${STATUS_GLYPH[r.status]} ${r.runId}  ${r.agent}  ${r.status}  ${dur}${tok}${ctx}${cost}${tools}${files}${err}${summary}${prov}`;
 }
 
 export function runTimelineRow(e: MessageEvent | ToolEvent): string {

package/src/panel/widget-rows.ts

@@ -119,7 +119,13 @@ function widgetLine(r: WidgetRun, now: number): string {
   const label = r.task ? `"${r.task.slice(0, 40)}"` : r.runId;
   // SPEC-6-5: cross-cwd glyph — when the run's cwd differs from the session cwd, mark it so the
   // operator sees "this run is scoped to a different project" at a glance. Same-cwd → no glyph.
-  const crossCwd = (r.cwd && r.sessionCwd && r.cwd !== r.sessionCwd) ? `  ↗${basename(r.cwd)}` : "";
+  // #62 NIT: isolated runs pin cwd to <child-cwd>/.pi/fleet/worktrees/<runId> — the basename
+  // was the cryptic run-id. Strip the worktrees suffix so the glyph names the TARGET repo dir.
+  const displayCwd = (cwd: string): string => {
+    const wt = cwd.indexOf("/.pi/fleet/worktrees/");
+    return wt > 0 ? basename(cwd.slice(0, wt)) : basename(cwd);
+  };
+  const crossCwd = (r.cwd && r.sessionCwd && r.cwd !== r.sessionCwd) ? `  ↗${displayCwd(r.cwd)}` : "";
   const agentSeg = r.agent && r.agent !== "general-purpose" ? `  · ${r.agent}` : "";
   // #23: liveness — only after LIVENESS_THRESHOLD_MS, to keep short runs concise (per acceptance).
   // turn N/max + last-event class (no prompt content, no args/results — only the tool name)

package/src/rpc/rpc-server.ts

@@ -7,6 +7,7 @@ import type { RunRegistry, RunRecord } from "../engine/run-registry.ts";
 import type { RunLog } from "../runtime/run-log.ts";
 import type { RunJournal } from "../runtime/run-journal.ts";
 import { resolveDispatchCwd } from "../tools/subagent.ts";
+import { isSessionRejection } from "../engine/session-rejection.ts";
 
 export type RpcErrorCode =
   | "E-CONTROL-DISABLED" | "E-RUN-NOT-FOUND" | "E-RUN-FINISHED" | "E-BAD-VERB"
@@ -183,8 +184,12 @@ export class RpcServer {
       if (!rec) return this.err(id, "E-RUN-NOT-FOUND", `no live run '${p.runId}' in the registry (finished runs older than the session are not listed)`);
       return { id, ok: true, data: { runs: [summarize(rec)] } };
     }
-    const runs = this.deps.runRegistry.list().slice(0, LIST_CAP).map(summarize);
-    return { id, ok: true, data: { runs } };
+    const runs = this.deps.runRegistry.list();
+    const capped = runs.slice(0, LIST_CAP).map(summarize);
+    // #84: surface the omitted count so RPC consumers know the list is partial. Absent
+    // when everything fit (additive field — consumers check presence, not falseness).
+    const truncated = runs.length - capped.length;
+    return { id, ok: true, data: truncated > 0 ? { runs: capped, truncated } : { runs: capped } };
   }
 
   private observeVerb(id: string, params: unknown): RpcReply {
@@ -251,6 +256,9 @@ export class RpcServer {
     try {
       await session.steer(p.message);
     } catch (e) {
+      // #84: typed rejections match by reason; string matching survives as a back-compat
+      // fallback for third-party ChildSession implementations that bubble bare Errors.
+      if (isSessionRejection(e) && e.reason === "steer-unsupported") return this.err(id, "E-STEER-UNSUPPORTED", e.message);
       const msg = (e as Error).message ?? "steer failed";
       if (msg.includes("not supported")) return this.err(id, "E-STEER-UNSUPPORTED", msg);
       return this.err(id, "E-INTERNAL", `steer failed: ${msg}`);
@@ -269,6 +277,8 @@ export class RpcServer {
     try {
       await session.abort();
     } catch (e) {
+      // #84: typed first (reason-based), string fallback for bare-Error handles.
+      if (isSessionRejection(e) && (e.reason === "already-aborted" || e.reason === "already-processing")) return this.err(id, "E-RUN-FINISHED", e.message);
       const msg = (e as Error).message ?? "abort failed";
       if (msg.includes("already")) return this.err(id, "E-RUN-FINISHED", msg);
       return this.err(id, "E-INTERNAL", `abort failed: ${msg}`);

package/src/runtime/run-log.ts

@@ -61,6 +61,12 @@ export interface RunMeta {
   cwd?: string;
   /** SPEC-6-5: the session cwd the dispatch originated from (= parentCwd). */
   sessionCwd?: string;
+  /** #59 NIT: the failure reason on failed runs (from run:ended). */
+  error?: string;
+  /** #61 NIT: executed-tool count (the zero-work signal). */
+  toolCallCount?: number;
+  /** #60 NIT: file paths the run mutated. */
+  filesTouched?: string[];
 }
 
 const ARGS_LIMIT = 200;
@@ -145,6 +151,8 @@ export class RunLog {
         meta.resultSummary = ended.resultSummary; meta.tokenTotal = ended.tokenTotal;
         meta.resumedFrom = ended.resumedFrom; meta.forkedFrom = ended.forkedFrom;
         meta.costTotal = ended.costTotal; meta.contextTokens = ended.contextTokens;
+        // #59/#60/#61 NIT: surface the newer journal fields to the Runs tab too.
+        meta.error = ended.error; meta.toolCallCount = ended.toolCallCount; meta.filesTouched = ended.filesTouched;
       }
       out.push(meta);
     }