@ngockhoale/ukit 3.4.67 → 3.4.68

package/template_project/.claude/ukit/index/task-budget-validator.mjs

@@ -6,15 +6,29 @@
 //
 // Usage:
 //   node .claude/ukit/index/task-budget-validator.mjs <path-to-TASK-xxx.md> [criteria JSON]
+//   node .claude/ukit/index/task-budget-validator.mjs --record <path-to-TASK-xxx.md>
 //
 // Output:
 //   First stdout line: `VERDICT: ok` or `VERDICT: needs_breakdown`
 //   Then one `REASON: <criterion>: <detail>` line per reason.
+//   In --record mode: an extra `RECORD:` line — `RECORD: ok <written line>` when the
+//   `Validator: ok <YYYY-MM-DD> <tool-version>` line was appended to `## Discussion`,
+//   `RECORD: already recorded` when one already exists (idempotent), and
+//   `RECORD: not recorded — <reason>` when the verdict is not ok or the section is missing.
 //   ALWAYS exits 0 — advisory gate, must never break a pipeline.
 
 import fs from 'node:fs';
+import path from 'node:path';
 import process from 'node:process';
-import { pathToFileURL } from 'node:url';
+import { fileURLToPath } from 'node:url';
+
+function isDirectRun() {
+  try {
+    return Boolean(process.argv[1]) && fs.realpathSync(process.argv[1]) === fs.realpathSync(fileURLToPath(import.meta.url));
+  } catch {
+    return false;
+  }
+}
 
 const DEFAULT_CRITERIA = Object.freeze({
   maxTargetFiles: 3,
@@ -216,8 +230,80 @@ export function validateTaskFile(markdown, criteria = DEFAULT_CRITERIA) {
   };
 }
 
+function localDateStamp() {
+  const d = new Date();
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+}
+
+// Stamp the writing tool into the recorded line (`Validator: ok 2026-10-24 ukit@3.4.67`).
+// The version comes from the installer-written `.ukit/storage/cli.json` (src/core/metadata.js
+// CLI_LOCATOR_REL); the script lives four levels under the project root regardless of cwd.
+function toolVersionStamp() {
+  try {
+    const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../..');
+    const cli = JSON.parse(fs.readFileSync(path.join(root, '.ukit/storage/cli.json'), 'utf8'));
+    if (cli && typeof cli.version === 'string' && cli.version) return `ukit@${cli.version}`;
+  } catch {
+    // missing/corrupt locator — still record, just without a trustworthy version
+  }
+  return 'ukit@unknown';
+}
+
+// CR-08: append `Validator: ok <date> <tool-version>` at the bottom of the `## Discussion`
+// thread so the flip-to-ready step reads the verdict from disk, not from session memory
+// (compaction-safe). Preserves the file's BOM and LF/CRLF convention; refuses non-ok
+// verdicts; idempotent on an existing ok line. Returns { raw, action }.
+export function appendValidatorOkLine(raw, opts = {}) {
+  const text = typeof raw === 'string' ? raw : '';
+  const eol = text.includes('\r\n') ? '\r\n' : '\n';
+  // The heading match must consume its whole line terminator (\r\n or \n) — `\s*` used to
+  // swallow the \r and shift the splice point, doubling \r on CRLF files.
+  const headingMatch = /^##[ \t]+Discussion[ \t]*(?:\r?\n|$)/m.exec(text);
+  if (!headingMatch) return { raw: text, action: 'no-discussion' };
+  const afterHeading = headingMatch.index + headingMatch[0].length;
+  const rest = text.slice(afterHeading);
+  const boundaryMatch = /^##\s|^-{3,}\s*$/m.exec(rest);
+  const sectionEnd = boundaryMatch ? afterHeading + boundaryMatch.index : text.length;
+  const section = text.slice(afterHeading, sectionEnd);
+  // Only the exact tool-written shape counts as recorded; any other `Validator: ok …` line
+  // (forged 2-field, hand-typed) is non-conforming and is replaced, never treated as recorded.
+  if (/^Validator: ok \d{4}-\d{2}-\d{2} ukit@\S+[ \t\r]*$/m.test(section)) return { raw: text, action: 'already' };
+  const line = `Validator: ok ${opts.date || localDateStamp()} ${opts.toolVersion || toolVersionStamp()}`;
+  const cleaned = section
+    .split(/\r?\n/)
+    .filter((l) => !/^[ \t]*Validator: ok\b/.test(l))
+    .join(eol)
+    .replace(/\s+$/, '');
+  // When another section follows, keep one blank line before its heading.
+  const gap = boundaryMatch ? eol : '';
+  const insertion = cleaned.length > 0
+    ? `${cleaned}${eol}${line}${eol}${gap}`
+    : `${eol}${line}${eol}${gap}`;
+  return { raw: text.slice(0, afterHeading) + insertion + text.slice(sectionEnd), action: 'recorded', line };
+}
+
+// Atomic temp-file + rename so a crash mid-write can never leave a torn task file.
+function atomicWrite(file, content) {
+  const tmp = `${file}.tmp-record-${process.pid}`;
+  try {
+    fs.writeFileSync(tmp, content, 'utf8');
+    fs.renameSync(tmp, file);
+    return true;
+  } catch {
+    try {
+      fs.unlinkSync(tmp);
+    } catch {
+      // nothing to clean
+    }
+    return false;
+  }
+}
+
 function main() {
-  const [, , targetPath, criteriaArg] = process.argv;
+  const [, , firstArg, secondArg] = process.argv;
+  const recordMode = firstArg === '--record';
+  const targetPath = recordMode ? secondArg : firstArg;
+  const criteriaArg = recordMode ? process.argv[4] : secondArg;
   let criteria = DEFAULT_CRITERIA;
   if (criteriaArg) {
     try {
@@ -240,9 +326,29 @@ function main() {
   for (const r of reasons) {
     console.log(`REASON: ${r.criterion}: ${r.detail}`);
   }
+  if (recordMode) {
+    if (verdict !== 'ok') {
+      console.log('RECORD: not recorded — verdict needs_breakdown (fix the reasons above, then re-run)');
+      process.exit(0);
+    }
+    const { raw, action, line } = appendValidatorOkLine(markdown);
+    if (action === 'already') {
+      console.log('RECORD: already recorded');
+      process.exit(0);
+    }
+    if (action === 'no-discussion') {
+      console.log('RECORD: not recorded — task file has no `## Discussion` section');
+      process.exit(0);
+    }
+    if (action !== 'recorded' || !atomicWrite(targetPath, raw)) {
+      console.log('RECORD: not recorded — write failed (file left unchanged)');
+      process.exit(0);
+    }
+    console.log(`RECORD: ok ${line}`);
+  }
   process.exit(0);
 }
 
-if (process.argv[1] && pathToFileURL(process.argv[1]).href === import.meta.url) {
+if (isDirectRun()) {
   main();
 }

package/template_project/.claude/ukit/runtime/execution-ledger.mjs

@@ -476,8 +476,10 @@ export async function writeResumeIntent(projectRoot, payload = {}, { now = Date.
 // marker, and a user-declared origin never consumes a marker at all.
 export const GATE_CONTINUATION_TTL_MS = 30 * 60 * 1000;
 const GATE_CONTINUATION_PREFIX = /^UKit completion gate:/;
-// The exact diagnostics tail evaluateCompletion appends to every gate reason.
-const GATE_CONTINUATION_DIAGNOSTICS = /\s\[task=\S+ contract=\S+ accepted-count=\d+ rejected=[^\]\s]*\]\s*$/;
+// The exact diagnostics tail evaluateCompletion appends to every gate reason. The
+// observed=/unmet=/cover= fields are optional in the shape so gate text emitted by an
+// older runtime (bare accepted-count/rejected tail) still binds.
+const GATE_CONTINUATION_DIAGNOSTICS = /\s\[task=\S+ contract=\S+ accepted-count=\d+ rejected=[^\]\s]*(?:\sobserved=[^\]\s]*)?(?:\sunmet=[^\]\s]*)?(?:\scover=\d+\/\d+)?\]\s*$/;
 const GATE_CONTINUATION_MAX_CHARS = 2000;
 
 export function isCompletionGateContinuationText(text) {
@@ -4443,7 +4445,22 @@ export function evaluateCompletion(args = {}) {
     rejectedEvidence: args.ledger && owned !== args.ledger ? ['ledger-task-ownership-mismatch'] : [],
   };
   result.diagnostics = diagnostics;
-  if (result.reason) result.reason += ` [task=${diagnostics.taskInstanceId || 'unknown'} contract=${diagnostics.contract || 'unknown'} accepted-count=${diagnostics.acceptedEvidence.length} rejected=${diagnostics.rejectedEvidence.join(',') || 'none'}]`;
+  // Field 3.4.67 (narrow diagnostic hardening): accepted-count counts satisfied
+  // obligation CLASSES and rejected= is ledger-task ownership only — a bare
+  // "accepted-count=0 rejected=none" was misread as "the gate saw nothing / is
+  // broken", sending the agent to re-read the same files. The tail now exposes
+  // what the LEDGER observed (observed=) and which obligations remain unmet
+  // (unmet=, plus expected source-path coverage cover=matched/total when the
+  // route names files). Ledger-scoped only: "none" means no LEDGER-captured
+  // evidence — never a claim about reads a host hook may not have captured, and
+  // Bash workspace activity is never counted as source evidence.
+  const diagExpectedFiles = Array.isArray(args.state?.routeSummary?.expectedSourceFiles)
+    ? args.state.routeSummary.expectedSourceFiles
+    : [];
+  const diagCoveredCount = diagExpectedFiles.length
+    ? diagExpectedFiles.filter((expected) => (Array.isArray(owned.sourceFiles) ? owned.sourceFiles : []).some((file) => fileMatchesExpected(file, expected))).length
+    : 0;
+  if (result.reason) result.reason += ` [task=${diagnostics.taskInstanceId || 'unknown'} contract=${diagnostics.contract || 'unknown'} accepted-count=${diagnostics.acceptedEvidence.length} rejected=${diagnostics.rejectedEvidence.join(',') || 'none'} observed=${diagnostics.observedEvidence.join(',') || 'none'} unmet=${diagnostics.unmetObligations.join(',') || 'none'}${diagExpectedFiles.length ? ` cover=${diagCoveredCount}/${diagExpectedFiles.length}` : ''}]`;
   try {
     const acceptance = evaluateFeatureAcceptance({ state: args.state, ledger: args.ledger, cwd: args.cwd });
     if (acceptance.applicable) result.playbookAcceptance = acceptance;

package/template_project/.claude/ukit/runtime/handoff-task-scope.mjs

@@ -0,0 +1,205 @@
+// handoff-task-scope.mjs — frozen RUN scope selection (pure, no fs). TaskScope:
+// <KEY> = queue:<slug> | plan:<path> | repair:<KEY>; KEY = TASK-001 (legacy) |
+// cycle-01/TASK-001 (ids restart per cycle). normalizeScopeCycle mirrors
+// parseRunCycle/normalizeClaimCycle; context cycle = opts.cycle (archive) else RUN
+// `Cycle:`. Exact cycle-NN/<id> wins; a bare id applies only while no other cycle
+// qualified it (else include + reconcile). repair: qualified parent exact; a bare
+// parent resolves in the CURRENT HOP's cycle (a qualified hop re-anchors context).
+// Rows stay only when mapped into the frozen set (absent = legacy). Ids/slugs fold
+// case; PLAN PATHS are case-sensitive always (A.md ≠ a.md; duplicates conflict).
+// Unknown/malformed/conflicting/cyclic → include + diagnostic; status never read.
+
+const SCOPE_QUEUE = /^ScopeQueue:(.*)$/i;
+const SCOPE_PLANS = /^ScopePlans:(.*)$/i;
+const TASK_SCOPE = /^TaskScope:(.*)$/i;
+const MAPPING = /^(\S+)\s*=\s*(queue|plan|repair):(\S.*)$/i;
+const IMPLICIT_REPAIR = /^(.+)-R\d+$/i;
+const RUN_CYCLE_FIELD = /^Cycle:(.*)$/im;
+
+const norm = (v) => String(v ?? '').trim().toLowerCase();
+
+export function normalizeScopeCycle(value) {
+  const m = String(value ?? '').trim().match(/^(?:cycle-)?(\d+)$/i);
+  return m ? `cycle-${m[1].padStart(2, '0')}` : null;
+}
+
+// `cycle-1/X` → `cycle-01/x`; a bare id stays literal.
+function normScopeKey(raw) {
+  const key = norm(raw);
+  const m = key.match(/^(?:cycle-)?(\d+)\/(.+)$/);
+  if (m) {
+    const cyc = normalizeScopeCycle(`cycle-${m[1]}`);
+    if (cyc) return `${cyc}/${m[2]}`;
+  }
+  return key;
+}
+
+function keyParts(key) {
+  const i = key.indexOf('/');
+  if (i <= 0) return { cycle: null, base: key };
+  const cycle = normalizeScopeCycle(key.slice(0, i));
+  return cycle ? { cycle, base: key.slice(i + 1) } : { cycle: null, base: key };
+}
+
+// null = legacy.
+function setKey(value, fold) {
+  const v = value.trim();
+  if (!v) return null;
+  if (v.toLowerCase() === 'none') return '';
+  return [...new Set(v.split(',').map((x) => (fold ? norm(x) : x.trim())).filter(Boolean))].sort().join(',');
+}
+
+function readFrozenSet(lines, re, label, diag, fold) {
+  const keys = [];
+  for (const line of lines) {
+    const m = line.match(re);
+    if (m) keys.push(setKey(m[1], fold));
+  }
+  if (keys.length === 0) return null;
+  if (new Set(keys).size > 1) {
+    diag(`conflicting ${label} values (${keys.map((k) => k ?? 'legacy').join(' | ')}); treated as legacy, all rows included`);
+    return null;
+  }
+  const key = keys[0];
+  if (key === null) return null;
+  return new Set(key === '' ? [] : key.split(','));
+}
+
+export function selectTaskScope(runText, rows, opts = {}) {
+  const diags = new Set();
+  const diag = (msg) => diags.add(msg);
+  const lines = String(runText ?? '').split(/\r?\n/).map((l) => l.trim());
+
+  const queueSet = readFrozenSet(lines, SCOPE_QUEUE, 'ScopeQueue', diag, true);
+  const planSet = readFrozenSet(lines, SCOPE_PLANS, 'ScopePlans', diag, false);
+  const anyScope = queueSet !== null || planSet !== null;
+  const ctx = normalizeScopeCycle(opts?.cycle)
+    ?? normalizeScopeCycle(String(runText ?? '').match(RUN_CYCLE_FIELD)?.[1] || '');
+
+  const shown = new Map(
+    rows.filter((r) => typeof r?.id === 'string' && r.id.trim()).map((r) => [norm(r.id), r.id.trim()]),
+  );
+  const writtenKeys = new Map();
+  const label = (id) => shown.get(id) ?? writtenKeys.get(id) ?? id;
+
+  const mappings = new Map();
+  const qualifiedByBase = new Map();
+  const conflicted = new Set();
+  for (const line of lines) {
+    const m = line.match(TASK_SCOPE);
+    if (!m) continue;
+    const mm = m[1].trim().match(MAPPING);
+    if (!mm) {
+      diag(`malformed TaskScope line ignored for reconciliation: "${line}"`);
+      continue;
+    }
+    const key = normScopeKey(mm[1]);
+    if (!writtenKeys.has(key)) writtenKeys.set(key, mm[1].trim());
+    const kind = mm[2].toLowerCase();
+    // repair values are KEYS; plan paths keep case.
+    const value = kind === 'repair' ? normScopeKey(mm[3]) : kind === 'plan' ? mm[3].trim() : norm(mm[3]);
+    const parts = keyParts(key);
+    if (parts.cycle) {
+      if (!qualifiedByBase.has(parts.base)) qualifiedByBase.set(parts.base, new Set());
+      qualifiedByBase.get(parts.base).add(parts.cycle);
+    }
+    const prev = mappings.get(key);
+    if (prev && (prev.kind !== kind || prev.value !== value)) {
+      conflicted.add(key);
+      diag(`conflicting TaskScope mapping for ${label(key)}; row included`);
+      continue;
+    }
+    mappings.set(key, { kind, value });
+  }
+
+  const rowIds = new Set(
+    rows.map((r) => (typeof r?.id === 'string' ? norm(r.id) : '')).filter(Boolean),
+  );
+
+  // id in `c` → { map, key } | { ambiguous, cycles } | { otherCycleOnly, cycles } | { none }.
+  function resolve(id, c) {
+    if (c) {
+      const exact = mappings.get(`${c}/${id}`);
+      if (exact) return { map: exact, key: `${c}/${id}` };
+    }
+    const unq = mappings.get(id);
+    const cycles = qualifiedByBase.get(id);
+    if (unq) {
+      if (c && cycles && [...cycles].some((x) => x !== c)) {
+        return { ambiguous: true, cycles: [...cycles].sort() };
+      }
+      return { map: unq, key: id };
+    }
+    if (cycles && cycles.size > 0) return { otherCycleOnly: true, cycles: [...cycles].sort() };
+    return { none: true };
+  }
+
+  function decideId(id, trail, c) {
+    if (trail.includes(id)) {
+      diag(`repair cycle through ${label(id)}; rows included`);
+      return true;
+    }
+    if (conflicted.has(id) || (c && conflicted.has(`${c}/${id}`))) return true;
+    const r = resolve(id, c);
+    if (r.map) {
+      if (r.map.kind === 'queue') return queueSet === null || queueSet.has(r.map.value);
+      if (r.map.kind === 'plan') return planSet === null || planSet.has(r.map.value);
+      return decideKey(r.map.value, [...trail, id], c);
+    }
+    if (!anyScope) return true;
+    if (r.ambiguous) {
+      diag(`ambiguous TaskScope for ${label(id)}: unqualified mapping while cycle-qualified mappings exist for other cycle(s) (${r.cycles.join(', ')}); included for reconciliation`);
+      return true;
+    }
+    if (r.otherCycleOnly) {
+      diag(`row ${label(id)} is mapped only for other cycle(s) (${r.cycles.join(', ')}); included for reconciliation`);
+      return true;
+    }
+    const m = id.match(IMPLICIT_REPAIR);
+    if (m) {
+      const base = norm(m[1]);
+      const br = resolve(base, c);
+      if (br.map || rowIds.has(base)) return decideId(base, [...trail, id], c);
+    }
+    diag(`unmapped row ${label(id)} under active scope; included for reconciliation`);
+    return true;
+  }
+
+  // A qualified key re-anchors `c` down the chain.
+  function decideKey(key, trail, c) {
+    if (trail.includes(key)) {
+      diag(`repair cycle through ${label(key)}; rows included`);
+      return true;
+    }
+    if (conflicted.has(key)) return true;
+    const parts = keyParts(key);
+    const r = parts.cycle ? { map: mappings.get(key), key } : resolve(parts.base, c);
+    if (r.map) {
+      if (conflicted.has(r.key)) return true; // retain before membership
+      if (r.map.kind === 'queue') return queueSet === null || queueSet.has(r.map.value);
+      if (r.map.kind === 'plan') return planSet === null || planSet.has(r.map.value);
+      return decideKey(r.map.value, [...trail, key], parts.cycle || c);
+    }
+    if (parts.cycle) {
+      diag(`repair ${label(key)} has absent parent ${label(key)}; included for reconciliation`);
+      return true;
+    }
+    if (!rowIds.has(parts.base) && !r.ambiguous && !r.otherCycleOnly) {
+      diag(`repair ${label(parts.base)} has absent parent ${label(parts.base)}; included for reconciliation`);
+      return true;
+    }
+    return decideId(parts.base, trail, c);
+  }
+
+  const selected = [];
+  for (const row of rows) {
+    const id = typeof row?.id === 'string' ? norm(row.id) : '';
+    if (!id) {
+      diag(`malformed row id ${JSON.stringify(row?.id ?? null)}; row included for reconciliation`);
+      selected.push(row);
+      continue;
+    }
+    if (decideId(id, [], ctx)) selected.push(row);
+  }
+  return { rows: selected, reconciliation: [...diags] };
+}

package/template_project/.claude/ukit/runtime/loop-state.mjs

@@ -38,7 +38,9 @@ export async function progressFingerprint(root, runRoot = root, payload = {}) {
   let cur = 'no-run';
   try {
     const t = await fs.readFile(path.join(runRoot, 'docs', 'AI_HANDOFF', 'RUN.md'), 'utf8');
-    cur = ['Phase', 'Cursor', 'Next'].map((n) => t.match(new RegExp(`^${n}:\\s*(.+)$`, 'm'))?.[1] || '').join('|');
+    // Cycle is part of progress identity: a reused task id under a new cycle is a new cycle's
+    // progress, not the previous cycle's stalled fingerprint carried over.
+    cur = ['Cycle', 'Phase', 'Cursor', 'Next'].map((n) => t.match(new RegExp(`^${n}:\\s*(.+)$`, 'm'))?.[1] || '').join('|');
   } catch {}
   const id = payload.session_id ? String(payload.session_id).trim().replace(/[^a-zA-Z0-9._-]/g, '_').slice(0, 96)
     : payload.transcript_path ? `transcript-${crypto.createHash('sha256').update(String(payload.transcript_path)).digest('hex').slice(0, 20)}` : 'default';

package/template_project/.claude/ukit/runtime/plan-dispatch.mjs

@@ -3,8 +3,9 @@
 // existing Agent|Task PreToolUse/PostToolUse hooks. Fail-open on IO trouble, fail-closed
 // on an explicit dependency/duplicate violation.
 import {
-  readResumableRun, writeResumableRun,
+  readResumableRun, writeResumableRun, resumableRunPath,
 } from './resumable-run.mjs';
+import { withAsyncLock } from './async-lock.mjs';
 import { evaluateContextBudget, SUBTASK_MARKER_RE, checkDispatch, applySubtaskStatus } from './context-budget-policy.mjs';
 
 const ROLE_BY_AGENT = { 'feature-implementer': 'implement-subagent', 'bug-debugger': 'implement-subagent', 'code-reviewer': 'review-subagent', 'handoff-planner': 'subagent', 'ukit-small-task-maintainer': 'simple-subagent', 'ukit-vision-analyst': 'simple-subagent' };
@@ -45,14 +46,27 @@ async function save(projectRoot, loaded, plan) {
 }
 
 /** PreToolUse: `{ok:true}` (marks running) or `{ok:false, reason, missing?}`. */
-export async function dispatchSubtask(projectRoot, subtaskId, toolInput = null) {
+export async function dispatchSubtask(projectRoot, subtaskId, toolInput = null, identity = {}) {
+  const result = await withAsyncLock(`${resumableRunPath(projectRoot, parentOf(subtaskId))}.dispatch`, {},
+    () => dispatchLocked(projectRoot, subtaskId, toolInput, identity));
+  return result.ok ? result.value : { ok: false, reason: result.reason };
+}
+
+async function dispatchLocked(projectRoot, subtaskId, toolInput, identity) {
   try {
     const loaded = await load(projectRoot, subtaskId);
     if (!loaded) return { ok: true, tracked: false };
     const plan = loaded.decisions[loaded.index];
     const verdict = checkDispatch(plan, subtaskId);
     if (!verdict.ok) return verdict;
-    const saved = await save(projectRoot, loaded, applySubtaskStatus(plan, subtaskId, 'running'));
+    const next = applySubtaskStatus(plan, subtaskId, 'running');
+    next.attempts = { ...plan.attempts };
+    if (identity.toolUseId && identity.sessionId) {
+      next.attempts[subtaskId] = { toolUseId: identity.toolUseId, sessionId: identity.sessionId };
+    } else {
+      delete next.attempts[subtaskId];
+    }
+    const saved = await save(projectRoot, loaded, next);
     return { ok: true, tracked: saved.ok === true, budget: subtaskBudgetAdvice(verdict.task, toolInput) };
   } catch {
     return { ok: true, tracked: false };
@@ -60,13 +74,26 @@ export async function dispatchSubtask(projectRoot, subtaskId, toolInput = null)
 }
 
 /** PostToolUse: done on success, back to pending (retryable) on failure. */
-export async function completeSubtask(projectRoot, subtaskId, { success }) {
+export async function completeSubtask(projectRoot, subtaskId, options) {
+  const result = await withAsyncLock(`${resumableRunPath(projectRoot, parentOf(subtaskId))}.dispatch`, {},
+    () => completeLocked(projectRoot, subtaskId, options));
+  return result.ok ? result.value : { ok: false, reason: result.reason };
+}
+
+async function completeLocked(projectRoot, subtaskId, { success, toolUseId = null, sessionId = null, authenticated = false }) {
   try {
     const loaded = await load(projectRoot, subtaskId);
     if (!loaded) return { ok: false, reason: 'no-plan' };
     const plan = loaded.decisions[loaded.index];
     if (!plan.tasks?.some((t) => t.id === subtaskId)) return { ok: false, reason: 'unknown-subtask' };
-    const saved = await save(projectRoot, loaded, applySubtaskStatus(plan, subtaskId, success ? 'done' : 'pending'));
+    const attempt = plan.attempts?.[subtaskId];
+    if ((attempt || authenticated) && (!attempt || attempt.toolUseId !== toolUseId || attempt.sessionId !== sessionId)) {
+      return { ok: false, reason: 'attempt-mismatch' };
+    }
+    const next = applySubtaskStatus(plan, subtaskId, success ? 'done' : 'pending');
+    next.attempts = { ...plan.attempts };
+    delete next.attempts[subtaskId];
+    const saved = await save(projectRoot, loaded, next);
     return { ok: saved.ok === true };
   } catch {
     return { ok: false, reason: 'io' };