@kevin5251984/guild 0.2.19 → 0.2.21

package/src/store.ts

@@ -26,7 +26,11 @@ import { DEFAULT_BOTS } from "./catalog/default-bots.ts";
 import { CATALOG_SKILLS } from "./catalog/skills.ts";
 import { CATALOG_SUBAGENTS } from "./catalog/subagents.ts";
 import { parseAgentFile } from "./agent-file.ts";
-import { parseMentionIds, sanitizeMentionIds } from "./mention.ts";
+import {
+  parseMentionIds,
+  sanitizeMentionIds,
+  withoutDeferredIds,
+} from "./mention.ts";
 
 const MARKDOWN: Record<LibraryKind, string> = {
   souls: "SOUL.md",
@@ -97,6 +101,9 @@ export type LiveTurn = {
   startedAt?: string;
   /** Full-ish tool history for Trajectory. Stripped from GET /live. */
   traces?: LiveTrace[];
+  /** Seat assignment text, kept so Continue can resume after Pause. */
+  asked?: string;
+  paused?: boolean;
 };
 
 export class GuildStore {
@@ -362,7 +369,6 @@ export class GuildStore {
   beginTurn(roomId: string, botIds: string[] = [""]): AbortSignal {
     const controller = new AbortController();
     const ids = botIds.length ? botIds : [""];
-    for (const botId of ids) this.bindBotAbort(roomId, botId, controller);
     this.turnGroups.set(controller.signal, {
       roomId,
       botIds: new Set(ids),
@@ -371,43 +377,54 @@ export class GuildStore {
     return controller.signal;
   }
 
+  /**
+   * Per-seat AbortController, child of the turn group. Pause/Stop one bot
+   * without taking the rest of the wave down.
+   */
+  armBotTurn(roomId: string, botId: string, parent: AbortSignal): AbortSignal {
+    const controller = new AbortController();
+    const onParent = () => {
+      if (!controller.signal.aborted) controller.abort();
+    };
+    if (parent.aborted) onParent();
+    else parent.addEventListener("abort", onParent, { once: true });
+    this.bindBotAbort(roomId, botId, controller);
+    const group = this.turnGroups.get(parent);
+    if (group && group.roomId === roomId) group.botIds.add(botId);
+    return controller.signal;
+  }
+
   adoptTurn(roomId: string, botId: string, signal: AbortSignal): void {
     const group = this.turnGroups.get(signal);
     if (!group || group.roomId !== roomId) return;
-    this.bindBotAbort(roomId, botId, group.controller);
     group.botIds.add(botId);
   }
 
+  private dropBotLive(roomId: string, botId: string): boolean {
+    const live = this.liveTurns.get(roomId);
+    const steers = this.pendingSteers.get(roomId);
+    const room = this.botAborts.get(roomId);
+    const hadLive = Boolean(live?.delete(botId));
+    steers?.delete(botId);
+    room?.delete(botId);
+    if (live && live.size === 0) this.liveTurns.delete(roomId);
+    if (steers && steers.size === 0) this.pendingSteers.delete(roomId);
+    if (room && room.size === 0) this.botAborts.delete(roomId);
+    for (const [sig, group] of this.turnGroups) {
+      if (group.roomId !== roomId || !group.botIds.has(botId)) continue;
+      group.botIds.delete(botId);
+      if (group.botIds.size === 0) this.turnGroups.delete(sig);
+    }
+    return hadLive;
+  }
+
   abortTurn(roomId: string, botId?: string): boolean {
     if (botId) {
-      const room = this.botAborts.get(roomId);
-      const controller = room?.get(botId);
-      if (!controller) {
-        const live = this.liveTurns.get(roomId);
-        const steers = this.pendingSteers.get(roomId);
-        const hadLive = Boolean(live?.delete(botId));
-        steers?.delete(botId);
-        if (live && live.size === 0) this.liveTurns.delete(roomId);
-        if (steers && steers.size === 0) this.pendingSteers.delete(roomId);
-        this.spillTrajectoryIfIdle(roomId);
-        return hadLive;
-      }
-      const group = this.turnGroups.get(controller.signal);
-      const ids = group ? [...group.botIds] : [botId];
-      this.turnGroups.delete(controller.signal);
-      const live = this.liveTurns.get(roomId);
-      const steers = this.pendingSteers.get(roomId);
-      for (const id of ids) {
-        room?.delete(id);
-        live?.delete(id);
-        steers?.delete(id);
-      }
-      if (room && room.size === 0) this.botAborts.delete(roomId);
-      if (live && live.size === 0) this.liveTurns.delete(roomId);
-      if (steers && steers.size === 0) this.pendingSteers.delete(roomId);
-      if (!controller.signal.aborted) controller.abort();
+      const controller = this.botAborts.get(roomId)?.get(botId);
+      const hadLive = this.dropBotLive(roomId, botId);
+      if (controller && !controller.signal.aborted) controller.abort();
       this.spillTrajectoryIfIdle(roomId);
-      return true;
+      return hadLive || Boolean(controller);
     }
     const room = this.botAborts.get(roomId);
     this.botAborts.delete(roomId);
@@ -415,10 +432,18 @@ export class GuildStore {
     this.pendingSteers.delete(roomId);
     let aborted = false;
     const seen = new Set<AbortController>();
+    for (const [sig, group] of [...this.turnGroups]) {
+      if (group.roomId !== roomId) continue;
+      this.turnGroups.delete(sig);
+      if (!group.controller.signal.aborted) {
+        group.controller.abort();
+        aborted = true;
+      }
+      seen.add(group.controller);
+    }
     for (const controller of room?.values() ?? []) {
       if (seen.has(controller)) continue;
       seen.add(controller);
-      this.turnGroups.delete(controller.signal);
       if (!controller.signal.aborted) {
         controller.abort();
         aborted = true;
@@ -428,6 +453,37 @@ export class GuildStore {
     return aborted || Boolean(room);
   }
 
+  pauseTurn(roomId: string, botId?: string): boolean {
+    const ids = botId
+      ? [botId]
+      : [...(this.liveTurns.get(roomId)?.keys() ?? [])];
+    let any = false;
+    for (const id of ids) {
+      if (!id) continue;
+      const live = this.getLiveBotTurn(roomId, id);
+      if (!live) continue;
+      const traces = (live.traces || []).map((tr) =>
+        tr.running ? { ...tr, running: false, text: tr.text || "paused" } : tr,
+      );
+      const steps = (live.steps || []).map((step) =>
+        step.running ? { ...step, running: false } : step,
+      );
+      this.setLiveTurn(roomId, {
+        ...live,
+        traces,
+        steps,
+        paused: true,
+      });
+      const controller = this.botAborts.get(roomId)?.get(id);
+      this.botAborts.get(roomId)?.delete(id);
+      const room = this.botAborts.get(roomId);
+      if (room && room.size === 0) this.botAborts.delete(roomId);
+      if (controller && !controller.signal.aborted) controller.abort();
+      any = true;
+    }
+    return any;
+  }
+
   endTurn(roomId: string, signal?: AbortSignal): void {
     const group = signal ? this.turnGroups.get(signal) : undefined;
     if (group) {
@@ -436,7 +492,11 @@ export class GuildStore {
       const live = this.liveTurns.get(roomId);
       const steers = this.pendingSteers.get(roomId);
       for (const botId of group.botIds) {
-        if (room?.get(botId) === group.controller) room.delete(botId);
+        if (live?.get(botId)?.paused) {
+          room?.delete(botId);
+          continue;
+        }
+        room?.delete(botId);
         live?.delete(botId);
         steers?.delete(botId);
       }
@@ -445,8 +505,14 @@ export class GuildStore {
       if (steers && steers.size === 0) this.pendingSteers.delete(roomId);
       if (!group.controller.signal.aborted) group.controller.abort();
     } else {
+      const live = this.liveTurns.get(roomId);
+      const kept = new Map<string, LiveTurn>();
+      for (const [id, turn] of live ?? []) {
+        if (turn.paused) kept.set(id, turn);
+      }
       this.botAborts.delete(roomId);
-      this.clearLiveTurn(roomId);
+      if (kept.size) this.liveTurns.set(roomId, kept);
+      else this.clearLiveTurn(roomId);
     }
     this.spillTrajectoryIfIdle(roomId);
   }
@@ -989,11 +1055,14 @@ export class GuildStore {
     const now = new Date().toISOString();
     const startedAt = author !== "you" ? usage?.startedAt : undefined;
     const bots = this.listBots();
-    const mentionIds = (
-      mentions !== undefined
+    const mentionIds = withoutDeferredIds(
+      (mentions !== undefined
         ? sanitizeMentionIds(mentions, bots)
         : parseMentionIds(text, bots, author === "you" ? "user" : "bot")
-    ).filter((id) => id !== author);
+      ).filter((id) => id !== author),
+      text,
+      bots,
+    );
     const message: ChatMessage = {
       id: randomUUID(),
       roomId,
@@ -1022,10 +1091,12 @@ export class GuildStore {
     const text = body.trim();
     if (!text) throw new StoreError(400, "message is required");
     const bots = this.listBots();
-    const mentionIds = (
+    const mentionIds = withoutDeferredIds(
       mentions !== undefined
         ? sanitizeMentionIds(mentions, bots)
-        : parseMentionIds(text, bots, "user")
+        : parseMentionIds(text, bots, "user"),
+      text,
+      bots,
     );
     const next = this.db.updateMessageBody(roomId, messageId, text, mentionIds);
     if (!next) throw new StoreError(404, "message not found");

package/src/subagent.ts

@@ -73,16 +73,21 @@ function agentKey(value: string): string {
   return value.trim().replace(/^\/+/, "").toLowerCase();
 }
 
-/** Parent read_only cannot escalate via spawn. Explorer from full_access keeps run. */
+/**
+ * A child never outruns its parent, and a read-only agent never gets `run`
+ * back: a readOnly child is pinned to read_only even under a full_access
+ * parent (that used to be an escalation hole — CHILD_TOOLS_RO advertised run
+ * and gateTool let a full_access child through it).
+ */
 export function childSpawnPolicy(
   parentSandbox: ToolContext["sandbox"],
   agentReadOnly: boolean,
 ): { sandbox: Sandbox; allowWrite: boolean } {
   const parent = parseSandbox(parentSandbox);
-  if (parent === "read_only") {
+  if (parent === "read_only" || agentReadOnly) {
     return { sandbox: "read_only", allowWrite: false };
   }
-  return { sandbox: parent, allowWrite: !agentReadOnly };
+  return { sandbox: parent, allowWrite: true };
 }
 
 export function resolveSubagent(
@@ -108,8 +113,8 @@ Never say you cannot access this machine. Check [exit code: N] on every run.
 Independent searches: emit multiple tool calls in one round; they run in parallel.`;
 
 const CHILD_TOOLS_RO = `You ARE already running on the user's local computer (Guild).
-Tools: run, read, list, skill. You cannot write files and cannot spawn subagents.
-Read-only. Never edit, patch, or create files. Check [exit code: N] on every run.
+Tools: read, list, skill. You cannot run shell commands, cannot write files, and cannot spawn subagents.
+Read-only. Never edit, patch, or create files.
 Independent searches: emit multiple tool calls in one round; they run in parallel.`;
 
 export const SPAWN_MAX_PARALLEL = 8;

package/src/tools.ts

@@ -7,6 +7,7 @@ import { Type, type Tool } from "@earendil-works/pi-ai";
 import { listHostSkills } from "./host-skills.ts";
 import type { McpToolRef } from "./mcp.ts";
 import {
+  defaultWorkspace,
   gateTool,
   parseSandbox,
   resolveToolPath,
@@ -186,7 +187,9 @@ export function guildTools(
       (tool) => tool.name === "read" || tool.name === "list",
     );
   } else if (sandbox === "workspace_write") {
-    tools = tools.filter((tool) => tool.name !== "image_gen");
+    tools = tools.filter(
+      (tool) => tool.name !== "image_gen" && tool.name !== "browser",
+    );
   }
   tools.push({
     name: "skill",
@@ -465,9 +468,11 @@ export async function builtinExecute(
   ctx: ToolContext = {},
 ): Promise<ToolOutcome> {
   try {
+    // workspace_write resolves relative paths from the workspace root, which
+    // defaults to the guild checkout (same root gateTool checks against).
     const pathBase =
-      parseSandbox(ctx.sandbox) === "workspace_write" && ctx.workspace
-        ? resolveToolPath(ctx.workspace)
+      parseSandbox(ctx.sandbox) === "workspace_write"
+        ? resolveToolPath(ctx.workspace?.trim() || defaultWorkspace())
         : HOME;
     if (name === "run") {
       return await runCommand(

package/src/version.ts

@@ -0,0 +1,25 @@
+import { readFileSync } from "node:fs";
+
+/**
+ * Outbound User-Agent. npm ships this package's source, so the manifest always
+ * sits one level above `src/` — same lookup as `--version` in cli.ts.
+ */
+export function guildUserAgent(): string {
+  return `Guild/${guildVersion()}`;
+}
+
+let cached: string | null = null;
+
+export function guildVersion(): string {
+  if (cached !== null) return cached;
+  try {
+    const pkg = JSON.parse(
+      readFileSync(new URL("../package.json", import.meta.url), "utf8"),
+    ) as { version?: unknown };
+    const version = typeof pkg.version === "string" ? pkg.version.trim() : "";
+    cached = version || "0";
+  } catch {
+    cached = "0";
+  }
+  return cached;
+}

package/vendor/protocol/src/index.ts

@@ -6,7 +6,12 @@ export type HealthResponse = {
 
 export type BotStatus = "bench" | "staffed" | "running" | "retired";
 
-export type ModelRef = { provider: string; model: string };
+export type ModelRef = {
+  provider: string;
+  model: string;
+  /** Seat-specific effort. Missing → that model's catalog default. */
+  reasoning?: string;
+};
 
 export type LibraryKind =
   | "souls"
@@ -133,9 +138,20 @@ export type LlmApi =
   | "anthropic-messages"
   | "openai-responses";
 
+export type ModelReasoning = {
+  /** Effort strings this model accepts, catalog order. Missing = no effort picker. */
+  supportedEfforts?: string[];
+  defaultEffort?: string;
+  /** When true, do not send `none` — reasoning cannot be turned off. */
+  mandatory?: boolean;
+  defaultEnabled?: boolean;
+  supportsMaxTokens?: boolean;
+};
+
 export type ModelEntry = {
   id: string;
   name?: string;
+  reasoning?: ModelReasoning;
 };
 
 export type ProviderEntry = {
@@ -158,7 +174,8 @@ export type AuxRole =
 
 export type ModelsFile = {
   default?: ModelRef | null;
-  reasoning?: "minimal" | "low" | "medium" | "high";
+  /** Guild-default effort when a seat has no `model.reasoning`. */
+  reasoning?: string;
   fast?: boolean;
   aux?: Partial<Record<AuxRole, ModelRef | null>>;
   recent?: ModelRef[];