@iowarp/clio-coder 0.5.0 → 0.5.2

package/dist/{chunk-LTWH2ACR.js → chunk-EQPFEDFV.js}

@@ -9,21 +9,21 @@ import {
   readGateDecisionArtifactsForRunIds,
   stagePendingGateDecision,
   verifyGateDecisionArtifact
-} from "./chunk-OV62D6KO.js";
+} from "./chunk-KQMYL5GR.js";
 import {
   codeStepDir,
   writeCodeStepRecord
-} from "./chunk-I4ELN5BX.js";
+} from "./chunk-ZTNOEJRI.js";
 import {
   captureWorkspaceCheckpoint,
   captureWorkspaceSnapshot,
   createWriteBoundaryEnforcer,
   workspaceCheckpointRef
-} from "./chunk-DXSETN72.js";
+} from "./chunk-7WUGNN43.js";
 import {
   executionPlanAncestors,
   spliceExecutionPlan
-} from "./chunk-NFSK2VNU.js";
+} from "./chunk-LZMTVVN4.js";
 import {
   formatTrustAxes,
   formatTrustSummary,
@@ -31,14 +31,14 @@ import {
   renderCodewikiDigest,
   sha256,
   trustVerdict
-} from "./chunk-OZ76TLGU.js";
+} from "./chunk-EEITU7S6.js";
 import {
   protectedArtifactFromSessionEntry,
   protectedArtifactStateFromSessionEntries,
   readAuditRows,
   readSessionEntriesForId,
   responseModelIdObservationFromRecord
-} from "./chunk-EOJPDNUP.js";
+} from "./chunk-GPTR6OTU.js";
 import {
   loadEvalArtifact,
   parseEvalArtifactV4,
@@ -51,7 +51,7 @@ import {
 import {
   parseRigorOverride,
   resolveRigor
-} from "./chunk-XMDBTYCH.js";
+} from "./chunk-N3CWOGVF.js";
 import {
   defaultRunEventJournal,
   removeRunEventJournals
@@ -83,7 +83,7 @@ import {
   foldDecisionBoard,
   startDispatchEventPump,
   workerOutputCaptureBytes
-} from "./chunk-U5QU5ZOD.js";
+} from "./chunk-XYPWFSU5.js";
 import {
   filterEntriesToActivePath
 } from "./chunk-O5F25NIE.js";
@@ -97,12 +97,12 @@ import {
   receiptAttestationFields,
   routeFactVerdict,
   spawnNativeWorker
-} from "./chunk-U6YTUVOX.js";
+} from "./chunk-Q4RMNWMZ.js";
 import {
   JUDGED_CHECK_MAX_OUTPUT_BYTES,
   judgeNumericTexts,
   judgePerfTexts
-} from "./chunk-7RET77VB.js";
+} from "./chunk-Q2HKY32Y.js";
 import {
   changedPathsSince,
   computeWikiContentHash,
@@ -165,10 +165,10 @@ import {
   isClaudeCanonicalTool,
   nodeResultContractFilesystem,
   serializeWorkerRuntimeDescriptor
-} from "./chunk-R7FGRZNF.js";
+} from "./chunk-LXYHCCIZ.js";
 import {
   assessFinishContract
-} from "./chunk-DOUISWEE.js";
+} from "./chunk-QOJ4ERMU.js";
 import {
   RUN_RECEIPT_INTEGRITY_ALGORITHM,
   RUN_RECEIPT_INTEGRITY_VERSION,
@@ -182,7 +182,7 @@ import {
   retiredIntegrityVersionOf,
   verifyReceiptIntegrity,
   withReceiptIntegrity
-} from "./chunk-VKHLUZNO.js";
+} from "./chunk-UZ7YBL43.js";
 import {
   AGENT_LEDGER_PROMPT_MAX_CHARS,
   COUNCIL_MIN_MEMBERS,
@@ -217,7 +217,7 @@ import {
   toolPromptHintsForNames,
   turnAllowsTool,
   validateJobSpec
-} from "./chunk-OQ2EOAHA.js";
+} from "./chunk-PF36KOGI.js";
 import {
   WORKER_CONTEXT_MAX_BYTES,
   completeHistoryLength,
@@ -240,7 +240,7 @@ import {
   routingIntentRejection,
   sameRouteIdentity,
   toRouteCandidate
-} from "./chunk-T33IYTZM.js";
+} from "./chunk-SAASVMIY.js";
 import {
   isLoadableExtension
 } from "./chunk-OH3YYA3B.js";
@@ -254,7 +254,7 @@ import {
 import {
   applyToolProfile,
   assertToolProfileEnforceable
-} from "./chunk-XZWSP67B.js";
+} from "./chunk-5APYAXCB.js";
 import {
   dispatchResultContract,
   gateRouteCorrelation,
@@ -262,7 +262,7 @@ import {
   requestExecutionRole,
   routeCorrelationFactsForRun,
   withAttemptRole
-} from "./chunk-BRCOSE7O.js";
+} from "./chunk-SZUO5BSE.js";
 import {
   declaredScopeIntent,
   declaredScopeReplacementDiagnostic,
@@ -275,17 +275,17 @@ import {
   directSurfaceNames,
   effectiveToolCall,
   withGatewayForCapabilities
-} from "./chunk-DE2LU267.js";
+} from "./chunk-KKAJGT3B.js";
 import {
   networkToolsDisabled
-} from "./chunk-KBUTSJSR.js";
+} from "./chunk-4XBYHXGK.js";
 import {
   compileGlobRegex,
   normalizeGlobInput
 } from "./chunk-DZLR4UEH.js";
 import {
   WRITE_ROOT_REFUSED_TOOLS
-} from "./chunk-733ZBT5P.js";
+} from "./chunk-E74MJF6G.js";
 import {
   TOOL_RESULT_TRUST_CONTRACT
 } from "./chunk-WXA2CFJO.js";
