@ngockhoale/ukit 3.4.1 → 3.4.2

package/src/core/runtimeConfig.js

@@ -529,6 +529,7 @@ export function buildDefaultRuntimeConfig(overrides = {}) {
       archiveAfterDays: 30,
       maxSessions: 20,
       maxArchivedSessions: 50,
+      maxPatternCandidates: 50,
       redactSecrets: true,
     },
     validation: {
@@ -1185,6 +1186,7 @@ export function validateRuntimeConfig(config) {
     pushPositiveNumberError(errors, config.memory.archiveAfterDays, 'memory.archiveAfterDays');
     pushPositiveNumberError(errors, config.memory.maxSessions, 'memory.maxSessions');
     pushPositiveNumberError(errors, config.memory.maxArchivedSessions, 'memory.maxArchivedSessions');
+    pushPositiveNumberError(errors, config.memory.maxPatternCandidates, 'memory.maxPatternCandidates');
     pushBooleanError(errors, config.memory.redactSecrets, 'memory.redactSecrets');
   }
 

package/src/core/status.js

@@ -138,6 +138,8 @@ export async function buildStatusReport(projectRoot) {
     throw new Error('Shared UKit runtime not found. Run `ukit install` first.');
   }
 
+  // C92-C-03: read-only — detectProjectContext defaults to mint:false, so this
+  // reports an existing identity but never creates/modifies the registry.
   const projectContext = await detectProjectContext(projectRoot);
   const config = await loadRuntimeConfig(projectRoot);
   const compactHistory = normalizeCompactEntries(await readStatusJson(runtimePaths.compactHistoryPath));

package/src/core/taskBudgetValidator.js

@@ -41,6 +41,12 @@ export const VERIFICATION_MINUTE_TABLE = Object.freeze({
   'node scripts/release/verify-release.mjs': 2,
 });
 
+// W3-05: `yarn test` / `yarn vitest run` with NO file args runs the entire
+// suite — the single most expensive verification command a task can carry.
+// Estimating it at 0 let verification-heavy tasks slip maxVerificationMinutes;
+// floor it at the release-core cost.
+const WHOLE_SUITE_MINUTES = 3;
+
 // Per-command minute estimate. `yarn vitest [run]` and the `yarn test` alias (the repo's
 // dominant verification form) → 0.5 per FILE argument (per non-flag token after the runner
 // word); anything else falls back to 1 flat.
@@ -60,7 +66,7 @@ export function estimateVerificationMinutes(commands) {
       const runIdx = tokens.indexOf('run');
       const tail = runIdx >= 0 ? tokens.slice(runIdx + 1) : tokens.slice(2);
       const fileArgs = tail.filter((t) => !t.startsWith('-') && t.length > 0);
-      total += fileArgs.length * 0.5;
+      total += fileArgs.length === 0 ? WHOLE_SUITE_MINUTES : fileArgs.length * 0.5;
       continue;
     }
     total += 1;

package/src/core/taskProgressGuard.js

@@ -188,7 +188,8 @@ export function checkMilestoneProgress({
   }
 
   if (Number.isFinite(newestTs)) {
-    const limitMs = 2 * milestoneIntervalMin * 60 * 1000;
+    const intervalMs = milestoneIntervalMin * 60 * 1000;
+    const limitMs = 2 * intervalMs;
     const ageMs = now - newestTs;
     // Boundary: ageMs === limitMs is still OK; ageMs > limitMs is stale.
     if (ageMs > limitMs) {
@@ -197,6 +198,15 @@ export function checkMilestoneProgress({
         detail: `newest entry is ${Math.round(ageMs / 60000)} min old; threshold is ${2 * milestoneIntervalMin} min`,
       });
     }
+    // W2-C7: a timestamp in the future would yield negative age and silently
+    // never fire staleness. Rule: >1 interval in the future counts as
+    // stale-milestone (same vocabulary); <=1 interval is tolerated clock skew.
+    if (newestTs - now > intervalMs) {
+      violations.push({
+        type: 'stale-milestone',
+        detail: `newest entry is ${Math.round((newestTs - now) / 60000)} min in the future; allowed skew is ${milestoneIntervalMin} min`,
+      });
+    }
   }
 
   const targetFiles = collectTargetFiles(markdown);

package/src/core/unattendedDoctor.js

@@ -3,7 +3,7 @@ import fs from 'node:fs/promises';
 import { execFile } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { parse } from 'yaml';
-import { pathExists, readJsonIfExists } from './fileOps.js';
+import { pathExists } from './fileOps.js';
 import { VALID_PERMISSION_MODES } from './runtimeConfig.js';
 
 // TASK-011 / SPEC §8 — unattended-mode doctor checks (FR-007).
@@ -69,11 +69,27 @@ async function readTemplateDenyMatches() {
   }
 }
 
+// FR-025 / W2-C3 — a corrupt `.ukit/storage/config.json` is exactly what doctor
+// exists to diagnose: readJsonIfExists would throw the SyntaxError and kill the
+// run, so the surface read is tolerant and the parse error becomes a finding.
+async function readRuntimeConfigSurface(projectRoot) {
+  const configPath = path.join(projectRoot, '.ukit', 'storage', 'config.json');
+  try {
+    return { exists: true, parsed: JSON.parse(await fs.readFile(configPath, 'utf8')), parseError: null };
+  } catch (error) {
+    if (error?.code === 'ENOENT') return { exists: false, parsed: null, parseError: null };
+    return { exists: true, parsed: null, parseError: error?.message ?? String(error) };
+  }
+}
+
 export async function inspectUnattendedMode({ projectRoot, ompPath = 'omp' }) {
-  const runtimeConfig = await readJsonIfExists(
-    path.join(projectRoot, '.ukit', 'storage', 'config.json'),
-  );
-  const permissionModeRaw = runtimeConfig?.orchestration?.permissionMode;
+  const runtimeConfigSurface = await readRuntimeConfigSurface(projectRoot);
+  const runtimeConfig = runtimeConfigSurface.parseError ? null : runtimeConfigSurface.parsed;
+  // A corrupt file hides its permissionMode; only a parsed (or absent) config may
+  // report the 'unattended (default)' detail — corruption must never masquerade.
+  const permissionModeRaw = runtimeConfigSurface.parseError
+    ? '<unreadable: corrupt config.json>'
+    : runtimeConfig?.orchestration?.permissionMode;
   const permissionModeValid = permissionModeRaw === undefined
     || VALID_PERMISSION_MODES.has(permissionModeRaw);
   const permissionMode = permissionModeRaw === undefined ? 'unattended' : permissionModeRaw;
@@ -146,6 +162,21 @@ export async function inspectUnattendedMode({ projectRoot, ompPath = 'omp' }) {
   });
 
   const checks = [
+    // 0 — runtime config.json parses (FR-025/W2-C3): a corrupt file is an
+    // owner-action finding, never a crash, and never silently treated as defaults.
+    check(
+      'runtime config.json parses',
+      !runtimeConfigSurface.parseError,
+      'owner-action',
+      'Fix or remove .ukit/storage/config.json — invalid JSON hides the declared permissionMode.',
+      {
+        detail: runtimeConfigSurface.parseError
+          ? `corrupt: ${runtimeConfigSurface.parseError}`
+          : runtimeConfigSurface.exists
+            ? 'parsed'
+            : 'absent (defaults apply)',
+      },
+    ),
     // 1 — permissionMode declared
     check(
       '`permissionMode` declared',

package/src/core/uninstall.js

@@ -3,12 +3,12 @@ import path from 'node:path';
 import {
   cleanupEmptyParents,
   copyFileRawExclusive,
-  readJsonIfExists,
   removeFileOrLinkOnly,
   removeLinkOrDir,
   removeLinkOnly,
   resolveProjectRelativePath,
 } from './fileOps.js';
+import { readInstallMetadata } from './metadata.js';
 import { removeGitignoreBlock } from './ensureGitignore.js';
 import { PROJECT_IMPORTANT_FILENAME } from './projectImportant.js';
 
@@ -245,14 +245,19 @@ async function hasSymlinkedParent(projectRoot, absolutePath) {
 // Hardcoded fallback for installs that predate file tracking (no 'files' field
 // in install.json). New installs always have a 'files' list, so this fallback
 // only applies when upgrading from a very old UKit version.
+//
+// W2-C5: the list is SHAPE-annotated. `dirPaths` are entries that were always
+// directories in legacy installs; `filePaths` are file/symlink entries. Only a
+// dirPaths entry that lstat confirms is a real directory gets recursive
+// removal — a file-shaped path must NEVER be rm -rf'd, because a user
+// directory planted at e.g. CLAUDE.md is user content, not a managed dir.
 function buildFallbackPaths(projectRoot) {
   const stateDir = path.join(projectRoot, '.claude', 'ukit', '.ukit');
   return {
-    regularPaths: [
+    filePaths: [
       path.join(projectRoot, 'CLAUDE.md'),
       path.join(projectRoot, 'AGENTS.md'),
       path.join(projectRoot, '.claude', 'commands', 'ukit.md'),
-      path.join(projectRoot, '.claude', 'ukit', 'mcp'),
       path.join(projectRoot, '.claude', 'ukit', 'scripts', 'setup-mcp.sh'),
       path.join(projectRoot, '.claude', 'ukit', '.env.example'),
       path.join(projectRoot, '.claude', 'ukit', 'permission-usage.json'),
@@ -274,6 +279,10 @@ function buildFallbackPaths(projectRoot) {
       path.join(projectRoot, '.omp', 'agents', 'handoff-planner.md'),
       path.join(projectRoot, '.omp', 'agents', 'ukit-small-task-maintainer.md'),
       path.join(projectRoot, '.omp', 'agents', 'ukit-vision-analyst.md'),
+    ],
+    dirPaths: [
+      // legacy MCP venv — a real directory in old installs (contained .venv/)
+      path.join(projectRoot, '.claude', 'ukit', 'mcp'),
       path.join(projectRoot, '.ukit'),
       stateDir,
     ],
@@ -287,6 +296,36 @@ function buildFallbackPaths(projectRoot) {
   };
 }
 
+// W2-C5: `recursive: true` is earned, not assumed — only for a declared
+// dir-shaped entry that lstat currently confirms is a real directory.
+// Files, symlinks-to-anything, FIFOs, and vanished paths all fall back to
+// removeFileOrLinkOnly semantics (non-recursive), so a user directory sitting
+// at a file-shaped fallback path is refused instead of rm -rf'd.
+async function classifyLegacyFallbackPaths(filePaths, dirPaths) {
+  const regularPaths = [];
+  const add = async (abs, declaredDir) => {
+    if (!declaredDir) {
+      regularPaths.push({ abs, recursive: false });
+      return;
+    }
+    let stat;
+    try {
+      stat = await fs.lstat(abs);
+    } catch {
+      stat = null; // missing or inaccessible — non-recursive unlink attempt is safe
+    }
+    const realDir = Boolean(stat?.isDirectory() && !stat.isSymbolicLink());
+    regularPaths.push({ abs, recursive: realDir });
+  };
+  for (const abs of filePaths) {
+    await add(abs, false);
+  }
+  for (const abs of dirPaths) {
+    await add(abs, true);
+  }
+  return regularPaths;
+}
+
 export async function uninstallUkit({ projectRoot, dryRun = false }) {
   const installMetaPath = path.join(projectRoot, '.claude', 'ukit', '.ukit', 'install.json');
 
@@ -294,12 +333,12 @@ export async function uninstallUkit({ projectRoot, dryRun = false }) {
   // An attacker (or confused user) could forge the file to trigger uninstall of
   // the hardcoded managed paths. Requiring 'tool: ukit' ensures the file was
   // written by the UKit installer, not created manually.
-  let installData;
-  try {
-    installData = await readJsonIfExists(installMetaPath);
-  } catch {
-    return { removed: 0, attempted: 0, wasInstalled: false };
-  }
+  // FR-002 (TASK-C93-002): corruption is NOT absence. A malformed ledger rejects
+  // with InstallMetadataError and non-parse fs errors (EISDIR, EACCES, …)
+  // propagate — neither may fall through to the no-install result, which would
+  // report a clean uninstall while orphaning every managed file. Absent file
+  // alone still maps to null → wasInstalled:false.
+  const installData = await readInstallMetadata(installMetaPath);
   if (!installData || installData.tool !== 'ukit') {
     return { removed: 0, attempted: 0, wasInstalled: false };
   }
@@ -377,9 +416,10 @@ export async function uninstallUkit({ projectRoot, dryRun = false }) {
     // These are user-created content (mergeStrategy: skip) — deleting them
     // would cause data loss. Users must remove them manually if desired.
     const fallback = buildFallbackPaths(projectRoot);
-    // Legacy installs have no per-file ownership metadata; the hardcoded list
-    // keeps its historical recursive semantics (.ukit/, state dir are dirs).
-    regularPaths = fallback.regularPaths.map((abs) => ({ abs, recursive: true }));
+    // W2-C5: recursive removal is reserved for declared dir entries that lstat
+    // confirms are real directories. File-shaped entries always go through the
+    // non-recursive remover so a user dir at a file path is refused.
+    regularPaths = await classifyLegacyFallbackPaths(fallback.filePaths, fallback.dirPaths);
     linkPaths = fallback.linkPaths;
   }
 

package/src/core/update.js

@@ -8,7 +8,11 @@ export const UKIT_PACKAGE_NAME = '@ngockhoale/ukit';
 // `ukit update` refreshes such a project automatically; it must never scaffold a
 // directory that merely happens to be the shell's cwd (install writes .claude/,
 // CLAUDE.md and edits .gitignore — an unwanted surprise in, say, a home directory).
-const INSTALLED_MARKERS = ['.ukit', '.claude', 'CLAUDE.md', 'AGENTS.md', '.codex'];
+// FR-015 (W2-C1): only UKit-specific state counts — the install metadata/state
+// tree (.claude/ukit/) or the storage root (.ukit/). A plain Claude Code repo
+// carries .claude/ + CLAUDE.md without ever having been installed, so those
+// generic engine files are deliberately NOT markers.
+const INSTALLED_MARKERS = ['.ukit', '.claude/ukit'];
 
 // BUG-C21-12 (SPEC FR-005): spawnSync defaults to NO timeout, so a wedged npm
 // (network partition, hung credential helper) would block the CLI forever.

package/src/decision/client.js

@@ -124,13 +124,27 @@ function isTransientStatus(status) {
 function parseMaybeSse(text) {
   const trimmed = String(text ?? '').trim();
   if (!trimmed.startsWith('{')) {
-    // Pure SSE frames: join data payloads.
-    const payload = trimmed
+    // SSE frames: a single full-completion payload parses directly; a chunked
+    // stream is one chunk object per `data:` frame and needs delta merge.
+    const payloads = trimmed
       .split('\n')
       .filter((line) => line.startsWith('data:') && !line.includes('[DONE]'))
-      .map((line) => line.slice(5).trim())
-      .join('');
-    return JSON.parse(payload || trimmed);
+      .map((line) => line.slice(5).trim());
+    const chunks = [];
+    for (const payload of payloads) {
+      try {
+        const parsed = JSON.parse(payload);
+        if (parsed && typeof parsed === 'object') chunks.push(parsed);
+      } catch { /* unparseable frame — drop it, merge what survives */ }
+    }
+    try {
+      const joined = JSON.parse(payloads.join('') || trimmed);
+      // A lone `data:` frame may itself be one chunk object — merge it so
+      // callers always see a completion, never a raw chunk.
+      if (joined?.choices?.[0]?.delta === undefined) return joined;
+    } catch { /* joined payload is not one object — merge chunks below */ }
+    if (chunks.length > 0) return mergeSseChunks(chunks);
+    return JSON.parse(trimmed); // let the caller map the parse error
   }
   // JSON object possibly followed by a glued SSE trailer (`}data: [DONE]`,
   // observed live) — extract the balanced object, strings/comments aware.
@@ -153,6 +167,60 @@ function parseMaybeSse(text) {
   return JSON.parse(trimmed);
 }
 
+// Fold chat.completion.chunk frames into a single completion-shaped object:
+// deltas merge into `choices[0].message`, per-index tool_calls arguments
+// concatenate. Throws (typed malformed-response upstream) when no chunk is
+// usable.
+function mergeSseChunks(chunks) {
+  const mergedCalls = [];
+  let finishReason = null;
+  let role = null;
+  for (const chunk of chunks) {
+    const choice = chunk?.choices?.[0];
+    if (!choice) continue;
+    if (choice.finish_reason) finishReason = choice.finish_reason;
+    const delta = choice.delta ?? {};
+    if (delta.role) role = delta.role;
+    for (const call of delta.tool_calls ?? []) {
+      const slot = mergedCalls[call.index ?? 0] ??= {
+        id: call.id ?? null,
+        type: call.type ?? 'function',
+        function: { name: call.function?.name ?? '', arguments: '' },
+      };
+      if (call.function?.arguments) slot.function.arguments += call.function.arguments;
+    }
+  }
+  if (mergedCalls.length === 0) {
+    throw new SyntaxError('unusable SSE stream — no tool_call chunks');
+  }
+  return {
+    choices: [{
+      index: 0,
+      finish_reason: finishReason,
+      message: { role: role ?? 'assistant', content: null, tool_calls: mergedCalls },
+    }],
+  };
+}
+
+// Abort-aware race: fetch's signal does not cover res.text()/res.json() once
+// headers arrived, and injected transports may ignore it entirely — the read
+// is bounded by the caller's remaining deadline either way.
+function abortError() {
+  return new DOMException('The operation was aborted.', 'AbortError');
+}
+
+function raceAbort(promise, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) { reject(signal.reason ?? abortError()); return; }
+    const onAbort = () => reject(signal.reason ?? abortError());
+    signal?.addEventListener('abort', onAbort, { once: true });
+    Promise.resolve(promise).then(
+      (v) => { signal?.removeEventListener('abort', onAbort); resolve(v); },
+      (e) => { signal?.removeEventListener('abort', onAbort); reject(e); },
+    );
+  });
+}
+
 async function readResponseBody(res) {
   if (res && typeof res.text === 'function') return parseMaybeSse(await res.text());
   if (res && typeof res.json === 'function') return res.json();
@@ -231,19 +299,53 @@ export function createDecisionClient({
     };
   }
 
-  async function postWithDeadline(url, headers, body, deadlineMs) {
+  // `deadlineAt` covers the WHOLE request lifetime — headers plus body
+  // consumption — not just the fetch() call. The abort timer is cleared only
+  // by release(), invoked after readBody()/discard() settle or on transport
+  // failure; until then a stalled body still aborts (W3-UD1).
+  async function postWithDeadline(url, headers, body, deadlineAt) {
     const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), deadlineMs);
-    try {
-      return await transport(url, {
-        method: 'POST',
-        headers: { 'content-type': 'application/json', ...headers },
-        body,
-        signal: controller.signal,
-      });
-    } finally {
+    const remaining = () => deadlineAt - now();
+    const timer = setTimeout(() => controller.abort(), Math.max(0, remaining()));
+    const release = () => {
       clearTimeout(timer);
+      controller.abort(); // signal any stale readers; settled callers unaffected
+    };
+    let res;
+    try {
+      // Race the transport await too — a transport that ignores the abort
+      // signal (or a hung socket before headers) must not outlive deadlineAt.
+      res = await raceAbort(
+        transport(url, {
+          method: 'POST',
+          headers: { 'content-type': 'application/json', ...headers },
+          body,
+          signal: controller.signal,
+        }),
+        controller.signal,
+      );
+    } catch (err) {
+      release();
+      throw err;
     }
+    const readBody = async (target = res) => {
+      try {
+        return await raceAbort(readResponseBody(target), controller.signal);
+      } finally {
+        release();
+      }
+    };
+    // Release the socket without parsing — the caller only needed headers.
+    const discard = async () => {
+      try {
+        if (typeof res?.body?.cancel === 'function') await res.body.cancel();
+        else if (typeof res?.text === 'function') {
+          await raceAbort(res.text(), controller.signal);
+        } else if (typeof res?.destroy === 'function') res.destroy();
+      } catch { /* best-effort release */ }
+      release();
+    };
+    return { res, readBody, discard };
   }
 
   /**
@@ -332,10 +434,14 @@ export function createDecisionClient({
           detail: error?.message ?? String(error),
         });
       }
-      const fingerprint = requestFingerprint(body);
+      let fingerprint = requestFingerprint(body);
       const deadlineMs = Number.isFinite(batch?.deadlineMs)
         ? batch.deadlineMs
         : timeoutMs;
+      // Cumulative budget: every attempt (headers AND body read) must finish
+      // before deadlineAt — retries share the caller's budget, they do not
+      // each get a fresh deadlineMs (W3-UD2).
+      const deadlineAt = now() + deadlineMs;
 
       // A half-open probe is a single trial — no retry against a possibly-dead
       // gateway; a closed circuit gets the bounded transient retry.
@@ -344,19 +450,25 @@ export function createDecisionClient({
       let lastStatus = null;
       for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
         const startedAt = now();
-        let res;
+        if (deadlineAt - startedAt <= 0) {
+          lastError = 'timeout';
+          lastStatus = null;
+          break;
+        }
+        let call;
         try {
-          res = await postWithDeadline(endpoint.url, endpoint.headers, body, deadlineMs);
+          call = await postWithDeadline(endpoint.url, endpoint.headers, body, deadlineAt);
         } catch (err) {
           const isTimeout =
             err?.name === 'AbortError' || err?.code === 'ABORT_ERR';
           lastError = isTimeout ? 'timeout' : 'unavailable';
           lastStatus = null;
           // Timeouts never retry; transient transport errors retry once inside
-          // the deadline.
+          // the remaining budget.
           if (isTimeout || attempt + 1 >= maxAttempts) break;
           continue;
         }
+        const { res, readBody, discard } = call;
 
         const status = res?.status ?? (res?.ok === false ? 500 : 200);
         if (res?.ok === false || status < 200 || status >= 300) {
@@ -365,21 +477,30 @@ export function createDecisionClient({
           // model, the credential-safe alias the owner provisions first.
           if (checkpoint !== FALLBACK_CHECKPOINT) {
             let notFound = status === 404;
+            let consumed = false;
             try {
               const clone = typeof res?.clone === 'function' ? res.clone() : null;
-              const errBody = clone ? parseMaybeSse(await clone.text()) : null;
-              if (errBody?.error?.code === 'model_not_found') notFound = true;
+              if (clone) {
+                const errBody = await readBody(clone);
+                consumed = true;
+                if (errBody?.error?.code === 'model_not_found') notFound = true;
+              }
             } catch { /* keep status-based guess */ }
             if (notFound) {
+              if (!consumed) await discard();
               checkpoint = FALLBACK_CHECKPOINT;
               try {
                 body = JSON.stringify(
                   encodeBatch({ model: checkpoint, statePacket: serialized, questions }),
                 );
               } catch { /* keep prior body */ }
+              // The receipt hash must cover the bytes actually sent — after
+              // the fallback re-encode the original fingerprint is stale.
+              fingerprint = requestFingerprint(body);
               continue;
             }
           }
+          await discard();
           if (isTransientStatus(status) && attempt + 1 < maxAttempts) continue;
           if (status === 401 || status === 403) {
             lastError = 'unavailable';
@@ -396,10 +517,17 @@ export function createDecisionClient({
 
         let parsed;
         try {
-          parsed = await readResponseBody(res);
-        } catch {
-          lastError = 'invalid';
-          lastStatus = 'malformed-response';
+          parsed = await readBody();
+        } catch (err) {
+          if (err?.name === 'AbortError' || err?.code === 'ABORT_ERR') {
+            // The body stream outlived the deadline — typed timeout, not a
+            // malformed response.
+            lastError = 'timeout';
+            lastStatus = null;
+          } else {
+            lastError = 'invalid';
+            lastStatus = 'malformed-response';
+          }
           break;
         }
 
@@ -456,13 +584,16 @@ export function createDecisionClient({
       max_tokens: 1,
     });
     try {
-      const res = await postWithDeadline(
+      const { res, discard } = await postWithDeadline(
         endpoint.url,
         endpoint.headers,
         body,
-        timeoutMs,
+        now() + timeoutMs,
       );
       const status = res?.status ?? (res?.ok === false ? 500 : 200);
+      // The probe only needed the headers — cancel the body so the keep-alive
+      // socket is released instead of idling to its own timeout.
+      await discard();
       if (res?.ok === false || status < 200 || status >= 300) {
         return { status: 'unavailable', httpStatus: status };
       }

package/src/decision/reviewVerdict.js

@@ -137,16 +137,20 @@ function stableBatchId(findings) {
  */
 export function buildReviewVerdictBatch({ findings = [], mode = 'solo' } = {}) {
   const usedIds = new Set();
+  // Sanitize the FULL finding set — MAX_FINDINGS is a display/transport bound
+  // for the batch, not a verdict bound. The deterministic verdict and the
+  // truncation clamp both run on `fullFindings` (W3-RV1).
   const sanitized = (Array.isArray(findings) ? findings : [])
-    .slice(0, MAX_FINDINGS)
     .map((raw, index) => sanitizeFinding(raw, index, usedIds));
+  const batchFindings = sanitized.slice(0, MAX_FINDINGS);
+  const truncated = sanitized.length > batchFindings.length;
 
   const verdictDecisionKey = mode === 'panel'
     ? REVIEW_VERDICT_KEYS.panel
     : REVIEW_VERDICT_KEYS.solo;
 
   const counts = { critical: 0, important: 0, minor: 0, unknown: 0 };
-  for (const f of sanitized) counts[f.severity] += 1;
+  for (const f of batchFindings) counts[f.severity] += 1;
 
   const verdictQuestion = {
     decisionKey: verdictDecisionKey,
@@ -165,7 +169,7 @@ export function buildReviewVerdictBatch({ findings = [], mode = 'solo' } = {}) {
   // One bucket question per finding. The shared registered key cannot repeat
   // in one batch (name-based reconciliation), so each wire name carries
   // `#<findingId>`; parseVerdictAnswer splits it back off.
-  const bucketQuestions = sanitized.map((f) => ({
+  const bucketQuestions = batchFindings.map((f) => ({
     decisionKey: `${REVIEW_VERDICT_KEYS.bucket}#${f.id}`,
     schemaVersion: 1,
     family: 'review',
@@ -183,20 +187,28 @@ export function buildReviewVerdictBatch({ findings = [], mode = 'solo' } = {}) {
   const statePacket = {
     kind: 'review-verdict',
     mode: mode === 'panel' ? 'panel' : 'solo',
-    findingCount: sanitized.length,
+    findingCount: batchFindings.length,
     severityCounts: counts,
-    findings: sanitized,
+    findings: batchFindings,
   };
 
   const batch = {
     batchVersion: 1,
-    batchId: stableBatchId(sanitized),
+    batchId: stableBatchId(batchFindings),
     boundary: 'review-verdict',
     questions,
     statePacket,
   };
 
-  return { questions, statePacket, batch, findings: sanitized, verdictDecisionKey };
+  return {
+    questions,
+    statePacket,
+    batch,
+    findings: batchFindings,
+    fullFindings: sanitized,
+    truncated,
+    verdictDecisionKey,
+  };
 }
 
 /**
@@ -285,6 +297,10 @@ export function parseVerdictAnswer(result, { findings = [] } = {}) {
         verdict = answer.value;
         verdictStatus = 'valid';
       } else {
+        // The pair stays consistent: an invalid answer for the verdict key
+        // clears any earlier valid verdict — never leave a stale APPROVED
+        // standing behind verdictStatus 'invalid' (W3-RV2).
+        verdict = null;
         verdictStatus = 'invalid';
       }
       continue;

package/src/diagnostics/failurePatterns.js

@@ -68,7 +68,7 @@ function failureCommands(ledger) {
 
 async function writeArtifact(filePath, result) {
   const dir = path.dirname(filePath);
-  const tmp = path.join(dir, `.failure-patterns-${process.pid}.tmp`);
+  const tmp = path.join(dir, `.failure-patterns-${process.pid}-${Math.random().toString(16).slice(2)}.tmp`);
   try {
     await fs.mkdir(dir, { recursive: true });
     await fs.writeFile(tmp, JSON.stringify(result, null, 2));

package/src/diagnostics/feedbackEvents.js

@@ -92,7 +92,7 @@ async function readManualEvents(projectRoot, byKind) {
 
 async function writeArtifact(filePath, result) {
   const dir = path.dirname(filePath);
-  const tmp = path.join(dir, `.feedback-events-${process.pid}.tmp`);
+  const tmp = path.join(dir, `.feedback-events-${process.pid}-${Math.random().toString(16).slice(2)}.tmp`);
   try {
     await fs.mkdir(dir, { recursive: true });
     await fs.writeFile(tmp, JSON.stringify(result, null, 2));