@capekai/core 1.0.0

package/src/sandbox/model.ts

@@ -0,0 +1,305 @@
+import { randomUUID } from 'crypto';
+import { simulateReadableStream } from 'ai';
+import { getSandboxController } from './controller';
+import { getSession } from '../storage/runtime';
+import type {
+  ErrorResponse,
+  LlmCallContext,
+  SandboxResponse,
+  SandboxToolDefinition,
+} from './types';
+
+const ERROR_TYPE_TO_STATUS: Record<NonNullable<ErrorResponse['errorType']>, number> = {
+  rate_limit: 429,
+  server: 500,
+  timeout: 408,
+  auth: 401,
+  invalid_request: 400,
+};
+
+interface SandboxPromptMessage {
+  role: string;
+  content: unknown;
+}
+
+interface SandboxModelCallOptions {
+  prompt: SandboxPromptMessage[];
+  tools?: unknown;
+  abortSignal?: AbortSignal;
+}
+
+interface SandboxLanguageModelOptions {
+  sessionId: string;
+  modelId: string;
+  providerId: string;
+}
+
+const defaultGenerateUsage = {
+  inputTokens: {
+    total: 10,
+    noCache: 10,
+    cacheRead: undefined,
+    cacheWrite: undefined,
+  },
+  outputTokens: {
+    total: 20,
+    text: 20,
+    reasoning: undefined,
+  },
+} as const;
+
+function toTools(tools: unknown): SandboxToolDefinition[] {
+  if (!tools) {
+    return [];
+  }
+
+  if (Array.isArray(tools)) {
+    return tools.map((tool, index) => {
+      const candidate = tool as {
+        name?: string;
+        description?: string;
+        inputSchema?: unknown;
+      };
+
+      return {
+        name: candidate.name ?? `tool-${index + 1}`,
+        description: candidate.description ?? '',
+        inputSchema: candidate.inputSchema,
+      };
+    });
+  }
+
+  return Object.entries(tools as Record<string, { description?: string; inputSchema?: unknown }>).map(([name, tool]) => ({
+    name,
+    description: tool.description ?? '',
+    inputSchema: tool.inputSchema,
+  }));
+}
+
+function toSystemPrompt(prompt: SandboxPromptMessage[]): string | undefined {
+  const systemMessage = prompt.find((message) => message.role === 'system');
+  if (!systemMessage) {
+    return undefined;
+  }
+
+  return typeof systemMessage.content === 'string' ? systemMessage.content : undefined;
+}
+
+function wrapStreamWithCompletion(
+  stream: ReadableStream<unknown>,
+  callId: string,
+): ReadableStream<unknown> {
+  return new ReadableStream<unknown>({
+    async start(controller): Promise<void> {
+      const reader = stream.getReader();
+
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) {
+            break;
+          }
+
+          controller.enqueue(value);
+        }
+
+        controller.close();
+      } catch (error: unknown) {
+        controller.error(error);
+      } finally {
+        reader.releaseLock();
+        getSandboxController().complete(callId);
+      }
+    },
+    async cancel(reason: unknown): Promise<void> {
+      await stream.cancel(reason);
+      getSandboxController().complete(callId);
+    },
+  });
+}
+
+export class SandboxLanguageModel {
+  readonly specificationVersion = 'v3' as const;
+  readonly provider: string;
+  readonly modelId: string;
+  readonly supportedUrls = Promise.resolve({});
+
+  private sessionId: string;
+
+  constructor(options: SandboxLanguageModelOptions) {
+    this.sessionId = options.sessionId;
+    this.modelId = options.modelId;
+    this.provider = options.providerId;
+  }
+
+  async doStream(options: SandboxModelCallOptions): Promise<{ stream: ReadableStream<unknown> }> {
+    const context = await this.createContext(options, 'stream');
+    const response = await getSandboxController().waitForResponse(context, options.abortSignal);
+    const stream = wrapStreamWithCompletion(this.responseToStream(response), context.callId);
+
+    return { stream };
+  }
+
+  async doGenerate(options: SandboxModelCallOptions): Promise<{
+    content: Array<{ type: 'text'; text: string }>;
+    finishReason: { unified: 'stop'; raw: undefined };
+    usage: typeof defaultGenerateUsage;
+    warnings: [];
+  }> {
+    const context = await this.createContext(options, 'generate');
+    const response = await getSandboxController().waitForResponse(context, options.abortSignal);
+
+    try {
+      return this.responseToGenerateResult(response);
+    } finally {
+      getSandboxController().complete(context.callId);
+    }
+  }
+
+  private async createContext(
+    options: SandboxModelCallOptions,
+    mode: 'stream' | 'generate',
+  ): Promise<LlmCallContext> {
+    return {
+      callId: randomUUID(),
+      sessionId: this.sessionId,
+      depth: await this.computeDepth(),
+      mode,
+      messages: options.prompt.map((message) => ({
+        role: message.role,
+        content: message.content,
+      })),
+      systemPrompt: toSystemPrompt(options.prompt),
+      tools: toTools(options.tools),
+      modelId: this.modelId,
+      providerId: this.provider,
+      timestamp: Date.now(),
+    };
+  }
+
+  private responseToStream(response: SandboxResponse): ReadableStream<unknown> {
+    if (response.type === 'error') {
+      throw createClassifiedError(response);
+    }
+
+    const chunks: unknown[] = [];
+
+    switch (response.type) {
+      case 'text': {
+        const textId = randomUUID();
+        const splitAt = Math.max(1, Math.floor(response.content.length / 2));
+        const textChunks = response.content.length > 1
+          ? [response.content.slice(0, splitAt), response.content.slice(splitAt)]
+          : [response.content];
+        chunks.push(
+          { type: 'text-start', id: textId },
+          ...textChunks.map((delta) => ({ type: 'text-delta', id: textId, delta })),
+          { type: 'text-end', id: textId },
+        );
+        break;
+      }
+
+      case 'reasoning': {
+        const reasoningId = randomUUID();
+        const textId = randomUUID();
+        chunks.push(
+          { type: 'reasoning-start', id: reasoningId },
+          { type: 'reasoning-delta', id: reasoningId, delta: response.reasoning },
+          { type: 'reasoning-end', id: reasoningId },
+          { type: 'text-start', id: textId },
+          { type: 'text-delta', id: textId, delta: response.text },
+          { type: 'text-end', id: textId },
+        );
+        break;
+      }
+
+      case 'tool-call': {
+        chunks.push({
+          type: 'tool-call',
+          toolCallId: response.toolCallId ?? randomUUID(),
+          toolName: response.toolName,
+          input: JSON.stringify(response.args),
+        });
+        break;
+      }
+
+      case 'multi-tool-call': {
+        for (const call of response.calls) {
+          chunks.push({
+            type: 'tool-call',
+            toolCallId: call.toolCallId ?? randomUUID(),
+            toolName: call.toolName,
+            input: JSON.stringify(call.args),
+          });
+        }
+        break;
+      }
+    }
+
+    chunks.push({
+      type: 'finish',
+      finishReason: { unified: 'stop' as const, raw: undefined },
+      logprobs: undefined,
+      usage: defaultGenerateUsage,
+    });
+
+    return simulateReadableStream({ chunks });
+  }
+
+  private responseToGenerateResult(response: SandboxResponse): {
+    content: Array<{ type: 'text'; text: string }>;
+    finishReason: { unified: 'stop'; raw: undefined };
+    usage: typeof defaultGenerateUsage;
+    warnings: [];
+  } {
+    if (response.type === 'error') {
+      throw createClassifiedError(response);
+    }
+
+    const text = response.type === 'text'
+      ? response.content
+      : response.type === 'reasoning'
+        ? response.text
+        : JSON.stringify(response);
+
+    return {
+      content: [{ type: 'text', text }],
+      finishReason: { unified: 'stop', raw: undefined },
+      usage: defaultGenerateUsage,
+      warnings: [],
+    };
+  }
+
+  private async computeDepth(): Promise<number> {
+    let depth = 0;
+    let session = await getSession(this.sessionId);
+
+    while (session?.parentId) {
+      depth += 1;
+      session = await getSession(session.parentId);
+    }
+
+    return depth;
+  }
+}
+
+function createClassifiedError(response: ErrorResponse): Error & { status?: number; isRateLimitError?: boolean; isRetryableError?: boolean; isTimeoutError?: boolean } {
+  const err = new Error(response.error) as Error & { status?: number; isRateLimitError?: boolean; isRetryableError?: boolean; isTimeoutError?: boolean };
+
+  if (response.errorType) {
+    const status = ERROR_TYPE_TO_STATUS[response.errorType];
+    err.status = status;
+
+    if (response.errorType === 'rate_limit') {
+      err.isRateLimitError = true;
+      err.isRetryableError = true;
+    } else if (response.errorType === 'server') {
+      err.isRetryableError = true;
+    } else if (response.errorType === 'timeout') {
+      err.isTimeoutError = true;
+      err.isRetryableError = true;
+    }
+  }
+
+  return err;
+}

