import { ToolDef } from '../../llm/openai-compat.js';
import { logger } from '../../logger.js';
import {
  ToolContext,
  ToolResult,
  ToolsConfig,
  ALL_TOOL_DEFS,
  executeCoreTools,
  runtimeLogsDir,
} from './core.js';
import { saveRawData, logRawDownload, RAW_SAVE_TOOLS, RAW_LOG_ONLY_TOOLS } from './raw-save.js';
import { saveStructuredBlocks } from './structured-blocks.js';
import type { McpAggregator } from '../../mcp/aggregator.js';
import type { McpRuntimeConfig } from '../../mcp/config.js';

export type { ToolContext, ToolResult, ToolsConfig };

let _mcpAggregator: McpAggregator | null = null;
export function setMcpAggregator(agg: McpAggregator | null): void {
  _mcpAggregator = agg;
}

type ExecuteCtxWithMcp = ToolContext & {
  ownerId?: string | null;
  jobId?: string | null;
  mcpConfig?: McpRuntimeConfig;
  mcpQuotaState?: { files: number; bytes: number };
};

// 外部モジュール（他チームが実装）のインターフェース型
interface ToolModule {
  TOOL_DEFS: Record<string, ToolDef>;
  executeTool(name: string, input: Record<string, unknown>, ctx: ToolContext): Promise<ToolResult | null>;
}

// 外部モジュールを動的にロード（存在しない場合は null）
async function tryLoadModule(specifier: string): Promise<ToolModule | null> {
  try {
    const mod = await import(specifier) as ToolModule;
    return mod;
  } catch {
    return null;
  }
}

// 外部モジュールのキャッシュ
let _webModule: ToolModule | null | undefined = undefined;
let _imageModule: ToolModule | null | undefined = undefined;
let _dataModule: ToolModule | null | undefined = undefined;
let _officeModule: ToolModule | null | undefined = undefined;
let _reviewModule: ToolModule | null | undefined = undefined;
let _xModule: ToolModule | null | undefined = undefined;
let _orchestrationModule: ToolModule | null | undefined = undefined;
let _browserModule: ToolModule | null | undefined = undefined;
let _mapsModule: ToolModule | null | undefined = undefined;
let _youtubeModule: ToolModule | null | undefined = undefined;
let _piecesModule: ToolModule | null | undefined = undefined;
let _amazonModule: ToolModule | null | undefined = undefined;
let _speechModule: ToolModule | null | undefined = undefined;
let _checklistModule: ToolModule | null | undefined = undefined;
let _msLearnModule: ToolModule | null | undefined = undefined;
let _slideModule: ToolModule | null | undefined = undefined;
let _userFolderModule: ToolModule | null | undefined = undefined;
let _appTestModule: ToolModule | null | undefined = undefined;

async function getWebModule(): Promise<ToolModule | null> {
  if (_webModule === undefined) {
    _webModule = await tryLoadModule('./web.js');
    if (_webModule) logger.debug('[tools/index] web module loaded');
  }
  return _webModule;
}

async function getImageModule(): Promise<ToolModule | null> {
  if (_imageModule === undefined) {
    _imageModule = await tryLoadModule('./image.js');
    if (_imageModule) logger.debug('[tools/index] image module loaded');
  }
  return _imageModule;
}

async function getDataModule(): Promise<ToolModule | null> {
  if (_dataModule === undefined) {
    _dataModule = await tryLoadModule('./data.js');
    if (_dataModule) logger.debug('[tools/index] data module loaded');
  }
  return _dataModule;
}

async function getOfficeModule(): Promise<ToolModule | null> {
  if (_officeModule === undefined) {
    _officeModule = await tryLoadModule('./office.js');
    if (_officeModule) logger.debug('[tools/index] office module loaded');
  }
  return _officeModule;
}

async function getReviewModule(): Promise<ToolModule | null> {
  if (_reviewModule === undefined) {
    _reviewModule = await tryLoadModule('./review.js');
    if (_reviewModule) logger.debug('[tools/index] review module loaded');
  }
  return _reviewModule;
}

