@yanlinglabs/winter-conformance 0.0.9 → 0.0.11

package/dist/{index-v0zvhx0z.js → index-5sjwc9ne.js}

@@ -110,9 +110,10 @@ async function fetchAndVerifyUpstream2(opts = {}) {
 }
 // src/official/capture.ts
 import { mkdtempSync as mkdtempSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, rmSync, readdirSync, statSync } from "node:fs";
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash2, randomUUID } from "node:crypto";
 import { tmpdir as tmpdir2 } from "node:os";
 import { dirname, join as join2 } from "node:path";
+import { fileURLToPath } from "node:url";
 var CANNED_TEXT_RESPONSE = {
   id: "msg_capture_canned_01",
   type: "message",
@@ -1530,6 +1531,117 @@ async function runCostCapture(officialSdk) {
       cleanup();
   }
 }
+var COMPACTION_GOLDEN_VOLATILE_TOP_LEVEL = new Set([
+  "uuid",
+  "logicalParentUuid",
+  "timestamp",
+  "cwd",
+  "sessionId",
+  "version",
+  "gitBranch",
+  "slug",
+  "userType",
+  "entrypoint",
+  "isMeta",
+  "promptId"
+]);
+var COMPACTION_GOLDEN_VOLATILE_METADATA = new Set(["preTokens", "postTokens", "durationMs", "preservedSegment", "preservedMessages", "cumulativeDroppedTokens"]);
+function normalizeCompactionEntry(raw) {
+  const out = {};
+  for (const [k, v] of Object.entries(raw)) {
+    if (COMPACTION_GOLDEN_VOLATILE_TOP_LEVEL.has(k))
+      continue;
+    if (k === "parentUuid" && v !== null)
+      continue;
+    out[k] = v;
+  }
+  if (out.compactMetadata !== undefined && typeof out.compactMetadata === "object" && out.compactMetadata !== null) {
+    out.compactMetadata = Object.fromEntries(Object.entries(out.compactMetadata).filter(([k]) => !COMPACTION_GOLDEN_VOLATILE_METADATA.has(k)));
+  }
+  return out;
+}
+function redactTranscriptPath(content, transcriptPath) {
+  return content.split(transcriptPath).join("<TRANSCRIPT_PATH>");
+}
+async function runCompactionCapture(officialSdk, opts = {}) {
+  const cleanups = [];
+  let server;
+  try {
+    const dirs = makeScenarioDirs("l", cleanups);
+    let requestCount = 0;
+    server = Bun.serve({
+      port: 0,
+      hostname: "127.0.0.1",
+      async fetch(req) {
+        requestCount++;
+        let body = {};
+        try {
+          body = await req.json();
+        } catch {}
+        const url = new URL(req.url);
+        console.error(`[loopback L] #${requestCount} ${req.method} ${url.pathname} model=${JSON.stringify(body.model)}`);
+        return jsonResponse({
+          id: `msg_capture_l_${requestCount}`,
+          type: "message",
+          role: "assistant",
+          model: body.model ?? "claude-haiku-4-5",
+          content: [{ type: "text", text: `capture: reply ${requestCount}` }],
+          stop_reason: "end_turn",
+          stop_sequence: null,
+          usage: { input_tokens: 20, output_tokens: 5 }
+        });
+      }
+    });
+    console.error(`
+=== Scenario L: the compaction golden (W18-12) ===`);
+    console.error(`[capture L] loopback ${server.url.href}; CLAUDE_CONFIG_DIR=${dirs.claudeConfigDir} HOME=${dirs.homeDir} (fresh mkdtemp)`);
+    const sessionId = randomUUID();
+    const commonOptions = { model: "claude-haiku-4-5", cwd: dirs.fixtureCwd, settingSources: [] };
+    const ac1 = new AbortController;
+    await drainWithDeadline(officialSdk.query({ prompt: "hi from turn one", options: { ...commonOptions, sessionId, abortController: ac1, env: hermeticEnv(dirs, server.url.href) } }), [], "capture L/turn1", 60000, ac1);
+    const ac2 = new AbortController;
+    await drainWithDeadline(officialSdk.query({ prompt: "hi from turn two", options: { ...commonOptions, resume: sessionId, abortController: ac2, env: hermeticEnv(dirs, server.url.href) } }), [], "capture L/turn2", 60000, ac2);
+    const ac3 = new AbortController;
+    const entries3 = [];
+    const r3 = await drainWithDeadline(officialSdk.query({ prompt: "/compact", options: { ...commonOptions, resume: sessionId, abortController: ac3, env: hermeticEnv(dirs, server.url.href) } }), entries3, "capture L/compact", 60000, ac3);
+    if (r3.thrown)
+      console.error(`[capture L] /compact threw: ${r3.thrown instanceof Error ? r3.thrown.stack ?? r3.thrown.message : String(r3.thrown)}`);
+    const transcripts = findFileRecursive(dirs.claudeConfigDir, (name) => name === `${sessionId}.jsonl`);
+    if (transcripts.length === 0) {
+      console.log(`
+--- Scenario L: NOT CAPTURABLE — no ${sessionId}.jsonl transcript was written ---`);
+      return;
+    }
+    const transcriptPath = transcripts[0];
+    const lines = readFileSync2(transcriptPath, "utf8").trim().split(`
+`).filter((l) => l.length > 0).map((l) => JSON.parse(l));
+    const rawBoundary = lines.find((e) => e.type === "system" && e.subtype === "compact_boundary");
+    const rawSummary = lines.find((e) => e.isCompactSummary === true);
+    if (rawBoundary === undefined || rawSummary === undefined) {
+      console.log(`
+--- Scenario L: NOT CAPTURABLE — /compact ran but wrote no boundary+summary pair (types: ${lines.map((e) => e.type).join(",")}) ---`);
+      return;
+    }
+    const boundary = normalizeCompactionEntry(rawBoundary);
+    const summaryMessage = rawSummary.message.content;
+    const summary = normalizeCompactionEntry({ ...rawSummary, message: { ...rawSummary.message, content: redactTranscriptPath(summaryMessage, transcriptPath) } });
+    console.log(`
+--- Scenario L: normalized boundary+summary ---`);
+    console.log(JSON.stringify({ boundary, summary }, null, 2));
+    if (opts.writeGolden === true) {
+      const goldenPath = fileURLToPath(new URL("../../goldens/claude-2.1.250/compaction.jsonl", import.meta.url));
+      writeFileSync2(goldenPath, `${JSON.stringify(boundary)}
+${JSON.stringify(summary)}
+`);
+      console.error(`[capture L] wrote ${goldenPath}`);
+    }
+    return { boundary, summary };
+  } finally {
+    server?.stop(true);
+    for (const cleanup of cleanups)
+      cleanup();
+  }
+}
 async function runCapture2() {
   requireBunRuntime2("runCapture", "Bun.spawn and Bun.serve", "It installs the pinned official SDK into a throwaway npm prefix and drives it against loopback fakes. Run the capture under Bun (`bun run scripts/capture-official-golden.ts`); the GOLDENS it produces are plain JSON and are readable from Node.");
   const only = (process.env.RUN_OFFICIAL_CAPTURE_ONLY ?? "").split(",").map((s) => s.trim().toUpperCase()).filter((s) => s.length > 0);
@@ -1568,6 +1680,8 @@ async function runCapture2() {
       await runModelControlCapture(officialSdk);
     if (want("K"))
       await runCostCapture(officialSdk);
+    if (want("L"))
+      await runCompactionCapture(officialSdk, { writeGolden: process.env.RUN_OFFICIAL_CAPTURE_WRITE_GOLDEN === "1" });
   } finally {
     for (const cleanup of cleanups)
       cleanup();

package/dist/index.js

@@ -14,7 +14,7 @@ import {
   resolveCacheDir2,
   fetchAndVerifyUpstream2,
   runCapture2
-} from "./index-v0zvhx0z.js";
+} from "./index-5sjwc9ne.js";
 // src/goldens.ts
 import { readFileSync, readdirSync } from "node:fs";
 import { join } from "node:path";

package/dist/official/capture.d.ts

@@ -1 +1,28 @@
+type OfficialQueryFn = (args: {
+    prompt: unknown;
+    options: Record<string, unknown>;
+}) => AsyncIterable<{
+    type: string;
+    subtype?: string;
+}>;
+type OfficialSdk = {
+    query: OfficialQueryFn;
+};
+/**
+ * Strips the fields that differ on every real capture (uuids, timestamps, host/session identity,
+ * the numeric token/timing counters, and any preserved-message relink data — `preservedMessages`/
+ * `preservedSegment` name capture-specific uuids, so they vary run to run even though, since fix
+ * round 1, Winter's own writer DOES reproduce `compactMetadata.preservedMessages` byte-shape-exact
+ * to this golden — see `claudeCompactBoundaryEntry`'s own header in `dialect.ts`) while keeping
+ * `parentUuid` when it is the fixed `null` the boundary always carries (that value IS the shape,
+ * not noise).
+ */
+export declare function normalizeCompactionEntry(raw: Record<string, unknown>): Record<string, unknown>;
+export declare function runCompactionCapture(officialSdk: OfficialSdk, opts?: {
+    writeGolden?: boolean;
+}): Promise<{
+    boundary: Record<string, unknown>;
+    summary: Record<string, unknown>;
+} | undefined>;
 export declare function runCapture(): Promise<void>;
+export {};

package/dist/official/index.js

@@ -10,7 +10,7 @@ import {
   resolveCacheDir2,
   fetchAndVerifyUpstream2,
   runCapture2
-} from "../index-v0zvhx0z.js";
+} from "../index-5sjwc9ne.js";
 import"../index-z5gwvsfh.js";
 export {
   BunRequiredError2 as BunRequiredError,

package/goldens/claude-2.1.250/compaction.jsonl

@@ -0,0 +1,2 @@
+{"parentUuid": null, "isSidechain": false, "type": "system", "subtype": "compact_boundary", "content": "Conversation compacted", "level": "info", "compactMetadata": {"trigger": "manual"}}
+{"isSidechain": false, "type": "user", "message": {"role": "user", "content": "This session is being continued from a previous conversation that ran out of context. The summary below covers the earlier portion of the conversation.\n\nturn-3-reply\n\nIf you need specific details from before compaction (like exact code snippets, error messages, or content you generated), read the full transcript at: <TRANSCRIPT_PATH>\nContinue the conversation from where it left off without asking the user any further questions. Resume directly \u2014 do not acknowledge the summary, do not recap what was happening, do not preface with \"I'll continue\" or similar. Pick up the last task as if the break never happened."}, "isVisibleInTranscriptOnly": true, "isCompactSummary": true}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yanlinglabs/winter-conformance",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "license": "MIT",
   "type": "module",
   "engines": {