@aion0/forge 0.9.11 → 0.9.13

package/lib/projects.ts

@@ -1,6 +1,7 @@
-import { readdirSync, existsSync, statSync, readFileSync } from 'node:fs';
+import { readdirSync, existsSync, statSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { loadSettings } from './settings';
+import { getDataDir } from './dirs';
 
 export interface LocalProject {
   name: string;
@@ -12,6 +13,67 @@ export interface LocalProject {
   lastModified: string;
 }
 
+/** Reserved name for the synthetic "scratch" project that lives under
+ *  <dataDir>/scratch. Default workspace for tasks that don't need a real
+ *  project (prompt schedules calling connectors / chat-launched temp tasks
+ *  / anything that just talks to APIs and doesn't touch files). */
+export const SCRATCH_PROJECT_NAME = 'scratch';
+
+/** Materialize <dataDir>/scratch on first call. Idempotent. Returns the
+ *  project path. Called from init.ts on startup so the dir exists before
+ *  any task tries to cd into it. */
+export function ensureScratchProject(): string {
+  const dir = join(getDataDir(), 'scratch');
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  const claudeMd = join(dir, 'CLAUDE.md');
+  if (!existsSync(claudeMd)) {
+    try {
+      writeFileSync(claudeMd,
+        '# Forge Scratch\n\n' +
+        'Default workspace for tasks that do not target a specific project.\n' +
+        'Files here are managed by Forge (per-instance, follows the data dir).\n' +
+        'Safe to wipe by hand if it accumulates clutter.\n',
+        'utf-8',
+      );
+    } catch { /* best-effort */ }
+  }
+  // Scratch is Forge-owned (no user hand-rolled .mcp.json to defy), so
+  // unlike real projects we materialize the root .mcp.json directly here.
+  // Without it, prompt-mode schedule tasks running in scratch can't see
+  // the Forge MCP server (claude CLI only auto-discovers root .mcp.json,
+  // not .forge/mcp.json). Always rewrite to keep mcpPort + user-managed
+  // entries in sync.
+  try {
+    const mcpPort = Number(process.env.MCP_PORT) || 8406;
+    let userServers: Record<string, unknown> = {};
+    try { userServers = loadSettings().mcpServers || {}; } catch {}
+    const cfg = {
+      mcpServers: {
+        forge: { type: 'sse', url: `http://localhost:${mcpPort}/sse` },
+        ...userServers,
+      },
+    };
+    writeFileSync(join(dir, '.mcp.json'), JSON.stringify(cfg, null, 2), 'utf-8');
+  } catch { /* best-effort */ }
+  return dir;
+}
+
+function scratchProject(): LocalProject {
+  const path = ensureScratchProject();
+  let mtime: string;
+  try { mtime = statSync(path).mtime.toISOString(); }
+  catch { mtime = new Date().toISOString(); }
+  return {
+    name: SCRATCH_PROJECT_NAME,
+    path,
+    root: getDataDir(),
+    hasGit: false,
+    hasClaudeMd: existsSync(join(path, 'CLAUDE.md')),
+    language: null,
+    lastModified: mtime,
+  };
+}
+
 export function scanProjects(): LocalProject[] {
   const settings = loadSettings();
   const roots = settings.projectRoots;
@@ -52,7 +114,10 @@ export function scanProjects(): LocalProject[] {
     }
   }
 
-  return projects.sort((a, b) => b.lastModified.localeCompare(a.lastModified));
+  // Prepend the synthetic scratch project so the UI surfaces it as a
+  // first-class option. It's stamped with the current date so it tends
+  // to sort to the top — that's intentional: it's the default fallback.
+  return [scratchProject(), ...projects.sort((a, b) => b.lastModified.localeCompare(a.lastModified))];
 }
 
 function detectLanguage(projectPath: string): string | null {

package/lib/prompts/store.ts

@@ -0,0 +1,142 @@
+/**
+ * Prompts file store — `<dataDir>/prompts/<name>.yaml`.
+ *
+ * Same external-file pattern as pipelines: name in DB / schedule row,
+ * configuration in YAML on disk. Edits don't require migrations.
+ */
+
+import { existsSync, readFileSync, readdirSync, writeFileSync, unlinkSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import YAML from 'yaml';
+import { getDataDir } from '@/lib/dirs';
+import type { Prompt, CreatePromptInput, UpdatePromptInput } from './types';
+
+function dir(): string {
+  return join(getDataDir(), 'prompts');
+}
+
+// Same constraint as pipeline names — also serves as filename `<name>.yaml`.
+const NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,63}$/;
+
+function pathFor(name: string): string {
+  return join(dir(), `${name}.yaml`);
+}
+
+function parsePrompt(yaml: string): Prompt {
+  const raw = YAML.parse(yaml);
+  if (!raw || typeof raw !== 'object') throw new Error('prompt yaml must be a mapping');
+  if (typeof raw.name !== 'string' || !raw.name) throw new Error('prompt.name required');
+  if (typeof raw.prompt !== 'string') throw new Error('prompt.prompt required (string)');
+
+  const ex = raw.executor || {};
+  const skills = Array.isArray(ex.skills)
+    ? ex.skills.filter((s: unknown) => typeof s === 'string')
+    : [];
+  const now = new Date().toISOString();
+  return {
+    name: raw.name,
+    prompt: raw.prompt,
+    executor: {
+      agent: typeof ex.agent === 'string' && ex.agent ? ex.agent : null,
+      skills,
+      config: ex.config && typeof ex.config === 'object' ? ex.config : undefined,
+    },
+    created_at: typeof raw.created_at === 'string' ? raw.created_at : now,
+    updated_at: typeof raw.updated_at === 'string' ? raw.updated_at : now,
+  };
+}
+
+function serialize(p: Prompt): string {
+  const executorOut: Record<string, unknown> = {
+    agent: p.executor.agent,
+    skills: p.executor.skills,
+  };
+  if (p.executor.config) executorOut.config = p.executor.config;
+  return YAML.stringify({
+    name: p.name,
+    prompt: p.prompt,
+    executor: executorOut,
+    created_at: p.created_at,
+    updated_at: p.updated_at,
+  });
+}
+
+export function listPrompts(): Prompt[] {
+  const d = dir();
+  if (!existsSync(d)) return [];
+  const out: Prompt[] = [];
+  for (const f of readdirSync(d).filter(f => f.endsWith('.yaml') || f.endsWith('.yml'))) {
+    try {
+      out.push(parsePrompt(readFileSync(join(d, f), 'utf-8')));
+    } catch (e) {
+      console.warn(`[listPrompts] skip ${f}: ${(e as Error).message}`);
+    }
+  }
+  return out.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+export function getPrompt(name: string): Prompt | null {
+  if (!NAME_RE.test(name)) return null;
+  const path = pathFor(name);
+  if (!existsSync(path)) return null;
+  try {
+    return parsePrompt(readFileSync(path, 'utf-8'));
+  } catch (e) {
+    console.warn(`[getPrompt] parse ${name}: ${(e as Error).message}`);
+    return null;
+  }
+}
+
+export function createPrompt(input: CreatePromptInput): Prompt {
+  if (!NAME_RE.test(input.name)) {
+    throw new Error(`invalid name (allowed: letters/digits/._-, 1-64 chars): '${input.name}'`);
+  }
+  if (!input.prompt || !input.prompt.trim()) {
+    throw new Error('prompt text required');
+  }
+  mkdirSync(dir(), { recursive: true });
+  if (existsSync(pathFor(input.name))) {
+    throw new Error(`prompt '${input.name}' already exists`);
+  }
+  const now = new Date().toISOString();
+  const p: Prompt = {
+    name: input.name,
+    prompt: input.prompt,
+    executor: {
+      agent: input.executor?.agent ?? null,
+      skills: input.executor?.skills ?? [],
+      config: input.executor?.config,
+    },
+    created_at: now,
+    updated_at: now,
+  };
+  writeFileSync(pathFor(input.name), serialize(p), 'utf-8');
+  return p;
+}
+
+export function updatePrompt(name: string, patch: UpdatePromptInput): Prompt {
+  const cur = getPrompt(name);
+  if (!cur) throw new Error(`prompt '${name}' not found`);
+  const next: Prompt = {
+    ...cur,
+    prompt: patch.prompt ?? cur.prompt,
+    executor: patch.executor
+      ? {
+          agent: patch.executor.agent ?? cur.executor.agent,
+          skills: patch.executor.skills ?? cur.executor.skills,
+          config: patch.executor.config ?? cur.executor.config,
+        }
+      : cur.executor,
+    updated_at: new Date().toISOString(),
+  };
+  writeFileSync(pathFor(name), serialize(next), 'utf-8');
+  return next;
+}
+
+export function deletePrompt(name: string): boolean {
+  if (!NAME_RE.test(name)) return false;
+  const path = pathFor(name);
+  if (!existsSync(path)) return false;
+  unlinkSync(path);
+  return true;
+}

package/lib/prompts/types.ts

@@ -0,0 +1,53 @@
+/**
+ * Forge Prompts — types (V3 B1)
+ *
+ * A Prompt is a stored body for `body_kind='prompt'` schedules. The schedule
+ * references it by name; the actual configuration (text + executor) lives
+ * in `<dataDir>/prompts/<name>.yaml`. Same external-file pattern Pipeline
+ * uses, so prompt fields can evolve without DB migrations.
+ *
+ * Wired into scheduler dispatch in B2 (#263).
+ */
+
+export interface PromptExecutorRetry {
+  /** 0 = don't retry (default). Failed prompt tasks just wait for the next tick. */
+  max: number;
+  backoff?: 'linear' | 'exponential';
+  /** Seconds before first retry. */
+  initial_delay?: number;
+}
+
+export interface PromptExecutorConfig {
+  /** Task timeout in seconds. Falls through to system default if unset. */
+  timeout?: number;
+  retry?: PromptExecutorRetry;
+}
+
+export interface PromptExecutor {
+  /** Agent id from Settings. null = use system default. */
+  agent: string | null;
+  /** Skills attached to the dispatched task; typically includes
+   *  `ai-orchestration` so the agent can discover + call connectors. */
+  skills: string[];
+  config?: PromptExecutorConfig;
+}
+
+export interface Prompt {
+  name: string;
+  /** User-authored prompt text. MUST be preserved verbatim — no LLM rewrites. */
+  prompt: string;
+  executor: PromptExecutor;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface CreatePromptInput {
+  name: string;
+  prompt: string;
+  executor?: Partial<PromptExecutor>;
+}
+
+export interface UpdatePromptInput {
+  prompt?: string;
+  executor?: Partial<PromptExecutor>;
+}

package/lib/schedules/scheduler.ts

@@ -12,7 +12,6 @@
  * 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 {
@@ -21,9 +20,9 @@ import {
   onTaskEvent,
   taskAppendSystemPromptOverrides,
 } from '@/lib/task-manager';
-import { getProjectInfo } from '@/lib/projects';
-import { dispatchTool } from '@/lib/chat/tool-dispatcher';
+import { getProjectInfo, SCRATCH_PROJECT_NAME } from '@/lib/projects';
 import { ensureInstalledInProject } from '@/lib/skills';
+import { getPrompt } from '@/lib/prompts/store';
 import { getDb } from '@/src/core/db/database';
 import { getDbPath } from '@/src/config';
 import {
@@ -50,7 +49,7 @@ export function startSchedulesScheduler(): void {
   if (g[schedulerKey]) return;
   g[schedulerKey] = true;
   ensureSchema();
-  installSkillTaskListener();
+  installTaskBackedRunListener();
   console.log('[schedules-scheduler] started');
   void tick();
   setInterval(() => { void tick(); }, TICK_INTERVAL_MS).unref?.();
@@ -135,9 +134,8 @@ export function advanceSchedule(s: Schedule): void {
  * 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);
+  if (s.body_kind === 'pipeline') return executePipelineBody(s, trigger);
+  if (s.body_kind === 'prompt')   return executePromptBody(s, trigger);
   throw new Error(`unknown body_kind: ${s.body_kind}`);
 }
 
@@ -202,38 +200,40 @@ async function preinstallSkillsForPipeline(
   }
 }
 
-// ─── skill body ───────────────────────────────────────────
+// ─── prompt body (V3) ────────────────────────────────────
 
 /**
- * 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.
+ * Prompt body: load prompts/<body_ref>.yaml, dispatch a one-shot Claude
+ * task with the YAML's prompt text + executor.agent + executor.skills.
+ * Schedule.input.project chooses where the task runs. The schedule_run
+ * carries task.id as target_id; the task event listener (below) settles
+ * status + body_output when the task reaches terminal state.
  *
- * 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)
+ * The user's prompt text is sent VERBATIM — no LLM rewrites, no template
+ * expansion. Schedule.input is currently ignored (project is the only
+ * required field); future versions may surface input.* as template vars.
  */
-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)');
-  }
+async function executePromptBody(s: Schedule, trigger: ScheduleRunTrigger): Promise<string> {
+  const def = getPrompt(s.body_ref);
+  if (!def) throw new Error(`prompt definition not found: prompts/${s.body_ref}.yaml`);
+
+  // input.project is optional for prompt body — empty / unset falls back
+  // to the synthetic 'scratch' project (<dataDir>/scratch) materialized
+  // at init time. Schedules created before the optional-project change
+  // also work: empty string → scratch.
+  const projectName = strField(s.input.project) || SCRATCH_PROJECT_NAME;
   const project = getProjectInfo(projectName);
-  if (!project) {
-    throw new Error(`project not found: "${projectName}"`);
-  }
+  if (!project) throw new Error(`project not found: "${projectName}"`);
+
+  // Merge prompt-yaml skills with any extra skills the schedule row carries.
+  // YAML is the primary source (designed per-prompt); schedule.skills is a
+  // legacy/override hook that we keep for parity with pipeline/skill bodies.
+  const skills = [
+    ...(def.executor.skills || []),
+    ...(s.skills || []),
+  ].filter((v, i, arr) => v && arr.indexOf(v) === i);
 
-  // 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) {
+  for (const skill of skills) {
     try {
       const r = await ensureInstalledInProject(skill, project.path);
       if (!r.installed) console.warn(`[schedules] skill "${skill}" not installable in ${project.path}: ${r.reason}`);
@@ -242,31 +242,15 @@ async function executeSkillBody(s: Schedule, trigger: ScheduleRunTrigger): Promi
     }
   }
 
-  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,
+    prompt: def.prompt,
     conversationId: '',
+    agent: def.executor.agent || undefined,
   });
 
-  // 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);
+  const append = renderSkillsAppendPrompt(skills);
   if (append) taskAppendSystemPromptOverrides.set(task.id, append);
 
   insertScheduleRun({ schedule_id: s.id, target_id: task.id, trigger });
@@ -274,82 +258,6 @@ async function executeSkillBody(s: Schedule, trigger: ScheduleRunTrigger): Promi
   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));