async function getXModule(): Promise<ToolModule | null> {
  if (_xModule === undefined) {
    _xModule = await tryLoadModule('./x.js');
    if (_xModule) logger.debug('[tools/index] x module loaded');
  }
  return _xModule;
}

async function getOrchestrationModule(): Promise<ToolModule | null> {
  if (_orchestrationModule === undefined) {
    _orchestrationModule = await tryLoadModule('./orchestration.js');
    if (_orchestrationModule) logger.debug('[tools/index] orchestration module loaded');
  }
  return _orchestrationModule;
}

async function getBrowserModule(): Promise<ToolModule | null> {
  if (_browserModule === undefined) {
    _browserModule = await tryLoadModule('./browser.js');
    if (_browserModule) logger.debug('[tools/index] browser module loaded');
  }
  return _browserModule;
}

async function getMapsModule(): Promise<ToolModule | null> {
  if (_mapsModule === undefined) {
    _mapsModule = await tryLoadModule('./maps.js');
    if (_mapsModule) logger.debug('[tools/index] maps module loaded');
  }
  return _mapsModule;
}

async function getYoutubeModule(): Promise<ToolModule | null> {
  if (_youtubeModule === undefined) {
    _youtubeModule = await tryLoadModule('./youtube.js');
    if (_youtubeModule) logger.debug('[tools/index] youtube module loaded');
  }
  return _youtubeModule;
}

async function getPiecesModule(): Promise<ToolModule | null> {
  if (_piecesModule === undefined) {
    _piecesModule = await tryLoadModule('./pieces.js');
    if (_piecesModule) logger.debug('[tools/index] pieces module loaded');
  }
  return _piecesModule;
}

async function getAmazonModule(): Promise<ToolModule | null> {
  if (_amazonModule === undefined) {
    _amazonModule = await tryLoadModule('./amazon.js');
    if (_amazonModule) logger.debug('[tools/index] amazon module loaded');
  }
  return _amazonModule;
}

async function getSpeechModule(): Promise<ToolModule | null> {
  if (_speechModule === undefined) {
    _speechModule = await tryLoadModule('./speech.js');
    if (_speechModule) logger.debug('[tools/index] speech module loaded');
  }
  return _speechModule;
}

async function getChecklistModule(): Promise<ToolModule | null> {
  if (_checklistModule === undefined) {
    _checklistModule = await tryLoadModule('./checklist.js');
    if (_checklistModule) logger.debug('[tools/index] checklist module loaded');
  }
  return _checklistModule;
}

async function getSlideModule(): Promise<ToolModule | null> {
  if (_slideModule === undefined) {
    _slideModule = await tryLoadModule('./slide.js');
    if (_slideModule) logger.debug('[tools/index] slide module loaded');
  }
  return _slideModule;
}

async function getMsLearnModule(): Promise<ToolModule | null> {
  if (_msLearnModule === undefined) {
    _msLearnModule = await tryLoadModule('./ms-learn.js');
    if (_msLearnModule) logger.debug('[tools/index] ms-learn module loaded');
  }
  return _msLearnModule;
}

let _docsModule: ToolModule | null | undefined;
async function getDocsModule(): Promise<ToolModule | null> {
  if (_docsModule === undefined) {
    _docsModule = await tryLoadModule('./docs.js');
    if (_docsModule) logger.debug('[tools/index] docs module loaded');
  }
  return _docsModule;
}

let _missionModule: ToolModule | null | undefined;
async function getMissionModule(): Promise<ToolModule | null> {
  if (_missionModule === undefined) {
    _missionModule = await tryLoadModule('./mission.js');
    if (_missionModule) logger.debug('[tools/index] mission module loaded');
  }
  return _missionModule;
}

let _taskConversationModule: ToolModule | null | undefined;
async function getTaskConversationModule(): Promise<ToolModule | null> {
  if (_taskConversationModule === undefined) {
    _taskConversationModule = await tryLoadModule('./task-conversation.js');
    if (_taskConversationModule) logger.debug('[tools/index] task-conversation module loaded');
  }
  return _taskConversationModule;
}

let _workspaceTaskSearchModule: ToolModule | null | undefined;
async function getWorkspaceTaskSearchModule(): Promise<ToolModule | null> {
  if (_workspaceTaskSearchModule === undefined) {
    _workspaceTaskSearchModule = await tryLoadModule('./workspace-task-search.js');
    if (_workspaceTaskSearchModule) logger.debug('[tools/index] workspace-task-search module loaded');
  }
  return _workspaceTaskSearchModule;
}

let _fileProvenanceModule: ToolModule | null | undefined;
async function getFileProvenanceModule(): Promise<ToolModule | null> {
  if (_fileProvenanceModule === undefined) {
    _fileProvenanceModule = await tryLoadModule('./file-provenance.js');
    if (_fileProvenanceModule) logger.debug('[tools/index] file-provenance module loaded');
  }
  return _fileProvenanceModule;
}

let _toolRequestModule: ToolModule | null | undefined;
async function getToolRequestModule(): Promise<ToolModule | null> {
  if (_toolRequestModule === undefined) {
    _toolRequestModule = await tryLoadModule('./tool-request.js');
    if (_toolRequestModule) logger.debug('[tools/index] tool-request module loaded');
  }
  return _toolRequestModule;
}

/**
 * Snapshot of all known static tool names, refreshed every getToolDefs() call
 * (which runs at movement start, before any tool executes). Injected into
 * RequestTool's ctx so it can classify an unknown tool name vs one that exists
 * but isn't allowed in the current movement. MCP names are handled separately
 * by RequestTool via the `mcp__` prefix, so they need not be in this set.
 */
let _allKnownToolNames: string[] = [];

async function getUserFolderModule(): Promise<ToolModule | null> {
  if (_userFolderModule === undefined) {
    _userFolderModule = await tryLoadModule('./user-folder.js');
    if (_userFolderModule) logger.debug('[tools/index] user-folder module loaded');
  }
  return _userFolderModule;
}

let _brainstormModule: ToolModule | null | undefined;
async function getBrainstormModule(): Promise<ToolModule | null> {
  if (_brainstormModule === undefined) {
    _brainstormModule = await tryLoadModule('./brainstorm.js');
    if (_brainstormModule) logger.debug('[tools/index] brainstorm module loaded');
  }
  return _brainstormModule;
}

let _appDocsModule: ToolModule | null | undefined;
async function getAppDocsModule(): Promise<ToolModule | null> {
  if (_appDocsModule === undefined) {
    _appDocsModule = await tryLoadModule('./app-docs.js');
    if (_appDocsModule) logger.debug('[tools/index] app-docs module loaded');
  }
  return _appDocsModule;
}

let _sshModule: ToolModule | null | undefined;
async function getSshModule(): Promise<ToolModule | null> {
  if (_sshModule === undefined) {
    _sshModule = await tryLoadModule('./ssh.js');
    if (_sshModule) logger.debug('[tools/index] ssh module loaded');
  }
  return _sshModule;
}

let _sshConsoleModule: ToolModule | null | undefined;
async function getSshConsoleModule(): Promise<ToolModule | null> {
  if (_sshConsoleModule === undefined) {
    _sshConsoleModule = await tryLoadModule('./ssh-console.js');
    if (_sshConsoleModule) logger.debug('[tools/index] ssh-console module loaded');
  }
  return _sshConsoleModule;
}

let _calendarModule: ToolModule | null | undefined = undefined;
async function getCalendarModule(): Promise<ToolModule | null> {
  if (_calendarModule === undefined) {
    _calendarModule = await tryLoadModule('./calendar.js');
    if (_calendarModule) logger.debug('[tools/index] calendar module loaded');
  }
  return _calendarModule;
}

