@pellux/goodvibes-agent 1.1.7 → 1.3.0

package/src/tools/agent-harness-tool.ts

@@ -1,131 +1,64 @@
 import type { Tool } from '@pellux/goodvibes-sdk/platform/types';
 import type { ToolRegistry } from '@pellux/goodvibes-sdk/platform/tools';
 import type { CommandContext, CommandRegistry } from '../input/command-registry.ts';
-import { buildAgentWorkspaceCommandEditorSubmission, isAgentWorkspaceCommandEditorKind } from '../input/agent-workspace-command-editor.ts';
-import { isAffirmative, splitList } from '../input/agent-workspace-editors.ts';
-import { createAgentWorkspaceLearnedBehavior } from '../input/agent-workspace-learned-behavior.ts';
-import type { AgentWorkspaceAction, AgentWorkspaceLocalEditor } from '../input/agent-workspace-types.ts';
-import { channelReadinessCatalogStatus, describeHarnessChannel, listHarnessChannels } from './agent-harness-channel-metadata.ts';
+import { agentOrchestrationCatalogStatus, agentOrchestrationSummary, describeAgentOrchestrationAgent } from './agent-harness-agent-orchestration.ts';
+import { autonomyIntakeSummary } from './agent-harness-autonomy-intake.ts';
+import { autonomyQueueCatalogStatus, autonomyQueueSummary, describeAutonomyQueueItem } from './agent-harness-autonomy-queue.ts';
+import { channelReadinessCatalogStatus, describeHarnessChannel, describeHarnessChannelDeliveries, describeHarnessChannelSetupGuide, describeHarnessChannelTriage, listHarnessChannels } from './agent-harness-channel-metadata.ts';
 import { blockedHarnessCliCommandTokens, describeHarnessCliCommand, listHarnessCliCommands, totalHarnessCliCommands } from './agent-harness-cli-metadata.ts';
-import { describeHarnessCommand, listHarnessCommands, resolveHarnessCommandDetail, type CommandDetailLookup } from './agent-harness-command-catalog.ts';
+import { describeHarnessCommand, listHarnessCommands } from './agent-harness-command-catalog.ts';
+import { describeLearningCandidate, learningCuratorCatalogStatus, learningCuratorSummary } from './agent-harness-learning-curator.ts';
 import { delegationPostureCatalogStatus, delegationPostureSummary, describeHarnessDelegationRoute } from './agent-harness-delegation-posture.ts';
 import { describeHarnessKeybinding, listHarnessKeybindings, listHarnessShortcuts, resetHarnessKeybinding, runHarnessKeybinding, setHarnessKeybinding, totalHarnessKeybindings, totalHarnessShortcuts } from './agent-harness-keybinding-metadata.ts';
 import { describeHarnessMediaProvider, mediaPostureCatalogStatus, mediaPostureSummary } from './agent-harness-media-posture.ts';
 import { describeHarnessNotificationTarget, listHarnessNotificationTargets, notificationTargetCatalogStatus } from './agent-harness-notification-metadata.ts';
 import { describeHarnessPanel, listHarnessPanels, openHarnessPanel, totalHarnessPanels } from './agent-harness-panel-metadata.ts';
 import { connectedHostStatusSummary } from './agent-harness-connected-host-status.ts';
-import { runLocalWorkspaceAction, runLocalWorkspaceEditorAction } from './agent-harness-local-operations.ts';
+import { backgroundProcessCatalogStatus, backgroundProcessSummary, describeBackgroundProcess, runBackgroundProcessAction } from './agent-harness-background-processes.ts';
+import { describeDocumentOpsLane, documentOpsCatalogStatus, documentOpsSummary } from './agent-harness-document-ops.ts';
+import { browserControlRouteSummary } from './agent-harness-browser-control.ts';
+import { describeExecutionHistoryItem, executionHistoryCatalogStatus, executionHistorySummary } from './agent-harness-execution-history.ts';
+import { describeHarnessExecutionRoute, executionPostureCatalogStatus, executionPostureSummary } from './agent-harness-execution-posture.ts';
+import { fileRecoveryCatalogStatus, fileRecoverySummary, runFileRecovery } from './agent-harness-file-recovery.ts';
 import { describeHarnessMcpServer, mcpServerCatalogStatus, mcpServerSummary } from './agent-harness-mcp-metadata.ts';
-import { describeHarnessModelRoute, modelRoutingCatalogStatus, modelRoutingSummary } from './agent-harness-model-routing.ts';
+import { describeHarnessModelRoute, modelRoutingCatalogStatus, modelRoutingSummary, runLocalModelServerSmoke } from './agent-harness-model-routing.ts';
 import { describeHarnessModelTool, listHarnessModelTools } from './agent-harness-model-tool-catalog.ts';
+import { describeMemoryProvider, memoryPostureCatalogStatus, memoryPostureSummary } from './agent-harness-memory-posture.ts';
+import { memoryRefinementCatalogStatus, memoryRefinementSummary, runMemoryRefinement } from './agent-harness-memory-refinement.ts';
 import { describeHarnessOperatorMethod, operatorMethodCatalogStatus, operatorMethodSummary } from './agent-harness-operator-methods.ts';
+import { describePersonalOpsLane, personalOpsBriefingSummary, personalOpsCatalogStatus, personalOpsIntakeSummary, personalOpsQueueSummary, personalOpsSummary, runPersonalOpsRead } from './agent-harness-personal-ops.ts';
 import { describeHarnessPairingRoute, pairingPostureCatalogStatus, pairingPostureSummary } from './agent-harness-pairing-posture.ts';
+import { explainAgentPolicyDecision } from './agent-policy-explanation.ts';
+import { promptContextCatalogStatus, promptContextSummary } from './agent-harness-prompt-context.ts';
+import { describeProjectContextFile, projectContextCatalogStatus, projectContextSummary } from './agent-harness-project-context.ts';
 import { describeHarnessProviderAccount, providerAccountCatalogStatus, providerAccountSummary } from './agent-harness-provider-account-metadata.ts';
+import { planAgentTaskRoute } from './agent-route-planner.ts';
 import { describeHarnessReleaseEvidenceArtifact, releaseEvidenceBundleStatus, releaseEvidenceSummary } from './agent-harness-release-evidence.ts';
 import { describeHarnessReleaseReadinessItem, releaseReadinessInventoryStatus, releaseReadinessSummary } from './agent-harness-release-readiness.ts';
+import { researchBriefingCatalogStatus, researchBriefingSummary } from './agent-harness-research-briefing.ts';
+import { describeResearchRun, researchRunsCatalogStatus, researchRunsSummary } from './agent-harness-research-runs.ts';
+import { researchWorkflowSummary } from './agent-harness-research-workflow.ts';
+import { describeResearchSource, researchQueueCatalogStatus, researchQueueSummary } from './agent-harness-research-queue.ts';
 import { describeHarnessSecurityFinding, describeHarnessSupportBundle, securityPostureCatalogStatus, securityPostureSummary, supportBundleCatalogStatus, supportBundleSummary } from './agent-harness-security-posture.ts';
 import { describeHarnessSession, sessionCatalogStatus, sessionSummary } from './agent-harness-session-metadata.ts';
 import { describeHarnessServiceEndpoint, servicePostureCatalogStatus, servicePostureSummary } from './agent-harness-service-posture.ts';
