@awak-app/simy-cli 0.5.30 → 0.5.32

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.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awak-app/simy-cli",
-  "version": "0.5.30",
+  "version": "0.5.32",
   "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 ./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",
+    "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

@@ -95,6 +95,7 @@ import {
   classifyExecutionRequirement,
   EXECUTION_GUARDRAIL_POLICY_VERSION,
 } from "./execution-guardrail.js";
+import { normalizeWorkflowObservationBinding } from "./workflow-observation-sender.js";
 import {
   createLocalTask,
   createLocalTaskId,
@@ -1072,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({
@@ -1087,6 +1101,7 @@ export async function startAgent({
             timeoutMs: body.timeout_ms,
             attachmentManifest: preparedAttachments,
             scenarioPack,
+            workflowObservationBinding,
           });
           hashLocalTaskIdempotencyKey(idempotencyKey);
         } catch (error) {
@@ -1211,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";
@@ -1444,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: {
@@ -1485,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" &&

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.30";
+export const CLI_VERSION = "0.5.32";
 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'); }
+}

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

@@ -10,6 +10,15 @@
             "timeout": 3
           }
         ]
+      },
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node --input-type=module -e \"import { pathToFileURL } from 'node:url'; import { join } from 'node:path'; const hook = await import(pathToFileURL(join(process.env.PLUGIN_ROOT, 'hooks', 'delivery-loop.mjs')).href); await hook.main('codex');\"",
+            "timeout": 3
+          }
+        ]
       }
     ],
     "UserPromptSubmit": [
@@ -22,6 +31,50 @@
           }
         ]
       }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node --input-type=module -e \"import { pathToFileURL } from 'node:url'; import { join } from 'node:path'; const hook = await import(pathToFileURL(join(process.env.PLUGIN_ROOT, 'hooks', 'delivery-loop.mjs')).href); await hook.main('codex');\"",
+            "timeout": 3
+          }
+        ]
+      }
+    ],
+    "SessionEnd": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node --input-type=module -e \"import { pathToFileURL } from 'node:url'; import { join } from 'node:path'; const hook = await import(pathToFileURL(join(process.env.PLUGIN_ROOT, 'hooks', 'delivery-loop.mjs')).href); await hook.main('codex');\"",
+            "timeout": 3
+          }
+        ]
+      }
+    ],
+    "Interrupt": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node --input-type=module -e \"import { pathToFileURL } from 'node:url'; import { join } from 'node:path'; const hook = await import(pathToFileURL(join(process.env.PLUGIN_ROOT, 'hooks', 'delivery-loop.mjs')).href); await hook.main('codex');\"",
+            "timeout": 3
+          }
+        ]
+      }
+    ],
+    "PermissionRequest": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node --input-type=module -e \"import { pathToFileURL } from 'node:url'; import { join } from 'node:path'; const hook = await import(pathToFileURL(join(process.env.PLUGIN_ROOT, 'hooks', 'delivery-loop.mjs')).href); await hook.main('codex');\"",
+            "timeout": 3
+          }
+        ]
+      }
     ]
   }
 }

