pi-codex-compaction 0.2.2 → 0.2.3

package/CHANGELOG.md

@@ -6,6 +6,13 @@ This project follows the spirit of [Keep a Changelog](https://keepachangelog.com
 
 ## [Unreleased]
 
+## [0.2.3] - 2026-10-09
+
+### Fixed
+
+- Load managed npm installations without a physical Pi AI dependency. Remove host filesystem resolution and internal serializer imports; verify retained output through the configured provider's public serialization boundary with transport disabled.
+- Test the actual packed entry outside the checkout without installing or linking Pi peers, including CLI startup and checkpoint/tool continuation/reload in print, JSON, and RPC modes.
+
 ## [0.2.2] - 2026-10-09
 
 ### Fixed

package/README.md

@@ -33,6 +33,10 @@ Or load it for one run:
 pi -e /path/to/pi-mono/packages/pi-codex-compaction
 ```
 
+Pi supplies the host packages through its extension loader; this package does
+not install or resolve a separate physical copy of Pi AI. No manual dependency
+installation is required. See Pi's [package dependency contract](https://github.com/earendil-works/pi/blob/v1.1.0/packages/coding-agent/docs/packages.md#declare-dependencies).
+
 Select a GPT-5/GPT-6 model on provider `openai`, API `openai-responses`, at
 `https://api.openai.com/v1`. No enable command is needed. A previously saved
 `off` setting on the current session branch remains respected.
@@ -84,6 +88,13 @@ On subsequent requests, it replaces the readable fallback and the retained
 assistant's serialized items with that checkpoint and output suffix. Later
 tool results and messages remain.
 
+Before adopting a checkpoint, the extension verifies the retained assistant
+through the configured provider's public `streamSimple` / `onPayload` boundary.
+This is a local serialization-only operation: it stops before transport, uses no
+real credential, blocks fetch, and adds no model request or usage. It does not
+import Pi's internal serializers or locate host files on disk. A serialization
+failure leaves history intact.
+
 The original transcript stays in the session file. Reload and tree navigation
 use the selected branch, not a global cache. Turning the mode off stops requesting
 new checkpoints but still replays a compatible saved checkpoint while the
@@ -171,7 +182,12 @@ incompatible in the public API.
 Tests use real Pi sessions with mocked transport to cover effective loadouts,
 streaming, tool continuations, checkpoint ordering, branches, reloads,
 cancellation, credential changes, context edits, default-on behavior, and
-the standard compaction safety net.
+the standard compaction safety net. The loading regression test packs the actual
+npm tarball and loads it outside the checkout with only declared runtime
+dependencies—no physical Pi peers. It uses the shipped bundled host's embedded
+module mapping, not just the ordinary SDK's filesystem aliases. It checks CLI
+flag registration and checkpoint adoption, tool continuation, and reload in
+print, JSON, and RPC modes.
 
 A small live subscription test with `gpt-6-astra` verified checkpoint adoption,
 replay, and synthetic fact recall. At a deliberately low 1,000-token threshold,
@@ -191,6 +207,12 @@ npm test -w packages/pi-codex-compaction
 npm run -w packages/pi-codex-compaction pack:dry-run
 ```
 
+Before releasing, also install the candidate tarball outside the checkout with
+host-peer installation suppressed, then load it through the installed Pi CLI.
+`pi -ne -e /path/to/installed/package --offline --help` must show both
+`--server-compaction` flags without loading errors or host-dependency warnings.
+Never add Pi peers to the candidate directory to make this smoke test pass.
+
 For an approved TUI smoke test, cross the configured threshold in a synthetic
 session, then check facts from earlier turns and a tool continuation. Check replay
 after `/reload`, mode-off, and branch navigation. Successful adoption should

package/SECURITY.md

@@ -49,8 +49,13 @@ a bounded transcript excerpt, not a complete summary. The original history and
 fallback remain subject to the user's Pi session-file permissions and retention.
 
 Replay checks the canonical retained assistant and serialized output
-fingerprints. Omitted, edited, or transformed messages fall back rather than
-restoring stale raw content. As with Pi text summaries, edits to already-compacted
+fingerprints. Before adoption, serialization uses the configured provider's
+public payload hook and aborts before transport. It uses a non-credential
+placeholder, a fetch function that always throws, and zero retries; it does not
+resolve real authentication or send an additional inference request. Missing
+hooks, serialization errors, or an attempted fetch prevent adoption. No host
+filesystem lookup or private serializer imports are required. Omitted, edited,
+or transformed messages fall back rather than restoring stale raw content. As with Pi text summaries, edits to already-compacted
 source history cannot alter an opaque checkpoint. Legacy checkpoint details are
 not migrated or replayed across provider/authentication boundaries.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-codex-compaction",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Keep Pi sessions flowing with automatic server-side compaction on public OpenAI Responses.",
   "type": "module",
   "license": "MIT",

package/src/automatic-compaction.ts

@@ -1,10 +1,5 @@
 import { createHash, createHmac, randomUUID } from "node:crypto";
-import type { Model } from "@earendil-works/pi-ai";
-// Resolve before importing: Pi's jiti root alias also matches subpaths.
-const aiEntry = import.meta.resolve("@earendil-works/pi-ai");
-const { convertResponsesMessages } = await import(new URL("./api/openai-responses-shared.js", aiEntry).href) as typeof import("@earendil-works/pi-ai/api/openai-responses-shared");
-const { createGrammarToolInputProperties } = await import(new URL("./api/constrained-sampling.js", aiEntry).href) as typeof import("@earendil-works/pi-ai/api/constrained-sampling");
-const { getCurrentSystemMessage, normalizeContext } = await import(new URL("./utils/transcript.js", aiEntry).href) as typeof import("@earendil-works/pi-ai/utils/transcript");
+import { getCurrentSystemMessage, normalizeContext, type AssistantMessage, type Model } from "@earendil-works/pi-ai";
 import {
   convertToLlm,
   serializeConversation,
@@ -185,6 +180,41 @@ function fallbackSummary(entries: SessionEntry[], ctx: ExtensionContext): string
   return `[${KIND}:${randomUUID()}]\nProvider checkpoint; the following is only a bounded readable fallback, not a full summary.\n${excerpt}`;
 }
 
+/**
+ * Ask the configured provider to serialize, then stop at its public onPayload
+ * boundary. Never resolve host files or reproduce its private serializer.
+ * The dummy credential, throwing fetch and zero retries prohibit inference,
+ * even if a future host accidentally continues past the payload callback.
+ */
+async function serializedAssistant(ctx: ExtensionContext, message: AssistantMessage): Promise<unknown[] | undefined> {
+  if (!supports(ctx.model) || ctx.signal?.aborted) return;
+  const provider = ctx.modelRegistry.getProvider(ctx.model.provider);
+  if (!provider) return;
+  const system = getCurrentSystemMessage(ctx.sessionManager.buildSessionProjection().messages);
+  const controller = new AbortController();
+  const stop = new Error("Serialization only; no provider request allowed");
+  let input: unknown[] | undefined;
+  let fetchAttempted = false;
+  const result = await provider.streamSimple(ctx.model, normalizeContext({
+    messages: [...(system ? [system] : []), message],
+  }), {
+    // Not an API key. No real credential is resolved or sent by this dry run.
+    apiKey: "serialization-only",
+    signal: controller.signal,
+    cacheRetention: "none",
+    maxRetries: 0,
+    fetch: async () => { fetchAttempted = true; throw stop; },
+    onPayload: (payload) => {
+      if (record(payload) && Array.isArray(payload.input) && bytes(payload.input) <= MAX_BYTES) {
+        input = structuredClone(payload.input);
+      }
+      controller.abort();
+      throw stop;
+    },
+  }).result();
+  return result.stopReason === "aborted" && !fetchAttempted && !ctx.signal?.aborted ? input : undefined;
+}
+
 /** Public Pi hooks only. No provider replacement, synthetic model turn, or private registry access. */
 export function registerAutomaticCompaction(pi: ExtensionAPI): void {
   pi.registerFlag("server-compaction", { type: "boolean", default: true,
@@ -332,7 +362,7 @@ export function registerAutomaticCompaction(pi: ExtensionAPI): void {
     attempt.items.clear();
   });
 
-  pi.on("turn_end", (event, ctx) => {
+  pi.on("turn_end", async (event, ctx) => {
     const current = attempt;
     attempt = undefined;
     inTurn = false;
@@ -364,13 +394,8 @@ export function registerAutomaticCompaction(pi: ExtensionAPI): void {
     // output before discarding any history. In particular, message_end redaction
     // must not later be undone by replaying an unredacted raw suffix.
     try {
-      const system = getCurrentSystemMessage(ctx.sessionManager.buildSessionProjection().messages);
-      const normalized = convertResponsesMessages(ctx.model,
-        normalizeContext({ messages: [...(system ? [system] : []), event.message] }), new Set(["openai"]), {
-          includeSystemPrompt: false,
-          grammarToolInputProperties: createGrammarToolInputProperties(
-            system?.toolsAdded ?? [], ctx.model.compat?.supportsOpenAIGrammarTools ?? false),
-        });
+      const normalized = await serializedAssistant(ctx, event.message);
+      if (!normalized) return;
       const actualHashes = normalized.map(outputHash).filter((value) => value !== undefined);
       if (hash(actualHashes) !== hash(hashes)) return;
     } catch { return; }