gsd-pi 2.34.0-dev.ed0bfbf → 2.35.0-dev.30eec3f

package/dist/resources/extensions/gsd/preferences-validation.js

@@ -14,9 +14,24 @@ export function validatePreferences(preferences) {
     const warnings = [];
     const validated = {};
     // ─── Unknown Key Detection ──────────────────────────────────────────
+    // Common key migration hints for pi-level settings that don't map to GSD prefs
+    const KEY_MIGRATION_HINTS = {
+        taskIsolation: 'use "git.isolation" instead (values: worktree, branch, none)',
+        task_isolation: 'use "git.isolation" instead (values: worktree, branch, none)',
+        isolation: 'use "git.isolation" instead (values: worktree, branch, none)',
+        manage_gitignore: 'use "git.manage_gitignore" instead',
+        auto_push: 'use "git.auto_push" instead',
+        main_branch: 'use "git.main_branch" instead',
+    };
     for (const key of Object.keys(preferences)) {
         if (!KNOWN_PREFERENCE_KEYS.has(key)) {
-            warnings.push(`unknown preference key "${key}" — ignored`);
+            const hint = KEY_MIGRATION_HINTS[key];
+            if (hint) {
+                warnings.push(`unknown preference key "${key}" — ${hint}`);
+            }
+            else {
+                warnings.push(`unknown preference key "${key}" — ignored`);
+            }
         }
     }
     if (preferences.version !== undefined) {
@@ -603,5 +618,43 @@ export function validatePreferences(preferences) {
             validated.git = git;
         }
     }
+    // ─── Auto Visualize ─────────────────────────────────────────────────
+    if (preferences.auto_visualize !== undefined) {
+        if (typeof preferences.auto_visualize === "boolean") {
+            validated.auto_visualize = preferences.auto_visualize;
+        }
+        else {
+            errors.push("auto_visualize must be a boolean");
+        }
+    }
+    // ─── Auto Report ────────────────────────────────────────────────────
+    if (preferences.auto_report !== undefined) {
+        if (typeof preferences.auto_report === "boolean") {
+            validated.auto_report = preferences.auto_report;
+        }
+        else {
+            errors.push("auto_report must be a boolean");
+        }
+    }
+    // ─── Compression Strategy ───────────────────────────────────────────
+    if (preferences.compression_strategy !== undefined) {
+        const validStrategies = new Set(["truncate", "compress"]);
+        if (typeof preferences.compression_strategy === "string" && validStrategies.has(preferences.compression_strategy)) {
+            validated.compression_strategy = preferences.compression_strategy;
+        }
+        else {
+            errors.push(`compression_strategy must be one of: truncate, compress`);
+        }
+    }
+    // ─── Context Selection ──────────────────────────────────────────────
+    if (preferences.context_selection !== undefined) {
+        const validModes = new Set(["full", "smart"]);
+        if (typeof preferences.context_selection === "string" && validModes.has(preferences.context_selection)) {
+            validated.context_selection = preferences.context_selection;
+        }
+        else {
+            errors.push(`context_selection must be one of: full, smart`);
+        }
+    }
     return { preferences: validated, errors, warnings };
 }

package/dist/resources/extensions/gsd/preferences.js

