@awak-app/simy-cli 0.7.36 → 0.7.38

package/src/codex-plugins/simy/hooks/registered-requirement-checker.mjs

@@ -0,0 +1,201 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { cp, lstat, mkdir, open, readFile, realpath, rm, stat, writeFile } from 'node:fs/promises';
+import { isAbsolute, join, relative, resolve } from 'node:path';
+import { spawn } from 'node:child_process';
+import { normalizeRequirementContract } from './requirement-acceptance.mjs';
+import { workspaceIdentity } from './purpose-workspace.mjs';
+
+const handles = new WeakMap();
+const observers = new WeakSet();
+const digest = bytes => createHash('sha256').update(bytes).digest('hex');
+const objectiveIdentity = objective => digest(typeof objective === 'string' ? objective.trim().slice(0, 4000) : '');
+const sha = value => /^[a-f0-9]{64}$/.test(value || '');
+const inside = (parent, path) => { const rel = relative(parent, path); return !rel || !rel.startsWith('..') && !isAbsolute(rel); };
+const identity = info => Object.fromEntries(['dev', 'ino', 'mode', 'size', 'mtimeMs', 'ctimeMs'].map(key => [key, info[key]]));
+const same = (left, right) => JSON.stringify(left) === JSON.stringify(right);
+const registrations = root => join(root, 'host-requirement-checkers');
+const registrationPath = (root, id) => join(registrations(root), `${id}.json`);
+
+async function readJSON(path, limit = 128 * 1024) {
+  if ((await stat(path)).size > limit) throw new Error('Checker document exceeds its bound.');
+  return JSON.parse(await readFile(path, 'utf8'));
+}
+async function pinFile(file, cwd) {
+  if (!isAbsolute(file?.path) || !sha(file.sha256)) throw new Error('Checker inputs require absolute paths and SHA-256 pins.');
+  const path = await realpath(file.path);
+  if (inside(cwd, path)) throw new Error('Checker inputs must be independent of the candidate workspace.');
+  const before = await lstat(path);
+  if (!before.isFile() || digest(await readFile(path)) !== file.sha256 || !same(identity(before), identity(await lstat(path))))
+    throw new Error('Pinned checker input changed.');
+  return { path, sha256: file.sha256, identity: identity(before) };
+}
+
+// Host-only enrollment capability. JSON read from managed-file/checkpoint cannot
+// recreate a WeakMap handle. This is not an OS sandbox against same-user Bash.
+export async function registerRequirementChecker({ root, provider, session, cwd, objective, publicRequest,
+  command, runtime, requirements, timeoutMs = 140_000, cancellationGraceMs = 1000 }) {
+  if (provider !== 'claude') throw new Error('Registered requirement execution currently supports the Claude live-hook channel only.');
+  cwd = await realpath(cwd);
+  root = resolve(root);
+  if (inside(cwd, root)) throw new Error('Host checker state must be outside the task workspace.');
+  await mkdir(registrations(root), { recursive: true });
+  root = await realpath(root);
+  if (inside(cwd, root)) throw new Error('Host checker state resolves inside the task workspace.');
+  if (typeof objective !== 'string' || !objective.trim() || typeof session !== 'string' || !session ||
+      !Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 180_000 ||
+      !Number.isSafeInteger(cancellationGraceMs) || cancellationGraceMs < 1000 || cancellationGraceMs > 45_000 ||
+      !runtime || !sha(runtime.digest) || !['public-docker-v1', 'deterministic-fixture'].includes(runtime.profile) ||
+      !isAbsolute(command?.executable) || !Array.isArray(command.args) || command.args.some(arg => typeof arg !== 'string') ||
+      !Array.isArray(command.pins) || !command.pins.length || command.pins.length > 100)
+    throw new Error('Invalid host checker registration.');
+  const pins = await Promise.all(command.pins.map(file => pinFile(file, cwd)));
+  if (new Set(pins.map(pin => pin.path)).size !== pins.length) throw new Error('Duplicate checker input.');
+  const executable = await realpath(command.executable);
+  if (!pins.some(pin => pin.path === executable)) throw new Error('Checker executable must be pinned.');
+  const request = await pinFile(publicRequest, cwd);
+  const environment = command.env || {};
+  if (Object.entries(environment).some(([key, value]) => !/^[A-Z][A-Z0-9_]*$/.test(key) || typeof value !== 'string' ||
+      /^(NODE_OPTIONS|NODE_PATH|PYTHONPATH|PYTHONHOME|LD_|DYLD_)/.test(key))) throw new Error('Invalid fixed checker environment.');
+  const checker = { command: { executable, args: [...command.args], env: { ...environment } }, pins,
+    runtime: structuredClone(runtime), timeoutMs, cancellationGraceMs };
+  const contract = normalizeRequirementContract({ schemaVersion: 1, checkVersion: `registered-${digest(JSON.stringify(checker))}`, requirements });
+  const spec = { schemaVersion: 1, id: randomUUID(), provider, session, cwd, objectiveHash: objectiveIdentity(objective), publicRequest: request, checker, contract };
+  const bytes = JSON.stringify(spec), binding = { id: spec.id, digest: digest(bytes) };
+  await writeFile(registrationPath(root, spec.id), bytes, { flag: 'wx', mode: 0o600 });
+  await mkdir(join(registrations(root), 'executions'), { recursive: true });
+  const handle = Object.freeze({ contract: structuredClone(contract) });
+  handles.set(handle, { root, spec, binding });
+  return handle;
+}
+
+export async function bindRequirementChecker(handle, { root, provider, session, cwd, objective }) {
+  const registration = handles.get(handle);
+  if (!registration || registration.root !== await realpath(root) || registration.spec.provider !== provider ||
+      registration.spec.session !== session || registration.spec.cwd !== await realpath(cwd) ||
+      registration.spec.objectiveHash !== objectiveIdentity(objective)) throw new Error('A matching host enrollment capability is required.');
+  await loadRegistration(root, registration.binding, true);
+  return { requirementChecker: { ...registration.binding }, requirementContract: structuredClone(registration.spec.contract) };
+}
+
+async function loadRegistration(root, binding, full = false) {
+  if (!/^[a-f0-9-]{36}$/.test(binding?.id || '') || !sha(binding?.digest)) throw new Error('Invalid enrolled checker binding.');
+  const bytes = await readFile(registrationPath(root, binding.id), 'utf8');
+  if (Buffer.byteLength(bytes) > 128 * 1024 || digest(bytes) !== binding.digest) throw new Error('Host checker registration changed.');
+  const spec = JSON.parse(bytes);
+  for (const file of [...spec.checker.pins, spec.publicRequest]) {
+    if (!same(identity(await lstat(file.path)), file.identity) ||
+        full && digest(await readFile(file.path)) !== file.sha256) throw new Error('Pinned checker input changed.');
+  }
+  return spec;
+}
+
+// Stop only checks the enrollment and inexpensive source metadata. Actual
+// execution validates the complete pinned bytes both before and afterwards.
+export async function registeredCheckerCurrent(root, binding) {
+  try { await loadRegistration(root, binding); return true; } catch { return false; }
+}
+
+export function receiptFromCaseReport(contract, candidateHash, report, evidenceRef) {
+  const expected = contract.requirements.flatMap(row => row.assertionIds);
+  const cases = report?.cases;
+  const complete = report?.schemaVersion === 1 && report.execution?.status === 'completed' && Array.isArray(cases) &&
+    cases.length === expected.length && new Set(cases.map(row => row?.id)).size === expected.length &&
+    cases.every(row => expected.includes(row?.id) && ['passed', 'failed'].includes(row.status));
+  return { schemaVersion: 1, contractHash: contract.contractHash, checkVersion: contract.checkVersion, candidateHash,
+    execution: { status: complete ? 'completed' : 'infrastructure_error', assertionCount: complete ? cases.length : 0 },
+    observations: complete ? contract.requirements.map(requirement => ({ requirementId: requirement.id,
+      status: cases.some(row => requirement.assertionIds.includes(row.id) && row.status === 'failed') ? 'failed' : 'verified',
+      assertionIds: requirement.assertionIds, evidenceRefs: [evidenceRef] })) : [] };
+}
+
+async function runProcess(spec, request, directory, signal) {
+  const stdout = await open(join(directory, 'stdout.log'), 'wx', 0o600);
+  const stderr = await open(join(directory, 'stderr.log'), 'wx', 0o600);
+  try {
+    signal.throwIfAborted();
+    const child = spawn(spec.command.executable, spec.command.args, {
+      cwd: directory, env: spec.command.env, stdio: ['pipe', stdout.fd, stderr.fd],
+    });
+    let killTimer;
+    const abort = () => { child.kill('SIGTERM'); killTimer ??= setTimeout(() => child.kill('SIGKILL'), spec.cancellationGraceMs ?? 1000); };
+    let inspecting = false;
+    const outputLimit = setInterval(async () => {
+      if (inspecting) return;
+      inspecting = true;
+      try { if ((await stdout.stat()).size + (await stderr.stat()).size > 8 * 1024 * 1024) abort(); }
+      catch { abort(); } finally { inspecting = false; }
+    }, 100);
+    const completion = new Promise(accept => {
+      let spawnError;
+      child.once('error', error => { spawnError = error; });
+      child.once('close', (code, terminationSignal) => accept({ code, signal: terminationSignal, ...(spawnError ? { error: spawnError.message } : {}) }));
+    });
+    signal.addEventListener('abort', abort, { once: true });
+    if (signal.aborted) abort();
+    child.stdin.on('error', () => {});
+    child.stdin.end(JSON.stringify(request));
+    try {
+      await writeFile(join(directory, 'process.json'), JSON.stringify({ pid: child.pid, launchedAt: new Date().toISOString() }), { flag: 'wx' });
+      return await completion;
+    } catch (error) { abort(); await completion; throw error;
+    } finally { clearTimeout(killTimer); clearInterval(outputLimit); signal.removeEventListener('abort', abort); }
+  } finally { await stdout.close(); await stderr.close(); }
+}
+
+export function registeredRequirementObserver({ root, binding, provider, session, runId, signal: outerSignal }) {
+  const observer = async ({ cwd, contract, candidateHash, signal = outerSignal }) => {
+    const spec = await loadRegistration(root, binding, true);
+    if (spec.provider !== provider || spec.session !== session || spec.cwd !== await realpath(cwd) ||
+        spec.contract.contractHash !== contract.contractHash) throw new Error('Registered checker target changed.');
+    const executions = join(registrations(root), 'executions', digest(JSON.stringify([binding, provider, session, runId, candidateHash])));
+    // Atomic one-use claim also covers a cold checkpoint subprocess. An unknown
+    // process is never replayed; a completed report has an explicit reuse link.
+    try { await mkdir(executions); }
+    catch (error) {
+      if (error.code !== 'EEXIST') throw error;
+      const result = await readJSON(join(executions, 'result.json'));
+      if (result.bindingDigest !== binding.digest || result.candidateHash !== candidateHash || result.status !== 'complete' || result.snapshotRemoved !== true)
+        throw new Error('Previous checker execution is unresolved; do not replay.');
+      const bytes = await readFile(join(executions, 'cases.json'));
+      if (digest(bytes) !== result.reportHash) throw new Error('Previous checker report changed.');
+      return receiptFromCaseReport(contract, candidateHash, JSON.parse(bytes), join(executions, 'result.json'));
+    }
+    await writeFile(join(executions, 'intent.json'), JSON.stringify({ binding, provider, session, runId, candidateHash,
+      createdAt: new Date().toISOString() }), { flag: 'wx' });
+    const controller = new AbortController();
+    const abort = () => controller.abort(signal.reason);
+    signal?.addEventListener('abort', abort, { once: true });
+    if (signal?.aborted) abort();
+    const timeout = setTimeout(() => controller.abort(new Error('Checker deadline exceeded.')), spec.checker.timeoutMs);
+    const snapshot = join(executions, 'candidate');
+    try {
+      const filter = path => !relative(cwd, path).split(/[\\/]/).some(part => ['.git', 'node_modules', '.npm-cache'].includes(part));
+      await cp(cwd, snapshot, { recursive: true, dereference: false, filter, preserveTimestamps: true });
+      if (await workspaceIdentity(snapshot, undefined, undefined, { signal: controller.signal }) !== candidateHash ||
+          await workspaceIdentity(cwd, root, undefined, { signal: controller.signal }) !== candidateHash) throw new Error('Candidate changed while freezing checker input.');
+      const process = await runProcess(spec.checker, { schemaVersion: 1, candidateHash, cwd: snapshot,
+        reportPath: join(executions, 'cases.json'), contract: spec.contract, runtime: spec.checker.runtime }, executions, controller.signal);
+      await loadRegistration(root, binding, true);
+      if (controller.signal.aborted || process.signal || process.error || ![0, 1].includes(process.code) ||
+          await workspaceIdentity(snapshot) !== candidateHash) throw new Error('Checker process or immutable input is unresolved.');
+      const report = await readJSON(join(executions, 'cases.json'));
+      const receipt = receiptFromCaseReport(contract, candidateHash, report, join(executions, 'result.json'));
+      if (receipt.execution.status !== 'completed' || process.code === 1 && !report.cases.some(row => row.status === 'failed')) throw new Error('Checker did not execute the complete required case set.');
+      await rm(snapshot, { recursive: true });
+      await writeFile(join(executions, 'result.json'), JSON.stringify({ status: 'complete', bindingDigest: binding.digest,
+        candidateHash, process, snapshotRemoved: true, reportHash: digest(await readFile(join(executions, 'cases.json'))) }), { flag: 'wx' });
+      return receipt;
+    } catch (error) {
+      await writeFile(join(executions, 'error.json'), JSON.stringify({ status: 'unresolved', message: error.message }), { flag: 'wx' });
+      throw error;
+    } finally {
+      clearTimeout(timeout); signal?.removeEventListener('abort', abort);
+      // Only our copied input, never the original workspace or Docker resources.
+      await rm(snapshot, { recursive: true, force: true });
+    }
+  };
+  observers.add(observer);
+  return observer;
+}
+
+export const isRegisteredRequirementObserver = observer => observers.has(observer);

