@saadnvd1/agent-os 0.3.700 → 0.3.715

package/lib/sidebar/shelves.ts

@@ -1,6 +1,6 @@
 // The sidebar's one flat list, sorted onto shelves: the workspace's pinned
-// orchestrator, Pinned, Needs you, Working, In review, Ongoing, Snoozed, then
-// Done. Client-safe: no database.
+// orchestrator, Pinned, the user's groups, Needs you, Working, In review,
+// Ongoing, Snoozed, then Done. Client-safe: no database.
 import type { Session } from "@/lib/db/types";
 import { fromSqliteTime } from "@/lib/session-meta";
 import type { PrStage } from "@/lib/tasks/pr-stage";
@@ -42,6 +42,25 @@ export interface RowStatus {
   detail?: string | null;
 }
 
+// A named shelf the user files sessions into (lib/session-groups). Native
+// reads the same shape from GET /api/sessions.
+export interface SessionGroup {
+  id: string;
+  workspace_id: string | null;
+  name: string;
+  sort_order: number;
+  collapsed: boolean;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface GroupShelf {
+  group: SessionGroup;
+  rows: SidebarRow[];
+  // What a folded header still has to say.
+  rollup: { needsYou: number };
+}
+
 export interface SidebarRow {
   session: Session;
   status: RowStatus | undefined;
@@ -60,8 +79,11 @@ export interface SidebarRow {
   activeAt: number;
   // While snoozed: when it wakes (ms).
   wakesAt?: number;
-  // A plain session in Done: marked by hand, or settled by itself.
+  // A plain session in Done: marked by hand, or settled by itself. In a
+  // group, "auto" only mutes the row: it stays where it was put.
   settled?: "manual" | "auto";
+  // The group it belongs to, even while Done holds it (Reopen goes back).
+  groupName?: string;
   // Its agent is being stopped, is stopped, or is starting again
   // (lib/tasks/pause): until is when it resumes by itself (ms), null: when
   // someone resumes it.
@@ -76,6 +98,8 @@ export interface Shelves {
   // Each shown workspace's current orchestrator, while it's pinned.
   orchestrators: SidebarRow[];
   pinned: SidebarRow[];
+  // The shown groups in order, empty ones too.
+  groups: GroupShelf[];
   needsYou: SidebarRow[];
   working: SidebarRow[];
   inReview: SidebarRow[];
@@ -145,6 +169,9 @@ export interface ShelfInput {
   currentOrchestrators?: ReadonlySet<string>;
   // Only the sessions this orchestrator session started.
   startedBy?: string | null;
+  // The live groups to show, in the order to draw them. A session in any
+  // other group id is filed by status as if it had none.
+  groups?: readonly SessionGroup[];
   // The clock (ms): wakes and 3-day settles are read from it.
   now?: number;
 }
@@ -274,6 +301,24 @@ function toRow(input: ShelfInput, session: Session, now: number): SidebarRow {
   };
 }
 
+// Where a row goes when nothing the user did holds it: what it needs, what
+// it's doing, then how finished it is. Sets settled on a plain session in Done.
+function statusShelf(
+  row: SidebarRow,
+  now: number
+): "needsYou" | "working" | "inReview" | "ongoing" | "snoozed" | "done" {
+  if (row.need) return "needsYou";
+  // A stopped agent is not working, whatever its last status said.
+  if (row.paused?.state === "paused") return "snoozed";
+  if (row.working) return "working";
+  if (row.wakesAt) return "snoozed";
+  if (row.task || row.session.task_status) return quietShelf(row.task);
+  const settled = settledHow(row.session, now);
+  if (!settled) return "ongoing";
+  row.settled = settled;
+  return "done";
+}
+
 export function buildShelves(input: ShelfInput): Shelves {
   const now = input.now ?? Date.now();
   const rows = input.sessions
@@ -314,6 +359,7 @@ export function buildShelves(input: ShelfInput): Shelves {
   const shelves: Shelves = {
     orchestrators: [],
     pinned: [],
+    groups: [],
     needsYou: [],
     working: [],
     inReview: [],
@@ -321,26 +367,36 @@ export function buildShelves(input: ShelfInput): Shelves {
     snoozed: [],
     done: [],
   };
+  const filtered = !!input.query?.trim() || !!input.projectId;
+  const grouped = new Map<string, GroupShelf>(
+    (input.groups ?? []).map((group) => [
+      group.id,
+      { group, rows: [], rollup: { needsYou: 0 } },
+    ])
+  );
   for (const row of top) {
     const { pinned, role, id } = row.session;
     const current = !!input.currentOrchestrators?.has(id);
+    const mine = grouped.get(row.session.session_group_id ?? "");
+    // Named on a row outside its group (Pinned, Done); inside, the header says it.
+    if (mine) row.groupName = mine.group.name;
     if (pinned && current) shelves.orchestrators.push(row);
     else if (pinned && role !== "orchestrator") shelves.pinned.push(row);
-    else if (row.need) shelves.needsYou.push(row);
-    // A stopped agent is not working, whatever its last status said.
-    else if (row.paused?.state === "paused") shelves.snoozed.push(row);
-    else if (row.working) shelves.working.push(row);
-    else if (row.wakesAt) shelves.snoozed.push(row);
-    else if (row.task || row.session.task_status)
-      shelves[quietShelf(row.task)].push(row);
     else {
-      const settled = settledHow(row.session, now);
-      if (settled) {
-        row.settled = settled;
-        shelves.done.push(row);
-      } else shelves.ongoing.push(row);
+      const shelf = statusShelf(row, now);
+      // Membership beats status. Only finished work goes on to Done (it keeps
+      // its group); a session that merely went quiet stays, muted.
+      if (mine && (shelf !== "done" || row.settled === "auto")) {
+        delete row.groupName;
+        mine.rows.push(row);
+        if (row.need) mine.rollup.needsYou++;
+      } else shelves[shelf].push(row);
     }
   }
+  for (const shelf of grouped.values()) {
+    shelf.rows.sort((a, b) => b.activeAt - a.activeAt);
+    if (!filtered || shelf.rows.length > 0) shelves.groups.push(shelf);
+  }
   shelves.orchestrators.sort(oldestFirst);
   shelves.pinned.sort(oldestFirst);
   shelves.needsYou.sort(newestFirst);
@@ -357,6 +413,24 @@ export function buildShelves(input: ShelfInput): Shelves {
   return shelves;
 }
 
+// The groups to draw, in the order to draw them: by workspace (in the order
+// given; groups of no workspace last), then by their own order.
+export function orderGroups(
+  groups: readonly SessionGroup[],
+  workspaceOrder: readonly string[]
+): SessionGroup[] {
+  const rank = (g: SessionGroup) => {
+    const at = g.workspace_id ? workspaceOrder.indexOf(g.workspace_id) : -1;
+    return at < 0 ? workspaceOrder.length : at;
+  };
+  return [...groups].sort(
+    (a, b) =>
+      rank(a) - rank(b) ||
+      a.sort_order - b.sort_order ||
+      a.created_at.localeCompare(b.created_at)
+  );
+}
+
 // Done shows 10 at first, then 25 more per "Show more".
 export const doneLimit = (pages: number) =>
   DONE_FIRST_PAGE + Math.max(0, pages) * DONE_PAGE;
@@ -424,6 +498,7 @@ export function sameRow(a: SidebarRow, b: SidebarRow): boolean {
     a.paused?.until === b.paused?.until &&
     a.paused?.note === b.paused?.note &&
     a.settled === b.settled &&
+    a.groupName === b.groupName &&
     a.workers.length === b.workers.length &&
     a.workers.every((w, i) => sameRow(w, b.workers[i])) &&
     (a.quick?.length ?? 0) === (b.quick?.length ?? 0) &&

package/lib/sidebar/visible-order.ts

@@ -11,6 +11,10 @@ export interface ShelfFolds {
 // to the pages shown. SessionShelves renders from this too, so the two agree.
 export function shownShelves(shelves: Shelves, folds: ShelfFolds) {
   return {
+    groups: shelves.groups.map((g) => ({
+      ...g,
+      rows: g.group.collapsed ? [] : g.rows,
+    })),
     snoozed: folds.snoozedCollapsed ? [] : shelves.snoozed,
     done: folds.doneCollapsed
       ? []
@@ -32,6 +36,7 @@ export function visibleSessionIds(
   return flatten([
     ...shelves.orchestrators,
     ...shelves.pinned,
+    ...shown.groups.flatMap((g) => g.rows),
     ...shelves.needsYou,
     ...shelves.working,
     ...shelves.inReview,

package/lib/tasks/hold-checks.ts

@@ -16,7 +16,7 @@ import { DEFAULT_PRIORITY, type Priority } from "./schedule-types";
 import { machineHolds, holdReason, type Hold } from "./holds";
 import { heavyNeeds, meetsNeeds, needsOf, type Need } from "./placement";
 import { expandHome } from "./session";
-import { afterLabel, hasFinished } from "./queue-rows";
+import { afterLabel, afterMet, hasFinished } from "./queue-rows";
 import type { QueueRow } from "./queue-types";
 import type { PauseBy } from "./schedule-types";
 
@@ -46,6 +46,8 @@ export const autoHold = (
 
 // `after X`: the task it waits on hasn't finished.
 export function afterHold(r: QueueRow): Hold | null {
+  if (r.after_claim && !afterMet(r))
+    return { code: "after_claim", text: `After ${afterLabel(r)}` };
   if (!r.after_task || hasFinished(r.after_task)) return null;
   return {
     code: "after",

package/lib/tasks/holds.ts

@@ -64,6 +64,7 @@ export type MachineCode =
 export type Hold =
   | { code: "after"; text: string }
   | { code: "after_any"; text: string }
+  | { code: "after_claim"; text: string }
   | { code: "orch_paused"; text: string }
   | { code: "window"; text: string }
   | {
@@ -80,6 +81,7 @@ export type Hold =
 export const HOLD_ORDER: readonly WaitCode[] = [
   "after",
   "after_any",
+  "after_claim",
   "orch_paused",
   "window",
   "needs",
@@ -95,6 +97,7 @@ export const HOLD_ORDER: readonly WaitCode[] = [
 const CLEARS_BY_ITSELF: Record<WaitCode, boolean> = {
   after: true,
   after_any: true,
+  after_claim: true,
   orch_paused: false,
   window: true,
   needs: false,

package/lib/tasks/index.ts

@@ -47,6 +47,7 @@ import {
   type TaskState,
 } from "./state";
 import { expandHome, prFor, storedPR, taskSessions } from "./session";
+import { fileInGroup } from "../session-groups/assignSessions";
 import { InProgressError, type OrchestratedBundle } from "./move-bundle";
 import { holdFor, mayHold } from "./held";
 import { orchestratorOf, recordStart, type StartVia } from "./starter";
@@ -169,6 +170,8 @@ export async function createTask(opts: {
   // How its agent runs: as a chat (the default, DEFAULT_START_VIEW) or in
   // a terminal.
   view?: StartView;
+  // The user's group it joins as it starts (lib/session-groups).
+  groupId?: string;
   // Started by another machine's orchestrator, which this one holds it for
   // (held.ts): that machine's paired device and its description of the task.
   held?: { device: string; orchestrated: OrchestratedBundle };
@@ -292,6 +295,7 @@ async function startTask(
       startedByDevice: opts.held?.device ?? opts.startedByDevice,
     });
     if (opts.pieceId) claimPiece(opts.pieceId, session.id);
+    if (opts.groupId) fileInGroup(session.id, opts.groupId);
     opts.onCreated?.(session.id);
     return session;
   }
@@ -416,6 +420,7 @@ async function startTask(
     throw error;
   }
   if (opts.held) holdFor(id, opts.held.device, opts.held.orchestrated);
+  if (opts.groupId) fileInGroup(id, opts.groupId);
   opts.onCreated?.(id);
   void naming.refine?.(id);
 

package/lib/tasks/queue-rows.ts

@@ -6,6 +6,7 @@
 import { db, type Session } from "../db";
 import { getProject } from "../projects";
 import { getWorkspace } from "../workspaces";
+import { liveClaim } from "../claims/store";
 import { queuedLabel } from "./queue-held";
 import type { Group } from "./schedule";
 import type { QueueRow } from "./queue-types";
@@ -106,6 +107,8 @@ export function stillWorking(taskId: string): boolean {
 }
 
 export function afterMet(r: QueueRow): boolean {
+  // A claim is over when it is gone, released or expired.
+  if (r.after_claim && liveClaim(r.after_claim)) return false;
   if (r.after_task && !hasFinished(r.after_task)) return false;
   if (r.after_any && !r.after_any_used) {
     const ids = JSON.parse(r.after_any) as string[];
@@ -171,7 +174,7 @@ export const waitingIn = (workspaceId: string) =>
       .prepare(
         `SELECT COUNT(*) AS n FROM task_queue q JOIN projects p ON p.id = q.project_id
          WHERE q.status = 'queued' AND p.workspace_id = ?
-           AND q.after_task IS NULL AND q.after_any IS NULL
+           AND q.after_task IS NULL AND q.after_any IS NULL AND q.after_claim IS NULL
            AND q.plan_only IS NULL`
       )
       .get(workspaceId) as { n: number }
@@ -180,6 +183,10 @@ export const waitingIn = (workspaceId: string) =>
 export const label = queuedLabel;
 
 export function afterLabel(r: QueueRow): string | null {
+  if (r.after_claim) {
+    const c = liveClaim(r.after_claim);
+    return c ? `${c.goal} on ${c.originName}` : "a work claim";
+  }
   if (r.after_task) {
     const s = sessionOf(r.after_task);
     const q = s ? null : row(r.after_task);

package/lib/tasks/queue-start.ts

@@ -138,6 +138,7 @@ export async function startRow(
     startedVia: (r.started_via ??
       (r.started_by ? "session" : "person")) as StartVia,
     view: r.view ?? undefined,
+    groupId: r.session_group_id ?? undefined,
     agent: (r.agent_type as AgentType | null) ?? undefined,
     baseBranch: r.base_branch ?? undefined,
     hostId: placed?.hostId ?? r.host_id ?? undefined,

package/lib/tasks/queue-types.ts

@@ -26,6 +26,8 @@ export interface QueueRow {
   started_by_device: string | null;
   started_via: string | null;
   view: "chat" | "terminal" | null;
+  // The user's group it joins when it starts (lib/session-groups).
+  session_group_id: string | null;
   agent_type: string | null;
   base_branch: string | null;
   host_id: string | null;
@@ -37,6 +39,9 @@ export interface QueueRow {
   // The finish (a task id) this "after any" waiter took; one finish lets one
   // waiter go (a unique index keeps it so).
   after_any_used: string | null;
+  // A work claim (lib/claims) it waits on, by claim id, until the claim is
+  // released or expires.
+  after_claim: string | null;
   priority: Priority;
   // What it needs from a machine, as JSON, when the starter said.
   machine_needs: string | null;
@@ -102,10 +107,13 @@ export interface QueueRequest {
   // The waiting plan piece it builds, claimed for its queue id.
   pieceId?: number;
   view?: "chat" | "terminal";
+  // The user's group it joins when it starts: a live group of its workspace.
+  groupId?: string;
   agent?: AgentType;
   baseBranch?: string;
   hostId?: string;
-  // A task's id or name, or "any" for whichever running task finishes first.
+  // A task's id or name, "any" for whichever running task finishes first, or
+  // "claim:<id>" for a work claim on a linked machine.
   after?: string;
   // Set when the orchestrator starts it.
   originWorkspaceId?: string;

package/lib/tasks/queue.ts

@@ -23,6 +23,7 @@ import { randomUUID } from "crypto";
 import { db } from "../db";
 import { getProject } from "../projects";
 import { isRemoteHost } from "../hosts";
+import { liveClaim } from "../claims/store";
 import { isPaused } from "../orchestrator/pause";
 import { BrakeRefused, recordStart } from "../orchestrator/brakes";
 import { discardQueuedHeld, queuedLabel } from "./queue-held";
@@ -81,6 +82,7 @@ export function queueIfNeeded(req: QueueRequest): QueuedTaskView | null {
   const limit = limitOf(workspaceId);
   let afterTask: string | null = null;
   let afterAny: string[] | null = null;
+  let afterClaim: string | null = null;
   const after = req.after?.trim();
   // "any" with nothing working is nothing to wait for: it starts at once.
   let waits = !!after;
@@ -92,6 +94,12 @@ export function queueIfNeeded(req: QueueRequest): QueuedTaskView | null {
       afterAny = null;
       waits = false;
     }
+  } else if (after?.toLowerCase().startsWith("claim:")) {
+    afterClaim = after.slice("claim:".length).trim();
+    if (!liveClaim(afterClaim))
+      throw new Error(
+        `No live work claim "${afterClaim}": it ended, or it isn't known here`
+      );
   } else if (after)
     afterTask = resolveAfter(after, req.originWorkspaceId ?? workspaceId).id;
   if (req.now && waits)
@@ -133,10 +141,10 @@ export function queueIfNeeded(req: QueueRequest): QueuedTaskView | null {
   // The row and the piece claim stand or fall together.
   db.transaction(() => {
     db.prepare(
-      `INSERT INTO task_queue (id, project_id, prompt, name, model, model_overrides, plan, plan_reason, plan_only, started_by, parent_session_id, started_by_device, started_via, view, agent_type, base_branch,
-         host_id, after_task, after_any, origin_workspace_id, priority, machine_needs, position)
-       VALUES (@id, @project_id, @prompt, @name, @model, @model_overrides, @plan, @plan_reason, @plan_only, @started_by, @parent_session_id, @started_by_device, @started_via, @view, @agent_type, @base_branch,
-         @host_id, @after_task, @after_any, @origin, @priority, @machine_needs,
+      `INSERT INTO task_queue (id, project_id, prompt, name, model, model_overrides, plan, plan_reason, plan_only, started_by, parent_session_id, started_by_device, started_via, view, session_group_id, agent_type, base_branch,
+         host_id, after_task, after_any, after_claim, origin_workspace_id, priority, machine_needs, position)
+       VALUES (@id, @project_id, @prompt, @name, @model, @model_overrides, @plan, @plan_reason, @plan_only, @started_by, @parent_session_id, @started_by_device, @started_via, @view, @session_group_id, @agent_type, @base_branch,
+         @host_id, @after_task, @after_any, @after_claim, @origin, @priority, @machine_needs,
          (SELECT COALESCE(MAX(position), 0) + 1 FROM task_queue))`
     ).run({
       id,
@@ -156,11 +164,13 @@ export function queueIfNeeded(req: QueueRequest): QueuedTaskView | null {
       started_by_device: req.startedByDevice ?? null,
       started_via: req.startedVia,
       view: req.view ?? null,
+      session_group_id: req.groupId ?? null,
       agent_type: req.agent ?? null,
       base_branch: req.baseBranch || null,
       host_id: req.hostId || null,
       after_task: afterTask,
       after_any: afterAny ? JSON.stringify(afterAny) : null,
+      after_claim: afterClaim,
       origin: req.originWorkspaceId ?? null,
       priority: req.priority ?? DEFAULT_PRIORITY,
       machine_needs: setting ? JSON.stringify(setting) : null,
@@ -217,7 +227,7 @@ export async function startQueuedForOrchestrator(
     wasFull: slots.full,
     running: slots.running,
     limit: slots.limit,
-    skippedAfter: !!(r.after_task || r.after_any),
+    skippedAfter: !!(r.after_task || r.after_any || r.after_claim),
   };
   const held = (text: string): ForcedStart => ({
     ...base,

package/lib/tasks/schedule-types.ts

@@ -33,6 +33,7 @@ export const isPriority = (v: unknown): v is Priority =>
 export type WaitCode =
   | "after"
   | "after_any"
+  | "after_claim"
   | "orch_paused"
   | "window"
   | "load_red"

package/lib/test-temp.ts

@@ -1,19 +1,35 @@
-import { mkdtempSync, rmSync } from "node:fs";
+import { existsSync, mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { join, sep } from "node:path";
+import { RUN_PREFIX } from "@/lib/worktree-sweep/testTemp";
 
 // Folders made by tempDir, removed when the test file ends (vitest.setup.ts
 // calls removeTempDirs). Kept on globalThis: vi.resetModules() would
 // otherwise lose the list.
 const KEY = Symbol.for("agentos.testTempDirs");
+const ROOT_KEY = Symbol.for("agentos.testTempRoot");
 const made = (): Set<string> => {
   const g = globalThis as unknown as Record<symbol, Set<string> | undefined>;
   return (g[KEY] ??= new Set<string>());
 };
 
+// The sweep recognises a test's leftovers by the RUN_PREFIX folder above
+// them. The suite's TMPDIR is already inside one; outside it (a script
+// importing this) the folder is made here, so every tempDir is under one.
+function base(): string {
+  const root = tmpdir();
+  if (root.split(sep).some((s) => s.startsWith(RUN_PREFIX))) return root;
+  const g = globalThis as unknown as Record<symbol, string | undefined>;
+  if (!g[ROOT_KEY] || !existsSync(g[ROOT_KEY])) {
+    g[ROOT_KEY] = mkdtempSync(join(root, RUN_PREFIX));
+    made().add(g[ROOT_KEY]);
+  }
+  return g[ROOT_KEY];
+}
+
 /** A fresh temp folder that is removed when the test file ends. */
 export function tempDir(prefix: string): string {
-  const dir = mkdtempSync(join(tmpdir(), prefix));
+  const dir = mkdtempSync(join(base(), prefix));
   made().add(dir);
   return dir;
 }

package/lib/workspaces.ts

@@ -5,6 +5,7 @@
 
 import { randomUUID } from "crypto";
 import { db, type Workspace } from "./db";
+import { clearForeignGroup } from "./session-groups/assignSessions";
 
 type WorkspaceRow = Omit<
   Workspace,
@@ -141,7 +142,14 @@ export function setProjectWorkspace(
   if (workspaceId && !getWorkspace(workspaceId)) {
     throw new Error("Unknown workspace");
   }
-  db.prepare(
-    `UPDATE projects SET workspace_id = ? WHERE id = ? AND is_uncategorized = 0`
-  ).run(workspaceId, projectId);
+  db.transaction(() => {
+    db.prepare(
+      `UPDATE projects SET workspace_id = ? WHERE id = ? AND is_uncategorized = 0`
+    ).run(workspaceId, projectId);
+    // Its sessions changed workspace, so they leave the old one's groups.
+    const ids = db
+      .prepare(`SELECT id FROM sessions WHERE project_id = ?`)
+      .all(projectId) as { id: string }[];
+    for (const { id } of ids) clearForeignGroup(id);
+  })();
 }

package/lib/worktree-sweep/testTemp.ts

@@ -1,116 +1,33 @@
-// Folders the test suite makes in the OS temp folder, by name. The sweep
-// takes only these, never another aos-… or agent-os-… folder, so AgentOS's
-// own temp folders (aos-review-, aos-rebase-…) and a person's are safe.
-// lib/test-temp.test.ts fails when a test uses a prefix missing here.
-export const TEST_TEMP_PREFIXES: readonly string[] = [
-  "agent-os-git-",
+// What the sweep may take from the OS temp folder as a test run's leftovers.
+// Every folder a test makes with tempDir() lives inside a run root named
+// RUN_PREFIX…, so the sweep matches that one prefix and a new test needs no
+// list edit. Names AgentOS makes itself (aos-snap-, aos-review-…) never
+// start with it.
+
+/** Short: a Unix socket path is capped at 104 bytes on macOS. */
+export const RUN_PREFIX = "aos-t-";
+
+// Names only the test suite created, left directly in the OS temp folder by
+// runs from before every test got its own root. Frozen: nothing new belongs
+// here. Names server code also creates (agentos-db-, agentos-img-…) are not
+// listed, since a live server could own them.
+export const LEGACY_TEST_TEMP_PREFIXES: readonly string[] = [
+  "agent-os-test-",
   "agent-os-home-",
-  "agent-os-kept-",
   "agent-os-limits-",
+  "agent-os-git-",
   "agent-os-session-logs-",
-  "agent-os-test-",
-  "aos-acc-",
-  "aos-add-",
-  "aos-armed-repo-",
-  "aos-art-",
-  "aos-autodeploy-",
-  "aos-caches-",
-  "aos-channel-",
-  "aos-clone-",
-  "aos-config-",
-  "aos-crypt-",
-  "aos-db-",
-  "aos-db-drops-",
-  "aos-db-wt-",
-  "aos-decl-",
-  "aos-device-keys-",
-  "aos-done-home-",
+  "agent-os-kept-",
   "aos-done-repo-",
-  "aos-env-",
-  "aos-fast-",
-  "aos-files-",
-  "aos-git-",
-  "aos-gr-",
-  "aos-heavy-",
-  "aos-init-route-",
-  "aos-install-",
-  "aos-kind-",
-  "aos-launch-plain-",
-  "aos-launch-repo-",
-  "aos-machine-",
-  "aos-limits-",
-  "aos-mcp-",
-  "aos-merge-policy-",
-  "aos-mig-",
-  "aos-move-",
-  "aos-no-approvals-",
-  "aos-nogit-",
-  "aos-notify-",
-  "aos-orch-act-",
-  "aos-orch-add-",
-  "aos-orch-approve-",
-  "aos-orch-armed-",
-  "aos-orch-asks-",
-  "aos-orch-brakes-",
+  "aos-orch-repo-",
+  "aos-armed-repo-",
   "aos-orch-ext-repo-",
   "aos-orch-external-",
-  "aos-orch-home-",
-  "aos-orch-move-",
-  "aos-orch-plain-",
-  "aos-orch-questions-",
-  "aos-orch-recipes-",
-  "aos-orch-remind-",
-  "aos-orch-repo-",
-  "aos-orch-rules-",
-  "aos-orch-settle-",
-  "aos-orch-signoff-",
-  "aos-orch-sweep-",
-  "aos-origin-",
-  "aos-path-",
-  "aos-peer-connect-",
-  "aos-peer-keys-",
-  "aos-plain-",
-  "aos-plan-",
-  "aos-ports-",
-  "aos-pr-",
-  "aos-pr-async-",
-  "aos-pr-create-",
-  "aos-pr-gen-",
-  "aos-pr-route-",
-  "aos-prompts-",
-  "aos-quick-",
   "aos-quick-repo-",
-  "aos-relay-",
-  "aos-relay-none-",
-  "aos-report-",
-  "aos-resurrect-claude-",
-  "aos-resurrect-home-",
-  "aos-run-",
-  "aos-runner-",
-  "aos-sec-",
-  "aos-shot-",
-  "aos-sim-",
-  "aos-spare-",
-  "aos-stack-",
-  "aos-start-opts-",
-  "aos-start-plain-",
-  "aos-sweep-own-",
-  "aos-t-",
-  "aos-task-diff-",
-  "aos-temp-helper-",
-  "aos-tmux-",
-  "aos-transcripts-",
-  "aos-ui-",
-  "aos-upd-",
-  "aos-usage-",
-  "aos-wg-",
-  "aos-wg-path-",
-  "aos-wl-",
-  "aos-worker-env-",
-  "aos-worker-tmux-",
-  "aos-wsl-",
-  "aos-wt-",
+  "aos-config-",
+  "agentos-link-",
 ];
 
 export const isTestTempName = (name: string) =>
-  TEST_TEMP_PREFIXES.some((p) => name.startsWith(p));
+  name.startsWith(RUN_PREFIX) ||
+  LEGACY_TEST_TEMP_PREFIXES.some((p) => name.startsWith(p));

package/package.json

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

package/scripts/agent-os

@@ -88,7 +88,7 @@ case "${1:-}" in
     passkeys)         shift; (cd "$(dirname "$SCRIPT_DIR")" && npx tsx lib/security/passkeys-cli.ts "$@") ;;
     logs)             cmd_logs ;;
     update)           cmd_update ;;
-    machine)          cmd_machine ;;
+    machine)          shift; cmd_machine "$@" ;;
     enable)           cmd_enable ;;
     disable)          cmd_disable ;;
     uninstall)        cmd_uninstall ;;

package/scripts/autodeploy

@@ -100,6 +100,8 @@ if [ "$head" != "$deployed" ]; then
   # The pull takes what landed while it waited, too.
   git rev-parse HEAD > "$state/deployed"
   date +%s > "$state/restarted"
+  # A link into an older clone would run an old aos on this machine.
+  scripts/sync-cli-links || log "CLI link sync failed"
 fi
 
 # Publishing waits minutes for npm to serve a version, so it runs on its own