@awak-app/simy-cli 0.7.46 → 0.7.48

package/src/desktop-host.js

@@ -1,3 +1,8 @@
+import {sendSessionGuidance, reconcileSessionGuidance, observeSessionGuidanceConnection} from './session-supervision/session-guidance.js';
+import {guidanceAllowed, guidanceTarget, guidancePending} from './codex-plugins/simy/native/guidance-intent.mjs';
+import { createClaudeStreamOwner } from './session-supervision/claude-stream-owner.js';
+import { claudeStreamPresentation } from './session-supervision/claude-stream-presentation.js';
+import { readOfficialNativeAccount, pairedNativeIdentity } from './native-provider-identity.js';
 import { createDesktopFrameWriter } from './desktop-frame-writer.js';
 import { createDesktopCatalogEncoder, createDesktopStatusSnapshot, copyOwnedDesktopStatus } from './desktop-catalog-frames.js';
 import { boundedDiscovery } from './session-supervision/progressive-discovery.js';
@@ -43,7 +48,7 @@ import { stopDesktopWorkForUpdate } from './desktop-update-stop.js';
 import { desktopAccessReady, desktopActionAllowed, requireDesktopAccess, validDesktopAccessPath } from './desktop-access.js';
 import { createActionDeadlineService } from './session-supervision/action-deadline.js';
 import { deliveryHookStatus, openHookSetup } from "./delivery-hooks/desktop.js";
-import { controlDelivery, verifyDelivery, decideManualAcceptance, createRecordReader, readRecord, updateRecord, recordProviderArchive, TERMINAL } from "./codex-plugins/simy/hooks/delivery-loop.mjs";
+import { controlDelivery, verifyDelivery, decideManualAcceptance, createRecordReader, readRecord, updateRecord, recordProviderArchive, processIdentity, TERMINAL } from "./codex-plugins/simy/hooks/delivery-loop.mjs";
 import { createManagedSupervisor } from "./delivery-hooks/supervisor.js";
 import { createActionAssociationHost } from "./session-supervision/action-association-host.js";
 import { createStopNotifier } from "./session-supervision/stop-notifications.js";