package/src/codex-plugins/simy/hooks/requirement-acceptance.mjs

@@ -0,0 +1,69 @@
+import { createHash } from 'node:crypto';
+
+const hash = value => createHash('sha256').update(JSON.stringify(value)).digest('hex');
+const identifier = value => typeof value === 'string' && /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,119}$/.test(value);
+const strings = (values, maximum) => Array.isArray(values) && values.length > 0 && values.length <= maximum &&
+  values.every(identifier) && new Set(values).size === values.length;
+
+// This opt-in contract is frozen at enrollment. Receipts cannot redefine its
+// requirements or replace a broad behavior requirement with a literal PASS file.
+export function normalizeRequirementContract(input) {
+  if (input?.schemaVersion !== 1 || !identifier(input.checkVersion) || !Array.isArray(input.requirements) ||
+      !input.requirements.length || input.requirements.length > 20) throw new Error('Invalid behavior requirement contract.');
+  const requirements = input.requirements.map(row => {
+    if (!identifier(row?.id) || typeof row.description !== 'string' || !row.description.trim() || row.description.length > 500 ||
+        !strings(row.assertionIds, 100)) throw new Error('Each behavior requirement needs an ID, description and distinct assertions.');
+    return { id: row.id, description: row.description, assertionIds: [...row.assertionIds].sort() };
+  }).sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+  if (new Set(requirements.map(row => row.id)).size !== requirements.length) throw new Error('Duplicate behavior requirement.');
+  const assertionIds = requirements.flatMap(row => row.assertionIds);
+  if (new Set(assertionIds).size !== assertionIds.length) throw new Error('Behavior assertion IDs must be unique across requirements.');
+  const contract = { schemaVersion: 1, checkVersion: input.checkVersion, requirements };
+  const contractHash = hash(contract);
+  if (input.contractHash !== undefined && input.contractHash !== contractHash) throw new Error('Behavior contract digest changed.');
+  return { ...contract, contractHash };
+}
+
+export function assessRequirementReceipt(contractInput, receipt, candidateHash) {
+  const contract = normalizeRequirementContract(contractInput);
+  const unknown = detail => contract.requirements.map(row => ({ requirementId: row.id, status: 'unknown', detail }));
+  if (!receipt || receipt.schemaVersion !== 1 || receipt.contractHash !== contract.contractHash ||
+      receipt.checkVersion !== contract.checkVersion || receipt.candidateHash !== candidateHash ||
+      !/^[a-f0-9]{64}$/.test(candidateHash || '')) return unknown('Missing or stale independently bound behavior observation.');
+  if (receipt.execution?.status !== 'completed' || !Number.isSafeInteger(receipt.execution.assertionCount) ||
+      receipt.execution.assertionCount <= 0) return unknown('Behavior observation did not execute assertions; infrastructure is unresolved.');
+  if (!Array.isArray(receipt.observations) || receipt.observations.length > 20) return unknown('Invalid behavior observation rows.');
+  const ids = receipt.observations.map(row => row?.requirementId);
+  if (new Set(ids).size !== ids.length || ids.some(id => !contract.requirements.some(row => row.id === id)))
+    return unknown('Duplicate or unexpected behavior observation rows.');
+  let observedCount = 0;
+  const rows = contract.requirements.map(requirement => {
+    const row = receipt.observations.find(item => item.requirementId === requirement.id);
+    if (!row || !['verified', 'failed', 'unknown'].includes(row.status) || !strings(row.assertionIds, 100) ||
+        !Array.isArray(row.evidenceRefs) || !row.evidenceRefs.length || row.evidenceRefs.length > 20 ||
+        row.evidenceRefs.some(ref => typeof ref !== 'string' || !ref.trim() || ref.length > 1000) ||
+        row.assertionIds.some(id => !requirement.assertionIds.includes(id)))
+      return { requirementId: requirement.id, status: 'unknown', detail: 'Requirement has no usable assertion/evidence observation.' };
+    observedCount += row.assertionIds.length;
+    if (row.status === 'verified' && requirement.assertionIds.some(id => !row.assertionIds.includes(id)))
+      return { requirementId: requirement.id, status: 'unknown', detail: 'Only part of the required behavior was observed.' };
+    return { requirementId: requirement.id, status: row.status,
+      detail: row.status === 'failed' ? 'Executed behavior assertion failed.' : row.status === 'unknown' ?
+        'Behavior remains unresolved.' : 'All required behavior assertions were independently observed.' };
+  });
+  return receipt.execution.assertionCount < observedCount ? unknown('Assertion count does not bind the observed rows.') : rows;
+}
+
+export function pendingRequirements(managed) {
+  if (!managed?.requirementContract) return [];
+  let contract;
+  try { contract = normalizeRequirementContract(managed.requirementContract); }
+  catch { return [{ id: 'behavior-contract', description: 'Frozen behavior requirements', check: 'behavior', status: 'unknown', detail: 'Behavior contract changed; inspect enrollment.' }]; }
+  const observation = managed.requirementObservation;
+  const rows = observation?.source === 'host_requirement_observer' && observation.current === true
+    ? assessRequirementReceipt(contract, observation.receipt, observation.candidateHash)
+    : contract.requirements.map(row => ({ requirementId: row.id, status: 'unknown', detail: 'Current host behavior observation is missing.' }));
+  return rows.filter(row => row.status !== 'verified').map(row => ({ id: `behavior:${row.requirementId}`,
+    description: contract.requirements.find(item => item.id === row.requirementId).description,
+    check: 'behavior', status: row.status, detail: row.detail }));
+}

