billion-context-pi 0.1.53 → 0.1.54-pr.264.52

package/dist/delegate-tool.d.ts

@@ -8,7 +8,7 @@ export declare function delegateSpawnOptions(cwd: string, env: NodeJS.ProcessEnv
  *  run the SDK inside another node process, so probe instead. Non-pi hosts
  *  (omp) keep argv[1] untouched. */
 export declare function resolvePiCliEntry(argv1: string, env?: NodeJS.ProcessEnv, piHost?: boolean): string;
-type RunStatus = "running" | "completed" | "failed" | "cancelled";
+export type RunStatus = "running" | "completed" | "failed" | "cancelled";
 interface DelegateRun {
     runId: string;
     agent: string;
@@ -104,6 +104,7 @@ declare const WaitParams: Type.TObject<{
 }>;
 export declare function accumulateUsage(a: Usage | undefined, b: Usage): Usage;
 export declare function makeDelegateTool(pi: ExtensionAPI): ToolDefinition<typeof DelegateParams>;
+export declare function formatRunResult(run: DelegateRun): string;
 /** Runs that reached a terminal state but whose result never reached the
  *  model: no parked waiter, not consumed by a tool result, and never injected
  *  as a notification. The model was promised a notification ("do NOT keep
@@ -163,5 +164,12 @@ export declare function buildChildArgs(args: DelegateArgs, rolePrompt: string, c
     isAsync: boolean;
     useJsonStream: boolean;
 }>;
-export declare function injectResult(pi: ExtensionAPI, agent: string, runId: string, task: string, code: number | null, file: string, timedOut?: string, usage?: Usage, mode?: "merged" | "separate", usageAlreadyReported?: boolean, body?: string): boolean;
+/** Watchdog/EOF finalize arrives with code === null (the child was killed or
+ *  never exited). If a result was delivered (non-empty reply or stderr), the
+ *  run counts as completed (0); otherwise it stays null = genuine failure. */
+export declare function effectiveExitCode(code: number | null, output: string, stderr: string): number | null;
+/** status (set by finalize from the effective exit code) is the authority for
+ *  the FAILED/completed decision; the raw code is diagnostic display only
+ *  ("exit ?"), so the notification can never disagree with run.status. */
+export declare function injectResult(pi: ExtensionAPI, agent: string, runId: string, task: string, status: RunStatus, code: number | null, file: string, timedOut?: string, usage?: Usage, mode?: "merged" | "separate", usageAlreadyReported?: boolean, body?: string): boolean;
 export {};

package/dist/index.js

@@ -424,18 +424,42 @@ function assignRefs(messages, options) {
   return { map, nextIndex: cursor, newlyAssigned };
 }
 function allocateFreeRef(map, start) {
-  let candidate = Math.max(start, MIN_INDEX);
-  while (candidate <= MAX_INDEX) {
+  const from = Math.max(start, MIN_INDEX);
+  for (let candidate = from; candidate <= MAX_INDEX; candidate++) {
+    const text = indexToRef(candidate);
+    if (!map.byRef[text]) {
+      return { text, index: candidate };
+    }
+  }
+  for (let candidate = MIN_INDEX; candidate < from; candidate++) {
     const text = indexToRef(candidate);
     if (!map.byRef[text]) {
       return { text, index: candidate };
     }
-    candidate++;
   }
   throw new Error(
-    `ref capacity exhausted: cannot allocate beyond ${indexToRef(MAX_INDEX)}`
+    `ref capacity exhausted: all ${MAX_INDEX} ref slots are occupied by live messages \u2014 nothing left to reclaim`
   );
 }
+function pruneDeadRefs(map, liveIds) {
+  let pruned = 0;
+  const byRaw = {};
+  for (const [rawId, ref] of Object.entries(map.byRaw)) {
+    if (liveIds.has(rawId)) {
+      byRaw[rawId] = ref;
+      continue;
+    }
+    pruned++;
+  }
+  return { map: rebuildRefIndex({ byRaw, byRef: {} }), pruned };
+}
+function rebuildRefIndex(map) {
+  const byRef = {};
+  for (const [rawId, ref] of Object.entries(map.byRaw)) {
+    if (ref !== BLOCKED_REF) byRef[ref] = rawId;
+  }
+  return { byRaw: { ...map.byRaw }, byRef };
+}
 function highestUsedIndex(map) {
   let highest = 0;
   for (const ref of Object.values(map.byRaw)) {
@@ -634,6 +658,13 @@ function syncBlocks(messages, state) {
       deactivated.push(block.blockId);
     }
   }
+  const liveIds = new Set(presentIds);
+  for (const block of result.blocks) {
+    if (!block.active) continue;
+    for (const id of block.effectiveMessageIds) liveIds.add(id);
+  }
+  const prunedRefs = pruneDeadRefs(result.messageRefs, liveIds);
+  result.messageRefs = prunedRefs.map;
   return { state: result, deactivated };
 }
 function defaultConfig(modelContextLimit, overrides = {}) {
@@ -744,12 +775,14 @@ var BoundaryNotFoundError = class extends Error {
   code = "BOUNDARY_NOT_FOUND";
   kind;
   endpoint;
-  constructor(kind, endpoint, message) {
+  reason;
+  constructor(kind, endpoint, message, reason = null) {
     super(message);
     this.name = "BoundaryNotFoundError";
     this.code = "BOUNDARY_NOT_FOUND";
     this.kind = kind;
     this.endpoint = endpoint;
+    this.reason = reason;
   }
 };
 function resolveBoundaries(input) {
@@ -820,7 +853,7 @@ function resolveAnchorIndex(boundary, state, indexByMessageId, endpoint) {
       throw new BoundaryNotFoundError(
         "unknown",
         endpoint,
-        `${label}="${boundary.raw}" does not exist in this session (typo or wrong session) \u2014 run acp_status for current refs.`
+        `${label}="${boundary.raw}" does not exist in this session (typo, wrong session, or the message was edited/removed and its ref released) \u2014 run acp_status for current refs.`
       );
     }
     const index = indexByMessageId.get(rawId);
@@ -834,10 +867,33 @@ function resolveAnchorIndex(boundary, state, indexByMessageId, endpoint) {
         snapped: `${label}="${boundary.raw}" refers to a message already compressed into an active block \u2014 anchored to the active block covering it instead.`
       };
     }
+    const coveringActive = state.blocks.filter(
+      (block2) => block2.active && block2.effectiveMessageIds.includes(rawId)
+    );
+    if (coveringActive.length > 0) {
+      throw new BoundaryNotFoundError(
+        "consumed",
+        endpoint,
+        `${label}="${boundary.raw}" is already compressed into active block(s) ${coveringActive.map((block2) => block2.blockId).join(", ")} \u2014 retry with the block ref(s) instead of the message ref.`,
+        "consumed"
+      );
+    }
+    const generationReplaced = state.blocks.some(
+      (block2) => !block2.active && block2.effectiveMessageIds.includes(rawId)
+    );
+    if (generationReplaced) {
+      throw new BoundaryNotFoundError(
+        "consumed",
+        endpoint,
+        `${label}="${boundary.raw}" was compressed into a block that has since been distilled or consumed \u2014 its content is no longer available in this session; run acp_status for current refs.`,
+        "generation-replaced"
+      );
+    }
     throw new BoundaryNotFoundError(
       "consumed",
       endpoint,
-      `${label}="${boundary.raw}" not found in visible context (likely consumed by an existing block).`
+      `${label}="${boundary.raw}" no longer exists \u2014 the message was edited or removed (its content id changed); run acp_status for current refs.`,
+      "edit-drift"
     );
   }
   const block = blockById(state, `b${boundary.numericId}`);
@@ -866,16 +922,21 @@ function resolveAnchorIndex(boundary, state, indexByMessageId, endpoint) {
     };
   }
   if (!block.active) {
+    const consumer = state.blocks.find(
+      (candidate) => candidate.active && candidate.directBlockIds.includes(block.blockId) && visibleBlockAnchor(candidate, indexByMessageId) !== null
+    );
     throw new BoundaryNotFoundError(
       "consumed",
       endpoint,
-      `${label}="b${boundary.numericId}" not found in visible context (block distilled/consumed by a higher-tier block).`
+      consumer ? `${label}="b${boundary.numericId}" was consumed by ${consumer.blockId} (higher-tier block) \u2014 retry with ${consumer.blockId} instead.` : `${label}="b${boundary.numericId}" is inactive (distilled or garbage-collected) and none of its content is visible in the current context \u2014 run acp_status for current refs.`,
+      "generation-replaced"
     );
   }
   throw new BoundaryNotFoundError(
     "consumed",
     endpoint,
-    `${label}="b${boundary.numericId}" is an active block but none of its content (raw messages or rendered summary) is visible in the current context \u2014 run acp_status to verify.`
+    `${label}="b${boundary.numericId}" is an active block but none of its content (raw messages or rendered summary) is present in the current view \u2014 its messages were likely edited or removed (id drift); it will be deactivated on the next state sync. Run acp_status to verify.`,
+    "edit-drift"
   );
 }
 function activeOwnerAnchor(state, ownedIds, indexByMessageId) {
@@ -1800,10 +1861,33 @@ function numericBlockId(id) {
   const parsed = /^b(\d+)$/.exec(id);
   return parsed ? Number(parsed[1]) : 0;
 }
+function refGateDiagnostics(state, requestedRanges, unknownCount) {
+  const highest = highestUsedIndex(state.messageRefs);
+  const highestRef = highest > 0 ? indexToRef(highest) : "none";
+  return `[diagnostics: session highest ref=${highestRef}, unknown ranges in request=${unknownCount}/${requestedRanges}, session history=${state.stats.compressionCount} compression(s), ${state.blocks.length} block(s)]`;
+}
+function danglingMessageRefs(state, messages, spec) {
+  const visible = new Set(messages.map((m) => m.id));
+  const dangling = [];
+  for (const ref of [spec.startRef, spec.endRef]) {
+    const parsed = parseBoundary(ref);
+    if (!parsed || parsed.kind !== "message") continue;
+    const rawId = state.messageRefs.byRef[parsed.raw] ?? state.messageRefs.byRef[indexToRef(parsed.numericId)];
+    if (!rawId || visible.has(rawId)) continue;
+    const covered = state.blocks.some(
+      (block) => block.active && block.effectiveMessageIds.includes(rawId)
+    );
+    if (!covered) dangling.push(parsed.raw);
+  }
+  return dangling;
+}
 function createCore(ports = {}) {
   const countTokens = ports.countTokens ?? defaultCountTokens;
   function applyCompression(input) {
-    const state = cloneState(input.state);
+    const state = syncBlocks(
+      input.messages,
+      input.state
+    ).state;
     const runId = allocateRunId(state);
     let blocksCreated = 0;
     let tokensCompressed = 0;
@@ -1900,7 +1984,15 @@ function createCore(ports = {}) {
       if (!hasBlockBoundaryRange && totalRangeChars < input.config.compress.minCompressRange) {
         const live = activeBlocks(state).map((b) => b.blockId).sort((x, y) => numericBlockId(x) - numericBlockId(y));
         const liveHint = live.length > 0 ? ` Current active blocks span ${live[0]}..${live[live.length - 1]} \u2014 retry with startId/endId set to active block IDs in that span.` : "";
-        const gateMessage = resolvableCount === 0 && consumedRanges.length === 0 && unknownCount > 0 ? `None of the ${input.ranges.length} requested range(s) resolved \u2014 every ref failed with "does not exist in this session". Refs recorded before an earlier compress are stale: each successful compress renumbers the remaining refs. Run acp_status, then call the compress tool again using only the refs it reports.` : consumedRanges.length > 0 ? `Requested range(s) already compressed (e.g. ${consumedRanges[0].startRef}..${consumedRanges[0].endRef}) \u2014 your refs are stale: a prior compress renumbered the remaining refs, so this range now falls inside an active block. Run acp_status, then call the compress tool again using only the CURRENT compressible ranges it reports.${liveHint}` : `Total compressible content too small (${totalRangeChars} chars across ${countedRanges} range(s), min ${input.config.compress.minCompressRange}). Combine more messages into your range(s) to meet the threshold.`;
+        const diagnostics = refGateDiagnostics(
+          state,
+          input.ranges.length,
+          unknownCount
+        );
+        const danglingRefs = consumedRanges.flatMap(
+          (spec) => danglingMessageRefs(state, input.messages, spec)
+        );
+        const gateMessage = resolvableCount === 0 && consumedRanges.length === 0 && unknownCount > 0 ? `None of the ${input.ranges.length} requested range(s) resolved \u2014 every ref is unknown to this session. Refs are per-session snapshots, assigned once when a message is first rendered; no compress reassigns them, so unknown refs cannot come from an earlier compress in this session. They come from a different generation: a previous session instance (switching model or upstream mid-conversation starts a fresh session whose refs restart at m00001), the generation before a native-compaction rebase (which also resets refs to m00001), a typo, or a message that was edited or removed (its old ref was released when the content id changed). ${diagnostics} Run acp_status, then call the compress tool again using only the refs it reports.` : consumedRanges.length > 0 ? danglingRefs.length > 0 ? `Requested range(s) cannot be anchored (e.g. ${consumedRanges[0].startRef}..${consumedRanges[0].endRef}) \u2014 the refs exist in this session's ref map, but the messages they point to are no longer in the visible context and no active block covers them: the message content changed (or the message was filtered out of the view) and now carries a new ref, leaving your old refs dangling. ${diagnostics} Run acp_status, then call the compress tool again using only the refs it reports.` : `Requested range(s) already compressed (e.g. ${consumedRanges[0].startRef}..${consumedRanges[0].endRef}) \u2014 those refs no longer point to directly compressible content: the range is covered by active block(s) or the block ref(s) are stale (distilled or consumed). ${diagnostics} Run acp_status, then call the compress tool again using only the CURRENT compressible ranges it reports.${liveHint}` : `Total compressible content too small (${totalRangeChars} chars across ${countedRanges} range(s), min ${input.config.compress.minCompressRange}). Combine more messages into your range(s) to meet the threshold.`;
         return {
           state: input.state,
           result: {
@@ -2043,9 +2135,15 @@ var assignRefsNode = {
   run(io, ctx) {
     const hasProtection = ctx.config.protectedTools.length > 0 || !!ctx.config.isToolProtected;
     const protectedFn = hasProtection ? (m) => isMessageProtected(m, ctx.config) : void 0;
+    const liveIds = new Set(io.messages.map((m) => m.id));
+    for (const block of io.state.blocks) {
+      if (!block.active) continue;
+      for (const id of block.effectiveMessageIds) liveIds.add(id);
+    }
+    const pruned = pruneDeadRefs(io.state.messageRefs, liveIds);
     const refResult = assignRefs(io.messages, {
-      existing: io.state.messageRefs,
-      nextIndex: highestUsedIndex(io.state.messageRefs) + 1,
+      existing: pruned.map,
+      nextIndex: highestUsedIndex(pruned.map) + 1,
       isProtected: protectedFn
     });
     return { ...io, state: { ...io.state, messageRefs: refResult.map } };
@@ -2617,26 +2715,6 @@ function computeContextBreakdown(messages, total, growth, countTokens) {
   }
   return { system, tool, summaries, code, text, total, growth };
 }
-function cloneState(state) {
-  return {
-    blocks: state.blocks.map((block) => ({
-      ...block,
-      directMessageIds: [...block.directMessageIds],
-      effectiveMessageIds: [...block.effectiveMessageIds],
-      directBlockIds: [...block.directBlockIds]
-    })),
-    messageRefs: {
-      byRaw: { ...state.messageRefs.byRaw },
-      byRef: { ...state.messageRefs.byRef }
-    },
-    tokenSnapshot: { ...state.tokenSnapshot ?? {} },
-    nudge: { ...state.nudge, anchors: { ...state.nudge.anchors } },
-    stats: { ...state.stats },
-    absorbed: (state.absorbed ?? []).map((record) => ({ ...record })),
-    nextBlockId: state.nextBlockId,
-    nextRunId: state.nextRunId
-  };
-}
 function scoreRelevance(block, terms) {
   const topic = (block.topic ?? "").toLowerCase();
   const summary = block.summary.toLowerCase();
@@ -2967,9 +3045,9 @@ function parseObjectValue(value, callId, diag) {
   const content = value["content"];
   if (content === void 0) {
     const single = validateEntry(value, callId);
-    if (single) {
+    if ("range" in single) {
       diag.kind = "ok";
-      return finish([single], diag);
+      return finish([single.range], diag);
     }
     diag.kind = "missing-content";
     return finish([], diag);
@@ -2990,7 +3068,7 @@ function parseObjectValue(value, callId, diag) {
     diag.kind = "content-not-array";
     return finish([], diag);
   }
-  const { ranges, invalid } = validateEntries(entries, callId);
+  const { ranges, invalid, reasons } = validateEntries(entries, callId);
   const topTopic = stringOr(value["topic"]);
   const topMaxChars = value["summaryMaxChars"];
   const hasTopMaxChars = typeof topMaxChars === "number" && Number.isFinite(topMaxChars);
@@ -3001,6 +3079,7 @@ function parseObjectValue(value, callId, diag) {
     }
   }
   diag.invalidItems = invalid;
+  if (reasons.length > 0) diag.invalidReasons = reasons;
   diag.kind = salvaged ? "truncated" : ranges.length > 0 ? "ok" : "no-valid-ranges";
   return finish(ranges, diag);
 }
@@ -3024,36 +3103,43 @@ function finish(ranges, diag) {
   return { ranges, diagnostics: diag };
 }
 function finishSalvage(entries, callId, diag, truncatedShape) {
-  const { ranges, invalid } = validateEntries(entries, callId);
+  const { ranges, invalid, reasons } = validateEntries(entries, callId);
   diag.invalidItems = invalid;
+  if (reasons.length > 0) diag.invalidReasons = reasons;
   diag.kind = entries.length > 0 || truncatedShape ? "truncated" : "malformed-json";
   return finish(ranges, diag);
 }
 function validateEntries(entries, callId) {
   const ranges = [];
+  const reasons = [];
   let invalid = 0;
-  for (const entry of entries) {
-    const range = validateEntry(entry, callId);
-    if (range !== null) ranges.push(range);
-    else invalid++;
+  for (let i = 0; i < entries.length; i++) {
+    const outcome = validateEntry(entries[i], callId);
+    if ("range" in outcome) ranges.push(outcome.range);
+    else {
+      invalid++;
+      reasons.push(`entry ${i}: ${outcome.reason}`);
+    }
   }
-  return { ranges, invalid };
+  return { ranges, invalid, reasons };
 }
 function validateEntry(entry, callId) {
-  if (entry === null || typeof entry !== "object" || Array.isArray(entry)) return null;
+  if (entry === null || typeof entry !== "object" || Array.isArray(entry)) return { reason: "not an object" };
   const e = entry;
   const start = stringOr(e["startRef"]) ?? stringOr(e["startId"]) ?? stringOr(e["messageId"]);
   const end = stringOr(e["endRef"]) ?? stringOr(e["endId"]) ?? stringOr(e["messageId"]);
-  if (start === void 0 || end === void 0) return null;
+  if (start === void 0 || end === void 0) {
+    return { reason: "missing range bounds (need startRef/startId and endRef/endId)" };
+  }
   const summary = stringOr(e["summary"]);
-  if (summary === void 0) return null;
+  if (summary === void 0) return { reason: "missing summary" };
   const range = { startRef: start, endRef: end, summary };
   const topic = stringOr(e["topic"]);
   if (topic !== void 0) range.topic = topic;
   const maxChars = e["summaryMaxChars"];
   if (typeof maxChars === "number" && Number.isFinite(maxChars)) range.summaryMaxChars = maxChars;
   if (callId !== void 0) range.compressCallId = callId;
-  return range;
+  return { range };
 }
 function stringOr(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
@@ -10691,7 +10777,7 @@ async function runDelegate(pi, args, ctx, signal) {
             await appendFile(file2, fallback ? `${fallback}
 ` : "(no output)\n");
           }
-          const effectiveCode = code ?? (output || stderrText ? 0 : null);
+          const effectiveCode = effectiveExitCode(code, output, stderrText);
           run.result = { code, file: file2, body: body2 };
           run.status = effectiveCode === 0 ? "completed" : "failed";
           run.finishedAt = Date.now();
@@ -10709,7 +10795,7 @@ async function runDelegate(pi, args, ctx, signal) {
             return;
           }
           const mode = delegateDisplayUsage;
-          const injected = injectResult(pi, args.agent, runId, args.task, code, file2, run.timedOut, run.usage, mode, run.usageReported, run.status === "failed" ? body2 : void 0);
+          const injected = injectResult(pi, args.agent, runId, args.task, run.status, code, file2, run.timedOut, run.usage, mode, run.usageReported, run.status === "failed" ? body2 : void 0);
           if (run.usage && !run.usageReported && (mode === "separate" || injected)) {
             run.usageReported = true;
           }
@@ -10834,15 +10920,18 @@ function formatSyncResult(agent, runId, task, r, file) {
   const body = r.timedOut ? "(timed out)" : r.stderr.trim() || "(no stderr)";
   return formatPayload(header, file, task, body);
 }
-function injectResult(pi, agent, runId, task, code, file, timedOut, usage, mode = "separate", usageAlreadyReported, body) {
+function effectiveExitCode(code, output, stderr) {
+  return code ?? (output || stderr ? 0 : null);
+}
+function injectResult(pi, agent, runId, task, status, code, file, timedOut, usage, mode = "separate", usageAlreadyReported, body) {
   const send = pi.sendUserMessage;
   if (typeof send !== "function") {
     debug.event("delegate-inject-skipped", { runId, reason: "sendUserMessage unavailable" });
     logWarn("delegate", { event: "inject-skipped", runId, reason: "sendUserMessage unavailable" });
     return false;
   }
-  const failed = code !== 0;
-  const status = failed ? "FAILED \u26A0\uFE0F" : "completed";
+  const failed = status === "failed";
+  const statusLabel = failed ? "FAILED \u26A0\uFE0F" : "completed";
   const remaining = Array.from(runs.values()).filter((r) => r.status === "running").length;
   const remainingLine = remaining > 0 ? ` ${remaining} delegate${remaining === 1 ? " is" : "s are"} still running; keep doing other work and their notifications will arrive as they finish.` : " No delegates are currently running.";
   const timeoutNote = timedOut ? ` (timed out: ${timedOut})` : "";
@@ -10877,7 +10966,7 @@ Tokens: ${totalUsage.input.toLocaleString()} in, ${totalUsage.output.toLocaleStr
     if (lines.length) usageNote = ` Usage: ${lines.join(", ")}.`;
   }
   const closing = failed ? "This delegate did NOT complete its task \u2014 its result is missing from your work. Read the error excerpt (and the result file if present), then decide whether to re-dispatch the task before wrapping up. This is an automated system notification, NOT a user message." : "This is an automated system notification, NOT a user message. Read the result file if you need the details, then continue your original task; do not treat this as a new user request.";
-  const header = `[acp_delegate ${status}] **${agent}** (runId \`${runId}\`, exit ${code ?? "?"})${timeoutNote}${remainingLine}${usageNote} ${closing}`;
+  const header = `[acp_delegate ${statusLabel}] **${agent}** (runId \`${runId}\`, exit ${code ?? "?"})${timeoutNote}${remainingLine}${usageNote} ${closing}`;
   const { text: recoveryText, covered } = buildRecoveryNotice(Array.from(runs.values()), runId);
   const text = formatPayload(header, file, task, failed ? body : void 0) + (recoveryText ? `
 
@@ -10902,6 +10991,7 @@ function notifyTerminalFailure(pi, run, body) {
     run.agent,
     run.runId,
     run.task,
+    run.status,
     run.result?.code ?? null,
     run.result?.file ?? "",
     run.timedOut,
@@ -11503,7 +11593,7 @@ async function statusReport(runtime, ctx) {
   const coveredIds = collectCoveredMessageIds(state);
   const sentTokens = estimateTokens(coreMessages, coveredIds, imageTokens) + systemPromptTokens;
   const turn = runtime.core.processTurn({ messages: coreMessages, state, config, tokenCount: anchorStale ? sentTokens : Math.max(sentTokens, realUsage?.tokens ?? 0) });
-  const versionStr = "0.1.53" ? `billion-context-pi@${"0.1.53"}` : void 0;
+  const versionStr = "0.1.54" ? `billion-context-pi@${"0.1.54"}` : void 0;
   let text = buildStatusPanel({
     version: versionStr,
     tokenCount: sessionTokens,
@@ -11866,7 +11956,7 @@ async function autoInstallLatest(latest, extDirOverride) {
       "--no-fund",
       "--no-save"
     ];
-    const prevVersion = (await readPackageJson(join8(extDir, "package.json")))?.version ?? "0.1.53";
+    const prevVersion = (await readPackageJson(join8(extDir, "package.json")))?.version ?? "0.1.54";
     const { code, stderr } = await runNpmImpl(installArgs(latest), { cwd: npmDir, timeout: 6e4 });
     if (code !== 0) {
       logWarn("update", {
@@ -11879,7 +11969,7 @@ async function autoInstallLatest(latest, extDirOverride) {
     }
     const verify = await verifyInstall(npmDir, latest);
     if (!verify.ok) {
-      const rollbackTo = SEMVER_RE.test(prevVersion) ? prevVersion : "0.1.53";
+      const rollbackTo = SEMVER_RE.test(prevVersion) ? prevVersion : "0.1.54";
       logWarn("update", { event: "auto-install-verify-failed", latest, reason: verify.reason, rollbackTo });
       const rb = await runNpmImpl(installArgs(rollbackTo), { cwd: npmDir, timeout: 6e4 });
       logInfo("update", { event: "rollback", from: latest, to: rollbackTo, ok: rb.code === 0 });
@@ -11940,7 +12030,7 @@ async function checkForUpdate(autoUpdate, notify) {
     const runtimeVersion = await getRuntimeVersion();
     const latest = await fetchLatestVersion();
     if (!latest) return;
-    const current = runtimeVersion ?? "0.1.53";
+    const current = runtimeVersion ?? "0.1.54";
     const hasUpdate = isNewer(latest, current);
     debug.event("update-check", {
       current,
@@ -12016,7 +12106,7 @@ function wireSessionLifecycle(pi, runtime) {
     setDelegateDisplayUsage("separate");
     const sid = ctx.sessionManager.getSessionId();
     const modelInfo = ctx.model;
-    logInfo("session", { event: "start", sid, cwd: ctx.cwd, debug: runtime.adapter.debug ?? null, version: true ? "0.1.53" : null, model: modelInfo?.id ?? null, modelApi: modelInfo?.api ?? null, contextWindow: modelInfo?.contextWindow ?? null });
+    logInfo("session", { event: "start", sid, cwd: ctx.cwd, debug: runtime.adapter.debug ?? null, version: true ? "0.1.54" : null, model: modelInfo?.id ?? null, modelApi: modelInfo?.api ?? null, contextWindow: modelInfo?.contextWindow ?? null });
     try {
       await runtime.reloadConfig(ctx.cwd);
       setDelegateDisplayUsage(resolveDelegate(runtime.adapter).displayUsage);