@adhdev/daemon-core 1.0.18-rc.20 → 1.0.18-rc.4

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.20",
+  "version": "1.0.18-rc.4",
   "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.20",
-    "@adhdev/session-host-core": "1.0.18-rc.20",
+    "@adhdev/mesh-shared": "1.0.18-rc.4",
+    "@adhdev/session-host-core": "1.0.18-rc.4",
     "@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,
@@ -362,22 +361,7 @@ export class CliStateEngine {
         // 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') {
+        if (this.provider.transcriptAuthority === 'provider' && this.currentStatus !== 'waiting_approval') {
             this.setStatus('generating', 'turn_started');
             this.callbacks.onStatusChange();
         }

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';
     }
 
     /**

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

@@ -254,54 +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>;
-} | null | undefined): boolean {
-    // No provider (e.g. an instance whose module isn't set when the stall watchdog
-    // ticks) ⇒ not the pure-PTY class. Guarding here protects every caller — the
-    // stall-reconcile and turn-start paths pass this.provider unguarded, and
-    // this.provider is genuinely nullable at runtime (see this.provider?.nativeHistory
-    // in cli-provider-instance.ts). Matches resolveLocalSessionPurePty's own
-    // no-provider ⇒ not-pure-PTY contract.
-    if (!provider) return false;
-    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/commands/cli-manager.ts

@@ -34,7 +34,6 @@ import type { SessionRegistry } from '../sessions/registry.js';
 import type { ProviderInstance } from '../providers/provider-instance.js';
 import { LOG } from '../logging/logger.js';
 import { shouldRestoreHostedRuntime } from './hosted-runtime-restore.js';
-import { findProviderAutoApproveMode, resolveProviderAutoApproveMode } from '../providers/auto-approve-modes.js';
 
 // ─── external dependency interface ──────────────────────────
 
@@ -453,40 +452,6 @@ export function expandThinkingLaunchArgs(
     return template.map((part) => part.includes('{{level}}') ? part.replace('{{level}}', mapped) : part);
 }
 
-function matchesRemovedLaunchArg(arg: string, removeArg: string): boolean {
-    return arg === removeArg || (removeArg.startsWith('--') && arg.startsWith(`${removeArg}=`));
-}
-
-/**
- * Apply a selected launch-args auto-approve mode without mutating provider metadata.
- * removeArgs only targets provider-owned base spawn.args; launchArgs are prepended to
- * per-launch args beside model/thinking args, making conflict removal order-independent.
- */
-export function applyAutoApproveModeLaunchArgs(
-    provider: ProviderModule | undefined,
-    cliArgs: string[] | undefined,
-    settings: Record<string, unknown> | undefined,
-): { provider: ProviderModule | undefined; cliArgs: string[] | undefined } {
-    if (!provider) return { provider, cliArgs };
-    const resolved = resolveProviderAutoApproveMode(provider, settings);
-    if (!resolved.active || resolved.strategy !== 'launch-args') return { provider, cliArgs };
-    const mode = findProviderAutoApproveMode(provider, resolved.modeId);
-    if (!mode || !Array.isArray(mode.launchArgs) || mode.launchArgs.length === 0) return { provider, cliArgs };
-
-    const removeArgs = Array.isArray(mode.removeArgs) ? mode.removeArgs : [];
-    const baseArgs = provider.spawn?.args;
-    const filteredBaseArgs = Array.isArray(baseArgs) && removeArgs.length > 0
-        ? baseArgs.filter((arg) => !removeArgs.some((removeArg) => matchesRemovedLaunchArg(arg, removeArg)))
-        : baseArgs;
-    const launchProvider = filteredBaseArgs === baseArgs
-        ? provider
-        : { ...provider, spawn: { ...provider.spawn!, args: filteredBaseArgs } };
-    return {
-        provider: launchProvider,
-        cliArgs: [...mode.launchArgs, ...(cliArgs || [])],
-    };
-}
-
 function readSubcommandSessionId(args: string[], subcommands: string[]): string | undefined {
     const resumeIndex = args.findIndex((arg) => subcommands.includes(arg));
     if (resumeIndex < 0) return undefined;
@@ -742,24 +707,6 @@ export class DaemonCliManager {
                     clearInterval(checkStopped);
                     setTimeout(() => {
                         if (this.adapters.has(key)) {
-                            // KIMI-MESH-COMPLETION-EMIT (axis 2): before removeInstance closes the
-                            // event-emit window, give a mesh DELEGATED worker one last chance to emit
-                            // its completion. A native-source worker (e.g. kimi) can have its PTY
-                            // killed by a false stall AFTER it finished the task (transcript written)
-                            // but BEFORE the FSM's idle→completed event fired — the instance is the
-                            // only thing that can emit that event, and it is about to be removed. The
-                            // instance-side method is a no-op for a non-mesh session or when the
-                            // turn's completion already fired (double-emit guard) or when there is no
-                            // transcript evidence of a finished turn. Best-effort — never blocks cleanup.
-                            try {
-                                const inst = instanceManager?.getInstance(key) as (ProviderInstance & { flushMeshCompletionBeforeCleanup?: () => boolean }) | undefined;
-                                if (typeof inst?.flushMeshCompletionBeforeCleanup === 'function') {
-                                    const emitted = inst.flushMeshCompletionBeforeCleanup();
-                                    if (emitted) LOG.info('CLI', `Emitted pre-cleanup mesh completion for ${cliType} session ${key} before auto-clean`);
-                                }
-                            } catch (e) {
-                                LOG.warn('CLI', `pre-cleanup mesh completion flush failed for ${key}: ${(e as Error)?.message || e}`);
-                            }
                             this.adapters.delete(key);
                             this.deps.removeAgentTracking(key);
                             sessionRegistry?.unregisterByInstanceKey(key);
@@ -1083,17 +1030,6 @@ export class DaemonCliManager {
             console.log(colorize('cyan', `  📦 Using provider: ${provider.name} (${provider.type})`));
         }
 
-        const launchSettings = {
-            ...this.providerLoader.getSettings(normalizedType),
-            ...(options?.settingsOverride || {}),
-        };
-        const versionResolvedProvider = provider
-            ? (this.providerLoader.resolve(cliType, { version: cliInfo.version }) || provider)
-            : undefined;
-        const autoApproveLaunch = applyAutoApproveModeLaunchArgs(versionResolvedProvider, cliArgs, launchSettings);
-        const launchProvider = autoApproveLaunch.provider || provider;
-        const cliArgsWithAutoApprove = autoApproveLaunch.cliArgs;
-
  // ─── Model axis (MAGI kind-panel): expand initialModel → launch args ───
  // For a plain CLI provider the model is selected at spawn time via the manifest's
  // modelLaunchArgs template ('{{model}}' → the requested model). ACP providers took
@@ -1101,10 +1037,10 @@ export class DaemonCliManager {
  // or no requested model, is a no-op — model selection is best-effort and must never
  // fail a launch. The model args are prepended so a caller's explicit cliArgs (e.g. a
  // resume flag) still win positionally where order matters.
-        const modelLaunchArgs = expandModelLaunchArgs(launchProvider?.modelLaunchArgs, initialModel);
+        const modelLaunchArgs = expandModelLaunchArgs(provider?.modelLaunchArgs, initialModel);
         const cliArgsWithModel = modelLaunchArgs
-            ? [...modelLaunchArgs, ...(cliArgsWithAutoApprove || [])]
-            : cliArgsWithAutoApprove;
+            ? [...modelLaunchArgs, ...(cliArgs || [])]
+            : cliArgs;
         if (initialModel && !modelLaunchArgs) {
             LOG.warn('CLI', `[${normalizedType}] initialModel='${initialModel}' requested but provider declares no modelLaunchArgs template — launching without model selection.`);
         }
@@ -1115,7 +1051,7 @@ export class DaemonCliManager {
  // Best-effort; a provider with no template (or no requested level) is a no-op. ACP
  // providers route thinking through setConfigOption('thought_level') above.
         const initialThinkingLevel = options?.initialThinkingLevel;
-        const thinkingLaunchArgs = expandThinkingLaunchArgs(launchProvider?.thinkingLaunchArgs, initialThinkingLevel, launchProvider?.thinkingLevelMap);
+        const thinkingLaunchArgs = expandThinkingLaunchArgs(provider?.thinkingLaunchArgs, initialThinkingLevel, provider?.thinkingLevelMap);
         const cliArgsWithBrain = thinkingLaunchArgs
             ? [...thinkingLaunchArgs, ...(cliArgsWithModel || [])]
             : cliArgsWithModel;
@@ -1124,13 +1060,13 @@ export class DaemonCliManager {
         }
 
  // ─── Resolve launch options → provider session binding ───
-        const sessionBinding = resolveCliSessionBinding(launchProvider, normalizedType, cliArgsWithBrain, options?.resumeSessionId);
+        const sessionBinding = resolveCliSessionBinding(provider, normalizedType, cliArgsWithBrain, options?.resumeSessionId);
         const resolvedCliArgs = sessionBinding.cliArgs;
 
  // If InstanceManager exists, manage as CliProviderInstance unified
         const instanceManager = this.deps.getInstanceManager();
-        if (launchProvider && instanceManager) {
-            const resolvedProvider = launchProvider;
+        if (provider && instanceManager) {
+            const resolvedProvider = this.providerLoader.resolve(cliType, { version: cliInfo.version }) || provider;
             await this.registerCliInstance(
                 key,
                 normalizedType,
@@ -1138,7 +1074,7 @@ export class DaemonCliManager {
                 resolvedDir,
                 resolvedCliArgs,
                 resolvedProvider,
-                launchSettings,
+                { ...this.providerLoader.getSettings(normalizedType), ...(options?.settingsOverride || {}) },
                 false,
                 {
                     providerSessionId: sessionBinding.providerSessionId,

package/src/commands/high-family/mesh-coordinator-launch.ts

@@ -115,12 +115,8 @@ export const meshCoordinatorLaunchHandlers: Record<string, HighFamilyHandler> =
                         try {
                             const { readOperatingNotes } = await import('../../mesh/mesh-ledger.js');
                             // readOperatingNotes filters out tombstoned (forgotten) notes so a
-                            // retracted lesson never rides into the prompt. Newest last.
-                            // Phase 2 (d): the byte-budget/count cap now bounds the injected list
-                            // (selectOperatingNotesForPrompt), so read a larger candidate tail than
-                            // the old fixed 20 and let injection-side ranking + budget do the
-                            // bounding. Keep a sane store-read ceiling to avoid unbounded arrays.
-                            const noteEntries = readOperatingNotes(id, { tail: 100 });
+                            // retracted lesson never rides into the prompt. Newest last; tail 20.
+                            const noteEntries = readOperatingNotes(id, { tail: 20 });
                             const notes = noteEntries
                                 .map((e) => {
                                     const p = (e.payload || {}) as Record<string, unknown>;
@@ -135,17 +131,6 @@ export const meshCoordinatorLaunchHandlers: Record<string, HighFamilyHandler> =
                                         category,
                                         createdAt: typeof p.createdAt === 'string' ? p.createdAt : e.timestamp,
                                         sourceCoordinator: typeof p.sourceCoordinator === 'string' ? p.sourceCoordinator : undefined,
-                                        // Operating-notes lifecycle: thread pinned/expiresAt so the
-                                        // injection-side selection can honor them. Legacy notes lack
-                                        // these → pinned defaults false, expiry governed by category TTL.
-                                        pinned: p.pinned === true,
-                                        ...(typeof p.expiresAt === 'string' ? { expiresAt: p.expiresAt } : {}),
-                                        // Phase 2 (b)/(c): thread the ledger id + supersedes/subjectKey
-                                        // so version-supersede targeting and same-class folding work.
-                                        // Legacy notes lack them → no supersede, fold by leading [tag].
-                                        noteId: e.id,
-                                        ...(typeof p.supersedes === 'string' ? { supersedes: p.supersedes } : {}),
-                                        ...(typeof p.subjectKey === 'string' ? { subjectKey: p.subjectKey } : {}),
                                     };
                                 })
                                 .filter((n): n is NonNullable<typeof n> => n !== null);

package/src/commands/high-family/mesh-events.ts

@@ -93,21 +93,10 @@ export const meshEventsHandlers: Record<string, HighFamilyHandler> = {
                 ? args.sessionId.trim()
                 : '';
         if (!sessionId) return { success: false, error: 'targetSessionId required' };
-        const rawResponse = args?.response ?? args;
+        const response = normalizeInteractivePromptResponse(args?.response ?? args);
         const instance = ctx.deps.instanceManager.getInstance(sessionId);
         if (!instance) return { success: false, error: `No running instance for session ${sessionId}` };
-        // mesh_answer_question (mission f1d25e11) sends a coordinator-friendly answer array
-        // that is resolved against the AUTHORITATIVE active prompt inside the instance
-        // (resolveInteractivePromptResponse). Forward that shape RAW. The legacy strict
-        // (questionId-keyed) form is still validated here so a malformed dashboard-local
-        // answer is rejected before it reaches the instance.
-        const isFriendlyArrayForm = rawResponse
-            && typeof rawResponse === 'object'
-            && Array.isArray((rawResponse as { answers?: unknown }).answers);
-        const payload = isFriendlyArrayForm
-            ? rawResponse
-            : normalizeInteractivePromptResponse(rawResponse);
-        ctx.deps.instanceManager.sendEvent(sessionId, 'interactive_prompt_response', payload);
+        ctx.deps.instanceManager.sendEvent(sessionId, 'interactive_prompt_response', response);
         return { success: true };
     },
 };

package/src/commands/med-family/mesh-crud.ts

@@ -399,161 +399,6 @@ export const meshCrudHandlers: Record<string, MedFamilyHandler> = {
         }
     },
 
-    // READ path for `.adhdev/mesh.json` — returns the currently-committed repo
-    // config (parsed + normalized) for a workspace so a UI can render/edit the
-    // existing declarative zones (notably `providerDefaults.autoApproveModes`)
-    // WITHOUT re-deriving them from the machine-local scaffold. Never writes.
-    // `config` is undefined when no repo file exists (sourceType 'unavailable') or
-    // it is unparseable (sourceType 'invalid', with the parse error surfaced).
-    read_mesh_json_config: async (_ctx: MedFamilyContext, args: any) => {
-        const workspace = typeof args?.workspace === 'string' && args.workspace.trim() ? args.workspace.trim() : process.cwd();
-        try {
-            const { loadRepoMeshJsonConfig } = await import('../../config/mesh-json-config.js');
-            const loaded = loadRepoMeshJsonConfig(workspace);
-            return {
-                success: true,
-                workspace,
-                sourceType: loaded.sourceType,
-                source: loaded.source,
-                ...(loaded.path ? { path: loaded.path } : {}),
-                ...(loaded.error ? { error: loaded.error } : {}),
-                config: loaded.config,
-                // Convenience projection so the UI does not have to reach into config.
-                providerDefaults: loaded.config?.providerDefaults,
-            };
-        } catch (e: any) {
-            return { success: false, error: e.message };
-        }
-    },
-
-    // Partial-edit WRITE path for `.adhdev/mesh.json` `providerDefaults` — a
-    // READ-MODIFY-WRITE that preserves operator hand-edits. Unlike
-    // write_mesh_json_config (which rebuilds the WHOLE file from the machine-local
-    // scaffold and can silently drop hand-edited zones), this parses the existing
-    // repo file, merges ONLY the providerDefaults.autoApproveModes zone, and
-    // re-serializes — coordinator prompt, operating notes and limits authored in
-    // the repo are carried through untouched. Defaults to dry-run.
-    //
-    // args: { workspace?, autoApproveModes: Record<providerType,modeId>, write?, merge? }
-    //   merge=true (default): per-provider merge into the existing map; a modeId of
-    //     '' | null removes that provider's entry. merge=false: REPLACE the whole
-    //     autoApproveModes map with the supplied one.
-    set_mesh_provider_defaults: async (_ctx: MedFamilyContext, args: any) => {
-        const workspace = typeof args?.workspace === 'string' && args.workspace.trim() ? args.workspace.trim() : process.cwd();
-        const write = args?.write === true;
-        const merge = args?.merge !== false; // default true
-        const inputModes = args?.autoApproveModes;
-        if (inputModes !== undefined && (typeof inputModes !== 'object' || inputModes === null || Array.isArray(inputModes))) {
-            return { success: false, error: 'autoApproveModes must be an object (providerType → modeId) when provided' };
-        }
-        try {
-            const {
-                loadRepoMeshJsonConfig,
-                normalizeRepoMeshDeclarativeConfig,
-                MESH_JSON_CONFIG_LOCATIONS,
-            } = await import('../../config/mesh-json-config.js');
-            const { existsSync, readFileSync, mkdirSync, writeFileSync } = await import('fs');
-            const { dirname, join } = await import('path');
-            const yaml = await import('js-yaml');
-
-            const relativePath = MESH_JSON_CONFIG_LOCATIONS[0];
-
-            // Read-modify-write: parse the EXISTING on-disk document (preferring the
-            // first existing json/yaml variant) so unrelated zones survive verbatim.
-            let baseDoc: Record<string, any> = { version: 1 };
-            let existingPath = join(workspace, relativePath);
-            let existedAsYaml = false;
-            for (const relative of MESH_JSON_CONFIG_LOCATIONS) {
-                const candidate = join(workspace, relative);
-                if (!existsSync(candidate)) continue;
-                try {
-                    const text = readFileSync(candidate, 'utf-8');
-                    const parsed = /\.json$/i.test(candidate) ? JSON.parse(text) : yaml.load(text);
-                    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
-                        baseDoc = parsed as Record<string, any>;
-                        existingPath = candidate;
-                        existedAsYaml = !/\.json$/i.test(candidate);
-                    }
-                } catch (e: any) {
-                    return { success: false, error: `existing ${relative} is unparseable, refusing to overwrite: ${e?.message || e}` };
-                }
-                break;
-            }
-
-            // Merge ONLY the providerDefaults.autoApproveModes zone.
-            const existingPd = baseDoc.providerDefaults && typeof baseDoc.providerDefaults === 'object' && !Array.isArray(baseDoc.providerDefaults)
-                ? baseDoc.providerDefaults as Record<string, any>
-                : {};
-            const existingModes = existingPd.autoApproveModes && typeof existingPd.autoApproveModes === 'object' && !Array.isArray(existingPd.autoApproveModes)
-                ? { ...existingPd.autoApproveModes as Record<string, string> }
-                : {};
-
-            const nextModes: Record<string, string> = merge ? existingModes : {};
-            if (inputModes) {
-                for (const [providerType, modeId] of Object.entries(inputModes as Record<string, unknown>)) {
-                    const type = typeof providerType === 'string' ? providerType.trim() : '';
-                    if (!type) continue;
-                    const id = typeof modeId === 'string' ? modeId.trim() : '';
-                    if (id) nextModes[type] = id;
-                    else delete nextModes[type]; // '' / null → remove this provider's entry
-                }
-            }
-
-            const nextDoc: Record<string, any> = { ...baseDoc, version: 1 };
-            if (Object.keys(nextModes).length) {
-                nextDoc.providerDefaults = { ...existingPd, autoApproveModes: nextModes };
-            } else {
-                // No entries left → drop the zone entirely so we don't leave an empty stub.
-                if (nextDoc.providerDefaults) {
-                    const { autoApproveModes, ...restPd } = nextDoc.providerDefaults;
-                    if (Object.keys(restPd).length) nextDoc.providerDefaults = restPd;
-                    else delete nextDoc.providerDefaults;
-                }
-            }
-
-            // Validate the merged document before it ever touches disk.
-            const validation = normalizeRepoMeshDeclarativeConfig(nextDoc);
-            if (!validation.valid) {
-                return { success: false, error: `merged mesh.json is invalid: ${validation.errors.join('; ')}` };
-            }
-
-            // Serialize in the on-disk format (JSON unless the existing file was YAML).
-            const absolutePath = existingPath;
-            const serialized = existedAsYaml
-                ? yaml.dump(nextDoc, { indent: 2 })
-                : `${JSON.stringify(nextDoc, null, 2)}\n`;
-
-            if (!write) {
-                return {
-                    success: true,
-                    written: false,
-                    dryRun: true,
-                    path: absolutePath,
-                    relativePath,
-                    merge,
-                    providerDefaults: nextDoc.providerDefaults,
-                    preview: serialized,
-                    note: 'Dry-run: nothing written. Re-run with write=true to persist. Only the providerDefaults zone is merged; other repo zones are preserved.',
-                };
-            }
-
-            mkdirSync(dirname(absolutePath), { recursive: true });
-            writeFileSync(absolutePath, serialized, 'utf-8');
-            return {
-                success: true,
-                written: true,
-                dryRun: false,
-                path: absolutePath,
-                relativePath,
-                merge,
-                providerDefaults: nextDoc.providerDefaults,
-                note: 'Wrote providerDefaults into .adhdev/mesh.json (read-modify-write; other zones preserved). Commit it to the repo.',
-            };
-        } catch (e: any) {
-            return { success: false, error: e.message };
-        }
-    },
-
     delete_mesh: async (_ctx: MedFamilyContext, args: any) => {
         const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
         if (!meshId) return { success: false, error: 'meshId required' };