package/src/sandbox/provider.ts

@@ -0,0 +1,53 @@
+import type { LanguageModel } from 'ai';
+import type { ProviderDescriptor, ProviderStatus } from '@capekai/types';
+import type {
+  ConnectableProvider,
+  ModelFactoryOptions,
+  ModelFactoryResult,
+  TokenResponse,
+} from '../providers/types';
+import { SandboxLanguageModel } from './model';
+
+export class SandboxProvider implements ConnectableProvider {
+  readonly descriptor: ProviderDescriptor = {
+    id: 'sandbox',
+    displayName: 'Sandbox (Interactive Mock)',
+    description: 'Interactive mock provider for sandbox testing',
+    authType: 'none',
+    connectable: false,
+  };
+
+  getStatus(): ProviderStatus {
+    return {
+      provider: this.descriptor.id,
+      connected: true,
+      displayName: this.descriptor.displayName,
+      description: this.descriptor.description,
+      authType: this.descriptor.authType,
+      connectable: this.descriptor.connectable,
+    };
+  }
+
+  async connect() {
+    return {};
+  }
+
+  async onTokensReceived(_tokens: TokenResponse): Promise<void> {
+    // Sandbox provider doesn't use OAuth
+  }
+
+  async disconnect(): Promise<void> {
+  }
+
+  async createModel(options: ModelFactoryOptions): Promise<ModelFactoryResult> {
+    return {
+      model: new SandboxLanguageModel({
+        sessionId: options.sessionId ?? 'default',
+        modelId: options.modelId,
+        providerId: options.providerId,
+      }) as unknown as LanguageModel,
+      useProviderInstructions: false,
+      omitMaxOutputTokens: true,
+    };
+  }
+}

