workplane 0.4.0 → 0.4.2

package/dist/server.js

@@ -9,13 +9,137 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// ../workplans/src/providers/anthropic.ts
+var anthropic_exports = {};
+__export(anthropic_exports, {
+  runAnthropicStep: () => runAnthropicStep
+});
+import Anthropic from "@anthropic-ai/sdk";
+async function runAnthropicStep(opts) {
+  const client = new Anthropic({ apiKey: opts.apiKey ?? process.env.ANTHROPIC_API_KEY });
+  const message = await client.messages.create({
+    model: opts.model,
+    max_tokens: 4096,
+    messages: [{ role: "user", content: opts.prompt }]
+  });
+  const block = message.content[0];
+  return block.type === "text" ? block.text : "";
+}
+var init_anthropic = __esm({
+  "../workplans/src/providers/anthropic.ts"() {
+    "use strict";
+  }
+});
+
+// ../workplans/src/providers/openai.ts
+var openai_exports = {};
+__export(openai_exports, {
+  runOpenAIStep: () => runOpenAIStep
+});
+import OpenAI from "openai";
+async function runOpenAIStep(opts) {
+  const client = new OpenAI({ apiKey: opts.apiKey ?? process.env.OPENAI_API_KEY });
+  const completion = await client.chat.completions.create({
+    model: opts.model,
+    messages: [{ role: "user", content: opts.prompt }]
+  });
+  return completion.choices[0]?.message.content ?? "";
+}
+var init_openai = __esm({
+  "../workplans/src/providers/openai.ts"() {
+    "use strict";
+  }
+});
+
+// ../workplans/src/providers/ollama.ts
+var ollama_exports = {};
+__export(ollama_exports, {
+  runOllamaStep: () => runOllamaStep
+});
+import { Ollama } from "ollama";
+async function runOllamaStep(opts) {
+  const host = opts.host ?? process.env.OLLAMA_HOST ?? "http://localhost:11434";
+  const client = new Ollama({ host });
+  const response = await client.generate({ model: opts.model, prompt: opts.prompt });
+  return response.response;
+}
+var init_ollama = __esm({
+  "../workplans/src/providers/ollama.ts"() {
+    "use strict";
+  }
+});
+
+// ../workplans/src/providers/shell.ts
+var shell_exports = {};
+__export(shell_exports, {
+  runShellStep: () => runShellStep
+});
+import { exec } from "child_process";
+import { promisify } from "util";
+async function runShellStep(opts) {
+  const { stdout } = await execAsync(opts.command, {
+    cwd: opts.cwd,
+    maxBuffer: 10 * 1024 * 1024
+  });
+  return stdout;
+}
+var execAsync;
+var init_shell = __esm({
+  "../workplans/src/providers/shell.ts"() {
+    "use strict";
+    execAsync = promisify(exec);
+  }
+});
+
+// ../workplans/src/providers/file.ts
+var file_exports = {};
+__export(file_exports, {
+  runFileStep: () => runFileStep
+});
+import { readFile } from "fs/promises";
+async function runFileStep(opts) {
+  return readFile(opts.path, opts.encoding ?? "utf8");
+}
+var init_file = __esm({
+  "../workplans/src/providers/file.ts"() {
+    "use strict";
+  }
+});
+
+// ../dbos/src/scheduler.ts
+var scheduler_exports = {};
+__export(scheduler_exports, {
+  registerDbosSchedulerTick: () => registerDbosSchedulerTick
+});
+import { DBOS } from "@dbos-inc/dbos-sdk";
+function registerDbosSchedulerTick(scheduler) {
+  if (registered) {
+    return;
+  }
+  DBOS.registerScheduled(
+    async () => {
+      await scheduler.tick();
+    },
+    { crontab: "* * * * *" }
+  );
+  registered = true;
+}
+var registered;
+var init_scheduler = __esm({
+  "../dbos/src/scheduler.ts"() {
+    "use strict";
+    registered = false;
+  }
+});
+
 // ../dbos/src/index.ts
 var src_exports = {};
 __export(src_exports, {
   DbosWorkflows: () => DbosWorkflows,
-  createDbosWorkflows: () => createDbosWorkflows
+  createDbosWorkflows: () => createDbosWorkflows,
+  registerDbosSchedulerTick: () => registerDbosSchedulerTick
 });
-import { DBOS } from "@dbos-inc/dbos-sdk";
+import { DBOS as DBOS2 } from "@dbos-inc/dbos-sdk";
 function createDbosWorkflows(store) {
   return new DbosWorkflows(store);
 }
