@awak-app/simy-cli 0.6.16 → 0.6.18

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

@@ -3,7 +3,7 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { mkdir, open, readFile, readdir, realpath, rename, rm, stat, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
-import { isAbsolute, join, relative, resolve } from 'node:path';
+import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { acquireWorkspaceLease, releaseWorkspaceLease } from './workspace-lease.mjs';
@@ -27,6 +27,23 @@ export const taskDirectory = record => record.run?.executionCwd || record.cwd;
 export const taskWorkspaceDirectories = record => [...new Set([record.cwd, taskDirectory(record)])];
 export const sharesTaskWorkspace = (left, right) => taskWorkspaceDirectories(left).some(cwd => taskWorkspaceDirectories(right).includes(cwd));
 const checkpointDirectoryMatches = (record, cwd) => record.cwd === cwd || taskDirectory(record) === cwd;
+// Plugins ship this standalone file without the CLI's provider-links module.
+// Honor the same durable revocation file before accepting hook work; missing
+// files retain legacy behavior, while malformed saved policy fails closed.
+export async function providerLinkState(root, provider) {
+  try {
+    const settings = JSON.parse(await readFile(join(dirname(resolve(root)), 'provider-links.json'), 'utf8'));
+    const valid = settings?.schemaVersion === 1 && ['codex', 'claude'].every(key => {
+      const value = settings.providers?.[key];
+      return value && typeof value.connected === 'boolean' && typeof value.requiresConsent === 'boolean' &&
+        (value.epoch === null || typeof value.epoch === 'string' && value.epoch.length > 0 && value.epoch.length <= 128);
+    });
+    return valid ? settings.providers[provider] ?? { connected: false, epoch: null } : { connected: false, epoch: null };
+  } catch (error) { return { connected: error.code === 'ENOENT', epoch: null }; }
+}
+export async function linkedProvider(root, provider) {
+  return (await providerLinkState(root, provider)).connected === true;
+}
 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;
@@ -472,7 +489,10 @@ export function deliveryAcceptanceContext(run) {
     ` Pending acceptance (last recorded checks): ${JSON.stringify(pendingAcceptance(run))}. Continue only within the original request and permissions; manual checks require the user. SQM is optional and 0 applicable checks do not establish quality acceptance.`;
 }
 export async function startDelivery({ root = rootDirectory(), provider, session, cwd = process.cwd(), executionCwd, upgradeRunId, objective, nextStep, maxFailures, continuationPolicy, managed, admission,
-  liveHookAdmission, autoContinueEpoch, inspectProcess = processIdentity, now = Date.now() }) {
+  liveHookAdmission, autoContinueEpoch, providerLinkEpoch, inspectProcess = processIdentity, now = Date.now() }) {
+  const link = await providerLinkState(root, provider);
+  if (providerLinkEpoch !== undefined && providerLinkEpoch !== link.epoch) throw Object.assign(new Error("SIMY provider connection changed before enrollment."), { code: "provider_link_changed" });
+  if (!link.connected) throw Object.assign(new Error("Reconnect this provider to SIMY before using it."), { code: "provider_link_disconnected" });
   cwd = await realpath(cwd);
   if (executionCwd !== undefined) {
     executionCwd = await realpath(executionCwd);
@@ -534,6 +554,8 @@ export async function startDelivery({ root = rootDirectory(), provider, session,
     }
     if (managedState && !managedState.contextBootstrap) freezeEnrollment(run, now);
     if (waiting) escalate(run, run.reason);
+    const latest = await providerLinkState(root, provider);
+    if (!latest.connected || latest.epoch !== link.epoch) throw Object.assign(new Error("SIMY connection changed before enrollment."), { code: "provider_link_disconnected" });
     return { ...previous, run };
   });
 }