package/src/codex-plugins/simy/skills/continue/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: continue
-description: Start SIMY Auto Continue for the original conversation when the user explicitly asks SIMY or @simy to take over or continue unfinished work. Also read its real execution status or turn automatic continuation off. This is a controller entry, not an independent delivery agent or an SQM check.
+description: Turn on SIMY Delivery Loop (Continue automatically) for the original conversation when the user explicitly asks SIMY or @simy to take over or continue unfinished work. Also read its real execution status or turn Delivery Loop off for this conversation. This is a controller entry, not an independent delivery agent or an SQM check.
 ---
 
 # Continue the original conversation with SIMY
@@ -32,8 +32,8 @@ existing conversation reference before changing anything.
 Use this command on the original local host. Preserve a remote selection's host
 and use its existing SIMY remote controls instead of treating it as local.
 
-This command delegates to the running SIMY app's existing Auto Continue control
-and background coordinator. It preserves the original goal, task history,
+This command delegates to the running SIMY app's existing Delivery Loop control
+(the Continue automatically switch) and background coordinator. It preserves the original goal, task history,
 corrections, permissions, failure budgets and approvals. It does not start a
 second provider process, create a replacement task, change accounts or models,
 trust hooks, or grant native permissions. The original current turn continues
@@ -51,7 +51,7 @@ result and acceptance. Continue already-authorized work in this conversation.
 To inspect again, use the same exact target with `auto-continue status` in place
 of `auto-continue on`. If the response was lost or status reading failed after
 saving, query status; never automatically repeat a mutation to infer success.
