@awak-app/simy-cli 0.7.45 → 0.7.47

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awak-app/simy-cli",
-  "version": "0.7.45",
+  "version": "0.7.47",
   "description": "Local SIMY executor for non-coding Local Tasks and Agentic Loop runs.",
   "type": "module",
   "bin": {
@@ -43,7 +43,7 @@
     "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/provider-plugin-repair.js && node --check ./src/sqm/provider-plugin-status.js && node --check ./src/sqm/advisory-guidance.js && 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/history-store.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/claude-delivery-fault-live-e2e.mjs && 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 && node --check ./scripts/codex-plugin-runtime-e2e.js",
+    "check:real-provider-syntax": "node --check ./scripts/real-codex-probe.js && node --check ./scripts/real-claude-probe.js && node --check ./scripts/claude-stream-acceptance.mjs && node --check ./scripts/claude-delivery-fault-live-e2e.mjs && 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 && node --check ./scripts/codex-plugin-runtime-e2e.js",
     "check:syntax": "node --check ./src/purpose-local-proof.js && node --check ./src/device-signing-identity.js && 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/connection-diagnostics.js && node --check ./src/launch-authorization.js && node --check ./src/codex-plugins/simy/hooks/connection-reminder.mjs && node --check ./src/codex-plugins/simy/hooks/dev-work.mjs && node --check ./src/dev-work-events.js && 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/login-shell-path.js && node --check ./src/hook-runtime.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 && node --check ./src/delivery-hooks/supervisor.js && node --check ./src/delivery-hooks/recovery.js && node --check ./src/delivery-hooks/supervisor-owner.js && node --check ./src/delivery-hooks/supervisor-watchdog.js && node --check ./src/delivery-hooks/supervisor-service.js && node --check ./scripts/supervisor-watchdog-live-e2e.js && node --check ./src/codex-plugins/simy/hooks/recovery-incident.mjs && node --check ./src/session-supervision/automatic-continuation.js && node --check ./src/session-supervision/stop-notifications.js",
     "check:package": "node ./scripts/check-package-contents.js",
     "build:macos-installer:dev": "bash packaging/build-macos-arm64.sh --unsigned-dev",

package/src/cli-contract.js

@@ -14,7 +14,7 @@ import {
 } from "./durable-local-task-steps-contract.js";
 import { buildExecutionCapabilityContract } from "./execution-capability-contract.js";
 
-export const CLI_VERSION = "0.7.45";
+export const CLI_VERSION = "0.7.47";
 export const CLI_API_CONTRACT_VERSION = 10;
 
 export function narrativeImageCapabilityMetadata() {

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

@@ -0,0 +1,11 @@
+{
+  "mcpServers": {
+    "simy_native": {
+      "command": "./native/launch",
+      "args": ["./native/server.mjs"],
+      "cwd": ".",
+      "env_vars": ["CODEX_APP_TOOLS_PIPE_PATH", "CODEX_MCP_NODE_PATH", "CODEX_BROWSER_USE_NODE_PATH", "CODEX_ELECTRON_RESOURCES_PATH", "CODEX_CLI_PATH", "SIMY_HOME", "HOME", "PATH"],
+      "startup_timeout_sec": 10
+    }
+  }
+}

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

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import {guidancePending} from '../native/guidance-intent.mjs';
 import { decideLoop, compactWorkHistory } from './loop-kernel.mjs';
 import { completionContractIdentity } from './purpose-completion-contract.mjs';
 import { captureDispatchProvenance } from './update-dispatch-identity.mjs';
@@ -34,6 +35,12 @@ import { associationContract, validateAssociationResult } from './action-associa
 import { minimalSufficientChangeInstruction } from './minimal-sufficient.mjs';
 import { continuationMode } from './continuation-policy.mjs';
 import { evaluateOutcomeProgress, restartOutcomeProgressWindow } from './outcome-progress.mjs';
+import { collectMeasurementTransition, retainMeasurementHookInstruction } from './measurement-collector.mjs';
+import { measurementBinding, appendMeasurement, enrollMeasurementFromPolicy, measurementCollectionEnabled, measurementPolicyEnabled } from './measurement-store.mjs';
+const measurementEnabled = async (...args) => {
+  try { const binding = await measurementBinding(...args); return Boolean(binding && measurementCollectionEnabled(...args)); }
+  catch { console.error('Adoption measurement configuration is unreadable; collection is incomplete.'); return false; }
+};
 
 export const TERMINAL = new Set(['completed', 'reported_done', 'stopped', 'failed', 'budget_exhausted']);
 const EVENTS = new Set(['SessionStart', 'UserPromptSubmit', 'Stop', 'StopFailure', 'SessionEnd', 'Interrupt', 'PermissionRequest', 'Notification', 'ConfigChange', 'PostModelSwitch']);
@@ -279,11 +286,15 @@ export async function updateRecord(root, provider, session, mutate, { inspectPro
   // Recovery requires positive process-death evidence and a serialized second
   // observation. Unknown/legacy owners are never reclaimed by age.
   const lockToken = await waitForStateLock(lock, inspectProcess);
-  let temporary, observation, result;
+  let temporary, observation, result, measurementObservation;
   try {
     const stored = await read(file, MAX_STATE_BYTES);
     const previous = await applyArchiveFence(root, applyProviderConsent(stored, await providerLinkState(root, provider)));
     const previousBytes = stored === null ? null : JSON.stringify(stored);
+    const measurementPriorRunId = previous?.run?.id;
+    let priorMeasurement, savedMeasurement;
+    try { savedMeasurement = await measurementBinding(root, provider, session); priorMeasurement = savedMeasurement && measurementCollectionEnabled(root, provider, session) ? savedMeasurement : null; } catch { /* Collection never blocks task state. */ }
+    const measurementPrevious = priorMeasurement ? structuredClone(previous) : null;
     const next = await mutate(previous);
     if (next) {
       // Older file_equals drafts used `path`, which an older verifier could
@@ -295,6 +306,12 @@ export async function updateRecord(root, provider, session, mutate, { inspectPro
         }
       }
       let serialized = JSON.stringify(next);
+      if (Buffer.byteLength(serialized) > MAX_STATE_BYTES) {
+        // Optional raw capture cannot consume the executor's state budget.
+        if (next.measurementObservation) Object.assign(next.measurementObservation, { response: null, responseComplete: false, prompt: null, promptComplete: false });
+        if (next.run?.managed?.measurementProviderResult) Object.assign(next.run.managed.measurementProviderResult, { response: null, responseComplete: false });
+        serialized = JSON.stringify(next);
+      }
       if (Buffer.byteLength(serialized) > MAX_STATE_BYTES / 2 && await compactConsistencyOutbox(root, next))
         serialized = JSON.stringify(next);
       if (Buffer.byteLength(serialized) > MAX_STATE_BYTES) throw new Error('Delivery state exceeds 4 MiB; retain history before reducing task details.');
@@ -317,9 +334,31 @@ export async function updateRecord(root, provider, session, mutate, { inspectPro
       // Runtime identity is revalidated by the caller that has a fresh direct
       // observation. Persistence alone is never treated as execution evidence.
       observation = { ...next, runtime: null };
+      let enrollProspectively = false;
+      try { enrollProspectively = (next.run?.id !== measurementPriorRunId || !next.run && !savedMeasurement) && measurementPolicyEnabled(root, provider, next.cwd); } catch { /* Collection never blocks task state. */ }
+      if (priorMeasurement || enrollProspectively)
+        measurementObservation = { previous: measurementPrevious, priorRunId: measurementPriorRunId, current: next, trace: priorMeasurement?.trace };
     }
     result = next;
   } finally { if (temporary) await rm(temporary, { force: true }); await releaseStateLock(lock, lockToken); }
+  if (measurementObservation) {
+    const { previous, priorRunId, current } = measurementObservation;
+    // Artifact reads run outside the task lock. A concurrent stop or new turn
+    // invalidates the snapshot instead of delaying a control or inventing S1.
+    const stamp = value => JSON.stringify([value?.run?.id, value?.run?.revision, value?.run?.controlRevision,
+      value?.run?.continuations, value?.run?.managed?.executionAttempt, value?.measurementObservation?.id,
+      value?.run?.managed?.measurementProviderResult?.id, value?.autoContinue, value?.providerArchived]);
+    const expected = stamp(current);
+    const validateCapture = async () => stamp(await read(file, MAX_STATE_BYTES)) === expected;
+    let trace = measurementObservation.trace;
+    try {
+      if (await validateCapture()) trace = (await enrollMeasurementFromPolicy({ root, previous: { run: { id: priorRunId } }, current }))?.trace || trace;
+      if (trace) await collectMeasurementTransition({ root, previous, current, trace, validateCapture });
+    } catch {
+      try { await appendMeasurement({ root, provider, session, trace, type: 'gap', key: `capture:${createHash('sha256').update(expected).digest('hex')}`, data: { reason: 'capture_failed' } }); }
+      catch { console.error('Adoption measurement journal unavailable; collection is incomplete.'); }
+    }
+  }
   // Do not wait on process inspection or the collector while holding the
   // delivery state lock. A matching fresh identity is required for start.
   if (observation) void (async () => {
@@ -1636,10 +1675,10 @@ export function externalReviewIsCurrent(managed,review,now) {
   const refs=[...(review.criteria||[]).filter(row=>row.passed),...(review.rules||[]).filter(row=>row.status==='satisfied'),...(review.workUnits||[])].flatMap(row=>row.evidenceRefs||[]).filter(link=>/^[a-f0-9]{64}$/.test(link.ref));
   // A flexible semantic verdict refers to its actual inspection, including
   // external observations even when no authored citation was supplied.
-  if (review.semanticInspection?.source === 'controller_actual_read_set') refs.push(...(review.semanticInspection.observationRefs || []).map(ref => ({ ref })));
+  if (['controller_actual_read_set', 'controller_conversation_answer'].includes(review.semanticInspection?.source)) refs.push(...(review.semanticInspection.observationRefs || []).map(ref => ({ ref })));
   const ledger=managed.purpose.evidence;
   const observations=[...(ledger?.observations||[]),...(ledger?.reviewObservationActionId===(review.decisionId||managed.decision.id) ? ledger.reviewObservations||[] : [])];
-  const inspected = new Set(review.semanticInspection?.source === 'controller_actual_read_set' ? review.semanticInspection.observationRefs || [] : []);
+  const inspected = new Set(['controller_actual_read_set', 'controller_conversation_answer'].includes(review.semanticInspection?.source) ? review.semanticInspection.observationRefs || [] : []);
   return refs.filter(link => inspected.has(link.ref) || observations.some(item => item.id === link.ref))
     .every(link=>observations.some(item=>item.id===link.ref && item.status==='observed' && currentPurposeObservation(item,now,review.observationWindow)));
 
@@ -1761,7 +1800,7 @@ export async function settlePurposeVerification({ root, provider, session, expec
       } else if (pending.length && pending.every(c => c.check.type === 'manual')) {
         run.state = 'verification_pending'; run.reason = 'Only explicitly human acceptance remains.'; state.phase = 'waiting';
         run.checkpoint = { status: 'completed', summary: review.summary }; managed.autoRecovery = false;
-      } else review = { ...review, passed: false, needsHuman: false, findings: ['Local acceptance changed during review; investigate and recheck.'] };
+      } else if (review.passed || review.needsHuman) review = { ...review, passed: false, needsHuman: false, findings: ['Local acceptance changed during review; investigate and recheck.'] };
     }
     state.review={...review,decisionId:managed.decision.id};
     if (!review.passed && !review.needsHuman && openFindings.some(item => item.observation)) {
@@ -2423,6 +2462,7 @@ function recordManagedOutcomeProgress(run, now, assessmentAvailable = true) {
 // Manual/legacy runs have no marker and retain their existing controls.
 export const ownerRenewalPending = record => ['awaiting_human', 'prepared', 'gate_committed'].includes(record?.run?.managed?.ownerRenewal?.status);
 export function automaticContinuationAllowed(record) {
+  if (guidancePending(record)) return false;
   if (ownerRenewalPending(record) || record?.run?.managed?.ownerRenewal?.needsReadOnlyReassessment === true) return false;
   if (record?.providerArchived === true || record?.run?.managed?.purpose && record.autoContinue === false) return false;
   const epoch = record?.run?.managed?.autoContinueEpoch;
@@ -2786,6 +2826,18 @@ async function handleHookState({ input, provider, root = rootDirectory(), now =
       return record;
     }
     record.observedAt = now; record.lastEvent = event;
+    if (await measurementEnabled(root, provider, input.session_id)) {
+      // Claude's hook has no stable turn identifier. Preserve it as unknown
+      // rather than deduplicating separate identical assistant messages.
+      if (['Stop', 'StopFailure', 'UserPromptSubmit', 'Interrupt', 'PermissionRequest'].includes(event))
+        record.measurementObservation = { id: input.turn_id || input.tool_use_id || randomUUID(), event, at: now,
+          stable: Boolean(input.turn_id || input.tool_use_id), hookActive: input.stop_hook_active === true,
+          response: typeof input.last_assistant_message === 'string' ? input.last_assistant_message.slice(0, 65536) : null,
+          responseComplete: typeof input.last_assistant_message === 'string' && input.last_assistant_message.length <= 65536,
+          prompt: event === 'UserPromptSubmit' && typeof input.prompt === 'string' ? input.prompt.slice(0, 65536) : null,
+          promptComplete: event === 'UserPromptSubmit' && typeof input.prompt === 'string' && input.prompt.length <= 65536,
+          origin: typeof input.origin?.kind === 'string' ? input.origin.kind.slice(0, 80) : null };
+    }
     if (provider === 'claude' && identity && ['SessionStart', 'UserPromptSubmit', 'Stop', 'StopFailure', 'SessionEnd', 'Interrupt', 'ConfigChange', 'PostModelSwitch'].includes(event)) {
       // Optional model/mode observations are not complete permission evidence.
       // Only an explicit empty task AND wakeup registry proves this boundary.
@@ -3043,6 +3095,10 @@ async function handleHookState({ input, provider, root = rootDirectory(), now =
         current.run.state !== observed.run.state) return {};
     output.reason += '\n' + perspectiveInstruction(memory);
   }
+  if (output.decision === 'block') {
+    try { await retainMeasurementHookInstruction({ root, record: observed, text: output.reason }); }
+    catch { console.error('Adoption measurement instruction context unavailable; collection is incomplete.'); }
+  }
   return output;
 }
 export function canReplanDelivery(run, provider, now = Date.now()) {

package/src/codex-plugins/simy/hooks/measurement-collector.mjs

@@ -0,0 +1,130 @@
+import { appendMeasurement, measurementBinding, measurementDirectory, measurementEventForSource, measurementCollectionEnabled, retainMeasurementArtifact } from './measurement-store.mjs';
+import { measurementDigest } from './measurement-contract.mjs';
+import { captureMeasurementSnapshot } from './measurement-snapshot.mjs';
+import { judgeMeasurementStop, readFrozenMeasurementJudge } from './measurement-judge.mjs';
+import { join } from 'node:path';
+
+const terminal = new Set(['completed', 'reported_done', 'stopped', 'failed', 'budget_exhausted']);
+// Called after state persistence, outside the task lock. The caller rechecks
+// the exact task/turn before and after artifact capture. It cannot authorize work.
+export async function collectMeasurementTransition({ root, previous, current, trace, capture = captureMeasurementSnapshot, validateCapture = async () => true }) {
+  if (!current) return;
+  const binding = await measurementBinding(root, current.provider, current.session, trace);
+  if (!binding) return;
+  if (!measurementCollectionEnabled(root, current.provider, current.session, binding.trace)) return;
+  const directory = measurementDirectory(root, current.provider, current.session, binding.trace);
+  if (!current.run && binding.loop === 'off' && binding.task === measurementDigest(`passive:${current.session}`))
+    current = { ...current, run: { id: `passive:${current.session}`, state: 'observing', continuations: 0 } };
+  if (!current.run) return;
+  const run = current.run, prior = previous?.run?.id === run.id ? previous.run : null;
+  const append = (type, key, data, at) => appendMeasurement({ root, provider: current.provider, session: current.session, trace: binding.trace, type, key, data, at });
+  if (binding.task !== measurementDigest(run.managed?.taskId || run.id)) {
+    await append('gap', `foreign_run:${run.id}`, { reason: 'history_incomplete' }); return;
+  }
+  const priorResults = new Set(prior?.resultCycle?.events?.map(row => row.id) || []);
+  const hook = current.measurementObservation;
+  const newHook = hook && JSON.stringify(hook) !== JSON.stringify(previous?.measurementObservation);
+  const results = (run.resultCycle?.events || []).filter(row => !(newHook && ['Stop', 'StopFailure'].includes(hook.event) && row.kind === 'stop'));
+  if (newHook && ['Stop', 'StopFailure'].includes(hook.event)) {
+    results.push({ id: `turn:${hook.id}`, kind: hook.event === 'StopFailure' ? 'failure' : 'stop', at: hook.at, stable: hook.stable });
+    if (!hook.stable) await append('gap', `hook_identity:${hook.id}`, { reason: 'unknown_stop_identity' }, hook.at);
+  }
+  if (newHook && hook.event === 'UserPromptSubmit') {
+    const event = await append('user_input', hook.id, { input: measurementDigest(hook.id) }, hook.at);
+    await retainMeasurementArtifact(join(directory, 'inputs', `${event.id}.json`), { schemaVersion: 1,
+      source: 'provider_user_role_hook', origin: hook.origin || null, prompt: hook.prompt || null, complete: hook.promptComplete === true });
+  }
+  if (newHook && ['Interrupt', 'PermissionRequest'].includes(hook.event)) await append('boundary', hook.id, { boundary: hook.event === 'Interrupt' ? 'user_stop' : 'permission' }, hook.at);
+  if (current.providerArchived && !previous?.providerArchived) await append('boundary', `archive:${run.id}`, { boundary: 'archive' });
+  if (current.autoContinue === false && previous?.autoContinue === true) await append('boundary', `disconnect:${run.controlRevision}`, { boundary: 'disconnect' });
+  if (run.managed?.nativeWait && JSON.stringify(run.managed.nativeWait) !== JSON.stringify(prior?.managed?.nativeWait))
+    await append('boundary', `native:${measurementDigest(run.managed.nativeWait)}`, { boundary: 'permission' });
+  if (run.managed?.userQuestion && run.managed.userQuestion !== prior?.managed?.userQuestion)
+    await append('boundary', `question:${measurementDigest(run.managed.userQuestion)}`, { boundary: 'question' });
+  if (prior?.managed && JSON.stringify(run.managed?.approvalScopes) !== JSON.stringify(prior.managed.approvalScopes))
+    await append('boundary', `scope:${run.controlRevision}:${run.revision}`, { boundary: 'scope_change' });
+  const providerResult = run.managed?.measurementProviderResult;
+  if (providerResult && providerResult.id !== prior?.managed?.measurementProviderResult?.id)
+    results.push({ id: `turn:${providerResult.turnId || providerResult.id}`, kind: providerResult.success ? 'stop' : 'failure', at: providerResult.at, stable: Boolean(providerResult.turnId) });
+  for (const result of results) {
+    if (priorResults.has(result.id) || !['stop', 'final_response', 'failure', 'checkpoint'].includes(result.kind)) continue;
+    if (await measurementEventForSource({ root, provider: current.provider, session: current.session, trace: binding.trace, type: 'stop', key: result.id })) continue;
+    // A structured checkpoint is not a natural provider turn end. The
+    // distinction is retained so it cannot become an S1 counterfactual.
+    const spec = await readFrozenMeasurementJudge(directory);
+    let snapshot = null;
+    try {
+      if (!await validateCapture()) throw new Error('Task changed before snapshot.');
+      snapshot = await capture({ directory, cwd: run.executionCwd || current.cwd, requiredPaths: spec?.checks.map(check => check.path) || [],
+      context: { objective: run.objective || null, originalContext: run.managed?.purpose?.originalContext || null, checkpoint: run.checkpoint || null,
+        providerResponse: newHook ? hook.response || null : providerResult?.response || run.managed?.finalResponseWithoutCheckpoint || null,
+        responseComplete: newHook ? hook.responseComplete === true : providerResult?.responseComplete === true } });
+      if (!await validateCapture()) throw new Error('Task changed during snapshot.');
+    }
+    catch { snapshot = null; await append('gap', `snapshot:${result.id}`, { reason: 'snapshot_unavailable' }, result.at); }
+    const stop = await append('stop', result.id, { snapshot: snapshot?.id || null, candidate: snapshot?.candidate || null,
+      natural: result.kind === 'stop' ? result.stable === false ? null : true : result.kind === 'checkpoint' ? false : null,
+      stop_kind: result.kind === 'failure' ? 'error' : 'unknown', influenced: (prior?.continuations || 0) > 0 ? true : null }, result.at);
+    if (snapshot && spec) await judgeMeasurementStop({ root, provider: current.provider, session: current.session, trace: binding.trace, stop, spec });
+  }
+  if (run.continuations > (prior?.continuations || 0)) {
+    await append('instruction', `continuation:${run.continuations}`, { decision: measurementDigest(run.managed?.decision?.id || `continuation:${run.continuations}`), instruction_type: 'unknown', dispatched: null }, run.updatedAt);
+    if (run.continuations - (prior?.continuations || 0) > 1) await append('gap', `continuations:${run.continuations}`, { reason: 'history_incomplete' }, run.updatedAt);
+  }
+  const attempt = run.managed?.executionAttempt, oldAttempt = prior?.managed?.executionAttempt;
+  if (attempt?.id && (!oldAttempt || oldAttempt.id !== attempt.id || oldAttempt.phase !== attempt.phase) && ['claimed', 'dispatching'].includes(attempt.phase)) {
+    await append('execution', `${attempt.id}:${attempt.phase}`, { attempt: measurementDigest(attempt.id), phase: attempt.phase, decision: attempt.decisionId ? measurementDigest(attempt.decisionId) : null, provider_turn: attempt.providerTurnId ? measurementDigest(attempt.providerTurnId) : null }, attempt.dispatchedAt || attempt.claimedAt);
+  }
+  if (attempt?.id && attempt.startedAt && (oldAttempt?.id !== attempt.id || !oldAttempt.startedAt)) {
+    await append('execution', `${attempt.id}:started`, { attempt: measurementDigest(attempt.id), phase: 'started', decision: attempt.decisionId ? measurementDigest(attempt.decisionId) : null, provider_turn: attempt.providerTurnId ? measurementDigest(attempt.providerTurnId) : null }, attempt.startedAt);
+    const instruction = await append('instruction', `attempt:${attempt.id}`, { decision: measurementDigest(attempt.decisionId || attempt.id), instruction_type: 'unknown', dispatched: true }, attempt.startedAt);
+    await retainMeasurementArtifact(join(directory, 'instructions', `${instruction.id}.json`), { schemaVersion: 1, source: 'controller_dispatch_context',
+      objective: run.objective || null, nextStep: run.nextStep || null, action: attempt.action || null, decision: run.managed?.decision || null });
+  }
+  for (const receipt of run.managed?.attempts || []) {
+    if ((prior?.managed?.attempts || []).some(row => row.id === receipt.id && row.outcome === receipt.outcome)) continue;
+    if (!['failed', 'cancelled', 'busy', 'checkpoint'].includes(receipt.outcome)) continue;
+    await append('execution', `${receipt.id}:${receipt.outcome}`, { attempt: measurementDigest(receipt.id), phase: receipt.outcome, decision: receipt.decisionId ? measurementDigest(receipt.decisionId) : null, provider_turn: attempt?.id === receipt.id && attempt.providerTurnId ? measurementDigest(attempt.providerTurnId) : null }, receipt.endedAt || receipt.finishedAt || receipt.at);
+    if (!['busy', 'cancelled'].includes(receipt.outcome) && run.managed?.lastUsage?.attemptId !== receipt.id)
+      await append('cost', `unavailable:${receipt.id}`, { attempt: measurementDigest(receipt.id), tokens: null, turns: null, amount_micros: null, currency: 'unknown', basis: 'unavailable' }, receipt.finishedAt || receipt.at);
+  }
+  const usage = run.managed?.lastUsage;
+  if (usage?.attemptId && JSON.stringify(usage) !== JSON.stringify(prior?.managed?.lastUsage)) {
+    await append('cost', `usage:${usage.attemptId}`, { attempt: measurementDigest(usage.attemptId), tokens: Number.isSafeInteger(usage.tokens) ? usage.tokens : null,
+      turns: null, amount_micros: null, currency: 'unknown', basis: 'provider_usage' });
+  }
+  if (run.stopReason?.actor === 'user' && JSON.stringify(run.stopReason) !== JSON.stringify(prior?.stopReason)) {
+    await append('boundary', `control:${run.controlRevision}:${run.stopReason.at}`, { boundary: run.state === 'paused' ? 'user_pause' : 'user_stop' }, run.stopReason.at);
+  }
+  if (terminal.has(run.state) && prior?.state !== run.state) await append('run_finished', `terminal:${run.state}:${run.controlRevision || 0}:${run.revision}`, { state: run.state }, run.updatedAt);
+}
+
+export async function retainMeasurementHookInstruction({ root, record, text }) {
+  if (!record?.run || typeof text !== 'string') return;
+  const binding = await measurementBinding(root, record.provider, record.session);
+  if (!binding || binding.task !== measurementDigest(record.run.managed?.taskId || record.run.id) ||
+      !measurementCollectionEnabled(root, record.provider, record.session, binding.trace)) return;
+  const event = await measurementEventForSource({ root, provider: record.provider, session: record.session, trace: binding.trace,
+    type: 'instruction', key: `continuation:${record.run.continuations}` });
+  if (!event) return;
+  await retainMeasurementArtifact(join(measurementDirectory(root, record.provider, record.session, binding.trace), 'instructions', `${event.id}.json`), {
+    schemaVersion: 1, source: 'generated_hook_instruction', emitted: null, text: text.slice(0, 65536), complete: text.length <= 65536,
+  });
+}
+
+export async function recordMeasurementSqm({ root, provider, session, trace, result }) {
+  if (!provider || !session || !result?.proof) return;
+  const binding = await measurementBinding(root, provider, session, trace);
+  if (!binding || !measurementCollectionEnabled(root, provider, session, binding.trace)) return;
+  const proof = result.proof, findings = proof.findings || result.findings || [];
+  await retainMeasurementArtifact(join(measurementDirectory(root, provider, session, binding.trace), 'sqm-proofs', `${measurementDigest(proof.proof_id)}.json`), {
+    schemaVersion: 1, proof, signedEvidence: result.signed_evidence || null,
+  });
+  const id = finding => measurementDigest(finding.finding_id || finding.id || finding);
+  await appendMeasurement({ root, provider, session, trace: binding.trace, type: 'sqm', key: proof.proof_id,
+    data: { proof: measurementDigest(proof.proof_id), candidate: measurementDigest(proof.repository_identity),
+      outcome: ['passed', 'failed', 'requires_human', 'requires_post_deploy', 'skipped'].includes(proof.outcome?.status) ? proof.outcome.status : 'unavailable',
+      findings: [...new Set(findings.map(id))], blocking: [...new Set(findings.filter(f => f.enforcement === 'blocking').map(id))],
+      advisory: [...new Set(findings.filter(f => f.enforcement !== 'blocking').map(id))],
+      scenarios: (proof.executions || []).reduce((sum, row) => sum + (row.scenarios?.length || 0), 0) } });
+}

package/src/codex-plugins/simy/hooks/measurement-contract.mjs

@@ -0,0 +1,51 @@
+import { createHash } from 'node:crypto';
+
+export const measurementDigest = value => createHash('sha256').update(typeof value === 'string' || value instanceof Uint8Array ? value : JSON.stringify(value)).digest('hex');
+export const MEASUREMENT_VERSION = 'adoption_measurement.v1';
+// Cloud transport is deliberately content-free. Artifacts and judge specifications
+// remain local; every reference below is a digest, never a path or conversation.
+export const MEASUREMENT_FIELDS = Object.freeze({
+  run_started: { loop: ['on', 'off'], cohort: 'hash', repository: 'nullable_repository', runtime: 'nullable_hash', collector: 'hash' },
+  stop: { snapshot: 'nullable_hash', candidate: 'nullable_hash', natural: 'nullable_boolean', stop_kind: ['unknown', 'claimed_done', 'plan_only', 'question', 'error', 'limit'], influenced: 'nullable_boolean' },
+  instruction: { decision: 'hash', instruction_type: ['unknown', 'boilerplate', 'informative', 'owner_wait'], dispatched: 'nullable_boolean' },
+  execution: { attempt: 'hash', phase: ['claimed', 'dispatching', 'started', 'finished', 'failed', 'cancelled', 'busy', 'checkpoint'], decision: 'nullable_hash', provider_turn: 'nullable_hash' },
+  sqm: { proof: 'hash', candidate: 'hash', outcome: ['passed', 'failed', 'requires_human', 'requires_post_deploy', 'skipped', 'unavailable'], findings: 'hashes', blocking: 'hashes', advisory: 'hashes', scenarios: 'integer' },
+  sqm_attempt: { attempt: 'hash', phase: ['min', 'full'], outcome: ['passed', 'failed', 'unavailable', 'unknown'], candidate: 'nullable_hash', diagnostic: 'nullable_hash' },
+  judge: { stop: 'hash', snapshot: 'hash', judge: 'hash', scope: ['artifact_predicates', 'task_acceptance'], satisfied: 'boolean', passed: 'integer', total: 'integer', violations: 'hashes' },
+  stop_label: { stop: 'hash', reviewer: 'hash', stop_kind: ['claimed_done', 'plan_only', 'question', 'error', 'limit'], influenced: 'boolean' },
+  instruction_label: { instruction: 'hash', reviewer: 'hash', instruction_type: ['boilerplate', 'informative', 'owner_wait'] },
+  resolution: { finding: 'hash', first_proof: 'hash', final_proof: 'nullable_hash', actor: ['controller', 'human', 'unresolved', 'unknown'], evidence: 'hash', reviewer: 'hash' },
+  gate: { gate: ['premature_finish', 'after_stop', 'permission', 'scope', 'resume_stopped', 'candidate_identity', 'execution_evidence', 'gap_disclosure', 'correct_recheck', 'pass_handling', 'handoff'], outcome: ['passed', 'failed', 'unknown'], evidence: 'hash', reviewer: 'hash' },
+  user_input: { input: 'hash' },
+  boundary: { boundary: ['user_stop', 'user_pause', 'permission', 'question', 'scope_change', 'archive', 'disconnect'] },
+  cost: { attempt: 'hash', tokens: 'nullable_integer', turns: 'nullable_integer', amount_micros: 'nullable_integer', currency: ['unknown', 'USD', 'JPY'], basis: ['provider_usage', 'billing', 'unavailable'] },
+  run_finished: { state: ['completed', 'reported_done', 'stopped', 'failed', 'budget_exhausted'] },
+  gap: { reason: ['capture_failed', 'snapshot_unavailable', 'late_enrollment', 'unknown_stop_identity', 'usage_unavailable', 'journal_error', 'history_incomplete'] },
+});
+const hashPattern = /^[a-f0-9]{64}$/;
+function fieldValid(value, type) {
+  if (Array.isArray(type)) return type.includes(value);
+  if (type.startsWith('nullable_')) return value === null || fieldValid(value, type.slice(9));
+  if (type === 'hash') return typeof value === 'string' && hashPattern.test(value);
+  if (type === 'repository') return typeof value === 'string' && /^[a-zA-Z0-9_.-]{1,100}\/[a-zA-Z0-9_.-]{1,100}$/.test(value);
+  if (type === 'hashes') return Array.isArray(value) && value.length <= 512 && new Set(value).size === value.length && value.every(item => fieldValid(item, 'hash'));
+  if (type === 'boolean') return typeof value === 'boolean';
+  return type === 'integer' && Number.isSafeInteger(value) && value >= 0;
+}
+export function validateMeasurementEvent(event) {
+  const keys = ['version', 'trace', 'provider', 'session', 'task', 'sequence', 'source', 'layer', 'type', 'at', 'data', 'id'];
+  const fields = Object.hasOwn(MEASUREMENT_FIELDS, event?.type) ? MEASUREMENT_FIELDS[event.type] : null;
+  if (!event || Object.keys(event).length !== keys.length || keys.some(key => !Object.hasOwn(event, key)) || !fields ||
+      event.version !== MEASUREMENT_VERSION || !['codex', 'claude'].includes(event.provider) ||
+      !['field', 'fixture'].includes(event.source) || ![null, 'N', 'S', 'F', 'W', 'X', 'B'].includes(event.layer) ||
+      !['trace', 'session', 'task', 'id'].every(key => fieldValid(event[key], 'hash')) ||
+      !Number.isSafeInteger(event.sequence) || event.sequence < 1 ||
+      typeof event.at !== 'string' || !/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d{3}Z$/.test(event.at) || !Number.isFinite(Date.parse(event.at)) || new Date(event.at).toISOString() !== event.at ||
+      !event.data || typeof event.data !== 'object' || Array.isArray(event.data) ||
+      Object.keys(event.data).length !== Object.keys(fields).length ||
+      Object.entries(fields).some(([key, type]) => !fieldValid(event.data[key], type))) throw new Error('Invalid adoption measurement event.');
+  const { id, ...unsigned } = event;
+  if (id !== measurementDigest(unsigned) || Buffer.byteLength(JSON.stringify(event)) > 65536) throw new Error('Adoption measurement identity mismatch.');
+  if (event.type === 'judge' && (event.data.total < 1 || event.data.passed > event.data.total || event.data.satisfied !== (event.data.passed === event.data.total && event.data.violations.length === 0))) throw new Error('Invalid independent judgement.');
+  return event;
+}

package/src/codex-plugins/simy/hooks/measurement-judge.mjs

@@ -0,0 +1,46 @@
+import { readFile } from 'node:fs/promises';
+import { join, isAbsolute } from 'node:path';
+import { measurementDigest } from './measurement-contract.mjs';
+import { appendMeasurement, measurementDirectory } from './measurement-store.mjs';
+import { readMeasurementSnapshot } from './measurement-snapshot.mjs';
+
+// Declarative, held-out predicates only. Never execute a command supplied by a
+// provider or let a judge create the very output it is supposed to evaluate.
+export function validateMeasurementJudge(spec) {
+  if (spec?.version !== 'artifact_judge.v1' || Object.keys(spec).some(key => !['version', 'checks', 'scope'].includes(key)) ||
+      ![undefined, 'artifact_predicates', 'task_acceptance'].includes(spec.scope) ||
+      !Array.isArray(spec.checks) || !spec.checks.length || spec.checks.length > 256) throw new Error('Invalid held-out judge.');
+  const ids = new Set();
+  for (const check of spec.checks) {
+    if (!check || typeof check.id !== 'string' || !check.id || ids.has(check.id) ||
+        typeof check.path !== 'string' || isAbsolute(check.path) || check.path.split(/[\\/]/).some(part => ['..', '.', ''].includes(part)) ||
+        !['equals', 'contains', 'absent', 'sha256'].includes(check.type) ||
+        Object.keys(check).some(key => !['id', 'path', 'type', 'expected', 'gate'].includes(key)) ||
+        typeof check.gate !== 'boolean' || check.type !== 'absent' && typeof check.expected !== 'string' ||
+        check.type === 'sha256' && !/^[a-f0-9]{64}$/.test(check.expected) ||
+        check.type === 'contains' && !check.expected) throw new Error('Invalid held-out predicate.');
+    ids.add(check.id);
+  }
+  return spec;
+}
+export async function judgeMeasurementStop({ root, provider, session, trace, stop, spec }) {
+  validateMeasurementJudge(spec);
+  if (stop.type !== 'stop' || !stop.data.snapshot) throw new Error('No complete snapshot to judge.');
+  const snapshot = await readMeasurementSnapshot(measurementDirectory(root, provider, session, trace), stop.data.snapshot, { paths: spec.checks.map(check => check.path) });
+  if (spec.checks.some(check => !snapshot.manifest.files.some(file => file.path === check.path))) throw new Error('Judge artifact was not included in this snapshot.');
+  const verdicts = spec.checks.map(check => {
+    const content = snapshot.files.get(check.path);
+    const passed = check.type === 'absent' ? !content : content !== undefined &&
+      (check.type === 'sha256' ? measurementDigest(content) === check.expected :
+        check.type === 'equals' ? content.equals(Buffer.from(check.expected)) : content.toString('utf8').includes(check.expected));
+    return { id: measurementDigest(check.id), passed, gate: check.gate };
+  });
+  const violations = verdicts.filter(v => v.gate && !v.passed).map(v => v.id), passed = verdicts.filter(v => v.passed).length;
+  return appendMeasurement({ root, provider, session, trace, type: 'judge', key: `${stop.id}:${measurementDigest(spec)}`,
+    data: { stop: stop.id, snapshot: stop.data.snapshot, judge: measurementDigest(spec), scope: spec.scope || 'artifact_predicates', satisfied: passed === verdicts.length && !violations.length,
+      passed, total: verdicts.length, violations } });
+}
+export async function readFrozenMeasurementJudge(directory) {
+  try { return validateMeasurementJudge(JSON.parse(await readFile(join(directory, 'judge.json'), 'utf8'))); }
+  catch (error) { if (error.code === 'ENOENT') return null; throw error; }
+}

package/src/codex-plugins/simy/hooks/measurement-snapshot.mjs

@@ -0,0 +1,89 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { lstat, readFile, mkdir, writeFile, realpath } from 'node:fs/promises';
+import { join, relative, resolve, sep } from 'node:path';
+import { measurementDigest } from './measurement-contract.mjs';
+
+const exec = promisify(execFile);
+const MAX_BYTES = 64 * 1024 * 1024;
+export async function measurementRepository(cwd) {
+  try {
+    const { stdout } = await exec('git', ['remote', 'get-url', 'origin'], { cwd, timeout: 2000, maxBuffer: 4096 });
+    const match = /(?:github\.com[:/])([a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+?)(?:\.git)?\s*$/.exec(stdout);
+    return match?.[1] || null;
+  } catch { return null; }
+}
+// Opt-in capture, local only. A bounded capture is either complete or unknown;
+// a partial directory must never be presented to a judge as the whole artifact.
+export async function captureMeasurementSnapshot({ directory, cwd, context = null, requiredPaths = [], maxBytes = MAX_BYTES }) {
+  cwd = await realpath(cwd);
+  const git = async args => (await exec('git', args, { cwd, maxBuffer: 16 * 1024 * 1024, timeout: 5000 })).stdout;
+  const head = (await git(['rev-parse', 'HEAD'])).trim();
+  const tree = (await git(['rev-parse', 'HEAD^{tree}'])).trim();
+  const patchArgs = ['diff', '--no-ext-diff', '--no-textconv', '--binary', 'HEAD'];
+  const patch = await git(patchArgs);
+  const listedPaths = async () => [...new Set([
+    ...(await git(['diff', '--no-ext-diff', '--no-textconv', '--name-only', '-z', 'HEAD'])).split('\0'),
+    ...(await git(['ls-files', '-z', '--others', '--exclude-standard'])).split('\0'),
+    ...requiredPaths,
+  ].filter(Boolean))].sort();
+  const paths = await listedPaths();
+  if (paths.length > 20000) throw new Error('Snapshot file limit exceeded.');
+  const files = []; let bytes = Buffer.byteLength(JSON.stringify(context)) + Buffer.byteLength(patch);
+  if (bytes > maxBytes) throw new Error('Snapshot byte limit exceeded.');
+  await mkdir(join(directory, 'blobs'), { recursive: true, mode: 0o700 });
+  await mkdir(join(directory, 'snapshots'), { recursive: true, mode: 0o700 });
+  for (const path of paths) {
+    const full = resolve(cwd, path), within = relative(cwd, full);
+    if (within.startsWith(`..${sep}`) || within === '..' || within === '' || full === cwd) throw new Error('Snapshot path escaped workspace.');
+    let parent = cwd;
+    for (const component of within.split(sep).slice(0, -1)) {
+      parent = join(parent, component);
+      let info; try { info = await lstat(parent); } catch (error) { if (error.code === 'ENOENT') break; throw error; }
+      if (!info.isDirectory() || info.isSymbolicLink()) throw new Error('Snapshot path traverses an unsupported directory.');
+    }
+    let before;
+    try { before = await lstat(full); } catch (error) { if (error.code === 'ENOENT') { files.push({ path, deleted: true }); continue; } throw error; }
+    if (!before.isFile()) throw new Error('Snapshot contains unsupported file type.');
+    if (await realpath(full) !== full) throw new Error('Snapshot path traverses a symbolic link.');
+    bytes += before.size;
+    if (bytes > maxBytes) throw new Error('Snapshot byte limit exceeded.');
+    const content = await readFile(full), after = await lstat(full);
+    if (!after.isFile() || after.ino !== before.ino || after.size !== before.size || after.mtimeMs !== before.mtimeMs || after.ctimeMs !== before.ctimeMs || content.length !== before.size) throw new Error('Workspace changed during snapshot.');
+    const blob = measurementDigest(content);
+    files.push({ path, blob, mode: before.mode & 0o777 });
+    // Content-addressed blobs are retained once, not accumulated in RAM for a
+    // repository-sized snapshot. Unchanged baseline assets are named by Git.
+    await writeOnce(join(directory, 'blobs', blob), content);
+  }
+  if ((await git(['rev-parse', 'HEAD'])).trim() !== head || await git(patchArgs) !== patch ||
+      JSON.stringify(await listedPaths()) !== JSON.stringify(paths)) throw new Error('Workspace identity changed during snapshot.');
+  for (const file of files) {
+    if (file.deleted) { try { await lstat(join(cwd, file.path)); throw new Error('Deleted artifact reappeared.'); } catch (error) { if (error.code !== 'ENOENT') throw error; } }
+    else if (measurementDigest(await readFile(join(cwd, file.path))) !== file.blob) throw new Error('Artifact changed during snapshot.');
+  }
+  const manifest = { schemaVersion: 1, head, tree, patch, files, context,
+    coverage: 'changed_files_and_declared_artifacts', requiredPaths: [...new Set(requiredPaths)].sort(),
+    baselineBytesIncluded: false };
+  const id = measurementDigest(manifest);
+  await writeOnce(join(directory, 'snapshots', `${id}.json`), JSON.stringify(manifest));
+  return { id, candidate: measurementDigest({ head, tree, patch, files }) };
+}
+async function writeOnce(path, content) {
+  try { await writeFile(path, content, { flag: 'wx', mode: 0o600 }); }
+  catch (error) { if (error.code !== 'EEXIST') throw error; const saved = await readFile(path); if (!saved.equals(Buffer.from(content))) throw new Error('Snapshot content conflict.'); }
+}
+export async function readMeasurementSnapshot(directory, id, { paths = null } = {}) {
+  if (!/^[a-f0-9]{64}$/.test(id)) throw new Error('Invalid snapshot reference.');
+  const manifest = JSON.parse(await readFile(join(directory, 'snapshots', `${id}.json`), 'utf8'));
+  if (measurementDigest(manifest) !== id) throw new Error('Snapshot manifest was modified.');
+  const files = new Map();
+  for (const file of manifest.files) {
+    if (file.deleted || paths && !paths.includes(file.path)) continue;
+    if (!/^[a-f0-9]{64}$/.test(file.blob)) throw new Error('Invalid snapshot blob.');
+    const content = await readFile(join(directory, 'blobs', file.blob));
+    if (measurementDigest(content) !== file.blob) throw new Error('Snapshot blob was modified.');
+    files.set(file.path, content);
+  }
+  return { manifest, files };
+}