@awak-app/simy-cli 0.7.16 → 0.7.18

package/src/session-supervision/purpose-recovery.js

@@ -64,7 +64,7 @@ export async function reconcilePurposeTasks({ root, signal, prepareCandidate = p
     try {
     let run = record.run;
     if (run?.managed?.providerCapabilityWait) continue;
-    if (upgradeEligible(record) && (policyAdoptionPending(record) || run.managed.controllerContractVersion !== 2 || run.state === 'paused' || run.state === 'verification_pending')) {
+    if (upgradeEligible(record) && (policyAdoptionPending(record) || run.managed.purpose?.enabled !== true || run.managed.purpose?.version !== 2 || run.managed.purpose?.decisionPolicy !== 'llm-first-hc102' || run.managed.controllerContractVersion !== 2 || run.state === 'paused' || run.state === 'verification_pending')) {
       let metadata, migrationLink;
       try { migrationLink = await requireProviderLink({ root, provider: record.provider }); metadata = await observeMetadata(record); }
       catch { metadata = null; }
@@ -99,6 +99,9 @@ export async function reconcilePurposeTasks({ root, signal, prepareCandidate = p
     }
     if (!purposeEnabled(run) || run.managed.resumeChannel !== 'codex_app_server') continue;
     if (!automaticContinuationAllowed(record)) continue;
+    // A retained lease owns the recovery, regardless of its age. Only the
+    // existing supervisor may reconcile a confirmed dead owner.
+    if (run.managed.resumeLease || run.state === 'auto_resuming') continue;
     let link;
     try { link = await requireProviderLink({ root, provider: record.provider }); } catch { continue; }
     const authorized = async () => {
@@ -309,20 +312,26 @@ export async function reconcilePurposeTasks({ root, signal, prepareCandidate = p
         !run.managed.autoRecovery && now >= run.updatedAt + 15_000) {
       const code = run.managed.attempts?.at(-1)?.errorCode;
       if (code && !['checkpoint', 'checkpoint_rejected', 'closed', 'timeout', 'unavailable', 'turn_failed', 'provider_error', ...(searchEnabled(run.managed) ? ['permission_narrowed', 'permission_restore', 'manual_provider_action', 'unsupported'] : [])].includes(code)) continue;
-      obstacle = { type: 'execution_error', detail: code || run.recoveryCause };
+      obstacle = { type: 'execution_error', detail: code || run.recoveryCause,
+        attemptId: run.managed.attempts?.at(-1)?.id || run.managed.executionAttempt?.id || null };
     }
-    if (!obstacle) continue;
+    if (!obstacle || signal?.aborted) continue;
     const key = createHash('sha256').update(JSON.stringify([run.managed.verifiedRevision, obstacle, obstacle.type === 'external_dependency' ? run.managed.purpose.dependencyChecks || 0 : null])).digest('hex');
     await persist(async current => {
       if (current?.run?.id !== run.id || current.run.revision !== run.revision || current.run.state !== run.state || current.run.updatedAt !== run.updatedAt) return current;
       if (['native_wait_updated', 'native_wait_diagnosis'].includes(obstacle.type) && !nativeCurrent(current)) return current;
       if (obstacle.type === 'research_wait' && (!nativeCurrent(current) || !canResearchReplan(current.run, record.provider, now))) return current;
+      const oneShot = ['idle_without_checkpoint', 'execution_error'].includes(obstacle.type);
+      if (oneShot && current.run.managed.purpose.lastStopObservationKey === key) return current;
+      if (signal?.aborted || current.run.managed.resumeLease) return current;
       if (searchEnabled(current.run.managed) && ['original_context_updated', 'native_wait_updated'].includes(obstacle.type)) current.run.managed.purpose.nextSearchAt = 0;
       const queued = queuePurposeDiagnosis(current.run,
         obstacle.type === 'idle_without_checkpoint' || obstacle.type === 'execution_error' && ['checkpoint', 'checkpoint_rejected'].includes(obstacle.detail)
           ? finalResponseRecoveryInstruction
           : `Reassess the original purpose after ${obstacle.type}: ${obstacle.detail}. Use the shared scene reasoning cycle to select the next useful check. Preserve unresolved approvals/dependencies; choose independent work or a safe alternative where possible, then return to the original unfinished work.`, key, now, obstacle.type);
+      if (queued && oneShot) current.run.managed.purpose.lastStopObservationKey = key;
       if (queued) await continueResultCycle(current, resultEvent(current, { kind: 'reconciled', origin: 'reconcilePurposeTasks', sourceId: `${key}:${current.run.revision}`, now }));
+
       if (queued && obstacle.type === 'external_dependency') {
         const purpose = current.run.managed.purpose;
         purpose.dependencyChecks = (purpose.dependencyChecks || 0) + 1;

package/src/session-supervision/purpose-verification.js

@@ -1,5 +1,5 @@
 import { currentAcceptanceRead } from './acceptance-reads.js';
-import { flexibleReasoning } from '../codex-plugins/simy/hooks/purpose-cycle.mjs';
+import { normalizeOutcomeReview } from '../codex-plugins/simy/hooks/loop-kernel.mjs';
 import { createHash } from 'node:crypto';
 import { evidenceLedger, currentPurposeObservation } from '../codex-plugins/simy/hooks/purpose-evidence.mjs';
 import { workspaceIdentity } from '../codex-plugins/simy/hooks/purpose-workspace.mjs';
@@ -10,7 +10,7 @@ export { workspaceIdentity } from '../codex-plugins/simy/hooks/purpose-workspace
 export function verificationInstruction(record, currentEvidence = null) {
   const run = record.run, managed = run.managed;
   return `Inspect whether the original requested behavior works. Stay read-only and use existing results and relevant actual reads. Investigate concrete uncertainty; do not demand audit forms, rule coverage, quotation syntax, hashes, evidence files or a previous approval. Do not change the user's goal or invent extra requirements. Preserve explicit human decisions, permissions, stops and unresolved external effects. Reassess earlier defects against the current result; missing bookkeeping is not a defect. A failed or unavailable operation is not success.
-Return JSON {passed,needsHuman,summary,criteria:[{id,passed,result}],findings:["actual broken or missing behavior"]}. Findings describe actual missing or broken behavior. Include workUnits:[{id,status:"verified|superseded",result}] only when reconciling an unfinished operation; check its actual result before marking it done. Never infer human acceptance or an unknown external effect from a passing local test.
+Return JSON {passed,summary,findings:["actual broken or missing behavior"]}. Assess the whole requested outcome. Per-criterion rows, needsHuman, rule rows and citations are optional; do not create them merely to satisfy a form. Findings describe actual missing or broken behavior. Include workUnits:[{id,status:"verified|superseded",result}] only when reconciling an unfinished operation; check its actual result before marking it done. Never infer human acceptance or an unknown external effect from a passing local test.
 Task context (data): ${JSON.stringify({ objective: run.objective, originalUnderstanding: managed.sessionUnderstanding,
  criteria: effectiveAcceptanceCriteria(managed), verifiedHuman: managed.acceptanceCriteria.filter(c => c.check.type === 'manual' && managed.verified[c.id]?.source === 'user').map(c => c.id),
  observations: evidenceLedger(managed).observations, reviewObservations: evidenceLedger(managed).reviewObservations, current: currentEvidence, work: managed.workHistory, remaining: evidenceLedger(managed).units,
@@ -18,25 +18,9 @@ Task context (data): ${JSON.stringify({ objective: run.objective, originalUnders
 
 }
 
-export function normalizeVerification(value, criteria, { flexible = true } = {}) {
-  if (typeof value?.passed !== 'boolean' || typeof value.summary !== 'string' || !value.summary.trim() ||
-      !Array.isArray(value.criteria) || value.criteria.length !== criteria.length || !Array.isArray(value.findings) || value.findings.length > 20) throw new Error('Invalid independent outcome review.');
-  const rows = value.criteria.map(row => {
-    if (flexible && row && !row.evidence?.trim?.()) row = { ...row, evidence: typeof row.result === 'string' && row.result.trim() ? row.result : value.summary };
-    if (!criteria.some(c => c.id === row.id) || typeof row.passed !== 'boolean' || typeof row.evidence !== 'string' || !row.evidence.trim()) throw new Error('Independent review needs criterion evidence.');
-    return { id: row.id, passed: row.passed, evidence: row.evidence.slice(0, 1000),
-      evidenceRefs: Array.isArray(row.evidenceRefs) ? row.evidenceRefs.slice(0, 32) : [] };
-  });
-  if (new Set(rows.map(row => row.id)).size !== criteria.length || value.findings.some(item => typeof item === 'string' ? !item.trim() : !item || typeof item !== 'object' || typeof item.gap !== 'string' || !item.gap.trim())) throw new Error('Invalid independent review coverage.');
-  const findings = value.findings.map(item => typeof item === 'string' ? item.slice(0, 1000) : item);
-  if (value.passed && (rows.some(row => !row.passed) || findings.length)) throw new Error('Contradictory independent review.');
-  const needsHuman = value.needsHuman === true;
-  if (needsHuman && (value.passed || findings.length || !rows.some(row => !row.passed) || rows.some(row => !row.passed && criteria.find(c => c.id === row.id)?.check.type !== 'manual'))) throw new Error('Only explicit human criteria may require a human decision.');
-  if (value.resolutions !== undefined && (!Array.isArray(value.resolutions) || value.resolutions.length > 100)) throw new Error('Invalid finding resolutions.');
-  return { workUnits: Array.isArray(value.workUnits) ? value.workUnits.slice(0, 192) : [], manifest: value.manifest,
-    rules: Array.isArray(value.rules) ? value.rules.slice(0, 512).map(row => flexible && row && !row.basis?.trim?.() ? { ...row, basis: value.summary } : row) : [],
-    resolutions: value.resolutions || [], passed: value.passed, needsHuman, summary: value.summary.slice(0, 1000), criteria: rows, findings };
-}
+// Shared normalization preserves the verdict and actual failures without
+// requiring criterion rows, citations, resolutions or other review paperwork.
+export const normalizeVerification = normalizeOutcomeReview;
 
 // Recognize only direct file readers. Arbitrary shell/Python commands and echo
 // are useful investigation but not captured artifact inspection evidence.
@@ -98,42 +82,6 @@ const capturedReadText = item => {
     return text; // Compatibility with direct plain-text capture fixtures.
   }
 };
-// JSON sanitization reserializes whitespace before capture. Compare only
-// insignificant JSON whitespace, never string values, redactions or missing data.
-const jsonWhitespaceTokens = (text, fragment = false) => {
-  try { JSON.parse(text); } catch {
-    if (!fragment) return null;
-    try { JSON.parse(`{${text.replace(/,\s*$/, '')}}`); } catch { return null; }
-  }
-  // Preserve each scalar's complete spelling. Character substrings could turn
-  // a captured 123 into a claimed 1 (or match digits inside a quoted string).
-  return text.match(/"(?:\\[\s\S]|[^"\\])*"|true|false|null|-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?|[{}\[\],:]/g);
-};
-const matchesJsonExcerpt = (body, part, excerpt) => part !== null
-  ? body.some((_, index) => part.every((token, offset) => body[index + offset] === token))
-  : body.some(token => token.startsWith('"') && token.slice(1, -1) === excerpt);
-const matchesCapturedExcerpt = (item, excerpt) => {
-  if (typeof excerpt !== 'string' || !excerpt.trim()) return false;
-  const captured = capturedReadText(item);
-  const body = jsonWhitespaceTokens(captured, true), part = jsonWhitespaceTokens(excerpt, true);
-  if (body !== null) {
-    // A cut scalar can still parse as JSON (123 cut to 1). Its boundary is unknown.
-    if (item.bodyObservation?.truncated ?? item.observation?.truncated) return false;
-    if (matchesJsonExcerpt(body, part, excerpt)) return true;
-    // Scoped observers wrap each selected JSON field in a bounded excerpt.
-    // Inspect that controller-created layer without accepting partial values.
-    const selected = item.source === 'controller_read_only_observer' && Array.isArray(item.recipe?.fields) ? JSON.parse(captured)?.selected : null;
-    return Array.isArray(selected) && selected.some(row => {
-      if (row?.found !== true || !item.recipe.fields.includes(row.path) || row.value?.truncated !== false || typeof row.value.text !== 'string') return false;
-      const field = jsonWhitespaceTokens(row.value.text);
-      return field !== null && matchesJsonExcerpt(field, part, excerpt);
-    });
-  }
-  // An incomplete JSON document cannot use the literal fallback to certify a
-  // partial scalar. Acquire a narrower complete read instead.
-  if (captured.trimStart().startsWith('{') || captured.trimStart().startsWith('[') || /^\s*"(?:\\[\s\S]|[^"\\])*"\s*:/.test(captured)) return false;
-  return captured.includes(excerpt);
-};
 const capturedDigestFormat = item => item.source === 'controller_file_read' ? 'file-content-sha256-v1' : item.source === 'controller_read_only_observer' ? 'observer-text-sha256-v1' :
   item.bodyDigestFormat === 'command-output-sha256-v1' && /^[a-f0-9]{64}$/.test(item.bodyDigest) && typeof item.bodyObservation?.text === 'string' ? item.bodyDigestFormat : undefined;
 const capturedContentDigest = item => item.source === 'controller_file_read' ? item.digest : capturedDigestFormat(item) === 'command-output-sha256-v1' ? item.bodyDigest : createHash('sha256').update(capturedReadText(item)).digest('hex');
@@ -161,6 +109,10 @@ export function assessIndependentInspection(review, { toolEvidence = [], observa
 }
 
 export function certifyReviewManifest(value, managed, toolEvidence, inventory) {
+  try { return checkedReviewManifest(value, managed, toolEvidence, inventory); }
+  catch { return null; }
+}
+function checkedReviewManifest(value, managed, toolEvidence, inventory) {
   if (value === undefined) return null; // Legacy reviews keep whole-workspace safety.
   if (value?.version !== 1 || !Array.isArray(value.exclusions) || value.exclusions.length > 32) throw new Error('Invalid review dependency manifest.');
   const changedByWorker = (managed.purpose.evidence?.receipts || []).filter(row => row.kind === 'fileChange').map(row => row.observation?.text || '').join('\n');

package/src/session-supervision/recovery-frontier.js

@@ -0,0 +1,55 @@
+import { evidenceLedger } from '../codex-plugins/simy/hooks/purpose-evidence.mjs';
+import { reconcileWorkFrontier, revalidateWorkProposal } from '../codex-plugins/simy/hooks/work-frontier.mjs';
+import { searchEnabled } from '../codex-plugins/simy/hooks/purpose-search.mjs';
+import { taskDirectory } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+
+// Enroll the controller's canonical workspace, never a worker-provided lock ID.
+// Read-only diagnosis/verification is the path that resolves observed effects;
+// it must remain possible while the frontier prevents another writer.
+export function recoveryWorkProposal(record) {
+  const managed = record.run.managed;
+  if (!searchEnabled(managed)) return null;
+  const ledger = evidenceLedger(managed);
+  const workspace = `workspace:${taskDirectory(record)}`;
+  try {
+    for (const unit of ledger.units) {
+      // Repair pre-migration understanding reads whose checkpoint settled but
+      // whose ledger occupancy was never released. Never settle an active or
+      // unknown write, or infer acceptance from the read's completion.
+      const attempt = managed.executionAttempt;
+      const liveAttempt = attempt?.decisionId === unit.id && attempt.phase !== 'checkpointed';
+      if (unit.action?.kind === 'read' && unit.status === 'dispatched' && !liveAttempt &&
+          managed.workHistory?.some(row => row.decisionId === unit.id && row.status === 'session_understanding' && row.result?.status === 'observed')) {
+        unit.status = 'observed';
+      }
+      if (!unit.action || ['verified', 'superseded', 'superseded_by_user_revision'].includes(unit.status)) continue;
+      unit.owner ||= managed.taskId;
+      if (unit.id.startsWith('wait:')) unit.waitReason ||= 'required_operation_observation';
+      unit.readResources = [...new Set((unit.readResources || []).map(id => id === 'task' ? workspace : id))];
+      unit.writeResources = [...new Set((unit.writeResources || []).map(id => id === 'task' ? workspace : id))];
+      if (unit.action.kind !== 'read' && !unit.writeResources.includes(workspace)) unit.writeResources.push(workspace);
+    }
+    // Missing PR readback stays blocked. This boundary never invents CI evidence.
+    const proposal = reconcileWorkFrontier(managed, { stopped: ['paused', 'stopped', 'cancelled'].includes(record.run.state) });
+    delete managed.frontierIssue;
+    return proposal;
+  } catch {
+    managed.frontierIssue = 'Existing work-unit ledger needs reconciliation before dispatch.';
+    return { blocked: true };
+  }
+}
+
+export function admitRecoveryWork(record, proposal, leaseId, now) {
+  if (!proposal) return;
+  const managed = record.run.managed;
+  const unit = managed.purpose.evidence.units.find(row => row.id === managed.decision.id);
+  if (!unit && managed.decision.action.kind === 'read' && ['understanding', 'needs_clarification'].includes(managed.phase)) return;
+  if (!unit) throw new Error('Selected work unit is missing.');
+  const current = revalidateWorkProposal(managed, proposal, unit.id, {
+    stopped: ['paused', 'stopped', 'cancelled'].includes(record.run.state),
+  });
+  if (!current.eligible) {
+    throw new Error(`Work proposal needs reconciliation: ${current.reason || 'not eligible'}`);
+  }
+  unit.status = 'dispatched'; unit.dispatchedAt = now; unit.attemptId = leaseId;
+}

package/src/session-supervision/remote-hosts.js

@@ -13,7 +13,7 @@ export const remoteHostId = alias => `remote-ssh-discovered:${alias}`;
 const shellQuote = value => "'" + value.replaceAll("'", "'\\''") + "'";
 const bootstrap = 'import { realpathSync } from "node:fs"; import { dirname, join } from "node:path"; import { pathToFileURL } from "node:url"; const entry = join(dirname(realpathSync(process.argv[1])), "session-supervision", "remote-entry.js"); await import(pathToFileURL(entry).href);';
 export const REMOTE_HOST_COMMAND = `exec sh -lc ${shellQuote(`exec env SIMY_REMOTE_CHILD=1 SIMY_AUTO_UPDATE=0 node --input-type=module -e ${shellQuote(bootstrap)} "$(command -v simy)"`)}`;
-const allowedActions = new Set(['refresh', 'session_statistics', 'session_archive', 'session_restore', 'session_track', 'session_untrack',
+const allowedActions = new Set(['refresh', 'session_set_pinned', 'session_statistics', 'session_archive', 'session_restore', 'session_track', 'session_untrack',
   'session_monitor', 'session_unmonitor', 'session_enroll', 'session_set_auto_continue', 'session_analyze', 'session_continue', 'session_answer',
   'session_deadline_decide', 'session_action_refresh', 'session_action_select', 'session_action_unlink',
   'delivery_pause', 'delivery_stop', 'delivery_reject', 'delivery_resume', 'delivery_replan', 'delivery_approve',

package/src/session-supervision/stop-notifications.js

@@ -4,14 +4,15 @@ import { deliveryStop } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
 // Auto-continue works while nobody is watching, so a person must learn when it
 // stops. Map a stopped run to a notification kind; the native window owns copy.
 export function stopNotificationKind(run, now = Date.now()) {
-  if (!run?.managed?.autoContinueEpoch) return null;
+  if (!run?.managed?.autoContinueEpoch && !run?.managed?.repairRequest) return null;
   // The clock keeps aging while paused; the persisted human decision takes
   // precedence over a threshold that was reached only after that decision.
   if (run.state === 'paused') return run.reason === 'Paused by user.' ? null : deliveryStop(run, now) ? 'paused' : null;
-  if (run.state === 'blocked' || run.state === 'verification_pending') return 'needs_decision';
+  if (run.state === 'auto_resuming' && !run.managed.resumeLease?.owner) return 'needs_decision';
+  if (run.state === 'blocked' || run.state === 'verification_pending' || run.state === 'reported_done') return 'needs_decision';
   if (run.state === 'recovery_required' && run.managed.autoRecovery !== true) return 'needs_decision';
   if (run.state === 'failed' || run.state === 'budget_exhausted') return 'failed';
-  if (run.state === 'completed' || run.state === 'reported_done') return 'finished';
+  if (run.state === 'completed') return 'finished';
   return null;
 }
 
@@ -24,19 +25,18 @@ export function createStopNotifier({ emit, now = Date.now } = {}) {
   let baseline = true;
   return {
     observe(records) {
-      const present = new Set();
       for (const record of records) {
         const run = record?.run, kind = stopNotificationKind(run, now());
         const key = JSON.stringify([record.provider, record.session, run?.managed?.taskId]);
-        present.add(key);
-        if (!kind) { seen.delete(key); continue; }
-        const id = createHash('sha256').update(JSON.stringify([record.provider, record.session, run.managed.taskId, run.state, run.revision, run.reason])).digest('hex').slice(0, 32);
+        if (!kind) continue;
+        const id = createHash('sha256').update(JSON.stringify([record.provider, record.session, run.managed.taskId, run.id, kind, run.blocker, run.reason])).digest('hex').slice(0, 32);
         if (seen.get(key) === id) continue;
         seen.set(key, id);
         if (!baseline) emit({ type: 'notify', id, kind, provider: record.provider, session: record.session,
           objective: String(run.objective || '').slice(0, 200) });
       }
-      for (const key of seen.keys()) if (!present.has(key)) seen.delete(key);
+      // Temporary provider absence or a diagnostic pass is not a new stop.
+      // Retain fingerprints until a materially different outcome is observed.
       baseline = false;
     },
   };

package/src/sqm/agent-skill.js

@@ -40,7 +40,7 @@ Prefer the fixed local \`$HOME/.simy/bin/simy\` (or \`$SIMY_HOME/bin/simy\`) whe
 3. Read \`proof.json\` and require \`outcome.status\` to be \`passed\`.
 4. If either command fails, SQM is unavailable, or the proof is not passed, report the exact blocker. Do not claim SQM passed or silently bypass the requested check.
 5. Verify the proof's repository, base, HEAD and working-tree/diff identity and its bound signature with SQM tooling. Use separate artifact paths outside the diff, and rerun after bound inputs change.
-6. Include proof paths, outcome reasons, matched modules, evaluated rules and scenario statuses from \`executions\` in the PR evidence, separating blocking and advisory results. A pass with \`no_applicable_rules\`, zero scenario evaluations or advisory-only checks does not establish feature or historical incident coverage. Scenario statuses are deterministic evaluations, not browser/provider/deployed execution evidence. Retain relevant uncovered incidents and their concrete regression result or gap; do not promote incomplete delivery acceptance.
+6. Include proof paths, outcome reasons, matched modules, evaluated rules and scenario statuses from \`executions\` in the PR evidence, separating blocking and advisory results. A pass with \`no_applicable_rules\`, zero scenario evaluations or advisory-only checks does not establish feature or historical incident coverage. Scenario statuses are deterministic evaluations, not browser/provider/deployed execution evidence. Retain relevant uncovered incidents and their concrete regression result or gap; do not promote incomplete delivery acceptance. Zero coverage alone is not a Delivery Loop missing_information blocker: investigate rule applicability and available verification, and continue authorized repair or testing. Keep requested SQM acceptance unmet until it is actually satisfied; alternative tests do not substitute for it. Use an information wait only for a specific question that requires the user's answer.
 
 Do not replace SQM with an LLM review, and do not claim the check passed without reading the generated proof.
 Use existing authorization for minimal related repair and recheck; do not request another continuation after ordinary blockers are resolved. LLM judgment is the base, relevant HC-01–HC-102 lenses are supplemental, and explicit stops, irreversible actions and real permissions remain boundaries.

package/src/sqm/checkers.js

@@ -1,6 +1,6 @@
 import { isAdvisoryGuidance, advisoryGuidanceDescriptions } from './advisory-guidance.js';
 import { createHash } from "node:crypto";
-import { lstat, readFile } from "node:fs/promises";
+import { lstat, readFile, realpath } from "node:fs/promises";
 import path from "node:path";
 
 import { lintKnowledgeModule } from "./reliability.js";
@@ -307,7 +307,9 @@ function activeExceptionPatterns(module) {
 }
 
 function selectPaths(paths, globs) {
-  return paths.filter((file) => matchesAny(globs, file)).slice(0, MAX_FILES_PER_PATTERN);
+  const selected = paths.filter((file) => matchesAny(globs, file));
+  if (selected.length > MAX_FILES_PER_PATTERN) throw new Error("SQM inspection scope exceeds file limit; coverage is incomplete.");
+  return selected;
 }
 
 function matchesAny(globs, file) {
@@ -365,12 +367,16 @@ async function readText(root, relative) {
   const resolved = path.resolve(root, relative);
   if (resolved !== root && !resolved.startsWith(`${root}${path.sep}`)) throw new Error("SQM path escaped the repository root.");
   try {
+    const actualRoot = await realpath(root);
+    const actualFile = await realpath(resolved);
+    if (!actualFile.startsWith(`${actualRoot}${path.sep}`)) throw new Error("SQM path escaped the repository root.");
     const fileStat = await lstat(resolved);
-    if (!fileStat.isFile() || fileStat.isSymbolicLink()) return "";
-    const buffer = await readFile(resolved);
-    if (buffer.length > MAX_FILE_BYTES || buffer.includes(0)) return "";
+    if (!fileStat.isFile() || fileStat.isSymbolicLink()) throw new Error("Not a regular file.");
+    if (fileStat.size > MAX_FILE_BYTES) throw new Error("Unreadable text scope.");
+    const buffer = await readFile(actualFile);
+    if (buffer.length > MAX_FILE_BYTES || buffer.includes(0)) throw new Error("Unreadable text scope.");
     return buffer.toString("utf8");
   } catch {
-    return "";
+    throw new Error(`SQM could not inspect ${relative}; coverage is incomplete.`);
   }
 }

package/src/sqm/claude-plugin-update.js

@@ -1,6 +1,7 @@
-import { readFile, realpath } from "node:fs/promises";
+import { lstat, readFile, realpath } from "node:fs/promises";
 import path from "node:path";
 import { CLAUDE_MARKETPLACE, CLAUDE_PLUGIN_SELECTOR } from "./claude-plugin.js";
+import { pluginCacheMatches, repairPluginCache } from "./plugin-cache.js";
 
 export async function refreshClaudePlugin({ status, home, claudeHome, resolveExecutable, run }) {
   if (!status.claude_plugin?.installed) return { outcome: "not_enabled" };
@@ -19,21 +20,34 @@ export async function refreshClaudePlugin({ status, home, claudeHome, resolveExe
       await realpath(marketplace.path) !== await realpath(status.claude_plugin.marketplace_root)) {
     throw new Error("Enabled SIMY Claude plugin points to a different marketplace; refresh skipped.");
   }
-  const cacheCurrent = async (entry) => {
-    if (!entry?.installPath || entry.version !== status.claude_plugin.version) return false;
+  const cacheLocation = async (entry) => {
+    if (!entry?.installPath || entry.version !== status.claude_plugin.version) return null;
     const cacheRoot = await realpath(path.join(claudeHome, "plugins/cache")).catch(() => null);
-    if (!cacheRoot) return false;
+    if (!cacheRoot) return null;
     const installedPath = await realpath(entry.installPath).catch(() => null);
     const relative = installedPath && path.relative(cacheRoot, installedPath);
-    if (!relative || relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) return false;
+    if (!relative || relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) return null;
+    return installedPath;
+  };
+  const cacheCurrent = async (entry) => {
+    const installedPath = await cacheLocation(entry);
+    if (!installedPath) return false;
     try {
-      return JSON.parse(await readFile(path.join(installedPath, ".claude-plugin/plugin.json"), "utf8")).version === status.claude_plugin.version;
-    } catch (error) { if (error.code === "ENOENT" || error instanceof SyntaxError) return false; throw error; }
+      return JSON.parse(await readFile(path.join(installedPath, ".claude-plugin/plugin.json"), "utf8")).version === status.claude_plugin.version &&
+        await pluginCacheMatches(status.claude_plugin.path, installedPath);
+    } catch (error) { if (['ENOENT', 'ENOTDIR'].includes(error.code) || error instanceof SyntaxError) return false; throw error; }
   };
   if (await cacheCurrent(installed)) return { outcome: "current" };
   await run(executable, ["plugin", "marketplace", "update", CLAUDE_MARKETPLACE], options);
   await run(executable, ["plugin", "update", CLAUDE_PLUGIN_SELECTOR, "--scope", "user"], options);
-  const refreshed = (await list()).find((entry) => entry.id === CLAUDE_PLUGIN_SELECTOR && entry.scope === "user");
+  let refreshed = (await list()).find((entry) => entry.id === CLAUDE_PLUGIN_SELECTOR && entry.scope === "user");
+  if (refreshed?.enabled && !await cacheCurrent(refreshed)) {
+    const location = await cacheLocation(refreshed);
+    if (location && !(await lstat(refreshed.installPath)).isSymbolicLink()) {
+      await repairPluginCache(status.claude_plugin.path, location);
+      refreshed = (await list()).find((entry) => entry.id === CLAUDE_PLUGIN_SELECTOR && entry.scope === "user");
+    }
+  }
   if (!refreshed?.enabled || !await cacheCurrent(refreshed)) {
     throw new Error("Claude Code did not confirm the updated SIMY plugin cache; will retry.");
   }

package/src/sqm/claude-plugin.js

@@ -25,6 +25,9 @@ export async function claudePluginFiles() {
   // Claude workflow without shipping it back into Codex's skill inventory.
   files.set("skills/delivery-loop/SKILL.md", await readFile(
     new URL("../delivery-hooks/claude-workflow.md", import.meta.url), "utf8"));
+  for (const name of ["loop-kernel.mjs", "loop-kernel/index.mjs", "loop-kernel/policy.json", "loop-kernel/pin.json", "loop-kernel/outcome-review.mjs", "loop-kernel/work-frontier.mjs", "loop-kernel/task-pool.mjs"]) {
+    files.set(`hooks/${name}`, await readFile(path.join(SOURCE, "hooks", name), "utf8"));
+  }
   files.set("hooks/delivery-loop.mjs", await readFile(path.join(SOURCE, "hooks/delivery-loop.mjs"), "utf8"));
   files.set("hooks/recovery-incident.mjs", await readFile(path.join(SOURCE, "hooks/recovery-incident.mjs"), "utf8"));
   files.set("hooks/minimal-sufficient.mjs", await readFile(path.join(SOURCE, "hooks/minimal-sufficient.mjs"), "utf8"));
@@ -38,6 +41,7 @@ export async function claudePluginFiles() {
   files.set("hooks/purpose-search.mjs", await readFile(path.join(SOURCE, "hooks/purpose-search.mjs"), "utf8"));
   files.set("hooks/completion-binding.mjs", await readFile(path.join(SOURCE, "hooks/completion-binding.mjs"), "utf8"));
   files.set("hooks/consistency-handoff.mjs", await readFile(path.join(SOURCE, "hooks/consistency-handoff.mjs"), "utf8"));
+  files.set("hooks/purpose-completion-contract.mjs", await readFile(path.join(SOURCE, "hooks/purpose-completion-contract.mjs"), "utf8"));
   files.set("hooks/purpose-evidence.mjs", await readFile(path.join(SOURCE, "hooks/purpose-evidence.mjs"), "utf8"));
   files.set("hooks/user-experience.mjs", await readFile(path.join(SOURCE, "hooks/user-experience.mjs"), "utf8"));
   files.set("hooks/result-cycle.mjs", await readFile(path.join(SOURCE, "hooks/result-cycle.mjs"), "utf8"));

package/src/sqm/local-tests.js

@@ -8,8 +8,8 @@ import path from 'node:path';
 // This catalog is shipped with the CLI; a repository cannot supply shell commands.
 const profiles = {
   'delivery-loop': [
-    { id: 'stop-investigation-regressions', files: ['test/result-cycle.test.js', 'test/stop-investigation-regression.test.js', 'test/acceptance-reads.test.js', 'test/browser-recovery.test.js', 'test/browser-cdp.test.js', 'test/interaction-task.test.js', 'test/native-interaction.test.js'] },
-    { id: 'autonomous-recovery', files: ['test/autonomous-recovery.test.js', 'test/scene-reasoning.test.js', 'test/supervisor-watchdog.test.js', 'test/supervisor-handover.test.js'] },
+    { id: 'stop-investigation-regressions', files: ['test/result-cycle.test.js', 'test/delivery-result-followthrough.test.js', 'test/corrective-followup.test.js', 'test/stop-investigation-regression.test.js', 'test/acceptance-reads.test.js', 'test/browser-recovery.test.js', 'test/browser-cdp.test.js', 'test/interaction-task.test.js', 'test/native-interaction.test.js'] },
+    { id: 'autonomous-recovery', files: ['test/autonomous-recovery.test.js', 'test/scene-reasoning.test.js', 'test/supervisor-watchdog.test.js', 'test/supervisor-handover.test.js', 'test/work-frontier.test.js', 'test/legacy-hook-routing.test.js', 'test/procedure-free-review.test.js'] },
     { id: 'perspective-memory', files: ['test/perspective-memory.test.js'] },
     { id: 'optional-reasoning', files: ['test/purpose-selective-rules.test.js', 'test/purpose-evidence.test.js', 'test/purpose-rule-review.test.js'] },
     // This connected controller group now contains over 200 cases. Keep a

package/src/sqm/plugin-cache.js

@@ -0,0 +1,67 @@
+import { lstat, mkdir, readFile, readdir, rename, rm, writeFile } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+import path from 'node:path';
+
+// A matching manifest version does not prove that the cached hooks can run.
+// Compare every shipped file; provider-owned cache metadata may coexist.
+export async function pluginCacheMatches(source, cache) {
+  async function visit(sourceDirectory, cacheDirectory) {
+    const target = await lstat(cacheDirectory);
+    if (!target.isDirectory() || target.isSymbolicLink()) return false;
+    for (const entry of await readdir(sourceDirectory, { withFileTypes: true })) {
+      const from = path.join(sourceDirectory, entry.name);
+      const to = path.join(cacheDirectory, entry.name);
+      if (entry.isDirectory()) {
+        if (!await visit(from, to)) return false;
+      } else {
+        if (!entry.isFile()) return false;
+        const cached = await lstat(to);
+        if (!cached.isFile() || cached.isSymbolicLink()) return false;
+        if (!(await readFile(from)).equals(await readFile(to))) return false;
+      }
+    }
+    return true;
+  }
+  try { return await visit(source, cache); }
+  catch (error) {
+    if (['ENOENT', 'ENOTDIR'].includes(error.code)) return false;
+    throw error;
+  }
+}
+
+// Some providers skip recopying a cache whose version already matches. Restore
+// only the shipped files of an already enabled, source-verified cache. Never
+// follow links or remove provider-owned metadata. Each file replacement is atomic.
+export async function repairPluginCache(source, cache) {
+  const directory = async target => {
+    const info = await lstat(target);
+    if (!info.isDirectory() || info.isSymbolicLink()) throw new Error('Plugin cache repair requires real directories.');
+  };
+  await directory(source);
+  await directory(cache);
+  async function visit(from, to) {
+    await directory(from);
+    await directory(to);
+    for (const entry of await readdir(from, { withFileTypes: true })) {
+      const original = path.join(from, entry.name), target = path.join(to, entry.name);
+      if (entry.isSymbolicLink() || !entry.isDirectory() && !entry.isFile()) throw new Error('Plugin source contains an unsupported file.');
+      let existing;
+      try { existing = await lstat(target); } catch (error) { if (error.code !== 'ENOENT') throw error; }
+      if (existing?.isSymbolicLink()) throw new Error('Plugin cache repair refuses symbolic links.');
+      if (entry.isDirectory()) {
+        if (!existing) await mkdir(target);
+        await visit(original, target);
+      } else {
+        if (existing && !existing.isFile()) throw new Error('Plugin cache repair requires regular files.');
+        const contents = await readFile(original);
+        if (existing && contents.equals(await readFile(target))) continue;
+        const temporary = path.join(to, `.simy-repair-${randomUUID()}`);
+        try {
+          await writeFile(temporary, contents, { flag: 'wx', mode: (await lstat(original)).mode & 0o777 });
+          await rename(temporary, target);
+        } finally { await rm(temporary, { force: true }); }
+      }
+    }
+  }
+  await visit(source, cache);
+}

package/src/sqm/proof.js

@@ -75,6 +75,7 @@ export function buildProof({ organizationId, repository, bundle, minCheck, evalu
       enforcement: 'blocking', rule_results: [], scenarios: [], state_models: [], stressors: [],
       local_tests: localTests,
     }] : [])],
+    inspection_scope: sqmInspectionScope(evaluation.modules),
     findings,
     outcome: {
       status,
@@ -159,6 +160,30 @@ function taggedDigest(value) {
   return `sha256:${createHash("sha256").update(canonicalize(value), "utf8").digest("hex")}`;
 }
 
+// This scope is part of the signed proof. Static scenarios never become UI or
+// human acceptance evidence, even when the legacy enforcement outcome is passed.
+export function sqmInspectionScope(modules) {
+  const checks = modules.flatMap(module => (module.rule_results || []).map(rule => ({
+    module_id: module.module_id, rule_id: rule.rule_id, status: rule.status,
+  })));
+  return { evidence_kind: "static_check", checks, checked_count: checks.length,
+    status: checks.length === 0 ? "unconfirmed" : checks.every(check => check.status === "passed") ? "verified" : "unmet",
+    scenario_evaluations: modules.reduce((count, module) => count + (module.scenarios || []).length, 0),
+    scenario_generation: "not_observed", real_ui_test: "not_observed", human_acceptance: "not_observed" };
+}
+
+export function verifyProofScope(proof, evidence, { repository, requiredChecks, trustedKeyId } = {}) {
+  const verified = verifySignedEvidence(proof, evidence);
+  if (!trustedKeyId || verified.key_id !== trustedKeyId) throw new Error("SQM signer is not the enrolled trusted key.");
+  if (!repository?.head_commit || !sameRepositoryIdentity(proof.repository_identity, repositoryIdentity(repository))) throw new Error("SQM proof revision is stale.");
+  const scope = sqmInspectionScope(proof.executions);
+  if (canonicalize(scope) !== canonicalize(proof.inspection_scope || null)) throw new Error("SQM inspection scope is missing or inconsistent.");
+  if (!Array.isArray(requiredChecks) || !requiredChecks.length || scope.status !== "verified" ||
+      requiredChecks.some(required => !scope.checks.some(check => check.module_id === required.module_id && check.rule_id === required.rule_id && check.status === "passed"))) throw new Error("SQM required inspection coverage is incomplete.");
+  if (proof.outcome.status !== "passed") throw new Error("SQM enforcement did not pass.");
+  return { ...verified, evidence_kind: "static_check", checked_count: scope.checked_count };
+}
+
 export function localTestsFromProof(proof) {
   return proof?.executions?.find(row => row.kind === 'local_test_profile')?.local_tests || null;
 }

package/src/sqm/report.js

@@ -25,6 +25,7 @@ export function formatSqmCoverage(proof) {
   const semantic = rules.filter(rule => rule.assessment).map(rule => rule.assessment);
   if (semantic.length) lines.push(`Semantic assessments: ${semantic.filter(result => result.executed).length} executed · ${semantic.filter(result => result.outcome === 'scored').length} scored · ${semantic.filter(result => result.outcome !== 'scored').length} inconclusive. Local model judgments are advisory and do not establish independent acceptance.`);
   lines.push("Scenario evaluations are deterministic checks, not browser/provider/deployed journey evidence. Record incident coverage and delivery acceptance separately.");
+  if (proof.inspection_scope) lines.push(`Artifact/UI/human acceptance: not established by this static proof; inspection status=${proof.inspection_scope.status}.`);
   return lines.join("\n");
 }
 

package/src/sqm/workflow-onboarding.js

@@ -1,5 +1,3 @@
-import { createInterface } from "node:readline/promises";
-
 import { inspectSqmAgentSkill, installSqmAgentSkill } from "./agent-skill.js";
 
 const INSTALL_FLAG = "--install-workflows";
@@ -9,11 +7,8 @@ export async function prepareDaemonWorkflows({
   argv,
   daemon,
   daemonChild = process.env.SIMY_DAEMON_CHILD === "1",
-  stdinIsTTY = process.stdin.isTTY === true,
-  stdoutIsTTY = process.stdout.isTTY === true,
   inspect = inspectSqmAgentSkill,
   install = installSqmAgentSkill,
-  confirm = confirmWorkflowInstallation,
   logger = console.log,
   errorLogger = console.error,
 } = {}) {
@@ -42,23 +37,12 @@ export async function prepareDaemonWorkflows({
     return { outcome: "update_pending", status };
   }
 
-  if (!installRequested && (!stdinIsTTY || !stdoutIsTTY)) {
-    logger(
-      "SIMY Codex/Claude workflows are missing or outdated. Re-run in a terminal with --install-workflows to install them.",
-    );
-    return { outcome: "confirmation_unavailable", status };
-  }
-
-  const accepted = installRequested || (await confirm({ status }));
-  if (!accepted) {
-    logger("SIMY workflow installation skipped. The daemon will still start.");
-    return { outcome: "declined", status };
-  }
-
+  // Source preparation is CLI startup work, including unattended service starts.
+  // Provider plugin enablement and hook trust remain provider-owned controls.
   try {
     const installed = await install();
     logger(
-      "SIMY workflows installed. In Codex, restart, then find and install SIMY in Plugins for SQM and PR review. For the Codex Agentic Loop, run simy in a terminal and select Codex. In Claude Code, add the SIMY marketplace and install simy@simy-local before using /simy:sqm-loop or /simy:pr-review. For Claude Code Delivery Loop, review and enable SIMY hooks in /hooks, then request /simy:delivery-loop for each task. Plugin installation does not grant hook trust.",
+      "SIMY workflows installed. In Codex, restart, then find and install SIMY in Plugins. In Claude Code, add the SIMY marketplace and install simy@simy-local before using /simy:sqm-loop or /simy:pr-review. For Delivery Loop, review and enable SIMY hooks in /hooks. Delivery Loop then starts automatically on user prompts, without per-task commands. Plugin installation does not grant hook trust.",
     );
     if (installed.claude_plugin?.marketplace_root) {
       logger(`Claude Code: claude plugin marketplace add ${JSON.stringify(installed.claude_plugin.marketplace_root)}`);
@@ -71,26 +55,6 @@ export async function prepareDaemonWorkflows({
   }
 }
 
-export async function confirmWorkflowInstallation({
-  input = process.stdin,
-  output = process.stdout,
-} = {}) {
-  output.write(
-    [
-      "SIMY can install or update its Codex and Claude Code plugin sources and opt-in SQM skills.",
-      "Existing unrelated plugins and hooks will be preserved.",
-      "",
-    ].join("\n"),
-  );
-  const prompt = createInterface({ input, output });
-  try {
-    const answer = await prompt.question("Install SIMY workflows now? [y/N] ");
-    return /^(y|yes)$/i.test(answer.trim());
-  } finally {
-    prompt.close();
-  }
-}
-
 function message(error) {
   return error instanceof Error ? error.message : String(error);
 }