package/src/sandbox/types.ts

@@ -0,0 +1,110 @@
+export interface SandboxCallMessage {
+  role: string;
+  content: unknown;
+}
+
+export interface SandboxToolDefinition {
+  name: string;
+  description: string;
+  inputSchema: unknown;
+}
+
+export interface LlmCallContext {
+  callId: string;
+  sessionId: string;
+  depth: number;
+  mode: 'stream' | 'generate';
+  messages: SandboxCallMessage[];
+  systemPrompt?: string;
+  tools: SandboxToolDefinition[];
+  modelId: string;
+  providerId: string;
+  timestamp: number;
+  parentCallId?: string;
+}
+
+export interface TextResponse {
+  type: 'text';
+  content: string;
+}
+
+export interface ToolCallResponse {
+  type: 'tool-call';
+  toolName: string;
+  args: Record<string, unknown>;
+  toolCallId?: string;
+}
+
+export interface MultiToolCallResponse {
+  type: 'multi-tool-call';
+  calls: Array<{
+    toolName: string;
+    args: Record<string, unknown>;
+    toolCallId?: string;
+  }>;
+}
+
+export interface ErrorResponse {
+  type: 'error';
+  error: string;
+  errorType?: 'rate_limit' | 'server' | 'timeout' | 'auth' | 'invalid_request';
+}
+
+export interface ReasoningResponse {
+  type: 'reasoning';
+  reasoning: string;
+  text: string;
+}
+
+export type SandboxResponse =
+  | TextResponse
+  | ToolCallResponse
+  | MultiToolCallResponse
+  | ErrorResponse
+  | ReasoningResponse;
+
+export interface AutoResponderRule {
+  match: {
+    mode?: 'stream' | 'generate';
+    depth?: number | number[];
+    sessionId?: string | string[];
+    hasToolResults?: boolean;
+  };
+  response: SandboxResponse;
+  maxUses?: number;
+  label?: string;
+}
+
+export interface SandboxHistoryEntry {
+  callId: string;
+  context: LlmCallContext;
+  response: SandboxResponse | null;
+  respondedAt: number | null;
+  completedAt: number | null;
+}
+
+export interface SandboxCallWaitingEvent {
+  type: 'sandbox.call_waiting';
+  context: LlmCallContext;
+}
+
+export interface SandboxRespondMessage {
+  type: 'sandbox.respond';
+  callId: string;
+  response: SandboxResponse;
+}
+
+export interface SandboxCallCompletedEvent {
+  type: 'sandbox.call_completed';
+  callId: string;
+}
+
+export interface SandboxHistoryEvent {
+  type: 'sandbox.history';
+  entries: SandboxHistoryEntry[];
+}
+
+export type SandboxControlEvent =
+  | SandboxCallWaitingEvent
+  | SandboxCallCompletedEvent
+  | SandboxHistoryEvent;

