appostle-installer 0.0.8 → 0.0.9

package/dist/worker.js

@@ -2302,7 +2302,8 @@ function toAgentPayload(agent, options) {
     pendingPermissions: sanitizePendingPermissions(agent.pendingPermissions),
     persistence: sanitizePersistenceHandle(agent.persistence),
     title: options?.title ?? null,
-    labels: agent.labels
+    labels: agent.labels,
+    internal: agent.internal
   };
   const usage = sanitizeUsage(agent.lastUsage);
   if (usage !== void 0) {
@@ -2372,7 +2373,8 @@ function buildStoredAgentPayload(record, providerRegistry, logger) {
     attentionReason: record.attentionReason ?? null,
     attentionTimestamp: record.attentionTimestamp ?? null,
     archivedAt: record.archivedAt ?? null,
-    labels: record.labels
+    labels: record.labels,
+    internal: record.internal
   };
 }
 function resolveStoredAgentPayloadUpdatedAt(record) {
@@ -2414,7 +2416,13 @@ function buildSerializableConfig(config) {
     serializable.systemPrompt = config.systemPrompt;
   }
   if (config.mcpServers) {
-    serializable.mcpServers = config.mcpServers;
+    const persistable = {};
+    for (const [name, server] of Object.entries(config.mcpServers)) {
+      if (server.type !== "sdk") persistable[name] = server;
+    }
+    if (Object.keys(persistable).length > 0) {
+      serializable.mcpServers = persistable;
+    }
   }
   return Object.keys(serializable).length ? serializable : null;
 }