package/src/codex-plugins/simy/skills/delivery-loop/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: delivery-loop
+description: Continue an explicitly requested SIMY Delivery Loop in the current provider conversation using user-reviewed hooks, bounded checkpoints, and human blocker handling.
+---
+
+# SIMY Delivery Loop
+
+Use only when the user explicitly requests this skill or SIMY Delivery Loop for the current task. Installing this plugin does not opt a task in. Do not run SQM unless separately requested.
+
+1. Require the SIMY SessionStart hook context with the exact provider and session ID. If absent, explain how to install the SIMY plugin, review and enable its hooks with `/hooks`, and start a new conversation. Codex settings can be opened at `codex://settings`; a hooks subpage deep link is not guaranteed. Never change hook trust or bypass permissions yourself.
+2. Use `simy delivery start --provider <provider> --session <exact-session-id> --objective '<user outcome and acceptance criteria>' --next-step '<concrete next action>'`. Default limits: 6 automatic continuations, 3 consecutive failures/missing checkpoints, 30 minutes. Set different finite limits only if the user requests them. Use the current working directory. Never invent a session ID, start another loop to reset limits, or resume a stopped loop without a user request.
+3. Work in the current conversation with its normal permissions. Before ending each turn, write a JSON checkpoint and run `simy delivery checkpoint --provider <provider> --session <id> --file <file>` from the same directory. Keep checkpoints outside the tracked source diff.
+
+Checkpoint shapes:
+
+```json
+{"status":"in_progress","summary":"Tests identified one remaining failure","nextStep":"Fix the failing validation test and rerun the targeted suite"}
+```
+```json
+{"status":"blocked","blocker":"authorization","summary":"Deployment requires the user's approval"}
+```
+
+For missing information use `blocker: "missing_information"`. For a failed attempt use `status: "error"` and a concrete `nextStep`; repeated errors stop the loop. Do not reclassify blocked work as in_progress to force continuation. Never assume a provider error means permission to switch accounts, credentials, or bypass approvals.
+
+For completed work use `{"status":"completed","summary":"Actual result","acceptanceMet":true,"evidence":["Exact checks and observed results"]}` only after checking the user's acceptance criteria. Evidence is a report, not independent certification: preserve failed checks and deployment gaps. The hook must not infer success from optimistic closing text.
+
+4. The Stop hook evaluates checkpoints and supplies the next instruction within the original budgets. Missing checkpoints consume the failure budget. A human interrupt stops the loop. Approval/input events block it. Provider errors/exits may require reopening the existing conversation; these hooks cannot restart a dead provider process.
+5. After the user explicitly resolves the blocker and requests continuation, `simy delivery resume --provider <provider> --session <id>` retains all budgets. `simy delivery stop` permanently ends this loop. `simy delivery status` shows observed hook activity and loop states; old observations do not prove hooks remain enabled today.

package/src/delivery-hooks/command.js

@@ -0,0 +1,31 @@
+import { readFile } from 'node:fs/promises';
+import { startDelivery, checkpointDelivery, controlDelivery, listRecords, rootDirectory } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+
+export async function runDeliveryCommand(argv, { root = rootDirectory(), cwd = process.cwd(), output = console.log } = {}) {
+  const [action, ...args] = argv;
+  if (!action || action === '--help') {
+    output('simy delivery start --provider codex|claude --session ID --objective TEXT --next-step TEXT [--max-continuations 6] [--max-failures 3] [--max-minutes 30]\nsimy delivery checkpoint --provider codex|claude --session ID --file checkpoint.json\nsimy delivery status\nsimy delivery stop|resume --provider codex|claude --session ID\nEnable and review SIMY hooks in your provider first. Starting a loop opts in only this session. Resume requires the user to resolve the blocker; original budgets are retained.');
+    return 0;
+  }
+  const options = {};
+  const allowed = new Set(['provider', 'session', 'objective', 'next-step', 'max-continuations', 'max-failures', 'max-minutes', 'file']);
+  for (let i = 0; i < args.length; i += 2) {
+    const key = args[i]?.replace(/^--/, '');
+    if (!args[i]?.startsWith('--') || !allowed.has(key) || args[i + 1] === undefined || Object.hasOwn(options, key)) throw new Error('Invalid delivery option. Use simy delivery --help.');
+    options[key] = args[i + 1];
+  }
+  const base = { root, cwd, provider: options.provider, session: options.session };
+  let result;
+  if (action === 'status') result = (await listRecords(root)).filter(r => (!options.provider || r.provider === options.provider) && (!options.session || r.session === options.session));
+  else if (action === 'start') result = await startDelivery({ ...base, objective: options.objective, nextStep: options['next-step'],
+    ...Object.fromEntries([['max-continuations', 'maxContinuations'], ['max-failures', 'maxFailures'], ['max-minutes', 'maxMinutes']].filter(([key]) => options[key] !== undefined).map(([key, field]) => [field, Number(options[key])])) });
+  else if (action === 'checkpoint') {
+    if (!options.file) throw new Error('--file is required.');
+    const data = await readFile(options.file, 'utf8');
+    if (Buffer.byteLength(data) > 64 * 1024) throw new Error('Checkpoint exceeds 64 KiB.');
+    result = await checkpointDelivery({ ...base, checkpoint: JSON.parse(data) });
+  } else if (['stop', 'resume'].includes(action)) result = await controlDelivery({ ...base, action });
+  else throw new Error('Unknown delivery command.');
+  output(JSON.stringify(result, null, 2));
+  return 0;
+}