@@ -1052,12 +1074,16 @@ async function providerProcess(provider) {
   return null;
 }
 export async function handleHook({ input, provider, root = rootDirectory(), now = Date.now(), observedProcess = undefined, inspectProcess = processIdentity }) {
+  const link = await providerLinkState(root, provider);
+  if (!link.connected) return {};
   if (!EVENTS.has(input?.hook_event_name) || !text(input.session_id) || !text(input.cwd)) return {};
   let cwd; try { cwd = await realpath(input.cwd); } catch { return {}; }
   const event = input.hook_event_name;
   const identity = observedProcess === undefined && (['SessionStart', 'UserPromptSubmit', 'Stop', 'StopFailure', 'SessionEnd', 'Interrupt'].includes(event)) ? await providerProcess(provider) : observedProcess;
   let output = {}, boundaryLease = null, claimedWorkspace = null;
   try { await updateRecord(root, provider, input.session_id, async old => {
+    const currentLink = await providerLinkState(root, provider);
+    if (!currentLink.connected || currentLink.epoch !== link.epoch) return old;
     if (old && old.cwd !== cwd) return old;
     const record = old || { schemaVersion: 1, provider, session: input.session_id, cwd, run: null };
     const owner = record.run?.managed?.liveHookOwner;
@@ -1139,7 +1165,8 @@ export async function handleHook({ input, provider, root = rootDirectory(), now
     } else if (event === 'Stop') {
       // OFF suppresses future Stop blocking; it never interrupts the provider
       // turn. Lease settlement and runtime observation above still run.
-      if (!automaticContinuationAllowed(record)) return record;
+      const latestLink = await providerLinkState(root, provider);
+      if (!automaticContinuationAllowed(record) || !latestLink.connected || latestLink.epoch !== link.epoch) return record;
       // Codex turn IDs make re-delivered Stop events idempotent. Claude has no
       // stable event ID; never dedupe on text (identical text can be a new turn).
       const key = input.turn_id ? `${input.turn_id}:${Boolean(input.stop_hook_active)}:${run.revision}` : null;

package/src/codex-plugins/simy/hooks/dev-work.mjs

@@ -9,6 +9,7 @@
 // never a secret), and it always exits 0. The raw provider session id is never
 // sent or stored; only a provider-scoped SHA-256 of it leaves this process.
 
+import { linkedProvider, providerLinkState } from "./delivery-loop.mjs";
 import { execFile } from "node:child_process";
 import { createHash } from "node:crypto";
 import { mkdir, readFile, readdir, rename, writeFile } from "node:fs/promises";
@@ -177,12 +178,14 @@ export async function runDevWorkHook({
   fetchImpl = globalThis.fetch,
   runImpl = run,
 }) {
+  const sessionRoot = env.SIMY_HOME?.trim() || join(homedir(), ".simy");
+  const link = await providerLinkState(join(sessionRoot, "delivery-hooks"), provider);
+  if (!link.connected) return { sent: false, reason: "provider_link_disconnected" };
   const cwd = typeof input.cwd === "string" && input.cwd ? input.cwd : process.cwd();
   const sessionId = input.session_id || input.sessionId || env.CODEX_THREAD_ID;
   const event = await collectDevWorkEvent({ cwd, provider, sessionId, env, runImpl });
   if (!event) return { sent: false, reason: "not_applicable" };
 
-  const sessionRoot = env.SIMY_HOME?.trim() || join(homedir(), ".simy");
   const pluginData =
     env.PLUGIN_DATA?.trim() || env.CLAUDE_PLUGIN_DATA?.trim() || join(sessionRoot, "plugin-data", "simy");
   // The upstream observation is keyed by (Project, repo, HEAD, session): a
@@ -192,10 +195,13 @@ export async function runDevWorkHook({
   if ((await readState(statePath))?.fingerprint === fingerprint) {
     return { sent: false, reason: "unchanged" };
   }
+  if (!await linkedProvider(join(sessionRoot, "delivery-hooks"), provider)) return { sent: false, reason: "provider_link_disconnected" };
   const port = await findAgentPort({ env, sessionRoot });
   if (!port) return { sent: false, reason: "agent_unavailable" };
   const prUrl = await pullRequestUrl({ cwd, repo: event.repo, env, runImpl });
   if (prUrl) event.pr_url = prUrl;
+  const latest = await providerLinkState(join(sessionRoot, "delivery-hooks"), provider);
+  if (!latest.connected || latest.epoch !== link.epoch) return { sent: false, reason: "provider_link_disconnected" };
 
   const response = await fetchImpl(`http://127.0.0.1:${port}/v1/dev-work-events`, {
     method: "POST",

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

@@ -7,7 +7,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node --input-type=module -e \"import { pathToFileURL } from 'node:url'; import { join } from 'node:path'; const hook = await import(pathToFileURL(join(process.env.PLUGIN_ROOT, 'hooks', 'connection-reminder.mjs')).href); await hook.main();\"",
+            "command": "node --input-type=module -e \"import { pathToFileURL } from 'node:url'; import { join } from 'node:path'; const hook = await import(pathToFileURL(join(process.env.PLUGIN_ROOT, 'hooks', 'connection-reminder.mjs')).href); await hook.main('codex');\"",
             "timeout": 3,
             "statusMessage": "SIMY connection check at session start"
           }
@@ -29,7 +29,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node --input-type=module -e \"import { pathToFileURL } from 'node:url'; import { join } from 'node:path'; const hook = await import(pathToFileURL(join(process.env.PLUGIN_ROOT, 'hooks', 'connection-reminder.mjs')).href); await hook.main();\"",
+            "command": "node --input-type=module -e \"import { pathToFileURL } from 'node:url'; import { join } from 'node:path'; const hook = await import(pathToFileURL(join(process.env.PLUGIN_ROOT, 'hooks', 'connection-reminder.mjs')).href); await hook.main('codex');\"",
             "timeout": 3,
             "statusMessage": "SIMY connection check before a prompt"
           }

package/src/codex-work-pattern-sync.js

@@ -6,6 +6,7 @@ import { basename, join, relative, resolve, sep } from "node:path";
 import { createInterface } from "node:readline";
 
 import { webApiErrorMessage, webApiHeaders, webApiUrl } from "./web-api.js";
+import { readProviderLinks } from "./provider-links.js";
 
 const MAX_THREADS = 10;
 const MAX_MESSAGES = 24;
@@ -76,9 +77,20 @@ export async function syncCodexWorkPatterns({
   onDirectoryVisited,
   onBeforeExtract,
   signal,
+  connectedProviders = [PROVIDER_CODEX, PROVIDER_CLAUDE],
 }) {
   if (!token || !deviceId || !sessionRoot) return { status: "not_connected", uploaded: 0 };
   signal?.throwIfAborted();
+  const links = await readProviderLinks(sessionRoot);
+  const providersToRead = connectedProviders.filter(provider => links[provider]?.connected === true);
+  if (providersToRead.length === 0) return { status: "provider_disconnected", uploaded: 0 };
+  const authorizeProviders = async () => {
+    signal?.throwIfAborted();
+    const current = await readProviderLinks(sessionRoot);
+    if (providersToRead.some(provider => !current[provider]?.connected || current[provider].epoch !== links[provider].epoch)) {
+      throw Object.assign(new Error("SIMY provider connection changed before history synchronization. Retry after reconnecting."), { code: "provider_link_changed" });
+    }
+  };
   // SIMY Web runs with trailingSlash=true; use the canonical slash form so the
   // POST body never depends on a 308 redirect being replayed.
   const endpoint = webApiUrl("work-pattern-observations/", {
@@ -114,7 +126,8 @@ export async function syncCodexWorkPatterns({
   });
   const persistedState = await readSyncState(statePath);
   const previousState = statusPayload.reset_cursor === true ? {} : persistedState;
-  const state = previousState.lookback_days === lookbackDays ? previousState : {};
+  const state = { ...previousState, providers: Object.fromEntries(Object.entries(previousState.providers || {})
+    .filter(([, cursor]) => cursor?.reset_pending !== true && (cursor?.lookback_days ?? previousState.lookback_days) === lookbackDays)) };
   const lookbackCutoffMs = now - lookbackDays * 24 * 60 * 60 * 1_000;
   const providerSpecs = [
     {
@@ -131,11 +144,12 @@ export async function syncCodexWorkPatterns({
       // machine-to-machine work, not a user's conversation, so exclude them.
       includeRelativePath: (filePath) => !filePath.split(sep).includes("subagents"),
     },
-  ];
+  ].filter(spec => providersToRead.includes(spec.provider));
   const inventories = new Map();
   let incompleteReplayRoot = false;
   let hasCompleteRoot = false;
   const files = (await Promise.all(providerSpecs.map(async (spec) => {
+    await authorizeProviders();
     const providerState = providerCursor(state, spec.provider);
     // Do not use the history window as a pre-read mtime filter: restored or
     // migrated files can have mtimes that disagree with their message dates.
@@ -170,6 +184,7 @@ export async function syncCodexWorkPatterns({
   for (const file of selectedFiles) {
     const spec = providerSpecs.find((item) => item.provider === file.provider);
     await onBeforeExtract?.(file);
+    await authorizeProviders();
     const extracted = await spec.extract(file.path, {
       deviceId,
       fallbackObservedAt: new Date(file.mtimeMs).toISOString(),
@@ -204,6 +219,7 @@ export async function syncCodexWorkPatterns({
   }
   const shouldAcknowledgeEmptyReset =
     statusPayload.reset_cursor === true &&
+    providerSpecs.length === 2 &&
     hasCompleteRoot &&
     !incompleteReplayRoot &&
     selectedFiles.length === successfullyReadFiles.length &&
@@ -213,10 +229,10 @@ export async function syncCodexWorkPatterns({
   }
 
   const uploadResult = threads.length > 0
-    ? await uploadThreadBatches({ endpoint, token, threads, fetchImpl, signal })
+    ? await uploadThreadBatches({ endpoint, token, threads, fetchImpl, signal, authorizeProviders })
     : { uploaded: 0 };
   if (shouldAcknowledgeEmptyReset) {
-    const { payload } = await postThreadBatch({ endpoint, token, threads: [], fetchImpl, signal });
+    const { payload } = await postThreadBatch({ endpoint, token, threads: [], fetchImpl, signal, authorizeProviders });
     validateThreadBatchAcknowledgement(payload, []);
   }
   if (selectedFiles.length === 0) return { status: "up_to_date", uploaded: 0 };
@@ -227,15 +243,21 @@ export async function syncCodexWorkPatterns({
     };
   }
 
-  const providers = {};
+  // Keep disconnected providers' acknowledged history intact. Their own
+  // lookback records prevent a later reconnect from inheriting a changed window.
+  const providers = Object.fromEntries(Object.entries(persistedState.providers || {})
+    .filter(([provider]) => !providersToRead.includes(provider))
+    .map(([provider, cursor]) => [provider, { ...cursor, lookback_days: cursor?.lookback_days ?? persistedState.lookback_days,
+      ...(statusPayload.reset_cursor === true ? { reset_pending: true } : {}) }]));
   for (const spec of providerSpecs) {
-    providers[spec.provider] = advanceProviderCursor(
+    providers[spec.provider] = { ...advanceProviderCursor(
       providerCursor(state, spec.provider),
       successfullyReadFiles.filter((file) => file.provider === spec.provider),
       inventories.get(spec.provider),
-    );
+    ), lookback_days: lookbackDays };
   }
   signal?.throwIfAborted();
+  await authorizeProviders();
   await writeSyncState(statePath, {
     schema_version: STATE_SCHEMA_VERSION,
     lookback_days: lookbackDays,
@@ -257,7 +279,7 @@ export function workPatternSyncStatePath({ sessionRoot, apiOrigin, accountId, de
   return join(sessionRoot, "work-pattern-history-sync", `${scopeHash}.json`);
 }
 
-async function uploadThreadBatches({ endpoint, token, threads, fetchImpl, signal }) {
+async function uploadThreadBatches({ endpoint, token, threads, fetchImpl, signal, authorizeProviders }) {
   const batches = [];
   let batch = [];
   for (const thread of threads) {
@@ -284,13 +306,14 @@ async function uploadThreadBatches({ endpoint, token, threads, fetchImpl, signal
       threads: current,
       fetchImpl,
       signal,
+      authorizeProviders,
     });
     uploaded += result.uploaded;
   }
   return { uploaded };
 }
 
-async function postBatchWithBounded413Recovery({ endpoint, token, threads, fetchImpl, signal }) {
+async function postBatchWithBounded413Recovery({ endpoint, token, threads, fetchImpl, signal, authorizeProviders }) {
   const { response, payload } = await postThreadBatch({
     endpoint,
     token,
@@ -298,6 +321,7 @@ async function postBatchWithBounded413Recovery({ endpoint, token, threads, fetch
     fetchImpl,
     signal,
     allow413: true,
+    authorizeProviders,
   });
   if (response.status !== 413) {
     validateThreadBatchAcknowledgement(payload, threads);
@@ -311,6 +335,7 @@ async function postBatchWithBounded413Recovery({ endpoint, token, threads, fetch
       threads: threads.slice(0, middle),
       fetchImpl,
       signal,
+      authorizeProviders,
     });
     const right = await postBatchWithBounded413Recovery({
       endpoint,
@@ -318,6 +343,7 @@ async function postBatchWithBounded413Recovery({ endpoint, token, threads, fetch
       threads: threads.slice(middle),
       fetchImpl,
       signal,
+      authorizeProviders,
     });
     return { uploaded: left.uploaded + right.uploaded };
   }
@@ -334,11 +360,13 @@ async function postThreadBatch({
   fetchImpl,
   signal,
   allow413 = false,
+  authorizeProviders,
 }) {
   const body = JSON.stringify({ threads });
   if (Buffer.byteLength(body, "utf8") > MAX_GATEWAY_BODY_BYTES) {
     throw new Error("Work-pattern observation payload exceeds the local CLI gateway limit.");
   }
+  await authorizeProviders();
   const response = await fetchImpl(endpoint, {
     method: "POST",
     headers: webApiHeaders({ token }, { "Content-Type": "application/json" }),

package/src/delivery-hooks/command.js

@@ -1,5 +1,6 @@
+import { deliveryEvidence } from './evidence.js';
 import { readFile } from 'node:fs/promises';
-import { startDelivery, checkpointDelivery, controlDelivery, listRecords, rootDirectory, verifyDelivery } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+import { startDelivery, checkpointDelivery, controlDelivery, listRecords, rootDirectory, verifyDelivery, readRecord } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
 import { continueSession } from '../session-supervision/index.js';
 import { cancelHandoffSession, handoffSession } from '../session-supervision/handoff.js';
 import { runActivityCommand } from './activity.js';
@@ -20,6 +21,7 @@ export async function runDeliveryCommand(argv, { root = rootDirectory(), cwd = p
   const [action, ...args] = argv;
   if (action === 'activity') return runActivityCommand(args, { root, output });
   if (!action || action === '--help') {
+    output('simy delivery evidence --provider codex|claude --session ID — read-only execution and acceptance receipts.');
     output('simy delivery activity [--watch] [--json] [--provider codex|claude] [--session ID] — local observations every 60 seconds; not productive time.');
     output('A task stops after repeated failures, and pauses for review when no progress is confirmed. Resume starts a new progress window.');
     output('simy delivery continuation_policy --provider PROVIDER --session ID --task-id ID --continuation-policy bounded|progress');
@@ -36,7 +38,12 @@ export async function runDeliveryCommand(argv, { root = rootDirectory(), cwd = p
   }
   const base = { root, cwd, provider: options.provider, session: options.session };
   let result;
-  if (action === 'status') result = (await listRecords(root)).filter(r => (!options.provider || r.provider === options.provider) && (!options.session || r.session === options.session));
+  if (action === 'evidence') {
+    const record = await readRecord(root, options.provider, options.session);
+    if (!record) throw new Error('Exact provider session record not found.');
+    result = deliveryEvidence(record, root);
+  }
+  else if (action === 'status') result = (await listRecords(root)).filter(r => (!options.provider || r.provider === options.provider) && (!options.session || r.session === options.session));
   else if (action === 'continue') result = await continueSession({ ...base, executionCwd: options['execution-cwd'], autonomyPolicy: options['autonomy-policy'], continuationPolicy: options['continuation-policy'],
     ...Object.fromEntries([['max-failures', 'maxFailures'], ['max-no-progress-minutes', 'maxNoProgressMinutes']]
       .filter(([key]) => options[key] !== undefined).map(([key, field]) => [field, Number(options[key])])) });

package/src/delivery-hooks/desktop.js

@@ -4,7 +4,7 @@ import { canReplanDelivery, pendingAcceptance, deliveryStop, deliveryStopBlocksR
 import { originalSessionTarget } from '../session-supervision/original-session-target.js';
 
 export const HOOK_SETUP = Object.freeze({
-  codex: { settingsUrl: 'codex://settings', docsUrl: 'https://learn.chatgpt.com/docs/hooks', command: '/hooks' },
+  codex: { settingsUrl: null, docsUrl: 'https://learn.chatgpt.com/docs/hooks', command: '/hooks' },
   claude: { settingsUrl: null, docsUrl: 'https://code.claude.com/docs/en/hooks-guide', command: '/hooks' },
 });
 
@@ -85,19 +85,17 @@ export async function deliveryHookStatus({ root = rootDirectory(), now = Date.no
   };
 }
 
-// Wait for the OS opener to exit. A successful spawn alone does not prove that
-// a custom URL scheme has a registered handler.
+// Codex registering its URL scheme does not prove a settings route exists.
+// Both providers use their official guide and leave hook trust to the user.
 export async function openHookSetup(provider, { platform = process.platform, run = promisify(execFile) } = {}) {
   const setup = HOOK_SETUP[provider];
   if (!setup) throw new Error("Unsupported provider.");
-  const targets = platform === "darwin" && setup.settingsUrl ? [setup.settingsUrl, setup.docsUrl] : [setup.docsUrl];
-  for (const url of targets) {
-    try {
-      const command = platform === "darwin" ? "open" : platform === "win32" ? "rundll32" : "xdg-open";
-      const args = platform === "win32" ? ["url.dll,FileProtocolHandler", url] : [url];
-      await run(command, args, { timeout: 5000, maxBuffer: 4096 });
-      return { opened: true, url };
-    } catch {}
+  const command = platform === "darwin" ? "/usr/bin/open" : platform === "win32" ? "rundll32" : "xdg-open";
+  const args = platform === "win32" ? ["url.dll,FileProtocolHandler", setup.docsUrl] : [setup.docsUrl];
+  try {
+    await run(command, args, { timeout: 5000, maxBuffer: 4096 });
+    return { opened: true, url: setup.docsUrl };
+  } catch {
+    throw new Error("Could not open hook setup. Use /hooks inside your provider.");
   }
-  throw new Error("Could not open hook setup. Use /hooks inside your provider.");
 }

package/src/delivery-hooks/evidence.js

@@ -0,0 +1,50 @@
+import { pendingAcceptance, recordPath, taskDirectory } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+
+// A read-only projection: provider reports and continuation instructions are
+// deliberately separate from supervisor checkpoint receipts and acceptance.
+export function deliveryEvidence(record, root) {
+  const run = record?.run;
+  const managed = run?.managed;
+  const attempts = managed?.attempts || [];
+  const counts = Object.fromEntries(['checkpoint', 'failed', 'cancelled', 'busy'].map(outcome =>
+    [outcome, attempts.filter(attempt => attempt.outcome === outcome).length]));
+  return {
+    schemaVersion: 1,
+    provider: record.provider, session: record.session,
+    recordPath: recordPath(root, record.provider, record.session),
+    providerCwd: record.cwd, executionCwd: taskDirectory(record),
+    runId: run?.id || null, taskId: managed?.taskId || null,
+    mode: !run ? 'not_started' : managed ? 'managed' : 'checkpoint_tracking',
+    state: run?.state || null,
+    controller: managed ? { capability: managed.capability, resumeChannel: managed.resumeChannel,
+      autoRecovery: managed.autoRecovery === true, deliveryLevel: managed.deliveryLevel || null } : null,
+    execution: {
+      supervisorAttemptsTotal: managed?.autoAttempts || 0,
+      retainedAttemptCount: attempts.length, retainedAttemptOutcomes: counts,
+      supervisorStructuredCheckpointCount: counts.checkpoint,
+      currentAttempt: managed?.executionAttempt ? {
+        id: managed.executionAttempt.id, phase: managed.executionAttempt.phase,
+        dispatchedAt: managed.executionAttempt.dispatchedAt || null,
+        checkpointRevision: managed.executionAttempt.checkpointRevision ?? null,
+      } : null,
+      continuationInstructions: run?.continuations || 0,
+      providerReportedWorkCount: managed?.workHistory?.length || 0,
+      historyScope: 'retained_history_only',
+    },
+    acceptance: {
+      status: !managed || !managed.acceptanceCriteria?.length ? 'not_independently_verified'
+        : pendingAcceptance(run).length ? 'pending' : 'recorded_checks_passed',
+      criteria: (managed?.acceptanceCriteria || []).map(criterion => ({
+        id: criterion.id, method: criterion.check.type,
+        receipt: managed.verified?.[criterion.id] || null,
+      })),
+      pending: managed ? pendingAcceptance(run).map(criterion => criterion.id) : [],
+    },
+    limitations: [
+      'Enrollment, claimed attempts and continuation instructions do not prove provider execution.',
+      'Structured checkpoints and provider-reported work do not certify user acceptance or DMG behavior.',
+      'Attempt and work history are bounded; counts describe retained receipts, not lifetime executions.',
+      'Recorded acceptance is a snapshot; this read-only command does not rerun checks.',
+    ],
+  };
+}

package/src/delivery-hooks/supervisor.js

@@ -1,3 +1,4 @@
+import { requireProviderLink } from '../provider-links.js';
 import { spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import { dirname } from 'node:path';
@@ -36,6 +37,7 @@ function watchLease(root, provider, session, inspect, onFailure) {
 }
 async function assertActiveLease(root, provider, session, leaseId, signal, currentTime = Date.now) {
   if (signal?.aborted) throw new Error('Managed recovery cancelled before provider dispatch.');
+  await requireProviderLink({ root, provider });
   const current = await readRecord(root, provider, session);
   if (signal?.aborted || current?.run?.state !== 'auto_resuming' || current.run.managed?.resumeLease?.id !== leaseId) {
     throw new Error('Managed recovery lease changed before provider dispatch.');
@@ -159,6 +161,7 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
       continue;
     }
     if (!automaticContinuationAllowed(record)) continue;
+    try { await requireProviderLink({ root, provider: record.provider }); } catch { continue; }
     const appServer = run.managed.resumeChannel === 'codex_app_server';
     const causeAllowed = run.recoveryCause === 'process_exit' || appServer && ['session_supervision', 'approved_action'].includes(run.recoveryCause);
     const approvedWait = run.managed.decision?.outcome === 'wait' && ['read', 'local_edit', 'local_test'].includes(run.managed.decision.action?.kind) &&
@@ -168,8 +171,9 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
     if (run.state !== 'recovery_required' || !causeAllowed || !run.managed.autoRecovery || run.managed.pendingApproval || run.managed.autonomyPolicy && run.managed.decision?.outcome === 'wait' && !approvedWait || appServer && run.managed.nextAttemptAt > claimNow) continue;
     let authorizationScope;
     const authorizeClaim = async () => {
+      await requireProviderLink({ root, provider: record.provider });
       if (!authorizeDispatch) return;
-      const latest = await authorizeDispatch();
+      const latest = await authorizeDispatch(record);
       if (authorizationScope !== undefined && latest !== authorizationScope) throw Object.assign(new Error("Desktop authorization scope changed."), { code: "desktop_access_required" });
       authorizationScope = latest;
     };
@@ -285,7 +289,9 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
           } });
         }
       }
-    } catch (error) { result = error?.code === 'desktop_access_required'
+    } catch (error) { result = error?.code === 'provider_link_disconnected'
+      ? { code: -2, cancelled: true }
+      : error?.code === 'desktop_access_required'
       ? { code: -3, busy: true, accessDenied: true }
       : { code: controller.signal.aborted ? -2 : -1, cancelled: controller.signal.aborted,
         errorCode: error?.code || 'provider_error', restorationUnverified: error?.restorationUnverified === true }; }

package/src/desktop-access.js

@@ -8,11 +8,12 @@ export function validDesktopAccessPath(path, slug) {
 }
 export const desktopAccessReady = value => value?.state === 'ready';
 const recoveryActions = new Set(['refresh', 'reconnect', 'login', 'authorization_open', 'organization_select', 'organization_cancel', 'organizations_refresh',
-  'check_update', 'update', 'quit', 'task_stop', 'delivery_stop', 'delivery_pause', 'delivery_reject',
-  'desktop_access_refresh', 'desktop_access_settings', 'desktop_access_members']);
+  'check_update', 'update', 'prepare_update_restart', 'quit', 'task_stop', 'delivery_stop', 'delivery_pause', 'delivery_reject',
+  'provider_disconnect', 'desktop_access_refresh', 'desktop_access_settings', 'desktop_access_members']);
 export function desktopActionAllowed(access, command) {
   return desktopAccessReady(access) || recoveryActions.has(command?.action) ||
-    command?.action === 'session_set_auto_continue' && command.enabled === false;
+    command?.action === 'session_set_auto_continue' && command.enabled === false ||
+    command?.action === 'session_set_email_reports' && command.enabled === false;
 }
 export function requireDesktopAccess(access) {
   if (!desktopAccessReady(access)) throw Object.assign(new Error('Sign in to an organization with SQM and Developer access before using SIMY.'), { code: 'desktop_access_required' });