@@ -186,6 +186,8 @@ function mergePreferences(base, override) {
         search_provider: override.search_provider ?? base.search_provider,
         compression_strategy: override.compression_strategy ?? base.compression_strategy,
         context_selection: override.context_selection ?? base.context_selection,
+        auto_visualize: override.auto_visualize ?? base.auto_visualize,
+        auto_report: override.auto_report ?? base.auto_report,
     };
 }
 function mergeStringLists(base, override) {

package/dist/resources/extensions/gsd/prompts/complete-milestone.md

@@ -28,6 +28,8 @@ Then:
 
 **Important:** Do NOT skip the success criteria and definition of done verification (steps 3-4). The milestone summary must reflect actual verified outcomes, not assumed success. If any criterion was not met, document it clearly in the summary and do not mark the milestone as passing verification.
 
+**File system safety:** When scanning milestone directories for evidence, use `ls` or `find` to list directory contents first — never pass a directory path (e.g. `tasks/`, `slices/`) directly to the `read` tool. The `read` tool only accepts file paths, not directories.
+
 **You MUST write `{{milestoneSummaryPath}}` AND update PROJECT.md before finishing.**
 
 When done, say: "Milestone {{milestoneId}} complete."

package/dist/resources/extensions/gsd/prompts/validate-milestone.md

@@ -67,4 +67,6 @@ If verdict is `needs-remediation`:
 
 **You MUST write `{{validationPath}}` before finishing.**
 
+**File system safety:** When scanning milestone directories for evidence, use `ls` or `find` to list directory contents first — never pass a directory path (e.g. `tasks/`, `slices/`) directly to the `read` tool. The `read` tool only accepts file paths, not directories.
+
 When done, say: "Milestone {{milestoneId}} validation complete — verdict: <verdict>."

package/dist/resources/extensions/gsd/roadmap-mutations.js

@@ -0,0 +1,55 @@
+/**
+ * Roadmap Mutations — shared utilities for modifying roadmap checkbox state.
+ *
+ * Extracts the duplicated "flip slice checkbox" pattern that existed in
+ * doctor.ts, mechanical-completion.ts, and auto-recovery.ts.
+ */
+import { readFileSync } from "node:fs";
+import { atomicWriteSync } from "./atomic-write.js";
+import { resolveMilestoneFile } from "./paths.js";
+import { clearParseCache } from "./files.js";
+/**
+ * Mark a slice as done ([x]) in the milestone roadmap.
+ * Idempotent — no-op if already checked or if the slice isn't found.
+ *
+ * @returns true if the roadmap was modified, false if no change was needed
+ */
+export function markSliceDoneInRoadmap(basePath, mid, sid) {
+    const roadmapFile = resolveMilestoneFile(basePath, mid, "ROADMAP");
+    if (!roadmapFile)
+        return false;
+    let content;
+    try {
+        content = readFileSync(roadmapFile, "utf-8");
+    }
+    catch {
+        return false;
+    }
+    const updated = content.replace(new RegExp(`^(\\s*-\\s+)\\[ \\]\\s+\\*\\*${sid}:`, "m"), `$1[x] **${sid}:`);
+    if (updated === content)
+        return false;
+    atomicWriteSync(roadmapFile, updated);
+    clearParseCache();
+    return true;
+}
+/**
+ * Mark a task as done ([x]) in the slice plan.
+ * Idempotent — no-op if already checked or if the task isn't found.
+ *
+ * @returns true if the plan was modified, false if no change was needed
+ */
+export function markTaskDoneInPlan(basePath, planPath, tid) {
+    let content;
+    try {
+        content = readFileSync(planPath, "utf-8");
+    }
+    catch {
+        return false;
+    }
+    const updated = content.replace(new RegExp(`^(\\s*-\\s+)\\[ \\]\\s+\\*\\*${tid}:`, "m"), `$1[x] **${tid}:`);
+    if (updated === content)
+        return false;
+    atomicWriteSync(planPath, updated);
+    clearParseCache();
+    return true;
+}

package/dist/resources/extensions/gsd/session-lock.js

@@ -32,8 +32,17 @@ let _lockPid = 0;
 let _lockCompromised = false;
 /** Whether we've already registered a process.on('exit') handler. */
 let _exitHandlerRegistered = false;
+/** Snapshotted lock file path — captured at acquireSessionLock time to avoid
+ *  gsdRoot() resolving differently in worktree vs project root contexts (#1363). */
+let _snapshotLockPath = null;
+/** Timestamp when the session lock was acquired — used to detect false-positive
+ *  onCompromised events from event loop stalls within the stale window (#1362). */
+let _lockAcquiredAt = 0;
 const LOCK_FILE = "auto.lock";
 function lockPath(basePath) {
+    // If we have a snapshotted path from acquisition, use it for consistency
+    if (_snapshotLockPath)
+        return _snapshotLockPath;
     return join(gsdRoot(basePath), LOCK_FILE);
 }
 // ─── Stray Lock Cleanup ─────────────────────────────────────────────────────
@@ -175,8 +184,17 @@ export function acquireSessionLock(basePath) {
             onCompromised: () => {
                 // proper-lockfile detected mtime drift (system sleep, event loop stall, etc.).
                 // Default handler throws inside setTimeout — an uncaught exception that crashes
-                // or corrupts process state. Instead, set a flag so validateSessionLock() can
-                // detect the compromise gracefully on the next dispatch cycle.
+                // or corrupts process state.
+                //
+                // False-positive suppression (#1362): If we're still within the stale window
+                // (30 min since acquisition), the mtime mismatch is from an event loop stall
+                // during a long LLM call — not a real takeover. Log and continue.
+                const elapsed = Date.now() - _lockAcquiredAt;
+                if (elapsed < 1_800_000) {
+                    process.stderr.write(`[gsd] Lock heartbeat mismatch after ${Math.round(elapsed / 1000)}s — event loop stall, continuing.\n`);
+                    return; // Suppress false positive
+                }
+                // Past the stale window — this is a real compromise
                 _lockCompromised = true;
                 _releaseFunction = null;
             },
@@ -185,6 +203,8 @@ export function acquireSessionLock(basePath) {
         _lockedPath = basePath;
         _lockPid = process.pid;
         _lockCompromised = false;
+        _lockAcquiredAt = Date.now();
+        _snapshotLockPath = lp; // Snapshot the resolved path for consistent access (#1363)
         // Safety net: clean up lock dir on process exit if _releaseFunction
         // wasn't called (e.g., normal exit after clean completion) (#1245).
         ensureExitHandler(gsdDir);
@@ -219,6 +239,8 @@ export function acquireSessionLock(basePath) {
                 _lockedPath = basePath;
                 _lockPid = process.pid;
                 _lockCompromised = false;
+                _lockAcquiredAt = Date.now();
+                _snapshotLockPath = lp; // Snapshot for retry path too (#1363)
                 // Safety net — uses centralized handler to avoid double-registration
                 ensureExitHandler(gsdDir);
                 atomicWriteSync(lp, JSON.stringify(lockData, null, 2));
@@ -348,6 +370,8 @@ export function releaseSessionLock(basePath) {
     _lockedPath = null;
     _lockPid = 0;
     _lockCompromised = false;
+    _lockAcquiredAt = 0;
+    _snapshotLockPath = null;
 }
 /**
  * Check if a session lock exists and return its data (for crash recovery).

package/dist/resources/extensions/gsd/templates/plan.md

@@ -113,6 +113,14 @@
   - Tasks execute sequentially in order (T01, T02, T03, ...)
   - est: is informational (e.g. 30m, 1h, 2h) and optional
 
+  Verify field rules:
+  - MUST be a mechanically executable command: `npm test`, `grep -q "pattern" file`, `test -f path`
+  - For content/document tasks: verify file existence, section count, YAML validity, or word count
+    NOT exact phrasing, specific formulas, or "zero TBD" aspirational criteria
+  - If no command can verify the output, write: "Manual review — file exists and is non-empty"
+  - BAD: "Sections 3.1 and 3.2 exist with exact formulas. Zero TBD/TODO."
+  - GOOD: `grep -c "^## " doc.md` returns >= 4 (4+ sections), `! grep -q "TBD\|TODO" doc.md`
+
   Integration closure rule:
   - At least one slice in any multi-boundary milestone should perform real composition/wiring, not just contract hardening
   - For the final assembly slice, verification must exercise the real entrypoint or runtime path

package/dist/resources/extensions/gsd/worktree-resolver.js

@@ -12,6 +12,8 @@
  * Key invariant: `createAutoWorktree()` and `enterAutoWorktree()` call
  * `process.chdir()` internally — this class MUST NOT double-chdir.
  */
+import { existsSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
 import { debugLog } from "./debug-logger.js";
 // ─── WorktreeResolver ──────────────────────────────────────────────────────
 export class WorktreeResolver {
@@ -253,6 +255,16 @@ export class WorktreeResolver {
                 fallback: "chdir-to-project-root",
             });
             ctx.notify(`Milestone merge failed: ${msg}`, "warning");
+            // Clean up stale merge state left by failed squash-merge (#1389)
+            try {
+                const gitDir = join(originalBase || this.s.basePath, ".git");
+                for (const f of ["SQUASH_MSG", "MERGE_HEAD", "MERGE_MSG"]) {
+                    const p = join(gitDir, f);
+                    if (existsSync(p))
+                        unlinkSync(p);
+                }
+            }
+            catch { /* best-effort */ }
             // Error recovery: always restore to project root
             if (originalBase) {
                 try {

package/dist/resources/extensions/remote-questions/remote-command.js

@@ -2,12 +2,12 @@
  * Remote Questions — /gsd remote command
  */
 import { AuthStorage } from "@gsd/pi-coding-agent";
-import { CURSOR_MARKER, Editor, Key, matchesKey, truncateToWidth } from "@gsd/pi-tui";
+import { Editor, Key, matchesKey, truncateToWidth } from "@gsd/pi-tui";
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { getGlobalGSDPreferencesPath, loadEffectiveGSDPreferences } from "../gsd/preferences.js";
 import { getRemoteConfigStatus, isValidChannelId, resolveRemoteConfig } from "./config.js";
-import { sanitizeError } from "../shared/sanitize.js";
+import { maskEditorLine, sanitizeError } from "../shared/mod.js";
 import { getLatestPromptSummary } from "./status.js";
 export async function handleRemote(subcommand, ctx, _pi) {
     const trimmed = subcommand.trim();
@@ -339,26 +339,6 @@ function removeRemoteQuestionsConfig() {
     const next = frontmatter ? `---\n${frontmatter}\n---${content.slice(fmMatch[0].length)}` : content.slice(fmMatch[0].length).replace(/^\n+/, "");
     writeFileSync(prefsPath, next, "utf-8");
 }
-function maskEditorLine(line) {
-    let output = "";
-    let i = 0;
-    while (i < line.length) {
-        if (line.startsWith(CURSOR_MARKER, i)) {
-            output += CURSOR_MARKER;
-            i += CURSOR_MARKER.length;
-            continue;
-        }
-        const ansiMatch = /^\x1b\[[0-9;]*m/.exec(line.slice(i));
-        if (ansiMatch) {
-            output += ansiMatch[0];
-            i += ansiMatch[0].length;
-            continue;
-        }
-        output += line[i] === " " ? " " : "*";
-        i += 1;
-    }
-    return output;
-}
 async function promptMaskedInput(ctx, label, hint) {
     if (!ctx.hasUI)
         return null;

package/dist/resources/extensions/shared/mod.js

@@ -6,6 +6,6 @@ export { toPosixPath } from "./path-display.js";
 export { showInterviewRound } from "./interview-ui.js";
 export { showNextAction } from "./next-action-ui.js";
 export { showConfirm } from "./confirm-ui.js";
-export { sanitizeError } from "./sanitize.js";
+export { sanitizeError, maskEditorLine } from "./sanitize.js";
 export { formatDateShort, truncateWithEllipsis } from "./format-utils.js";
 export { splitFrontmatter, parseFrontmatterMap } from "./frontmatter.js";

package/dist/resources/extensions/shared/sanitize.js

@@ -1,6 +1,8 @@
 /**
  * Sanitize error messages by redacting token-like strings before surfacing.
+ * Also provides maskEditorLine for masking sensitive TUI editor input.
  */
+import { CURSOR_MARKER } from "@gsd/pi-tui";
 const TOKEN_PATTERNS = [
     /xoxb-[A-Za-z0-9\-]+/g, // Slack bot tokens
     /xoxp-[A-Za-z0-9\-]+/g, // Slack user tokens
@@ -15,3 +17,31 @@ export function sanitizeError(msg) {
     }
     return sanitized;
 }
+/**
+ * Replace editor visible text with masked characters while preserving
+ * ANSI cursor/sequencer codes. Keeps border/metadata lines readable.
+ */
+export function maskEditorLine(line) {
+    if (line.startsWith("─")) {
+        return line;
+    }
+    let output = "";
+    let i = 0;
+    while (i < line.length) {
+        if (line.startsWith(CURSOR_MARKER, i)) {
+            output += CURSOR_MARKER;
+            i += CURSOR_MARKER.length;
+            continue;
+        }
+        const ansiMatch = /^\x1b\[[0-9;]*m/.exec(line.slice(i));
+        if (ansiMatch) {
+            output += ansiMatch[0];
+            i += ansiMatch[0].length;
+            continue;
+        }
+        const ch = line[i];
+        output += ch === " " ? " " : "*";
+        i += 1;
+    }
+    return output;
+}

package/dist/resources/extensions/subagent/index.js

@@ -20,6 +20,7 @@ import { StringEnum } from "@gsd/pi-ai";
 import { getMarkdownTheme } from "@gsd/pi-coding-agent";
 import { Container, Markdown, Spacer, Text } from "@gsd/pi-tui";
 import { Type } from "@sinclair/typebox";
+import { formatTokenCount } from "../shared/mod.js";
 import { discoverAgents } from "./agents.js";
 import { createIsolation, mergeDeltaPatches, readIsolationMode, } from "./isolation.js";
 import { registerWorker, updateWorker } from "./worker-registry.js";
@@ -58,31 +59,22 @@ async function stopLiveSubagents() {
         }
     }
 }
-function formatTokens(count) {
-    if (count < 1000)
-        return count.toString();
-    if (count < 10000)
-        return `${(count / 1000).toFixed(1)}k`;
-    if (count < 1000000)
-        return `${Math.round(count / 1000)}k`;
-    return `${(count / 1000000).toFixed(1)}M`;
-}
 function formatUsageStats(usage, model) {
     const parts = [];
     if (usage.turns)
         parts.push(`${usage.turns} turn${usage.turns > 1 ? "s" : ""}`);
     if (usage.input)
-        parts.push(`↑${formatTokens(usage.input)}`);
+        parts.push(`↑${formatTokenCount(usage.input)}`);
     if (usage.output)
-        parts.push(`↓${formatTokens(usage.output)}`);
+        parts.push(`↓${formatTokenCount(usage.output)}`);
     if (usage.cacheRead)
-        parts.push(`R${formatTokens(usage.cacheRead)}`);
+        parts.push(`R${formatTokenCount(usage.cacheRead)}`);
     if (usage.cacheWrite)
-        parts.push(`W${formatTokens(usage.cacheWrite)}`);
+        parts.push(`W${formatTokenCount(usage.cacheWrite)}`);
     if (usage.cost)
         parts.push(`$${(Number(usage.cost) || 0).toFixed(4)}`);
     if (usage.contextTokens && usage.contextTokens > 0) {
-        parts.push(`ctx:${formatTokens(usage.contextTokens)}`);
+        parts.push(`ctx:${formatTokenCount(usage.contextTokens)}`);
     }
     if (model)
         parts.push(model);

package/dist/resources/skills/create-gsd-extension/references/events-reference.md

@@ -61,10 +61,10 @@ pi.on("tool_call", async (event, ctx) => {
 
 **tool_result** — Fired after tool executes. Can modify result. Handlers chain like middleware.
 ```typescript
-import { isBashToolResult } from "@mariozechner/pi-coding-agent";
+import { isToolResultEventType } from "@mariozechner/pi-coding-agent";
 
 pi.on("tool_result", async (event, ctx) => {
-  if (isBashToolResult(event)) {
+  if (isToolResultEventType("bash", event)) {
     // event.details is typed as BashToolDetails
   }
   // Return partial patch: { content, details, isError }
@@ -105,7 +105,7 @@ pi.on("model_select", async (event, ctx) => {
 Built-in type guards for tool events:
 
 ```typescript
-import { isToolCallEventType, isBashToolResult } from "@mariozechner/pi-coding-agent";
+import { isToolCallEventType, isToolResultEventType } from "@mariozechner/pi-coding-agent";
 
 // Tool calls — narrows event.input type
 if (isToolCallEventType("bash", event)) { /* event.input: { command, timeout? } */ }
@@ -114,7 +114,7 @@ if (isToolCallEventType("write", event)) { /* event.input: { path, content } */
 if (isToolCallEventType("edit", event)) { /* event.input: { path, oldText, newText } */ }
 
 // Tool results — narrows event.details type
-if (isBashToolResult(event)) { /* event.details: BashToolDetails */ }
+if (isToolResultEventType("bash", event)) { /* event.details: BashToolDetails */ }
 ```
 
 For custom tools, export your input type and use explicit type params:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gsd-pi",
-  "version": "2.34.0-dev.ed0bfbf",
+  "version": "2.35.0-dev.30eec3f",
   "description": "GSD — Get Shit Done coding agent",
   "license": "MIT",
   "repository": {
@@ -50,6 +50,7 @@
     "copy-themes": "node scripts/copy-themes.cjs",
     "copy-export-html": "node scripts/copy-export-html.cjs",
     "test:unit": "node --import ./src/resources/extensions/gsd/tests/resolve-ts.mjs --experimental-strip-types --test src/resources/extensions/gsd/tests/*.test.ts src/resources/extensions/gsd/tests/*.test.mjs src/tests/*.test.ts",
+    "test:marketplace": "GSD_TEST_CLONE_MARKETPLACES=1 node --import ./src/resources/extensions/gsd/tests/resolve-ts.mjs --experimental-strip-types --test src/resources/extensions/gsd/tests/claude-import-tui.test.ts src/resources/extensions/gsd/tests/plugin-importer-live.test.ts src/tests/marketplace-discovery.test.ts",
     "test:coverage": "c8 --reporter=text --reporter=lcov --exclude='src/resources/extensions/gsd/tests/**' --exclude='src/tests/**' --exclude='scripts/**' --exclude='native/**' --exclude='node_modules/**' --check-coverage --statements=50 --lines=50 --branches=20 --functions=20 node --import ./src/resources/extensions/gsd/tests/resolve-ts.mjs --experimental-strip-types --test src/resources/extensions/gsd/tests/*.test.ts src/resources/extensions/gsd/tests/*.test.mjs src/tests/*.test.ts",
     "test:integration": "node --import ./src/resources/extensions/gsd/tests/resolve-ts.mjs --experimental-strip-types --test src/resources/extensions/gsd/tests/*integration*.test.ts src/tests/integration/*.test.ts",
     "test": "npm run test:unit && npm run test:integration",

package/packages/pi-agent-core/dist/agent-loop.d.ts

@@ -4,6 +4,20 @@
  */
 import { EventStream } from "@gsd/pi-ai";
 import type { AgentContext, AgentEvent, AgentLoopConfig, AgentMessage, StreamFn } from "./types.js";
+export declare const ZERO_USAGE: {
+    readonly input: 0;
+    readonly output: 0;
+    readonly cacheRead: 0;
+    readonly cacheWrite: 0;
+    readonly totalTokens: 0;
+    readonly cost: {
+        readonly input: 0;
+        readonly output: 0;
+        readonly cacheRead: 0;
+        readonly cacheWrite: 0;
+        readonly total: 0;
+    };
+};
 /**
  * Start an agent loop with a new prompt message.
  * The prompt is added to the context and events are emitted for it.

package/packages/pi-agent-core/dist/agent-loop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-loop.d.ts","sourceRoot":"","sources":["../src/agent-loop.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAGN,WAAW,EAIX,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EACX,YAAY,EACZ,UAAU,EACV,eAAe,EACf,YAAY,EAIZ,QAAQ,EACR,MAAM,YAAY,CAAC;AA8BpB;;;GAGG;AACH,wBAAgB,SAAS,CACxB,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,CAAC,EAAE,WAAW,EACpB,QAAQ,CAAC,EAAE,QAAQ,GACjB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CA8BzC;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAChC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,CAAC,EAAE,WAAW,EACpB,QAAQ,CAAC,EAAE,QAAQ,GACjB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CA+BzC"}
+{"version":3,"file":"agent-loop.d.ts","sourceRoot":"","sources":["../src/agent-loop.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAGN,WAAW,EAIX,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EACX,YAAY,EACZ,UAAU,EACV,eAAe,EACf,YAAY,EAIZ,QAAQ,EACR,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,UAAU;;;;;;;;;;;;;CAOb,CAAC;AA4CX;;;GAGG;AACH,wBAAgB,SAAS,CACxB,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,CAAC,EAAE,WAAW,EACpB,QAAQ,CAAC,EAAE,QAAQ,GACjB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CAwBzC;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAChC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,CAAC,EAAE,WAAW,EACpB,QAAQ,CAAC,EAAE,QAAQ,GACjB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CA0BzC"}

package/packages/pi-agent-core/dist/agent-loop.js

@@ -3,7 +3,7 @@
  * Transforms to Message[] only at the LLM call boundary.
  */
 import { EventStream, streamSimple, validateToolArguments, } from "@gsd/pi-ai";
-const ZERO_USAGE = {
+export const ZERO_USAGE = {
     input: 0,
     output: 0,
     cacheRead: 0,
@@ -29,6 +29,23 @@ function createErrorMessage(error, config) {
         timestamp: Date.now(),
     };
 }
+/**
+ * Emit a message_start + message_end pair for a single message.
+ */
+function emitMessagePair(stream, message) {
+    stream.push({ type: "message_start", message });
+    stream.push({ type: "message_end", message });
+}
+/**
+ * Emit the standard error sequence when the outer agent loop catches an error.
+ * Pushes message_start/end, turn_end, agent_end, then closes the stream.
+ */
+function emitErrorSequence(stream, errMsg, newMessages) {
+    emitMessagePair(stream, errMsg);
+    stream.push({ type: "turn_end", message: errMsg, toolResults: [] });
+    stream.push({ type: "agent_end", messages: [...newMessages, errMsg] });
+    stream.end([...newMessages, errMsg]);
+}
 /**
  * Start an agent loop with a new prompt message.
  * The prompt is added to the context and events are emitted for it.
@@ -44,19 +61,13 @@ export function agentLoop(prompts, context, config, signal, streamFn) {
         stream.push({ type: "agent_start" });
         stream.push({ type: "turn_start" });
         for (const prompt of prompts) {
-            stream.push({ type: "message_start", message: prompt });
-            stream.push({ type: "message_end", message: prompt });
+            emitMessagePair(stream, prompt);
         }
         try {
             await runLoop(currentContext, newMessages, config, signal, stream, streamFn);
         }
         catch (error) {
-            const errMsg = createErrorMessage(error, config);
-            stream.push({ type: "message_start", message: errMsg });
-            stream.push({ type: "message_end", message: errMsg });
-            stream.push({ type: "turn_end", message: errMsg, toolResults: [] });
-            stream.push({ type: "agent_end", messages: [...newMessages, errMsg] });
-            stream.end([...newMessages, errMsg]);
+            emitErrorSequence(stream, createErrorMessage(error, config), newMessages);
         }
     })();
     return stream;
@@ -86,12 +97,7 @@ export function agentLoopContinue(context, config, signal, streamFn) {
             await runLoop(currentContext, newMessages, config, signal, stream, streamFn);
         }
         catch (error) {
-            const errMsg = createErrorMessage(error, config);
-            stream.push({ type: "message_start", message: errMsg });
-            stream.push({ type: "message_end", message: errMsg });
-            stream.push({ type: "turn_end", message: errMsg, toolResults: [] });
-            stream.push({ type: "agent_end", messages: [...newMessages, errMsg] });
-            stream.end([...newMessages, errMsg]);
+            emitErrorSequence(stream, createErrorMessage(error, config), newMessages);
         }
     })();
     return stream;
@@ -121,8 +127,7 @@ async function runLoop(currentContext, newMessages, config, signal, stream, stre
             // Process pending messages (inject before next assistant response)
             if (pendingMessages.length > 0) {
                 for (const message of pendingMessages) {
-                    stream.push({ type: "message_start", message });
-                    stream.push({ type: "message_end", message });
+                    emitMessagePair(stream, message);
                     currentContext.messages.push(message);
                     newMessages.push(message);
                 }
@@ -144,14 +149,7 @@ async function runLoop(currentContext, newMessages, config, signal, stream, stre
                     api: config.model.api,
                     provider: config.model.provider,
                     model: config.model.id,
-                    usage: {
-                        input: 0,
-                        output: 0,
-                        cacheRead: 0,
-                        cacheWrite: 0,
-                        totalTokens: 0,
-                        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-                    },
+                    usage: ZERO_USAGE,
                     stopReason: signal?.aborted ? "aborted" : "error",
                     errorMessage: errorText,
                     timestamp: Date.now(),
@@ -478,8 +476,7 @@ function emitToolCallOutcome(toolCall, result, isError, stream) {
         isError,
         timestamp: Date.now(),
     };
-    stream.push({ type: "message_start", message: toolResultMessage });
-    stream.push({ type: "message_end", message: toolResultMessage });
+    emitMessagePair(stream, toolResultMessage);
     return toolResultMessage;
 }
 function skipToolCall(toolCall, stream, options) {