-When asked to turn automatic continuation off, use `auto-continue off` for the
+When asked to turn Delivery Loop off, use `auto-continue off` for the
 same target. OFF preserves the current native turn; an explicit stop uses the
 existing task Stop control. A stopped, rejected, archived, settled, disconnected
 or unavailable task stays within its existing boundary: report the returned

package/src/codex-plugins/simy/skills/continue/agents/openai.yaml

@@ -1,6 +1,6 @@
 interface:
-  display_name: "SIMY Auto Continue"
-  short_description: "Continue the original task through SIMY"
-  default_prompt: "Use $simy:continue to enable SIMY Auto Continue for this conversation and report its actual work state."
+  display_name: "SIMY Continue automatically"
+  short_description: "Turn on Delivery Loop for this conversation"
+  default_prompt: "Use $simy:continue to turn on SIMY Delivery Loop for this conversation and report its actual work state."
 policy:
   allow_implicit_invocation: true

package/src/codex-plugins/simy/skills/diagnose/SKILL.md

@@ -1,9 +1,9 @@
 ---
 name: diagnose
-description: Diagnose a stopped or unresponsive SIMY task when the user says “SIMY CLIに相談して”, asks why it stopped, or requests manual SIMY diagnosis. Distinguish read-only diagnosis from an explicit request to repair and continue the original work.
+description: Check why it stopped (停止理由の確認) for a stopped or unresponsive SIMY task when the user says “SIMY CLIに相談して” or asks why it stopped. Distinguish a read-only check from an explicit request to repair and continue the original work. Environment diagnosis is `simy doctor`, not this entry.
 ---
 