@@ -307,7 +307,7 @@ import {
   resolveRuntimeTarget,
   runtimeResolutionWarnings,
   runtimeTargetSnapshot
-} from "./chunk-EYTLV3W3.js";
+} from "./chunk-HTWTORF7.js";
 import {
   isDispatchEligibleRuntime
 } from "./chunk-6EJYVCTN.js";
@@ -322,7 +322,7 @@ import {
 import {
   ceilChars,
   estimateAgentMessageTokens
-} from "./chunk-6W75D37F.js";
+} from "./chunk-53P775GE.js";
 import {
   targetRequiresAuth
 } from "./chunk-Z4GLJ6J4.js";
@@ -334,9 +334,8 @@ import {
 } from "./chunk-L7G7K4I2.js";
 import {
   decisionRef,
-  isDecisionRecord,
-  isSkillActivation
-} from "./chunk-I4Y4WKZR.js";
+  isDecisionRecord
+} from "./chunk-F6KCJO3U.js";
 import {
   DEFAULT_AUTONOMY_LEVEL,
   autonomyDenyRejection,
@@ -344,6 +343,9 @@ import {
   mapAutonomy,
   modelMayActivateSkills
 } from "./chunk-UZVYEF57.js";
+import {
+  isSkillActivation
+} from "./chunk-MMZMM6SW.js";
 import {
   createRedactionTally,
   redactSecretsDeep,
@@ -351,7 +353,7 @@ import {
 } from "./chunk-O3VV6IVK.js";
 import {
   atomicWrite
-} from "./chunk-EKV4UBCM.js";
+} from "./chunk-PZBQUJ2F.js";
 import {
   assertSafeId
 } from "./chunk-UHW5V7HC.js";
@@ -370,16 +372,16 @@ import {
   resultContractAuthorship,
   validateRecipeResult,
   validateStructuredHelperResult
-} from "./chunk-LNOXCGN2.js";
+} from "./chunk-7UFDIOBT.js";
 import {
   INTEROP_AGENT_KINDS
 } from "./chunk-5EQO5NWP.js";
 import {
   classify
-} from "./chunk-VYRQHORQ.js";
+} from "./chunk-NMQSO6Z6.js";
 import {
   detectValidationCommand
-} from "./chunk-P4GNZPXO.js";
+} from "./chunk-OYUS3UZP.js";
 import {
   PATH_BOUNDARY_MAX_ENTRIES,
   pathBoundaryCovers,
@@ -396,7 +398,7 @@ import {
   ToolNames,
   isBuiltinToolName,
   isHarnessExtensionToolName
-} from "./chunk-V4XJWDHR.js";
+} from "./chunk-6UKFRTXI.js";
 import {
   DEFAULT_DELEGATION_CONNECT_TIMEOUT_MS,
   DEFAULT_DELEGATION_TURN_TIMEOUT_MS,
@@ -797,13 +799,13 @@ function normalizeRuleKey(text) {
   return text.toLowerCase().replace(/`([^`]+)`/g, "$1").replace(/[^a-z0-9.+:#/-]+/g, " ").replace(/\s+/g, " ").trim().replace(/[.!?]+$/, "");
 }
 function classifyConflict(text) {
-  const normalized = text.toLowerCase().replace(/`/g, "");
+  const normalized2 = text.toLowerCase().replace(/`/g, "");
   const packageManager2 = /\b(?:always\s+|must\s+|should\s+|prefer\s+|use\s+|run\s+)*(?:use|prefer|run)\s+(pnpm|npm|yarn|bun)\b/.exec(
-    normalized
+    normalized2
   );
   if (packageManager2?.[1]) return { key: "package-manager", value: packageManager2[1] };
   const testRunner = /\b(?:always\s+|must\s+|should\s+|prefer\s+|use\s+|run\s+)*(?:use|prefer|run)\s+(node:test|vitest|jest|pytest|cargo test|go test)\b/.exec(
-    normalized
+    normalized2
   );
   if (testRunner?.[1]) return { key: "test-runner", value: testRunner[1] };
   return void 0;
@@ -841,8 +843,8 @@ function buildImportPlan(sources) {
   const byConflictKey = /* @__PURE__ */ new Map();
   const conflicts = /* @__PURE__ */ new Map();
   for (const candidate of candidates) {
-    const normalized = normalizeRuleKey(candidate.text);
-    const existing = byNormalizedText.get(normalized);
+    const normalized2 = normalizeRuleKey(candidate.text);
+    const existing = byNormalizedText.get(normalized2);
     if (existing) {
       if (!existing.sources.includes(candidate.source.displayPath)) existing.sources.push(candidate.source.displayPath);
       if (!existing.providers.includes(candidate.source.providerLabel))
@@ -884,7 +886,7 @@ function buildImportPlan(sources) {
       ...candidate.conflict ? { conflictKey: candidate.conflict.key } : {}
     };
     accepted.push(rule);
-    byNormalizedText.set(normalized, rule);
+    byNormalizedText.set(normalized2, rule);
     if (candidate.conflict) byConflictKey.set(candidate.conflict.key, { value: candidate.conflict.value, rule });
     if (accepted.length >= MAX_IMPORTED_RULES) break;
   }
@@ -1306,9 +1308,9 @@ function parseNumbered(section) {
   return section.split("\n").map((line) => /^\d+\.\s+(.+?)\s*$/.exec(line)?.[1]?.trim()).filter((line) => Boolean(line));
 }
 function parseClioMd(source) {
-  const normalized = normalizeSource(source);
+  const normalized2 = normalizeSource(source);
   const warnings = [];
-  const footerResult = parseFooter(normalized);
+  const footerResult = parseFooter(normalized2);
   warnings.push(...footerResult.warnings);
   if (footerResult.errors.length > 0) return { ok: false, errors: footerResult.errors, warnings };
   const h1Matches = [...maskNonHeadingRegions(footerResult.body).matchAll(H1_RE)];
@@ -3215,25 +3217,25 @@ function ruleMatchesAnyPath(rule, workingPaths) {
       continue;
     }
     for (const path2 of workingPaths) {
-      const normalized = normalizeGlobInput(path2);
-      if (regex.test(normalized)) return true;
-      if (normalized.endsWith("/") && globMatchesInsideDirectory(regex, pattern, normalized)) return true;
+      const normalized2 = normalizeGlobInput(path2);
+      if (regex.test(normalized2)) return true;
+      if (normalized2.endsWith("/") && globMatchesInsideDirectory(regex, pattern, normalized2)) return true;
     }
   }
   return false;
 }
 function materializedGlobVariants(pattern) {
   let variants = [""];
-  const normalized = normalizeGlobInput(pattern);
-  for (let index = 0; index < normalized.length; index += 1) {
-    const character = normalized[index];
+  const normalized2 = normalizeGlobInput(pattern);
+  for (let index = 0; index < normalized2.length; index += 1) {
+    const character = normalized2[index];
     if (character === void 0) break;
-    if (character === "*" && normalized[index + 1] === "*" && normalized[index + 2] === "/") {
+    if (character === "*" && normalized2[index + 1] === "*" && normalized2[index + 2] === "/") {
       variants = variants.flatMap((prefix) => [prefix, `${prefix}x/`]).slice(0, 64);
       index += 2;
       continue;
     }
-    if (character === "*" && normalized[index + 1] === "*") {
+    if (character === "*" && normalized2[index + 1] === "*") {
       variants = variants.map((prefix) => `${prefix}x`);
       index += 1;
       continue;
@@ -3243,8 +3245,8 @@ function materializedGlobVariants(pattern) {
       continue;
     }
     if (character === "[") {
-      const end = normalized.indexOf("]", index + 1);
-      const selected = end === -1 ? "x" : normalized[index + 1] ?? "x";
+      const end = normalized2.indexOf("]", index + 1);
+      const selected = end === -1 ? "x" : normalized2[index + 1] ?? "x";
       variants = variants.map((prefix) => `${prefix}${selected}`);
       index = end === -1 ? index : end;
       continue;
@@ -4224,7 +4226,8 @@ import { isAbsolute as isAbsolute3 } from "node:path";
 
 // src/domains/memory/store.ts
 init_esm_shims();
-import { readFileSync as readFileSync10 } from "node:fs";
+import { createHash as createHash5 } from "node:crypto";
+import { closeSync as closeSync2, openSync as openSync2, readFileSync as readFileSync10, readSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { join as join10 } from "node:path";
 
@@ -4626,6 +4629,35 @@ function compareStrings(a, b) {
 var MEMORY_STORE_MAX_RECORDS = 500;
 var MEMORY_STALE_APPROVED_DAYS = 180;
 var MEMORY_STALE_UNAPPROVED_DAYS = 30;
+var MEMORY_PROMPT_STORE_MAX_BYTES = 16 * 1024 * 1024;
+function readMemoryStoreSnapshot(dataDir) {
+  const path2 = memoryStorePath(dataDir);
+  let fd;
+  try {
+    fd = openSync2(path2, "r");
+  } catch (error) {
+    if (isErrorWithCode(error) && error.code === "ENOENT") return { revision: "missing", records: [] };
+    throw error;
+  }
+  const chunks = [];
+  let total = 0;
+  try {
+    while (true) {
+      const chunk = Buffer.allocUnsafe(Math.min(64 * 1024, MEMORY_PROMPT_STORE_MAX_BYTES + 1 - total));
+      const count = readSync(fd, chunk);
+      if (count === 0) break;
+      total += count;
+      if (total > MEMORY_PROMPT_STORE_MAX_BYTES) throw new Error("memory prompt store exceeds read ceiling");
+      chunks.push(chunk.subarray(0, count));
+    }
+  } finally {
+    closeSync2(fd);
+  }
+  const raw = Buffer.concat(chunks);
+  const records = parseAndValidate(raw.toString("utf8"), path2);
+  if (records.length > MEMORY_STORE_MAX_RECORDS) throw new Error("memory prompt store exceeds record limit");
+  return { revision: createHash5("sha256").update(raw).digest("hex"), records };
+}
 function memoryRoot(dataDir) {
   return join10(dataDir, "memory");
 }
@@ -4764,37 +4796,12 @@ async function rejectMemoryRecord(dataDir, memoryId, now = /* @__PURE__ */ new D
 async function pruneStaleMemory(dataDir, now = /* @__PURE__ */ new Date()) {
   return pruneStaleMemoryRecords(dataDir, now);
 }
-function selectApprovedMemory(records, options) {
-  if (options.tokenBudget <= 0) return [];
+function eligibleMemoryRecords(records, options) {
   const allowedScopes = options.scopes === void 0 ? null : new Set(options.scopes);
   const activeRepository = canonicalActiveRepository(options.activeRepository);
   const activeRuntime = validActiveNamedIdentity(options.activeRuntime, "runtime");
   const activeAgent = validActiveNamedIdentity(options.activeAgent, "agent");
-  const candidates = sortMemoryRecords(records).filter((record) => record.approved).filter((record) => record.evidenceRefs.length > 0).filter((record) => record.regressions === void 0 || record.regressions.length === 0).filter((record) => allowedScopes === null || allowedScopes.has(record.scope)).filter((record) => repositoryApplies(record, activeRepository)).filter((record) => runtimeApplies(record, activeRuntime)).filter((record) => agentApplies(record, activeAgent)).sort(compareRetrievalPriority);
-  const selected = [];
-  let spent = 0;
-  for (const record of candidates) {
-    const cost = estimateMemoryTokens(record);
-    if (spent + cost > options.tokenBudget) continue;
-    selected.push(record);
-    spent += cost;
-  }
-  return selected;
-}
-function estimateMemoryTokens(record) {
-  const text = [
-    record.scope,
-    record.key,
-    record.lesson,
-    ...record.repository === void 0 ? [] : [record.repository.kind, record.repository.key],
-    ...record.runtime === void 0 ? [] : [record.runtime.kind, record.runtime.key],
-    ...record.agent === void 0 ? [] : [record.agent.kind, record.agent.key],
-    ...record.evidenceRefs,
-    ...record.appliesWhen,
-    ...record.avoidWhen,
-    ...record.regressions ?? []
-  ].join("\n");
-  return Math.max(1, ceilChars(text.length));
+  return sortMemoryRecords(records).filter((record) => record.approved).filter((record) => record.evidenceRefs.length > 0).filter((record) => record.regressions === void 0 || record.regressions.length === 0).filter((record) => allowedScopes === null || allowedScopes.has(record.scope)).filter((record) => repositoryApplies(record, activeRepository)).filter((record) => runtimeApplies(record, activeRuntime)).filter((record) => agentApplies(record, activeAgent)).sort(compareRetrievalPriority);
 }
 function cloneRecord(record) {
   const next = {
@@ -4888,7 +4895,7 @@ function compareRetrievalPriority(left, right) {
 
 // src/domains/memory/promotion.ts
 init_esm_shims();
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 function validateMemoryScopeSelection(selection, source) {
   switch (selection.scope) {
     case "repo": {
@@ -5058,7 +5065,7 @@ function scopeApplicability(selection) {
   }
 }
 function promotedMemoryId(value) {
-  const digest = createHash5("sha256").update(JSON.stringify(value), "utf8").digest("hex").slice(0, 16);
+  const digest = createHash6("sha256").update(JSON.stringify(value), "utf8").digest("hex").slice(0, 16);
   return `mem-${digest}`;
 }
 function uniqueStrings(values) {
@@ -5083,22 +5090,88 @@ function compareStrings2(left, right) {
 
 // src/domains/memory/prompt-section.ts
 init_esm_shims();
+
+// src/domains/memory/relevance.ts
+init_esm_shims();
+var MEMORY_RELEVANCE_VERSION = "lexical-v1";
+var MEMORY_RELEVANCE_WEIGHTS = { taskTerm: 1, path: 8, symbol: 4 };
+var STOP_WORDS = /* @__PURE__ */ new Set(["and", "are", "for", "from", "into", "the", "this", "that", "with", "use", "when"]);
+function normalized(value) {
+  return value.normalize("NFKC").toLowerCase();
+}
+function terms(value) {
+  return [...new Set(normalized(value.replace(/([a-z])([A-Z])/g, "$1 $2")).match(/[\p{L}\p{N}]+/gu) ?? [])].filter(
+    (term) => term.length >= 2 && !STOP_WORDS.has(term)
+  );
+}
+function pathKey(value) {
+  return normalized(value).replaceAll("\\", "/").replace(/^\.\//, "");
+}
+function rankMemoryByRelevance(records, options, input) {
+  const taskTerms = terms(input.taskText).slice(0, 64);
+  const paths = [...new Set((input.activePaths ?? []).map(pathKey).filter(Boolean))].slice(0, 32);
+  const symbols = [...new Set((input.activeSymbols ?? []).map(normalized).filter(Boolean))].slice(0, 32);
+  const candidates = eligibleMemoryRecords(records, options).map((record) => {
+    const text = [record.key, record.lesson, ...record.appliesWhen].join("\n");
+    const textTerms = new Set(terms(text));
+    const textPaths = new Set(
+      (text.match(/[\p{L}\p{N}_./\\:-]+/gu) ?? []).map((path2) => pathKey(path2.replace(/[.:]+$/, "")))
+    );
+    const textSymbols = new Set(normalized(text).match(/[\p{L}\p{N}_$]+/gu) ?? []);
+    const matches = {
+      taskTerms: taskTerms.filter((term) => textTerms.has(term)),
+      paths: paths.filter((path2) => textPaths.has(path2)),
+      symbols: symbols.filter((symbol) => textSymbols.has(symbol))
+    };
+    return {
+      record,
+      matches,
+      fallback: false,
+      score: matches.taskTerms.length * MEMORY_RELEVANCE_WEIGHTS.taskTerm + matches.paths.length * MEMORY_RELEVANCE_WEIGHTS.path + matches.symbols.length * MEMORY_RELEVANCE_WEIGHTS.symbol
+    };
+  });
+  candidates.sort((a, b) => b.score - a.score);
+  if ((candidates[0]?.score ?? 0) > 0) {
+    const fallbackIndex = candidates.findIndex((candidate) => candidate.score === 0);
+    if (fallbackIndex >= 0) {
+      const [fallback] = candidates.splice(fallbackIndex, 1);
+      if (fallback !== void 0) candidates.splice(1, 0, { ...fallback, fallback: true });
+    }
+  }
+  return candidates;
+}
+
+// src/domains/memory/prompt-section.ts
 var MEMORY_PROMPT_DEFAULT_TOKEN_BUDGET = 400;
 var MEMORY_PROMPT_DEFAULT_MAX_ITEMS = 5;
 var MEMORY_PROMPT_DEFAULT_SCOPES = ["global", "repo"];
 function selectMemoryForPrompt(records, options = {}) {
+  return inspectMemoryPromptSelection(records, options).records;
+}
+function inspectMemoryPromptSelection(records, options = {}) {
   const scopes = options.scopes ?? MEMORY_PROMPT_DEFAULT_SCOPES;
   const tokenBudget = options.tokenBudget ?? MEMORY_PROMPT_DEFAULT_TOKEN_BUDGET;
   const maxItems = options.maxItems ?? MEMORY_PROMPT_DEFAULT_MAX_ITEMS;
-  if (tokenBudget <= 0 || maxItems <= 0) return [];
-  const selected = selectApprovedMemory(records, {
+  if (!Number.isFinite(tokenBudget) || !Number.isFinite(maxItems) || tokenBudget <= 0 || maxItems < 1)
+    return { records: [], decisions: [] };
+  const eligibility = {
     scopes,
-    tokenBudget,
     activeRepository: options.activeRepository ?? null,
     activeRuntime: options.activeRuntime ?? null,
     activeAgent: options.activeAgent ?? null
-  });
-  return selected.slice(0, maxItems);
+  };
+  const candidates = options.relevance === void 0 ? eligibleMemoryRecords(records, eligibility).map((record) => ({ record, relevance: void 0 })) : rankMemoryByRelevance(records, eligibility, options.relevance).map(({ record, ...relevance }) => ({
+    record,
+    relevance
+  }));
+  const selected = [];
+  const decisions = [];
+  for (const { record, relevance } of candidates) {
+    const reason = selected.length >= Math.floor(maxItems) ? "item-limit" : ceilChars(renderMemoryPromptSection([...selected, record]).length) > tokenBudget ? "token-budget" : "selected";
+    decisions.push({ id: record.id, reason, ...relevance === void 0 ? {} : { relevance } });
+    if (reason === "selected") selected.push(record);
+  }
+  return { records: selected, decisions };
 }
 function renderMemoryPromptSection(records) {
   if (records.length === 0) return "";
@@ -5112,9 +5185,14 @@ function renderMemoryPromptSection(records) {
     const lesson = record.lesson.replace(/\s+/g, " ").trim();
     const evidence = record.evidenceRefs.join(", ");
     lines.push(`- [${record.id}] (${renderApplicability(record)}) ${lesson} Evidence: ${evidence}.`);
+    if (record.appliesWhen.length > 0) lines.push(`  Applies when: ${record.appliesWhen.map(compactText).join("; ")}.`);
+    if (record.avoidWhen.length > 0) lines.push(`  Avoid when: ${record.avoidWhen.map(compactText).join("; ")}.`);
   }
   return lines.join("\n");
 }
+function compactText(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
 function renderApplicability(record) {
   if (record.scope === "repo") {
     if (record.repository !== void 0) {
@@ -5133,13 +5211,13 @@ function renderApplicability(record) {
 function buildMemoryPromptSection(records, options = {}) {
   const selected = selectMemoryForPrompt(records, options);
   const section = renderMemoryPromptSection(selected);
-  const tokens2 = selected.reduce((acc, record) => acc + estimateMemoryTokens(record), 0);
+  const tokens2 = ceilChars(section.length);
   return { section, records: selected, tokens: tokens2 };
 }
 
 // src/domains/memory/proposal.ts
 init_esm_shims();
-import { createHash as createHash16 } from "node:crypto";
+import { createHash as createHash17 } from "node:crypto";
 
 // src/domains/evidence/index.ts
 init_esm_shims();
@@ -5308,7 +5386,7 @@ function persistWorkerContextSeed(input) {
 }
 
 // src/domains/dispatch/extension.ts
-import { createHash as createHash13, randomBytes as randomBytes5 } from "node:crypto";
+import { createHash as createHash14, randomBytes as randomBytes5 } from "node:crypto";
 import { readdirSync as readdirSync8, readFileSync as readFileSync22 } from "node:fs";
 import { isAbsolute as isAbsolute6, relative as relative6, resolve as resolvePath, sep as sep3 } from "node:path";
 import { performance as performance4 } from "node:perf_hooks";
@@ -6481,7 +6559,7 @@ function toolSurfaceHasTool(toolNames, tool) {
   return names.has(tool);
 }
 function canonicalToolPromptHints(entries, admitted) {
-  const normalized = entries.map((entry) => ({
+  const normalized2 = entries.map((entry) => ({
     tool: entry.tool.trim(),
     hint: normalizePromptHint(entry.hint) ?? ""
   })).filter((entry) => admitted.has(entry.tool) && entry.hint.length > 0).sort((a, b) => {
@@ -6490,7 +6568,7 @@ function canonicalToolPromptHints(entries, admitted) {
   });
   const seenTools = /* @__PURE__ */ new Set();
   const seenHints = /* @__PURE__ */ new Set();
-  return normalized.filter((entry) => {
+  return normalized2.filter((entry) => {
     if (seenTools.has(entry.tool) || seenHints.has(entry.hint)) return false;
     seenTools.add(entry.tool);
     seenHints.add(entry.hint);
@@ -8317,7 +8395,7 @@ init_esm_shims();
 
 // src/domains/dispatch/agent-ledger-store.ts
 init_esm_shims();
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash7 } from "node:crypto";
 import { existsSync as existsSync9, readFileSync as readFileSync13 } from "node:fs";
 import { join as join14 } from "node:path";
 var MAX_AGENT_LEDGER_RECORDS = 50;
@@ -8456,7 +8534,7 @@ function agentLedgerContribution(id, runId) {
   if (record === null) return null;
   const contribution = contributionFor(record, runId);
   const mine = record.entries.filter((entry) => entry.runId === runId).sort((left, right) => left.sequence - right.sequence);
-  const digest = createHash6("sha256").update(`clio-coder.agentLedger:${canonicalJson(mine)}`, "utf8").digest("hex");
+  const digest = createHash7("sha256").update(`clio-coder.agentLedger:${canonicalJson(mine)}`, "utf8").digest("hex");
   return { posted: contribution.posted, refused: contribution.refused, digest };
 }
 
@@ -8951,7 +9029,7 @@ function assessCapabilityMismatch(input) {
 
 // src/domains/dispatch/checkout-writer-lease.ts
 init_esm_shims();
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 import { existsSync as existsSync12, mkdirSync as mkdirSync4, readFileSync as readFileSync16, realpathSync as realpathSync2, unlinkSync } from "node:fs";
 import { dirname as dirname6, join as join17 } from "node:path";
 var held = /* @__PURE__ */ new Map();
@@ -8961,7 +9039,7 @@ function canonicalCheckout(checkout) {
 }
 function checkoutWriterLeasePath(checkout) {
   const canonical = canonicalCheckout(checkout);
-  const key = createHash7("sha256").update(canonical, "utf8").digest("hex");
+  const key = createHash8("sha256").update(canonical, "utf8").digest("hex");
   return join17(clioStateDir(), "checkout-writer-leases", `${key}.json`);
 }
 function validRecord3(value) {
@@ -9183,14 +9261,14 @@ function classifyHeartbeat(heartbeatMonotonicAt2, monotonicNow, spec) {
 // src/domains/dispatch/host-verification.ts
 init_esm_shims();
 import { execFileSync as execFileSync3 } from "node:child_process";
-import { createHash as createHash9, randomUUID as randomUUID2 } from "node:crypto";
+import { createHash as createHash10, randomUUID as randomUUID2 } from "node:crypto";
 import { existsSync as existsSync13, mkdirSync as mkdirSync6, readFileSync as readFileSync17, renameSync as renameSync2, writeFileSync as writeFileSync4 } from "node:fs";
 import { dirname as dirname7, join as join19, resolve as resolve9 } from "node:path";
 
 // src/domains/dispatch/code-step.ts
 init_esm_shims();
 import { execFileSync as execFileSync2, spawn } from "node:child_process";
-import { createHash as createHash8 } from "node:crypto";
+import { createHash as createHash9 } from "node:crypto";
 import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync3 } from "node:fs";
 import { isAbsolute as isAbsolute5, join as join18, resolve as resolve8 } from "node:path";
 var CODE_STEP_CAPTURE_MAX_BYTES = 1048576;
@@ -9210,10 +9288,10 @@ function canonicalCodeReport(report) {
   });
 }
 function codeReportDigest(report) {
-  return createHash8("sha256").update(canonicalCodeReport(report), "utf8").digest("hex");
+  return createHash9("sha256").update(canonicalCodeReport(report), "utf8").digest("hex");
 }
 function sha2563(value) {
-  return createHash8("sha256").update(value, "utf8").digest("hex");
+  return createHash9("sha256").update(value, "utf8").digest("hex");
 }
 function tailUtf8(value, limit, marker) {
   if (value.length <= limit) return { text: value.toString("utf8"), truncated: false };
@@ -9263,7 +9341,7 @@ function workspaceHasChanges(root) {
   return status.trim().length > 0;
 }
 function newCodeRunId() {
-  return `code-${createHash8("sha256").update(`${process.pid}:${Date.now()}:${Math.random()}`).digest("hex").slice(0, 12)}`;
+  return `code-${createHash9("sha256").update(`${process.pid}:${Date.now()}:${Math.random()}`).digest("hex").slice(0, 12)}`;
 }
 async function spawnCommand(input, cwd, argv) {
   const command = input.command;
@@ -9442,7 +9520,7 @@ var HTTP_URL_RE = /\bhttps?:\/\/\S+/gu;
 var CHECK_OUTPUT_PATH_RE = /\/?(?:[A-Za-z0-9_.@+-]+\/)+[A-Za-z0-9_.@+-]*\.(?:[cm]?[jt]sx?|json|ya?ml|md|txt|py|go|rs|c|h|cc|cpp|hpp|java|rb|sh|toml|css|html|sql)\b/gu;
 var IMPLICATED_PATH_CAP = PATH_BOUNDARY_MAX_ENTRIES;
 function sha2564(value) {
-  return createHash9("sha256").update(value, "utf8").digest("hex");
+  return createHash10("sha256").update(value, "utf8").digest("hex");
 }
 function outputTail(value) {
   const bytes = Buffer.from(value, "utf8");
@@ -10487,7 +10565,7 @@ function createFleetPlacementPreviewResolver(deps) {
 
 // src/domains/dispatch/receipt-findings.ts
 init_esm_shims();
-import { createHash as createHash10 } from "node:crypto";
+import { createHash as createHash11 } from "node:crypto";
 function lower(value) {
   return (value ?? "").toLowerCase();
 }
@@ -10509,12 +10587,12 @@ function canonicalJson2(value) {
   throw new Error(`response schema digest cannot represent ${typeof value}`);
 }
 function canonicalResponseSchemaDigest(schema) {
-  return createHash10("sha256").update(canonicalJson2(schema), "utf8").digest("hex");
+  return createHash11("sha256").update(canonicalJson2(schema), "utf8").digest("hex");
 }
 function typedValidationFactsFromToolStats(toolStats) {
   return toolStats.filter((stat) => stat.tool === "verify" && stat.count > 0).map((stat) => ({
     sourceId: "tool:verify",
-    validatorDigest: createHash10("sha256").update(canonicalJson2(stat), "utf8").digest("hex"),
+    validatorDigest: createHash11("sha256").update(canonicalJson2(stat), "utf8").digest("hex"),
     passed: stat.ok === stat.count && stat.errors === 0 && stat.blocked === 0
   }));
 }
@@ -10678,7 +10756,7 @@ function selectApprovedRecoveryCandidates(input) {
 // src/domains/dispatch/reproducibility.ts
 init_esm_shims();
 import { spawnSync } from "node:child_process";
-import { createHash as createHash11 } from "node:crypto";
+import { createHash as createHash12 } from "node:crypto";
 function collectReproducibilityMetadata(cwd, safety) {
   const branch = git(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
   const commit = git(cwd, ["rev-parse", "HEAD"]);
@@ -10715,7 +10793,7 @@ function git(cwd, args) {
   return trimmed.length > 0 ? trimmed : null;
 }
 function sha2565(input) {
-  return createHash11("sha256").update(input, "utf8").digest("hex");
+  return createHash12("sha256").update(input, "utf8").digest("hex");
 }
 
 // src/domains/dispatch/route-observer.ts
@@ -10891,7 +10969,7 @@ function isPhaseTiming(value) {
 
 // src/domains/dispatch/route-quality.ts
 init_esm_shims();
-import { createHash as createHash12 } from "node:crypto";
+import { createHash as createHash13 } from "node:crypto";
 function compareStrings3(left, right) {
   return left < right ? -1 : left > right ? 1 : 0;
 }
@@ -11006,7 +11084,7 @@ function reduceRouteQuality(input) {
   return { label, checks, correlatedGates, sourceDigests: [...sourceDigests].sort(compareStrings3) };
 }
 function routeQualityEvalDigest(artifact) {
-  return createHash12("sha256").update(canonicalJson3(artifact), "utf8").digest("hex");
+  return createHash13("sha256").update(canonicalJson3(artifact), "utf8").digest("hex");
 }
 function canonicalJson3(value) {
   if (value === null) return "null";
@@ -11356,19 +11434,19 @@ function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function eventDetail(event) {
-  const normalized = isRecord9(event) ? normalizeClioCoderEventRecord(event) : event;
-  const text = assistantTextFromEvent(normalized);
+  const normalized2 = isRecord9(event) ? normalizeClioCoderEventRecord(event) : event;
+  const text = assistantTextFromEvent(normalized2);
   if (text.length > 0) return truncateUtf8(text, RUN_TAIL_TEXT_LIMIT, "...");
-  if (!isRecord9(normalized)) return void 0;
-  if (normalized.type === "clio_coder_tool_finish" && isRecord9(normalized.payload)) {
-    const tool = typeof normalized.payload.tool === "string" ? normalized.payload.tool : "tool";
-    const outcome = typeof normalized.payload.outcome === "string" ? normalized.payload.outcome : "";
+  if (!isRecord9(normalized2)) return void 0;
+  if (normalized2.type === "clio_coder_tool_finish" && isRecord9(normalized2.payload)) {
+    const tool = typeof normalized2.payload.tool === "string" ? normalized2.payload.tool : "tool";
+    const outcome = typeof normalized2.payload.outcome === "string" ? normalized2.payload.outcome : "";
     return `${tool} ${outcome}`.trim();
   }
-  if (normalized.type === "attempt_start") {
-    const attempt = typeof normalized.attempt === "number" ? normalized.attempt : "?";
-    const runId = typeof normalized.runId === "string" ? normalized.runId : "?";
-    const reason = typeof normalized.reason === "string" ? normalized.reason : "retry";
+  if (normalized2.type === "attempt_start") {
+    const attempt = typeof normalized2.attempt === "number" ? normalized2.attempt : "?";
+    const runId = typeof normalized2.runId === "string" ? normalized2.runId : "?";
+    const reason = typeof normalized2.reason === "string" ? normalized2.reason : "retry";
     return truncateUtf8(`attempt ${attempt} -> ${runId}: ${reason}`, RUN_TAIL_TEXT_LIMIT, "...");
   }
   return void 0;
@@ -12254,7 +12332,7 @@ function requestOriginFor(req) {
   return req.requestOrigin ?? "agent";
 }
 function sha2566(input) {
-  return createHash13("sha256").update(input, "utf8").digest("hex");
+  return createHash14("sha256").update(input, "utf8").digest("hex");
 }
 function promptHash(systemPrompt) {
   return systemPrompt.length > 0 ? sha2566(systemPrompt) : null;
@@ -16073,9 +16151,9 @@ function createDispatchBundle(context, options) {
         if (req.fleetGateReceipt === void 0) return null;
         try {
           const content = readFileSync22(resolvePath(lifecycle.cwd, req.fleetGateReceipt.path));
-          return { path: req.fleetGateReceipt.path, pathHash: createHash13("sha256").update(content).digest("hex") };
+          return { path: req.fleetGateReceipt.path, pathHash: createHash14("sha256").update(content).digest("hex") };
         } catch {
-          return { path: req.fleetGateReceipt.path, pathHash: createHash13("sha256").update("").digest("hex") };
+          return { path: req.fleetGateReceipt.path, pathHash: createHash14("sha256").update("").digest("hex") };
         }
       })();
       const ledgerContribution = (() => {
@@ -17536,7 +17614,7 @@ var DispatchManifest = {
 
 // src/domains/dispatch/delegation-plan.ts
 init_esm_shims();
-import { createHash as createHash14 } from "node:crypto";
+import { createHash as createHash15 } from "node:crypto";
 var DELEGATION_PROPOSAL_BRIEFING_MAX_BYTES = 12e3;
 function buildDelegationProposalBriefing(proposals) {
   const value = proposals.map((proposal) => `PROPOSAL ${proposal.agent}
@@ -17644,7 +17722,7 @@ function validateDelegationPlan(input) {
     }
   }
   const plan = { tasks };
