@saadnvd1/agent-os 0.3.534 → 0.3.535

package/README.md

@@ -969,8 +969,12 @@ name, a time (presets for hourly, daily, weekdays and weekly, or any
 five-field cron expression, in America/Chicago unless you pick another zone),
 a project and a prompt, and starts one of:
 
-- **Task**: a background task that ends in a pull request, as above.
-- **Session**: a chat session in the project that runs the prompt and stays.
+- **Task** and **Session**: now recipes (Settings > Recipes) with a timer.
+  Migration 81 turned each existing recurring task or session schedule into a
+  recipe, with its run history; the Schedules form no longer offers them. A
+  one-off that still has one of these kinds is left as it was. To undo the
+  move, stop AgentOS and run
+  `npx tsx scripts/revert-schedules-move.ts --db <path to agent-os.db>`.
 - **Orchestrator**: the prompt, posted to the workspace's orchestrator as a
   message from "Schedule <name>", marked as a scheduled prompt so it never
   counts as an approval.

package/components/Schedules/ScheduleForm.tsx

@@ -34,6 +34,7 @@ import {
   wall,
   type PresetKind,
 } from "@/lib/schedules/cron";
+import { recipesUiActions } from "@/stores/recipesUi";
 import { parseWhen, relativeTime } from "@/lib/schedules/when";
 
 const KINDS: { value: ScheduleKind; label: string; hint: string }[] = [
@@ -59,6 +60,10 @@ const KINDS: { value: ScheduleKind; label: string; hint: string }[] = [
   },
 ];
 
