chainlesschain 0.163.2 → 0.163.4

package/src/harness/prompt-compressor.js

@@ -11,6 +11,7 @@
 
 import { createHash } from "node:crypto";
 import { feature, featureVariant } from "../lib/feature-flags.js";
+import { isAbortError } from "../lib/abort-utils.js";
 import {
   DURABLE_SYSTEM_MESSAGE_KINDS,
   getDurableSystemMessageProvenance,
@@ -566,6 +567,8 @@ export class PromptCompressor {
     let degradedReason = null;
     let rawSummary;
     let summaryUsage = null;
+    let summaryUsageUnknown = false;
+    let summaryUsageUnknownReason = null;
     let summaryProvider = null;
     let summaryModel = null;
     try {
@@ -592,6 +595,12 @@ export class PromptCompressor {
                   usage.cache_creation_tokens,
               ) || 0,
           };
+        } else if (queryResult.usageOutcome !== "not-billable") {
+          // Standard provider adapters return an explicit `usage` field. A
+          // successful response without it is still a paid call whose amount
+          // is unknown; never let a hard budget silently count it as zero.
+          summaryUsageUnknown = true;
+          summaryUsageUnknownReason = "provider_usage_not_reported";
         }
         summaryProvider = queryResult.provider || null;
         summaryModel = queryResult.model || null;
@@ -599,9 +608,18 @@ export class PromptCompressor {
         rawSummary = queryResult;
       }
     } catch (error) {
+      // Cancellation is authoritative. Treating AbortError as an ordinary
+      // provider failure would manufacture an extractive summary after Stop and
+      // let callers apply/persist it even though the operation was cancelled.
+      if (isAbortError(error)) throw error;
       degraded = true;
       summaryMode = "extractive-fallback";
       degradedReason = `llm_query_failed:${boundedFailureMessage(error)}`;
+      // A transport exception does not prove that the provider rejected the
+      // request before billing it. Keep that uncertainty explicit so a hard
+      // budget can latch instead of silently accounting the call as $0.
+      summaryUsageUnknown = true;
+      summaryUsageUnknownReason = "provider_transport_outcome_unknown";
     }
     if (!degraded) {
       try {
@@ -644,6 +662,12 @@ export class PromptCompressor {
         summaryInputChars: prompt.length,
         summaryInputLimit: this.summaryInputMaxChars,
         ...(summaryUsage ? { summaryUsage } : {}),
+        ...(summaryUsageUnknown
+          ? {
+              summaryUsageUnknown: true,
+              summaryUsageUnknownReason,
+            }
+          : {}),
         ...(summaryProvider ? { summaryProvider } : {}),
         ...(summaryModel ? { summaryModel } : {}),
       },

package/src/harness/provider-backed-compaction.js

@@ -0,0 +1,205 @@
+import {
+  estimateMessagesTokens,
+  PromptCompressor,
+  sanitizeToolPairs,
+} from "./prompt-compressor.js";
+
+const DEFAULT_MAX_OUTPUT_TOKENS = 2048;
+const MIN_MAX_OUTPUT_TOKENS = 256;
+const MAX_MAX_OUTPUT_TOKENS = 4096;
+const MANUAL_MAX_MESSAGES = 4;
+
+function boundedMaxOutputTokens(value) {
+  const parsed = Math.trunc(Number(value));
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return DEFAULT_MAX_OUTPUT_TOKENS;
+  }
+  return Math.min(
+    MAX_MAX_OUTPUT_TOKENS,
+    Math.max(MIN_MAX_OUTPUT_TOKENS, parsed),
+  );
+}
+
+function tokenCount(value) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? Math.trunc(parsed) : 0;
+}
+
+function responseSummary(response) {
+  if (typeof response === "string") return response;
+  return response?.message?.content ?? response?.content ?? "";
+}
+
+function preserveCompletedExchange(originalMessages, compactedMessages) {
+  if (originalMessages.at(-1)?.role === "user") return compactedMessages;
+  let lastUserIndex = -1;
+  for (let index = originalMessages.length - 1; index >= 0; index -= 1) {
+    if (originalMessages[index]?.role === "user") {
+      lastUserIndex = index;
+      break;
+    }
+  }
+  if (lastUserIndex < 0) return compactedMessages;
+
+  const completedExchange = originalMessages.slice(lastUserIndex);
+  const exchangeMessages = new Set(completedExchange);
+  const prefix = compactedMessages.filter(
+    (message) => !exchangeMessages.has(message),
+  );
+  return sanitizeToolPairs([...prefix, ...completedExchange]);
+}
+
+/**
+ * Convert PromptCompressor's provider-neutral summary accounting into the
+ * token-usage wire shape shared by the agent hosts.
+ */
+export function compactionTokenUsage(stats) {
+  const usage = stats?.summaryUsage;
+  if (!usage || typeof usage !== "object") return null;
+  return {
+    input_tokens: tokenCount(usage.inputTokens),
+    output_tokens: tokenCount(usage.outputTokens),
+    cache_read_input_tokens: tokenCount(usage.cacheReadTokens),
+    cache_creation_input_tokens: tokenCount(usage.cacheCreationTokens),
+  };
+}
+
+/**
+ * Build one provider-backed semantic compaction operation.
+ *
+ * The provider request is deliberately tool-free. A missing provider adapter,
+ * transport error, or malformed summary is handled by PromptCompressor's
+ * structured extractive handoff, so every host gets the same safe degradation
+ * contract instead of falling back to positional truncation.
+ */
+export async function compactConversationWithProvider(messages, options = {}) {
+  const originalMessages = Array.isArray(messages) ? [...messages] : [];
+  const provider = options.provider || null;
+  const model = options.model || null;
+  const maxOutputTokens = boundedMaxOutputTokens(options.maxOutputTokens);
+  const chatFn = options.chatFn;
+  const llmQuery =
+    typeof options.llmQuery === "function"
+      ? options.llmQuery
+      : async (prompt) => {
+          if (typeof chatFn !== "function") {
+            throw new Error("provider adapter unavailable");
+          }
+          const response = await chatFn([{ role: "user", content: prompt }], {
+            ...(options.chatOptions || {}),
+            provider,
+            model,
+            baseUrl: options.baseUrl,
+            apiKey: options.apiKey,
+            signal: options.signal,
+            contextEngine: null,
+            enabledToolNames: [],
+            extraToolDefinitions: [],
+            hostManagedToolPolicy: null,
+            onToken: undefined,
+            onStall: undefined,
+            onStreamRetry: undefined,
+            maxOutputTokens,
+          });
+          return {
+            summary: responseSummary(response),
+            usage: response?.usage || null,
+            provider,
+            model,
+          };
+        };
+
+  const compressor =
+    options.compressor ||
+    new PromptCompressor({
+      model,
+      provider,
+      llmQuery,
+      ...(options.force === true
+        ? { maxMessages: options.maxMessages || MANUAL_MAX_MESSAGES }
+        : options.maxMessages
+          ? { maxMessages: options.maxMessages }
+          : {}),
+      ...(options.maxTokens ? { maxTokens: options.maxTokens } : {}),
+      summaryInputMaxChars: options.summaryInputMaxChars,
+    });
+  if (
+    options.onlyIfNeeded === true &&
+    !compressor.shouldAutoCompact(originalMessages)
+  ) {
+    const originalTokens = estimateMessagesTokens(originalMessages);
+    return {
+      messages: originalMessages,
+      stats: {
+        strategy: "none",
+        originalMessages: originalMessages.length,
+        compressedMessages: originalMessages.length,
+        originalTokens,
+        compressedTokens: originalTokens,
+        saved: 0,
+        ratio: 1,
+        trimmed: 0,
+      },
+      degradedEvent: null,
+      usageEvent: null,
+      usageUnknownEvent: null,
+    };
+  }
+  const result = await compressor.compress(originalMessages, {
+    preserveToolPairs: true,
+    ...(typeof options.isPinned === "function"
+      ? { isPinned: options.isPinned }
+      : {}),
+  });
+  const compactedMessages =
+    options.preserveCompletedExchange === true
+      ? preserveCompletedExchange(originalMessages, result.messages)
+      : result.messages;
+  const originalTokens = estimateMessagesTokens(originalMessages);
+  const compressedTokens = estimateMessagesTokens(compactedMessages);
+  const stats = {
+    ...result.stats,
+    originalMessages: originalMessages.length,
+    compressedMessages: compactedMessages.length,
+    originalTokens,
+    compressedTokens,
+    saved: originalTokens - compressedTokens,
+    ratio: originalTokens > 0 ? compressedTokens / originalTokens : 1,
+    trimmed: Math.max(0, originalMessages.length - compactedMessages.length),
+  };
+  const usage = compactionTokenUsage(stats);
+  const usageUnknownEvent =
+    stats.summaryUsageUnknown === true
+      ? {
+          provider: stats.summaryProvider || provider,
+          model: stats.summaryModel || model,
+          source: "semantic-compaction",
+          reason:
+            stats.summaryUsageUnknownReason ||
+            "provider_transport_outcome_unknown",
+          usageOutcome: "unknown",
+        }
+      : null;
+
+  return {
+    messages: compactedMessages,
+    stats,
+    degradedEvent:
+      stats.degraded === true
+        ? {
+            reason: stats.degradedReason || "semantic-summary-degraded",
+            summaryMode: stats.summaryMode || "extractive-fallback",
+            stats,
+          }
+        : null,
+    usageEvent: usage
+      ? {
+          provider: stats.summaryProvider || provider,
+          model: stats.summaryModel || model,
+          usage,
+          source: "semantic-compaction",
+        }
+      : null,
+    usageUnknownEvent,
+  };
+}