-import { describeHarnessSetupItem, setupPostureCatalogStatus, setupPostureSummary } from './agent-harness-setup-posture.ts';
+import { clearSetupCheckpoint, describeHarnessSetupItem, markSetupCheckpoint, provisionConnectedHostOperatorToken, runSetupInstallSmoke, setupCheckpointSummary, setupPostureCatalogStatus, setupPostureSummary, setupRepairSummary } from './agent-harness-setup-posture.ts';
 import { AGENT_HARNESS_MODES, AGENT_HARNESS_PARAMETER_PROPERTIES } from './agent-harness-tool-schema.ts';
+import { runCommand } from './agent-harness-command-runner.ts';
+import { runWorkspaceAction } from './agent-harness-workspace-action-runner.ts';
+import type { AgentHarnessToolArgs, AgentHarnessToolDeps } from './agent-harness-tool-types.ts';
+import { error, output, readLimit, readString, requireConfirmedAction, settingLookupArgs } from './agent-harness-tool-utils.ts';
 import { describeHarnessMode, HARNESS_MODE_DESCRIPTORS, listHarnessModes, type AgentHarnessMode } from './agent-harness-mode-catalog.ts';
 import { describeHarnessUiSurface, listHarnessUiSurfaces, openHarnessUiSurface, totalHarnessUiSurfaces } from './agent-harness-ui-surface-metadata.ts';
-import { AGENT_WORKSPACE_CATEGORIES, allWorkspaceActions, buildWorkspaceEditorContext, createWorkspaceEditor, describeWorkspaceAction, describeWorkspaceCategory, describeWorkspaceEditor, listWorkspaceActions, resolveWorkspaceActionDetail } from './agent-harness-workspace-actions.ts';
-import { describeWorkspaceEditorModelExecution } from './agent-harness-workspace-editor-execution.ts';
+import { AGENT_WORKSPACE_CATEGORIES, allWorkspaceActions, buildWorkspaceEditorContext, describeWorkspaceAction, describeWorkspaceCategory, listWorkspaceActions, resolveWorkspaceActionDetail } from './agent-harness-workspace-actions.ts';
 import { connectedHostSummary, describeConnectedHostCapability, settingsPolicySummary } from './agent-harness-metadata.ts';
 import { countHarnessSettings, formatHarnessError, listHarnessSettings, resetHarnessSetting, resolveHarnessSetting, setHarnessSetting } from '../agent/harness-control.ts';
-
-interface AgentHarnessToolArgs {
-  readonly mode?: unknown;
-  readonly query?: unknown;
-  readonly command?: unknown;
-  readonly cliCommand?: unknown;
-  readonly commandName?: unknown;
-  readonly args?: unknown;
-  readonly channelId?: unknown;
-  readonly notificationTargetId?: unknown;
-  readonly providerId?: unknown;
-  readonly mcpServerId?: unknown;
-  readonly setupItemId?: unknown;
-  readonly modelRouteId?: unknown;
-  readonly pairingRouteId?: unknown;
-  readonly delegationRouteId?: unknown;
-  readonly findingId?: unknown;
-  readonly bundlePath?: unknown;
-  readonly mediaProviderId?: unknown;
-  readonly sessionId?: unknown;
-  readonly categoryId?: unknown;
-  readonly panelId?: unknown;
-  readonly actionId?: unknown;
-  readonly recordId?: unknown;
-  readonly fields?: unknown;
-  readonly combo?: unknown;
-  readonly combos?: unknown;
-  readonly surfaceId?: unknown;
-  readonly key?: unknown;
-  readonly value?: unknown;
-  readonly target?: unknown;
-  readonly artifactId?: unknown;
-  readonly itemId?: unknown;
-  readonly methodId?: unknown;
-  readonly endpointId?: unknown;
-  readonly capabilityId?: unknown;
-  readonly toolName?: unknown;
-  readonly category?: unknown;
-  readonly prefix?: unknown;
-  readonly includeHidden?: unknown;
-  readonly includeParameters?: unknown;
-  readonly limit?: unknown;
-  readonly pane?: unknown;
-  readonly confirm?: unknown;
-  readonly explicitUserRequest?: unknown;
-}
-
-interface AgentHarnessToolDeps {
-  readonly commandRegistry: CommandRegistry;
-  readonly commandContext: CommandContext;
-  readonly toolRegistry: ToolRegistry;
-}
+import { buildAssistantCockpitFromSummaries } from '../agent/assistant-cockpit.ts';
 
 function isMode(value: unknown): value is AgentHarnessMode {
   return typeof value === 'string' && AGENT_HARNESS_MODES.includes(value as AgentHarnessMode);
 }
 