+// New jobs of these shapes are recipes; the kinds stay only to edit a
+// schedule that still has one (a one-off, say).
+const LEGACY_KINDS: ScheduleKind[] = ["task", "session"];
+
 type Preset = PresetKind | "custom" | "once";
 
 const PRESETS: { value: Preset; label: string }[] = [
@@ -171,7 +176,7 @@ export function ScheduleForm({
   );
   const [name, setName] = useState(existing?.name ?? draft?.name ?? "");
   const [kind, setKind] = useState<ScheduleKind>(
-    existing?.kind ?? draft?.kind ?? "task"
+    existing?.kind ?? draft?.kind ?? "orchestrator"
   );
   const [targetId, setTargetId] = useState(
     existing?.target_session_id ?? draft?.targetSessionId ?? ""
@@ -329,7 +334,9 @@ export function ScheduleForm({
         <Segmented
           label="What it starts"
           value={kind}
-          options={KINDS}
+          options={KINDS.filter(
+            (k) => !LEGACY_KINDS.includes(k.value) || existing?.kind === k.value
+          )}
           onChange={(k) => {
             setKind(k);
             if (preset === "every" && !frequent(k)) setPreset("daily");
@@ -338,6 +345,17 @@ export function ScheduleForm({
         <p className="text-muted-foreground text-xs">
           {KINDS.find((k) => k.value === kind)?.hint}
         </p>
+        <p className="text-muted-foreground text-xs">
+          To start a task or session on a timer, use a{" "}
+          <button
+            type="button"
+            className="text-foreground underline underline-offset-2"
+            onClick={() => recipesUiActions.open(workspaceId ?? null)}
+          >
+            recipe
+          </button>
+          .
+        </p>
       </Field>
 
       {!workspaceId && (

package/lib/db/migrations.ts

@@ -8,6 +8,7 @@ import {
   TABLES_WATCHED_80,
 } from "./changes";
 import type Database from "better-sqlite3";
+import { moveSchedulesToRecipes } from "./schedules-move";
 
 interface Migration {
   id: number;
@@ -1957,6 +1958,21 @@ const migrations: Migration[] = [
       installChangeTriggers(db, TABLES_WATCHED_80);
     },
   },
+  {
+    id: 81,
+    name: "schedules_into_recipes",
+    up: (db) => {
+      // Live task and session schedules become recipes with a timer, and
+      // their runs become recipe runs (lib/db/schedules-move). Reversible:
+      // scripts/revert-schedules-move.ts.
+      const cols = (
+        db.prepare(`PRAGMA table_info(schedules)`).all() as { name: string }[]
+      ).map((c) => c.name);
+      if (!cols.includes("recipe_id") || !cols.includes("migrated_from_kind"))
+        throw new Error("migration 80 hasn't run");
+      moveSchedulesToRecipes(db);
+    },
+  },
 ];
 
 // `upTo`: stop after this id (tests that start from an older database).

package/lib/db/schedules-move.ts

@@ -0,0 +1,220 @@
+// Migration 81: live task and session schedules become recipes with a timer
+// (lib/recipes), and their runs become recipe runs. `migrated_from_kind` on
+// the schedule row is what makes it reversible: revertSchedulesMove.
+//
+// A one-off (run_at) and an archived schedule are left as they are: a timer
+// repeats, and history of archived ones stays where it was.
+
+import { randomUUID } from "crypto";
+import type Database from "better-sqlite3";
+
+interface ScheduleRow {
+  id: string;
+  workspace_id: string;
+  project_id: string | null;
+  name: string;
+  prompt: string;
+  kind: "task" | "session";
+  created_by_session_id: string | null;
+  created_at: string;
+}
+
+interface RunRow {
+  id: number;
+  trigger: string;
+  session_id: string;
+  created_at: string;
+  task_status: string | null;
+  pr_number: number | null;
+  pr_url: string | null;
+  session_exists: number;
+}
+
+const TRIGGER: Record<string, string> = {
+  schedule: "timer",
+  "catch-up": "catch-up",
+  manual: "manual",
+};
+
+const FINAL: Record<string, string> = {
+  merged: "succeeded",
+  done: "succeeded",
+  dropped: "failed",
+};
+
+// The name is unique among a workspace's live recipes, ignoring case.
+function freeName(
+  db: Database.Database,
+  workspaceId: string,
+  name: string
+): string {
+  const taken = db.prepare(
+    `SELECT 1 FROM recipes WHERE workspace_id = ? AND archived_at IS NULL AND name = ? COLLATE NOCASE`
+  );
+  if (!taken.get(workspaceId, name)) return name;
+  for (let n = 1; ; n++) {
+    const candidate = `${name} (schedule${n > 1 ? ` ${n}` : ""})`;
+    if (!taken.get(workspaceId, candidate)) return candidate;
+  }
+}
+
+export function moveSchedulesToRecipes(db: Database.Database): {
+  schedules: number;
+  runs: number;
+} {
+  const sessionCols = (
+    db.prepare(`PRAGMA table_info(sessions)`).all() as { name: string }[]
+  ).map((c) => c.name);
+  const pr = sessionCols.includes("pr_number")
+    ? "s.pr_number, s.pr_url"
+    : "NULL AS pr_number, NULL AS pr_url";
+  const hasTaskStatus = sessionCols.includes("task_status");
+
+  const schedules = db
+    .prepare(
+      `SELECT id, workspace_id, project_id, name, prompt, kind, created_by_session_id, created_at
+         FROM schedules
+        WHERE archived_at IS NULL AND kind IN ('task','session')
+          AND run_at IS NULL AND project_id IS NOT NULL
+        ORDER BY created_at, id`
+    )
+    .all() as ScheduleRow[];
+
+  const insertRecipe = db.prepare(
+    `INSERT INTO recipes (id, workspace_id, project_id, name, kind, brief, model, view, created_by_session_id, updated_by_session_id, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, NULL, 'chat', ?, ?, ?)`
+  );
+  const insertRevision = db.prepare(
+    `INSERT INTO recipe_revisions (recipe_id, brief, settings, edited_by_session_id) VALUES (?, ?, ?, ?)`
+  );
+  const switchSchedule = db.prepare(
+    `UPDATE schedules SET kind = 'recipe', recipe_id = ?, migrated_from_kind = ?, updated_at = datetime('now') WHERE id = ?`
+  );
+  const runsOf = db.prepare(
+    `SELECT r.id, r.trigger, r.session_id, r.created_at,
+            ${hasTaskStatus ? "s.task_status" : "NULL"} AS task_status, ${pr},
+            s.id IS NOT NULL AS session_exists
+       FROM schedule_runs r LEFT JOIN sessions s ON s.id = r.session_id
+      WHERE r.schedule_id = ? AND r.session_id IS NOT NULL
+      ORDER BY r.id`
+  );
+  const insertRun = db.prepare(
+    `INSERT INTO recipe_runs (recipe_id, seq, trigger, schedule_run_id, prompt, status, session_id, pr_number, pr_url, summary, started_at, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  );
+
+  let movedRuns = 0;
+  const move = db.transaction(() => {
+    for (const s of schedules) {
+      const recipeId = randomUUID();
+      insertRecipe.run(
+        recipeId,
+        s.workspace_id,
+        s.project_id,
+        freeName(db, s.workspace_id, s.name),
+        s.kind,
+        s.prompt,
+        s.created_by_session_id,
+        s.created_by_session_id,
+        s.created_at
+      );
+      insertRevision.run(
+        recipeId,
+        s.prompt,
+        JSON.stringify({
+          kind: s.kind,
+          model: null,
+          view: "chat",
+          auto_done: true,
+          max_minutes: null,
+        }),
+        s.created_by_session_id
+      );
+      switchSchedule.run(recipeId, s.kind, s.id);
+
+      const runs = runsOf.all(s.id) as RunRow[];
+      runs.forEach((r, i) => {
+        // One live run per recipe: only the latest may still be running
+        // (settle judges it); an earlier one with no recorded end is
+        // closed as cancelled rather than guessed a result.
+        const final = r.task_status ? FINAL[r.task_status] : undefined;
+        const last = i === runs.length - 1;
+        const status = final ?? (last ? "running" : "cancelled");
+        insertRun.run(
+          recipeId,
+          i + 1,
+          TRIGGER[r.trigger] ?? "timer",
+          r.id,
+          s.prompt,
+          status,
+          r.session_id,
+          r.pr_number,
+          r.pr_url,
+          status === "cancelled"
+            ? "Ran before recipes; its outcome wasn't recorded"
+            : null,
+          r.created_at,
+          r.created_at
+        );
+        movedRuns++;
+      });
+    }
+  });
+  move();
+  return { schedules: schedules.length, runs: movedRuns };
+}
+
+// Undo the move: each moved schedule gets its old kind (and the brief as it
+// stands now) back, and the recipes the move made go, with their runs and
+// revisions. The runs stay in schedule_runs, which the move never touched.
+// Migration 81 stays recorded as applied, so a restart doesn't redo it.
+export function revertSchedulesMove(db: Database.Database): {
+  schedules: number;
+} {
+  const moved = db
+    .prepare(
+      `SELECT id, recipe_id, migrated_from_kind FROM schedules WHERE migrated_from_kind IS NOT NULL`
+    )
+    .all() as {
+    id: string;
+    recipe_id: string | null;
+    migrated_from_kind: string;
+  }[];
+  const recipe = db.prepare(
+    `SELECT brief, project_id FROM recipes WHERE id = ?`
+  );
+  const restore = db.prepare(
+    `UPDATE schedules SET kind = ?, recipe_id = NULL, migrated_from_kind = NULL,
+       prompt = COALESCE(?, prompt), project_id = COALESCE(?, project_id), updated_at = datetime('now')
+     WHERE id = ?`
+  );
+  const drop = (table: string) =>
+    db.prepare(`DELETE FROM ${table} WHERE recipe_id = ?`);
+  const [dropRuns, dropRevisions] = [
+    drop("recipe_runs"),
+    drop("recipe_revisions"),
+  ];
+  const dropRecipe = db.prepare(`DELETE FROM recipes WHERE id = ?`);
+
+  db.transaction(() => {
+    for (const s of moved) {
+      const r = s.recipe_id
+        ? (recipe.get(s.recipe_id) as
+            | { brief: string; project_id: string }
+            | undefined)
+        : undefined;
+      restore.run(
+        s.migrated_from_kind,
+        r?.brief ?? null,
+        r?.project_id ?? null,
+        s.id
+      );
+      if (s.recipe_id) {
+        dropRuns.run(s.recipe_id);
+        dropRevisions.run(s.recipe_id);
+        dropRecipe.run(s.recipe_id);
+      }
+    }
+  })();
+  return { schedules: moved.length };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.534",
+  "version": "0.3.535",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"

package/scripts/revert-schedules-move.ts

@@ -0,0 +1,24 @@
+/**
+ * Undoes migration 81: schedules that became recipes get their old kind
+ * (task or session) and brief back, and the recipes the move made are
+ * removed with their runs. Stop AgentOS first; it reads the database too.
+ *
+ *   npx tsx scripts/revert-schedules-move.ts --db <path to agent-os.db>
+ *
+ * Migration 81 stays recorded as applied, so a restart won't redo the move.
+ */
+
+import Database from "better-sqlite3";
+import { revertSchedulesMove } from "../lib/db/schedules-move";
+
+const args = process.argv.slice(2);
+const dbPath = args[args.indexOf("--db") + 1];
+if (!args.includes("--db") || !dbPath || dbPath.startsWith("--")) {
+  console.error("usage: revert-schedules-move.ts --db <path>");
+  process.exit(2);
+}
+
+const db = new Database(dbPath, { fileMustExist: true, timeout: 10000 });
+const { schedules } = revertSchedulesMove(db);
+console.log(`Restored ${schedules} schedule(s) to their old kind.`);
+db.close();