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

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

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

@@ -9,67 +9,6 @@
  */
 import { readStringValue } from '../router.js';
 import type { MedFamilyContext, MedFamilyHandler } from './types.js';
-import { LOG } from '../../logging/logger.js';
-import type { CancelledTaskAssignment } from '../../mesh/mesh-work-queue.js';
-
-/**
- * CANCEL-STICKY-TERMINAL (authoritative cancel): stop the worker a just-cancelled task was
- * bound to. Mirrors the transport-aware stop mesh-event-forwarding's stopStaleMeshWorker
- * performs for reclaimed workers, but runs from the command layer using ctx.deps (which the
- * pure queue-store module lacks): local adapter → stop_cli directly; otherwise resolve the
- * worker node's daemon id from mesh config and dispatch stop_cli over P2P/relay. Fully
- * best-effort — a failed stop only loses the belt-and-suspenders; the cancelled row is already
- * terminal and cannot be resurrected (updateTaskStatus terminal guard).
- */
-async function stopCancelledTaskWorker(
-    ctx: MedFamilyContext,
-    meshId: string,
-    prior: CancelledTaskAssignment,
-): Promise<void> {
-    const { sessionId, nodeId, providerType } = prior;
-    const stopArgs: Record<string, unknown> = {
-        targetSessionId: sessionId,
-        ...(providerType ? { cliType: providerType } : {}),
-        mode: 'hard',
-        reason: 'mesh_task_cancelled',
-    };
-    try {
-        const cliManager = ctx.deps.cliManager as any;
-        const isLocal = cliManager?.adapters?.has?.(sessionId) === true;
-        if (isLocal) {
-            if (!stopArgs.cliType) {
-                const localType = cliManager?.adapters?.get?.(sessionId)?.cliType;
-                if (localType) stopArgs.cliType = localType;
-            }
-            await Promise.resolve(cliManager?.handleCliCommand?.('stop_cli', stopArgs))
-                .catch((e: any) => LOG.warn('MeshQueue', `Local stop of cancelled worker ${sessionId} failed: ${e?.message || e}`));
-            return;
-        }
-        // Remote: resolve the worker node's daemon id from mesh config, then dispatch stop_cli.
-        const dispatch = ctx.deps.dispatchMeshCommand;
-        let daemonId: string | undefined;
-        if (nodeId) {
-            try {
-                const [{ getMesh }, { meshNodeIdMatches }, { readMeshNodeDaemonId }] = await Promise.all([
-                    import('../../config/mesh-config.js'),
-                    import('@adhdev/mesh-shared'),
-                    import('../../mesh/mesh-node-identity.js'),
-                ]);
-                const mesh = getMesh(meshId) as { nodes?: any[] } | undefined;
-                const node = mesh?.nodes?.find((n: any) => meshNodeIdMatches(n, nodeId));
-                daemonId = node ? readMeshNodeDaemonId(node) || undefined : undefined;
-            } catch { /* best-effort resolution */ }
-        }
-        if (daemonId && dispatch) {
-            await Promise.resolve(dispatch(daemonId, 'stop_cli', stopArgs))
-                .catch((e: any) => LOG.warn('MeshQueue', `Remote stop of cancelled worker ${sessionId} on daemon ${daemonId} failed: ${e?.message || e}`));
-        } else {
-            LOG.warn('MeshQueue', `Cannot stop cancelled worker ${sessionId}: no local adapter and no resolvable remote daemon id (node ${nodeId ?? '?'}). Row is already terminal; if the worker completes it strand-fails harmlessly.`);
-        }
-    } catch (e: any) {
-        LOG.warn('MeshQueue', `stopCancelledTaskWorker error for ${sessionId}: ${e?.message || e}`);
-    }
-}
 
 export const meshQueueHandlers: Record<string, MedFamilyHandler> = {
     get_mesh_queue: async (_ctx: MedFamilyContext, args: any) => {
@@ -111,22 +50,10 @@ export const meshQueueHandlers: Record<string, MedFamilyHandler> = {
         const ownerFailure = await ctx.requireMeshHostMutationOwner(meshId, args?.inlineMesh, 'queue cancellation');
         if (ownerFailure) return ownerFailure;
         try {
-            const { cancelTask, takeCancelledTaskAssignment } = await import('../../mesh/mesh-work-queue.js');
+            const { cancelTask } = await import('../../mesh/mesh-work-queue.js');
             const reason = typeof args?.reason === 'string' ? args.reason : undefined;
             const task = cancelTask(meshId, taskId, { reason });
             if (!task) return { success: false, error: `Queue task '${taskId}' not found` };
-            // CANCEL-STICKY-TERMINAL (authoritative cancel): stop the worker that was bound to the
-            // now-cancelled task. cancelTask already cleared the queue's assignment fields (so the
-            // reclaim watchdog no longer sees it as a live assignment), but a still-running worker
-            // keeps emitting delivery/turn signals that re-ignite reclaim. cancelTask runs in the
-            // pure queue-store module (no DaemonComponents), so the transport-aware stop is done
-            // here where ctx.deps holds cliManager / dispatchMeshCommand. Best-effort: a failed
-            // stop only loses the belt-and-suspenders — the row is already terminal and un-revivable
-            // thanks to the updateTaskStatus terminal guard.
-            const prior = takeCancelledTaskAssignment(meshId, taskId);
-            if (prior?.sessionId) {
-                void stopCancelledTaskWorker(ctx, meshId, prior);
-            }
             return { success: true, task };
         } catch (e: any) {
             return { success: false, error: e.message };

package/src/commands/router-refine.ts

@@ -36,10 +36,8 @@ import {
     RefineExecFileAsync,
     RefineStageOutcome,
     classifyPatchEquivalenceFailure,
-    convergeDivergedSubmoduleGitlinks,
     recordMeshRefineStage,
     resolveRefineryAutoPublishSubmoduleMainCommits,
-    rootRebaseResolvingGitlinks,
     runMeshRefineEffectiveDiffGate,
     runMeshRefinePatchEquivalenceGate,
     runMeshRefineSubmoduleReachabilityGate,
@@ -541,9 +539,6 @@ async function computeBranchBaseDivergence(
 export async function refineSyncBaseStage(self: DaemonCommandRouter, ctx: RefineContext): Promise<RefineStageOutcome> {
             const { repoRoot, baseHead, node, branch, baseBranch, refineStages, execFileAsync } = ctx;
             let branchHead = ctx.branchHead;
-            // Converged submodule gitlink resolutions (path → rebased commit) from STEP 1;
-            // consumed by the gitlink-aware root rebase (STEP 2) to resolve gitlink conflicts.
-            let gitlinkResolutions: Array<{ path: string; rebasedCommit: string }> = [];
             const syncStarted = Date.now();
             const divergence = await computeBranchBaseDivergence(execFileAsync, node.workspace, baseHead, branchHead);
 
@@ -576,87 +571,25 @@ export async function refineSyncBaseStage(self: DaemonCommandRouter, ctx: Refine
                 const preRebasePe = await runMeshRefinePatchEquivalenceGate(repoRoot, baseHead, branchHead);
                 const alreadyMerged = !preRebasePe.actualPatchId && !!preRebasePe.expectedPatchId;
                 const submoduleConflict = preRebasePe.actionableHint?.kind === 'submodule_conflict';
-                if (alreadyMerged) {
+                if (alreadyMerged || submoduleConflict) {
                     recordMeshRefineStage(refineStages, 'sync_base', 'passed', syncStarted, {
                         ahead: divergence.ahead,
                         behind: divergence.behind,
                         rebased: false,
-                        reason: 'already_merged_via_other_path_skip_rebase',
+                        reason: alreadyMerged ? 'already_merged_via_other_path_skip_rebase' : 'submodule_conflict_defer_to_patch_equivalence',
                     });
                     return { kind: 'continue', ctx };
                 }
-                if (submoduleConflict) {
-                    // DS3: a "submodule conflict" here means base and branch advanced the
-                    // SAME submodule to DIVERGED sibling commits (neither an ancestor of the
-                    // other), so the gitlink stays in the diff and patch-equivalence fails.
-                    // Attempt to auto-converge it (STEP 1): rebase the branch-side submodule
-                    // commit onto the base-side commit INSIDE the worktree submodule, so the
-                    // base-side commit becomes a strict ancestor of the rebased tip. The root
-                    // rebase below (STEP 2) then resolves the gitlink conflict to that rebased
-                    // commit. Together this automates the documented manual strict-ff bypass
-                    // and keeps the landed oss history linear. On any real submodule content
-                    // conflict it backs out cleanly → we FALL BACK to the historical
-                    // defer→patch_equivalence path below.
-                    const converge = convergeDivergedSubmoduleGitlinks(node.workspace, repoRoot, baseHead, branchHead);
-                    if (converge.converged) {
-                        gitlinkResolutions = converge.resolutions;
-                        recordMeshRefineStage(refineStages, 'submodule_gitlink_converge', 'passed', syncStarted, {
-                            reason: 'submodule_diverged_auto_rebased',
-                            gitlinks: converge.gitlinks,
-                        });
-                        LOG.info('Mesh', `[Refinery] Auto-converged diverged submodule gitlink(s) onto base for node ${node.id}: `
-                            + converge.resolutions.map(r => `${r.path}→${r.rebasedCommit.slice(0, 12)}`).join(', '));
-                        // Fall through (do NOT return) → the gitlink-aware root rebase below runs.
-                    } else {
-                        // Fail-safe: convergence declined (conflict / unreachable / not a real
-                        // divergence) → preserve the historical defer→blocked_review behavior.
-                        recordMeshRefineStage(refineStages, 'submodule_gitlink_converge', 'skipped', syncStarted, {
-                            reason: 'submodule_conflict_defer_to_patch_equivalence',
-                            convergeReason: converge.reason,
-                            gitlinks: converge.gitlinks,
-                        });
-                        recordMeshRefineStage(refineStages, 'sync_base', 'passed', syncStarted, {
-                            ahead: divergence.ahead,
-                            behind: divergence.behind,
-                            rebased: false,
-                            reason: 'submodule_conflict_defer_to_patch_equivalence',
-                        });
-                        return { kind: 'continue', ctx };
-                    }
-                }
             } catch { /* fail-open: on gate error, fall through to the rebase */ }
 
             // behind>0: strictly-behind OR diverged. Rebase the branch onto the pinned
             // baseHead. A conflict aborts and terminates blocked_review (retryable=false —
             // a real content conflict needs human resolution, not a base-movement retry).
-            //
-            // When STEP 1 converged a diverged submodule gitlink, use the gitlink-aware
-            // root rebase (STEP 2): git's recursive merge refuses to auto-merge the still-
-            // diverged intermediate gitlink, so we drive the rebase and resolve each
-            // submodule-gitlink conflict to the converged commit. A non-gitlink conflict
-            // aborts and falls through to the same blocked_review handling as a plain
-            // rebase conflict below (via the thrown gitlinkRebaseError).
             const rebaseStarted = Date.now();
             try {
-                if (gitlinkResolutions.length > 0) {
-                    const gitlinkRebase = rootRebaseResolvingGitlinks(node.workspace, baseHead, gitlinkResolutions);
-                    if (!gitlinkRebase.ok) {
-                        // Surface as a rebase failure so the shared blocked_review handling
-                        // (submodule-hint recovery included) runs — nothing was left mid-rebase
-                        // (rootRebaseResolvingGitlinks aborts on failure).
-                        const err: any = new Error(`gitlink-aware rebase aborted: ${gitlinkRebase.reason || 'unknown'}`);
-                        err.gitlinkRebaseReason = gitlinkRebase.reason;
-                        err.gitlinkRebaseConflicts = gitlinkRebase.conflictPaths;
-                        err.alreadyAborted = true;
-                        throw err;
-                    }
-                } else {
-                    execFileSync('git', ['rebase', baseHead], { cwd: node.workspace, stdio: ['ignore', 'pipe', 'pipe'] });
-                }
+                execFileSync('git', ['rebase', baseHead], { cwd: node.workspace, stdio: ['ignore', 'pipe', 'pipe'] });
             } catch (rebaseErr: any) {
-                if (!rebaseErr?.alreadyAborted) {
-                    try { execFileSync('git', ['rebase', '--abort'], { cwd: node.workspace, stdio: 'ignore' }); } catch { /* ignore */ }
-                }
+                try { execFileSync('git', ['rebase', '--abort'], { cwd: node.workspace, stdio: 'ignore' }); } catch { /* ignore */ }
                 // A rebase conflict on a submodule/gitlink divergence is a SPECIAL case the
                 // patch-equivalence gate describes with a rich actionable hint (which
                 // submodule, base vs branch commit, how to resolve). Run that gate against

package/src/commands/router.ts

@@ -227,14 +227,6 @@ const MESH_FORWARDABLE_SESSION_COMMANDS = new Set([
     // MUTATES the worker PTY, so forwarding to the real owner (not a wrong local session) is
     // doubly important. The daemon re-enforces the destructive-key confirm gate after the forward.
     'send_keys',
-    // interactive_prompt_response (mesh_answer_question, mission f1d25e11): the coordinator
-    // answers a REMOTE worker's AskUserQuestion (waiting_choice). The answer must reach the
-    // OWNING worker session's live instance — its activeInteractivePrompt (the authoritative
-    // prompt the labels/indexes resolve against) and its adapter.setInteractivePromptResponse
-    // live only there. Without forwarding, the coordinator's local high-family handler returns
-    // 'No running instance for session …' and the question is never answered — the exact
-    // remote-worker forwarding gap of mission 6938892f, now closed for questions too.
-    'interactive_prompt_response',
 ]);
 
 function normalizeCommandSource(source: string): CommandLogEntry['source'] {