@awak-app/simy-cli 0.5.29 → 0.5.31

package/README.md

@@ -76,11 +76,13 @@ marketplace still points to SIMY’s generated local source. Plugin versions inc
 receive a fresh cache. Use a new Codex task to pick up updated skills; running
 tasks are not restarted. Missing or disabled plugins are not enabled automatically.
 Failed refreshes retry on the next check without blocking daemon startup.
-Delivery Loop is a SIMY Web/CLI runtime workflow, not a local Codex skill.
-The plugin ships only SQM and PR review. Updating to this release removes the
-previously bundled Delivery Loop from managed plugin sources and refreshes the
-enabled cache. Older running CLI releases can restore their old bundled skill
-until upgraded; deleting a local skill alone does not change their updater.
+The plugin also provides an opt-in, hook-based Delivery Loop in the user's existing
+Codex or Claude Code conversation. Install the plugin, review and enable SIMY hooks
+with `/hooks`, then request `/simy:delivery-loop` for the task. Installing or updating
+the plugin never approves hook trust. SIMY's Connection & settings panel links to
+Codex settings and the Claude setup guide and shows observed hook activity and
+blocked/recovery states. The legacy `agentic-delivery-loop` skill remains retired;
+the Web/CLI executor is unchanged. See [hook delivery behavior and limits](docs/delivery-hooks.md).
 `--no-auto-update` or `SIMY_AUTO_UPDATE=0` disables these background updates too;
 `--no-workflow-prompt` only suppresses the initial installation prompt.
 
@@ -342,6 +344,14 @@ SQM deliberately has two identity-bound stages:
    state transitions, invariants, stress/strength expectations, and scenarios,
    writes `proof.json`, and signs that proof with the local device identity.
 