@@ -367,31 +275,31 @@ function renderSkillsAppendPrompt(skills: string[] | undefined): string {
   ].join('\n');
 }
 
-// ─── Skill task settler ───────────────────────────────────
+// ─── Task-backed run 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.
+ * is a Claude task (body_kind='prompt' dispatches one-shot tasks and stores
+ * task.id as target_id).
+ *
+ * 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.
+ * Idempotent: updateScheduleRunStatus only touches rows with status='started'
+ * AND target_id=taskId, so a duplicate event (or a non-schedule task) is a no-op.
  */
-let skillListenerInstalled = false;
-function installSkillTaskListener(): void {
-  if (skillListenerInstalled) return;
-  skillListenerInstalled = true;
+let taskBackedListenerInstalled = false;
+function installTaskBackedRunListener(): void {
+  if (taskBackedListenerInstalled) return;
+  taskBackedListenerInstalled = true;
   onTaskEvent((taskId, event, data) => {
     if (event !== 'status') return;
     if (data !== 'done' && data !== 'failed' && data !== 'cancelled') return;
-    settleSkillRunIfMatch(taskId, data as ScheduleRunStatus);
+    settleTaskBackedRun(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.
+function settleTaskBackedRun(taskId: string, status: ScheduleRunStatus): void {
   const t = getTask(taskId);
   if (!t) {
     updateScheduleRunStatus({ target_id: taskId, status, error: 'task row gone' });
@@ -404,7 +312,7 @@ function settleSkillRunIfMatch(taskId: string, status: ScheduleRunStatus): void
     error: status === 'failed' ? (t.error || null) : null,
   });
   void runActionForTarget(taskId).catch((e) => {
-    console.error(`[schedules-scheduler] action for skill target ${taskId} crashed`, e);
+    console.error(`[schedules-scheduler] action for task target ${taskId} crashed`, e);
   });
 }
 

package/lib/schedules/store.ts

@@ -485,10 +485,9 @@ export function setScheduleRunAction(args: {
 
 // ─── Zombie reconciliation ────────────────────────────────
 
-/** Same idea as Job's reconcileStalePipelineRuns: any started+30s+
- *  schedule_run whose target is gone OR in terminal state → fix the
- *  DB row. Handles body_kind=pipeline (read JSON file) and
- *  body_kind=skill (read tasks table). connector_tool lands in phase 3. */
+/** Any started+30s+ schedule_run whose target is gone OR in terminal
+ *  state → fix the DB row. Handles body_kind=pipeline (read JSON file)
+ *  and body_kind=prompt (read tasks table). */
 export function reconcileStaleScheduleRuns(): void {
   try {
     const stale = db().prepare(`
@@ -513,16 +512,8 @@ export function reconcileStaleScheduleRuns(): void {
       let settled = false;
       if (row.body_kind === 'pipeline') {
         settled = reconcilePipelineRun(row.id, row.target_id, pipelineDir);
-      } else if (row.body_kind === 'skill') {
-        settled = reconcileSkillRun(row.id, row.target_id);
-      } else if (row.body_kind === 'connector_tool') {
-        // connector_tool dispatch is in-memory async. If it's still
-        // 'started' 30s later it means forge crashed mid-call, or the
-        // tool itself is hanging. Either way: fail the run so future
-        // ticks aren't blocked by isScheduleBusy.
-        markRunStatus(row.id, 'failed');
-        console.warn(`[schedules] reconciled stale connector_tool schedule_run ${row.id} → failed (no in-memory progress after 30s)`);
-        settled = true;
+      } else if (row.body_kind === 'prompt') {
+        settled = reconcileTaskBackedRun(row.id, row.target_id);
       } else {
         markRunStatus(row.id, 'failed');
         console.warn(`[schedules] reconciled schedule_run ${row.id} → failed (unsupported body_kind '${row.body_kind}')`);
@@ -590,7 +581,7 @@ function reconcilePipelineRun(
 
 /** Same contract as reconcilePipelineRun: true if settled, false if
  *  task still in flight (caller must NOT fire action yet). */
-function reconcileSkillRun(runId: string, taskId: string): boolean {
+function reconcileTaskBackedRun(runId: string, taskId: string): boolean {
   try {
     const t = db().prepare(
       `SELECT status, result_summary FROM tasks WHERE id = ?`,

package/lib/schedules/types.ts

@@ -1,21 +1,15 @@
 /**
- * Forge Schedules — types (V2)
+ * Forge Schedules — types (V3)
  *
- * V2 generalizes Schedule from "pipeline + input + trigger" to
- * "trigger + body + action". body is one of pipeline / skill /
- * connector_tool (skill + connector_tool land in later phases).
- * action is one of none / chat / email / telegram (chat/email/telegram
- * land in later phases).
- *
- * Phase 1 only renames + extends fields; runtime behavior unchanged
- * (body_kind defaults to 'pipeline', action_kind defaults to 'none').
+ * trigger + body + action. body is one of pipeline / prompt.
+ * action is one of none / chat / email / telegram.
  */
 
 export type ScheduleKind = 'period' | 'once' | 'cron' | 'manual';
 export type ScheduleRunStatus = 'started' | 'done' | 'failed' | 'cancelled';
 export type ScheduleRunTrigger = 'schedule' | 'manual';
 
-export type ScheduleBodyKind = 'pipeline' | 'skill' | 'connector_tool';
+export type ScheduleBodyKind = 'pipeline' | 'prompt';
 export type ScheduleActionKind = 'none' | 'chat' | 'email' | 'telegram';
 export type ScheduleActionStatus = 'pending' | 'done' | 'failed' | 'skipped';
 
@@ -27,15 +21,17 @@ export interface Schedule {
 
   // Body — what to run when this schedule fires.
   body_kind: ScheduleBodyKind;
-  /** Reference depends on body_kind: pipeline name / skill id / `<plugin>.<tool>`. */
+  /** Reference depends on body_kind:
+   *   pipeline → pipeline name (flows/<name>.yaml)
+   *   prompt   → prompt name (prompts/<name>.yaml) */
   body_ref: string;
   /** Input params; shape depends on body_kind. */
   input: Record<string, unknown>;
 
   /** Extra Forge skills attached to the dispatched body. For body=pipeline
    *  these are forwarded to startPipeline({skills}) → every task gets the
-   *  --append-system-prompt block. For body=skill they're merged with
-   *  body_ref into a single prompt. body=connector_tool ignores this. */
+   *  --append-system-prompt block. For body=prompt they're merged with the
+   *  prompt yaml's executor.skills and installed before dispatch. */
   skills: string[];
 
   // Action — what to do with body's output. action_config JSON shape
@@ -72,7 +68,7 @@ export interface ScheduleRun {
   id: string;
   schedule_id: string;
   /** ID of the dispatched body — pipeline_id for body=pipeline,
-   *  task_id for body=skill, fresh uuid for body=connector_tool. */
+   *  task_id for body=prompt. */
   target_id: string;
   trigger: ScheduleRunTrigger;
   status: ScheduleRunStatus;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aion0/forge",
-  "version": "0.9.11",
+  "version": "0.9.13",
   "description": "Unified AI workflow platform — multi-model task orchestration, persistent sessions, web terminal, remote access",
   "type": "module",
   "scripts": {