shennian 0.3.85 → 0.3.86

package/dist/src/native-fusion/service.js

@@ -1,2 +1,739 @@
-import B from"node:fs";import O from"node:crypto";import{publishPendingSessionIndexes as k}from"../session/index-publisher.js";import{NativeFusionFileWatcher as R}from"./file-watcher.js";import{NativeEventIdentityConflictError as q,NativeFusionLocalRepository as L}from"./local-repository.js";import{listClaudeTranscriptFiles as D,listCodexRolloutFiles as W,listOpenCodeSessionFiles as $,listNativeTranscriptRoots as z,inspectNativeSessionFile as U,lookupCodexThreadName as H,parseClaudeTranscriptChunk as V,parseCodexRolloutChunk as Q,parseOpenCodeSessionFile as Y}from"./parsers.js";import{MAX_JSONL_SCAN_BYTES_PER_PASS as X}from"./parser-common.js";import{loadNativeScannerState as j,saveNativeScannerState as J}from"./state.js";const G=5*6e4,Z=2*6e4,ee=30*6e4,se=2e3,te=1,F=16,ie=3e4,N=240*6e4;function ne(d){return d.replace(/\r\n/g,`
-`).trim()}function C(){return new Promise(d=>setImmediate(d))}function oe(d){return d.split(/[\\/]+/).includes(".codex")}class me{client;repository;timer=null;activeTimer=null;scanPromise=null;queuedTargetFiles=new Set;pendingBoundaryFiles=new Set;sourceFiles=new Map;fullScanQueued=!1;watchEnabled=!1;lifecycleRevision=0;watcher=new R(e=>{this.scanNow(e).catch(s=>{console.error("[native-fusion] watched file scan failed",s)})});pendingClaims;suppressionWindows;externalObservations=new Map;externalTerminalHandler=null;constructor(e,s=new L){this.client=e,this.repository=s,this.pendingClaims=new Map((this.repository.listManagedClaims?.()??[]).map(t=>[t.canonicalMessageId,t])),this.suppressionWindows=new Map((this.repository.listManagedSuppressions?.()??[]).map(t=>[I(t.agentType,t.sourceSessionKey),t]))}start(){this.timer||(this.timer=setInterval(()=>{this.scanNow().catch(e=>{console.error("[native-fusion] periodic scan failed",e)})},G))}stop(){this.lifecycleRevision+=1,this.timer&&clearInterval(this.timer),this.timer=null,this.activeTimer&&clearInterval(this.activeTimer),this.activeTimer=null,this.pendingBoundaryFiles.clear(),this.watchEnabled=!1,this.watcher.stop()}setExternalTerminalHandler(e){this.externalTerminalHandler=e}handleConnected(){const e=++this.lifecycleRevision;this.watchEnabled=!0,this.scanNow().catch(s=>{console.error("[native-fusion] initial scan failed",s)}).finally(()=>{this.lifecycleRevision===e&&this.start()})}registerManagedSend(e){if(!e.canonicalMessageId)return;const s=e.sourceAgentType??e.agentType;if(s!=="codex"&&s!=="claude"&&s!=="opencode")return;const t=e.canonicalMessageId,i=this.pendingClaims.get(t),a=P(e.text);if(i&&(i.sessionId!==e.sessionId||i.sourceAgentType!==s||i.textHash!==a))throw new Error(`managed echo claim identity conflict: ${t}`);const u={sessionId:e.sessionId,agentType:e.agentType,sourceAgentType:s,canonicalMessageId:e.canonicalMessageId,textHash:a,createdAt:i?.createdAt??Date.now(),sourceSessionKey:e.sourceSessionKey??i?.sourceSessionKey??null,managedEchoPolicy:e.managedEchoPolicy??"suppress_following",externalRunId:e.externalRunId??null};if(this.repository.upsertManagedClaim?.(u),this.pendingClaims.set(t,u),e.externalRunId&&e.sourceSessionKey){const p=`${s}:${e.sourceSessionKey}`,y=this.externalObservations.get(p)??[];y.push({sessionId:e.sessionId,sourceSessionKey:e.sourceSessionKey,runId:e.externalRunId,canonicalMessageId:e.canonicalMessageId,state:"queued",createdAt:Date.now(),lastPublishedAt:Date.now()}),this.externalObservations.set(p,y),this.emitExternalActivity(y[y.length-1],"queued"),this.ensureActiveScanning()}}cancelManagedSend(e){this.repository.removeManagedClaim?.(e),this.pendingClaims.delete(e)}noteManagedSourceSession(e,s,t){if(t){this.repository.updateManagedClaimSource?.(e,s,t);for(const i of this.pendingClaims.values())i.sessionId===e&&i.sourceAgentType===s&&(i.sourceSessionKey=t)}}handleSessionDeleted(e){for(const[s,t]of this.pendingClaims.entries())t.sessionId===e&&this.pendingClaims.delete(s);for(const[s,t]of this.suppressionWindows.entries())t.sessionId===e&&this.suppressionWindows.delete(s);for(const[s,t]of this.externalObservations.entries()){const i=t.filter(a=>a.sessionId!==e);i.length===0?this.externalObservations.delete(s):this.externalObservations.set(s,i)}this.repository.purgeSession(e)}ensureActiveScanning(e=!0){this.activeTimer||(this.activeTimer=setInterval(()=>{if(this.externalObservations.size===0&&this.pendingBoundaryFiles.size===0){this.activeTimer&&clearInterval(this.activeTimer),this.activeTimer=null;return}this.scanActiveTargets()},se),e&&this.scanActiveTargets())}scanActiveTargets(){const e=this.activeScanTargets();e===void 0&&this.scanPromise||this.scanNow(e).catch(s=>{console.error("[native-fusion] active observation scan failed",s)})}activeScanTargets(){const e=[...this.externalObservations.keys()];if(!e.some(s=>!this.sourceFiles.has(s)))return[...new Set([...this.pendingBoundaryFiles,...e.flatMap(s=>{const t=this.sourceFiles.get(s);return t?[t]:[]})])]}emitExternalActivity(e,s){this.client.sendAgentEvent({type:"event",event:"agent",id:`external-owner-${e.runId}-${s}-${e.lastPublishedAt}`,payload:{state:s==="queued"?"start":"heartbeat",sessionId:e.sessionId,runId:e.runId,seq:s==="queued"?0:1,runPhase:"thinking",canStop:!1,owner:"external",ownerLabel:"Codex Desktop",lifecycle:s}})}emitExternalTerminal(e,s="completed"){const t=s==="completed"?"final":s==="aborted"?"aborted":"error";this.client.sendAgentEvent({type:"event",event:"agent",id:`external-owner-${e.runId}-${t}`,payload:{state:t,sessionId:e.sessionId,runId:e.runId,seq:2,...t==="error"?{message:"Codex Desktop turn failed"}:{},owner:"external",ownerLabel:"Codex Desktop"}}),this.externalTerminalHandler?.(e.sessionId)}pruneState(){const e=Date.now();for(const[s,t]of this.suppressionWindows.entries())t.endsAt>e||(this.repository.removeManagedSuppression?.(t.agentType,t.sourceSessionKey),this.suppressionWindows.delete(s))}async scanNow(e){if(this.client.getState()==="connected"){if(this.scanPromise){const s=this.scanPromise;if(e)for(const t of e)this.queuedTargetFiles.add(t);else this.fullScanQueued=!0;if(await s,this.fullScanQueued)return this.fullScanQueued=!1,this.queuedTargetFiles.clear(),this.scanNow();if(this.queuedTargetFiles.size>0){const t=[...this.queuedTargetFiles];return this.queuedTargetFiles.clear(),this.scanNow(t)}return}return this.scanPromise=this.runScanLoop(e).finally(()=>{this.scanPromise=null}),this.scanPromise}}async runScanLoop(e){let s=e?[...new Set(e)]:void 0;for(;;){if(await this.runScan(s),this.fullScanQueued){await C(),this.fullScanQueued=!1,this.queuedTargetFiles.clear(),s=void 0;continue}if(this.queuedTargetFiles.size>0){await C(),s=[...this.queuedTargetFiles],this.queuedTargetFiles.clear();continue}return}}async runScan(e){this.pruneState(),this.refreshExternalObservations();const s=j(),t={...s.files},i=[],a=new Map,u=new Map,p=new Map,y=e?[...e]:[...W(),...D(),...$()];!e&&this.watchEnabled&&this.watcher.refresh(y,z());for(let n=0;n<y.length;n+=1){const o=y[n];if(n>0&&n%te===0&&await C(),!B.existsSync(o)){this.watchEnabled&&this.watcher.untrackFile(o),this.pendingBoundaryFiles.delete(o);for(const[r,f]of this.sourceFiles.entries())f===o&&this.sourceFiles.delete(r);continue}this.watchEnabled&&this.watcher.trackFile(o);const l=B.statSync(o),E=oe(o),h=o.endsWith(".opencode-session.json");let c=s.files[o];const x=`${String(l.dev)}:${String(l.ino)}:${String(l.birthtimeMs)}`;let b=!c;if(c&&!h&&(l.size<c.offset||c.fileIdentity&&c.fileIdentity!==x)&&(c=void 0,b=!0),!!(c&&c.fileIdentity===x&&c.mtimeMs===l.mtimeMs&&c.offset>=l.size&&c.sources?.length)&&c){for(const r of c.sources??[])this.sourceFiles.set(I(r.agentType,r.sourceSessionKey),o);c.classification==="live"&&c.awaitingUserBoundary?this.pendingBoundaryFiles.add(o):this.pendingBoundaryFiles.delete(o);continue}const g=c?.sources?.length&&!h?{status:"ready",createdAtMs:c.sessionCreatedAtMs??l.birthtimeMs,sources:c.sources}:U(o);if(g.status==="pending"){l.birthtimeMs>=s.fusionEpochMs&&this.pendingBoundaryFiles.add(o);continue}for(const r of g.sources)this.sourceFiles.set(I(r.agentType,r.sourceSessionKey),o);if(!h&&g.sources.length>0&&g.sources.every(r=>this.repository.isSourceDeleted?.(r.agentType,r.sourceSessionKey))){t[o]={...c??{daemonInstallationId:s.daemonInstallationId,classification:g.createdAtMs>=s.fusionEpochMs?"live":"historical",awaitingUserBoundary:!0,sessionCreatedAtMs:g.createdAtMs,sourceBoundaryEstablished:{}},offset:l.size,mtimeMs:l.mtimeMs,fileIdentity:x};continue}if(!c)c={daemonInstallationId:s.daemonInstallationId,offset:0,mtimeMs:l.mtimeMs,classification:g.createdAtMs>=s.fusionEpochMs?"live":"historical",awaitingUserBoundary:!0,sessionCreatedAtMs:g.createdAtMs,sourceBoundaryEstablished:{}};else if(h&&c.mtimeMs===l.mtimeMs)continue;const A=h?0:c.offset,w=h?Y(o,A):E?Q(o,A):V(o,A);for(const r of w.events)this.repository.isSourceDeleted?.(r.agentType,r.sourceSessionKey)||r.title?.trim()&&r.titleSource==="agent_native"&&p.set(`${r.agentType}:${r.sourceSessionKey}`,r);let K,S;if(h){const r=ae(w.events,c,s.fusionEpochMs,b,l.mtimeMs,w.nextOffset);K=r.events,S=r.cursor}else if(b&&c.classification==="historical")K=[],S={...c,offset:w.nextOffset,mtimeMs:l.mtimeMs,awaitingUserBoundary:!0};else{const r=re(w.events,c,w.nextOffset,l.mtimeMs);K=r.events,S=r.cursor}S.fileIdentity=x,S.sources=g.sources,t[o]=S,w.nextOffset<l.size&&l.size-A>X&&this.queuedTargetFiles.add(o),S.classification==="live"&&S.awaitingUserBoundary?this.pendingBoundaryFiles.add(o):this.pendingBoundaryFiles.delete(o);for(const r of K){if(this.repository.isSourceDeleted?.(r.agentType,r.sourceSessionKey))continue;const f=this.tryClaimManagedEcho(r);if(f){i.push(f.event),a.set(f.claimKey,f.suppression??null),f.suppression&&u.set(I(f.suppression.agentType,f.suppression.sourceSessionKey),{window:f.suppression,claimKey:f.claimKey});continue}const _=this.suppressionFor(r,u,a);if(_){i.push({...r,claimSessionId:_.sessionId,localDisposition:"managed_echo_suppressed"});continue}i.push(r)}}const v=[...i].sort((n,o)=>n.ts-o.ts),T=new Set,m=new Set,M=n=>{try{this.repository.commitEvents(n)}catch(o){if(!(o instanceof q))throw o;const l=n.find(h=>h.sourceEventKey===o.sourceEventKey);if(!l)throw o;T.add(l.sourceEventKey),l.claimCanonicalMessageId&&m.add(l.claimCanonicalMessageId),console.warn(`[native-fusion] quarantined conflicting native event ${l.sourceEventKey}`);const E=n.filter(h=>h!==l);E.length>0&&M(E)}};v.length===0&&this.repository.commitEvents([]);for(let n=0;n<v.length;n+=F)M(v.slice(n,n+F)),n+F<v.length&&await C();for(const[n,o]of a)m.has(n)||(this.repository.completeManagedClaim?.(n,o??void 0),this.pendingClaims.delete(n),o&&this.suppressionWindows.set(I(o.agentType,o.sourceSessionKey),o));for(const n of p.values())this.repository.observeNativeTitle(n.agentType,n.sourceSessionKey,n.title??"");for(const n of this.repository.listSourceBindings()){if(n.agentType!=="codex")continue;const o=H(n.sourceSessionKey);o&&this.repository.observeNativeTitle("codex",n.sourceSessionKey,o)}for(const n of v)T.has(n.sourceEventKey)||this.observeExternalLifecycle(n);s.files=t,J(s),this.pendingBoundaryFiles.size>0&&this.ensureActiveScanning(!1),!(this.fullScanQueued||this.queuedTargetFiles.size>0)&&(this.repository.repairMissingUserBoundaries?.(),await k(this.client).catch(n=>{console.error("[native-fusion] index projection sync failed; retained for retry",n)}))}refreshExternalObservations(){const e=Date.now();for(const[s,t]of this.externalObservations.entries()){const i=t.filter(u=>e-u.createdAt<N);if(i.length===0){this.externalObservations.delete(s);continue}this.externalObservations.set(s,i);const a=i[0];e-a.lastPublishedAt<ie||(a.lastPublishedAt=e,this.emitExternalActivity(a,a.state))}}tryClaimManagedEcho(e){const s=Date.now();for(const[t,i]of this.pendingClaims.entries()){if(i.sourceAgentType!==e.agentType||e.role!=="user"||!i.sourceSessionKey||i.sourceSessionKey!==e.sourceSessionKey)continue;const a=i.externalRunId?N:Z;if(Math.abs(e.ts-i.createdAt)>a||P(e.payload)!==i.textHash)continue;const u=i.managedEchoPolicy==="suppress_following"?{sessionId:i.sessionId,agentType:e.agentType,sourceSessionKey:e.sourceSessionKey,claimSourceEventKey:e.sourceEventKey,startedAt:e.ts,endsAt:Math.max(s,e.ts)+ee}:void 0;return{claimKey:t,suppression:u,event:{...e,sourceMode:"managed_echo_claim",claimCanonicalMessageId:i.canonicalMessageId,claimSessionId:i.sessionId,managedEchoPolicy:i.managedEchoPolicy}}}return null}observeExternalLifecycle(e){const s=`${e.agentType}:${e.sourceSessionKey}`,t=this.externalObservations.get(s);if(!t?.length)return;const i=t[0];if(e.claimCanonicalMessageId===i.canonicalMessageId&&i.state==="queued"&&(this.repository.updateMessageDeliveryState(i.sessionId,i.canonicalMessageId,"executing"),i.state="running",i.lastPublishedAt=Date.now(),this.emitExternalActivity(i,"running")),!e.terminal||i.state!=="running")return;const a=e.terminalState??"completed";this.repository.updateMessageDeliveryState(i.sessionId,i.canonicalMessageId,a==="aborted"?"cancelled":a==="failed"?"failed":"completed"),this.emitExternalTerminal(i,a),t.shift(),t.length===0?this.externalObservations.delete(s):(this.externalObservations.set(s,t),t[0].lastPublishedAt=Date.now(),this.emitExternalActivity(t[0],"queued"))}suppressionFor(e,s,t){const i=I(e.agentType,e.sourceSessionKey),a=s.get(i),u=a?.window??this.suppressionWindows.get(i);return!u||e.ts<u.startedAt?null:e.ts>u.endsAt?(this.clearSuppression(i,u,a,s,t),null):e.role==="user"?(e.sourceEventKey===u.claimSourceEventKey||this.clearSuppression(i,u,a,s,t),null):u}clearSuppression(e,s,t,i,a){if(t){i.delete(e),a.set(t.claimKey,null);return}this.repository.removeManagedSuppression?.(s.agentType,s.sourceSessionKey),this.suppressionWindows.delete(e)}}function P(d){return O.createHash("sha256").update(ne(d)).digest("hex")}function I(d,e){return`${d}:${e}`}function re(d,e,s,t){if(!e.awaitingUserBoundary)return{events:d,cursor:{...e,offset:s,mtimeMs:t}};if(d.length===0)return{events:[],cursor:{...e,offset:s,mtimeMs:t,awaitingUserBoundary:!0}};const i=d.findIndex(a=>a.role==="user");return i<0?{events:[],cursor:{...e,mtimeMs:t,awaitingUserBoundary:!0}}:{events:d.slice(i),cursor:{...e,offset:s,mtimeMs:t,awaitingUserBoundary:!1}}}function ae(d,e,s,t,i,a){const u={...e.sourceBoundaryEstablished??{}},p=e.eventWatermarkTs??-1,y=new Set(e.eventKeysAtWatermark??[]),v=t?d:d.filter(n=>n.ts>p||n.ts===p&&!y.has(n.sourceEventKey)),T=[];for(const n of v){const o=n.sourceSessionKey;if(u[o]){T.push(n);continue}!(!t||(n.sourceSessionCreatedAtMs??0)>=s)||n.role!=="user"||(u[o]=!0,T.push(n))}const m=d.reduce((n,o)=>Math.max(n,o.ts),p),M=new Set(m===p?e.eventKeysAtWatermark??[]:[]);for(const n of d)n.ts===m&&M.add(n.sourceEventKey);return{events:T,cursor:{...e,offset:a,mtimeMs:i,eventWatermarkTs:m>=0?m:void 0,eventKeysAtWatermark:m>=0?[...M]:void 0,sourceBoundaryEstablished:u}}}export{me as NativeSessionFusionService};
+// @arch docs/architecture/cli/native-session-fusion.md
+// @test src/__tests__/native-fusion-parsers.test.ts
+import fs from 'node:fs';
+import crypto from 'node:crypto';
+import { publishPendingSessionIndexes } from '../session/index-publisher.js';
+import { NativeFusionFileWatcher } from './file-watcher.js';
+import { NativeEventIdentityConflictError, NativeFusionLocalRepository, } from './local-repository.js';
+import { listClaudeTranscriptFiles, listCodexRolloutFiles, listOpenCodeSessionFiles, listNativeTranscriptRoots, inspectNativeSessionFile, lookupCodexThreadName, parseClaudeTranscriptChunk, parseCodexRolloutChunk, parseOpenCodeSessionFile, } from './parsers.js';
+import { MAX_JSONL_SCAN_BYTES_PER_PASS } from './parser-common.js';
+import { loadNativeScannerState, saveNativeScannerState } from './state.js';
+const SCAN_INTERVAL_MS = 5 * 60_000;
+const CLAIM_TTL_MS = 2 * 60_000;
+const MANAGED_RUN_SUPPRESSION_TTL_MS = 30 * 60_000;
+const ACTIVE_SCAN_INTERVAL_MS = 2_000;
+const SCAN_YIELD_EVERY_FILES = 1;
+const COMMIT_YIELD_EVERY_EVENTS = 16;
+const EXTERNAL_ACTIVITY_HEARTBEAT_MS = 30_000;
+const EXTERNAL_OBSERVATION_TTL_MS = 4 * 60 * 60_000;
+function normalizeText(text) {
+    return text.replace(/\r\n/g, '\n').trim();
+}
+function yieldToEventLoop() {
+    return new Promise((resolve) => setImmediate(resolve));
+}
+function isCodexRolloutPath(filePath) {
+    return filePath.split(/[\\/]+/).includes('.codex');
+}
+export class NativeSessionFusionService {
+    client;
+    repository;
+    timer = null;
+    activeTimer = null;
+    scanPromise = null;
+    queuedTargetFiles = new Set();
+    pendingBoundaryFiles = new Set();
+    sourceFiles = new Map();
+    fullScanQueued = false;
+    watchEnabled = false;
+    lifecycleRevision = 0;
+    watcher = new NativeFusionFileWatcher((filePaths) => {
+        void this.scanNow(filePaths).catch((error) => {
+            console.error('[native-fusion] watched file scan failed', error);
+        });
+    });
+    pendingClaims;
+    suppressionWindows;
+    externalObservations = new Map();
+    externalTerminalHandler = null;
+    constructor(client, repository = new NativeFusionLocalRepository()) {
+        this.client = client;
+        this.repository = repository;
+        this.pendingClaims = new Map((this.repository.listManagedClaims?.() ?? [])
+            .map((claim) => [claim.canonicalMessageId, claim]));
+        this.suppressionWindows = new Map((this.repository.listManagedSuppressions?.() ?? [])
+            .map((window) => [sourceKey(window.agentType, window.sourceSessionKey), window]));
+    }
+    start() {
+        if (this.timer)
+            return;
+        this.timer = setInterval(() => {
+            void this.scanNow().catch((error) => {
+                console.error('[native-fusion] periodic scan failed', error);
+            });
+        }, SCAN_INTERVAL_MS);
+    }
+    stop() {
+        this.lifecycleRevision += 1;
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = null;
+        if (this.activeTimer)
+            clearInterval(this.activeTimer);
+        this.activeTimer = null;
+        this.pendingBoundaryFiles.clear();
+        this.watchEnabled = false;
+        this.watcher.stop();
+    }
+    setExternalTerminalHandler(handler) {
+        this.externalTerminalHandler = handler;
+    }
+    handleConnected() {
+        const lifecycleRevision = ++this.lifecycleRevision;
+        this.watchEnabled = true;
+        void this.scanNow()
+            .catch((error) => {
+            console.error('[native-fusion] initial scan failed', error);
+        })
+            .finally(() => {
+            if (this.lifecycleRevision === lifecycleRevision)
+                this.start();
+        });
+    }
+    registerManagedSend(params) {
+        if (!params.canonicalMessageId)
+            return;
+        const sourceAgentType = params.sourceAgentType ?? params.agentType;
+        if (sourceAgentType !== 'codex' &&
+            sourceAgentType !== 'claude' &&
+            sourceAgentType !== 'opencode')
+            return;
+        const claimKey = params.canonicalMessageId;
+        const existing = this.pendingClaims.get(claimKey);
+        const textHash = normalizedTextHash(params.text);
+        if (existing && (existing.sessionId !== params.sessionId
+            || existing.sourceAgentType !== sourceAgentType
+            || existing.textHash !== textHash)) {
+            throw new Error(`managed echo claim identity conflict: ${claimKey}`);
+        }
+        const claim = {
+            sessionId: params.sessionId,
+            agentType: params.agentType,
+            sourceAgentType,
+            canonicalMessageId: params.canonicalMessageId,
+            textHash,
+            createdAt: existing?.createdAt ?? Date.now(),
+            sourceSessionKey: params.sourceSessionKey ?? existing?.sourceSessionKey ?? null,
+            managedEchoPolicy: params.managedEchoPolicy ?? 'suppress_following',
+            externalRunId: params.externalRunId ?? null,
+        };
+        this.repository.upsertManagedClaim?.(claim);
+        this.pendingClaims.set(claimKey, claim);
+        if (params.externalRunId && params.sourceSessionKey) {
+            const key = `${sourceAgentType}:${params.sourceSessionKey}`;
+            const observations = this.externalObservations.get(key) ?? [];
+            observations.push({
+                sessionId: params.sessionId,
+                sourceSessionKey: params.sourceSessionKey,
+                runId: params.externalRunId,
+                canonicalMessageId: params.canonicalMessageId,
+                state: 'queued',
+                createdAt: Date.now(),
+                lastPublishedAt: Date.now(),
+            });
+            this.externalObservations.set(key, observations);
+            this.emitExternalActivity(observations[observations.length - 1], 'queued');
+            this.ensureActiveScanning();
+        }
+    }
+    cancelManagedSend(canonicalMessageId) {
+        this.repository.removeManagedClaim?.(canonicalMessageId);
+        this.pendingClaims.delete(canonicalMessageId);
+    }
+    noteManagedSourceSession(sessionId, agentType, sourceSessionKey) {
+        if (!sourceSessionKey)
+            return;
+        this.repository.updateManagedClaimSource?.(sessionId, agentType, sourceSessionKey);
+        for (const claim of this.pendingClaims.values()) {
+            if (claim.sessionId === sessionId && claim.sourceAgentType === agentType) {
+                claim.sourceSessionKey = sourceSessionKey;
+            }
+        }
+    }
+    handleSessionDeleted(sessionId) {
+        for (const [key, claim] of this.pendingClaims.entries()) {
+            if (claim.sessionId === sessionId)
+                this.pendingClaims.delete(key);
+        }
+        for (const [key, window] of this.suppressionWindows.entries()) {
+            if (window.sessionId === sessionId)
+                this.suppressionWindows.delete(key);
+        }
+        for (const [key, observations] of this.externalObservations.entries()) {
+            const remaining = observations.filter((observation) => observation.sessionId !== sessionId);
+            if (remaining.length === 0)
+                this.externalObservations.delete(key);
+            else
+                this.externalObservations.set(key, remaining);
+        }
+        this.repository.purgeSession(sessionId);
+    }
+    ensureActiveScanning(runImmediately = true) {
+        if (this.activeTimer)
+            return;
+        this.activeTimer = setInterval(() => {
+            if (this.externalObservations.size === 0 && this.pendingBoundaryFiles.size === 0) {
+                if (this.activeTimer)
+                    clearInterval(this.activeTimer);
+                this.activeTimer = null;
+                return;
+            }
+            this.scanActiveTargets();
+        }, ACTIVE_SCAN_INTERVAL_MS);
+        if (runImmediately)
+            this.scanActiveTargets();
+    }
+    scanActiveTargets() {
+        const targets = this.activeScanTargets();
+        // One in-flight full reconciliation is already locating an observation's
+        // source. Do not queue another full pass every two seconds behind it.
+        if (targets === undefined && this.scanPromise)
+            return;
+        void this.scanNow(targets).catch((error) => {
+            console.error('[native-fusion] active observation scan failed', error);
+        });
+    }
+    activeScanTargets() {
+        const observedSourceKeys = [...this.externalObservations.keys()];
+        if (observedSourceKeys.some((key) => !this.sourceFiles.has(key)))
+            return undefined;
+        return [...new Set([
+                ...this.pendingBoundaryFiles,
+                ...observedSourceKeys.flatMap((key) => {
+                    const filePath = this.sourceFiles.get(key);
+                    return filePath ? [filePath] : [];
+                }),
+            ])];
+    }
+    emitExternalActivity(observation, lifecycle) {
+        this.client.sendAgentEvent({
+            type: 'event',
+            event: 'agent',
+            id: `external-owner-${observation.runId}-${lifecycle}-${observation.lastPublishedAt}`,
+            payload: {
+                state: lifecycle === 'queued' ? 'start' : 'heartbeat',
+                sessionId: observation.sessionId,
+                runId: observation.runId,
+                seq: lifecycle === 'queued' ? 0 : 1,
+                runPhase: 'thinking',
+                canStop: false,
+                owner: 'external',
+                ownerLabel: 'Codex Desktop',
+                lifecycle,
+            },
+        });
+    }
+    emitExternalTerminal(observation, terminalState = 'completed') {
+        const state = terminalState === 'completed'
+            ? 'final'
+            : terminalState === 'aborted'
+                ? 'aborted'
+                : 'error';
+        this.client.sendAgentEvent({
+            type: 'event',
+            event: 'agent',
+            id: `external-owner-${observation.runId}-${state}`,
+            payload: {
+                state,
+                sessionId: observation.sessionId,
+                runId: observation.runId,
+                seq: 2,
+                ...(state === 'error' ? { message: 'Codex Desktop turn failed' } : {}),
+                owner: 'external',
+                ownerLabel: 'Codex Desktop',
+            },
+        });
+        // The relay event updates remote clients, but the local SessionManager also
+        // owns the durable queue. Wake it explicitly so an externally-owned Codex
+        // turn cannot leave the next mobile message queued forever.
+        this.externalTerminalHandler?.(observation.sessionId);
+    }
+    pruneState() {
+        const now = Date.now();
+        for (const [key, window] of this.suppressionWindows.entries()) {
+            if (window.endsAt > now)
+                continue;
+            this.repository.removeManagedSuppression?.(window.agentType, window.sourceSessionKey);
+            this.suppressionWindows.delete(key);
+        }
+    }
+    async scanNow(targetFiles) {
+        if (this.client.getState() !== 'connected')
+            return;
+        if (this.scanPromise) {
+            const activeScan = this.scanPromise;
+            if (targetFiles) {
+                for (const filePath of targetFiles)
+                    this.queuedTargetFiles.add(filePath);
+            }
+            else {
+                this.fullScanQueued = true;
+            }
+            await activeScan;
+            if (this.fullScanQueued) {
+                this.fullScanQueued = false;
+                this.queuedTargetFiles.clear();
+                return this.scanNow();
+            }
+            if (this.queuedTargetFiles.size > 0) {
+                const queued = [...this.queuedTargetFiles];
+                this.queuedTargetFiles.clear();
+                return this.scanNow(queued);
+            }
+            return;
+        }
+        this.scanPromise = this.runScanLoop(targetFiles).finally(() => {
+            this.scanPromise = null;
+        });
+        return this.scanPromise;
+    }
+    async runScanLoop(initialTargets) {
+        let targets = initialTargets ? [...new Set(initialTargets)] : undefined;
+        while (true) {
+            await this.runScan(targets);
+            if (this.fullScanQueued) {
+                await yieldToEventLoop();
+                this.fullScanQueued = false;
+                this.queuedTargetFiles.clear();
+                targets = undefined;
+                continue;
+            }
+            if (this.queuedTargetFiles.size > 0) {
+                await yieldToEventLoop();
+                targets = [...this.queuedTargetFiles];
+                this.queuedTargetFiles.clear();
+                continue;
+            }
+            return;
+        }
+    }
+    async runScan(targetFiles) {
+        this.pruneState();
+        this.refreshExternalObservations();
+        const state = loadNativeScannerState();
+        const nextFilesState = { ...state.files };
+        const batches = [];
+        const claimTransitions = new Map();
+        const stagedSuppressions = new Map();
+        const observedTitles = new Map();
+        const files = targetFiles ? [...targetFiles] : [
+            ...listCodexRolloutFiles(),
+            ...listClaudeTranscriptFiles(),
+            ...listOpenCodeSessionFiles(),
+        ];
+        if (!targetFiles && this.watchEnabled)
+            this.watcher.refresh(files, listNativeTranscriptRoots());
+        for (let fileIndex = 0; fileIndex < files.length; fileIndex += 1) {
+            const filePath = files[fileIndex];
+            if (fileIndex > 0 && fileIndex % SCAN_YIELD_EVERY_FILES === 0) {
+                await yieldToEventLoop();
+            }
+            if (!fs.existsSync(filePath)) {
+                if (this.watchEnabled)
+                    this.watcher.untrackFile(filePath);
+                this.pendingBoundaryFiles.delete(filePath);
+                for (const [key, mappedPath] of this.sourceFiles.entries()) {
+                    if (mappedPath === filePath)
+                        this.sourceFiles.delete(key);
+                }
+                continue;
+            }
+            if (this.watchEnabled)
+                this.watcher.trackFile(filePath);
+            const stat = fs.statSync(filePath);
+            const isCodex = isCodexRolloutPath(filePath);
+            const isOpenCode = filePath.endsWith('.opencode-session.json');
+            let current = state.files[filePath];
+            const fileIdentity = `${String(stat.dev)}:${String(stat.ino)}:${String(stat.birthtimeMs)}`;
+            let isNewFile = !current;
+            if (current && !isOpenCode && (stat.size < current.offset
+                || (current.fileIdentity && current.fileIdentity !== fileIdentity))) {
+                current = undefined;
+                isNewFile = true;
+            }
+            const unchanged = Boolean(current
+                && current.fileIdentity === fileIdentity
+                && current.mtimeMs === stat.mtimeMs
+                && current.offset >= stat.size
+                && current.sources?.length);
+            if (unchanged && current) {
+                for (const source of current.sources ?? []) {
+                    this.sourceFiles.set(sourceKey(source.agentType, source.sourceSessionKey), filePath);
+                }
+                if (current.classification === 'live' && current.awaitingUserBoundary) {
+                    this.pendingBoundaryFiles.add(filePath);
+                }
+                else {
+                    this.pendingBoundaryFiles.delete(filePath);
+                }
+                continue;
+            }
+            const inspection = current?.sources?.length && !isOpenCode
+                ? {
+                    status: 'ready',
+                    createdAtMs: current.sessionCreatedAtMs ?? stat.birthtimeMs,
+                    sources: current.sources,
+                }
+                : inspectNativeSessionFile(filePath);
+            if (inspection.status === 'pending') {
+                if (stat.birthtimeMs >= state.fusionEpochMs)
+                    this.pendingBoundaryFiles.add(filePath);
+                continue;
+            }
+            for (const source of inspection.sources) {
+                this.sourceFiles.set(sourceKey(source.agentType, source.sourceSessionKey), filePath);
+            }
+            if (!isOpenCode
+                && inspection.sources.length > 0
+                && inspection.sources.every((source) => (this.repository.isSourceDeleted?.(source.agentType, source.sourceSessionKey)))) {
+                nextFilesState[filePath] = {
+                    ...(current ?? {
+                        daemonInstallationId: state.daemonInstallationId,
+                        classification: inspection.createdAtMs >= state.fusionEpochMs ? 'live' : 'historical',
+                        awaitingUserBoundary: true,
+                        sessionCreatedAtMs: inspection.createdAtMs,
+                        sourceBoundaryEstablished: {},
+                    }),
+                    offset: stat.size,
+                    mtimeMs: stat.mtimeMs,
+                    fileIdentity,
+                };
+                continue;
+            }
+            if (!current) {
+                current = {
+                    daemonInstallationId: state.daemonInstallationId,
+                    offset: 0,
+                    mtimeMs: stat.mtimeMs,
+                    classification: inspection.createdAtMs >= state.fusionEpochMs ? 'live' : 'historical',
+                    awaitingUserBoundary: true,
+                    sessionCreatedAtMs: inspection.createdAtMs,
+                    sourceBoundaryEstablished: {},
+                };
+            }
+            else if (isOpenCode && current.mtimeMs === stat.mtimeMs) {
+                continue;
+            }
+            const startOffset = isOpenCode ? 0 : current.offset;
+            const parsed = isOpenCode
+                ? parseOpenCodeSessionFile(filePath, startOffset)
+                : isCodex
+                    ? parseCodexRolloutChunk(filePath, startOffset)
+                    : parseClaudeTranscriptChunk(filePath, startOffset);
+            for (const event of parsed.events) {
+                if (this.repository.isSourceDeleted?.(event.agentType, event.sourceSessionKey))
+                    continue;
+                if (event.title?.trim() && event.titleSource === 'agent_native') {
+                    observedTitles.set(`${event.agentType}:${event.sourceSessionKey}`, event);
+                }
+            }
+            let acceptedEvents;
+            let nextFileState;
+            if (isOpenCode) {
+                const planned = planOpenCodeSnapshot(parsed.events, current, state.fusionEpochMs, isNewFile, stat.mtimeMs, parsed.nextOffset);
+                acceptedEvents = planned.events;
+                nextFileState = planned.cursor;
+            }
+            else if (isNewFile && current.classification === 'historical') {
+                acceptedEvents = [];
+                nextFileState = {
+                    ...current,
+                    offset: parsed.nextOffset,
+                    mtimeMs: stat.mtimeMs,
+                    awaitingUserBoundary: true,
+                };
+            }
+            else {
+                const planned = planJsonlEvents(parsed.events, current, parsed.nextOffset, stat.mtimeMs);
+                acceptedEvents = planned.events;
+                nextFileState = planned.cursor;
+            }
+            nextFileState.fileIdentity = fileIdentity;
+            nextFileState.sources = inspection.sources;
+            nextFilesState[filePath] = nextFileState;
+            if (parsed.nextOffset < stat.size
+                && stat.size - startOffset > MAX_JSONL_SCAN_BYTES_PER_PASS) {
+                this.queuedTargetFiles.add(filePath);
+            }
+            if (nextFileState.classification === 'live' && nextFileState.awaitingUserBoundary) {
+                this.pendingBoundaryFiles.add(filePath);
+            }
+            else {
+                this.pendingBoundaryFiles.delete(filePath);
+            }
+            for (const event of acceptedEvents) {
+                if (this.repository.isSourceDeleted?.(event.agentType, event.sourceSessionKey))
+                    continue;
+                const claimed = this.tryClaimManagedEcho(event);
+                if (claimed) {
+                    batches.push(claimed.event);
+                    claimTransitions.set(claimed.claimKey, claimed.suppression ?? null);
+                    if (claimed.suppression) {
+                        stagedSuppressions.set(sourceKey(claimed.suppression.agentType, claimed.suppression.sourceSessionKey), { window: claimed.suppression, claimKey: claimed.claimKey });
+                    }
+                    continue;
+                }
+                const suppression = this.suppressionFor(event, stagedSuppressions, claimTransitions);
+                if (suppression) {
+                    batches.push({
+                        ...event,
+                        claimSessionId: suppression.sessionId,
+                        localDisposition: 'managed_echo_suppressed',
+                    });
+                    continue;
+                }
+                batches.push(event);
+            }
+        }
+        const orderedBatches = [...batches].sort((left, right) => left.ts - right.ts);
+        const quarantinedEventKeys = new Set();
+        const quarantinedClaimKeys = new Set();
+        const commitBatch = (events) => {
+            try {
+                this.repository.commitEvents(events);
+            }
+            catch (error) {
+                if (!(error instanceof NativeEventIdentityConflictError))
+                    throw error;
+                const conflict = events.find((event) => event.sourceEventKey === error.sourceEventKey);
+                if (!conflict)
+                    throw error;
+                quarantinedEventKeys.add(conflict.sourceEventKey);
+                if (conflict.claimCanonicalMessageId) {
+                    quarantinedClaimKeys.add(conflict.claimCanonicalMessageId);
+                }
+                console.warn(`[native-fusion] quarantined conflicting native event ${conflict.sourceEventKey}`);
+                const remaining = events.filter((event) => event !== conflict);
+                if (remaining.length > 0)
+                    commitBatch(remaining);
+            }
+        };
+        if (orderedBatches.length === 0)
+            this.repository.commitEvents([]);
+        for (let start = 0; start < orderedBatches.length; start += COMMIT_YIELD_EVERY_EVENTS) {
+            commitBatch(orderedBatches.slice(start, start + COMMIT_YIELD_EVERY_EVENTS));
+            if (start + COMMIT_YIELD_EVERY_EVENTS < orderedBatches.length)
+                await yieldToEventLoop();
+        }
+        for (const [claimKey, suppression] of claimTransitions) {
+            if (quarantinedClaimKeys.has(claimKey))
+                continue;
+            this.repository.completeManagedClaim?.(claimKey, suppression ?? undefined);
+            this.pendingClaims.delete(claimKey);
+            if (suppression) {
+                this.suppressionWindows.set(sourceKey(suppression.agentType, suppression.sourceSessionKey), suppression);
+            }
+        }
+        for (const event of observedTitles.values()) {
+            this.repository.observeNativeTitle(event.agentType, event.sourceSessionKey, event.title ?? '');
+        }
+        for (const binding of this.repository.listSourceBindings()) {
+            if (binding.agentType !== 'codex')
+                continue;
+            const title = lookupCodexThreadName(binding.sourceSessionKey);
+            if (title)
+                this.repository.observeNativeTitle('codex', binding.sourceSessionKey, title);
+        }
+        for (const event of orderedBatches) {
+            if (!quarantinedEventKeys.has(event.sourceEventKey))
+                this.observeExternalLifecycle(event);
+        }
+        state.files = nextFilesState;
+        saveNativeScannerState(state);
+        if (this.pendingBoundaryFiles.size > 0)
+            this.ensureActiveScanning(false);
+        // A large transcript is reconciled over several bounded passes. Publishing
+        // after every pass repeats the full dirty session projection and can flood
+        // the relay with large, superseded index frames. Keep the dirty projection
+        // local until the queued backlog drains, then publish its final revision
+        // once. The scan loop always consumes these queued targets before returning.
+        if (this.fullScanQueued || this.queuedTargetFiles.size > 0)
+            return;
+        this.repository.repairMissingUserBoundaries?.();
+        await publishPendingSessionIndexes(this.client).catch((error) => {
+            console.error('[native-fusion] index projection sync failed; retained for retry', error);
+        });
+    }
+    refreshExternalObservations() {
+        const now = Date.now();
+        for (const [key, observations] of this.externalObservations.entries()) {
+            const active = observations.filter((observation) => now - observation.createdAt < EXTERNAL_OBSERVATION_TTL_MS);
+            if (active.length === 0) {
+                this.externalObservations.delete(key);
+                continue;
+            }
+            this.externalObservations.set(key, active);
+            const current = active[0];
+            if (now - current.lastPublishedAt < EXTERNAL_ACTIVITY_HEARTBEAT_MS)
+                continue;
+            current.lastPublishedAt = now;
+            this.emitExternalActivity(current, current.state);
+        }
+    }
+    tryClaimManagedEcho(event) {
+        const now = Date.now();
+        for (const [claimKey, claim] of this.pendingClaims.entries()) {
+            if (claim.sourceAgentType !== event.agentType)
+                continue;
+            if (event.role !== 'user')
+                continue;
+            if (!claim.sourceSessionKey)
+                continue;
+            if (claim.sourceSessionKey !== event.sourceSessionKey)
+                continue;
+            const claimWindowMs = claim.externalRunId ? EXTERNAL_OBSERVATION_TTL_MS : CLAIM_TTL_MS;
+            if (Math.abs(event.ts - claim.createdAt) > claimWindowMs)
+                continue;
+            if (normalizedTextHash(event.payload) !== claim.textHash)
+                continue;
+            const suppression = claim.managedEchoPolicy === 'suppress_following'
+                ? {
+                    sessionId: claim.sessionId,
+                    agentType: event.agentType,
+                    sourceSessionKey: event.sourceSessionKey,
+                    claimSourceEventKey: event.sourceEventKey,
+                    startedAt: event.ts,
+                    endsAt: Math.max(now, event.ts) + MANAGED_RUN_SUPPRESSION_TTL_MS,
+                }
+                : undefined;
+            return {
+                claimKey,
+                suppression,
+                event: {
+                    ...event,
+                    sourceMode: 'managed_echo_claim',
+                    claimCanonicalMessageId: claim.canonicalMessageId,
+                    claimSessionId: claim.sessionId,
+                    managedEchoPolicy: claim.managedEchoPolicy,
+                },
+            };
+        }
+        return null;
+    }
+    observeExternalLifecycle(event) {
+        const key = `${event.agentType}:${event.sourceSessionKey}`;
+        const observations = this.externalObservations.get(key);
+        if (!observations?.length)
+            return;
+        const current = observations[0];
+        if (event.claimCanonicalMessageId === current.canonicalMessageId &&
+            current.state === 'queued') {
+            this.repository.updateMessageDeliveryState(current.sessionId, current.canonicalMessageId, 'executing');
+            current.state = 'running';
+            current.lastPublishedAt = Date.now();
+            this.emitExternalActivity(current, 'running');
+        }
+        if (!event.terminal || current.state !== 'running')
+            return;
+        const terminalState = event.terminalState ?? 'completed';
+        this.repository.updateMessageDeliveryState(current.sessionId, current.canonicalMessageId, terminalState === 'aborted'
+            ? 'cancelled'
+            : terminalState === 'failed'
+                ? 'failed'
+                : 'completed');
+        this.emitExternalTerminal(current, terminalState);
+        observations.shift();
+        if (observations.length === 0) {
+            this.externalObservations.delete(key);
+        }
+        else {
+            this.externalObservations.set(key, observations);
+            observations[0].lastPublishedAt = Date.now();
+            this.emitExternalActivity(observations[0], 'queued');
+        }
+    }
+    suppressionFor(event, staged, transitions) {
+        const key = sourceKey(event.agentType, event.sourceSessionKey);
+        const stagedEntry = staged.get(key);
+        const window = stagedEntry?.window ?? this.suppressionWindows.get(key);
+        if (!window || event.ts < window.startedAt)
+            return null;
+        if (event.ts > window.endsAt) {
+            this.clearSuppression(key, window, stagedEntry, staged, transitions);
+            return null;
+        }
+        if (event.role === 'user') {
+            // A cursor rollback may replay the user event that established this
+            // suppression window. It is not a new terminal-authored turn and must
+            // not release suppression for agent output that arrived after the crash.
+            if (event.sourceEventKey === window.claimSourceEventKey)
+                return null;
+            this.clearSuppression(key, window, stagedEntry, staged, transitions);
+            return null;
+        }
+        return window;
+    }
+    clearSuppression(key, window, stagedEntry, staged, transitions) {
+        if (stagedEntry) {
+            staged.delete(key);
+            transitions.set(stagedEntry.claimKey, null);
+            return;
+        }
+        this.repository.removeManagedSuppression?.(window.agentType, window.sourceSessionKey);
+        this.suppressionWindows.delete(key);
+    }
+}
+function normalizedTextHash(text) {
+    return crypto.createHash('sha256').update(normalizeText(text)).digest('hex');
+}
+function sourceKey(agentType, sourceSessionKey) {
+    return `${agentType}:${sourceSessionKey}`;
+}
+function planJsonlEvents(events, current, nextOffset, mtimeMs) {
+    if (!current.awaitingUserBoundary) {
+        return { events, cursor: { ...current, offset: nextOffset, mtimeMs } };
+    }
+    if (events.length === 0) {
+        return {
+            events: [],
+            cursor: { ...current, offset: nextOffset, mtimeMs, awaitingUserBoundary: true },
+        };
+    }
+    const userBoundary = events.findIndex((event) => event.role === 'user');
+    if (userBoundary < 0) {
+        return { events: [], cursor: { ...current, mtimeMs, awaitingUserBoundary: true } };
+    }
+    return {
+        events: events.slice(userBoundary),
+        cursor: { ...current, offset: nextOffset, mtimeMs, awaitingUserBoundary: false },
+    };
+}
+function planOpenCodeSnapshot(events, current, fusionEpochMs, isNewFile, mtimeMs, nextOffset) {
+    const established = { ...(current.sourceBoundaryEstablished ?? {}) };
+    const watermarkTs = current.eventWatermarkTs ?? -1;
+    const keysAtWatermark = new Set(current.eventKeysAtWatermark ?? []);
+    const candidates = isNewFile
+        ? events
+        : events.filter((event) => event.ts > watermarkTs
+            || (event.ts === watermarkTs && !keysAtWatermark.has(event.sourceEventKey)));
+    const accepted = [];
+    for (const event of candidates) {
+        const sourceKey = event.sourceSessionKey;
+        if (established[sourceKey]) {
+            accepted.push(event);
+            continue;
+        }
+        const sourceIsLive = !isNewFile || (event.sourceSessionCreatedAtMs ?? 0) >= fusionEpochMs;
+        if (!sourceIsLive || event.role !== 'user')
+            continue;
+        established[sourceKey] = true;
+        accepted.push(event);
+    }
+    const maxTimestamp = events.reduce((maximum, event) => Math.max(maximum, event.ts), watermarkTs);
+    const nextKeySet = new Set(maxTimestamp === watermarkTs ? current.eventKeysAtWatermark ?? [] : []);
+    for (const event of events) {
+        if (event.ts === maxTimestamp)
+            nextKeySet.add(event.sourceEventKey);
+    }
+    return {
+        events: accepted,
+        cursor: {
+            ...current,
+            offset: nextOffset,
+            mtimeMs,
+            eventWatermarkTs: maxTimestamp >= 0 ? maxTimestamp : undefined,
+            eventKeysAtWatermark: maxTimestamp >= 0 ? [...nextKeySet] : undefined,
+            sourceBoundaryEstablished: established,
+        },
+    };
+}