@haaaiawd/loom 2.1.0 → 2.1.2

package/cli/src/protocol.js

@@ -75,10 +75,12 @@ list. Each decision node carries an entry condition, options, judgment criteria,
 a counterexample, and an output. Nodes without sources are not accepted; branches without
 counterexamples are fixed steps in disguise.
 
-Build dossiers in four steps: research (collect expert narratives, case studies, and methodology
-sources), synthesize (construct the project-specific decision tree from research), confirm (the user
-confirms which expert scenario this project most resembles — the Agent must not decide this alone),
-and confirmed. \`loom capability research\` creates a \`_guide.md\` in the research directory explaining
+Build dossiers in four steps: research (collect expert narratives, case studies, and methodology
+sources), synthesize (construct the project-specific decision tree from research), select the scenario,
+and confirm its authority. Use \`loom capability confirm <slug> --scenario <text> --source human\` when
+the user confirms which expert situation applies. Use \`--source agent\` only for a reversible provisional
+selection when the human is unavailable; it remains visibly provisional until a human confirms it.
+\`loom capability research\` creates a \`_guide.md\` in the research directory explaining
 what to write — create one .md file per source, citing where the knowledge came from. \`loom capability
 synthesize\` reads those files and validates that every decision tree node has a source citation and a
 counterexample. A dossier that has not been confirmed should not be referenced by Tasks, but the
@@ -110,8 +112,12 @@ Each Task records:
 - **reads**: every file, document, or artifact the Agent must consume to do this Task. Must be specific
   paths, not categories. If the Agent needs it, list it; if it is not listed, the Agent should not
   depend on it.
-- **touches**: every file, document, or artifact the Task is expected to produce or modify. Must be
-  specific paths. A Task that touches nothing is not a Task.
+- **touches**: every file, document, or artifact the Task is expected to produce or modify. Must be
+  specific paths. A Task that touches nothing is not a Task.
+- **implements**: the design decision this Task realizes. If no design applies, use a concrete
+  \`design_exemption\` instead of leaving the relationship implicit.
+- **capability_hooks**: the professional decision-tree nodes activated by this Task. If no dossier
+  applies, use a concrete \`capability_exemption\`; an empty array alone is not a decision.
 - **depends_on**: other Tasks that must be done first. Empty is valid only when this Task has no
   prerequisites.
 - **covers**: which delivery units this Task advances. Use this to check that the delivery surface is
@@ -216,17 +222,34 @@ The human's patience is the project's fuel. Do not let several Tasks pass in sil
   output, a visualization, a working demo — reach an early slice of it sooner rather than saving it for
   last. The human's "I want to see more" feeling is real project fuel.
 
+## Handle user feedback before changing code
+
+When the human gives feedback, a fix suggestion, or a direction change, do not jump straight to editing
+code. First judge whether the feedback changes the project's design intent, Task scope, or acceptance
+conditions.
+
+- **Consequential feedback** (changes design, scope, boundaries, or what "done" means): record it with
+  \`loom decision --json-file\` before editing. Update the affected design document or Task. If a done Task
+  is affected, \`loom check\` will warn — reopen it if the change invalidates prior evidence. Then edit
+  code.
+- **Implementation detail** (a small bug, a color tweak, a wording fix, a test that broke): fix it
+  directly. No decision record needed.
+- **When you are not sure**: lean toward recording. A decision record for a small change costs almost
+  nothing; skipping one for a consequential change creates silent drift that is expensive to trace later.
+
 Do not narrate this protocol to the human unless it helps them understand a decision, risk, or handoff.`;
 
 export const AGENT_ANCHOR = `<!-- loom:v2 -->
 ## LOOM
 
-This project uses LOOM as Agent-only continuity infrastructure. Run \`loom context\` when entering the
-project, after a context reset, and before substantial work. When a Task is active, the command restores
-its execution protocol, exact state, and declared context; rerun it before editing after any interruption.
-Keep project truth, design documents, professional capability dossiers, and Tasks current through the CLI,
-and never ask the human to operate LOOM. Do not rerun LOOM before every tool call: persist and restore at
-meaningful work boundaries.`;
+This project uses LOOM as Agent-only continuity infrastructure. Run \`loom context\` when entering the
+project, after a context reset, before substantial work, and when the human gives feedback or a direction
+change. When a Task is active, the command restores its execution protocol, exact state, and declared
+context; rerun it before editing after any interruption. Keep project truth, design documents, professional
+capability dossiers, and Tasks current through the CLI, and never ask the human to operate LOOM. Do not
+rerun LOOM before every tool call: persist and restore at meaningful work boundaries. The installed
+\`loom\` command is the stable project-local invocation. If it is not on PATH in a source checkout, use
+the absolute path to that checkout's \`cli/bin/loom.js\`; do not guess a relative path from this project.`;
 
 function renderKeeperGap(item) {
   if (typeof item === 'string') return `  - ${item}`;
@@ -341,9 +364,14 @@ after the gaps are fixed without requiring another Keeper round:
 \`\`\`json
 {
   "run_id": "<unique-id>",
-  "prepared_digest": "<digest-above>",
-  "verdict": "passed | needs_revision | blocked",
-  "summary": "<concise handoff judgment>",
+  "prepared_digest": "<digest-above>",
+  "verdict": "passed | needs_revision | blocked",
+  "review": {
+    "mode": "independent | self",
+    "reviewer_id": "<fresh Agent or current Agent identity>",
+    "evidence": "<how the host isolated this review from shaping context>"
+  },
+  "summary": "<concise handoff judgment>",
   "gaps": [
     {
       "gap": "<missing or contradictory truth>",
@@ -356,8 +384,12 @@ after the gaps are fixed without requiring another Keeper round:
 }
 \`\`\`
 
-Record the result with \`loom keeper record --json-file <result.json>\`. Use \`passed\` only when you
-could responsibly begin the first Task. Otherwise use \`needs_revision\` with concrete gaps and the
+Record the result with \`loom keeper record --json-file <result.json>\`. Use \`passed\` only when you are
+a genuinely fresh Agent, could responsibly begin the first Task, and can record \`review.mode\` as
+\`independent\` with concrete isolation evidence.
+If you shaped this project, do not review your own work as independent; ask the host for a fresh Agent,
+or use \`loom keeper skip --reason <concrete limitation>\` when isolation is unavailable. Otherwise use
+\`needs_revision\` with concrete gaps and the
 observable evidence that would close each one, or \`blocked\` when progress requires unavailable
 authority or external state. A failed attempt returns the project to shaping; revision requires a
 changed digest. When all gaps are minor and 3 or fewer, fixing them and running \`loom project ready\`
@@ -395,7 +427,8 @@ decision surface it owns. Complex subsystems should have their own files under \
 
 Link each separate field dossier under \`.loom/capabilities/<field>/capability.md\` and state which
 design decisions it changes. Do not merge distinct fields into one dossier. Capabilities are shaped in
-four steps: \`loom capability research\` → \`synthesize\` → \`confirm\` (user confirms the scenario).
+four steps: \`loom capability research\` → \`synthesize\` → \`confirm --source human\` (user-confirmed)
+or \`confirm --source agent\` (explicitly provisional when the human is unavailable).
 
 ## Project structure
 
@@ -521,9 +554,9 @@ Name the established field, what expertise it contributes, and what belongs to a
 
 ## Project scenario
 
-> This section records the user-confirmed project scenario: which expert situation this project most
-> closely resembles. The Agent must not fill this alone; it requires user confirmation via
-> \`loom capability confirm <slug> --scenario <text>\`.
+> This section records which expert situation the project most closely resembles. Use
+> \`loom capability confirm <slug> --scenario <text> --source human\` for user confirmation. When the
+> human is unavailable, use \`--source agent\`; LOOM records the selection as provisional.
 
 State the project scenario that determines which branches of the decision tree are active.
 

package/cli/src/store.js

@@ -196,7 +196,10 @@ function validateTasks(tasks) {
         if (acc.evidence !== undefined && typeof acc.evidence !== 'string') throw new Error(`${task.id} acceptance evidence must be a string`);
       }
     }
-    if (task.implements !== undefined && typeof task.implements !== 'string') throw new Error(`${task.id} implements must be a string referencing a design decision`);
+    if (task.implements !== undefined && typeof task.implements !== 'string') throw new Error(`${task.id} implements must be a string referencing a design decision`);
+    if (task.design_exemption !== undefined && (typeof task.design_exemption !== 'string' || (task.design_exemption && task.design_exemption.length < 10))) throw new Error(`${task.id} design_exemption must be a concrete reason`);
+    if (task.capability_exemption !== undefined && (typeof task.capability_exemption !== 'string' || (task.capability_exemption && task.capability_exemption.length < 10))) throw new Error(`${task.id} capability_exemption must be a concrete reason`);
+    if (task.integrity_version !== undefined && task.integrity_version !== 1) throw new Error(`${task.id} integrity_version is unsupported`);
     if (task.capability_hooks !== undefined) {
       if (!Array.isArray(task.capability_hooks)) throw new Error(`${task.id} capability_hooks must be an array`);
       for (const hook of task.capability_hooks) {
@@ -404,18 +407,21 @@ export function synthesizeCapability(slug, root = findRoot()) {
   return { slug, status: 'synthesized', nodes: nodes.length, materials: materials.length };
 }
 
-export function confirmCapability(slug, options = {}, root = findRoot()) {
-  if (!options.scenario || options.scenario.length < 20) throw new Error('Confirm requires --scenario <text> (at least 20 characters describing which expert situation this project most resembles)');
+export function confirmCapability(slug, options = {}, root = findRoot()) {
+  if (!options.scenario || options.scenario.length < 20) throw new Error('Confirm requires --scenario <text> (at least 20 characters describing which expert situation this project most resembles)');
+  if (!['human', 'agent'].includes(options.source)) throw new Error('Capability confirmation requires explicit provenance: --source human|agent');
   const { paths } = loadProject(root);
   const dir = join(paths.capabilities, slug);
   if (!existsSync(dir)) throw new Error(`Capability not found: ${slug}`);
   const statusPath = join(dir, 'status.json');
   if (!existsSync(statusPath)) throw new Error(`Capability ${slug} is not a research-directory dossier`);
   const status = readJson(statusPath, 'status.json');
-  if (status.status !== 'synthesized') throw new Error(`Capability ${slug} must be synthesized before confirmation. Run loom capability synthesize ${slug} first.`);
-  status.scenario = options.scenario;
-  status.status = 'confirmed';
-  status.confirmed_at = now();
+  if (!['synthesized', 'provisional'].includes(status.status)) throw new Error(`Capability ${slug} must be synthesized before confirmation. Run loom capability synthesize ${slug} first.`);
+  status.scenario = options.scenario;
+  status.source = options.source;
+  status.status = options.source === 'human' ? 'confirmed' : 'provisional';
+  status.selected_at = now();
+  status.confirmed_at = options.source === 'human' ? now() : '';
   status.updated_at = now();
   atomicJson(statusPath, status);
   const capabilityPath = join(dir, 'capability.md');
@@ -429,7 +435,7 @@ export function confirmCapability(slug, options = {}, root = findRoot()) {
     const updated = content.replace(/## Project scenario\n[\s\S]*?\n## /, `${prefix}${blockquoteText}\n${options.scenario}\n${suffix}`);
     writeFileSync(capabilityPath, updated, 'utf8');
   }
-  return { slug, status: 'confirmed', scenario: options.scenario };
+  return { slug, status: status.status, scenario: options.scenario, source: options.source };
 }
 
 export function getCapabilityStatus(slug, root = findRoot()) {
@@ -533,9 +539,12 @@ export function importTasks(payload, root = findRoot()) {
       boundaries: raw.boundaries || [],
       depends_on: raw.depends_on || [],
       reads: raw.reads || ['.loom/PROJECT.md'],
-      touches: raw.touches || [],
-      implements: raw.implements || '',
-      capability_hooks: raw.capability_hooks || [],
+      touches: raw.touches || [],
+      implements: raw.implements || '',
+      design_exemption: raw.design_exemption || '',
+      capability_hooks: raw.capability_hooks || [],
+      capability_exemption: raw.capability_exemption || '',
+      integrity_version: 1,
       covers: raw.covers || [],
       status: 'open',
       progress: raw.progress || { completed: [], current: '', next: '' },
@@ -566,18 +575,48 @@ export function getTask(id, root = findRoot()) {
   return task;
 }
 
-function nextTask(tasks) {
+function nextTask(tasks) {
   const active = tasks.find((task) => task.status === 'active');
   if (active) return active;
   const done = new Set(tasks.filter((task) => task.status === 'done').map((task) => task.id));
   return tasks.find((task) => task.status === 'open' && task.depends_on.every((id) => done.has(id))) || null;
-}
-
-export function updateTask(id, patch, root = findRoot()) {
+}
+
+function taskIntegrityFindings(task, designs, capabilities) {
+  if (task.integrity_version !== 1) return [];
+  const findings = [];
+  if (designs.length && !task.implements?.trim() && !task.design_exemption?.trim()) findings.push('is missing implements or design_exemption');
+  if (capabilities.length && !(task.capability_hooks || []).length && !task.capability_exemption?.trim()) findings.push('is missing capability_hooks or capability_exemption');
+  return findings;
+}
+
+function assertTaskIntegrityClassification(task, root) {
+  const findings = taskIntegrityFindings(task, listDesigns(root), listCapabilities(root));
+  if (findings.length) throw new Error(`${task.id} has unresolved integrity classification:\n- ${findings.join('\n- ')}\nAdd the relevant link or a concrete exemption before execution.`);
+}
+
+function declaredArtifactPath(paths, ref) {
+  const normalized = ref.replaceAll('\\', '/');
+  if (isAbsolute(normalized) || normalized.startsWith('/') || normalized.includes('..')) throw new Error(`Unsafe declared artifact path: ${ref}`);
+  const fromLoom = normalized === '.loom' || normalized.startsWith('.loom/');
+  const base = fromLoom ? paths.loom : paths.root;
+  const relativeRef = fromLoom ? normalized.slice('.loom'.length).replace(/^\//, '') : normalized;
+  const absolute = resolve(base, relativeRef);
+  const prefix = `${base}${process.platform === 'win32' ? '\\' : '/'}`;
+  if (!absolute.startsWith(prefix) && absolute !== base) throw new Error(`Unsafe declared artifact path: ${ref}`);
+  return absolute;
+}
+
+function missingTaskOutputs(task, paths) {
+  if (task.integrity_version !== 1) return [];
+  return task.touches.filter((ref) => !existsSync(declaredArtifactPath(paths, ref)));
+}
+
+export function updateTask(id, patch, root = findRoot()) {
   const { paths, taskStore } = loadProject(root);
   const task = taskStore.tasks.find((item) => item.id === id);
   if (!task) throw new Error(`Task not found: ${id}`);
-  const allowed = ['title', 'outcome', 'acceptance', 'done_when', 'boundaries', 'depends_on', 'reads', 'touches', 'implements', 'capability_hooks', 'covers', 'progress', 'evidence'];
+  const allowed = ['title', 'outcome', 'acceptance', 'done_when', 'boundaries', 'depends_on', 'reads', 'touches', 'implements', 'design_exemption', 'capability_hooks', 'capability_exemption', 'covers', 'progress', 'evidence'];
   for (const key of Object.keys(patch)) if (!allowed.includes(key)) throw new Error(`Task field cannot be updated: ${key}`);
   Object.assign(task, patch, { updated_at: now() });
   validateTasks(taskStore.tasks);
@@ -628,12 +667,13 @@ export function reopenTask(id, options = {}, root = findRoot()) {
   return task;
 }
 
-export function startTask(id, root = findRoot()) {
-  const { paths, state, taskStore } = loadProject(root);
+export function startTask(id, root = findRoot()) {
+  const { paths, state, taskStore } = loadProject(root);
   if (!['passed', 'skipped'].includes(state.keeper.status)) throw new Error('The one-time Keeper handoff has not passed. Run loom keeper prompt.');
   if (taskStore.tasks.some((task) => task.status === 'active')) throw new Error('Another Task is already active');
-  const task = taskStore.tasks.find((item) => item.id === id);
-  if (!task || task.status !== 'open') throw new Error(`${id} is not open`);
+  const task = taskStore.tasks.find((item) => item.id === id);
+  if (!task || task.status !== 'open') throw new Error(`${id} is not open`);
+  assertTaskIntegrityClassification(task, root);
   const done = new Set(taskStore.tasks.filter((item) => item.status === 'done').map((item) => item.id));
   const missing = task.depends_on.filter((dep) => !done.has(dep));
   if (missing.length) throw new Error(`${id} has incomplete dependencies: ${missing.join(', ')}`);
@@ -648,12 +688,15 @@ export function startTask(id, root = findRoot()) {
   return task;
 }
 
-export function completeTask(id, payload, root = findRoot()) {
+export function completeTask(id, payload, root = findRoot()) {
   const { paths, state, taskStore } = loadProject(root);
   const task = taskStore.tasks.find((item) => item.id === id);
   if (!task) throw new Error(`Task not found: ${id}`);
-  if (task.status !== 'active') throw new Error(`${id} is not active`);
-  if (!Array.isArray(payload.evidence) || !payload.evidence.length) throw new Error('Completing a Task requires concrete evidence');
+  if (task.status !== 'active') throw new Error(`${id} is not active`);
+  if (!Array.isArray(payload.evidence) || !payload.evidence.length) throw new Error('Completing a Task requires concrete evidence');
+  assertTaskIntegrityClassification(task, root);
+  const missingOutputs = missingTaskOutputs(task, paths);
+  if (missingOutputs.length) throw new Error(`${id} declared output does not exist:\n- ${missingOutputs.join('\n- ')}`);
   const hasAcceptance = Array.isArray(task.acceptance) && task.acceptance.length > 0;
   if (hasAcceptance) {
     if (!Array.isArray(payload.acceptance_results)) throw new Error('Completing a Task with acceptance[] requires acceptance_results[]');
@@ -757,11 +800,15 @@ export function getKeeperPrompt(root = findRoot()) {
   return keeperProtocol({ attemptNumber: state.keeper.prepared_attempt, preparedDigest: state.keeper.prepared_digest });
 }
 
-export function recordKeeper(payload, root = findRoot()) {
+export function recordKeeper(payload, root = findRoot()) {
   const { paths, state, taskStore } = loadProject(root);
   if (state.project.status !== 'ready_for_keeper') throw new Error('Keeper result cannot be recorded before loom project ready');
-  if (!['passed', 'needs_revision', 'blocked'].includes(payload.verdict)) throw new Error('Keeper verdict must be passed, needs_revision, or blocked');
-  if (!payload.summary || !Array.isArray(payload.evidence) || !payload.evidence.length) throw new Error('Keeper result requires summary and evidence');
+  if (!['passed', 'needs_revision', 'blocked'].includes(payload.verdict)) throw new Error('Keeper verdict must be passed, needs_revision, or blocked');
+  if (!payload.summary || !Array.isArray(payload.evidence) || !payload.evidence.length) throw new Error('Keeper result requires summary and evidence');
+  if (payload.verdict === 'passed') {
+    if (!payload.review || payload.review.mode !== 'independent') throw new Error('Keeper pass requires an independent review; use review.mode="independent" from a fresh Agent, or loom keeper skip with a concrete reason');
+    if (!payload.review.reviewer_id || payload.review.reviewer_id.length < 6 || !payload.review.evidence || payload.review.evidence.length < 10) throw new Error('Independent Keeper review requires reviewer_id and concrete review evidence');
+  }
   if (payload.evidence.some((item) => typeof item !== 'string' || !item.trim())) throw new Error('Keeper evidence entries must be non-empty strings');
   if (payload.gaps !== undefined && !Array.isArray(payload.gaps)) throw new Error('Keeper gaps must be an array');
   for (const gap of payload.gaps || []) {
@@ -784,7 +831,7 @@ export function recordKeeper(payload, root = findRoot()) {
   if (!payload.prepared_digest || payload.prepared_digest !== state.keeper.prepared_digest) throw new Error('Keeper result prepared_digest does not match the current ready state');
   const currentDigest = projectDigest(paths, taskStore.tasks);
   if (currentDigest !== state.keeper.prepared_digest) throw new Error('Project truth changed after loom project ready; prepare a new Keeper attempt');
-  const attempt = { run_id: payload.run_id, prepared_digest: payload.prepared_digest, verdict: payload.verdict, summary: payload.summary, evidence: payload.evidence, gaps: payload.gaps || [], can_auto_pass: canAutoPass, at: now() };
+  const attempt = { run_id: payload.run_id, prepared_digest: payload.prepared_digest, verdict: payload.verdict, summary: payload.summary, evidence: payload.evidence, gaps: payload.gaps || [], review: payload.review || { mode: 'unverified', reviewer_id: '', evidence: '' }, can_auto_pass: canAutoPass, at: now() };
   state.keeper.attempts.push(attempt);
   state.keeper.status = payload.verdict;
   if (payload.verdict === 'passed') state.project.status = 'build_ready';
@@ -818,7 +865,7 @@ export function recordDecision(payload, root = findRoot()) {
   return { id, summary: payload.summary, changes: payload.changes, affected_tasks: payload.affected_tasks || [] };
 }
 
-export function compileContext(options = {}, root = findRoot()) {
+export function compileContext(options = {}, root = findRoot()) {
   const { paths, state, taskStore } = loadProject(root);
   const designs = listDesigns(root);
   const capabilities = listCapabilities(root);
@@ -834,8 +881,12 @@ export function compileContext(options = {}, root = findRoot()) {
         : state.project.status === 'shaping'
           ? 'Project is still shaping. Confirm the intended result, identify open questions, and build the Work Map before starting material work.'
           : 'No executable Task. Create or update Tasks so the Work Map matches the project goal.';
-  const statusBlock = `## Current LOOM state and recommended action\n\n- Project status: ${state.project.status}\n- Active task: ${summary.active || 'none'}\n- Work map: ${summary.total} total, ${summary.open} open, ${summary.done} done, ${summary.blocked} blocked\n- Design documents: ${designs.length}\n- Capability dossiers: ${capabilities.length}\n- Keeper status: ${state.keeper.status}\n\n**Recommended next action:** ${recommendation}\n\nThis is a recommendation, not a script. Use your judgment; if you choose differently, record the reason in \`.loom/DECISIONS.md\` or the active Task evidence.`;
-  const blocks = [statusBlock, agentProtocol({ humanChannel: options.humanChannel || 'available' }), shapingContext({ state, taskSummary: summary, capabilityNames: capabilities, designNames: designs, forKeeper: Boolean(options.keeper) })];
+  const capabilityStates = capabilities.map((name) => {
+    const statusPath = join(paths.capabilities, name, 'status.json');
+    return existsSync(statusPath) ? `${name} (${readJson(statusPath, 'status.json').status || 'unknown'})` : `${name} (legacy)`;
+  });
+  const statusBlock = `## Current LOOM state and recommended action\n\n- Project status: ${state.project.status}\n- Active task: ${summary.active || 'none'}\n- Work map: ${summary.total} total, ${summary.open} open, ${summary.done} done, ${summary.blocked} blocked\n- Design documents: ${designs.length}\n- Capability dossiers: ${capabilityStates.length ? capabilityStates.join(', ') : 'none'}\n- Keeper status: ${state.keeper.status}\n\n**Recommended next action:** ${recommendation}\n\nThis is a recommendation, not a script. Use your judgment; if you choose differently, record the reason in \`.loom/DECISIONS.md\` or the active Task evidence.`;
+  const blocks = [statusBlock, agentProtocol({ humanChannel: options.humanChannel || 'available' }), shapingContext({ state, taskSummary: summary, capabilityNames: capabilityStates, designNames: designs, forKeeper: Boolean(options.keeper) })];
   blocks.push(`## Project whole (${normalizeRef(paths, paths.project)})\n\n${readFileSync(paths.project, 'utf8')}`);
   if (existsSync(paths.structure)) blocks.push(`## Project structure (${normalizeRef(paths, paths.structure)})\n\n${readFileSync(paths.structure, 'utf8')}`);
   if (options.keeper) {
@@ -889,20 +940,31 @@ function readContextDocument(paths, ref) {
   return readFileSync(absolute, 'utf8');
 }
 
-export function checkProject(root = findRoot()) {
-  const { paths, state, taskStore } = loadProject(root);
-  const errors = [];
-  const warnings = [];
+export function checkProject(root = findRoot()) {
+  const { paths, state, taskStore } = loadProject(root);
+  const designs = listDesigns(root);
+  const capabilities = listCapabilities(root);
+  const errors = [];
+  const warnings = [];
   for (const task of taskStore.tasks) {
     for (const ref of task.reads) {
       try { readContextDocument(paths, ref); } catch (error) { errors.push(`${task.id}: ${error.message}`); }
     }
-    if (task.capability_hooks) {
+    if (task.capability_hooks) {
       for (const hook of task.capability_hooks) {
         const nodeContent = extractCapabilityNode(paths, hook.node);
         if (nodeContent === null) warnings.push(`${task.id} references missing capability node: ${hook.node}`);
-      }
-    }
+      }
+    }
+    if (task.integrity_version === 1) {
+      const classificationFindings = taskIntegrityFindings(task, designs, capabilities);
+      const target = ['active', 'done'].includes(task.status) ? errors : warnings;
+      target.push(...classificationFindings.map((finding) => `${task.id} ${finding}`));
+      if (task.status === 'done') {
+        const missingOutputs = missingTaskOutputs(task, paths);
+        errors.push(...missingOutputs.map((output) => `${task.id} declared output does not exist: ${output}`));
+      }
+    }
     const hasAcceptance = Array.isArray(task.acceptance) && task.acceptance.length > 0;
     const hasDoneWhen = Array.isArray(task.done_when) && task.done_when.length > 0;
     if (!hasAcceptance && hasDoneWhen) warnings.push(`${task.id} uses done_when[] without acceptance[] — consider migrating to structured acceptance for clearer verification`);
@@ -919,23 +981,25 @@ export function checkProject(root = findRoot()) {
     const task = taskStore.tasks.find((item) => item.id === taskId);
     if (task && task.status === 'done') warnings.push(`${taskId} is done but was marked affected by a decision; consider reopening if the change invalidates prior work`);
   }
-  if (!listCapabilities(root).length) warnings.push('No capability dossier exists; acceptable only when specialist judgment would not change the work');
-  if (!listDesigns(root).length) warnings.push('No design document exists; PROJECT.md should remain a concise map of the whole');
+  if (!capabilities.length) warnings.push('No capability dossier exists; acceptable only when specialist judgment would not change the work');
+  if (!designs.length) warnings.push('No design document exists; PROJECT.md should remain a concise map of the whole');
   if (!existsSync(paths.structure)) warnings.push('No STRUCTURE.md exists; declare where files go so the Agent does not guess');
   else if (readFileSync(paths.structure, 'utf8').includes('Where implementation files go. Example:')) warnings.push('STRUCTURE.md still contains template instructions; customize it for this project');
-  for (const name of listDesigns(root)) {
+  for (const name of designs) {
     if (readFileSync(join(paths.design, name), 'utf8').includes('Describe the project-specific decision, mechanism, boundary, or evidence owned by this section.')) warnings.push(`Design document still contains template instructions: ${name}`);
   }
-  for (const name of listCapabilities(root)) {
+  for (const name of capabilities) {
     const content = readFileSync(capabilityPath(paths, name), 'utf8');
     if (capabilityTemplateResidue(content)) warnings.push(`Capability dossier still contains template instructions: ${name}`);
     if (content.includes('### C') && !content.includes('source:')) warnings.push(`Capability dossier has decision tree nodes without source citations: ${name}`);
     const statusPath = join(paths.capabilities, name, 'status.json');
     if (existsSync(statusPath)) {
       const capStatus = readJson(statusPath, 'status.json');
-      if (capStatus.status && capStatus.status !== 'confirmed') warnings.push(`Capability ${name} is ${capStatus.status}, not confirmed; tasks referencing it proceed provisionally`);
-    }
-  }
+      if (capStatus.status && capStatus.status !== 'confirmed') warnings.push(`Capability ${name} is ${capStatus.status}, not confirmed; tasks referencing it proceed provisionally`);
+    }
+  }
+  const latestKeeper = state.keeper.attempts.at(-1);
+  if (state.keeper.status === 'passed' && latestKeeper && latestKeeper.review?.mode !== 'independent') warnings.push('Keeper pass has no independently attested review provenance; prepare a fresh review before relying on it');
   const coverage = checkDeliverableCoverage(root);
   if (coverage.uncovered > 0) warnings.push(`Uncovered deliverables: ${coverage.uncovered_items.map((item) => item.slug).join(', ')}`);
   return { healthy: errors.length === 0, errors, warnings, summary: taskSummary(taskStore.tasks), deliverable_coverage: { total: coverage.total, covered: coverage.covered, uncovered: coverage.uncovered } };

package/design.md

@@ -75,8 +75,12 @@ Cross-field synthesis lives in the design document whose decision it changes. A
 - generic failure modes and observable verification signals;
 - opened sources, what each changed, conflicts, and uncertainty when research is used.
 
-Acquisition can happen quietly. The Agent may briefly name the capability it is obtaining, but does not
-turn research logistics into user workflow.
+Acquisition can happen quietly. The Agent may briefly name the capability it is obtaining, but does not
+turn research logistics into user workflow.
+
+Scenario authority is explicit. `capability confirm --source human` records a confirmed scenario;
+`--source agent` records a provisional, reversible selection when the human is unavailable. Context and
+health checks preserve that distinction instead of allowing an Agent assumption to masquerade as user confirmation.
 
 ### Work Map and Task
 
@@ -94,8 +98,10 @@ Task is the single execution contract:
   "done_when": ["A forced-reset transcript resumes correctly"],
   "boundaries": ["The human never operates LOOM"],
   "depends_on": [],
-  "reads": [".loom/PROJECT.md", ".loom/design/context-system.md", ".loom/capabilities/human-agent-interaction.md", "fixtures/reset-case.md"],
-  "touches": ["cli/src/context.js"],
+  "reads": [".loom/PROJECT.md", ".loom/design/context-system.md", ".loom/capabilities/human-agent-interaction.md", "fixtures/reset-case.md"],
+  "touches": ["cli/src/context.js"],
+  "implements": ".loom/design/context-system.md#Context selection",
+  "capability_hooks": [{ "node": "human-agent-interaction#C1", "at": "selecting reset context" }],
   "status": "active",
   "progress": {
     "completed": [],
@@ -106,17 +112,23 @@ Task is the single execution contract:
 }
 ```
 
-There is at most one active Task. Completion requires a concrete evidence mapping for every exact `done_when`
-criterion. A completed Task can be reopened with a reason when later evidence disproves it. The Task plan may change without
-human approval when the change is a reversible implementation refinement inside the agreed whole; outcome,
-authority, risk, or material cost changes return to the conversation.
+There is at most one active Task. Completion requires a concrete evidence mapping for every exact `done_when`
+criterion. A completed Task can be reopened with a reason when later evidence disproves it. The Task plan may change without
+human approval when the change is a reversible implementation refinement inside the agreed whole; outcome,
+authority, risk, or material cost changes return to the conversation.
+
+New Tasks must make design and capability applicability explicit: use `implements` and `capability_hooks`, or
+record a concrete `design_exemption` / `capability_exemption`. Task start rejects an unclassified active horizon.
+Completion verifies that every declared local `touches` path exists, and `loom check` detects later filesystem drift.
 
 ### One-time Keeper
 
 Keeper is not a recurring role. It is a single isolation test at the transition from shaping to material
 execution. A fresh Agent receives no prior conversation, runs `loom context --keeper`, explains the whole,
 selects a first Task, navigates its design documents and professional capabilities, and identifies concrete evidence. Every attempt binds a unique
-fresh-thread `run_id` to the digest frozen by `project ready`. It may return gaps; summary, evidence and exact gaps
+fresh-thread `run_id` to the digest frozen by `project ready`. A passing record also carries an explicit independent
+review attestation (`review.mode`, reviewer identity, and isolation evidence); known self-review cannot be recorded as
+passed. This is an auditable host assertion, not cryptographic identity proof. It may return gaps; summary, evidence and exact gaps
 are injected into the main Agent's next context. Revision must change project truth or Task definitions before a
 new digest and fresh Keeper run are allowed. Once passed, normal Task evidence replaces further Keeper ceremony.
 
@@ -132,15 +144,15 @@ cli/src/protocol.js   layered Agent prompts and every human-readable template
 cli/test/run-all.js   end-to-end contract tests
 ```
 
-The CLI has six responsibilities:
+The CLI has six responsibilities:
 
 1. Initialize the minimal project backbone.
 2. Record structured understanding and decision history safely.
 3. Scaffold a scalable design-document graph and separate professional-field dossiers.
-4. Maintain a large Work Map and a single active Task.
-5. Compile only decision-relevant context after reset.
-6. Adapt clarification to whether a human response channel is actually available.
-7. Prepare one-time Keeper and controlled Evil Eval artifacts.
+4. Maintain a large Work Map and a single active Task.
+5. Compile only decision-relevant context after reset.
+6. Adapt clarification to whether a human response channel is actually available.
+7. Prepare one-time Keeper and controlled Evil Eval artifacts.
 
 It does not orchestrate models, browse the web, generate project documents, or pretend that a CLI command
 clears model memory. Those capabilities belong to the host Agent and its tools.
@@ -157,42 +169,43 @@ ready_for_keeper ⇄ fresh Keeper needs_revision or blocked → shaping
 build_ready → building ⇄ Task repair or block or reopen → complete
 ```
 
-`project ready` checks only structural prerequisites: PROJECT.md is no longer a template, at least one design
-document and a Work Map exist, and no high-impact open question remains. Keeper judges semantic build-readiness. Task start requires Keeper
-pass or an explicit recorded skip. An unchanged revision, duplicate Keeper run, wrong digest, or stale prepared
-state is rejected. Imported Tasks start open, `task start` rejects missing or directory-level context reads,
-generic updates cannot change status, and completion requires criterion-by-criterion evidence.
+`project ready` checks only structural prerequisites: PROJECT.md is no longer a template, at least one design
+document and a Work Map exist, and no high-impact open question remains. Keeper judges semantic build-readiness. Task start requires Keeper
+pass or an explicit recorded skip. An unchanged revision, duplicate Keeper run, wrong digest, or stale prepared
+state is rejected. Imported Tasks start open, `task start` rejects missing or directory-level context reads and
+unclassified design/capability applicability, generic updates cannot change status, and completion requires
+criterion-by-criterion evidence plus existence of every declared local output.
 
 ## Context selection
 
-`loom context` always injects:
+`loom context` always injects:
 
 - the stable Agent protocol;
 - compact state counts and open uncertainty;
 - PROJECT.md, with decision history identified as on-demand context;
-- the active Task, if one exists;
-- the exact design, capability, source, contract, or fixture files named in that Task's `reads` list.
-
-### Environment adaptation and isolated state
-
-The host supplies human-channel availability at context time. With `available` (the default), the Agent may
-ask the human for consequential intent, preference, authority, or facts that only they hold. With
-`unavailable`, it must not fabricate a user exchange or replace an intent/authority question with web search.
-It first inspects discoverable workspace facts and permitted tools, researches only objective external facts when
-the task allows it, then records a bounded assumption and chooses a safe reversible action or blocks on
-unavailable authority.
-
-`--state-dir <outside-workspace-dir>` places LOOM's state tree in a per-run sidecar rather than the workspace.
-This is for benchmark or sandbox runners whose scored workspace must remain pristine. The sidecar remains
-semantically `.loom/` to LOOM documents and Task references, but initialization does not edit the workspace
-or add an AGENTS.md anchor. Every command in that run must receive the same state directory.
-
-When a Task is active, context also injects a short execution protocol. It tells a reset Agent to reconcile
-the Task with the current workspace and version-control state, inspect relevant tests before editing, choose
-verification according to risk and the exact `done_when` claims, persist `completed/current/next` at meaningful
-handoff boundaries, and close only with reproducible criterion-level evidence. It deliberately does not require
-a ceremonial unit test for every kind of work or a branch, commit, or pull request for every Task. Those
-delivery mechanisms remain conditional on the human request and repository workflow.
+- the active Task, if one exists;
+- the exact design, capability, source, contract, or fixture files named in that Task's `reads` list.
+
+### Environment adaptation and isolated state
+
+The host supplies human-channel availability at context time. With `available` (the default), the Agent may
+ask the human for consequential intent, preference, authority, or facts that only they hold. With
+`unavailable`, it must not fabricate a user exchange or replace an intent/authority question with web search.
+It first inspects discoverable workspace facts and permitted tools, researches only objective external facts when
+the task allows it, then records a bounded assumption and chooses a safe reversible action or blocks on
+unavailable authority.
+
+`--state-dir <outside-workspace-dir>` places LOOM's state tree in a per-run sidecar rather than the workspace.
+This is for benchmark or sandbox runners whose scored workspace must remain pristine. The sidecar remains
+semantically `.loom/` to LOOM documents and Task references, but initialization does not edit the workspace
+or add an AGENTS.md anchor. Every command in that run must receive the same state directory.
+
+When a Task is active, context also injects a short execution protocol. It tells a reset Agent to reconcile
+the Task with the current workspace and version-control state, inspect relevant tests before editing, choose
+verification according to risk and the exact `done_when` claims, persist `completed/current/next` at meaningful
+handoff boundaries, and close only with reproducible criterion-level evidence. It deliberately does not require
+a ceremonial unit test for every kind of work or a branch, commit, or pull request for every Task. Those
+delivery mechanisms remain conditional on the human request and repository workflow.
 
 Workspace code paths in `touches` are identified but not automatically copied into context. Full decision
 history is not repeatedly injected because current truth belongs in PROJECT.md and linked design documents.
@@ -209,7 +222,8 @@ an automated semantic migration can be designed only after real v1 projects reve
 
 - External capability acquisition is represented but not automated yet; the host Agent performs research.
 - Markdown is intentionally human-editable. LOOM validates file existence and structured state, not prose truth.
-- Keeper independence depends on the host creating a fresh thread or window.
+- Keeper independence depends on the host creating a fresh thread or window. LOOM requires and records the
+  host's independent-review attestation but cannot cryptographically prove Agent identity.
 - Evil Eval scaffolding controls experiment design but does not itself launch model runs.
 - A one-time Keeper verifies build-readiness, not the eventual quality of every implementation Task.