-# Consult SIMY CLI
+# Check why it stopped (停止理由の確認)
 
 Use this entry for an explicit consultation, diagnosis, or repair-and-continue request, independently of Delivery Loop enrollment or permission to resume. Prefer `$SIMY_HOME/bin/simy` or `$HOME/.simy/bin/simy`. Inspect `--version` and `delivery --help` to confirm `consult` is available. If only `diagnose` exists, use the legacy command below for diagnosis and report repair as unavailable; never reinterpret a failed consult invocation as execution. An older installed CLI is a compatibility gap, never permission to switch its live runtime.
 

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

@@ -1,9 +1,9 @@
 ---
 name: sqm-loop
-description: Run the SIMY Software Quality Monitor against the repository and changes discussed in the current Codex thread. Use when the user asks SIMY to start SQM, quality-check the current work, or prepare a PR quality proof.
+description: Run a SIMY SQM check on the repository and changes discussed in the current Codex thread, on request. Use when the user asks SIMY to start SQM or quality-check the current work now. The opted-in pre-PR gate is the separate simy-sqm-pr-check skill.
 ---
 
-# SIMY SQM Loop
+# SIMY SQM check
 
 Treat the current Codex thread, its attachments, and the active repository as the request context. Convert that context into explicit quality expectations, then verify the actual repository state; do not merely summarize the conversation.
 