@@ -167,7 +172,10 @@ export async function startDesktopHost({ input = process.stdin, output = process
   const frames = createDesktopFrameWriter(output, { capture: frame => frame,
     encode: frame => typeof frame === 'string' ? frame : catalogEncoder.encode(frame) });
   const pendingRemoteReceipts = new Map();
-  let operationJournal, ownerTransport;
+  const guidanceReads = new Map(), guidanceReadAt = new Map(), guidanceProbes = new Map();
+  let guidanceAbort = new AbortController();
+  let operationJournal, ownerTransport, claudeOwner;
+  const claudeOwnerStates = new Map();
   // An explicitly requested window update releases only its viewer. The same
   // authenticated owner, tasks and pending permissions remain alive on IPC.
   let windowUpdatePrepared = false, viewerDetached = false, relayStatus = null;
@@ -209,6 +217,16 @@ export async function startDesktopHost({ input = process.stdin, output = process
   const emitStatus = status => {
     let catalogObservation;
     status = projectCatalogFrame(status);
+    const claudeScope = agent?.getTeamThreadsScope?.();
+    if (desktopAccessReady(status.access) && providerLinks.claude?.connected && claudeScope?.authenticated && status.sessionSupervision?.sessions) {
+      const known = new Set(status.sessionSupervision.sessions.filter(row => row.provider === 'claude').map(row => row.session));
+      const owners = [...claudeOwnerStates.values()].filter(owner => owner.scope === claudeScope.fenceKey && owner.epoch === (providerLinks.claude.epoch ?? 'legacy-connected'));
+      const added = owners.filter(owner => !known.has(owner.session)).map(owner => ({ provider: 'claude', session: owner.session, hostId: 'local',
+        cwd: owner.cwd, title: 'Connected Claude conversation', model: owner.model, source: 'simy_claude_stream', isRunning: owner.state !== 'idle' && owner.state !== 'closed',
+        autoContinue: false, capabilities: { canMonitor: false, canAutoContinue: false }, conversationPresentation: {} }));
+      status = { ...status, sessionSupervision: { ...status.sessionSupervision, sessions: [...status.sessionSupervision.sessions, ...added]
+        .map(row => claudeStreamPresentation(row, owners.find(owner => owner.session === row.session))) } };
+    }
     status = { ...status, windowUpdate: { version: 1, preservesWork: Boolean(ownerTransport), prepared: windowUpdatePrepared } };
     const updateSettings = updater?.snapshot?.() || {};
     status = { ...status, update: { ...status.update,
@@ -295,7 +313,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
     ...(dependencies.observeUpdateProvider ? {observe:dependencies.observeUpdateProvider} : {}) });
   const coordinator = createUpdateCoordinator({ ...(dependencies.updateDetachment || {
     store:updateRuntime.store,gate:updateRuntime.gate,
-    boundary:dependencies.updateSafeBoundary || (async()=>{const holds=updater?.updateDrainState?.();if(holds && (holds.activeWork || holds.applyHolds))return {safe:false,liveExecutions:holds.activeWork,pendingWrites:holds.applyHolds,unsettledPermissions:0};return updateRuntime.boundary();}),
+    boundary:dependencies.updateSafeBoundary || (async()=>{if(claudeOwner?.busy())return {safe:false,liveExecutions:1,pendingWrites:0,unsettledPermissions:1};const holds=updater?.updateDrainState?.();if(holds && (holds.activeWork || holds.applyHolds))return {safe:false,liveExecutions:holds.activeWork,pendingWrites:holds.applyHolds,unsettledPermissions:0};return updateRuntime.boundary();}),
     reconcile:dependencies.reconcileUpdateConnection || createCoordinatorReconciler(dependencies.updateReconciliation) || updateRuntime.reconcile,
   }), preserveConnectedOnStartup:true, initialState:env.SIMY_UPDATE_TRANSFER_TOKEN?'detached':'connected',
     onChange:()=>{if(agent && !closed && !relay)setImmediate(()=>void publish().catch(()=>{}));} });
@@ -335,6 +353,11 @@ export async function startDesktopHost({ input = process.stdin, output = process
     const previouslyReady = desktopAccessReady(currentAccess);
     currentAccess = access || { state: 'unavailable', organizationId: null, organizationName: null };
     if (previousScope !== accessScope(currentAccess) || previouslyReady && !desktopAccessReady(currentAccess)) {
+      // revoke fences new writes synchronously. Cleanup must not be awaited
+      // from authorization: that refresh may belong to the owner operation
+      // currently holding the cleanup queue.
+      void claudeOwner?.revoke?.().catch(error => diagnostics.write(`Claude owner cleanup retained: ${error?.code || 'unknown'}`));
+      guidanceAbort.abort(); guidanceAbort = new AbortController();
       updateIdentityRevision++;
       // A privilege loss also invalidates consent reads, even when the
       // credential/organization revision itself did not change.
@@ -592,6 +615,22 @@ export async function startDesktopHost({ input = process.stdin, output = process
     if (expectedScope !== undefined && expectedScope !== scope) throw Object.assign(new Error("Desktop account or organization changed."), { code: "desktop_access_required" });
     return scope;
   };
+  claudeOwner = (dependencies.createClaudeStreamOwner || createClaudeStreamOwner)({ root,
+    inspectProcess: dependencies.processIdentity || processIdentity,
+    executable: async () => { const native = await (dependencies.inspectBackendExecutable || inspectBackendExecutable)('claude');
+      if (!native?.compatible || !native.executable) throw Object.assign(new Error('Claude Code is unavailable.'), { code: 'claude_stream_unavailable' });
+      return native.executable; },
+    authorize: () => authorizeProvider('claude'),
+    context: async () => {
+      const scope = agent?.getTeamThreadsScope?.();
+      if (!scope?.authenticated || !scope.allowed || !scope.fenceKey) throw Object.assign(new Error('Sign in to SIMY first.'), { code: 'desktop_access_required' });
+      const link = await requireProviderLink({ root: deliveryRoot, provider: 'claude' });
+      const email = await (dependencies.readOfficialNativeAccount || readOfficialNativeAccount)('claude');
+      if (!email) throw Object.assign(new Error('Sign in to Claude Code first.'), { code: 'native_identity_unavailable' });
+      return { scope: scope.fenceKey, epoch: link.epoch ?? 'legacy-connected',
+        account: pairedNativeIdentity({ deviceId: scope.fenceKey, provider: 'claude', email, connectionEpoch: link.epoch }).account_id };
+    },
+    onChange: owner => { claudeOwnerStates.set(owner.session, owner); if (!closed && agent) setImmediate(() => { void publish().catch(() => {}); }); } });
   const selectedScopes = new WeakMap(), selectedLinkEpochs = new WeakMap();
   const guardedEnroll = async options => {
     await authorizeProvider(options.provider);
@@ -618,7 +657,54 @@ export async function startDesktopHost({ input = process.stdin, output = process
   let catalogAnalysisJob = null, catalogAnalysisAgain = false;
   const withCurrentSettings = (sessions, records) => {
     const byKey = new Map(records.map(record => [`${record.provider}:${record.session}`, record]));
-    return sessions.map(candidate => projectSessionAutoContinue(candidate, byKey.get(`${candidate.provider}:${candidate.session}`)));
+    return sessions.map(candidate => {
+      const record = byKey.get(`${candidate.provider}:${candidate.session}`);
+      const projected = projectSessionAutoContinue(candidate, record);
+      // An authenticated native Stop can be newer than the catalog's running
+      // observation while history is loading. It wakes read-only analysis;
+      // fresh context and the native writer lock still gate actual dispatch.
+      if (candidate.provider === 'codex' && projected.autoContinue === true && typeof candidate.cwd === 'string' && candidate.cwd && record?.cwd === candidate.cwd &&
+          record.lastEvent === 'Stop' && record.runtime?.isRunning === false && record.runtime.process?.identity &&
+          Number.isFinite(record.runtime.observedAt) && Number.isFinite(candidate.observation?.observedAt) &&
+          record.runtime.observedAt > candidate.observation.observedAt) return { ...projected, isRunning: false,
+        observation: { ...candidate.observation, observedAt: record.runtime.observedAt } };
+      return projected;
+    });
+  };
+  const automaticCandidates = discovery => discovery.sessions.filter(candidate => {
+    if (discovery.completeProviders?.includes(candidate.provider)) return true;
+    // A newly read exact Codex conversation need not wait for unrelated
+    // history pages. Context, consent, native permissions and the writer
+    // lock are still checked by the existing enrollment/dispatch path.
+    const admission = candidate.continuationAdmission;
+    return candidate.provider === 'codex' && discovery.providers?.codex?.discovery === 'ready' &&
+      candidate.observation?.source === 'codex_app_server' && admission?.source === 'codex_app_server' &&
+      admission.provider === candidate.provider && admission.session === candidate.session &&
+      admission.cwd === candidate.cwd && typeof admission.model === 'string' && admission.model.length > 0 &&
+      Number.isFinite(admission.validatedAt) && Number.isFinite(discovery.discoveryAttempt?.requestedAt) &&
+      admission.validatedAt >= discovery.discoveryAttempt.requestedAt;
+  });
+  let automaticRefresh = null, automaticRefreshAgain = false;
+  // Execution scheduling must not wait for optional Action/deadline projection.
+  // The coordinator still owns fresh context, opt-in, authority and writer checks.
+  const refreshAutomaticContinuation = () => {
+    automaticRefreshAgain = true;
+    if (automaticRefresh) return automaticRefresh;
+    const scope = accessScope(currentAccess), controller = automaticContinuation;
+    automaticRefresh = Promise.resolve().then(async () => {
+      while (automaticRefreshAgain) {
+        automaticRefreshAgain = false;
+        const records = await recordReader.list();
+        if (closed || relay || discoveryStopped || controller !== automaticContinuation ||
+            !desktopAccessReady(currentAccess) || accessScope(currentAccess) !== scope || !coordinator.acceptsNewWork()) return;
+        controller?.tick(automaticCandidates({ ...sessionStatus,
+          sessions: withCurrentSettings(sessionStatus.sessions, records) }));
+      }
+    }).catch(() => {}).finally(() => {
+      automaticRefresh = null;
+      if (automaticRefreshAgain && !closed && !relay && !discoveryStopped) void refreshAutomaticContinuation();
+    });
+    return automaticRefresh;
   };
   const refreshCatalogAnalysis = () => {
     catalogAnalysisAgain = true;
@@ -633,6 +719,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
         await manager.update(analysisSessions(withCurrentSettings(sessionStatus.sessions, records)), {
           priorityKeys: new Set(records.filter(supervisedSession).map(record => `${record.provider}:${record.session}`)),
         });
+        void refreshAutomaticContinuation();
       }
     }).catch(() => {}).finally(() => {
       catalogAnalysisJob = null;
@@ -809,7 +896,8 @@ export async function startDesktopHost({ input = process.stdin, output = process
       candidate = sessionStatus.sessions.find(matches);
     }
     if (!candidate) throw new Error('This conversation is unavailable; refresh its provider.');
-    candidate = projectSessionAutoContinue(candidate, await readRecord(deliveryRoot, command.provider, command.session));
+    const selectedRecord = await readRecord(deliveryRoot, command.provider, command.session);
+    candidate = withCurrentSettings([candidate], selectedRecord ? [selectedRecord] : [])[0];
     await authorizeProvider(command.provider, scope, link.epoch);
     const selected = { ...candidate };
     selectedScopes.set(selected, scope);
@@ -820,6 +908,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
     if (!PROVIDER_LINKS.includes(provider)) throw new Error("Unsupported SIMY provider connection.");
     if (providerLinkBusy.has(provider)) throw new Error("SIMY connection is already changing.");
     providerRepairControllers.get(provider)?.abort();
+    guidanceAbort.abort(); guidanceAbort = new AbortController();
     providerLinkBusy.add(provider);
     providerLinkFeedback[provider] = { state: connected ? "connecting" : "disconnecting" };
     let phase = "read_settings";
@@ -827,6 +916,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
       providerLinks = await readProviderLinks(root);
       phase = "save_disconnect";
       if (!connected) providerLinks = await writeProviderLink(root, provider, false);
+      if (provider === 'claude' && !connected) await claudeOwner.revoke();
       if (activeStatisticsRead?.key.startsWith(`${provider}:`)) activeStatisticsRead.controller.abort();
       discoveryController?.abort(); enrichmentController?.abort();
       sessionRefreshAgain = false;
@@ -958,9 +1048,12 @@ export async function startDesktopHost({ input = process.stdin, output = process
       return (dependencies.analyzeContinuation || analyzeContinuation)(candidate, { ...options,
         beforeProviderDispatch: () => authorizeProvider(candidate.provider, scope, link.epoch) });
     },
-    onChange: () => { if (!closed && !relay) setImmediate(() => { void publish().catch(() => {}); }); },
+    onChange: () => { if (!closed && !relay) {
+      void refreshAutomaticContinuation();
+      setImmediate(() => { void publish().catch(() => {}); });
+    } },
   });
-  // Batch burst notifications and maintenance completions into one frame. The
+  // Batch burst notifications and heartbeat/status requests into one frame. The
   // short window leaves commands responsive and the regular heartbeat intact.
   const publish = () => {
     if (closed || relay || !agent) return Promise.resolve();
@@ -985,6 +1078,14 @@ export async function startDesktopHost({ input = process.stdin, output = process
       const sampledAccess = structuredClone(status.access || { state: 'unavailable', organizationId: null, organizationName: null });
       if (!await acceptStatusAccess(sampledAccess)) { publishAgain = true; return; }
       status.access = sampledAccess;
+      const nativeScope = agent.getTeamThreadsScope?.();
+      if (desktopAccessReady(sampledAccess) && providerLinks.claude?.connected && nativeScope?.authenticated && nativeScope.allowed &&
+          nativeScope.fenceKey && claudeLoadedScope !== nativeScope.fenceKey) {
+        try {
+          for (const owner of await claudeOwner.list()) claudeOwnerStates.set(owner.session, owner);
+          claudeLoadedScope = nativeScope.fenceKey;
+        } catch { /* The connection stays unavailable until native identity is verified. */ }
+      }
       status.updateDetachment = updateRuntime.snapshot(coordinator.snapshot(),updater?.snapshot?.(),{accessReady:desktopAccessReady(sampledAccess)});
       preferenceScope = controllerScope(status);
       if (preferenceScope) await controllerPreferences.load(preferenceScope);
@@ -1062,6 +1163,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
     }).finally(() => { connectionPublishing = null; });
     return connectionPublishing;
   };
+  let claudeLoadedScope = null;
   const projectStatus = () => {
     if (closed || relay || !agent) return Promise.resolve();
     if (publishing) { publishAgain = true; return publishConnectionStatus(); }
@@ -1079,6 +1181,22 @@ export async function startDesktopHost({ input = process.stdin, output = process
       if (preferenceScope) await controllerPreferences.load(preferenceScope);
       const requestedLinks = await decorateProviderSettings(status);
       const allRecords = await recordReader.list();
+      if (desktopAccessReady(currentAccess) && coordinator.acceptsNewWork()) {
+        for (const record of allRecords) {
+          if (guidanceReads.size >= 2) break;
+          if (!guidancePending(record) || !record.run.managed.userGuidance.bridgeAttemptedAt || guidanceReads.has(record.session) ||
+              Date.now() - (guidanceReadAt.get(record.session) || 0) < 15_000) continue;
+          guidanceReadAt.set(record.session, Date.now());
+          const scope = accessScope(currentAccess);
+          const authorize = async () => {
+            if (closed || !coordinator.acceptsNewWork() || accessScope(currentAccess) !== scope) throw new Error('Guidance read scope changed.');
+            await authorizeProvider(record.provider, scope);
+          };
+          const work = reconcileSessionGuidance({root: deliveryRoot, record, authorize, signal: guidanceAbort.signal}).then(changed => {if (changed) void publish();})
+            .catch(() => {}).finally(() => guidanceReads.delete(record.session));
+          guidanceReads.set(record.session, work);
+        }
+      }
       if (accessScope(currentAccess) === requestedScope) {
         // Keep explicit preference overrides until the scope changes. A full
         // projection that started before the save can finish after this read.
@@ -1153,7 +1271,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
       await actionAssociations.decorate(status.deliveryHooks, projection);
       const catalog = refreshSessions();
       const discovery = { ...catalog, sessions: withCurrentSettings(catalog.sessions, records) };
-      if (coordinator.acceptsNewWork()) automaticContinuation?.tick(discovery.sessions.filter(candidate => Array.isArray(discovery.completeProviders) && discovery.completeProviders.includes(candidate.provider)));
+
       let sessions = discovery.sessions.map(candidate => automaticContinuation.project(analysisManager.project(candidate)));
       await analysisManager.observeContinuationWaits?.(sessions);
       sessions = sessions.map(candidate => analysisManager.projectContinuationWait?.(candidate) || candidate);
@@ -1254,7 +1372,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
     const results = await Promise.allSettled([stopDiscovery({ drain: true }), publishing, connectionPublishing,
       pluginInspection,
       ...providerRepairJobs,
-      controllerPreferences.close(), operationJournal.close(), remoteHosts?.close(), remoteMetadata.close(), actionAssociations.close(), automaticContinuation?.close(), analysisManager?.close(),
+      claudeOwner.close(), controllerPreferences.close(), operationJournal.close(), remoteHosts?.close(), remoteMetadata.close(), actionAssociations.close(), automaticContinuation?.close(), analysisManager?.close(),
       managedSupervisor.close(), recordReader.close(), stopWorkflows(),
       agent ? createAgentShutdown(agent)() : undefined]);
     const failure = results.find(result => result.status === "rejected");
@@ -1262,6 +1380,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
   };
   const close = () => shuttingDown ||= (async () => {
     closed = true;
+    guidanceAbort.abort();
     frames.close();
     commands?.close();
     input.pause?.();
@@ -1425,7 +1544,11 @@ export async function startDesktopHost({ input = process.stdin, output = process
     const maintenance = new Map();
     const tick = worker => {
       if (closed || relay || !coordinator.acceptsNewWork() || maintenance.has(worker)) return;
-      const pending = Promise.resolve().then(() => worker.tick()).then(() => { if (!closed && !relay) return publish(); }).catch(() => {}).finally(() => maintenance.delete(worker));
+      // The existing heartbeat publishes completed background maintenance.
+      // Completion itself does not prove a visible change; after the short
+      // batching window it otherwise reprojects/repaints the entire history.
+      // Explicit commands and actual change notifications keep their live path.
+      const pending = Promise.resolve().then(() => worker.tick()).catch(() => {}).finally(() => maintenance.delete(worker));
       maintenance.set(worker, pending);
     };
     tick(actionAssociations);
@@ -1435,6 +1558,9 @@ export async function startDesktopHost({ input = process.stdin, output = process
       if (desktopAccessReady(currentAccess)) {
         tick(actionAssociations);
         tick(managedSupervisor);
+        // Observe native Stop records even when the full status projection or
+        // unrelated provider history is still pending.
+        void refreshCatalogAnalysis();
       }
       void publish().catch(() => emit({ type: "error", message: "SIMY status could not be refreshed." }));
     }, 3_000);
@@ -1499,6 +1625,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
     }
   };
   const executeUpdate = (prepareRestart = false) => {
+    if (claudeOwner.busy()) throw new Error('Stop the connected Claude turn or answer its permission request before updating.');
     const kind = prepareRestart ? 'restart' : 'install';
     if (updateOperation && updateOperationKind !== kind) throw new Error('Another update operation is in progress. Retry after it finishes.');
     if (updateOperation) return updateOperation;
@@ -1596,6 +1723,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
           await publish(); return;
         }
         if (action === "quit") {
+          if (claudeOwner.busy()) throw new Error('Stop the connected Claude turn or answer its permission request before quitting.');
           if (command.forUpdate === true) {
             if (command.force !== true) throw new Error('Confirm before stopping unfinished tasks.');
             await stopWorkForUpdate();
@@ -1850,7 +1978,23 @@ export async function startDesktopHost({ input = process.stdin, output = process
           await authorizeProvider(command.provider, commandScope, commandProviderLink?.epoch);
           const cached = lastStatus?.sessionSupervision?.sessions?.find(item =>
             item.provider === command.provider && item.session === command.session && (!item.hostId || item.hostId === 'local'));
-          const record = await readRecord(deliveryRoot, command.provider, command.session);
+          let record = await readRecord(deliveryRoot, command.provider, command.session);
+          if (guidanceAllowed(record)) {
+            const observation = record.run.managed.nativeConnectionObservation;
+            const age = Date.now() - observation?.at;
+            const key = JSON.stringify([commandScope, guidanceTarget(record)]);
+            let probe = guidanceProbes.get(key);
+            if (!probe && !(age >= 0 && age < 15_000) && guidanceProbes.size < 2) {
+              const authorize = () => authorizeProvider(command.provider, commandScope, commandProviderLink?.epoch);
+              const signal = AbortSignal.any([guidanceAbort.signal, AbortSignal.timeout(20_000)]);
+              probe = (dependencies.observeSessionGuidanceConnection || observeSessionGuidanceConnection)({root: deliveryRoot,
+                record, signal, authorize}).finally(() => guidanceProbes.delete(key));
+              guidanceProbes.set(key, probe);
+            }
+            if (probe) await probe;
+            record = await readRecord(deliveryRoot, command.provider, command.session);
+            if (frameRecordScope === commandScope) frameRecords.set(`${command.provider}:${command.session}`, record);
+          }
           const observed = sessionStatus.sessions.find(item => item.provider === command.provider && item.session === command.session);
           if (!record && !observed) throw new Error('This conversation status is unavailable; refresh its provider.');
           // Read one durable task without scheduling a complete provider scan
@@ -1864,13 +2008,16 @@ export async function startDesktopHost({ input = process.stdin, output = process
           const selectedRun = controls.runs?.find(run => run.provider === command.provider && run.session === command.session);
           row.decisionRequest = sessionDecisionPresentation(row, selectedRun);
           row.conversationPresentation = conversationPresentation(row, selectedRun, { rawRecord: record });
+          const owner = claudeOwnerStates.get(command.session);
+          if (owner?.scope === agent.getTeamThreadsScope?.()?.fenceKey) Object.assign(row, claudeStreamPresentation(row, owner));
           await authorizeProvider(command.provider, commandScope, commandProviderLink?.epoch);
           // The same app projection carries observation time and next action;
           // saved consent and an active record cannot prove a provider send.
           const { provider, session, title, autoContinue, autoContinueStatus, autoContinueReason,
-            binding, workState, dispatchReadiness, conversationPresentation: presentation, decisionRequest } = row;
+            binding, workState, dispatchReadiness, conversationPresentation: presentation, decisionRequest, claudeConnection, originalSessionTarget } = row;
           emit({ type: 'result', id: command.id, ok: true, data: { provider, session, title,
-            autoContinue, autoContinueStatus, autoContinueReason, binding, workState, dispatchReadiness, conversationPresentation: presentation, decisionRequest } });
+            autoContinue, autoContinueStatus, autoContinueReason, binding, workState, dispatchReadiness, conversationPresentation: presentation, decisionRequest, claudeConnection, originalSessionTarget } });
+          void publish().catch(() => {});
           return;
         }
         if (action === 'session_read_context') {
@@ -2347,6 +2494,30 @@ export async function startDesktopHost({ input = process.stdin, output = process
           await (dependencies.monitorSession || monitorSession)({ root: join(root, "delivery-hooks"), provider: command.provider,
             session: command.session, monitor: action === "session_monitor", expectedProviderEpoch: commandProviderLink?.epoch });
           await refreshSessions(true);
+        } else if (['claude_connection_create', 'claude_connection_connect', 'claude_connection_disconnect', 'claude_connection_stop', 'claude_permission_decide'].includes(action)) {
+          if (command.hostId && command.hostId !== 'local' || command.provider !== 'claude') throw new Error('Connected Claude requires this local host.');
+          await authorizeProvider('claude', commandScope, commandProviderLink?.epoch);
+          const data = action === 'claude_connection_create' ? await claudeOwner.create({ cwd: command.cwd, model: command.model,
+            permissionMode: command.permissionMode, confirmedNew: command.confirmedNew }) : action === 'claude_connection_connect' ? await claudeOwner.connect(command)
+            : action === 'claude_connection_disconnect' ? await claudeOwner.disconnect(command) : action === 'claude_connection_stop' ? await claudeOwner.stop(command, { authorize: () => authorizeWork(commandScope) }) : await claudeOwner.decide(command);
+          claudeOwnerStates.set(data.session, data);
+          emit({ type: 'result', id: command.id, ok: true, data }); await publish(); return;
+        } else if (action === 'session_guidance' && command.provider === 'claude') {
+          if (command.hostId && command.hostId !== 'local') throw new Error('Direct guidance requires the original local host.');
+          await authorizeProvider('claude', commandScope, commandProviderLink?.epoch);
+          const data = await claudeOwner.send(command);
+          emit({ type: 'result', id: command.id, ok: true, data }); await publish(); return;
+        } else if (action === 'session_guidance') {
+          if (command.hostId && command.hostId !== 'local') throw new Error('Direct guidance requires the original local host.');
+          const candidate = await selectedSession(command);
+          if (candidate.provider !== 'codex' || candidate.isRunning !== false) throw new Error('The original conversation must be idle before sending guidance.');
+          const data = await (dependencies.sendSessionGuidance || sendSessionGuidance)({root: deliveryRoot,
+            provider: command.provider, session: command.session, requestId: command.requestId,
+            expectedRunId: command.expectedRunId, taskId: command.taskId, expectedRevision: command.expectedRevision,
+            expectedEpoch: command.expectedEpoch, text: command.text, signal: guidanceAbort.signal,
+            authorize: () => authorizeProvider(candidate.provider, commandScope, selectedLinkEpochs.get(candidate))});
+          emit({type: 'result', id: command.id, ok: true, data});
+          await publish(); return;
         } else if (action === "session_followup") {
           const candidate = await selectedSession(command);
           if (!candidate.followup?.previousRunId || command.previousRunId !== candidate.followup.previousRunId) {
@@ -2465,6 +2636,7 @@ function sessionActionError(error, action) {
   if (/workspace changed|metadata.*unavailable|session.*changed/i.test(message)) return "The conversation identity or workspace changed. Refresh and select it again.";
   if (/objective|acceptance|autonomy policy|budget/i.test(message)) return message.replace(/[\r\n\x00-\x1f]/g, " ").slice(0, 240);
   if (/question changed|answer is empty|session understanding|context/i.test(message)) return message.replace(/[\r\n\x00-\x1f]/g, " ").slice(0, 240);
+  if (action === 'session_guidance') return 'Guidance acceptance is unconfirmed. Your draft is kept. Check the original conversation before sending again.';
   if (action === "session_answer") return "Answer acceptance is unconfirmed. Check the original conversation before sending again.";
   return "This conversation could not be enrolled. Refresh its provider status and try again.";
 }

package/src/session-supervision/claude-sessions.js

@@ -30,7 +30,7 @@ function candidateMetadata(id, metadata, lastActivityAt, observedAt) {
     provider: 'claude', session: id, ...(metadata.parentSessionId ? { parentSession: { provider: 'claude', session: metadata.parentSessionId } } : {}), cwd: metadata.cwd, title: metadata.title,
     source: 'claude_cli', lastActivityAt, createdAt: metadata.createdAt ?? null,
     observation: { source: 'claude_local_index', observedAt },
-    availability: 'unsupported', model: null,
+    availability: 'unsupported', model: null, observedModel: metadata.observedModel || null,
     capabilities: { canMonitor: true, canEnroll: false, canAutoContinue: false },
     reason: 'Claude session ownership and safe exact-session takeover are unverified; monitoring only.',
   };
@@ -66,7 +66,7 @@ function metadataFromPrefix(bytes, id) {
   const text = bytes.toString('utf8');
   const complete = text.slice(0, text.lastIndexOf('\n') + 1);
   if (!complete) return null;
-  let cwd = '', title = '', customTitle = '', parentSessionId = null, found = false, createdAt = null;
+  let cwd = '', title = '', customTitle = '', parentSessionId = null, found = false, createdAt = null, observedModel = null;
   for (const line of complete.split('\n').slice(0, MAX_LINES)) {
     if (!line) continue;
     let item;
@@ -83,10 +83,11 @@ function metadataFromPrefix(bytes, id) {
     if (!cwd) cwd = resolve(item.cwd);
     // A conversation can cd into a child directory without changing identity.
     if (!within(cwd, resolve(item.cwd))) return null;
+    if (item.type === 'assistant' && /^claude-[a-zA-Z0-9._:-]{1,140}$/.test(item.message?.model || '')) observedModel = item.message.model;
     if (!title) title = sessionTitle(item.slug);
     found = true;
   }
-  return found ? { cwd, title: customTitle || title, parentSessionId, createdAt } : null;
+  return found ? { cwd, title: customTitle || title, parentSessionId, createdAt, observedModel } : null;
 }
 
 // /rename appends a custom-title envelope, often beyond the bounded prefix.
@@ -363,7 +364,7 @@ async function humanBoundaryFromHandle(handle, opened, path, session, cwd, reque
   if (cursor && (cursor.path !== path || cursor.session !== session || cursor.cwd !== cwd ||
       !matchesHumanCursorIdentity(cursor, initial) || !Number.isSafeInteger(cursor.size) ||
       cursor.size <= 0 || opened.size < cursor.size || !/^[a-f0-9]{64}$/.test(cursor.prefixSHA256 || ''))) return null;
-  const prefixHash = createHash('sha256'), userIds = new Set();
+  const prefixHash = createHash('sha256'), userIds = new Set(), appendedUserIds = new Set();
   const decoder = new TextDecoder('utf-8', { fatal: true });
   let latest = null, scanned;
   try {
@@ -383,7 +384,7 @@ async function humanBoundaryFromHandle(handle, opened, path, session, cwd, reque
         if (item.message?.content?.every?.(part => part?.type === 'tool_result')) return;
         if (!UUID.test(item.uuid || '') || userIds.has(item.uuid)) return false;
         userIds.add(item.uuid);
-        if (!cursor || start >= cursor.size) latest = item;
+        if (!cursor || start >= cursor.size) { latest = item; appendedUserIds.add(item.uuid); }
       } });
   } catch (error) { if (signal?.aborted) throw error; return null; }
   if (!scanned || cursor && prefixHash.digest('hex') !== cursor.prefixSHA256) return null;
@@ -393,7 +394,7 @@ async function humanBoundaryFromHandle(handle, opened, path, session, cwd, reque
       humanFileFingerprint(initial) !== humanFileFingerprint(pathAfter)) return null;
   if (request.snapshot) return { version: 2, session, cwd, path, dev: String(initial.dev), ino: String(initial.ino),
     birthtimeNs: String(initial.birthtimeNs), size: opened.size, prefixSHA256: scanned.digest };
-  if (request.validateCursor) return cursor ? { valid: true } : null;
+  if (request.validateCursor) return cursor && (!request.streamOwner || [...appendedUserIds].every(id => id === request.allowedNewUserRef)) ? { valid: true } : null;
   if (!cursor || !latest || latest.origin?.kind !== 'human' || latest.cwd !== cwd || latest.message?.role !== 'user') return null;
   const at = Date.parse(latest.timestamp), text = textContent(latest.message.content);
   if (!Number.isFinite(at) || at < request.notBefore || at > request.now ||
@@ -413,6 +414,12 @@ export async function snapshotClaudeHumanCursor({ session, cwd }, options) {
 export async function validateClaudeHumanCursor(cursor, options) {
   return !!cursor && !!await exactHumanTranscript(cursor.session, cursor.cwd, { cursor, validateCursor: true }, options);
 }
+// An owned stream may append only its currently acknowledged native user UUID.
+// Assistant/progress metadata is allowed; another human writer invalidates it.
+export async function validateClaudeStreamCursor(cursor, allowedNewUserRef = null, options) {
+  return !!cursor && !!await exactHumanTranscript(cursor.session, cursor.cwd,
+    { cursor, validateCursor: true, streamOwner: true, allowedNewUserRef }, options);
+}
 export async function readClaudeHumanBoundary({ session, cwd, promptSHA256, promptBytes, notBefore, cursor, now = Date.now() }, options) {
   if (!/^[a-f0-9]{64}$/.test(promptSHA256 || '') || !Number.isSafeInteger(promptBytes) || promptBytes <= 0 ||
       !Number.isFinite(notBefore) || !Number.isFinite(now) || notBefore > now || !cursor) return null;
@@ -526,7 +533,7 @@ async function scanNativeRows(path, visit, { signal, expectedDigest } = {}) {
     if (!before.isFile()) throw new Error('Native transcript unavailable');
     const decoder = new TextDecoder('utf-8', { fatal: true });
     const scanned = await scanTranscriptLines(handle, before, { maxBytes: MAX_COMPLETE_TRANSCRIPT_BYTES, signal,
-      onLine: line => visit(JSON.parse(decoder.decode(line))) });
+      onLine: (line, _offset, index) => visit(JSON.parse(decoder.decode(line)), index) });
     const after = await handle.stat();
     const pathAfter = await lstat(path);
     if (await realpath(path) !== path || pathAfter.isSymbolicLink() || pathAfter.ino !== before.ino || pathAfter.dev !== before.dev ||
@@ -542,10 +549,10 @@ async function nativeParentTranscript(candidate, { home, signal }, visit) {
     .filter(row => row.cwd === candidate.cwd && row.boundary?.complete);
   if (matches.length !== 1) return null;
   const parentPath = matches[0].transcriptPath;
-  const scanned = await scanNativeRows(parentPath, row => {
+  const scanned = await scanNativeRows(parentPath, (row, index) => {
     if (row.sessionId !== undefined && row.sessionId !== candidate.session ||
         ['user', 'assistant'].includes(row.type) && (row.isSidechain === true || row.cwd !== candidate.cwd)) return false;
-    return visit(row);
+    return visit(row, index);
   }, { signal, expectedDigest: matches[0].boundary.digest });
   return { parentPath, ...scanned };
 }
@@ -561,23 +568,27 @@ export async function readClaudeNativeAgentContract(candidate, { home, signal }
 export async function readClaudeNativeReview(candidate, request, { home, signal } = {}) {
   try {
     const calls = [], contracts = createForegroundAgentContractCollector(candidate);
-    const parent = await nativeParentTranscript(candidate, { home, signal }, row => {
+    const parent = await nativeParentTranscript(candidate, { home, signal }, (row, index) => {
       if (row.sessionId === candidate.session && !row.isSidechain && row.type === 'assistant' && Date.parse(row.timestamp) >= request.requestedAt) {
         for (const part of row.message?.content || []) {
           if (part.type === 'tool_use' && ['Agent', 'Task'].includes(part.name) && part.input?.prompt === request.prompt)
-            calls.push({ call: part, contract: contracts.finish() });
+            calls.push({ call: part, index, contract: contracts.finish() });
           if (calls.length > 1) return false;
         }
       }
       contracts.add(row);
     });
     if (!parent || calls.length !== 1) return null;
-    const { parentPath } = parent, { call, contract } = calls[0];
+    const { parentPath } = parent, { call, index, contract } = calls[0];
     if (call.input.subagent_type !== request.agentType || !isForegroundNativeReviewInput(call.name, call.input, contract?.schema)) return null;
     const receipts = [];
-    const receiptScan = await scanNativeRows(parentPath, row => {
+    const receiptScan = await scanNativeRows(parentPath, (row, receiptIndex) => {
       if (row.sessionId === candidate.session && !row.isSidechain && row.type === 'user' &&
-          row.message?.content?.some?.(part => part.type === 'tool_result' && part.tool_use_id === call.id) && row.toolUseResult) receipts.push(row);
+          row.message?.content?.some?.(part => part.type === 'tool_result' && part.tool_use_id === call.id) && row.toolUseResult) {
+        // A result preceding its exact invocation cannot prove it returned.
+        if (receiptIndex <= index) return false;
+        receipts.push(row);
+      }
       if (receipts.length > 1) return false;
     }, { signal, expectedDigest: parent.digest });
     if (receiptScan.snapshot !== parent.snapshot) return null;