@awak-app/simy-cli 0.7.15 → 0.7.17

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

@@ -2,8 +2,11 @@ import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { mkdir, lstat, readFile, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
+import { dirname, join, isAbsolute, delimiter } from 'node:path';
+import { installPinnedCliEntry } from './legacy-hook-routing.js';
 import { pinnedWorkflowSource } from './local-runtime.js';
+import { inspectBackendExecutable, backendCandidates, CODEX_WRITER_LOCK_MINIMUM_VERSION } from '../backend-executable.js';
+import { runSceneReasoning } from '../codex-plugins/simy/hooks/scene-reasoning.mjs';
 import { readSupervisorState } from './supervisor-owner.js';
 
 const exec = promisify(execFile);
@@ -12,9 +15,12 @@ const xml = text => String(text).replaceAll('&', '&amp;').replaceAll('<', '&lt;'
 const systemdArgument = text => `"${String(text).replaceAll('\\', '\\\\').replaceAll('"', '\\"').replaceAll('%', '%%').replaceAll('$', () => '$$')}"`;
 const windowsArgument = text => `"${String(text).replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/g, '$1$1')}"`;
 
-export function supervisorServiceDefinition({ root, entry, node = process.execPath, platform = process.platform, home = homedir() }) {
+export function supervisorServiceDefinition({ root, entry, node = process.execPath, platform = process.platform, home = homedir(), providerEnvironment = {} }) {
   if ([root, entry, node].some(value => typeof value !== 'string' || /[\r\n\0]/.test(value))) throw new Error('Invalid supervisor service path.');
-  const args = [entry, 'delivery', 'runtime', 'supervisor-watch', '--root', root, '--no-auto-update'];
+  const environment = Object.fromEntries(Object.entries(providerEnvironment).filter(([key]) => ['PATH', 'SIMY_CODEX_BIN', 'SIMY_CODEX_EXPECTED_VERSION'].includes(key)));
+  if (Object.values(environment).some(value => typeof value !== 'string' || /[\r\n\0]/.test(value))) throw new Error('Invalid provider environment.');
+  const bootstrap = Object.keys(environment).length ? ['--import', `data:text/javascript,${encodeURIComponent(`Object.assign(process.env,${JSON.stringify(environment)})`)}`] : [];
+  const args = [...bootstrap, entry, 'delivery', 'runtime', 'supervisor-watch', '--root', root, '--no-auto-update'];
   if (platform === 'linux') {
     const name = 'simy-delivery-supervisor.service';
     return { name, file: join(home, '.config/systemd/user', name),
@@ -37,17 +43,19 @@ export function supervisorServiceDefinition({ root, entry, node = process.execPa
 // Explicit service installation only. Installing/updating a runtime alone
 // never enables this service or enrolls a conversation.
 export async function installSupervisorService({ root, home = homedir(), platform = process.platform,
-  run = exec, inspectPin = pinnedWorkflowSource } = {}) {
+  run = exec, inspectPin = pinnedWorkflowSource, inspectBackend = inspectBackendExecutable, environment = process.env } = {}) {
   const control = await readSupervisorState(join(root, 'supervisor-runtime/control.json'));
   if (control?.version !== 1 || control.enabled !== true) throw new Error('Enable supervisor recovery explicitly before installing its OS service.');
   await inspectPin({ root });
   const pin = await readSupervisorState(join(root, 'delivery-runtime/current.json'));
   if (!pin || pin.digest !== control.digest || pin.release !== control.release) throw new Error('Supervisor activation no longer matches the fixed runtime.');
-  const definition = supervisorServiceDefinition({ root, home, platform, entry: join(pin.release, 'src/index.js') });
+  const provider = await supervisorProviderEnvironment({ home, platform, environment, inspectBackend });
+  const definition = supervisorServiceDefinition({ root, home, platform, entry: join(root, 'bin/simy-runtime.mjs'), providerEnvironment: provider.environment });
   try {
     const info = await lstat(definition.file);
     if (!info.isFile() || info.isSymbolicLink() || !(await readFile(definition.file, 'utf8')).includes(marker)) throw new Error('Supervisor service path is not managed by SIMY.');
   } catch (error) { if (error.code !== 'ENOENT') throw error; }
+  await installPinnedCliEntry(root);
   await mkdir(dirname(definition.file), { recursive: true, mode: 0o700 });
   await writeFile(definition.file, definition.content, { mode: 0o600 });
   if (platform === 'linux') {
@@ -61,5 +69,29 @@ export async function installSupervisorService({ root, home = homedir(), platfor
     await run(scheduler, ['/Create', '/TN', definition.name, '/XML', definition.file, '/F']);
     await run(scheduler, ['/Run', '/TN', definition.name]);
   }
-  return { ...definition, content: undefined, status: 'registered', scope: 'previously_enrolled_tasks_only' };
+  return { ...definition, content: undefined, status: 'registered', execution: 'awaiting_service_observation', provider: provider.inspection, scope: 'previously_enrolled_tasks_only' };
+}
+
+
+// Resolve and re-probe under exactly the environment passed to the service.
+// This is a prerequisite observation, never proof of task execution/acceptance.
+export async function supervisorProviderEnvironment({ home = homedir(), platform = process.platform, environment = process.env,
+  inspectBackend = inspectBackendExecutable, onStep } = {}) {
+  return runSceneReasoning({ home, platform, environment }, {
+    understand_scene: scene => ({ ...scene, candidates: backendCandidates('codex', { home, platform, environment }).filter(value => typeof value === 'string' && isAbsolute(value)) }),
+    derive_perspectives: async scene => ({ ...scene, inspection: await inspectBackend('codex', {
+      candidates: scene.candidates, minimumVersion: CODEX_WRITER_LOCK_MINIMUM_VERSION, discoveryOptions: { home, platform, environment },
+    }) }),
+    prioritize_options: scene => {
+      if (!scene.inspection.compatible || !isAbsolute(scene.inspection.executable || '')) throw new Error('No compatible absolute Codex executable for the supervisor service.');
+      const selected = scene.inspection.executable;
+      return { ...scene, selected, environment: { PATH: [dirname(process.execPath), dirname(selected), environment.PATH || environment.Path || ''].join(delimiter), SIMY_CODEX_BIN: selected, SIMY_CODEX_EXPECTED_VERSION: scene.inspection.installed_version } };
+    },
+    connect_to_next_check: async scene => {
+      const verified = await inspectBackend('codex', { candidates: [scene.selected], minimumVersion: CODEX_WRITER_LOCK_MINIMUM_VERSION,
+        discoveryOptions: { home, platform, environment: scene.environment }, executionEnvironment: scene.environment });
+      if (!verified.compatible || verified.executable !== scene.selected || verified.installed_version !== scene.inspection.installed_version) throw new Error('Supervisor provider changed during service-environment verification.');
+      return { environment: scene.environment, inspection: verified };
+    },
+  }, { onStep });
 }

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

@@ -5,6 +5,7 @@ import { setTimeout as delay } from 'node:timers/promises';
 import { acquireDesktopProcessLock, assertNoDesktopHostForOrigin } from '../desktop-process-lock.js';
 import { pinnedWorkflowSource } from './local-runtime.js';
 import { resolveWebOrigin } from '../web-origin.js';
+import { completeSupervisorHandover } from './supervisor-handover.js';
 import { observeSupervisorOwner, supervisorProcessAlive, supervisorProcessIdentity,
   readSupervisorState, saveSupervisorState } from './supervisor-owner.js';
 
@@ -39,17 +40,18 @@ export async function supervisorWatchdogStatus({ root, now = Date.now(), observe
 export function createSupervisorWatchdog({ root, inspectPin = verifiedPin, readControl = () => readSupervisorState(controlPath(root)),
   observeOwner = observeSupervisorOwner, checkDesktop = assertNoDesktopHostForOrigin,
   launch = (bin, args, options) => spawn(bin, args, options), now = Date.now,
+  completeHandover = completeSupervisorHandover, watcherNonce,
   identity = supervisorProcessIdentity, save = state => saveSupervisorState(statePath(root), state) } = {}) {
   let child = null, childIdentity = null, launchTime = null, closed = false, running = null, lastExit = null;
-  let pendingPin = null, lastWall = null, controlEpoch;
+  let pendingPin = null, lastWall = null, controlEpoch, handoverRetryAt = 0;
   const clock = () => Math.max(0, now());
   const tick = async () => {
     if (closed) return;
     const at = clock(), control = await readControl();
     controlEpoch = control?.epoch;
     const previous = pendingPin || await readSupervisorState(statePath(root));
-    const state = { version: 1, at, action: 'observe', supervisor: null, lastExit,
-      lastLaunchAt: launchTime ?? previous?.lastLaunchAt ?? null, epoch: previous?.epoch || null };
+    const state = { version: 1, handoverVersion: 1, watcherNonce, at, action: 'observe', supervisor: null, lastExit,
+      lastLaunchAt: launchTime ?? previous?.lastLaunchAt ?? null, epoch: control?.epoch || null };
     if (!control || control.version !== 1 || control.enabled !== true) { state.action = 'disabled'; await save(state); return state; }
     state.supervisor = await observeOwner(root, { now: at });
     if (state.supervisor.state === 'running') {
@@ -57,6 +59,15 @@ export function createSupervisorWatchdog({ root, inspectPin = verifiedPin, readC
       await save(state); return state;
     }
     if (!['missing', 'dead'].includes(state.supervisor.state)) { state.action = 'owner_unknown'; await save(state); return state; }
+    const retryAt = Math.max(handoverRetryAt, previous?.handoverRetryAt || 0);
+    if (retryAt > at) { state.action = 'handover_backoff'; state.handoverRetryAt = retryAt; await save(state); return state; }
+    try {
+      if (await completeHandover(root)) { state.action = 'handover_activated'; await save(state); return state; }
+    } catch (error) {
+      state.action = 'handover_wait'; state.reason = error.code === 'process_conflict' ? 'owner_not_released' : 'activation_failed';
+      handoverRetryAt = state.handoverRetryAt = at + 30_000;
+      await save(state); return state;
+    }
     if (child && child.exitCode === null && child.signalCode === null) { state.action = 'child_starting'; await save(state); return state; }
     // Persist the launch intent before spawn. On watchdog crash/restart this
     // gives the previous child time to publish its singleton owner receipt.
@@ -125,7 +136,7 @@ export async function watchSupervisor({ root, signal, once = false, wait = delay
   let watchdog, initialEpoch;
   try {
     initialEpoch = (await readSupervisorState(controlPath(root)))?.epoch;
-    watchdog = createWatchdog({ root });
+    watchdog = createWatchdog({ root, watcherNonce: lock.nonce });
     do {
       if (signal?.aborted) break;
       await watchdog.tick();

package/src/delivery-hooks/supervisor.js

@@ -1,6 +1,10 @@
 import { captureDispatchProvenance } from '../update-detachment/provenance.js';
 import { captureDispatchOwner, assertTaskAdmission, dispatchWithFence, queueDispatchReceipt, rootFromDelivery, observeDispatchEvent } from '../update-detachment/dispatch-gate.js';
+import { bindCompletionArtifacts } from '../session-supervision/completion-artifacts.js';
+import { recoveryWorkProposal, admitRecoveryWork } from '../session-supervision/recovery-frontier.js';
 import { safeCheckpointDiagnostic } from './checkpoint-diagnostic.js';
+import { continueResultCycle, resultEvent, executeResultCycle, acceptResultEvent } from '../codex-plugins/simy/hooks/result-cycle.mjs';
+import { finalResponseRecoveryInstruction } from '../session-supervision/final-response-recovery.js';
 import { recordHandoffStage } from '../codex-plugins/simy/hooks/consistency-handoff.mjs';
 import { retainControllerEvidence } from '../codex-plugins/simy/hooks/purpose-evidence.mjs';
 import { workspaceIdentity, reviewWorkspaceIdentity } from '../session-supervision/purpose-verification.js';
@@ -15,10 +19,12 @@ import { requireProviderLink } from '../provider-links.js';
 import { spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import { dirname } from 'node:path';
-import { hasPendingUserStop, recordPath, canExecuteAutonomousExternal, automaticContinuationAllowed, settlePurposeVerification, assessedCheckpointContract, checkpointDelivery, decideStop, deliveryProgressContext, deliveryStop, listRecords, readRecord, managedBudgetReason, notifyState, processIdentity, sharesTaskWorkspace, taskDirectory, reconcileRecords, updateRecord, verifyAutomaticCriteria } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+import { hasPendingUserStop, recordPath, canExecuteAutonomousExternal, automaticContinuationAllowed, queuePurposeDiagnosis, settlePurposeVerification, informationWaitInstruction, assessedCheckpointContract, checkpointDelivery, decideStop, deliveryProgressContext, deliveryStop, listRecords, readRecord, managedBudgetReason, notifyState, processIdentity, sharesTaskWorkspace, taskDirectory, reconcileRecords, updateRecord, verifyAutomaticCriteria } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
 import { resolveBackendExecutable } from '../backend-executable.js';
-import { executeCodexAppServer } from '../session-supervision/codex-app-server.js';
+import { safeProviderFailure, providerEnvironmentIdentity, checkProviderRetry } from '../session-supervision/provider-failure.js';
+import { executeCodexAppServer, inspectCodexAppServer } from '../session-supervision/codex-app-server.js';
 import { acquireWorkspaceLease, leaseOwnerDead } from '../session-supervision/workspace-lease.js';
+import { createTaskPool } from '../codex-plugins/simy/hooks/loop-kernel.mjs';
 
 const MAX_OUTPUT = 64 * 1024;
 const SAFE_PROVIDER_CODES = new Set(['authentication_required', 'identity', 'permission_narrowed', 'permission_restore', 'turn_failed', 'checkpoint',
@@ -100,7 +106,7 @@ export async function executeCodexResume(record, { signal, root, leaseId, execut
     remainingWork: run.managed.remainingWork, acceptanceCriteria: run.managed.acceptanceCriteria, proposedAction: run.managed.proposedAction,
     currentDecision: run.managed.autonomyPolicy ? run.managed.decision : undefined, diagnosis: run.managed.plan?.diagnosis,
     progress: deliveryProgressContext(run) };
-  const prompt = run.managed.autonomyPolicy ? `Continue the existing SIMY managed task in this exact session. Context: ${JSON.stringify(context)}\nExecute ONLY currentDecision.action. Its expectedVerification and rollback apply to this turn. Stay within provider permissions. End with ONLY one JSON checkpoint. ${assessedCheckpointContract(run.managed.decision, run.managed)} Do not write SIMY state directly.` : `Continue the existing SIMY managed task in this exact session. Context: ${JSON.stringify(context)}\n${minimalSufficientChangeInstruction()}\nStay within the original task and provider permissions. End with ONLY one JSON object: {"status":"in_progress|completed|blocked|error","summary":"...","nextStep":"...","remainingWork":"...","proposedAction":{"kind":"read|local_edit|local_test|external|destructive|scope_change|unknown","scope":"...","summary":"..."},"evidence":[],"acceptanceMet":false}. For blocked include blocker (authorization, missing_information, external_dependency), and for authorization include approval {kind,scope,summary}. Do not claim completion without checking frozen acceptance. SIMY independently verifies supported criteria. Do not write SIMY state directly. If approval or input is needed, return blocked and stop.`;
+  const prompt = run.managed.autonomyPolicy ? `Continue the existing SIMY managed task in this exact session. Context: ${JSON.stringify(context)}\nExecute ONLY currentDecision.action. Its expectedVerification and rollback apply to this turn. Stay within provider permissions. End with ONLY one JSON checkpoint. ${assessedCheckpointContract(run.managed.decision, run.managed)} Do not write SIMY state directly.` : `Continue the existing SIMY managed task in this exact session. Context: ${JSON.stringify(context)}\n${minimalSufficientChangeInstruction()}\nStay within the original task and provider permissions. End with ONLY one JSON object: {"status":"in_progress|completed|blocked|error","summary":"...","nextStep":"...","remainingWork":"...","proposedAction":{"kind":"read|local_edit|local_test|external|destructive|scope_change|unknown","scope":"...","summary":"..."},"evidence":[],"acceptanceMet":false}. ${informationWaitInstruction} For blocked include blocker (authorization, missing_information, external_dependency), and for authorization include approval {kind,scope,summary}. Do not claim completion without checking frozen acceptance. SIMY independently verifies supported criteria. Do not write SIMY state directly. If approval or input is needed, return blocked and stop.`;
   const sandbox = run.managed.autonomyPolicy && run.managed.decision?.action.kind === 'read' ? 'read-only' : run.managed.autoRecoverySandbox;
   const args = ['exec', '--json', '--skip-git-repo-check', '-s', sandbox, '-m', run.managed.resumeModel, 'resume', record.session, prompt];
   if (signal?.aborted) throw new Error('Managed recovery cancelled before provider dispatch.');
@@ -150,7 +156,7 @@ export async function executeCodexResume(record, { signal, root, leaseId, execut
   });
 }
 
-export async function tickManagedTasks({ root, webOrigin, now = Date.now(), execute, inspectProcess = processIdentity, signal, beforeClaim, authorizeDispatch, readRecords, observeTurn, observeAuthentication } = {}) {
+export async function tickManagedTasks({ root, webOrigin, now = Date.now(), execute, inspectProcess = processIdentity, signal, beforeClaim, authorizeDispatch, readRecords, observeTurn, observeAuthentication, inspectProvider = inspectCodexAppServer, shouldYield } = {}) {
   const tickWallStart = Date.now();
   const currentTime = () => now + Math.max(0, Date.now() - tickWallStart);
   if (signal?.aborted) return;
@@ -160,7 +166,7 @@ export async function tickManagedTasks({ root, webOrigin, now = Date.now(), exec
   if (signal?.aborted) return;
   const records = await readCandidates();
   for (let record of records) {
-    if (signal?.aborted) break;
+    if (signal?.aborted || await shouldYield?.()) break;
     const claimNow = currentTime();
     if (!record.run?.managed) continue;
     record = await recoverOutcomeAuditLease(record, { root, inspectProcess });
@@ -181,9 +187,27 @@ export async function tickManagedTasks({ root, webOrigin, now = Date.now(), exec
       const owner = run.managed.resumeLease?.owner;
       const ownerDead = await leaseOwnerDead(owner, inspectProcess);
       // A live/unknown owner is never taken over merely because time passed.
-      if (!ownerDead && (owner || claimNow - run.managed.resumeLease?.claimedAt <= 5 * 60_000)) continue;
-      await updateRecord(root, record.provider, record.session, current => {
+      const acceptedCheckpoint = run.managed.executionAttempt?.id === run.managed.resumeLease?.id &&
+        run.managed.executionAttempt?.phase === 'checkpointed' &&
+        run.managed.executionAttempt?.checkpointRevision === run.revision;
+      if (!ownerDead && (owner || !acceptedCheckpoint)) continue;
+      await updateRecord(root, record.provider, record.session, async current => {
         if (hasPendingUserStop(root, current) || current?.run?.state !== 'auto_resuming' || current.run.managed.resumeLease?.id !== run.managed.resumeLease?.id) return current;
+        const accepted = current.run.managed.executionAttempt;
+        if (accepted?.id === current.run.managed.resumeLease?.id && accepted.phase === 'checkpointed' &&
+            accepted.checkpointRevision === current.run.revision) {
+          // The checkpoint transaction survived but its host did not. Settle
+          // that checkpoint; never dispatch the already acknowledged action.
+          delete current.run.managed.resumeLease;
+          await verifyAutomaticCriteria(current, claimNow);
+          const decision = decideStop(current.run, claimNow);
+          current.run = decision.run;
+          if (current.run.state === 'active') {
+            current.run.state = 'recovery_required';
+            current.run.recoveryCause = current.run.managed.resumeChannel === 'codex_app_server' ? 'session_supervision' : 'process_exit';
+          }
+          current.run.updatedAt = claimNow; notifyState(current.run, claimNow); return current;
+        }
         current.run.state = 'recovery_required'; current.run.recoveryCause = 'interrupted_owner'; current.run.managed.autoRecovery = false;
         recordRecoveryIncident(current.run, { code: 'interrupted_owner', subject: current.run.managed.executionAttempt?.id || '', now: claimNow });
         recordRecoveryStage(current.run, 'interrupted', { now: claimNow, attemptId: current.run.managed.executionAttempt?.id });
@@ -192,12 +216,34 @@ export async function tickManagedTasks({ root, webOrigin, now = Date.now(), exec
         if (attempt?.budgetReservation && attempt.phase === 'dispatching') { attempt.budgetReservation.state = 'unknown'; current.run.managed.unknownConsumption = true; if (current.run.managed.maxTokens) current.run.managed.usageBlocked = true; }
         if (attempt?.phase === 'dispatching' && attempt.action?.kind !== 'read') current.run.managed.executionUncertain = {
           attemptId: attempt.id, decisionId: attempt.decisionId, action: attempt.action, at: claimNow };
+        // Ownership is released only after the existing process-identity check
+        // proves the owner dead and uncertain effects have been retained.
+        delete current.run.managed.resumeLease;
         current.run.updatedAt = claimNow; notifyState(current.run, claimNow); return current;
       });
       continue;
     }
     if (!automaticContinuationAllowed(record)) continue;
-    try { await requireProviderLink({ root, provider: record.provider }); } catch { continue; }
+    let providerLink;
+    try { providerLink = await requireProviderLink({ root, provider: record.provider }); } catch { continue; }
+    if (run.managed.providerCapabilityWait) {
+      if (run.state !== 'recovery_required' || run.managed.resumeLease || managedBudgetReason(run, claimNow)) continue;
+      const expected = run.managed.providerCapabilityWait;
+      let check;
+      try { check = await checkProviderRetry(expected, inspectProvider, { now: claimNow, signal }); } catch { continue; }
+      record = await updateRecord(root, record.provider, record.session, current => {
+        if (current?.run?.id !== run.id || !automaticContinuationAllowed(current) || current.run.state !== 'recovery_required' ||
+            current.run.managed.resumeLease || JSON.stringify(current.run.managed.providerCapabilityWait) !== JSON.stringify(expected)) return current;
+        if (check.retry) {
+          delete current.run.managed.providerCapabilityWait;
+          current.run.managed.autoRecovery = true; current.run.recoveryCause = 'session_supervision';
+          current.run.managed.nextAttemptAt = claimNow;
+        } else current.run.managed.providerCapabilityWait = check.wait;
+        return current;
+      });
+      run = record.run;
+      if (run.managed.providerCapabilityWait) 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', 'external'].includes(run.managed.decision.action?.kind) &&
@@ -207,7 +253,7 @@ export async function tickManagedTasks({ root, webOrigin, now = Date.now(), exec
     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 });
+      await requireProviderLink({ root, provider: record.provider, expectedEpoch: providerLink.epoch });
       if (!authorizeDispatch) return;
       const latest = await authorizeDispatch(record);
       if (authorizationScope !== undefined && latest !== authorizationScope) throw Object.assign(new Error("Desktop authorization scope changed."), { code: "desktop_access_required" });
@@ -228,8 +274,16 @@ export async function tickManagedTasks({ root, webOrigin, now = Date.now(), exec
     let claimed;
     try { claimed = await updateRecord(root, record.provider, record.session, current => {
       const live = current?.run;
+      // Re-read if the selected task or action changed while acquiring the state lock.
+      if (live?.id !== run.id || live.revision !== run.revision || live.controlRevision !== run.controlRevision ||
+          live.managed?.taskId !== run.managed?.taskId || live.managed?.decision?.id !== run.managed?.decision?.id ||
+          live.managed?.providerCapabilityWait) return current;
+
       if (!automaticContinuationAllowed(current)) return current;
       if (live?.managed?.outcomeAudit?.lease) return current;
+      if (current.autoContinueEpoch !== record.autoContinueEpoch ||
+          live.managed?.executionUncertain && live.managed.recoveryDiagnosisDecisionId !== live.managed.decision?.id ||
+          ['pending', 'transferred', 'pending_received'].includes(live.managed?.handoff?.status)) return current;
       const appChannel = live?.managed?.resumeChannel === 'codex_app_server';
       const allowedCause = live?.recoveryCause === 'process_exit' || appChannel && ['session_supervision', 'approved_action'].includes(live?.recoveryCause);
       const approved = live?.managed?.decision?.outcome === 'wait' && ['read', 'local_edit', 'local_test', 'external'].includes(live.managed.decision.action?.kind) &&
@@ -239,12 +293,20 @@ export async function tickManagedTasks({ root, webOrigin, now = Date.now(), exec
       if (stop) {
         live.state = stop.code === 'purpose_budget' ? 'budget_exhausted' : stop.code === 'failure_limit' ? 'failed' : 'paused'; live.reason = stop.reason; live.updatedAt = currentTime(); notifyState(live, live.updatedAt); return current;
       }
+      const workProposal = recoveryWorkProposal(current);
+      if (workProposal?.blocked) return current;
       live.state = 'auto_resuming'; live.managed.resumeLease = { id: leaseId, claimedAt: currentTime(), checkpointRevision: live.revision, decisionId: live.managed.decision?.id || null,
-        owner: { pid: process.pid, identity: ownerIdentity } };
+        owner: { pid: process.pid, identity: ownerIdentity }, workProposal: workProposal ? { inputDigest: workProposal.inputDigest } : null };
       live.managed.executionAttempt = { id: leaseId, decisionId: live.managed.decision?.id || null,
         action: live.managed.decision?.action || live.managed.proposedAction,
         budgetReservation: { rootTaskId: live.managed.taskId, tokens: live.managed.maxTokens ? Math.max(0, live.managed.maxTokens - (live.managed.tokensUsed || 0)) : null, state: 'reserved', epoch: leaseId }, phase: 'claimed', claimedAt: currentTime(), lastActivityAt: currentTime() };
       live.managed.executionAttempt.recoveryIncidentId = live.managed.recovery?.currentId || null;
+      const pendingResult = live.resultCycle?.events.find(row => row.id === live.resultCycle.pendingId);
+      // Carry the actual preceding result into its dispatch receipt. A synthetic
+      // initial/condition event is needed only when no unconsumed result exists.
+      if (!pendingResult || pendingResult.dispatchAttemptId) acceptResultEvent(current, resultEvent(current, {
+        kind: 'condition_changed', origin: 'supervisor_claim',
+        sourceId: `dispatch:${live.managed.decision?.id}:${live.revision}`, now: currentTime() }));
       // Retain the repair action identity during independent verification.
       // Older receipts can still be executing after a verifier; bind those to
       // the next actual diagnosis/repair only after all lease/authority fences.
@@ -318,7 +380,8 @@ export async function tickManagedTasks({ root, webOrigin, now = Date.now(), exec
         if (!result) {
         await authorizeClaim();
         const runner = execute || (appServer ? executeCodexAppServer : executeCodexResume);
-        result = await runner(claimed, { signal: controller.signal, root, webOrigin, leaseId, currentTime, leaseMonitored: true,
+        result = await executeResultCycle({ record: claimed, attemptId: leaseId, execute: runner, persist: persistReceipt,
+          options: { signal: controller.signal, root, webOrigin, leaseId, currentTime, leaseMonitored: true,
           onStarted: async observation => {
             await persistReceipt(current => {
               const attempt = current?.run?.managed?.executionAttempt;
@@ -352,6 +415,16 @@ export async function tickManagedTasks({ root, webOrigin, now = Date.now(), exec
               const live = current?.run;
               if (live?.state !== 'auto_resuming' || live.managed?.resumeLease?.id !== leaseId) throw new Error('Managed recovery lease changed before provider dispatch.');
               if (!automaticContinuationAllowed(current)) throw new Error('Automatic continuation was disabled before provider dispatch.');
+              if (live.managed.executionAttempt?.id !== leaseId || live.managed.executionAttempt.phase !== 'claimed') {
+                throw new Error('Managed attempt was already dispatched or replaced.');
+              }
+              if (current.autoContinueEpoch !== claimed.autoContinueEpoch ||
+                  live.revision !== live.managed.resumeLease.checkpointRevision ||
+                  (live.managed.decision?.id || null) !== live.managed.resumeLease.decisionId ||
+                  ['pending', 'transferred', 'pending_received'].includes(live.managed.handoff?.status) ||
+                  live.managed.executionUncertain && live.managed.recoveryDiagnosisDecisionId !== live.managed.decision?.id) {
+                throw new Error('Managed recovery authorization changed before provider dispatch.');
+              }
               if (appServer) {
                 if (!providerSandbox || !['readOnly', 'workspaceWrite', 'dangerFullAccess', 'externalSandbox'].includes(providerSandbox.type)) throw new Error('Original Codex sandbox policy is unavailable.');
                 // Observation is not enrollment authority. In particular, a
@@ -362,6 +435,7 @@ export async function tickManagedTasks({ root, webOrigin, now = Date.now(), exec
               const ledger=live.managed.purpose?.evidence;
               if(selected?.dependsOn?.some(id=>!ledger?.units?.some(unit=>unit.id===id && unit.status==='verified' && unit.purposeRevision===ledger.purposeRevision))) throw new Error('Required dependency is not independently verified.');
               if (live.managed.decision?.autonomousExternal && !canExecuteAutonomousExternal(live.managed)) throw new Error('Autonomous external authority changed before dispatch.');
+              admitRecoveryWork(current, live.managed.resumeLease.workProposal, leaseId, currentTime());
               const approved = live.managed.approvedAction;
               live.managed.executionAttempt.phase = 'dispatching';
               live.managed.executionAttempt.dispatchedAt = currentTime();
@@ -376,7 +450,7 @@ export async function tickManagedTasks({ root, webOrigin, now = Date.now(), exec
               return current;
             });
             await authorizeClaim();
-          } });
+          } } });
         }
       }
     } catch (error) { result = error?.code === 'provider_link_disconnected'
@@ -384,15 +458,25 @@ export async function tickManagedTasks({ root, webOrigin, now = Date.now(), exec
       : error?.code === 'desktop_access_required'
       ? { code: -3, busy: true, accessDenied: true }
       : { code: controller.signal.aborted ? -2 : -1, cancelled: controller.signal.aborted,
-        providerTurnId: error?.providerTurnId, providerSessionId:error?.providerSessionId, question: error?.question, errorCode: error?.code || 'provider_error', restorationUnverified: error?.restorationUnverified === true }; }
+        providerTurnId: error?.providerTurnId, providerSessionId:error?.providerSessionId, question: error?.question,
+        finalResponseWithoutCheckpoint: error?.finalResponseWithoutCheckpoint,
+        errorCode: error?.code || 'provider_error', diagnostic: safeProviderFailure(error?.diagnostic), restorationUnverified: error?.restorationUnverified === true }; }
     try {
+    if (!dispatched && ['unsupported', 'unavailable'].includes(result.errorCode) && ['writer_lock', 'provider_available', 'service_identity', 'bounded_history', 'connector_inventory', 'connector_pagination', 'review_configuration', 'review_isolation'].includes(result.diagnostic?.capability)) {
+      try { result.providerEnvironment = await providerEnvironmentIdentity(inspectProvider); } catch { /* No guessed identity: normal bounded failure path remains. */ }
+    }
     await usageQueue;
     if (usageError) result = { ...result, code: -1, errorCode: 'usage_unavailable' };
     usage ||= result?.usage || null;
     if (controller.signal.aborted) result = { ...result, code: -2, cancelled: true };
     if (result.code === 0) {
       try {
-        if (result.verification) await settlePurposeVerification({ root, provider: record.provider, session: record.session, expectedLease: leaseId, review: result.verification, verifySnapshot: current => reviewWorkspaceIdentity(current, root, result.verification, { signal: controller.signal }), now: Date.now() });
+        if (result.verification) await settlePurposeVerification({ root, provider: record.provider, session: record.session, expectedLease: leaseId, review: result.verification, verifySnapshot: async current => {
+          const refreshed = await bindCompletionArtifacts(current, result.verification, {
+            authorize: async () => { await assertActiveLease(root, record.provider, record.session, leaseId, controller.signal, currentTime); await authorizeClaim(); }, signal: controller.signal });
+          Object.assign(result.verification, refreshed);
+          return reviewWorkspaceIdentity(current, root, result.verification, { signal: controller.signal });
+        }, now: Date.now() });
         else await checkpointDelivery({ root, provider: record.provider, session: record.session, cwd: record.cwd,
           checkpoint: result.checkpoint || parseAgentCheckpoint(result.output, record.session), expectedLease: leaseId, toolEvidence: result.toolEvidence || [], sourceContext: result.sourceContext, controllerEvidence: result.controllerEvidence, now: Date.now() });
         if (result.dispatchAttemptId) queueDispatchReceipt({ root: rootFromDelivery(root), attemptId: result.dispatchAttemptId, receiptId: `checkpoint:${leaseId}`, resultRef: `delivery-record:${record.provider}:${record.session}:${leaseId}` });
@@ -435,7 +519,15 @@ export async function tickManagedTasks({ root, webOrigin, now = Date.now(), exec
       }
       if (result.errorCode === 'checkpoint_rejected') live.managed.lastCheckpointRejection = { at: Date.now(), decisionId: claimed.run.managed.decision?.id, diagnostic: result.diagnostic };
       else if (result.code === 0) delete live.managed.lastCheckpointRejection;
+      if (result.errorCode === 'checkpoint' && result.finalResponseWithoutCheckpoint) {
+        live.managed.finalResponseWithoutCheckpoint = { ...result.finalResponseWithoutCheckpoint,
+          providerTurnId: result.providerTurnId, providerSessionId: result.providerSessionId || record.session };
+      } else if (result.code === 0) delete live.managed.finalResponseWithoutCheckpoint;
       const attempt = live.managed.executionAttempt;
+      const attemptedUnit = live.managed.purpose?.evidence?.units?.find(unit => unit.id === attempt?.decisionId);
+      if (attemptedUnit?.status === 'dispatched' && result.code !== 0) {
+        attemptedUnit.status = attempt.action?.kind === 'read' ? 'failed' : 'unknown';
+      }
       if (!result.busy && attempt?.phase === 'dispatching' && attempt.action?.kind !== 'read') live.managed.executionUncertain = {
         attemptId: leaseId, decisionId: attempt.decisionId, action: attempt.action, at: Date.now() };
       live.managed.attempts ||= [];
@@ -445,8 +537,9 @@ export async function tickManagedTasks({ root, webOrigin, now = Date.now(), exec
         checkpointRevision: live.revision, outcome: result.busy ? 'busy' : result.cancelled ? 'cancelled' : result.code === 0 ? 'checkpoint' : 'failed',
         errorCode: result.code === 0 || result.busy || result.cancelled ? null : safeProviderCode(result.errorCode),
         ...(result.providerSessionId ? {providerSessionId:result.providerSessionId} : {}),
+        ...(safeProviderFailure(result.diagnostic) ? { diagnostic: safeProviderFailure(result.diagnostic) } : {}),
         restorationUnverified: result.restorationUnverified === true,
-        reason: result.accessDenied ? 'Desktop organization access is required before another provider turn.' : result.busy ? 'Exact provider session currently has another writer.' : result.cancelled ? 'Managed recovery cancelled before completion.' : result.code === 0 ? 'Structured checkpoint recorded.' : 'Provider failed or returned an invalid checkpoint.',
+        reason: result.accessDenied ? 'Desktop organization access is required before another provider turn.' : result.busy ? 'Exact provider session currently has another writer.' : result.cancelled ? 'Managed recovery cancelled before completion.' : result.code === 0 ? 'Structured checkpoint recorded.' : result.diagnostic ? `Provider capability unavailable: ${safeProviderFailure(result.diagnostic)?.capability || 'unknown'}. Retry after its environment changes.` : 'Provider failed or returned an invalid checkpoint.',
         nextStep: live.nextStep });
       live.managed.attempts = live.managed.attempts.slice(-20);
       if (result.code !== 0) recordRecoveryStage(live, result.busy ? 'waiting' : 'interrupted', {
@@ -486,6 +579,10 @@ export async function tickManagedTasks({ root, webOrigin, now = Date.now(), exec
       } else if (result.cancelled) {
         live.managed.autoRecovery = false; live.state = 'recovery_required'; live.recoveryCause = 'shutdown_cancelled';
         live.reason = 'Managed recovery was cancelled; inspect the original session before the next bounded recovery.';
+      } else if (result.providerEnvironment && !dispatched) {
+        live.managed.providerCapabilityWait = { diagnostic: safeProviderFailure(result.diagnostic), environmentIdentity: result.providerEnvironment.identity, nextCheckAt: currentTime() + 60000, checks: 0 };
+        live.managed.autoRecovery = true; live.state = 'recovery_required'; live.recoveryCause = 'session_supervision';
+        live.reason = 'Provider capability needs an environment change; bounded read-only checks continue without spending another provider turn.';
       } else if (result.code !== 0) {
         live.failures += 1; live.managed.autoRecovery = false;
         live.state = failureLimitReached(live) ? 'failed' : 'recovery_required';
@@ -493,6 +590,16 @@ export async function tickManagedTasks({ root, webOrigin, now = Date.now(), exec
         live.reason = appServer ? providerFailureReason(safeProviderCode(result.errorCode)) +
           (result.restorationUnverified ? ' Original provider permissions also require inspection.' : '') :
           'Codex recovery process failed; inspect its checkpoint and original session before the next bounded recovery.';
+        // Recover the missing handoff with a read diagnosis, never by replaying
+        // the last action. The existing dispatcher rechecks leases and rights.
+        if (appServer && live.state !== 'failed' && automaticContinuationAllowed(current) &&
+            !live.managed.pendingApproval && !live.managed.nativeWait && !live.managed.purpose?.nativeBoundary &&
+            (result.errorCode === 'checkpoint' && result.finalResponseWithoutCheckpoint || result.errorCode === 'checkpoint_rejected')) {
+          await continueResultCycle(current, resultEvent(current, { kind: 'final_response', origin: 'executor_result',
+            sourceId: result.providerTurnId || leaseId, attemptId: leaseId, resultRef: `attempt:${leaseId}` }), {
+            selectNext: () => queuePurposeDiagnosis(live, finalResponseRecoveryInstruction,
+              `missing-handoff:${result.providerTurnId || leaseId}`, Date.now(), 'checkpoint') });
+        }
       } else if (live.revision <= run.revision) {
         live.failures += 1;
         live.reason = result.code === 0 ? 'Codex recovery returned without a checkpoint.' : 'Codex recovery failed; inspect the original session.';
@@ -514,6 +621,9 @@ export async function tickManagedTasks({ root, webOrigin, now = Date.now(), exec
           current.run.reason = 'Verified checkpoint recorded; next bounded exact-session attempt is pending.';
         }
       }
+      if (result.code !== 0) await continueResultCycle(current, resultEvent(current, {
+        kind: 'failure', origin: 'executor_result', sourceId: result.providerTurnId || leaseId,
+        attemptId: leaseId, resultRef: `attempt:${leaseId}` }));
       current.run.updatedAt = Date.now(); notifyState(current.run, current.run.updatedAt); return current;
     });
     // Settling uncertainty must precede unlocking: otherwise another session
@@ -526,19 +636,42 @@ export async function tickManagedTasks({ root, webOrigin, now = Date.now(), exec
 export function createManagedSupervisor(options) {
   let running = null, auditing = null, closed = false;
   const controller = new AbortController();
+  const workers = createTaskPool({ concurrency: options.concurrency ?? 4 });
+  const readCandidates = options.readRecords || (() => listRecords(options.root));
   return {
     tick() {
       if (closed) return Promise.resolve();
       if (!auditing) auditing = (async () => {
         const runtime = await desktopRuntimeStatus({ root: dirname(options.root) }).catch(() => ({ state: 'runtime_observation_failed' }));
         await runConsistencyMonitor({ root: options.root, runtime, readRecords: options.readRecords || (() => listRecords(options.root)),
-          onAudit: (record, findings, request) => auditConsistencyTask(record, findings, request, {
+          onAudit: async (record, findings, request) => closed || await options.shouldYield?.() ? undefined : auditConsistencyTask(record, findings, request, {
             root: options.root, signal: controller.signal, authorize: options.authorizeDispatch || (async () => {}) }) });
       })().catch(() => {}).finally(() => { auditing = null; });
-      if (!running) running = tickManagedTasks({ ...options, signal: controller.signal }).finally(() => { running = null; });
+      if (!running) running = (async () => {
+        for (const record of await readCandidates()) {
+          if (closed || await options.shouldYield?.()) break;
+          if (!record.run?.managed) continue;
+          const key = `${record.provider}:${record.session}`;
+          workers.offer(key, async () => {
+            if (closed || await options.shouldYield?.()) return;
+            // A queue entry is a wakeup, not authority or a saved action. Re-read
+            // consent, revisions and task identity at admission and each claim.
+            const readRecords = async () => {
+              const rows = options.readRecords ? await options.readRecords()
+                : [await readRecord(options.root, record.provider, record.session)];
+              return rows.filter(row => row?.provider === record.provider && row.session === record.session &&
+                row.run?.id === record.run.id && row.run?.managed?.taskId === record.run.managed.taskId);
+            };
+            await tickManagedTasks({ ...options, readRecords, signal: controller.signal });
+          });
+        }
+      })().finally(() => { running = null; });
       return running;
     },
-    async close() { closed = true; controller.abort(); await Promise.allSettled([running, auditing]); },
+    status() { return workers.snapshot(); },
+    async idle() { await running; await workers.idle(); },
+    async drain() { closed = true; await Promise.allSettled([running, auditing, workers.stop()]); },
+    async close() { closed = true; controller.abort(); await Promise.allSettled([running, auditing, workers.stop()]); },
   };
 }
 

package/src/desktop-access.js

@@ -13,7 +13,8 @@ const recoveryActions = new Set(['refresh', 'reconnect', 'login', 'authorization
 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_email_reports' && command.enabled === false;
+    command?.action === 'session_set_email_reports' && command.enabled === false ||
+    command?.action === 'team_thread_share' && 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' });

package/src/desktop-host.js

@@ -5,6 +5,8 @@ import { createLedgerCoordinatorAdapters } from "./update-detachment/ledger-adap
 import { createUpdateCoordinator } from "./update-detachment/coordinator.js";
 import { sessionWorkState, compareSessionWork, reconcileFamilyCompletion, expireSessionWorkState } from './session-supervision/work-state.js';
 import { createPullRequestObserver } from './session-supervision/pull-requests.js';
+import { createTeamThreads, teamThreadKey } from './team-threads.js';
+import { createTeamStatusFenceStore } from './team-status-fence-store.js';
 import { sessionDecisionPresentation } from './session-supervision/decision-presentation.js';
 import { PROVIDER_LINKS, readProviderLinks, writeProviderLink, requireProviderLink } from "./provider-links.js";
 import { randomUUID } from "node:crypto";
@@ -221,6 +223,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
   let statisticsSelection = { key: null, generation: 0 };
   const stopNotifier = createStopNotifier({ emit: event => { if (!closed && !relay) emit(event); } });
   if (env.SIMY_REMOTE_CHILD !== "1" && process.platform !== "win32") remoteHosts = (dependencies.createRemoteHostManager || createRemoteHostManager)({ root, onChange: () => { if (!closed && !relay) setImmediate(() => { void publish().catch(() => {}); }); } });
+  let teamThreads;
   let currentAccess = { state: 'checking', organizationId: null, organizationName: null };
   let nativeDevelopmentReports = { state: 'loading', enrollments: [] };
   let nativeDevelopmentReportsScope = null;
@@ -713,6 +716,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
         if (JSON.stringify(await readProviderLinks(root)) !== requestedLinks) { publishAgain = true; return; }
         if (connectionRevision !== requestedConnectionRevision || !sameAccess(sampledAccess, agent?.getDesktopAccess ? agent.getDesktopAccess() : await readAccess())) { publishAgain = true; return; }
         status.nativeDevelopmentReports = { state: 'loading', enrollments: [] };
+        status.teamThreads = teamThreads?.snapshot();
         if (!closed && !relay) emitStatus(status);
         return;
       }
@@ -764,6 +768,13 @@ export async function startDesktopHost({ input = process.stdin, output = process
       status.sessionSupervision = { ...discovery, refreshing: Boolean(sessionRefresh), sessions: reconcileFamilyCompletion(sessions.map(candidate => ({ ...candidate,
         decisionRequest: sessionDecisionPresentation(candidate, runsBySession.get(`${candidate.provider}:${candidate.session}`)),
         workState: sessionWorkState(candidate, runsBySession.get(`${candidate.provider}:${candidate.session}`) || stateRunsBySession.get(`${candidate.provider}:${candidate.session}`), { provider: discovery.providers?.[candidate.provider] }) }))).sort(compareSessionWork) };
+      teamThreads?.tick(sessions);
+      status.teamThreads = teamThreads?.snapshot();
+      for (const session of status.sessionSupervision.sessions) {
+        const key = teamThreadKey(agent.getTeamThreadsScope?.() || {}, session);
+        const own = status.teamThreads?.own.find(item => item.threadKey === key);
+        session.teamSharing = { enabled: own?.enabled === true, pendingStop: status.teamThreads?.pendingStops.includes(key) === true };
+      }
       const latestAccess = await accessSnapshot();
       if (JSON.stringify(await readProviderLinks(root)) !== requestedLinks ||
         !desktopAccessReady(latestAccess) || accessScope(latestAccess) !== requestedScope ||
@@ -779,12 +790,14 @@ export async function startDesktopHost({ input = process.stdin, output = process
         if (accessScope(latestConnectionStatus?.access) !== requestedScope || !desktopAccessReady(latestConnectionStatus?.access)) { publishAgain = true; return; }
         status = { ...structuredClone(latestConnectionStatus), deliveryHooks: status.deliveryHooks, sessionSupervision: status.sessionSupervision };
       }
+      status.teamThreads = teamThreads?.snapshot();
       if (!closed && !relay) emitStatus(status);
     }).finally(() => { publishing = null; if (publishAgain && !closed) { publishAgain = false; setImmediate(() => { void publish().catch(() => {}); }); } });
     return publishing;
   };
   const stopAgent = async () => {
     clearInterval(timer);
+    teamThreads?.close();
     pluginInspectionAbort.abort();
     activeStatisticsRead?.controller.abort();
     discoveryStopped = true;
@@ -843,6 +856,13 @@ export async function startDesktopHost({ input = process.stdin, output = process
       },
     });
     if (env.SIMY_UPDATE_TRANSFER_TOKEN) await coordinator.reconnect();
+    teamThreads = createTeamThreads({
+      readScope: () => agent.getTeamThreadsScope?.() || {key: accessScope(currentAccess),allowed:false,authenticated:false},
+      request: (body,signal) => agent.requestTeamThreads(body,signal),
+      fenceStore: createTeamStatusFenceStore(root),
+      readContext: dependencies.readTeamThreadContext,
+      onChange: () => { if(!closed) setImmediate(() => {void publish().catch(() => {});}); },
+    });
     stopWorkflows = (dependencies.startWorkflowUpdates || startWorkflowUpdates)({ enabled: env.SIMY_AUTO_UPDATE !== "0" });
     updater.on?.("change", () => { void publish().catch(() => {}); });
     updater.start({ registry: agent.registry, coordinator, isDesktopIdle: () => !unfinishedDesktopWork,
@@ -1105,15 +1125,28 @@ export async function startDesktopHost({ input = process.stdin, output = process
         const commandScope = accessScope(access);
         if (!desktopActionAllowed(access, command)) throw Object.assign(new Error('Desktop access is required.'), { code: 'desktop_access_required' });
         const recoveryControl = ['provider_disconnect', 'session_unmonitor'].includes(action) ||
-          ['session_set_auto_continue', 'session_set_email_reports'].includes(action) && command.enabled === false;
+          ['session_set_auto_continue', 'session_set_email_reports', 'team_thread_share'].includes(action) && command.enabled === false;
         if (['detach_update', 'update_reconnect'].includes(action)) requireDesktopAccess(access);
         else if (!recoveryControl && desktopAccessReady(access) && !desktopActionAllowed({ state: 'unavailable' }, command)) await authorizeWork();
 
         if (!coordinator.acceptsNewWork() && !recoveryControl && !["refresh", "reconnect", "task_detail", "check_update", "quit", "delivery_stop", "delivery_pause", "delivery_reject"].includes(action)) {
           throw new Error("The update connection requires recovery.");
         }
+        if (['team_threads_refresh','team_thread_open','team_thread_share'].includes(action)) {
+          let ok;
+          if(action === 'team_threads_refresh') ok = await teamThreads.refresh({memberId:command.memberId});
+          else if(action === 'team_thread_open') ok = await teamThreads.open({memberId:command.memberId,threadKey:command.threadKey});
+          else {
+            if (command.organizationId !== undefined && command.organizationId !== access.organizationId) throw new Error('Sharing organization changed. Confirm again.');
+            const selected = sessionStatus.sessions.find(item => item.provider === command.provider && item.session === command.session);
+            if(!selected) throw new Error('Refresh and select your conversation again.');
+            ok = await teamThreads.setSharing(selected,command.enabled);
+          }
+          emit({type:'result',id:command.id,ok:ok===true}); void publish().catch(() => {}); return;
+        }
+
         let commandProviderLink;
-        if (command.provider && !["provider_connect", "provider_disconnect", "delivery_stop", "delivery_pause", "delivery_reject", "session_untrack", "session_unmonitor"].includes(action) &&
+        if (command.provider && !["refresh", "provider_connect", "provider_disconnect", "delivery_stop", "delivery_pause", "delivery_reject", "session_untrack", "session_unmonitor"].includes(action) &&
           !(action === "session_set_auto_continue" && command.enabled === false)) {
           commandProviderLink = await requireProviderLink({ root: deliveryRoot, provider: command.provider });
         }