package/src/delivery-hooks/desktop.js

@@ -0,0 +1,40 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { reconcileRecords, rootDirectory } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+
+export const HOOK_SETUP = Object.freeze({
+  codex: { settingsUrl: 'codex://settings', docsUrl: 'https://learn.chatgpt.com/docs/hooks', command: '/hooks' },
+  claude: { settingsUrl: null, docsUrl: 'https://code.claude.com/docs/en/hooks-guide', command: '/hooks' },
+});
+
+export async function deliveryHookStatus({ root = rootDirectory(), now = Date.now() } = {}) {
+  const records = await reconcileRecords({ root, now });
+  return {
+    providers: Object.fromEntries(['codex', 'claude'].map(provider => {
+      const latest = records.filter(r => r.provider === provider).sort((a, b) => b.observedAt - a.observedAt)[0];
+      return [provider, { ...HOOK_SETUP[provider], state: latest ? 'observed' : 'not_observed', lastObservedAt: latest?.observedAt || null }];
+    })),
+    runs: records.filter(r => r.run).sort((a, b) => b.run.updatedAt - a.run.updatedAt).slice(0, 30).map(r => ({
+      provider: r.provider, session: r.session, objective: r.run.objective, state: r.run.state, reason: r.run.reason,
+      continuations: r.run.continuations, maxContinuations: r.run.maxContinuations, deadline: r.run.deadline,
+      needsAttention: ['blocked', 'failed', 'recovery_required', 'budget_exhausted'].includes(r.run.state), updatedAt: r.run.updatedAt,
+    })),
+  };
+}
+
+// Wait for the OS opener to exit. A successful spawn alone does not prove that
+// a custom URL scheme has a registered handler.
+export async function openHookSetup(provider, { platform = process.platform, run = promisify(execFile) } = {}) {
+  const setup = HOOK_SETUP[provider];
+  if (!setup) throw new Error("Unsupported provider.");
+  const targets = platform === "darwin" && setup.settingsUrl ? [setup.settingsUrl, setup.docsUrl] : [setup.docsUrl];
+  for (const url of targets) {
+    try {
+      const command = platform === "darwin" ? "open" : platform === "win32" ? "rundll32" : "xdg-open";
+      const args = platform === "win32" ? ["url.dll,FileProtocolHandler", url] : [url];
+      await run(command, args, { timeout: 5000, maxBuffer: 4096 });
+      return { opened: true, url };
+    } catch {}
+  }
+  throw new Error("Could not open hook setup. Use /hooks inside your provider.");
+}

package/src/desktop-host.js

@@ -1,3 +1,5 @@
+import { deliveryHookStatus, openHookSetup } from "./delivery-hooks/desktop.js";
+import { controlDelivery } from "./codex-plugins/simy/hooks/delivery-loop.mjs";
 import { createWindowsDesktopUpdater } from "./windows-desktop-updater.js";
 import { spawn, execFile } from "node:child_process";
 import { promisify } from "node:util";
@@ -13,7 +15,8 @@ import { createAgentShutdown } from "./shutdown.js";
 import { resolveWebOrigin } from "./web-origin.js";
 import { openAuthorizationUrl } from "./browser.js";
 import { inspectBackendExecutable } from "./backend-executable.js";