@@ -23,39 +147,40 @@ var DbosWorkflows;
 var init_src = __esm({
   "../dbos/src/index.ts"() {
     "use strict";
+    init_scheduler();
     DbosWorkflows = class {
       registered;
       constructor(store) {
-        const createTask = DBOS.registerWorkflow(
-          async (input) => DBOS.runStep(() => store.createTask(input), { name: "store-create-task" }),
+        const createTask = DBOS2.registerWorkflow(
+          async (input) => DBOS2.runStep(() => store.createTask(input), { name: "store-create-task" }),
           { name: "createTaskWorkflow" }
         );
-        const retryTask = DBOS.registerWorkflow(
-          async (taskId) => DBOS.runStep(() => store.retryTask(taskId), { name: "store-retry-task" }),
+        const retryTask = DBOS2.registerWorkflow(
+          async (taskId) => DBOS2.runStep(() => store.retryTask(taskId), { name: "store-retry-task" }),
           { name: "retryTaskWorkflow" }
         );
-        const cancelTask = DBOS.registerWorkflow(
-          async (taskId) => DBOS.runStep(() => store.cancelTask(taskId), { name: "store-cancel-task" }),
+        const cancelTask = DBOS2.registerWorkflow(
+          async (taskId) => DBOS2.runStep(() => store.cancelTask(taskId), { name: "store-cancel-task" }),
           { name: "cancelTaskWorkflow" }
         );
-        const updateRunStatus = DBOS.registerWorkflow(
-          async (runId, status, error) => DBOS.runStep(() => store.updateRunStatus(runId, status, error), { name: "store-update-run-status" }),
+        const updateRunStatus = DBOS2.registerWorkflow(
+          async (runId, status, error) => DBOS2.runStep(() => store.updateRunStatus(runId, status, error), { name: "store-update-run-status" }),
           { name: "updateRunStatusWorkflow" }
         );
-        const appendRunLogs = DBOS.registerWorkflow(
-          async (runId, logs) => DBOS.runStep(() => store.appendRunLogs(runId, logs), { name: "store-append-run-logs" }),
+        const appendRunLogs = DBOS2.registerWorkflow(
+          async (runId, logs) => DBOS2.runStep(() => store.appendRunLogs(runId, logs), { name: "store-append-run-logs" }),
           { name: "appendRunLogsWorkflow" }
         );
-        const createArtifact = DBOS.registerWorkflow(
-          async (runId, input) => DBOS.runStep(() => store.createArtifact(runId, input), { name: "store-create-artifact" }),
+        const createArtifact = DBOS2.registerWorkflow(
+          async (runId, input) => DBOS2.runStep(() => store.createArtifact(runId, input), { name: "store-create-artifact" }),
           { name: "createArtifactWorkflow" }
         );
-        const appendInputEvent = DBOS.registerWorkflow(
-          async (runId, input) => DBOS.runStep(() => store.appendInputEvent(runId, input), { name: "store-append-input-event" }),
+        const appendInputEvent = DBOS2.registerWorkflow(
+          async (runId, input) => DBOS2.runStep(() => store.appendInputEvent(runId, input), { name: "store-append-input-event" }),
           { name: "appendInputEventWorkflow" }
         );
-        const markInputDelivered = DBOS.registerWorkflow(
-          async (runId, sequence) => DBOS.runStep(() => store.markInputDelivered(runId, sequence), { name: "store-mark-input-delivered" }),
+        const markInputDelivered = DBOS2.registerWorkflow(
+          async (runId, sequence) => DBOS2.runStep(() => store.markInputDelivered(runId, sequence), { name: "store-mark-input-delivered" }),
           { name: "markInputDeliveredWorkflow" }
         );
         this.registered = {
@@ -70,48 +195,48 @@ var init_src = __esm({
         };
       }
       async launch(options) {
-        DBOS.setConfig({
+        DBOS2.setConfig({
           name: options.appName,
           systemDatabaseUrl: options.systemDatabaseUrl
         });
-        await DBOS.launch({
+        await DBOS2.launch({
           conductorKey: options.conductorKey,
           conductorURL: options.conductorUrl
         });
       }
       async shutdown() {
-        await DBOS.shutdown();
+        await DBOS2.shutdown();
       }
       async createTask(input) {
-        const handle = await DBOS.startWorkflow(this.registered.createTask)(input);
+        const handle = await DBOS2.startWorkflow(this.registered.createTask)(input);
         return handle.getResult();
       }
       async retryTask(taskId) {
-        const handle = await DBOS.startWorkflow(this.registered.retryTask)(taskId);
+        const handle = await DBOS2.startWorkflow(this.registered.retryTask)(taskId);
         return handle.getResult();
       }
       async cancelTask(taskId) {
-        const handle = await DBOS.startWorkflow(this.registered.cancelTask)(taskId);
+        const handle = await DBOS2.startWorkflow(this.registered.cancelTask)(taskId);
         return handle.getResult();
       }
       async updateRunStatus(runId, status, error) {
-        const handle = await DBOS.startWorkflow(this.registered.updateRunStatus)(runId, status, error);
+        const handle = await DBOS2.startWorkflow(this.registered.updateRunStatus)(runId, status, error);
         return handle.getResult();
       }
       async appendRunLogs(runId, logs) {
-        const handle = await DBOS.startWorkflow(this.registered.appendRunLogs)(runId, logs);
+        const handle = await DBOS2.startWorkflow(this.registered.appendRunLogs)(runId, logs);
         return handle.getResult();
       }
       async createArtifact(runId, input) {
-        const handle = await DBOS.startWorkflow(this.registered.createArtifact)(runId, input);
+        const handle = await DBOS2.startWorkflow(this.registered.createArtifact)(runId, input);
         return handle.getResult();
       }
       async appendInputEvent(runId, input) {
-        const handle = await DBOS.startWorkflow(this.registered.appendInputEvent)(runId, input);
+        const handle = await DBOS2.startWorkflow(this.registered.appendInputEvent)(runId, input);
         return handle.getResult();
       }
       async markInputDelivered(runId, sequence) {
-        const handle = await DBOS.startWorkflow(this.registered.markInputDelivered)(runId, sequence);
+        const handle = await DBOS2.startWorkflow(this.registered.markInputDelivered)(runId, sequence);
         await handle.getResult();
       }
     };
@@ -183,7 +308,7 @@ import Database from "better-sqlite3";
 import { Pool } from "pg";
 
 // ../db/src/pg-store.ts
-import { and, asc, desc, eq, gt, sql as sql2 } from "drizzle-orm";
+import { and, arrayContains, asc, desc, eq, gt, isNotNull, lte, sql as sql2 } from "drizzle-orm";
 
 // ../core/src/ids.ts
 import { randomUUID } from "crypto";
@@ -199,10 +324,13 @@ __export(pg_exports, {
   runInputEvents: () => runInputEvents,
   runLogs: () => runLogs,
   runs: () => runs,
-  tasks: () => tasks
+  tasks: () => tasks,
+  workplanRuns: () => workplanRuns,
+  workplanSchedules: () => workplanSchedules,
+  workplanStepResults: () => workplanStepResults
 });
 import { isNull, sql } from "drizzle-orm";
-import { bigint, bigserial, index, integer, jsonb, pgTable, text, timestamp, uniqueIndex } from "drizzle-orm/pg-core";
+import { bigint, bigserial, boolean, index, integer, jsonb, pgTable, text, timestamp, uniqueIndex } from "drizzle-orm/pg-core";
 var tasks = pgTable("tasks", {
   id: text("id").primaryKey(),
   kind: text("kind").notNull(),
@@ -260,6 +388,49 @@ var artifacts = pgTable("artifacts", {
 }, (table) => ({
   runIdIdx: index("idx_artifacts_run_id").on(table.runId)
 }));
+var workplanSchedules = pgTable("workplan_schedules", {
+  id: text("id").primaryKey(),
+  planId: text("plan_id").notNull(),
+  name: text("name").notNull(),
+  cronExpression: text("cron_expression").notNull(),
+  timezone: text("timezone").notNull(),
+  inputs: jsonb("inputs").$type().notNull().default({}),
+  enabled: boolean("enabled").notNull().default(true),
+  lastRunAt: timestamp("last_run_at", { withTimezone: true }),
+  nextRunAt: timestamp("next_run_at", { withTimezone: true }),
+  createdBy: text("created_by"),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => ({
+  dueIdx: index("idx_workplan_schedules_due").on(table.nextRunAt)
+}));
+var workplanRuns = pgTable("workplan_runs", {
+  id: text("id").primaryKey(),
+  scheduleId: text("schedule_id").references(() => workplanSchedules.id),
+  planId: text("plan_id").notNull(),
+  planName: text("plan_name").notNull(),
+  status: text("status").notNull().default("running"),
+  idempotencyKey: text("idempotency_key"),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  endedAt: timestamp("ended_at", { withTimezone: true }),
+  error: text("error")
+}, (table) => ({
+  scheduleIdx: index("idx_workplan_runs_schedule_id").on(table.scheduleId),
+  idempotencyUnique: uniqueIndex("idx_workplan_runs_idempotency").on(table.idempotencyKey)
+}));
+var workplanStepResults = pgTable("workplan_step_results", {
+  id: text("id").primaryKey(),
+  workplanRunId: text("workplan_run_id").notNull().references(() => workplanRuns.id),
+  stepId: text("step_id").notNull(),
+  stepName: text("step_name").notNull(),
+  output: text("output"),
+  exitCode: integer("exit_code"),
+  durationMs: integer("duration_ms"),
+  metadata: jsonb("metadata").$type(),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => ({
+  runIdx: index("idx_workplan_step_results_run_id").on(table.workplanRunId)
+}));
 var runInputEvents = pgTable("run_input_events", {
   id: bigserial("id", { mode: "number" }).primaryKey(),
   runId: text("run_id").notNull().references(() => runs.id),
@@ -339,16 +510,46 @@ function toInputEventRecord(row) {
     deliveredAt: row.deliveredAt?.toISOString() ?? null
   };
 }
-function mapRawTask(row) {
+function toScheduleRecord(row) {
   return {
-    id: String(row.id),
-    kind: String(row.kind),
-    adapter: String(row.adapter),
-    payload: row.payload ?? {},
-    requires: row.requires ?? [],
+    id: row.id,
+    planId: row.planId,
+    name: row.name,
+    cronExpression: row.cronExpression,
+    timezone: row.timezone,
+    inputs: row.inputs ?? {},
+    enabled: row.enabled,
+    lastRunAt: row.lastRunAt?.toISOString() ?? null,
+    nextRunAt: row.nextRunAt?.toISOString() ?? null,
+    createdBy: row.createdBy ?? null,
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString()
+  };
+}
+function toWorkplanRunRecord(row) {
+  return {
+    id: row.id,
+    scheduleId: row.scheduleId ?? null,
+    planId: row.planId,
+    planName: row.planName,
     status: row.status,
-    createdAt: new Date(String(row.created_at)).toISOString(),
-    updatedAt: new Date(String(row.updated_at)).toISOString()
+    idempotencyKey: row.idempotencyKey ?? null,
+    createdAt: row.createdAt.toISOString(),
+    endedAt: row.endedAt?.toISOString() ?? null,
+    error: row.error ?? null
+  };
+}
+function toWorkplanStepResultRecord(row) {
+  return {
+    id: row.id,
+    workplanRunId: row.workplanRunId,
+    stepId: row.stepId,
+    stepName: row.stepName,
+    output: row.output ?? null,
+    exitCode: row.exitCode ?? null,
+    durationMs: row.durationMs ?? null,
+    metadata: row.metadata ?? null,
+    createdAt: row.createdAt.toISOString()
   };
 }
 function mapRawRun(row) {
@@ -421,22 +622,15 @@ var PgStore = class {
   }
   async pollNode(nodeId, capabilities) {
     return await this.db.transaction(async (tx) => {
-      await tx.execute(sql2`
-        UPDATE nodes
-        SET capabilities = ${capabilities}::text[], status = 'online',
-            last_heartbeat_at = now(), updated_at = now()
-        WHERE id = ${nodeId}
-      `);
-      const taskResult = await tx.execute(sql2`
-        SELECT * FROM tasks
-        WHERE status = 'queued' AND requires <@ ${capabilities}::text[]
-        ORDER BY created_at ASC
-        LIMIT 1
-        FOR UPDATE SKIP LOCKED
-      `);
-      if (taskResult.rows.length === 0) return null;
-      const taskRow = taskResult.rows[0];
-      const taskId = String(taskRow.id);
+      await tx.update(nodes).set({
+        capabilities,
+        status: "online",
+        lastHeartbeatAt: sql2`now()`,
+        updatedAt: sql2`now()`
+      }).where(eq(nodes.id, nodeId));
+      const [taskRow] = await tx.select().from(tasks).where(and(eq(tasks.status, "queued"), arrayContains(tasks.requires, capabilities))).orderBy(asc(tasks.createdAt)).limit(1).for("update", { skipLocked: true });
+      if (!taskRow) return null;
+      const taskId = taskRow.id;
       const attemptResult = await tx.execute(sql2`
         SELECT COALESCE(MAX(attempt), 0) AS max_attempt FROM runs WHERE task_id = ${taskId}
       `);
@@ -451,7 +645,7 @@ var PgStore = class {
         UPDATE tasks SET status = 'assigned', updated_at = now() WHERE id = ${taskId}
       `);
       return {
-        task: mapRawTask(taskRow),
+        task: toTaskRecord(taskRow),
         run: mapRawRun(runResult.rows[0])
       };
     });
@@ -564,10 +758,122 @@ var PgStore = class {
   async markInputDelivered(runId, sequence) {
     await this.db.update(runInputEvents).set({ deliveredAt: sql2`now()` }).where(and(eq(runInputEvents.runId, runId), eq(runInputEvents.sequence, sequence)));
   }
+  async createWorkplanSchedule(input) {
+    const [row] = await this.db.insert(workplanSchedules).values({
+      id: makeId("sched"),
+      planId: input.planId,
+      name: input.name,
+      cronExpression: input.cronExpression,
+      timezone: input.timezone,
+      inputs: input.inputs ?? {},
+      enabled: input.enabled ?? true,
+      nextRunAt: input.enabled === false ? null : input.nextRunAt ? new Date(input.nextRunAt) : null,
+      createdBy: input.createdBy ?? null
+    }).returning();
+    return toScheduleRecord(row);
+  }
+  async listWorkplanSchedules(enabled) {
+    const rows = await this.db.select().from(workplanSchedules).where(enabled === void 0 ? void 0 : eq(workplanSchedules.enabled, enabled)).orderBy(desc(workplanSchedules.createdAt));
+    return rows.map(toScheduleRecord);
+  }
+  async getWorkplanSchedule(scheduleId) {
+    const [row] = await this.db.select().from(workplanSchedules).where(eq(workplanSchedules.id, scheduleId));
+    return row ? toScheduleRecord(row) : null;
+  }
+  async updateWorkplanSchedule(scheduleId, input) {
+    const patch = {};
+    if (input.name !== void 0) patch.name = input.name;
+    if (input.cronExpression !== void 0) patch.cronExpression = input.cronExpression;
+    if (input.timezone !== void 0) patch.timezone = input.timezone;
+    if (input.inputs !== void 0) patch.inputs = input.inputs;
+    if (input.enabled !== void 0) patch.enabled = input.enabled;
+    if (input.nextRunAt !== void 0) patch.nextRunAt = input.nextRunAt ? new Date(input.nextRunAt) : null;
+    patch.updatedAt = /* @__PURE__ */ new Date();
+    const [row] = await this.db.update(workplanSchedules).set(patch).where(eq(workplanSchedules.id, scheduleId)).returning();
+    return row ? toScheduleRecord(row) : null;
+  }
+  async deleteWorkplanSchedule(scheduleId) {
+    return await this.db.transaction(async (tx) => {
+      await tx.update(workplanRuns).set({ scheduleId: null }).where(eq(workplanRuns.scheduleId, scheduleId));
+      const deleted = await tx.delete(workplanSchedules).where(eq(workplanSchedules.id, scheduleId)).returning({ id: workplanSchedules.id });
+      return deleted.length > 0;
+    });
+  }
+  async listDueWorkplanSchedules(asOf) {
+    const asOfDate = new Date(asOf);
+    const rows = await this.db.select().from(workplanSchedules).where(and(
+      eq(workplanSchedules.enabled, true),
+      isNotNull(workplanSchedules.nextRunAt),
+      lte(workplanSchedules.nextRunAt, asOfDate)
+    )).orderBy(asc(workplanSchedules.nextRunAt));
+    return rows.map(toScheduleRecord);
+  }
+  async markWorkplanScheduleRan(scheduleId, lastRunAt, nextRunAt) {
+    await this.db.update(workplanSchedules).set({
+      lastRunAt: new Date(lastRunAt),
+      nextRunAt: new Date(nextRunAt),
+      updatedAt: sql2`now()`
+    }).where(eq(workplanSchedules.id, scheduleId));
+  }
+  async tryCreateWorkplanRun(input) {
+    try {
+      const [row] = await this.db.insert(workplanRuns).values({
+        id: makeId("wprun"),
+        scheduleId: input.scheduleId ?? null,
+        planId: input.planId,
+        planName: input.planName,
+        status: "running",
+        idempotencyKey: input.idempotencyKey ?? null
+      }).returning();
+      return toWorkplanRunRecord(row);
+    } catch (err) {
+      const code = err.code;
+      if (input.idempotencyKey && code === "23505") {
+        return null;
+      }
+      throw err;
+    }
+  }
+  async updateWorkplanRun(runId, status, error, endedAt) {
+    const [row] = await this.db.update(workplanRuns).set({
+      status,
+      error: error ?? null,
+      endedAt: endedAt ? new Date(endedAt) : status !== "running" ? /* @__PURE__ */ new Date() : null
+    }).where(eq(workplanRuns.id, runId)).returning();
+    return row ? toWorkplanRunRecord(row) : null;
+  }
+  async getWorkplanRun(runId) {
+    const [row] = await this.db.select().from(workplanRuns).where(eq(workplanRuns.id, runId));
+    return row ? toWorkplanRunRecord(row) : null;
+  }
+  async listWorkplanRuns(filters) {
+    const rows = await this.db.select().from(workplanRuns).where(filters?.scheduleId ? eq(workplanRuns.scheduleId, filters.scheduleId) : void 0).orderBy(desc(workplanRuns.createdAt)).limit(100);
+    return rows.map(toWorkplanRunRecord);
+  }
+  async appendWorkplanStepResults(runId, steps) {
+    if (steps.length === 0) return [];
+    const rows = await this.db.insert(workplanStepResults).values(
+      steps.map((step) => ({
+        id: makeId("wpstep"),
+        workplanRunId: runId,
+        stepId: step.stepId,
+        stepName: step.stepName,
+        output: step.output ?? null,
+        exitCode: step.exitCode ?? null,
+        durationMs: step.durationMs ?? null,
+        metadata: step.metadata ?? null
+      }))
+    ).returning();
+    return rows.map(toWorkplanStepResultRecord);
+  }
+  async listWorkplanStepResults(runId) {
+    const rows = await this.db.select().from(workplanStepResults).where(eq(workplanStepResults.workplanRunId, runId)).orderBy(asc(workplanStepResults.createdAt));
+    return rows.map(toWorkplanStepResultRecord);
+  }
 };
 
 // ../db/src/sqlite-store.ts
-import { and as and2, asc as asc2, desc as desc2, eq as eq2, gt as gt2 } from "drizzle-orm";
+import { and as and2, asc as asc2, desc as desc2, eq as eq2, gt as gt2, lte as lte2, sql as sql4 } from "drizzle-orm";
 
 // ../db/src/schema/sqlite.ts
 var sqlite_exports = {};
@@ -577,7 +883,10 @@ __export(sqlite_exports, {
   runInputEvents: () => runInputEvents2,
   runLogs: () => runLogs2,
   runs: () => runs2,
-  tasks: () => tasks2
+  tasks: () => tasks2,
+  workplanRuns: () => workplanRuns2,
+  workplanSchedules: () => workplanSchedules2,
+  workplanStepResults: () => workplanStepResults2
 });
 import { isNull as isNull2, sql as sql3 } from "drizzle-orm";
 import { index as index2, integer as integer2, sqliteTable, text as text2, uniqueIndex as uniqueIndex2 } from "drizzle-orm/sqlite-core";
@@ -639,6 +948,49 @@ var artifacts2 = sqliteTable("artifacts", {
 }, (table) => ({
   runIdIdx: index2("idx_artifacts_run_id").on(table.runId)
 }));
+var workplanSchedules2 = sqliteTable("workplan_schedules", {
+  id: text2("id").primaryKey(),
+  planId: text2("plan_id").notNull(),
+  name: text2("name").notNull(),
+  cronExpression: text2("cron_expression").notNull(),
+  timezone: text2("timezone").notNull(),
+  inputs: text2("inputs", { mode: "json" }).$type().notNull().default({}),
+  enabled: integer2("enabled", { mode: "boolean" }).notNull().default(true),
+  lastRunAt: text2("last_run_at"),
+  nextRunAt: text2("next_run_at"),
+  createdBy: text2("created_by"),
+  createdAt: text2("created_at").notNull().default(nowDefault),
+  updatedAt: text2("updated_at").notNull().default(nowDefault)
+}, (table) => ({
+  dueIdx: index2("idx_workplan_schedules_due").on(table.nextRunAt)
+}));
+var workplanRuns2 = sqliteTable("workplan_runs", {
+  id: text2("id").primaryKey(),
+  scheduleId: text2("schedule_id").references(() => workplanSchedules2.id),
+  planId: text2("plan_id").notNull(),
+  planName: text2("plan_name").notNull(),
+  status: text2("status").notNull().default("running"),
+  idempotencyKey: text2("idempotency_key"),
+  createdAt: text2("created_at").notNull().default(nowDefault),
+  endedAt: text2("ended_at"),
+  error: text2("error")
+}, (table) => ({
+  scheduleIdx: index2("idx_workplan_runs_schedule_id").on(table.scheduleId),
+  idempotencyUnique: uniqueIndex2("idx_workplan_runs_idempotency").on(table.idempotencyKey)
+}));
+var workplanStepResults2 = sqliteTable("workplan_step_results", {
+  id: text2("id").primaryKey(),
+  workplanRunId: text2("workplan_run_id").notNull().references(() => workplanRuns2.id),
+  stepId: text2("step_id").notNull(),
+  stepName: text2("step_name").notNull(),
+  output: text2("output"),
+  exitCode: integer2("exit_code"),
+  durationMs: integer2("duration_ms"),
+  metadata: text2("metadata", { mode: "json" }).$type(),
+  createdAt: text2("created_at").notNull().default(nowDefault)
+}, (table) => ({
+  runIdx: index2("idx_workplan_step_results_run_id").on(table.workplanRunId)
+}));
 var runInputEvents2 = sqliteTable("run_input_events", {
   id: integer2("id").primaryKey({ autoIncrement: true }),
   runId: text2("run_id").notNull().references(() => runs2.id),
@@ -721,7 +1073,49 @@ function toInputEventRecord2(row) {
     deliveredAt: row.deliveredAt ?? null
   };
 }
-function mapRawTask2(row) {
+function toScheduleRecord2(row) {
+  return {
+    id: row.id,
+    planId: row.planId,
+    name: row.name,
+    cronExpression: row.cronExpression,
+    timezone: row.timezone,
+    inputs: row.inputs ?? {},
+    enabled: row.enabled,
+    lastRunAt: row.lastRunAt ?? null,
+    nextRunAt: row.nextRunAt ?? null,
+    createdBy: row.createdBy ?? null,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+function toWorkplanRunRecord2(row) {
+  return {
+    id: row.id,
+    scheduleId: row.scheduleId ?? null,
+    planId: row.planId,
+    planName: row.planName,
+    status: row.status,
+    idempotencyKey: row.idempotencyKey ?? null,
+    createdAt: row.createdAt,
+    endedAt: row.endedAt ?? null,
+    error: row.error ?? null
+  };
+}
+function toWorkplanStepResultRecord2(row) {
+  return {
+    id: row.id,
+    workplanRunId: row.workplanRunId,
+    stepId: row.stepId,
+    stepName: row.stepName,
+    output: row.output ?? null,
+    exitCode: row.exitCode ?? null,
+    durationMs: row.durationMs ?? null,
+    metadata: row.metadata ?? null,
+    createdAt: row.createdAt
+  };
+}
+function mapRawTask(row) {
   return {
     id: row.id,
     kind: row.kind,
@@ -829,7 +1223,7 @@ var SqliteStore = class {
       ).run(runId, task.id, nodeId, max_attempt + 1, now, now, now);
       raw.prepare("UPDATE tasks SET status = 'assigned', updated_at = ? WHERE id = ?").run(now, task.id);
       return {
-        task: mapRawTask2(task),
+        task: mapRawTask(task),
         run: mapRawRun2(raw.prepare("SELECT * FROM runs WHERE id = ?").get(runId))
       };
     })();
@@ -925,7 +1319,7 @@ var SqliteStore = class {
         }
       }
       raw.prepare("UPDATE tasks SET status = 'cancelled', updated_at = ? WHERE id = ?").run(now, taskId);
-      return mapRawTask2(raw.prepare("SELECT * FROM tasks WHERE id = ?").get(taskId));
+      return mapRawTask(raw.prepare("SELECT * FROM tasks WHERE id = ?").get(taskId));
     })();
   }
   async appendInputEvent(runId, input) {
@@ -959,6 +1353,119 @@ var SqliteStore = class {
   async markInputDelivered(runId, sequence) {
     await this.db.update(runInputEvents2).set({ deliveredAt: nowIso() }).where(and2(eq2(runInputEvents2.runId, runId), eq2(runInputEvents2.sequence, sequence)));
   }
+  async createWorkplanSchedule(input) {
+    const now = nowIso();
+    const [row] = await this.db.insert(workplanSchedules2).values({
+      id: makeId("sched"),
+      planId: input.planId,
+      name: input.name,
+      cronExpression: input.cronExpression,
+      timezone: input.timezone,
+      inputs: input.inputs ?? {},
+      enabled: input.enabled ?? true,
+      nextRunAt: input.enabled === false ? null : input.nextRunAt ?? null,
+      createdBy: input.createdBy ?? null,
+      createdAt: now,
+      updatedAt: now
+    }).returning();
+    return toScheduleRecord2(row);
+  }
+  async listWorkplanSchedules(enabled) {
+    const rows = await this.db.select().from(workplanSchedules2).where(enabled === void 0 ? void 0 : eq2(workplanSchedules2.enabled, enabled)).orderBy(desc2(workplanSchedules2.createdAt));
+    return rows.map(toScheduleRecord2);
+  }
+  async getWorkplanSchedule(scheduleId) {
+    const [row] = await this.db.select().from(workplanSchedules2).where(eq2(workplanSchedules2.id, scheduleId));
+    return row ? toScheduleRecord2(row) : null;
+  }
+  async updateWorkplanSchedule(scheduleId, input) {
+    const patch = { updatedAt: nowIso() };
+    if (input.name !== void 0) patch.name = input.name;
+    if (input.cronExpression !== void 0) patch.cronExpression = input.cronExpression;
+    if (input.timezone !== void 0) patch.timezone = input.timezone;
+    if (input.inputs !== void 0) patch.inputs = input.inputs;
+    if (input.enabled !== void 0) patch.enabled = input.enabled;
+    if (input.nextRunAt !== void 0) patch.nextRunAt = input.nextRunAt;
+    const [row] = await this.db.update(workplanSchedules2).set(patch).where(eq2(workplanSchedules2.id, scheduleId)).returning();
+    return row ? toScheduleRecord2(row) : null;
+  }
+  async deleteWorkplanSchedule(scheduleId) {
+    const raw = this.db.$client;
+    return raw.transaction(() => {
+      raw.prepare("UPDATE workplan_runs SET schedule_id = NULL WHERE schedule_id = ?").run(scheduleId);
+      const result = raw.prepare("DELETE FROM workplan_schedules WHERE id = ?").run(scheduleId);
+      return (result.changes ?? 0) > 0;
+    })();
+  }
+  async listDueWorkplanSchedules(asOf) {
+    const rows = await this.db.select().from(workplanSchedules2).where(and2(
+      eq2(workplanSchedules2.enabled, true),
+      sql4`${workplanSchedules2.nextRunAt} IS NOT NULL`,
+      lte2(workplanSchedules2.nextRunAt, asOf)
+    )).orderBy(asc2(workplanSchedules2.nextRunAt));
+    return rows.map(toScheduleRecord2);
+  }
+  async markWorkplanScheduleRan(scheduleId, lastRunAt, nextRunAt) {
+    await this.db.update(workplanSchedules2).set({ lastRunAt, nextRunAt, updatedAt: nowIso() }).where(eq2(workplanSchedules2.id, scheduleId));
+  }
+  async tryCreateWorkplanRun(input) {
+    const now = nowIso();
+    try {
+      const [row] = await this.db.insert(workplanRuns2).values({
+        id: makeId("wprun"),
+        scheduleId: input.scheduleId ?? null,
+        planId: input.planId,
+        planName: input.planName,
+        status: "running",
+        idempotencyKey: input.idempotencyKey ?? null,
+        createdAt: now
+      }).returning();
+      return toWorkplanRunRecord2(row);
+    } catch (err) {
+      if (input.idempotencyKey && err instanceof Error && err.message.includes("UNIQUE constraint failed")) {
+        return null;
+      }
+      throw err;
+    }
+  }
+  async updateWorkplanRun(runId, status, error, endedAt) {
+    const [row] = await this.db.update(workplanRuns2).set({
+      status,
+      error: error ?? null,
+      endedAt: endedAt ?? (status !== "running" ? nowIso() : null)
+    }).where(eq2(workplanRuns2.id, runId)).returning();
+    return row ? toWorkplanRunRecord2(row) : null;
+  }
+  async getWorkplanRun(runId) {
+    const [row] = await this.db.select().from(workplanRuns2).where(eq2(workplanRuns2.id, runId));
+    return row ? toWorkplanRunRecord2(row) : null;
+  }
+  async listWorkplanRuns(filters) {
+    const rows = await this.db.select().from(workplanRuns2).where(filters?.scheduleId ? eq2(workplanRuns2.scheduleId, filters.scheduleId) : void 0).orderBy(desc2(workplanRuns2.createdAt)).limit(100);
+    return rows.map(toWorkplanRunRecord2);
+  }
+  async appendWorkplanStepResults(runId, steps) {
+    if (steps.length === 0) return [];
+    const now = nowIso();
+    const rows = await this.db.insert(workplanStepResults2).values(
+      steps.map((step) => ({
+        id: makeId("wpstep"),
+        workplanRunId: runId,
+        stepId: step.stepId,
+        stepName: step.stepName,
+        output: step.output ?? null,
+        exitCode: step.exitCode ?? null,
+        durationMs: step.durationMs ?? null,
+        metadata: step.metadata ?? null,
+        createdAt: now
+      }))
+    ).returning();
+    return rows.map(toWorkplanStepResultRecord2);
+  }
+  async listWorkplanStepResults(runId) {
+    const rows = await this.db.select().from(workplanStepResults2).where(eq2(workplanStepResults2.workplanRunId, runId)).orderBy(asc2(workplanStepResults2.createdAt));
+    return rows.map(toWorkplanStepResultRecord2);
+  }
 };
 
 // ../db/src/client.ts
@@ -1125,6 +1632,497 @@ function validateInputEvent(input) {
   return inputEventSchema.parse(input);
 }
 
+// ../server/src/schedule-validation.ts
+import { z as z3 } from "zod";
+var createScheduleSchema = z3.object({
+  planId: z3.string().min(1),
+  name: z3.string().min(1),
+  cronExpression: z3.string().min(1),
+  timezone: z3.string().min(1),
+  inputs: z3.record(z3.unknown()).optional(),
+  enabled: z3.boolean().optional()
+});
+var updateScheduleSchema = z3.object({
+  name: z3.string().min(1).optional(),
+  cronExpression: z3.string().min(1).optional(),
+  timezone: z3.string().min(1).optional(),
+  inputs: z3.record(z3.unknown()).optional(),
+  enabled: z3.boolean().optional()
+});
+function validateCreateSchedule(body) {
+  return createScheduleSchema.parse(body);
+}
+function validateUpdateSchedule(body) {
+  return updateScheduleSchema.parse(body);
+}
+
+// ../agent-skills/src/skills/code-review.ts
+function codeReviewPlan(opts = {}) {
+  const { repoPath = ".", model = "claude-haiku-4-5-20251001", branch } = opts;
+  const diffCmd = branch ? `git diff ${branch}..HEAD` : "git diff HEAD~1";
+  return {
+    id: "code-review",
+    name: "Code Review",
+    steps: [
+      {
+        id: "diff",
+        name: "Git Diff",
+        adapter: "shell",
+        provider: "shell",
+        payload: { command: diffCmd, cwd: repoPath },
+        output: { dest: "next" }
+      },
+      {
+        id: "summarize",
+        name: "Summarize",
+        adapter: "ollama",
+        provider: "ollama",
+        model: "llama3",
+        payload: { prompt: "Summarize these code changes concisely:\n{{prevOutput}}" },
+        output: { dest: "next" }
+      },
+      {
+        id: "critique",
+        name: "Critique",
+        adapter: "anthropic",
+        provider: "anthropic",
+        model,
+        payload: { prompt: "Review this summary for correctness, security issues, and code quality:\n{{prevOutput}}" }
+      }
+    ]
+  };
+}
+
+// ../agent-skills/src/skills/hello.ts
+function helloPlan(opts = {}) {
+  const message = opts.message ?? "hello from workplane";
+  return {
+    id: "hello",
+    name: "Hello",
+    description: "Single shell echo \u2014 useful for scheduler smoke tests",
+    steps: [
+      {
+        id: "echo",
+        name: "Echo",
+        adapter: "shell",
+        provider: "shell",
+        payload: { command: `echo ${JSON.stringify(message)}` }
+      }
+    ]
+  };
+}
+
+// ../agent-skills/src/skills/summarize-file.ts
+function summarizeFilePlan(opts) {
+  const { filePath, provider = "ollama", model = "llama3" } = opts;
+  return {
+    id: "summarize-file",
+    name: "Summarize File",
+    steps: [
+      {
+        id: "read",
+        name: "Read File",
+        adapter: "file",
+        provider: "file",
+        payload: { path: filePath },
+        output: { dest: "next" }
+      },
+      {
+        id: "summarize",
+        name: "Summarize",
+        adapter: provider,
+        provider,
+        model,
+        payload: { prompt: "Summarize the following file content concisely:\n{{prevOutput}}" }
+      }
+    ]
+  };
+}
+
+// ../agent-skills/src/skills/index.ts
+var SkillRegistry = class {
+  skills = /* @__PURE__ */ new Map();
+  register(entry) {
+    this.skills.set(entry.name, entry);
+  }
+  get(name) {
+    return this.skills.get(name);
+  }
+  list() {
+    return Array.from(this.skills.values());
+  }
+};
+function createDefaultRegistry() {
+  const registry = new SkillRegistry();
+  registry.register({
+    name: "hello",
+    description: "Shell echo (scheduler smoke test)",
+    buildPlan: (opts) => helloPlan({
+      message: typeof opts.message === "string" ? opts.message : void 0
+    })
+  });
+  registry.register({
+    name: "code-review",
+    description: "Git diff \u2192 local summarize (ollama) \u2192 frontier critique (anthropic)",
+    buildPlan: (opts) => codeReviewPlan({
+      repoPath: typeof opts.repo === "string" ? opts.repo : void 0,
+      model: typeof opts.model === "string" ? opts.model : void 0,
+      branch: typeof opts.branch === "string" ? opts.branch : void 0
+    })
+  });
+  registry.register({
+    name: "summarize-file",
+    description: "Read file \u2192 summarize with configurable provider (default: ollama)",
+    buildPlan: (opts) => {
+      const filePath = typeof opts.file === "string" ? opts.file : "";
+      if (!filePath) throw new Error("--file is required for summarize-file");
+      return summarizeFilePlan({
+        filePath,
+        provider: typeof opts.provider === "string" ? opts.provider : void 0,
+        model: typeof opts.model === "string" ? opts.model : void 0
+      });
+    }
+  });
+  return registry;
+}
+
+// ../workplans/src/sinks/stdout.ts
+function printStepResult(stepName, output) {
+  process.stdout.write(`=== step: ${stepName} ===
+${output}
+
+`);
+}
+
+// ../workplans/src/context.ts
+var WorkplaneNodeHandle = class {
+  constructor(serverUrl, nodeToken) {
+    this.serverUrl = serverUrl;
+    this.nodeToken = nodeToken;
+  }
+  serverUrl;
+  nodeToken;
+  async execute(step) {
+    const start = Date.now();
+    const taskRes = await fetch(`${this.serverUrl}/tasks`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${this.nodeToken}`
+      },
+      body: JSON.stringify({
+        kind: "workplan.step",
+        adapter: step.adapter,
+        payload: step.payload,
+        requires: step.requires ?? []
+      })
+    });
+    if (!taskRes.ok) {
+      throw new Error(`failed to submit step ${step.id}: ${taskRes.status}`);
+    }
+    const task = await taskRes.json();
+    const output = await this.pollUntilDone(task.id);
+    return { stepId: step.id, output, exitCode: 0, durationMs: Date.now() - start };
+  }
+  async pollUntilDone(taskId) {
+    const terminalStatuses = /* @__PURE__ */ new Set(["succeeded", "failed", "cancelled"]);
+    for (; ; ) {
+      await new Promise((r) => setTimeout(r, 1e3));
+      const res = await fetch(`${this.serverUrl}/tasks/${taskId}`, {
+        headers: { authorization: `Bearer ${this.nodeToken}` }
+      });
+      const task = await res.json();
+      if (terminalStatuses.has(task.status)) {
+        if (task.status !== "succeeded") {
+          throw new Error(`step task ${taskId} ended with status: ${task.status}`);
+        }
+        return typeof task.payload?.output === "string" ? task.payload.output : "";
+      }
+    }
+  }
+};
+var LocalWorkplanContext = class {
+  serverUrl;
+  nodeToken;
+  constructor(opts = {}) {
+    this.serverUrl = opts.serverUrl ?? process.env.WORKPLANE_SERVER_URL ?? "http://localhost:8787";
+    this.nodeToken = opts.nodeToken ?? process.env.WORKPLANE_NODE_TOKEN ?? "";
+  }
+  async resolveNode(_requires, _provider) {
+    return new WorkplaneNodeHandle(this.serverUrl, this.nodeToken);
+  }
+  emitResult(_stepId, stepName, output) {
+    printStepResult(stepName, output);
+  }
+};
+
+// ../workplans/src/template.ts
+function applyTemplate(payload, prevOutput) {
+  return Object.fromEntries(
+    Object.entries(payload).map(([k, v]) => [
+      k,
+      typeof v === "string" ? v.replaceAll("{{prevOutput}}", prevOutput) : v
+    ])
+  );
+}
+
+// ../workplans/src/runner.ts
+var INLINE_PROVIDERS = /* @__PURE__ */ new Set(["anthropic", "openai", "ollama", "shell", "file"]);
+async function runInlineStep(step, prompt) {
+  const provider = step.provider;
+  if (provider === "anthropic") {
+    const { runAnthropicStep: runAnthropicStep2 } = await Promise.resolve().then(() => (init_anthropic(), anthropic_exports));
+    return runAnthropicStep2({ model: step.model ?? "claude-haiku-4-5-20251001", prompt });
+  }
+  if (provider === "openai") {
+    const { runOpenAIStep: runOpenAIStep2 } = await Promise.resolve().then(() => (init_openai(), openai_exports));
+    return runOpenAIStep2({ model: step.model ?? "gpt-4o-mini", prompt });
+  }
+  if (provider === "ollama") {
+    const { runOllamaStep: runOllamaStep2 } = await Promise.resolve().then(() => (init_ollama(), ollama_exports));
+    return runOllamaStep2({ model: step.model ?? "llama3", prompt });
+  }
+  if (provider === "shell") {
+    const { runShellStep: runShellStep2 } = await Promise.resolve().then(() => (init_shell(), shell_exports));
+    return runShellStep2({
+      command: String(step.payload.command ?? ""),
+      cwd: typeof step.payload.cwd === "string" ? step.payload.cwd : void 0
+    });
+  }
+  if (provider === "file") {
+    const { runFileStep: runFileStep2 } = await Promise.resolve().then(() => (init_file(), file_exports));
+    return runFileStep2({ path: String(step.payload.path ?? "") });
+  }
+  throw new Error(`unknown inline provider: ${provider}`);
+}
+var SequentialWorkplanRunner = class {
+  async run(plan, ctx) {
+    const results = [];
+    let prevOutput = "";
+    let planSucceeded = true;
+    for (const step of plan.steps) {
+      const payload = prevOutput ? applyTemplate(step.payload, prevOutput) : step.payload;
+      const prompt = typeof payload.prompt === "string" ? payload.prompt : "";
+      const start = Date.now();
+      let output = "";
+      let exitCode = 0;
+      try {
+        if (step.provider && INLINE_PROVIDERS.has(step.provider)) {
+          output = await runInlineStep({ ...step, payload }, prompt);
+        } else {
+          const node = await ctx.resolveNode(step.requires ?? [], step.provider);
+          const result = await node.execute({ ...step, payload });
+          output = result.output;
+          exitCode = result.exitCode;
+        }
+      } catch (err) {
+        exitCode = 1;
+        output = err instanceof Error ? err.message : String(err);
+        planSucceeded = false;
+        const stepResult2 = {
+          stepId: step.id,
+          output,
+          exitCode,
+          durationMs: Date.now() - start
+        };
+        results.push(stepResult2);
+        ctx.emitResult(step.id, step.name, output);
+        if (!step.continueOnError) {
+          return {
+            planId: plan.id,
+            status: "step_failed",
+            steps: results,
+            succeeded: false
+          };
+        }
+        prevOutput = "";
+        continue;
+      }
+      const dest = step.output?.dest ?? "stdout";
+      const stepResult = {
+        stepId: step.id,
+        output,
+        exitCode,
+        durationMs: Date.now() - start
+      };
+      results.push(stepResult);
+      if (dest === "stdout" || dest === "artifact") {
+        ctx.emitResult(step.id, step.name, output);
+        prevOutput = "";
+      } else if (dest === "next") {
+        prevOutput = output;
+      }
+    }
+    return {
+      planId: plan.id,
+      status: planSucceeded ? "completed" : "failed",
+      steps: results,
+      succeeded: planSucceeded
+    };
+  }
+};
+
+// ../workplans/src/schedule-builder.ts
+import { CronExpressionParser } from "cron-parser";
+var ScheduleBuilder = class _ScheduleBuilder {
+  static nextRunAt(cronExpression, timezone) {
+    const expr = CronExpressionParser.parse(cronExpression, { tz: timezone });
+    return expr.next().toISOString() ?? (/* @__PURE__ */ new Date()).toISOString();
+  }
+  static withNextRunAt(schedule) {
+    return {
+      ...schedule,
+      nextRunAt: _ScheduleBuilder.nextRunAt(schedule.cronExpression, schedule.timezone)
+    };
+  }
+};
+
+// ../workplans/src/scheduler.ts
+var WorkplanScheduler = class {
+  constructor(store, resolver, contextFactory, runner = new SequentialWorkplanRunner()) {
+    this.store = store;
+    this.resolver = resolver;
+    this.contextFactory = contextFactory;
+    this.runner = runner;
+  }
+  store;
+  resolver;
+  contextFactory;
+  runner;
+  async tick(now = /* @__PURE__ */ new Date()) {
+    const due = await this.store.listDueWorkplanSchedules(now.toISOString());
+    const launched = [];
+    for (const schedule of due) {
+      if (!schedule.nextRunAt) {
+        continue;
+      }
+      const run = await this.executeSchedule(schedule, {
+        scheduledTime: schedule.nextRunAt,
+        advanceSchedule: true
+      });
+      if (run) {
+        launched.push(run);
+      }
+    }
+    return launched;
+  }
+  async runNow(scheduleId) {
+    const schedule = await this.store.getWorkplanSchedule(scheduleId);
+    if (!schedule) {
+      return null;
+    }
+    return this.executeSchedule(schedule, {
+      scheduledTime: (/* @__PURE__ */ new Date()).toISOString(),
+      advanceSchedule: false
+    });
+  }
+  async executeSchedule(schedule, options) {
+    const idempotencyKey = options.idempotencyKey ?? (options.advanceSchedule ? `${schedule.id}:${options.scheduledTime}` : void 0);
+    const run = await this.store.tryCreateWorkplanRun({
+      scheduleId: schedule.id,
+      planId: schedule.planId,
+      planName: schedule.name,
+      idempotencyKey
+    });
+    if (!run) {
+      return null;
+    }
+    if (options.advanceSchedule) {
+      const nextRunAt = ScheduleBuilder.nextRunAt(schedule.cronExpression, schedule.timezone);
+      await this.store.markWorkplanScheduleRan(schedule.id, options.scheduledTime, nextRunAt);
+    }
+    try {
+      const plan = this.resolver.resolve(schedule.planId, schedule.inputs);
+      const result = await this.runner.run(plan, this.contextFactory());
+      const stepNames = new Map(plan.steps.map((step) => [step.id, step.name]));
+      const stepInputs = result.steps.map((step) => ({
+        stepId: step.stepId,
+        stepName: stepNames.get(step.stepId) ?? step.stepId,
+        output: step.output,
+        exitCode: step.exitCode,
+        durationMs: step.durationMs,
+        metadata: step.metadata
+      }));
+      await this.store.appendWorkplanStepResults(run.id, stepInputs);
+      const error = result.succeeded ? void 0 : result.steps.at(-1)?.output;
+      return await this.store.updateWorkplanRun(run.id, result.status, error);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return await this.store.updateWorkplanRun(run.id, "failed", message);
+    }
+  }
+};
+
+// ../server/src/schedule-service.ts
+var skillRegistry = createDefaultRegistry();
+function createWorkplanScheduler(store) {
+  return new WorkplanScheduler(
+    store,
+    {
+      resolve(planId, inputs) {
+        const skill = skillRegistry.get(planId);
+        if (!skill) {
+          throw new Error(`unknown workplan skill: ${planId}`);
+        }
+        return skill.buildPlan(inputs);
+      }
+    },
+    () => new LocalWorkplanContext()
+  );
+}
+function withScheduleTiming(input) {
+  if (input.enabled === false) {
+    return { ...input, nextRunAt: null };
+  }
+  return {
+    ...input,
+    nextRunAt: ScheduleBuilder.nextRunAt(input.cronExpression, input.timezone)
+  };
+}
+function withUpdatedScheduleTiming(current, input) {
+  const cronExpression = input.cronExpression ?? current.cronExpression;
+  const timezone = input.timezone ?? current.timezone;
+  const enabled = input.enabled ?? current.enabled;
+  if (!enabled) {
+    return { ...input, nextRunAt: null };
+  }
+  if (input.cronExpression !== void 0 || input.timezone !== void 0 || input.enabled === true) {
+    return {
+      ...input,
+      nextRunAt: ScheduleBuilder.nextRunAt(cronExpression, timezone)
+    };
+  }
+  return input;
+}
+function isSchedulerEnabled() {
+  return process.env.WORKPLANE_SCHEDULER_ENABLED !== "false";
+}
+function schedulerIntervalMs() {
+  const raw = process.env.WORKPLANE_SCHEDULER_INTERVAL_MS;
+  const parsed = raw ? Number(raw) : 6e4;
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 6e4;
+}
+function startSchedulerLoop(scheduler) {
+  const intervalMs = schedulerIntervalMs();
+  const timer = setInterval(() => {
+    void scheduler.tick().catch((error) => {
+      process.stderr.write(`workplan scheduler tick failed: ${String(error)}
+`);
+    });
+  }, intervalMs);
+  timer.unref();
+  void scheduler.tick().catch((error) => {
+    process.stderr.write(`workplan scheduler initial tick failed: ${String(error)}
+`);
+  });
+  process.stdout.write(`workplan scheduler enabled (interval ${intervalMs}ms)
+`);
+  return () => clearInterval(timer);
+}
+function listKnownPlanIds() {
+  return skillRegistry.list().map((skill) => skill.name);
+}
+
 // ../core/src/auth.ts
 function parseBearerToken(authorizationHeader) {
   if (!authorizationHeader) {
@@ -1211,6 +2209,21 @@ function routeAuthFor(method, pathname) {
   if (method === "POST" && /^\/tasks\/[^/]+\/cancel$/.test(pathname)) {
     return "operator";
   }
+  if (method === "POST" && pathname === "/schedules") {
+    return "operator";
+  }
+  if (method === "PATCH" && /^\/schedules\/[^/]+$/.test(pathname)) {
+    return "operator";
+  }
+  if (method === "DELETE" && /^\/schedules\/[^/]+$/.test(pathname)) {
+    return "operator";
+  }
+  if (method === "POST" && /^\/schedules\/[^/]+\/run$/.test(pathname)) {
+    return "operator";
+  }
+  if (method === "POST" && pathname === "/schedules/tick") {
+    return "operator";
+  }
   return "public";
 }
 function requiresConfiguredToken(auth, config) {
@@ -1266,7 +2279,17 @@ async function buildWorkflows(store, config) {
 async function main() {
   const config = loadServerConfig();
   const { store, close: closeStore } = createStore(config.databaseUrl);
+  const scheduler = createWorkplanScheduler(store);
+  if (process.env.WORKPLANE_USE_DBOS === "true" && isSchedulerEnabled()) {
+    const { registerDbosSchedulerTick: registerDbosSchedulerTick2 } = await Promise.resolve().then(() => (init_scheduler(), scheduler_exports));
+    registerDbosSchedulerTick2(scheduler);
+  }
   const { workflows, shutdown: shutdownWorkflows } = await buildWorkflows(store, config);
+  let stopSchedulerLoop = () => {
+  };
+  if (process.env.WORKPLANE_USE_DBOS !== "true" && isSchedulerEnabled()) {
+    stopSchedulerLoop = startSchedulerLoop(scheduler);
+  }
   const server = createServer(async (req, res) => {
     try {
       if (!req.url || !req.method) {
@@ -1430,6 +2453,114 @@ async function main() {
         writeJson(res, 200, { ok: true });
         return;
       }
+      if (req.method === "GET" && url.pathname === "/plans") {
+        writeJson(res, 200, { plans: listKnownPlanIds() });
+        return;
+      }
+      if (req.method === "POST" && url.pathname === "/schedules") {
+        const body = await readJson(req);
+        const validated = validateCreateSchedule(body);
+        if (!listKnownPlanIds().includes(validated.planId)) {
+          writeJson(res, 400, {
+            error: `unknown planId: ${validated.planId}`,
+            availablePlans: listKnownPlanIds()
+          });
+          return;
+        }
+        const schedule = await store.createWorkplanSchedule(withScheduleTiming(validated));
+        writeJson(res, 201, schedule);
+        return;
+      }
+      if (req.method === "GET" && url.pathname === "/schedules") {
+        const enabledParam = url.searchParams.get("enabled");
+        const enabled = enabledParam === null ? void 0 : enabledParam === "true";
+        const schedules = await store.listWorkplanSchedules(enabled);
+        writeJson(res, 200, { schedules });
+        return;
+      }
+      if (req.method === "GET" && /^\/schedules\/[^/]+$/.test(url.pathname)) {
+        const scheduleId = url.pathname.split("/")[2];
+        const schedule = await store.getWorkplanSchedule(scheduleId);
+        if (!schedule) {
+          writeJson(res, 404, { error: "schedule not found" });
+          return;
+        }
+        writeJson(res, 200, schedule);
+        return;
+      }
+      if (req.method === "PATCH" && /^\/schedules\/[^/]+$/.test(url.pathname)) {
+        const scheduleId = url.pathname.split("/")[2];
+        const existing = await store.getWorkplanSchedule(scheduleId);
+        if (!existing) {
+          writeJson(res, 404, { error: "schedule not found" });
+          return;
+        }
+        const body = await readJson(req);
+        const validated = validateUpdateSchedule(body);
+        const schedule = await store.updateWorkplanSchedule(
+          scheduleId,
+          withUpdatedScheduleTiming(existing, validated)
+        );
+        writeJson(res, 200, schedule);
+        return;
+      }
+      if (req.method === "DELETE" && /^\/schedules\/[^/]+$/.test(url.pathname)) {
+        const scheduleId = url.pathname.split("/")[2];
+        const deleted = await store.deleteWorkplanSchedule(scheduleId);
+        if (!deleted) {
+          writeJson(res, 404, { error: "schedule not found" });
+          return;
+        }
+        writeJson(res, 200, { ok: true });
+        return;
+      }
+      if (req.method === "POST" && /^\/schedules\/[^/]+\/run$/.test(url.pathname)) {
+        const scheduleId = url.pathname.split("/")[2];
+        const schedule = await store.getWorkplanSchedule(scheduleId);
+        if (!schedule) {
+          writeJson(res, 404, { error: "schedule not found" });
+          return;
+        }
+        const run = await scheduler.runNow(scheduleId);
+        if (!run) {
+          writeJson(res, 500, { error: "failed to start workplan run" });
+          return;
+        }
+        writeJson(res, 201, run);
+        return;
+      }
+      if (req.method === "POST" && url.pathname === "/schedules/tick") {
+        const runs3 = await scheduler.tick();
+        writeJson(res, 200, { runs: runs3 });
+        return;
+      }
+      if (req.method === "GET" && url.pathname === "/workplan-runs") {
+        const scheduleId = url.searchParams.get("scheduleId") ?? void 0;
+        const runs3 = await store.listWorkplanRuns(scheduleId ? { scheduleId } : void 0);
+        writeJson(res, 200, { runs: runs3 });
+        return;
+      }
+      if (req.method === "GET" && /^\/workplan-runs\/[^/]+\/steps$/.test(url.pathname)) {
+        const runId = url.pathname.split("/")[2];
+        const run = await store.getWorkplanRun(runId);
+        if (!run) {
+          writeJson(res, 404, { error: "workplan run not found" });
+          return;
+        }
+        const steps = await store.listWorkplanStepResults(runId);
+        writeJson(res, 200, { steps });
+        return;
+      }
+      if (req.method === "GET" && /^\/workplan-runs\/[^/]+$/.test(url.pathname)) {
+        const runId = url.pathname.split("/")[2];
+        const run = await store.getWorkplanRun(runId);
+        if (!run) {
+          writeJson(res, 404, { error: "workplan run not found" });
+          return;
+        }
+        writeJson(res, 200, run);
+        return;
+      }
       writeJson(res, 404, { error: "not found" });
     } catch (error) {
       if (error instanceof ZodError) {
@@ -1449,6 +2580,7 @@ async function main() {
 `);
   });
   const shutdown = async () => {
+    stopSchedulerLoop();
     await shutdownWorkflows();
     await closeStore();
     server.close();