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

package/dist/mesh/coordinator-prompt.d.ts

@@ -68,41 +68,6 @@ export interface CoordinatorOperatingNote {
     category?: 'provider_quirk' | 'pattern_to_avoid' | 'recovery_lesson';
     createdAt?: string;
     sourceCoordinator?: string;
-    /**
-     * Operating-notes lifecycle (minimal first cut). When true the note ALWAYS
-     * rides into the coordinator prompt — it is never dropped by TTL expiry and
-     * survives the injection cap ahead of unpinned notes. Legacy notes without
-     * this field default to false.
-     */
-    pinned?: boolean;
-    /**
-     * Optional explicit expiry ISO timestamp. When set and in the past, an
-     * UNPINNED note is dropped from the injected prompt (read-side only — the
-     * ledger entry is never pruned by age). When absent, the category→TTL map
-     * (see isNoteExpired) governs expiry; pinned notes never expire regardless.
-     */
-    expiresAt?: string;
-    /**
-     * Phase 2 — the ledger id of this note, when known. Threaded from the ledger
-     * entry id at launch so version-supersede can target a specific note and
-     * same-class folding can list the subsumed ids. Repo-declared notes may lack
-     * one; absent is fine (folding/supersede fall back to the subject key).
-     */
-    noteId?: string;
-    /**
-     * Phase 2 (b) version-supersede — an optional note-id or stable subject-key
-     * this note replaces. At injection, any earlier LIVE note whose `noteId` or
-     * `subjectKey` matches this value is hidden from the prompt (the ledger entry
-     * is retained for audit). Optional and lossless: absent = supersedes nothing.
-     */
-    supersedes?: string;
-    /**
-     * Phase 2 (b)/(c) — an optional stable subject-key grouping notes about the
-     * same subject. Drives version-supersede targeting and same-class folding.
-     * When absent, folding derives a key from a leading `[tag]` bracket instead,
-     * so legacy notes still collapse by their conventional tag prefix.
-     */
-    subjectKey?: string;
 }
 export interface CoordinatorPromptContext {
     mesh: LocalMeshEntry;
@@ -137,46 +102,6 @@ export interface CoordinatorPromptContext {
     magiKindPanels?: MagiKindPanelMap;
 }
 export declare function buildCoordinatorSystemPrompt(ctx: CoordinatorPromptContext): string;
-/**
- * Phase 2 (c) — deterministic same-class fold. Given ranked notes (already
- * highest-priority first), collapse runs of UNPINNED notes that share the same
- * category AND subject key into a single injected entry: keep the highest-ranked
- * (first-seen) note and record the note-ids/count it subsumes so the rendered
- * line can say "(+N earlier)". Pinned notes never fold — each pinned note is
- * author-opted-in and shown verbatim. The store is untouched; this is a pure,
- * model-free text fold at injection time.
- *
- * Returns the folded note list (order preserved) with per-entry subsumed info.
- */
-interface FoldedNote {
-    note: CoordinatorOperatingNote;
-    /** note-ids of same-class notes this entry subsumes (may be empty). */
-    subsumedIds: string[];
-    /** count of subsumed notes (== subsumedIds.length, but counts id-less ones too). */
-    subsumedCount: number;
-}
-/**
- * Operating-notes lifecycle selection (read-side). Given the effective notes
- * (oldest-first, ledger order) and the current time, produce the ordered list
- * that rides into the prompt:
- *   (i)    ALWAYS include pinned notes.
- *   (ii)   drop expired UNPINNED notes (per category TTL / explicit expiresAt).
- *   (iii)  Phase 2 (b) drop any note SUPERSEDED by a later live note (by noteId
- *          or subjectKey); pinned notes are never dropped by supersede.
- *   (iv)   rank pinned-first, then durable-category, then recency (newest first).
- *   (v)    Phase 2 (c) fold same-category/same-subject unpinned runs into one.
- *   (vi)   Phase 2 (d) fill up to a byte budget AND a count cap; pinned always
- *          kept even if they alone exceed the byte budget.
- * Pure + deterministic given `now`. Returns { shown, omittedCount } where `shown`
- * carries per-entry fold info for the renderer.
- *
- * Ranking is stable on the original ledger index so, within a tier, newest notes
- * lead. The caps keep the leading (highest-priority) entries.
- */
-export declare function selectOperatingNotesForPrompt(notes: CoordinatorOperatingNote[], now: number, cap?: number, byteBudget?: number): {
-    shown: FoldedNote[];
-    omittedCount: number;
-};
 /**
  * Render the machine-local MAGI kind-panel bindings so the coordinator KNOWS
  * which cross-verification panels (rca / design / claim_audit / freeform) are
@@ -189,4 +114,3 @@ export declare function selectOperatingNotesForPrompt(notes: CoordinatorOperatin
  * That keeps a MAGI-less mesh's prompt byte-identical to before.
  */
 export declare function buildMagiKindPanelsSection(panels: MagiKindPanelMap | undefined | null): string | null;
-export {};

package/dist/mesh/mesh-active-work.d.ts

@@ -1,7 +1,7 @@
 import type { MeshLedgerEntry } from './mesh-ledger.js';
 import type { MeshWorkQueueEntry, DirectDispatchRecord } from './mesh-work-queue.js';
 export type MeshActiveWorkSource = 'queue' | 'direct';
-export type MeshActiveWorkStatus = 'pending' | 'assigned' | 'generating' | 'idle' | 'failed' | 'awaiting_approval' | 'awaiting_choice';
+export type MeshActiveWorkStatus = 'pending' | 'assigned' | 'generating' | 'idle' | 'failed' | 'awaiting_approval';
 export interface MeshActiveWorkRecord {
     taskId: string;
     source: MeshActiveWorkSource;

package/dist/mesh/mesh-ledger.d.ts

@@ -15,7 +15,7 @@
 import { EventEmitter } from 'events';
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
 import { type MeshLedgerOriginatingCoordinatorV2 } from './contracts.js';
-export type MeshLedgerKind = 'task_dispatched' | 'task_completed' | 'task_failed' | 'task_stalled' | 'task_approval_needed' | 'task_question_pending' | 'p2p_dispatch_failed' | 'session_launched' | 'session_auto_launch' | 'session_stopped' | 'checkpoint_created' | 'node_cloned' | 'node_joined' | 'node_removed' | 'coordinator_started' | 'recovery_attempted' | 'ledger_replicated' | 'ledger_reconciled' | 'direct_fast_forward' | 'delivery_unroutable' | 'direct_dispatch_pruned' | 'event_held' | 'event_held_requeued' | 'task_reclaimed' | 'coordinator_operating_note' | 'coordinator_operating_note_tombstone' | 'mission_created' | 'mission_status_changed' | 'mission_goal_updated' | 'magi_dispatched' | 'magi_synthesis' | 'key_injection' | 'worktree_cleanup_candidate';
+export type MeshLedgerKind = 'task_dispatched' | 'task_completed' | 'task_failed' | 'task_stalled' | 'task_approval_needed' | 'p2p_dispatch_failed' | 'session_launched' | 'session_auto_launch' | 'session_stopped' | 'checkpoint_created' | 'node_cloned' | 'node_joined' | 'node_removed' | 'coordinator_started' | 'recovery_attempted' | 'ledger_replicated' | 'ledger_reconciled' | 'direct_fast_forward' | 'delivery_unroutable' | 'direct_dispatch_pruned' | 'event_held' | 'event_held_requeued' | 'task_reclaimed' | 'coordinator_operating_note' | 'coordinator_operating_note_tombstone' | 'mission_created' | 'mission_status_changed' | 'mission_goal_updated' | 'magi_dispatched' | 'magi_synthesis' | 'key_injection';
 export interface MeshLedgerEntry {
     id: string;
     meshId: string;
@@ -162,33 +162,6 @@ export declare const OPERATING_NOTE_KIND: MeshLedgerKind;
 export declare const OPERATING_NOTE_TOMBSTONE_KIND: MeshLedgerKind;
 export declare const OPERATING_NOTE_DEDUPE_WINDOW = 40;
 export declare const OPERATING_NOTE_KEEP_LATEST = 100;
-export declare const OPERATING_NOTE_CATEGORY_TTL_DAYS: Readonly<Record<string, number>>;
-/**
- * Shape isNoteExpired reads. Structural so mesh-ledger stays free of a
- * coordinator-prompt import (CoordinatorOperatingNote satisfies this).
- */
-export interface OperatingNoteExpiryInput {
-    category?: string;
-    pinned?: boolean;
-    createdAt?: string;
-    /** Explicit expiry override; wins over the category TTL when parseable. */
-    expiresAt?: string;
-    /** Fallback creation time (ledger entry timestamp) when createdAt absent. */
-    timestamp?: string;
-}
-/**
- * Pure helper: is this UNPINNED operating note expired as of `now` (epoch ms)?
- *
- * Rules:
- *  - pinned notes NEVER expire (always false).
- *  - an explicit, parseable `expiresAt` in the past → expired.
- *  - otherwise the category TTL applies; a durable category (provider_quirk,
- *    uncategorized, or any category not in the TTL map) never expires.
- *  - age is measured from createdAt, falling back to `timestamp` (ledger entry
- *    time). If neither is a valid date, the note is treated as NOT expired
- *    (never silently drop a note we cannot age).
- */
-export declare function isNoteExpired(note: OperatingNoteExpiryInput, now: number): boolean;
 export declare function getLedgerDir(): string;
 /**
  * Footer to append to worker task messages so workers output structured results

package/dist/mesh/mesh-node-identity.d.ts

@@ -107,29 +107,6 @@ export declare function resolveEffectiveMeshNodeHealth(node: any): string;
  * replica that can never run.
  */
 export declare function isMeshNodeHealthLaunchable(node: any): boolean;
-/**
- * Launch FRESHNESS gate — distinct from the health gate above.
- *
- * `deriveMeshNodeHealthFromGit` reports a clean-tree node with `behind > 0` as
- * 'online', so the health gate (isMeshNodeHealthLaunchable) happily lets a STALE
- * node — one whose branch is N commits behind its upstream — win auto-launch fitness
- * routing and run a fresh worker against out-of-date code. `behind` is deliberately
- * NOT folded into deriveMeshNodeHealthFromGit because "behind" is not universally
- * unhealthy (the MAGI planner and other callers share that resolver); it is only
- * unhealthy for *spawning new work*. This gate encodes exactly that launch-time axis.
- *
- * Returns false (NOT fresh → skip / de-rank) only when git telemetry is PRESENT and
- * proves staleness:
- *   - behind count exceeds `maxBehind` (default 0 — any behind blocks), OR
- *   - a submodule is out of sync (gitlink points off upstream — cannot be caught up
- *     by a simple worktree ff and would launch against a mismatched submodule).
- *
- * When telemetry is absent it returns true (fresh), preserving the online/unknown-pass
- * philosophy: we never block on missing data, only on data that proves the node stale.
- */
-export declare function isMeshNodeFreshEnoughToLaunch(node: any, opts?: {
-    maxBehind?: number;
-}): boolean;
 export declare function applyInlineMeshBranchConvergence(mesh: any, node: any, status: Record<string, unknown>): void;
 export declare function summarizeInlineMeshBranchConvergence(nodes: Array<Record<string, unknown>>): Record<string, unknown>;
 export declare function readCachedInlineMeshActiveSessions(node: any): string[];

package/dist/mesh/mesh-refine-gates.d.ts

@@ -504,95 +504,6 @@ type GitlinkTrivialFastForwardEvaluation = {
  * gate.
  */
 export declare function collectFastForwardGitlinkPaths(repoRoot: string, baseHead: string, branchHead: string): string[];
-export type SubmoduleGitlinkConvergeResult = {
-    /** True when at least one diverged gitlink submodule was rebased onto its base-side commit. */
-    converged: boolean;
-    /**
-     * Set when convergence was declined/aborted (fail-safe → caller keeps the
-     * original defer→blocked_review path). One of:
-     *   no_changed_gitlinks — no gitlink differs base↔branch
-     *   not_diverged        — the gitlink is ff/behind/equal (gate handles it)
-     *   rebase_conflict     — replaying branch-side onto base-side hit a real
-     *                         content conflict inside the submodule (aborted)
-     */
-    reason?: string;
-    /**
-     * Converged gitlinks: path → the rebased submodule commit (SUBNEW) that the
-     * root rebase must resolve the gitlink conflict to. Only populated for paths
-     * whose submodule was successfully rebased (base-side is now a strict ancestor).
-     */
-    resolutions: Array<{
-        path: string;
-        baseCommit: string;
-        branchCommit: string;
-        rebasedCommit: string;
-    }>;
-    /** Per-path outcome for observability/logging. */
-    gitlinks: Array<{
-        path: string;
-        baseCommit?: string;
-        branchCommit?: string;
-        rebasedCommit?: string;
-        action: 'rebased' | 'skipped_not_diverged' | 'rebase_conflict';
-    }>;
-};
-/**
- * STEP 1 of auto-converging diverged oss-style submodule gitlinks: rebase the
- * branch-side submodule commit(s) onto the base-side submodule commit INSIDE the
- * worktree's submodule checkout (detached HEAD), so the base-side commit becomes a
- * strict ancestor of the rebased tip. Returns the rebased commit per path so the
- * caller's root rebase can resolve the gitlink conflict to it (STEP 2, see
- * {@link rootRebaseResolvingGitlinks}). This automates the documented manual
- * strict-fast-forward bypass and keeps the landed submodule history linear rather
- * than masking a divergence.
- *
- * Fail-safe by construction: it only touches gitlinks that are a genuine sibling
- * divergence (both commits local, neither an ancestor of the other, shared merge
- * base). A submodule rebase content conflict aborts, restores the branch-side
- * checkout, and returns `converged:false` (caller keeps defer→blocked_review). It
- * never commits the root and NEVER pushes — remote publish is the merge/
- * reachability stage's job; this stage is local reconciliation only.
- *
- * @param worktreeRoot the branch worktree root (its `<path>` submodule checkout is rebased)
- * @param baseRepoRoot the source/base repo root (reads the base-side gitlink commit)
- * @param baseHead     the fetched base head (root ref) — source of base-side gitlink commits
- * @param branchHead   the worktree branch head (root ref) — source of branch-side gitlink commits
- */
-export declare function convergeDivergedSubmoduleGitlinks(worktreeRoot: string, baseRepoRoot: string, baseHead: string, branchHead: string): SubmoduleGitlinkConvergeResult;
-export type RootRebaseGitlinkResolveResult = {
-    /** True when the root rebase completed (with gitlink conflicts resolved to the converged commits). */
-    ok: boolean;
-    /** New root HEAD after the rebase (only meaningful when ok). */
-    branchHead?: string;
-    /**
-     * Set when the rebase was aborted (fail-safe). One of:
-     *   non_gitlink_conflict — a conflict on a non-submodule path (genuine content conflict)
-     *   unexpected_gitlink   — a gitlink conflicted that we have no converged commit for
-     *   rebase_error         — the rebase failed for a non-conflict reason
-     */
-    reason?: string;
-    /** The paths that conflicted at the point of abort (for diagnostics). */
-    conflictPaths?: string[];
-};
-/**
- * STEP 2 of auto-converging diverged submodule gitlinks: rebase the worktree root
- * branch onto `baseHead`, resolving each submodule-gitlink conflict to the
- * pre-converged commit from {@link convergeDivergedSubmoduleGitlinks}. git's
- * recursive merge refuses to auto-merge a diverged gitlink ("Recursive merging
- * with submodules currently only supports trivial cases"), so we drive the rebase
- * ourselves: on each stop, if the ONLY unmerged paths are gitlinks we have a
- * converged commit for, we stage those to the converged commit and `--continue`.
- * Any non-gitlink conflict (or a gitlink with no converged commit) aborts the
- * rebase and returns `ok:false` → caller keeps the defer→blocked_review path.
- *
- * On success the base-side gitlink is a strict ancestor of the resolved branch-side
- * commit, so the downstream patch-equivalence gate treats it as a trivial
- * fast-forward and passes.
- */
-export declare function rootRebaseResolvingGitlinks(worktreeRoot: string, baseHead: string, resolutions: Array<{
-    path: string;
-    rebasedCommit: string;
-}>): RootRebaseGitlinkResolveResult;
 /**
  * Decide whether a merge-tree submodule conflict between base and branch is a
  * trivial gitlink fast-forward (and nothing else).

package/dist/mesh/mesh-remote-event-pull.d.ts

@@ -1,9 +1,6 @@
 import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
 import type { LocalMeshEntry } from '../repo-mesh-types.js';
 export declare function pullRemoteNodeQueues(components: DaemonComponents, mesh: LocalMeshEntry, localDaemonId: string | undefined, candidateDaemonIds: string[]): Promise<void>;
-export declare function pullPendingEventsFromNode(components: DaemonComponents, meshId: string, node: {
-    daemonId?: string;
-}, localDaemonId: string | undefined, candidateDaemonIds: string[], pulls: Array<Record<string, unknown>>): Promise<void>;
 export declare function unwrapReadChatPayload(raw: unknown): Record<string, unknown> | null;
 export declare function readChatPayloadStatus(payload: Record<string, unknown> | null): string;
 export declare function realTerminalEmitPendingForTask(meshId: string, taskId: string): boolean;

package/dist/mesh/mesh-runtime-store.d.ts

@@ -23,17 +23,6 @@ export declare class MeshRuntimeStore {
     private static loggedGetInstanceFailure;
     static getInstance(): MeshRuntimeStore;
     static resetForTests(): void;
-    /**
-     * VACUUM the SQLite database to reclaim on-disk space. Retention prunes rows
-     * with DELETE, which frees pages inside the file but does NOT shrink it — the
-     * mesh-runtime.db grew to hundreds of MB (mission 86def38d disk-accumulation
-     * bootstrap failure) precisely because the file was never compacted. This
-     * rewrites the DB into a minimal footprint. Best-effort: a VACUUM failure (e.g.
-     * insufficient temp space, a read lock) is logged and swallowed so it can never
-     * block daemon shutdown. Called once on shutdown (see daemon-lifecycle), never
-     * on the hot path — VACUUM takes an exclusive lock and rewrites the whole file.
-     */
-    vacuum(): void;
     close(): void;
     transaction<T>(fn: () => T): T;
     private migrate;

package/dist/mesh/mesh-work-queue.d.ts

@@ -337,15 +337,7 @@ export type DependencyFailurePolicy = 'block' | 'cancel';
  * Update the status of a specific task.
  * Used when a session completes, fails, or stalls.
  */
-export declare function updateTaskStatus(meshId: string, taskId: string, status: MeshTaskStatus, opts?: {
-    /**
-     * CANCEL-STICKY-TERMINAL: operator/system override to permit a terminal→non-terminal
-     * transition (e.g. an explicit operator reopen). Without this, a write that would flip
-     * a `completed`/`failed`/`cancelled` row back to `pending`/`assigned` is refused as a
-     * no-op. Terminal→terminal and any transition FROM a non-terminal state are unaffected.
-     */
-    force?: boolean;
-} & MeshQueueMutationOptions): MeshWorkQueueEntry | null;
+export declare function updateTaskStatus(meshId: string, taskId: string, status: MeshTaskStatus, opts?: MeshQueueMutationOptions): MeshWorkQueueEntry | null;
 export declare function recordTaskAutoLaunch(meshId: string, taskId: string, autoLaunch: Omit<NonNullable<MeshWorkQueueEntry['autoLaunch']>, 'updatedAt'>): MeshWorkQueueEntry | null;
 /**
  * Mark a queue task as manually cancelled without deleting audit history.
@@ -353,21 +345,6 @@ export declare function recordTaskAutoLaunch(meshId: string, taskId: string, aut
 export declare function cancelTask(meshId: string, taskId: string, opts?: {
     reason?: string;
 } & MeshQueueMutationOptions): MeshWorkQueueEntry | null;
-/**
- * CANCEL-STICKY-TERMINAL: the assignment a task carried at cancel time, handed to the cancel
- * command handler so it can stop the bound worker. cancelTask runs in the pure queue-store
- * module (no DaemonComponents), so it records the binding here and the handler drains it.
- */
-export interface CancelledTaskAssignment {
-    sessionId: string;
-    nodeId?: string;
-    providerType?: string;
-}
-/**
- * Read-and-clear the assignment a just-cancelled task was bound to. Returns undefined when the
- * cancelled task had no live assignment (nothing to stop). One-shot: the entry is deleted on read.
- */
-export declare function takeCancelledTaskAssignment(meshId: string, taskId: string): CancelledTaskAssignment | undefined;
 /**
  * Return a queue task to pending for retry. By default, dead session targeting
  * and assigned ownership are cleared so stale assignments do not strand again.

package/dist/providers/chat-message-normalization.d.ts

@@ -58,28 +58,6 @@ export declare function extractFinalAssistantSummaryEvidence(messages: ChatMessa
  * grace gate) on top of this structural check.
  */
 export declare function selectFinalAssistantTurnEndMessage(messages: ChatMessage[] | null | undefined): ChatMessage | null;
-/**
- * EARLY-IDLE-COMPLETION-FALSE-POSITIVE — trailing tool/terminal activity detector.
- *
- * True when the transcript's LAST non-empty user-facing assistant bubble is followed
- * by one or more TOOL / TERMINAL activity bubbles (a tool_use/command the assistant
- * fired AFTER its text) — i.e. the assistant emitted a preamble ("Let me explore…"),
- * then started running Read/Grep, so the turn is still executing and its answer has
- * not landed. Callers that would otherwise promote that preamble to a turn-end summary
- * off a momentary (startup-grace / inter-tool) idle read use this as a veto.
- *
- * Deliberately NARROW so the pure-PTY completion rescue is preserved:
- *   - Only TOOL/TERMINAL activity trailing the assistant vetoes. A trailing THOUGHT or
- *     status bubble does NOT (a finished turn can end on an internal thought), matching
- *     selectFinalAssistantTurnEndMessage's skip set minus the "still-working" signals.
- *   - A genuinely FINISHED worker (final assistant last, no trailing tool activity —
- *     the kimi pure-PTY continuous-idle shape) returns false, so its early completion
- *     is untouched.
- *
- * Returns false when there is no final assistant bubble at all (the caller's
- * selectFinalAssistantTurnEndMessage already handles that as "not a turn end").
- */
-export declare function hasTrailingToolActivityAfterFinalAssistant(messages: ChatMessage[] | null | undefined): boolean;
 export declare const BUILTIN_CHAT_MESSAGE_KINDS: readonly ["standard", "thought", "tool", "terminal", "system"];
 export type BuiltinChatMessageKind = typeof BUILTIN_CHAT_MESSAGE_KINDS[number];
 export type ChatMessageKind = BuiltinChatMessageKind | (string & {});

package/dist/providers/cli-provider-instance-types.d.ts

@@ -19,7 +19,6 @@ export type CompletedFinalizationBlock = {
     terminal?: boolean;
     allowTimeout?: boolean;
     holdForTranscript?: boolean;
-    noExternalTranscriptSource?: boolean;
 };
 export type CompletionFinalAssistantEvidence = {
     present: boolean;
@@ -38,11 +37,8 @@ export type ExternalTranscriptProbe = {
 };
 export declare const COMPLETED_FINALIZATION_RETRY_MS = 1000;
 export declare const COMPLETED_FINALIZATION_MAX_WAIT_MS = 30000;
-export declare const CANON_C_MISSING_ASSISTANT_MIN_ELAPSED_MS = 20000;
 export declare const NATIVE_HISTORY_MESH_IDLE_SETTLE_MS = 4000;
 export declare const PTY_PARSED_FINAL_ASSISTANT_QUIET_DWELL_MS = 1200;
-export declare const ANTIGRAVITY_HOLD_QUIET_DWELL_MS = 3000;
-export declare const ANTIGRAVITY_HOLD_HARD_CAP_MS: number;
 export declare const BACKGROUND_TASK_HOLD_MAX_MS: number;
 export declare const USER_INPUT_ACK_DEDUP_WINDOW_MS = 60000;
 export declare const STARTUP_GRACE_IDLE_COLLAPSE_WINDOW_MS = 12000;

package/dist/providers/cli-provider-instance.d.ts

@@ -192,7 +192,6 @@ export declare class CliProviderInstance implements ProviderInstance {
     private meshStallEmittedForAnchor;
     private meshStallTurnActiveLast;
     private meshStallLastFiredAt;
-    private meshStallNativeTranscriptSample;
     private busyEpoch;
     private fastCollapseSynthesizedTaskId;
     private startupGraceCollapseAt;
@@ -202,7 +201,6 @@ export declare class CliProviderInstance implements ProviderInstance {
     private generatingDebounceTimer;
     private generatingDebouncePending;
     private lastApprovalEventFingerprint;
-    private lastInteractivePromptEventKey;
     private autoApproveBusy;
     private autoApproveBusyTimer;
     private lastAutoApprovalSignature;
@@ -425,7 +423,6 @@ export declare class CliProviderInstance implements ProviderInstance {
      * once at completion). Reset on the next turn's start.
      */
     private lastCompletionSummary;
-    private lastEmittedCompletion;
     private enforceFreshSessionLaunchIfNeeded;
     /**
      * BRAIN-ROUTING (runtime-control thinking axis): for a provider that selects
@@ -476,7 +473,6 @@ export declare class CliProviderInstance implements ProviderInstance {
     private completionFinalSummary;
     private buildCompletedFinalizationDiagnostic;
     private hasAdapterPendingResponse;
-    private antigravityHoldPtyStillActive;
     private shouldSuppressStaleParsedBusyStatus;
     private getCompletedFinalizationBlock;
     private hasApprovalResolutionEvidence;
@@ -576,76 +572,6 @@ export declare class CliProviderInstance implements ProviderInstance {
      * starts with a clean slate (a restart is not throttled by a prior stall).
      */
     private resetMeshStallEpisode;
-    /**
-     * KIMI-MESH-COMPLETION-EMIT (axis 1). For a native-source provider
-     * (transcriptAuthority=provider — its authoritative history is an on-disk
-     * transcript file, e.g. kimi's wire.jsonl), sample the transcript's current
-     * progress fingerprint (record count + source-file mtime) WITHOUT parsing the
-     * PTY. Used by the stall watchdog to distinguish "PTY render is quiet but the
-     * worker is still doing long tool work (transcript growing)" from a genuine
-     * wedge. Returns null for a pure-PTY provider (no native source) or when the
-     * source cannot be resolved this tick — the caller then falls back to the
-     * unchanged lastOutputAt-only judgment.
-     *
-     * Generalized on the provider's native-source flag, NOT a hardcoded provider
-     * type, so every current and future pure-PTY long-tool native-source provider
-     * benefits. Cheap enough for the stall path: it runs only at the stall threshold
-     * (≥180s of PTY stasis), never on the routine 5s tick.
-     */
-    private sampleNativeTranscriptProgress;
-    /**
-     * KIMI-MESH-COMPLETION-EMIT (axis 2). Last-chance completion emit for a mesh
-     * DELEGATED worker whose PTY has already exited (e.g. killed by a false stall)
-     * and is about to be auto-cleaned (cli-manager.startCliExitMonitor →
-     * removeInstance closes the event-emit window forever). If the worker actually
-     * FINISHED its assigned turn — its authoritative native transcript holds a final
-     * assistant message for the injected task — but the completion event never fired
-     * (the stall-kill happened before the FSM's idle transition), emit it now so the
-     * coordinator learns the task completed instead of waiting ~180s for the reconcile
-     * transcript-poll to reclaim it.
-     *
-     * Scope & guards (must all hold to emit):
-     *   • mesh worker session only — a normal standalone session's ordinary exit is
-     *     never synthesized (isMeshWorkerSession()).
-     *   • DOUBLE-EMIT guard — refuse if this turn's completion already fired
-     *     (lastEmittedCompletion matches the current taskId). A worker that completed
-     *     cleanly and is merely being cleaned up never double-emits.
-     *   • evidence gate — reuse the same final-assistant/turn-scoped summary machinery
-     *     as the normal completion path (completionFinalSummary over the native
-     *     transcript). No in-turn assistant summary ⇒ no proof of completion ⇒ leave
-     *     the reclaim path to handle a genuinely-unfinished worker.
-     *
-     * Returns true when a synthetic completion was emitted, false otherwise. Safe to
-     * call unconditionally from the cleanup path.
-     */
-    flushMeshCompletionBeforeCleanup(): boolean;
-    /**
-     * KIMI-PURE-PTY-COMPLETION-EMIT (Fix 3): stall-path completion reconcile for the
-     * PURE-PTY transcript class (kimi and kin — no native transcript, no provider
-     * authority; see isPurePtyTranscriptProvider). Such a worker whose
-     * generating_completed never emitted (the onTurnStarted idle→idle collapse Fix 1
-     * fixes at the source) sits at a STATIC idle prompt: its PTY output stops the
-     * instant the answer is rendered, so the status-agnostic no-progress watchdog
-     * (checkMeshWorkerStall) reads the finished-but-quiet session as a stall and would
-     * false-fire monitor:no_progress. The native-transcript reconcile
-     * (sampleNativeTranscriptProgress) does NOT cover this class (no native source →
-     * null sample), so the stall path needs its own guard.
-     *
-     * Called from checkMeshWorkerStall just before the fire. Returns true when the
-     * session is a finished pure-PTY turn — idle, no pending response, and a PTY-parsed
-     * in-turn final assistant summary — in which case it emits the missing
-     * generating_completed (idempotent: a real/late emit writes the terminal ledger and
-     * the coordinator's reconcile makes any duplicate a no-op) and the caller SUPPRESSES
-     * the stall. Returns false for every other class/state (native-source provider, a
-     * genuinely mid-turn or wedged worker with no final assistant), so a real stall still
-     * fires unchanged.
-     *
-     * Evidence bar is identical to flushMeshCompletionBeforeCleanup: injected task's turn
-     * genuinely started + an in-turn final assistant summary. Conservative by
-     * construction — no summary ⇒ no proof of completion ⇒ return false and let the real
-     * stall fire.
-     */
-    private tryReconcilePurePtyCompletionForStall;
     /**
      * AUTOAPPROVE-FLAP-RECUR (Fix A+B): how long a busy blip / modal scroll-out may
      * persist before the in-progress settle gate is torn down. For a delegated
@@ -810,11 +736,7 @@ export declare class CliProviderInstance implements ProviderInstance {
     getAdapter(): ProviderCliAdapter;
     get cliType(): string;
     get cliName(): string;
-    private resolveAutoApproveMode;
-    /** Legacy boolean view retained for internal/test compatibility. */
     private shouldAutoApprove;
-    private shouldUsePtyAutoApprove;
-    private resetPtyAutoApproveState;
     /** @see ProviderInstance.noteManualInteraction */
     noteManualInteraction(now?: number, opts?: {
         passive?: boolean;

package/dist/providers/contracts.d.ts

@@ -389,21 +389,6 @@ export interface ProviderCompatibilityEntry {
     ideVersion: string;
     scriptDir: string;
 }
-export type AutoApproveModeStrategy = 'pty-parse-default' | 'launch-args' | 'post-boot-command';
-export type AutoApproveModeRisk = 'safe' | 'caution' | 'dangerous';
-export interface AutoApproveMode {
-    id: string;
-    label: string;
-    strategy: AutoApproveModeStrategy;
-    risk: AutoApproveModeRisk;
-    warning?: string;
-    launchArgs?: string[];
-    removeArgs?: string[];
-}
-export interface AutoApproveModesConfig {
-    default: string;
-    modes: AutoApproveMode[];
-}
 export interface ProviderModule {
     /** Unique identifier (e.g. 'cline', 'cursor', 'gemini-cli') */
     type: string;
@@ -433,8 +418,6 @@ export interface ProviderModule {
     status?: string;
     /** Inventory/support detail string maintained in adhdev-providers */
     details?: string;
-    /** Provider-specific auto-approve choices and their launch/runtime strategy. */
-    autoApproveModes?: AutoApproveModesConfig;
     /** Install instructions (shown when command is missing) */
     install?: string;
     /** Custom version detection command (e.g. 'cursor --version', 'claude -v') */

package/dist/providers/provider-schema.d.ts

@@ -3,4 +3,3 @@ export interface ProviderValidationResult {
     warnings: string[];
 }
 export declare function validateProviderDefinition(raw: unknown): ProviderValidationResult;
-export declare function validateAutoApproveModes(raw: unknown, errors: string[]): void;

package/dist/providers/sdk/v1/builders/cli/detect-status.d.ts

@@ -75,20 +75,6 @@ export interface DetectStatusTuiSpec {
 declare function scopeText(input: CliStatusInput, scope: SpinnerSpec['scope'] | SettledPromptSpec['scope'], windowLines: number | undefined): string;
 declare function spinnerMatches(spec: SpinnerSpec, input: CliStatusInput): boolean;
 declare function settledPromptMatches(spec: SettledPromptSpec, input: CliStatusInput): boolean;
-/**
- * APPROVAL-PICKER-MISROUTE (mission f1d25e11) defense-in-depth: an
- * AskUserQuestion multi-choice picker is NOT an approval modal. Its option rows
- * ("❯ 1. label") can otherwise satisfy the approval button cue and get
- * mis-classified as `waiting_approval`, so the worker's question is surfaced to
- * the coordinator as a task_approval_needed (→ mesh_approve, which cannot answer
- * it). The picker carries a distinctive signature the approval FSM never does:
- * the claude TUI select footer ("Enter to select … Esc to cancel") together with
- * the freeform escape hatch ("Type something" / "Chat about this"). When both are
- * present the screen is a question picker — surfaced separately as
- * waiting_choice — so the approval matchers must yield. Mirrors the legacy
- * looksLikeSelectionPicker guard (cli-provider-instance.ts) ported to SDK-v1.
- */
-export declare function isAskUserQuestionPickerSignature(text: string): boolean;
 declare function modalMatches(spec: ModalSpec, input: CliStatusInput): boolean;
 export declare function buildDetectStatusFromTui(spec: DetectStatusTuiSpec): CliDetectStatusFn;
 export declare const __internal: {

package/dist/providers/types/interactive-prompt.d.ts

@@ -28,24 +28,6 @@ export interface InteractiveAnswer {
 }
 export declare function normalizeInteractivePrompt(raw: unknown): InteractivePrompt | null;
 export declare function normalizeInteractivePromptResponse(raw: unknown): InteractivePromptResponse;
-/**
- * Resolve a coordinator-friendly answer form into the strict, questionId-keyed
- * InteractivePromptResponse the TUI/answer machinery consumes (mission f1d25e11).
- *
- * mesh_answer_question lets the coordinator answer against the option LABELS or
- * 1-based INDEXES it saw in the agent:waiting_choice event, without having to
- * reconstruct the exact questionId → selectedLabels map. This resolves that
- * ergonomic form against the AUTHORITATIVE active prompt (the daemon holds it),
- * so index/label resolution and question ordering are correct by construction.
- *
- * Accepted `raw` shapes:
- *   - The strict form ({ promptId, answers: { [questionId]: { selectedLabels } } })
- *     — passed straight to normalizeInteractivePromptResponse (back-compat).
- *   - The friendly form ({ promptId, answers: [ { questionId?, select?, freeform? } ] })
- *     — entries map to questions by questionId, else by array position. `select`
- *     is a label (string) / 1-based index (number) / array of either.
- */
-export declare function resolveInteractivePromptResponse(prompt: InteractivePrompt, raw: unknown): InteractivePromptResponse;
 export declare function buildClaudeInteractiveToolResult(response: InteractivePromptResponse): string;
 export interface ClaudeInteractiveTuiPage {
     screenText: string;