+The full-check summary reports applicable modules, evaluated rules, scenario
+statuses and blocking/advisory scope. `passed` with `no_applicable_rules` or zero
+scenario evaluations does not establish feature or historical incident coverage.
+Scenario statuses come from deterministic rule evaluation, not browser/provider
+execution. Keep concrete regression and delivery acceptance evidence separately.
+If knowledge is unavailable, the command returns exit 2 with the service cause
+and writes no new proof; any older artifact is not evidence for that attempt.
+
 Normal runs do not require a separate sync command: the CLI
 uses a verified local cache and revalidates it with TTL and ETag semantics.
 The Agentic Loop runs min-check after each code modification and the full check

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awak-app/simy-cli",
-  "version": "0.5.29",
+  "version": "0.5.31",
   "description": "Local SIMY executor for non-coding Local Tasks and Agentic Loop runs.",
   "type": "module",
   "bin": {
@@ -38,9 +38,10 @@
     "test:e2e:console:fullstack": "node ./scripts/fullstack-cli-smoke.js",
     "check": "npm run check:auto-update && node --check ./src/desktop-executor.js && node --check ./src/local-task.js && node --check ./scripts/desktop-executor-e2e.js && node --check ./scripts/pre-guardrail-e2e.js && node --check ./scripts/fixtures/fake-desktop-provider.js && npm run check:syntax && npm run check:real-provider-syntax && npm test && npm run check:package",
     "check:auto-update": "node --check ./src/auto-update.js && node --check ./scripts/auto-update-e2e.js && npm run check:sqm",
+    "check:workflow-observation-sender": "node --check ./src/workflow-observation-sender.js",
     "check:sqm": "node --check ./src/sqm/canonical.js && node --check ./src/sqm/validation.js && node --check ./src/sqm/reliability.js && node --check ./src/sqm/repository.js && node --check ./src/sqm/checkers.js && node --check ./src/sqm/bundle-store.js && node --check ./src/sqm/proof.js && node --check ./src/sqm/evidence-client.js && node --check ./src/sqm/session.js && node --check ./src/sqm/index.js && node --check ./src/sqm/command.js && node --check ./src/sqm/agent-skill.js && node --check ./src/sqm/workflow-onboarding.js && node --check ./src/sqm/workflow-update.js && node --check ./src/sqm/review-worker.js && node --check ./scripts/sqm-complete-loop-e2e.js && node --check ./scripts/sqm-local-review-e2e.js",
     "check:real-provider-syntax": "node --check ./scripts/real-codex-probe.js && node --check ./scripts/real-claude-probe.js && node --check ./scripts/real-provider-console-fixture.js && node --check ./scripts/real-provider-console-e2e.js && node --check ./scripts/claude-parity-runtime-e2e.js && node --check ./scripts/claude-plugin-runtime-e2e.js",
-    "check:syntax": "node --check ./src/index.js && node --check ./src/install-update.js && node --check ./src/agent.js && node --check ./src/connection-discovery.js && node --check ./src/codex-plugins/simy/hooks/connection-reminder.mjs && node --check ./src/browser.js && node --check ./src/web-api.js && node --check ./src/durable-local-task-worker.js && node --check ./src/durable-local-task-steps-contract.js && node --check ./src/bounded-local-task-subtasks-contract.js && node --check ./src/bounded-local-task-subtask-pool.js && node --check ./src/local-task-artifact-contract.js && node --check ./src/execution-capability-contract.js && node --check ./src/shutdown.js && node --check ./src/run-registry.js && node --check ./src/direct-executor.js && node --check ./src/execution-guardrail.js && node --check ./src/backend-executable.js && node --check ./src/provider-stream.js && node --check ./src/console/index.js && node --check ./src/console/app.js && node --check ./src/console/commands.js && node --check ./src/local-attachments.js && node --check ./src/repository-inventory.js && node --check ./src/session-store.js && node --check ./src/web-origin.js && node --check ./src/workspace-context.js && node --check ./src/orchestrator/index.js && node --check ./src/orchestrator/shared.js && node --check ./src/orchestrator/recovery.js && node --check ./src/orchestrator/risk.js && node --check ./src/orchestrator/contract.js && node --check ./src/orchestrator/completion-contract.js && node --check ./src/orchestrator/pr-preparation.js && node --check ./src/orchestrator/minimum-completion.js && node --check ./src/orchestrator/delivery/scripts/check-minimum-completion.mjs && node --check ./src/orchestrator/instruction.js && node --check ./src/orchestrator/problem-solving.js && node --check ./src/orchestrator/budget.js && node --check ./src/orchestrator/execution-io.js && node --check ./src/orchestrator/presentation.js && node --check ./src/orchestrator/result.js && node --check ./src/orchestrator/retry.js && node --check ./src/orchestrator/evidence.js && node --check ./src/orchestrator/independent-audit.js && node --check ./src/orchestrator/audit.js && node --check ./src/orchestrator/loop.js && node --check ./src/runner.js && node --check ./scripts/fixtures/completion-contract-fixture.js && node --check ./scripts/fixtures/fake-coding-backend.js && node --check ./scripts/e2e-terminal-evidence.js && node --check ./scripts/audit-gate-e2e.js && node --check ./scripts/completion-contract-e2e.js && node --check ./scripts/retry-circuit-e2e.js && node --check ./scripts/follow-up-charter-e2e.js && node --check ./scripts/task-routing-e2e.js && node --check ./scripts/executor-version-preflight-e2e.js && node --check ./scripts/blocked-recovery-e2e.js && node --check ./scripts/process-localization-e2e.js && node --check ./scripts/hypothesis-retries-e2e.js && node --check ./scripts/budget-enforcement-e2e.js && node --check ./scripts/local-task-default-workspace-e2e.js && node --check ./scripts/local-task-idempotency-e2e.js && node --check ./scripts/console-e2e-fixture.js && node --check ./scripts/console-e2e.js && node --check ./scripts/console-recovery-e2e-fixture.js && node --check ./scripts/console-recovery-e2e.js && node --check ./scripts/real-provider-console-fixture.js && node --check ./scripts/real-provider-console-e2e.js && node --check ./scripts/fullstack-cli-smoke.js && node --check ./scripts/check-package-contents.js",
+    "check:syntax": "node --check ./src/index.js && node --check ./src/install-update.js && node --check ./src/agent.js && node --check ./src/connection-discovery.js && node --check ./src/codex-plugins/simy/hooks/connection-reminder.mjs && node --check ./src/browser.js && node --check ./src/web-api.js && node --check ./src/durable-local-task-worker.js && node --check ./src/durable-local-task-steps-contract.js && node --check ./src/bounded-local-task-subtasks-contract.js && node --check ./src/bounded-local-task-subtask-pool.js && node --check ./src/local-task-artifact-contract.js && node --check ./src/execution-capability-contract.js && node --check ./src/shutdown.js && node --check ./src/run-registry.js && node --check ./src/direct-executor.js && node --check ./src/execution-guardrail.js && node --check ./src/backend-executable.js && node --check ./src/provider-stream.js && node --check ./src/console/index.js && node --check ./src/console/app.js && node --check ./src/console/commands.js && node --check ./src/local-attachments.js && node --check ./src/repository-inventory.js && node --check ./src/session-store.js && node --check ./src/web-origin.js && node --check ./src/workspace-context.js && node --check ./src/orchestrator/index.js && node --check ./src/orchestrator/shared.js && node --check ./src/orchestrator/recovery.js && node --check ./src/orchestrator/risk.js && node --check ./src/orchestrator/contract.js && node --check ./src/orchestrator/completion-contract.js && node --check ./src/orchestrator/pr-preparation.js && node --check ./src/orchestrator/minimum-completion.js && node --check ./src/orchestrator/delivery/scripts/check-minimum-completion.mjs && node --check ./src/orchestrator/instruction.js && node --check ./src/orchestrator/problem-solving.js && node --check ./src/orchestrator/budget.js && node --check ./src/orchestrator/execution-io.js && node --check ./src/orchestrator/presentation.js && node --check ./src/orchestrator/result.js && node --check ./src/orchestrator/retry.js && node --check ./src/orchestrator/evidence.js && node --check ./src/orchestrator/independent-audit.js && node --check ./src/orchestrator/audit.js && node --check ./src/orchestrator/loop.js && node --check ./src/runner.js && node --check ./src/coding-run-store.js && node --check ./scripts/fixtures/completion-contract-fixture.js && node --check ./scripts/fixtures/fake-coding-backend.js && node --check ./scripts/e2e-terminal-evidence.js && node --check ./scripts/audit-gate-e2e.js && node --check ./scripts/completion-contract-e2e.js && node --check ./scripts/retry-circuit-e2e.js && node --check ./scripts/follow-up-charter-e2e.js && node --check ./scripts/task-routing-e2e.js && node --check ./scripts/executor-version-preflight-e2e.js && node --check ./scripts/blocked-recovery-e2e.js && node --check ./scripts/process-localization-e2e.js && node --check ./scripts/hypothesis-retries-e2e.js && node --check ./scripts/budget-enforcement-e2e.js && node --check ./scripts/local-task-default-workspace-e2e.js && node --check ./scripts/local-task-idempotency-e2e.js && node --check ./scripts/console-e2e-fixture.js && node --check ./scripts/console-e2e.js && node --check ./scripts/console-recovery-e2e-fixture.js && node --check ./scripts/console-recovery-e2e.js && node --check ./scripts/real-provider-console-fixture.js && node --check ./scripts/real-provider-console-e2e.js && node --check ./scripts/fullstack-cli-smoke.js && node --check ./scripts/check-package-contents.js && node --check ./src/codex-plugins/simy/hooks/delivery-loop.mjs && node --check ./src/delivery-hooks/command.js && node --check ./src/delivery-hooks/desktop.js",
     "check:package": "node ./scripts/check-package-contents.js",
     "build:macos-installer:dev": "bash packaging/build-macos-arm64.sh --unsigned-dev",
     "build:macos-installer": "bash packaging/build-macos-arm64.sh --production",

package/src/agent.js

@@ -10,6 +10,7 @@ import {
   createRun,
   increaseLocalCodingRunProviderTokenBudget,
   LocalRunRegistry,
+  markCodingRunMonitorFailure,
   isLocalRepositoryApprovalPending,
   pauseLocalCodingRun,
   queueLocalCodingGuidance,
@@ -19,10 +20,12 @@ import {
   restoreRun,
   resumeLocalCodingRun,
   startLocalCodingRun,
+  syncLocalCodingRun,
   stopLocalCodingRun,
   toCompatibleCodingLoopState,
   toLedgerSnapshot,
 } from "./runner.js";
+import { codingRunsRoot, loadCodingRunSnapshots, saveCodingRunSnapshot } from "./coding-run-store.js";
 import {
   expiresAtFromNow,
   isSessionValid,
@@ -92,6 +95,7 @@ import {
   classifyExecutionRequirement,
   EXECUTION_GUARDRAIL_POLICY_VERSION,
 } from "./execution-guardrail.js";
+import { normalizeWorkflowObservationBinding } from "./workflow-observation-sender.js";
 import {
   createLocalTask,
   createLocalTaskId,
@@ -134,6 +138,7 @@ import {
 } from "./connection-discovery.js";
 
 const DEVICE_HEARTBEAT_INTERVAL_MS = 20_000;
+const CODING_RUN_MONITOR_INTERVAL_MS = 5 * 60_000;
 
 export async function startAgent({
   requestedPort = 0,
@@ -148,6 +153,7 @@ export async function startAgent({
 } = {}) {
   const apiOrigin = resolveWebOrigin(webOrigin);
   const registry = new LocalRunRegistry();
+  const codingRunStateRoot = codingRunsRoot(sessionRoot);
   const directRegistry = new DirectTaskRegistry();
   const localTaskRegistry = new LocalTaskRegistry();
   const taskStorageRoot = localTasksRoot(
@@ -217,6 +223,8 @@ export async function startAgent({
   let port = requestedPort;
   let heartbeatTimer = null;
   let heartbeatInFlight = null;
+  let codingRunMonitorTimer = null;
+  let codingRunMonitorInFlight = null;
   let shuttingDown = false;
   const notifyDesktopStatusChange = () => {
     if (shuttingDown) return;
@@ -296,6 +304,14 @@ export async function startAgent({
     return loginUrl.toString();
   };
 
+  const publishOrSyncRestoredRun = async (run) => {
+    if (run.restoredFromState || run.restoredObjectiveUnverified) {
+      await publishRestoredLocalCodingRun(run);
+    } else {
+      syncLocalCodingRun(run);
+    }
+  };
+
   const restoreRemoteRuns = async () => {
     if (shuttingDown || !isSessionValid(session, Date.now(), apiOrigin) || !session?.device_id) return;
     const snapshots = dependencies.listRemoteRuns
@@ -309,24 +325,113 @@ export async function startAgent({
           apiBaseUrl: session.api_base_url,
           token: session.token,
         });
+    const remoteIds = new Set();
     let restored = false;
     for (const snapshot of snapshots) {
       if (shuttingDown) return;
-      if (!snapshot?.id || registry.has(snapshot.id)) continue;
+      if (!snapshot?.id) continue;
+      remoteIds.add(snapshot.id);
+      if (registry.has(snapshot.id)) {
+        const localRun = registry.get(snapshot.id);
+        localRun.session = session;
+        localRun.apiOrigin = apiOrigin;
+        const remoteTime = Date.parse(snapshot.updated_at || "") || 0;
+        const localTime = Date.parse(localRun.snapshot.updated_at || "") || 0;
+        if (remoteTime > localTime) {
+          const repository = findRepository(repositoryInventory, snapshot.charter?.repository);
+          const remoteRun = restoreRun({
+            snapshot, session, apiOrigin,
+            localPath: repository?.local_path || null,
+            localStateRoot: codingRunStateRoot,
+          });
+          Object.assign(localRun, {
+            request: remoteRun.request,
+            status: remoteRun.status,
+            snapshot: remoteRun.snapshot,
+            controlState: remoteRun.controlState,
+            completedAt: remoteRun.completedAt,
+            restoredFromState: remoteRun.restoredFromState,
+            restoredObjectiveUnverified: remoteRun.restoredObjectiveUnverified,
+          });
+          await saveCodingRunSnapshot(codingRunStateRoot, localRun.snapshot);
+          await publishRestoredLocalCodingRun(localRun);
+        } else {
+          await publishOrSyncRestoredRun(localRun);
+        }
+        continue;
+      }
       const repository = findRepository(repositoryInventory, snapshot.charter?.repository);
       const restoredRun = restoreRun({
         snapshot,
         session,
         apiOrigin,
         localPath: repository?.local_path || null,
+        localStateRoot: codingRunStateRoot,
       });
       registry.create(restoredRun);
       restored = true;
       await publishRestoredLocalCodingRun(restoredRun);
     }
+    for (const localRun of registry.list()) {
+      if (!remoteIds.has(localRun.id)) await publishOrSyncRestoredRun(localRun);
+    }
     if (restored) notifyDesktopStatusChange();
   };
 
+  const restoreLocalCodingRuns = async () => {
+    const { snapshots, errors } = await loadCodingRunSnapshots(codingRunStateRoot);
+    for (const error of errors) {
+      reportStartupConnectionError(new Error(`Coding run ${error.id}: ${error.message}`), quiet);
+    }
+    for (const snapshot of snapshots) {
+      const boundDevice = snapshot?.metadata?.execution_device_id;
+      if (boundDevice && boundDevice !== session?.device_id) continue;
+      if (registry.has(snapshot.id)) {
+        const existing = registry.get(snapshot.id);
+        existing.session = session;
+        existing.apiOrigin = apiOrigin;
+        continue;
+      }
+      try {
+        const repository = findRepository(repositoryInventory, snapshot.charter?.repository);
+        const run = restoreRun({
+          snapshot, session, apiOrigin,
+          localPath: repository?.local_path || null,
+          localStateRoot: codingRunStateRoot,
+        });
+        // Keep the persisted timestamp until the Web ledger has been compared.
+        // Publishing recovery here would make an older local record look newest.
+        registry.create(run);
+      } catch (error) {
+        reportStartupConnectionError(error, quiet);
+      }
+    }
+  };
+
+  const monitorCodingRuns = () => {
+    if (!daemon || !isSessionValid(session, Date.now(), apiOrigin)) return Promise.resolve();
+    if (codingRunMonitorInFlight) return codingRunMonitorInFlight;
+    codingRunMonitorInFlight = (async () => {
+      for (const run of registry.list()) {
+        if (!["pr_ready_for_review", "merge_ready"].includes(run.status) || run.operation || run.child) continue;
+        try {
+          await (dependencies.recheckCodingRun || recheckLocalCodingRun)(run);
+        } catch (error) {
+          await markCodingRunMonitorFailure(run, error);
+        }
+      }
+    })().finally(() => { codingRunMonitorInFlight = null; });
+    return codingRunMonitorInFlight;
+  };
+
+  const startCodingRunMonitor = () => {
+    if (!daemon || codingRunMonitorTimer) return;
+    codingRunMonitorTimer = setInterval(() => {
+      void monitorCodingRuns().catch((error) => reportStartupConnectionError(error, quiet));
+    }, dependencies.codingRunMonitorIntervalMs || CODING_RUN_MONITOR_INTERVAL_MS);
+    codingRunMonitorTimer.unref();
+  };
+
   const heartbeat = () => {
     if (shuttingDown || !isSessionValid(session, Date.now(), apiOrigin)) return Promise.resolve(false);
     if (heartbeatInFlight) return heartbeatInFlight;
@@ -406,7 +511,9 @@ export async function startAgent({
       reportHeartbeatError(error, quiet);
     }
     try {
+      await restoreLocalCodingRuns();
       await restoreRemoteRuns();
+      startCodingRunMonitor();
     } catch (error) {
       reportStartupConnectionError(error, quiet);
     }
@@ -966,6 +1073,19 @@ export async function startAgent({
           }
           throw error;
         }
+        let workflowObservationBinding;
+        try {
+          workflowObservationBinding = normalizeWorkflowObservationBinding(
+            body.workflow_observation_binding,
+            { provider: body.backend },
+          );
+        } catch (error) {
+          json(res, 400, {
+            error: error instanceof Error ? error.message : "WorkFlow observation binding is invalid.",
+            code: "workflow_observation_binding_invalid",
+          });
+          return;
+        }
         let requestFingerprint;
         try {
           requestFingerprint = createLocalTaskRequestFingerprint({
@@ -981,6 +1101,7 @@ export async function startAgent({
             timeoutMs: body.timeout_ms,
             attachmentManifest: preparedAttachments,
             scenarioPack,
+            workflowObservationBinding,
           });
           hashLocalTaskIdempotencyKey(idempotencyKey);
         } catch (error) {
@@ -1105,12 +1226,15 @@ export async function startAgent({
             timeoutMs: body.timeout_ms,
             idempotencyKeyHash: hashLocalTaskIdempotencyKey(idempotencyKey),
             requestFingerprint,
+            workflowObservationBinding,
           });
           await persistLocalTask(task);
           localTaskRegistry.create(task);
           requestClaim.complete(task);
           requestClaimCompleted = true;
-          const runLocalTask = dependencies.runLocalTask || startLocalTask;
+          const runLocalTask =
+            dependencies.runLocalTask ||
+            ((localTask) => startLocalTask(localTask, { session, apiOrigin }));
           task.operation_promise = Promise.resolve(runLocalTask(task))
             .catch(async (error) => {
               task.status = "failed";
@@ -1338,6 +1462,19 @@ export async function startAgent({
           return;
         }
         const indexedRepository = await ensureRepositoryIndexed(body.repository);
+        let workflowObservationBinding;
+        try {
+          workflowObservationBinding = normalizeWorkflowObservationBinding(
+            body.workflow_observation_binding,
+            { provider: body.backend },
+          );
+        } catch (error) {
+          json(res, 400, {
+            error: error instanceof Error ? error.message : "WorkFlow observation binding is invalid.",
+            code: "workflow_observation_binding_invalid",
+          });
+          return;
+        }
         const run = createRun({
           runId,
           request: {
@@ -1379,6 +1516,7 @@ export async function startAgent({
               typeof body.design_review_url === "string" ? body.design_review_url : "",
             must_not: Array.isArray(body.must_not) ? body.must_not : [],
             proposal_id: typeof body.proposal_id === "string" ? body.proposal_id : null,
+            workflow_observation_binding: workflowObservationBinding,
             charter_context:
               body.charter_context &&
               typeof body.charter_context === "object" &&
@@ -1389,8 +1527,10 @@ export async function startAgent({
           },
           session,
           apiOrigin,
+          localStateRoot: codingRunStateRoot,
         });
         try {
+          await saveCodingRunSnapshot(codingRunStateRoot, run.snapshot);
           registry.create(run);
         } catch (error) {
           await cleanupRunAttachments(stagedAttachments);
@@ -1678,8 +1818,10 @@ export async function startAgent({
       await refreshAuthorizedRepositoryInventory();
       if (shuttingDown) return;
       await heartbeat();
+      await restoreLocalCodingRuns();
       if (shuttingDown) return;
       await restoreRemoteRuns();
+      startCodingRunMonitor();
     } catch (error) {
       reportStartupConnectionError(error, quiet);
     }
@@ -1703,6 +1845,8 @@ export async function startAgent({
     shuttingDown = true;
     shutdownPromise = (async () => {
       if (heartbeatTimer) clearInterval(heartbeatTimer);
+      if (codingRunMonitorTimer) clearInterval(codingRunMonitorTimer);
+      if (codingRunMonitorInFlight) await codingRunMonitorInFlight;
       updateManager?.stop?.();
       await sqmLocalReviewWorker?.close?.();
       await durableLocalTaskWorker?.close?.();
@@ -1824,7 +1968,8 @@ export async function startAgent({
             });
         const runId = String(remoteRun?.id || "");
         if (!runId) throw new Error("SIMY Web did not return an Agentic Loop run id.");
-        const run = createRun({ runId, request, session, apiOrigin });
+        const run = createRun({ runId, request, session, apiOrigin, localStateRoot: codingRunStateRoot });
+        await saveCodingRunSnapshot(codingRunStateRoot, run.snapshot);
         registry.create(run);
         void startLocalCodingRun(run, runOptions);
         return run;

package/src/cli-contract.js

@@ -13,7 +13,7 @@ import {
 } from "./durable-local-task-steps-contract.js";
 import { buildExecutionCapabilityContract } from "./execution-capability-contract.js";
 
-export const CLI_VERSION = "0.5.29";
+export const CLI_VERSION = "0.5.31";
 export const CLI_API_CONTRACT_VERSION = 10;
 
 export function withCliContract(

package/src/codex-plugins/simy/.codex-plugin/plugin.json

@@ -1,25 +1,34 @@
 {
   "name": "simy",
   "version": "0.1.0",
-  "description": "Run SIMY quality and pull request review workflows from the current Codex thread.",
+  "description": "SIMY quality, PR review, and opt-in hook-based Delivery Loop in the current conversation.",
   "author": {
     "name": "Specialist Doctors Inc.",
     "url": "https://github.com/SpecialistDoctors-Inc"
   },
   "repository": "https://github.com/SpecialistDoctors-Inc/simy-cli",
   "license": "UNLICENSED",
-  "keywords": ["simy", "sqm", "pull-request"],
+  "keywords": [
+    "simy",
+    "sqm",
+    "pull-request"
+  ],
   "skills": "./skills/",
   "interface": {
     "displayName": "SIMY",
-    "shortDescription": "Quality and PR review workflows for SIMY.",
-    "longDescription": "SIMY turns the current Codex thread into a bounded quality check or a read-only pull request review. Delivery Loop runs through SIMY Web and CLI, not a local Codex skill.",
+    "shortDescription": "Quality, PR review, and bounded Delivery Loop.",
+    "longDescription": "Run quality checks and PR reviews, or explicitly start a bounded Delivery Loop using user-reviewed hooks in the current conversation. Hook trust and per-task opt-in are required; Web/CLI delivery remains available.",
     "developerName": "Specialist Doctors Inc.",
     "category": "Developer Tools",
-    "capabilities": ["Quality", "Review"],
+    "capabilities": [
+      "Quality",
+      "Review",
+      "Delivery"
+    ],
     "defaultPrompt": [
       "Run the SIMY SQM Loop for the current thread.",
-      "Review the current pull request with SIMY."
+      "Review the current pull request with SIMY.",
+      "Start SIMY Delivery Loop for the current task."
     ]
   }
 }

package/src/codex-plugins/simy/hooks/README.md

@@ -15,3 +15,18 @@ When `SIMY_WEB_ORIGIN` or `SIMY_API_ORIGIN` is set, only that origin is accepted
 Otherwise the hook checks at most 16 origin-keyed discovery records and accepts
 the first live, authenticated connection with a fresh cloud heartbeat. It never
 scans ports or reads stored session tokens.
+
+## Delivery Loop hooks
+
+`delivery-loop.mjs` is an independent opt-in workflow, shared by the Codex and
+Claude distributions. SessionStart supplies the exact session identity. It does
+not start a loop. After an explicit `simy delivery start`, Stop checks that
+session's checkpoint and returns bounded next-step instructions. Approval/input
+blocks, interruption, completion, failures and budgets stop automatic continuation.
+Provider errors/exits are surfaced to SIMY's desktop; a dead provider is not
+silently restarted. No hook writes trust, permission settings, or SQM evidence.
+
+Private state is under `SIMY_HOME/delivery-hooks` (default `~/.simy/delivery-hooks`),
+keyed by provider and session ID and bound to the canonical working directory.
+Historical hook observations do not prove hooks are still enabled. See the
+bundled delivery-loop skill for checkpoint commands and explicit recovery.

package/src/codex-plugins/simy/hooks/delivery-loop.mjs

@@ -0,0 +1,196 @@
+#!/usr/bin/env node
+// Standalone by design: this exact module is shipped to both provider plugins.
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, readFile, readdir, realpath, rename, rm, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+export const TERMINAL = new Set(['completed', 'stopped', 'failed', 'budget_exhausted']);
+const EVENTS = new Set(['SessionStart', 'Stop', 'StopFailure', 'SessionEnd', 'Interrupt', 'PermissionRequest', 'Notification']);
+const MAX_BYTES = 64 * 1024;
+const RETRYABLE = new Set(['overloaded', 'server_error', 'rate_limit']);
+export const rootDirectory = (env = process.env) => join(env.SIMY_HOME?.trim() || join(homedir(), '.simy'), 'delivery-hooks');
+const digest = value => createHash('sha256').update(value).digest('hex');
+const text = (value, max = 4000) => typeof value === 'string' ? value.trim().slice(0, max) : '';
+export function recordPath(root, provider, session) {
+  if (!['codex', 'claude'].includes(provider) || typeof session !== 'string' || !/^[A-Za-z0-9_-]{1,256}$/.test(session)) throw new Error('A provider and exact session ID are required.');
+  return join(root, `${digest(`${provider}\0${session}`)}.json`);
+}
+async function read(file) {
+  try { const raw = await readFile(file, 'utf8'); if (Buffer.byteLength(raw) > MAX_BYTES) throw new Error('State exceeds limit.'); return JSON.parse(raw); }
+  catch (e) { if (e.code === 'ENOENT') return null; throw e; }
+}
+export async function updateRecord(root, provider, session, mutate) {
+  await mkdir(root, { recursive: true, mode: 0o700 });
+  const file = recordPath(root, provider, session), lock = `${file}.lock`;
+  // Short, non-waiting critical sections keep hooks bounded. A crashed writer's
+  // stale lock is surfaced, never silently removed while a writer may own it.
+  try { await mkdir(lock); } catch (e) { if (e.code === 'EEXIST') throw new Error('Delivery state is busy; retry the command.'); throw e; }
+  let temporary;
+  try {
+    const next = await mutate(await read(file));
+    if (next) {
+      temporary = `${file}.${randomUUID()}.tmp`;
+      await writeFile(temporary, JSON.stringify(next), { mode: 0o600 });
+      await rename(temporary, file);
+    }
+    return next;
+  } finally { if (temporary) await rm(temporary, { force: true }); await rm(lock, { recursive: true, force: true }); }
+}
+export async function listRecords(root = rootDirectory()) {
+  let names; try { names = await readdir(root); } catch (e) { if (e.code === 'ENOENT') return []; throw e; }
+  const results = await Promise.all(names.filter(n => /^[a-f0-9]{64}\.json$/.test(n)).slice(0, 500).map(async n => {
+    try { const r = await read(join(root, n)); return r?.schemaVersion === 1 && recordPath(root, r.provider, r.session) === join(root, n) ? r : null; } catch { return null; }
+  }));
+  return results.filter(Boolean);
+}
+function positive(value, fallback, max) {
+  if (value === undefined) return fallback;
+  if (!Number.isSafeInteger(value) || value < 1 || value > max) throw new Error('Invalid delivery budget.');
+  return value;
+}
+export async function startDelivery({ root = rootDirectory(), provider, session, cwd = process.cwd(), objective, nextStep, maxContinuations, maxFailures, maxMinutes, now = Date.now() }) {
+  cwd = await realpath(cwd);
+  if (!text(objective) || !text(nextStep)) throw new Error('Objective and concrete next step are required.');
+  return updateRecord(root, provider, session, previous => {
+    if (!previous?.observedAt || previous.cwd !== cwd) throw new Error('No matching hook session observed here. Enable SIMY hooks, then start a new turn and use the session ID from hook context.');
+    if (previous.run) throw new Error('This session already has a Delivery Loop. Resume or stop it; budgets cannot be reset by starting again.');
+    return { ...previous, run: { id: randomUUID(), objective: text(objective), state: 'active', nextStep: text(nextStep), startedAt: now, updatedAt: now,
+      deadline: now + positive(maxMinutes, 30, 1440) * 60_000, maxContinuations: positive(maxContinuations, 6, 50), maxFailures: positive(maxFailures, 3, 10),
+      continuations: 0, failures: 0, revision: 0, consumedRevision: -1, checkpoint: null, reason: 'started' } };
+  });
+}
+export async function checkpointDelivery({ root = rootDirectory(), provider, session, cwd = process.cwd(), checkpoint, now = Date.now() }) {
+  try { cwd = await realpath(cwd); } catch { throw new Error('No matching active Delivery Loop.'); }
+  const statuses = ['in_progress', 'completed', 'blocked', 'error'];
+  if (!checkpoint || !statuses.includes(checkpoint.status)) throw new Error('Checkpoint status must be in_progress, completed, blocked, or error.');
+  if (!text(checkpoint.summary)) throw new Error('Checkpoint summary is required.');
+  if (['in_progress', 'error'].includes(checkpoint.status) && !text(checkpoint.nextStep)) throw new Error('A concrete nextStep is required.');
+  if (checkpoint.status === 'blocked' && !['authorization', 'missing_information'].includes(checkpoint.blocker)) throw new Error('Specify authorization or missing_information.');
+  const evidence = Array.isArray(checkpoint.evidence) ? checkpoint.evidence.map(v => text(v, 1000)).filter(Boolean).slice(0, 20) : [];
+  if (checkpoint.status === 'completed' && (!evidence.length || checkpoint.acceptanceMet !== true)) throw new Error('Completion requires acceptanceMet and concrete verification evidence.');
+  return updateRecord(root, provider, session, record => {
+    const run = record?.run;
+    if (!run || record.cwd !== cwd) throw new Error('No matching active Delivery Loop.');
+    if (TERMINAL.has(run.state) || run.state === 'blocked' || run.state === 'recovery_required') throw new Error('Loop is stopped or awaiting a human resume.');
+    run.checkpoint = { status: checkpoint.status, summary: text(checkpoint.summary), nextStep: text(checkpoint.nextStep), blocker: checkpoint.blocker, evidence, acceptanceMet: checkpoint.acceptanceMet === true };
+    run.revision += 1; run.updatedAt = now;
+    return record;
+  });
+}
+export function decideStop(run, now = Date.now()) {
+  if (TERMINAL.has(run.state) || ['blocked', 'recovery_required'].includes(run.state)) return { run, output: {} };
+  const next = structuredClone(run);
+  const finish = (state, reason) => { next.state = state; next.reason = reason; next.updatedAt = now; return { run: next, output: {} }; };
+  // A fresh, explicitly evidenced completion may finish at the budget boundary.
+  const fresh = next.checkpoint && next.revision > next.consumedRevision;
+  const cp = fresh ? next.checkpoint : null;
+  if (cp?.status === 'completed') return finish('completed', cp.summary);
+  if (cp?.status === 'blocked') { next.blocker = cp.blocker; return finish('blocked', cp.summary); }
+  if (now >= next.deadline || next.continuations >= next.maxContinuations) return finish('budget_exhausted', 'Delivery time or continuation budget exhausted.');
+  if (!fresh || cp.status === 'error') next.failures += 1;
+  else next.failures = 0;
+  if (next.failures >= next.maxFailures) return finish('failed', 'Repeated failure or missing progress checkpoint; human review required.');
+  next.consumedRevision = next.revision;
+  if (cp?.nextStep) next.nextStep = cp.nextStep;
+  next.continuations += 1; next.updatedAt = now; next.state = 'active';
+  next.reason = fresh ? 'continue_pending_work' : 'checkpoint_missing';
+  const instruction = fresh ? next.nextStep : `Check the actual delivery status first. Record an honest checkpoint with simy delivery checkpoint before stopping; do not claim completion without verification. Pending step: ${next.nextStep}`;
+  return { run: next, output: { decision: 'block', reason: `SIMY Delivery Loop (${next.continuations}/${next.maxContinuations}). ${instruction}\nStay within the original request and permissions. If authorization or information is missing, record a blocked checkpoint and stop. Do not reset budgets or start a replacement loop.` } };
+}
+// A process signature protects against PID reuse. Never treat a stale timer alone
+// as a crash; an idle provider may be waiting for its user.
+export async function processIdentity(pid) {
+  if (!Number.isSafeInteger(pid) || pid < 2 || process.platform === 'win32') return null;
+  try { const { stdout } = await promisify(execFile)('/bin/ps', ['-p', String(pid), '-o', 'lstart=,comm='], { timeout: 500, maxBuffer: 2048 }); return text(stdout, 1000) || null; }
+  catch (e) { return e.code === 1 ? '' : null; }
+}
+async function providerProcess(provider) {
+  if (process.platform === 'win32') return null;
+  let pid = process.ppid;
+  for (let i = 0; i < 3 && pid > 1; i++) {
+    const identity = await processIdentity(pid);
+    if (identity && new RegExp(`(?:^|[/\\\\ ])${provider}(?:$|[ .-])`, 'i').test(identity)) return { pid, identity };
+    try { const r = await promisify(execFile)('/bin/ps', ['-p', String(pid), '-o', 'ppid='], { timeout: 300, maxBuffer: 128 }); pid = Number(r.stdout.trim()); } catch { return null; }
+  }
+  return null;
+}
+export async function handleHook({ input, provider, root = rootDirectory(), now = Date.now(), observedProcess = undefined }) {
+  if (!EVENTS.has(input?.hook_event_name) || !text(input.session_id) || !text(input.cwd)) return {};
+  let cwd; try { cwd = await realpath(input.cwd); } catch { return {}; }
+  const event = input.hook_event_name;
+  const identity = observedProcess === undefined && event === 'SessionStart' ? await providerProcess(provider) : observedProcess;
+  let output = {};
+  await updateRecord(root, provider, input.session_id, old => {
+    if (old && old.cwd !== cwd) return old;
+    const record = old || { schemaVersion: 1, provider, session: input.session_id, cwd, run: null };
+    record.observedAt = now; record.lastEvent = event;
+    if (identity) record.process = identity;
+    if (event === 'SessionStart') {
+      output = { hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: `SIMY hooks observed this ${provider} session: ${input.session_id}. Only if the user requests SIMY Delivery Loop, use simy delivery start --provider ${provider} --session ${input.session_id} with the agreed objective and next step. Existing loop: ${record.run?.state || 'not started'}. Never enable, trust, resume, or reset a loop on the user's behalf without their request.` } };
+    }
+    const run = record.run;
+    if (!run || TERMINAL.has(run.state)) return record;
+    if (event === 'Interrupt') { run.state = 'stopped'; run.reason = 'User interrupted the provider.'; }
+    else if (event === 'PermissionRequest' || event === 'Notification' && ['permission_prompt', 'elicitation_dialog'].includes(input.notification_type)) {
+      run.state = 'blocked'; run.blocker = 'authorization'; run.reason = 'Resolve the provider approval or input request, then explicitly resume Delivery Loop.';
+    } else if (event === 'SessionEnd') {
+      run.state = 'recovery_required'; run.reason = 'Provider session ended. Check why it ended before resuming; no automatic restart.';
+    } else if (event === 'StopFailure') {
+      run.failures += 1;
+      run.state = run.failures >= run.maxFailures ? 'failed' : 'recovery_required';
+      run.reason = RETRYABLE.has(input.error) ? 'Transient provider error. Resume the existing conversation after the provider recovers.' : 'Provider error requires attention before resuming.';
+      run.errorCode = text(input.error, 100); run.retryable = RETRYABLE.has(input.error);
+    } else if (event === 'Stop') {
+      // Codex turn IDs make re-delivered Stop events idempotent. Claude has no
+      // stable event ID; never dedupe on text (identical text can be a new turn).
+      const key = input.turn_id ? `${input.turn_id}:${Boolean(input.stop_hook_active)}:${run.revision}` : null;
+      if (key && run.lastStopKey === key) return record;
+      const decision = decideStop(run, now); record.run = decision.run; output = decision.output;
+      record.run.lastStopKey = key;
+    }
+    record.run.updatedAt = now;
+    return record;
+  });
+  return output;
+}
+export async function controlDelivery({ root = rootDirectory(), provider, session, action, now = Date.now() }) {
+  return updateRecord(root, provider, session, record => {
+    const run = record?.run;
+    if (!run) throw new Error('Delivery Loop not found.');
+    if (action === 'stop') { run.state = 'stopped'; run.reason = 'Stopped by user.'; }
+    else if (action === 'resume') {
+      if (!['blocked', 'recovery_required'].includes(run.state)) throw new Error('Only a blocked or recoverable loop can resume.');
+      if (now >= run.deadline || run.continuations >= run.maxContinuations || run.failures >= run.maxFailures) throw new Error('Original budget exhausted. Loop cannot resume.');
+      run.state = 'active'; run.reason = 'Explicit user resume'; run.checkpoint = null; run.consumedRevision = run.revision;
+    } else throw new Error('Unsupported control.');
+    run.updatedAt = now; return record;
+  });
+}
+export async function reconcileRecords({ root = rootDirectory(), now = Date.now(), inspectProcess = processIdentity } = {}) {
+  const records = await listRecords(root);
+  for (const record of records) {
+    if (!record.run || TERMINAL.has(record.run.state)) continue;
+    const observed = record.process ? await inspectProcess(record.process.pid) : null;
+    await updateRecord(root, record.provider, record.session, current => {
+      if (!current?.run || TERMINAL.has(current.run.state)) return current;
+      const run = current.run;
+      if (now >= run.deadline) { run.state = 'budget_exhausted'; run.reason = 'Delivery time budget exhausted.'; run.updatedAt = now; }
+      else if (run.state === 'active' && observed !== null && observed !== current.process?.identity && current.process?.identity === record.process?.identity) {
+        run.state = 'recovery_required'; run.reason = 'Observed provider process exited. Reopen the existing conversation and explicitly resume.'; run.updatedAt = now;
+      }
+      return current;
+    }).catch(() => {});
+  }
+  return listRecords(root);
+}
+export async function main(provider) {
+  let raw = '';
+  try {
+    for await (const chunk of process.stdin) { raw += String(chunk); if (Buffer.byteLength(raw) > MAX_BYTES) throw new Error('Hook input too large.'); }
+    const output = await handleHook({ input: JSON.parse(raw || '{}'), provider });
+    process.stdout.write(`${JSON.stringify(output)}\n`);
+  } catch { process.stdout.write('{}\n'); process.stderr.write('SIMY could not check delivery state; continuation was skipped. Inspect simy delivery status.\n'); }
+}