@awak-app/simy-cli 0.7.15 → 0.7.17

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/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,7 +41,10 @@ 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"));
   files.set("hooks/scene-reasoning.mjs", await readFile(path.join(SOURCE, "hooks/scene-reasoning.mjs"), "utf8"));
   files.set("hooks/purpose-cycle.mjs", await readFile(path.join(SOURCE, "hooks/purpose-cycle.mjs"), "utf8"));
   files.set("hooks/purpose-rule-policy.mjs", await readFile(path.join(SOURCE, "hooks/purpose-rule-policy.mjs"), "utf8"));

package/src/sqm/local-tests.js

@@ -8,7 +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: 'autonomous-recovery', files: ['test/autonomous-recovery.test.js', 'test/scene-reasoning.test.js', 'test/supervisor-watchdog.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);
 }

package/src/sqm/workflow-update.js

@@ -7,6 +7,7 @@ import { pinnedWorkflowSource } from "../delivery-hooks/local-runtime.js";
 
 import { runProviderCommand } from "./provider-command.js";
 import { refreshClaudePlugin } from "./claude-plugin-update.js";
+import { pluginCacheMatches } from "./plugin-cache.js";
 
 import { resolveBackendExecutable } from "../backend-executable.js";
 import { inspectSqmAgentSkill, installSqmAgentSkill, retireLegacySqmGate } from "./agent-skill.js";
@@ -14,13 +15,18 @@ import { inspectSqmAgentSkill, installSqmAgentSkill, retireLegacySqmGate } from
 
 const CHECK_INTERVAL_MS = 60 * 60 * 1000;
 
