pi-condense 2.10.2 → 2.10.4

package/src/config.ts

@@ -115,22 +115,58 @@ function normalize(existing: Partial<ContextPruneConfig>): ContextPruneConfig {
   };
 }
 
-async function readJsonObject(path: string): Promise<Record<string, unknown> | undefined> {
+export class SettingsReadError extends Error {
+  constructor(
+    public readonly path: string,
+    public readonly reason: string,
+  ) {
+    super(`settings.json unreadable at ${path}: ${reason}`);
+    this.name = "SettingsReadError";
+  }
+}
+
+/**
+ * Single classifier for settings.json read outcomes. Only ENOENT means "no
+ * file"; every other failure throws so a save never starts from `{}` over a
+ * file it could not read.
+ */
+async function readJsonObject(
+  path: string,
+  read: typeof readFile = readFile,
+): Promise<Record<string, unknown> | undefined> {
+  let raw: string;
   try {
-    const raw = await readFile(path, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-      return parsed as Record<string, unknown>;
-    }
-    return undefined;
+    raw = await read(path, "utf-8");
+  } catch (err) {
+    const e = err as NodeJS.ErrnoException;
+    if (e.code === "ENOENT") return undefined;
+    throw new SettingsReadError(path, e.code ?? e.message);
+  }
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
   } catch {
-    return undefined;
+    throw new SettingsReadError(path, "invalid JSON");
+  }
+  if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+    return parsed as Record<string, unknown>;
   }
+  throw new SettingsReadError(path, "not a JSON object");
 }
 
