@saadnvd1/agent-os 0.3.794 → 0.3.807

package/lib/db/migrations.ts

@@ -26,6 +26,11 @@ export type { Migration } from "./migration-types";
 // typecheck, lint and test) and is not committed. A duplicate id or key, or a
 // file whose name does not match its id, throws when this module loads.
 // lib/db/migrations.test.ts enforces the rest.
+//
+// A migration must leave the previous release runnable: an automatic update
+// that isn't healthy rolls the code back but not the database (chat workers
+// keep writing through the restart, so a restore would drop their work). Add
+// columns and tables; don't rename or drop what the last release reads.
 
 export const migrationKey = (m: Migration): string => m.key ?? String(m.id);
 const migrationName = (m: Migration): string =>
@@ -93,6 +98,22 @@ function compareToUpTo(m: Migration, upTo: number | string): number {
 // All migrations in order - never modify existing ones, only add new
 export const migrations: Migration[] = buildRegistry(migrationFiles);
 
+/** How many of this build's migrations the database has; the update health check reads it. */
+export function migrationStatus(db: Database.Database): {
+  known: number;
+  applied: number;
+} {
+  const rows = db.prepare(`SELECT id, key FROM _migrations`).all() as {
+    id: number;
+    key: string | null;
+  }[];
+  const have = new Set(rows.map((r) => r.key ?? String(r.id)));
+  return {
+    known: migrations.length,
+    applied: migrations.filter((m) => have.has(migrationKey(m))).length,
+  };
+}
+
 // `upTo`: stop after this legacy id or timestamp key, inclusive (tests that
 // start from an older database).
 export function runMigrations(

package/lib/keybindings/focus.ts

@@ -27,3 +27,20 @@ export function fieldOwnsKey(target: EventTarget | null): boolean {
   if (el.isContentEditable) return (el.textContent ?? "").trim().length > 0;
   return false;
 }
+
+// Whether a bare letter is free for the app: nothing is being typed into, no
+// terminal or dialog holds the key, and no menu is open.
+export function isFreeTarget(target: EventTarget | null): boolean {
+  const el = target as HTMLElement | null;
+  if (!el || typeof el.closest !== "function") return true;
+  if (el.closest(".xterm")) return false;
+  if (el.closest('[role="dialog"],[role="menu"],[role="listbox"]'))
+    return false;
+  const tag = el.tagName;
+  if (tag === "TEXTAREA" || tag === "SELECT") return false;
+  if (tag === "INPUT") return NON_TEXT.has((el as HTMLInputElement).type);
+  return !(
+    el.isContentEditable ||
+    el.closest('[contenteditable]:not([contenteditable="false"])')
+  );
+}

package/lib/keybindings/keymap.ts

@@ -0,0 +1,120 @@
+// Every shortcut the app has, in one table: the keys that act on it, the
+// shortcuts panel and the palette hints all read this. A `keys` string with
+// a space is a sequence (press g, then i); without one it is a chord.
+
+export type KeyGroup = "Go to" | "Chats" | "General" | "Browser";
+
+export interface KeyEntry {
+  id: string;
+  keys: string;
+  label: string;
+  group: KeyGroup;
+  // A bare key or sequence: only while nothing is being typed, and off with
+  // the single-key switch.
+  single?: boolean;
+  // The browser acts on it, not the app: listed so it can be found.
+  browser?: boolean;
+}
+
+export const KEYMAP: KeyEntry[] = [
+  { id: "go.inbox", keys: "g i", label: "Inbox", group: "Go to", single: true },
+  {
+    id: "go.bookmarks",
+    keys: "g b",
+    label: "Bookmarks",
+    group: "Go to",
+    single: true,
+  },
+  {
+    id: "go.messages",
+    keys: "g m",
+    label: "Messages",
+    group: "Go to",
+    single: true,
+  },
+  {
+    id: "go.settings",
+    keys: "g s",
+    label: "Settings",
+    group: "Go to",
+    single: true,
+  },
+  {
+    id: "chat.previous",
+    keys: "g p",
+    label: "Previous chat (flip back and forth)",
+    group: "Chats",
+    single: true,
+  },
+  {
+    id: "chat.open",
+    keys: "o c",
+    label: "Open a chat",
+    group: "Chats",
+    single: true,
+  },
+  {
+    id: "chat.new",
+    keys: "c",
+    label: "New chat",
+    group: "Chats",
+    single: true,
+  },
+  { id: "switcher.open", keys: "mod+p", label: "Switch chat", group: "Chats" },
+  {
+    id: "session.previous",
+    keys: "mod+up",
+    label: "Chat above in the sidebar",
+    group: "Chats",
+  },
+  {
+    id: "session.next",
+    keys: "mod+down",
+    label: "Chat below in the sidebar",
+    group: "Chats",
+  },
+  {
+    id: "palette.open",
+    keys: "mod+k",
+    label: "Command palette",
+    group: "General",
+  },
+  {
+    id: "help.open",
+    keys: "?",
+    label: "Keyboard shortcuts",
+    group: "General",
+    single: true,
+  },
+  {
+    id: "history.back",
+    keys: "mod+[",
+    label: "Back to the chat you came from",
+    group: "Browser",
+    browser: true,
+  },
+  {
+    id: "history.forward",
+    keys: "mod+]",
+    label: "Forward",
+    group: "Browser",
+    browser: true,
+  },
+];
+
+export const keysOf = (id: string): string => {
+  const e = KEYMAP.find((k) => k.id === id);
+  if (!e) throw new Error(`No shortcut "${id}"`);
+  return e.keys;
+};
+
+export const isSequence = (keys: string) => keys.includes(" ");
+
+/** The table's entries a search finds, in table order; no search finds all. */
+export function searchKeymap(query: string): KeyEntry[] {
+  const q = query.trim().toLowerCase();
+  if (!q) return KEYMAP;
+  return KEYMAP.filter((k) =>
+    `${k.label} ${k.keys} ${k.group}`.toLowerCase().includes(q)
+  );
+}

package/lib/keybindings/sequence.ts

@@ -0,0 +1,64 @@
+// Two-key sequences (g then i). The matcher is fed every plain key press; it
+// says whether the key started a sequence, finished one, or is nobody's.
+
+export const SEQUENCE_MS = 1500;
+
+/**
+ * The key a bare shortcut sees, or null. The hints print letters in
+ * capitals, so Shift+G counts as g; other shifted keys are nobody's but "?".
+ */
+export function plainKey(key: string, shift: boolean): string | null {
+  if (key === "?" || /^[a-z]$/i.test(key)) return key.toLowerCase();
+  return shift ? null : key;
+}
+
+export type SequenceStep =
+  | { kind: "none" }
+  | { kind: "pending"; first: string }
+  | { kind: "match"; id: string };
+
+export class SequenceMatcher {
+  private first: string | null = null;
+  private at = 0;
+  private starts: Set<string>;
+  private pairs: Map<string, string>;
+
+  /** `sequences` maps "g i" to the id it runs. */
+  constructor(
+    sequences: Record<string, string>,
+    private now: () => number = Date.now
+  ) {
+    this.pairs = new Map(
+      Object.entries(sequences).map(([k, id]) => [k.toLowerCase(), id])
+    );
+    this.starts = new Set([...this.pairs.keys()].map((k) => k.split(" ")[0]));
+  }
+
+  /** A key was pressed with no modifier but maybe shift. */
+  feed(key: string): SequenceStep {
+    const k = key.toLowerCase();
+    if (this.first !== null && this.now() - this.at <= SEQUENCE_MS) {
+      const id = this.pairs.get(`${this.first} ${k}`);
+      this.first = null;
+      if (id) return { kind: "match", id };
+    }
+    this.first = null;
+    if (this.starts.has(k)) {
+      this.first = k;
+      this.at = this.now();
+      return { kind: "pending", first: k };
+    }
+    return { kind: "none" };
+  }
+
+  /** Whether the first key of a sequence is waiting for its second. */
+  pending(): string | null {
+    return this.first !== null && this.now() - this.at <= SEQUENCE_MS
+      ? this.first
+      : null;
+  }
+
+  reset(): void {
+    this.first = null;
+  }
+}

package/lib/live/service.ts

@@ -259,7 +259,7 @@ export async function changeCode(
   id: string,
   next: { generate: true } | { code: string } | null
 ): Promise<void> {
-  const rt = runtimeFor(id);
+  runtimeFor(id);
   let code: string | null = null;
   if (next && "code" in next) {
     const why = codeRefusal(next.code);

package/lib/nav/history-mirror.ts

@@ -0,0 +1,59 @@
+/**
+ * What the page remembers of the history entries it made, for the menu behind
+ * the back button: the browser won't list its own history. Entries are keyed
+ * by the `index` also kept in each entry's state, so a reload or a back
+ * button still finds its place.
+ */
+export interface MirrorEntry {
+  index: number;
+  sessionId: string;
+  name: string;
+}
+
+export interface Mirror {
+  entries: MirrorEntry[];
+  current: number;
+}
+
+export const MAX_MIRROR = 100;
+
+export const emptyMirror = (): Mirror => ({ entries: [], current: -1 });
+
+/** Standing on an entry that is new (a push) or known (replace or reload):
+ * a push drops the forward entries, as the browser does. */
+export function visit(
+  m: Mirror,
+  entry: MirrorEntry,
+  how: "push" | "replace"
+): Mirror {
+  const kept =
+    how === "push"
+      ? m.entries.filter((e) => e.index < entry.index)
+      : m.entries.filter((e) => e.index !== entry.index);
+  const entries = [...kept, entry]
+    .sort((a, b) => a.index - b.index)
+    .slice(-MAX_MIRROR);
+  return { entries, current: entry.index };
+}
+
+/** Back or forward landed on the entry with this index. */
+export const moveTo = (m: Mirror, index: number): Mirror =>
+  m.entries.some((e) => e.index === index) ? { ...m, current: index } : m;
+
+export const earlier = (m: Mirror): MirrorEntry[] =>
+  m.entries.filter((e) => e.index < m.current).reverse();
+
+export const later = (m: Mirror): MirrorEntry[] =>
+  m.entries.filter((e) => e.index > m.current);
+
+/** A renamed chat reads under its new name in the menu. */
+export const renameIn = (
+  m: Mirror,
+  sessionId: string,
+  name: string
+): Mirror => ({
+  ...m,
+  entries: m.entries.map((e) =>
+    e.sessionId === sessionId ? { ...e, name } : e
+  ),
+});

package/lib/nav/history-writer.ts

@@ -0,0 +1,109 @@
+import type { Position } from "./position";
+
+/**
+ * The one place the page writes browser history. A chat switch or a bookmark
+ * pushes an entry; where the reader is in the chat goes into the CURRENT
+ * entry's state with replaceState, at most once per POSITION_EVERY_MS, so
+ * back lands on the message that was on screen without filling the history
+ * (Safari throws after 100 calls in 30 seconds, Firefox throws on a burst,
+ * Chrome drops them silently).
+ *
+ * Next patches pushState/replaceState to carry its own keys in the state it
+ * is given, so the state is always the current one with `aos` replaced.
+ */
+export interface NavState {
+  v: 1;
+  /** Counts up with every push; the menu's key for the entry. */
+  index: number;
+  sessionId: string | null;
+  pos?: Position;
+}
+
+export interface HistoryLike {
+  state: unknown;
+  pushState(state: unknown, unused: string, url?: string): void;
+  replaceState(state: unknown, unused: string, url?: string): void;
+}
+
+export const POSITION_EVERY_MS = 2000;
+// Position writes stop, navigation never does, when a burst gets this close
+// to the limits above.
+const BURST_WINDOW_MS = 30_000;
+const BURST_MAX = 50;
+
+export function navStateOf(state: unknown): NavState | null {
+  const aos = (state as { aos?: NavState } | null)?.aos;
+  return aos && aos.v === 1 && typeof aos.index === "number" ? aos : null;
+}
+
+const withNav = (state: unknown, aos: NavState) => ({
+  ...(state && typeof state === "object" ? state : {}),
+  aos,
+});
+
+export class HistoryWriter {
+  private pending: { sessionId: string; pos: Position } | null = null;
+  private lastWrite = -Infinity;
+  private timer: ReturnType<typeof setTimeout> | null = null;
+  private writes: number[] = [];
+
+  constructor(private h: HistoryLike) {}
+
+  /** The state of the entry the page is on. */
+  current(): NavState | null {
+    return navStateOf(this.h.state);
+  }
+
+  /** Where the reader is now; written into the current entry, coalesced. */
+  setPosition(sessionId: string, pos: Position): void {
+    this.pending = { sessionId, pos };
+    if (this.timer) return;
+    const wait = this.lastWrite + POSITION_EVERY_MS - Date.now();
+    if (wait <= 0) this.flush();
+    else this.timer = setTimeout(() => this.flush(), wait);
+  }
+
+  /** Writes the waiting position now, if it belongs to the current entry. */
+  flush(): void {
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = null;
+    const p = this.pending;
+    this.pending = null;
+    const cur = this.current();
+    if (!p || !cur || cur.sessionId !== p.sessionId) return;
+    const now = Date.now();
+    this.writes = this.writes.filter((t) => now - t < BURST_WINDOW_MS);
+    if (this.writes.length >= BURST_MAX) return;
+    this.writes.push(now);
+    this.lastWrite = now;
+    this.h.replaceState(withNav(this.h.state, { ...cur, pos: p.pos }), "");
+  }
+
+  /** A new entry for a chat. The one being left keeps its position first. */
+  push(href: string, sessionId: string | null): NavState {
+    this.flush();
+    const cur = this.current();
+    const next: NavState = {
+      v: 1,
+      index: (cur?.index ?? 0) + 1,
+      sessionId,
+    };
+    this.h.pushState(withNav(null, next), "", href);
+    return next;
+  }
+
+  /** The same entry at another address (a rename), keeping its state. A page
+   * that has none yet gets its first, index 0. */
+  replace(href: string, sessionId: string | null): NavState {
+    const cur = this.current();
+    const next: NavState = cur
+      ? { ...cur, sessionId }
+      : { v: 1, index: 0, sessionId };
+    // A different chat takes the entry over: its position was another's.
+    if (cur && cur.sessionId !== sessionId) delete next.pos;
+    if (this.pending && this.pending.sessionId !== sessionId)
+      this.pending = null;
+    this.h.replaceState(withNav(this.h.state, next), "", href);
+    return next;
+  }
+}

package/lib/nav/position.ts

@@ -0,0 +1,67 @@
+import type { ChatItem } from "@/lib/chat/events";
+import type { ChatView } from "@/lib/chat-views/types";
+
+/** Where a reader is in a chat: the block in view's key, how far its top is
+ * from the top of the list, and whether they follow the latest output. */
+export interface Position {
+  block: string | null;
+  offsetPx: number;
+  atEnd: boolean;
+}
+
+export interface RowRect {
+  key: string;
+  top: number;
+  bottom: number;
+}
+
+/** The first row whose bottom is below the top of the list, and how far its
+ * top sits from there (negative when it is partly scrolled off). */
+export function anchorOf(
+  listTop: number,
+  rows: RowRect[],
+  atEnd: boolean
+): Position {
+  if (atEnd) return { block: null, offsetPx: 0, atEnd: true };
+  const row = rows.find((r) => r.bottom > listTop + 1);
+  if (!row) return { block: null, offsetPx: 0, atEnd: true };
+  return {
+    block: row.key,
+    offsetPx: Math.round(row.top - listTop),
+    atEnd: false,
+  };
+}
+
+export type OpenAt =
+  | { kind: "latest" }
+  | { kind: "new"; itemId: string; hasBefore: boolean }
+  | { kind: "position"; block: string; offsetPx: number };
+
+interface OpenInput {
+  /** What the server remembers about this chat; none when never opened. */
+  view: Pick<ChatView, "itemId" | "offsetPx" | "atEnd" | "viewedAt"> | null;
+  /** The loaded items, oldest first. */
+  items: Pick<ChatItem, "id" | "createdAt">[];
+  /** Opened from a notification, Needs you or the Inbox. */
+  latest: boolean;
+}
+
+/**
+ * Where a chat opens when nothing asked for a particular message:
+ * - from a notification, Needs you or the Inbox: the latest;
+ * - with items newer than the last time it was open: the first new one;
+ * - otherwise where it was left, unless that was the end;
+ * - never opened: the latest.
+ */
+export function decideOpen({ view, items, latest }: OpenInput): OpenAt {
+  if (latest || !view) return { kind: "latest" };
+  const firstNew = items.findIndex((i) => i.createdAt > view.viewedAt);
+  if (firstNew !== -1)
+    return {
+      kind: "new",
+      itemId: items[firstNew].id,
+      hasBefore: firstNew > 0,
+    };
+  if (view.atEnd || !view.itemId) return { kind: "latest" };
+  return { kind: "position", block: view.itemId, offsetPx: view.offsetPx };
+}

package/lib/nav/recent.ts

@@ -0,0 +1,34 @@
+// Which chat was open before this one, and chats most-recently-opened first.
+// "Opened" is the chat's viewed_at, which the page stamps whenever a chat is
+// shown, so it is the same on every device.
+
+/** When each chat was last opened, by session id (epoch ms). */
+export type Opened = Record<string, number | undefined>;
+
+/** Most recently opened first; never-opened chats keep their order after. */
+export function recentFirst<T extends { id: string }>(
+  items: readonly T[],
+  opened: Opened
+): T[] {
+  return items
+    .map((item, i) => ({ item, i, at: opened[item.id] ?? -1 }))
+    .sort((a, b) => b.at - a.at || a.i - b.i)
+    .map((x) => x.item);
+}
+
+/** The chat opened just before the current one, among those still open. */
+export function previousChatId(
+  ids: readonly string[],
+  opened: Opened,
+  currentId: string | null | undefined
+): string | null {
+  let best: string | null = null;
+  let bestAt = -1;
+  for (const id of ids) {
+    const at = opened[id];
+    if (id === currentId || at === undefined || at <= bestAt) continue;
+    best = id;
+    bestAt = at;
+  }
+  return best;
+}

package/lib/orchestrator/armed.ts

@@ -30,6 +30,7 @@ import { isFast } from "../project-tier/getProjectTier";
 import { workspaceTask } from "./targets";
 import { markStatusDirty } from "../status/dirty";
 import { setPr } from "../db/session-parts";
+import { noteAutoArmed } from "./fast-lane-state";
 
 // Judged again at least this often, for what the fingerprint can't see.
 export const ARMED_RECHECK_MS = 5 * 60 * 1000;
@@ -140,6 +141,10 @@ async function armedNow(workspaceId: string, task: Session): Promise<string> {
 export function disarm(workspaceId: string, ref: string): string {
   const task = workspaceTask(workspaceId, ref);
   setArmed(task.id, false);
+  // A fast task not yet auto-armed would be armed on the next pass; mark
+  // its PR as handled so the disarm sticks either way.
+  if (isFast(task) && task.pr_number)
+    noteAutoArmed(task.id, workspaceId, task.pr_number);
   return `Disarmed ${task.name}: it merges only through sign_off now.`;
 }
 

package/lib/palette/sections.ts

@@ -18,6 +18,8 @@ export interface Section {
 export const PER_TAB = 5;
 export const RECENT = 5;
 const NEEDS_YOU = 5;
+// The hint on the chat on show, which a switcher skips past.
+export const CURRENT = "Current";
 const SUGGESTED = 6;
 
 const label = (tab: PaletteTab) =>
@@ -61,11 +63,10 @@ export function tabItems(
   usage: Usage,
   now: number
 ): PaletteCommand[] {
-  return scoreCommands(
-    commands.filter((c) => tabOf(c) === tab),
-    query,
-    boostFor(usage, now)
-  ).map((m) => m.c);
+  const inTab = commands.filter((c) => tabOf(c) === tab);
+  // Sessions read most-recent-first (the order they were registered in).
+  if (tab === "sessions" && !query.trim()) return inTab;
+  return scoreCommands(inTab, query, boostFor(usage, now)).map((m) => m.c);
 }
 
 // The short list All opens on: the last things run, sessions that need the
@@ -99,13 +100,18 @@ export function emptySections(
       .filter((c): c is PaletteCommand => !!c),
     RECENT
   );
+  const recentChats = take(
+    commands.filter((c) => tabOf(c) === "sessions" && c.hint !== CURRENT),
+    RECENT
+  );
   const sections: Section[] = [
+    { name: "Recent chats", items: recentChats },
     { name: "Recent", items: recent },
     { name: "Needs you / running", items: busy },
     { name: "This session", items: here },
   ];
   // A first run has no history: offer the commands that start things.
-  if (recent.length + busy.length + here.length < 4)
+  if (recent.length + busy.length + here.length + recentChats.length < 4)
     sections.push({
       name: "Suggested",
       items: take(

package/lib/recipes/timer.ts

@@ -67,7 +67,9 @@ export function setTimer(
   if (!isTimezone(timezone)) throw new Error(`Unknown time zone "${timezone}"`);
   const bad = cronError(cron);
   if (bad) throw new Error(bad);
-  if (minGapMinutes(cron, timezone) < MIN_GAP_MINUTES)
+  if (
+    minGapMinutes(cron, timezone, Date.now(), MIN_GAP_MINUTES) < MIN_GAP_MINUTES
+  )
     throw new Error("A recipe runs at most once an hour");
   const enabled = input.enabled ?? true;
   if (!existing) {

package/lib/schedules/cron.ts

@@ -261,16 +261,25 @@ export const MIN_GAP_MINUTES = 60;
 // A message to a session, at most this often.
 export const MESSAGE_MIN_GAP_MINUTES = 10;
 
-// The shortest gap between runs over the next few weeks of them.
+// The shortest gap between runs over the next few weeks of them. With
+// `stopBelow`, it returns as soon as a gap under it turns up: "every minute"
+// then costs two searches, not two hundred.
 export function minGapMinutes(
   cron: string,
   timezone: string,
-  from = Date.now()
+  from = Date.now(),
+  stopBelow = 0
 ): number {
-  const runs = nextRuns(cron, from, 200, timezone);
+  const parsed = parseCron(cron);
   let min = Infinity;
-  for (let i = 1; i < runs.length; i++)
-    min = Math.min(min, (runs[i] - runs[i - 1]) / 60_000);
+  let prev = nextRun(parsed, from, timezone);
+  for (let i = 1; i < 200 && prev !== null; i++) {
+    const next = nextRun(parsed, prev, timezone);
+    if (next === null) break;
+    min = Math.min(min, (next - prev) / 60_000);
+    if (min < stopBelow) break;
+    prev = next;
+  }
   return min;
 }
 

package/lib/schedules/store.ts

@@ -298,7 +298,7 @@ function validate(
   if (
     !oneOff &&
     (input.kind === "task" || input.kind === "session") &&
-    minGapMinutes(cron, timezone) < MIN_GAP_MINUTES
+    minGapMinutes(cron, timezone, Date.now(), MIN_GAP_MINUTES) < MIN_GAP_MINUTES
   )
     throw new Error(
       "A task or session schedule runs at most once an hour; for more often, post to the orchestrator"
@@ -309,7 +309,8 @@ function validate(
   if (
     !oneOff &&
     (message || agentCheckIn) &&
-    minGapMinutes(cron, timezone) < MESSAGE_MIN_GAP_MINUTES
+    minGapMinutes(cron, timezone, Date.now(), MESSAGE_MIN_GAP_MINUTES) <
+      MESSAGE_MIN_GAP_MINUTES
   )
     throw new Error(
       `A message schedule runs at most every ${MESSAGE_MIN_GAP_MINUTES} minutes`

package/lib/security/demo.ts

@@ -150,6 +150,8 @@ const READS = [
   "demo",
   // The changelog: a static file, no agent.
   "whats-new",
+  // Tip of the Day: reading is a static file plus two settings.
+  "tips",
 ].map(route);
 
 // The only writes, each a database write and nothing more in demo mode: