takos-control 1.0.0

package/src/application/services/agent/simple-loop.ts

@@ -0,0 +1,367 @@
+/**
+ * Simple LLM loop and no-LLM fallback execution modes for the Agent Runner.
+ *
+ * These are fallback execution paths when LangGraph is unavailable or
+ * when no LLM API key is configured.
+ */
+
+import type { AgentMessage, AgentConfig, AgentEvent } from './agent-models';
+import type { RunTerminalPayload } from '../run-notifier';
+import type { LLMClient } from './llm';
+import type { ToolExecutorLike } from '../../tools/executor';
+import type { ToolExecution } from './runner-types';
+import type { Env } from '../../../shared/types';
+import type { RunStatus } from '../../../shared/types';
+import type { AgentMemoryRuntime } from '../memory-graph/memory-graph-runtime';
+import type {
+  SkillCatalogEntry,
+  SkillSelection,
+  SkillContext,
+} from './skills';
+import { buildSkillEnhancedPrompt } from './skills';
+import { getTimeoutConfig } from './runner-config';
+import { withTimeout } from '../../../shared/utils/with-timeout';
+import {
+  anySignal,
+  addToolExecution,
+  redactSensitiveArgs,
+  MAX_TOTAL_TOOL_CALLS,
+} from './runner-types';
+
+export interface SimpleLoopDeps {
+  env: Env;
+  config: AgentConfig;
+  llmClient: LLMClient;
+  toolExecutor: ToolExecutorLike | undefined;
+  skillLocale: 'ja' | 'en';
+  availableSkills: SkillCatalogEntry[];
+  selectedSkills: SkillSelection[];
+  activatedSkills: SkillContext[];
+  spaceId: string;
+  abortSignal?: AbortSignal;
+  toolExecutions: ToolExecution[];
+  totalUsage: { inputTokens: number; outputTokens: number };
+  toolCallCount: number;
+  totalToolCalls: number;
+  memoryRuntime?: AgentMemoryRuntime;
+
+  // Callbacks
+  throwIfCancelled: (context: string) => Promise<void>;
+  emitEvent: (type: AgentEvent['type'], data: Record<string, unknown>) => Promise<void>;
+  addMessage: (message: AgentMessage, metadata?: Record<string, unknown>) => Promise<void>;
+  updateRunStatus: (status: RunStatus, output?: string, error?: string) => Promise<void>;
+  buildTerminalEventPayload: (
+    status: 'completed' | 'failed' | 'cancelled',
+    details?: Record<string, unknown>,
+  ) => RunTerminalPayload;
+  getConversationHistory: () => Promise<AgentMessage[]>;
+}
+
+/**
+ * Run with simple LLM loop (no LangGraph).
+ */
+export async function runWithSimpleLoop(deps: SimpleLoopDeps): Promise<void> {
+  const history = await deps.getConversationHistory();
+  const enhancedPrompt = buildSkillEnhancedPrompt(
+    deps.config.systemPrompt,
+    {
+      locale: deps.skillLocale,
+      availableSkills: deps.availableSkills,
+      selectableSkills: deps.availableSkills.filter((skill) => skill.availability !== 'unavailable'),
+      selectedSkills: deps.selectedSkills,
+      activatedSkills: deps.activatedSkills,
+    },
+    deps.spaceId,
+  );
+
+  const messages: AgentMessage[] = [
+    { role: 'system', content: enhancedPrompt },
+    ...history,
+  ];
+
+  let iteration = 0;
+  const runStartTime = Date.now();
+  const maxIterations = deps.config.maxIterations || 10;
+  const timeoutConfig = getTimeoutConfig(deps.env);
+  const totalTimeoutMs = timeoutConfig.totalTimeout;
+  const iterationTimeoutMs = timeoutConfig.iterationTimeout;
+
+  while (iteration < maxIterations) {
+    await deps.throwIfCancelled('iteration');
+    // Check total run timeout
+    const elapsed = Date.now() - runStartTime;
+    if (elapsed > totalTimeoutMs) {
+      const timeoutMinutes = Math.round(totalTimeoutMs / 60000);
+      throw new Error(`Run timed out after ${timeoutMinutes} minutes`);
+    }
+
+    iteration++;
+    await deps.emitEvent('thinking', { iteration, message: 'Processing...', engine: 'simple' });
+
+    // Refresh active memory before each LLM call
+    if (deps.memoryRuntime) {
+      const activation = deps.memoryRuntime.beforeModel();
+      if (activation.hasContent) {
+        // Find or insert [ACTIVE_MEMORY] marker in messages
+        const markerIndex = messages.findIndex(m =>
+          m.role === 'system' && m.content.includes('[ACTIVE_MEMORY]'),
+        );
+        const memoryMessage: AgentMessage = {
+          role: 'system',
+          content: `[ACTIVE_MEMORY]\n${activation.segment}`,
+        };
+        if (markerIndex >= 0) {
+          messages[markerIndex] = memoryMessage;
+        } else {
+          // Insert after the first system message (base prompt)
+          messages.splice(1, 0, memoryMessage);
+        }
+      }
+    }
+
+    // Add timeout to LLM call to prevent stuck iterations
+    const response = await withTimeout(
+      (signal) => {
+        const combinedSignal = deps.abortSignal && signal
+          ? anySignal([deps.abortSignal, signal])
+          : deps.abortSignal || signal;
+        return deps.llmClient.chat(messages, deps.config.tools, combinedSignal);
+      },
+      iterationTimeoutMs,
+      `LLM call timed out after ${iterationTimeoutMs / 1000} seconds (iteration ${iteration})`
+    );
+
+    deps.totalUsage.inputTokens += response.usage.inputTokens;
+    deps.totalUsage.outputTokens += response.usage.outputTokens;
+
+    if (response.toolCalls && response.toolCalls.length > 0) {
+      const assistantMsg: AgentMessage = {
+        role: 'assistant',
+        content: response.content,
+        tool_calls: response.toolCalls,
+      };
+      messages.push(assistantMsg);
+      await deps.addMessage(assistantMsg);
+
+      for (const toolCall of response.toolCalls) {
+        await deps.throwIfCancelled('tool-call');
+        // Rate limit check
+        deps.toolCallCount++;
+        const rateLimit = deps.config.rateLimit;
+        if (rateLimit && deps.toolCallCount > rateLimit) {
+          const errorMsg = `Rate limit exceeded: ${deps.toolCallCount} tool calls (max: ${rateLimit})`;
+          throw new Error(errorMsg);
+        }
+
+        // Security: Hard limit on total tool calls per run
+        deps.totalToolCalls++;
+        if (deps.totalToolCalls > MAX_TOTAL_TOOL_CALLS) {
+          const errorMsg = `Total tool call limit exceeded: ${deps.totalToolCalls} (max: ${MAX_TOTAL_TOOL_CALLS})`;
+          throw new Error(errorMsg);
+        }
+
+        const toolStartTime = Date.now();
+        // Security: Redact sensitive arguments before logging/emitting
+        const redactedArgs = redactSensitiveArgs(toolCall.arguments);
+        await deps.emitEvent('tool_call', {
+          tool: toolCall.name,
+          arguments: redactedArgs,
+          tool_call_id: toolCall.id,
+        });
+
+        if (!deps.toolExecutor) {
+          throw new Error('Tool executor not initialized');
+        }
+        const result = await deps.toolExecutor.execute({
+          id: toolCall.id,
+          name: toolCall.name,
+          arguments: toolCall.arguments,
+        });
+
+        const toolDuration = Date.now() - toolStartTime;
+
+        addToolExecution(deps.toolExecutions, {
+          name: toolCall.name,
+          arguments: toolCall.arguments,
+          result: result.error ? undefined : result.output,
+          error: result.error,
+          startedAt: toolStartTime,
+          duration_ms: toolDuration,
+        });
+
+        await deps.emitEvent('tool_result', {
+          tool: toolCall.name,
+          output: result.output,
+          error: result.error,
+          tool_call_id: toolCall.id,
+        });
+
+        const toolMsg: AgentMessage = {
+          role: 'tool',
+          content: result.error || result.output,
+          tool_call_id: toolCall.id,
+        };
+        messages.push(toolMsg);
+        await deps.addMessage(toolMsg);
+      }
+      continue;
+    }
+
+    await deps.throwIfCancelled('before-complete');
+    // Final response with tool executions metadata
+    const finalMsg: AgentMessage = {
+      role: 'assistant',
+      content: response.content,
+    };
+
+    const messageMetadata: Record<string, unknown> = {};
+    if (deps.toolExecutions.length > 0) {
+      messageMetadata.tool_executions = deps.toolExecutions.map(exec => ({
+        name: exec.name,
+        arguments: exec.arguments,
+        result: exec.result
+          ? (exec.result.length > 500 ? exec.result.slice(0, 500) + '...' : exec.result)
+          : undefined,
+        error: exec.error,
+        duration_ms: exec.duration_ms,
+      }));
+      deps.toolExecutions.length = 0;
+    }
+
+    await deps.addMessage(finalMsg, messageMetadata);
+    await deps.emitEvent('message', { content: response.content });
+
+    await deps.updateRunStatus('completed', JSON.stringify({
+      response: response.content,
+      iterations: iteration,
+      engine: 'simple',
+    }));
+    await deps.emitEvent('completed', {
+      ...deps.buildTerminalEventPayload('completed', {
+        success: true,
+        iterations: iteration,
+        engine: 'simple',
+      }),
+    });
+    return;
+  }
+
+  await deps.updateRunStatus('completed', JSON.stringify({
+    message: 'Max iterations reached',
+    iterations: iteration,
+    engine: 'simple',
+  }));
+  await deps.emitEvent('completed', {
+    ...deps.buildTerminalEventPayload('completed', {
+      success: true,
+      maxIterations: true,
+    }),
+  });
+}
+
+export interface NoLLMDeps {
+  toolExecutor: ToolExecutorLike | undefined;
+  emitEvent: (type: AgentEvent['type'], data: Record<string, unknown>) => Promise<void>;
+  addMessage: (message: AgentMessage, metadata?: Record<string, unknown>) => Promise<void>;
+  updateRunStatus: (status: RunStatus, output?: string, error?: string) => Promise<void>;
+  buildTerminalEventPayload: (
+    status: 'completed' | 'failed' | 'cancelled',
+    details?: Record<string, unknown>,
+  ) => RunTerminalPayload;
+}
+
+/**
+ * Run without LLM (fallback mode).
+ */
+export async function runWithoutLLM(
+  deps: NoLLMDeps,
+  history: AgentMessage[],
+): Promise<void> {
+  await deps.emitEvent('thinking', { message: 'Processing (no LLM)...' });
+
+  const lastUserMessage = history.filter(m => m.role === 'user').pop();
+  const userQuery = lastUserMessage?.content || 'No message provided';
+
+  // Simple pattern matching
+  const response = await generateSimpleResponse(deps.toolExecutor, userQuery);
+
+  await deps.addMessage({
+    role: 'assistant',
+    content: response,
+  });
+
+  await deps.emitEvent('message', { content: response });
+  await deps.updateRunStatus('completed', JSON.stringify({ response, mode: 'no-llm' }));
+  await deps.emitEvent('completed', {
+    ...deps.buildTerminalEventPayload('completed', {
+      success: true,
+      mode: 'no-llm',
+    }),
+  });
+}
+
+/**
+ * Generate a simple response without LLM.
+ */
+async function generateSimpleResponse(
+  toolExecutor: ToolExecutorLike | undefined,
+  query: string,
+): Promise<string> {
+  if (!toolExecutor) {
+    return 'Tool executor not available. Please try again.';
+  }
+
+  const queryLower = query.toLowerCase();
+
+  if (queryLower.includes('list files') || queryLower.includes('show files')) {
+    const result = await toolExecutor.execute({
+      id: 'simple-file-list',
+      name: 'file_list',
+      arguments: { path: '' },
+    });
+    if (result.error) {
+      return `Error listing files: ${result.error}`;
+    }
+    return `Here are the files in your workspace:\n\n${result.output}`;
+  }
+
+  if (queryLower.includes('read file') || queryLower.includes('show file')) {
+    const pathMatch = query.match(/['"]([^'"]+)['"]/);
+    if (pathMatch) {
+      const result = await toolExecutor.execute({
+        id: 'simple-file-read',
+        name: 'file_read',
+        arguments: { path: pathMatch[1] },
+      });
+      if (result.error) {
+        return `Error reading file: ${result.error}`;
+      }
+      return `Content of ${pathMatch[1]}:\n\n\`\`\`\n${result.output}\n\`\`\``;
+    }
+    return 'Please specify a file path, e.g., "read file \'packages/control/src/web.ts\'"';
+  }
+
+  if (queryLower.includes('search for') || queryLower.includes('find')) {
+    const searchMatch = query.match(/(?:search for|find)\s+['"]?([^'"]+)['"]?/i);
+    if (searchMatch) {
+      const result = await toolExecutor.execute({
+        id: 'simple-search',
+        name: 'search',
+        arguments: { query: searchMatch[1], type: 'filename' },
+      });
+      return result.output;
+    }
+  }
+
+  return `I understand you're asking about: "${query}"\n\n` +
+    `I'm an AI agent that can help you with:\n` +
+    `- Reading and writing files\n` +
+    `- Searching your workspace\n` +
+    `- Deploying workers\n` +
+    `- Running build commands\n` +
+    `- Working with repositories and containers\n` +
+    `- Remembering information\n` +
+    `- Creating code and documentation\n\n` +
+    `Try asking me to "list files" or "read file 'path/to/file'".\n\n` +
+    `Note: LLM API key not configured. Running in limited mode.`;
+}

