@ngockhoale/ukit 3.4.1 → 3.4.2

package/template_project/.claude/ukit/runtime/hook-telemetry.mjs

@@ -93,9 +93,78 @@ export function telemetryDirFor(projectRoot) {
   return path.join(projectRoot, '.ukit', 'storage', 'cache', 'hook-latency');
 }
 
+// --- session-file lock (C90-19) ----------------------------------------------
+// Synchronous variant of the `<file>.lock` convention async-lock.mjs owns for
+// the async twins (mkdir is atomic, so exactly one process wins; `owner` stamps
+// pid+token so stale reclaim is validated). The telemetry writers are all
+// short-lived, fully-sync hook processes — the async lock would need an event
+// loop these callers deliberately avoid — so the sync copy stays minimal:
+// bounded spin, stale reclaim when the recorded pid is provably gone, and a
+// fail-closed return (a missed budget drops the row — telemetry is advisory).
+const TEL_LOCK_STALE_MS = 10_000;
+const TEL_LOCK_BUDGET_MS = 300;
+
+function isLockOwnerAlive(lockPath) {
+  try {
+    const owner = JSON.parse(fs.readFileSync(path.join(lockPath, 'owner'), 'utf8'));
+    if (!Number.isInteger(owner?.pid) || owner.pid <= 0) return false;
+    process.kill(owner.pid, 0);
+    return true;
+  } catch (error) {
+    // EPERM: the process exists but belongs to another user — still alive.
+    return error?.code === 'EPERM';
+  }
+}
+
+function withTelemetryFileLock(filePath, fn) {
+  const lockPath = `${filePath}.lock`;
+  const deadline = Date.now() + TEL_LOCK_BUDGET_MS;
+  let held = false;
+  while (!held && Date.now() < deadline) {
+    try {
+      fs.mkdirSync(lockPath);
+      held = true;
+      try {
+        fs.writeFileSync(
+          path.join(lockPath, 'owner'),
+          `${JSON.stringify({ pid: process.pid, token: `${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`, ts: Date.now() })}\n`,
+        );
+      } catch {
+        // Owner stamp is advisory (stale reclaim degrades to the mtime
+        // threshold); failing to write it must not drop the held lock.
+      }
+    } catch (error) {
+      if (!error || error.code !== 'EEXIST') return undefined;
+      try {
+        const stat = fs.statSync(lockPath);
+        if (Date.now() - stat.mtimeMs > TEL_LOCK_STALE_MS && !isLockOwnerAlive(lockPath)) {
+          fs.rmSync(lockPath, { recursive: true, force: true });
+          continue;
+        }
+      } catch {
+        // stat raced away — fall through to the bounded spin
+      }
+      const spinUntil = Date.now() + 5;
+      while (Date.now() < spinUntil) { /* bounded spin — sync callers only */ }
+    }
+  }
+  if (!held) return undefined;
+  try {
+    return fn();
+  } finally {
+    try {
+      fs.rmSync(lockPath, { recursive: true, force: true });
+    } catch {
+      // Leftover lock self-heals via the stale threshold above.
+    }
+  }
+}
+
 // Bounded work on THIS session's file only: stat, at most one read of a file
 // already capped at maxBytes, one rewrite of the kept half. Directory growth is
 // bounded separately by the sampled sweepTelemetryDir below (BUG-C21-10).
+// C90-19: the rewrite is tmp+rename — the pre-fix in-place writeFileSync on the
+// live file could expose a torn file or lose an interleaved append.
 function rotateIfNeeded(filePath, incomingBytes, maxBytes) {
   let size = 0;
   try {
@@ -116,7 +185,17 @@ function rotateIfNeeded(filePath, incomingBytes, maxBytes) {
       keep.unshift(lines[i]);
       kept += lineBytes;
     }
-    fs.writeFileSync(filePath, keep.length ? `${keep.join('\n')}\n` : '', 'utf8');
+    const tmpPath = `${filePath}.rot-${process.pid}-${Math.random().toString(16).slice(2)}`;
+    try {
+      fs.writeFileSync(tmpPath, keep.length ? `${keep.join('\n')}\n` : '', 'utf8');
+      fs.renameSync(tmpPath, filePath);
+    } catch (renameError) {
+      try { fs.rmSync(tmpPath, { force: true }); } catch { /* best effort */ }
+      if (renameError?.code !== 'EXDEV') throw renameError;
+      // EXDEV: tmp and destination on different mounts — same copy-over
+      // fallback token-utils writeJson carries.
+      fs.writeFileSync(filePath, keep.length ? `${keep.join('\n')}\n` : '', 'utf8');
+    }
   } catch {
     // Rotation failed; drop this row rather than grow past the cap.
   }
@@ -230,12 +309,18 @@ export function appendTelemetryRow(projectRoot, sessionId, row, options = {}) {
     fs.mkdirSync(dir, { recursive: true });
     const filePath = path.join(dir, `${safeName(sessionId)}.jsonl`);
     const line = `${JSON.stringify(row)}\n`;
-    rotateIfNeeded(filePath, Buffer.byteLength(line, 'utf8'), capBytes(options.maxBytes));
-    fs.appendFileSync(filePath, line, 'utf8');
-    // Sampled bounded dir sweep (BUG-C21-10): advisory — a sweep failure must
-    // never alter the row this call just appended.
-    try { maybeSweepTelemetryDir(dir); } catch (error) { noteSweepFailure(error); }
-    return true;
+    // C90-19: rotation and the append run under the session-file lock — an
+    // unlocked append landing between the rotator's readFileSync and its
+    // rename was the lost-row window. Lock budget expiry drops the row
+    // (telemetry is advisory, never a blocker).
+    return withTelemetryFileLock(filePath, () => {
+      rotateIfNeeded(filePath, Buffer.byteLength(line, 'utf8'), capBytes(options.maxBytes));
+      fs.appendFileSync(filePath, line, 'utf8');
+      // Sampled bounded dir sweep (BUG-C21-10): advisory — a sweep failure must
+      // never alter the row this call just appended.
+      try { maybeSweepTelemetryDir(dir); } catch (error) { noteSweepFailure(error); }
+      return true;
+    }) === true;
   } catch {
     // Advisory: an unwritable or corrupt telemetry target must never alter a
     // hook's verdict, output, or exit status.

package/template_project/.claude/ukit/runtime/memory-freshness.mjs

@@ -61,6 +61,23 @@ async function checkFileEvidence(projectRoot, entry) {
   const abs = resolveLocator(projectRoot, entry.locator);
   if (abs == null) return { state: UNKNOWN, detail: 'locator-unverifiable' };
 
+  // Symlink defense (SPEC §14): a locator that resolves inside projectRoot
+  // but lands on a symlink pointing outside must never be followed — the
+  // realpath containment check makes escapes unverifiable → 'unknown'.
+  try {
+    const lst = await fsp.lstat(abs);
+    if (lst.isSymbolicLink()) {
+      const root = path.resolve(projectRoot);
+      const real = await fsp.realpath(abs).catch(() => null);
+      if (real == null || (real !== root && !real.startsWith(root + path.sep))) {
+        return { state: UNKNOWN, detail: 'locator-unverifiable' };
+      }
+    }
+  } catch {
+    // lstat failure → fall through to the normal stat path, which maps
+    // ENOENT to 'file-missing' and other errors to 'file-unverified'.
+  }
+
   const fp = entry.fingerprint;
   if (typeof fp === 'string' && fp.startsWith('sha1:')) {
     const actual = await sha1Fingerprint(abs);

package/template_project/.claude/ukit/runtime/observability-emit.mjs

@@ -249,7 +249,9 @@ function sanitizeValue(value, ctx, depth) {
     let kept = 0;
     for (const [k, v] of Object.entries(value)) {
       if (kept >= MAX_OBJECT_KEYS) break;
-      if (DENIED_PAYLOAD_FIELDS.has(k)) continue;
+      // TASK-C91-015 (W3-OB1): the denylist is case-insensitive — 'Prompt'
+      // and 'AUTHORIZATION' leak the same data as their lowercase forms.
+      if (DENIED_PAYLOAD_FIELDS.has(k.toLowerCase())) continue;
       const key = sanitizeKey(k, ctx);
       if (key === null) continue;
       const sv = sanitizeValue(v, ctx, depth + 1);
@@ -473,6 +475,10 @@ const MAX_POLICY_VERSION_CHARS = 128;
 const SAMPLING_BUCKETS = 10000;
 const SAMPLING_SEED = 0;
 let samplingConfigInvalidSeen = false;
+// TASK-C91-015 (W3-OB2): the CONFIG_INVALID report latch is process-level —
+// emitOne re-creates its per-call `state`, so a `state.configInvalidReported`
+// flag re-reported the aggregate on every emit in the same process.
+let samplingConfigInvalidReported = false;
 
 function resolveSampling(config = null) {
   const node = isPlainObject(config) ? config.observability : undefined;
@@ -659,24 +665,46 @@ async function withTimeout(promise, ms) {
   return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
 }
 
+// Marks a readState result synthesized from a FAILED read (corrupt file,
+// transient EACCES/IO_TIMEOUT, non-object payload) — in-memory only, never
+// persisted (parity with segments/internal.js STATE_READ_FAILED).
+const STATE_READ_FAILED = Symbol('ukit.observability.stateReadFailed');
+
 async function readState(root, timeoutMs) {
   try {
     const raw = await withTimeout(fs.promises.readFile(path.join(root, STATE_FILE), 'utf8'), timeoutMs);
     const parsed = JSON.parse(raw);
-    return { ...STATE_DEFAULTS, ...(parsed && typeof parsed === 'object' ? parsed : {}) };
-  } catch {
-    return { ...STATE_DEFAULTS };
+    // TASK-C91-015 (W3-OB3): a torn/corrupt state file must fail CLOSED —
+    // defaulting to `disabled:false` would keep the total-size gate open
+    // through corruption. Only ENOENT means "no state yet" (open); every
+    // other failure and every non-object payload is disabled:true until a
+    // clean write re-enables the store. The synthesized state is MARKED so
+    // it is never persisted back as durable disabled:true.
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      return { ...STATE_DEFAULTS, disabled: true, [STATE_READ_FAILED]: true };
+    }
+    return { ...STATE_DEFAULTS, ...parsed };
+  } catch (err) {
+    if (err && err.code === 'ENOENT') return { ...STATE_DEFAULTS };
+    return { ...STATE_DEFAULTS, disabled: true, [STATE_READ_FAILED]: true };
   }
 }
 
 async function writeState(root, state, timeoutMs) {
+  // TASK-C91-015 (W3-OB3): atomic publish — tmp sibling + rename, same
+  // convention as segments/internal.js writeState, so a crash mid-write
+  // leaves the previous _state.json (or none), never a torn file. A state
+  // synthesized from a failed read is never published — persisting it
+  // would turn a transient I/O error into permanent disabled:true.
+  if (state && state[STATE_READ_FAILED]) return false;
+  const statePath = path.join(root, STATE_FILE);
+  const tmpPath = `${statePath}.tmp-${process.pid}-${crypto.randomBytes(4).toString('hex')}`;
   try {
-    await withTimeout(
-      fs.promises.writeFile(path.join(root, STATE_FILE), JSON.stringify(state, null, 2)),
-      timeoutMs,
-    );
+    await withTimeout(fs.promises.writeFile(tmpPath, JSON.stringify(state, null, 2)), timeoutMs);
+    await withTimeout(fs.promises.rename(tmpPath, statePath), timeoutMs);
     return true;
   } catch {
+    try { await fs.promises.unlink(tmpPath); } catch { /* best-effort */ }
     return false;
   }
 }
@@ -876,8 +904,8 @@ async function emitOne({ projectRoot, config, record, deps, deadlineMs }) {
       }
       return fail('sampled-out');
     }
-    if (samplingConfigInvalidSeen && !state.configInvalidReported) {
-      state.configInvalidReported = true;
+    if (samplingConfigInvalidSeen && !samplingConfigInvalidReported) {
+      samplingConfigInvalidReported = true;
       const aggregate = fillEnvelope({
         semantic_name: 'telemetry.dropped',
         payload: { reason_code: 'CONFIG_INVALID', dropped_count: 1 },

package/template_project/.claude/ukit/runtime/output-compression.mjs

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import crypto from 'node:crypto';
 import fs from 'node:fs/promises';
 import fsSync from 'node:fs';
 import path from 'node:path';
@@ -331,6 +332,7 @@ function buildRecoveryFileName({
   summary = '',
   profile = 'generic',
   exitCode = null,
+  contentHash = '',
 } = {}) {
   const slug = sanitizeFileComponent(String(command).split(/\s+/).slice(0, 3).join('-'), {
     fallback: sanitizeFileComponent(profile, { fallback: 'output', maxLength: 16 }),
@@ -341,6 +343,10 @@ function buildRecoveryFileName({
     summary: String(summary ?? '').trim(),
     profile: String(profile ?? 'generic').trim(),
     exitCode: Number.isFinite(Number(exitCode)) ? Number(exitCode) : null,
+    // C90-05: bind the name to the bytes it stores. The older inputs let two
+    // compressions of the same command compressing to the same summary (the
+    // normal retry loop) collide at the tee dir and overwrite each other.
+    contentHash: String(contentHash ?? ''),
   }).split(':').at(-1)?.replace(/[^a-z0-9_-]/gi, '-').slice(0, 16) || 'recovery';
   return `${slug}-${fingerprint}.log`;
 }
@@ -527,6 +533,11 @@ async function persistRawOutput(projectRoot, {
     summary,
     profile,
     exitCode,
+    contentHash: crypto.createHash('sha256')
+      .update(String(stdout ?? ''))
+      .update('\0')
+      .update(String(stderr ?? ''))
+      .digest('hex'),
   });
   const absolutePath = path.join(teeCacheDir, fileName);
   const rawOutputText = buildRawOutputText({

package/template_project/.claude/ukit/runtime/reinject-context.mjs

@@ -153,7 +153,7 @@ async function main() {
       ? hookPayload.session_id.trim()
       : undefined,
   };
-  const state = await loadFreshRouteState(projectRoot);
+  const state = await loadFreshRouteState(projectRoot, sessionConfig.sessionId);
   const compressEnabled = shouldCompress(config);
   const header = '=== PROJECT CONTEXT (post-compaction) ===';
   const footer = '=== END ===';
@@ -375,13 +375,34 @@ async function loadRuntimeConfig(projectRoot) {
   return deepMerge(defaultRuntimeConfig(), raw && typeof raw === 'object' ? raw : {});
 }
 
-async function loadFreshRouteState(projectRoot) {
+// W3-RI1: route state is session-scoped — its top-level `sessionId` is the
+// owner stamp both writers (skill-router.sh and route-task.mjs) persist.
+// Comparing it before reinjecting matters: session A's compaction must never
+// adopt session B's lane/plans as its own. Fail conservative (planner note):
+// a state whose stored sessionId is absent or different is not reinjected for
+// a sessioned caller; a sessionless payload (legacy/unknown harness) compares
+// against nothing and is left to the same equality — ownerless↔ownerless only.
+async function loadFreshRouteState(projectRoot, sessionId) {
   const statePath = path.join(projectRoot, '.claude', 'ukit', 'skill-router-state.json');
   const state = await readJson(statePath, {});
   if (typeof state?.ts === 'number' && (Date.now() - state.ts) > STATE_TTL_MS) {
     return {};
   }
-  return state && typeof state === 'object' ? state : {};
+  if (!state || typeof state !== 'object') return {};
+  const ownerId = typeof state.sessionId === 'string' && state.sessionId.trim()
+    ? state.sessionId.trim()
+    : null;
+  if (ownerId !== (sessionId ?? null)) {
+    try {
+      process.stderr.write(
+        `[UKit] reinject-context: skipped shared route state owned by a different session (owner=${ownerId ?? 'none'}).\n`,
+      );
+    } catch {
+      // diagnostics are best-effort
+    }
+    return {};
+  }
+  return state;
 }
 
 function unique(values) {

package/template_project/.claude/ukit/runtime/resumable-run.mjs

@@ -352,6 +352,37 @@ async function drainRunJournal(target) {
   }
   return records;
 }
+// W3-RR1: the journal's drain→rm window is one locked section under the SAME
+// journal-local lock appendRunJournal serializes on — a checkpoint appended
+// between the drain and the rm was silently deleted. `update` runs while the
+// record lock is already held; `applied: true` means it landed the target
+// write, so the journal can be consumed. When the journal lock itself is
+// contended the update still runs (the record lock serializes this section),
+// but the journal is kept: an in-flight append has not been observed and the
+// next holder re-merges idempotently. Lock order is record→journal only;
+// appenders never hold the journal while waiting on the record lock, so this
+// cannot deadlock.
+async function runJournalUpdate(target, update) {
+  const journalPath = runJournalPathFor(target);
+  const lockedOutcome = await withAsyncLock(
+    journalPath,
+    { deadlineMs: RUN_JOURNAL_LOCK_BUDGET_MS },
+    async () => {
+      const result = await update();
+      if (result?.applied === true) {
+        try {
+          await fs.rm(journalPath, { force: true });
+        } catch {
+          // a leftover journal re-applies idempotently on the next lock
+        }
+      }
+      return result;
+    },
+  );
+  if (lockedOutcome?.ok === true) return lockedOutcome.value;
+  return update();
+}
+
 
 function recordTimestamp(record) {
   return Number.isFinite(record?.updatedAt) ? record.updatedAt : 0;
@@ -397,17 +428,17 @@ export async function writeResumableRun(projectRoot, record, {
     // Reconcile first: journaled snapshots from earlier busy writes are
     // candidates alongside the incoming record; the newest updatedAt wins and
     // lands in ONE atomic write. The journal is removed only after the write
-    // lands, so a crash mid-section leaves the records re-appliable.
-    const journaled = await drainRunJournal(target);
-    const candidates = [...journaled, stamped];
-    const winner = candidates.reduce((a, b) => (recordTimestamp(b) >= recordTimestamp(a) ? b : a));
-    await writeJsonAtomic(target, winner);
-    try {
-      await fs.rm(runJournalPathFor(target), { force: true });
-    } catch {
-      // a leftover journal re-applies idempotently on the next lock
-    }
-    return winner;
+    // lands, so a crash mid-section leaves the records re-appliable — and the
+    // drain+rm runs under the journal lock (W3-RR1) so an append racing the
+    // rm can never lose a checkpoint.
+    const result = await runJournalUpdate(target, async () => {
+      const journaled = await drainRunJournal(target);
+      const candidates = [...journaled, stamped];
+      const winner = candidates.reduce((a, b) => (recordTimestamp(b) >= recordTimestamp(a) ? b : a));
+      await writeJsonAtomic(target, winner);
+      return { applied: true, value: winner };
+    });
+    return result.value;
   });
 
   if (outcome?.ok === true) {
@@ -606,27 +637,26 @@ export async function invalidateResumableRun(projectRoot, taskId, codes, {
 
   const outcome = await withAsyncLock(target, { signal, deadlineMs }, async () => {
     // Reconcile the journal first so invalidation applies to the newest known
-    // state, not a superseded on-disk record.
-    const journaled = await drainRunJournal(target);
-    let parsed;
-    try {
-      parsed = JSON.parse(await fs.readFile(target, 'utf8'));
-    } catch (error) {
-      if (error?.code !== 'ENOENT') return { ok: false, reason: 'invalid' };
-      parsed = null;
-    }
-    const candidates = [...journaled, ...(parsed ? [parsed] : [])];
-    if (candidates.length === 0) return { ok: false, reason: 'absent' };
-    const base = candidates.reduce((a, b) => (recordTimestamp(b) >= recordTimestamp(a) ? b : a));
-    const { record, invalidated } = applyInvalidationCodes(base, codeList);
-    record.updatedAt = Date.now();
-    await writeJsonAtomic(target, record);
-    try {
-      await fs.rm(runJournalPathFor(target), { force: true });
-    } catch {
-      // leftover journal re-applies idempotently on the next lock
-    }
-    return { ok: true, invalidated };
+    // state, not a superseded on-disk record. The drain+rm runs under the
+    // journal lock (W3-RR1) — same convention as the write path.
+    const result = await runJournalUpdate(target, async () => {
+      const journaled = await drainRunJournal(target);
+      let parsed;
+      try {
+        parsed = JSON.parse(await fs.readFile(target, 'utf8'));
+      } catch (error) {
+        if (error?.code !== 'ENOENT') return { applied: false, value: { ok: false, reason: 'invalid' } };
+        parsed = null;
+      }
+      const candidates = [...journaled, ...(parsed ? [parsed] : [])];
+      if (candidates.length === 0) return { applied: false, value: { ok: false, reason: 'absent' } };
+      const base = candidates.reduce((a, b) => (recordTimestamp(b) >= recordTimestamp(a) ? b : a));
+      const { record, invalidated } = applyInvalidationCodes(base, codeList);
+      record.updatedAt = Date.now();
+      await writeJsonAtomic(target, record);
+      return { applied: true, value: { ok: true, invalidated } };
+    });
+    return result.value;
   });
 
   if (outcome?.ok === true) return outcome.value;

package/template_project/.claude/ukit/runtime/token-utils.mjs

@@ -283,10 +283,18 @@ export function compactContextBlock(
           forceFirstCount: (header ? 1 : 0) + normalizedAnchorLines.length,
         },
       ).join('\n').trim();
-      validationMode = 'forced-anchors';
+      // 'forced-anchors' means every anchor is present — verify it. When the block
+      // budget cannot hold them all, the mode must report the shortfall instead of
+      // claiming an anchor-complete block that silently dropped the tail anchors
+      // (C92-H-03: the dropped tail used to be memory-bridge + ask-before-drop).
+      validationMode = findMissingAnchors(text, normalizedAnchorLines).length === 0
+        ? 'forced-anchors'
+        : 'anchor-shortfall';
     }
   }
 
+  const missingAnchors = findMissingAnchors(text, normalizedAnchorLines);
+
   return {
     text,
     tokensBefore: estimateTokenCount(beforeText),
@@ -294,6 +302,7 @@ export function compactContextBlock(
     savedTokens: Math.max(0, estimateTokenCount(beforeText) - estimateTokenCount(text)),
     validationMode,
     anchorCount: normalizedAnchorLines.length,
+    missingAnchors,
   };
 }
 
@@ -361,11 +370,13 @@ function buildCompactedContextLines(
     forceFirstCount = 0,
   } = {},
 ) {
+  const hardTokenCap = Math.max(maxTokens, Math.ceil(maxTokens * 2));
   const sourceLines = Array.isArray(lines) ? lines : [];
   const selected = [];
   const seen = new Set();
   let usedTokens = 0;
   let nonEmptyCount = 0;
+  let forcedRemaining = forceFirstCount;
 
   for (const line of sourceLines) {
     const compressed = compressLine(line);
@@ -379,20 +390,37 @@ function buildCompactedContextLines(
     }
 
     const tokens = estimateTokenCount(compressed);
-    const forceLine = nonEmptyCount < forceFirstCount;
-    const wouldOverflow = selected.length > 0 && (usedTokens + tokens) > maxTokens;
+    // Forced lines (header + anchors) are the first `forceFirstCount` distinct
+    // non-empty source lines: they bypass the line cap and the soft token budget —
+    // dropping a forced anchor would silently break the anchor contract this
+    // function exists to enforce. The quota is consumed on the candidate itself,
+    // whether or not it fits, so a dropped forced anchor never slides its slot
+    // onto a following content line.
+    const forceLine = forcedRemaining > 0;
+    if (forceLine) {
+      forcedRemaining -= 1;
+    }
     const wouldExceedLines = nonEmptyCount >= maxLines;
 
-    if (!forceLine && (wouldOverflow || wouldExceedLines)) {
+    if ((!forceLine && wouldExceedLines) || (!forceLine && selected.length > 0 && (usedTokens + tokens) > maxTokens)) {
       break;
     }
-    if (forceLine && wouldExceedLines) {
-      break;
+
+    const selectedLine = forceLine && (usedTokens + tokens) > hardTokenCap
+      ? truncateToTokenBudget(compressed, hardTokenCap - usedTokens)
+      : compressed;
+    const selectedTokens = estimateTokenCount(selectedLine);
+
+    // A forced line whose remaining slice of hardTokenCap is empty used to break
+    // the loop, dropping every anchor after it. Keep going so later anchors still
+    // get their chance — the caller reports whichever anchors never landed.
+    if (!selectedLine) {
+      continue;
     }
 
-    selected.push(compressed);
+    selected.push(selectedLine);
     seen.add(dedupeKey);
-    usedTokens += tokens;
+    usedTokens += selectedTokens;
     nonEmptyCount += 1;
   }
 
@@ -411,6 +439,13 @@ function findMissingAnchors(text, anchorLines) {
   });
 }
 
+function truncateToTokenBudget(line, maxTokens) {
+  if (maxTokens <= 0) return '';
+  const maxChars = Math.max(1, (maxTokens * 4) - 4);
+  const value = String(line ?? '');
+  return value.length <= maxChars ? value : `${value.slice(0, Math.max(1, maxChars - 1)).trimEnd()}…`;
+}
+
 function normalizePromptCacheEntry(entry) {
   if (!entry || typeof entry !== 'object') {
     return null;
@@ -595,10 +630,18 @@ export async function recordCompaction(projectRoot, entry, { maxEntries = DEFAUL
   }
 
   const runtimePaths = buildRuntimePaths(projectRoot);
-  const history = normalizeCompactHistoryDocument(await readJson(runtimePaths.compactHistoryPath, null), { maxEntries });
-  const nextDocument = normalizeCompactHistoryDocument({
-    entries: [normalizedEntry, ...history.entries],
-  }, { maxEntries });
-  await writeJson(runtimePaths.compactHistoryPath, nextDocument);
-  return normalizedEntry;
+  // C90-06: lock the read-modify-write like the src twin
+  // (src/core/compact/index.js recordCompaction → appendCompactHistory) —
+  // concurrent hook processes each prepended to a stale snapshot and
+  // last-write-wins silently dropped one entry. The same lock protocol the
+  // prompt-cache RMW above uses; fail-closed (a skipped write is journaled,
+  // matching the history file's advisory-cache posture).
+  return withFileLock(runtimePaths.compactHistoryPath, async () => {
+    const history = normalizeCompactHistoryDocument(await readJson(runtimePaths.compactHistoryPath, null), { maxEntries });
+    const nextDocument = normalizeCompactHistoryDocument({
+      entries: [normalizedEntry, ...history.entries],
+    }, { maxEntries });
+    await writeJson(runtimePaths.compactHistoryPath, nextDocument);
+    return normalizedEntry;
+  });
 }