@awak-app/simy-cli 0.5.29 → 0.5.31

package/src/runner.js

@@ -42,7 +42,14 @@ import { LocalRunRegistry } from "./run-registry.js";
 import { webApiHeaders, webApiUrl } from "./web-api.js";
 import { normalizeGitHubRemote } from "./workspace-context.js";
 import { CLI_VERSION } from "./cli-contract.js";
+import { reviseObjective, verifyObjective } from "./orchestrator/outcome-monitor.js";
+import { hasUserOutcomeProof } from "./orchestrator/completion-contract.js";
 import { createSqmChecker } from "./sqm/index.js";
+import {
+  createWorkflowObservationSender,
+  normalizeWorkflowObservationBinding,
+} from "./workflow-observation-sender.js";
+import { saveCodingRunSnapshot } from "./coding-run-store.js";
 
 const execFileAsync = promisify(execFile);
 const MAX_LOCAL_LOG_LINES = 1_000;
@@ -73,24 +80,29 @@ const INTERRUPTED_STATES = new Set([
   "checking_pr",
   "re_instructing",
 ]);
-const RESTORABLE_STATES = new Set([...RESUMABLE_STATES, ...INTERRUPTED_STATES]);
+const RESTORABLE_STATES = new Set([...RESUMABLE_STATES, "merge_ready", ...INTERRUPTED_STATES]);
 const PR_PREPARATION_IDS = new Set(PR_PREPARATION_CHECKS.map((row) => row.id));
 
 export { LocalRunRegistry };
 