package/src/application/services/agent/skill-contracts.ts

@@ -0,0 +1,21 @@
+export type SkillLocale = 'ja' | 'en';
+export type OfficialSkillCategory = 'research' | 'writing' | 'planning' | 'slides' | 'software';
+export type SkillCategory = OfficialSkillCategory | 'custom';
+export type DurableOutputHint = 'artifact' | 'reminder' | 'repo' | 'app' | 'workspace_file';
+export type SkillOutputMode = 'chat' | DurableOutputHint;
+export type SkillSource = 'official' | 'custom';
+
+export interface SkillExecutionContract {
+  preferred_tools: string[];
+  durable_output_hints: DurableOutputHint[];
+  output_modes: SkillOutputMode[];
+  required_mcp_servers: string[];
+  template_ids: string[];
+}
+
+export interface CustomSkillMetadata {
+  locale?: SkillLocale;
+  category?: OfficialSkillCategory;
+  activation_tags?: string[];
+  execution_contract?: Partial<SkillExecutionContract>;
+}

package/src/application/services/agent/skill-loader.ts

@@ -0,0 +1,319 @@
+/**
+ * Skill Loading and Runtime Resolution.
+ *
+ * Contains functions that load equipped skills from the database,
+ * build skill resolution context from conversation history and
+ * thread metadata, and emit skill load outcome events.
+ *
+ * Extracted from skills.ts to separate runtime loading concerns
+ * from scoring and resolution logic.
+ */
+
+import type { AgentConfig, AgentMessage, AgentEvent } from './agent-models';
+import type { ToolExecutorLike } from '../../tools/executor';
+import { getDb, runs, threads } from '../../../infra/db';
+import { eq } from 'drizzle-orm';
+import { listLocalizedOfficialSkills, resolveSkillLocale } from './official-skills';
+import { listEnabledCustomSkillContext } from '../source/skills';
+import { listMcpServers } from '../platform/mcp';
+import { getSpaceLocale } from '../identity/locale';
+import { getDelegationPacketFromRunInput, isDelegationLocale } from './delegation';
+import { listSkillTemplates } from './skill-templates';
+import { logError, logWarn } from '../../../shared/utils/logger';
+import type { SqlDatabaseBinding } from '../../../shared/types/bindings.ts';
+import type {
+  SkillCatalogEntry,
+  SkillContext,
+  SkillResolutionContext,
+  SkillSelection,
+} from './skill-resolution';
+import { resolveSkillPlan } from './skill-resolution';
+
+// ── Constants ───────────────────────────────────────────────────────────
+
+// Skill loading limits - balanced for security and usability
+const MAX_TOTAL_INSTRUCTIONS_SIZE = 1_000_000; // 1MB total for selected detailed skill instructions
+const MAX_PER_SKILL_INSTRUCTIONS_SIZE = 50_000; // 50KB per skill
+
+// ── Types ───────────────────────────────────────────────────────────────
+
+export interface SkillLoadResult {
+  success: boolean;
+  error?: string;
+  skillLocale: 'ja' | 'en';
+  availableSkills: SkillCatalogEntry[];
+  selectedSkills: SkillSelection[];
+  activatedSkills: SkillContext[];
+}
+
+type SkillAvailabilityInput = {
+  availableToolNames: string[];
+};
+
+// ── Skill loading ───────────────────────────────────────────────────────
+
+/**
+ * Load equipped skills for the workspace.
+ *
+ * Security: Limits number of skills and total instruction size to prevent
+ * DoS attacks via excessive skill data loading.
+ */
+async function loadEquippedSkillsWithAvailability(
+  db: SqlDatabaseBinding,
+  spaceId: string,
+  config: AgentConfig,
+  skillContext: SkillResolutionContext,
+  input: SkillAvailabilityInput,
+): Promise<SkillLoadResult> {
+  const defaultResult: SkillLoadResult = {
+    success: false,
+    skillLocale: 'en',
+    availableSkills: [],
+    selectedSkills: [],
+    activatedSkills: [],
+  };
+
+  try {
+    const localeSamples = [
+      ...(skillContext.conversation ?? []),
+      skillContext.threadTitle ?? '',
+      skillContext.threadSummary ?? '',
+      ...((skillContext.threadKeyPoints ?? []).slice(0, 8)),
+    ].filter(Boolean);
+    const preferredLocale =
+      typeof skillContext.runInput?.skill_locale === 'string' ? skillContext.runInput.skill_locale
+        : typeof skillContext.runInput?.locale === 'string' ? skillContext.runInput.locale
+          : skillContext.preferredLocale
+            ?? skillContext.spaceLocale
+            ?? (typeof skillContext.runInput?.accept_language === 'string' ? skillContext.runInput.accept_language : null);
+    const skillLocale = resolveSkillLocale({
+      preferredLocale,
+      acceptLanguage: skillContext.acceptLanguage,
+      textSamples: localeSamples,
+    });
+    const availableMcpServerNames = (await listMcpServers(db, spaceId))
+      .filter((server) => server.enabled)
+      .map((server) => server.name);
+    const availableTemplateIds = listSkillTemplates().map((template) => template.id);
+    const officialSkills = listLocalizedOfficialSkills(skillLocale).map((skill) => ({
+      id: skill.id,
+      locale: skill.locale,
+      version: skill.version,
+      name: skill.name,
+      description: skill.description,
+      instructions: skill.instructions,
+      triggers: [...skill.triggers],
+      source: 'official' as const,
+      category: skill.category,
+      priority: skill.priority,
+      activation_tags: [...skill.activation_tags],
+      execution_contract: {
+        preferred_tools: [...skill.execution_contract.preferred_tools],
+        durable_output_hints: [...skill.execution_contract.durable_output_hints],
+        output_modes: [...skill.execution_contract.output_modes],
+        required_mcp_servers: [...skill.execution_contract.required_mcp_servers],
+        template_ids: [...skill.execution_contract.template_ids],
+      },
+      availability: 'available' as const,
+      availability_reasons: [],
+    }));
+    const customSkills = await listEnabledCustomSkillContext(db, spaceId);
+
+    const plan = resolveSkillPlan(
+      [
+        ...officialSkills,
+        ...customSkills,
+      ],
+      {
+        ...skillContext,
+        locale: skillLocale,
+        availableToolNames: input.availableToolNames,
+        availableMcpServerNames,
+        availableTemplateIds,
+        maxTotalInstructionBytes: MAX_TOTAL_INSTRUCTIONS_SIZE,
+        maxPerSkillInstructionBytes: MAX_PER_SKILL_INSTRUCTIONS_SIZE,
+      },
+    );
+
+    return {
+      success: true,
+      skillLocale,
+      availableSkills: plan.availableSkills,
+      selectedSkills: plan.selectedSkills,
+      activatedSkills: plan.activatedSkills,
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    logError('Failed to load equipped skills', errorMessage, { module: 'services/agent/runner' });
+    return { ...defaultResult, error: errorMessage };
+  }
+}
+
+export async function loadEquippedSkills(
+  db: SqlDatabaseBinding,
+  spaceId: string,
+  toolExecutor: ToolExecutorLike | undefined,
+  config: AgentConfig,
+  skillContext: SkillResolutionContext,
+): Promise<SkillLoadResult> {
+  return loadEquippedSkillsWithAvailability(
+    db,
+    spaceId,
+    config,
+    skillContext,
+    {
+      availableToolNames: toolExecutor?.getAvailableTools().map((tool) => tool.name) ?? [],
+    },
+  );
+}
+
+/**
+ * Build the skill resolution context from conversation history and thread metadata.
+ */
+export async function buildSkillResolutionContext(
+  db: SqlDatabaseBinding,
+  context: { threadId: string; runId: string; spaceId: string },
+  config: AgentConfig,
+  history: AgentMessage[],
+): Promise<SkillResolutionContext> {
+  const drizzleDb = getDb(db);
+  const recentUserConversation = history
+    .filter((message) => message.role === 'user')
+    .map((message) => message.content);
+
+  const thread = await drizzleDb.select({
+    title: threads.title,
+    locale: threads.locale,
+    summary: threads.summary,
+    keyPoints: threads.keyPoints,
+  }).from(threads).where(eq(threads.id, context.threadId)).get();
+
+  const runRow = await drizzleDb.select({
+    input: runs.input,
+  }).from(runs).where(eq(runs.id, context.runId)).get();
+
+  let parsedRunInput: Record<string, unknown> = {};
+  try {
+    const parsed = JSON.parse(runRow?.input || '{}') as unknown;
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+      parsedRunInput = parsed as Record<string, unknown>;
+    }
+  } catch (error) {
+    logWarn('Failed to parse run input for skill resolution', { module: 'services/agent/runner', error: error instanceof Error ? error.message : String(error) });
+  }
+
+  let threadKeyPoints: string[] = [];
+  try {
+    const parsed = JSON.parse(thread?.keyPoints || '[]') as unknown;
+    if (Array.isArray(parsed)) {
+      threadKeyPoints = parsed.map((item) => String(item).trim()).filter(Boolean);
+    }
+  } catch (error) {
+    logWarn('Failed to parse thread key points for skill resolution', { module: 'services/agent/runner', error: error instanceof Error ? error.message : String(error) });
+  }
+
+  const delegationPacket = getDelegationPacketFromRunInput(parsedRunInput);
+  const preferredLocale = delegationPacket?.locale
+    ?? (isDelegationLocale(thread?.locale) ? thread.locale : null);
+
+  return {
+    conversation: recentUserConversation,
+    threadTitle: thread?.title ?? null,
+    threadSummary: thread?.summary ?? null,
+    threadKeyPoints,
+    runInput: parsedRunInput,
+    agentType: config.type,
+    preferredLocale,
+    spaceLocale: await getSpaceLocale(db, context.spaceId),
+    acceptLanguage: typeof parsedRunInput.accept_language === 'string'
+      ? parsedRunInput.accept_language
+      : typeof parsedRunInput.acceptLanguage === 'string'
+        ? parsedRunInput.acceptLanguage
+        : null,
+  };
+}
+
+export async function resolveSkillPlanForRun(
+  db: SqlDatabaseBinding,
+  input: {
+    threadId: string;
+    runId: string;
+    spaceId: string;
+    agentType: string;
+    history: AgentMessage[];
+    availableToolNames: string[];
+  },
+): Promise<SkillLoadResult> {
+  const skillContext = await buildSkillResolutionContext(
+    db,
+    {
+      threadId: input.threadId,
+      runId: input.runId,
+      spaceId: input.spaceId,
+    },
+    {
+      type: input.agentType,
+      systemPrompt: '',
+      tools: [],
+    },
+    input.history,
+  );
+
+  return loadEquippedSkillsWithAvailability(
+    db,
+    input.spaceId,
+    {
+      type: input.agentType,
+      systemPrompt: '',
+      tools: [],
+    },
+    skillContext,
+    {
+      availableToolNames: input.availableToolNames,
+    },
+  );
+}
+
+/**
+ * Emit the skill load outcome event (success with details, or warning on failure).
+ */
+export async function emitSkillLoadOutcome(
+  result: SkillLoadResult,
+  emitEvent: (type: AgentEvent['type'], data: Record<string, unknown>) => Promise<void>,
+): Promise<void> {
+  if (result.success && result.availableSkills.length > 0) {
+    const officialCount = result.availableSkills.filter((skill) => skill.source === 'official').length;
+    const customCount = result.availableSkills.filter((skill) => skill.source === 'custom').length;
+    await emitEvent('thinking', {
+      message: `Loaded ${result.availableSkills.length} available skill(s), selected ${result.selectedSkills.length}, activated ${result.activatedSkills.length} for this run`,
+      skill_locale: result.skillLocale,
+      available_skill_count: result.availableSkills.length,
+      selectable_skill_count: result.availableSkills.filter((skill) => skill.availability !== 'unavailable').length,
+      selected_skill_count: result.selectedSkills.length,
+      activated_skill_count: result.activatedSkills.length,
+      official_skill_count: officialCount,
+      custom_skill_count: customCount,
+      available_skill_ids: result.availableSkills.map((skill) => skill.id),
+      selectable_skill_ids: result.availableSkills
+        .filter((skill) => skill.availability !== 'unavailable')
+        .map((skill) => skill.id),
+      selected_skill_ids: result.selectedSkills.map((entry) => entry.skill.id),
+      activated_skill_ids: result.activatedSkills.map((skill) => skill.id),
+      selected_skills: result.selectedSkills.map((entry) => ({
+        id: entry.skill.id,
+        name: entry.skill.name,
+        score: entry.score,
+        reasons: entry.reasons,
+      })),
+      skills: result.activatedSkills.map((skill) => skill.name),
+    });
+    return;
+  }
+
+  if (!result.success) {
+    await emitEvent('thinking', {
+      message: `Warning: Failed to load skills - ${result.error}`,
+      warning: true,
+    });
+  }
+}