-  return { ok: true, plan, hash: createHash14("sha256").update(JSON.stringify(plan)).digest("hex") };
+  return { ok: true, plan, hash: createHash15("sha256").update(JSON.stringify(plan)).digest("hex") };
 }
 
 // src/domains/dispatch/execution-scheduler.ts
@@ -18178,7 +18256,7 @@ function gateFailureLines(output) {
 
 // src/domains/dispatch/fleet-run.ts
 init_esm_shims();
-import { createHash as createHash15 } from "node:crypto";
+import { createHash as createHash16 } from "node:crypto";
 import { readFileSync as readFileSync23 } from "node:fs";
 import { join as join24 } from "node:path";
 
@@ -18666,7 +18744,7 @@ async function executeFleetRun(input) {
               } catch {
                 gateBytes = "";
               }
-              gatePathHash = createHash15("sha256").update(gateBytes).digest("hex");
+              gatePathHash = createHash16("sha256").update(gateBytes).digest("hex");
               const command = input.commands?.commands.get(step.gate.commandId);
               if (gateBytes.length === 0 || command === void 0) {
                 stepSucceeded = false;
@@ -20667,6 +20745,20 @@ function renderSessionTranscriptEntry(linked, calls) {
   if (entry.kind === "contextRecall") {
     return [`${prefix} contextRecall ref=${entry.ref.entry} trigger=${entry.trigger} tokens=${entry.tokensReadmitted}`];
   }
+  if (entry.kind === "handoffTransaction") {
+    const link = entry.transition;
+    const detail = entry.event.phase === "failed" || entry.event.phase === "paused" ? ` reason=${entry.event.reason}` : entry.event.phase === "resumed" ? ` action=${entry.event.authority.action} answers=${entry.event.authority.pausedOrFailedEntryId}` : "";
+    return [
+      `${prefix} handoffTransaction handoff=${entry.identity.handoffId} phase=${entry.event.phase} seq=${link.sequence} attempt=${link.attempt} prev=${link.prevEntryId ?? "none"}${detail}`
+    ];
+  }
+  if (entry.kind === "continuityCommit") {
+    const commit = entry.continuity.commit;
+    const ref = commit.summaryRef ?? commit.evictionRef ?? "none";
+    return [
+      `${prefix} continuityCommit handoff=${entry.continuity.identity.handoffId} commit=${entry.continuity.identity.commitId} outcome=${commit.outcome} ref=${ref} tokens=${commit.tokensBefore}->${commit.tokensAfter} state=${entry.continuity.state.event.phase}`
+    ];
+  }
   const _exhaustive = entry;
   return [`${prefix} ${String(_exhaustive)}`];
 }
@@ -21607,7 +21699,7 @@ async function proposeMemoryFromEvidence(dataDir, evidenceId, selection) {
   return { record, created: true };
 }
 function memoryIdFromEvidence(evidenceId) {
-  const digest = createHash16("sha256").update(evidenceId, "utf8").digest("hex").slice(0, 16);
+  const digest = createHash17("sha256").update(evidenceId, "utf8").digest("hex").slice(0, 16);
   return `mem-${digest}`;
 }
 function memoryRecordFromEvidence(overview, findings, selection) {
@@ -21652,7 +21744,7 @@ function memoryRecordFromEvidence(overview, findings, selection) {
   return validated.record;
 }
 function memoryIdFromEvidenceScope(evidenceId, scopeKey) {
-  const digest = createHash16("sha256").update(`${evidenceId}
+  const digest = createHash17("sha256").update(`${evidenceId}
 ${scopeKey}`, "utf8").digest("hex").slice(0, 16);
   return `mem-${digest}`;
 }
@@ -22119,7 +22211,7 @@ function taskMemoryBankSize(snapshot) {
 
 // src/domains/memory/task-memory-trace.ts
 init_esm_shims();
-import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync8, openSync as openSync2, writeSync as writeSync2 } from "node:fs";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync8, openSync as openSync3, writeSync as writeSync2 } from "node:fs";
 import { dirname as dirname8 } from "node:path";
 var TRACE_TEXT_MAX_CHARS = 8e3;
 function taskMemoryTracePath(env = process.env) {
@@ -22133,7 +22225,7 @@ function createTaskMemoryTrace(path2, now = () => /* @__PURE__ */ new Date()) {
       try {
         if (!opened) {
           mkdirSync8(dirname8(path2), { recursive: true });
-          writeSync2(openSync2(path2, "w"), "");
+          writeSync2(openSync3(path2, "w"), "");
           opened = true;
         }
         const row = {
@@ -22895,6 +22987,7 @@ export {
   inspectWikiPageEvidence,
   runWikiGenerate,
   runContextRefresh,
+  readMemoryStoreSnapshot,
   memoryStorePath,
   loadMemoryRecords,
   loadMemoryRecordsSync,
@@ -22906,6 +22999,7 @@ export {
   memoryRuntimeIdentity,
   memoryAgentIdentity,
   proposeMemoryPromotion,
+  MEMORY_RELEVANCE_VERSION,
   buildMemoryPromptSection,
   selectWorkerContext,
   protectedResidencyModels,
@@ -22924,6 +23018,7 @@ export {
   ACP_MAX_TOOL_PROGRESS_FRAMES_PER_CALL,
   ACP_MIN_TOOL_PROGRESS_INTERVAL_MS,
   ACP_MAX_TOOL_CALL_ID_BYTES,
+  sessionCanUseSkills,
   compile,
   compileWorker,
   setCapacityDraining,
@@ -22999,4 +23094,4 @@ export {
   buildWikiPlanPrompt,
   buildWikiPagePrompt
 };
-//# sourceMappingURL=chunk-LTWH2ACR.js.map
+//# sourceMappingURL=chunk-EQPFEDFV.js.map