@saadnvd1/agent-os 0.3.457 → 0.3.459

package/lib/orchestrator/digest.ts

@@ -0,0 +1,339 @@
+/**
+ * What an orchestrator knows when it starts: the workspace's state read
+ * straight from the database, no model involved. It goes in the brief on
+ * every start, so a fresh conversation (a new orchestrator, or one started
+ * over at its context threshold) loses nothing that matters. Sections run
+ * most important first and the whole stays under a token budget; ordering
+ * is by id, so the same database gives the same text.
+ */
+
+import { db } from "../db";
+import { openAsks } from "./asks";
+import { listRules } from "./rules";
+import { shortId } from "./describe";
+import { untrusted } from "./untrusted";
+
+// About four characters a token: close enough to cap a prompt.
+export const CHARS_PER_TOKEN = 4;
+export const DIGEST_TOKENS = 4000;
+const LINE_CAP = 300;
+const NOTES_SCANNED = 200;
+// An external PR gated this recently is still worth a line.
+const EXTERNAL_DAYS = 2;
+
+// One line, cut to length. A cut that leaves a fence around another
+// session's text open closes it, so what follows isn't read as inside it.
+const clip = (text: string, cap = LINE_CAP) => {
+  const one = text.replace(/\s+/g, " ").trim();
+  if (one.length <= cap) return one;
+  const cut = `${one.slice(0, cap - 3)}...`;
+  const opens = cut.match(/<untrusted[\s>]/g)?.length ?? 0;
+  const closes = cut.match(/<\/untrusted>/g)?.length ?? 0;
+  return opens > closes ? `${cut}</untrusted>` : cut;
+};
+
+const sha7 = (sha: string | null) => (sha ? sha.slice(0, 7) : "?");
+
+interface Section {
+  title: string;
+  lines: string[];
+  // Shown when the section is empty; omitted otherwise.
+  empty?: string;
+  // How to see what didn't fit.
+  more: string;
+}
+
+interface TaskRow {
+  id: string;
+  name: string;
+  project: string | null;
+  pr_number: number | null;
+  pr_status: string | null;
+  view: string;
+  armed_at: string | null;
+}
+
+interface CheckRow {
+  session_id: string;
+  sha: string;
+  kind: string;
+  status: string;
+}
+
+interface FailureRow {
+  session_id: string;
+  gate: string;
+  count: number;
+  escalated_at: string | null;
+}
+
+function checksBySession(workspaceId: string): Map<string, CheckRow[]> {
+  // The newest verdict of each kind per session or PR.
+  const rows = db
+    .prepare(
+      `SELECT c.session_id, c.sha, c.kind, c.status FROM orchestrator_checks c
+       WHERE c.workspace_id = ? AND c.id = (
+         SELECT MAX(id) FROM orchestrator_checks
+         WHERE workspace_id = c.workspace_id AND session_id = c.session_id
+           AND kind = c.kind)
+       ORDER BY c.session_id, c.kind`
+    )
+    .all(workspaceId) as CheckRow[];
+  const by = new Map<string, CheckRow[]>();
+  for (const r of rows)
+    by.set(r.session_id, [...(by.get(r.session_id) ?? []), r]);
+  return by;
+}
+
+function failuresBySession(workspaceId: string): Map<string, FailureRow[]> {
+  const rows = db
+    .prepare(
+      `SELECT session_id, gate, count, escalated_at FROM orchestrator_gate_failures
+       WHERE workspace_id = ? AND count > 0 ORDER BY session_id, gate`
+    )
+    .all(workspaceId) as FailureRow[];
+  const by = new Map<string, FailureRow[]>();
+  for (const r of rows)
+    by.set(r.session_id, [...(by.get(r.session_id) ?? []), r]);
+  return by;
+}
+
+function gateState(
+  checks: CheckRow[] = [],
+  failures: FailureRow[] = []
+): string {
+  const parts: string[] = [];
+  if (checks.length)
+    parts.push(
+      checks.map((c) => `${c.kind} ${c.status}@${sha7(c.sha)}`).join(", ")
+    );
+  const failed = failures.map(
+    (f) =>
+      `${f.gate} failed ${f.count}x${f.escalated_at ? " (Saad's now)" : ""}`
+  );
+  if (failed.length) parts.push(failed.join(", "));
+  return parts.join("; ");
+}
+
+function rulesSection(workspaceId: string): Section {
+  return {
+    title: "Standing rules",
+    // Saad's in plain text; its own fenced, since it writes them from what
+    // it read: a line planted there can't pass for his word.
+    lines: listRules(workspaceId).map((r) =>
+      r.added_by === "saad"
+        ? `- [rule ${r.id}, from Saad] ${clip(r.text)}`
+        : `- [rule ${r.id}, kept by you] ${untrusted("a rule you kept", clip(r.text))}`
+    ),
+    empty: "- None. Keep one with rule_add.",
+    more: "",
+  };
+}
+
+function asksSection(workspaceId: string): Section {
+  return {
+    title: "Open asks (waiting on Saad)",
+    lines: openAsks(workspaceId).map((a) => {
+      const on = a.subject.startsWith("task:")
+        ? ` | task ${shortId(a.subject.slice(5))}`
+        : a.subject.startsWith("pr:")
+          ? ` | ${a.subject.slice(3)}`
+          : "";
+      const at = a.sha ? `@${sha7(a.sha)}` : "";
+      return `- [ask ${a.id}] ${a.kind}: ${untrusted("ask title", clip(a.title, 160))}${on}${at}`;
+    }),
+    empty: "- None.",
+    more: "",
+  };
+}
+
+function tasksSection(
+  workspaceId: string,
+  checks: Map<string, CheckRow[]>,
+  failures: Map<string, FailureRow[]>
+): Section {
+  const tasks = db
+    .prepare(
+      `SELECT s.id, s.name, p.name AS project, s.pr_number, s.pr_status, s.view,
+         s.merge_armed_at AS armed_at
+       FROM sessions s JOIN projects p ON p.id = s.project_id
+       WHERE p.workspace_id = ? AND s.role IS NULL AND s.archived_at IS NULL
+         AND s.task_status = 'running'
+       ORDER BY s.created_at, s.id`
+    )
+    .all(workspaceId) as TaskRow[];
+  return {
+    title: "Running tasks",
+    lines: tasks.map((t) => {
+      const pr = t.pr_number
+        ? `PR #${t.pr_number} ${t.pr_status ?? "open"}`
+        : "no PR yet";
+      const gates = gateState(checks.get(t.id), failures.get(t.id));
+      const arm = t.armed_at ? " | armed to merge" : "";
+      return `- ${clip(t.name, 80)} (${t.project ?? "?"}, ${t.view}, id ${shortId(t.id)}): ${pr}${arm}${gates ? ` | ${gates}` : ""}`;
+    }),
+    empty: "- None.",
+    more: "the sessions tool",
+  };
+}
+
+function externalSection(
+  workspaceId: string,
+  checks: Map<string, CheckRow[]>,
+  failures: Map<string, FailureRow[]>
+): Section {
+  const recent = db
+    .prepare(
+      `SELECT session_id FROM orchestrator_checks
+       WHERE workspace_id = ? AND session_id LIKE 'pr:%'
+         AND created_at >= datetime('now', ?)
+       GROUP BY session_id ORDER BY session_id`
+    )
+    .all(workspaceId, `-${EXTERNAL_DAYS} days`) as { session_id: string }[];
+  return {
+    title: `External PRs gated in the last ${EXTERNAL_DAYS} days (may have merged since)`,
+    lines: recent.map(
+      ({ session_id }) =>
+        `- ${session_id.slice(3)} | ${gateState(checks.get(session_id), failures.get(session_id))}`
+    ),
+    more: "review on the PR",
+  };
+}
+
+function queueSection(workspaceId: string): Section {
+  const rows = db
+    .prepare(
+      `SELECT q.id, q.name, q.prompt, q.status, q.after_task, q.after_any,
+         p.name AS project, a.name AS after_name
+       FROM task_queue q JOIN projects p ON p.id = q.project_id
+       LEFT JOIN sessions a ON a.id = q.after_task
+       WHERE p.workspace_id = ? AND q.status IN ('queued', 'starting', 'failed')
+       ORDER BY q.position`
+    )
+    .all(workspaceId) as {
+    id: string;
+    name: string | null;
+    prompt: string;
+    status: string;
+    after_task: string | null;
+    after_any: string | null;
+    project: string;
+    after_name: string | null;
+  }[];
+  return {
+    title: "Queued tasks, in line order",
+    lines: rows.map((r, i) => {
+      const after = r.after_task
+        ? ` | after ${r.after_name ?? shortId(r.after_task)}`
+        : r.after_any
+          ? " | after any running task"
+          : "";
+      const status = r.status === "queued" ? "" : ` | ${r.status}`;
+      return `- ${i + 1}. ${clip(r.name ?? r.prompt, 80)} (${r.project}, id ${shortId(r.id)})${after}${status}`;
+    }),
+    more: "the sessions tool",
+  };
+}
+
+function schedulesSection(workspaceId: string): Section {
+  const rows = db
+    .prepare(
+      `SELECT name, cron, timezone, prompt, enabled FROM schedules
+       WHERE workspace_id = ? AND archived_at IS NULL ORDER BY created_at, id`
+    )
+    .all(workspaceId) as {
+    name: string;
+    cron: string;
+    timezone: string;
+    prompt: string;
+    enabled: number;
+  }[];
+  return {
+    title: "Schedules",
+    lines: rows.map(
+      (s) =>
+        `- "${clip(s.name, 60)}" ${s.cron} ${s.timezone}${s.enabled ? "" : " (off)"}: ${clip(s.prompt, 160)}`
+    ),
+    more: "`aos schedules`",
+  };
+}
+
+function notesSection(workspaceId: string): Section {
+  const rows = db
+    .prepare(
+      `SELECT kind, text, created_at FROM orchestrator_notes
+       WHERE workspace_id = ? ORDER BY id DESC LIMIT ?`
+    )
+    .all(workspaceId, NOTES_SCANNED) as {
+    kind: string;
+    text: string;
+    created_at: string;
+  }[];
+  return {
+    title: "Decision log, newest first",
+    lines: rows.map(
+      (n) =>
+        `- ${n.created_at.slice(0, 16)} UTC${n.kind === "note" ? "" : ` ${n.kind}`}: ${untrusted(n.kind === "note" ? "your note" : `${n.kind} log line`, clip(n.text))}`
+    ),
+    more: "",
+  };
+}
+
+// Sections in order until the budget runs out; a section cut short says
+// how many lines it left out and where to find them.
+export function renderDigest(
+  sections: Section[],
+  budgetTokens: number
+): string {
+  const budget = budgetTokens * CHARS_PER_TOKEN;
+  const out: string[] = [];
+  let used = 0;
+  const fits = (text: string) => used + text.length + 1 <= budget;
+  const put = (text: string) => {
+    out.push(text);
+    used += text.length + 1;
+  };
+  for (const s of sections) {
+    const lines = s.lines.length ? s.lines : s.empty ? [s.empty] : [];
+    if (!lines.length) continue;
+    const head = `\n### ${s.title}`;
+    if (!fits(`${head}\n${lines[0]}`)) break;
+    put(head);
+    let shown = 0;
+    for (const line of lines) {
+      if (!fits(line)) break;
+      put(line);
+      shown++;
+    }
+    const left = lines.length - shown;
+    if (left) {
+      const more = `- ...and ${left} more${s.more ? ` (see ${s.more})` : ""}.`;
+      if (fits(more)) put(more);
+      break;
+    }
+  }
+  return out.join("\n").trim();
+}
+
+export function buildDigest(
+  workspaceId: string,
+  budgetTokens = DIGEST_TOKENS
+): string {
+  const checks = checksBySession(workspaceId);
+  const failures = failuresBySession(workspaceId);
+  const head =
+    "## Where things stand (read from AgentOS's database as you started)";
+  const body = renderDigest(
+    [
+      rulesSection(workspaceId),
+      asksSection(workspaceId),
+      tasksSection(workspaceId, checks, failures),
+      externalSection(workspaceId, checks, failures),
+      queueSection(workspaceId),
+      schedulesSection(workspaceId),
+      notesSection(workspaceId),
+    ],
+    budgetTokens - Math.ceil((head.length + 2) / CHARS_PER_TOKEN)
+  );
+  return `${head}\n\n${body}`;
+}

