@saadnvd1/agent-os 0.3.533 → 0.3.535

package/lib/db/migrations.ts

@@ -5,8 +5,10 @@ import {
   TABLES_WATCHED_56,
   TABLES_WATCHED_58,
   TABLES_WATCHED_78,
+  TABLES_WATCHED_80,
 } from "./changes";
 import type Database from "better-sqlite3";
+import { moveSchedulesToRecipes } from "./schedules-move";
 
 interface Migration {
   id: number;
@@ -1830,6 +1832,147 @@ const migrations: Migration[] = [
       if (!has) db.exec(`ALTER TABLE task_queue ADD COLUMN agent_type TEXT`);
     },
   },
+  {
+    id: 80,
+    name: "recipes",
+    up: (db) => {
+      // Recipes: a saved brief that starts a fresh task or session each run
+      // (lib/recipes), and the features a plan splits into pieces
+      // (lib/plans). All additive. A run or piece finds its session by
+      // session_id, so sessions gains no column.
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS recipes (
+          id TEXT PRIMARY KEY,
+          workspace_id TEXT NOT NULL,
+          project_id TEXT NOT NULL,
+          name TEXT NOT NULL,
+          kind TEXT NOT NULL,
+          brief TEXT NOT NULL,
+          model TEXT,
+          view TEXT NOT NULL DEFAULT 'chat',
+          auto_done INTEGER NOT NULL DEFAULT 1,
+          max_minutes INTEGER,
+          carry_cleared_at INTEGER,
+          source_session_id TEXT,
+          created_by_session_id TEXT,
+          updated_by_session_id TEXT,
+          archived_at TEXT,
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+        CREATE UNIQUE INDEX IF NOT EXISTS idx_recipes_name
+          ON recipes(workspace_id, name COLLATE NOCASE) WHERE archived_at IS NULL;
+
+        CREATE TABLE IF NOT EXISTS recipe_runs (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          recipe_id TEXT NOT NULL,
+          seq INTEGER NOT NULL,
+          trigger TEXT NOT NULL,
+          triggered_by_session_id TEXT,
+          schedule_run_id INTEGER,
+          request_id TEXT,
+          note TEXT,
+          prompt TEXT NOT NULL,
+          revision_id INTEGER,
+          status TEXT NOT NULL,
+          session_id TEXT,
+          pr_number INTEGER,
+          pr_url TEXT,
+          summary TEXT,
+          outputs TEXT,
+          summary_source TEXT,
+          error TEXT,
+          cost_usd REAL,
+          duration_ms INTEGER,
+          started_at TEXT,
+          ended_at TEXT,
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          UNIQUE (recipe_id, seq)
+        );
+        CREATE INDEX IF NOT EXISTS idx_recipe_runs_recipe
+          ON recipe_runs(recipe_id, id DESC);
+        CREATE INDEX IF NOT EXISTS idx_recipe_runs_session
+          ON recipe_runs(session_id);
+        CREATE UNIQUE INDEX IF NOT EXISTS idx_recipe_runs_one_live
+          ON recipe_runs(recipe_id)
+          WHERE status IN ('queued','starting','running');
+        CREATE UNIQUE INDEX IF NOT EXISTS idx_recipe_runs_request
+          ON recipe_runs(request_id) WHERE request_id IS NOT NULL;
+
+        CREATE TABLE IF NOT EXISTS recipe_revisions (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          recipe_id TEXT NOT NULL,
+          brief TEXT NOT NULL,
+          settings TEXT NOT NULL,
+          edited_by_session_id TEXT,
+          created_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+
+        CREATE TABLE IF NOT EXISTS features (
+          id TEXT PRIMARY KEY,
+          workspace_id TEXT NOT NULL,
+          name TEXT NOT NULL,
+          plan_session_id TEXT NOT NULL,
+          plan_text TEXT NOT NULL,
+          status TEXT NOT NULL,
+          done_at TEXT,
+          cost_usd REAL,
+          duration_ms INTEGER,
+          created_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+        CREATE INDEX IF NOT EXISTS idx_features_plan
+          ON features(plan_session_id);
+
+        CREATE TABLE IF NOT EXISTS feature_pieces (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          feature_id TEXT NOT NULL,
+          position INTEGER NOT NULL,
+          name TEXT NOT NULL,
+          slice TEXT NOT NULL,
+          project_id TEXT NOT NULL,
+          after_position INTEGER,
+          after_kind TEXT,
+          reasons TEXT,
+          owns TEXT,
+          status TEXT NOT NULL,
+          session_id TEXT,
+          note TEXT,
+          UNIQUE (feature_id, position)
+        );
+        CREATE INDEX IF NOT EXISTS idx_feature_pieces_session
+          ON feature_pieces(session_id);
+      `);
+      const cols = (
+        db.prepare(`PRAGMA table_info(schedules)`).all() as { name: string }[]
+      ).map((c) => c.name);
+      if (!cols.includes("recipe_id"))
+        db.exec(`ALTER TABLE schedules ADD COLUMN recipe_id TEXT`);
+      if (!cols.includes("migrated_from_kind"))
+        db.exec(`ALTER TABLE schedules ADD COLUMN migrated_from_kind TEXT`);
+      const plan = (
+        db.prepare(`PRAGMA table_info(sessions)`).all() as { name: string }[]
+      ).map((c) => c.name);
+      // Edits Saad made to a plan's pieces before approving it (merge, drop).
+      if (!plan.includes("plan_edits"))
+        db.exec(`ALTER TABLE sessions ADD COLUMN plan_edits TEXT`);
+      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/queries.ts

@@ -32,7 +32,10 @@ export function sessionListColumns(db: Database.Database, alias = ""): string {
     .split(",")
     .map((c) => `${prefix}${c}`)
     .join(", ");
-  return `${list}, (${prefix}task_brief IS NOT NULL AND ${prefix}task_brief != '') AS has_brief`;
+  // The recipe run or feature piece a session is, as JSON, for its row's chip.
+  const recipe = `(SELECT json_object('id', r.id, 'name', r.name, 'seq', rr.seq) FROM recipe_runs rr JOIN recipes r ON r.id = rr.recipe_id WHERE rr.session_id = ${alias || "sessions"}.id)`;
+  const piece = `(SELECT json_object('feature', f.id, 'name', f.name, 'position', fp.position, 'total', (SELECT COUNT(*) FROM feature_pieces WHERE feature_id = f.id AND status != 'dropped')) FROM feature_pieces fp JOIN features f ON f.id = fp.feature_id WHERE fp.session_id = ${alias || "sessions"}.id)`;
+  return `${list}, (${prefix}task_brief IS NOT NULL AND ${prefix}task_brief != '') AS has_brief, ${recipe} AS recipe_run, ${piece} AS feature_piece`;
 }
 
 export const queries = {

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/lib/db/types.ts

@@ -26,6 +26,8 @@ export interface Session {
   started_by?: string | null;
   // 1 planned, 0 no plan, null not stated; why, in the starter's words.
   plan_decided?: number | null;
+  // JSON: the pieces Saad merged or dropped before approving the plan.
+  plan_edits?: string | null;
   plan_reason?: string | null;
   system_prompt: string | null;
   group_path: string; // Deprecated - use project_id
@@ -55,6 +57,10 @@ export interface Session {
   task_brief?: string | null;
   // Lists carry this instead of the brief itself (0/1).
   has_brief?: number;
+  // JSON, in lists: the recipe run this session is ({id, name, seq}), and the
+  // feature piece it builds ({feature, name, position, total}).
+  recipe_run?: string | null;
+  feature_piece?: string | null;
   // How the session is shown: a chat conversation or a terminal.
   view: "chat" | "terminal";
   chat_access: ChatAccess;

package/lib/models/plan-step.ts

@@ -21,6 +21,8 @@ import { ANTHROPIC } from "./roles";
 import { queueEvent } from "../orchestrator/events";
 import { addNote } from "../orchestrator/notes";
 import { amendBrief, amendmentsOf } from "../orchestrator/amendments";
+import { PIECES_PROMPT, pieceBrief } from "../plans/pieces";
+import { createFeature, planFor, planPathOf, splitOf } from "../plans/features";
 
 export const PLAN_FILE = ".agentos/plan.md";
 
@@ -31,7 +33,9 @@ export function planPrompt(task: string, only = false): string {
   return `${task}
 
 ---
-Plan first. This turn, only read and plan: write the implementation plan for the task above to \`${PLAN_FILE}\` in this worktree (what to change, file by file; the tests; how you'll verify it; anything ambiguous and the call you'd make). Change no other file, and don't commit, push or open a PR. Don't end your turn while subagents or background commands you started are still running; wait for their results and write the plan in the same turn. End the turn once the plan is written: ${after}.`;
+Plan first. This turn, only read and plan: write the implementation plan for the task above to \`${PLAN_FILE}\` in this worktree (what to change, file by file; the tests; how you'll verify it; anything ambiguous and the call you'd make). Change no other file, and don't commit, push or open a PR. Don't end your turn while subagents or background commands you started are still running; wait for their results and write the plan in the same turn. End the turn once the plan is written: ${after}.
+
+${PIECES_PROMPT}`;
 }
 
 export const PLAN_RETRY_PROMPT = `Write the plan to \`${PLAN_FILE}\` now, plan only.`;
@@ -42,10 +46,16 @@ export const planRetryMessageId = (sessionId: string) =>
 // treated as having nothing running and re-prompted.
 export const PLAN_BACKGROUND_WAIT_MS = 20 * 60 * 1000;
 
-export function implementPrompt(planned: boolean, amendment?: string): string {
-  const base = planned
-    ? `The plan is in \`${PLAN_FILE}\`. Implement it now, finishing the task as its instructions above say. Where the plan turns out wrong, do what's right and say so.`
-    : `No plan was written to \`${PLAN_FILE}\`. Plan briefly, then implement the task, finishing it as its instructions above say.`;
+export function implementPrompt(
+  planned: boolean,
+  amendment?: string,
+  piece?: string
+): string {
+  const base = piece
+    ? `The plan is in \`${PLAN_FILE}\`. ${piece}\nFinish it as the task's instructions above say. Where the plan turns out wrong, do what's right and say so.`
+    : planned
+      ? `The plan is in \`${PLAN_FILE}\`. Implement it now, finishing the task as its instructions above say. Where the plan turns out wrong, do what's right and say so.`
+      : `No plan was written to \`${PLAN_FILE}\`. Plan briefly, then implement the task, finishing it as its instructions above say.`;
   return amendment
     ? `${base}\n\nThe plan was approved with this change, which is now part of the task's scope:\n${amendment}`
     : base;
@@ -87,6 +97,18 @@ export function planSummary(text: string, max = 5): string[] {
   return picked.map((l) => trim(l.text));
 }
 
+function piecesLine(r: NonNullable<ReturnType<typeof planFor>>): string {
+  const parts = r.pieces.map((p) => {
+    const after = p.afterPosition
+      ? ` after ${p.afterPosition} is ${p.afterKind}`
+      : "";
+    const why = p.reasons.length ? ` (${p.reasons.join("+")})` : "";
+    return `${p.position} ${p.name}${after}${why}`;
+  });
+  const folded = r.folded.length ? `, ${r.folded.length} folded` : "";
+  return `${r.pieces.length} pieces${folded}: ${parts.join("; ")}`;
+}
+
 // Tells the orchestrator that started a task its plan is written, once.
 function announcePlan(s: Session, ref: string | null, retried = false): void {
   if (!s.started_by && !s.held_by_device) return;
@@ -105,6 +127,8 @@ function announcePlan(s: Session, ref: string | null, retried = false): void {
     const summary = planSummary(fs.readFileSync(file, "utf8"));
     head = `Task "${s.name}": plan written to ${file}; ${next}.`;
     if (summary.length) head += `\n${summary.map((l) => `- ${l}`).join("\n")}`;
+    const pieces = planFor(s, fs.readFileSync(file, "utf8"));
+    if (pieces && pieces.pieces.length > 1) head += `\n${piecesLine(pieces)}`;
   } catch {
     // No plan file: the line says so.
   }
@@ -118,6 +142,14 @@ function announcePlan(s: Session, ref: string | null, retried = false): void {
   queueEvent(workspaceId!, `plan-done:${s.id}`, s.id, head);
 }
 
+function readPlan(s: Session): string | null {
+  try {
+    return fs.readFileSync(path.join(s.worktree_path!, PLAN_FILE), "utf8");
+  } catch {
+    return null;
+  }
+}
+
 export const implementMessageId = (sessionId: string) =>
   `implement-${sessionId}`;
 
@@ -146,6 +178,9 @@ async function startImplementing(
     override: taskOverride(s),
   });
   const id = implementMessageId(sessionId);
+  const planText = readPlan(s);
+  const split = planText ? splitOf(s, planText) : null;
+  const workspaceId = sessionWorkspace(s);
   const claimed = db.transaction(() => {
     const changed = db
       .prepare(
@@ -155,11 +190,26 @@ async function startImplementing(
       .run(sessionId, from).changes;
     if (!changed) return false;
     setSessionModel(sessionId, routed);
+    let piece: string | undefined;
+    let note = amendment;
+    if (split?.notBuilding.length)
+      note = [amendment, `Not building: ${split.notBuilding.join("; ")}`]
+        .filter(Boolean)
+        .join("\n");
+    if (split && split.pieces.length > 1 && planText && workspaceId) {
+      const feature = createFeature(s, planText, split.pieces, workspaceId);
+      piece = pieceBrief(
+        split.pieces.length,
+        split.pieces[0],
+        planPathOf(feature.id)
+      );
+    }
     enqueue(sessionId, {
       id,
       text: implementPrompt(
         fs.existsSync(path.join(s.worktree_path!, PLAN_FILE)),
-        amendment
+        note,
+        piece
       ),
       origin: { kind: "decision", label: "Plan step" },
     });
@@ -308,6 +358,17 @@ export async function handoffAfterPlan(
   } catch (e) {
     console.error("plan-done event failed:", e);
   }
+  try {
+    const text = readPlan(s);
+    const planned = text ? planFor(s, text) : null;
+    (await import("../notify/push/events")).pushPlanAwaiting(
+      s.id,
+      s.name,
+      planned?.pieces.length ?? 1
+    );
+  } catch (e) {
+    console.error("plan push failed:", e);
+  }
   // The worker has nothing left to do: it ends at this turn boundary, and
   // the next message (an approval, or a revision) starts one that resumes.
   try {

package/lib/notify/copy.ts

@@ -13,14 +13,14 @@ import {
   type PushEvent,
   type PushLevel,
 } from "./push-types";
-import { safeId, safeKey } from "./redact";
+import { safeId, safeKey, scrubText } from "./redact";
 
 export interface CategoryDef {
   level: PushLevel;
   defaultOn: boolean;
   /** Settings label. */
   label: string;
-  /** The one word or phrase shown as the body. Fixed text, no event data. */
+  /** The word or phrase shown as the body unless the sender names one. */
   word: string;
   /** App path for an id, or the fallback when the id is missing or unsafe. */
   link: (id: string | null) => string;
@@ -51,6 +51,13 @@ export const CATEGORIES: Record<PushCategory, CategoryDef> = {
     word: "Ready for review",
     link: (id) => (id ? `/task/${id}` : FALLBACK_LINK),
   },
+  plan: {
+    level: "active",
+    defaultOn: true,
+    label: "Plan ready",
+    word: "Plan ready",
+    link: (id) => (id ? `/task/${id}` : FALLBACK_LINK),
+  },
   ci: {
     level: "active",
     defaultOn: true,
@@ -108,9 +115,18 @@ export function enabledCategories(
     : defaultCategories();
 }
 
+const NAMED_MAX = 80;
+
+/** Text a sender named for the alert: one scrubbed line, or null. */
+function named(text: string | null | undefined): string | null {
+  const clean = scrubText(text, NAMED_MAX);
+  return clean || null;
+}
+
 /**
- * The v1 payload for an event. Built only from the registry and a vetted id
- * and key, so it carries no event text whatever the caller passes.
+ * The v1 payload for an event. Built from the registry, a vetted id and key,
+ * and at most a title and body the sender named (a plan's or feature's name),
+ * each scrubbed to one short line with no secret-shaped runs.
  */
 export function buildPushPayload(event: PushEvent): PushEnvelopeV1 {
   const def = CATEGORIES[event.category];
@@ -118,8 +134,8 @@ export function buildPushPayload(event: PushEvent): PushEnvelopeV1 {
   return {
     v: 1,
     c: event.category,
-    t: PUSH_TITLE,
-    b: def.word,
+    t: named(event.title) ?? PUSH_TITLE,
+    b: named(event.body) ?? def.word,
     l: def.link(id),
     k: safeKey(event.key) ?? `${event.category}:${id ?? "-"}`,
     p: def.level,
@@ -169,8 +185,8 @@ export function isAppLink(link: string): boolean {
 }
 
 /**
- * True only for a payload the registry could have built: fixed title, the
- * category's own word, a known link shape, a plain key. A sender checks this
+ * True only for a payload the registry could have built: a scrubbed title
+ * and body, a known link shape, a plain key. A sender checks this
  * before it sends, so nothing else can leave the machine.
  */
 export function isGenericPayload(p: unknown): p is PushEnvelopeV1 {
@@ -180,8 +196,10 @@ export function isGenericPayload(p: unknown): p is PushEnvelopeV1 {
   const def = CATEGORIES[o.c];
   return (
     Object.keys(o).sort().join() === "b,c,k,l,p,t,v" &&
-    o.t === PUSH_TITLE &&
-    o.b === def.word &&
+    typeof o.t === "string" &&
+    named(o.t) === o.t &&
+    typeof o.b === "string" &&
+    named(o.b) === o.b &&
     o.p === def.level &&
     typeof o.l === "string" &&
     isAppLink(o.l) &&

package/lib/notify/push/events.ts

@@ -52,8 +52,42 @@ export const pushCiFailed = (taskId: string, sha: string) =>
   forTask("ci", "ci", taskId, sha);
 export const pushReviewBlocked = (taskId: string, sha: string) =>
   forTask("ci", "review-block", taskId, sha);
-export const pushMerged = (taskId: string) =>
-  forTask("merged", "merged", taskId);
+// A piece of a feature is covered by the feature's own push when it closes.
+const isFeaturePiece = (sessionId: string) =>
+  !!db
+    .prepare(`SELECT 1 FROM feature_pieces WHERE session_id = ?`)
+    .get(sessionId);
+
+export const pushMerged = (taskId: string) => {
+  if (!isFeaturePiece(taskId)) forTask("merged", "merged", taskId);
+};
+
+export const pushFeatureMerged = (featureId: string, name: string) =>
+  fire({
+    category: "merged",
+    id: null,
+    key: `feature:${featureId}`,
+    collapse: `group:feature:${featureId}`,
+    title: "Feature merged",
+    body: name,
+  });
+
+export const pushPlanAwaiting = (
+  taskId: string,
+  name: string,
+  pieces: number
+) =>
+  fire(
+    {
+      category: "plan",
+      id: taskId,
+      key: `plan-ready:${taskId}`,
+      collapse: `plan:${taskId}`,
+      title: "Plan ready",
+      body: `${name}, ${pieces} ${pieces === 1 ? "piece" : "pieces"}`,
+    },
+    taskId
+  );
 
 export const pushPlanReady = (sessionId: string, itemId: string) => {
   // Only a task has a screen to open; a plain chat's plan goes to the list.