@@ -22,7 +22,7 @@ Investigate and repair authorized reversible setup; preserve real account,
 organization, device and provider authority. Do not guess credentials or invent a
 successful scope. A connected scope is not quality acceptance.
 
-## Run the quality loop
+## Run the SQM check
 
 1. Identify the repository root and the user-visible behavior or incident discussed in the current thread.
 2. Preserve unrelated user changes and follow repository instructions.

package/src/codex-plugins/simy/skills/sqm-loop/agents/openai.yaml

@@ -1,6 +1,6 @@
 interface:
-  display_name: "SIMY SQM Loop"
-  short_description: "Run SQM from the current Codex thread"
+  display_name: "SIMY SQM check"
+  short_description: "Run an SQM check on the current work"
   default_prompt: "Use $sqm-loop to quality-check the work in this thread."
 policy:
   allow_implicit_invocation: true

package/src/console/app.js

@@ -176,7 +176,7 @@ export function AgenticLoopConsole({ agent, onQuit = () => {}, remoteConnections
     }
     if (!selectedRun) {
       if (command.type !== "guidance") {
-        setNotice("That command requires a selected Agentic Loop run.");
+        setNotice("That command requires a selected Delivery Loop run.");
         return;
       }
       setBusy(true);
@@ -213,12 +213,12 @@ export function AgenticLoopConsole({ agent, onQuit = () => {}, remoteConnections
             setNotice("Guidance queued for the next executor handoff.");
           } else {
             await agent.controls.continue(selectedRun, command.message);
-            setNotice("Human guidance accepted. The agentic loop is continuing.");
+            setNotice("Human guidance accepted. The Delivery Loop is continuing.");
           }
           break;
         case "decision":
           await agent.controls.applyDecision(selectedRun, command);
-          setNotice("Human decision recorded. The agentic loop is continuing.");
+          setNotice("Human decision recorded. The Delivery Loop is continuing.");
           break;
         case "recheck":
           await agent.controls.recheck(selectedRun);
@@ -297,7 +297,7 @@ export function AgenticLoopConsole({ agent, onQuit = () => {}, remoteConnections
         await agent.controls.selectRepository(selectedRun, match);
         setDetailOpen(true);
         setDetailScrollFromEnd(0);
-        setNotice(`Authorized ${match.repository}. The same Agentic Loop run is continuing.`);
+        setNotice(`Authorized ${match.repository}. The same Delivery Loop run is continuing.`);
       } else if (selectedRun) {
         setNotice(
           `${selectedRun.request.repository} was not found under ${result.root}. Run /scan <path> for another authorized root.`,
@@ -328,7 +328,7 @@ export function AgenticLoopConsole({ agent, onQuit = () => {}, remoteConnections
         setRepositoryPicker(null);
         setDetailOpen(true);
         setDetailScrollFromEnd(0);
-        setNotice(`Authorized ${selected.repository}. The same Agentic Loop run is continuing.`);
+        setNotice(`Authorized ${selected.repository}. The same Delivery Loop run is continuing.`);
       } else {
         const verified = await agent.controls.selectRepository(null, selected);
         setDraft((current) => ({
@@ -510,7 +510,7 @@ export function AgenticLoopConsole({ agent, onQuit = () => {}, remoteConnections
       if (confirmStop) void execute("/stop");
       else {
         setConfirmStop(true);
-        setNotice("Press x again to stop the selected Agentic Loop run.");
+        setNotice("Press x again to stop the selected Delivery Loop run.");
       }
       return;
     }
@@ -641,7 +641,7 @@ function NewTask({ draft, loginUrl, width }) {
         dimColor: true,
         wrap: "wrap",
         children:
-          "Describe the outcome. SIMY will choose a one-time Local Task or an Agentic Loop.",
+          "Describe the outcome. SIMY will choose a one-time Local Task or a Delivery Loop.",
       }),
       jsx(Text, { children: " " }),
       jsx(Text, {

package/src/delivery-hooks/claude-workflow.md

@@ -44,7 +44,7 @@ resume or reset a task. Prompt hooks enroll eligible conversations under CLI aut
 Use when the user requests this skill or SIMY Delivery Loop, or current hook context confirms automatic enrollment. Preserve that existing loop and proceed to checkpoints without starting again. Installing this plugin does not opt a task in. Do not run SQM unless separately requested.
 
 1. Resolve the exact original provider and session ID from the SIMY hook context or verified existing session admission. If no valid connection exists, report the observed missing capability and the smallest confirmed connection step. Never invent a session ID, change hook trust, bypass permissions, or replace the conversation. Codex settings can be opened at `codex://settings`; a hooks subpage deep link is not guaranteed.
-2. Only start or resume a Delivery Loop when the user requests it. For a new regular Loop, use `simy delivery start --provider <provider> --session <exact-session-id> --objective '<user outcome and acceptance criteria>' --next-step '<concrete next action>'`. For a Loop that must track acceptance, use the existing managed specification with `--managed-file <task.json>` as described below: freeze the original user outcome, selected delivery level when one exists, and necessary applicable acceptance criteria before work. A regular start can only end as `reported_done`; do not present it as a fully verified Agentic Loop. A verified original `codex_app_server` admission and existing user continuation delegation can use `simy delivery continue --provider codex --session <exact-original-session-id>` without SessionStart when the user requests continuation. Preserve the original objective and acceptance. Never start another loop to reset limits or resume user-stopped work without a user request. Authorized automatic recovery from ordinary blockers is distinct from resuming user-stopped work.
+2. Only start or resume a Delivery Loop when the user requests it. For a new regular Loop, use `simy delivery start --provider <provider> --session <exact-session-id> --objective '<user outcome and acceptance criteria>' --next-step '<concrete next action>'`. For a Loop that must track acceptance, use the existing managed specification with `--managed-file <task.json>` as described below: freeze the original user outcome, selected delivery level when one exists, and necessary applicable acceptance criteria before work. A regular start can only end as `reported_done`; do not present it as a fully verified managed Delivery Loop. A verified original `codex_app_server` admission and existing user continuation delegation can use `simy delivery continue --provider codex --session <exact-original-session-id>` without SessionStart when the user requests continuation. Preserve the original objective and acceptance. Never start another loop to reset limits or resume user-stopped work without a user request. Authorized automatic recovery from ordinary blockers is distinct from resuming user-stopped work.
 
 3. Work in the current conversation with its normal permissions. Before ending each turn, submit a JSON checkpoint through standard input with `simy delivery checkpoint --provider <provider> --session <id> --file -` (for example, a shell heredoc). This updates SIMY state; it does not require writing a checkpoint file to the user's workspace. A file path remains supported when authorized.
 

package/src/delivery-hooks/command.js

@@ -225,18 +225,18 @@ export async function runDeliveryCommand(argv, { root = rootDirectory(), cwd = p
   }
   if (action === 'activity') return runActivityCommand(args, { root, output });
   if (!action || action === '--help') {
-    output('simy delivery auto-continue on|off|status --provider codex|claude --session UUID — use the running app’s Auto Continue control and read its actual work state.');
-    output('simy delivery observability status — show the state-only telemetry status for this device. The single default-OFF consent checkbox is in SIMY settings; disabling it stops uploads and discards pending telemetry. It never enables Auto-continue or starts a task.');
+    output('simy delivery auto-continue on|off|status --provider codex|claude --session UUID — Continue this conversation automatically: turns Delivery Loop on or off for one exact conversation through the running app’s existing control, and reads its actual work state.');
+    output('simy delivery observability status — show the state-only telemetry status for this device. The single default-OFF consent checkbox is in SIMY settings; disabling it stops uploads and discards pending telemetry. It never turns on Delivery Loop or starts a task.');
     output('simy delivery followup --provider codex --session ID --previous-run-id ID --objective TEXT — explicitly supervise the current goal after an exact finished run. A new goal archives the prior run; the same ordinary reported_done goal retains its identity and budgets for read-only reconciliation. Uses the existing supervisor; never reopens stopped, failed or budget-exhausted work.');
-    output('simy delivery auto on|off|status --provider codex|claude — inspect or override CLI automatic start for this project directory (on by default). The next nonempty prompt in a conversation without a loop starts checkpoint tracking. Existing loops are preserved; provider hooks must already be enabled.');
+    output('simy delivery auto on|off|status --provider codex|claude — Start Delivery Loop automatically in this workspace: inspect or override automatic start for future conversations in this project directory (on by default). The next nonempty prompt in a conversation without a Delivery Loop starts checkpoint tracking. Existing loops are preserved; provider hooks must already be enabled.');
     output('simy delivery redelegate-native --provider codex --session ID --task-id ID --consent-ref REF — explicitly delegate current native local edit/test permissions to an exact legacy task. Preserves enrollment, history, budgets and stops; does not resume or grant external actions.');
     output('simy delivery runtime install|status|workflows — install an immutable local candidate, inspect its version/digest, or refresh existing plugin sources/cache while preserving enabled state and hook trust. Never enables a task.');
     output('simy delivery runtime doctor|desktop-install|desktop-activate|watch — audit live host/state/monitor alignment, or prepare a separate local desktop using the verified fixed runtime. Does not start or resume tasks.');
     output('simy delivery runtime policy-adopt [--task-id ID [--criterion-id ID]] — explicitly delegate decisions within existing permissions. Manual acceptance stays manual unless the user names the exact task and criterion to delegate its verifier.');
     output('simy delivery link_parent --provider codex|claude --session CHILD --parent-provider codex|claude --parent-session PARENT — record an explicit observed navigation relationship without starting work.');
     output('simy delivery supervise [--once] — service already opted-in tasks with this runtime; refuses an active desktop host.');
-    output('simy delivery consult [--scope diagnose|repair_continue] [--request-id USER_TURN_ID] [--context-file context.json] [--provider codex|claude --session ID | --task-id ID] — use observed current conversation or selected original work; repair scope never implies completion.');
-    output('simy delivery diagnose --provider codex|claude --session ID [--task-id ID] [--mode analyze|evidence] [--issues-file issues.json] [--detail brief|full] — advisory diagnosis in a separate process; never resumes the target. Exact --task-id alone is also supported.');
+    output('simy delivery consult [--scope diagnose|repair_continue] [--request-id USER_TURN_ID] [--context-file context.json] [--provider codex|claude --session ID | --task-id ID] — diagnose scope: check why it stopped, using the observed current conversation or selected original work; repair_continue scope never implies completion.');
+    output('simy delivery diagnose --provider codex|claude --session ID [--task-id ID] [--mode analyze|evidence] [--issues-file issues.json] [--detail brief|full] — advisory check of why it stopped, in a separate process; never resumes the target. Exact --task-id alone is also supported.');
     output('simy delivery evidence --provider codex|claude --session ID — read-only execution and acceptance receipts.');
     output('simy delivery activity [--watch] [--json] [--provider codex|claude] [--session ID] — local observations every 60 seconds; not productive time.');
     output('A task stops after repeated failures, and pauses for review when no progress is confirmed. Resume starts a new progress window.');

package/src/delivery-hooks/supervisor-watchdog.js

@@ -20,12 +20,13 @@ async function verifiedPin(root) {
   return { digest: pin.digest, release: pin.release };
 }
 export async function setSupervisorWatchdog({ root, enabled, webOrigin,
-  inspectPin = verifiedPin, now = Date.now(), expectedEpoch, target } = {}) {
+  inspectPin = verifiedPin, now = Date.now(), expectedEpoch, target,
+  identity = supervisorProcessIdentity } = {}) {
   if (target && !enabled) throw new Error('A recovery target requires explicit enable.');
   const binding = target ? await supervisorTarget(root, target) : null;
   const pin = enabled ? await inspectPin(root) : null;
   const lock = await acquireDesktopProcessLock(join(folder(root), 'control-lock'), {
-    alive: supervisorProcessAlive, identity: supervisorProcessIdentity });
+    alive: supervisorProcessAlive, identity });
   try {
   const previous = await readSupervisorState(controlPath(root));
   if (expectedEpoch !== undefined && previous?.epoch !== expectedEpoch) return previous;