-function readString(value: unknown): string {
-  return typeof value === 'string' ? value.trim() : '';
-}
-
-function settingLookupArgs(args: AgentHarnessToolArgs) {
-  return {
-    key: readString(args.key) || undefined,
-    target: readString(args.target) || undefined,
-    query: readString(args.query) || undefined,
-    category: readString(args.category) || undefined,
-    prefix: readString(args.prefix) || undefined,
-    includeHidden: args.includeHidden === true,
-  };
-}
-
-function readLimit(value: unknown, fallback: number): number {
-  const parsed = typeof value === 'string' && value.trim() ? Number(value) : value;
-  if (typeof parsed !== 'number' || !Number.isFinite(parsed)) return fallback;
-  return Math.max(1, Math.min(500, Math.trunc(parsed)));
-}
-
-function readFieldMap(value: unknown): Readonly<Record<string, string>> {
-  if (typeof value !== 'object' || value === null || Array.isArray(value)) return {};
-  return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, typeof entry === 'string' ? entry : String(entry)]));
-}
-
-function output(value: unknown): { readonly success: true; readonly output: string } {
-  return {
-    success: true,
-    output: typeof value === 'string' ? value : JSON.stringify(value, null, 2),
-  };
-}
-
-function error(message: string): { readonly success: false; readonly error: string } { return { success: false, error: message }; }
-
 function harnessModeIdsByKind(kind: AgentHarnessModeGuideKind): readonly AgentHarnessMode[] {
   return HARNESS_MODE_DESCRIPTORS
     .filter((descriptor) => descriptor.kind === kind)
@@ -147,254 +80,53 @@ function compactHarnessModeGuide(): Record<string, unknown> {
 
 function detailedHarnessModelAccessGuide(): Record<string, string> {
   return {
-    cliCommands: 'List mode:"cli_commands"; inspect mode:"cli_command" with cliCommand|commandName|query. Discovery only.',
-    panels: 'List mode:"panels"; inspect mode:"panel"; navigate mode:"open_panel" with confirm:true and explicitUserRequest.',
-    uiSurfaces: 'List mode:"ui_surfaces"; inspect mode:"ui_surface"; navigate mode:"open_ui_surface" with confirmation.',
-    shortcuts: 'List mode:"shortcuts"; inspect mode:"keybinding"; run mode:"run_keybinding"; edit with set_keybinding/reset_keybinding and confirmation.',
-    slashCommands: 'List mode:"commands"; inspect mode:"command"; execute mode:"run_command" with confirmation.',
-    channels: 'List mode:"channels"; inspect mode:"channel"; deliver with agent_channel_send and confirmation.',
+    cliCommands: 'Prefer workspace action:"cli_commands|cli_command" for CLI discovery. Lower-level cli command modes remain available.',
+    panels: 'Prefer workspace action:"panels|panel|open_panel"; visible navigation needs confirm:true and explicitUserRequest.',
+    uiSurfaces: 'Prefer workspace action:"surfaces|surface|open" for visible UI and computer action:"browser|open_browser" for browser/PWA. Lower-level UI modes remain available.',
+    shortcuts: 'Prefer workspace action:"shortcuts|keybindings|keybinding|run_keybinding|set_keybinding|reset_keybinding"; effects need confirmation.',
+    slashCommands: 'Prefer workspace action:"commands|command|run_command"; slash-command execution needs confirmation.',
+    channels: 'Prefer channels action:"status|channel|setup|triage|deliveries"; deliver with agent_channel_send and confirmation. Lower-level channel harness modes remain available for detail.',
     notifications: 'List mode:"notifications"; inspect mode:"notification_target"; deliver with agent_notify and confirmation.',
-    providerAccounts: 'List mode:"provider_accounts"; inspect mode:"provider_account"; auth changes stay confirmed workspace/command flows.',
+    providerAccounts: 'Prefer models action:"providers|provider" for account and subscription posture. Lower-level mode:"provider_accounts" and mode:"provider_account" remain available; auth changes stay confirmed workspace/command flows.',
     mcpServers: 'List mode:"mcp_servers"; inspect mode:"mcp_server"; trust/server changes stay confirmed workspace/command flows.',
-    setupPosture: 'List mode:"setup_posture"; inspect mode:"setup_item"; setup mutations stay confirmed visible flows.',
-    modelRouting: 'List mode:"model_routing"; inspect mode:"model_route"; selection and provider edits stay confirmed visible flows.',
-    pairingPosture: 'List mode:"pairing_posture"; inspect mode:"pairing_route"; raw token/QR and pairing effects stay visible user flows.',
-    delegationPosture: 'List mode:"delegation_posture"; inspect mode:"delegation_route"; delegated submission stays confirmed visible flow.',
-    securityPosture: 'List mode:"security_posture"; inspect mode:"security_finding"; mutate only through confirmed security routes.',
-    supportBundles: 'List mode:"support_bundles"; inspect mode:"support_bundle"; export/import stays confirmation-gated.',
-    mediaPosture: 'List mode:"media_posture"; inspect mode:"media_provider"; generate with agent_media_generate and confirmation.',
-    sessions: 'List mode:"sessions"; inspect mode:"session"; save/resume/export/delete stays visible confirmed flow.',
-    workspace: 'List mode:"workspace" or mode:"workspace_categories"; actions via mode:"workspace_actions", mode:"workspace_action", and mode:"run_workspace_action"; includeParameters:true inlines editor schemas.',
-    settings: 'List mode:"settings" with category|prefix|query|includeHidden:true; mode:"get_setting", mode:"set_setting", and mode:"reset_setting" use key|target|query; writes require confirmation.',
+    setupPosture: 'Prefer setup action:"status|item|repair|checkpoint|token|smoke|finish"; lower-level setup_* modes remain available for detailed harness inspection.',
+    routeDecision: 'Prefer route action:"plan" before choosing a specialized tool when the user task could map to setup, Personal Ops, research, autonomy, execution, delegation, computer/browser, workspace, host, or device routes.',
+    projectContext: 'Prefer context action:"files|file"; lower-level project_context modes remain available for detail. Context files are read-only and secret-scanned.',
+    promptContext: 'Prefer context action:"prompt|receipts|receipt" for prompt composition, selected/suppressed records, token budget, and prompt receipt outcomes.',
+    agentOrchestration: 'List mode:"agent_orchestration" for managed plan and closeout cards; dispatch approved plan items with agent_work_plan action:"dispatch_agents"; inspect mode:"agent_orchestration_agent"; spawn/message/wait/cancel stay on first-class agent.',
+    modelRouting: 'Prefer models action:"status|local|route|smoke" for model choice, local cookbook, route inspection, and confirmed local server checks. Lower-level mode:"model_routing", mode:"model_route", and mode:"run_local_model_smoke" remain available; changes stay visible.',
+    executionPosture: 'Prefer execution action:"status|route"; use computer action:"plan" for browser, screenshot, or desktop-control route planning; use local read/edit/exec when current workspace is sufficient, delegation for isolation/parallel/remote.',
+    backgroundProcesses: 'Use execution action:"processes|process|capabilities" to inspect tracked local commands and process parity, terminal background:true to start visible tracked commands, and process action:list|poll|log|wait|kill|write to manage them. Lower-level background_* modes remain for compatibility. process action:"capabilities" probes SDK/daemon interactive contracts; write dispatches only when a safe ProcessManager stdin method exists and is explicitly confirmed; PTY/sudo stay typed-contract or foreground-only boundaries.',
+    executionHistory: 'Prefer execution action:"history|record" for activity cards and records; use returned verification, supervision, and recovery routes.',
+    fileRecovery: 'Prefer execution action:"recovery"; apply local file undo/redo snapshots with mode:"run_file_recovery" and confirmation.',
+    personalOps: 'Prefer personal_ops action:"briefing|status|queue|intake|lane|read"; lower-level modes personal_ops_briefing/personal_ops/personal_ops_queue/personal_ops_intake/personal_ops_lane/run_personal_ops_read remain available for harness inspection.',
+    memoryPosture: 'Prefer memory action:"status|provider|refinement|run_refinement|curator|candidate|list|search|get"; run_refinement, memory writes, vector rebuilds, and embedding-provider changes stay on confirmed existing routes.',
+    autonomyQueue: 'Prefer autonomy action:"intake|queue|item" for ongoing work and visible autonomous work; lower-level autonomy_* modes remain available for detail. Effects stay confirmed on the owning route.',
+    learningCurator: 'Prefer memory action:"curator|candidate"; writes stay on reviewed Agent-local routes.',
+    researchWorkflow: 'Prefer research action:"briefing" for the current next-action queue, action:"plan" for deep-research route planning, action:"search" for bounded public source candidates, and action:"runner" for browser-runner readiness; lower-level mode:"research_workflow" sequences visible run, web/fetch or browser posture, source queue, report, and Knowledge promotion routes.',
+    researchRuns: 'Prefer research action:"runs|run"; lower-level mode:"research_runs" and mode:"research_run" inspect run posture; checkpoint/cancel/complete stays confirmed.',
+    researchQueue: 'Prefer research action:"sources|source|bundle|reports|report_artifact"; lower-level research modes inspect source posture; capture/review/report/ingest stay confirmed.',
+    documentOps: 'List mode:"document_ops"; inspect mode:"document_ops_lane"; browse saved artifacts with agent_artifacts; use returned routes for documents, review packet wizard, reviewer readiness, uploads, exports, source checks, artifacts, and blind compare.',
+    pairingPosture: 'Prefer device action:"status|capability" for device maps. Lower-level mode:"pairing_posture" and mode:"pairing_route" remain available; raw token/QR and pairing effects stay visible user flows.',
+    delegationPosture: 'Prefer delegation action:"status|routes|route"; delegated submission stays confirmed visible flow.',
+    securityPosture: 'Prefer security action:"status|finding|explain"; lower-level security modes remain available for detail.',
+    supportBundles: 'Prefer support action:"status|bundle"; lower-level support-bundle modes remain available; export/import stays confirmation-gated.',
+    mediaPosture: 'Prefer device action:"voice|provider" for voice/media posture. Lower-level mode:"media_posture" and mode:"media_provider" remain available; generate with agent_media_generate and confirmation.',
+    sessions: 'Prefer sessions action:"list|get"; lower-level session modes remain available; save/resume/export/delete stays visible confirmed flow.',
+    workspace: 'Prefer workspace action:"status|actions|action|run|surfaces|surface|open|commands|command|run_command"; includeParameters:true inlines editor schemas.',
+    settings: 'Prefer settings action:"list|get|set|reset|import"; list accepts category|prefix|query|includeHidden:true; lower-level settings modes remain for compatibility.',
     tools: 'List mode:"tools" with query|limit|includeParameters:true; inspect mode:"tool" with toolName|target|query.',
     modeCatalog: 'Search mode:"modes" with query|target; inspect one contract with mode:"mode" target:"...".',
-    releaseEvidence: 'Operator/audit: list mode:"release_evidence"; inspect mode:"release_evidence_artifact"; includeParameters:true inlines artifact detail.',
-    releaseReadiness: 'Operator/audit: list mode:"release_readiness"; inspect mode:"release_readiness_item"; includeParameters:true inlines item detail.',
-    operatorMethods: 'List mode:"operator_methods"; inspect mode:"operator_method"; execute only through the returned first-class tool.',
-    servicePosture: 'List mode:"service_posture"; inspect mode:"service_endpoint"; includeParameters:true adds probes and redacted log tail.',
-    connectedHost: 'Map mode:"connected_host"; inspect mode:"connected_host_capability"; no lifecycle control.',
-    connectedHostStatus: 'Live read-only mode:"connected_host_status" for host reachability, token posture, and Knowledge readiness.',
-    daemon: 'Daemon aliases route to mode:"connected_host" and mode:"connected_host_status"; lifecycle control is not exposed.',
+    releaseEvidence: 'Operator/audit: prefer audit action:"evidence|artifact"; includeParameters:true inlines artifact detail.',
+    releaseReadiness: 'Operator/audit: prefer audit action:"readiness|item"; includeParameters:true inlines item detail.',
+    operatorMethods: 'Prefer host action:"methods|method"; lower-level mode:"operator_methods|operator_method" remains for detail. Run exact daemon methods with agent_operator_method; write/admin routes require confirmation.',
+    servicePosture: 'Prefer host action:"services|service"; lower-level mode:"service_posture|service_endpoint" remains for probes and redacted log tail.',
+    connectedHost: 'Prefer host action:"capabilities|capability"; lower-level mode:"connected_host|connected_host_capability" remains for route-family detail.',
+    connectedHostStatus: 'Prefer host action:"status" for host reachability, token posture, and Knowledge readiness.',
+    daemon: 'Daemon aliases route to host action:"capabilities|status"; use agent_operator_method for exact confirmed contract calls.',
   };
 }
 
-function requireConfirmedAction(args: AgentHarnessToolArgs, action: string): string | null {
-  const explicitUserRequest = readString(args.explicitUserRequest);
-  if (!explicitUserRequest) return `${action} requires explicitUserRequest with the user's exact request or a short faithful summary.`;
-  if (args.confirm !== true) return `${action} requires confirm:true after an explicit user request.`;
-  return null;
-}
-
-function invocationArgsFromLookup(lookup: CommandDetailLookup): readonly string[] {
-  return lookup.resolvedBy === 'description' ? [] : lookup.parsedArgs;
-}
-
-function safeCommandDisplay(name: string): string {
-  return `/${name}`;
-}
-
-async function runCommand(deps: AgentHarnessToolDeps, args: AgentHarnessToolArgs): Promise<{ readonly success: boolean; readonly output?: string; readonly error?: string }> {
-  const confirmationError = requireConfirmedAction(args, 'Slash command invocation');
-  if (confirmationError) return error(confirmationError);
-  const resolved = resolveHarnessCommandDetail(deps.commandRegistry, args);
-  if (resolved?.status === 'ambiguous') {
-    return error(`Ambiguous slash command ${resolved.input}. Candidates: ${JSON.stringify(resolved.candidates)}`);
-  }
-  if (!resolved) return error('run_command requires a valid command, commandName, target, or query. Use mode:"commands" to inspect available commands.');
-
-  const printed: string[] = [];
-  const toolContext: CommandContext = {
-    ...deps.commandContext,
-    print: (text: string) => {
-      printed.push(text);
-    },
-    renderRequest: () => {},
-    executeCommand: async (name: string, commandArgs: string[]) => {
-      return deps.commandRegistry.execute(name, commandArgs, toolContext);
-    },
-  };
-  const commandArgs = invocationArgsFromLookup(resolved.lookup);
-  const handled = await deps.commandRegistry.execute(resolved.command.name, [...commandArgs], toolContext);
-  if (!handled) return error(`Unknown slash command /${resolved.command.name}.`);
-  return output([
-    `Command ${safeCommandDisplay(resolved.command.name)} completed.`,
-    `Resolved by ${resolved.lookup.source} ${resolved.lookup.resolvedBy}.`,
-    printed.length > 0 ? printed.join('\n') : '(no text output)',
-  ].join('\n'));
-}
-
-function fieldReader(editor: AgentWorkspaceLocalEditor, fields: Readonly<Record<string, string>>): (fieldId: string) => string {
-  return (fieldId: string) => fields[fieldId] ?? editor.fields.find((field) => field.id === fieldId)?.value ?? '';
-}
-
-function missingRequiredEditorFields(editor: AgentWorkspaceLocalEditor, fields: Readonly<Record<string, string>>): readonly string[] {
-  const readField = fieldReader(editor, fields);
-  return editor.fields
-    .filter((field) => field.required && !readField(field.id).trim())
-    .map((field) => field.id);
-}
-
-async function runWorkspaceEditorAction(
-  deps: AgentHarnessToolDeps,
-  action: AgentWorkspaceAction,
-  editor: AgentWorkspaceLocalEditor,
-  args: AgentHarnessToolArgs,
-): Promise<{ readonly success: boolean; readonly output?: string; readonly error?: string }> {
-  const fields = readFieldMap(args.fields);
-  const missing = missingRequiredEditorFields(editor, fields);
-  if (missing.length > 0) {
-    return output({
-      status: 'missing_required_fields',
-      missing,
-      action: action.id,
-      editor: describeWorkspaceEditor(editor),
-      modelExecution: describeWorkspaceEditorModelExecution(editor.kind),
-    });
-  }
-
-  if (editor.kind === 'learned-behavior') {
-    const confirmationError = requireConfirmedAction(args, 'Workspace learned-behavior capture');
-    if (confirmationError) return error(confirmationError);
-    const shellPaths = deps.commandContext.workspace.shellPaths;
-    if (!shellPaths) return error('Agent shell paths are unavailable.');
-    const readField = fieldReader(editor, fields);
-    const target = readField('target').trim().toLowerCase();
-    if (target !== 'skill' && target !== 'routine' && target !== 'persona') {
-      return error('learned-behavior target must be skill, routine, or persona.');
-    }
-    const created = createAgentWorkspaceLearnedBehavior(shellPaths, {
-      target,
-      name: readField('name'),
-      description: readField('description'),
-      notes: readField('notes'),
-      tags: splitList(readField('tags')),
-      triggers: splitList(readField('triggers')),
-      enable: isAffirmative(readField('enable')),
-    });
-    return output({
-      status: 'created',
-      kind: created.kind,
-      id: created.id,
-      name: created.name,
-      policy: 'Agent-local behavior only; no connected-host mutation, default knowledge write, or delegated job was created.',
-    });
-  }
-
-  if (editor.kind === 'profile') {
-    const readField = fieldReader(editor, fields);
-    const name = readField('name');
-    const template = readField('template');
-    const parts = ['/agent-profile', 'create', name];
-    if (template.trim() && template.trim().toLowerCase() !== 'none') parts.push('--template', template);
-    parts.push('--yes');
-    return runCommand(deps, {
-      ...args,
-      command: parts.map((part, index) => index < 2 || part.startsWith('--') ? part : JSON.stringify(part)).join(' '),
-    });
-  }
-
-  if (!isAgentWorkspaceCommandEditorKind(editor.kind)) {
-    if (
-      editor.kind === 'memory'
-      || editor.kind === 'note'
-      || editor.kind === 'persona'
-      || editor.kind === 'skill'
-      || editor.kind === 'routine'
-    ) {
-      return runLocalWorkspaceEditorAction(deps, editor, args);
-    }
-    return output({
-      status: 'model_tool_required',
-      action: action.id,
-      editor: describeWorkspaceEditor(editor),
-      modelExecution: describeWorkspaceEditorModelExecution(editor.kind),
-    });
-  }
-
-  const submission = buildAgentWorkspaceCommandEditorSubmission(
-    editor,
-    fieldReader(editor, fields),
-    true,
-    true,
-  );
-  if (submission.kind === 'editor') {
-    return output({
-      status: submission.status,
-      action: action.id,
-      editor: describeWorkspaceEditor(submission.editor),
-      modelExecution: describeWorkspaceEditorModelExecution(editor.kind),
-      actionResult: submission.actionResult ?? null,
-    });
-  }
-  if (submission.kind === 'prompt') {
-    return output({
-      status: submission.status,
-      action: action.id,
-      prompt: submission.prompt,
-      actionResult: submission.actionResult,
-      modelExecution: describeWorkspaceEditorModelExecution(editor.kind),
-      note: 'This workspace action submits a normal main-conversation prompt in the TUI. In model-tool context, use the returned prompt as the conversation task instead of creating a hidden nested turn.',
-    });
-  }
-  return runCommand(deps, {
-    ...args,
-    command: submission.command,
-  });
-}
-
-async function runWorkspaceAction(
-  deps: AgentHarnessToolDeps,
-  args: AgentHarnessToolArgs,
-): Promise<{ readonly success: boolean; readonly output?: string; readonly error?: string }> {
-  const resolved = resolveWorkspaceActionDetail(args);
-  if (resolved?.status === 'ambiguous') return error(`Ambiguous Agent workspace action ${resolved.input}. Candidates: ${JSON.stringify(resolved.candidates)}`);
-  if (!resolved) return error('run_workspace_action requires a valid actionId, command, target, or query. Use mode:"workspace_actions" to inspect available actions.');
-  const { category, action, lookup } = resolved;
-
-  if (action.safety === 'blocked') {
-    return error(`Workspace action ${action.id} is blocked in Agent: ${action.detail}`);
-  }
-  if (action.kind === 'guidance') {
-    const editorContext = buildWorkspaceEditorContext(deps.commandContext, args);
-    return output({
-      status: 'guidance',
-      action: describeWorkspaceAction(category, action, { includeEditor: true, editorContext, lookup }),
-    });
-  }
-  if (action.kind === 'workspace' && action.targetCategoryId) {
-    const target = AGENT_WORKSPACE_CATEGORIES.find((entry) => entry.id === action.targetCategoryId);
-    return output({
-      status: 'workspace_target',
-      action: describeWorkspaceAction(category, action, { lookup }),
-      targetCategory: target ? describeWorkspaceCategory(target) : action.targetCategoryId,
-      targetActions: target ? target.actions.map((entry) => describeWorkspaceAction(target, entry)).slice(0, 40) : [],
-    });
-  }
-  if (action.kind === 'command' && action.command) {
-    if (/<[^>\s]+(?:\s+[^>]*)?>/.test(action.command)) {
-      return output({
-        status: 'needs_concrete_command',
-        action: describeWorkspaceAction(category, action, { lookup }),
-        note: 'This workspace action is a command template. Provide concrete values with mode:"run_command" once the exact command is known.',
-      });
-    }
-    return runCommand(deps, { ...args, command: action.command });
-  }
-  if (action.kind === 'editor' && action.editorKind) {
-    const editor = createWorkspaceEditor(action.editorKind, buildWorkspaceEditorContext(deps.commandContext, args));
-    if (!editor) return error(`No workspace editor route exists for ${action.editorKind}.`);
-    return runWorkspaceEditorAction(deps, action, editor, args);
-  }
-  if (action.kind === 'local-selection' || action.kind === 'local-operation') {
-    return runLocalWorkspaceAction(deps, action, args);
-  }
-  const editorContext = buildWorkspaceEditorContext(deps.commandContext, args);
-  return output({
-    status: 'no_direct_effect',
-    action: describeWorkspaceAction(category, action, { includeEditor: true, editorContext, lookup }),
-  });
-}
-
 export function createAgentHarnessTool(deps: AgentHarnessToolDeps): Tool {
   return {
     definition: {
@@ -414,7 +146,71 @@ export function createAgentHarnessTool(deps: AgentHarnessToolDeps): Tool {
       if (!isMode(args.mode)) return error(`Unknown agent_harness mode: ${String(args.mode)}`);
       try {
         if (args.mode === 'summary') {
+          const channelReadiness = channelReadinessCatalogStatus(deps.commandContext);
+          const notificationTargets = notificationTargetCatalogStatus(deps.commandContext);
+          const providerAccounts = await providerAccountCatalogStatus(deps.commandContext).catch((err) => ({
+            modes: ['provider_accounts', 'provider_account'],
+            status: 'unavailable',
+            error: formatHarnessError(err),
+          }));
+          const mcpServers = mcpServerCatalogStatus(deps.commandContext);
+          const setupPosture = await setupPostureCatalogStatus(deps.commandContext).catch((err) => ({
+            modes: ['setup_posture', 'setup_item', 'setup_repair', 'setup_checkpoint', 'mark_setup_checkpoint', 'clear_setup_checkpoint', 'provision_connected_host_token', 'run_setup_smoke'],
+            status: 'unavailable',
+            error: formatHarnessError(err),
+          }));
+          const projectContext = projectContextCatalogStatus(deps.commandContext);
+          const promptContext = promptContextCatalogStatus(deps.commandContext);
+          const agentOrchestration = agentOrchestrationCatalogStatus(deps.commandContext, deps.toolRegistry);
+          const modelRouting = await modelRoutingCatalogStatus(deps.commandContext).catch((err) => ({
+            modes: ['model_routing', 'model_route'],
+            status: 'unavailable',
+            error: formatHarnessError(err),
+          }));
+          const executionPosture = executionPostureCatalogStatus(deps.commandContext, deps.toolRegistry);
+          const backgroundProcesses = backgroundProcessCatalogStatus(deps.commandContext);
+          const executionHistory = executionHistoryCatalogStatus(deps.commandContext);
+          const fileRecovery = fileRecoveryCatalogStatus(deps.commandContext);
+          const personalOps = personalOpsCatalogStatus(deps.commandContext);
+          const memoryPosture = await memoryPostureCatalogStatus(deps.commandContext).catch((err) => ({
+            modes: ['memory_posture', 'memory_provider'],
+            status: 'unavailable',
+            error: formatHarnessError(err),
+          }));
+          const memoryRefinement = memoryRefinementCatalogStatus(deps.commandContext);
+          const autonomyQueue = autonomyQueueCatalogStatus(deps.commandContext);
+          const learningCurator = learningCuratorCatalogStatus(deps.commandContext);
+          const researchBriefing = researchBriefingCatalogStatus(deps.commandContext);
+          const researchRuns = researchRunsCatalogStatus(deps.commandContext);
+          const researchQueue = researchQueueCatalogStatus(deps.commandContext);
+          const documentOps = documentOpsCatalogStatus(deps.commandContext);
+          const pairingPosture = pairingPostureCatalogStatus(deps.commandContext);
+          const delegationPosture = delegationPostureCatalogStatus(deps.commandContext);
+          const securityPosture = securityPostureCatalogStatus(deps.commandContext);
+          const supportBundles = supportBundleCatalogStatus();
+          const mediaPosture = mediaPostureCatalogStatus(deps.commandContext);
+          const sessions = sessionCatalogStatus(deps.commandContext);
+          const releaseEvidence = releaseEvidenceBundleStatus();
+          const releaseReadiness = releaseReadinessInventoryStatus();
+          const operatorMethods = operatorMethodCatalogStatus();
+          const servicePosture = servicePostureCatalogStatus();
+          const connectedHost = connectedHostSummary(deps.commandContext, deps.toolRegistry, {
+            includeParameters: args.includeParameters === true,
+          });
           return output({
+            assistant: buildAssistantCockpitFromSummaries({
+              setupPosture,
+              projectContext,
+              agentOrchestration,
+              modelRouting,
+              executionPosture,
+              backgroundProcesses,
+              personalOps,
+              autonomyQueue,
+              researchRuns,
+              documentOps,
+              securityPosture,
+            }),
             harnessModes: HARNESS_MODE_DESCRIPTORS.length,
             cliCommands: totalHarnessCliCommands(),
             blockedCliCommandTokens: blockedHarnessCliCommandTokens(),
@@ -423,44 +219,46 @@ export function createAgentHarnessTool(deps: AgentHarnessToolDeps): Tool {
             shortcuts: totalHarnessShortcuts(deps.commandContext),
             keybindings: totalHarnessKeybindings(deps.commandContext),
             commands: deps.commandRegistry.list().length,
-            channelReadiness: channelReadinessCatalogStatus(deps.commandContext),
-            notificationTargets: notificationTargetCatalogStatus(deps.commandContext),
-            providerAccounts: await providerAccountCatalogStatus(deps.commandContext).catch((err) => ({
-              modes: ['provider_accounts', 'provider_account'],
-              status: 'unavailable',
-              error: formatHarnessError(err),
-            })),
-            mcpServers: mcpServerCatalogStatus(deps.commandContext),
-            setupPosture: await setupPostureCatalogStatus(deps.commandContext).catch((err) => ({
-              modes: ['setup_posture', 'setup_item'],
-              status: 'unavailable',
-              error: formatHarnessError(err),
-            })),
-            modelRouting: await modelRoutingCatalogStatus(deps.commandContext).catch((err) => ({
-              modes: ['model_routing', 'model_route'],
-              status: 'unavailable',
-              error: formatHarnessError(err),
-            })),
-            pairingPosture: pairingPostureCatalogStatus(deps.commandContext),
-            delegationPosture: delegationPostureCatalogStatus(deps.commandContext),
-            securityPosture: securityPostureCatalogStatus(deps.commandContext),
-            supportBundles: supportBundleCatalogStatus(),
-            mediaPosture: mediaPostureCatalogStatus(deps.commandContext),
-            sessions: sessionCatalogStatus(deps.commandContext),
+            channelReadiness,
+            notificationTargets,
+            providerAccounts,
+            mcpServers,
+            setupPosture,
+            projectContext,
+            promptContext,
+            agentOrchestration,
+            modelRouting,
+            executionPosture,
+            backgroundProcesses,
+            executionHistory,
+            fileRecovery,
+            personalOps,
+            memoryPosture,
+            memoryRefinement,
+            autonomyQueue,
+            learningCurator,
+            researchBriefing,
+            researchRuns,
+            researchQueue,
+            documentOps,
+            pairingPosture,
+            delegationPosture,
+            securityPosture,
+            supportBundles,
+            mediaPosture,
+            sessions,
             settings: deps.commandContext.platform.configManager.getSchema().length,
             workspaceCategories: AGENT_WORKSPACE_CATEGORIES.length,
             workspaceActions: allWorkspaceActions().length,
             tools: deps.toolRegistry.getToolDefinitions().length,
-            releaseEvidence: releaseEvidenceBundleStatus(),
-            releaseReadiness: releaseReadinessInventoryStatus(),
-            operatorMethods: operatorMethodCatalogStatus(),
-            servicePosture: servicePostureCatalogStatus(),
+            releaseEvidence,
+            releaseReadiness,
+            operatorMethods,
+            servicePosture,
             modeGuide: compactHarnessModeGuide(),
             ...(args.includeParameters === true ? { modelAccess: detailedHarnessModelAccessGuide() } : {}),
             settingsPolicy: settingsPolicySummary(),
-            connectedHost: connectedHostSummary(deps.commandContext, deps.toolRegistry, {
-              includeParameters: args.includeParameters === true,
-            }),
+            connectedHost,
           });
         }
         if (args.mode === 'modes') return output(listHarnessModes(args));
@@ -470,6 +268,7 @@ export function createAgentHarnessTool(deps: AgentHarnessToolDeps): Tool {
           if (mode.status === 'missing_lookup') return error(String(mode.usage));
           return output(mode.mode);
         }
+        if (args.mode === 'route_decision') return output(planAgentTaskRoute(deps.commandContext, args));
         if (args.mode === 'cli_commands') {
           const commands = listHarnessCliCommands(args);
           return output({
@@ -551,6 +350,14 @@ export function createAgentHarnessTool(deps: AgentHarnessToolDeps): Tool {
           if (resolved.status === 'ambiguous') return error(`Ambiguous channel ${resolved.input}. Candidates: ${JSON.stringify(resolved.candidates)}`);
           return error(resolved.usage);
         }
+        if (args.mode === 'channel_setup_guide') {
+          const resolved = describeHarnessChannelSetupGuide(deps.commandContext, args);
+          if (resolved.status === 'found') return output(resolved.guide);
+          if (resolved.status === 'ambiguous') return error(`Ambiguous channel setup guide target ${resolved.input}. Candidates: ${JSON.stringify(resolved.candidates)}`);
+          return error(resolved.usage);
+        }
+        if (args.mode === 'channel_triage') return output(await describeHarnessChannelTriage(deps.commandContext, args));
+        if (args.mode === 'channel_deliveries') return output(describeHarnessChannelDeliveries(deps.commandContext, args));
         if (args.mode === 'notifications') return output(listHarnessNotificationTargets(deps.commandContext, args));
         if (args.mode === 'notification_target') {
           const resolved = describeHarnessNotificationTarget(deps.commandContext, args);
@@ -579,6 +386,49 @@ export function createAgentHarnessTool(deps: AgentHarnessToolDeps): Tool {
           if (resolved.status === 'ambiguous') return error(`Ambiguous setup item ${resolved.input}. Candidates: ${JSON.stringify(resolved.candidates)}`);
           return error(resolved.usage);
         }
+        if (args.mode === 'setup_repair') return output(await setupRepairSummary(deps.commandContext, args));
+        if (args.mode === 'setup_checkpoint') return output(await setupCheckpointSummary(deps.commandContext));
+        if (args.mode === 'mark_setup_checkpoint') {
+          const confirmationError = requireConfirmedAction(args, 'Setup wizard checkpoint save');
+          if (confirmationError) return error(confirmationError);
+          return output(await markSetupCheckpoint(deps.commandContext, args));
+        }
+        if (args.mode === 'clear_setup_checkpoint') {
+          const confirmationError = requireConfirmedAction(args, 'Setup wizard checkpoint clear');
+          if (confirmationError) return error(confirmationError);
+          return output(clearSetupCheckpoint(deps.commandContext, args));
+        }
+        if (args.mode === 'project_context') return output(projectContextSummary(deps.commandContext, args));
+        if (args.mode === 'project_context_file') {
+          const resolved = describeProjectContextFile(deps.commandContext, args);
+          if (resolved.status === 'found') return output(resolved.file);
+          if (resolved.status === 'ambiguous') return error(`Ambiguous project context file ${resolved.input}. Candidates: ${JSON.stringify(resolved.candidates)}`);
+          return error(resolved.usage);
+        }
+        if (args.mode === 'prompt_context') return output(promptContextSummary(deps.commandContext, args));
+        if (args.mode === 'agent_orchestration') return output(agentOrchestrationSummary(deps.commandContext, deps.toolRegistry, args));
+        if (args.mode === 'agent_orchestration_agent') {
+          const resolved = describeAgentOrchestrationAgent(deps.commandContext, args);
+          if (resolved.status === 'found') return output(resolved.agent);
+          if (resolved.status === 'ambiguous') return error(`Ambiguous visible Agent ${resolved.input}. Candidates: ${JSON.stringify(resolved.candidates)}`);
+          return error(resolved.usage);
+        }
+        if (args.mode === 'provision_connected_host_token') {
+          const confirmationError = requireConfirmedAction(args, 'Connected-host token provisioning');
+          if (confirmationError) return error(confirmationError);
+          const setupItemId = readString(args.setupItemId);
+          if (setupItemId && setupItemId !== 'connected-host-auth') {
+            return error('provision_connected_host_token supports setupItemId:"connected-host-auth" only.');
+          }
+          return output(provisionConnectedHostOperatorToken(deps.commandContext, args));
+        }
+        if (args.mode === 'run_setup_smoke') {
+          const confirmationError = requireConfirmedAction(args, 'Setup smoke');
+          if (confirmationError) return error(confirmationError);
+          const setupItemId = readString(args.setupItemId);
+          if (setupItemId && setupItemId !== 'install-smoke') return error('run_setup_smoke currently supports setupItemId:"install-smoke" only.');
+          return output(await runSetupInstallSmoke(deps.commandContext, args));
+        }
         if (args.mode === 'model_routing') return output(await modelRoutingSummary(deps.commandContext, args));
         if (args.mode === 'model_route') {
           const resolved = await describeHarnessModelRoute(deps.commandContext, args);
@@ -586,6 +436,99 @@ export function createAgentHarnessTool(deps: AgentHarnessToolDeps): Tool {
           if (resolved.status === 'ambiguous') return error(`Ambiguous model route ${resolved.input}. Candidates: ${JSON.stringify(resolved.candidates)}`);
           return error(resolved.usage);
         }
+        if (args.mode === 'run_local_model_smoke') {
+          const confirmationError = requireConfirmedAction(args, 'Local model smoke');
+          return confirmationError ? error(confirmationError) : output(await runLocalModelServerSmoke(deps.commandContext, args));
+        }
+        if (args.mode === 'execution_posture') return output(executionPostureSummary(deps.commandContext, deps.toolRegistry, args));
+        if (args.mode === 'browser_control_route') return output(browserControlRouteSummary(deps.commandContext, deps.toolRegistry, args));
+        if (args.mode === 'execution_route') {
+          const resolved = describeHarnessExecutionRoute(deps.commandContext, deps.toolRegistry, args);
+          if (resolved.status === 'found') return output(resolved.route);
+          if (resolved.status === 'ambiguous') return error(`Ambiguous execution route ${resolved.input}. Candidates: ${JSON.stringify(resolved.candidates)}`);
+          return error(resolved.usage);
+        }
+        if (args.mode === 'background_processes') return output(backgroundProcessSummary(deps.commandContext, args));
+        if (args.mode === 'background_process') {
+          const resolved = describeBackgroundProcess(deps.commandContext, args);
+          if (resolved.status === 'found') return output(resolved.process);
+          if (resolved.status === 'ambiguous') return error(`Ambiguous background process ${resolved.input}. Candidates: ${JSON.stringify(resolved.candidates)}`);
+          return error(resolved.usage);
+        }
+        if (args.mode === 'run_background_process') return output(await runBackgroundProcessAction(deps.commandContext, args));
+        if (args.mode === 'execution_history') return output(executionHistorySummary(deps.commandContext, args));
+        if (args.mode === 'execution_history_item') {
+          const resolved = describeExecutionHistoryItem(deps.commandContext, args);
+          if (resolved.status === 'found') return output(resolved.record);
+          if (resolved.status === 'ambiguous') return error(`Ambiguous execution history record ${resolved.input}. Candidates: ${JSON.stringify(resolved.candidates)}`);
+          return error(resolved.usage);
+        }
+        if (args.mode === 'file_recovery') return output(fileRecoverySummary(deps.commandContext, args));
+        if (args.mode === 'run_file_recovery') {
+          const confirmationError = requireConfirmedAction(args, 'File recovery');
+          return confirmationError ? error(confirmationError) : output(runFileRecovery(deps.commandContext, args));
+        }
+        if (args.mode === 'personal_ops_briefing') return output(await personalOpsBriefingSummary(deps.commandContext, args));
+        if (args.mode === 'personal_ops') return output(await personalOpsSummary(deps.commandContext, args));
+        if (args.mode === 'personal_ops_queue') return output(await personalOpsQueueSummary(deps.commandContext, args));
+        if (args.mode === 'personal_ops_intake') return output(await personalOpsIntakeSummary(deps.commandContext, args));
+        if (args.mode === 'personal_ops_lane') {
+          const resolved = await describePersonalOpsLane(deps.commandContext, args);
+          if (resolved.status === 'found') return output(resolved.lane);
+          if (resolved.status === 'ambiguous') return error(`Ambiguous Personal Ops lane ${resolved.input}. Candidates: ${JSON.stringify(resolved.candidates)}`);
+          return error(resolved.usage);
+        }
+        if (args.mode === 'run_personal_ops_read') return output(await runPersonalOpsRead(deps.commandContext, args));
+        if (args.mode === 'memory_posture') return output(await memoryPostureSummary(deps.commandContext, args));
+        if (args.mode === 'memory_provider') {
+          const resolved = await describeMemoryProvider(deps.commandContext, args);
+          if (resolved.status === 'found') return output(resolved.provider);
+          if (resolved.status === 'ambiguous') return error(`Ambiguous memory provider ${resolved.input}. Candidates: ${JSON.stringify(resolved.candidates)}`);
+          return error(resolved.usage);
+        }
+        if (args.mode === 'memory_refinement') return output(memoryRefinementSummary(deps.commandContext, args));
+        if (args.mode === 'run_memory_refinement') {
+          const confirmationError = requireConfirmedAction(args, 'Agent Knowledge semantic refinement');
+          return confirmationError ? error(confirmationError) : output(await runMemoryRefinement(deps.commandContext, args));
+        }
+        if (args.mode === 'autonomy_intake') return output(autonomyIntakeSummary(deps.commandContext, args));
+        if (args.mode === 'autonomy_queue') return output(autonomyQueueSummary(deps.commandContext, args));
+        if (args.mode === 'autonomy_queue_item') {
+          const resolved = describeAutonomyQueueItem(deps.commandContext, args);
+          if (resolved.status === 'found') return output(resolved.item);
+          if (resolved.status === 'ambiguous') return error(`Ambiguous autonomy queue item ${resolved.input}. Candidates: ${JSON.stringify(resolved.candidates)}`);
+          return error(resolved.usage);
+        }
+        if (args.mode === 'learning_curator') return output(learningCuratorSummary(deps.commandContext, args));
+        if (args.mode === 'learning_candidate') {
+          const resolved = describeLearningCandidate(deps.commandContext, args);
+          if (resolved.status === 'found') return output(resolved.candidate);
+          if (resolved.status === 'ambiguous') return error(`Ambiguous learning candidate ${resolved.input}. Candidates: ${JSON.stringify(resolved.candidates)}`);
+          return error(resolved.usage);
+        }
+        if (args.mode === 'research_briefing') return output(researchBriefingSummary(deps.commandContext, args));
+        if (args.mode === 'research_workflow') return output(researchWorkflowSummary(deps.commandContext, args));
+        if (args.mode === 'research_runs') return output(researchRunsSummary(deps.commandContext, args));
+        if (args.mode === 'research_run') {
+          const resolved = describeResearchRun(deps.commandContext, args);
+          if (resolved.status === 'found') return output(resolved.run);
+          if (resolved.status === 'ambiguous') return error(`Ambiguous research run ${resolved.input}. Candidates: ${JSON.stringify(resolved.candidates)}`);
+          return error(resolved.usage);
+        }
+        if (args.mode === 'research_queue') return output(researchQueueSummary(deps.commandContext, args));
+        if (args.mode === 'research_source') {
+          const resolved = describeResearchSource(deps.commandContext, args);
+          if (resolved.status === 'found') return output(resolved.source);
+          if (resolved.status === 'ambiguous') return error(`Ambiguous research source ${resolved.input}. Candidates: ${JSON.stringify(resolved.candidates)}`);
+          return error(resolved.usage);
+        }
+        if (args.mode === 'document_ops') return output(documentOpsSummary(deps.commandContext, args));
+        if (args.mode === 'document_ops_lane') {
+          const resolved = describeDocumentOpsLane(deps.commandContext, args);
+          if (resolved.status === 'found') return output(resolved.lane);
+          if (resolved.status === 'ambiguous') return error(`Ambiguous Document Ops lane ${resolved.input}. Candidates: ${JSON.stringify(resolved.candidates)}`);
+          return error(resolved.usage);
+        }
         if (args.mode === 'pairing_posture') return output(pairingPostureSummary(deps.commandContext, args));
         if (args.mode === 'pairing_route') {
           const resolved = describeHarnessPairingRoute(deps.commandContext, args);
@@ -607,6 +550,12 @@ export function createAgentHarnessTool(deps: AgentHarnessToolDeps): Tool {
           if (resolved.status === 'ambiguous') return error(`Ambiguous security finding ${resolved.input}. Candidates: ${JSON.stringify(resolved.candidates)}`);
           return error(resolved.usage);
         }
+        if (args.mode === 'policy_explain') {
+          const resolved = explainAgentPolicyDecision(deps.commandContext, deps.toolRegistry, args);
+          if (resolved.status === 'found') return output(resolved.explanation);
+          if (resolved.status === 'ambiguous') return error(`Ambiguous policy explanation target ${resolved.input}. Candidates: ${JSON.stringify(resolved.candidates)}`);
+          return error(resolved.usage);
+        }
         if (args.mode === 'support_bundles') return output(supportBundleSummary(args));
         if (args.mode === 'support_bundle') {
           const resolved = describeHarnessSupportBundle(deps.commandContext, args);