-export function createRun({ runId, request, session, apiOrigin }) {
+export function createRun({ runId, request, session, apiOrigin, localStateRoot = null }) {
   const emitter = new EventEmitter();
   const normalizedRequest = {
     ...request,
     execution_target: normalizeDesktopExecutionTarget(request?.execution_target),
     execution_device_id:
       String(request?.execution_device_id || session?.device_id || "").trim() || null,
+    workflow_observation_binding: normalizeWorkflowObservationBinding(
+      request?.workflow_observation_binding,
+      { provider: request?.backend },
+    ),
   };
   return {
     id: runId,
     request: normalizedRequest,
     session,
     apiOrigin,
+    localStateRoot,
     status: "queued",
     lastOutput: "",
     startedAt: null,
@@ -105,18 +117,31 @@ export function createRun({ runId, request, session, apiOrigin }) {
     emitter,
     pendingLedgerUpdate: null,
     ledgerUpdateRunning: false,
+    ledgerRetryTimer: null,
     snapshot: createCodingLoopSnapshot({
       runId,
       request: normalizedRequest,
       metadata: {
         local_orchestrator_version: 1,
         local_output_persisted: false,
+        ...(normalizedRequest.workflow_observation_binding
+          ? {
+              workflow_observation: {
+                status: "pending",
+                workflow_id: normalizedRequest.workflow_observation_binding.workflow_id,
+                workflow_run_id:
+                  normalizedRequest.workflow_observation_binding.workflow_run_id,
+                development_outcome: "unverified",
+                binding: normalizedRequest.workflow_observation_binding,
+              },
+            }
+          : {}),
       },
     }),
   };
 }
 
-export function restoreRun({ snapshot, session, apiOrigin, localPath = null }) {
+export function restoreRun({ snapshot, session, apiOrigin, localPath = null, localStateRoot = null }) {
   if (!snapshot || typeof snapshot !== "object" || !snapshot.charter) {
     throw new Error("Cannot restore an invalid agentic loop snapshot.");
   }
@@ -125,6 +150,7 @@ export function restoreRun({ snapshot, session, apiOrigin, localPath = null }) {
     runId: String(snapshot.id || ""),
     session,
     apiOrigin,
+    localStateRoot,
     request: {
       backend: charter.backend === "claude" ? "claude" : "codex",
       execution_target: normalizeDesktopExecutionTarget(charter.execution_target),
@@ -153,6 +179,8 @@ export function restoreRun({ snapshot, session, apiOrigin, localPath = null }) {
       require_human_approval: charter.require_human_approval !== false,
       must_not: Array.isArray(charter.must_not) ? charter.must_not : [],
       proposal_id: typeof charter.proposal_id === "string" ? charter.proposal_id : null,
+      workflow_observation_binding:
+        snapshot.metadata?.workflow_observation?.binding ?? null,
       charter_context: {
         source_charter_id: charter.id,
         audit_backend: charter.audit_backend,
@@ -188,7 +216,11 @@ export function restoreRun({ snapshot, session, apiOrigin, localPath = null }) {
     throw new Error(`Agentic loop ${run.id} is not in a restorable state.`);
   }
   const restoredFromState = INTERRUPTED_STATES.has(persistedState) ? persistedState : null;
-  const restoredState = restoredFromState ? "waiting_human" : persistedState;
+  const objectiveCheck = verifyObjective(restoredSnapshot.charter);
+  const savedGoalUnproven = (persistedState === "merge_ready" || persistedState === "pr_ready_for_review") &&
+    !hasUserOutcomeProof(restoredSnapshot.attempts?.at(-1)?.independent_audit?.coverage_review);
+  const objectiveUnverified = !objectiveCheck.valid || objectiveCheck.legacy || savedGoalUnproven;
+  const restoredState = restoredFromState || objectiveUnverified ? "waiting_human" : persistedState;
   if (restoredFromState) {
     restoredSnapshot.events = Array.isArray(restoredSnapshot.events)
       ? restoredSnapshot.events
@@ -203,9 +235,30 @@ export function restoreRun({ snapshot, session, apiOrigin, localPath = null }) {
       },
     );
   }
+  if (objectiveUnverified) {
+    restoredSnapshot.done_gate_passed = false;
+    restoredSnapshot.implementation_gate_passed = false;
+    restoredSnapshot.final_audit = {
+      passed: false,
+      summary: "The saved user objective or its outcome evidence cannot be verified after restart.",
+      findings: [{
+        code: objectiveCheck.legacy ? "OBJECTIVE_BASELINE_UNVERIFIED" :
+          !objectiveCheck.valid ? "OBJECTIVE_CONTRACT_CHANGED" : "USER_OUTCOME_UNPROVEN",
+        severity: "blocker",
+        target: savedGoalUnproven && objectiveCheck.valid && !objectiveCheck.legacy ? "user_outcome" : "objective_contract",
+        explanation: "Confirm the original user outcome and its acceptance criteria before resuming or claiming completion.",
+        repairability: "manual",
+      }],
+    };
+    appendEvent(restoredSnapshot, "waiting_human", "Saved objective requires human confirmation.", {
+      code: objectiveCheck.legacy ? "objective_baseline_unverified" :
+        !objectiveCheck.valid ? "objective_contract_changed" : "user_outcome_unproven",
+    });
+  }
 
   run.snapshot = restoredSnapshot;
   run.snapshot.state = restoredState;
+  run.snapshot.metadata = { ...run.snapshot.metadata, pr_lifecycle_state: restoredState };
   run.status = restoredState;
   run.lastOutput = restoredFromState
     ? `Local CLI restarted during ${restoredFromState}; provide guidance to continue this run.`
@@ -214,12 +267,15 @@ export function restoreRun({ snapshot, session, apiOrigin, localPath = null }) {
   run.completedAt = restoredSnapshot.updated_at || null;
   run.controlState = restoredState === "stopped" ? "stopped" : "waiting_human";
   run.restoredFromState = restoredFromState;
+  run.restoredObjectiveUnverified = objectiveUnverified;
   return run;
 }
 
 export async function publishRestoredLocalCodingRun(run) {
-  if (!run?.restoredFromState) return run?.snapshot || null;
+  if (!run?.restoredFromState && !run?.restoredObjectiveUnverified) return run?.snapshot || null;
   await updateRun(run, "waiting_human");
+  run.restoredFromState = null;
+  run.restoredObjectiveUnverified = false;
   return run.snapshot;
 }
 
@@ -236,6 +292,16 @@ export async function startLocalCodingRun(
 export async function continueLocalCodingRun(run, guidance, dependencies = {}) {
   const message = String(guidance || "").trim();
   if (!message) throw new Error("Human guidance is required.");
+  assertRunCanContinue(run);
+  run.completedAt = null;
+  run.stopRequested = false;
+  run.controlState = "running";
+  run.resumeCount += 1;
+  emitControl(run, "human_input", `Human guidance accepted: ${message}`);
+  return executeLocalCodingRun(run, dependencies, { humanGuidance: message, resume: true });
+}
+
+function assertRunCanContinue(run) {
   if (run.operation || run.child) throw new Error("The selected Agentic Loop run is still active.");
   if (!RESUMABLE_STATES.has(run.status)) {
     throw new Error("Human guidance is available only when the selected run is waiting.");
@@ -249,12 +315,6 @@ export async function continueLocalCodingRun(run, guidance, dependencies = {}) {
   if (nextAttempt > run.snapshot.charter.max_attempts) {
     throw new Error("The Agentic Loop run used its retry budget. Start a new run to continue.");
   }
-  run.completedAt = null;
-  run.stopRequested = false;
-  run.controlState = "running";
-  run.resumeCount += 1;
-  emitControl(run, "human_input", `Human guidance accepted: ${message}`);
-  return executeLocalCodingRun(run, dependencies, { humanGuidance: message, resume: true });
 }
 
 export async function increaseLocalCodingRunProviderTokenBudget(run, value) {
@@ -359,10 +419,29 @@ export async function applyLocalHumanDecision(
 ) {
   const guidance = String(message || "").trim();
   if (!guidance) throw new Error("A human decision note is required.");
+  assertRunCanContinue(run);
   const charter = run.snapshot.charter;
   if (acceptanceCriteria.length > 0) {
-    charter.acceptance_criteria = acceptanceCriteria.map(String).map((item) => item.trim()).filter(Boolean);
+    const previousCriteria = charter.acceptance_criteria;
+    const nextCriteria = acceptanceCriteria.map(String).map((item) => item.trim()).filter(Boolean);
+    if (nextCriteria.length === 0) throw new Error("At least one acceptance criterion is required.");
+    charter.acceptance_criteria = nextCriteria;
     charter.acceptance_criteria_source = "explicit";
+    if (JSON.stringify(previousCriteria) !== JSON.stringify(nextCriteria)) {
+      if (JSON.stringify(charter.completion_contract.minimum_scope) === JSON.stringify(previousCriteria)) {
+        charter.completion_contract.minimum_scope = nextCriteria;
+      }
+      charter.completion_contract.criterion_ids = nextCriteria.map((_, index) => `AC-${index + 1}`);
+      reviseObjective(charter, {
+        kind: "explicit_human_decision",
+        run_id: run.id,
+        note_sha256: executionTextSha256(guidance),
+        recorded_at: new Date().toISOString(),
+      });
+      run.snapshot.implementation_gate_passed = false;
+      run.snapshot.done_gate_passed = false;
+      run.snapshot.final_audit = null;
+    }
   }
   if (requiredChecks.length > 0) {
     charter.required_checks = requiredChecks.map(String).map((item) => item.trim()).filter(Boolean);
@@ -668,6 +747,26 @@ export async function recheckLocalCodingRun(run, { collectEvidence } = {}) {
   return run.snapshot;
 }
 
+export async function markCodingRunMonitorFailure(run, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  run.snapshot.done_gate_passed = false;
+  run.snapshot.final_audit = {
+    passed: false,
+    summary: "Background outcome recheck could not establish current completion.",
+    findings: [{
+      code: "BACKGROUND_RECHECK_UNAVAILABLE",
+      severity: "blocker",
+      target: "outcome_monitor",
+      explanation: message,
+      repairability: "auto",
+    }],
+  };
+  appendEvent(run.snapshot, "pr_ready_for_review", "Background outcome recheck requires retry.", {
+    code: "background_recheck_unavailable",
+  });
+  await updateRun(run, "pr_ready_for_review");
+}
+
 function sqmBundleEndpoint(session) {
   if (process.env.SIMY_SQM_BUNDLE_URL?.trim()) return process.env.SIMY_SQM_BUNDLE_URL.trim();
   if (!session?.api_base_url) return undefined;
@@ -680,7 +779,7 @@ function sqmEvidenceEndpoint(session) {
   return new URL("sqm/run-evidence", session.api_base_url).href;
 }
 
-async function executeProcessAttempt({
+export async function executeProcessAttempt({
   backend,
   instruction,
   repositoryPath,
@@ -698,6 +797,15 @@ async function executeProcessAttempt({
   const stderr = [];
   const tokenUsageRecords = [];
   const phase = marker === "SIMY_AUDIT_JSON:" ? "reviewer" : "executor";
+  const observationSender =
+    phase === "executor" && run.snapshot.metadata?.workflow_observation?.status !== "accepted"
+      ? createWorkflowObservationSender({
+          binding: run.request.workflow_observation_binding,
+          backend,
+          session: run.session,
+          apiOrigin: run.apiOrigin,
+        })
+      : null;
 
   return new Promise((resolve) => {
     let settled = false;
@@ -714,6 +822,7 @@ async function executeProcessAttempt({
       backend,
       stream: "stdout",
       onLine: (line) => emitOutput(run, line, { backend }),
+      onEvent: (event) => observationSender?.observe(event),
       onTerminalError: (message) => { terminalError ||= message; },
       onUsage: (usage) =>
         tokenUsageRecords.push({
@@ -740,12 +849,26 @@ async function executeProcessAttempt({
     child.stdout?.on("data", (chunk) => collect(stdout, stdoutDecoder, chunk));
     child.stderr?.on("data", (chunk) => collect(stderr, stderrDecoder, chunk));
 
-    const finish = ({ exitCode = null, error = null } = {}) => {
+    const finish = async ({ exitCode = null, error = null } = {}) => {
       if (settled) return;
       settled = true;
       stdoutDecoder.flush();
       stderrDecoder.flush();
       run.child = null;
+      if (observationSender) {
+        const observation = await observationSender.flush();
+        run.snapshot.metadata.workflow_observation = {
+          ...observation,
+          binding: run.request.workflow_observation_binding,
+        };
+        if (observation.status === "failed") {
+          emitOutput(
+            run,
+            "WorkFlow observation was not accepted; the Provider result is unchanged and development completion remains unverified.",
+            { backend },
+          );
+        }
+      }
       const rawStdout = stdout.join("");
       const assistantText = extractAssistantText(rawStdout);
       const parse =
@@ -769,8 +892,8 @@ async function executeProcessAttempt({
       });
     };
 
-    child.on("error", (error) => finish({ error: error.message }));
-    child.on("close", (code) => finish({ exitCode: code }));
+    child.on("error", (error) => void finish({ error: error.message }));
+    child.on("close", (code) => void finish({ exitCode: code }));
   });
 }
 
@@ -878,6 +1001,7 @@ function emitControl(run, state, message) {
 async function updateRun(run, state) {
   run.status = state;
   run.snapshot.state = state;
+  run.snapshot.metadata = { ...run.snapshot.metadata, pr_lifecycle_state: state };
   run.snapshot.updated_at = new Date().toISOString();
   run.completedAt = TERMINAL_STATES.has(state) ? run.snapshot.updated_at : null;
   if (state === "waiting_human" || state === "pr_ready_for_review") {
@@ -892,7 +1016,9 @@ async function updateRun(run, state) {
     run.controlState = "running";
   }
 
-  run.emitter.emit("event", { type: "run", run: toLedgerSnapshot(run.snapshot) });
+  const durableSnapshot = toLedgerSnapshot(run.snapshot);
+  if (run.localStateRoot) await saveCodingRunSnapshot(run.localStateRoot, run.snapshot);
+  run.emitter.emit("event", { type: "run", run: durableSnapshot });
   const latestEvent = run.snapshot.events.at(-1);
   run.emitter.emit("event", {
     type: "status",
@@ -916,21 +1042,34 @@ function queueLedgerUpdate(run) {
     completedAt: run.completedAt,
     snapshot: toLedgerSnapshot(run.snapshot),
   };
+  if (run.ledgerRetryTimer) return;
   if (run.ledgerUpdateRunning) return;
   run.ledgerUpdateRunning = true;
   void drainLedgerUpdates(run);
 }
 
+export function syncLocalCodingRun(run) {
+  queueLedgerUpdate(run);
+}
+
 async function drainLedgerUpdates(run) {
   try {
     while (run.pendingLedgerUpdate) {
       const update = run.pendingLedgerUpdate;
       run.pendingLedgerUpdate = null;
-      await persistRunStatus(run, update);
+      if (!(await persistRunStatus(run, update))) {
+        run.pendingLedgerUpdate ||= update;
+        run.ledgerRetryTimer = setTimeout(() => {
+          run.ledgerRetryTimer = null;
+          queueLedgerUpdate(run);
+        }, 30_000);
+        run.ledgerRetryTimer.unref?.();
+        break;
+      }
     }
   } finally {
     run.ledgerUpdateRunning = false;
-    if (run.pendingLedgerUpdate) queueLedgerUpdate(run);
+    if (run.pendingLedgerUpdate && !run.ledgerRetryTimer) queueLedgerUpdate(run);
   }
 }
 
@@ -956,9 +1095,12 @@ async function persistRunStatus(run, update) {
     });
     if (!response.ok) {
       emitOutput(run, `SIMY ledger update failed with HTTP ${response.status}.`);
+      return false;
     }
+    return true;
   } catch {
-    // The local snapshot remains authoritative while the CLI is running.
+    emitOutput(run, "SIMY ledger update unavailable; durable local record retained for retry.");
+    return false;
   }
 }
 

package/src/sqm/agent-skill.js

@@ -7,7 +7,7 @@ import { fileURLToPath } from "node:url";
 import { inspectClaudePlugin, installClaudePlugin } from "./claude-plugin.js";
 
 export const SQM_AGENT_SKILL_ID = "simy-sqm-pr-check";
-export const SQM_AGENT_SKILL_VERSION = "3.0.0";
+export const SQM_AGENT_SKILL_VERSION = "3.1.0";
 export const SIMY_CODEX_PLUGIN_ID = "simy";
 export const SIMY_CODEX_PLUGIN_VERSION = "0.1.0";
 
@@ -36,7 +36,8 @@ When opted in, before creating or proposing a pull request:
 2. Run \`simy sqm check --proof proof.json --signed-evidence proof.json.signed.json\`.
 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. Include the proof path and SQM outcome in the PR body when the check passes.
+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.
 
 Do not replace SQM with an LLM review, and do not claim the check passed without reading the generated proof.
 `;

package/src/sqm/claude-plugin.js

@@ -20,13 +20,18 @@ export async function claudePluginFiles() {
     const content = await readFile(path.join(SOURCE, relative), "utf8");
     files.set(relative, content.replaceAll("current Codex thread", "current Claude Code conversation"));
   }
+  files.set("hooks/delivery-loop.mjs", await readFile(path.join(SOURCE, "hooks/delivery-loop.mjs"), "utf8"));
   files.set("hooks/connection-reminder.mjs", await readFile(path.join(SOURCE, "hooks/connection-reminder.mjs"), "utf8"));
   const hooks = JSON.parse(await readFile(path.join(SOURCE, "hooks/hooks.json"), "utf8"));
+  delete hooks.hooks.Interrupt; // Codex-only event; Claude interruptions cannot be vetoed.
+  hooks.hooks.StopFailure = structuredClone(hooks.hooks.Stop);
+  hooks.hooks.Notification = structuredClone(hooks.hooks.PermissionRequest);
   for (const groups of Object.values(hooks.hooks)) {
     for (const group of groups) {
       for (const hook of group.hooks) {
         hook.command = hook.command.replace(/^node /, `${quoteRuntime(process.execPath)} `)
-          .replaceAll("process.env.PLUGIN_ROOT", "process.env.CLAUDE_PLUGIN_ROOT");
+          .replaceAll("process.env.PLUGIN_ROOT", "process.env.CLAUDE_PLUGIN_ROOT")
+          .replaceAll("hook.main('codex')", "hook.main('claude')");
       }
     }
   }

package/src/sqm/command.js

@@ -10,6 +10,7 @@ import { evaluateKnowledgeBundle } from "./checkers.js";
 import { runSqmCheck, runSqmMinCheck } from "./index.js";
 import { lintKnowledgeModule, summarizeReplay } from "./reliability.js";
 import { ensureSqmSession } from "./session.js";
+import { formatSqmCoverage } from "./report.js";
 
 export async function runSqmCommand(argv, { cliVersion }) {
   if (argv.includes("--help") || argv.includes("-h") || !argv.length) {
@@ -64,7 +65,9 @@ export async function runSqmCommand(argv, { cliVersion }) {
     minCheck = await runSqmMinCheck(common);
     await atomicJson(minPath, minCheck);
   }
+  if (minCheck.status === "unavailable") return printUnavailable(minCheck, argv);
   const result = await runSqmCheck({ ...common, minCheck, deviceId, signingKeyPath: option(argv, "--signing-key") || undefined });
+  if (result.status === "unavailable") return printUnavailable(result, argv);
   const proofPath = path.resolve(option(argv, "--proof") || "proof.json");
   const evidencePath = path.resolve(option(argv, "--signed-evidence") || `${proofPath}.signed.json`);
   const diagnosticsPath = path.resolve(option(argv, "--diagnostics") || `${proofPath}.diagnostics.json`);
@@ -206,8 +209,18 @@ function printMin(result, output) {
   console.log(`Result: ${output}`);
 }
 
+function printUnavailable(result, argv) {
+  if (argv.includes("--json")) console.log(JSON.stringify(result, null, 2));
+  else {
+    console.error("SQM full check: unavailable · no new proof written. Run min-check again after resolving the cause.");
+    for (const warning of result.warnings || []) console.error(`warning: ${warning}`);
+  }
+  return 2;
+}
+
 function printFull(result) {
   console.log(`SQM full check: ${result.proof.outcome.status} · ${result.findings.length} finding(s)`);
+  console.log(formatSqmCoverage(result.proof));
   console.log(`Proof ${result.proof.proof_id} (${result.proof.integrity.digest})`);
   console.log(`Per-run signature: valid · ${result.signature_verification.key_id}`);
   console.log(`Artifacts: ${result.artifacts.proof} · ${result.artifacts.signed_evidence} · ${result.artifacts.diagnostics}`);

package/src/sqm/report.js

@@ -0,0 +1,23 @@
+// Presentation only: retain the signed proof and enforcement outcome unchanged.
+export function formatSqmCoverage(proof) {
+  const modules = proof.executions;
+  const rules = modules.flatMap(module => module.rule_results);
+  const scenarios = modules.flatMap(module => module.scenarios);
+  const blocking = modules.filter(module => module.enforcement === "blocking").length;
+  const advisory = modules.filter(module => module.enforcement === "advisory").length;
+  const statusCounts = new Map();
+  for (const scenario of scenarios) {
+    statusCounts.set(scenario.status, (statusCounts.get(scenario.status) || 0) + 1);
+  }
+  const lines = [
+    `SQM scope: ${modules.length} module(s) · ${rules.length} rule(s) · ${scenarios.length} scenario evaluation(s)`,
+    `Enforcement: ${blocking} blocking module(s) · ${advisory} advisory module(s)`,
+  ];
+  if (scenarios.length) lines.push(`Scenario evaluations: ${[...statusCounts].map(([status, count]) => `${status}=${count}`).join(" · ")}`);
+  if (proof.outcome.reasons.length) lines.push(`Outcome reasons: ${proof.outcome.reasons.join(", ")}`);
+  if (!modules.length) lines.push("No applicable rules: this result does not establish feature or historical incident coverage.");
+  else if (!scenarios.length) lines.push("No scenario evaluations: rule results alone do not establish scenario coverage.");
+  if (modules.length && !blocking) lines.push("Advisory-only scope: findings do not block this outcome.");
+  lines.push("Scenario evaluations are deterministic checks, not browser/provider/deployed journey evidence. Record incident coverage and delivery acceptance separately.");
+  return lines.join("\n");
+}

package/src/sqm/workflow-onboarding.js

@@ -58,7 +58,7 @@ export async function prepareDaemonWorkflows({
   try {
     const installed = await install();
     logger(
-      "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.",
+      "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, then request /simy:delivery-loop for each task. 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)}`);