async function getAppTestModule(): Promise<ToolModule | null> {
  if (_appTestModule === undefined) {
    _appTestModule = await tryLoadModule('./app-test.js');
    if (_appTestModule) logger.debug('[tools/index] app-test module loaded');
  }
  return _appTestModule;
}

/**
 * 全モジュールのツール定義を統合して返す。
 * allowedTools と editAllowed に応じてフィルタリングする。
 */
export async function getToolDefs(
  allowedTools: string[],
  editAllowed: boolean,
  options?: { vlmEnabled?: boolean; ownerId?: string | null; mcpDisabled?: boolean; spaceId?: string | null },
): Promise<ToolDef[]> {
  // 全ツール定義を収集
  const allDefs: Record<string, ToolDef> = { ...ALL_TOOL_DEFS };

  const webMod = await getWebModule();
  if (webMod) Object.assign(allDefs, webMod.TOOL_DEFS);

  const imageMod = await getImageModule();
  if (imageMod) Object.assign(allDefs, imageMod.TOOL_DEFS);

  const dataMod = await getDataModule();
  if (dataMod) Object.assign(allDefs, dataMod.TOOL_DEFS);

  const officeMod = await getOfficeModule();
  if (officeMod) Object.assign(allDefs, officeMod.TOOL_DEFS);

  const reviewMod = await getReviewModule();
  if (reviewMod) Object.assign(allDefs, reviewMod.TOOL_DEFS);

  const xMod = await getXModule();
  if (xMod) Object.assign(allDefs, xMod.TOOL_DEFS);

  const orchestrationMod = await getOrchestrationModule();
  if (orchestrationMod) Object.assign(allDefs, orchestrationMod.TOOL_DEFS);

  const browserMod = await getBrowserModule();
  if (browserMod) Object.assign(allDefs, browserMod.TOOL_DEFS);

  const mapsMod = await getMapsModule();
  if (mapsMod) Object.assign(allDefs, mapsMod.TOOL_DEFS);

  const youtubeMod = await getYoutubeModule();
  if (youtubeMod) Object.assign(allDefs, youtubeMod.TOOL_DEFS);

  const piecesMod = await getPiecesModule();
  if (piecesMod) Object.assign(allDefs, piecesMod.TOOL_DEFS);

  const amazonMod = await getAmazonModule();
  if (amazonMod) Object.assign(allDefs, amazonMod.TOOL_DEFS);

  const speechMod = await getSpeechModule();
  if (speechMod) Object.assign(allDefs, speechMod.TOOL_DEFS);

  const checklistMod = await getChecklistModule();
  if (checklistMod) Object.assign(allDefs, checklistMod.TOOL_DEFS);

  const msLearnMod = await getMsLearnModule();
  if (msLearnMod) Object.assign(allDefs, msLearnMod.TOOL_DEFS);

  const slideMod = await getSlideModule();
  if (slideMod) Object.assign(allDefs, slideMod.TOOL_DEFS);

  const docsMod = await getDocsModule();
  if (docsMod) Object.assign(allDefs, docsMod.TOOL_DEFS);

  const missionMod = await getMissionModule();
  if (missionMod) Object.assign(allDefs, missionMod.TOOL_DEFS);

  const taskConversationMod = await getTaskConversationModule();
  if (taskConversationMod) Object.assign(allDefs, taskConversationMod.TOOL_DEFS);

  const workspaceTaskSearchMod = await getWorkspaceTaskSearchModule();
  if (workspaceTaskSearchMod) Object.assign(allDefs, workspaceTaskSearchMod.TOOL_DEFS);

  const fileProvenanceMod = await getFileProvenanceModule();
  if (fileProvenanceMod) Object.assign(allDefs, fileProvenanceMod.TOOL_DEFS);

  const userFolderMod = await getUserFolderModule();
  if (userFolderMod) Object.assign(allDefs, userFolderMod.TOOL_DEFS);

  const brainstormMod = await getBrainstormModule();
  if (brainstormMod) Object.assign(allDefs, brainstormMod.TOOL_DEFS);

  const appDocsMod = await getAppDocsModule();
  if (appDocsMod) Object.assign(allDefs, appDocsMod.TOOL_DEFS);

  const sshMod = await getSshModule();
  if (sshMod) Object.assign(allDefs, sshMod.TOOL_DEFS);

  const sshConsoleMod = await getSshConsoleModule();
  if (sshConsoleMod) Object.assign(allDefs, sshConsoleMod.TOOL_DEFS);


  const calendarMod = await getCalendarModule();
  if (calendarMod) Object.assign(allDefs, calendarMod.TOOL_DEFS);

  const appTestMod = await getAppTestModule();
  if (appTestMod) Object.assign(allDefs, appTestMod.TOOL_DEFS);

  const { TOOL_DEFS: skillToolDefs } = await import('./skills.js');
  Object.assign(allDefs, skillToolDefs);

  const toolRequestMod = await getToolRequestModule();
  if (toolRequestMod) Object.assign(allDefs, toolRequestMod.TOOL_DEFS);

  // Refresh the known-tool snapshot for RequestTool classification.
  //
  // CONCURRENCY INVARIANT (must hold): this is taken HERE — after every static
  // module is merged into `allDefs`, but BEFORE the per-job MCP defs are
  // appended below. The static catalog does NOT depend on movement / ownerId /
  // spaceId / mcpDisabled, so every concurrent getToolDefs() writer produces an
  // IDENTICAL array. That is why this module-global is safe to read from a
  // different movement's RequestTool dispatch. If you ever make a STATIC tool's
  // presence in `allDefs` conditional (feature flag, per-space, etc.), this
  // snapshot becomes movement-dependent and the global must move into ctx
  // instead — otherwise concurrent movements would misclassify each other's
  // tools as `unknown`.
  _allKnownToolNames = Object.keys(allDefs);

  // メタツール: ワークスペースのツール設定に関係なく常に利用可能
  // - ReadToolDoc: 全ツールのドキュメント参照
  // - CreateChecklist / CheckItem / GetChecklist: 進捗管理 (複数ステップタスクで使用)
  // - MissionUpdate: タスクの目標 / 進捗のピン止めメモを更新 (会話が長くなって
  //   最初の要件を見失わないため。常時上書き可能、未指定フィールドは保持)
  // - ListUserAssets / RunUserScript: ユーザーフォルダのスクリプト探索・実行
  // - ReadUserAgents / UpdateUserAgents: per-user AGENTS.md (常時指示書) の読み書き
  //   (UpdateUserMemory が事実断片、こちらは振る舞い方針そのもの)
  // - Brainstorm: 着手前 or 行き詰まり時の多アプローチ比較 (issue #247)
  // - ReadAppDoc / ListAppDocs / GetMyOrchestratorState: Help アシスタント用 (#help piece)
  //   ただし他の piece からも参照できるようにメタ扱い
  // - RequestTool: 足りないツールの要求を記録（タスク詳細／ピース集計で可視化）
  const META_TOOLS = ['ReadToolDoc', 'CreateChecklist', 'CheckItem', 'GetChecklist', 'MissionUpdate', 'SearchTaskConversation', 'ReadTaskConversation', 'SearchWorkspaceTasks', 'GetFileProvenance', 'ListWorkspaceFiles', 'ListUserAssets', 'RunUserScript', 'UpdateUserMemory', 'ReadUserMemory', 'ReadUserAgents', 'UpdateUserAgents', 'WriteUserScript', 'Brainstorm', 'ReadAppDoc', 'ListAppDocs', 'GetMyOrchestratorState', 'ReadSkill', 'ListSkills', 'InstallSkill', 'RequestTool'];
  const effectiveAllowed = [...allowedTools];
  for (const meta of META_TOOLS) {
    if (!effectiveAllowed.includes(meta) && meta in allDefs) {
      effectiveAllowed.push(meta);
    }
  }

  const staticDefs = effectiveAllowed
    .filter((name) => {
      if (!editAllowed && (name === 'Write' || name === 'Edit')) return false;
      if (!options?.vlmEnabled && name === 'ReadImage') return false;
      return name in allDefs;
    })
    .map((name) => allDefs[name]!);

  // Per-space isolation: the MCP server set is scoped to the job's space.
  // options.spaceId === undefined → aggregator falls back to the legacy
  // NULL-space set (non-space jobs keep prior behaviour).
  const mcpDefs =
    _mcpAggregator && options?.ownerId && !options?.mcpDisabled
      ? await _mcpAggregator.getToolDefs(options.ownerId, allowedTools, options.spaceId)
      : [];

  return [...staticDefs, ...mcpDefs];
}

