@capekai/core 1.0.0

package/src/core/tool-builders/workspace-tools.ts

@@ -0,0 +1,293 @@
+import { tool, jsonSchema } from 'ai';
+import {
+  getContributedDomainToolPayloads,
+  getDomainToolFallback,
+  mergeDomainToolVisualization,
+  type DomainToolPayload,
+} from '../../runtime/domain-tool-source';
+import { getWorkspace } from '../../storage/runtime';
+import {
+  createAskApi,
+  rejectPendingAsksByToolCallId,
+  type AskBroadcastFn,
+} from '../../permission/ask-user-api';
+import { interruptManager } from '../interrupt';
+import type { WorkflowInput } from '@capekai/types';
+import type { PermissionRiskLevel } from '@capekai/tool';
+import type { ToolMap } from './types';
+
+export interface WorkspaceToolsOptions {
+  workspaceId: string;
+  workspacePath: string;
+  rootSessionId: string;
+  sessionId: string;
+  canSpawn: boolean;
+  canSpawnSubagents?: boolean | string[] | null;
+  allowSelfAsSubagent?: boolean;
+  allowedSubagentIds?: string[];
+  broadcastFn?: AskBroadcastFn;
+  agentId?: string | null;
+  allowedSkills?: string[] | null;
+  agentSkillsDir?: string;
+}
+
+export async function buildWorkspaceTools(options: WorkspaceToolsOptions): Promise<ToolMap> {
+  const {
+    workspaceId,
+    workspacePath,
+    rootSessionId,
+    sessionId,
+    canSpawn,
+    canSpawnSubagents,
+    allowSelfAsSubagent,
+    broadcastFn,
+    agentId,
+    allowedSkills,
+    agentSkillsDir,
+  } = options;
+
+  const tools: ToolMap = {};
+  const workspace = await getWorkspace(workspaceId);
+  if (!workspace) return tools;
+
+  // The generic contributed-domain-tool payload map is resolved once and
+  // shared by the skill, memory, workflow, skill_manage, session_search,
+  // and scheduler builders: null means the unscoped path (registered
+  // fallbacks may apply), an empty map means a composed scope without
+  // domain payloads (fallbacks disabled).
+  const scopedDomainPayloads = getContributedDomainToolPayloads();
+  const domainPayload = (name: string): DomainToolPayload | null =>
+    scopedDomainPayloads === null
+      ? getDomainToolFallback(name)
+      : scopedDomainPayloads.get(name) ?? null;
+
+  // ── Skill tool ────────────────────────────────────────────
+  if (workspacePath) {
+    const skillPayload = domainPayload('skill');
+    const skillDefinition = await skillPayload?.resolveDefinition?.(sessionId, {
+      workspacePath,
+      allowedSkills,
+      agentSkillsDir,
+    });
+    if (skillPayload && skillDefinition) {
+      tools['skill'] = tool({
+        description: skillDefinition.description,
+        inputSchema: jsonSchema(skillDefinition.inputSchema),
+        execute: async (args: Record<string, unknown>) =>
+          skillPayload.execute(args, {
+            workspaceId,
+            sessionId,
+            ask: async () => {
+              throw new Error('Cannot ask user: no broadcast channel available');
+            },
+            agentId,
+            workspacePath,
+            allowedSkills,
+            agentSkillsDir,
+          }).then((result) => mergeDomainToolVisualization(skillPayload, args, result)),
+      });
+    }
+  }
+
+  // ── Memory tool ───────────────────────────────────────────
+  const memoryPayload = domainPayload('memory');
+  const memorySettings = workspace.settings?.memory;
+  if (memoryPayload && memorySettings?.enabled) {
+    const permissionRisk = memorySettings.permissionRisk;
+    tools['memory'] = tool({
+      description: memoryPayload.description,
+      inputSchema: jsonSchema(memoryPayload.inputSchema),
+      execute: async (args: Record<string, unknown>, { toolCallId }: { toolCallId: string }) => {
+        const _toolAbortController = interruptManager.registerToolExecution(sessionId, toolCallId);
+        try {
+          const askApi = createAskApiOrThrow(sessionId, toolCallId, 'memory', broadcastFn, workspaceId, rootSessionId);
+          const result = await memoryPayload.execute(args, {
+            workspaceId,
+            sessionId,
+            ask: (ask: import('@capekai/tool').Ask) => askApi(ask),
+            agentId,
+            workspacePath,
+            permissionRisk,
+          });
+          return mergeDomainToolVisualization(memoryPayload, args, result);
+        } finally {
+          interruptManager.unregisterToolExecution(sessionId, toolCallId);
+          await rejectPendingAsksByToolCallId(toolCallId);
+        }
+      },
+    });
+  }
+
+  // ── Workflow tool ─────────────────────────────────────────────
+  // Same generic domain seam as session_search and scheduler: the domain
+  // payload owns the depth gate (isEnabled) and the dynamic definition
+  // (allowed leaf agent list); the workspace settings gate stays here, and
+  // the allowed-subagent list is captured at build time from the resolved
+  // definition exactly like pre-C5.
+  const workflowPayload = domainPayload('workflow');
+  const workflowSettings = workspace.settings?.workflow;
+  if (workflowPayload && workflowSettings?.enabled && canSpawn && await workflowPayload.isEnabled?.(workspaceId, sessionId) === true) {
+    const workflowDefinition = await workflowPayload.resolveDefinition?.(sessionId, {
+      canSpawnSubagents,
+      allowSelfAsSubagent,
+    });
+    if (workflowDefinition) {
+      tools['workflow'] = tool({
+        description: workflowDefinition.description,
+        inputSchema: jsonSchema(workflowDefinition.inputSchema),
+        execute: async (args: Record<string, unknown>, { toolCallId }: { toolCallId: string }) => {
+          const toolAbortController = interruptManager.registerToolExecution(sessionId, toolCallId);
+          try {
+            const workflowInput = {
+              prompt: args.prompt as string,
+              ...(args.description ? { description: args.description as string } : {}),
+              ...(args.subtasks ? { subtasks: args.subtasks as WorkflowInput['subtasks'] } : {}),
+              ...(args.leafPreconfigId ? { leafPreconfigId: args.leafPreconfigId as string } : {}),
+              ...(args.outputSchema ? { outputSchema: args.outputSchema as Record<string, unknown> } : {}),
+            } as WorkflowInput;
+
+            return await workflowPayload.execute(
+              workflowInput as unknown as Record<string, unknown>,
+              {
+              workspaceId,
+              sessionId,
+              ask: broadcastFn
+                ? (ask: import('@capekai/tool').Ask) =>
+                  createAskApi(sessionId, toolCallId, workflowPayload.name, broadcastFn, workspaceId, rootSessionId)(ask)
+                : async () => {
+                  throw new Error('Cannot ask user: no broadcast channel available');
+                },
+              agentId,
+              workspacePath,
+              abortSignal: toolAbortController.signal,
+              allowedSubagentIds: workflowDefinition.allowedSubagentIds,
+            });
+          } finally {
+            interruptManager.unregisterToolExecution(sessionId, toolCallId);
+          }
+        },
+      });
+    }
+  }
+
+  // ── Skill management tool ─────────────────────────────────
+  const skillManagePayload = domainPayload('skill_manage');
+  const skillSettings = workspace.settings?.skills;
+  if (skillManagePayload && skillSettings?.managementEnabled) {
+    const permissionRisk = skillSettings.permissionRisk;
+    const skillManageDefinition = await skillManagePayload.resolveDefinition?.(sessionId, {
+      workspacePath,
+    });
+    if (skillManageDefinition) {
+      tools['skill_manage'] = tool({
+        description: skillManageDefinition.description,
+        inputSchema: jsonSchema(skillManageDefinition.inputSchema),
+        execute: async (args: Record<string, unknown>, { toolCallId }: { toolCallId: string }) => {
+          const _toolAbortController = interruptManager.registerToolExecution(sessionId, toolCallId);
+          try {
+          const askApi = createAskApiOrThrow(sessionId, toolCallId, 'skill_manage', broadcastFn, workspaceId, rootSessionId);
+          const result = await skillManagePayload.execute(args, {
+            workspaceId,
+            sessionId,
+            ask: (ask: import('@capekai/tool').Ask) => askApi(ask),
+            agentId,
+            workspacePath,
+            permissionRisk,
+          });
+          return mergeDomainToolVisualization(skillManagePayload, args, result);
+          } finally {
+            interruptManager.unregisterToolExecution(sessionId, toolCallId);
+            await rejectPendingAsksByToolCallId(toolCallId);
+          }
+        },
+      });
+    }
+  }
+
+  // ── Session search tool ───────────────────────────────────
+  // The domain payload owns the settings gate (isEnabled) and the executor;
+  // the settings values the executor needs are captured here at build time
+  // exactly like pre-C5 and passed through the execution context.
+  const sessionSearchPayload = domainPayload('session_search');
+  const searchSettings = workspace.settings?.sessionSearch;
+  if (sessionSearchPayload && await sessionSearchPayload.isEnabled?.(workspaceId, sessionId) === true) {
+    tools['session_search'] = tool({
+      description: sessionSearchPayload.description,
+      inputSchema: jsonSchema(sessionSearchPayload.inputSchema as Record<string, unknown>),
+      execute: async (args: Record<string, unknown>, { toolCallId }: { toolCallId: string }) => {
+        const _toolAbortController = interruptManager.registerToolExecution(sessionId, toolCallId);
+        try {
+          const askApi = createAskApiOrThrow(sessionId, toolCallId, sessionSearchPayload.name, broadcastFn, workspaceId, rootSessionId);
+          const result = await sessionSearchPayload.execute(
+            args,
+            {
+              workspaceId,
+              sessionId,
+              ask: (ask: import('@capekai/tool').Ask) => askApi(ask),
+              agentId,
+              permissionRisk: searchSettings?.permissionRisk,
+              includeToolResults: searchSettings?.includeToolResults === true,
+            },
+          );
+          return mergeDomainToolVisualization(sessionSearchPayload, args, result);
+        } finally {
+          interruptManager.unregisterToolExecution(sessionId, toolCallId);
+          await rejectPendingAsksByToolCallId(toolCallId);
+        }
+      },
+    });
+  }
+
+  // ── Scheduler tool ────────────────────────────────────────
+  // Same generic domain seam as session_search: the domain payload owns the
+  // workspace settings gate plus the current-session scheduled-job recursion
+  // gate (isEnabled) and the executor; the permission risk is captured here
+  // at build time exactly like pre-C5 and passed through the execution
+  // context.
+  const schedulerPayload = domainPayload('scheduler');
+  if (schedulerPayload && await schedulerPayload.isEnabled?.(workspaceId, sessionId) === true) {
+    const schedulingRisk: PermissionRiskLevel = workspace.settings?.scheduling?.permissionRisk ?? 'none';
+    tools['scheduler'] = tool({
+      description: schedulerPayload.description,
+      inputSchema: jsonSchema(schedulerPayload.inputSchema as Record<string, unknown>),
+      execute: async (args: Record<string, unknown>, { toolCallId }: { toolCallId: string }) => {
+        const _toolAbortController = interruptManager.registerToolExecution(sessionId, toolCallId);
+        try {
+          const askApi = createAskApiOrThrow(sessionId, toolCallId, schedulerPayload.name, broadcastFn, workspaceId, rootSessionId);
+          const result = await schedulerPayload.execute(
+            args,
+            {
+              workspaceId,
+              sessionId,
+              ask: (ask: import('@capekai/tool').Ask) => askApi(ask),
+              agentId,
+              permissionRisk: schedulingRisk,
+            },
+          );
+          return mergeDomainToolVisualization(schedulerPayload, args, result);
+        } finally {
+          interruptManager.unregisterToolExecution(sessionId, toolCallId);
+          await rejectPendingAsksByToolCallId(toolCallId);
+        }
+      },
+    });
+  }
+
+  return tools;
+}
+
+// ── Shared helpers ───────────────────────────────────────────
+
+function createAskApiOrThrow(
+  sessionId: string,
+  toolCallId: string,
+  toolName: string,
+  broadcastFn: AskBroadcastFn | undefined,
+  workspaceId: string | undefined,
+  rootSessionId: string,
+): import('@capekai/tool').AskApi {
+  if (!broadcastFn) {
+    throw new Error('Cannot ask user: no broadcast channel available');
+  }
+  return createAskApi(sessionId, toolCallId, toolName, broadcastFn, workspaceId, rootSessionId);
+}

