@aion0/forge 0.9.12 → 0.9.14

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.12",
+  "version": "0.9.14",
   "description": "Unified AI workflow platform — multi-model task orchestration, persistent sessions, web terminal, remote access",
   "type": "module",
   "scripts": {