/**
 * ツールを実行する内部ルーター。
 * core → web → image → data の順で各モジュールに委譲し、
 * 最初に null でない結果を返したモジュールの結果を使う。
 */
async function executeToolInner(
  name: string,
  input: Record<string, unknown>,
  ctx: ToolContext,
): Promise<ToolResult> {
  if (name.startsWith('mcp__')) {
    if (ctx.mcpDisabled) {
      return { output: 'MCP tools are disabled for this task (options.mcpDisabled)', isError: true };
    }
    if (!_mcpAggregator) {
      return { output: 'MCP サブシステムが初期化されていません', isError: true };
    }
    const ctxWithMcp = ctx as ExecuteCtxWithMcp;
    if (!ctxWithMcp.mcpQuotaState) {
      ctxWithMcp.mcpQuotaState = { files: 0, bytes: 0 };
    }
    if (!ctxWithMcp.mcpConfig) {
      return { output: 'MCP 設定が ToolContext に伝播していません', isError: true };
    }
    const result = await _mcpAggregator.executeTool(name, input, {
      workspacePath: ctx.workspacePath,
      ownerId: ctxWithMcp.ownerId ?? '',
      jobId: ctxWithMcp.jobId ?? '',
      config: ctxWithMcp.mcpConfig,
      quotaState: ctxWithMcp.mcpQuotaState,
      // Job cancel/deadline signal so a slow/hung MCP server is interrupted
      // instead of pinning the worker slot past the deadline.
      abortSignal: ctx.abortSignal,
      // Per-space isolation guard (defense in depth). undefined = legacy
      // NULL-space job → only NULL-space servers are callable.
      spaceId: ctx.spaceId ?? null,
    });
    if (result === null) {
      return { output: `MCP ツール dispatch が ${name} に対して null を返しました`, isError: true };
    }
    return { output: result.output, isError: result.isError };
  }

  // core ツール
  const coreResult = await executeCoreTools(name, input, ctx);
  if (coreResult !== null) return coreResult;

  // web ツール
  const webMod = await getWebModule();
  if (webMod) {
    const webResult = await webMod.executeTool(name, input, ctx);
    if (webResult !== null) return webResult;
  }

  // image ツール
  const imageMod = await getImageModule();
  if (imageMod) {
    const imageResult = await imageMod.executeTool(name, input, ctx);
    if (imageResult !== null) return imageResult;
  }

  // data ツール
  const dataMod = await getDataModule();
  if (dataMod) {
    const dataResult = await dataMod.executeTool(name, input, ctx);
    if (dataResult !== null) return dataResult;
  }

  // office ツール
  const officeMod = await getOfficeModule();
  if (officeMod) {
    const officeResult = await officeMod.executeTool(name, input, ctx);
    if (officeResult !== null) return officeResult;
  }

  // review ツール
  const reviewMod = await getReviewModule();
  if (reviewMod) {
    const reviewResult = await reviewMod.executeTool(name, input, ctx);
    if (reviewResult !== null) return reviewResult;
  }

  // x tools
  const xMod = await getXModule();
  if (xMod) {
    const xResult = await xMod.executeTool(name, input, ctx);
    if (xResult !== null) return xResult;
  }

  // orchestration ツール
  const orchestrationMod = await getOrchestrationModule();
  if (orchestrationMod) {
    const orchestrationResult = await orchestrationMod.executeTool(name, input, ctx);
    if (orchestrationResult !== null) return orchestrationResult;
  }

  // browser ツール
  const browserMod = await getBrowserModule();
  if (browserMod) {
    const browserResult = await browserMod.executeTool(name, input, ctx);
    if (browserResult !== null) return browserResult;
  }

  // maps ツール
  const mapsMod = await getMapsModule();
  if (mapsMod) {
    const mapsResult = await mapsMod.executeTool(name, input, ctx);
    if (mapsResult !== null) return mapsResult;
  }

  // youtube ツール
  const youtubeMod = await getYoutubeModule();
  if (youtubeMod) {
    const youtubeResult = await youtubeMod.executeTool(name, input, ctx);
    if (youtubeResult !== null) return youtubeResult;
  }

  // pieces ツール
  const piecesMod = await getPiecesModule();
  if (piecesMod) {
    const piecesResult = await piecesMod.executeTool(name, input, ctx);
    if (piecesResult !== null) return piecesResult;
  }

  // amazon ツール
  const amazonMod = await getAmazonModule();
  if (amazonMod) {
    const amazonResult = await amazonMod.executeTool(name, input, ctx);
    if (amazonResult !== null) return amazonResult;
  }

  // speech ツール
  const speechMod = await getSpeechModule();
  if (speechMod) {
    const speechResult = await speechMod.executeTool(name, input, ctx);
    if (speechResult !== null) return speechResult;
  }

  // checklist ツール
  const checklistMod = await getChecklistModule();
  if (checklistMod) {
    const checklistResult = await checklistMod.executeTool(name, input, ctx);
    if (checklistResult !== null) return checklistResult;
  }

  // ms-learn ツール
  const msLearnMod = await getMsLearnModule();
  if (msLearnMod) {
    const msLearnResult = await msLearnMod.executeTool(name, input, ctx);
    if (msLearnResult !== null) return msLearnResult;
  }

  // slide ツール (SetTheme / AddSlide / BuildPptx / ResetSlides)
  const slideMod = await getSlideModule();
  if (slideMod) {
    const slideResult = await slideMod.executeTool(name, input, ctx);
    if (slideResult !== null) return slideResult;
  }

  // docs ツール (ReadToolDoc)
  const docsMod = await getDocsModule();
  if (docsMod) {
    const docsResult = await docsMod.executeTool(name, input, ctx);
    if (docsResult !== null) return docsResult;
  }

  // mission ツール (MissionUpdate)
  const missionMod = await getMissionModule();
  if (missionMod) {
    const missionResult = await missionMod.executeTool(name, input, ctx);
    if (missionResult !== null) return missionResult;
  }

  // task-conversation ツール (SearchTaskConversation / ReadTaskConversation)
  const taskConversationMod = await getTaskConversationModule();
  if (taskConversationMod) {
    const taskConversationResult = await taskConversationMod.executeTool(name, input, ctx);
    if (taskConversationResult !== null) return taskConversationResult;
  }

  // workspace-task-search ツール (SearchWorkspaceTasks)
  const workspaceTaskSearchMod2 = await getWorkspaceTaskSearchModule();
  if (workspaceTaskSearchMod2) {
    const r = await workspaceTaskSearchMod2.executeTool(name, input, ctx);
    if (r !== null) return r;
  }

  // file-provenance ツール (GetFileProvenance / ListWorkspaceFiles)
  const fileProvenanceMod = await getFileProvenanceModule();
  if (fileProvenanceMod) {
    const fileProvenanceResult = await fileProvenanceMod.executeTool(name, input, ctx);
    if (fileProvenanceResult !== null) return fileProvenanceResult;
  }

  // RequestTool: 足りないツールの要求を記録。分類用に既知ツール一覧を注入する
  // (getToolDefs が movement 開始時に更新した最新スナップショット)。
  const toolRequestMod = await getToolRequestModule();
  if (toolRequestMod) {
    if (name === 'RequestTool') ctx.knownToolNames = _allKnownToolNames;
    const toolRequestResult = await toolRequestMod.executeTool(name, input, ctx);
    if (toolRequestResult !== null) return toolRequestResult;
  }

  // user-folder ツール (ListUserAssets / RunUserScript)
  const userFolderMod = await getUserFolderModule();
  if (userFolderMod) {
    const userFolderResult = await userFolderMod.executeTool(name, input, ctx);
    if (userFolderResult !== null) return userFolderResult;
  }

  // brainstorm ツール (Brainstorm)
  const brainstormMod = await getBrainstormModule();
  if (brainstormMod) {
    const brainstormResult = await brainstormMod.executeTool(name, input, ctx);
    if (brainstormResult !== null) return brainstormResult;
  }

  // app-docs ツール (ReadAppDoc / ListAppDocs / GetMyOrchestratorState)
  const appDocsMod = await getAppDocsModule();
  if (appDocsMod) {
    const appDocsResult = await appDocsMod.executeTool(name, input, ctx);
    if (appDocsResult !== null) return appDocsResult;
  }

  // ssh ツール (SshExec / SshUpload / SshDownload)
  const sshMod = await getSshModule();
  if (sshMod) {
    const sshResult = await sshMod.executeTool(name, input, ctx);
    if (sshResult !== null) return sshResult;
  }

  // ssh-console ツール (SshConsoleEnsure / Send / Snapshot)
  const sshConsoleMod = await getSshConsoleModule();
  if (sshConsoleMod) {
    const sshConsoleResult = await sshConsoleMod.executeTool(name, input, ctx);
    if (sshConsoleResult !== null) return sshConsoleResult;
  }

  // calendar ツール (AddCalendarEvent / ListCalendarEvents)
  const calendarMod = await getCalendarModule();
  if (calendarMod) {
    const calendarResult = await calendarMod.executeTool(name, input, ctx);
    if (calendarResult !== null) return calendarResult;
  }

  // app-test ツール (TestWorkspaceApp)
  const appTestMod = await getAppTestModule();
  if (appTestMod) {
    const appTestResult = await appTestMod.executeTool(name, input, ctx);
    if (appTestResult !== null) return appTestResult;
  }

  // skills ツール (ReadSkill)
  const { executeSkillTool } = await import('./skills.js');
  const skillResult = executeSkillTool(name, input, ctx);
  if (skillResult !== null) return skillResult;

  return { output: `Unknown tool: ${name}`, isError: true };
}

/**
 * ツールを実行するルーター（生データ自動保存ラッパー付き）。
 * executeToolInner に委譲した後、成功した対象ツールの結果を logs/raw/ に保存する。
 */
export async function executeTool(
  name: string,
  input: Record<string, unknown>,
  ctx: ToolContext,
): Promise<ToolResult> {
  logger.debug(`[tools/index] executing ${name}`);

  const result = await executeToolInner(name, input, ctx);

  // raw保存ラッパー: 成功した対象ツールの結果を {logsRoot}/raw/ に保存（計画5: runtimeDir 解決）
  if (ctx.workspacePath && !result.isError) {
    const logsRoot = runtimeLogsDir(ctx);
    if (RAW_SAVE_TOOLS.has(name)) {
      saveRawData(logsRoot, name, result.output);
    } else if (RAW_LOG_ONLY_TOOLS.has(name)) {
      const pathMatch = result.output.match(/-> (.+?) \(/);
      if (pathMatch?.[1]) {
        logRawDownload(logsRoot, name, pathMatch[1], result.output.length);
      }
    }
    // 構造化データ保存: structuredBlocks があれば {logsRoot}/structured/ に保存
    if (result.structuredBlocks?.length) {
      saveStructuredBlocks(logsRoot, result.structuredBlocks);
    }
  }

  return result;
}