@saadnvd1/agent-os 0.3.698 → 0.3.715

package/lib/connect/heartbeat.ts

@@ -7,12 +7,14 @@
 
 import fs from "fs";
 import path from "path";
-import { ApiError, clean } from "./control-api";
+import { ApiError, clean, type Beat } from "./control-api";
 
 export const HEARTBEAT_MS = 60_000;
 
 export interface HeartbeatOptions {
-  beat: () => Promise<{ enabled: boolean }>;
+  beat: () => Promise<Beat>;
+  /** Every answer, for what it says about the account (plan, peers). */
+  onBeat?: (beat: Beat) => void;
   /** The account disabled this machine: stop the tunnel. */
   onDisabled: () => void;
   /** The service no longer knows this machine. */
@@ -43,9 +45,15 @@ export function startHeartbeat(opts: HeartbeatOptions) {
   const tick = async () => {
     timer = null;
     try {
-      const { enabled } = await opts.beat();
+      const answer = await opts.beat();
+      const { enabled } = answer;
       if (stopped) return;
       failing = false;
+      try {
+        opts.onBeat?.(answer);
+      } catch (err) {
+        log(`connect: ${clean((err as Error)?.message ?? String(err))}`);
+      }
       if (enabled === false) {
         stop();
         log("connect: this machine was disabled in your account; tunnel off");

package/lib/connect/serve.ts

@@ -40,6 +40,7 @@ import {
   type Tunnel,
 } from "./control-api";
 import { appVersion, startHeartbeat } from "./heartbeat";
+import { noteHeartbeat } from "@/lib/peer/account";
 import { ensureCloudflared } from "./cloudflared";
 import {
   reapTunnel,
@@ -331,6 +332,7 @@ export function startConnect(
     const version = appVersion();
     const heartbeat = startHeartbeat({
       beat: () => beat(config, machineKey, version),
+      onBeat: noteHeartbeat,
       log,
       intervalMs: deps.heartbeatMs,
       onDisabled: () => {

package/lib/db/changes.ts

@@ -45,6 +45,10 @@ export const TABLES_WATCHED_CHAT_BOOKMARKS = ["chat_bookmarks"] as const;
 
 export const TABLES_WATCHED_LEARNING_CARDS = ["learning_cards"] as const;
 
+export const TABLES_WATCHED_SESSION_GROUPS = ["session_groups"] as const;
+
+export const TABLES_WATCHED_WORK_CLAIMS = ["work_claims"] as const;
+
 // Every table any migration watches, for the browser's topic map to cover.
 export const WATCHED_TABLES: readonly string[] = [
   ...TABLES_WATCHED_45,
@@ -55,6 +59,8 @@ export const WATCHED_TABLES: readonly string[] = [
   ...TABLES_WATCHED_80,
   ...TABLES_WATCHED_CHAT_BOOKMARKS,
   ...TABLES_WATCHED_LEARNING_CARDS,
+  ...TABLES_WATCHED_SESSION_GROUPS,
+  ...TABLES_WATCHED_WORK_CLAIMS,
 ];
 
 export function installChangeTriggers(

package/lib/db/migrations/20261020T1400_work_claims.ts

@@ -0,0 +1,35 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  key: "20261020T1400_work_claims",
+  up: (db) => {
+    // What each live session, here or on a linked machine, is working on:
+    // repo, branch, goal and the paths of its diff. Never code. Times are
+    // this machine's clock in ms; they cross the wire as durations.
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS work_claims (
+        id TEXT PRIMARY KEY,
+        origin TEXT NOT NULL,
+        origin_name TEXT NOT NULL,
+        via_machine TEXT,
+        hops INTEGER NOT NULL DEFAULT 0,
+        source TEXT NOT NULL,
+        session_id TEXT,
+        session_name TEXT,
+        repo TEXT NOT NULL,
+        branch TEXT,
+        base TEXT,
+        goal TEXT NOT NULL,
+        files TEXT NOT NULL DEFAULT '[]',
+        files_more INTEGER NOT NULL DEFAULT 0,
+        pr_url TEXT,
+        started_at INTEGER NOT NULL,
+        expires_at INTEGER NOT NULL,
+        released TEXT,
+        updated_at INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_work_claims_repo ON work_claims (repo, expires_at);
+      CREATE INDEX IF NOT EXISTS idx_work_claims_session ON work_claims (session_id);
+    `);
+  },
+} satisfies Migration;

package/lib/db/migrations/20261020T1515_peer_unlinked.ts

@@ -0,0 +1,22 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  key: "20261020T1515_peer_unlinked",
+  up: (db) => {
+    // A machine unlinked here, from either side (lib/peer/unlink.ts): its pin
+    // is gone, and its signing key is kept for 30 days so its next call can
+    // be told, provably, that it's no longer linked, and so Machines can say
+    // who unlinked it. Never trusted for anything else.
+    db.exec(`CREATE TABLE IF NOT EXISTS peer_unlinked (
+      machine_id TEXT PRIMARY KEY,
+      host_id TEXT,
+      sign_pub TEXT NOT NULL,
+      by_peer INTEGER NOT NULL DEFAULT 0,
+      reason TEXT NOT NULL,
+      at INTEGER NOT NULL
+    )`);
+    db.exec(
+      `CREATE INDEX IF NOT EXISTS idx_peer_unlinked_host ON peer_unlinked(host_id)`
+    );
+  },
+} satisfies Migration;

package/lib/db/migrations/20261020T1600_bus_waits.ts

@@ -0,0 +1,35 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  key: "20261020T1600_bus_waits",
+  up: (db) => {
+    // A session waiting on another (lib/bus/waits): for its reply, or for it
+    // to go idle or merge. Closed rows stay as history.
+    db.exec(`CREATE TABLE IF NOT EXISTS bus_waits (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      waiter_id TEXT NOT NULL,
+      target_id TEXT NOT NULL,
+      kind TEXT NOT NULL,
+      message_id INTEGER,
+      request TEXT,
+      deadline INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      seen_busy_at INTEGER,
+      nudged_at INTEGER,
+      closed_at INTEGER,
+      outcome TEXT,
+      reply_id INTEGER
+    )`);
+    db.exec(
+      `CREATE INDEX IF NOT EXISTS idx_bus_waits_open ON bus_waits(target_id) WHERE closed_at IS NULL`
+    );
+    db.exec(
+      `CREATE INDEX IF NOT EXISTS idx_bus_waits_waiter ON bus_waits(waiter_id) WHERE closed_at IS NULL`
+    );
+    const cols = db.prepare(`PRAGMA table_info(bus_messages)`).all() as {
+      name: string;
+    }[];
+    if (!cols.some((c) => c.name === "reply_to"))
+      db.exec(`ALTER TABLE bus_messages ADD COLUMN reply_to INTEGER`);
+  },
+} satisfies Migration;

package/lib/db/migrations/20261020T1700_clean_connect_names.ts

@@ -0,0 +1,18 @@
+import type { Migration } from "../migration-types";
+import { cleanMachineName } from "../../peer/name";
+
+export default {
+  key: "20261020T1700_clean_connect_names",
+  up: (db) => {
+    // Connect machines linked before names were cleaned in full (lib/peer/name.ts)
+    // keep the name the service gave them; clean those once.
+    const rows = db
+      .prepare(`SELECT id, name FROM hosts WHERE kind = 'connect'`)
+      .all() as { id: string; name: string }[];
+    const set = db.prepare(`UPDATE hosts SET name = ? WHERE id = ?`);
+    for (const r of rows) {
+      const clean = cleanMachineName(r.name);
+      if (clean !== r.name) set.run(clean, r.id);
+    }
+  },
+} satisfies Migration;

package/lib/db/migrations/20261020T1800_session_groups.ts

@@ -0,0 +1,49 @@
+import type { Migration } from "../migration-types";
+import {
+  installChangeTriggers,
+  TABLES_WATCHED_SESSION_GROUPS,
+} from "../changes";
+import { createSessionRowsView } from "../session-parts/view";
+
+export default {
+  key: "20261020T1800_session_groups",
+  up: (db) => {
+    // Named shelves a user files sessions into (lib/session-groups). Not the
+    // old `groups` table, which nothing reads. Additive.
+    db.exec(`CREATE TABLE IF NOT EXISTS session_groups (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT REFERENCES workspaces(id) ON DELETE SET NULL,
+      name TEXT NOT NULL,
+      sort_order INTEGER NOT NULL DEFAULT 0,
+      collapsed INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      deleted_at TEXT
+    )`);
+    db.exec(
+      `CREATE UNIQUE INDEX IF NOT EXISTS session_groups_name
+         ON session_groups(COALESCE(workspace_id, ''), lower(name))
+         WHERE deleted_at IS NULL`
+    );
+    const has = (
+      db.prepare(`PRAGMA table_info(sessions)`).all() as { name: string }[]
+    ).some((c) => c.name === "session_group_id");
+    if (!has)
+      db.exec(
+        `ALTER TABLE sessions ADD COLUMN session_group_id TEXT
+           REFERENCES session_groups(id) ON DELETE SET NULL`
+      );
+    db.exec(
+      `CREATE INDEX IF NOT EXISTS sessions_session_group
+         ON sessions(session_group_id)`
+    );
+    // A queued task remembers the group it starts in.
+    const queueHas = (
+      db.prepare(`PRAGMA table_info(task_queue)`).all() as { name: string }[]
+    ).some((c) => c.name === "session_group_id");
+    if (!queueHas)
+      db.exec(`ALTER TABLE task_queue ADD COLUMN session_group_id TEXT`);
+    createSessionRowsView(db);
+    installChangeTriggers(db, TABLES_WATCHED_SESSION_GROUPS);
+  },
+} satisfies Migration;

package/lib/db/migrations/20261020T1900_task_queue_after_claim.ts

@@ -0,0 +1,13 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  key: "20261020T1900_task_queue_after_claim",
+  up: (db) => {
+    // The work claim (lib/claims) a queued task waits on, by claim id.
+    const cols = db.prepare(`PRAGMA table_info(task_queue)`).all() as {
+      name: string;
+    }[];
+    if (!cols.some((c) => c.name === "after_claim"))
+      db.exec(`ALTER TABLE task_queue ADD COLUMN after_claim TEXT`);
+  },
+} satisfies Migration;

package/lib/db/migrations/20261020T2000_claim_notices.ts

@@ -0,0 +1,20 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  key: "20261020T2000_claim_notices",
+  up: (db) => {
+    // What a mid-work overlap between two claims has told the local session:
+    // how many syncs it has held, the shared paths last told, and whether the
+    // winner's merge has been passed on. Times are this machine's clock in ms.
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS claim_notices (
+        pair_key TEXT PRIMARY KEY,
+        hits INTEGER NOT NULL DEFAULT 0,
+        shared TEXT NOT NULL DEFAULT '[]',
+        told_at INTEGER,
+        merged_at INTEGER,
+        seen_at INTEGER NOT NULL
+      );
+    `);
+  },
+} satisfies Migration;

package/lib/db/migrations/20261020T2100_claims_via_host.ts

@@ -0,0 +1,21 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  key: "20261020T2100_claims_via_host",
+  up: (db) => {
+    // The link (hosts.id) a remote claim arrived through, and which claims
+    // machine each link talks to, so a machine linked twice is asked once.
+    const cols = db.prepare(`PRAGMA table_info(work_claims)`).all() as {
+      name: string;
+    }[];
+    if (!cols.some((c) => c.name === "via_host"))
+      db.exec(`ALTER TABLE work_claims ADD COLUMN via_host TEXT`);
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS claim_peers (
+        host_id TEXT PRIMARY KEY,
+        machine_id TEXT NOT NULL,
+        seen_at INTEGER NOT NULL
+      );
+    `);
+  },
+} satisfies Migration;

package/lib/db/migrations/20261020T2200_work_claims_watch.ts

@@ -0,0 +1,10 @@
+import type { Migration } from "../migration-types";
+import { installChangeTriggers, TABLES_WATCHED_WORK_CLAIMS } from "../changes";
+
+export default {
+  key: "20261020T2200_work_claims_watch",
+  up: (db) => {
+    // The claims sheet and the overlap pills refetch when a claim changes.
+    installChangeTriggers(db, TABLES_WATCHED_WORK_CLAIMS);
+  },
+} satisfies Migration;

package/lib/db/queries.ts

@@ -94,24 +94,6 @@ export const queries = {
       `UPDATE sessions SET worktree_path = ?, branch_name = ?, base_branch = ?, dev_server_port = ?, updated_at = datetime('now') WHERE id = ?`
     ),
 
-  updateSessionGroup: (db: Database.Database) =>
-    getStmt(
-      db,
-      `UPDATE sessions SET group_path = ?, updated_at = datetime('now') WHERE id = ?`
-    ),
-
-  getSessionsByGroup: (db: Database.Database) =>
-    getStmt(
-      db,
-      `SELECT * FROM session_rows WHERE group_path = ? ORDER BY updated_at DESC`
-    ),
-
-  moveSessionsToGroup: (db: Database.Database) =>
-    getStmt(
-      db,
-      `UPDATE sessions SET group_path = ?, updated_at = datetime('now') WHERE group_path = ?`
-    ),
-
   updateSessionProject: (db: Database.Database) =>
     getStmt(
       db,
@@ -196,28 +178,6 @@ export const queries = {
       `SELECT * FROM tool_calls WHERE message_id = ? ORDER BY timestamp ASC`
     ),
 
-  // Groups
-  getAllGroups: (db: Database.Database) =>
-    getStmt(db, `SELECT * FROM groups ORDER BY sort_order ASC, name ASC`),
-
-  getGroup: (db: Database.Database) =>
-    getStmt(db, `SELECT * FROM groups WHERE path = ?`),
-
-  createGroup: (db: Database.Database) =>
-    getStmt(db, `INSERT INTO groups (path, name, sort_order) VALUES (?, ?, ?)`),
-
-  updateGroupName: (db: Database.Database) =>
-    getStmt(db, `UPDATE groups SET name = ? WHERE path = ?`),
-
-  updateGroupExpanded: (db: Database.Database) =>
-    getStmt(db, `UPDATE groups SET expanded = ? WHERE path = ?`),
-
-  updateGroupOrder: (db: Database.Database) =>
-    getStmt(db, `UPDATE groups SET sort_order = ? WHERE path = ?`),
-
-  deleteGroup: (db: Database.Database) =>
-    getStmt(db, `DELETE FROM groups WHERE path = ?`),
-
   // Projects
   createProject: (db: Database.Database) =>
     getStmt(

package/lib/db/session-parts/columns.ts

@@ -183,4 +183,5 @@ export const SESSION_ROW_COLUMNS: readonly string[] = [
   "started_via",
   "plan_waits_for_caller",
   "plan_handoff_message",
+  "session_group_id",
 ];

package/lib/db/types.ts

@@ -90,11 +90,27 @@ export interface Session {
   pause_id?: number | null;
   // Why a requested resume hasn't happened yet.
   pause_note?: string | null;
+  // Set only by GET /api/sessions: the sessions it waits on, and who waits on
+  // it, as a short line (lib/bus/waits/store).
+  waiting_on?: string | null;
+  waited_by?: string | null;
+  // Set only by GET /api/sessions: the strongest overlap of this session's
+  // work with a claim here or on a linked machine (lib/claims/overlapCache).
+  overlap?: {
+    strength: "strong" | "weak";
+    machine: string;
+    goal: string;
+    shared: number;
+    claimId: string;
+    mineId: string;
+  } | null;
   placed_note?: string | null;
   // Set by done: hidden from the sidebar and the orchestrator, never deleted.
   archived_at: string | null;
   // On the sidebar's Pinned shelf (0/1 from SQLite).
   pinned: boolean;
+  // The user's group it sits in (session_groups), or null.
+  session_group_id?: string | null;
   // A workspace's standing orchestrator chat (and that workspace), or null.
   role: "orchestrator" | null;
   // An orchestrator's tool-call secret.
@@ -161,14 +177,6 @@ export interface Session {
   worker_status: "pending" | "running" | "completed" | "failed" | null;
 }
 
-export interface Group {
-  path: string;
-  name: string;
-  expanded: boolean;
-  sort_order: number;
-  created_at: string;
-}
-
 // production: every merge gate applies. fast: a task's PR merges when it opens.
 export type ProjectTier = "production" | "fast";
 
@@ -310,4 +318,8 @@ export interface Host {
   kind?: "ssh" | "connect";
   // Paired with that machine's own AgentOS (lib/hosts/link.ts); 0/1 from SQLite.
   linked?: boolean | number;
+  // Connect hosts (lib/peer): the link's state, and why it's suspended or
+  // who unlinked it.
+  peer_state?: "active" | "suspended" | "unlinked" | null;
+  peer_note?: string | null;
 }

package/lib/doctor/checks.ts

@@ -5,7 +5,11 @@
  */
 
 import { execFile } from "child_process";
+import fs from "fs";
+import os from "os";
+import path from "path";
 import { promisify } from "util";
+import { agentOsHome, liveCheckout } from "../dev-instance/liveServer";
 import { probeAgents, type AgentProbe } from "../agents/probe";
 import { getAllProviderDefinitions } from "../providers/registry";
 
@@ -37,12 +41,14 @@ export interface DoctorDeps {
   exec: ExecFn;
   probe: (fresh: boolean) => Promise<Record<string, AgentProbe>>;
   nodeVersion: string;
+  cliLinks: () => DoctorCheck | null;
 }
 
 const defaultDeps: DoctorDeps = {
   exec: promisify(execFile) as ExecFn,
   probe: probeAgents,
   nodeVersion: process.versions.node,
+  cliLinks: () => checkCliLinks(),
 };
 
 const INSTALL = {
@@ -190,6 +196,62 @@ export function checkAgents(probes: Record<string, AgentProbe>): DoctorCheck {
   };
 }
 
+const CLI_LINKS: Array<[string, string]> = [
+  ["agent-os", "scripts/agent-os"],
+  ["aos", "bin/aos"],
+];
+
+const real = (p: string) => {
+  try {
+    return fs.realpathSync(p);
+  } catch {
+    return null;
+  }
+};
+
+/**
+ * Do the CLI links in ~/.local/bin run the checkout the live server runs from?
+ * A link into an older clone runs an old `aos`. Null when there is no live
+ * server record or no link to judge.
+ */
+export function checkCliLinks(
+  binDir = process.env.AOS_BIN_DIR || path.join(os.homedir(), ".local/bin"),
+  home = agentOsHome()
+): DoctorCheck | null {
+  const live = liveCheckout(home);
+  if (!live) return null;
+  const stale: string[] = [];
+  let seen = 0;
+  for (const [name, rel] of CLI_LINKS) {
+    const link = path.join(binDir, name);
+    let target: string;
+    try {
+      target = fs.readlinkSync(link);
+    } catch {
+      continue;
+    }
+    seen++;
+    const want = real(path.join(live, rel));
+    if (!want || real(path.resolve(binDir, target)) !== want)
+      stale.push(`${name} -> ${target}`);
+  }
+  if (seen === 0) return null;
+  if (stale.length === 0)
+    return {
+      id: "cli-links",
+      label: "CLI links",
+      status: "ok",
+      detail: `Point at ${live}`,
+    };
+  return {
+    id: "cli-links",
+    label: "CLI links",
+    status: "warn",
+    detail: `${stale.join(", ")}; the live server runs from ${live}`,
+    fix: `${live}/scripts/sync-cli-links`,
+  };
+}
+
 let cache: { at: number; checks: Promise<DoctorCheck[]> } | null = null;
 
 /** Every check, in parallel, cached for a minute. `fresh` runs them again. */
@@ -214,7 +276,8 @@ export function runDoctor(
         detail: "Couldn't check the agent CLIs",
         fix: "Check again",
       })),
-  ]);
+    Promise.resolve(d.cliLinks()),
+  ]).then((all) => all.filter((c): c is DoctorCheck => c !== null));
   if (!custom) cache = { at: Date.now(), checks };
   return checks;
 }

package/lib/done/archive.ts

@@ -4,6 +4,7 @@
 import fs from "fs";
 import { db, queries, type Session } from "../db";
 import { statusOf } from "../orchestrator/facts";
+import { kickWaits } from "../bus/waits/kick";
 import { peerSessionLink } from "../hosts/peer-actions";
 
 export interface ArchivedView {
@@ -26,6 +27,7 @@ export function archiveSession(id: string): void {
   db.prepare(
     `UPDATE sessions SET archived_at = datetime('now') WHERE id = ? AND archived_at IS NULL`
   ).run(id);
+  kickWaits();
 }
 
 export function unarchiveSession(id: string): Session {

package/lib/git-remote.ts

@@ -12,6 +12,36 @@ export function slugOfRemote(url: string | null | undefined): string | null {
   return m ? `${m[1]}/${m[2]}`.toLowerCase() : null;
 }
 
+// A repository's key across clones and URL forms: ssh and https of the same
+// remote give the same key, with no scheme, credentials, port or ".git".
+// "host/path", lower case; null for anything that isn't a remote URL.
+export function repoKeyOfRemote(url: string | null | undefined): string | null {
+  const raw = (url ?? "").trim();
+  if (!raw) return null;
+  let host = "";
+  let path = "";
+  const scp = /^(?:[^@/:\s]+@)?([^/:\s]+):(?!\/\/)(.+)$/.exec(raw);
+  if (scp && !/^[a-z][a-z0-9+.-]*:\/\//i.test(raw)) {
+    host = scp[1];
+    path = scp[2];
+  } else {
+    try {
+      const u = new URL(raw);
+      if (!/^(https?|ssh|git):$/.test(u.protocol)) return null;
+      host = u.hostname;
+      path = u.pathname;
+    } catch {
+      return null;
+    }
+  }
+  path = path
+    .replace(/^\/+|\/+$/g, "")
+    .replace(/\.git$/i, "")
+    .toLowerCase();
+  host = host.toLowerCase();
+  return host && path.includes("/") ? `${host}/${path}` : null;
+}
+
 // A remote's URL doesn't change under a running server often enough to ask
 // git on every lookup.
 const SLUG_TTL_MS = 5 * 60 * 1000;
@@ -45,3 +75,16 @@ export function repoSlugSync(dir: string): string | null {
   slugs.set(dir, { at: Date.now(), slug });
   return slug;
 }
+
+const keys = new Map<string, { at: number; key: string | null }>();
+
+export async function repoKey(dir: string): Promise<string | null> {
+  const hit = keys.get(dir);
+  if (hit && Date.now() - hit.at < SLUG_TTL_MS) return hit.key;
+  const url = await git(dir, ["config", "--get", "remote.origin.url"], {
+    timeout: 10000,
+  }).catch(() => "");
+  const key = repoKeyOfRemote(url);
+  keys.set(dir, { at: Date.now(), key });
+  return key;
+}

package/lib/hosts/index.ts

@@ -29,7 +29,16 @@ export function listRemoteHosts(): Host[] {
       `SELECT h.*, CASE WHEN h.kind = 'connect'
           THEN EXISTS (SELECT 1 FROM peer_links p WHERE p.host_id = h.id)
           ELSE EXISTS (SELECT 1 FROM host_links l WHERE l.host_id = h.id)
-        END AS linked
+        END AS linked,
+        CASE WHEN h.kind = 'connect' THEN COALESCE(
+          (SELECT p.state FROM peer_links p WHERE p.host_id = h.id),
+          (SELECT 'unlinked' FROM peer_unlinked u WHERE u.host_id = h.id LIMIT 1))
+        END AS peer_state,
+        CASE WHEN h.kind = 'connect' THEN COALESCE(
+          (SELECT p.suspended_reason FROM peer_links p WHERE p.host_id = h.id),
+          (SELECT u.reason FROM peer_unlinked u WHERE u.host_id = h.id
+            ORDER BY u.at DESC LIMIT 1))
+        END AS peer_note
          FROM hosts h ORDER BY sort_order, created_at`
     )
     .all() as Host[];

package/lib/orchestration.ts

@@ -19,6 +19,7 @@ import { UNSET_SERVER_ENV } from "./agents/server-env";
 import { runInBackground } from "./async-operations";
 import { tmux } from "./tmux/exec";
 import { endTmuxSession } from "./tmux/end";
+import { inheritGroup } from "@/lib/session-groups/assignSessions";
 
 export interface SpawnWorkerOptions {
   conductorSessionId: string;
@@ -146,6 +147,7 @@ export async function spawnWorker(
     agentType,
     "uncategorized" // project_id
   );
+  inheritGroup(conductorSessionId, sessionId);
 
   // Update worktree info if created
   if (worktreePath) {