-/** Reads `<agent-dir>/settings.json` and returns the `contextPrune` block, or defaults. */
+/**
+ * Reads `<agent-dir>/settings.json` and returns the `contextPrune` block, or
+ * defaults. Fail-soft: an unreadable or malformed file yields defaults, since
+ * a broken settings.json is pi-wide and not this extension's to report.
+ */
 export async function loadConfig(): Promise<ContextPruneConfig> {
-  const main = await readJsonObject(settingsPath());
+  let main: Record<string, unknown> | undefined;
+  try {
+    main = await readJsonObject(settingsPath());
+  } catch (err) {
+    if (err instanceof SettingsReadError) return { ...DEFAULT_CONFIG };
+    throw err;
+  }
   const namespaced = main?.[SETTINGS_KEY];
   if (namespaced && typeof namespaced === "object" && !Array.isArray(namespaced)) {
     return normalize(namespaced as Partial<ContextPruneConfig>);
@@ -140,18 +176,39 @@ export async function loadConfig(): Promise<ContextPruneConfig> {
 
 /**
  * Writes the full config back to `<agent-dir>/settings.json` under
- * {@link SETTINGS_KEY}, preserving every other top-level key in the file. Uses
- * a tmp-file + atomic rename so concurrent pi writes (e.g. theme changes via
- * `/settings`) cannot observe a partial file. We do not coordinate with pi's
- * own internal lock since both writers do whole-file replacements and a
- * last-write-wins race only loses a single change, never corrupts the file.
+ * {@link SETTINGS_KEY}, preserving every other top-level key in the file.
+ * Tmp-file + atomic rename, so a concurrent reader never observes a partial
+ * file. A file that cannot be read as a JSON object is never replaced: the
+ * read throws {@link SettingsReadError} before anything is written. Concurrent
+ * saves (ours or pi's own) are last-write-wins; that race is not coordinated.
  */
-export async function saveConfig(config: ContextPruneConfig): Promise<void> {
+export async function saveConfig(config: ContextPruneConfig, read: typeof readFile = readFile): Promise<void> {
   const path = settingsPath();
-  const current = (await readJsonObject(path)) ?? {};
+  const current = (await readJsonObject(path, read)) ?? {};
   const next = { ...current, [SETTINGS_KEY]: config };
   await mkdir(dirname(path), { recursive: true });
   const tmpPath = `${path}.${randomBytes(8).toString("hex")}.tmp`;
   await writeFile(tmpPath, `${JSON.stringify(next, null, 2)}\n`);
   await rename(tmpPath, path);
 }
+
+type Notify = (message: string, type?: "info" | "warning" | "error") => void;
+
+/**
+ * Saves and reports failure through `notify` instead of rejecting, so callers
+ * can fire-and-forget. The in-memory change stands; only persistence failed.
+ */
+export async function persistConfig(
+  notify: Notify,
+  config: ContextPruneConfig,
+  save: (config: ContextPruneConfig) => Promise<void> = saveConfig,
+): Promise<void> {
+  try {
+    await save(config);
+  } catch (err) {
+    const reason = err instanceof SettingsReadError
+      ? err.reason
+      : ((err as NodeJS.ErrnoException | null | undefined)?.code ?? String(err));
+    notify(`Could not save settings to ${settingsPath()}: ${reason}. Change applies to this session only.`, "error");
+  }
+}

package/src/protected.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { globToRegExp, isProtected } from "./protected.js";
+import { globToRegExp, isProtected, normalizePath } from "./protected.js";
 import { DEFAULT_CONFIG } from "./types.js";
 
 describe("globToRegExp", () => {
@@ -82,3 +82,10 @@ describe("isProtected", () => {
     expect(isProtected("read", { path: "skills/a/SKILL.md" }, { protectedTools: [], protectedPaths: [] })).toBe(false);
   });
 });
+
+describe("normalizePath", () => {
+  test("normalizePath turns backslashes into forward slashes and nothing else", () => {
+    expect(normalizePath("h\\skills\\x\\SKILL.md")).toBe("h/skills/x/SKILL.md");
+    expect(normalizePath("./a/../b.md")).toBe("./a/../b.md");
+  });
+});

package/src/protected.ts

@@ -41,11 +41,16 @@ export function globToRegExp(pattern: string): RegExp {
   return compiled;
 }
 
+/** Identity normalization shared by protection matching and supersession: slash direction only, no resolution. */
+export function normalizePath(path: string): string {
+  return path.replace(/\\/g, "/");
+}
+
 export function isProtected(toolName: string, args: unknown, config: ProtectionConfig): boolean {
   if (config.protectedTools.includes(toolName)) return true;
   if (config.protectedPaths.length === 0) return false;
   const path = (args as Record<string, unknown> | null | undefined)?.path;
   if (typeof path !== "string") return false;
-  const normalized = path.replace(/\\/g, "/");
+  const normalized = normalizePath(path);
   return config.protectedPaths.some((p) => globToRegExp(p).test(normalized));
 }

package/src/pruner.test.ts

@@ -4,7 +4,9 @@ import { ToolCallIndexer } from "./indexer.js";
 import { CUSTOM_TYPE_INDEX } from "./types.js";
 import type { ChainCompressionConfig, ChainCompressionEntry } from "./types.js";
 import { DiagnosticSink } from "./diagnostics.js";
-import { pruneWithZeroSweepAssertion } from "./test-support.js";
+import { pruneWithZeroSweepAssertion, expectNoOrphanToolResults } from "./test-support.js";
+import { createSupersedeState, supersededStub } from "./supersede.js";
+import { isProtected } from "./protected.js";
 
 // Minimal mock exposing only the ToolCallIndexer surface that pruneMessages calls.
 // `hasLegacyBareRecord` defaults to the bare `summarized` set: most of the fixture
@@ -1053,3 +1055,74 @@ describe("G4/C3: orphan-sweep zero-fire proof across pruner fixtures", () => {
     it(`zero orphan sweeps: ${name}`, run);
   }
 });
+
+describe("pruneMessages phase 1b (supersede)", () => {
+  const protection = { protectedTools: [], protectedPaths: ["**/skills/**/*.md"] };
+  const isProt = (n: string, a: unknown) => isProtected(n, a, protection);
+  const SKILL = "/h/skills/x/SKILL.md";
+
+  function twoReads(): any[] {
+    return [
+      { role: "user", timestamp: 1, content: [{ type: "text", text: "go" }] },
+      { role: "assistant", timestamp: 2, content: [{ type: "toolCall", id: "r1", name: "read", input: { path: SKILL } }] },
+      { role: "toolResult", toolCallId: "r1", toolName: "read", content: [{ type: "text", text: "FIRST" }], isError: false, timestamp: 3 },
+      { role: "assistant", timestamp: 4, content: [{ type: "text", text: "ok" }] },
+      { role: "user", timestamp: 5, content: [{ type: "text", text: "again" }] },
+      { role: "assistant", timestamp: 6, content: [{ type: "toolCall", id: "r2", name: "read", input: { path: SKILL } }] },
+      { role: "toolResult", toolCallId: "r2", toolName: "read", content: [{ type: "text", text: "SECOND" }], isError: false, timestamp: 7 },
+      { role: "assistant", timestamp: 8, content: [{ type: "text", text: "done" }] },
+    ];
+  }
+
+  it("supersede param absent -> output identical to today", () => {
+    const msgs = twoReads();
+    const { messages: out, pruned } = pruneMessages(msgs, makeMockIndexer(), undefined, undefined, protection);
+    expect(pruned).toBe(false);
+    expect(out).toBe(msgs);
+  });
+
+  it("nothing activated -> input reference, pruned false", () => {
+    const msgs = twoReads();
+    const state = createSupersedeState();
+    const { messages: out, pruned } = pruneMessages(msgs, makeMockIndexer(), undefined, undefined, protection, 0, undefined, { state, isProtected: isProt });
+    expect(pruned).toBe(false);
+    expect(out).toBe(msgs);
+  });
+
+  it("one activation -> fresh array, pruned true, input untouched, newest verbatim, metadata kept", () => {
+    const msgs = twoReads();
+    const before = JSON.stringify(msgs);
+    const state = createSupersedeState();
+    state.floor = 0;
+    const { messages: out, pruned } = pruneMessages(msgs, makeMockIndexer(), undefined, undefined, protection, 0, undefined, { state, isProtected: isProt });
+    expect(pruned).toBe(true);
+    expect(out).not.toBe(msgs);
+    expect(JSON.stringify(msgs)).toBe(before);
+    expect(out[2]).toEqual({ ...msgs[2], content: [{ type: "text", text: supersededStub(SKILL) }] });
+    expect(out[6]).toBe(msgs[6]);
+    expectNoOrphanToolResults(out);
+  });
+
+  it("superseded read inside a compressed chain relocates as the stub", () => {
+    const msgs = twoReads();
+    const entry = {
+      blockId: "b1",
+      startUserTimestamp: 1,
+      droppedToolCallIds: ["r1"],
+      protectedToolCallIds: ["r1"],
+      finalAssistantTimestamp: 4,
+      toolRefs: [],
+      compressedAt: 100,
+    } as any;
+    const indexer = makeMockIndexer({ chainEntries: [entry], summaryBodyMap: new Map([["r1", "SUMMARY"]]) });
+    const state = createSupersedeState();
+    state.floor = 0;
+    const { messages: out } = pruneMessages(msgs, indexer, enabledCC, undefined, protection, 0, undefined, { state, isProtected: isProt });
+    const synthetic = out.find((m: any) => typeof m.content?.[0]?.text === "string" && m.content[0].text.startsWith("<compressed-chain"));
+    expect(synthetic.content[0].text).toContain('<protected-output tool="read">');
+    expect(synthetic.content[0].text).toContain(supersededStub(SKILL));
+    expect(synthetic.content[0].text).not.toContain("FIRST");
+    expect(out.find((m: any) => m.role === "toolResult" && m.toolCallId === "r2").content[0].text).toBe("SECOND");
+    expectNoOrphanToolResults(out);
+  });
+});

package/src/pruner.ts

@@ -8,6 +8,7 @@ import { inGraceRecoveryToolCallIds } from "./recovery-grace.js";
 import { occKey } from "./occurrence-key.js";
 import { sweepOrphanToolResults } from "./orphan-sweep.js";
 import type { DiagnosticSink } from "./diagnostics.js";
+import { applySupersede, type SupersedeState } from "./supersede.js";
 
 /**
  * Estimate of a message array's context weight. Serializing the whole array
@@ -20,7 +21,7 @@ export function sizeMessages(messages: any[]): number {
 }
 
 /**
- * Transforms the `context` event message array in four phases:
+ * Transforms the `context` event message array in five phases:
  *
  * Phase 1 — stub-replace: ToolResultMessages for summarized tool calls are
  * replaced with short stubs pointing the model at `context_tree_query`.
@@ -37,6 +38,13 @@ export function sizeMessages(messages: any[]): number {
  *     to recovery is present on the toolResult itself, not only in the
  *     separate summary message.
  *
+ * Phase 1b — supersede: protected reads (never indexed) whose `args.path`
+ * is read again later in the same context are replaced with a one-line
+ * "superseded" stub, but only once `SupersedeState.floor` says the pruner
+ * is rewriting at/before their position anyway (or the cache is cold).
+ * See src/supersede.ts. Runs before phase 3 so a superseded read inside a
+ * compressed chain relocates as the stub, not the verbatim body.
+ *
  * Phase 2 — error purge: replaces failed toolCall arg bodies with stubs after a
  * cooldown, reclaiming context from large `write`/`edit` arguments that will
  * never succeed. The toolResult error message stays visible.
@@ -78,6 +86,7 @@ export function pruneMessages(
   protection?: ProtectionConfig,
   recoveryGraceTurns: number = 0,
   diagnostics?: DiagnosticSink,
+  supersede?: { state: SupersedeState; isProtected: (toolName: string, args: unknown) => boolean },
 ): { messages: any[]; pruned: boolean; beforeChars: number; afterChars: number } {
   // Phase 1: stub-replace summarized tool results
   let pruned = false;
@@ -136,6 +145,15 @@ export function pruneMessages(
 
   let current: any[] = pruned ? next : messages;
 
+  // Phase 1b: supersede older protected reads of a re-read path
+  if (supersede) {
+    const afterSupersede = applySupersede(current, supersede.state, supersede.isProtected);
+    if (afterSupersede !== current) {
+      current = afterSupersede;
+      pruned = true;
+    }
+  }
+
   // Phase 2: error purge — replace failed toolCall arg bodies after cooldown
   if (errorPurge?.enabled) {
     const afterPurge = purgeErroredArgs(current, errorPurge);