@saadnvd1/agent-os 0.3.778 → 0.3.780

package/lib/chat/worker/host.ts

@@ -33,7 +33,14 @@ import {
   settle,
 } from "../store";
 import { handleMcpAuth, stopMcpWatches } from "./mcp-auth";
-import { claimNext, enqueue, listQueue, moveToFront } from "../queued";
+import {
+  claimNext,
+  enqueue,
+  listQueue,
+  moveToFront,
+  peekNextSentBy,
+} from "../queued";
+import { GuestGate, isGuestDrive } from "./guest-gate";
 import { isHeld } from "../hold";
 import {
   recordCompaction,
@@ -145,6 +152,8 @@ export class ChatHost {
   // need words), and the ones No approvals mode allowed.
   private waitingCards = new Map<string, string>();
   private autoAllowed = new Set<string>();
+  // Holds a live guest's turn to the host's taps (./guest-gate).
+  private gate: GuestGate;
   // Whether its driver says when that is (lib/chat/driver atRest).
   private atRest = true;
   private restartedNote = false;
@@ -188,6 +197,11 @@ export class ChatHost {
     // What a session's role adds: its brief and its own tools.
     extras: RoleExtras = {}
   ) {
+    this.gate = new GuestGate((note) => {
+      if (!this.busy()) return;
+      this.record(note);
+      void this.handle({ type: "interrupt", hard: true });
+    }, session.id);
     this.usage = startingTotals(session.id, !!session.claude_session_id);
     const driver = chatDriverFor(session.agent_type);
     if (!driver)
@@ -251,6 +265,7 @@ export class ChatHost {
       disallowedTools: extras.disallowedTools,
       permissionMode: extras.permissionMode,
       toolGuard: extras.toolGuard,
+      guestGate: this.gate,
       // Not an orchestrator: it starts a fresh conversation instead.
       compactContext: orchestrator
         ? undefined
@@ -294,7 +309,7 @@ export class ChatHost {
   // No approvals mode: a tool-permission card is allowed as it appears, and
   // marks itself so the transcript shows who allowed it.
   private markAuto(item: ChatItem): ChatItem {
-    if (item.kind !== "approval" || item.questions) return item;
+    if (item.kind !== "approval" || item.questions || item.guest) return item;
     if (item.status === "pending") {
       this.waitingCards.set(item.id, item.title);
       return item;
@@ -432,6 +447,7 @@ export class ChatHost {
           // short, so what's sent next isn't queued behind it.
           if (this.hardStopped()) void this.conversation.interrupt();
           this.turnsStarted++;
+          this.gate.onTurnStart();
           this.turnStartedAt ??= Date.now();
           if (this.behind) this.behind--;
           clearTimeout(this.restTimer);
@@ -451,8 +467,10 @@ export class ChatHost {
           this.setCompacting(e.active);
         } else if (e.type === "state") {
           // A stop, an error or the end of the turn ends a compaction too.
-          if (e.state === "idle" || e.state === "error")
+          if (e.state === "idle" || e.state === "error") {
             this.setCompacting(false);
+            this.gate.onIdle();
+          }
           if (e.state === "idle") {
             flushItems();
             // A turn cut off mid-sentence (Esc, Stop) keeps what it streamed.
@@ -553,7 +571,12 @@ export class ChatHost {
       this.compactingNow
     )
       return;
-    for (let next; (next = claimNext(this.session.id));) {
+    // A guest's message is always its own turn: it waits for this one's end.
+    for (
+      let next;
+      !isGuestDrive(peekNextSentBy(this.session.id) ?? {}) &&
+      (next = claimNext(this.session.id));
+    ) {
       this.emit({ type: "queue" });
       this.sendUser(next);
     }
@@ -573,6 +596,11 @@ export class ChatHost {
     this.hardStopAt = 0;
     // A message sent now stops the turn and is read next: nothing waits.
     const midTurn = this.busy() && !now;
+    this.gate.onSend(
+      m,
+      midTurn,
+      this.busy() && this.turnsStarted <= this.turnsEnded ? 1 : 0
+    );
     if (this.busy()) this.behind++;
     // Sent now, it stops the running turn, which still ends after this.
     if (!this.busy()) now = false;
@@ -650,7 +678,7 @@ export class ChatHost {
   async handle(cmd: WorkerCommand): Promise<void> {
     switch (cmd.type) {
       case "send": {
-        if (this.sent.has(cmd.id)) return;
+        if (this.sent.has(cmd.id) || this.gate.refuses(cmd)) return;
         // Sent just as a move or Land took hold (lib/chat/hold): it waits
         // in the queue rather than start a turn the stop would cut short.
         // Or for the current worker that takes over from a retiring one.
@@ -669,6 +697,7 @@ export class ChatHost {
         }
         this.sent.add(cmd.id);
         await this.modeChange.catch(() => {});
+        if (this.gate.refuses(cmd)) return;
         const user = {
           id: cmd.id,
           kind: "user" as const,
@@ -703,6 +732,7 @@ export class ChatHost {
         // Another agent's message doesn't speak for the reader.
         if (
           this.stopping &&
+          !isGuestDrive(cmd) &&
           (this.hardStopped() || (!cmd.from && !cmd.peer && !cmd.origin)) &&
           this.busy() &&
           !listQueue(this.session.id).length
@@ -723,7 +753,10 @@ export class ChatHost {
         if (this.compactFirst(cmd)) return;
         // A compaction run for an earlier message takes nothing in: what's
         // sent meanwhile goes behind that message.
-        if ((cmd.queue || this.compacting) && (this.busy() || backlog)) {
+        if (
+          (cmd.queue || this.compacting || isGuestDrive(cmd)) &&
+          (this.busy() || backlog)
+        ) {
           // Behind the running turn, and behind anything queued before it.
           enqueue(this.session.id, cmd);
           this.emit({ type: "queue" });
@@ -835,6 +868,16 @@ export class ChatHost {
           });
         }
         return;
+      case "guest_release":
+      case "guest_stop":
+        return this.gate.command(cmd, this.session.id, {
+          queueChanged: () => this.emit({ type: "queue" }),
+          busy: () => this.busy(),
+          stopTurn: () =>
+            this.busy()
+              ? this.handle({ type: "interrupt", hard: true })
+              : undefined,
+        });
       case "retire":
         this.retiring = true;
         return this.retireIfDone();
@@ -1064,6 +1107,7 @@ export class ChatHost {
     clearTimeout(this.retireTimer);
     clearTimeout(this.restTimer);
     this.closed = true;
+    this.gate.close();
     this.setCompacting(false);
     flushItems();
     this.onClose();

package/lib/chat/worker/main.ts

@@ -9,7 +9,12 @@
 import fs from "fs";
 import net from "net";
 import { adoptServerEnv } from "./env";
-import { lineReader, PROTOCOL_VERSION, socketPath } from "./protocol";
+import {
+  GUEST_GATE_CAP,
+  lineReader,
+  PROTOCOL_VERSION,
+  socketPath,
+} from "./protocol";
 import { buildId } from "../../build";
 import type { WorkerCommand, WorkerEvent } from "./protocol";
 import type { Session } from "../../db";
@@ -76,7 +81,16 @@ async function main(sessionId: string) {
         state: host.state,
         compacting: host.compactingNow,
         streaming: [...host.streaming.values()],
-        caps: ["plan", "queue", "retire", "fresh", "background", "mcp_auth"],
+        caps: [
+          "plan",
+          "queue",
+          "retire",
+          "fresh",
+          "background",
+          "mcp_auth",
+          // Only the Claude driver runs the guest gate's hook.
+          ...(session.agent_type === "claude" ? [GUEST_GATE_CAP] : []),
+        ],
       } satisfies WorkerEvent)}\n`
     );
     client.on(

package/lib/chat/worker/protocol.ts

@@ -25,6 +25,10 @@ import type { CompactFirst } from "../stale";
 
 export const PROTOCOL_VERSION = 1;
 
+// In a worker's hello caps: it holds a live guest's turns to the host's taps
+// (./guest-gate). Without it no Drive prompt is sent to it.
+export const GUEST_GATE_CAP = "guest-gate";
+
 // Server -> worker. A send carries the id its user item gets, so a send
 // retried after a dropped connection is never run twice.
 export type WorkerCommand =
@@ -37,6 +41,7 @@ export type WorkerCommand =
       from?: string;
       peer?: PeerMessage;
       origin?: ChatOrigin;
+      host?: true;
       // From the composer: waits its turn behind a running one, in the
       // queue, rather than joining it.
       queue?: boolean;
@@ -79,6 +84,12 @@ export type WorkerCommand =
   // (now, if idle) the agent's conversation ends and the next worker
   // starts a new one with today's brief and permissions.
   | { type: "fresh" }
+  // A live share's Drive is over (downgrade, take-back, kick, end): its
+  // queued prompts go, a turn it steers stops, and nothing more from it is
+  // taken in (lib/chat/worker/guest-gate).
+  | { type: "guest_release"; share: string; wheel: string }
+  // The driving guest's Stop: ends a turn their wheel steers, never another.
+  | { type: "guest_stop"; share: string; wheel: string }
   | { type: "close" };
 
 // Worker -> server: what's live right now on connecting, then events.

package/lib/connect/control-api.ts

@@ -488,12 +488,16 @@ export interface LiveShare {
 export async function createLiveShare(
   config: ConnectConfig,
   privateKey: string,
-  share: { title: string; expiresIn: LiveExpiry }
+  share: { title: string; expiresIn: LiveExpiry; access?: string }
 ): Promise<LiveShare> {
   const res = await signed(config, privateKey)(
     "POST",
     `/api/v1/machines/${config.machineId}/live-shares`,
-    { title: share.title, expires_in: share.expiresIn }
+    {
+      title: share.title,
+      expires_in: share.expiresIn,
+      ...(share.access ? { access: share.access } : {}),
+    }
   );
   const r = (await res.json().catch(() => null)) as Record<
     string,

package/lib/db/migrations/20261030T1200_live_share_level.ts

@@ -0,0 +1,19 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  key: "20261030T1200_live_share_level",
+  up: (db) => {
+    const cols = (
+      db.prepare(`PRAGMA table_info(live_shares)`).all() as { name: string }[]
+    ).map((c) => c.name);
+    // Existing links keep what they always did: suggest, with the whole chat.
+    if (!cols.includes("level"))
+      db.exec(
+        `ALTER TABLE live_shares ADD COLUMN level TEXT NOT NULL DEFAULT 'suggest'`
+      );
+    if (!cols.includes("history"))
+      db.exec(
+        `ALTER TABLE live_shares ADD COLUMN history INTEGER NOT NULL DEFAULT 1`
+      );
+  },
+} satisfies Migration;

package/lib/db/migrations/20261030T1300_chat_guest_steers.ts

@@ -0,0 +1,20 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  key: "20261030T1300_chat_guest_steers",
+  up: (db) => {
+    // A live guest's steer on a chat (lib/chat/worker/guest-gate): kept
+    // here so a worker that restarts mid-Drive still gates its turns.
+    db.exec(
+      `CREATE TABLE IF NOT EXISTS chat_guest_steers (
+         session_id TEXT PRIMARY KEY,
+         share_id TEXT NOT NULL,
+         wheel TEXT NOT NULL,
+         guest_id TEXT NOT NULL,
+         name TEXT NOT NULL,
+         tool_calls INTEGER NOT NULL DEFAULT 0,
+         started_at INTEGER NOT NULL
+       )`
+    );
+  },
+} satisfies Migration;

package/lib/db/migrations/20261030T1400_chat_guest_steers_ended.ts

@@ -0,0 +1,14 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  key: "20261030T1400_chat_guest_steers_ended",
+  up: (db) => {
+    // When the steer's Drive ended: a worker that restarts after it has no
+    // guest turn left to gate.
+    const cols = db.prepare(`PRAGMA table_info(chat_guest_steers)`).all() as {
+      name: string;
+    }[];
+    if (!cols.some((c) => c.name === "ended_at"))
+      db.exec(`ALTER TABLE chat_guest_steers ADD COLUMN ended_at INTEGER`);
+  },
+} satisfies Migration;

package/lib/live/clean.ts

@@ -38,6 +38,12 @@ export function cleanName(input: unknown): string | null {
   return s;
 }
 
+/**
+ * Claude Code reads an `@path` in a message as a file to attach, with no
+ * tool call a gate could stop: a guest's `@` can't be one.
+ */
+export const noMentions = (t: string) => t.replace(/@/g, "\uff20");
+
 /** A block of text (a suggestion): newlines and tabs kept, or null. */
 export function cleanBody(input: unknown, max = MAX_SUGGESTION): string | null {
   if (typeof input !== "string" || !wellFormed(input)) return null;