@awak-app/simy-cli 0.7.25 → 0.7.27

package/README.md

@@ -345,6 +345,8 @@ from the same maintained source as Codex; only provider terminology and hook/man
 format differ. Installing source files does not imply that either provider has enabled
 the plugin. Existing Claude settings, unrelated marketplaces, and plugins are preserved.
 
+State-only feature-improvement collection ships with the generated Claude plugin, but uploads require the paired desktop CLI runtime to refresh device consent and drain its local outbox. Without that paired authenticated runtime, the plugin remains default-off and does not enable Auto-continue.
+
 After that first installation, the daemon checks installed workflows at startup
 and every hour, including after a CLI automatic upgrade. It updates only existing
 platform installations and refreshes an already enabled SIMY Codex plugin through
@@ -1425,3 +1427,9 @@ interrupted write or approve a pending external action. Explicit task
 stop/pause, provider permission prompts and unanswered user questions remain
 boundaries. `runtime supervisor-disable` is a durable explicit stop and is never
 reversed by waking or booting. A later explicit enable is required.
+
+A recovery read can inspect the one unknown operation it is bound to while
+that operation continues to block writes. Observing the result settles local
+occupancy without accepting the task. Long-running tasks transmit current
+recovery context and recent work; the full history remains in durable state
+and can be inspected through `delivery status`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awak-app/simy-cli",
-  "version": "0.7.25",
+  "version": "0.7.27",
   "description": "Local SIMY executor for non-coding Local Tasks and Agentic Loop runs.",
   "type": "module",
   "bin": {
@@ -39,7 +39,7 @@
     "test:e2e:console:real-provider": "node ./scripts/real-provider-console-e2e.js",
     "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:session-supervision-syntax && npm run check:real-provider-syntax && npm test && npm run check:package",
-    "check:session-supervision-syntax": "node --check ./src/session-supervision/session-list.js && node --check ./src/console/sessions.js && node --check ./src/session-supervision/remote-hosts.js && node --check ./src/session-supervision/remote-entry.js && node --check ./src/session-supervision/index.js && node --check ./src/session-supervision/discovery-window.js && node --check ./src/session-supervision/codex-app-server.js && node --check ./src/session-supervision/claude-sessions.js && node --check ./src/session-supervision/original-session-target.js && node --check ./src/session-supervision/action-association.js && node --check ./src/session-supervision/action-association-host.js && node --check ./src/session-supervision/action-association-api.js && node --check ./src/session-supervision/association-store.js && node --check ./src/session-supervision/action-deadline.js && node --check ./src/session-supervision/action-deadline-store.js && node --check ./src/codex-plugins/simy/hooks/action-association.mjs && node --check ./src/session-supervision/purpose-instruction.js && node --check ./src/session-supervision/purpose-recovery.js && node --check ./src/session-supervision/purpose-candidate.js && node --check ./src/codex-plugins/simy/hooks/scene-reasoning.mjs && node --check ./src/codex-plugins/simy/hooks/purpose-cycle.mjs && node --check ./src/codex-plugins/simy/hooks/purpose-rule-review.mjs && node --check ./src/codex-plugins/simy/hooks/purpose-search.mjs && node --check ./src/codex-plugins/simy/hooks/purpose-evidence.mjs && node --check ./src/session-supervision/purpose-observer.js && node --check ./src/session-supervision/purpose-verification.js && node --check ./src/codex-plugins/simy/hooks/purpose-workspace.mjs && node --check ./scripts/purpose-search-live-e2e.js",
+    "check:session-supervision-syntax": "node --check ./src/session-supervision/session-list.js && node --check ./src/console/sessions.js && node --check ./src/session-supervision/remote-hosts.js && node --check ./src/session-supervision/remote-entry.js && node --check ./src/session-supervision/index.js && node --check ./src/session-supervision/discovery-window.js && node --check ./src/session-supervision/codex-app-server.js && node --check ./src/session-supervision/claude-sessions.js && node --check ./src/session-supervision/original-session-target.js && node --check ./src/session-supervision/action-association.js && node --check ./src/session-supervision/action-association-host.js && node --check ./src/session-supervision/action-association-api.js && node --check ./src/session-supervision/association-store.js && node --check ./src/session-supervision/action-deadline.js && node --check ./src/session-supervision/action-deadline-store.js && node --check ./src/codex-plugins/simy/hooks/action-association.mjs && node --check ./src/session-supervision/purpose-instruction.js && node --check ./src/session-supervision/purpose-recovery.js && node --check ./src/session-supervision/purpose-candidate.js && node --check ./src/codex-plugins/simy/hooks/scene-reasoning.mjs && node --check ./src/codex-plugins/simy/hooks/purpose-cycle.mjs && node --check ./src/codex-plugins/simy/hooks/purpose-rule-review.mjs && node --check ./src/codex-plugins/simy/hooks/purpose-search.mjs && node --check ./src/codex-plugins/simy/hooks/purpose-evidence.mjs && node --check ./src/session-supervision/purpose-observer.js && node --check ./src/session-supervision/purpose-verification.js && node --check ./src/codex-plugins/simy/hooks/purpose-workspace.mjs && node --check ./scripts/purpose-search-live-e2e.js && node --check ./src/session-supervision/remote-managed-delivery.js",
     "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",

package/src/agent.js

@@ -1,4 +1,5 @@
 import { connectionOverview, readSqmConnectionObservation } from './connection-overview.js';
+import { flushObservability, observeHeartbeat, syncObservabilityConsent } from './cli-observability.js';
 import { readLocalPhotoSource } from "./local-photos.js";
 import { resolveLocalTaskDestination, saveLocalTaskDestination } from "./local-task-destination.js";
 import { observePairedNativeIdentities } from './native-provider-identity.js';
@@ -939,6 +940,27 @@ export async function startAgent({
         deviceHeartbeatSucceeded = true;
         connectionStatus.success();
         notifyDesktopStatusChange();
+        // Delivery state persistence writes the bounded local outbox. Draining
+        // it here reuses the authenticated existing runtime; it never creates
+        // a daemon, changes Auto-continue, or blocks the device heartbeat.
+        const observabilityPaired = typeof requestedSession.account_id === 'string' && requestedSession.account_id.length > 0 &&
+          typeof requestedSession.device_id === 'string' && requestedSession.device_id.length > 0;
+        if (observabilityPaired) {
+          void syncObservabilityConsent({
+            root: sessionRoot,
+            apiOrigin,
+            apiBaseUrl: requestedSession.api_base_url,
+            token: requestedSession.token,
+            actor: { accountId: requestedSession.account_id, deviceId: requestedSession.device_id, organizationId: requestedSession.organization_id },
+            fetchImpl: dependencies.fetch || globalThis.fetch,
+          }).then(() => observeHeartbeat(sessionRoot)).then(() => flushObservability({
+            root: sessionRoot,
+            apiOrigin,
+            apiBaseUrl: requestedSession.api_base_url,
+            token: requestedSession.token,
+            fetchImpl: dependencies.fetch || globalThis.fetch,
+          })).catch(() => {});
+        }
         // Register the device immediately; provider subprocesses must not delay
         // browser authorization. Publish verified readiness after their probe.
         const publishVerifiedProviders = async () => {

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.25";
+export const CLI_VERSION = "0.7.27";
 export const CLI_API_CONTRACT_VERSION = 10;
 
 export function narrativeImageCapabilityMetadata() {

package/src/cli-observability.js

@@ -0,0 +1,262 @@
+// State-only feature-improvement transport. It never imports provider clients or
+// serializes conversation content, paths, titles, logs, or credentials.
+import { randomUUID } from 'node:crypto';
+import { link, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { webApiHeaders, webApiUrl } from './web-api.js';
+// Keep this leaf module package-safe: hooks load it before the full CLI contract.
+const CLI_VERSION = '0.7.27';
+
+const STORE = 'cli-observability-state.json';
+const LEGACY_CONFIG = 'cli-observability.json';
+const LEGACY_OUTBOX = 'cli-observability-outbox.json';
+const MAX_BYTES = 256 * 1024, MAX_AGE = 7 * 24 * 60 * 60 * 1000, MAX_FLUSH = 50;
+const 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;
+const EVENT_TYPES = new Set(['settings_changed', 'execution_requested', 'execution_started', 'execution_ended', 'result_confirmed', 'observation_gap', 'heartbeat']);
+const EXECUTION = new Set(['idle', 'start_requested', 'started', 'ended', 'unknown']);
+const RESULTS = new Set(['success', 'failed', 'waiting_human', 'reported_done', 'unknown']);
+const REASONS = new Set(['cancelled', 'needs_user_input', 'timeout', 'provider_error', 'transport_error', 'runtime_recovery', 'queue_overflow', 'sequence_gap', 'clock_skew', 'session_expired']);
+const keyFor = (provider, session) => `${provider}:${session}`;
+const file = (root, name) => join(root, name);
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+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 stdout.trim() || ''; }
+  catch (error) { return error.code === 1 ? '' : null; }
+}
+function environmentFromOrigin(origin) {
+  try {
+    const url = new URL(origin);
+    if (url.protocol !== 'https:' || url.port || url.username || url.password || url.pathname !== '/' || url.search || url.hash) return null;
+    return url.hostname === 'app-dev.simy.one' ? 'dev' : url.hostname === 'app.simy.one' ? 'prod' : null;
+  } catch { return null; }
+}
+async function withStoreLock(root, operation) {
+  const lock = file(root, '.cli-observability.lock');
+  const owner = {
+    pid: process.pid,
+    identity: await processIdentity(process.pid),
+    token: randomUUID(),
+  };
+  await mkdir(root, { recursive: true, mode: 0o700 });
+  const candidate = `${lock}.${owner.token}.candidate`;
+  await writeFile(candidate, JSON.stringify(owner), { mode: 0o600, flag: 'wx' });
+  try {
+    for (let i = 0; i < 40; i++) {
+      try {
+        // link(2) publishes an already-complete owner file atomically.
+        await link(candidate, lock);
+        try {
+          return await operation();
+        } finally {
+          try {
+            const held = JSON.parse(await readFile(lock, 'utf8'));
+            if (held.token === owner.token) await rm(lock, { force: true });
+          } catch {}
+        }
+      } catch (error) {
+        if (error.code !== 'EEXIST') throw error;
+        let prior;
+        try {
+          prior = JSON.parse(await readFile(lock, 'utf8'));
+          const current = await processIdentity(prior?.pid);
+          if (current !== '' && !(current && prior?.identity && current !== prior.identity)) {
+            await sleep(10 + Math.floor(Math.random() * 10));
+            continue;
+          }
+          // Move the exact stale inode away. This avoids a stale contender
+          // deleting a replacement lock published by another process.
+          const reclaimed = `${lock}.${owner.token}.reclaimed`;
+          await rename(lock, reclaimed);
+          const moved = JSON.parse(await readFile(reclaimed, 'utf8'));
+          if (moved?.token !== prior?.token) {
+            // A release/reacquire raced us. Restore only if nobody has already
+            // published a replacement; never remove a lock we do not own.
+            try { await link(reclaimed, lock); } catch {}
+          }
+          await rm(reclaimed, { force: true });
+        } catch {}
+        await sleep(10 + Math.floor(Math.random() * 10));
+      }
+    }
+  } finally {
+    await rm(candidate, { force: true });
+  }
+  throw new Error('Observability store is busy.');
+}
+async function readJson(path, fallback) { try { return JSON.parse(await readFile(path, 'utf8')); } catch (error) { if (error.code === 'ENOENT') return fallback; throw error; } }
+async function saveJson(path, value) { await mkdir(dirname(path), { recursive: true, mode: 0o700 }); const tmp = `${path}.${randomUUID()}.tmp`; try { await writeFile(tmp, `${JSON.stringify(value)}\n`, { mode: 0o600 }); await rename(tmp, path); } finally { await rm(tmp, { force: true }); } }
+function blankConfig() { return { schemaVersion: 1, enabled: false, consentGeneration: null, environment: null, actor: null, conversations: {}, retry: { attempts: 0, at: 0 }, lost: false }; }
+function blankState() { return { schemaVersion: 1, config: blankConfig(), outbox: { schemaVersion: 1, events: [] } }; }
+function validConversation(value) { return value && ['codex', 'claude'].includes(value.provider) && typeof value.session === 'string' && /^[A-Za-z0-9_-]{1,256}$/.test(value.session) && UUID.test(String(value.conversationRef)) && ['dev', 'prod'].includes(value.environment); }
+function validGeneration(value) { return UUID.test(String(value)); }
+async function readStore(root) {
+  const existing = await readJson(file(root, STORE), null);
+  if (existing?.schemaVersion === 1 && existing.config?.conversations && Array.isArray(existing.outbox?.events)) return existing;
+  const oldConfig = await readJson(file(root, LEGACY_CONFIG), null), oldOutbox = await readJson(file(root, LEGACY_OUTBOX), null);
+  if (!oldConfig && !oldOutbox) return blankState();
+  const state = blankState(); state.config = { ...state.config, ...oldConfig, conversations: oldConfig?.conversations || oldConfig?.scopes || {}, lost: !(oldConfig && oldOutbox) };
+  state.outbox = oldOutbox || { schemaVersion: 1, events: [] }; return state;
+}
+async function saveStore(root, state) { await saveJson(file(root, STORE), state); }
+function status(state) { return { enabled: state.config.enabled === true, conversations: Object.values(state.config.conversations).map(({ provider, session, sequence }) => ({ provider, session, sequence })), queued: state.outbox.events.length }; }
+export async function readObservability(root) { return (await readStore(root)).config; }
+export async function observabilityStatus(root) { return status(await readStore(root)); }
+function stateFromRecord(record, now = Date.now()) {
+  const raw = record?.run?.state;
+  const fresh = Number.isFinite(record?.runtime?.observedAt) && now >= record.runtime.observedAt && now - record.runtime.observedAt <= 45_000;
+  const executionState = fresh && record.runtime?.isRunning === true ? 'started' : fresh && record.runtime?.isRunning === false ? 'idle' : ['completed', 'reported_done', 'stopped', 'failed', 'budget_exhausted'].includes(raw) ? 'ended' : 'unknown';
+  return { autoContinue: record?.autoContinue === true ? 'on' : record?.autoContinue === false ? 'off' : 'unknown', executionState,
+    result: raw === 'reported_done' ? 'reported_done' : 'unknown', ...(fresh && record.runtime?.isRunning === true ? { runtimeObservedAt: new Date(record.runtime.observedAt).toISOString() } : {}),
+    ...({ stopped: 'cancelled', budget_exhausted: 'timeout', paused: 'needs_user_input', blocked: 'needs_user_input', recovery_required: 'runtime_recovery' }[raw] ? { reasonCode: ({ stopped: 'cancelled', budget_exhausted: 'timeout', paused: 'needs_user_input', blocked: 'needs_user_input', recovery_required: 'runtime_recovery' })[raw] } : {}) };
+}
+export const observabilityStateFromRecord = stateFromRecord;
+function transition(previous, next) {
+  if (!previous || previous.autoContinue !== next.autoContinue) return previous ? 'settings_changed' : null;
+  if (previous.executionState !== next.executionState) return next.executionState === 'started' ? 'execution_started' : next.executionState === 'ended' ? 'execution_ended' : 'observation_gap';
+  return previous.result !== next.result && next.result !== 'unknown' ? 'result_confirmed' : null;
+}
+function event(conversation, key, type, state, now) {
+  if (!EVENT_TYPES.has(type) || !EXECUTION.has(state.executionState) || !RESULTS.has(state.result)) throw new Error('Invalid observability event.');
+  const request = { schema_version: 1, event_id: randomUUID(), consent_generation: conversation.consentGeneration, provider: conversation.provider, environment: conversation.environment, conversation_ref: conversation.conversationRef, sequence: conversation.sequence, event_type: type, occurred_at: new Date(now).toISOString(), auto_continue: state.autoContinue, execution_state: state.executionState, result: state.result, cli_version: CLI_VERSION };
+  if (state.reasonCode && REASONS.has(state.reasonCode)) request.reason_code = state.reasonCode;
+  if (type === 'execution_started' && state.runtimeObservedAt) request.runtime_observed_at = state.runtimeObservedAt;
+  if (state.missing === true) request.missing = true;
+  return { key, createdAt: now, request };
+}
+function limits(options = {}) { return { maxBytes: options.maxBytes ?? MAX_BYTES, maxAge: options.maxAge ?? MAX_AGE }; }
+function trim(state, now, options) {
+  const dropped = new Map(), { maxBytes, maxAge } = limits(options), remember = (item, reason) => { if (item?.key && !dropped.has(item.key)) dropped.set(item.key, reason); };
+  const retained = []; for (const item of state.outbox.events) { if (!Number.isFinite(item.createdAt) || item.createdAt < now - maxAge) remember(item, 'sequence_gap'); else retained.push(item); } state.outbox.events = retained;
+  while (Buffer.byteLength(JSON.stringify(state.outbox), 'utf8') > maxBytes && state.outbox.events.length) remember(state.outbox.events.shift(), 'queue_overflow');
+  return dropped;
+}
+function enqueueGap(state, key, reason, now) { const c = state.config.conversations[key]; if (!validConversation(c)) return; c.sequence = Number.isSafeInteger(c.sequence) && c.sequence >= 0 ? c.sequence + 1 : 1; state.outbox.events.push(event(c, key, 'observation_gap', { autoContinue: c.last?.autoContinue || 'unknown', executionState: 'unknown', result: 'unknown', reasonCode: reason, missing: true }, now)); }
+function materializeGaps(state, dropped, now, options) {
+  for (const [key, reason] of dropped) enqueueGap(state, key, reason, now);
+  // Gap markers are compact; preserve them in preference to ordinary events.
+  const { maxBytes } = limits(options);
+  const lateDrops = new Map();
+  while (Buffer.byteLength(JSON.stringify(state.outbox), 'utf8') > maxBytes) {
+    const index = state.outbox.events.findIndex(item => item.request?.event_type !== 'observation_gap');
+    if (index < 0) break;
+    const [removed] = state.outbox.events.splice(index, 1);
+    if (removed?.key && !dropped.has(removed.key) && !lateDrops.has(removed.key)) lateDrops.set(removed.key, 'queue_overflow');
+  }
+  // A marker may itself be the only remaining item and be larger than an
+  // artificially tiny test limit; production's 10 MiB limit easily holds it.
+  for (const [key, reason] of lateDrops) enqueueGap(state, key, reason, now);
+}
+function resetForIdentity(state, actor) { state.config = { ...blankConfig(), actor }; state.outbox = { schemaVersion: 1, events: [] }; }
+function sameActor(a, b) { return a && b && a.origin === b.origin && a.accountId === b.accountId && a.deviceId === b.deviceId && a.organizationId === b.organizationId; }
+export async function syncObservabilityConsent({ root, apiOrigin, apiBaseUrl, token, actor, fetchImpl = globalThis.fetch }) {
+  const environment = environmentFromOrigin(apiOrigin);
+  // Collection is defined only for canonical SIMY dev/prod origins. Fixtures,
+  // loopback hosts, and arbitrary origins stay inert without a network call.
+  if (!environment) {
+    const preflight = await readStore(root);
+    if (!preflight.config.enabled && preflight.outbox.events.length === 0) return status(preflight);
+    return withStoreLock(root, async () => {
+      const state = await readStore(root);
+      state.config = blankConfig();
+      state.outbox = { schemaVersion: 1, events: [] };
+      await saveStore(root, state);
+      return status(state);
+    });
+  }
+  const response = await fetchImpl(webApiUrl('devices/heartbeat/?observability=consent', { webOrigin: apiOrigin, apiBaseUrl }), { method: 'POST', headers: webApiHeaders({ token }), body: '{}', signal: AbortSignal.timeout(5_000) });
+  const payload = await response.json().catch(() => null); if (!response.ok) throw new Error('SIMY Web could not read observability consent.');
+  const identity = { origin: apiOrigin, accountId: actor?.accountId || null, deviceId: actor?.deviceId || null, organizationId: actor?.organizationId || null };
+  const generation = payload?.consent_generation;
+  const active = payload?.enabled === true && validGeneration(generation) && typeof identity.accountId === 'string' && identity.accountId.length > 0 && typeof identity.deviceId === 'string' && identity.deviceId.length > 0;
+  // A negative first response is deliberately side-effect free. The periodic
+  // device heartbeat can ask the server for consent, but default OFF must not
+  // create a collector directory that races ordinary temporary-root cleanup.
+  const preflight = await readStore(root);
+  const needsCleanup = preflight.config.enabled || validGeneration(preflight.config.consentGeneration) ||
+    preflight.outbox.events.length > 0 || Object.keys(preflight.config.conversations).length > 0;
+  if (!active && !needsCleanup) return status(preflight);
+  return withStoreLock(root, async () => {
+    const state = await readStore(root);
+    if (!active) {
+      if (state.config.actor && !sameActor(state.config.actor, identity)) resetForIdentity(state, identity); else state.config.actor = identity;
+      state.outbox.events = [];
+      for (const c of Object.values(state.config.conversations)) { c.sequence = 0; c.last = null; }
+      state.config.enabled = false;
+      state.config.environment = environment;
+      state.config.consentGeneration = null;
+      state.config.retry = { attempts: 0, at: 0 };
+      await saveStore(root, state);
+      return status(state);
+    }
+    if (state.config.actor && !sameActor(state.config.actor, identity)) resetForIdentity(state, identity); else state.config.actor = identity;
+    if (state.config.consentGeneration && state.config.consentGeneration !== generation) {
+      state.outbox.events = [];
+      for (const c of Object.values(state.config.conversations)) { c.sequence = 0; c.last = null; }
+    }
+    state.config.enabled = true;
+    state.config.environment = environment;
+    state.config.consentGeneration = generation;
+    state.config.retry = { attempts: 0, at: 0 };
+    await saveStore(root, state);
+    return status(state);
+  });
+}
+// Called only after authoritative record persistence. The lock covers every
+// state/outbox write; it is intentionally never held while network I/O runs.
+export async function observeDeliveryRecord(root, record, now = Date.now(), options = {}) {
+  if (!record || !['codex', 'claude'].includes(record.provider) || typeof record.session !== 'string') return false;
+  // Default OFF must be inert: do not create a lock, directory, or queue until
+  // the paired device has recorded active consent. Recheck under the lock so a
+  // concurrent consent change cannot publish an event under a stale generation.
+  const preflight = (await readStore(root)).config;
+  if (!preflight.enabled || !validGeneration(preflight.consentGeneration) || !['dev', 'prod'].includes(preflight.environment)) return false;
+  return withStoreLock(root, async () => { const state = await readStore(root), config = state.config; if (!config.enabled || !validGeneration(config.consentGeneration) || !['dev', 'prod'].includes(config.environment)) return false;
+    const key = keyFor(record.provider, record.session); let c = config.conversations[key];
+    if (!c) { c = config.conversations[key] = { provider: record.provider, session: record.session, environment: config.environment, conversationRef: randomUUID(), consentGeneration: config.consentGeneration, sequence: 0, last: stateFromRecord(record, now), lastObservedAt: now };
+      if (config.lost) { enqueueGap(state, key, 'sequence_gap', now); config.lost = false; await saveStore(root, state); return true; }
+      await saveStore(root, state); return false; // baseline is never a historical event
+    }
+    if (!validConversation(c)) return false; c.consentGeneration = config.consentGeneration; c.environment = config.environment;
+    const next = stateFromRecord(record, now), type = transition(c.last, next); c.last = next; c.lastObservedAt = now; if (!type) { await saveStore(root, state); return false; }
+    c.sequence = Number.isSafeInteger(c.sequence) && c.sequence >= 0 ? c.sequence + 1 : 1; state.outbox.events.push(event(c, key, type, next, now)); materializeGaps(state, trim(state, now, options), now, options); await saveStore(root, state); return true; });
+}
+export async function observeHeartbeat(root, now = Date.now(), options = {}) {
+  const preflight = (await readStore(root)).config;
+  if (!preflight.enabled || !validGeneration(preflight.consentGeneration)) return false;
+  return withStoreLock(root, async () => {
+    const state = await readStore(root), config = state.config;
+    if (!config.enabled || !validGeneration(config.consentGeneration)) return false;
+    const active = Object.entries(config.conversations).filter(([, conversation]) =>
+      validConversation(conversation) && Number.isFinite(conversation.lastObservedAt) &&
+      now - conversation.lastObservedAt >= 0 && now - conversation.lastObservedAt <= 90_000);
+    if (!active.length) return false;
+    const start = Number.isSafeInteger(config.heartbeatCursor) ? config.heartbeatCursor % active.length : 0;
+    const selected = Array.from({ length: Math.min(25, active.length) }, (_, index) => active[(start + index) % active.length]);
+    config.heartbeatCursor = (start + selected.length) % active.length;
+    for (const [key, conversation] of selected) {
+      // A newer heartbeat supersedes an unsent one for this conversation.
+      state.outbox.events = state.outbox.events.filter(item => !(item.key === key && item.request?.event_type === 'heartbeat'));
+      conversation.consentGeneration = config.consentGeneration;
+      conversation.sequence = Number.isSafeInteger(conversation.sequence) && conversation.sequence >= 0 ? conversation.sequence + 1 : 1;
+      state.outbox.events.push(event(conversation, key, 'heartbeat', conversation.last || { autoContinue: 'unknown', executionState: 'unknown', result: 'unknown' }, now));
+    }
+    materializeGaps(state, trim(state, now, options), now, options);
+    await saveStore(root, state);
+    return true;
+  });
+}
+function retryAt(now, attempts) { return now + Math.min(60_000, 1_000 * 2 ** Math.min(attempts, 5)) + Math.floor(Math.random() * 500); }
+export async function flushObservability({ root, apiOrigin, apiBaseUrl, token, fetchImpl = globalThis.fetch, now = Date.now() }) {
+  const preflight = (await readStore(root)).config;
+  if (!preflight.enabled || !validGeneration(preflight.consentGeneration)) return { sent: 0, queued: 0 };
+  const snapshot = await withStoreLock(root, async () => { const state = await readStore(root); if (!state.config.enabled || !validGeneration(state.config.consentGeneration) || state.config.retry.at > now) return null; if (state.config.actor?.origin !== apiOrigin) return null; return { generation: state.config.consentGeneration, actor: state.config.actor, events: [...state.outbox.events].sort((left, right) => Number(left.request?.event_type === 'heartbeat') - Number(right.request?.event_type === 'heartbeat')).slice(0, MAX_FLUSH) }; });
+  if (!snapshot?.events.length) return { sent: 0, queued: snapshot ? 0 : (await observabilityStatus(root)).queued, ...(snapshot ? {} : { retryPending: true }) };
+  const delivered = new Set(), rejected = new Set(); let failed = false, resync = false;
+  for (const item of snapshot.events) { try { const response = await fetchImpl(webApiUrl('devices/heartbeat/?observability=event', { webOrigin: apiOrigin, apiBaseUrl }), { method: 'POST', headers: webApiHeaders({ token }, { 'Content-Type': 'application/json' }), body: JSON.stringify(item.request), signal: AbortSignal.timeout(5_000) }); if (response.ok) { delivered.add(item.request.event_id); continue; } if ([400, 409, 422].includes(response.status)) { rejected.add(item.request.event_id); continue; } if ([401, 403].includes(response.status)) resync = true; failed = true; break; } catch { failed = true; break; } }
+  return withStoreLock(root, async () => { const state = await readStore(root); if (!state.config.enabled || state.config.consentGeneration !== snapshot.generation || !sameActor(state.config.actor, snapshot.actor)) { state.outbox.events = []; await saveStore(root, state); return { sent: 0, queued: 0 }; }
+    state.outbox.events = state.outbox.events.filter(item => !delivered.has(item.request.event_id) && !rejected.has(item.request.event_id)); for (const item of snapshot.events) if (rejected.has(item.request.event_id)) enqueueGap(state, item.key, 'sequence_gap', now); if (resync) state.config.enabled = false; state.config.retry = failed ? { attempts: state.config.retry.attempts + 1, at: retryAt(now, state.config.retry.attempts) } : { attempts: 0, at: 0 }; await saveStore(root, state); return { sent: delivered.size, queued: state.outbox.events.length, ...(failed ? { retryPending: true } : {}) }; });
+}

package/src/codex-plugins/simy/hooks/consistency-handoff.mjs

@@ -1,3 +1,48 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+// Keep every original receipt outside the mutable task record before collapsing
+// repeated inspections of the same contract, stage, decision and lease. This is
+// storage maintenance, never a completed action or permission to replay one.
+export async function compactConsistencyOutbox(root, record) {
+  const managed = record.run?.managed, outbox = managed?.consistencyOutbox;
+  if (!Array.isArray(outbox) || outbox.length < 2) return false;
+  const groups = new Map();
+  for (const item of outbox) {
+    const compatible = item.stage === 'executing' && item.decisionId && item.leaseId ||
+      item.stage === 'inspected' && item.targetTask && item.objectiveDigest;
+    const key = compatible
+      ? JSON.stringify([item.targetTask, item.version, item.objectiveDigest, item.stage, item.decisionId, item.leaseId, item.advisory === true, item.result])
+      : item;
+    if (!groups.has(key)) groups.set(key, []);
+    groups.get(key).push(item);
+  }
+  if (groups.size === outbox.length) return false;
+  const payload = JSON.stringify({ schema: 1, kind: 'execution_handoff_snapshot', provider: record.provider,
+    session: record.session, runId: record.run.id, requests: outbox });
+  const digest = createHash('sha256').update(payload).digest('hex');
+  const directory = join(root, 'consistency', 'handoff-history');
+  const file = join(directory, `${digest}.json`), temporary = `${file}.${randomUUID()}.tmp`;
+  await mkdir(directory, { recursive: true, mode: 0o700 });
+  try {
+    await writeFile(temporary, payload, { mode: 0o600 });
+    await rename(temporary, file);
+    if (await readFile(file, 'utf8') !== payload) throw new Error('Handoff history could not be retained.');
+  } finally { await rm(temporary, { force: true }); }
+  managed.consistencyOutbox = [...groups.values()].map(items => {
+    if (items.length === 1) return items[0];
+    const latest = items.at(-1);
+    return { ...latest, findings: [...new Set(items.flatMap(item => item.findings || []))],
+      ...Object.fromEntries(['createdAt', 'dueAt'].flatMap(key => {
+        const values = items.map(item => item[key]).filter(Number.isFinite);
+        return values.length ? [[key, Math.min(...values)]] : [];
+      })),
+      retainedHistory: { digest, requestCount: items.reduce((count, item) => count + (item.retainedHistory?.requestCount || 1), 0) } };
+  });
+  return true;
+}
+
 // Durable handoff deadlines concern unowned work, never a live effect lease.
 // Expiry queues diagnosis; it does not replay a write or grant permission.
 export const HANDOFF_RECEIPT_MS = 2 * 60_000;

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

@@ -8,7 +8,7 @@ import { currentRecoveryIncident, recordRecoveryIncident, recordRecoveryStage, s
 import { rememberPerspectives, perspectiveScope, recallPerspectives, perspectiveInstruction } from './perspective-memory.mjs';
 import { recordHypothesisSheet } from './hypothesis-sheet.mjs';
 import { bindControllerCompletion } from './completion-binding.mjs';
-import { recordHandoffStage } from './consistency-handoff.mjs';
+import { recordHandoffStage, compactConsistencyOutbox } from './consistency-handoff.mjs';
 import { retainApplicableRules } from './purpose-rule-policy.mjs';
 import { reconcileRequirements, retainControllerEvidence, reconcileFindings, findingText, evidenceLedger, currentPurposeObservation } from './purpose-evidence.mjs';
 import { workspaceIdentity } from './purpose-workspace.mjs';
@@ -20,6 +20,8 @@ import { homedir } from 'node:os';
 import { atomicSave, readState } from './update-state-store.mjs';
 import { captureHookOwner, fenceHook, rootFromDelivery, readDispatchGate, readTaskAdmission } from './update-dispatch-gate.mjs';
 import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path';
+const observeDeliveryRecord = (...args) => import('../../../cli-observability.js')
+  .then(({ observeDeliveryRecord: observe }) => observe(...args)).catch(() => false);
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { acquireWorkspaceLease, releaseWorkspaceLease } from './workspace-lease.mjs';
@@ -116,11 +118,20 @@ export async function linkedProvider(root, provider) {
 const digest = value => createHash('sha256').update(value).digest('hex');
 const text = (value, max = 4000) => typeof value === 'string' ? value.trim().slice(0, max) : '';
 const exactText = value => typeof value === 'string' && Buffer.byteLength(value, 'utf8') <= 1000 ? value : null;
-export function canUpgradeDelivery(run) {
+// Candidate discovery reserves an association ID even when no Action exists.
+// Only a confirmed no-match snapshot can distinguish that reservation from
+// existing ownership; missing, bound and unlinked snapshots remain protected.
+export function associationBlocksFollowup(record) {
+  return Boolean(record?.associationTaskId) &&
+    !(record.actionAssociation?.status === 'no_match' && record.actionAssociation.binding === null);
+}
+export function canUpgradeDelivery(run, { automatic = false } = {}) {
   return Boolean(run && !run.managed && text(run.id) && text(run.objective) && Number.isFinite(run.startedAt) &&
     Number.isSafeInteger(run.maxFailures) && run.maxFailures > 0 &&
     (['active', 'paused', 'recovery_required'].includes(run.state) ||
-      run.state === 'blocked' && run.blocker === 'external_dependency'));
+      run.state === 'blocked' && run.blocker === 'external_dependency') &&
+    (!automatic || run.stopReason?.actor !== 'user' && (run.state !== 'paused' || run.stopReason?.actor === 'system' ||
+      /^(?:Paused because no progress was confirmed in \d+ minutes\.|No verified acceptance progress in \d+ minutes\.|Paused after \d+ steps without confirmed progress\.) Review the original conversation, then resume\.$/.test(run.reason || ''))));
 }
 const contextText = (value, max = 500) => text(value, max).replace(/\b(?:sk|key)-[A-Za-z0-9_-]{12,}\b|\bBearer\s+\S+|\b(?:password|token|api[_-]?key)\s*[:=]\s*\S+/gi, '[redacted]');
 export function recordPath(root, provider, session) {
@@ -260,7 +271,7 @@ 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;
+  let temporary, observation, result;
   try {
     const stored = await read(file, MAX_STATE_BYTES);
     const previous = await applyArchiveFence(root, applyProviderConsent(stored, await providerLinkState(root, provider)));
@@ -275,7 +286,9 @@ export async function updateRecord(root, provider, session, mutate, { inspectPro
           delete criterion.check.path;
         }
       }
-      const serialized = JSON.stringify(next);
+      let 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.');
       if (serialized === previousBytes) return next;
       temporary = `${file}.${randomUUID()}.tmp`;
@@ -290,9 +303,29 @@ export async function updateRecord(root, provider, session, mutate, { inspectPro
           await new Promise(resolve => setTimeout(resolve, 25 * (attempt + 1)));
         }
       }
-    }
-    return next;
+      // This is intentionally post-persistence and best-effort: visibility
+      // recording cannot make an existing delivery state update fail or cause
+      // a task to start, stop, or retry.
+      // 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 };
+    }
+    result = next;
   } finally { if (temporary) await rm(temporary, { force: true }); await releaseStateLock(lock, lockToken); }
+  // 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 () => {
+    const runtime = observation.runtime || result?.runtime;
+    const verified = result?.autoContinue === true && result.run?.managed &&
+      runtime?.isRunning === true && runtime.process?.identity &&
+      Number.isSafeInteger(runtime.process?.pid) &&
+      await inspectProcess(runtime.process.pid).catch(() => null) === runtime.process.identity;
+    await observeDeliveryRecord(dirname(root), {
+      ...observation,
+      runtime: verified ? runtime : null,
+    });
+  })().catch(() => {});
+  return result;
 }
 export async function readRecord(root = rootDirectory(), provider, session) {
   const path = recordPath(root, provider, session);
@@ -859,12 +892,13 @@ export async function startDelivery({ root = rootDirectory(), provider, session,
       if (following && text(objective) === prior.objective) throw new Error('Follow-up requires a new objective; use the original task controls for unfinished work.');
       if (hasPendingUserStop(root, previous) || previous.providerArchived || previous.automaticStartBlocked || previous.autoContinue === false && previous.autoContinueEpoch ||
           prior.managed?.resumeLease || prior.managed?.liveWorkspaceLease || prior.managed?.outcomeAudit?.lease || prior.managed?.executionUncertain || prior.managed?.pendingApproval || prior.managed?.nativeWait ||
-          ['pending', 'transferred', 'pending_received'].includes(prior.managed?.handoff?.status) || previous.associationTaskId) throw new Error('Resolve the existing stop, opt-out, ownership, approval or uncertain result before enrolling follow-up work.');
+          ['pending', 'transferred', 'pending_received'].includes(prior.managed?.handoff?.status) || associationBlocksFollowup(previous)) throw new Error('Resolve the existing stop, opt-out, ownership, approval or uncertain result before enrolling follow-up work.');
       const gateRoot = rootFromDelivery(root), gate = readDispatchGate(gateRoot);
       const fences = Object.values(gate.taskFences?.records || {}).filter(item => item.taskId === (prior.managed?.taskId || prior.id) && item.identity.provider === provider && item.identity.session === session);
       if (fences.some(item => !readTaskAdmission({ root: gateRoot, identity: item.identity, taskId: item.taskId }).canResume)) throw new Error('Existing task admission must be reconciled before enrolling follow-up work.');
     }
-    if (upgrading && ((!reconciling && !canUpgradeDelivery(previous.run)) || previous.run.id !== upgradeRunId)) throw new Error('Only the exact nonterminal ordinary loop can be upgraded; resolve its blocker or resume its original task first.');
+    if (upgrading && ((!reconciling && !canUpgradeDelivery(previous.run, { automatic: Boolean(autoContinueEpoch) })) ||
+        autoContinueEpoch && hasPendingUserStop(root, previous) || previous.run.id !== upgradeRunId)) throw new Error('Only the exact nonterminal ordinary loop can be upgraded; resolve its blocker or resume its original task first.');
     if (previous.run && !upgrading && !following) throw new Error('This session already has a Delivery Loop. Resume or stop it; budgets cannot be reset by starting again.');
     if (upgrading && (text(objective) !== previous.run.objective || executionCwd && previous.run.executionCwd && executionCwd !== previous.run.executionCwd)) throw new Error('Upgrade must preserve the original objective and task directory.');
     const managedConfig = managed && { ...(managed === true ? {} : managed),
@@ -1201,6 +1235,18 @@ export async function checkpointDelivery({ root = rootDirectory(), provider, ses
     const localReconciliation = flexibleReasoning(run.managed) && ['read','local_edit','local_test'].includes(uncertainAction?.kind);
     if (run.managed?.executionUncertain && run.managed.recoveryDiagnosisDecisionId === lastWork?.result?.decisionId && lastWork.result.status === 'observed' && (lastWork.result.evidence?.length || lastWork.result.observationSource === 'controller_tool_result' || localReconciliation) && lastWork.action.kind === 'read') {
       run.managed.recoveryEvidence = { decisionId: lastWork.result.decisionId, source: lastWork.result.observationSource || 'provider_reported_read', checkedAt: now };
+      const priorUnit = run.managed.purpose?.evidence?.units?.find(unit =>
+        unit.id === uncertain.decisionId && unit.status === 'unknown' &&
+        (!uncertain.attemptId || unit.attemptId === uncertain.attemptId));
+      if (priorUnit) {
+        priorUnit.status = 'observed';
+        // The read already met the reconciliation guard above, including a
+        // local observation reported without separate evidence references.
+        // Release only local occupancy, never acceptance or external effects.
+        if (['local_edit', 'local_test'].includes(priorUnit.action?.kind)) {
+          priorUnit.localExecutionSettledAt = now;
+        }
+      }
       delete run.managed.executionUncertain;
       resolveRecoveryReceipt(run, uncertain?.attemptId);
       delete run.managed.recoveryDiagnosisDecisionId;
@@ -1873,14 +1919,15 @@ export async function processIdentity(pid) {
 export async function claudeHookChannel(record, { session, cwd, inspectProcess = processIdentity, platform = process.platform } = {}) {
   const unavailable = (code, reason) => ({ ready: false, code, reason });
   if (platform === 'win32') return unavailable('platform_unsupported', 'Claude process verification is unavailable on Windows; monitoring remains available.');
-  if (!record) return unavailable('hook_missing', 'SIMY has not observed a session-start event for this conversation. Check the SIMY plugin and hook execution in the original Claude window.');
+  if (!record) return unavailable('hook_missing', 'Waiting for the original Claude hook. SIMY recovers automatically when the next verified prompt or response-end hook arrives. If no notifications arrive, check the SIMY plugin in the original Claude window.');
   if (record.provider !== 'claude' || record.session !== session) return unavailable('session_mismatch', 'The observed hook belongs to a different Claude conversation. Refresh this conversation.');
   try { if (record.cwd !== await realpath(cwd)) return unavailable('workspace_mismatch', 'The observed Claude hook belongs to a different folder. Refresh this conversation.'); }
   catch { return unavailable('workspace_unavailable', 'The Claude conversation folder could not be verified. Check the folder and refresh.'); }
   if (record.hookEndedAt || record.lastEvent === 'SessionEnd') return unavailable('session_ended', 'This Claude session has ended. Return to the original conversation to continue.');
+  if (!record.hookStartedAt && record.hookRecoveryBlocked) return unavailable('process_changed', 'A different Claude process reported this conversation. Reopen the original conversation to establish its hook owner.');
   if (!record.hookStartedAt) return unavailable(record.hookObservedAt ? 'process_unverified' : 'hook_missing', record.hookObservedAt
     ? 'The session-start hook ran, but SIMY could not identify its Claude process. Check the hook diagnostics.'
-    : 'SIMY has not observed a session-start event for this conversation. Check the SIMY plugin and hook execution in the original Claude window.');
+    : 'Waiting for the original Claude hook. SIMY recovers automatically when the next verified prompt or response-end hook arrives. If no notifications arrive, check the SIMY plugin in the original Claude window.');
   const owner = record.hookSessionProcess || record.process; // Existing verified records remain compatible.
   if (!owner?.identity || !Number.isSafeInteger(owner.pid) || owner.pid < 2) return unavailable('process_unverified', 'The session-start hook ran, but SIMY could not identify its Claude process. Check the hook diagnostics.');
   if (record.process?.pid !== owner.pid || record.process?.identity !== owner.identity) return unavailable('process_changed', 'A different Claude process reported this conversation. Refresh the original conversation.');
@@ -2019,6 +2066,22 @@ async function handleHookState({ input, provider, root = rootDirectory(), now =
         backgroundIdle: event === 'Stop' && Array.isArray(input.background_tasks) && input.background_tasks.length === 0 && Array.isArray(input.session_crons) && input.session_crons.length === 0 };
     }
     record.lastNotificationType = event === 'Notification' ? text(input.notification_type, 80) : null;
+    if (provider === 'claude' && event !== 'SessionStart' && identity && record.process &&
+        (record.process.pid !== identity.pid || record.process.identity !== identity.identity)) {
+      record.hookRecoveryBlocked = 'process_changed';
+    }
+    // A plugin loaded after the conversation opened can miss SessionStart.
+    // A real prompt/stop hook proves the same exact session and provider parent
+    // without fabricating a start event or adopting an existing task/owner.
+    if (provider === 'claude' && ['UserPromptSubmit', 'Stop'].includes(event) &&
+        !record.run && !record.hookStartedAt && !record.hookSessionProcess && !record.hookEndedAt && !record.hookRecoveryBlocked &&
+        !record.parentSession && !env.SIMY_PARENT_SESSION && !env.CODEX_THREAD_ID &&
+        !record.providerArchived && identity?.identity && Number.isSafeInteger(identity.pid) && identity.pid > 1 &&
+        (!record.process || record.process.pid === identity.pid && record.process.identity === identity.identity)) {
+      record.hookStartedAt = now;
+      record.hookSessionProcess = { ...identity };
+      record.hookRecovery = { source: event, recoveredAt: now, reason: 'session_start_missing' };
+    }
     if (identity) {
       // Legacy records have no frozen hook owner; a new process must not inherit
       // an old SessionStart admission through a later prompt or stop event.
@@ -2028,6 +2091,8 @@ async function handleHookState({ input, provider, root = rootDirectory(), now =
     }
     if (event === 'SessionStart') {
       record.hookObservedAt = now;
+      delete record.hookRecovery;
+      delete record.hookRecoveryBlocked;
       delete record.hookEndedAt;
       if (identity) { record.hookStartedAt = now; record.hookSessionProcess = { ...identity }; }
       else { delete record.hookStartedAt; delete record.hookSessionProcess; delete record.process; }