package/src/core/tool-capabilities.ts

@@ -0,0 +1,65 @@
+import type { Session } from '@capekai/types';
+import { getSession } from '../storage/runtime';
+
+export type ToolExecutionScope = 'subsession' | 'scheduled';
+
+const RESTRICTED_CAPABILITIES: Record<ToolExecutionScope, ReadonlySet<string>> = {
+  subsession: new Set(['interactive-user-input']),
+  scheduled: new Set(['interactive-user-input']),
+};
+
+export async function resolveToolExecutionScopes(
+  sessionId: string,
+  sessionLookup: (id: string) => Session | null | Promise<Session | null> = getSession,
+): Promise<ReadonlySet<ToolExecutionScope>> {
+  const scopes = new Set<ToolExecutionScope>();
+  const visited = new Set<string>();
+  let current = await sessionLookup(sessionId);
+
+  if (!current) {
+    return scopes;
+  }
+
+  if (current.parentId) {
+    scopes.add('subsession');
+  }
+
+  while (current) {
+    if (visited.has(current.id)) {
+      break;
+    }
+    visited.add(current.id);
+
+    if (!current.parentId) {
+      const scheduledJobId = current.metadata?.scheduledJobId;
+      if (typeof scheduledJobId === 'string' && scheduledJobId.length > 0) {
+        scopes.add('scheduled');
+      }
+      break;
+    }
+
+    current = await sessionLookup(current.parentId);
+  }
+
+  return scopes;
+}
+
+export function isToolAllowedInContext(
+  capabilities: readonly string[] | undefined,
+  scopes: ReadonlySet<ToolExecutionScope>,
+): boolean {
+  if (!capabilities || capabilities.length === 0) {
+    return true;
+  }
+
+  for (const scope of scopes) {
+    const restricted = RESTRICTED_CAPABILITIES[scope];
+    for (const capability of capabilities) {
+      if (restricted.has(capability)) {
+        return false;
+      }
+    }
+  }
+
+  return true;
+}

