@adhdev/daemon-core 1.0.18-rc.19 → 1.0.18-rc.2

package/dist/repo-mesh-types.d.ts

@@ -14,8 +14,6 @@ import type { GitRepoStatus, GitCompactSummary } from './git/git-types.js';
 import type { MeshMissionSummary, MeshMissionSlimSummary } from './mesh/mesh-missions.js';
 import type { MeshMagiActivitySummary } from './mesh/mesh-magi-status.js';
 import type { MagiKindPanelMap, DifficultyBrainMap, NodeCapabilitySlot } from '@adhdev/mesh-shared';
-import type { ProviderModule } from './providers/contracts.js';
-import type { RepoMeshDeclarativeConfig } from './config/mesh-json-config.js';
 export interface RepoMesh {
     id: string;
     name: string;
@@ -257,8 +255,6 @@ export interface RepoMeshPolicy {
      * A node policy may override this per-node (RepoMeshNodePolicy.delegatedWorkerAutoApprove).
      */
     delegatedWorkerAutoApprove?: boolean;
-    /** Explicit opt-in required before delegated workers may use a dangerous provider mode. */
-    delegatedWorkerDangerousModeAllow?: boolean;
     /**
      * MESH-SEND-KEYS (feature 3): opt-in to allow the coordinator to inject
      * DESTRUCTIVE keys (CTRL_C / ESC) into a worker PTY via mesh_send_keys. These
@@ -410,8 +406,6 @@ export interface RepoMeshNodePolicy {
      * precedence over the mesh-level policy for worker sessions launched onto this node.
      */
     delegatedWorkerAutoApprove?: boolean;
-    /** Per-node override for dangerous delegated worker mode authorization. */
-    delegatedWorkerDangerousModeAllow?: boolean;
     /**
      * MESH-SEND-KEYS (feature 3): per-node override for
      * RepoMeshPolicy.allowSendKeysDestructive.
@@ -530,39 +524,13 @@ export declare function normalizeAutoFastForwardPolicy(value: unknown): NonNulla
  */
 export declare function mergeAndNormalizePolicy(base: RepoMeshPolicy | undefined, patch: Partial<RepoMeshPolicy> | undefined): RepoMeshPolicy;
 /**
- * Resolve delegated worker auto-approve. Legacy providers return a boolean. Providers
- * with modes return a mode id, except a dangerous mode is downgraded to a
- * non-dangerous PTY mode unless mesh/node policy explicitly opts in.
- *
- * THREE EXPLICIT STAGES — do not collapse them; the ordering is a hard MAGI
- * invariant:
- *
- *   ① ENABLE gate (machine-local policy only): node boolean > mesh boolean.
- *      `enabled=false` returns `false` IMMEDIATELY, BEFORE any mode selection.
- *      The repo `mesh.json` providerDefaults has ZERO influence here — a
- *      node/mesh opt-out is never overridden by a repo-declared requested mode.
- *
- *   ② MODE selection (only when enabled === true):
- *        task override [FUTURE — param reserved below, not yet wired] >
- *        repo mesh.json providerDefaults.autoApproveModes[providerType] >
- *        provider spec autoApproveModes.default.
- *      A repo-requested mode ID is adopted ONLY when it exists in the provider's
- *      own `autoApproveModes.modes`; an unknown/stale/typo'd ID is IGNORED and we
- *      fall back to the provider default (fail-closed: never coerce into a
- *      dangerous mode via a bad ID).
- *
- *   ③ DANGEROUS gate: whichever mode stage ② picked, if it is dangerous and the
- *      machine-local delegatedWorkerDangerousModeAllow is not set, downgrade to a
- *      non-dangerous PTY-parse mode (or `false` if none exists).
+ * Resolve whether a delegated worker session launched onto `nodePolicy` (within a mesh
+ * governed by `meshPolicy`) should auto-approve. Precedence: node override → mesh policy
+ * → default true. The result is stamped into the worker launch settings envelope as
+ * `autoApprove`; it wins over the global per-provider-type autoApprove config because the
+ * launch path merges the envelope as a settingsOverride on top of the provider defaults.
  */
-export declare function resolveDelegatedWorkerAutoApprove(meshPolicy?: Pick<RepoMeshPolicy, 'delegatedWorkerAutoApprove' | 'delegatedWorkerDangerousModeAllow'> | null, nodePolicy?: Pick<RepoMeshNodePolicy, 'delegatedWorkerAutoApprove' | 'delegatedWorkerDangerousModeAllow'> | null, provider?: Pick<ProviderModule, 'autoApproveModes'> | null, repoConfig?: RepoMeshDeclarativeConfig | null, providerType?: string | null): boolean | string;
-export declare function resolveDelegatedWorkerDangerousModeAllow(meshPolicy?: Pick<RepoMeshPolicy, 'delegatedWorkerDangerousModeAllow'> | null, nodePolicy?: Pick<RepoMeshNodePolicy, 'delegatedWorkerDangerousModeAllow'> | null): boolean;
-/** Shape a boolean-or-mode resolution for the settings precedence contract. */
-export declare function delegatedWorkerAutoApproveSettings(meshPolicy?: Pick<RepoMeshPolicy, 'delegatedWorkerAutoApprove' | 'delegatedWorkerDangerousModeAllow'> | null, nodePolicy?: Pick<RepoMeshNodePolicy, 'delegatedWorkerAutoApprove' | 'delegatedWorkerDangerousModeAllow'> | null, provider?: Pick<ProviderModule, 'autoApproveModes'> | null, repoConfig?: RepoMeshDeclarativeConfig | null, providerType?: string | null): {
-    autoApprove: boolean | undefined;
-    autoApproveMode: string | undefined;
-    delegatedWorkerDangerousModeAllow: boolean;
-};
+export declare function resolveDelegatedWorkerAutoApprove(meshPolicy?: Pick<RepoMeshPolicy, 'delegatedWorkerAutoApprove'> | null, nodePolicy?: Pick<RepoMeshNodePolicy, 'delegatedWorkerAutoApprove'> | null): boolean;
 /**
  * MESH-SEND-KEYS (feature 3): resolve whether DESTRUCTIVE key injection
  * (CTRL_C/ESC via mesh_send_keys) is permitted for a node. Node policy overrides

package/dist/shared-types.d.ts

@@ -13,7 +13,7 @@ export type { ProviderState, ProviderStatus, ActiveChatData, IdeProviderState, C
 export type { ProviderErrorReason } from './providers/provider-instance.js';
 import type { ActiveChatData as _ActiveChatData, ProviderErrorReason as _ProviderErrorReason } from './providers/provider-instance.js';
 import type { WorkspaceEntry } from './config/workspaces.js';
-import type { AutoApproveModesConfig, ProviderMeshCoordinatorConfig, ProviderResumeCapability } from './providers/contracts.js';
+import type { ProviderMeshCoordinatorConfig, ProviderResumeCapability } from './providers/contracts.js';
 import type { GitCompactSummary, GitWorkspaceUpdate, WorkspaceGitSubscriptionParams } from './git/git-types.js';
 import type { InteractivePrompt } from './providers/types/interactive-prompt.js';
 export type { GitCommandName, GitCompactSummary, GitDiffSummary, GitFailureReason, GitFileChange, GitFileChangeStatus, GitRepoIdentity, GitRepoStatus, GitSnapshot, GitSnapshotCompareSummary, GitSnapshotReason, GitWorkspaceUpdate, WorkspaceGitSubscriptionParams, } from './git/git-types.js';
@@ -428,8 +428,6 @@ export interface AvailableProviderInfo {
     lastVerification?: MachineProviderCheckResult;
     /** Provider-declared Repo Mesh coordinator/MCP behavior. */
     meshCoordinator?: ProviderMeshCoordinatorConfig;
-    /** Provider-declared auto-approve choices shown by session launch UIs. */
-    autoApproveModes?: AutoApproveModesConfig;
     /** BRAIN-ROUTING: suggested model values for the new-session model dropdown. */
     modelOptions?: string[];
     /** BRAIN-ROUTING: reasoning-effort values for the new-session thinking dropdown. */
@@ -626,7 +624,7 @@ export interface DashboardBootstrapDaemonEntry extends Partial<CloudDaemonSummar
     p2p?: StatusReportPayload['p2p'];
     timestamp?: number;
 }
-export type DaemonStatusEventName = 'agent:generating_started' | 'agent:waiting_approval' | 'agent:waiting_choice' | 'agent:generating_completed' | 'agent:stopped' | 'monitor:no_progress' | 'monitor:long_generating';
+export type DaemonStatusEventName = 'agent:generating_started' | 'agent:waiting_approval' | 'agent:generating_completed' | 'agent:stopped' | 'monitor:no_progress' | 'monitor:long_generating';
 /** Minimal daemon-originated event payload relayed through the server. */
 export interface DaemonStatusEventPayload {
     event: DaemonStatusEventName;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "1.0.18-rc.19",
+  "version": "1.0.18-rc.2",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -47,8 +47,8 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "1.0.18-rc.19",
-    "@adhdev/session-host-core": "1.0.18-rc.19",
+    "@adhdev/mesh-shared": "1.0.18-rc.2",
+    "@adhdev/session-host-core": "1.0.18-rc.2",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",

package/src/boot/daemon-lifecycle.ts

@@ -39,7 +39,6 @@ import type { IdeProviderInstance } from '../providers/ide-provider-instance.js'
 import { createDefaultGitCommandServices } from '../git/git-commands.js';
 import { setupMeshEventForwarding } from '../mesh/mesh-events.js';
 import { setupMeshReconcileLoop } from '../mesh/mesh-reconcile-loop.js';
-import { MeshRuntimeStore } from '../mesh/mesh-runtime-store.js';
 import { loadMeshCoordinatorRegistry } from '../mesh/coordinator-registry.js';
 import { applyProcessHardening } from './process-hardening.js';
 import { installProviderProcessShim } from '../providers/sdk/v1/sandbox/require-whitelist.js';
@@ -504,13 +503,4 @@ export async function shutdownDaemonComponents(components: DaemonComponents): Pr
         try { m.disconnect(); } catch { /* noop */ }
     }
     cdpManagers.clear();
-
-    // 7. VACUUM the mesh runtime DB. Retention prunes rows with DELETE (frees pages
-    // inside the file but never shrinks it); the mesh-runtime.db grew to hundreds of
-    // MB (mission 86def38d disk-accumulation bootstrap failure) because it was never
-    // compacted. Do this LAST, after all writers (reconcile loop, CLIs, instances)
-    // are stopped, so nothing contends for the exclusive VACUUM lock. Best-effort —
-    // vacuum() swallows its own errors; the try/catch guards the getInstance() throw
-    // when the store never opened (degraded JSONL-only mode).
-    try { MeshRuntimeStore.getInstance().vacuum(); } catch { /* store unavailable — nothing to vacuum */ }
 }

