chainlesschain 0.162.189 → 0.162.197

package/src/commands/compact.js

@@ -7,15 +7,14 @@
  *                                        checkpoint event the resume path honors)
  *   cc compact <session-id> --dry-run    preview the reduction, write nothing
  *
- * Engine: the existing PromptCompressor (snip + dedup + collapse + truncate).
- * Runs OFFLINE and deterministic — no LLM summarization is wired here, so a
- * compaction never makes a network call and is reproducible. By default it
- * sizes its thresholds to the session's recorded model/provider context window;
- * override with --model/--provider or the hard --max-tokens/--max-messages.
+ * Engine: PromptCompressor with a bounded structured semantic handoff using the
+ * session's recorded provider. `--offline` explicitly selects deterministic
+ * extractive/count-based compaction. Provider failure degrades visibly to the
+ * bounded extractive handoff instead of silently discarding facts.
  *
- * After compaction the new history is appended as a JSONL `compact` event;
- * `rebuildMessages()` already rebuilds from the last such event, so a later
- * `cc agent --resume <id>` picks up the shortened history automatically.
+ * After compaction the new history is appended as a revision-checked JSONL
+ * `compact` event; verified resume rebuilds from the last such event, so a
+ * later `cc agent --resume <id>` picks up the shortened history automatically.
  * Distinct from `cc checkpoint` (file state) and `cc workflow checkpoint`
  * (execution state).
  */
@@ -23,12 +22,12 @@
 import chalk from "chalk";
 import { logger } from "../lib/logger.js";
 import {
+  appendAuthorityEventIfHead,
+  readVerifiedProjection,
   sessionExists,
-  readEvents,
-  rebuildMessages,
-  appendCompactEvent,
 } from "../harness/jsonl-session-store.js";
 import { PromptCompressor } from "../harness/prompt-compressor.js";
+import { chatWithTools } from "../runtime/agent-core.js";
 
 /** Build a compressor sized to the session (or explicit overrides). */
 function buildCompressor(options, recorded) {
@@ -38,19 +37,81 @@ function buildCompressor(options, recorded) {
     : undefined;
   if (maxTokens || maxMessages) {
     // Hard thresholds win — adaptive sizing is bypassed by the constructor.
-    return new PromptCompressor({ maxTokens, maxMessages });
+    return new PromptCompressor({
+      maxTokens,
+      maxMessages,
+      llmQuery: buildSemanticQuery(options, recorded),
+    });
   }
   const model = options.model || recorded.model || undefined;
   const provider = options.provider || recorded.provider || undefined;
   // model/provider → adaptive context-window thresholds; neither → defaults.
-  return new PromptCompressor({ model, provider });
+  return new PromptCompressor({
+    model,
+    provider,
+    llmQuery: buildSemanticQuery(options, { model, provider }),
+  });
+}
+
+function buildSemanticQuery(options, recorded) {
+  const provider = options.provider || recorded.provider || undefined;
+  const model = options.model || recorded.model || undefined;
+  if (options.offline || !provider) return null;
+  const baseUrl =
+    options.baseUrl ||
+    (provider === "ollama" ? "http://localhost:11434" : undefined);
+  return async (prompt) => {
+    const response = await chatWithTools([{ role: "user", content: prompt }], {
+      provider,
+      model,
+      baseUrl,
+      enabledToolNames: [],
+      extraToolDefinitions: [],
+      maxOutputTokens: 2048,
+    });
+    return {
+      summary: response?.message?.content || "",
+      usage: response?.usage || null,
+      provider,
+      model,
+    };
+  };
+}
+
+function readCompactSource(sessionId) {
+  return readVerifiedProjection(sessionId, () => {
+    let recorded = Object.freeze({ model: "", provider: "" });
+    let sawSessionStart = false;
+    return {
+      accept(event) {
+        if (!sawSessionStart && event?.type === "session_start") {
+          sawSessionStart = true;
+          recorded = Object.freeze({
+            model:
+              typeof event.data?.model === "string" ? event.data.model : "",
+            provider:
+              typeof event.data?.provider === "string"
+                ? event.data.provider
+                : "",
+          });
+        }
+      },
+      finish(authority) {
+        return Object.freeze({
+          headHash: authority.headHash,
+          messages: Object.freeze([...authority.readMessages()]),
+          recorded,
+        });
+      },
+    };
+  });
 }
 
 export function registerCompactCommand(program) {
   program
     .command("compact <session-id>")
     .description(
-      "Compact a stored session's history (offline; persists for --resume)",
+      "Compact a stored session into a structured handoff (persists for --resume)",
     )
     .option(
       "-m, --model <model>",
@@ -66,6 +127,11 @@ export function registerCompactCommand(program) {
       "Override the message-count threshold (skips adaptive)",
     )
     .option("--dry-run", "Preview the reduction without writing")
+    .option(
+      "--offline",
+      "Disable provider summarization and stay deterministic",
+    )
+    .option("--base-url <url>", "Provider base URL for semantic compaction")
     .option("--json", "Output as JSON")
     .action(async (sessionId, options) => {
       try {
@@ -76,15 +142,9 @@ export function registerCompactCommand(program) {
           return;
         }
 
-        const events = readEvents(sessionId);
-        const start = events.find((e) => e.type === "session_start");
-        const recorded = {
-          model: start?.data?.model || "",
-          provider: start?.data?.provider || "",
-        };
-
-        const messages = rebuildMessages(sessionId);
-        const compressor = buildCompressor(options, recorded);
+        const source = readCompactSource(sessionId);
+        const messages = source.messages;
+        const compressor = buildCompressor(options, source.recorded);
         const { messages: compacted, stats } =
           await compressor.compress(messages);
 
@@ -106,7 +166,12 @@ export function registerCompactCommand(program) {
         }
 
         if (!options.dryRun) {
-          appendCompactEvent(sessionId, { ...stats, messages: compacted });
+          appendAuthorityEventIfHead(
+            sessionId,
+            "compact",
+            { ...stats, messages: compacted },
+            source.headHash,
+          );
         }
 
         if (options.json) {
@@ -133,6 +198,13 @@ export function registerCompactCommand(program) {
               ` (saved ${stats.saved}, ${stats.strategy})`,
           ),
         );
+        if (stats.degraded === true) {
+          logger.log(
+            chalk.yellow(
+              `  semantic summary degraded to ${stats.summaryMode}: ${stats.degradedReason}`,
+            ),
+          );
+        }
         if (options.dryRun) {
           logger.log(
             chalk.gray(`  re-run without --dry-run to persist the compaction`),
@@ -143,7 +215,11 @@ export function registerCompactCommand(program) {
           );
         }
       } catch (err) {
-        logger.error(chalk.red(`compact failed: ${err.message}`));
+        const reason =
+          err?.code === "SESSION_REVISION_STALE"
+            ? "session changed while compacting; retry"
+            : err.message;
+        logger.error(chalk.red(`compact failed: ${reason}`));
         process.exitCode = 1;
       }
     });