codecartographer-pi 0.9.1 → 0.11.0

package/dist/extensions/codecarto/agent-runner.d.ts

@@ -1,4 +1,15 @@
 import { type AgentSession, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+export declare function needsPhaseContinuation(messages: ReadonlyArray<{
+    role: string;
+    stopReason?: string;
+}>): boolean;
+export declare function shouldContinuePhase(messages: ReadonlyArray<{
+    role: string;
+    stopReason?: string;
+}>, primaryOutputPresent: boolean): boolean;
+export declare function primaryOutputExists(cwd: string, primaryOutput: string): Promise<boolean>;
+export declare function buildPhaseContinuationPrompt(compacted: boolean): string;
+export declare function waitForCompaction(compactionCompleted: Promise<boolean>, timeoutMs?: number): Promise<boolean>;
 export interface PhaseRunCallbacks {
     onSessionCreated?: (session: AgentSession) => void;
     onToolStart?: (toolCallId: string, toolName: string) => void;
@@ -10,12 +21,20 @@ export interface PhaseRunCallbacks {
         output: number;
         cacheWrite: number;
     }) => void;
+    onCompactionEnd?: (event: {
+        reason: "manual" | "threshold" | "overflow";
+        successful: boolean;
+        aborted: boolean;
+    }) => void;
 }
 export interface PhaseRunOptions {
     /** Display name written via appendSessionInfo so the session shows up in
      *  /resume's picker as e.g. "CodeCartographer phase: blueprint". Pi reads
      *  it via SessionManager.getSessionName(). */
     sessionName?: string;
+    /** Primary output relative to `.codecarto/`; used to detect provider runs
+     * that stop normally before writing their required artifact. */
+    primaryOutput?: string;
 }
 export interface PhaseRunResult {
     session: AgentSession;

package/dist/extensions/codecarto/agent-runner.js

@@ -9,11 +9,51 @@
 // system prompt, no parent-context inheritance, no turn-limit grace logic.
 // Codecarto phases are bounded by their phase prompt and validation gate;
 // they don't need the full subagent-framework machinery.
+import { access } from "node:fs/promises";
+import { join, resolve } from "node:path";
 import { createAgentSession, DefaultResourceLoader, getAgentDir, SessionManager, SettingsManager, } from "@earendil-works/pi-coding-agent";
+import { canonicalPath, isWithinPath } from "../../core/index.js";
+import { phaseCompactionExtension } from "./phase-compaction.js";
 // Tools available to the phase sub-agent. Matches the codecarto interception
 // allowlist (SAFE_TOOL_NAMES in extensions/codecarto/index.ts), minus bash.
 // Phases analyze source code and write findings; they don't need a shell.
 const PHASE_TOOL_NAMES = ["read", "edit", "write", "grep", "find", "ls"];
+const COMPACTION_SETTLE_TIMEOUT_MS = 30_000;
+export function needsPhaseContinuation(messages) {
+    const last = messages.at(-1);
+    if (!last)
+        return false;
+    return last.role === "toolResult" || (last.role === "assistant" && last.stopReason === "toolUse");
+}
+export function shouldContinuePhase(messages, primaryOutputPresent) {
+    return !primaryOutputPresent || needsPhaseContinuation(messages);
+}
+export async function primaryOutputExists(cwd, primaryOutput) {
+    const workspaceRoot = await canonicalPath(join(cwd, ".codecarto"));
+    const candidate = await canonicalPath(resolve(workspaceRoot, primaryOutput));
+    if (!isWithinPath(candidate, workspaceRoot))
+        return false;
+    return access(candidate).then(() => true, () => false);
+}
+export function buildPhaseContinuationPrompt(compacted) {
+    const recovery = compacted
+        ? "Continue the current CodeCartographer phase from the compacted context and durable checkpoint."
+        : "The previous phase run stopped before finalizing its required output. Continue from the current session context.";
+    return `${recovery} Finish the declared primary output, validation block, status updates, and closeout before ending.`;
+}
+export async function waitForCompaction(compactionCompleted, timeoutMs = COMPACTION_SETTLE_TIMEOUT_MS) {
+    let timer;
+    try {
+        return await Promise.race([
+            compactionCompleted,
+            new Promise((resolve) => { timer = setTimeout(() => resolve(false), timeoutMs); }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
 /**
  * Run one CodeCartographer phase as an isolated AgentSession. Awaiting this
  * function blocks until the phase completes (or aborts via signal). The
@@ -30,17 +70,19 @@ const PHASE_TOOL_NAMES = ["read", "edit", "write", "grep", "find", "ls"];
 export async function runPhase(ctx, prompt, callbacks = {}, options = {}, signal) {
     const cwd = ctx.cwd;
     const agentDir = getAgentDir();
-    // Resource loader: load Pi extensions and skills (so codecarto's own tool
-    // interception applies to the child) but skip prompt templates, themes,
-    // and project context files — they'd just bloat the system prompt.
+    // Resource loader: isolate the child from global extensions/skills and load
+    // only CodeCartographer's inline phase guards and compaction hooks. This
+    // avoids duplicate registration when CodeCartographer is globally installed
+    // while preserving the same safety when it was loaded explicitly with -e.
     const loader = new DefaultResourceLoader({
         cwd,
         agentDir,
-        noExtensions: false,
-        noSkills: false,
+        noExtensions: true,
+        noSkills: true,
         noPromptTemplates: true,
         noThemes: true,
         noContextFiles: true,
+        extensionFactories: [phaseCompactionExtension],
     });
     await loader.reload();
     // File-backed session in the same directory the orchestrator's TUI uses.
@@ -64,7 +106,6 @@ export async function runPhase(ctx, prompt, callbacks = {}, options = {}, signal
         agentDir,
         sessionManager,
         settingsManager: SettingsManager.create(cwd, agentDir),
-        modelRegistry: ctx.modelRegistry,
         model: ctx.model,
         tools: PHASE_TOOL_NAMES,
         resourceLoader: loader,
@@ -75,6 +116,8 @@ export async function runPhase(ctx, prompt, callbacks = {}, options = {}, signal
     let turnCount = 0;
     let currentMessageText = "";
     let aborted = false;
+    let resolveCompaction;
+    const compactionCompleted = new Promise((resolve) => { resolveCompaction = resolve; });
     const unsubscribe = session.subscribe((event) => {
         switch (event.type) {
             case "tool_execution_start": {
@@ -117,6 +160,16 @@ export async function runPhase(ctx, prompt, callbacks = {}, options = {}, signal
                 }
                 break;
             }
+            case "compaction_end": {
+                const compactEvent = event;
+                callbacks.onCompactionEnd?.({
+                    reason: compactEvent.reason,
+                    successful: compactEvent.result !== undefined && compactEvent.result !== null && !compactEvent.aborted && !compactEvent.errorMessage,
+                    aborted: compactEvent.aborted,
+                });
+                resolveCompaction?.(true);
+                break;
+            }
         }
     });
     let abortCleanup = () => { };
@@ -130,6 +183,15 @@ export async function runPhase(ctx, prompt, callbacks = {}, options = {}, signal
     }
     try {
         await session.prompt(prompt);
+        let primaryOutputPresent = true;
+        if (options.primaryOutput) {
+            primaryOutputPresent = await primaryOutputExists(cwd, options.primaryOutput);
+        }
+        if (!aborted && shouldContinuePhase(session.messages, primaryOutputPresent)) {
+            const compacted = await waitForCompaction(compactionCompleted);
+            if (!aborted)
+                await session.prompt(buildPhaseContinuationPrompt(compacted));
+        }
     }
     finally {
         unsubscribe();

package/dist/extensions/codecarto/agent-state.d.ts

@@ -1,4 +1,5 @@
 import type { AgentSession } from "@earendil-works/pi-coding-agent";
+import { type CompactionTelemetry } from "../../core/usage.ts";
 export type PhaseStatus = "running" | "completed" | "error" | "aborted";
 export interface PhaseActivity {
     phaseId: string;
@@ -17,6 +18,8 @@ export interface PhaseActivity {
         output: number;
         cacheWrite: number;
     };
+    /** Compaction outcomes observed during this phase session. */
+    compactions: CompactionTelemetry;
     session?: AgentSession;
     error?: string;
 }

package/dist/extensions/codecarto/agent-state.js

@@ -2,6 +2,7 @@
 // it from session-event callbacks; the agents widget (M2) reads it on each
 // render. Module-scoped Map so different command handlers can hand work to
 // the runner and the widget sees the same state without explicit plumbing.
+import { emptyCompactionTelemetry } from "../../core/usage.js";
 const phaseActivity = new Map();
 export function getPhaseActivity(phaseId) {
     return phaseActivity.get(phaseId);
@@ -22,6 +23,7 @@ export function startPhase(phaseId) {
         activeTools: new Map(),
         responseText: "",
         lifetimeUsage: { input: 0, output: 0, cacheWrite: 0 },
+        compactions: emptyCompactionTelemetry(),
     };
     phaseActivity.set(phaseId, activity);
     return activity;

package/dist/extensions/codecarto/agent-summary.d.ts

@@ -9,6 +9,11 @@ export interface PhaseSummaryInput {
         output: number;
         cacheWrite: number;
     };
+    compactions?: {
+        successful: number;
+        failed: number;
+        aborted: number;
+    };
     durationMs: number;
     responseText: string;
     sessionFile?: string;

package/dist/extensions/codecarto/agent-summary.js

@@ -39,6 +39,15 @@ function formatStats(input) {
     const totalTokens = input.tokens.input + input.tokens.output;
     if (totalTokens > 0)
         parts.push(formatTokens(totalTokens));
+    const compact = input.compactions;
+    if (compact && compact.successful + compact.failed + compact.aborted > 0) {
+        const details = [`${compact.successful} compaction${compact.successful === 1 ? "" : "s"}`];
+        if (compact.failed > 0)
+            details.push(`${compact.failed} failed`);
+        if (compact.aborted > 0)
+            details.push(`${compact.aborted} aborted`);
+        parts.push(details.join(", "));
+    }
     if (input.durationMs > 0)
         parts.push(formatDuration(input.durationMs));
     return parts.length > 0 ? `_${parts.join(" · ")}_` : "_(no activity recorded)_";

package/dist/extensions/codecarto/agent-widget.js

@@ -186,6 +186,9 @@ function formatRunningStats(a) {
     const tokens = a.lifetimeUsage.input + a.lifetimeUsage.output;
     if (tokens > 0)
         parts.push(formatTokens(tokens));
+    const compactions = a.compactions.successful + a.compactions.failed + a.compactions.aborted;
+    if (compactions > 0)
+        parts.push(`${compactions} compact`);
     parts.push(formatDuration(Date.now() - a.startedAt));
     return parts.join(" · ");
 }
@@ -198,6 +201,9 @@ function formatFinishedStats(a) {
     const tokens = a.lifetimeUsage.input + a.lifetimeUsage.output;
     if (tokens > 0)
         parts.push(formatTokens(tokens));
+    const compactions = a.compactions.successful + a.compactions.failed + a.compactions.aborted;
+    if (compactions > 0)
+        parts.push(`${compactions} compact`);
     const dur = a.completedAt ? a.completedAt - a.startedAt : 0;
     if (dur > 0)
         parts.push(formatDuration(dur));

package/dist/extensions/codecarto/auto-runner.js

@@ -69,7 +69,16 @@ export async function runSinglePhase(ctx, pi, state, phase, options) {
                 activity.lifetimeUsage.output += usage.output;
                 activity.lifetimeUsage.cacheWrite += usage.cacheWrite;
             },
-        }, { sessionName: `CodeCartographer phase: ${phase.id}` }, options.signal);
+            onCompactionEnd: (event) => {
+                activity.compactions.reasons[event.reason]++;
+                if (event.aborted)
+                    activity.compactions.aborted++;
+                else if (event.successful)
+                    activity.compactions.successful++;
+                else
+                    activity.compactions.failed++;
+            },
+        }, { sessionName: `CodeCartographer phase: ${phase.id}`, primaryOutput: phase.primary_output }, options.signal);
         const status = result.aborted ? "aborted" : "completed";
         finishPhase(phase.id, { status });
         if (ctx.hasUI) {
@@ -85,6 +94,7 @@ export async function runSinglePhase(ctx, pi, state, phase, options) {
                 turnCount: activity.turnCount,
                 toolUses: activity.toolUses,
                 tokens: activity.lifetimeUsage,
+                compactions: activity.compactions,
                 durationMs: (activity.completedAt ?? Date.now()) - activity.startedAt,
                 responseText: result.responseText,
                 sessionFile: result.sessionFile,
@@ -113,6 +123,7 @@ export async function runSinglePhase(ctx, pi, state, phase, options) {
                 turnCount: activity.turnCount,
                 toolUses: activity.toolUses,
                 tokens: activity.lifetimeUsage,
+                compactions: activity.compactions,
                 durationMs: (activity.completedAt ?? Date.now()) - activity.startedAt,
                 responseText: "",
                 error: message,
@@ -394,6 +405,7 @@ async function recordUsage(workspaceDir, phaseId, status, activity, sessionFile)
                 output: activity.lifetimeUsage.output,
                 cache_write: activity.lifetimeUsage.cacheWrite,
             },
+            compactions: activity.compactions,
             ...(sessionFile ? { session_file: sessionFile } : {}),
         });
     }

package/dist/extensions/codecarto/dashboard-narrator.js

@@ -155,7 +155,6 @@ async function runNarratorOnce(ctx, prompt) {
         agentDir,
         sessionManager: SessionManager.inMemory(cwd),
         settingsManager: SettingsManager.create(cwd, agentDir),
-        modelRegistry: ctx.modelRegistry,
         model: ctx.model,
         tools: [],
         resourceLoader: loader,

package/dist/extensions/codecarto/index.d.ts

@@ -1,2 +1,2 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { type ExtensionAPI } from "@earendil-works/pi-coding-agent";
 export default function codeCartographerExtension(pi: ExtensionAPI): void;

package/dist/extensions/codecarto/index.js

@@ -6,6 +6,7 @@ import { parseDashboardFlags } from "./dashboard-flags.js";
 import { narrateDashboard } from "./dashboard-narrator.js";
 import { writeDashboard } from "./dashboard-writer.js";
 import { parseNextFlags } from "./next-flags.js";
+import { phaseCompactionExtension } from "./phase-compaction.js";
 import { buildPhasePrompt, buildSkillPrompt, buildValidationSummary, canonicalPath, computePerPhaseTotals, computeTotals, createEmptyStatus, DEFAULT_PIPELINE_PATH, getNextEligiblePhase, getPipelineLabel, getWorkspaceState, isWithinPath, listSkillNames, loadCodecartoConfig, loadUsage, loadYamlFile, normalizeForComparison, packagedWorkspaceDir, pathExists, PACKAGE_VERSION, PIPELINE_ALIASES, resolvePhase, resolvePipelineChoice, stringifySimpleYaml, validatePhaseOutput, } from "../../core/index.js";
 const STATUS_WIDGET_ID = "codecarto-widget";
 const STATUS_LINE_ID = "codecarto-status";
@@ -62,6 +63,7 @@ function setUiState(ctx, state, extraLines = []) {
     ctx.ui.setWidget(STATUS_WIDGET_ID, buildStatusLines(state, extraLines));
 }
 export default function codeCartographerExtension(pi) {
+    phaseCompactionExtension(pi);
     let lastFeedbackLines = [];
     let codecartoModeActive = false;
     const readWorkspaceState = async (ctx, notifyOnError = true) => {
@@ -143,6 +145,28 @@ export default function codeCartographerExtension(pi) {
         }
         return undefined;
     });
+    pi.registerCommand("codecarto-open", {
+        description: "Activate an existing .codecarto workspace without resetting durable state",
+        handler: async (_args, ctx) => {
+            const workspaceDir = join(ctx.cwd, ".codecarto");
+            if (!(await pathExists(join(workspaceDir, "workflow", "status.yaml")))) {
+                ctx.ui.notify("No existing CodeCartographer workspace found. Run /codecarto-init first.", "warning");
+                return;
+            }
+            try {
+                const state = await getWorkspaceState(ctx.cwd);
+                codecartoModeActive = true;
+                lastFeedbackLines = [`Opened existing workspace: ${getPipelineLabel(state.status.pipeline)}`];
+                pi.setActiveTools(SAFE_TOOL_NAMES);
+                await refreshWorkspaceUi(ctx, lastFeedbackLines);
+                ctx.ui.notify("Opened existing CodeCartographer workspace without resetting state.", "info");
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                ctx.ui.notify(`Unable to open CodeCartographer workspace: ${message}`, "error");
+            }
+        },
+    });
     pi.registerCommand("codecarto-init", {
         description: "Initialize .codecarto/ in the current repository",
         getArgumentCompletions: (prefix) => {
@@ -426,11 +450,14 @@ export default function codeCartographerExtension(pi) {
             lines.push(`Total runs: ${totals.runs}`);
             lines.push(`Total tokens: ${formatUsageTokens(totals.tokens.input)} in · ${formatUsageTokens(totals.tokens.output)} out · ${formatUsageTokens(totals.tokens.cache_write)} cache-write`);
             lines.push(`Total duration: ${formatUsageDuration(totals.duration_ms)} · ${totals.tool_uses} tool uses`);
+            lines.push(totals.compaction_runs > 0
+                ? `Compactions: ${totals.compactions.successful} successful · ${totals.compactions.failed} failed · ${totals.compactions.aborted} aborted`
+                : "Compactions: unavailable — historical or host usage records did not report compaction events");
             lines.push("");
             lines.push("Per-phase totals:");
             for (const [phaseId, t] of perPhase) {
                 const tokensTotal = t.tokens.input + t.tokens.output;
-                lines.push(`  ${phaseId}: ${t.runs} run${t.runs === 1 ? "" : "s"} · ${formatUsageTokens(tokensTotal)} tokens · ${t.tool_uses} tool uses · ${formatUsageDuration(t.duration_ms)}`);
+                lines.push(`  ${phaseId}: ${t.runs} run${t.runs === 1 ? "" : "s"} · ${formatUsageTokens(tokensTotal)} tokens · ${t.tool_uses} tool uses · ${t.compaction_runs > 0 ? `${t.compactions.successful + t.compactions.failed + t.compactions.aborted} compactions` : "compactions unavailable"} · ${formatUsageDuration(t.duration_ms)}`);
             }
             lastFeedbackLines = lines;
             setUiState(ctx, state, lastFeedbackLines);

package/dist/extensions/codecarto/phase-compaction.d.ts

@@ -0,0 +1,11 @@
+import { type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+export declare function phaseIdFromSessionName(sessionName: string | undefined): string | null;
+export declare function buildPhaseCompactionInstructions(phaseId: string, primaryOutput?: string): string;
+export declare function writePhaseCheckpoint(cwd: string, phaseId: string, summary: string, tokensBefore: number): Promise<string>;
+/**
+ * Phase-only compaction hooks shared by the parent extension and isolated
+ * child sessions. Keeping this as a standalone inline extension ensures that
+ * children spawned from an explicitly loaded (`pi -e ...`) CodeCartographer
+ * extension receive the same checkpoint behavior as globally installed runs.
+ */
+export declare function phaseCompactionExtension(pi: ExtensionAPI): void;

package/dist/extensions/codecarto/phase-compaction.js

@@ -0,0 +1,115 @@
+import { mkdir, rename, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { compact } from "@earendil-works/pi-coding-agent";
+import { canonicalPath, getWorkspaceState, isWithinPath } from "../../core/index.js";
+const PHASE_SESSION_PREFIX = "CodeCartographer phase: ";
+export function phaseIdFromSessionName(sessionName) {
+    if (!sessionName?.startsWith(PHASE_SESSION_PREFIX))
+        return null;
+    const phaseId = sessionName.slice(PHASE_SESSION_PREFIX.length).trim();
+    return /^[a-z0-9][a-z0-9-]*$/.test(phaseId) ? phaseId : null;
+}
+export function buildPhaseCompactionInstructions(phaseId, primaryOutput) {
+    const output = primaryOutput ? `.codecarto/${primaryOutput}` : "the phase's declared primary output";
+    return [
+        `This is a CodeCartographer phase session for ${phaseId}.`,
+        `Produce a phase-aware continuation summary for ${output}.`,
+        "Preserve these details explicitly:",
+        "- phase goal and constraints",
+        "- evidence-backed conclusions and their evidence levels",
+        "- files inspected and subsystems covered or skipped",
+        "- primary-output sections already written and sections still missing",
+        "- edits already made under .codecarto/",
+        "- open questions and carry-forward candidates",
+        "- validation criteria already satisfied and validation criteria still at risk",
+        "- exact next steps needed to finish and validate the phase.",
+        "Do not turn an inference into an observed fact. Retain file paths, finding IDs, and unresolved gaps verbatim where possible.",
+    ].join("\n");
+}
+export async function writePhaseCheckpoint(cwd, phaseId, summary, tokensBefore) {
+    const dir = join(cwd, ".codecarto", "scratch", "checkpoints");
+    const target = join(dir, `${phaseId}.md`);
+    const temp = `${target}.${process.pid}.${Date.now()}.tmp`;
+    await mkdir(dir, { recursive: true });
+    const content = [
+        "---",
+        `phase: ${phaseId}`,
+        `updated_at: ${new Date().toISOString()}`,
+        `tokens_before: ${tokensBefore}`,
+        "source: pi-compaction",
+        "---",
+        "",
+        "# Phase checkpoint",
+        "",
+        summary.trim(),
+        "",
+    ].join("\n");
+    await writeFile(temp, content, "utf8");
+    await rename(temp, target);
+    return target;
+}
+/**
+ * Phase-only compaction hooks shared by the parent extension and isolated
+ * child sessions. Keeping this as a standalone inline extension ensures that
+ * children spawned from an explicitly loaded (`pi -e ...`) CodeCartographer
+ * extension receive the same checkpoint behavior as globally installed runs.
+ */
+export function phaseCompactionExtension(pi) {
+    pi.on("tool_call", async (event, ctx) => {
+        if (!phaseIdFromSessionName(ctx.sessionManager.getSessionName()))
+            return undefined;
+        if (event.toolName === "bash") {
+            return { block: true, reason: "CodeCartographer phase sessions disable bash to keep source analysis read-only." };
+        }
+        if (event.toolName === "edit" || event.toolName === "write") {
+            const inputPath = typeof event.input.path === "string" ? event.input.path : "";
+            const strippedPath = inputPath.startsWith("@") ? inputPath.slice(1) : inputPath;
+            const targetPath = await canonicalPath(resolve(ctx.cwd, strippedPath));
+            const allowedRoot = await canonicalPath(join(ctx.cwd, ".codecarto"));
+            if (!isWithinPath(targetPath, allowedRoot)) {
+                return {
+                    block: true,
+                    reason: `CodeCartographer phase sessions only allow ${event.toolName} within .codecarto/`,
+                };
+            }
+        }
+        return undefined;
+    });
+    pi.on("session_before_compact", async (event, ctx) => {
+        const phaseId = phaseIdFromSessionName(ctx.sessionManager.getSessionName());
+        if (!phaseId || !ctx.model)
+            return undefined;
+        try {
+            const state = await getWorkspaceState(ctx.cwd);
+            const phase = state.pipeline.phases.find((candidate) => candidate.id === phaseId);
+            const auth = await ctx.modelRegistry.getApiKeyAndHeaders(ctx.model);
+            if (!auth.ok || !auth.apiKey)
+                return undefined;
+            const instructions = buildPhaseCompactionInstructions(phaseId, phase?.primary_output);
+            const result = await compact(event.preparation, ctx.model, auth.apiKey, auth.headers, instructions, event.signal);
+            return { compaction: result };
+        }
+        catch (error) {
+            if (ctx.hasUI) {
+                const message = error instanceof Error ? error.message : String(error);
+                ctx.ui.notify(`Phase-aware compaction unavailable (${message}); using host default.`, "warning");
+            }
+            return undefined;
+        }
+    });
+    pi.on("session_compact", async (event, ctx) => {
+        const phaseId = phaseIdFromSessionName(ctx.sessionManager.getSessionName());
+        if (!phaseId)
+            return;
+        try {
+            await writePhaseCheckpoint(ctx.cwd, phaseId, event.compactionEntry.summary, event.compactionEntry.tokensBefore);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (ctx.hasUI)
+                ctx.ui.notify(`Phase checkpoint could not be written: ${message}`, "warning");
+            else
+                console.warn(`[codecarto] Phase checkpoint could not be written: ${message}`);
+        }
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codecartographer-pi",
-  "version": "0.9.1",
+  "version": "0.11.0",
   "description": "CodeCartographer packaged for Pi as an extension-driven workflow wrapper.",
   "type": "module",
   "keywords": [
@@ -43,7 +43,7 @@
     "@modelcontextprotocol/sdk": "^1.29.0"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "~0.74.0",
+    "@earendil-works/pi-coding-agent": "^0.80.10",
     "@sinclair/typebox": "*"
   },
   "pi": {