package/src/cli-adapters/cli-state-engine.ts

@@ -15,7 +15,6 @@ import {
 import {
     buildCliScreenSnapshot,
     compactPromptText,
-    isPurePtyTranscriptProvider,
     normalizePromptText,
     promptLikelyVisible,
     type CliChatMessage,
@@ -87,18 +86,6 @@ interface IdleFinishCandidate {
     assistantLength: number;
 }
 
-/**
- * Minimal shape computeApprovalContentSignature / isStaleResolvedApproval
- * actually need — deliberately narrower than the full CliBufferSnapshot so
- * callers outside the settled-eval loop (e.g. the adapter's startup-gate
- * modal parse in getStatus/getDebugState) can supply just these two fields
- * without having to fabricate an entire snapshot.
- */
-interface ApprovalSignatureSnapshot {
-    screenText?: string;
-    accumulatedBuffer?: string;
-}
-
 interface SettledEvalContext {
     now: number;
     modal: { message: string; buttons: string[] } | null;
@@ -168,22 +155,6 @@ export class CliStateEngine {
     // ── Approval ─────────────────────────────────────
     lastApprovalResolvedAt = 0;
     lastResolvedModalMessage = '';
-    /**
-     * Normalized approval-context signature captured at resolve time (see
-     * `computeApprovalContentSignature`) — the screen text with blank-line
-     * padding and any manifest-declared chrome (transcriptPty.chromePatterns,
-     * spinner.patterns) stripped out. Used by applyWaitingApproval's
-     * isStaleResolvedRepaint check to tell "the same already-answered modal,
-     * re-parsed from a screen that has not meaningfully changed" apart from
-     * "a genuinely new approval" — content-based, not time-based, because
-     * ordinary TUI chrome (status bar, context meter, blank-line repaint)
-     * keeps producing fresh PTY bytes on an otherwise-unchanged screen and
-     * defeats any output-timestamp discriminator within a few hundred ms.
-     * Cleared whenever a turn starts or the session tears down (see
-     * onTurnStarted / resetActiveTurnState / onPtyExit) so a next-turn
-     * approval is never compared against stale prior-turn state.
-     */
-    lastApprovalResolvedContentSignature = '';
     /**
      * Monotonic counter bumped every time the FSM *enters* waiting_approval
      * with a freshly captured modal (see `applyWaitingApproval`). It is the
@@ -333,61 +304,12 @@ export class CliStateEngine {
         // anchor its window on dispatch time rather than completion time.
         this.currentTurnStartedAt = Date.now();
         this.responseEpoch += 1;
-        // A new turn's own prompt echo is real new content, so the stale-repaint
-        // guard's signature would naturally drift anyway — but clear the
-        // resolve-time bookkeeping explicitly here too, so a next-turn approval
-        // that happens to share message text with a previous turn's already-
-        // resolved one is never compared against stale prior-turn state.
-        this.clearApprovalResolutionMemory();
-        // (fix: kimi K3 send→idle-looking→generating lag / missed-generating on
-        // fast tool turns) For transcriptAuthority:'provider' providers (kimi,
-        // and other native-transcript sources), the PTY-scanned parser always
-        // returns messages:[] — the provider owns the transcript, not the PTY —
-        // so evaluateSettled's shouldHoldGenerating fast-path exception
-        // (hasFinalCurrentTurnAssistant) can never release early and
-        // recent_activity_hold ends up carrying the ENTIRE "is this turn still
-        // generating" signal for these providers regardless of what the spinner
-        // script does. That fallback only fires once a settle tick actually
-        // runs, which needs PTY output to schedule — for a model that "thinks"
-        // silently for many seconds before its first repaint (observed 12-20s
-        // for Kimi K3's default "high" effort), the dashboard looks idle for
-        // that whole window even though the turn was already accepted. Worse,
-        // a turn that fully completes (tool calls + reply) within a single
-        // settle debounce window can go straight idle→idle with no visible
-        // generating state at all (observed live with a yolo tool-use turn).
-        // onTurnStarted is the authoritative "a turn was just submitted" signal
-        // — promote to generating immediately instead of waiting on PTY-driven
-        // detection. This does not weaken completion detection: applyIdle /
-        // finishResponse (authoritative settled evidence) still own the actual
-        // idle transition, unchanged. Scoped to transcriptAuthority:'provider'
-        // only, so PTY-authoritative providers (whose spinner/settled parsing
-        // already drives generating promptly) are unaffected.
-        //
-        // (fix: kimi pure-PTY completion-emit) The pure-PTY full-buffer class
-        // (kimi and kin — see isPurePtyTranscriptProvider) is NOT
-        // transcriptAuthority:'provider', so without this it stays idle when a
-        // prompt is submitted from idle: the FSM never crosses generating→idle,
-        // detectStatusTransition's generating|waiting_approval→idle arm never
-        // runs, and agent:generating_completed is never emitted — the mesh
-        // coordinator leaves the task 'assigned' and the status-agnostic stall
-        // watchdog then false-fires task_stalled on the finished-but-idle
-        // session. Promoting this class to generating on turn-start makes the
-        // existing PTY-parsed final-assistant idle gate produce a real
-        // generating→idle completion edge. Same idle safety as above: applyIdle
-        // / finishResponse still own the actual idle transition.
-        const promoteOnTurnStart = this.provider.transcriptAuthority === 'provider'
-            || isPurePtyTranscriptProvider(this.provider);
-        if (promoteOnTurnStart && this.currentStatus !== 'waiting_approval') {
-            this.setStatus('generating', 'turn_started');
-            this.callbacks.onStatusChange();
-        }
     }
 
     /** Called when PTY exits */
     onPtyExit(): void {
         this.clearAllTimers();
         this.setStatus('stopped', 'pty_exit');
-        this.clearApprovalResolutionMemory();
     }
 
     /** Called when adapter starts up successfully */
@@ -460,11 +382,6 @@ export class CliStateEngine {
         this.activeModal = null;
         this.lastApprovalResolvedAt = Date.now();
         this.lastResolvedModalMessage = currentModalMessage;
-        // Snapshot the chrome-stripped screen at the moment of resolve — the
-        // baseline applyWaitingApproval's isStaleResolvedRepaint check compares
-        // against to tell a stale re-parse of THIS modal apart from a
-        // genuinely new one, regardless of how much wall-clock time passes.
-        this.lastApprovalResolvedContentSignature = this.computeApprovalContentSignature(snap);
         this.lastResolvedEntrySeq = this.approvalEntrySeq;
         this.responseSettleIgnoreUntil = Date.now() + this.timeouts.outputSettle + 400;
         if (this.approvalExitTimeout) { clearTimeout(this.approvalExitTimeout); this.approvalExitTimeout = null; }
@@ -582,7 +499,6 @@ export class CliStateEngine {
         this.pendingScriptStatusSince = 0;
         this.approvalResumeDeferSince = 0;
         this.approvalResumeDeferEpoch = -1;
-        this.clearApprovalResolutionMemory();
     }
 
     clearIdleFinishCandidate(reason: string): void {
@@ -763,9 +679,7 @@ export class CliStateEngine {
         if (!status) return;
 
         const prevStatus = this.currentStatus;
-        const ctx: SettledEvalContext = {
-            now, modal, status, parsedMessages, lastParsedAssistant, parsedStatus: parsedStatus || null, prevStatus,
-        };
+        const ctx: SettledEvalContext = { now, modal, status, parsedMessages, lastParsedAssistant, parsedStatus: parsedStatus || null, prevStatus };
 
         if (!this.applyPendingScriptStatusDebounce(ctx)) return;
 
@@ -829,7 +743,7 @@ export class CliStateEngine {
             this.applyError(ctx, session);
             return;
         }
-        if (status === 'waiting_approval') { this.applyWaitingApproval(ctx, snap); return; }
+        if (status === 'waiting_approval') { this.applyWaitingApproval(ctx); return; }
         if (status === 'generating') { this.applyGenerating(ctx); return; }
         if (status === 'idle') { this.applyIdle(ctx, snap, now); }
     }
@@ -887,7 +801,7 @@ export class CliStateEngine {
         this.callbacks.onStatusChange();
     }
 
-    private applyWaitingApproval(ctx: SettledEvalContext, snap: CliBufferSnapshot): void {
+    private applyWaitingApproval(ctx: SettledEvalContext): void {
         const { modal } = ctx;
         this.clearIdleFinishCandidate('waiting_approval');
         const inCooldown = this.lastApprovalResolvedAt
@@ -978,51 +892,6 @@ export class CliStateEngine {
                 }
                 return;
             }
-            // (fix: kimi stale-approval re-latch, observed live on kimi-code
-            // v0.28.1/K3) A freshly-*parsed* modal is not proof the CLI is
-            // presenting it right now — parseApproval scans an accumulated
-            // raw-output window (recentOutputBuffer / window-around-question
-            // scope), which can still contain the text of an approval that was
-            // ALREADY resolved a moment ago and re-surface it on the very next
-            // settle pass, even though resolveModal() already wrote the key and
-            // cleared activeModal. Reproduced live: after approving a tool call,
-            // the FSM re-latched `waiting_approval` on the identical
-            // already-answered question with NO further genuinely new content
-            // ever arriving afterward — the dashboard stayed wedged on "waiting
-            // for approval" until the 5-minute maxResponse watchdog forced a
-            // recheck.
-            //
-            // An output-TIMESTAMP discriminator ("has any PTY byte arrived since
-            // the resolve") was tried first and found insufficient: a live
-            // standalone repro showed kimi's own idle-screen chrome (status bar,
-            // context meter, blank-line repaint) advances lastNonEmptyOutputAt
-            // within ~300ms of the resolve even though NOTHING approval-relevant
-            // changed, so the guard stopped protecting almost immediately instead
-            // of for as long as the staleness actually persisted (observed 30s+).
-            //
-            // Reject a recapture only when ALL of: (a) this is the first capture
-            // since the last resolve (`!this.activeModal` — a genuinely repeated
-            // approval re-enters this branch too, since resolveModal always nulls
-            // activeModal), (b) the message text matches the one we just
-            // resolved, AND (c) the chrome-stripped approval-context signature
-            // (computeApprovalContentSignature — screen text with blank-line
-            // padding and manifest-declared chrome removed) is UNCHANGED from
-            // the signature captured at resolve time. (c) is the load-bearing,
-            // content-based condition, deliberately not time-bounded: it keeps
-            // rejecting for as long as nothing approval-relevant changes,
-            // regardless of how many chrome-only repaints occur or how much
-            // wall-clock time passes, and it stops rejecting the instant real
-            // new content (tool output, a fresh conversational turn) appears.
-            // This also keeps consecutive-approvals-with-identical-text (e.g.
-            // two back-to-back "Allow Bash command?" prompts) working correctly:
-            // a real follow-up approval necessarily means the CLI produced real
-            // new output first (running the previous tool, then asking again),
-            // which changes the signature regardless of shared message text.
-            const isStaleResolvedRepaint = !this.activeModal && this.isStaleResolvedApproval(modal, snap);
-            if (isStaleResolvedRepaint) {
-                LOG.debug('CLI', `[${this.provider.type}] ignoring stale re-parsed approval matching the just-resolved modal (approval-context signature unchanged)`);
-                return;
-            }
             this.modalLostAt = 0;
             this.isWaitingForResponse = true;
             this.setStatus('waiting_approval', 'script_detect');
@@ -1387,92 +1256,6 @@ export class CliStateEngine {
 
     // ─── Helpers ────────────────────────────────────────────────────────────
 
-    /**
-     * Derive a stable approval-context signature from the current screen,
-     * with blank-line padding and any manifest-declared chrome stripped out.
-     *
-     * Generic by design — no kimi- or provider-specific hardcoding: it reads
-     * whatever `tui.transcriptPty.chromePatterns` and `tui.spinner.patterns`
-     * the ACTIVE provider's own manifest already declares (present on any
-     * declarative-TUI provider; simply absent/empty for scripted providers,
-     * in which case this degrades to blank-line stripping only — never worse
-     * than comparing the raw screen). Those pattern lists exist precisely to
-     * name "known volatile repaint noise" (status bar, context meter, spinner
-     * ticks, banners) — reusing them here means the SAME declared knowledge
-     * that governs transcript-chrome stripping also governs staleness
-     * detection, instead of re-encoding provider knowledge into daemon-core.
-     *
-     * Deliberately NOT a hash of the whole screen/buffer: an ordinary TUI
-     * repaints its footer/status/context-meter chrome continuously even while
-     * genuinely idle, so a raw whole-screen or whole-buffer fingerprint (or a
-     * mere "did any bytes arrive" timestamp) changes on every repaint tick
-     * regardless of whether anything approval-relevant actually happened.
-     * Stripping the declared chrome first yields a signature that only
-     * changes when the surrounding conversation/tool-output content itself
-     * changes — exactly the discriminator applyWaitingApproval's
-     * isStaleResolvedRepaint check needs.
-     */
-    private computeApprovalContentSignature(snap: ApprovalSignatureSnapshot): string {
-        const screenText = snap.screenText || snap.accumulatedBuffer || '';
-        if (!screenText) return '';
-        const tui = (this.provider as { tui?: Record<string, any> }).tui;
-        const patternSpecs: Array<{ regex?: unknown; flags?: unknown }> = [
-            ...(Array.isArray(tui?.transcriptPty?.chromePatterns) ? tui!.transcriptPty.chromePatterns : []),
-            ...(Array.isArray(tui?.spinner?.patterns) ? tui!.spinner.patterns : []),
-        ];
-        const chromeRegexes: RegExp[] = [];
-        for (const spec of patternSpecs) {
-            if (spec && typeof spec.regex === 'string') {
-                try {
-                    chromeRegexes.push(new RegExp(spec.regex, typeof spec.flags === 'string' ? spec.flags : ''));
-                } catch {
-                    // Ignore an unparseable manifest regex — signature just skips that filter.
-                }
-            }
-        }
-        const kept: string[] = [];
-        for (const rawLine of screenText.split('\n')) {
-            const line = rawLine.trim();
-            if (!line) continue; // strip blank-line repaint padding
-            if (chromeRegexes.some((re) => re.test(line))) continue; // strip declared chrome
-            kept.push(line);
-        }
-        return kept.join('\n');
-    }
-
-    /**
-     * True when `modal` is a stale re-parse of an already-resolved approval:
-     * same message text, and the chrome-stripped approval-context signature
-     * of `snap` is unchanged from the signature captured at resolve time.
-     *
-     * Public and reused verbatim by BOTH the settled-eval capture path
-     * (applyWaitingApproval, below) and any OUTSIDE re-parse the adapter
-     * performs independently of the settle loop — e.g. provider-cli-adapter's
-     * getStatus()/getDebugState() startup-gate modal detection, which reads
-     * `recentOutputBuffer` directly while `startupParseGate` is open and can
-     * re-surface the same already-resolved modal before the gate closes.
-     * Centralizing the discriminator here means there is exactly ONE
-     * definition of "stale" for the whole session — no divergent duplicate
-     * heuristic re-implemented per call site.
-     */
-    isStaleResolvedApproval(modal: { message: string; buttons: string[] } | null, snap: ApprovalSignatureSnapshot): boolean {
-        if (!modal) return false;
-        const normalizedMessage = typeof modal.message === 'string' ? modal.message.trim() : '';
-        if (!normalizedMessage) return false;
-        return this.lastApprovalResolvedAt > 0
-            && normalizedMessage === this.lastResolvedModalMessage
-            && this.computeApprovalContentSignature(snap) === this.lastApprovalResolvedContentSignature;
-    }
-
-    /** Clear all resolve-time approval bookkeeping (message, timestamp, content
-     *  signature) — called at turn/session boundaries so a next-turn or
-     *  next-session approval is never compared against stale prior state. */
-    private clearApprovalResolutionMemory(): void {
-        this.lastApprovalResolvedAt = 0;
-        this.lastResolvedModalMessage = '';
-        this.lastApprovalResolvedContentSignature = '';
-    }
-
     /**
      * Schedule one more settled evaluation while pinned to `waiting_approval`
      * with no actionable modal. The settled FSM normally only re-runs on new

package/src/cli-adapters/provider-cli-adapter.ts

@@ -39,7 +39,6 @@ import {
     compactPromptText,
     estimatePromptDisplayLines,
     extractPromptRetrySnippet,
-    isPurePtyTranscriptProvider,
     listCliScriptNames,
     normalizePromptText,
     normalizeScreenSnapshot,
@@ -457,7 +456,12 @@ export class ProviderCliAdapter implements CliAdapter {
      * provider-owned) so no other provider's turn-scoped parse changes.
      */
     private parsesFullPtyTranscriptFromBuffer(): boolean {
-        return isPurePtyTranscriptProvider(this.provider);
+        if (this.providerOwnsTranscript()) return false;
+        // nativeHistory is a top-level provider field not surfaced on
+        // CliProviderModule; read it via the same structural cast used for `tui`.
+        if ((this.provider as { nativeHistory?: unknown }).nativeHistory) return false;
+        const transcriptPty = (this.provider.tui as { transcriptPty?: { scope?: unknown } } | undefined)?.transcriptPty;
+        return transcriptPty?.scope === 'buffer';
     }
 
     /**
@@ -703,10 +707,8 @@ export class ProviderCliAdapter implements CliAdapter {
             }
         });
 
-        this.ptyProcess.onExit(({ exitCode, signal }: { exitCode: number | null; signal?: number | null }) => {
-            // Preserve the unknown case: a null exitCode (signal-terminated or
-            // otherwise unreported) is logged as "unknown", never as exit 0.
-            LOG.info('CLI', `[${this.cliType}] Exit code ${exitCode === null || exitCode === undefined ? 'unknown' : exitCode}${signal ? ` (signal ${signal})` : ''}`);
+        this.ptyProcess.onExit(({ exitCode }: { exitCode: number }) => {
+            LOG.info('CLI', `[${this.cliType}] Exit code ${exitCode}`);
             this.flushPendingOutputParse();
             this.ptyProcess = null;
             this.engine.onPtyExit();
@@ -1070,19 +1072,7 @@ export class ProviderCliAdapter implements CliAdapter {
 
     getStatus(options: { allowParse?: boolean } = {}): CliSessionStatus {
         const allowParse = options.allowParse !== false;
-        let startupModal = allowParse && this.startupParseGate ? this.runParseApproval(this.recentOutputBuffer) : null;
-        // (fix: kimi startup-gate stale-approval bypass) startupParseGate can
-        // still be open by the time a real approval is requested AND resolved
-        // — this ad-hoc parse of recentOutputBuffer runs independently of the
-        // settled-eval loop and previously had no staleness protection at all,
-        // so it kept re-surfacing the identical already-resolved modal for as
-        // long as its text remained anywhere in the rolling buffer, bypassing
-        // engine.activeModal (which resolveModal() had already correctly
-        // cleared). Reuse the SAME discriminator the settle loop uses instead
-        // of inventing a second one here.
-        if (startupModal && this.engine.isStaleResolvedApproval(startupModal, { screenText: this.terminalScreen.getText(), accumulatedBuffer: this.accumulatedBuffer })) {
-            startupModal = null;
-        }
+        const startupModal = allowParse && this.startupParseGate ? this.runParseApproval(this.recentOutputBuffer) : null;
         const startupDetectedStatus = allowParse && this.startupParseGate && !startupModal
             ? this.runDetectStatus(this.recentOutputBuffer || this.terminalScreen.getText())
             : null;
@@ -1189,20 +1179,7 @@ export class ProviderCliAdapter implements CliAdapter {
                 // and let a later evaluate find the complete modal.
                 const buttonsOk = liveModal && Array.isArray(liveModal.buttons)
                     && liveModal.buttons.some((b: any) => typeof b === 'string' && b.trim());
-                // (fix: kimi live-detect stale-approval bypass) This fallback is
-                // NOT gated by startupParseGate — it runs on every getStatus()
-                // call (including the periodic background status heartbeat)
-                // for as long as isWaitingForResponse stays true, which for a
-                // provider that keeps "thinking" after the approved tool call
-                // can be the whole rest of the turn. Its own unguarded re-parse
-                // of recentOutputBuffer/terminalScreen previously kept
-                // re-writing engine.activeModal directly — bypassing setStatus
-                // (so rawStatus never even flipped) and bypassing
-                // applyWaitingApproval's staleness guard entirely, silently
-                // re-corrupting the engine's own state moments after
-                // resolveModal() had correctly cleared it. Reuse the same
-                // engine-owned discriminator here too.
-                if (liveModal && buttonsOk && !this.engine.isStaleResolvedApproval(liveModal, { screenText: this.terminalScreen.getText(), accumulatedBuffer: this.accumulatedBuffer })) {
+                if (liveModal && buttonsOk) {
                     effectiveModal = liveModal;
                     if (!this.engine.activeModal) this.engine.activeModal = liveModal;
                 }
@@ -2497,14 +2474,7 @@ export class ProviderCliAdapter implements CliAdapter {
 
     getDebugState(): Record<string, any> {
         const screenText = sanitizeTerminalText(this.terminalScreen.getText());
-        let startupModal = this.startupParseGate ? this.runParseApproval(this.recentOutputBuffer) : null;
-        // (fix: kimi startup-gate stale-approval bypass) See the matching
-        // comment in getStatus() — this ad-hoc startup-gate parse bypassed
-        // engine.activeModal's staleness protection entirely. Reuse the same
-        // engine-owned discriminator rather than duplicating it here.
-        if (startupModal && this.engine.isStaleResolvedApproval(startupModal, { screenText: this.terminalScreen.getText(), accumulatedBuffer: this.accumulatedBuffer })) {
-            startupModal = null;
-        }
+        const startupModal = this.startupParseGate ? this.runParseApproval(this.recentOutputBuffer) : null;
         const startupDetectedStatus = this.startupParseGate && !startupModal
             ? this.runDetectStatus(this.recentOutputBuffer || screenText)
             : null;

package/src/cli-adapters/provider-cli-shared.ts

@@ -254,47 +254,6 @@ export interface CliProviderModule {
     _versionWarning?: string | null;
 }
 
-/**
- * PURE-PTY TRANSCRIPT CLASS predicate (kimi and kin).
- *
- * A provider is "pure-PTY full-buffer" when it reconstructs its ENTIRE transcript
- * from the rendered PTY buffer on every read and has NO alternate transcript
- * source:
- *   - transcriptAuthority !== 'provider'  (the daemon PTY parser owns the transcript,
- *     not a provider-side canonical source)
- *   - NO nativeHistory              (no on-disk / native-source history to fall back to)
- *   - tui.transcriptPty.scope === 'buffer' (the parser walks the full rendered buffer)
- *
- * This class is invisible to two provider-authority-keyed code paths that other
- * providers rely on for mesh completion semantics:
- *   1. CliStateEngine.onTurnStarted only promotes to 'generating' for
- *      transcriptAuthority==='provider' providers — so a pure-PTY session that
- *      submits a prompt while already idle collapses idle→idle, the
- *      generating→idle edge never occurs, and agent:generating_completed is never
- *      emitted (the coordinator ledger leaves the task 'assigned' forever).
- *   2. checkMeshWorkerStall's native-transcript completion reconcile is gated on
- *      the native-source shape, so a finished pure-PTY worker's static idle is
- *      misread as monitor:no_progress (a false task_stalled).
- *
- * The runtime capability, NOT any single spec field value, is authoritative: a
- * given kimi manifest checkout may declare nativeHistory/transcriptAuthority, but
- * the live-loaded pure-PTY session has none. Callers that only hold a
- * CliProviderModule (the engine) share this exact predicate with the adapter
- * (parsesFullPtyTranscriptFromBuffer) so the two never drift.
- */
-export function isPurePtyTranscriptProvider(provider: {
-    transcriptAuthority?: 'provider' | 'daemon';
-    nativeHistory?: unknown;
-    tui?: Record<string, unknown>;
-}): boolean {
-    if (provider.transcriptAuthority === 'provider') return false;
-    // nativeHistory is a top-level provider field not surfaced on
-    // CliProviderModule; read it via the same structural shape the adapter uses.
-    if (provider.nativeHistory) return false;
-    const transcriptPty = (provider.tui as { transcriptPty?: { scope?: unknown } } | undefined)?.transcriptPty;
-    return transcriptPty?.scope === 'buffer';
-}
-
 function stripAnsi(str: string): string {
     // eslint-disable-next-line no-control-regex
     return str

package/src/cli-adapters/pty-transport.d.ts

@@ -37,8 +37,7 @@ export interface PtyRuntimeTransport {
     getMetadata?(): PtyRuntimeMetadata | null;
     onData(callback: (data: string) => void): void;
     onExit(callback: (info: {
-        exitCode: number | null;
-        signal?: number | null;
+        exitCode: number;
     }) => void): void;
 }
 export interface PtyTransportFactory {

package/src/cli-adapters/pty-transport.ts

@@ -62,7 +62,7 @@ export interface PtyRuntimeTransport {
   updateMeta?(meta: Record<string, unknown>, replace?: boolean): void;
   getMetadata?(): PtyRuntimeMetadata | null;
   onData(callback: (data: string) => void): void;
-  onExit(callback: (info: { exitCode: number | null; signal?: number | null }) => void): void;
+  onExit(callback: (info: { exitCode: number }) => void): void;
 }
 
 export interface PtyTransportFactory {

package/src/cli-adapters/session-host-transport.ts

@@ -42,7 +42,7 @@ class SessionHostRuntimeTransport implements PtyRuntimeTransport {
 
     private readonly client: SessionHostClient;
     private readonly dataCallbacks = new Set<(data: string) => void>();
-    private readonly exitCallbacks = new Set<(info: { exitCode: number | null; signal?: number | null }) => void>();
+    private readonly exitCallbacks = new Set<(info: { exitCode: number }) => void>();
     private readonly pendingOutput: string[] = [];
     private operationChain = Promise.resolve();
     private unsubscribe: (() => void) | null = null;
@@ -79,7 +79,7 @@ class SessionHostRuntimeTransport implements PtyRuntimeTransport {
         }
     }
 
-    onExit(callback: (info: { exitCode: number | null; signal?: number | null }) => void): void {
+    onExit(callback: (info: { exitCode: number }) => void): void {
         this.exitCallbacks.add(callback);
     }
 
@@ -361,13 +361,8 @@ class SessionHostRuntimeTransport implements PtyRuntimeTransport {
             return;
         }
         if (event.type === 'session_exit') {
-            // Preserve the nullable/unknown exitCode and signal exactly as the
-            // session host reported them — never collapse null to 0, which would
-            // make a signal-terminated process indistinguishable from a clean exit.
-            const exitCode = typeof event.exitCode === 'number' ? event.exitCode : null;
-            const signal = typeof event.signal === 'number' ? event.signal : null;
             for (const callback of this.exitCallbacks) {
-                callback({ exitCode, signal });
+                callback({ exitCode: event.exitCode ?? 0 });
             }
             void this.closeClient(false);
         }