@@ -2453,34 +2461,42 @@ function cloneAvailableModes(modes) {
 function normalizeFeatures(features) {
   return Array.isArray(features) ? features.map((feature) => ({ ...feature })) : [];
 }
-function sanitizeOptionalJson(value) {
+var SANITIZE_MAX_DEPTH = 32;
+function sanitizeOptionalJson(value, seen = /* @__PURE__ */ new WeakSet(), depth = 0) {
   if (value === void 0) {
     return void 0;
   }
   if (value === null) {
     return null;
   }
-  if (Array.isArray(value)) {
-    const sanitized = value.map((item) => sanitizeOptionalJson(item)).filter((item) => item !== void 0);
-    return sanitized;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
   }
   if (value instanceof Date) {
     return value.toISOString();
   }
-  if (typeof value === "object") {
-    const result = {};
-    for (const [key, val] of Object.entries(value)) {
-      const sanitized = sanitizeOptionalJson(val);
-      if (sanitized !== void 0) {
-        result[key] = sanitized;
-      }
-    }
-    return Object.keys(result).length ? result : void 0;
+  if (typeof value !== "object") {
+    return void 0;
   }
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return value;
+  if (depth >= SANITIZE_MAX_DEPTH) {
+    return void 0;
   }
-  return void 0;
+  if (seen.has(value)) {
+    return void 0;
+  }
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const sanitized = value.map((item) => sanitizeOptionalJson(item, seen, depth + 1)).filter((item) => item !== void 0);
+    return sanitized;
+  }
+  const result = {};
+  for (const [key, val] of Object.entries(value)) {
+    const sanitized = sanitizeOptionalJson(val, seen, depth + 1);
+    if (sanitized !== void 0) {
+      result[key] = sanitized;
+    }
+  }
+  return Object.keys(result).length ? result : void 0;
 }
 function isJsonObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -2541,6 +2557,34 @@ function sanitizeUsage(value) {
   } else if (contextWindowUsedTokens !== void 0 && contextWindowUsedTokens !== null) {
     return void 0;
   }
+  const rateLimits = sanitized.rateLimits;
+  if (Array.isArray(rateLimits)) {
+    const VALID_RATE_LIMIT_TYPES = /* @__PURE__ */ new Set([
+      "five_hour",
+      "seven_day",
+      "seven_day_opus",
+      "seven_day_sonnet",
+      "overage"
+    ]);
+    const sanitizedRateLimits = [];
+    for (const entry of rateLimits) {
+      if (!entry || typeof entry !== "object") continue;
+      const { rateLimitType, utilization, resetsAt } = entry;
+      if (typeof rateLimitType !== "string" || !VALID_RATE_LIMIT_TYPES.has(rateLimitType)) continue;
+      if (typeof utilization !== "number" || !Number.isFinite(utilization)) continue;
+      const limit = {
+        rateLimitType,
+        utilization
+      };
+      if (typeof resetsAt === "number" && Number.isFinite(resetsAt)) {
+        limit.resetsAt = resetsAt;
+      }
+      sanitizedRateLimits.push(limit);
+    }
+    if (sanitizedRateLimits.length > 0) {
+      result.rateLimits = sanitizedRateLimits;
+    }
+  }
   return Object.keys(result).length ? result : void 0;
 }
 function sanitizeRuntimeInfo(runtimeInfo) {
@@ -3327,6 +3371,13 @@ var QuestRecordSchema = z8.object({
   cwd: z8.string(),
   /** User's task prompt — fed to every card unless overridden per-card. */
   prompt: z8.string(),
+  /**
+   * Short auto-generated label for the quest, derived from the user prompt by a
+   * small internal metadata agent (mirrors how single-agent sessions get a
+   * title). Empty string until generation finishes (or if it fails). Optional +
+   * default so old persisted records remain valid.
+   */
+  name: z8.string().optional().default(""),
   defaultProvider: AgentProviderSchema,
   defaultModel: z8.string().nullable(),
   termination: QuestTerminationSchema,
@@ -3397,6 +3448,8 @@ var QuestListItemSchema = z9.object({
   status: QuestStatusSchema,
   cwd: z9.string(),
   prompt: z9.string(),
+  /** Auto-generated short label. Optional for backward compat with old daemons. */
+  name: z9.string().optional().default(""),
   createdAt: z9.string(),
   updatedAt: z9.string()
 });
@@ -3748,13 +3801,25 @@ var AgentCapabilityFlagsSchema = z10.object({
   supportsReasoningStream: z10.boolean(),
   supportsToolInvocations: z10.boolean()
 });
+var AgentRateLimitSchema = z10.object({
+  rateLimitType: z10.enum([
+    "five_hour",
+    "seven_day",
+    "seven_day_opus",
+    "seven_day_sonnet",
+    "overage"
+  ]),
+  utilization: z10.number(),
+  resetsAt: z10.number().optional()
+});
 var AgentUsageSchema = z10.object({
   inputTokens: z10.number().optional(),
   cachedInputTokens: z10.number().optional(),
   outputTokens: z10.number().optional(),
   totalCostUsd: z10.number().optional(),
   contextWindowMaxTokens: z10.number().optional(),
-  contextWindowUsedTokens: z10.number().optional()
+  contextWindowUsedTokens: z10.number().optional(),
+  rateLimits: z10.array(AgentRateLimitSchema).optional()
 });
 var McpStdioServerConfigSchema = z10.object({
   type: z10.literal("stdio"),
@@ -4140,7 +4205,15 @@ var AgentSnapshotPayloadSchema = z10.object({
   archivedAt: z10.string().nullable().optional(),
   // Fork lineage — optional for backward compat with pre-fork agents.
   parentAgentId: z10.string().optional(),
-  forkedFromMessageUuid: z10.string().optional()
+  forkedFromMessageUuid: z10.string().optional(),
+  /**
+   * True when the agent is a system-spawned helper (orchestrator queens,
+   * handoff workers). Optional for backward compat — older clients ignore
+   * the field. Newer clients filter these out of workspace tab lists / agent
+   * lists at display time. The agent itself is a real, full-featured session
+   * in every other respect; `internal` is a UI visibility hint, nothing more.
+   */
+  internal: z10.boolean().optional()
 });
 var VoiceAudioChunkMessageSchema = z10.object({
   type: z10.literal("voice_audio_chunk"),
@@ -18090,6 +18163,8 @@ function toClaudeSdkMcpConfig(config) {
         url: config.url,
         headers: config.headers
       };
+    case "sdk":
+      return config.config;
   }
 }
 var homeMcpServersCache = null;
@@ -20009,6 +20084,43 @@ ${error.stack ?? ""}` : JSON.stringify(error);
         }
         break;
       }
+      case "rate_limit_event": {
+        const info = message.rate_limit_info;
+        if (info && typeof info === "object") {
+          const { rateLimitType, utilization, resetsAt } = info;
+          const VALID_TYPES = /* @__PURE__ */ new Set([
+            "five_hour",
+            "seven_day",
+            "seven_day_opus",
+            "seven_day_sonnet",
+            "overage"
+          ]);
+          if (typeof rateLimitType === "string" && VALID_TYPES.has(rateLimitType) && typeof utilization === "number") {
+            const rateLimit = {
+              rateLimitType,
+              utilization
+            };
+            if (typeof resetsAt === "number") {
+              rateLimit.resetsAt = resetsAt;
+            }
+            const existingLimits = this.lastRateLimits ?? [];
+            const updated = existingLimits.filter((l) => l.rateLimitType !== rateLimitType);
+            updated.push(rateLimit);
+            this.lastRateLimits = updated;
+            const usage = {
+              rateLimits: updated
+            };
+            if (this.lastContextWindowMaxTokens !== void 0) {
+              usage.contextWindowMaxTokens = this.lastContextWindowMaxTokens;
+            }
+            if (this.lastContextWindowUsedTokens !== void 0) {
+              usage.contextWindowUsedTokens = this.lastContextWindowUsedTokens;
+            }
+            events.push({ type: "usage_updated", provider: "claude", usage });
+          }
+        }
+        break;
+      }
       default:
         break;
     }
@@ -20117,6 +20229,9 @@ ${error.stack ?? ""}` : JSON.stringify(error);
       outputTokens: message.usage.output_tokens,
       totalCostUsd: message.total_cost_usd
     };
+    if (this.lastRateLimits !== void 0) {
+      usage.rateLimits = this.lastRateLimits;
+    }
     const contextWindowMaxTokens = extractContextWindowSize(modelUsage ?? message.modelUsage);
     if (contextWindowMaxTokens !== void 0) {
       this.lastContextWindowMaxTokens = contextWindowMaxTokens;
@@ -20486,10 +20601,10 @@ ${error.stack ?? ""}` : JSON.stringify(error);
       return void 0;
     }
     const server = entry?.server ?? block.server ?? "tool";
-    const tool = entry?.name ?? block.tool_name ?? "tool";
+    const tool2 = entry?.name ?? block.tool_name ?? "tool";
     const content = coerceToolResultContentToString(block.content);
     const input = entry?.input;
-    const structured = this.buildStructuredToolResult(server, tool, content, input);
+    const structured = this.buildStructuredToolResult(server, tool2, content, input);
     if (structured) {
       return structured;
     }
@@ -20506,9 +20621,9 @@ ${error.stack ?? ""}` : JSON.stringify(error);
     }
     return Object.keys(result).length > 0 ? result : void 0;
   }
-  buildStructuredToolResult(server, tool, output, input) {
+  buildStructuredToolResult(server, tool2, output, input) {
     const normalizedServer = server.toLowerCase();
-    const normalizedTool = tool.toLowerCase();
+    const normalizedTool = tool2.toLowerCase();
     if (normalizedServer.includes("bash") || normalizedServer.includes("shell") || normalizedServer.includes("command") || normalizedTool.includes("bash") || normalizedTool.includes("shell") || normalizedTool.includes("command") || input && (typeof input.command === "string" || Array.isArray(input.command))) {
       const command = this.extractCommandText(input ?? {}) ?? "command";
       return {
@@ -21822,8 +21937,8 @@ function resolveStatus(rawStatus, error, output) {
   }
   return output !== null && output !== void 0 ? "completed" : "running";
 }
-function buildMcpToolName(server, tool) {
-  const trimmedTool = tool.trim();
+function buildMcpToolName(server, tool2) {
+  const trimmedTool = tool2.trim();
   if (!trimmedTool) {
     return "tool";
   }
@@ -21993,11 +22108,11 @@ function mapFileChangeItem(item, options) {
   };
 }
 function mapMcpToolCallItem(item, options) {
-  const tool = item.tool.trim();
-  if (!tool) {
+  const tool2 = item.tool.trim();
+  if (!tool2) {
     return null;
   }
-  const name = buildMcpToolName(item.server, tool);
+  const name = buildMcpToolName(item.server, tool2);
   const input = item.arguments ?? null;
   const output = item.result ?? null;
   const error = item.error ?? null;
@@ -22958,6 +23073,8 @@ function toCodexMcpConfig(config) {
         url: config.url,
         http_headers: config.headers
       };
+    case "sdk":
+      return null;
   }
 }
 var CodexAppServerClient = class {
@@ -25100,7 +25217,8 @@ var CodexAppServerAgentSession = class {
     if (this.config.mcpServers) {
       const mcpServers = {};
       for (const [name, serverConfig] of Object.entries(this.config.mcpServers)) {
-        mcpServers[name] = toCodexMcpConfig(serverConfig);
+        const codexConfig = toCodexMcpConfig(serverConfig);
+        if (codexConfig) mcpServers[name] = codexConfig;
       }
       innerConfig.mcp_servers = mcpServers;
     }
@@ -27146,9 +27264,10 @@ function normalizeMcpServers(servers) {
   if (!servers) {
     return [];
   }
-  return Object.entries(servers).map(([name, config]) => {
+  const out = [];
+  for (const [name, config] of Object.entries(servers)) {
     if (config.type === "stdio") {
-      return {
+      out.push({
         name,
         command: config.command,
         args: config.args ?? [],
@@ -27156,29 +27275,35 @@ function normalizeMcpServers(servers) {
           name: envName,
           value
         }))
-      };
+      });
+      continue;
     }
     if (config.type === "http") {
-      return {
+      out.push({
         type: "http",
         name,
         url: config.url,
         headers: Object.entries(config.headers ?? {}).map(([headerName, value]) => ({
           name: headerName,
-          value
+          value: String(value)
         }))
-      };
+      });
+      continue;
     }
-    return {
-      type: "sse",
-      name,
-      url: config.url,
-      headers: Object.entries(config.headers ?? {}).map(([headerName, value]) => ({
-        name: headerName,
-        value
-      }))
-    };
-  });
+    if (config.type === "sse") {
+      out.push({
+        type: "sse",
+        name,
+        url: config.url,
+        headers: Object.entries(config.headers ?? {}).map(([headerName, value]) => ({
+          name: headerName,
+          value: String(value)
+        }))
+      });
+      continue;
+    }
+  }
+  return out;
 }
 function toACPContentBlocks(prompt) {
   if (typeof prompt === "string") {
@@ -28009,12 +28134,15 @@ function toOpenCodeMcpConfig(config) {
       enabled: true
     };
   }
-  return {
-    type: "remote",
-    url: config.url,
-    ...config.headers ? { headers: config.headers } : {},
-    enabled: true
-  };
+  if (config.type === "http" || config.type === "sse") {
+    return {
+      type: "remote",
+      url: config.url,
+      ...config.headers ? { headers: config.headers } : {},
+      enabled: true
+    };
+  }
+  return null;
 }
 function stringifyUnknownError(error) {
   if (typeof error === "string") {
@@ -28957,7 +29085,7 @@ function translateOpenCodeEvent(event, state) {
         break;
       }
       const metadata = readOpenCodeRecord(event.properties.metadata);
-      const tool = readOpenCodeRecord(event.properties.tool);
+      const tool2 = readOpenCodeRecord(event.properties.tool);
       const patterns = Array.isArray(event.properties.patterns) ? event.properties.patterns.filter((value) => typeof value === "string") : [];
       const command = readPermissionField(metadata, PERMISSION_COMMAND_KEYS);
       const cwd = readPermissionField(metadata, PERMISSION_CWD_KEYS);
@@ -28965,7 +29093,7 @@ function translateOpenCodeEvent(event, state) {
       const input = buildOpenCodePermissionInput({
         patterns,
         metadata,
-        tool,
+        tool: tool2,
         command
       });
       const detail = buildOpenCodePermissionDetail({
@@ -29713,6 +29841,7 @@ var OpenCodeAgentSession = class {
   async configureMcpServers(mcpServers) {
     for (const [name, serverConfig] of Object.entries(mcpServers)) {
       const mappedConfig = toOpenCodeMcpConfig(serverConfig);
+      if (!mappedConfig) continue;
       await this.registerMcpServer(name, mappedConfig);
     }
   }
@@ -41250,7 +41379,7 @@ ${details}`.trim());
     );
     const registryRecords = await this.agentStorage.list();
     const liveIds = new Set(agentSnapshots.map((a) => a.id));
-    const persistedAgents = registryRecords.filter((record) => !liveIds.has(record.id) && !record.internal).map((record) => this.buildStoredAgentPayload(record));
+    const persistedAgents = registryRecords.filter((record) => !liveIds.has(record.id)).map((record) => this.buildStoredAgentPayload(record));
     let agents = [...liveAgents, ...persistedAgents];
     agents = agents.filter((agent) => this.isProviderVisibleToClient(agent.provider));
     if (filter?.labels) {
@@ -43852,6 +43981,7 @@ ${details}`.trim());
         status: w.status,
         cwd: w.cwd,
         prompt: w.prompt,
+        name: w.name,
         createdAt: w.createdAt,
         updatedAt: w.updatedAt
       }));
@@ -51684,7 +51814,7 @@ var AgentManager = class {
         }
         break;
       case "usage_updated":
-        agent.lastUsage = event.usage;
+        agent.lastUsage = { ...agent.lastUsage, ...event.usage };
         this.emitState(agent);
         break;
       case "timeline":
@@ -51734,7 +51864,7 @@ var AgentManager = class {
           },
           "handleStreamEvent: turn_completed"
         );
-        agent.lastUsage = event.usage;
+        agent.lastUsage = { ...agent.lastUsage, ...event.usage };
         agent.lastError = void 0;
         if (!isForegroundEvent && agent.lifecycle !== "idle" && !agent.pendingReplacement) {
           agent.lifecycle = "idle";
@@ -52024,17 +52154,6 @@ var AgentManager = class {
       if (subscriber.agentId && event.type === "agent_state" && subscriber.agentId !== event.agent.id) {
         continue;
       }
-      if (!subscriber.agentId) {
-        if (event.type === "agent_state" && event.agent.internal) {
-          continue;
-        }
-        if (event.type === "agent_stream") {
-          const agent = this.agents.get(event.agentId);
-          if (agent?.internal) {
-            continue;
-          }
-        }
-      }
       subscriber.callback(event);
     }
   }
@@ -55580,6 +55699,97 @@ function getRulesForKind(kind) {
   }
 }
 
+// ../server/src/server/quest/quest-metadata-generator.ts
+import { z as z41 } from "zod";
+var MAX_AUTO_QUEST_NAME_CHARS = 40;
+function hasExplicitName(name) {
+  return Boolean(name && name.trim().length > 0);
+}
+function normalizeAutoName(name) {
+  const normalized = name.trim();
+  if (!normalized) {
+    return null;
+  }
+  return normalized.slice(0, MAX_AUTO_QUEST_NAME_CHARS).trim() || null;
+}
+function buildPrompt2(prompt) {
+  return [
+    "Generate a short label for a multi-agent quest based on the user prompt.",
+    `Name: short descriptive label (<= ${MAX_AUTO_QUEST_NAME_CHARS} chars).`,
+    "Return JSON only with a single field 'name'.",
+    "",
+    "User prompt:",
+    prompt
+  ].join("\n");
+}
+async function generateAndApplyQuestMetadata(options) {
+  const prompt = options.prompt.trim();
+  if (!prompt) {
+    return;
+  }
+  if (hasExplicitName(options.explicitName)) {
+    return;
+  }
+  const schema = z41.object({
+    name: z41.string().min(1).max(MAX_AUTO_QUEST_NAME_CHARS)
+  });
+  const generator = options.deps?.generateStructuredAgentResponseWithFallback ?? generateStructuredAgentResponseWithFallback;
+  let result;
+  try {
+    result = await generator({
+      manager: options.questService.agentManager,
+      cwd: options.cwd,
+      prompt: buildPrompt2(prompt),
+      schema,
+      schemaName: "QuestMetadata",
+      maxRetries: 2,
+      providers: DEFAULT_STRUCTURED_GENERATION_PROVIDERS,
+      agentConfigOverrides: {
+        title: "Quest metadata generator",
+        internal: true
+      }
+    });
+  } catch (error) {
+    if (error instanceof StructuredAgentResponseError || error instanceof StructuredAgentFallbackError) {
+      options.logger.warn(
+        { err: error, questId: options.questId },
+        "Structured quest metadata generation failed"
+      );
+      return;
+    }
+    options.logger.error(
+      { err: error, questId: options.questId },
+      "Quest metadata generation failed"
+    );
+    return;
+  }
+  if (typeof result.name !== "string") {
+    return;
+  }
+  const normalized = normalizeAutoName(result.name);
+  if (!normalized) {
+    return;
+  }
+  try {
+    await options.questService.setName(options.questId, normalized);
+  } catch (error) {
+    options.logger.warn(
+      { err: error, questId: options.questId },
+      "Failed to apply generated quest name"
+    );
+  }
+}
+function scheduleQuestMetadataGeneration(options) {
+  queueMicrotask(() => {
+    void generateAndApplyQuestMetadata(options).catch((error) => {
+      options.logger.error(
+        { err: error, questId: options.questId },
+        "Quest metadata generation crashed"
+      );
+    });
+  });
+}
+
 // ../server/src/server/quest/service.ts
 var QUEST_ID_LENGTH = 8;
 var DEFAULT_PROVIDER = "claude";
@@ -55748,6 +55958,7 @@ var QuestService = class {
       rules,
       cwd: options.cwd,
       prompt,
+      name: "",
       defaultProvider: options.defaultProvider ?? DEFAULT_PROVIDER,
       defaultModel: options.defaultModel ?? null,
       termination: options.termination,
@@ -55762,6 +55973,13 @@ var QuestService = class {
     });
     await this.store.upsert(record);
     this.publish(record);
+    scheduleQuestMetadataGeneration({
+      questService: this,
+      questId: record.id,
+      cwd: record.cwd,
+      prompt,
+      logger: this.logger
+    });
     const runner = this.runners[options.kind];
     if (!runner) {
       const failed = QuestRecordSchema.parse({
@@ -55896,6 +56114,17 @@ var QuestService = class {
     }
     return this.persistAndPublish(record, { hivemindPath });
   }
+  /** Set the auto-generated quest name. No-op if the name hasn't actually changed. */
+  async setName(questId, name) {
+    const record = this.store.get(questId);
+    if (!record) {
+      throw new Error(`Quest "${questId}" not found`);
+    }
+    if (record.name === name) {
+      return record;
+    }
+    return this.persistAndPublish(record, { name });
+  }
   /** Mark the quest's terminal status. Idempotent — running→stopped is fine. */
   async markStatus(questId, status) {
     const record = this.store.get(questId);
@@ -56176,257 +56405,329 @@ ${text || "(no output)"}`).join("\n\n");
 }
 
 // ../server/src/server/quest/runner-orchestrator.ts
-import { appendFile, mkdir as mkdir8, readFile as readFile5, writeFile as writeFile7 } from "node:fs/promises";
+import { access, readFile as readFile5 } from "node:fs/promises";
 import path26 from "node:path";
-function nowIso4() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
-async function resolveAllRoles(record) {
-  const out = [];
-  for (const card of record.cards) {
-    if (!card.role) {
-      out.push({
-        cardIndex: card.index,
-        roleName: `card-${card.index}`,
-        body: null,
-        allowedTools: []
-      });
-      continue;
-    }
-    const resolved = await resolveRole({ roleName: card.role, workspaceRoot: record.cwd });
-    out.push({
-      cardIndex: card.index,
-      roleName: card.role,
-      body: resolved?.body ?? null,
-      allowedTools: resolved?.allowedTools ?? []
-    });
-  }
-  return out;
-}
-function buildQueenSystemPrompt(args) {
-  const roleSections = args.roles.map((r) => {
-    const body = r.body ? r.body.trim() : "(no role body found \u2014 this card has no system prompt)";
-    return [`### Card ${r.cardIndex} \xB7 role: \`${r.roleName}\``, "", body].join("\n");
-  }).join("\n\n---\n\n");
-  return [
-    "You are the QUEEN BEE \u2014 the planner of a multi-agent orchestration.",
-    "",
-    "You do NOT do the work yourself. Your one and only job is to read the",
-    "user's task plus the role roster below and emit ONE JSON plan that",
-    "delegates the work across your team.",
-    "",
-    "A plan is an ORDERED list of waves. Each wave is a SET of role dispatches",
-    "that the runner will execute IN PARALLEL. Wave N+1 starts only after",
-    "every dispatch in wave N has finished.",
-    "",
-    "Use parallelism aggressively. Place roles in the SAME wave whenever they",
-    "do not depend on each other's output. Place a role in a LATER wave only",
-    "when it genuinely needs the result of an earlier wave.",
-    "",
-    "Each role on the roster runs AT MOST ONCE \u2014 do not schedule the same",
-    "role twice anywhere in the plan. You may also OMIT roles that are not",
-    "needed for the user's task.",
-    "",
-    "## Your team",
-    "",
-    "Read every role description carefully so you understand what each worker",
-    "can and cannot do, and what inputs they need.",
-    "",
-    roleSections,
-    "",
-    "## Hivemind doc",
-    "",
-    `The hivemind doc lives at: ${args.hivemindPath}`,
-    "",
-    "After every wave the runner appends each worker's final output to that",
-    "doc, and feeds the hivemind contents inline into the prompts of any",
-    "workers in later waves so they can build on prior results. You do not",
-    "need to think about this \u2014 just write self-contained dispatch prompts.",
-    "",
-    "## Response contract \u2014 STRICT",
-    "",
-    "Respond with EXACTLY one fenced JSON code block and nothing else. No",
-    "prose before or after. The JSON must match this shape:",
-    "",
-    "```json",
-    "{",
-    '  "plan": [',
-    '    { "dispatches": [',
-    '        { "role": "<roleName>", "prompt": "<concrete sub-task>" }',
-    "    ]}",
-    "  ]",
-    "}",
-    "```",
-    "",
-    "Rules:",
-    "- `role` must match one of the role names listed above EXACTLY.",
-    "- A role appears AT MOST ONCE across the entire plan.",
-    "- `prompt` is a precise, self-contained task for the worker. Cite any",
-    "  expected upstream inputs by role name (the runner injects the hivemind",
-    "  contents automatically).",
-    "- The plan ends when its last wave finishes. There is no `done` action."
-  ].join("\n");
-}
-function extractFencedJson(text) {
-  const fence = /```(?:json)?\s*([\s\S]*?)```/i.exec(text);
-  if (fence?.[1]) return fence[1].trim();
-  const brace = /\{[\s\S]*\}/.exec(text);
-  return brace ? brace[0].trim() : null;
-}
-function parseQueenPlan(text, knownRoles) {
-  const block = extractFencedJson(text);
-  if (!block) {
-    return { ok: false, reason: "no JSON block found in queen response" };
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(block);
-  } catch (err) {
-    return {
-      ok: false,
-      reason: `JSON parse error: ${err instanceof Error ? err.message : String(err)}`
-    };
-  }
-  if (!parsed || typeof parsed !== "object") {
-    return { ok: false, reason: "queen response is not an object" };
-  }
-  const planRaw = parsed.plan;
-  if (!Array.isArray(planRaw) || planRaw.length === 0) {
-    return { ok: false, reason: "plan must be a non-empty array of waves" };
-  }
-  const seenRoles = /* @__PURE__ */ new Set();
-  const waves = [];
-  for (let i = 0; i < planRaw.length; i += 1) {
-    const waveRaw = planRaw[i];
-    if (!waveRaw || typeof waveRaw !== "object") {
-      return { ok: false, reason: `wave ${i + 1} is not an object` };
-    }
-    const dispatchesRaw = waveRaw.dispatches;
-    if (!Array.isArray(dispatchesRaw) || dispatchesRaw.length === 0) {
-      return { ok: false, reason: `wave ${i + 1} has no dispatches` };
-    }
-    const dispatches = [];
-    for (const d of dispatchesRaw) {
-      if (!d || typeof d !== "object" || typeof d.role !== "string" || typeof d.prompt !== "string") {
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+
+// ../server/src/server/quest/orchestrator-mcp.ts
+import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk";
+import { z as z42 } from "zod";
+var HANDOFF_INPUT_SHAPE = {
+  rolePath: z42.string().min(1).describe(
+    "Absolute filesystem path to the role .md file the worker should adopt as its system prompt. Must be one of the role file paths listed in your team roster \u2014 do not invent paths."
+  ),
+  task: z42.string().min(1).describe(
+    "Concrete, self-contained instruction for the worker. The worker has its own toolbelt and reads the role at rolePath as its system prompt \u2014 write the task as a normal user message describing what to do, what inputs to read, and where to write outputs. Reference the hivemind doc by absolute path if relevant."
+  )
+};
+function buildOrchestratorMcpServer(options) {
+  const {
+    questId,
+    agentManager,
+    resolveWorkerConfig,
+    onHandoffSpawned,
+    onHandoffCompleted,
+    logger,
+    signal
+  } = options;
+  const handoffTool = tool(
+    "handoff",
+    [
+      "Spawn a fresh full Appostle agent session, give it a role and a task, wait for it to finish, and return its final text.",
+      "",
+      "Use this tool \u2014 and ONLY this tool \u2014 to delegate work. Do not attempt to do the work yourself, do not shell out, do not invoke ephemeral subagents.",
+      "",
+      "Each call spawns one independent session with its own clean context (the whole point: it saves YOUR context budget). To run multiple workers in parallel, emit multiple handoff tool calls in the same response \u2014 they will execute concurrently and you will see all the results in the next turn. To run sequentially, wait for one call's result before issuing the next."
+    ].join("\n"),
+    HANDOFF_INPUT_SHAPE,
+    async (args) => {
+      const log = logger.child({ tool: "appostle.handoff", questId });
+      log.info({ rolePath: args.rolePath }, "handoff: spawning worker");
+      let workerConfig;
+      try {
+        workerConfig = await resolveWorkerConfig({
+          rolePath: args.rolePath,
+          taskTitle: deriveTaskTitle(args.task)
+        });
+      } catch (err) {
+        log.warn({ err }, "handoff: failed to resolve worker config");
         return {
-          ok: false,
-          reason: `wave ${i + 1}: every dispatch needs string \`role\` and string \`prompt\``
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `handoff failed: could not resolve role at "${args.rolePath}" \u2014 ${err instanceof Error ? err.message : String(err)}`
+            }
+          ]
         };
       }
-      const role = d.role.trim();
-      const prompt = d.prompt;
-      if (!knownRoles.has(role)) {
-        return { ok: false, reason: `wave ${i + 1}: unknown role \`${role}\`` };
+      let workerAgentId;
+      try {
+        const created = await agentManager.createAgent(workerConfig);
+        workerAgentId = created.id;
+      } catch (err) {
+        log.error({ err }, "handoff: createAgent failed");
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `handoff failed: could not spawn worker \u2014 ${err instanceof Error ? err.message : String(err)}`
+            }
+          ]
+        };
       }
-      if (seenRoles.has(role)) {
+      onHandoffSpawned?.({
+        rolePath: args.rolePath,
+        task: args.task,
+        workerAgentId
+      });
+      const onAbort = () => {
+        void agentManager.cancelAgentRun(workerAgentId).catch(() => {
+        });
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+      try {
+        const run = await agentManager.runAgent(workerAgentId, args.task);
+        const finalText = run.finalText.trim();
+        if (run.canceled) {
+          onHandoffCompleted?.({
+            rolePath: args.rolePath,
+            workerAgentId,
+            status: "stopped",
+            errorMessage: null
+          });
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Worker ${workerAgentId} was canceled before completing.
+
+Partial output (may be empty):
+
+${finalText || "(no output)"}`
+              }
+            ]
+          };
+        }
+        onHandoffCompleted?.({
+          rolePath: args.rolePath,
+          workerAgentId,
+          status: "succeeded",
+          errorMessage: null
+        });
         return {
-          ok: false,
-          reason: `wave ${i + 1}: role \`${role}\` was already scheduled in an earlier wave`
+          content: [
+            {
+              type: "text",
+              text: finalText ? `Worker ${workerAgentId} finished. Final output:
+
+${finalText}` : `Worker ${workerAgentId} finished but produced no final assistant text. Inspect the session if you need the full timeline.`
+            }
+          ]
         };
+      } catch (err) {
+        const errorMessage2 = err instanceof Error ? err.message : String(err);
+        log.error({ err, workerAgentId }, "handoff: runAgent threw");
+        onHandoffCompleted?.({
+          rolePath: args.rolePath,
+          workerAgentId,
+          status: "failed",
+          errorMessage: errorMessage2
+        });
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `handoff failed mid-run for worker ${workerAgentId}: ${errorMessage2}`
+            }
+          ]
+        };
+      } finally {
+        signal.removeEventListener("abort", onAbort);
       }
-      seenRoles.add(role);
-      dispatches.push({ role, prompt });
     }
-    waves.push({ dispatches });
-  }
-  return { ok: true, plan: waves };
+  );
+  const sdkInstance = createSdkMcpServer({
+    name: "appostle",
+    version: "0.1.0",
+    tools: [handoffTool],
+    // Always load — we never want the queen to have to "discover" the handoff
+    // tool. Without this it could be deferred behind tool search.
+    alwaysLoad: true
+  });
+  return {
+    type: "sdk",
+    name: "appostle",
+    config: sdkInstance
+  };
 }
-function resolveFinalTextFromRun2(run) {
-  if (run.finalText.trim()) {
-    return run.finalText;
+function deriveTaskTitle(task) {
+  const firstLine = task.split("\n")[0]?.trim() ?? "";
+  if (firstLine.length === 0) return "handoff";
+  return firstLine.length > 80 ? `${firstLine.slice(0, 77)}\u2026` : firstLine;
+}
+
+// ../server/src/server/quest/runner-orchestrator.ts
+var QUEEN_ALLOWED_TOOLS = ["Read", "Glob", "Grep", "Write", "mcp__appostle__handoff"];
+function nowIso4() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+async function resolveTeam(record) {
+  let roleIndex = [];
+  try {
+    roleIndex = await listRoles({ workspaceRoot: record.cwd });
+  } catch {
   }
-  for (let i = run.timeline.length - 1; i >= 0; i -= 1) {
-    const item = run.timeline[i];
-    if (item && typeof item === "object" && "type" in item && item.type === "assistant_message" && "text" in item && typeof item.text === "string") {
-      const text = item.text;
-      if (text.trim()) {
-        return text;
-      }
+  return record.cards.map((card) => {
+    if (!card.role) {
+      return { cardIndex: card.index, name: null, path: null, description: "" };
     }
+    const match = roleIndex.find((r) => r.name === card.role);
+    return {
+      cardIndex: card.index,
+      name: card.role,
+      path: match?.path ?? null,
+      description: match?.description ?? ""
+    };
+  });
+}
+var FALLBACK_QUEEN_PROMPT_TEMPLATE = [
+  "you are going to send out agents, but first you get aquanted with 'the team'",
+  "You don't go do the work yourself!",
+  "",
+  "this team has very deep knowledge of the task at hand. they have very detailed skills and output prefs so they are smarter than you. don't assume otherwise.",
+  "",
+  "the team is split up in categories. you will try to consolidate all of their knowledge into an approach for the task below.",
+  "",
+  "",
+  "The team:",
+  "",
+  "{{team}}",
+  "",
+  "===",
+  "",
+  "The task at hand:",
+  "",
+  "",
+  ">>>>>",
+  "{{task}}",
+  "<<<<<<<<<<",
+  "",
+  "Again, whatever you are thinking of now I repeat: You don't go do the work yourself!",
+  "What your job IS tho:",
+  "",
+  "Now you have full knowledge of what the user wants and how he composed his 'team'",
+  "you do not delegate this team as subagents but you spawn new handoff sessions, you decide on what can be done in paralel and what needs to happen before the next can start. stage. the amount of handof sessions you spawn is equal to the amount of team entries in your prompt.",
+  "",
+  "",
+  "",
+  "We are going to use a hivemind dock in the repo.",
+  "What you can do, is now startup that hivemind doc in /.hivemind/orchestrator-{{questId}}.md",
+  "",
+  "",
+  "You instruct every handoff with a clear instruction on it's task.",
+  "But you also make sure that each handoff knows the greater context of the end goal and knows of the existence of the hivemind document.",
+  "it should know that it can write to it but first needs to check if there are no conflicts.",
+  "",
+  "",
+  "do not use subagents because these are emphetic. we need full sessions."
+].join("\n");
+var QUEEN_PROMPT_FILENAME = "queen-prompt.md";
+var QUEEN_PROMPT_MAX_LOOKUP_LEVELS = 10;
+async function findQueenPromptOnDisk() {
+  const start = path26.dirname(fileURLToPath3(import.meta.url));
+  let cursor = start;
+  for (let i = 0; i < QUEEN_PROMPT_MAX_LOOKUP_LEVELS; i += 1) {
+    const candidate = path26.join(cursor, QUEEN_PROMPT_FILENAME);
+    try {
+      await access(candidate);
+      return candidate;
+    } catch {
+    }
+    const parent = path26.dirname(cursor);
+    if (parent === cursor) break;
+    cursor = parent;
   }
-  return "";
+  return null;
 }
-function resolveHivemindPaths(cwd, questId) {
-  const dir = path26.join(cwd, ".hiveminds", "orchestrator");
-  return {
-    dir,
-    filePath: path26.join(dir, `orchestrator-${questId}.md`)
-  };
+async function loadQueenPromptTemplate(logger) {
+  const onDisk = await findQueenPromptOnDisk();
+  if (onDisk) {
+    try {
+      const template = await readFile5(onDisk, "utf8");
+      return { template, source: onDisk };
+    } catch (err) {
+      logger.warn(
+        { err, path: onDisk },
+        "orchestrator: queen prompt found on disk but could not be read; using embedded fallback"
+      );
+    }
+  } else {
+    logger.warn("orchestrator: queen prompt not found on disk; using embedded fallback");
+  }
+  return { template: FALLBACK_QUEEN_PROMPT_TEMPLATE, source: "<embedded fallback>" };
 }
-async function initializeHivemind(args) {
-  await mkdir8(args.paths.dir, { recursive: true });
-  const roster = args.roles.map((r) => `- card ${r.cardIndex} \xB7 \`${r.roleName}\``).join("\n");
-  const planSummary = args.plan.map(
-    (wave, i) => `**wave ${i + 1}** \u2014 ${wave.dispatches.map((d) => `\`${d.role}\``).join(", ")}`
-  ).join("\n");
-  const body = [
-    `# Orchestrator ${args.record.id}`,
-    "",
-    `- createdAt: ${args.record.createdAt}`,
-    `- prompt: ${args.record.prompt}`,
-    "",
-    "## Roster",
-    "",
-    roster,
-    "",
-    "## Plan",
-    "",
-    planSummary,
-    "",
-    "## Waves",
-    ""
-  ].join("\n");
-  await writeFile7(args.paths.filePath, body, "utf8");
+function renderTeamLines(team) {
+  return team.map((m, i) => {
+    const idx = i + 1;
+    if (!m.name) return `[value ${idx}, (no role assigned to this card)]`;
+    const filePath = m.path ?? "(role file not resolved on disk)";
+    const desc = m.description ? ` \u2014 ${m.description}` : "";
+    return `[value ${idx}, ${m.name}${desc}, ${filePath}]`;
+  }).join("\n\n");
 }
-async function appendHivemind(filePath, chunk) {
-  await appendFile(filePath, chunk, "utf8");
+function buildMetaPrompt(args) {
+  return args.template.split("{{team}}").join(renderTeamLines(args.team)).split("{{task}}").join(args.userPrompt).split("{{questId}}").join(args.questId);
 }
-async function readHivemind(filePath) {
+async function resolveWorkerConfigForHandoff(args) {
+  const { record, rolePath, taskTitle } = args;
+  const modeId = getProviderFullAccessModeId(record.defaultProvider) ?? void 0;
+  const baseConfig = {
+    provider: record.defaultProvider,
+    cwd: record.cwd,
+    model: record.defaultModel ?? void 0,
+    modeId,
+    title: `quest ${record.id} handoff: ${taskTitle}`,
+    internal: true
+  };
+  const roleName = path26.basename(rolePath, path26.extname(rolePath));
   try {
-    return await readFile5(filePath, "utf8");
+    const resolved = await resolveRole({
+      roleName,
+      workspaceRoot: record.cwd
+    });
+    if (resolved) {
+      const config = { ...baseConfig };
+      if (resolved.body) config.systemPrompt = resolved.body;
+      if (resolved.allowedTools.length > 0) config.allowedTools = resolved.allowedTools;
+      return config;
+    }
   } catch {
-    return "";
   }
+  return baseConfig;
 }
 function buildQueenAgentConfig(args) {
   const modeId = getProviderFullAccessModeId(args.record.defaultProvider) ?? void 0;
   return {
     provider: args.record.defaultProvider,
     cwd: args.record.cwd,
+    // Queen runs on whatever model the user picked at the quest level. We
+    // don't hard-code a model here — observe behaviour across model choices.
     model: args.record.defaultModel ?? void 0,
     modeId,
-    systemPrompt: args.systemPrompt,
+    // No system prompt overlay. The queen's instruction is the first user
+    // message (the meta-prompt). She gets a vanilla agent identity from the
+    // provider preset.
+    allowedTools: QUEEN_ALLOWED_TOOLS,
+    // In-process MCP server with the `handoff` tool. Registered under the
+    // name `appostle`, so the queen sees `mcp__appostle__handoff`.
+    mcpServers: { appostle: args.mcpServer },
     title: `quest ${args.record.id} queen`,
     internal: true
   };
 }
-function buildWorkerAgentConfig(args) {
-  const modeId = getProviderFullAccessModeId(args.record.defaultProvider) ?? void 0;
-  return {
-    provider: args.record.defaultProvider,
-    cwd: args.record.cwd,
-    model: args.card.model ?? args.record.defaultModel ?? void 0,
-    modeId,
-    systemPrompt: args.roleBody ?? void 0,
-    allowedTools: args.allowedTools.length > 0 ? args.allowedTools : void 0,
-    title: `quest ${args.record.id} card ${args.card.index} ${args.card.role ?? ""}`.trim(),
-    internal: true
-  };
-}
-function buildWorkerPrompt(args) {
-  if (args.isFirstWave) {
-    return args.dispatchPrompt;
-  }
-  return [
-    args.dispatchPrompt,
-    "",
-    "---",
-    "",
-    "## Hivemind context (outputs from earlier waves)",
-    "",
-    args.hivemindMarkdown
-  ].join("\n");
-}
 var OrchestratorRunner = class {
   constructor(options) {
     this.logger = options.logger.child({ module: "quest-runner-orchestrator" });
@@ -56447,23 +56748,66 @@ var OrchestratorRunner = class {
       await service.markStatus(questId, "failed");
       throw new Error("Orchestrate quest requires at least one role card");
     }
-    const hivemindPaths = resolveHivemindPaths(initial.cwd, initial.id);
-    const resolvedRoles = await resolveAllRoles(initial);
-    const knownRoles = new Set(resolvedRoles.map((r) => r.roleName));
-    const cardIndexByRole = /* @__PURE__ */ new Map();
-    for (const r of resolvedRoles) {
-      if (!cardIndexByRole.has(r.roleName)) {
-        cardIndexByRole.set(r.roleName, r.cardIndex);
+    const team = await resolveTeam(initial);
+    const { template, source: templateSource } = await loadQueenPromptTemplate(this.logger);
+    this.logger.info({ questId, templateSource }, "orchestrator: queen prompt loaded");
+    const metaPrompt = buildMetaPrompt({
+      template,
+      team,
+      userPrompt: initial.prompt,
+      questId: initial.id
+    });
+    const cardIndexByRolePath = /* @__PURE__ */ new Map();
+    for (const member of team) {
+      if (member.path) cardIndexByRolePath.set(member.path, member.cardIndex);
+    }
+    const mcpServer = buildOrchestratorMcpServer({
+      questId: initial.id,
+      agentManager: service.agentManager,
+      logger: this.logger,
+      signal,
+      resolveWorkerConfig: ({ rolePath, taskTitle }) => resolveWorkerConfigForHandoff({
+        record: initial,
+        rolePath,
+        taskTitle
+      }),
+      onHandoffSpawned: ({ rolePath, workerAgentId }) => {
+        const cardIndex = cardIndexByRolePath.get(rolePath);
+        if (cardIndex === void 0) {
+          this.logger.warn(
+            { rolePath, questId: initial.id },
+            "orchestrator: handoff for unknown rolePath \u2014 no card to attach"
+          );
+          return;
+        }
+        void service.updateCard(initial.id, cardIndex, {
+          status: "running",
+          agentId: workerAgentId,
+          startedAt: nowIso4()
+        }).catch(
+          (err) => this.logger.warn(
+            { err, cardIndex },
+            "orchestrator: failed to stamp card with worker agentId"
+          )
+        );
+      },
+      onHandoffCompleted: ({ rolePath, status: workerStatus }) => {
+        const cardIndex = cardIndexByRolePath.get(rolePath);
+        if (cardIndex === void 0) return;
+        void service.updateCard(initial.id, cardIndex, {
+          status: workerStatus,
+          completedAt: nowIso4()
+        }).catch(
+          (err) => this.logger.warn(
+            { err, cardIndex, workerStatus },
+            "orchestrator: failed to stamp card with worker completion"
+          )
+        );
       }
-    }
-    await service.setHivemindPath(questId, hivemindPaths.filePath);
-    const queenSystemPrompt = buildQueenSystemPrompt({
-      roles: resolvedRoles,
-      hivemindPath: hivemindPaths.filePath
     });
     const queenStartedAt = nowIso4();
     const queenAgent = await service.agentManager.createAgent(
-      buildQueenAgentConfig({ record: initial, systemPrompt: queenSystemPrompt })
+      buildQueenAgentConfig({ record: initial, mcpServer })
     );
     const queenCard = QuestCardSchema.parse({
       index: 0,
@@ -56483,233 +56827,50 @@ var OrchestratorRunner = class {
       });
     };
     signal.addEventListener("abort", onAbort);
-    let plan;
+    let finalStatus = "succeeded";
     try {
-      const queenRun = await service.agentManager.runAgent(queenAgent.id, initial.prompt);
+      const queenRun = await service.agentManager.runAgent(queenAgent.id, metaPrompt);
       if (queenRun.canceled || signal.aborted) {
         await service.updateQueenCard(questId, {
           status: "stopped",
           completedAt: nowIso4()
         });
-        await this.markRemainingCardsStopped(questId, service);
         await service.markStatus(questId, "stopped");
         return;
       }
-      const queenText = resolveFinalTextFromRun2(queenRun);
-      const result = parseQueenPlan(queenText, knownRoles);
-      if (!result.ok) {
-        await mkdir8(hivemindPaths.dir, { recursive: true });
-        await writeFile7(
-          hivemindPaths.filePath,
-          [
-            `# Orchestrator ${initial.id}`,
-            "",
-            `- createdAt: ${initial.createdAt}`,
-            `- prompt: ${initial.prompt}`,
-            "",
-            "## Plan parse failed",
-            "",
-            `Reason: ${result.reason}`,
-            "",
-            "### Queen response",
-            "",
-            "```",
-            queenText.slice(0, 4e3),
-            "```",
-            ""
-          ].join("\n"),
-          "utf8"
-        );
-        await service.updateQueenCard(questId, {
-          status: "failed",
-          completedAt: nowIso4()
-        });
-        await this.markRemainingCardsStopped(questId, service);
-        await service.markStatus(questId, "failed");
-        return;
-      }
-      plan = result.plan;
+      await service.updateQueenCard(questId, {
+        status: "succeeded",
+        completedAt: nowIso4()
+      });
     } catch (err) {
       this.logger.error({ err, questId }, "orchestrator: queen errored");
       await service.updateQueenCard(questId, {
         status: "failed",
         completedAt: nowIso4()
       });
-      await this.markRemainingCardsStopped(questId, service);
-      await service.markStatus(questId, "failed");
-      return;
+      finalStatus = "failed";
     } finally {
       signal.removeEventListener("abort", onAbort);
     }
-    await service.updateQueenCard(questId, {
-      status: "succeeded",
-      completedAt: nowIso4()
-    });
-    await initializeHivemind({
-      paths: hivemindPaths,
-      record: initial,
-      roles: resolvedRoles,
-      plan
-    });
-    const scheduledRoles = /* @__PURE__ */ new Set();
-    for (const wave of plan) {
-      for (const d of wave.dispatches) scheduledRoles.add(d.role);
-    }
-    for (const card of initial.cards) {
-      if (card.role && !scheduledRoles.has(card.role) && card.status === "queued") {
-        await service.updateCard(questId, card.index, {
-          status: "stopped",
-          completedAt: nowIso4()
-        });
-      }
-    }
-    let aborted = false;
-    let anyWaveFailed = false;
-    for (let i = 0; i < plan.length; i += 1) {
-      const wave = plan[i];
-      const waveNumber = i + 1;
-      const current = service.getRecord(questId);
-      if (!current || current.status !== "running" || signal.aborted) {
-        aborted = true;
-        break;
-      }
-      const waveHeader = [
-        `
-### wave ${waveNumber} \u2014 dispatch`,
-        "",
-        ...wave.dispatches.map(
-          (d) => `- \`${d.role}\` \u2190 ${d.prompt.replace(/\s+/g, " ").slice(0, 200)}`
-        ),
-        ""
-      ].join("\n");
-      await appendHivemind(hivemindPaths.filePath, waveHeader);
-      const hivemindMarkdown = await readHivemind(hivemindPaths.filePath);
-      const outcomes = await Promise.all(
-        wave.dispatches.map((dispatch) => {
-          const cardIndex = cardIndexByRole.get(dispatch.role);
-          const role = resolvedRoles.find((r) => r.cardIndex === cardIndex);
-          return this.runWorker({
-            record: initial,
-            cardIndex,
-            workerPrompt: buildWorkerPrompt({
-              dispatchPrompt: dispatch.prompt,
-              hivemindMarkdown,
-              isFirstWave: i === 0
-            }),
-            roleBody: role?.body ?? null,
-            allowedTools: role?.allowedTools ?? [],
-            service,
-            signal
-          });
-        })
-      );
-      for (const outcome of outcomes) {
-        const heading = `
-#### card ${outcome.card.index} \xB7 \`${outcome.card.role ?? "(no role)"}\` \u2014 ${outcome.status}
-
-`;
-        const bodyText = outcome.status === "succeeded" ? outcome.finalText.trim() || "_(empty output)_" : `_(${outcome.errorMessage ?? outcome.status})_`;
-        await appendHivemind(hivemindPaths.filePath, heading + bodyText + "\n");
-      }
-      if (outcomes.some((o) => o.status === "stopped") || signal.aborted) {
-        aborted = true;
-        break;
-      }
-      if (outcomes.some((o) => o.status === "failed")) {
-        anyWaveFailed = true;
-      }
-    }
-    if (aborted) {
-      await this.markRemainingCardsStopped(questId, service);
-      await service.markStatus(questId, "stopped");
-      return;
-    }
-    await service.markStatus(questId, anyWaveFailed ? "failed" : "succeeded");
-  }
-  async markRemainingCardsStopped(questId, service) {
     const current = service.getRecord(questId);
-    if (!current) return;
-    for (const card of current.cards) {
-      if (card.status === "queued" || card.status === "running") {
-        await service.updateCard(questId, card.index, {
-          status: "stopped",
-          completedAt: nowIso4()
-        });
-      }
-    }
-  }
-  async runWorker(args) {
-    const { record, cardIndex, workerPrompt, roleBody, allowedTools, service, signal } = args;
-    const fresh = service.getRecord(record.id);
-    const card = fresh?.cards.find((c) => c.index === cardIndex) ?? record.cards.find((c) => c.index === cardIndex);
-    if (!card) {
-      return {
-        card: record.cards[0],
-        status: "failed",
-        finalText: "",
-        errorMessage: `card ${cardIndex} not found`
-      };
-    }
-    const startedAt = nowIso4();
-    let agent;
-    try {
-      agent = await service.agentManager.createAgent(
-        buildWorkerAgentConfig({ record, card, roleBody, allowedTools })
-      );
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      this.logger.error({ err, questId: record.id, cardIndex }, "orchestrator: spawn failed");
-      await service.updateCard(record.id, cardIndex, {
-        status: "failed",
-        completedAt: nowIso4(),
-        prompt: workerPrompt
-      });
-      return { card, status: "failed", finalText: "", errorMessage: msg };
-    }
-    await service.updateCard(record.id, cardIndex, {
-      status: "running",
-      agentId: agent.id,
-      startedAt,
-      prompt: workerPrompt
-    });
-    const onAbort = () => {
-      void service.agentManager.cancelAgentRun(agent.id).catch(() => {
-      });
-    };
-    signal.addEventListener("abort", onAbort, { once: true });
-    try {
-      const run = await service.agentManager.runAgent(agent.id, workerPrompt);
-      const finalText = resolveFinalTextFromRun2(run);
-      if (run.canceled) {
-        await service.updateCard(record.id, cardIndex, {
-          status: "stopped",
-          completedAt: nowIso4()
-        });
-        return { card, status: "stopped", finalText, errorMessage: null };
+    if (current) {
+      for (const card of current.cards) {
+        if (card.status === "queued") {
+          await service.updateCard(questId, card.index, {
+            status: "stopped",
+            completedAt: nowIso4()
+          });
+        }
       }
-      await service.updateCard(record.id, cardIndex, {
-        status: "succeeded",
-        completedAt: nowIso4()
-      });
-      return { card, status: "succeeded", finalText, errorMessage: null };
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      this.logger.error({ err, questId: record.id, cardIndex }, "orchestrator: worker failed");
-      await service.updateCard(record.id, cardIndex, {
-        status: "failed",
-        completedAt: nowIso4()
-      });
-      return { card, status: "failed", finalText: "", errorMessage: msg };
-    } finally {
-      signal.removeEventListener("abort", onAbort);
     }
+    await service.markStatus(questId, finalStatus);
   }
 };
 
 // ../server/src/server/quest/runner-ralph.ts
 import { promisify as promisify4 } from "node:util";
 import { execFile as execFile3 } from "node:child_process";
-import { appendFile as appendFile2, mkdir as mkdir9, writeFile as writeFile8 } from "node:fs/promises";
+import { appendFile, mkdir as mkdir8, writeFile as writeFile7 } from "node:fs/promises";
 import path27 from "node:path";
 var execFileAsync3 = promisify4(execFile3);
 var MAX_VERIFY_OUTPUT_BYTES2 = 64 * 1024;
@@ -56765,7 +56926,7 @@ function buildRalphIterationPrompt(args) {
     "- If not complete yet, continue making changes and do not output the token."
   ].join("\n");
 }
-function resolveFinalTextFromRun3(run) {
+function resolveFinalTextFromRun2(run) {
   if (run.finalText.trim()) {
     return run.finalText;
   }
@@ -56781,7 +56942,7 @@ function resolveFinalTextFromRun3(run) {
   return "";
 }
 function runContainsPromise(run, completionPromise) {
-  const finalText = resolveFinalTextFromRun3(run);
+  const finalText = resolveFinalTextFromRun2(run);
   return finalText.includes(completionPromise);
 }
 function resolveRalphStatePaths(cwd) {
@@ -56797,8 +56958,8 @@ async function initializeRalphState(args) {
     dir: base.dir,
     logPath: path27.join(base.dir, `ralphloop_${args.record.id}.md`)
   };
-  await mkdir9(paths.dir, { recursive: true });
-  await writeFile8(
+  await mkdir8(paths.dir, { recursive: true });
+  await writeFile7(
     paths.logPath,
     [
       `# Ralph Loop ${args.record.id}`,
@@ -56815,12 +56976,12 @@ async function initializeRalphState(args) {
     ].join("\n") + "\n",
     "utf8"
   );
-  await appendFile2(paths.logPath, `- [${nowIso5()}] started
+  await appendFile(paths.logPath, `- [${nowIso5()}] started
 `, "utf8");
   return paths;
 }
 async function appendRalphProgress(paths, message) {
-  await appendFile2(paths.logPath, `- [${nowIso5()}] ${message}
+  await appendFile(paths.logPath, `- [${nowIso5()}] ${message}
 `, "utf8");
 }
 function newCard(index) {
@@ -57977,13 +58138,13 @@ function createTerminalManager() {
 }
 
 // ../server/src/shared/connection-offer.ts
-import { z as z41 } from "zod";
-var ConnectionOfferV2Schema = z41.object({
-  v: z41.literal(2),
-  serverId: z41.string().min(1),
-  daemonPublicKeyB64: z41.string().min(1),
-  relay: z41.object({
-    endpoint: z41.string().min(1)
+import { z as z43 } from "zod";
+var ConnectionOfferV2Schema = z43.object({
+  v: z43.literal(2),
+  serverId: z43.string().min(1),
+  daemonPublicKeyB64: z43.string().min(1),
+  relay: z43.object({
+    endpoint: z43.string().min(1)
   })
 });
 
@@ -58582,7 +58743,7 @@ function createAuthServerClient(options) {
 // ../server/src/server/package-version.ts
 import { existsSync as existsSync17, readFileSync as readFileSync9 } from "node:fs";
 import path28 from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
 var PackageVersionResolutionError = class extends Error {
   constructor(params) {
     super(`Unable to resolve ${params.packageName} version from module URL ${params.moduleUrl}.`);
@@ -58591,7 +58752,7 @@ var PackageVersionResolutionError = class extends Error {
 };
 function resolvePackageVersion(params) {
   const moduleUrl = params.moduleUrl ?? import.meta.url;
-  let currentDir = path28.dirname(fileURLToPath3(moduleUrl));
+  let currentDir = path28.dirname(fileURLToPath4(moduleUrl));
   while (true) {
     const packageJsonPath = path28.join(currentDir, "package.json");
     if (existsSync17(packageJsonPath)) {
@@ -59526,21 +59687,21 @@ async function closeAllAgents(logger, agentManager) {
 
 // ../server/src/server/config.ts
 import path31 from "node:path";
-import { z as z45 } from "zod";
+import { z as z47 } from "zod";
 
 // ../server/src/server/speech/speech-config-resolver.ts
-import { z as z44 } from "zod";
+import { z as z46 } from "zod";
 
 // ../server/src/server/speech/providers/local/config.ts
 import path30 from "node:path";
-import { z as z42 } from "zod";
+import { z as z44 } from "zod";
 var DEFAULT_LOCAL_MODELS_SUBDIR = path30.join("models", "local-speech");
-var NumberLikeSchema2 = z42.union([z42.number(), z42.string().trim().min(1)]);
-var OptionalFiniteNumberSchema2 = NumberLikeSchema2.pipe(z42.coerce.number().finite()).optional();
-var OptionalIntegerSchema = NumberLikeSchema2.pipe(z42.coerce.number().int()).optional();
-var LocalSpeechResolutionSchema = z42.object({
-  includeProviderConfig: z42.boolean(),
-  modelsDir: z42.string().trim().min(1),
+var NumberLikeSchema2 = z44.union([z44.number(), z44.string().trim().min(1)]);
+var OptionalFiniteNumberSchema2 = NumberLikeSchema2.pipe(z44.coerce.number().finite()).optional();
+var OptionalIntegerSchema = NumberLikeSchema2.pipe(z44.coerce.number().int()).optional();
+var LocalSpeechResolutionSchema = z44.object({
+  includeProviderConfig: z44.boolean(),
+  modelsDir: z44.string().trim().min(1),
   dictationLocalSttModel: LocalSttModelIdSchema.default(DEFAULT_LOCAL_STT_MODEL),
   voiceLocalSttModel: LocalSttModelIdSchema.default(DEFAULT_LOCAL_STT_MODEL),
   voiceLocalTtsModel: LocalTtsModelIdSchema.default(DEFAULT_LOCAL_TTS_MODEL),
@@ -59596,17 +59757,17 @@ function resolveLocalSpeechConfig(params) {
 }
 
 // ../server/src/server/speech/speech-types.ts
-import { z as z43 } from "zod";
-var SpeechProviderIdSchema2 = z43.enum(["openai", "local"]);
-var RequestedSpeechProviderSchema = z43.object({
+import { z as z45 } from "zod";
+var SpeechProviderIdSchema2 = z45.enum(["openai", "local"]);
+var RequestedSpeechProviderSchema = z45.object({
   provider: SpeechProviderIdSchema2,
-  explicit: z43.boolean(),
-  enabled: z43.boolean().optional()
+  explicit: z45.boolean(),
+  enabled: z45.boolean().optional()
 });
 
 // ../server/src/server/speech/speech-config-resolver.ts
-var OptionalSpeechProviderSchema = z44.string().trim().toLowerCase().pipe(SpeechProviderIdSchema2).optional();
-var OptionalBooleanFlagSchema = z44.union([z44.boolean(), z44.string().trim().toLowerCase()]).optional().transform((value) => {
+var OptionalSpeechProviderSchema = z46.string().trim().toLowerCase().pipe(SpeechProviderIdSchema2).optional();
+var OptionalBooleanFlagSchema = z46.union([z46.boolean(), z46.string().trim().toLowerCase()]).optional().transform((value) => {
   if (typeof value === "boolean") {
     return value;
   }
@@ -59621,7 +59782,7 @@ var OptionalBooleanFlagSchema = z44.union([z44.boolean(), z44.string().trim().to
   }
   return void 0;
 });
-var RequestedSpeechProvidersSchema = z44.object({
+var RequestedSpeechProvidersSchema = z46.object({
   dictationStt: OptionalSpeechProviderSchema.default("local"),
   voiceTurnDetection: OptionalSpeechProviderSchema.default("local"),
   voiceStt: OptionalSpeechProviderSchema.default("local"),
@@ -59730,9 +59891,9 @@ function parseBooleanEnv(value) {
   }
   return void 0;
 }
-var OptionalVoiceLlmProviderSchema = z45.union([z45.string(), z45.null(), z45.undefined()]).transform(
+var OptionalVoiceLlmProviderSchema = z47.union([z47.string(), z47.null(), z47.undefined()]).transform(
   (value) => typeof value === "string" ? value.trim().toLowerCase() : null
-).pipe(z45.union([AgentProviderSchema, z45.null()]));
+).pipe(z47.union([AgentProviderSchema, z47.null()]));
 function parseOptionalVoiceLlmProvider(value) {
   const parsed = OptionalVoiceLlmProviderSchema.safeParse(value);
   return parsed.success ? parsed.data : null;
@@ -60007,7 +60168,7 @@ function createRootLogger(configInput, options) {
 }
 
 // ../server/src/server/pid-lock.ts
-import { open, readFile as readFile7, unlink as unlink3, mkdir as mkdir10 } from "node:fs/promises";
+import { open, readFile as readFile7, unlink as unlink3, mkdir as mkdir9 } from "node:fs/promises";
 import { existsSync as existsSync20 } from "node:fs";
 import { join as join18 } from "node:path";
 import { hostname } from "node:os";
@@ -60038,7 +60199,7 @@ function resolveOwnerPid(ownerPid) {
 async function acquirePidLock(appostleHome, listen, options) {
   const pidPath = getPidFilePath(appostleHome);
   if (!existsSync20(appostleHome)) {
-    await mkdir10(appostleHome, { recursive: true });
+    await mkdir9(appostleHome, { recursive: true });
   }
   let existingLock = null;
   try {