@adhdev/daemon-core 0.9.82-rc.360 → 0.9.82-rc.361

package/dist/mesh/mesh-events-utils.d.ts

@@ -1,8 +1,6 @@
 import type { SessionRecoveryContext } from './mesh-ledger.js';
 export declare function readNonEmptyString(value: unknown): string;
 export declare function readRecord(value: unknown): Record<string, unknown> | undefined;
-export declare function canonicalDaemonId(value: unknown): string;
-export declare function sameDaemonId(a: unknown, b: unknown): boolean;
 /**
  * The relay-safety metadata a worker session must carry so that its completion /
  * generating events route back to the coordinator proactively (without waiting for

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.360",
+  "version": "0.9.82-rc.361",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -46,7 +46,7 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.360",
+    "@adhdev/mesh-shared": "0.9.82-rc.361",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/commands/cli-manager.ts

@@ -148,6 +148,18 @@ function hasCompletedStartingLaunch(adapter: any): boolean {
     return hasFinalAssistantMessage(parsedStatus?.messages);
 }
 
+/**
+ * WTCLAIM (B): compare two workspace paths for node scoping. Normalizes separator
+ * style, trailing slashes, and case (Windows paths are case-insensitive; the
+ * coordinator-supplied node.workspace and the adapter's launch workingDir can
+ * differ only in those) so a base node and a worktree clone are still told apart
+ * by their distinct workspace roots.
+ */
+function normalizeDirForCompare(dir?: string): string {
+    if (typeof dir !== 'string') return '';
+    return dir.trim().replace(/[\\/]+/g, '/').replace(/\/+$/, '').toLowerCase();
+}
+
 function shouldSuppressStaleParsedBusyStatus(adapterStatus: string, parsedStatus: any, adapter: any): boolean {
     const parsedRawStatus = normalizeAgentStatus(parsedStatus?.status);
     if (!BUSY_AGENT_STATUSES.has(parsedRawStatus)) return false;
@@ -1142,6 +1154,40 @@ export class DaemonCliManager {
         return adapter ? { adapter, key: ik } : null;
     }
 
+    /**
+     * WTCLAIM (B): resolve the adapter for a mesh dispatch that named a node
+     * (meshContext.nodeId) but carried no explicit session. Matches by the
+     * instance's bound mesh node id (settings.meshNodeId, falling back to the
+     * sticky meshLastNodeId) first, then by the node workspace (workingDir).
+     *
+     * Unlike findAdapter's step-2 fuzzy fallback, this NEVER degrades to a
+     * provider-only first-match: on a daemon hosting BOTH a base node and a
+     * cloned worktree node (same daemonId), that fuzzy match could land a
+     * worktree-targeted task on the base session. Returns null when no session
+     * is bound to this node so the caller fails closed.
+     */
+    private findMeshNodeAdapter(agentType: string, nodeId: string, dir?: string): { adapter: CliAdapter; key: string } | null {
+        const instanceManager = this.deps.getInstanceManager();
+        const targetDir = normalizeDirForCompare(dir);
+        let workspaceMatch: { adapter: CliAdapter; key: string } | null = null;
+        for (const [k, a] of this.adapters) {
+            if (a.cliType !== agentType) continue;
+            const settings = (instanceManager?.getInstance(k) as any)?.getState?.()?.settings as Record<string, unknown> | undefined;
+            const boundNodeId = (typeof settings?.meshNodeId === 'string' && settings.meshNodeId.trim())
+                ? settings.meshNodeId.trim()
+                : (typeof settings?.meshLastNodeId === 'string' ? settings.meshLastNodeId.trim() : '');
+            // Exact node binding wins immediately (most precise).
+            if (boundNodeId && boundNodeId === nodeId) return { adapter: a, key: k };
+            // Workspace identity is the secondary signal for a session not (yet)
+            // stamped with a node id — a base node and a worktree clone always have
+            // distinct workspaces, so this still separates them.
+            if (!workspaceMatch && targetDir && normalizeDirForCompare(a.workingDir) === targetDir) {
+                workspaceMatch = { adapter: a, key: k };
+            }
+        }
+        return workspaceMatch;
+    }
+
  // ─── CLI command handling ────────────────────────────
 
     async handleCliCommand(cmd: string, args: any): Promise<CommandResult | null> {
@@ -1343,10 +1389,29 @@ export class DaemonCliManager {
                 const action = args?.action;
                 if (!agentType || !action) throw new Error('agentType and action required');
 
-                const found = this.findAdapter(agentType, {
-                    dir: args?.dir,
-                    instanceKey: args?.targetSessionId,
-                });
+                // WTCLAIM (B): a mesh dispatch that named a node (meshContext.nodeId)
+                // but resolved no explicit session must be scoped to THAT node's
+                // session — never routed by findAdapter's provider-only fuzzy fallback,
+                // which on a daemon hosting both a base node and a cloned worktree node
+                // (same daemonId) could land a worktree task on the base session. Fail
+                // closed when no session is bound to the node so the coordinator
+                // launches/retries instead of mis-landing the work.
+                const meshScopeNodeId = (() => {
+                    const mc = (args as any)?.meshContext;
+                    return mc && typeof mc === 'object' && typeof mc.nodeId === 'string' ? mc.nodeId.trim() : '';
+                })();
+                let found: { adapter: CliAdapter; key: string } | null;
+                if (meshScopeNodeId && !args?.targetSessionId) {
+                    found = this.findMeshNodeAdapter(agentType, meshScopeNodeId, args?.dir);
+                    if (!found) {
+                        throw new Error(`No mesh worker session bound to node '${meshScopeNodeId}' for agent '${agentType}' on this daemon; refusing provider-only fuzzy match to avoid cross-node dispatch`);
+                    }
+                } else {
+                    found = this.findAdapter(agentType, {
+                        dir: args?.dir,
+                        instanceKey: args?.targetSessionId,
+                    });
+                }
                 if (!found) throw new Error(`CLI agent not running: ${agentType}`);
                 const { adapter, key } = found;
 

package/src/commands/low-family/index.ts

@@ -0,0 +1,23 @@
+/**
+ * RF-ROUTER LOW family — command registry.
+ *
+ * Aggregates the low-coupling command handlers extracted from
+ * DaemonCommandRouter.executeDaemonCommand into a single cmd → handler map.
+ * The router consults this registry before its switch (registry hit → return the
+ * handler result; miss → fall through to the remaining switch / CommandHandler
+ * delegation), so the facade and dispatch semantics are unchanged.
+ */
+import { sessionHostHandlers } from './session-host.js';
+import { specProviderDevHandlers } from './spec-providerdev.js';
+import { refineConfigHandlers } from './refine-config.js';
+import type { LowFamilyRegistry } from './types.js';
+
+export type { LowFamilyContext, LowFamilyHandler, LowFamilyRegistry } from './types.js';
+
+export const lowFamilyRegistry: LowFamilyRegistry = new Map(
+    Object.entries({
+        ...sessionHostHandlers,
+        ...specProviderDevHandlers,
+        ...refineConfigHandlers,
+    }),
+);

package/src/commands/low-family/refine-config.ts

@@ -0,0 +1,106 @@
+/**
+ * RF-ROUTER LOW family — mesh refine-config / change-impact config commands.
+ *
+ * Schema/validate/suggest endpoints for the repo mesh refine config and the
+ * change-impact config. Pure: every handler is a function of args only (it reads
+ * no router deps), so ctx is unused. Extracted verbatim from executeDaemonCommand;
+ * the config helpers are imported from their source modules, identical to router.ts.
+ */
+import {
+    CHANGE_IMPACT_CONFIG_LOCATIONS,
+    CHANGE_IMPACT_CONFIG_SCHEMA,
+    loadChangeImpactConfig,
+    suggestChangeImpactConfig,
+    validateChangeImpactConfig,
+} from '../../git/change-impact-config.js';
+import {
+    MESH_REFINE_CONFIG_LOCATIONS,
+    MESH_REFINE_CONFIG_SCHEMA,
+    loadMeshRefineConfig,
+    suggestMeshRefineConfig,
+    validateMeshRefineConfig,
+} from '../../mesh/refine-config.js';
+import {
+    MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS,
+    MESH_WORKTREE_BOOTSTRAP_CONFIG_SCHEMA,
+} from '../../mesh/worktree-bootstrap-config.js';
+import type { LowFamilyContext, LowFamilyHandler } from './types.js';
+
+export const refineConfigHandlers: Record<string, LowFamilyHandler> = {
+    get_mesh_refine_config_schema: async (_ctx: LowFamilyContext, _args: any) => {
+        return {
+            success: true,
+            schema: MESH_REFINE_CONFIG_SCHEMA,
+            locations: MESH_REFINE_CONFIG_LOCATIONS,
+            worktreeBootstrap: {
+                schema: MESH_WORKTREE_BOOTSTRAP_CONFIG_SCHEMA,
+                locations: MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS,
+                sourceOfTruth: 'repo worktree bootstrap config',
+                runBehavior: 'When present and enabled, clone_mesh_node runs commands after submodule initialization and records status on the worktree node.',
+            },
+            sourceOfTruth: 'repo mesh/refine config',
+            heuristicRole: 'suggestions_only_not_execution_path',
+        };
+    },
+
+    validate_mesh_refine_config: async (_ctx: LowFamilyContext, args: any) => {
+        const workspace = typeof args?.workspace === 'string' ? args.workspace : process.cwd();
+        const mesh = args?.inlineMesh || {};
+        const loaded = args?.config !== undefined
+            ? { config: args.config, source: 'inline', sourceType: 'mesh_policy' as const }
+            : loadMeshRefineConfig(mesh, workspace);
+        const validation = loaded.config
+            ? validateMeshRefineConfig(loaded.config, loaded.source)
+            : { valid: false, errors: [((loaded as { error?: string }).error) || 'repo mesh/refine config unavailable'], commands: [], rejectedCommands: [] };
+        return { success: validation.valid, ...loaded, ...validation };
+    },
+
+    suggest_mesh_refine_config: async (_ctx: LowFamilyContext, args: any) => {
+        const workspace = typeof args?.workspace === 'string' ? args.workspace : process.cwd();
+        const mesh = args?.inlineMesh || {};
+        return {
+            success: true,
+            ...suggestMeshRefineConfig(mesh, workspace),
+            note: 'Suggestions are heuristic scaffold only; Refinery will not execute them until saved into repo mesh/refine config.',
+        };
+    },
+
+    get_mesh_change_impact_config_schema: async (_ctx: LowFamilyContext, _args: any) => {
+        return {
+            success: true,
+            schema: CHANGE_IMPACT_CONFIG_SCHEMA,
+            locations: CHANGE_IMPACT_CONFIG_LOCATIONS,
+            sourceOfTruth: 'repo change-impact config',
+            heuristicRole: 'suggestions_only_not_execution_path',
+            note: 'Declarative config only — JSON/YAML are parsed but never executed. Defines which package/file changes require a daemon rebuild/restart vs. a web-only redeploy vs. nothing.',
+        };
+    },
+
+    validate_mesh_change_impact_config: async (_ctx: LowFamilyContext, args: any) => {
+        const workspace = typeof args?.workspace === 'string' ? args.workspace : process.cwd();
+        if (args?.config !== undefined) {
+            const validation = validateChangeImpactConfig(args.config, 'inline');
+            return { success: validation.valid, source: 'inline', sourceType: 'mesh_policy', ...validation };
+        }
+        const loaded = loadChangeImpactConfig(workspace);
+        if (loaded.sourceType === 'repo_file') {
+            const validation = validateChangeImpactConfig(loaded.config, loaded.source);
+            return { success: validation.valid, ...loaded, ...validation };
+        }
+        return {
+            success: false,
+            ...loaded,
+            valid: false,
+            errors: [loaded.error || 'repo change-impact config unavailable'],
+        };
+    },
+
+    suggest_mesh_change_impact_config: async (_ctx: LowFamilyContext, args: any) => {
+        const workspace = typeof args?.workspace === 'string' ? args.workspace : process.cwd();
+        return {
+            success: true,
+            ...suggestChangeImpactConfig(workspace),
+            note: 'Suggestions are heuristic scaffold only; the draft must be reviewed and saved into repo change-impact config before it takes effect. Nothing is executed.',
+        };
+    },
+};

package/src/commands/low-family/session-host.ts

@@ -0,0 +1,274 @@
+/**
+ * RF-ROUTER LOW family — session-host control commands.
+ *
+ * Extracted verbatim from DaemonCommandRouter.executeDaemonCommand. Each handler
+ * reads only ctx.deps.sessionHostControl (+ cliManager for the resume/restart
+ * hosted-session restore) and returns the same CommandRouterResult as before.
+ * The trace/summarize helpers were `this`-free module functions in router.ts and
+ * are relocated here unchanged.
+ */
+import type { HostedCliRuntimeDescriptor } from '../cli-manager.js';
+import { recordDebugTrace } from '../../logging/debug-trace.js';
+import { getSessionHostSurfaceKind, partitionSessionHostRecords } from '../../session-host/runtime-surface.js';
+import type { LowFamilyContext, LowFamilyHandler } from './types.js';
+
+function toHostedCliRuntimeDescriptor(record: any): HostedCliRuntimeDescriptor | null {
+    if (!record || typeof record !== 'object') return null;
+    const runtimeId = typeof record.sessionId === 'string' ? record.sessionId : '';
+    const cliType = typeof record.providerType === 'string' ? record.providerType : '';
+    const workspace = typeof record.workspace === 'string' ? record.workspace : '';
+    if (!runtimeId || !cliType || !workspace) return null;
+    return {
+        runtimeId,
+        runtimeKey: typeof record.runtimeKey === 'string' ? record.runtimeKey : undefined,
+        displayName: typeof record.displayName === 'string' ? record.displayName : undefined,
+        workspaceLabel: typeof record.workspaceLabel === 'string' ? record.workspaceLabel : undefined,
+        lifecycle: typeof record.lifecycle === 'string' ? record.lifecycle as HostedCliRuntimeDescriptor['lifecycle'] : undefined,
+        recoveryState: typeof record.meta?.runtimeRecoveryState === 'string'
+            ? String(record.meta.runtimeRecoveryState)
+            : null,
+        cliType,
+        workspace,
+        cliArgs: Array.isArray(record.meta?.cliArgs) ? record.meta.cliArgs as string[] : [],
+        providerSessionId: typeof record.meta?.providerSessionId === 'string'
+            ? String(record.meta.providerSessionId)
+            : undefined,
+    };
+}
+
+function getWriteConflictOwnerClientId(error: unknown): string | undefined {
+    const message = typeof error === 'string'
+        ? error
+        : error instanceof Error
+            ? error.message
+            : '';
+    const match = /^Write owned by\s+(.+)$/.exec(message.trim());
+    return match?.[1]?.trim() || undefined;
+}
+
+function summarizeSessionHostRecord(result: unknown): Record<string, unknown> {
+    if (!result || typeof result !== 'object') return {};
+    const record = result as Record<string, any>;
+    return {
+        runtimeKey: typeof record.runtimeKey === 'string' ? record.runtimeKey : undefined,
+        lifecycle: typeof record.lifecycle === 'string' ? record.lifecycle : undefined,
+        surfaceKind: getSessionHostSurfaceKind(record as any),
+        attachedClientCount: Array.isArray(record.attachedClients) ? record.attachedClients.length : undefined,
+        hasWriteOwner: !!record.writeOwner,
+        writeOwnerClientId: typeof record.writeOwner?.clientId === 'string' ? record.writeOwner.clientId : undefined,
+    };
+}
+
+function summarizeSessionHostRecords(result: unknown): Record<string, unknown> {
+    const records = Array.isArray(result) ? result : [];
+    const groups = partitionSessionHostRecords(records as any[]);
+    return {
+        sessionCount: records.length,
+        liveRuntimeCount: groups.liveRuntimes.length,
+        recoverySnapshotCount: groups.recoverySnapshots.length,
+        inactiveRecordCount: groups.inactiveRecords.length,
+    };
+}
+
+function summarizeSessionHostDiagnostics(result: unknown): Record<string, unknown> {
+    const diagnostics = result && typeof result === 'object' ? result as Record<string, any> : {};
+    const sessions = Array.isArray(diagnostics.sessions) ? diagnostics.sessions : [];
+    return {
+        runtimeCount: typeof diagnostics.runtimeCount === 'number' ? diagnostics.runtimeCount : undefined,
+        ...summarizeSessionHostRecords(sessions),
+    };
+}
+
+function summarizeSessionHostPruneResult(result: unknown): Record<string, unknown> {
+    const value = result && typeof result === 'object' ? result as Record<string, any> : {};
+    return {
+        duplicateGroupCount: typeof value.duplicateGroupCount === 'number' ? value.duplicateGroupCount : undefined,
+        prunedCount: Array.isArray(value.prunedSessionIds) ? value.prunedSessionIds.length : undefined,
+        keptCount: Array.isArray(value.keptSessionIds) ? value.keptSessionIds.length : undefined,
+    };
+}
+
+async function traceSessionHostAction<T>(
+    action: string,
+    args: any,
+    run: () => Promise<T>,
+    summarizeResult?: (result: T) => Record<string, unknown>,
+): Promise<T> {
+    const interactionId = typeof args?._interactionId === 'string' ? args._interactionId : undefined;
+    const sessionId = typeof args?.sessionId === 'string' ? args.sessionId : undefined;
+    const requestedPayload: Record<string, unknown> = { action };
+    if (sessionId) requestedPayload.sessionId = sessionId;
+    if (typeof args?.clientId === 'string') requestedPayload.clientId = args.clientId;
+    if (typeof args?.signal === 'string') requestedPayload.signal = args.signal;
+    if (typeof args?.providerType === 'string') requestedPayload.providerType = args.providerType;
+    if (typeof args?.workspace === 'string') requestedPayload.workspace = args.workspace;
+    if (typeof args?.dryRun === 'boolean') requestedPayload.dryRun = args.dryRun;
+
+    recordDebugTrace({
+        interactionId,
+        category: 'session_host',
+        stage: 'action_requested',
+        level: 'info',
+        sessionId,
+        payload: requestedPayload,
+    });
+
+    try {
+        const result = await run();
+        recordDebugTrace({
+            interactionId,
+            category: 'session_host',
+            stage: 'action_result',
+            level: 'info',
+            sessionId,
+            payload: {
+                ...requestedPayload,
+                success: true,
+                ...(summarizeResult ? summarizeResult(result) : {}),
+            },
+        });
+        return result;
+    } catch (error: any) {
+        recordDebugTrace({
+            interactionId,
+            category: 'session_host',
+            stage: 'action_failed',
+            level: 'error',
+            sessionId,
+            payload: {
+                ...requestedPayload,
+                error: error?.message || String(error),
+                failureKind: getWriteConflictOwnerClientId(error) ? 'write_conflict' : 'request_failed',
+                conflictOwnerClientId: getWriteConflictOwnerClientId(error),
+            },
+        });
+        throw error;
+    }
+}
+
+export const sessionHostHandlers: Record<string, LowFamilyHandler> = {
+    session_host_get_diagnostics: async (ctx: LowFamilyContext, args: any) => {
+        if (!ctx.deps.sessionHostControl) return { success: false, error: 'Session host control unavailable' };
+        const diagnostics = await traceSessionHostAction('session_host_get_diagnostics', args, () => ctx.deps.sessionHostControl!.getDiagnostics({
+            includeSessions: args?.includeSessions !== false,
+            limit: Number(args?.limit) || undefined,
+        }), (result) => ({
+            includeSessions: args?.includeSessions !== false,
+            limit: Number(args?.limit) || undefined,
+            ...summarizeSessionHostDiagnostics(result),
+        }));
+        return { success: true, diagnostics };
+    },
+
+    session_host_list_sessions: async (ctx: LowFamilyContext, args: any) => {
+        if (!ctx.deps.sessionHostControl) return { success: false, error: 'Session host control unavailable' };
+        const sessions = await traceSessionHostAction('session_host_list_sessions', args, () => ctx.deps.sessionHostControl!.listSessions(), (records) => summarizeSessionHostRecords(records));
+        return { success: true, sessions };
+    },
+
+    session_host_stop_session: async (ctx: LowFamilyContext, args: any) => {
+        if (!ctx.deps.sessionHostControl) return { success: false, error: 'Session host control unavailable' };
+        const sessionId = typeof args?.sessionId === 'string' ? args.sessionId : '';
+        if (!sessionId) return { success: false, error: 'sessionId required' };
+        const record = await traceSessionHostAction('session_host_stop_session', args, () => ctx.deps.sessionHostControl!.stopSession(sessionId), (result) => summarizeSessionHostRecord(result));
+        return { success: true, record };
+    },
+
+    session_host_resume_session: async (ctx: LowFamilyContext, args: any) => {
+        if (!ctx.deps.sessionHostControl) return { success: false, error: 'Session host control unavailable' };
+        const sessionId = typeof args?.sessionId === 'string' ? args.sessionId : '';
+        if (!sessionId) return { success: false, error: 'sessionId required' };
+        const record = await traceSessionHostAction('session_host_resume_session', args, async () => {
+            const nextRecord = await ctx.deps.sessionHostControl!.resumeSession(sessionId);
+            const hosted = toHostedCliRuntimeDescriptor(nextRecord);
+            if (hosted) {
+                await ctx.deps.cliManager.restoreHostedSessions([hosted]);
+            }
+            return nextRecord;
+        }, (result) => ({
+            ...summarizeSessionHostRecord(result),
+            restoredHostedSession: !!toHostedCliRuntimeDescriptor(result),
+        }));
+        return { success: true, record };
+    },
+
+    session_host_restart_session: async (ctx: LowFamilyContext, args: any) => {
+        if (!ctx.deps.sessionHostControl) return { success: false, error: 'Session host control unavailable' };
+        const sessionId = typeof args?.sessionId === 'string' ? args.sessionId : '';
+        if (!sessionId) return { success: false, error: 'sessionId required' };
+        const record = await traceSessionHostAction('session_host_restart_session', args, async () => {
+            const nextRecord = await ctx.deps.sessionHostControl!.restartSession(sessionId);
+            const hosted = toHostedCliRuntimeDescriptor(nextRecord);
+            if (hosted) {
+                await ctx.deps.cliManager.restoreHostedSessions([hosted]);
+            }
+            return nextRecord;
+        }, (result) => ({
+            ...summarizeSessionHostRecord(result),
+            restoredHostedSession: !!toHostedCliRuntimeDescriptor(result),
+        }));
+        return { success: true, record };
+    },
+
+    session_host_send_signal: async (ctx: LowFamilyContext, args: any) => {
+        if (!ctx.deps.sessionHostControl) return { success: false, error: 'Session host control unavailable' };
+        const sessionId = typeof args?.sessionId === 'string' ? args.sessionId : '';
+        const signal = typeof args?.signal === 'string' ? args.signal : '';
+        if (!sessionId) return { success: false, error: 'sessionId required' };
+        if (!signal) return { success: false, error: 'signal required' };
+        const record = await traceSessionHostAction('session_host_send_signal', args, () => ctx.deps.sessionHostControl!.sendSignal(sessionId, signal), (result) => summarizeSessionHostRecord(result));
+        return { success: true, record };
+    },
+
+    session_host_force_detach_client: async (ctx: LowFamilyContext, args: any) => {
+        if (!ctx.deps.sessionHostControl) return { success: false, error: 'Session host control unavailable' };
+        const sessionId = typeof args?.sessionId === 'string' ? args.sessionId : '';
+        const clientId = typeof args?.clientId === 'string' ? args.clientId : '';
+        if (!sessionId) return { success: false, error: 'sessionId required' };
+        if (!clientId) return { success: false, error: 'clientId required' };
+        const record = await traceSessionHostAction('session_host_force_detach_client', args, () => ctx.deps.sessionHostControl!.forceDetachClient(sessionId, clientId), (result) => summarizeSessionHostRecord(result));
+        return { success: true, record };
+    },
+
+    session_host_prune_duplicate_sessions: async (ctx: LowFamilyContext, args: any) => {
+        if (!ctx.deps.sessionHostControl) return { success: false, error: 'Session host control unavailable' };
+        const result = await traceSessionHostAction('session_host_prune_duplicate_sessions', args, () => ctx.deps.sessionHostControl!.pruneDuplicateSessions({
+            providerType: typeof args?.providerType === 'string' ? args.providerType : undefined,
+            workspace: typeof args?.workspace === 'string' ? args.workspace : undefined,
+            dryRun: args?.dryRun === true,
+        }), (value) => summarizeSessionHostPruneResult(value));
+        return { success: true, result };
+    },
+
+    session_host_acquire_write: async (ctx: LowFamilyContext, args: any) => {
+        if (!ctx.deps.sessionHostControl) return { success: false, error: 'Session host control unavailable' };
+        const sessionId = typeof args?.sessionId === 'string' ? args.sessionId : '';
+        const clientId = typeof args?.clientId === 'string' ? args.clientId : '';
+        const ownerType = args?.ownerType === 'agent' ? 'agent' : 'user';
+        if (!sessionId) return { success: false, error: 'sessionId required' };
+        if (!clientId) return { success: false, error: 'clientId required' };
+        const record = await traceSessionHostAction('session_host_acquire_write', args, () => ctx.deps.sessionHostControl!.acquireWrite({
+            sessionId,
+            clientId,
+            ownerType,
+            force: args?.force !== false,
+        }), (result) => ({
+            ...summarizeSessionHostRecord(result),
+            ownerType,
+        }));
+        return { success: true, record };
+    },
+
+    session_host_release_write: async (ctx: LowFamilyContext, args: any) => {
+        if (!ctx.deps.sessionHostControl) return { success: false, error: 'Session host control unavailable' };
+        const sessionId = typeof args?.sessionId === 'string' ? args.sessionId : '';
+        const clientId = typeof args?.clientId === 'string' ? args.clientId : '';
+        if (!sessionId) return { success: false, error: 'sessionId required' };
+        if (!clientId) return { success: false, error: 'clientId required' };
+        const record = await traceSessionHostAction('session_host_release_write', args, () => ctx.deps.sessionHostControl!.releaseWrite({
+            sessionId,
+            clientId,
+        }), (result) => summarizeSessionHostRecord(result));
+        return { success: true, record };
+    },
+};