package/lib/orchestrator/presence-binding.ts

@@ -10,6 +10,8 @@ export const askPresence = (askId: number, binding: string) =>
 export const resumePresence = (workspaceId: string) => `resume:${workspaceId}`;
 export const revokePresence = (passkeyId: string) => `revoke:${passkeyId}`;
 export const APPROVALS_OFF_PRESENCE = "approvals-off";
+// Writing a workspace's standing rules as Saad.
+export const rulesPresence = (workspaceId: string) => `rules:${workspaceId}`;
 
 export function presenceBinding(b: {
   purpose?: PresencePurpose;
@@ -36,6 +38,9 @@ export function presenceBinding(b: {
       return "enroll";
     case "approvals-off":
       return APPROVALS_OFF_PRESENCE;
+    case "rules":
+      if (!b.workspaceId) throw new PresenceError("Which workspace?");
+      return rulesPresence(b.workspaceId);
     case "revoke":
       if (!b.passkeyId) throw new PresenceError("Which passkey?");
       return revokePresence(b.passkeyId);

package/lib/orchestrator/rules.ts

@@ -0,0 +1,124 @@
+/**
+ * A workspace's standing rules: what its orchestrator must keep knowing
+ * across fresh starts ("never merge #111", "briefs must not name
+ * competitors"). The orchestrator writes them with rule_add and rule_remove,
+ * Saad in Settings → Workspaces, and every start reads them into its brief.
+ * They restrict and inform; none can approve anything. A removed rule stays
+ * in the table, marked.
+ */
+
+import { db } from "../db";
+import { redact } from "./untrusted";
+
+export type RuleAuthor = "orchestrator" | "saad";
+
+export interface RuleRow {
+  id: number;
+  workspace_id: string;
+  text: string;
+  added_by: RuleAuthor;
+  created_at: string;
+  updated_at: string;
+  removed_at: string | null;
+  removed_by: RuleAuthor | null;
+}
+
+// Kept small: every one is in every start's prompt.
+export const MAX_RULES = 25;
+export const MAX_RULE_CHARS = 300;
+
+function clean(text: string): string {
+  const body = redact(text).replace(/\s+/g, " ").trim();
+  if (!body) throw new Error("The rule is empty");
+  if (body.length > MAX_RULE_CHARS)
+    throw new Error(`A rule is at most ${MAX_RULE_CHARS} characters`);
+  return body;
+}
+
+export function listRules(workspaceId: string): RuleRow[] {
+  return db
+    .prepare(
+      `SELECT * FROM orchestrator_rules
+       WHERE workspace_id = ? AND removed_at IS NULL ORDER BY id`
+    )
+    .all(workspaceId) as RuleRow[];
+}
+
+function getRule(workspaceId: string, id: number): RuleRow | null {
+  return (
+    (db
+      .prepare(
+        `SELECT * FROM orchestrator_rules
+         WHERE id = ? AND workspace_id = ? AND removed_at IS NULL`
+      )
+      .get(id, workspaceId) as RuleRow | undefined) ?? null
+  );
+}
+
+// The same text twice is the rule already there.
+export function addRule(
+  workspaceId: string,
+  text: string,
+  by: RuleAuthor
+): RuleRow {
+  const body = clean(text);
+  return db.transaction(() => {
+    const rules = listRules(workspaceId);
+    const same = rules.find((r) => r.text === body);
+    // Saad writing one the orchestrator kept makes it his.
+    if (same && by === "saad" && same.added_by !== "saad") {
+      db.prepare(
+        `UPDATE orchestrator_rules SET added_by = 'saad', updated_at = datetime('now')
+         WHERE id = ?`
+      ).run(same.id);
+      return getRule(workspaceId, same.id)!;
+    }
+    if (same) return same;
+    if (rules.length >= MAX_RULES)
+      throw new Error(
+        `This workspace has ${MAX_RULES} rules already; remove one first`
+      );
+    const { lastInsertRowid } = db
+      .prepare(
+        `INSERT INTO orchestrator_rules (workspace_id, text, added_by) VALUES (?, ?, ?)`
+      )
+      .run(workspaceId, body, by);
+    return getRule(workspaceId, Number(lastInsertRowid))!;
+  })();
+}
+
+export function updateRule(
+  workspaceId: string,
+  id: number,
+  text: string
+): RuleRow {
+  const body = clean(text);
+  const { changes } = db
+    .prepare(
+      `UPDATE orchestrator_rules SET text = ?, updated_at = datetime('now')
+       WHERE id = ? AND workspace_id = ? AND removed_at IS NULL`
+    )
+    .run(body, id, workspaceId);
+  if (!changes) throw new Error(`No rule ${id} in this workspace`);
+  return getRule(workspaceId, id)!;
+}
+
+export function removeRule(
+  workspaceId: string,
+  id: number,
+  by: RuleAuthor
+): RuleRow {
+  const rule = getRule(workspaceId, id);
+  if (!rule) throw new Error(`No rule ${id} in this workspace`);
+  // Saad's restrictions hold until he lifts them: text the orchestrator
+  // read can't talk it into removing one.
+  if (by === "orchestrator" && rule.added_by === "saad")
+    throw new Error(
+      `Rule ${id} is Saad's: only he removes it, in Settings → Workspaces`
+    );
+  db.prepare(
+    `UPDATE orchestrator_rules SET removed_at = datetime('now'), removed_by = ?
+     WHERE id = ?`
+  ).run(by, id);
+  return rule;
+}

package/lib/orchestrator/serve.ts

@@ -15,6 +15,7 @@ import { sessionFacts } from "./facts";
 import { describeExternal, externalSessions } from "./external-sessions";
 import { resolveStaleAsks } from "./ask-settle";
 import { addNote } from "./notes";
+import { addRule, removeRule } from "./rules";
 import { askSaad } from "./ask-tool";
 import { listOrchestratorPeers, messageOrchestrator } from "./cross";
 import { PAUSED_REFUSAL } from "./pause";
@@ -122,6 +123,16 @@ export async function runTool(
     case "note":
       addNote(w, p(tool, raw).text);
       return "Noted.";
+    case "rule_add": {
+      const rule = addRule(w, p(tool, raw).text, "orchestrator");
+      addNote(w, `Standing rule ${rule.id}: ${rule.text}`);
+      return `Rule ${rule.id} kept: it's in your brief on every start.`;
+    }
+    case "rule_remove": {
+      const rule = removeRule(w, p(tool, raw).id, "orchestrator");
+      addNote(w, `Removed standing rule ${rule.id}: ${rule.text}`);
+      return `Rule ${rule.id} removed.`;
+    }
     case "review": {
       const a = p(tool, raw);
       return reviewTarget(w, a.target, { fresh: a.fresh });

package/lib/orchestrator/tool-names.ts

@@ -22,6 +22,8 @@ export const TOOL_NAMES = {
   stop: name("stop"),
   done: name("done"),
   note: name("note"),
+  rule_add: name("rule_add"),
+  rule_remove: name("rule_remove"),
   review: name("review"),
   sign_off: name("sign_off"),
   arm: name("arm"),

package/lib/orchestrator/tool-schemas.ts

@@ -4,6 +4,7 @@
 import { z } from "zod";
 import { BRANCH_NAME } from "../git";
 import { RAISED_KINDS } from "./asks";
+import { MAX_RULE_CHARS } from "./rules";
 
 const ref = (what: string) => z.string().trim().min(1).max(300).describe(what);
 const session = ref("Session name, project/name, or id from sessions");
@@ -100,6 +101,15 @@ export const TOOL_SHAPES = {
   stop: { session },
   done: { session },
   note: { text: z.string().trim().min(1).max(2000) },
+  rule_add: {
+    text: z
+      .string()
+      .trim()
+      .min(1)
+      .max(MAX_RULE_CHARS)
+      .describe("The rule, one sentence"),
+  },
+  rule_remove: { id: z.number().int().positive().describe("The rule's id") },
   review: {
     target: ref("The task, or its PR (#12 or URL)"),
     fresh: z

package/lib/orchestrator/tools.ts

@@ -72,6 +72,10 @@ const DESCRIPTIONS: Record<ToolName, string> = {
   stop: "Stop a session's agent, keeping its worktree and branch.",
   done: "Finish a session whose work is complete: a task's open PR merges through the sign-off gates first (refused naming the failing gate), then its agent stops, its worktree is removed if nothing would be lost, and it's archived. Not a rejection.",
   note: "Add a line to this workspace's decision log; it shows in your chat.",
+  rule_add:
+    'Keep a standing rule for this workspace, in your brief on every start from now on ("never merge #111", "briefs must not name competitors"). It restricts or informs; it can never approve anything.',
+  rule_remove:
+    "Remove a standing rule you kept, by its id, only when Saad says so or it no longer applies (the PR it names merged or closed). Saad's rules are his to remove.",
   review:
     "Start an independent read-only review of a PR at its exact head commit, or read the stored verdict for that commit. Takes a task, or any open PR in a workspace repository by #N, owner/repo#N or URL, even one no task owns.",
   sign_off:

package/lib/orchestrator/worker.ts

@@ -9,6 +9,7 @@ import {
   orchestratorToolsDigest,
 } from "./tools";
 import type { RoleExtras } from "../chat/worker/extras";
+import { refreshSettings } from "../chat/refresh";
 
 // What an orchestrator's chat worker starts with on top of any chat: its
 // brief, its tools, and permissions fixed by its role.
@@ -29,5 +30,9 @@ export async function orchestratorExtras(
     },
     ...ORCHESTRATOR_PERMISSIONS,
     toolsDigest: orchestratorToolsDigest(),
+    refresh: {
+      atTokens: refreshSettings().orchestratorTokens,
+      role: "orchestrator",
+    },
   };
 }

package/lib/security/presence.ts

@@ -41,7 +41,8 @@ export type PresencePurpose =
   | "resume"
   | "enroll"
   | "revoke"
-  | "approvals-off";
+  | "approvals-off"
+  | "rules";
 
 export class PresenceError extends Error {
   constructor(

package/package.json

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

package/styles/themes.css

@@ -24,6 +24,10 @@
      Cool white with a violet accent
      =========================================================================== */
   :root {
+    /* Find in a conversation: every match, and the one it's on. */
+    --find-match: 48 96% 53% / 0.45;
+    --find-current: 25 95% 53%;
+    --find-current-foreground: 0 0% 0%;
     --background: 240 10% 95.5%;
     --foreground: 240 12% 14%;
     --card: 0 0% 100%;
@@ -287,6 +291,7 @@
      Blue-black with a violet accent
      =========================================================================== */
   .dark {
+    --find-match: 48 96% 53% / 0.35;
     --background: 240 18% 3.5%;
     --foreground: 240 10% 93%;
     --card: 240 14% 6%;