@selesai/code 0.13.0 → 0.13.2

package/dist/extensions/pi-rewind-hook/index.ts

@@ -17,6 +17,8 @@ const RETENTION_SWEEP_THRESHOLD = 50;
 const RETENTION_VERSION = 2;
 const EMPTY_TREE_SHA = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
 
+class UnsupportedSubmoduleStateError extends Error {}
+
 type ExecFn = (cmd: string, args: string[]) => Promise<{ stdout: string; stderr: string; code: number }>;
 
 type GitExecResult = Awaited<ReturnType<ExecFn>>;
@@ -70,6 +72,11 @@ interface ExactState {
   treeSha: string;
 }
 
+interface GitlinkEntry {
+  path: string;
+  commitSha: string;
+}
+
 interface ActiveBranchState {
   currentCommitSha?: string;
   currentTreeSha?: string;
@@ -387,7 +394,7 @@ export default function rewindExtension(pi: ExtensionAPI) {
   let pendingTreeState: PendingResultingState | null = null;
   let activePromptText: string | null = null;
   let newSnapshotsSinceSweep = 0;
-  let sweepRunning = false;
+  let retentionSweep: Promise<void> | undefined;
   let sweepCompletedThisSession = false;
   let forceConversationOnlyOnNextFork = false;
   let forceConversationOnlySource: string | null = null;
@@ -461,6 +468,87 @@ export default function rewindExtension(pi: ExtensionAPI) {
     return repoRoot;
   }
 
+  async function getGitlinkEntries(treeSha: string, gitPrefix: string[] = []): Promise<GitlinkEntry[]> {
+    const result = await execGitChecked([...gitPrefix, "ls-tree", "-r", "-z", treeSha, "--"]);
+    return parseGitlinkEntries(result.stdout);
+  }
+
+  function parseGitlinkEntries(output: string): GitlinkEntry[] {
+    return output.split("\0").flatMap((record) => {
+      const separator = record.indexOf("\t");
+      if (separator < 0) return [];
+
+      const [mode, type, commitSha] = record.slice(0, separator).split(/\s+/);
+      if (mode !== "160000" || type !== "commit" || !commitSha) return [];
+      return [{ path: record.slice(separator + 1), commitSha }];
+    });
+  }
+
+  async function getIndexedGitlinkEntries(): Promise<GitlinkEntry[]> {
+    const result = await execGitChecked(["ls-files", "--stage", "-z"]);
+    return parseGitlinkEntries(result.stdout);
+  }
+
+  async function assertSubmoduleWorktreesClean(root: string, entries: GitlinkEntry[], action: string) {
+    for (const entry of entries) {
+      const submodulePath = resolve(root, entry.path);
+      if (!isInsidePath(submodulePath, root)) {
+        throw new UnsupportedSubmoduleStateError(`refusing ${action} for submodule path outside repo root: ${entry.path}`);
+      }
+
+      const status = await pi.exec("git", ["-C", submodulePath, "status", "--porcelain", "--untracked-files=all"]);
+      if (status.code !== 0) {
+        throw new UnsupportedSubmoduleStateError(`cannot ${action} with uninitialized submodule: ${entry.path}`);
+      }
+      if (status.stdout.trim()) {
+        throw new UnsupportedSubmoduleStateError(`cannot ${action} with dirty submodule: ${entry.path}`);
+      }
+    }
+  }
+
+  async function prepareSubmoduleRestore(root: string, currentEntries: GitlinkEntry[], targetEntries: GitlinkEntry[]) {
+    const currentPaths = new Set(currentEntries.map((entry) => entry.path));
+    const targetPaths = new Set(targetEntries.map((entry) => entry.path));
+    const changedPaths = [...new Set([...currentPaths, ...targetPaths])]
+      .filter((entryPath) => !currentPaths.has(entryPath) || !targetPaths.has(entryPath));
+    if (changedPaths.length > 0) {
+      throw new UnsupportedSubmoduleStateError(
+        `exact rewind does not support adding or removing submodules: ${changedPaths.join(", ")}`,
+      );
+    }
+
+    await assertSubmoduleWorktreesClean(root, currentEntries, "restore exact files");
+
+    const commitsToInspect = new Map<string, GitlinkEntry>();
+    for (const entry of [...currentEntries, ...targetEntries]) {
+      commitsToInspect.set(`${entry.path}\0${entry.commitSha}`, entry);
+    }
+
+    for (const entry of commitsToInspect.values()) {
+      const entryPath = entry.path;
+      const commitSha = entry.commitSha;
+      const submodulePath = resolve(root, entryPath);
+      const commit = await pi.exec("git", ["-C", submodulePath, "cat-file", "-e", `${commitSha}^{commit}`]);
+      if (commit.code !== 0) {
+        throw new UnsupportedSubmoduleStateError(
+          `cannot inspect submodule ${entryPath}: commit ${commitSha.slice(0, 12)} is unavailable locally`,
+        );
+      }
+
+      const targetTreeSha = (await execGitChecked(["-C", submodulePath, "show", "-s", "--format=%T", commitSha])).stdout.trim();
+      const nestedEntries = await getGitlinkEntries(targetTreeSha, ["-C", submodulePath]);
+      if (nestedEntries.length > 0) {
+        throw new UnsupportedSubmoduleStateError(`cannot restore nested submodules: ${entryPath}`);
+      }
+    }
+  }
+
+  async function restoreSubmodules(root: string, entries: GitlinkEntry[]) {
+    for (const entry of entries) {
+      await execGitChecked(["-C", resolve(root, entry.path), "checkout", "--detach", entry.commitSha]);
+    }
+  }
+
   async function captureWorktreeTree(): Promise<{ treeSha: string }> {
     const root = await getRepoRoot(pi.exec);
     const tempDir = await mkdtemp(join(tmpdir(), "pi-rewind-"));
@@ -470,7 +558,12 @@ export default function rewindExtension(pi: ExtensionAPI) {
       const env = { ...process.env, GIT_INDEX_FILE: tempIndex };
       await execAsync("git add -A", { cwd: root, env });
       const { stdout } = await execAsync("git write-tree", { cwd: root, env });
-      return { treeSha: stdout.trim() };
+      const treeSha = stdout.trim();
+      const entriesByPath = new Map<string, GitlinkEntry>();
+      for (const entry of await getIndexedGitlinkEntries()) entriesByPath.set(entry.path, entry);
+      for (const entry of await getGitlinkEntries(treeSha)) entriesByPath.set(entry.path, entry);
+      await assertSubmoduleWorktreesClean(root, [...entriesByPath.values()], "capture exact files");
+      return { treeSha };
     } finally {
       await rm(tempDir, { recursive: true, force: true }).catch(() => {
         // Best effort cleanup for temporary index directory.
@@ -542,19 +635,38 @@ export default function rewindExtension(pi: ExtensionAPI) {
       return "preserved-empty";
     }
 
-    let head: string | undefined;
-    for (const commitSha of uniqueLiveCommits) {
-      head = await createStoreKeepaliveCommit(commitSha, head);
-    }
+    let attempts = 0;
+    let lastError: unknown;
+    let preserveConcurrentHead = false;
+
+    while (attempts < 5) {
+      attempts += 1;
+      const oldHead = await getStoreHead();
+      // A failed compare-and-swap means another session added snapshots while
+      // this sweep was running. Preserve that new reachability and let a later
+      // uncontended sweep prune anything no longer retained.
+      let head = preserveConcurrentHead ? oldHead : undefined;
+      for (const commitSha of uniqueLiveCommits) {
+        head = await createStoreKeepaliveCommit(commitSha, head);
+      }
 
-    const oldHead = await getStoreHead();
-    if (oldHead) {
-      await execGitChecked(["update-ref", STORE_REF, head!, oldHead]);
-      return "rewritten";
+      try {
+        if (oldHead) {
+          await execGitChecked(["update-ref", STORE_REF, head!, oldHead]);
+        } else {
+          await execGitChecked(["update-ref", STORE_REF, head!, LEGACY_ZERO_SHA]);
+        }
+        return "rewritten";
+      } catch (error) {
+        // Retry if another process updated the store ref concurrently.
+        // Keep the most recent error for actionable failure context.
+        lastError = error;
+        preserveConcurrentHead = true;
+      }
     }
 
-    await execGitChecked(["update-ref", STORE_REF, head!, LEGACY_ZERO_SHA]);
-    return "rewritten";
+    const detail = lastError instanceof Error ? lastError.message : String(lastError);
+    throw new Error(`failed to rewrite rewind store ref: ${detail}`);
   }
 
   async function ensureSnapshotForTree(treeSha: string): Promise<string> {
@@ -606,6 +718,12 @@ export default function rewindExtension(pi: ExtensionAPI) {
     const { treeSha: currentTreeSha } = await captureWorktreeTree();
     const targetTreeSha = await getCommitTreeSha(targetCommitSha);
 
+    const currentSubmodules = await getGitlinkEntries(currentTreeSha);
+    const targetSubmodules = await getGitlinkEntries(targetTreeSha);
+    if (currentSubmodules.length > 0 || targetSubmodules.length > 0) {
+      await prepareSubmoduleRestore(repoRoot!, currentSubmodules, targetSubmodules);
+    }
+
     if (currentTreeSha === targetTreeSha) {
       lastExact = { commitSha: targetCommitSha, treeSha: targetTreeSha };
       return { changed: false, targetTreeSha };
@@ -615,6 +733,13 @@ export default function rewindExtension(pi: ExtensionAPI) {
     const pathsToDelete = await getDeletedPaths(currentTreeSha, targetTreeSha);
     await deletePathsFromWorkingTree(pathsToDelete);
     await execGitChecked(["restore", `--source=${targetCommitSha}`, "--worktree", "--", "."]);
+    if (targetSubmodules.length > 0) {
+      await restoreSubmodules(repoRoot!, targetSubmodules);
+      const { treeSha: restoredTreeSha } = await captureWorktreeTree();
+      if (restoredTreeSha !== targetTreeSha) {
+        throw new Error(`submodule restore did not produce target tree ${targetTreeSha}`);
+      }
+    }
     lastExact = { commitSha: targetCommitSha, treeSha: targetTreeSha };
     return { changed: true, undoCommitSha, targetTreeSha };
   }
@@ -964,13 +1089,13 @@ export default function rewindExtension(pi: ExtensionAPI) {
     if (reason === "new-snapshots" && newSnapshotsSinceSweep < RETENTION_SWEEP_THRESHOLD) return;
     if (reason === "shutdown" && sweepCompletedThisSession && newSnapshotsSinceSweep < RETENTION_SWEEP_THRESHOLD) return;
     if (!repoRoot) return;
-    if (sweepRunning) return;
-    sweepRunning = true;
-    try {
-      await runRetentionSweep(ctx, reason);
-    } finally {
-      sweepRunning = false;
-    }
+    // Session replacement invalidates ctx after session_shutdown resolves, so reuse
+    // the in-flight startup sweep and let shutdown await it before returning.
+    if (retentionSweep) return retentionSweep;
+    retentionSweep = runRetentionSweep(ctx, reason).finally(() => {
+      retentionSweep = undefined;
+    });
+    return retentionSweep;
   }
 
   async function runRetentionSweep(ctx: ExtensionContext, reason: "startup" | "new-snapshots" | "shutdown") {
@@ -1127,7 +1252,12 @@ export default function rewindExtension(pi: ExtensionAPI) {
     }
 
     await getRepoRoot(pi.exec);
-    await reconstructState(ctx);
+    try {
+      await reconstructState(ctx);
+    } catch (error) {
+      if (!(error instanceof UnsupportedSubmoduleStateError)) throw error;
+      notify(ctx, `Rewind unavailable: ${error.message}`, "warning");
+    }
     updateStatus(ctx);
     maybeSweepRetention(ctx, "startup").catch((error) => {
       notify(ctx, `Rewind retention startup sweep failed: ${error instanceof Error ? error.message : String(error)}`, "warning");
@@ -1151,7 +1281,7 @@ export default function rewindExtension(pi: ExtensionAPI) {
     const ctx = activeContext;
     if (!ctx) return;
 
-    checkpointEntry(ctx, data.entryId).catch((error) => {
+    return checkpointEntry(ctx, data.entryId).catch((error) => {
       notify(ctx, `Rewind: failed to checkpoint ${data.entryId} (${error instanceof Error ? error.message : String(error)})`, "warning");
     });
   });

package/dist/extensions/pi-rewind-hook/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-rewind-hook",
-  "version": "1.8.4",
+  "version": "1.8.6",
   "description": "Rewind extension for Pi agent - automatic git checkpoints with file/conversation restore",
   "repository": {
     "type": "git",
@@ -18,12 +18,14 @@
   "author": "nicobailon",
   "license": "MIT",
   "pi": {
-    "extensions": ["./index.ts"]
+    "extensions": [
+      "./index.ts"
+    ]
   },
   "scripts": {
     "test": "npx --yes tsx --tsconfig tsconfig.test.json --test index.test.ts"
   },
-  "devDependencies": {
+  "peerDependencies": {
     "@selesai/code": "*"
   }
 }

package/dist/extensions/pi-subagents/.oxlintrc.json

@@ -0,0 +1,43 @@
+{
+  "$schema": "./node_modules/oxlint/configuration_schema.json",
+  "ignorePatterns": [
+    ".agent/**",
+    ".agents/**",
+    ".claude/**",
+    ".codex/**",
+    ".continue/**",
+    ".cursor/**",
+    ".fallow/**",
+    ".gemini/**",
+    ".opencode/**",
+    ".pi/**",
+    ".roo/**",
+    ".windsurf/**",
+    "test/fixtures/pi-coding-agent-shim/dist/**",
+    "node_modules/**",
+    "tools/oxlint/anti-slop/**"
+  ],
+  "jsPlugins": [
+    {
+      "name": "anti-slop",
+      "specifier": "./tools/oxlint/anti-slop/index.ts"
+    }
+  ],
+  "rules": {
+    "anti-slop/no-chained-type-assertions": "error",
+    "anti-slop/no-conditional-empty-object-spread": "error",
+    "anti-slop/no-known-value-widening": "error",
+    "anti-slop/no-module-mocking": "error",
+    "anti-slop/no-object-parameters": "error",
+    "anti-slop/no-reflect-apply": "error",
+    "anti-slop/no-reflect-get": "error",
+    "anti-slop/no-runtime-typeof": "error",
+    "anti-slop/no-shape-in-symbol-names": "error",
+    "anti-slop/no-unknown-parameters": "error",
+    "anti-slop/no-unknown-returns": "error",
+    "anti-slop/no-unknown-type-aliases": "error",
+    "anti-slop/no-unsafe-dictionary-type": "error",
+    "anti-slop/no-widen-then-assert": "error",
+    "anti-slop/require-safety-comment-for-type-assertion": "error"
+  }
+}

package/dist/extensions/pi-subagents/AGENTS.md

@@ -0,0 +1,5 @@
+# AGENTS.md
+
+Agents working in this repository must read [VISION.md](VISION.md) before making product, architecture, scope, or backlog-disposition decisions.
+VISION.md is the acceptance policy for this project: use it to judge whether a proposed change, issue, or PR fits.
+This file intentionally does not duplicate user-global or tool-level instructions.

package/dist/extensions/pi-subagents/CHANGELOG.md

@@ -2,6 +2,163 @@
 
 ## [Unreleased]
 
+## [0.59.0] - 2026-08-28
+
+### Highlights
+- Run host commands from workflow scripts with safer saved output and clearer command results.
+- Build sequential parallel workflows with `runs.lanes(...)`, launch preflight labels, and better retained-resume behavior.
+- See cleaner async status, child labels, and worktree handoff details without extra setup.
+- Recover more reliably from stale contexts, provider aborts, missing outputs, malformed MCP metadata, and Windows file locks.
+- Control live workflow children from more places, including non-TUI and RPC hosts.
+
+### Added
+- Add `runs.host(...)` command steps to `workflowScript`, with required timeouts, saved output, and status and receipt evidence (#1648).
+- Add CI and gate monitor rows that record monitor kind, terminal verdict, freshness, and report pointers in workflow status and receipts.
+- Persist workflow lane metadata in child status, receipts, and existing worktree handoff manifests, including display-only worktree paths and branches.
+- Add `runs.lanes(...)` for parallel sequential workflow stages with per-lane results and retained-resume support (#1633).
+- Add display-only `preflight` lane metadata for workflowScript launches, with coverage warnings and planned-lane rendering in launch, status, and live-card views.
+- Add a plan-only `worktree.cleanup` management action that records a cleanup plan without removing worktrees or branches.
+- Give every subagent child session a human-readable display name, and include it in result, progress, status, workflow, nested, and intercom payloads. Thanks to [@yanqianglu](https://github.com/yanqianglu) for #1615.
+- Add `/subagents-steer <run-id> [--child <child-id>] <message>` so non-TUI sessions and RPC hosts can steer live async runs. Thanks to [@yanqianglu](https://github.com/yanqianglu) for #1608.
+- Add explicit `allowNestedSubagents` agent authorization for nested fanout without replacing inherited tools or extensions. Thanks to [@tutu359](https://github.com/tutu359) for #1587.
+- Accept a child id on `/subagents-stop <run-id> <child-id>` so one child of a multi-child async run can be stopped without stopping the whole run. Thanks to [@yanqianglu](https://github.com/yanqianglu) for #1603.
+
+### Changed
+- Reduce noisy launch, status, output, settings, and worktree cleanup messages without changing behavior.
+- Include a direct resumable child id in missing workflow receipt guidance when retained status proves it is safe.
+- Clarify `workflowScript` contracts for retained resume keys and durable child output paths.
+- Record merge or supersession evidence in existing worktree handoff manifests and show cleanup eligibility without removing anything.
+- Show optional lane and work-item context in async status rows, including phase, gate, next action, output, run reference, and stale or blocked state.
+- Show workflow child labels and phases in async status progress while preserving stable workflow keys.
+- Remove assistant turn budgets, including hard termination, wrap-up prompt injection, and launch configuration.
+- Split internal launch, status, settlement, evidence, and direct-MCP planning code into smaller modules without changing public behavior.
+
+### Fixed
+- Match detached workflow completion by exact child identity, keep host gate rows in snapshots, and report missing host verdicts as inconclusive.
+- Replace explicit `runs.host(...)` output files atomically inside their verified directory, and retry transient Windows destination locks.
+- Reject malformed MCP direct-tool server and metadata-cache fields when JSON is loaded.
+- Preserve live composite child tool-call ids for `cursor-native`, so Cursor MCP results keep matching pending execs. Thanks to [@moofone](https://github.com/moofone) for #1677 and #1678.
+- Ignore stale cached UI contexts during background status refresh and session lifecycle cleanup (#1670).
+- Compact workflow preflight status in default TUI and status views while keeping full details available when expanded (#1668).
+- Give `runs.lanes(...)` stage-0 retained-resume validation actionable `runs.run(...)` guidance instead of a generic error (#1657).
+- Remove the remaining `lane:` prefix from operator-facing async status rows in the TUI (#1658).
+- Allow scheduled project roots shared through a registered Git worktree's `.pi` symlink while rejecting unrelated or unproven Git-layout escapes. Thanks to [@sususu98](https://github.com/sususu98) for #1656.
+- Include delegated child usage in subagent tool results and `/subagent-cost`, including completed async workflow children and parent compaction usage with persisted workflow-receipt recovery when needed (#1662, #1666). Thanks to [@Geraldo-Morais](https://github.com/Geraldo-Morais) for #1662 and [@jf88888](https://github.com/jf88888) for #1666.
+- Avoid false preflight mismatch warnings for generated `runs.lanes(...)` stage keys (#1649).
+- Accept long host tool-call ids in workflow child summaries, matching the existing 4,096-byte session id bound. Thanks to [@SudoKillMe](https://github.com/SudoKillMe) for #1653.
+- Keep an async `workflowScript` continuation live while an awaited child coordinates with its supervisor, so later sequential steps still run (#1634).
+- Stop stale extension and slash-command contexts from escaping during reload or session replacement.
+- Include saved workflow child output paths and inline previews in completion notices (#1629).
+- Format million-scale context limits as `1M` instead of `1000k` in live status displays.
+- Restore active workflow children under their workflow parent in Fleet Status after reload, while keeping unmatched shell rows visible.
+- Prefer loaded workspace context over repeated internal workflow keys in async TUI lane rows (#1619).
+- Accept path-like Pi session ids up to 4,096 characters when snapshotting background work. Thanks to [@dvishoot](https://github.com/dvishoot) for #1616.
+- Accept bare leaf model ids reported by provider drivers when verifying provider-qualified launch candidates. Thanks to [@lallenlowe](https://github.com/lallenlowe) for #1609.
+- Resume compaction-induced child aborts once when retained state is safe, and report the exact recovery blocker otherwise.
+- Report aborted or signalled no-output child runs with their terminal stop, stderr, or process signal before missing-output handoff diagnostics.
+- Apply `globalConcurrencyLimit` to `workflowScript` children launched through `runs.run` and `runs.all`, not only legacy multi-child runners. Thanks to [@mateominato](https://github.com/mateominato) for #1600.
+- Ignore nested `.pi` and `sync-backups` directories during agent discovery so stale backup definitions cannot become executable agents. Thanks to [@arlishansenn](https://github.com/arlishansenn) for #1596.
+- Let projects layer agent overrides by the active parent model provider without duplicating agent definitions. Thanks to [@arichiardi](https://github.com/arichiardi) for #1597.
+- Let operators configure the default `subagent_wait` window and report window expiry as non-error active work while preserving strict headless draining. Thanks to [@Shujakuinkuraudo](https://github.com/Shujakuinkuraudo) for #1591.
+- Degrade run status to the stored fan-out budget snapshot when persisted state is unavailable, instead of failing the entire run list. Thanks to [@qsgy-edge](https://github.com/qsgy-edge) for #1595.
+- Enforce MCP server `includeTools` and `excludeTools` policies for child direct-tool grants, including adapter-compatible glob matching. Thanks to [@Shujakuinkuraudo](https://github.com/Shujakuinkuraudo) for #1590.
+- Prevent Fleet prompt audit rendering from crashing on malformed non-string task payloads. Thanks to [@bengidev](https://github.com/bengidev) for #1586.
+- Resume a retained child session once after a provider or transport abort follows useful progress, without restarting the task or involving the parent model.
+- Retry unused fallback models after a provider reports a plain-text `500` or `internal server error`. Thanks to [@rafafortes](https://github.com/rafafortes) for #1642.
+- Mark missing required child handoffs with useful mutation evidence as partial needs-attention results.
+
+## [0.58.0] - 2026-08-27
+
+### Highlights
+- Launch MCP tools from more places, including runtime-registered servers, Pi package manifests, and Agent Plugin configs.
+- Keep agent context smaller by default, with an explicit `inheritGlobalContext` opt-in when a child needs the operator's global context.
+- Make detached and recovered workflow results more reliable, with clearer terminal handoffs and recovery actions.
+- Show better launch and status diagnostics for workspace, authority, context-window, and missing-directory problems.
+- Keep fast OpenAI-Codex launches compatible with priority service tier without losing provider request fields.
+
+### Added
+- Support direct MCP tool launches from runtime-registered servers.
+- Add `inheritGlobalContext` agent configuration so children can opt into the operator's global context file separately from repository context. Thanks to [@hknatm](https://github.com/hknatm) for #1560.
+- Add process-local event registration so independent Pi extensions can register runtime agents through the installed owner. Thanks to [@fmoda3](https://github.com/fmoda3) for #1533.
+- Add advisory launch preflight diagnostics for likely workspace scope and authority mismatches.
+- Document per-run thinking suffixes in model-facing subagent guidance. Thanks to [@yanqianglu](https://github.com/yanqianglu) for #1565.
+- Document unsupported native child options for external CLI agents in the subagent tool help, packaged guide, and packaged skill.
+
+### Changed
+- Agents now omit the operator's global context file by default, including existing agents with `inheritProjectContext: true`; set `inheritGlobalContext: true` to preserve the previous behavior. Thanks to [@hknatm](https://github.com/hknatm) for #1560.
+
+### Fixed
+- Fail explicitly requested models closed when a cached model exclusion is active, instead of silently selecting a fallback. Thanks to [@harpsychord](https://github.com/harpsychord) for #1556.
+- Preserve fast-mode provider request root fields when adding OpenAI's priority service tier. Thanks to [@nothingrotf](https://github.com/nothingrotf) for #1570.
+- Classify workflow budget and timeout stops as partial terminal outcomes while preserving settled child evidence. Thanks to [@yceachan](https://github.com/yceachan) for #1530.
+- Publish a deterministic terminal handoff with settled child evidence and keyed recovery actions when detached workflow lanes settle. Thanks to [@yceachan](https://github.com/yceachan) for #1530.
+- Resolve direct MCP tool selections from Pi package manifests and Agent Plugin configs. Thanks to [@fmoda3](https://github.com/fmoda3) for #1541.
+- Fail closed with a launch diagnostic when configured runtime-style MCP direct-tool selectors cannot be resolved.
+- Sync Herdr status after restoring active async jobs, so recovered work appears without waiting for another lifecycle event. Thanks to [@vicocamacho](https://github.com/vicocamacho) for #1553.
+- Show task intent and context-window use in compact in-progress async status rows.
+- Report deterministic settlement diagnostics when background children fail before required output handoff.
+- Auto-resume workflow children once after setup-phase aborts that produce zero usage, preserving the retained transcript instead of rerunning the whole task.
+- Finalize detached foreground worktree handoffs after terminal child completion, preserving captured changes before cleanup. Thanks to [@jpriverar](https://github.com/jpriverar) for #1562.
+- Fail native child launches before spawn when the requested local working directory is missing or not a directory, with the requested and resolved paths in the error.
+- Map report paths requested in workflow child tasks to the actual saved child output when workflow output routing overrides them.
+- Stop same-session workflows recovered after extension reload through the durable control channel.
+- Let agents declare extension mutation tools so real non-Git or untracked edits satisfy the implementation completion guard. Thanks to [@AlphaGodzilla](https://github.com/AlphaGodzilla) for #1532.
+- Deliver async results from an explicitly replaced predecessor session without accepting unrelated session results. Thanks to [@DresvyanskiyDenis](https://github.com/DresvyanskiyDenis) for #1531.
+- Avoid attributing assistant-issued workflow stops to the user.
+
+## [0.57.0] - 2026-08-26
+
+### Highlights
+- Run Codex, Claude Code, and Cursor Agent subagents with packaged read-only and writing profiles.
+- Validate workflow scripts before launch, and reuse workflow code from files with `workflowScriptPath`.
+- Resume, inspect, and recover workflow children more reliably after errors, compaction, or session reloads.
+- See clearer Fleet and status output, including task labels and live context-window usage.
+- Recover from more async, scheduling, discovery, model fallback, and Windows edge cases without losing useful run history.
+
+### Added
+- Add read-only and workspace-writing profiles for `codex-exec`, `claude-code`, and `cursor-agent`, with bounded result capture and opt-in smoke checks.
+- Add external one-shot runner support for bounded parser hooks and logs, environment allowlists, cached launch preflight, parser progress, and process cleanup.
+- Add compact external CLI capability and receipt metadata for adapter identity, artifacts, handoff mode, supervisor support, and resumability.
+- Add configured pruned fork sessions with budgeted transcript-overflow summaries, stable recovery refs, and private recovery sidecars.
+- Add offline `workflowScript` syntax and structural validation through the public subagent tool. Thanks to [@elecnix](https://github.com/elecnix) for #1462.
+- Add `workflowScriptPath` so workflows can be loaded from files for execution, validation, and schedules. Thanks to [@elecnix](https://github.com/elecnix) for #1464.
+- Add bounded workflow-child summaries to workflow results, status, receipts, and completion replay. Thanks to [@rochecompaan](https://github.com/rochecompaan) for #1453.
+- Add live context-window usage to status and Fleet views, separate from cumulative token spend. Thanks to [@nazzeDe](https://github.com/nazzeDe) for #1444.
+- Add active workflow task labels to compact status surfaces and Herdr pane metadata. Thanks to [@phoenixdam](https://github.com/phoenixdam) for #1459.
+- Add `modelExclusions.defaultTtlMs` for controlling how long model exclusions stay active, with launch diagnostics for skipped candidates. Thanks to [@mithyer](https://github.com/mithyer) for #1439 and #1438.
+- Add a package-internal one-use permit for one exact native child in a foreground `workflowScript`. Thanks to [@maroffo](https://github.com/maroffo) for #1494.
+
+### Fixed
+- Preserve agent frontmatter output defaults for prompt-template delegated leaves. Thanks to [@ashlineldridge](https://github.com/ashlineldridge) for #1521.
+- Preserve structured-output and related bounded child contract fields when foreground workflow children resume. Thanks to [@Livan-pro](https://github.com/Livan-pro) for #1460.
+- Preserve typed errors, partial output, transcript metadata, and artifact metadata when foreground workflow children resume. See #1513.
+- Keep inline workflow children resumable from their foreground runs without mistaking a missing async directory for lost state. Thanks to [@lancegui](https://github.com/lancegui) for #1442.
+- Make workflow validation and return serialization failures easier to recover from with no-child-launch diagnostics, portable rewrite guidance, workflow ids, and completed-child output references (#1432, #1434).
+- Clarify terminal keyed workflow-resume failures when `workflow-receipt.json` is unavailable, including direct child-run recovery from status and event logs (#1512).
+- Preserve bounded async child failure context after compaction, including missing file-only output, instead of leaving failed run summaries empty. See #1495.
+- Ignore stale child-settled events from retrying compaction attempts, so resumed children are not aborted before their replacement attempt can finish. See #1504.
+- Make async runs visible to exact status lookup as soon as launch succeeds, and deliver one completion when a runner dies before its normal status write. Thanks to [@rafafortes](https://github.com/rafafortes) for #1471 and [@VincentHanxiaoDu](https://github.com/VincentHanxiaoDu) for #1480.
+- Record explicit completed, failed, timed-out, stopped, and interrupted outcomes in run history. Thanks to [@rafafortes](https://github.com/rafafortes) for #1474.
+- Repair bounded dead async run candidates before retention classifies them, so stale run directories can be reclaimed without deleting ambiguous worktrees or branches. Thanks to [@rafafortes](https://github.com/rafafortes) for #1477.
+- Exclude completed one-shot schedules from the pending schedule limit without deleting their durable history. Thanks to [@rafafortes](https://github.com/rafafortes) for #1478.
+- Reclaim failed async capacity slots after a configurable abandoned timeout when the runner PID is gone, while keeping clear diagnostics for unknown process state. Thanks to [@rafafortes](https://github.com/rafafortes) for #1472.
+- Preserve parent model inheritance for workflow children when workflow setup reads session data before launch, and avoid carrying a stale live-session model into scheduled owners. Thanks to [@alexei-led](https://github.com/alexei-led) for #1489 and #1490.
+- Retry fallback models for transient provider connection failures. Thanks to [@genkikadomatsu](https://github.com/genkikadomatsu) for #1508.
+- Resolve the `advisor` builtin alias through the bundled `oracle` definition in model listings. Thanks to [@smileBeda](https://github.com/smileBeda) for #1502.
+- Follow symlinked directories during agent discovery without revisiting recursive links. Thanks to [@robsdudeson](https://github.com/robsdudeson) for #1505 and #1510.
+- Explain unknown-agent failures with the effective cwd and discovery inputs. Thanks to [@genkikadomatsu](https://github.com/genkikadomatsu) for #1511.
+- Resolve package subagents from bare HTTP(S) Git URLs stored in Pi settings. Thanks to [@trancikk](https://github.com/trancikk) for #1452.
+- Preview runtime-recorded workflow child sessions in Fleet and inspect without trusting sibling transcripts. Thanks to [@JHa13y](https://github.com/JHa13y) for #1441.
+- Distinguish same-agent parallel children in Fleet with their explicit task labels. Thanks to [@ljie-PI](https://github.com/ljie-PI) for #1487.
+- Preserve the local user identity and temporary-directory environment needed by authenticated Claude Code adapter runs.
+- Report child processes that exit during tool execution as mid-tool failures instead of cold starts, even when earlier assistant text exists. Thanks to [@cyzlmh](https://github.com/cyzlmh) for #1437.
+- Keep unaddressable legacy result aliases and overlong public result filenames from blocking canonical hashed or pending fallbacks. Thanks to [@LeonardBode](https://github.com/LeonardBode) for #1440.
+- Bypass repository fsmonitor hooks when collecting mutation evidence. Thanks to [@jpriverar](https://github.com/jpriverar) for #1497.
+- Avoid the fatal Node `ReadFileUtf8` retention path. Thanks to [@pgoodjohn](https://github.com/pgoodjohn) for #1501.
+- Base64-encode Herdr inspector session roots so `inspector.open` handles Windows PowerShell argument parsing correctly. Thanks to [@stavg91](https://github.com/stavg91) for #1499.
+- Keep async runner terminal event delivery from crashing the session when the captured extension context is stale after a session replacement or reload. Thanks to [@AdrianAcala](https://github.com/AdrianAcala) for #1485.
+- Reject non-string workflow-child summary identifiers when reading receipt metadata.
+
 ## [0.56.0] - 2026-08-23
 
 ### Highlights

package/dist/extensions/pi-subagents/README.md

@@ -4,14 +4,14 @@
 
 # pi-subagents
 
-`pi-subagents` lets Pi delegate work to focused child agents. Use it for code review, scouting, implementation, parallel audits, saved workflows, background jobs, and anything else that benefits from a second or third set of model eyes.
+`pi-subagents` lets Selesai delegate work to focused child agents. Use it for code review, scouting, implementation, parallel audits, saved workflows, background jobs, and anything else that benefits from a second or third set of model eyes.
 
 <https://github.com/user-attachments/assets/702554ec-faaf-4635-80aa-fb5d6e292fd1>
 
 ## Install
 
 ```bash
-pi install npm:pi-subagents
+selesai install npm:pi-subagents
 ```
 
 That is the only required step.
@@ -36,15 +36,15 @@ Use scout to understand this code based on our discussion, then ask me clarifica
 Run parallel reviewers: one for correctness, one for tests, and one for unnecessary complexity.
 ```
 
-That is enough to start. Pi decides whether to call the `subagent` tool, which agent to use, and how to compose the work.
+That is enough to start. Selesai decides whether to call the `subagent` tool, which agent to use, and how to compose the work.
 
 ## How it works
 
-Pi is the parent session. A subagent is a focused child Pi session with its own job.
+Selesai is the parent session. A subagent is a focused child Selesai session with its own job.
 
-When you ask for a subagent, Pi starts the child, gives it the task, and brings the result back. Foreground runs stream in the conversation. Background runs keep working and can be checked later.
+When you ask for a subagent, Selesai starts the child, gives it the task, and brings the result back. Foreground runs stream in the conversation. Background runs keep working and can be checked later.
 
-Installing the extension does not start an automatic reviewer in the background. It gives Pi a delegation tool. If you want every implementation reviewed, say so in your prompt or project instructions:
+Installing the extension does not start an automatic reviewer in the background. It gives Selesai a delegation tool. If you want every implementation reviewed, say so in your prompt or project instructions:
 
 ```text
 When you finish implementing, run a reviewer subagent before summarizing.
@@ -62,6 +62,12 @@ The extension ships with agents you can use immediately:
 | `reviewer` | Code review and small fixes against the task/plan, tests, edge cases, and simplicity. |
 | `oracle` | A second opinion before acting. Challenges assumptions without editing. |
 | `delegate` | A lightweight general delegate that behaves close to the parent session. |
+| `architect` | Read-only architecture and implementation planning. |
+| `builder` | Mutation-capable scoped implementation. |
+| `commentator` | Read-only evidence-based review. |
+| `explorer` | Read-only local codebase reconnaissance. |
+| `recapper` | Read-only handoff and context synthesis. |
+| `codex-exec`, `claude-code`, `cursor-agent` | External CLI runners with their own adapter contracts. |
 
 Rule of thumb: `scout` before you understand the code, `researcher` before you trust external facts, `worker` to implement, `reviewer` to check, and `oracle` when the decision itself feels risky.
 

package/dist/extensions/pi-subagents/VISION.md

@@ -0,0 +1,81 @@
+# Vision
+
+## What pi-subagents is
+
+pi-subagents lets one Pi session delegate focused work to child agents with supervision, evidence, and control.
+It serves a single Pi operator first: one person who wants more leverage from one session without losing control of what runs in their name.
+It stays flexible enough for other people and other workflows, but it does not redesign itself around them.
+It owns the Pi delegation layer: child launch contracts, workflow orchestration, supervision, observability, and result handoff.
+
+## One parent, many focused children
+
+The parent session stays the orchestrator and the decision maker.
+Each child gets a clear task, a bounded contract, and a defined way to hand its result back.
+Complex semi-autonomous work, such as repository backlog maintenance or several unrelated tasks running in parallel worktrees, composes from these same parts.
+Those workflows are capabilities the system must support well, not the product identity.
+
+## Authority comes from clarity
+
+Authority is moderate, not maximal in either direction.
+When user intent and policy are clear, safe routine authority can be inferred without a fresh ask.
+A blocked child can ask its supervisor to unblock it before interrupting the user.
+User and project instructions can tighten or loosen this authority, and the system respects both directions.
+
+## Evidence closes work
+
+A child saying it is done is not enough.
+Completion needs evidence: concrete outputs, changed files where change was expected, validation results, or an explicit blocked state.
+When behavior cannot be proven, the system fails closed instead of reporting optimistic success.
+
+## Compose before inventing
+
+Existing primitives come first.
+A new mode, runner, or abstraction is justified only when current primitives cannot honestly express the needed behavior.
+
+## Scope must earn size
+
+Pull requests should be narrow enough to review with confidence.
+A large diff is a warning sign, not proof of rigor.
+Size is acceptable only when the issue, design, and owner approval justify it.
+
+Broad changes need approval before they expand across launch paths, public APIs, persistence, or runner lifecycle code.
+When a proposal touches those surfaces without that approval, the right response is adversarial review and reduction.
+Each PR should prove one clear invariant and stop before it turns into a framework.
+
+## Performance is a product constraint
+
+Delegation must stay fast enough that one parent session can keep several children moving without the operator waiting on the tool.
+Status, progress, watchers, TUI refresh, filesystem scans, and orchestration setup are hot paths.
+Token cost is part of the same constraint: extra context, extra children, and extra layers have to earn their keep.
+A change that makes those paths slower needs proof or explicit owner approval.
+Unmeasured risk in a hot path is a reason to refuse the change.
+
+## Background work stays visible
+
+Work that runs out of sight must never disappear.
+Status views, FleetView, and run artifacts exist so the operator can always see and inspect running work, and steer or stop it when the runner supports those controls.
+They are safety infrastructure for delegation, not the product itself.
+
+## External agents earn trust
+
+Agents that are not Pi children are welcome inside workflows.
+Over time this points toward a vendor-neutral adapter layer for external CLIs and other harnesses.
+Today, external agents must be honest: they declare their real capabilities, receive a deliberate handoff instead of pretended native context, and fail closed when behavior is not proven.
+A passing demo is not a capability contract.
+
+## What this project refuses
+
+It does not become a general project manager or issue tracker.
+It does not own CI, merge policy, or release policy; it reports evidence into those systems.
+It does not add integrations for niche tools without clear demand.
+It does not treat external agents as native Pi children before their capabilities are proven.
+It does not run background reviewers on every edit by default; delegation happens because the operator asked for it, directly or through their instructions.
+It does not accept a slower status loop, watcher, or common workflow just to make the machinery look richer.
+
+## How to judge a change
+
+A change fits when it gives one operator more leverage with the same or better control, visibility, and evidence.
+A change fits when it composes from existing primitives or honestly shows why it cannot.
+A change fits when it keeps or improves speed and token cost, or proves why a cost is worth paying.
+A change does not fit when it adds hot-path cost without proof, hides running work, accepts confidence in place of evidence, widens authority beyond the operator's instructions, or grows scope toward general project management.
+When a proposal is in doubt, ask whether it makes delegation more trustworthy for the person whose name it runs under.

package/dist/extensions/pi-subagents/agents/claude-code-writer.md

@@ -0,0 +1,15 @@
+---
+name: claude-code-writer
+description: Explicit file-writing Claude Code CLI mode; requires local authentication and trusted user settings/hooks
+runner:
+  type: external-cli
+  adapter: claude-code-writer
+  command: claude
+  promptDelivery: stdin
+async: true
+systemPromptMode: replace
+inheritProjectContext: true
+inheritSkills: false
+---
+
+Prerequisites: the local Claude Code CLI is authenticated, and the operator trusts its user-level settings and hooks. Use only the code-owned Read, Write, Edit, Glob, and Grep tools. Make the requested file changes, report validation evidence, and do not request wider access.