package/src/scheduler/host.ts

@@ -0,0 +1,22 @@
+import type { CreateScheduledJobInput, ScheduledJob, UpdateScheduledJobInput } from '@capekai/types';
+
+export interface SchedulerHost {
+  create(workspaceId: string, input: CreateScheduledJobInput): ScheduledJob;
+  get(id: string): ScheduledJob | null;
+  list(workspaceId: string): ScheduledJob[];
+  update(id: string, updates: UpdateScheduledJobInput): ScheduledJob | null;
+  delete(id: string): boolean;
+  trigger(job: ScheduledJob): void;
+}
+
+const defaultHost: SchedulerHost = {
+  create() { throw new Error('Scheduler host is not configured'); },
+  get: () => null,
+  list: () => [],
+  update: () => null,
+  delete: () => false,
+  trigger: () => {},
+};
+let host = defaultHost;
+export function configureSchedulerHost(value?: SchedulerHost): void { host = value ?? defaultHost; }
+export function getSchedulerHost(): SchedulerHost { return host; }

package/src/scheduler/scheduler-tool.ts

@@ -0,0 +1,172 @@
+import type { PermissionAsk } from '@capekai/tool'
+import type { PermissionRiskLevel } from '@capekai/tool'
+import type { ScheduleConfig, ScheduleKind, ScheduledJob, UpdateScheduledJobInput } from '@capekai/types';
+import { getSchedulerHost, type SchedulerHost } from './host';
+
+export const schedulerToolDefinition = {
+  name: 'scheduler',
+  description: `Manage scheduled tasks for the current workspace. Create recurring or one-shot automated tasks that run as agent sessions on a schedule. Each run creates a new session (or reuses one) with the given prompt.
+
+Actions:
+- "create": Create a new scheduled job. Requires name, prompt, and schedule.
+- "list": List all scheduled jobs in the workspace.
+- "update": Update an existing job by ID. All fields optional except jobId.
+- "pause": Pause a job (stops scheduling, keeps the job).
+- "resume": Resume a paused job.
+- "trigger": Run a job immediately (does not affect the schedule).
+- "remove": Permanently delete a job.
+
+Schedule types (convert the user's natural language to these):
+- { type: "once", runAt: "2025-01-15T14:30:00.000Z" } — one-shot at an ISO timestamp
+- { type: "interval", intervalMinutes: 120 } — recurring every N minutes
+- { type: "daily", time: "09:00" } — daily at a specific time (HH:mm, server timezone)
+- { type: "weekly", days: [1,2,3,4,5], time: "17:00" } — on specific weekdays (0=Sun, 1=Mon, ..., 6=Sat) at a time
+
+Examples:
+- "every 2 hours" → { type: "interval", intervalMinutes: 120 }
+- "daily at 9am" → { type: "daily", time: "09:00" }
+- "every weekday at 5pm" → { type: "weekly", days: [1,2,3,4,5], time: "17:00" }
+- "in 30 minutes" → { type: "once", runAt: "<ISO timestamp 30 min from now>" }
+
+The prompt should be self-contained — it is the full instruction given to the agent for each run.`,
+  inputSchema: {
+    type: 'object' as const,
+    properties: {
+      action: { type: 'string' as const, enum: ['create', 'list', 'update', 'pause', 'resume', 'trigger', 'remove'], description: 'The action to perform.' },
+      jobId: { type: 'string' as const, description: 'Job ID (for update/pause/resume/trigger/remove actions). Use "list" to find job IDs.' },
+      name: { type: 'string' as const, description: 'Friendly name for the job (create/update).' },
+      prompt: { type: 'string' as const, description: 'The task instruction to run on each execution (create/update). Must be self-contained.' },
+      schedule: { type: 'object' as const, description: 'Schedule configuration (create/update). See tool description for format.', properties: { type: { type: 'string' as const, enum: ['once', 'interval', 'daily', 'weekly'] }, runAt: { type: 'string' as const, description: 'ISO timestamp (for type: "once")' }, intervalMinutes: { type: 'number' as const, description: 'Minutes between runs (for type: "interval")' }, time: { type: 'string' as const, description: 'HH:mm time (for type: "daily" or "weekly")' }, days: { type: 'array' as const, items: { type: 'number' as const }, description: 'Weekdays 0-6 (0=Sun) for type: "weekly"' } } },
+      repeatLimit: { type: 'number' as const, description: 'Maximum number of runs. Omit for infinite. (create/update)' },
+      reuseSession: { type: 'boolean' as const, description: 'If true, all runs accumulate in the same session. If false (default), each run creates a new session.' },
+      includeHistory: { type: 'boolean' as const, description: 'When reuseSession is true, whether the agent sees previous run history. Default false.' },
+      autoApproveSeverity: { type: 'string' as const, enum: ['off', 'none', 'low', 'medium', 'high'], description: 'Auto-approve severity for sessions created by this job. Omit or null to use workspace default.' },
+      notificationsEnabled: { type: 'boolean' as const, description: 'When true, scheduled runs may send completion, failure, and permission push notifications (subject to each browser subscription\'s existing preferences). Defaults to false (no notifications). (create/update)' },
+    }, required: ['action'],
+  }, timeout: 10000,
+};
+export interface SchedulerToolResult { success: boolean; action: string; title: string; job?: ScheduledJob; jobs?: ScheduledJob[]; jobId?: string; error?: string }
+
+function parseSchedule(raw: Record<string, unknown>): { kind: ScheduleKind; config: ScheduleConfig } | { error: string } {
+  const type = raw.type as string;
+  if (!type) return { error: 'Schedule type is required' };
+  if (type === 'once') {
+    const runAt = raw.runAt as string;
+    if (!runAt) return { error: 'runAt (ISO timestamp) is required for type "once"' };
+    const timestamp = new Date(runAt).getTime();
+    return Number.isFinite(timestamp) ? { kind: 'once', config: { type: 'once', runAt: new Date(timestamp).toISOString() } } : { error: `Invalid runAt timestamp: ${runAt}` };
+  }
+  if (type === 'interval') {
+    const minutes = raw.intervalMinutes as number;
+    return minutes && minutes >= 1 ? { kind: 'interval', config: { type: 'interval', intervalMinutes: minutes } } : { error: 'intervalMinutes must be a positive number' };
+  }
+  if (type === 'daily') {
+    const time = raw.time as string;
+    return time && /^\d{2}:\d{2}$/.test(time) ? { kind: 'daily', config: { type: 'daily', time } } : { error: 'time must be in HH:mm format for type "daily"' };
+  }
+  if (type === 'weekly') {
+    const time = raw.time as string;
+    const days = raw.days as number[];
+    if (!time || !/^\d{2}:\d{2}$/.test(time)) return { error: 'time must be in HH:mm format for type "weekly"' };
+    if (!Array.isArray(days) || days.length === 0) return { error: 'days array is required for type "weekly"' };
+    const valid = days.filter((day) => typeof day === 'number' && day >= 0 && day <= 6);
+    return valid.length > 0 ? { kind: 'weekly', config: { type: 'weekly', days: valid, time } } : { error: 'days must contain valid weekday numbers (0-6)' };
+  }
+  return { error: `Unknown schedule type: ${type}` };
+}
+
+/** Unscoped execution path: reads the configured module-level host, exactly
+ * like the pre-C5 tool. */
+export async function executeSchedulerTool(input: Record<string, unknown>, workspaceId: string, currentSessionId: string, risk: PermissionRiskLevel, askFn?: (ask: PermissionAsk) => Promise<unknown>): Promise<SchedulerToolResult> {
+  return runScheduler(getSchedulerHost(), input, workspaceId, currentSessionId, risk, askFn);
+}
+
+/** Composed execution path: the domain plugin captures the process-scoped
+ * host service at setup and passes it here, so composed execution never
+ * reads the mutable module-global host accessor. */
+export async function executeSchedulerToolWithHost(host: SchedulerHost, input: Record<string, unknown>, workspaceId: string, currentSessionId: string, risk: PermissionRiskLevel, askFn?: (ask: PermissionAsk) => Promise<unknown>): Promise<SchedulerToolResult> {
+  return runScheduler(host, input, workspaceId, currentSessionId, risk, askFn);
+}
+
+async function runScheduler(host: SchedulerHost, input: Record<string, unknown>, workspaceId: string, currentSessionId: string, risk: PermissionRiskLevel, askFn?: (ask: PermissionAsk) => Promise<unknown>): Promise<SchedulerToolResult> {
+  const action = input.action as string;
+  if (action !== 'list' && risk !== 'none' && askFn) {
+    const verb = ({ create: 'create', update: 'update', pause: 'pause', resume: 'resume', trigger: 'trigger', remove: 'delete' } as Record<string, string>)[action] || action;
+    const name = (input.name as string) || (input.jobId as string) || '';
+    console.log(`[scheduler-tool] Requesting permission for "${verb}"...`);
+    const approved = await askFn({ type: 'permission', question: name ? `Allow scheduler to ${verb} scheduled job "${name.slice(0, 80)}"?` : `Allow scheduler to ${verb} a scheduled job?`, description: `Tool: scheduler\nAction: ${verb}${name ? `\nJob: ${name.slice(0, 200)}` : ''}`, risk, resource: 'scheduler', action: verb });
+    if (!approved) return { success: false, action, title: 'Permission denied', error: 'USER_REJECTION' };
+  }
+  try {
+    switch (action) {
+      case 'create': return create(input, workspaceId, currentSessionId, host);
+      case 'list': { const jobs = host.list(workspaceId); return { success: true, action, title: `${jobs.length} scheduled job${jobs.length === 1 ? '' : 's'}`, jobs }; }
+      case 'update': return update(input, workspaceId, host);
+      case 'pause': return stateChange(input, workspaceId, 'paused', host);
+      case 'resume': return stateChange(input, workspaceId, 'active', host);
+      case 'trigger': return trigger(input, workspaceId, host);
+      case 'remove': return remove(input, workspaceId, host);
+      default: return { success: false, action, title: 'Invalid action', error: `Unknown action: ${action}` };
+    }
+  } catch (error: unknown) {
+    console.error(`[scheduler-tool] Action "${action}" failed:`, error);
+    return { success: false, action, title: 'Internal error', error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+function create(input: Record<string, unknown>, workspaceId: string, sessionId: string, host: SchedulerHost): SchedulerToolResult {
+  const name = input.name as string;
+  const prompt = input.prompt as string;
+  const schedule = input.schedule as Record<string, unknown>;
+  if (!name || typeof name !== 'string' || name.trim() === '') return { success: false, action: 'create', title: 'Validation error', error: 'name is required' };
+  if (!prompt || typeof prompt !== 'string' || prompt.trim() === '') return { success: false, action: 'create', title: 'Validation error', error: 'prompt is required' };
+  if (!schedule || typeof schedule !== 'object') return { success: false, action: 'create', title: 'Validation error', error: 'schedule is required' };
+  const parsed = parseSchedule(schedule);
+  if ('error' in parsed) return { success: false, action: 'create', title: 'Validation error', error: parsed.error };
+  const job = host.create(workspaceId, { name: name.trim(), prompt: prompt.trim(), scheduleKind: parsed.kind, scheduleConfig: parsed.config, repeatLimit: input.repeatLimit as number | null | undefined, reuseSession: input.reuseSession as boolean | undefined, includeHistory: input.includeHistory as boolean | undefined, originSessionId: sessionId, autoApproveSeverity: input.autoApproveSeverity as ScheduledJob['autoApproveSeverity'], notificationsEnabled: input.notificationsEnabled as boolean | undefined });
+  return { success: true, action: 'create', title: `Scheduled job "${job.name}" created`, job };
+}
+function wrongWorkspace(job: ScheduledJob, workspaceId: string, action: string): SchedulerToolResult | null {
+  return job.workspaceId === workspaceId
+    ? null
+    : { success: false, action, title: 'Access denied', error: 'Job does not belong to this workspace' };
+}
+
+function update(input: Record<string, unknown>, workspaceId: string, host: SchedulerHost): SchedulerToolResult {
+  const id = input.jobId as string;
+  if (!id) return { success: false, action: 'update', title: 'Validation error', error: 'jobId is required' };
+  const existing = host.get(id);
+  if (!existing) return { success: false, action: 'update', title: 'Not found', error: `Job ${id} not found` };
+  const denied = wrongWorkspace(existing, workspaceId, 'update');
+  if (denied) return denied;
+  const updates: UpdateScheduledJobInput = {};
+  for (const key of ['name', 'prompt', 'repeatLimit', 'reuseSession', 'includeHistory', 'autoApproveSeverity', 'notificationsEnabled'] as const) if (input[key] !== undefined) Object.assign(updates, { [key]: input[key] });
+  if (input.schedule) {
+    const parsed = parseSchedule(input.schedule as Record<string, unknown>);
+    if ('error' in parsed) return { success: false, action: 'update', title: 'Validation error', error: parsed.error };
+    updates.scheduleKind = parsed.kind; updates.scheduleConfig = parsed.config;
+  }
+  const job = host.update(id, updates);
+  return job ? { success: true, action: 'update', title: `Scheduled job "${job.name}" updated`, job } : { success: false, action: 'update', title: 'Update failed', error: 'Failed to update job' };
+}
+function stateChange(input: Record<string, unknown>, workspaceId: string, state: 'active' | 'paused', host: SchedulerHost): SchedulerToolResult {
+  const id = input.jobId as string; const action = input.action as string;
+  if (!id) return { success: false, action, title: 'Validation error', error: 'jobId is required' };
+  const existing = host.get(id); if (!existing) return { success: false, action, title: 'Not found', error: `Job ${id} not found` };
+  const denied = wrongWorkspace(existing, workspaceId, action); if (denied) return denied;
+  return { success: true, action, title: `Job "${existing.name}" ${state === 'paused' ? 'paused' : 'resumed'}`, job: host.update(id, { state }) ?? undefined };
+}
+function trigger(input: Record<string, unknown>, workspaceId: string, host: SchedulerHost): SchedulerToolResult {
+  const id = input.jobId as string;
+  if (!id) return { success: false, action: 'trigger', title: 'Validation error', error: 'jobId is required' };
+  const job = host.get(id); if (!job) return { success: false, action: 'trigger', title: 'Not found', error: `Job ${id} not found` };
+  const denied = wrongWorkspace(job, workspaceId, 'trigger'); if (denied) return denied;
+  host.trigger(job); return { success: true, action: 'trigger', title: `Job "${job.name}" triggered`, jobId: id };
+}
+function remove(input: Record<string, unknown>, workspaceId: string, host: SchedulerHost): SchedulerToolResult {
+  const id = input.jobId as string;
+  if (!id) return { success: false, action: 'remove', title: 'Validation error', error: 'jobId is required' };
+  const job = host.get(id); if (!job) return { success: false, action: 'remove', title: 'Not found', error: `Job ${id} not found` };
+  const denied = wrongWorkspace(job, workspaceId, 'remove'); if (denied) return denied;
+  host.delete(id); return { success: true, action: 'remove', title: `Job "${job.name}" deleted`, jobId: id };
+}