-import { startWorkflowUpdates } from "./sqm/workflow-update.js";
+import { inspectSqmAgentSkill } from "./sqm/agent-skill.js";
+import { startWorkflowUpdates, syncInstalledWorkflows } from "./sqm/workflow-update.js";
 import {
   acquireDesktopProcessLock,
   assertNoLegacyCliDaemon,
@@ -38,11 +41,21 @@ export async function startDesktopHost({ input = process.stdin, output = process
   let agent, updater, stopWorkflows = async () => {}, timer, closed = false, relay = null, publishing = null;
   let shuttingDown = null;
   let commands;
+  let pluginSetup = { state: "unknown" };
+  const inspectPlugins = dependencies.inspectPlugins || inspectSqmAgentSkill;
+  const refreshPlugins = async () => {
+    try {
+      const status = await inspectPlugins();
+      pluginSetup = { state: status.installed ? "ready" : "missing", refreshPending: status.installed && pluginSetup.refreshPending === true };
+    } catch { pluginSetup = { state: "error" }; }
+  };
   const packageInfo = dependencies.packageInfo || await readCliPackageInfo();
   const publish = () => {
     if (closed || relay || !agent) return Promise.resolve();
     if (publishing) return publishing;
-    publishing = Promise.resolve(agent.getDesktopStatus()).then((status) => {
+    publishing = Promise.resolve(agent.getDesktopStatus()).then(async (status) => {
+      status.pluginSetup = { ...pluginSetup };
+      status.deliveryHooks = await (dependencies.deliveryHookStatus || deliveryHookStatus)({ root: join(root, "delivery-hooks") }).catch(() => ({ error: "Delivery hook status unavailable", providers: {}, runs: [] }));
       if (!closed && !relay) emit({ type: "status", status });
     }).finally(() => { publishing = null; });
     return publishing;
@@ -132,6 +145,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
         lines.close(); child.kill("SIGTERM"); throw error;
       }
     } });
+    await refreshPlugins();
     await publish();
     timer = setInterval(() => { void publish().catch(() => emit({ type: "error", message: "SIMY status could not be refreshed." })); }, 3_000);
   } catch (error) { await close(); throw error; }
@@ -160,6 +174,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
           if (agent.refreshProviderStatus) await agent.refreshProviderStatus();
           else await agent.refreshCodexStatus?.();
           await agent.refreshDesktopStatus();
+          await refreshPlugins();
         }
         else if (action === "login") {
           const url = await agent.requestDesktopLogin();
@@ -178,6 +193,28 @@ export async function startDesktopHost({ input = process.stdin, output = process
           if (login) await login(root);
           else await openProviderLogin(provider, root);
         }
+        else if (action === "install_plugins") {
+          pluginSetup = { state: "installing" };
+          await publish();
+          try {
+            const result = await (dependencies.installPlugins || syncInstalledWorkflows)({ installMissing: true });
+            if (result.outcome === "busy") throw new Error("Plugin installation is busy.");
+            await refreshPlugins();
+            if (pluginSetup.state !== "ready") throw new Error("Plugin files could not be verified.");
+            pluginSetup.refreshPending = result.refreshPending === true;
+          } catch {
+            pluginSetup = { state: "error" };
+            await publish();
+            throw new Error("Plugin setup failed.");
+          }
+        }
+        else if (action === "codex_hooks" || action === "claude_hooks") {
+          const provider = action === "codex_hooks" ? "codex" : "claude";
+          await (dependencies.openHookSettings || openHookSetup)(provider);
+        } else if (action === "delivery_stop" || action === "delivery_resume") {
+          await controlDelivery({ root: join(root, "delivery-hooks"), provider: command.provider, session: command.session,
+            action: action === "delivery_stop" ? "stop" : "resume" });
+        }
         else if (action === "quit") {
           const status = await agent.getDesktopStatus();
           if (status.tasks.activeCount > 0 && command.force !== true) throw new Error("Tasks are still running. Confirm before quitting.");

package/src/index.js

@@ -70,6 +70,13 @@ if (!configuredWebOrigin) {
 }
 
 async function runCommand(installMode) {
+  if (dispatchArgv[0] === "delivery") {
+    try {
+      const { runDeliveryCommand } = await import("./delivery-hooks/command.js");
+      process.exitCode = await runDeliveryCommand(dispatchArgv.slice(1));
+    } catch (error) { console.error(error.message); process.exitCode = 2; }
+    return;
+  }
   if (dispatchArgv[0] === "sqm") {
     try {
       const { runSqmCommand } = await import("./sqm/command.js");

package/src/local-task.js

@@ -38,6 +38,10 @@ import {
 } from "./local-task-scenario-packs.js";
 import { createProviderStreamDecoder } from "./provider-stream.js";
 import { signalExecutorProcess } from "./runner.js";
+import {
+  createWorkflowObservationSender,
+  normalizeWorkflowObservationBinding,
+} from "./workflow-observation-sender.js";
 
 export const DEFAULT_LOCAL_TASK_TOKEN_BUDGET = 100_000;
 export const DEFAULT_LOCAL_TASK_TIMEOUT_MS = 10 * 60_000;
@@ -251,6 +255,7 @@ export function createLocalTask({
   timeoutMs = DEFAULT_LOCAL_TASK_TIMEOUT_MS,
   idempotencyKeyHash = null,
   requestFingerprint = null,
+  workflowObservationBinding = null,
 }) {
   validateTaskId(id);
   const now = new Date().toISOString();
@@ -259,6 +264,10 @@ export function createLocalTask({
   const normalizedScenarioPack = normalizeLocalTaskScenarioPack(scenarioPack);
   const scenarioExpectedOutputs =
     localTaskScenarioExpectedOutputs(normalizedScenarioPack);
+  const normalizedWorkflowObservationBinding = normalizeWorkflowObservationBinding(
+    workflowObservationBinding,
+    { provider: backend },
+  );
   return {
     id,
     kind: "local_task",
@@ -296,6 +305,17 @@ export function createLocalTask({
     provider_token_budget: tokenBudget,
     provider_tokens_used: 0,
     token_usage: { records: [] },
+    ...(normalizedWorkflowObservationBinding
+      ? {
+          workflow_observation_binding: normalizedWorkflowObservationBinding,
+          workflow_observation: {
+            status: "pending",
+            workflow_id: normalizedWorkflowObservationBinding.workflow_id,
+            workflow_run_id: normalizedWorkflowObservationBinding.workflow_run_id,
+            development_outcome: "unverified",
+          },
+        }
+      : {}),
     timeout_ms: normalizedTimeout,
     created_at: now,
     updated_at: now,
@@ -327,6 +347,7 @@ export function createLocalTaskRequestFingerprint({
   timeoutMs,
   attachmentManifest,
   scenarioPack,
+  workflowObservationBinding = null,
 }) {
   const normalizedModel = normalizeLocalTaskModel(model);
   const manifest = Array.isArray(attachmentManifest)
@@ -339,6 +360,10 @@ export function createLocalTaskRequestFingerprint({
           sha256: String(item.sha256 || "").toLowerCase(),
         }))
     : [];
+  const normalizedWorkflowObservationBinding = normalizeWorkflowObservationBinding(
+    workflowObservationBinding,
+    { provider: backend },
+  );
   const payload = {
     instruction: String(instruction || "").trim(),
     backend: String(backend || ""),
@@ -352,6 +377,9 @@ export function createLocalTaskRequestFingerprint({
     timeout_ms: normalizeTimeoutMs(timeoutMs),
     attachment_manifest: manifest,
     scenario_pack: normalizeLocalTaskScenarioPack(scenarioPack),
+    ...(normalizedWorkflowObservationBinding
+      ? { workflow_observation_binding: normalizedWorkflowObservationBinding }
+      : {}),
   };
   return createHash("sha256").update(JSON.stringify(payload)).digest("hex");
 }
@@ -363,6 +391,9 @@ export async function startLocalTask(
     environment = process.env,
     persist = persistLocalTask,
     beforeProviderInvocation = null,
+    session = null,
+    apiOrigin = null,
+    observationFetch = globalThis.fetch,
   } = {},
 ) {
   if (!task || task.status !== "queued") throw new Error("Local Task must be queued.");
@@ -442,6 +473,14 @@ export async function startLocalTask(
   // synchronous spawn boundary so a stopped task can never start Provider work.
   if (task.stop_requested || task.status !== "running") return task;
 
+  const observationSender = createWorkflowObservationSender({
+    binding: task.workflow_observation_binding,
+    backend: task.backend,
+    session,
+    apiOrigin,
+    fetchImpl: observationFetch,
+  });
+
   const runtimeTempBase = process.platform === "darwin" ? "/tmp" : tmpdir();
   const runtimeTempRoot = await mkdtemp(
     path.join(runtimeTempBase, `simy-local-task-${task.id}-`),
@@ -513,6 +552,7 @@ export async function startLocalTask(
       stream: "stdout",
       onLine,
       onUsage,
+      onEvent: (event) => observationSender?.observe(event),
       onTerminalError: (message) => {
         task.error ||= message;
         task.reason_code ||= "provider_execution_failed";
@@ -560,6 +600,9 @@ export async function startLocalTask(
         (total, item) => total + providerTokenCount(item),
         0,
       );
+      if (observationSender) {
+        task.workflow_observation = await observationSender.flush();
+      }
 
       let artifacts = [];
       let scenarioAcceptance = null;
@@ -709,6 +752,9 @@ export function localTaskSnapshot(task, { includeEvents = true, includeLocalPath
     provider_token_budget: task.provider_token_budget,
     provider_tokens_used: task.provider_tokens_used,
     token_usage: structuredClone(task.token_usage),
+    ...(task.workflow_observation
+      ? { workflow_observation: structuredClone(task.workflow_observation) }
+      : {}),
     timeout_ms: task.timeout_ms,
     created_at: task.created_at,
     updated_at: task.updated_at,
@@ -724,6 +770,7 @@ export function localTaskSnapshot(task, { includeEvents = true, includeLocalPath
           outputs_root_expected: task.outputs_root_expected,
           idempotency_key_hash: task.idempotency_key_hash || null,
           request_fingerprint: task.request_fingerprint || null,
+          workflow_observation_binding: task.workflow_observation_binding || null,
         }
       : {}),
   };
@@ -913,6 +960,10 @@ export async function localTaskArtifact(task, artifactId) {
 }
 
 function restoreLocalTask(snapshot) {
+  const workflowObservationBinding = normalizeWorkflowObservationBinding(
+    snapshot.workflow_observation_binding,
+    { provider: snapshot.backend },
+  );
   return {
     ...snapshot,
     outputs_root_expected:
@@ -926,6 +977,8 @@ function restoreLocalTask(snapshot) {
     scenario_acceptance: snapshot.scenario_acceptance || null,
     warnings: Array.isArray(snapshot.warnings) ? snapshot.warnings : [],
     token_usage: snapshot.token_usage || { records: [] },
+    workflow_observation_binding: workflowObservationBinding,
+    workflow_observation: snapshot.workflow_observation || null,
     child: null,
     operation_promise: null,
     stop_requested: false,

package/src/provider-stream.js

@@ -5,7 +5,7 @@ const STRUCTURED_MARKERS = ["SIMY_RESULT_JSON:", "SIMY_AUDIT_JSON:"];
 const CODEX_MCP_AUTH_WARNING =
   "[Codex] MCP warning: optional connector authorization expired; coding continues.";
 
-export function createProviderStreamDecoder({ backend, stream = "stdout", onLine, onUsage, onTerminalError }) {
+export function createProviderStreamDecoder({ backend, stream = "stdout", onLine, onUsage, onTerminalError, onEvent }) {
   let pending = "";
   let previous = "";
   let model = "";
@@ -22,6 +22,8 @@ export function createProviderStreamDecoder({ backend, stream = "stdout", onLine
       return;
     }
 
+    if (onEvent) onEvent(event);
+
     const terminalError = providerTerminalError(backend, event);
     if (terminalError && onTerminalError) onTerminalError(terminalError);
 

package/src/runner.js

@@ -45,6 +45,10 @@ 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);
@@ -88,6 +92,10 @@ export function createRun({ runId, request, session, apiOrigin, localStateRoot =
     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,
@@ -116,6 +124,18 @@ export function createRun({ runId, request, session, apiOrigin, localStateRoot =
       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,
+              },
+            }
+          : {}),
       },
     }),
   };
@@ -159,6 +179,8 @@ export function restoreRun({ snapshot, session, apiOrigin, localPath = null, loc
       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,
@@ -757,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,
@@ -775,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;
@@ -791,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({
@@ -817,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 =
@@ -846,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 }));
   });
 }
 

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/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)}`);

package/src/sqm/workflow-update.js

@@ -31,7 +31,7 @@ export function startWorkflowUpdates({ enabled, sync = syncInstalledWorkflows, i
   };
 }
 
-export async function syncInstalledWorkflows({ home = homedir(),
+export async function syncInstalledWorkflows({ home = homedir(), installMissing = false,
   codexHome = process.env.CODEX_HOME || path.join(home, ".codex"),
   claudeHome = process.env.CLAUDE_CONFIG_DIR || path.join(home, ".claude"),
   inspect = inspectSqmAgentSkill, install = installSqmAgentSkill,
@@ -52,7 +52,7 @@ export async function syncInstalledWorkflows({ home = homedir(),
     const migrated = await retireLegacySqmGate({ home });
     let status = await inspect({ home });
     const platforms = Object.entries(status.platforms)
-      .filter(([, entry]) => entry.state === "outdated").map(([platform]) => platform);
+      .filter(([, entry]) => entry.state === "outdated" || (installMissing && entry.state === "missing")).map(([platform]) => platform);
     if (platforms.length) status = await install({ home, platforms });
     const results = {};
     const failures = [];
@@ -63,6 +63,9 @@ export async function syncInstalledWorkflows({ home = homedir(),
       try { results[provider] = await refresh(); }
       catch (error) { failures.push(error); }
     }
+    // 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) 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;

package/src/workflow-observation-sender.js

@@ -0,0 +1,208 @@
+import { webApiHeaders, webApiUrl } from "./web-api.js";
+
+const DIGEST = /^sha256:[0-9a-f]{64}$/;
+const SOURCE_REF = /^(codex|claude):[0-9a-f]{64}$/;
+const WORKFLOW_UUID =
+  /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+
+export function normalizeWorkflowObservationBinding(value, { provider = null } = {}) {
+  if (value === undefined || value === null) return null;
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw bindingError();
+  }
+  const keys = Object.keys(value).sort();
+  const expected = ["action_digest", "source_ref", "workflow_id", "workflow_run_id"];
+  if (
+    keys.length !== expected.length ||
+    keys.some((key, index) => key !== expected[index]) ||
+    !WORKFLOW_UUID.test(String(value.workflow_id || "")) ||
+    !WORKFLOW_UUID.test(String(value.workflow_run_id || "")) ||
+    !DIGEST.test(String(value.action_digest || "")) ||
+    !SOURCE_REF.test(String(value.source_ref || "")) ||
+    (provider !== null && !String(value.source_ref).startsWith(`${provider}:`))
+  ) {
+    throw bindingError();
+  }
+  return Object.freeze({
+    workflow_id: String(value.workflow_id),
+    workflow_run_id: String(value.workflow_run_id),
+    action_digest: String(value.action_digest),
+    source_ref: String(value.source_ref),
+  });
+}
+
+export function createWorkflowObservationSender({
+  binding,
+  backend,
+  session,
+  apiOrigin,
+  fetchImpl = globalThis.fetch,
+  now = () => new Date(),
+}) {
+  const normalizedBinding = normalizeWorkflowObservationBinding(binding, { provider: backend });
+  if (!normalizedBinding) return null;
+  if (backend !== "codex" && backend !== "claude") {
+    throw new Error("WorkFlow observation provider must be codex or claude.");
+  }
+
+  let providerSessionId = null;
+  let terminal = null;
+
+  return {
+    observe(event) {
+      if (!event || typeof event !== "object" || terminal) return;
+      providerSessionId ||= providerSessionIdentifier(backend, event);
+      const terminalEvent = terminalProviderState(backend, event);
+      if (!terminalEvent) return;
+      terminal = {
+        ...terminalEvent,
+        observedAt: now().toISOString(),
+      };
+    },
+
+    async flush() {
+      if (!terminal) {
+        return observationState("failed", normalizedBinding, {
+          reason_code: "provider_terminal_event_missing",
+        });
+      }
+      if (!providerSessionId) {
+        return observationState("failed", normalizedBinding, {
+          reason_code: "provider_session_identity_missing",
+        });
+      }
+      if (!session?.token || !session?.api_base_url) {
+        return observationState("failed", normalizedBinding, {
+          reason_code: "device_session_unavailable",
+        });
+      }
+
+      const body = {
+        action_digest: normalizedBinding.action_digest,
+        source_ref: normalizedBinding.source_ref,
+        observed_at: terminal.observedAt,
+        event: {
+          provider: backend,
+          type: terminal.eventType,
+          outcome: terminal.outcome,
+        },
+      };
+
+      let response;
+      for (let attempt = 1; attempt <= 2; attempt += 1) {
+        try {
+          response = await fetchImpl(
+            webApiUrl(
+              `workflows/${encodeURIComponent(normalizedBinding.workflow_id)}/runs/${encodeURIComponent(normalizedBinding.workflow_run_id)}/observations`,
+              {
+              webOrigin: apiOrigin,
+              apiBaseUrl: session.api_base_url,
+              },
+            ),
+            {
+              method: "POST",
+              headers: webApiHeaders(
+                { token: session.token },
+                { "Content-Type": "application/json" },
+              ),
+              body: JSON.stringify(body),
+              signal: AbortSignal.timeout(10_000),
+            },
+          );
+        } catch {
+          if (attempt === 2) {
+            return observationState("failed", normalizedBinding, {
+              reason_code: "observation_service_unavailable",
+            });
+          }
+          continue;
+        }
+        if (response.status < 500 || attempt === 2) break;
+      }
+
+      const payload = await response.json().catch(() => null);
+      if (!response.ok) {
+        return observationState("failed", normalizedBinding, {
+          reason_code: response.status === 401 || response.status === 403
+            ? "device_or_source_not_authorized"
+            : response.status === 404 || response.status === 410
+              ? "workflow_binding_unavailable"
+              : "observation_not_accepted",
+          http_status: response.status,
+        });
+      }
+      const receipt = payload?.receipt;
+      if (!validReceipt(receipt, normalizedBinding)) {
+        return observationState("failed", normalizedBinding, {
+          reason_code: "invalid_observation_receipt",
+        });
+      }
+      return observationState("accepted", normalizedBinding, {
+        observation_id: receipt.observation_id,
+      });
+    },
+  };
+}
+
+function providerSessionIdentifier(backend, event) {
+  if (backend === "codex" && event.type === "thread.started") {
+    return cleanIdentifier(event.thread_id);
+  }
+  if (backend === "claude" && event.type === "system" && event.subtype === "init") {
+    return cleanIdentifier(event.session_id);
+  }
+  return null;
+}
+
+function terminalProviderState(backend, event) {
+  if (backend === "codex") {
+    if (event.type === "turn.completed") {
+      return { eventType: "turn.completed", outcome: "succeeded" };
+    }
+    if (event.type === "turn.failed") {
+      return { eventType: "turn.failed", outcome: "failed" };
+    }
+    return null;
+  }
+  if (event.type !== "result") return null;
+  return {
+    eventType: "result",
+    outcome:
+      event.is_error === true || String(event.subtype || "").startsWith("error")
+        ? "failed"
+        : "succeeded",
+  };
+}
+
+function validReceipt(receipt, binding) {
+  return Boolean(
+    receipt &&
+      typeof receipt === "object" &&
+      receipt.accepted === true &&
+      receipt.workflow_id === binding.workflow_id &&
+      receipt.workflow_run_id === binding.workflow_run_id &&
+      typeof receipt.observation_id === "string" &&
+      WORKFLOW_UUID.test(receipt.observation_id),
+  );
+}
+
+function observationState(status, binding, extra = {}) {
+  return {
+    status,
+    workflow_id: binding.workflow_id,
+    workflow_run_id: binding.workflow_run_id,
+    development_outcome: "unverified",
+    ...extra,
+  };
+}
+
+function cleanIdentifier(value) {
+  const identifier = String(value || "").trim();
+  return identifier && identifier.length <= 500 ? identifier : null;
+}
+
+function bindingError() {
+  const error = new Error("WorkFlow observation binding is invalid.");
+  error.code = "workflow_observation_binding_invalid";
+  return error;
+}