package/src/harness/worktree-isolator.js

@@ -9,7 +9,9 @@
 
 import {
   existsSync,
+  appendFileSync,
   lstatSync,
+  readFileSync,
   realpathSync,
   rmdirSync,
   symlinkSync,
@@ -97,17 +99,36 @@ function gitRepositoryIdentity(repoDir) {
   const absoluteCommonDir = isAbsolute(commonDir)
     ? commonDir
     : resolve(repoDir, commonDir);
+  const commonDirPath = canonicalExistingPrefixPath(absoluteCommonDir);
   return {
     topLevel,
     topLevelIdentity: normalizeFilesystemPath(
       canonicalExistingPrefixPath(topLevel),
     ),
-    commonDirIdentity: normalizeFilesystemPath(
-      canonicalExistingPrefixPath(absoluteCommonDir),
-    ),
+    commonDirPath,
+    commonDirIdentity: normalizeFilesystemPath(commonDirPath),
   };
 }
 
+function ensureManagedWorktreeExcluded(context) {
+  const infoDir = resolve(context.repository.commonDirPath, "info");
+  const excludeFile = resolve(infoDir, "exclude");
+  mkdirSync(infoDir, { recursive: true });
+  try {
+    assertNotSymlink(infoDir, "git info directory");
+    assertNotSymlink(excludeFile, "git exclude file");
+  } catch (error) {
+    if (error?.code !== "ENOENT") throw error;
+  }
+  const pattern = `/${WORKTREE_DIR}/`;
+  const current = existsSync(excludeFile)
+    ? readFileSync(excludeFile, "utf8")
+    : "";
+  if (current.split(/\r?\n/).includes(pattern)) return;
+  const separator = current.length > 0 && !/\r?\n$/.test(current) ? "\n" : "";
+  appendFileSync(excludeFile, `${separator}${pattern}\n`, "utf8");
+}
+
 function assertSameGitRepository(repoDir, expectedCommonDir, expectedRoot) {
   const identity = gitRepositoryIdentity(repoDir);
   if (
@@ -381,6 +402,8 @@ export function createWorktree(repoDir, branchName, baseBranch, options = {}) {
     throw new Error("Not a git repository");
   }
 
+  const context = repositoryManagementContext(repoDir);
+  ensureManagedWorktreeExcluded(context);
   const worktreePath = assertManagedWorktreePath(
     repoDir,
     managedWorktreePath(repoDir, branchName),

package/src/lib/agent-worktree.js

@@ -164,18 +164,57 @@ function removeVerifiedAgentWorktree(info, deps, expectedBranchOid) {
 export function setupAgentWorktree({
   cwd = process.cwd(),
   now = new Date(),
+  requireCleanSource = false,
   deps = _deps,
 } = {}) {
   const repoRoot = findProjectRoot(cwd);
   if (!repoRoot) {
     throw new Error("--worktree requires running inside a git repository");
   }
+  if (requireCleanSource) {
+    const status = git(
+      [
+        "status",
+        "--porcelain=v1",
+        "--untracked-files=all",
+        "--ignore-submodules=none",
+        "--",
+        ".",
+        ":(exclude).worktrees",
+      ],
+      repoRoot,
+      deps,
+    ).trim();
+    if (status) {
+      throw new Error(
+        "Background worktree isolation requires a clean source checkout; commit/stash the current changes or pass --no-worktree explicitly.",
+      );
+    }
+  }
   const stamp = now.toISOString().slice(0, 19).replace(/[-:T]/g, "");
   const suffix = Math.random().toString(36).slice(2, 6);
   const branch = `cc-agent-${stamp}-${suffix}`;
   const info = (deps.createWorktree || createWorktree)(repoRoot, branch);
-  const baseSha = git(["rev-parse", "HEAD"], info.path, deps).trim();
-  return { ...info, repoRoot, baseSha };
+  try {
+    const baseSha = git(["rev-parse", "HEAD"], info.path, deps).trim();
+    return { ...info, repoRoot, baseSha };
+  } catch (error) {
+    // createWorktree is transactional internally, but ownership has already
+    // transferred to this wrapper when the follow-up base-SHA query runs. Roll
+    // that partial setup back here so callers never receive `_worktree = null`
+    // while a branch and linked checkout have already been created.
+    try {
+      (deps.removeWorktree || removeWorktree)(repoRoot, info.path, {
+        deleteBranch: true,
+        branchName: branch,
+        force: false,
+      });
+    } catch (cleanupError) {
+      error.retainedWorktree = { ...info, repoRoot, branch };
+      error.worktreeCleanupError = cleanupError;
+    }
+    throw error;
+  }
 }
 
 /**

package/src/lib/app-preview.js

@@ -311,6 +311,9 @@ export function buildEvidenceArtifact(kind, data = {}) {
         ...base,
         // The image bytes/path are opaque to this layer; only metadata here.
         ref: d.ref == null ? null : String(d.ref),
+        digest: /^sha256:[0-9a-f]{64}$/iu.test(String(d.digest || ""))
+          ? String(d.digest).toLowerCase()
+          : null,
         width: Number.isFinite(Number(d.width)) ? Number(d.width) : null,
         height: Number.isFinite(Number(d.height)) ? Number(d.height) : null,
       };