-export function startWorkflowUpdates({ enabled, sync = syncInstalledWorkflows, intervalMs = CHECK_INTERVAL_MS,
+export function startWorkflowUpdates({ enabled, installMissing = true, sync = syncInstalledWorkflows, intervalMs = CHECK_INTERVAL_MS,
   errorLogger = console.error } = {}) {
   let pending;
   let stopped = !enabled;
   const check = () => {
     if (stopped || pending) return;
-    pending = Promise.resolve().then(sync).catch((error) => {
+    pending = Promise.resolve().then(() => sync({ installMissing })).then((result) => {
+      if (result?.refreshPending) {
+        const details = result.refreshFailures?.map(({ provider, message }) => `${provider}: ${message}`).join('; ');
+        errorLogger(`SIMY workflow sources are prepared, but plugin cache refresh is pending; will retry later.${details ? ` ${details}` : ''}`);
+      }
+    }).catch((error) => {
       errorLogger(`SIMY workflow update failed; will retry later: ${error.message}`);
     }).finally(() => { pending = null; });
   };
@@ -79,16 +85,20 @@ export async function syncInstalledWorkflows({ home = homedir(), installMissing
     if (platforms.length) status = await install({ home, platforms });
     const results = {};
     const failures = [];
+    const refreshFailures = [];
     for (const [provider, refresh] of [
       ["codex", () => refreshCodexPlugin({ status, home, codexHome, resolveExecutable, run })],
       ["claude", () => refreshClaudePlugin({ status, home, claudeHome, resolveExecutable, run })],
     ]) {
       try { results[provider] = await refresh(); }
-      catch (error) { failures.push(error); }
+      catch (error) {
+        failures.push(error);
+        refreshFailures.push({ provider, message: error.message });
+      }
     }
     // Explicit desktop setup prepares both sources even when a provider CLI is
     // absent. Cache refresh remains retryable; no provider is enabled here.
-    if (failures.length && installMissing) return { outcome: "prepared", refreshPending: true };
+    if (failures.length && installMissing) return { outcome: "prepared", refreshPending: true, refreshFailures, providers: results };
     if (failures.length) throw new AggregateError(failures, failures.map((error) => error.message).join("; "));
     if (results.claude.outcome === "updated") return { ...results.claude, providers: results };
     if (results.codex.outcome !== "not_enabled") return results.codex;
@@ -123,8 +133,9 @@ async function refreshCodexPlugin({ status, home, codexHome, resolveExecutable,
     const cacheManifest = path.join(codexHome, "plugins", "cache", marketplace.name,
       "simy", status.codex_plugin.version, ".codex-plugin", "plugin.json");
     const cacheCurrent = async () => {
-      try { return JSON.parse(await readFile(cacheManifest, "utf8")).version === status.codex_plugin.version; }
-      catch (error) { if (error.code === "ENOENT" || error instanceof SyntaxError) return false; throw error; }
+      try { return JSON.parse(await readFile(cacheManifest, "utf8")).version === status.codex_plugin.version &&
+        await pluginCacheMatches(status.codex_plugin.path, path.dirname(path.dirname(cacheManifest))); }
+      catch (error) { if (['ENOENT', 'ENOTDIR'].includes(error.code) || error instanceof SyntaxError) return false; throw error; }
     };
     if (installed.version === status.codex_plugin.version && await cacheCurrent()) return { outcome: "current" };
     await run(executable, ["plugin", "add", selector, "--json"], options);

package/src/startup-preflight.js

@@ -1,5 +1,3 @@
-import { createCodingLoopSnapshot } from "./orchestrator/contract.js";
-import { validateCharter } from "./orchestrator/charter-validation.js";
 
 // Reuse the execution charter rather than inventing a second approval policy.
 // These checks inspect local metadata only; model access requires real dispatch.
@@ -9,28 +7,12 @@ export function startupRequirementChecks(request = {}) {
     action: { id: "review_model_access", type: "inspect_provider", label: "Review provider and model settings" } }];
   if (!String(request.requirement || "").trim()) {
     checks.push({ key: "task_requirements", status: "unknown", blocking: false,
-      summary: "Environment check only. Supply the task requirement to check acceptance criteria and design approval.",
+      summary: "Environment check only. Supply the task requirement to identify the requested outcome.",
       action: { id: "provide_requirement", type: "edit_requirements", label: "Provide task requirements" } });
     return checks;
   }
-  const { charter } = createCodingLoopSnapshot({ runId: "preflight", request });
-  const findings = validateCharter(charter);
-  for (const [key, code, passed, actionId, label] of [
-    ["acceptance_criteria", "EXPLICIT_ACCEPTANCE_CRITERIA_REQUIRED", "Acceptance criteria satisfy the task risk policy.", "provide_acceptance_criteria", "Provide explicit acceptance criteria"],
-    ["design_review", "DESIGN_REVIEW_REQUIRED", "Design approval satisfies the task risk policy.", "approve_design", "Provide design review and approval evidence"],
-    ["required_checks", "REQUIRED_CI_CHECKS_MISSING", "Required checks satisfy the task risk policy.", "provide_required_checks", "Provide CI and security check names"],
-  ]) {
-    const finding = findings.find(item => item.code === code);
-    checks.push({ key, status: finding ? "failed" : "passed", blocking: Boolean(finding),
-      summary: finding?.explanation || passed,
-      ...(finding ? { code, action: { id: actionId, type: "edit_requirements", label } } : {}) });
-  }
-  checks.push({ key: "assurance_selection", status: "unknown", blocking: false,
-    summary: "The executor must verify the five-level comparison and user selection in existing decision evidence before material implementation.",
-    action: { id: "review_assurance_selection", type: "review_decision_evidence", label: "Review assurance level and selection evidence" } });
   checks.push({ key: "external_dependencies", status: "unknown", blocking: false,
-    summary: "Confirm test accounts, external resources and permissions required by the acceptance criteria. Local readiness does not certify Cloud entitlement.",
-    action: { id: "confirm_external_dependencies", type: "edit_requirements", label: "Confirm external inputs and permissions" } });
+    summary: "Check external inputs and permissions when the requested action needs them. Local readiness does not certify Cloud entitlement." });
   return checks;
 }
 

package/src/team-status-fence-store.js

@@ -0,0 +1,32 @@
+import { mkdir, open, readFile, rename, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+// Only an opaque device/account/org/thread digest and a pending OFF version
+// persist. Conversation text and provider identifiers never enter this store.
+export function createTeamStatusFenceStore(root) {
+  const directory = join(root, 'team-status-revocations');
+  const path = key => {
+    if (!/^[a-f0-9]{64}$/.test(key)) throw new Error('Invalid revocation scope');
+    return join(directory, `${key}.json`);
+  };
+  return {
+    async read(key) {
+      let raw;
+      try { raw = await readFile(path(key), 'utf8'); } catch (error) { if (error.code === 'ENOENT') return null; throw error; }
+      const value = JSON.parse(raw);
+      if (value?.schemaVersion !== 1 || !Number.isSafeInteger(value.expectedVersion) || value.expectedVersion < 0) throw new Error('Invalid revocation fence');
+      return { expectedVersion: value.expectedVersion };
+    },
+    async write(key, expectedVersion) {
+      await mkdir(directory, { recursive: true, mode: 0o700 });
+      const destination = path(key), temporary = `${destination}.${randomUUID()}.tmp`;
+      try {
+        const handle = await open(temporary, 'wx', 0o600);
+        try { await handle.writeFile(JSON.stringify({schemaVersion:1,expectedVersion})); await handle.sync(); } finally { await handle.close(); }
+        await rename(temporary, destination);
+        if (process.platform !== 'win32') { const parent = await open(directory, 'r'); try { await parent.sync(); } finally { await parent.close(); } }
+      } finally { await rm(temporary, {force:true}); }
+    },
+    async clear(key) { await rm(path(key), {force:true}); },
+  };
+}