@kevin5251984/guild 0.2.12 → 0.2.13

package/src/subagent.ts

@@ -1,8 +1,6 @@
-import { randomUUID } from "node:crypto";
 import { parseAgentFile } from "./agent-file.ts";
 import { listHostAgents, type HostAgent } from "./host-agents.ts";
 import type { LibraryItem } from "@guild/protocol";
-import { parseSandbox, type Sandbox } from "./harness.ts";
 import {
   hostContext,
   type SubAgentRef,
@@ -72,18 +70,6 @@ function agentKey(value: string): string {
   return value.trim().replace(/^\/+/, "").toLowerCase();
 }
 
-/** Parent read_only cannot escalate via spawn. Explorer from full_access keeps run. */
-export function childSpawnPolicy(
-  parentSandbox: ToolContext["sandbox"],
-  agentReadOnly: boolean,
-): { sandbox: Sandbox; allowWrite: boolean } {
-  const parent = parseSandbox(parentSandbox);
-  if (parent === "read_only") {
-    return { sandbox: "read_only", allowWrite: false };
-  }
-  return { sandbox: parent, allowWrite: !agentReadOnly };
-}
-
 export function resolveSubagent(
   name: string,
   agents: SubAgentRef[],
@@ -103,192 +89,11 @@ export function resolveSubagent(
 
 const CHILD_TOOLS = `You ARE already running on the user's local computer (Guild).
 Tools: run, read, write, list, skill, image_gen. You cannot spawn subagents.
-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.`;
+Never say you cannot access this machine. Check [exit code: N] on every run.`;
 
 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.
-Independent searches: emit multiple tool calls in one round; they run in parallel.`;
-
-export const SPAWN_MAX_PARALLEL = 8;
-export const SPAWN_CONCURRENCY = 4;
-
-export type SpawnJob = {
-  prompt: string;
-  name: string;
-  description: string;
-};
-
-/** Devin luna-explore / Pi scout → Guild explorer. */
-export function spawnProfile(raw: string): string {
-  const key = raw.trim().toLowerCase();
-  if (!key) return "";
-  if (key === "luna-explore" || key === "explore" || key === "scout") {
-    return "explorer";
-  }
-  if (key === "luna-general" || key === "general") return "worker";
-  if (key === "luna-reviewer") return "reviewer";
-  return raw.trim();
-}
-
-function recordOf(value: unknown): Record<string, unknown> | null {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-  return value as Record<string, unknown>;
-}
-
-function flagTrue(value: unknown): boolean {
-  return value === true || value === "true";
-}
-
-function flagFalse(value: unknown): boolean {
-  return value === false || value === "false";
-}
-
-function oneJob(raw: Record<string, unknown>): SpawnJob {
-  const prompt = String(raw.prompt || raw.task || "").trim();
-  const name = spawnProfile(
-    String(raw.profile || raw.name || raw.agent || raw.subagent_type || ""),
-  );
-  const description = String(raw.title || raw.description || "").trim();
-  return { prompt, name, description };
-}
-
-function handlesOf(ctx: ToolContext) {
-  if (!ctx.spawnHandles) ctx.spawnHandles = new Map();
-  return ctx.spawnHandles;
-}
-
-function startBackground(job: SpawnJob, ctx: ToolContext) {
-  const id = randomUUID();
-  const title = job.description || job.name || "worker";
-  const profile = job.name || "worker";
-  const handle: {
-    id: string;
-    title: string;
-    profile: string;
-    done: Promise<ToolOutcome>;
-    outcome?: ToolOutcome;
-  } = {
-    id,
-    title,
-    profile,
-    done: Promise.resolve({ text: "", isError: false }),
-  };
-  handle.done = spawnSubagent({ ...job, ctx }).then((outcome) => {
-    handle.outcome = outcome;
-    return outcome;
-  });
-  handlesOf(ctx).set(id, handle);
-  return handle;
-}
-
-function ackBackground(
-  rows: { id: string; title: string; profile: string }[],
-): string {
-  return rows
-    .map(
-      (row) =>
-        `agent_id: ${row.id}\ntitle: ${row.title}\nprofile: ${row.profile}\nstatus: running\nCall read_spawn with this agent_id (block=true) before the final reply.`,
-    )
-    .join("\n\n");
-}
-
-/** Pi subagent: single {prompt|task, name|agent} or parallel tasks[]. */
-export function spawnJobs(args: Record<string, unknown>): SpawnJob[] {
-  if (Array.isArray(args.tasks) && args.tasks.length) {
-    return args.tasks.map((item) => oneJob(recordOf(item) || {}));
-  }
-  return [oneJob(args)];
-}
-
-async function mapWithConcurrency<T, R>(
-  items: T[],
-  concurrency: number,
-  fn: (item: T, index: number) => Promise<R>,
-): Promise<R[]> {
-  if (!items.length) return [];
-  const limit = Math.max(1, Math.min(concurrency, items.length));
-  const out: R[] = new Array(items.length);
-  let next = 0;
-  await Promise.all(
-    Array.from({ length: limit }, async () => {
-      while (true) {
-        const i = next++;
-        if (i >= items.length) return;
-        out[i] = await fn(items[i], i);
-      }
-    }),
-  );
-  return out;
-}
-
-export async function runSpawnJobs(
-  args: Record<string, unknown>,
-  ctx: ToolContext,
-): Promise<ToolOutcome> {
-  const jobs = spawnJobs(args);
-  if (!jobs.length || jobs.some((job) => !job.prompt)) {
-    return { text: "spawn needs a prompt or task", isError: true };
-  }
-  if (jobs.length > SPAWN_MAX_PARALLEL) {
-    return {
-      text: `Too many parallel tasks (${jobs.length}). Max is ${SPAWN_MAX_PARALLEL}.`,
-      isError: true,
-    };
-  }
-  const background = flagTrue(args.background) || flagTrue(args.is_background);
-  if (background) {
-    const started = jobs.map((job) => startBackground(job, ctx));
-    return { text: ackBackground(started), isError: false };
-  }
-  if (jobs.length === 1) {
-    return spawnSubagent({ ...jobs[0], ctx });
-  }
-  const results = await mapWithConcurrency(jobs, SPAWN_CONCURRENCY, (job) =>
-    spawnSubagent({ ...job, ctx }),
-  );
-  const failed = results.filter((row) => row.isError).length;
-  const body = results
-    .map((row, i) => {
-      const label = jobs[i].description || jobs[i].name || "worker";
-      const status = row.isError ? "failed" : "completed";
-      return `### [${label}] ${status}\n\n${row.text}`;
-    })
-    .join("\n\n---\n\n");
-  return {
-    text: `Parallel: ${results.length - failed}/${results.length} succeeded\n\n${body}`,
-    isError: failed === results.length,
-  };
-}
-
-export async function readSpawn(
-  args: Record<string, unknown>,
-  ctx: ToolContext,
-): Promise<ToolOutcome> {
-  const id = String(args.agent_id || args.id || "").trim();
-  if (!id) return { text: "read_spawn needs agent_id", isError: true };
-  const handle = handlesOf(ctx).get(id);
-  if (!handle) {
-    return {
-      text: `unknown agent_id ${id}. It must come from a background spawn in this turn.`,
-      isError: true,
-    };
-  }
-  if (flagFalse(args.block) && !handle.outcome) {
-    return {
-      text: `agent_id: ${handle.id}\ntitle: ${handle.title}\nprofile: ${handle.profile}\nstatus: running`,
-      isError: false,
-    };
-  }
-  const outcome = await handle.done;
-  return {
-    text: `# ${handle.title}\nagent_id: ${handle.id}\nprofile: ${handle.profile}\nstatus: ${
-      outcome.isError ? "failed" : "completed"
-    }\n\n${outcome.text}`,
-    isError: outcome.isError,
-  };
-}
+Read-only. Never edit, patch, or create files. Check [exit code: N] on every run.`;
 
 export async function spawnSubagent(input: {
   prompt: string;
@@ -310,13 +115,12 @@ export async function spawnSubagent(input: {
     ? input.ctx.subagents
     : listSpawnRefs([]);
   const agent = resolveSubagent(input.name || "worker", agents);
-  const child = childSpawnPolicy(input.ctx.sandbox, agent.readOnly);
   const { llmComplete } = await import("./llm.ts");
   const label = (input.description || agent.name).trim();
   const system = [
     agent.instructions,
     hostContext(),
-    child.allowWrite ? CHILD_TOOLS : CHILD_TOOLS_RO,
+    agent.readOnly ? CHILD_TOOLS_RO : CHILD_TOOLS,
   ]
     .filter(Boolean)
     .join("\n\n");
@@ -326,7 +130,7 @@ export async function spawnSubagent(input: {
     system,
     messages: [{ role: "user", content: prompt }],
     temperature: 0.3,
-    role: "spawn",
+    role: "chat",
     tools: true,
     skills: input.ctx.skills,
     toolCtx: {
@@ -335,11 +139,10 @@ export async function spawnSubagent(input: {
       dataDir,
       env: input.ctx.env,
       spawnDepth: 1,
-      allowWrite: child.allowWrite,
-      sandbox: child.sandbox,
+      allowWrite: !agent.readOnly,
+      sandbox: input.ctx.sandbox,
       workspace: input.ctx.workspace,
       dispatch: input.ctx.dispatch,
-      signal: input.ctx.signal,
     },
   });
   if (!result) {

package/src/tools.ts

@@ -75,17 +75,6 @@ export type ToolContext = {
     args: Record<string, unknown>,
     ctx: ToolContext,
   ) => Promise<ToolOutcome>;
-  /** Devin-style background spawn handles for this turn. */
-  spawnHandles?: Map<
-    string,
-    {
-      id: string;
-      title: string;
-      profile: string;
-      done: Promise<ToolOutcome>;
-      outcome?: ToolOutcome;
-    }
-  >;
 };
 
 const BASE_TOOLS: Tool[] = [
@@ -189,7 +178,7 @@ export function guildTools(
       name: Type.String({ description: "Skill name or slug" }),
     }),
   });
-  if ((ctx.spawnDepth ?? 0) < 1) {
+  if ((ctx.spawnDepth ?? 0) < 1 && sandbox !== "read_only") {
     const agents = ctx.subagents ?? [];
     const listed = agents
       .slice(0, 40)
@@ -201,28 +190,14 @@ export function guildTools(
     const catalog = listed ? ` Available: ${listed}.` : "";
     tools.push({
       name: "spawn",
-      description: `Delegate to a specialist (Devin run_subagent / Pi subagent / Codex spawn_agent). Fresh context; returns a summary, not a transcript. You stay coordinator. Single: title + task + profile (aliases: description/prompt, name/agent). Profiles: explorer (read-only survey), reviewer (read-only critique), worker (bounded patch). luna-explore maps to explorer, luna-general to worker. Independent surveys: background=true (is_background), then read_spawn with the agent_id before the final reply. Parallel: several spawn calls this round, or tasks: [{title, task, profile}, ...] (max 8, 4 at a time). Do not spawn for one known file or a one-line change.${catalog} A read_only parent still spawns; the child stays read_only. Subagents cannot spawn children.`,
+      description: `Spawn a subagent with a fresh context. It returns a summary, not a transcript. Use for parallel exploration, review, or a bounded implementation slice.${catalog} Subagents cannot spawn children.`,
       parameters: Type.Object({
-        prompt: Type.Optional(
-          Type.String({
-            description: "Self-contained task. Same as task.",
-          }),
-        ),
-        task: Type.Optional(
-          Type.String({ description: "Alias of prompt (Devin/Pi)" }),
-        ),
+        prompt: Type.String({
+          description: "Self-contained task for the subagent. Include paths, constraints, and the deliverable.",
+        }),
         name: Type.Optional(
           Type.String({
-            description: "Subagent name or slug. Default worker.",
-          }),
-        ),
-        agent: Type.Optional(
-          Type.String({ description: "Alias of name (Pi)" }),
-        ),
-        profile: Type.Optional(
-          Type.String({
-            description:
-              "Devin profile: explorer | reviewer | worker. luna-explore → explorer, luna-general → worker.",
+            description: "Subagent name or slug from the library. Default worker.",
           }),
         ),
         description: Type.Optional(
@@ -230,51 +205,6 @@ export function guildTools(
             description: "Short 3–8 word label for the chat UI",
           }),
         ),
-        title: Type.Optional(
-          Type.String({ description: "Alias of description (Devin title)" }),
-        ),
-        background: Type.Optional(
-          Type.Boolean({
-            description:
-              "If true, return agent_id immediately and keep working. Then call read_spawn.",
-          }),
-        ),
-        is_background: Type.Optional(
-          Type.Boolean({ description: "Alias of background (Devin)" }),
-        ),
-        tasks: Type.Optional(
-          Type.Array(
-            Type.Object({
-              prompt: Type.Optional(Type.String()),
-              task: Type.Optional(Type.String()),
-              name: Type.Optional(Type.String()),
-              agent: Type.Optional(Type.String()),
-              profile: Type.Optional(Type.String()),
-              description: Type.Optional(Type.String()),
-              title: Type.Optional(Type.String()),
-            }),
-            {
-              description:
-                "Pi parallel: run these subagents concurrently (max 8, 4 at a time).",
-            },
-          ),
-        ),
-      }),
-    });
-    tools.push({
-      name: "read_spawn",
-      description:
-        "Read a background spawn started with background=true (Devin read_subagent). Pass agent_id from spawn. block=true (default) waits; block=false returns running or the summary.",
-      parameters: Type.Object({
-        agent_id: Type.Optional(
-          Type.String({ description: "Id returned by background spawn" }),
-        ),
-        id: Type.Optional(Type.String({ description: "Alias of agent_id" })),
-        block: Type.Optional(
-          Type.Boolean({
-            description: "Wait for the child. Default true.",
-          }),
-        ),
       }),
     });
   }
@@ -292,7 +222,7 @@ export const GUILD_TOOLS: Tool[] = guildTools();
 
 function openaiParameters(name: string): {
   type: "object";
-  properties: Record<string, unknown>;
+  properties: Record<string, { type: "string"; description?: string }>;
   required: string[];
 } {
   if (name === "run") {
@@ -327,42 +257,14 @@ function openaiParameters(name: string): {
     };
   }
   if (name === "spawn") {
-    const job = {
+    return {
       type: "object",
       properties: {
-        prompt: { type: "string", description: "Self-contained task. Same as task." },
-        task: { type: "string", description: "Alias of prompt" },
+        prompt: { type: "string", description: "Self-contained task" },
         name: { type: "string", description: "Subagent name or slug" },
-        agent: { type: "string", description: "Alias of name" },
-        profile: { type: "string", description: "explorer | reviewer | worker" },
         description: { type: "string", description: "Short UI label" },
-        title: { type: "string", description: "Alias of description" },
-      },
-    };
-    return {
-      type: "object",
-      properties: {
-        ...job.properties,
-        background: { type: "boolean", description: "Return agent_id immediately" },
-        is_background: { type: "boolean", description: "Alias of background" },
-        tasks: {
-          type: "array",
-          description: "Pi parallel: [{name, prompt}, ...] max 8, 4 at a time",
-          items: job,
-        },
       },
-      required: [],
-    };
-  }
-  if (name === "read_spawn") {
-    return {
-      type: "object",
-      properties: {
-        agent_id: { type: "string", description: "Id from background spawn" },
-        id: { type: "string", description: "Alias of agent_id" },
-        block: { type: "boolean", description: "Wait. Default true." },
-      },
-      required: [],
+      required: ["prompt"],
     };
   }
   if (name === "image_gen") {
@@ -425,7 +327,6 @@ export const BUILTIN_TOOL_NAMES = [
   "list",
   "skill",
   "spawn",
-  "read_spawn",
   "image_gen",
   "browser",
 ] as const;
@@ -483,12 +384,13 @@ export async function builtinExecute(
     if (name === "list") return listDir(asString(args.path), pathBase);
     if (name === "skill") return loadSkill(asString(args.name), ctx.skills ?? []);
     if (name === "spawn") {
-      const { runSpawnJobs } = await import("./subagent.ts");
-      return runSpawnJobs(args, ctx);
-    }
-    if (name === "read_spawn") {
-      const { readSpawn } = await import("./subagent.ts");
-      return readSpawn(args, ctx);
+      const { spawnSubagent } = await import("./subagent.ts");
+      return spawnSubagent({
+        prompt: asString(args.prompt),
+        name: typeof args.name === "string" ? args.name : "",
+        description: typeof args.description === "string" ? args.description : "",
+        ctx,
+      });
     }
     if (name === "image_gen") {
       const { generateImage } = await import("./image-gen.ts");
@@ -811,8 +713,7 @@ Never say you cannot access this machine. Never tell the user to run the command
 When the question is about this computer, call tools first, then answer with evidence from the output.
 To generate an image, call image_gen with a prompt. Do not search the disk or load skills looking for Imagine. After it returns, include the markdown image in your reply.
 To use a real website in a browser, call browser with action=open and a url, then snapshot/click/type using refs like @e1. Default is a Hermes-shaped snapshot of the user's last_used Chrome profile (never the live profile). Set GUILD_BROWSER_REAL_PROFILE=0 for a throwaway empty profile.
-You stay coordinator. Spawn is the specialist, not a last resort (Devin run_subagent / Pi subagent / Codex spawn_agent). Call spawn for a survey (explorer / luna-explore), a critique (reviewer), or a bounded patch (worker / luna-general) instead of stuffing that work into this turn with list/read/run. Do not spawn for one known file or a one-line change. Independent surveys: spawn with background=true, keep working, then read_spawn {agent_id, block:true} before the final reply. Or several spawn calls / tasks: [{title, task, profile}] this round. Task must be self-contained (child has a fresh context). Do not let a child commit, push, or decide architecture. A read_only seat can still spawn; the child stays read_only. Subagents cannot spawn children.
-Independent tool calls in one round also run in parallel — fire several reads/searches together.
+To delegate a bounded slice (explore, review, implement) to a specialist with its own context, call spawn. Pass a self-contained prompt. The subagent returns a summary. Subagents cannot spawn children.
 Check the [exit code: N] marker on every run result; investigate failures before moving on. Prefer the workdir argument over cd.
 To follow a staffed skill, call skill with its exact name (or slug) before applying it. Relative paths in a skill resolve against that skill's base directory.
 Prefer small commands. macOS RAM: sysctl hw.memsize ; memory_pressure. Disk: df -h.`;

package/src/trajectory.ts

@@ -38,35 +38,6 @@ export function clip(text: string, n = CLIP): string {
   return one.slice(0, n - 1) + "…";
 }
 
-function recordOf(value: unknown): Record<string, unknown> | null {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-  return value as Record<string, unknown>;
-}
-
-/** Old rows logged spawn as TOOL "spawn spawn". Present them as spawn. */
-export function promoteSpawnEvent<T extends { kind: string; summary: string; payload?: unknown }>(
-  event: T,
-): T & { kind: TrajectoryKind; summary: string } {
-  if (event.kind === "spawn") return event as T & { kind: TrajectoryKind; summary: string };
-  const payload = recordOf(event.payload);
-  const toolName = String(payload?.name || "");
-  const looksSpawn =
-    event.kind === "tool" &&
-    (toolName === "spawn" || /^\s*spawn(\s+spawn)?\s*$/i.test(event.summary || ""));
-  if (!looksSpawn) return event as T & { kind: TrajectoryKind; summary: string };
-  const args = recordOf(payload?.args) || payload || {};
-  const agent = String(args.name || "worker").trim() || "worker";
-  const label = String(args.description || "").replace(/\s+/g, " ").trim();
-  const prompt = String(args.prompt || "").replace(/\s+/g, " ").trim();
-  return {
-    ...event,
-    kind: "spawn",
-    summary: clip(
-      `${agent}${label ? " · " + label : ""}${prompt ? " — " + prompt : ""}`,
-    ),
-  };
-}
-
 function cap(value: unknown): unknown {
   if (typeof value === "string") {
     return value.length > FIELD_CAP ? value.slice(0, FIELD_CAP) : value;
@@ -169,34 +140,17 @@ export function turnTrajectoryEvents(input: {
       });
       continue;
     }
-    if (trace.name === "spawn" || trace.name === "read_spawn") {
-      const agent =
-        String(
-          trace.args.profile ||
-            trace.args.name ||
-            trace.args.agent ||
-            "worker",
-        ).trim() || "worker";
-      const label = String(trace.args.title || trace.args.description || "")
-        .replace(/\s+/g, " ")
-        .trim();
-      const prompt = String(trace.args.prompt || trace.args.task || "")
-        .replace(/\s+/g, " ")
-        .trim();
-      const bg =
-        trace.args.background === true || trace.args.is_background === true
-          ? " (bg)"
-          : "";
-      const waitId = String(trace.args.agent_id || trace.args.id || "").trim();
+    if (trace.name === "spawn") {
+      const agent = String(trace.args.name || "worker").trim() || "worker";
+      const label = String(trace.args.description || "").replace(/\s+/g, " ").trim();
+      const prompt = String(trace.args.prompt || "").replace(/\s+/g, " ").trim();
       events.push({
         ts,
         turnId,
         botId,
         kind: "spawn",
         summary: clip(
-          trace.name === "read_spawn"
-            ? `read ${waitId || agent}${trace.running ? " …" : ""}`
-            : `${agent}${bg}${label ? " · " + label : ""}${prompt ? " — " + prompt : ""}${trace.running ? " …" : ""}`,
+          `${agent}${label ? " · " + label : ""}${prompt ? " — " + prompt : ""}${trace.running ? " …" : ""}`,
         ),
         payload: cap(trace.args),
         result: String(cap(trace.text ?? "")),

package/src/usage.ts

@@ -59,19 +59,13 @@ export function fromOpenAiUsage(usage?: {
   prompt_tokens?: number;
   completion_tokens?: number;
   total_tokens?: number;
-  prompt_tokens_details?: { cached_tokens?: number };
-  input_tokens_details?: { cached_tokens?: number };
 } | null): ChatUsage {
   if (!usage) return { rounds: 1 };
   const input = num(usage.prompt_tokens);
   const output = num(usage.completion_tokens);
-  const cacheRead =
-    num(usage.prompt_tokens_details?.cached_tokens) ??
-    num(usage.input_tokens_details?.cached_tokens);
   return {
     input,
     output,
-    cacheRead,
     totalTokens: num(usage.total_tokens) || sum(input, output),
     rounds: 1,
   };
@@ -80,8 +74,6 @@ export function fromOpenAiUsage(usage?: {
 export function fromAnthropicUsage(usage?: {
   input_tokens?: number;
   output_tokens?: number;
-  cache_read_input_tokens?: number;
-  cache_creation_input_tokens?: number;
 } | null): ChatUsage {
   if (!usage) return { rounds: 1 };
   const input = num(usage.input_tokens);
@@ -89,8 +81,6 @@ export function fromAnthropicUsage(usage?: {
   return {
     input,
     output,
-    cacheRead: num(usage.cache_read_input_tokens),
-    cacheWrite: num(usage.cache_creation_input_tokens),
     totalTokens: sum(input, output),
     rounds: 1,
   };

package/vendor/protocol/src/index.ts

@@ -37,8 +37,6 @@ export type Bot = {
   skillIds: string[];
   defaultPositionId: string;
   oneLiner?: string;
-  /** Public /generated/… sprite. Missing → procedural tavern buddy. */
-  portrait?: string;
   /** Chat model for this bot. Missing → guild default. */
   model?: ModelRef | null;
   createdAt: string;
@@ -143,8 +141,7 @@ export type AuxRole =
   | "skills"
   | "approval"
   | "title"
-  | "generate"
-  | "spawn";
+  | "generate";
 
 export type ModelsFile = {
   default?: ModelRef | null;