package/src/goals/evaluator.ts

@@ -0,0 +1,171 @@
+import type { BroadcastFn, BroadcastSessionFn } from '../runtime/host';
+import type { GoalEvaluation, MessageWithParts, TextPart, ToolPart } from '@capekai/types';
+import { listMessagesWithParts } from '../storage/runtime';
+import { runOrchestratorSession } from '../workflow/orchestrator-session';
+
+/**
+ * Goal domain: the goal evaluator model turn. Moved byte-for-byte from
+ * `core/goal-evaluator.ts`; the unscoped export keeps the pre-C5 module
+ * path (module storage plus the pinned core orchestrator-session
+ * compatibility forwarder), and `evaluateGoalWithDeps` runs against the
+ * injected transcript listing and orchestrator turn contract captured by
+ * the goal domain plugin. The composed path never imports workflow
+ * implementation code: the plugin bridges the shared
+ * `capek.orchestrator-session` contract into these structural types.
+ */
+
+const MAX_TRANSCRIPT_MESSAGES = 20;
+const MAX_TOOL_OUTPUT_CHARS = 500;
+
+function summarizeToolState(toolPart: ToolPart): string {
+  const state = toolPart.state;
+  if (state.status === 'completed') {
+    if (typeof state.output === 'string') return state.output.slice(0, MAX_TOOL_OUTPUT_CHARS);
+    if (state.output && typeof state.output === 'object') return JSON.stringify(state.output).slice(0, MAX_TOOL_OUTPUT_CHARS);
+    return '(completed)';
+  }
+  if (state.status === 'error') return `ERROR: ${state.error ?? 'unknown'}`;
+  return `(${state.status})`;
+}
+
+async function buildTranscriptSummary(
+  listTranscript: (sessionId: string) => MessageWithParts[] | Promise<MessageWithParts[]>,
+  sessionId: string,
+): Promise<string> {
+  const messages = await listTranscript(sessionId);
+  return messages.slice(-MAX_TRANSCRIPT_MESSAGES).map((entry) => {
+    if (entry.message.role === 'user') {
+      const text = entry.parts
+        .filter((part): part is TextPart => part.type === 'text')
+        .map((part) => part.text || '')
+        .join('');
+      return text ? `[USER]: ${text}` : '';
+    }
+    if (entry.message.role === 'assistant') {
+      return entry.parts.map((part) => {
+        if (part.type === 'text' && part.text) return `[ASSISTANT]: ${part.text}`;
+        if (part.type === 'tool') return `[TOOL: ${part.name}]: ${summarizeToolState(part)}`;
+        return '';
+      }).filter(Boolean).join('\n');
+    }
+    return '';
+  }).filter(Boolean).join('\n\n');
+}
+
+/** Structural copy of the shared orchestrator-session contract result. The
+ * goal domain never imports workflow implementation code; the plugin
+ * bridges the named `capek.orchestrator-session` contract into this shape. */
+export interface GoalOrchestratorTurnOptions {
+  parentSessionId: string;
+  title: string;
+  agentName: string;
+  systemPrompt: string;
+  userPrompt: string;
+  maxTokens?: number;
+  abortSignal?: AbortSignal;
+  broadcast?: BroadcastFn;
+  broadcastSessionCreated?: BroadcastSessionFn;
+  broadcastSessionUpdated?: BroadcastSessionFn;
+}
+
+export interface GoalOrchestratorTurnResult {
+  text: string;
+  json: Record<string, unknown> | null;
+  sessionId: string;
+}
+
+export interface GoalEvaluatorDeps {
+  listTranscript(sessionId: string): MessageWithParts[] | Promise<MessageWithParts[]>;
+  orchestrator: {
+    run(options: GoalOrchestratorTurnOptions): Promise<GoalOrchestratorTurnResult>;
+  };
+}
+
+export interface EvaluateGoalOptions {
+  sessionId: string;
+  condition: string;
+  turn: number;
+  maxTurns: number;
+  abortSignal?: AbortSignal;
+  broadcast?: BroadcastFn;
+  broadcastSessionCreated?: BroadcastSessionFn;
+  broadcastSessionUpdated?: BroadcastSessionFn;
+}
+
+/** Unscoped evaluator: module storage transcript plus the pinned core
+ * orchestrator-session forwarder, exactly like the pre-C5 path. */
+export async function evaluateGoal(options: EvaluateGoalOptions): Promise<GoalEvaluation> {
+  return evaluateGoalWithDeps(options, {
+    listTranscript: listMessagesWithParts,
+    orchestrator: { run: runOrchestratorSession },
+  });
+}
+
+/** Composed evaluator over the injected transcript listing and orchestrator
+ * turn contract. */
+export async function evaluateGoalWithDeps(
+  options: EvaluateGoalOptions,
+  deps: GoalEvaluatorDeps,
+): Promise<GoalEvaluation> {
+  console.log('[goal:evaluator] Starting evaluation', {
+    sessionId: options.sessionId,
+    turn: options.turn,
+    conditionPreview: options.condition.slice(0, 80),
+  });
+
+  const transcript = await buildTranscriptSummary(deps.listTranscript, options.sessionId);
+  const system = [
+    'You are a goal evaluator. Your job is to determine if a completion condition',
+    'has been met based on the conversation transcript of an AI agent working on a task.',
+    '',
+    `Completion condition: "${options.condition}"`,
+    '',
+    'Rules:',
+    '- Look for evidence in tool outputs (test results, lint output, build status, file contents).',
+    '- Only return goalMet: true if you find CONCRETE evidence the condition is satisfied.',
+    '- Do NOT assume the condition is met just because the agent said it was — verify from tool outputs.',
+    '- If the condition requires tests to pass, look for actual test output showing all tests passing.',
+    '',
+    `Conversation transcript (turn ${options.turn} of ${options.maxTurns}):`,
+    transcript,
+    '',
+    'Respond with ONLY valid JSON (no markdown fences, no extra text):',
+    '{"goalMet": true/false, "reason": "explanation", "remainingWork": "what is left to do"}',
+  ].join('\n');
+  const result = await deps.orchestrator.run({
+    parentSessionId: options.sessionId,
+    title: `Goal Eval (Turn ${options.turn}): ${options.condition.slice(0, 40)}`,
+    agentName: 'goal-evaluator',
+    systemPrompt: system,
+    userPrompt: `Evaluate: has the condition "${options.condition}" been met based on the transcript above?`,
+    maxTokens: 2048,
+    abortSignal: options.abortSignal,
+    broadcast: options.broadcast,
+    broadcastSessionCreated: options.broadcastSessionCreated,
+    broadcastSessionUpdated: options.broadcastSessionUpdated,
+  });
+
+  console.log('[goal:evaluator] Evaluation complete', {
+    goalMet: result.json?.goalMet === true,
+    reason: result.json?.reason,
+  });
+
+  return {
+    goalMet: result.json?.goalMet === true,
+    reason: (result.json?.reason as string) ?? 'No reason provided',
+    remainingWork: (result.json?.remainingWork as string) ?? undefined,
+  };
+}
+
+/** The run directive for the next turn when the goal is not yet met. Moved
+ * byte-for-byte from the pre-C5 goal-evaluator export. */
+export function buildContinuationMessage(condition: string, reason: string, remainingWork?: string): string {
+  return [
+    `The goal is NOT yet met: ${condition}`,
+    '',
+    `Evaluator feedback: ${reason}`,
+    remainingWork ? `\nRemaining work: ${remainingWork}` : '',
+    '',
+    'Continue working toward the goal. Do not repeat work you have already done.',
+  ].join('\n');
+}

package/src/goals/index.ts

@@ -0,0 +1,3 @@
+export * from './evaluator';
+export * from './loop';
+export * from './service';