@aion0/forge 0.9.1 → 0.9.3

package/lib/schedules/action-runner.ts

@@ -0,0 +1,257 @@
+/**
+ * Schedules action runner — fires the schedule's action against the
+ * body_output once the body settles.
+ *
+ * Phase 4 ships action.kind='chat' only. email + telegram land in
+ * phases 5-6. action_kind='none' is the default no-op.
+ *
+ * Wired into every body-completion site:
+ *   - pipeline-scheduler.syncRunStatus (pipeline body done)
+ *   - scheduler.settleSkillRunIfMatch  (skill body done)
+ *   - scheduler.invokeConnectorTool    (connector_tool done)
+ *   - store.reconcileStaleScheduleRuns (forge-restart catch-up)
+ *
+ * Action runs at-most-once per run (we look at action_status='pending'/
+ * null and set to 'done'/'failed'/'skipped' atomically).
+ */
+
+import { getDb } from '@/src/core/db/database';
+import { getDbPath } from '@/src/config';
+import { getScheduleRun, getSchedule, setScheduleRunAction } from './store';
+import { appendMessage, getSession } from '@/lib/chat/session-store';
+import { loadSettings } from '@/lib/settings';
+import type { Schedule, ScheduleRun, ScheduleActionStatus } from './types';
+
+function db() { return getDb(getDbPath()); }
+
+/**
+ * Run the action for a settled schedule_run by target_id (the most
+ * common entry point — callers know target_id, not run_id). Looks up
+ * the latest non-pending row for that target. Safe to call multiple
+ * times; idempotent against `action_status`.
+ */
+export async function runActionForTarget(targetId: string): Promise<void> {
+  const row = db().prepare(
+    `SELECT id FROM schedule_runs WHERE target_id = ?
+       ORDER BY started_at DESC LIMIT 1`,
+  ).get(targetId) as { id: string } | undefined;
+  if (!row) return;
+  await runAction(row.id);
+}
+
+/** Run the action against a specific schedule_run. */
+export async function runAction(runId: string): Promise<void> {
+  const run = getScheduleRun(runId);
+  if (!run) return;
+  if (run.action_status !== null) return; // already settled
+
+  const schedule = getSchedule(run.schedule_id);
+  if (!schedule) {
+    markAction(runId, 'failed', 'schedule gone');
+    return;
+  }
+
+  if (schedule.action_kind === 'none') {
+    markAction(runId, 'done', null);
+    return;
+  }
+
+  // Body must have completed successfully for action to fire.
+  // 'failed' / 'cancelled' body: skip action (downstream chat/email
+  // shouldn't get a half-baked output).
+  if (run.status !== 'done') {
+    markAction(runId, 'skipped', `body status was ${run.status}`);
+    return;
+  }
+
+  const output = (run.body_output || '').trim();
+  if (!output && schedule.action_skip_on_empty) {
+    markAction(runId, 'skipped', 'body produced no output and action_skip_on_empty=true');
+    return;
+  }
+
+  try {
+    if (schedule.action_kind === 'chat') {
+      await runChatAction(schedule, run, output);
+      markAction(runId, 'done', null);
+    } else if (schedule.action_kind === 'email') {
+      await runEmailAction(schedule, run, output);
+      markAction(runId, 'done', null);
+    } else if (schedule.action_kind === 'telegram') {
+      await runTelegramAction(schedule, run, output);
+      markAction(runId, 'done', null);
+    } else {
+      markAction(runId, 'failed', `unknown action_kind '${schedule.action_kind}'`);
+    }
+  } catch (e) {
+    const err = e as Error;
+    console.error(`[schedules:action] run ${runId} ${schedule.action_kind} failed:`, err);
+    markAction(runId, 'failed', err.message || String(e));
+  }
+}
+
+function markAction(runId: string, status: ScheduleActionStatus, error: string | null): void {
+  setScheduleRunAction({ run_id: runId, status, error });
+}
+
+// ─── chat action ──────────────────────────────────────────
+
+async function runChatAction(schedule: Schedule, run: ScheduleRun, output: string): Promise<void> {
+  const cfg = schedule.action_config || {};
+  const sessionId = typeof cfg.session_id === 'string' ? cfg.session_id.trim() : '';
+  if (!sessionId) {
+    throw new Error('chat action requires action_config.session_id');
+  }
+  const session = getSession(sessionId);
+  if (!session) {
+    throw new Error(`chat session "${sessionId}" not found`);
+  }
+  const prefix = typeof cfg.prefix === 'string' ? cfg.prefix : '';
+  const header = `📋 Schedule "${schedule.name}" — ${new Date(run.started_at).toLocaleString()}`;
+  const text = prefix
+    ? `${header}\n\n${prefix}${output}`
+    : `${header}\n\n${output}`;
+
+  // Route through chat-standalone so an open chat tab gets the SSE
+   // `message_saved` push. Writing the row directly via appendMessage
+   // works for persistence but the tab only sees the message after a
+   // reload. Fall back to direct write if the standalone is down.
+  const chatPort = Number(process.env.CHAT_PORT) || 8408;
+  const payload = JSON.stringify({ role: 'assistant', blocks: [{ type: 'text', text }] });
+  try {
+    const r = await fetch(`http://127.0.0.1:${chatPort}/api/sessions/${encodeURIComponent(sessionId)}/inject`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: payload,
+    });
+    if (!r.ok) throw new Error(`inject HTTP ${r.status}`);
+  } catch (e) {
+    console.warn(`[schedules:chat] inject via standalone failed (${(e as Error).message}); falling back to direct DB write`);
+    appendMessage({
+      session_id: sessionId,
+      role: 'assistant',
+      blocks: [{ type: 'text', text }],
+    });
+  }
+}
+
+// ─── email action ─────────────────────────────────────────
+
+/**
+ * Email action via nodemailer. SMTP transport is configured globally
+ * in settings.smtp* (host/port/secure/user/password/from). Each
+ * schedule supplies the recipient + templates in action_config:
+ *
+ *   {
+ *     "to":               "alice@example.com" | ["a@..", "b@.."],
+ *     "subject_template": "Daily bug list — {date}",
+ *     "body_template":    "{body_output}",
+ *     "html":             false   // (optional) treat body as HTML
+ *   }
+ *
+ * Templates support two placeholders for now:
+ *   {date}        — current date (YYYY-MM-DD)
+ *   {body_output} — captured body output
+ */
+async function runEmailAction(schedule: Schedule, _run: ScheduleRun, output: string): Promise<void> {
+  const settings = loadSettings();
+  if (!settings.smtpHost) {
+    throw new Error('SMTP not configured (Settings → SMTP)');
+  }
+  const cfg = schedule.action_config || {};
+  const toRaw = cfg.to;
+  const to = Array.isArray(toRaw)
+    ? (toRaw as unknown[]).filter((x) => typeof x === 'string' && x.trim()).map((x) => String(x).trim())
+    : (typeof toRaw === 'string' && toRaw.trim() ? [toRaw.trim()] : []);
+  if (to.length === 0) {
+    throw new Error('email action requires action_config.to (string or string[])');
+  }
+
+  const today = new Date().toISOString().slice(0, 10);
+  const subjectTpl = typeof cfg.subject_template === 'string' && cfg.subject_template
+    ? cfg.subject_template
+    : `Forge schedule: ${schedule.name}`;
+  const bodyTpl = typeof cfg.body_template === 'string' && cfg.body_template
+    ? cfg.body_template
+    : '{body_output}';
+  const subject = subjectTpl.replace('{date}', today).replace('{body_output}', output);
+  const bodyText = bodyTpl.replace('{date}', today).replace('{body_output}', output);
+  const asHtml = !!cfg.html;
+
+  // Lazy import keeps the SMTP client out of the main bundle until the
+  // first email action actually fires.
+  const nodemailer = (await import('nodemailer')).default;
+  const transport = nodemailer.createTransport({
+    host: settings.smtpHost,
+    port: settings.smtpPort,
+    secure: !!settings.smtpSecure,
+    auth: settings.smtpUser
+      ? { user: settings.smtpUser, pass: settings.smtpPassword }
+      : undefined,
+  } as any);
+  const from = settings.smtpFrom || (settings.smtpUser ? settings.smtpUser : '');
+  if (!from) throw new Error('SMTP from address required (Settings → SMTP → from or user)');
+  await transport.sendMail({
+    from,
+    to,
+    subject,
+    [asHtml ? 'html' : 'text']: bodyText,
+  });
+}
+
+// ─── telegram action ──────────────────────────────────────
+
+/**
+ * Telegram action — posts body_output via the same bot Forge already
+ * uses for task notifications. Reuses settings.telegramBotToken; chat
+ * id falls back to settings.telegramChatId so a user can just toggle
+ * the radio without per-schedule config.
+ *
+ * action_config:
+ *   chat_id      string (optional, overrides settings.telegramChatId)
+ *   prefix       string (optional, prepended to body_output)
+ *   parse_mode   "Markdown" | "MarkdownV2" | "HTML" | "" (default Markdown)
+ */
+async function runTelegramAction(schedule: Schedule, run: ScheduleRun, output: string): Promise<void> {
+  const settings = loadSettings();
+  if (!settings.telegramBotToken) {
+    throw new Error('telegramBotToken not configured (Settings → Telegram)');
+  }
+  const cfg = schedule.action_config || {};
+  const chatId = typeof cfg.chat_id === 'string' && cfg.chat_id.trim()
+    ? cfg.chat_id.trim()
+    : settings.telegramChatId;
+  if (!chatId) {
+    throw new Error('telegram action requires action_config.chat_id (or settings.telegramChatId)');
+  }
+  const prefix = typeof cfg.prefix === 'string' ? cfg.prefix : '';
+  const parseMode = typeof cfg.parse_mode === 'string' ? cfg.parse_mode : 'Markdown';
+  const header = `📋 *${escapeTelegram(schedule.name)}* — ${new Date(run.started_at).toLocaleString()}`;
+  const text = prefix
+    ? `${header}\n\n${prefix}${output}`
+    : `${header}\n\n${output}`;
+
+  const url = `https://api.telegram.org/bot${settings.telegramBotToken}/sendMessage`;
+  const body: Record<string, unknown> = {
+    chat_id: chatId,
+    text,
+    disable_web_page_preview: true,
+  };
+  if (parseMode) body.parse_mode = parseMode;
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+  if (!res.ok) {
+    const errText = await res.text().catch(() => '');
+    throw new Error(`telegram sendMessage failed: ${res.status} ${errText.slice(0, 200)}`);
+  }
+}
+
+/** Escape underscores / asterisks in the schedule name so Markdown
+ *  doesn't try to render them. parse_mode='Markdown' is lenient but
+ *  unbalanced `_` causes a 400 from the API. */
+function escapeTelegram(s: string): string {
+  return s.replace(/([_*`\[])/g, '\\$1');
+}

package/lib/schedules/scheduler.ts

@@ -0,0 +1,422 @@
+/**
+ * Schedules scheduler — 60s tick loop parallel to the Job scheduler.
+ *
+ * Each tick:
+ *   1. reconcile stale schedule_runs (zombie cleanup)
+ *   2. for each due, non-manual schedule:
+ *      - advance next_run_at (period / once / cron)
+ *      - skip if it already has inflight body
+ *      - dispatch body (pipeline / skill / connector_tool — phase-gated)
+ *      - insert schedule_run row
+ *
+ * No sequential / on_failure / dedup / retry knobs. All body-internal.
+ */
+
+import { randomUUID } from 'node:crypto';
+import { CronExpressionParser } from 'cron-parser';
+import { startPipeline, getWorkflow } from '@/lib/pipeline';
+import {
+  createTask,
+  getTask,
+  onTaskEvent,
+  taskAppendSystemPromptOverrides,
+} from '@/lib/task-manager';
+import { getProjectInfo } from '@/lib/projects';
+import { dispatchTool } from '@/lib/chat/tool-dispatcher';
+import { ensureInstalledInProject } from '@/lib/skills';
+import { getDb } from '@/src/core/db/database';
+import { getDbPath } from '@/src/config';
+import {
+  ensureSchema,
+  listDueSchedules,
+  countInflightForSchedule,
+  setNextRunAt,
+  setLastRunAt,
+  insertScheduleRun,
+  reconcileStaleScheduleRuns,
+  updateSchedule,
+  updateScheduleRunStatus,
+  setScheduleRunBodyOutputByTarget,
+  getSchedule,
+} from './store';
+import { runActionForTarget } from './action-runner';
+import type { Schedule, ScheduleRunTrigger, ScheduleRunStatus } from './types';
+
+const TICK_INTERVAL_MS = 60_000;
+const schedulerKey = Symbol.for('forge-schedules-scheduler');
+
+export function startSchedulesScheduler(): void {
+  const g = globalThis as any;
+  if (g[schedulerKey]) return;
+  g[schedulerKey] = true;
+  ensureSchema();
+  installSkillTaskListener();
+  console.log('[schedules-scheduler] started');
+  void tick();
+  setInterval(() => { void tick(); }, TICK_INTERVAL_MS).unref?.();
+}
+
+async function tick(): Promise<void> {
+  try {
+    reconcileStaleScheduleRuns();
+  } catch (e) {
+    console.warn(`[schedules-scheduler] reconcile failed: ${(e as Error).message}`);
+  }
+
+  let due: Schedule[] = [];
+  try { due = listDueSchedules(); }
+  catch (e) {
+    console.error('[schedules-scheduler] listDue failed', e);
+    return;
+  }
+
+  for (const s of due) {
+    try {
+      advanceSchedule(s);
+    } catch (e) {
+      console.warn(`[schedules-scheduler] advanceSchedule ${s.id} failed: ${(e as Error).message}`);
+    }
+    if (countInflightForSchedule(s.id) > 0) {
+      // Prior body still running — skip this tick (will retry next minute).
+      continue;
+    }
+    void executeSchedule(s, 'schedule').catch((err) => {
+      console.error(`[schedules-scheduler] execute ${s.id} crashed`, err);
+    });
+  }
+}
+
+function toSqlIso(d: Date): string {
+  return d.toISOString().replace('T', ' ').slice(0, 19);
+}
+
+/**
+ * Compute the next_run_at after this tick fires. Behaviour mirrors
+ * the Job scheduler's advanceSchedule so users see consistent semantics.
+ */
+export function advanceSchedule(s: Schedule): void {
+  const now = Date.now();
+
+  if (s.schedule_kind === 'manual') {
+    // Should never reach here (listDueSchedules excludes manual), but be safe.
+    setNextRunAt(s.id, null);
+    return;
+  }
+
+  if (s.schedule_kind === 'once') {
+    // One-shot: this tick fires, then auto-disable.
+    setNextRunAt(s.id, null);
+    try { updateSchedule(s.id, { enabled: false }); } catch (e) {
+      console.warn(`[schedules-scheduler] auto-disable once schedule ${s.id} failed:`, e);
+    }
+    return;
+  }
+
+  if (s.schedule_kind === 'cron' && s.schedule_cron) {
+    try {
+      const iter = CronExpressionParser.parse(s.schedule_cron, { currentDate: new Date(now) });
+      const next = iter.next().toDate();
+      setNextRunAt(s.id, toSqlIso(next));
+      return;
+    } catch (e) {
+      console.warn(`[schedules-scheduler] cron parse failed for ${s.id} ("${s.schedule_cron}"):`, (e as Error).message);
+      // Fall through to period default so a broken cron doesn't tight-loop.
+    }
+  }
+
+  // Default / 'period' path.
+  const minutes = Math.max(1, s.schedule_interval_minutes || 30);
+  const next = new Date(now + minutes * 60_000);
+  setNextRunAt(s.id, toSqlIso(next));
+}
+
+/**
+ * Launch one body run for this schedule. Used by the tick loop AND
+ * the manual fire API. Returns the target_id (the dispatched body's id).
+ */
+export async function executeSchedule(s: Schedule, trigger: ScheduleRunTrigger): Promise<string> {
+  if (s.body_kind === 'pipeline')       return executePipelineBody(s, trigger);
+  if (s.body_kind === 'skill')          return executeSkillBody(s, trigger);
+  if (s.body_kind === 'connector_tool') return executeConnectorToolBody(s, trigger);
+  throw new Error(`unknown body_kind: ${s.body_kind}`);
+}
+
+// ─── pipeline body ────────────────────────────────────────
+
+async function executePipelineBody(s: Schedule, trigger: ScheduleRunTrigger): Promise<string> {
+  // Coerce input values to strings for the pipeline orchestrator.
+  // Schedule.input is typed `Record<string, unknown>` because the UI form
+  // can save anything (numbers, booleans, nested), but startPipeline
+  // currently expects `Record<string, string>`. Stringify non-strings.
+  const stringInput: Record<string, string> = {};
+  for (const [k, v] of Object.entries(s.input || {})) {
+    if (v == null) { stringInput[k] = ''; continue; }
+    stringInput[k] = typeof v === 'string' ? v : (typeof v === 'object' ? JSON.stringify(v) : String(v));
+  }
+  // Pre-install skills into every project the workflow's nodes target,
+  // mirroring Job's dispatcher (lib/jobs/scheduler.ts ~563). Without
+  // this Claude's `/skill-name` invocations fail because the skill
+  // SKILL.md isn't on disk under the project's .claude/skills/.
+  await preinstallSkillsForPipeline(s.body_ref, stringInput, s.skills);
+  const pipeline = startPipeline(s.body_ref, stringInput, { skills: s.skills });
+  insertScheduleRun({ schedule_id: s.id, target_id: pipeline.id, trigger });
+  setLastRunAt(s.id, toSqlIso(new Date()));
+  return pipeline.id;
+}
+
+/** For each unique project name referenced by the workflow's nodes,
+ *  resolve it (cheap `{{input.X}}` expansion) and install every skill
+ *  there. Idempotent — `ensureInstalledInProject` no-ops if the skill
+ *  is already at the right version. Errors are warned, not thrown. */
+async function preinstallSkillsForPipeline(
+  workflowName: string,
+  input: Record<string, string>,
+  skills: string[],
+): Promise<void> {
+  if (!skills || skills.length === 0) return;
+  const workflow = getWorkflow(workflowName);
+  if (!workflow) return;
+  const projectNames = new Set<string>();
+  for (const n of Object.values(workflow.nodes)) {
+    if (n.project) projectNames.add(n.project);
+  }
+  const seenPaths = new Set<string>();
+  for (const pName of projectNames) {
+    // Lightweight template expansion — pipeline.ts resolveTemplate is
+    // not exported. Only handles `{{input.X}}` which covers the
+    // common case (`project: "{{input.project}}"`). Literal names
+    // pass through unchanged.
+    const resolved = pName.replace(/\{\{\s*input\.([\w-]+)\s*\}\}/g, (_, k: string) => input[k] ?? '');
+    if (!resolved) continue;
+    const pInfo = getProjectInfo(resolved);
+    if (!pInfo || seenPaths.has(pInfo.path)) continue;
+    seenPaths.add(pInfo.path);
+    for (const skill of skills) {
+      try {
+        const r = await ensureInstalledInProject(skill, pInfo.path);
+        if (!r.installed) console.warn(`[schedules] skill "${skill}" not installable in ${pInfo.path}: ${r.reason}`);
+      } catch (e) {
+        console.warn(`[schedules] skill "${skill}" install failed in ${pInfo.path}: ${(e as Error).message}`);
+      }
+    }
+  }
+}
+
+// ─── skill body ───────────────────────────────────────────
+
+/**
+ * Skill body: create a one-shot Claude task in the configured project
+ * with the skill loaded via --append-system-prompt. We use the task as
+ * the dispatched unit; on completion the task event listener captures
+ * task.resultSummary and settles the schedule_run.
+ *
+ * Required input fields:
+ *   - project      (string, project name from Forge's local projects list)
+ *
+ * Optional input fields:
+ *   - user_prompt  (string, the actual question to ask Claude)
+ *                  defaults to "Run skill /<body_ref>"
+ *   - <any other key/value> — passed in the user message verbatim
+ *     (advanced; phase 2 doesn't do template expansion)
+ */
+async function executeSkillBody(s: Schedule, trigger: ScheduleRunTrigger): Promise<string> {
+  const projectName = strField(s.input.project);
+  if (!projectName) {
+    throw new Error('skill body requires input.project (Forge project name)');
+  }
+  const project = getProjectInfo(projectName);
+  if (!project) {
+    throw new Error(`project not found: "${projectName}"`);
+  }
+
+  // Pre-install body_ref + any extras into the target project. Idempotent;
+  // body_ref was validated as installed at POST time but only on SOME
+  // project (or globally) — make sure it's actually on disk for THIS one.
+  const skillsToInstall = [s.body_ref, ...(s.skills || [])].filter((v, i, arr) => v && arr.indexOf(v) === i);
+  for (const skill of skillsToInstall) {
+    try {
+      const r = await ensureInstalledInProject(skill, project.path);
+      if (!r.installed) console.warn(`[schedules] skill "${skill}" not installable in ${project.path}: ${r.reason}`);
+    } catch (e) {
+      console.warn(`[schedules] skill "${skill}" install failed in ${project.path}: ${(e as Error).message}`);
+    }
+  }
+
+  const userPrompt = strField(s.input.user_prompt) || `Run skill /${s.body_ref}`;
+  // Pass other input keys as a JSON block appended after user_prompt
+  // so the skill can extract them.
+  const extras: Record<string, string> = {};
+  for (const [k, v] of Object.entries(s.input || {})) {
+    if (k === 'project' || k === 'user_prompt') continue;
+    extras[k] = strField(v);
+  }
+  const extrasBlock = Object.keys(extras).length
+    ? `\n\n--- Schedule input ---\n${JSON.stringify(extras, null, 2)}\n`
+    : '';
+
+  const task = createTask({
+    projectName: project.name,
+    projectPath: project.path,
+    prompt: userPrompt + extrasBlock,
+    conversationId: '',
+  });
+
+  // Skill is hooked via --append-system-prompt before the runner picks
+  // the task up. Same mechanism Pipelines use (lib/pipeline.ts:1448+).
+  // body_ref is the primary skill; extra s.skills are merged for tasks
+  // that need additional skills alongside (e.g. /forge-mr-triage + /git-helpers).
+  const skillSet = [s.body_ref, ...(s.skills || [])].filter((v, i, arr) => v && arr.indexOf(v) === i);
+  const append = renderSkillsAppendPrompt(skillSet);
+  if (append) taskAppendSystemPromptOverrides.set(task.id, append);
+
+  insertScheduleRun({ schedule_id: s.id, target_id: task.id, trigger });
+  setLastRunAt(s.id, toSqlIso(new Date()));
+  return task.id;
+}
+
+// ─── connector_tool body ──────────────────────────────────
+
+/**
+ * Connector tool body: a single synchronous HTTP-style invocation
+ * (run through tool-dispatcher; no Claude, no pipeline). body_ref is
+ * "<plugin>.<tool>" (e.g. "mantis.search_bugs"). input is passed
+ * verbatim as tool input.
+ *
+ * Synthetic target_id (uuid prefix "ct_") since there's no backing
+ * task/pipeline row. The schedule_run carries the full lifecycle.
+ *
+ * Dispatch is fire-and-forget — we return the target_id immediately
+ * so the caller (tick loop / manual fire API) doesn't block on slow
+ * connector tools. The async helper settles body_output + status
+ * when the call resolves.
+ */
+function executeConnectorToolBody(s: Schedule, trigger: ScheduleRunTrigger): string {
+  const targetId = `ct_${randomUUID().slice(0, 12).replace(/-/g, '')}`;
+  insertScheduleRun({ schedule_id: s.id, target_id: targetId, trigger });
+  setLastRunAt(s.id, toSqlIso(new Date()));
+  void invokeConnectorTool(s, targetId).catch((err) => {
+    console.error(`[schedules] connector_tool body for ${s.id} crashed`, err);
+    updateScheduleRunStatus({
+      target_id: targetId,
+      status: 'failed',
+      error: (err as Error)?.message || String(err),
+    });
+  });
+  return targetId;
+}
+
+async function invokeConnectorTool(s: Schedule, targetId: string): Promise<void> {
+  // body_ref is "<plugin_id>.<tool_name>". Some tools could contain
+  // dots, but our internal naming is always plugin.tool and the
+  // dispatcher splits on the FIRST dot.
+  const dot = s.body_ref.indexOf('.');
+  if (dot <= 0 || dot === s.body_ref.length - 1) {
+    updateScheduleRunStatus({
+      target_id: targetId,
+      status: 'failed',
+      error: `invalid body_ref: expected "<plugin>.<tool>", got "${s.body_ref}"`,
+    });
+    return;
+  }
+  const fullName = s.body_ref;
+
+  try {
+    const result = await dispatchTool({
+      id: `schedule-${targetId}`,
+      name: fullName,
+      input: s.input || {},
+    });
+    const output = typeof result.content === 'string' ? result.content : JSON.stringify(result.content ?? '');
+    setScheduleRunBodyOutputByTarget(targetId, output);
+    if (result.is_error) {
+      updateScheduleRunStatus({
+        target_id: targetId,
+        status: 'failed',
+        error: output.slice(0, 500) || 'connector tool returned is_error',
+      });
+    } else {
+      updateScheduleRunStatus({ target_id: targetId, status: 'done' });
+    }
+  } catch (err) {
+    updateScheduleRunStatus({
+      target_id: targetId,
+      status: 'failed',
+      error: (err as Error)?.message || String(err),
+    });
+  } finally {
+    void runActionForTarget(targetId).catch((e) => {
+      console.error(`[schedules-scheduler] action for connector_tool target ${targetId} crashed`, e);
+    });
+  }
+}
+
+function strField(v: unknown): string {
+  if (v == null) return '';
+  return typeof v === 'string' ? v : (typeof v === 'object' ? JSON.stringify(v) : String(v));
+}
+
+/** Duplicated from lib/pipeline.ts:renderSkillsAppendPrompt — small enough
+ *  to inline rather than create an import edge. */
+function renderSkillsAppendPrompt(skills: string[] | undefined): string {
+  if (!skills || skills.length === 0) return '';
+  const lines = skills.map((s) => `  /${s}`).join('\n');
+  return [
+    'For this task, the following Forge skills are available and should be used as appropriate:',
+    lines,
+    "Read each skill's SKILL.md before invoking. Prefer invoking these skills (with /<name>) over reimplementing their workflows inline.",
+  ].join('\n');
+}
+
+// ─── Skill task settler ───────────────────────────────────
+
+/**
+ * Global task event listener that settles schedule_runs whose target_id
+ * is a Claude task (i.e. body_kind='skill'). We only act on terminal
+ * status events; reads getTask to capture resultSummary as body_output.
+ *
+ * Idempotent: updateScheduleRunStatus only touches rows with status='started',
+ * so a duplicate event is a no-op.
+ */
+let skillListenerInstalled = false;
+function installSkillTaskListener(): void {
+  if (skillListenerInstalled) return;
+  skillListenerInstalled = true;
+  onTaskEvent((taskId, event, data) => {
+    if (event !== 'status') return;
+    if (data !== 'done' && data !== 'failed' && data !== 'cancelled') return;
+    settleSkillRunIfMatch(taskId, data as ScheduleRunStatus);
+  });
+}
+
+function settleSkillRunIfMatch(taskId: string, status: ScheduleRunStatus): void {
+  // We don't know body kind without a join; just attempt the update.
+  // updateScheduleRunStatus only touches rows with status='started'
+  // AND target_id=taskId, so it's a no-op for non-schedule tasks.
+  const t = getTask(taskId);
+  if (!t) {
+    updateScheduleRunStatus({ target_id: taskId, status, error: 'task row gone' });
+    return;
+  }
+  setScheduleRunBodyOutputByTarget(taskId, t.resultSummary || null);
+  updateScheduleRunStatus({
+    target_id: taskId,
+    status,
+    error: status === 'failed' ? (t.error || null) : null,
+  });
+  void runActionForTarget(taskId).catch((e) => {
+    console.error(`[schedules-scheduler] action for skill target ${taskId} crashed`, e);
+  });
+}
+
+/**
+ * Refusing a manual fire when something's already inflight unless caller
+ * passed cancel_inflight=1. Returns null if not busy. Returns a reason
+ * string if busy.
+ */
+export function isScheduleBusy(id: string): { busy: boolean; reason: string } {
+  const s = getSchedule(id);
+  if (!s) return { busy: false, reason: '' };
+  const n = countInflightForSchedule(id);
+  if (n > 0) return { busy: true, reason: `${n} body run${n === 1 ? '' : 's'} still running from this schedule` };
+  return { busy: false, reason: '' };
+}