appostle-installer 0.0.4 → 0.0.6

package/dist/worker.js

@@ -8,7 +8,7 @@ import { createReadStream, unlinkSync, existsSync as existsSync18 } from "fs";
 import { stat as stat9 } from "fs/promises";
 import { randomUUID as randomUUID15 } from "node:crypto";
 import { hostname as getHostname2 } from "node:os";
-import path26 from "node:path";
+import path29 from "node:path";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
 
@@ -461,18 +461,18 @@ function resolveNodePtyPackageRoot() {
     return null;
   }
 }
-function ensureExecutableBit(path30) {
-  if (!existsSync2(path30)) {
+function ensureExecutableBit(path33) {
+  if (!existsSync2(path33)) {
     return;
   }
-  const stat10 = statSync(path30);
+  const stat10 = statSync(path33);
   if (!stat10.isFile()) {
     return;
   }
   if ((stat10.mode & 73) === 73) {
     return;
   }
-  chmodSync(path30, stat10.mode | 73);
+  chmodSync(path33, stat10.mode | 73);
 }
 function ensureNodePtySpawnHelperExecutableForCurrentPlatform(options = {}) {
   const platform = options.platform ?? process.platform;
@@ -1090,11 +1090,11 @@ function parseGitRevParsePath(stdout) {
   if (lines.length !== 1) {
     return null;
   }
-  const path30 = lines[0]?.trim() ?? "";
-  if (!path30 || path30.startsWith("--")) {
+  const path33 = lines[0]?.trim() ?? "";
+  if (!path33 || path33.startsWith("--")) {
     return null;
   }
-  return path30;
+  return path33;
 }
 function resolveGitRevParsePath(cwd, stdout) {
   const parsed = parseGitRevParsePath(stdout);
@@ -1867,9 +1867,9 @@ async function deleteAppostleWorktree({
     }
   }
 }
-async function pathExists(path30) {
+async function pathExists(path33) {
   try {
-    await stat(path30);
+    await stat(path33);
     return true;
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -1878,8 +1878,8 @@ async function pathExists(path30) {
     throw error;
   }
 }
-async function removeDirectoryWithRetries(path30) {
-  if (!await pathExists(path30)) {
+async function removeDirectoryWithRetries(path33) {
+  if (!await pathExists(path33)) {
     return;
   }
   const delaysMs = [0, 100, 300, 700, 1500];
@@ -1889,17 +1889,17 @@ async function removeDirectoryWithRetries(path30) {
       await new Promise((resolve14) => setTimeout(resolve14, delay));
     }
     try {
-      await rm(path30, { recursive: true, force: true });
-      if (!await pathExists(path30)) {
+      await rm(path33, { recursive: true, force: true });
+      if (!await pathExists(path33)) {
         return;
       }
-      lastError = new Error(`Directory still present after rm: ${path30}`);
+      lastError = new Error(`Directory still present after rm: ${path33}`);
     } catch (error) {
       lastError = error;
     }
   }
-  if (await pathExists(path30)) {
-    throw lastError instanceof Error ? lastError : new Error(`Failed to remove worktree directory: ${path30}`);
+  if (await pathExists(path33)) {
+    throw lastError instanceof Error ? lastError : new Error(`Failed to remove worktree directory: ${path33}`);
   }
 }
 var createWorktree = async ({
@@ -3225,14 +3225,14 @@ var LoopStopResponseSchema = z7.object({
   })
 });
 
-// ../server/src/server/workflow/rpc-schemas.ts
+// ../server/src/server/quest/rpc-schemas.ts
 import { z as z9 } from "zod";
 
-// ../server/src/server/workflow/types.ts
+// ../server/src/server/quest/types.ts
 import { z as z8 } from "zod";
-var WorkflowKindSchema = z8.enum(["loop", "ralph"]);
+var QuestKindSchema = z8.enum(["loop", "ralph", "run", "orchestrate"]);
 var FieldModeSchema = z8.enum(["locked", "inherit", "free"]);
-var WorkflowRulesSchema = z8.object({
+var QuestRulesSchema = z8.object({
   perCardRole: FieldModeSchema,
   perCardModel: FieldModeSchema,
   perCardPrompt: FieldModeSchema,
@@ -3256,79 +3256,101 @@ var CardWiringSchema = z8.object({
   inputs: CardWiringInputsSchema,
   outputs: CardWiringOutputsSchema
 });
-var WorkflowCardStatusSchema = z8.enum([
+var QuestCardStatusSchema = z8.enum([
   "queued",
   "running",
   "succeeded",
   "failed",
   "stopped"
 ]);
-var WorkflowCardVerifySchema = z8.object({
+var QuestCardVerifySchema = z8.object({
   verifierAgentId: z8.string().nullable(),
   passed: z8.boolean().nullable(),
   reason: z8.string().nullable(),
   startedAt: z8.string().nullable(),
   completedAt: z8.string().nullable()
 });
-var WorkflowCardSchema = z8.object({
+var QuestCardSchema = z8.object({
   /**
    * 1..N for iteration cards. The summarizer card uses 0 as a sentinel —
-   * it lives on `WorkflowRecord.summarizerCard`, not in the cards array,
+   * it lives on `QuestRecord.summarizerCard`, not in the cards array,
    * and the UI renders it as "Summary" when it sees index === 0.
    */
   index: z8.number().int().nonnegative(),
-  /** Role name resolved against the agents/.scanner. Null = use workflow default. */
+  /** Role name resolved against the agents/.scanner. Null = use quest default. */
   role: z8.string().nullable(),
-  /** Model override. Null = use workflow.defaultModel. */
+  /** Model override. Null = use quest.defaultModel. */
   model: z8.string().nullable(),
-  /** Prompt override. Null = use workflow.prompt. */
+  /** Prompt override. Null = use quest.prompt. */
   prompt: z8.string().nullable(),
   wiring: CardWiringSchema,
-  status: WorkflowCardStatusSchema,
+  status: QuestCardStatusSchema,
   /** Populated when the card runs. Null until the runner spawns the agent. */
   agentId: z8.string().nullable(),
   startedAt: z8.string().nullable(),
   completedAt: z8.string().nullable(),
   /** Ralph-only — null for loop cards. */
-  verify: WorkflowCardVerifySchema.nullable()
+  verify: QuestCardVerifySchema.nullable()
 });
-var WorkflowTerminationCountSchema = z8.object({
+var QuestTerminationCountSchema = z8.object({
   type: z8.literal("count"),
   /** 1..10 in v1. */
   n: z8.number().int().min(1).max(10)
 });
-var WorkflowTerminationVerifySchema = z8.object({
+var QuestTerminationVerifySchema = z8.object({
   type: z8.literal("verify"),
   /** Verifier agent system prompt. Null means rely on shell checks alone. */
   verifyPrompt: z8.string().nullable(),
   /** Shell commands that must exit 0 for the iteration to pass. */
   verifyChecks: z8.array(z8.string()),
+  /**
+   * Exact completion token that MUST appear in worker output before the quest
+   * may succeed. Mirrors Ralph's completion-promise guardrail.
+   */
+  completionPromise: z8.string().trim().min(1).optional().default("<promise>COMPLETE</promise>"),
   /** Hard cap on iterations regardless of verifier outcome. */
   maxIterations: z8.number().int().min(1)
 });
-var WorkflowTerminationSchema = z8.discriminatedUnion("type", [
-  WorkflowTerminationCountSchema,
-  WorkflowTerminationVerifySchema
+var QuestTerminationOrchestrateSchema = z8.object({
+  type: z8.literal("orchestrate")
+});
+var QuestTerminationSchema = z8.discriminatedUnion("type", [
+  QuestTerminationCountSchema,
+  QuestTerminationVerifySchema,
+  QuestTerminationOrchestrateSchema
 ]);
-var WorkflowStatusSchema = z8.enum(["running", "succeeded", "failed", "stopped"]);
-var WorkflowRecordSchema = z8.object({
+var QuestStatusSchema = z8.enum(["running", "succeeded", "failed", "stopped"]);
+var QuestRecordSchema = z8.object({
   id: z8.string(),
-  kind: WorkflowKindSchema,
-  rules: WorkflowRulesSchema,
+  kind: QuestKindSchema,
+  rules: QuestRulesSchema,
   cwd: z8.string(),
   /** User's task prompt — fed to every card unless overridden per-card. */
   prompt: z8.string(),
   defaultProvider: AgentProviderSchema,
   defaultModel: z8.string().nullable(),
-  termination: WorkflowTerminationSchema,
+  termination: QuestTerminationSchema,
   /**
    * For "loop" kind: pre-rendered N cards from the start.
    * For "ralph" kind: appended as iterations execute.
    */
-  cards: z8.array(WorkflowCardSchema),
+  cards: z8.array(QuestCardSchema),
   /** Populated when summarizer is enabled. Runs after all cards complete. */
-  summarizerCard: WorkflowCardSchema.nullable(),
-  status: WorkflowStatusSchema,
+  summarizerCard: QuestCardSchema.nullable(),
+  /**
+   * Queen-bee coordinator card for "orchestrate" kind. The queen reads the
+   * hivemind doc, decides dispatch waves, and writes JSON decisions back. It
+   * is promotable (same affordance as regular cards). Null for non-orchestrate
+   * kinds. Optional + default so old persisted records remain valid.
+   */
+  queenCard: QuestCardSchema.nullable().optional().default(null),
+  /**
+   * Path to the orchestration's hivemind markdown doc. Null for non-
+   * orchestrate kinds. Optional + default so old persisted records remain
+   * valid.
+   */
+  hivemindPath: z8.string().nullable().optional().default(null),
+  status: QuestStatusSchema,
   createdAt: z8.string(),
   updatedAt: z8.string(),
   startedAt: z8.string().nullable(),
@@ -3336,107 +3358,293 @@ var WorkflowRecordSchema = z8.object({
   stopRequestedAt: z8.string().nullable()
 });
 
-// ../server/src/server/workflow/rpc-schemas.ts
-var WorkflowCardConfigInputSchema = z9.object({
+// ../server/src/server/quest/rpc-schemas.ts
+var QuestCardConfigInputSchema = z9.object({
   role: z9.string().nullable().optional(),
   model: z9.string().nullable().optional(),
   prompt: z9.string().nullable().optional()
 });
-var WorkflowRunRequestSchema = z9.object({
-  type: z9.literal("workflow/run"),
+var QuestRunRequestSchema = z9.object({
+  type: z9.literal("quest/run"),
   requestId: z9.string(),
-  kind: WorkflowKindSchema,
+  kind: QuestKindSchema,
   cwd: z9.string(),
   prompt: z9.string().trim().min(1),
   defaultProvider: AgentProviderSchema.optional(),
   defaultModel: z9.string().trim().min(1).optional(),
-  termination: WorkflowTerminationSchema,
+  termination: QuestTerminationSchema,
   /** Per-card overrides (length must match termination.n for "count"). Optional. */
-  cards: z9.array(WorkflowCardConfigInputSchema).optional(),
+  cards: z9.array(QuestCardConfigInputSchema).optional(),
   summarizerEnabled: z9.boolean().optional()
 });
-var WorkflowListRequestSchema = z9.object({
-  type: z9.literal("workflow/list"),
+var QuestListRequestSchema = z9.object({
+  type: z9.literal("quest/list"),
   requestId: z9.string()
 });
-var WorkflowInspectRequestSchema = z9.object({
-  type: z9.literal("workflow/inspect"),
+var QuestInspectRequestSchema = z9.object({
+  type: z9.literal("quest/inspect"),
   requestId: z9.string(),
   id: z9.string().trim().min(1)
 });
-var WorkflowStopRequestSchema = z9.object({
-  type: z9.literal("workflow/stop"),
+var QuestStopRequestSchema = z9.object({
+  type: z9.literal("quest/stop"),
   requestId: z9.string(),
   id: z9.string().trim().min(1)
 });
-var WorkflowListItemSchema = z9.object({
+var QuestListItemSchema = z9.object({
   id: z9.string(),
-  kind: WorkflowKindSchema,
-  status: WorkflowStatusSchema,
+  kind: QuestKindSchema,
+  status: QuestStatusSchema,
   cwd: z9.string(),
   prompt: z9.string(),
   createdAt: z9.string(),
   updatedAt: z9.string()
 });
-var WorkflowRunResponseSchema = z9.object({
-  type: z9.literal("workflow/run/response"),
+var QuestRunResponseSchema = z9.object({
+  type: z9.literal("quest/run/response"),
+  payload: z9.object({
+    requestId: z9.string(),
+    quest: QuestRecordSchema.nullable(),
+    error: z9.string().nullable()
+  })
+});
+var QuestListResponseSchema = z9.object({
+  type: z9.literal("quest/list/response"),
+  payload: z9.object({
+    requestId: z9.string(),
+    quests: z9.array(QuestListItemSchema),
+    error: z9.string().nullable()
+  })
+});
+var QuestInspectResponseSchema = z9.object({
+  type: z9.literal("quest/inspect/response"),
+  payload: z9.object({
+    requestId: z9.string(),
+    quest: QuestRecordSchema.nullable(),
+    error: z9.string().nullable()
+  })
+});
+var QuestStopResponseSchema = z9.object({
+  type: z9.literal("quest/stop/response"),
+  payload: z9.object({
+    requestId: z9.string(),
+    quest: QuestRecordSchema.nullable(),
+    error: z9.string().nullable()
+  })
+});
+var QuestStreamMessageSchema = z9.object({
+  type: z9.literal("quest/stream"),
+  questId: z9.string(),
+  quest: QuestRecordSchema
+});
+var RoleScopeSchema = z9.enum(["global", "project"]);
+var RoleEntrySchema = z9.object({
+  id: z9.string(),
+  scope: RoleScopeSchema,
+  /** Category subfolder inside .roles/, or null for flat files. */
+  category: z9.string().nullable().optional(),
+  name: z9.string(),
+  description: z9.string(),
+  /** Trigger words from the `trigger-words` frontmatter key. */
+  triggerWords: z9.array(z9.string()).optional().default([]),
+  provider: z9.string(),
+  model: z9.string(),
+  mode: z9.string(),
+  path: z9.string(),
+  modifiedAt: z9.string(),
+  size: z9.number()
+});
+var RoleFrontmatterSchema = z9.object({
+  description: z9.string().optional(),
+  triggerWords: z9.array(z9.string()).optional(),
+  allowedTools: z9.array(z9.string()).optional(),
+  provider: z9.string().optional(),
+  model: z9.string().optional(),
+  mode: z9.string().optional()
+});
+var RolesListRequestSchema = z9.object({
+  type: z9.literal("roles/list"),
+  requestId: z9.string(),
+  workspaceRoot: z9.string().optional()
+});
+var RolesListResponseSchema = z9.object({
+  type: z9.literal("roles/list/response"),
   payload: z9.object({
     requestId: z9.string(),
-    workflow: WorkflowRecordSchema.nullable(),
+    roles: z9.array(RoleEntrySchema),
     error: z9.string().nullable()
   })
 });
-var WorkflowListResponseSchema = z9.object({
-  type: z9.literal("workflow/list/response"),
+var RolesListScopeRequestSchema = z9.object({
+  type: z9.literal("roles/list-scope"),
+  requestId: z9.string(),
+  scope: RoleScopeSchema,
+  workspaceRoot: z9.string().optional()
+});
+var RolesListScopeResponseSchema = z9.object({
+  type: z9.literal("roles/list-scope/response"),
   payload: z9.object({
     requestId: z9.string(),
-    workflows: z9.array(WorkflowListItemSchema),
+    roles: z9.array(RoleEntrySchema),
     error: z9.string().nullable()
   })
 });
-var WorkflowInspectResponseSchema = z9.object({
-  type: z9.literal("workflow/inspect/response"),
+var RoleCreateRequestSchema = z9.object({
+  type: z9.literal("roles/create"),
+  requestId: z9.string(),
+  scope: RoleScopeSchema,
+  name: z9.string(),
+  category: z9.string().optional(),
+  workspaceRoot: z9.string().optional()
+});
+var RoleCreateResponseSchema = z9.object({
+  type: z9.literal("roles/create/response"),
   payload: z9.object({
     requestId: z9.string(),
-    workflow: WorkflowRecordSchema.nullable(),
+    /** Absolute path of the created .md file. Empty string when error is set. */
+    path: z9.string(),
     error: z9.string().nullable()
   })
 });
-var WorkflowStopResponseSchema = z9.object({
-  type: z9.literal("workflow/stop/response"),
+var RoleWriteFrontmatterRequestSchema = z9.object({
+  type: z9.literal("roles/write-frontmatter"),
+  requestId: z9.string(),
+  /** Absolute path inside an allowlisted role root. */
+  path: z9.string(),
+  workspaceRoot: z9.string().optional(),
+  frontmatter: RoleFrontmatterSchema
+});
+var RoleWriteFrontmatterResponseSchema = z9.object({
+  type: z9.literal("roles/write-frontmatter/response"),
   payload: z9.object({
     requestId: z9.string(),
-    workflow: WorkflowRecordSchema.nullable(),
+    path: z9.string(),
     error: z9.string().nullable()
   })
 });
-var WorkflowStreamMessageSchema = z9.object({
-  type: z9.literal("workflow/stream"),
-  workflowId: z9.string(),
-  workflow: WorkflowRecordSchema
+var RoleMoveRequestSchema = z9.object({
+  type: z9.literal("roles/move"),
+  requestId: z9.string(),
+  path: z9.string(),
+  newName: z9.string().optional(),
+  newCategory: z9.string().optional(),
+  workspaceRoot: z9.string().optional()
 });
-var AgentRoleEntrySchema = z9.object({
+var RoleMoveResponseSchema = z9.object({
+  type: z9.literal("roles/move/response"),
+  payload: z9.object({
+    requestId: z9.string(),
+    path: z9.string(),
+    error: z9.string().nullable()
+  })
+});
+var BrandScopeSchema = z9.literal("project");
+var BrandVariableTypeSchema = z9.enum([
+  "color",
+  "font",
+  "asset",
+  "text",
+  "number",
+  "select"
+]);
+var BrandSectionSchema = z9.enum(["visual", "voice"]);
+var BrandVariableSchema = z9.object({
+  key: z9.string(),
+  type: BrandVariableTypeSchema,
+  label: z9.string(),
+  value: z9.string(),
+  section: BrandSectionSchema.optional(),
+  options: z9.array(z9.string()).optional(),
+  fileRef: z9.string().optional()
+});
+var BrandEntrySchema = z9.object({
   id: z9.string(),
-  scope: z9.enum(["global", "project"]),
+  scope: BrandScopeSchema,
   name: z9.string(),
   description: z9.string(),
-  provider: z9.string().nullable(),
-  model: z9.string().nullable(),
-  mode: z9.string().nullable(),
+  tags: z9.array(z9.string()).optional().default([]),
+  variables: z9.array(BrandVariableSchema).optional().default([]),
   path: z9.string(),
   modifiedAt: z9.string(),
   size: z9.number()
 });
-var AgentRolesListRequestSchema = z9.object({
-  type: z9.literal("agents/list"),
+var BrandFrontmatterSchema = z9.object({
+  description: z9.string().optional(),
+  tags: z9.array(z9.string()).optional(),
+  variables: z9.array(BrandVariableSchema).optional()
+});
+var BrandsListScopeRequestSchema = z9.object({
+  type: z9.literal("brands/list-scope"),
+  requestId: z9.string(),
+  workspaceRoot: z9.string().optional()
+});
+var BrandsListScopeResponseSchema = z9.object({
+  type: z9.literal("brands/list-scope/response"),
+  payload: z9.object({
+    requestId: z9.string(),
+    brands: z9.array(BrandEntrySchema),
+    error: z9.string().nullable()
+  })
+});
+var BrandCreateRequestSchema = z9.object({
+  type: z9.literal("brands/create"),
   requestId: z9.string(),
+  name: z9.string(),
   workspaceRoot: z9.string().optional()
 });
-var AgentRolesListResponseSchema = z9.object({
-  type: z9.literal("agents/list/response"),
+var BrandCreateResponseSchema = z9.object({
+  type: z9.literal("brands/create/response"),
+  payload: z9.object({
+    requestId: z9.string(),
+    path: z9.string(),
+    error: z9.string().nullable()
+  })
+});
+var BrandAssetCopyRequestSchema = z9.object({
+  type: z9.literal("brands/asset-copy"),
+  requestId: z9.string(),
+  workspaceRoot: z9.string(),
+  sourcePath: z9.string(),
+  targetName: z9.string()
+});
+var BrandAssetUploadRequestSchema = z9.object({
+  type: z9.literal("brands/asset-upload"),
+  requestId: z9.string(),
+  workspaceRoot: z9.string(),
+  targetName: z9.string(),
+  sourceName: z9.string().optional(),
+  dataBase64: z9.string()
+});
+var BrandAssetUploadResponseSchema = z9.object({
+  type: z9.literal("brands/asset-upload/response"),
+  payload: z9.object({
+    requestId: z9.string(),
+    relativePath: z9.string(),
+    absolutePath: z9.string(),
+    error: z9.string().nullable()
+  })
+});
+var BrandAssetCopyResponseSchema = z9.object({
+  type: z9.literal("brands/asset-copy/response"),
+  payload: z9.object({
+    requestId: z9.string(),
+    relativePath: z9.string(),
+    absolutePath: z9.string(),
+    error: z9.string().nullable()
+  })
+});
+var BrandWriteFrontmatterRequestSchema = z9.object({
+  type: z9.literal("brands/write-frontmatter"),
+  requestId: z9.string(),
+  path: z9.string(),
+  workspaceRoot: z9.string().optional(),
+  frontmatter: BrandFrontmatterSchema
+});
+var BrandWriteFrontmatterResponseSchema = z9.object({
+  type: z9.literal("brands/write-frontmatter/response"),
   payload: z9.object({
     requestId: z9.string(),
-    roles: z9.array(AgentRoleEntrySchema),
+    path: z9.string(),
     error: z9.string().nullable()
   })
 });
@@ -3990,6 +4198,7 @@ var UpdateAgentRequestMessageSchema = z10.object({
   agentId: z10.string(),
   name: z10.string().optional(),
   labels: z10.record(z10.string()).optional(),
+  internal: z10.boolean().optional(),
   requestId: z10.string()
 });
 var SetVoiceModeMessageSchema = z10.object({
@@ -4779,6 +4988,25 @@ var FileDeleteRequestSchema = z10.object({
   path: z10.string(),
   requestId: z10.string()
 });
+var FileExplorerDeleteRequestSchema = z10.object({
+  type: z10.literal("file_explorer_delete_request"),
+  cwd: z10.string(),
+  path: z10.string(),
+  requestId: z10.string()
+});
+var FileMkdirRequestSchema = z10.object({
+  type: z10.literal("file_mkdir_request"),
+  cwd: z10.string(),
+  path: z10.string(),
+  requestId: z10.string()
+});
+var FileMoveRequestSchema = z10.object({
+  type: z10.literal("file_move_request"),
+  cwd: z10.string(),
+  sourcePath: z10.string(),
+  destinationPath: z10.string(),
+  requestId: z10.string()
+});
 var ClearAgentAttentionMessageSchema = z10.object({
   type: z10.literal("clear_agent_attention"),
   agentId: z10.union([z10.string(), z10.array(z10.string())]),
@@ -5051,6 +5279,9 @@ var SessionInboundMessageSchema = z10.discriminatedUnion("type", [
   FileExplorerRequestSchema,
   FileWriteRequestSchema,
   FileDeleteRequestSchema,
+  FileExplorerDeleteRequestSchema,
+  FileMkdirRequestSchema,
+  FileMoveRequestSchema,
   ProjectIconRequestSchema,
   FileDownloadTokenRequestSchema,
   ClearAgentAttentionMessageSchema,
@@ -5060,6 +5291,15 @@ var SessionInboundMessageSchema = z10.discriminatedUnion("type", [
   ListSkillsRequestSchema,
   CreateSkillRequestSchema,
   WriteSkillFrontmatterRequestSchema,
+  RolesListScopeRequestSchema,
+  RoleCreateRequestSchema,
+  RoleWriteFrontmatterRequestSchema,
+  RoleMoveRequestSchema,
+  BrandsListScopeRequestSchema,
+  BrandCreateRequestSchema,
+  BrandWriteFrontmatterRequestSchema,
+  BrandAssetCopyRequestSchema,
+  BrandAssetUploadRequestSchema,
   RegisterPushTokenMessageSchema,
   RegisterWebPushSubscriptionMessageSchema,
   UnregisterWebPushSubscriptionMessageSchema,
@@ -5094,11 +5334,11 @@ var SessionInboundMessageSchema = z10.discriminatedUnion("type", [
   LoopInspectRequestSchema,
   LoopLogsRequestSchema,
   LoopStopRequestSchema,
-  WorkflowRunRequestSchema,
-  WorkflowListRequestSchema,
-  WorkflowInspectRequestSchema,
-  WorkflowStopRequestSchema,
-  AgentRolesListRequestSchema
+  QuestRunRequestSchema,
+  QuestListRequestSchema,
+  QuestInspectRequestSchema,
+  QuestStopRequestSchema,
+  RolesListRequestSchema
 ]);
 var ActivityLogPayloadSchema = z10.object({
   id: z10.string(),
@@ -6224,6 +6464,34 @@ var FileDeleteResponseSchema = z10.object({
     requestId: z10.string()
   })
 });
+var FileExplorerDeleteResponseSchema = z10.object({
+  type: z10.literal("file_explorer_delete_response"),
+  payload: z10.object({
+    cwd: z10.string(),
+    path: z10.string(),
+    error: z10.string().nullable(),
+    requestId: z10.string()
+  })
+});
+var FileMkdirResponseSchema = z10.object({
+  type: z10.literal("file_mkdir_response"),
+  payload: z10.object({
+    cwd: z10.string(),
+    path: z10.string(),
+    error: z10.string().nullable(),
+    requestId: z10.string()
+  })
+});
+var FileMoveResponseSchema = z10.object({
+  type: z10.literal("file_move_response"),
+  payload: z10.object({
+    cwd: z10.string(),
+    sourcePath: z10.string(),
+    destinationPath: z10.string(),
+    error: z10.string().nullable(),
+    requestId: z10.string()
+  })
+});
 var ProjectIconSchema = z10.object({
   data: z10.string(),
   mimeType: z10.string()
@@ -6556,6 +6824,9 @@ var SessionOutboundMessageSchema = z10.discriminatedUnion("type", [
   FileExplorerResponseSchema,
   FileWriteResponseSchema,
   FileDeleteResponseSchema,
+  FileExplorerDeleteResponseSchema,
+  FileMkdirResponseSchema,
+  FileMoveResponseSchema,
   ProjectIconResponseSchema,
   FileDownloadTokenResponseSchema,
   ListProviderModelsResponseMessageSchema,
@@ -6570,6 +6841,10 @@ var SessionOutboundMessageSchema = z10.discriminatedUnion("type", [
   ListSkillsResponseSchema,
   CreateSkillResponseSchema,
   WriteSkillFrontmatterResponseSchema,
+  RolesListScopeResponseSchema,
+  RoleCreateResponseSchema,
+  RoleWriteFrontmatterResponseSchema,
+  RoleMoveResponseSchema,
   ListTerminalsResponseSchema,
   TerminalsChangedSchema,
   CreateTerminalResponseSchema,
@@ -6596,11 +6871,16 @@ var SessionOutboundMessageSchema = z10.discriminatedUnion("type", [
   LoopInspectResponseSchema,
   LoopLogsResponseSchema,
   LoopStopResponseSchema,
-  WorkflowRunResponseSchema,
-  WorkflowListResponseSchema,
-  WorkflowInspectResponseSchema,
-  WorkflowStopResponseSchema,
-  AgentRolesListResponseSchema,
+  QuestRunResponseSchema,
+  QuestListResponseSchema,
+  QuestInspectResponseSchema,
+  QuestStopResponseSchema,
+  RolesListResponseSchema,
+  BrandsListScopeResponseSchema,
+  BrandCreateResponseSchema,
+  BrandWriteFrontmatterResponseSchema,
+  BrandAssetCopyResponseSchema,
+  BrandAssetUploadResponseSchema,
   GetVapidPublicKeyResponseSchema,
   LinkAccountResponseMessageSchema
 ]);
@@ -8655,6 +8935,12 @@ async function resolveEditorLaunch(input) {
   if (!executable) {
     throw new Error(`Editor target unavailable: ${target.label}`);
   }
+  if (input.editorId === "finder") {
+    return {
+      command: executable,
+      args: ["-R", input.path]
+    };
+  }
   return {
     command: executable,
     args: [input.path]
@@ -9086,14 +9372,14 @@ var DictationStreamManager = class {
       PCM_CHANNELS,
       PCM_BITS_PER_SAMPLE
     );
-    const path30 = await maybePersistDictationDebugAudio(
+    const path33 = await maybePersistDictationDebugAudio(
       wavBuffer,
       { sessionId: state.sessionId, dictationId: state.dictationId, format: "audio/wav" },
       this.logger,
       state.debugChunkWriter?.folder
     );
-    state.debugRecordingPath = path30;
-    return path30;
+    state.debugRecordingPath = path33;
+    return path33;
   }
   failDictationStream(dictationId, error, retryable) {
     this.emit({
@@ -10559,14 +10845,14 @@ function parseDiff(diffText) {
     const firstLine = lines[0];
     const isNew = section.includes("new file mode") || section.includes("--- /dev/null");
     const isDeleted = section.includes("deleted file mode") || section.includes("+++ /dev/null");
-    let path30 = "unknown";
+    let path33 = "unknown";
     const pathMatch = firstLine.match(/a\/(.*?) b\//);
     if (pathMatch) {
-      path30 = pathMatch[1];
+      path33 = pathMatch[1];
     } else {
       const newFileMatch = firstLine.match(/b\/(.+)$/);
       if (newFileMatch) {
-        path30 = newFileMatch[1];
+        path33 = newFileMatch[1];
       }
     }
     const hunks = [];
@@ -10610,7 +10896,7 @@ function parseDiff(diffText) {
     if (currentHunk) {
       hunks.push(currentHunk);
     }
-    files.push({ path: path30, isNew, isDeleted, additions, deletions, hunks });
+    files.push({ path: path33, isNew, isDeleted, additions, deletions, hunks });
   }
   return files;
 }
@@ -10666,9 +10952,9 @@ function buildTokenLookup(lineMap, highlighted) {
   }
   return lookup;
 }
-function buildFullFileTokenLookup(fileContent, path30) {
+function buildFullFileTokenLookup(fileContent, path33) {
   const lookup = /* @__PURE__ */ new Map();
-  const highlighted = highlightCode(fileContent, path30);
+  const highlighted = highlightCode(fileContent, path33);
   for (let i = 0; i < highlighted.length; i++) {
     lookup.set(i + 1, highlighted[i]);
   }
@@ -12373,11 +12659,11 @@ async function listCheckoutFileChanges(cwd, ref, ignoreWhitespace = false) {
       }
       continue;
     }
-    const path30 = tabParts[1];
-    if (!path30) continue;
+    const path33 = tabParts[1];
+    if (!path33) continue;
     const code = rawStatus[0];
     changes.push({
-      path: path30,
+      path: path33,
       status: rawStatus,
       isNew: code === "A",
       isDeleted: code === "D"
@@ -12412,9 +12698,9 @@ async function listCheckoutFileChanges(cwd, ref, ignoreWhitespace = false) {
   }
   return Array.from(byPath.values());
 }
-async function readGitFileContentAtRef(cwd, ref, path30) {
+async function readGitFileContentAtRef(cwd, ref, path33) {
   try {
-    const { stdout } = await runGitCommand(["show", `${ref}:${path30}`], {
+    const { stdout } = await runGitCommand(["show", `${ref}:${path33}`], {
       cwd,
       env: READ_ONLY_GIT_ENV2
     });
@@ -12475,21 +12761,21 @@ async function getTrackedNumstatByPath(cwd, ref, ignoreWhitespace = false) {
     const additionsField = parts[0] ?? "";
     const deletionsField = parts[1] ?? "";
     const rawPath = parts.slice(2).join("	");
-    const path30 = normalizeNumstatPath(rawPath);
-    if (!path30) {
+    const path33 = normalizeNumstatPath(rawPath);
+    if (!path33) {
       continue;
     }
     if (additionsField === "-" || deletionsField === "-") {
-      stats.set(path30, { additions: 0, deletions: 0, isBinary: true });
+      stats.set(path33, { additions: 0, deletions: 0, isBinary: true });
       continue;
     }
     const additions = Number.parseInt(additionsField, 10);
     const deletions = Number.parseInt(deletionsField, 10);
     if (Number.isNaN(additions) || Number.isNaN(deletions)) {
-      stats.set(path30, null);
+      stats.set(path33, null);
       continue;
     }
-    stats.set(path30, { additions, deletions, isBinary: false });
+    stats.set(path33, { additions, deletions, isBinary: false });
   }
   return stats;
 }
@@ -13181,10 +13467,10 @@ async function listUncommittedFiles(cwd) {
         if (dest) results.push({ path: dest, changeType: code });
         continue;
       }
-      const path30 = parts[1];
-      if (!path30) continue;
+      const path33 = parts[1];
+      if (!path33) continue;
       if (code === "A" || code === "M" || code === "D") {
-        results.push({ path: path30, changeType: code });
+        results.push({ path: path33, changeType: code });
       }
     }
   } catch {
@@ -16528,6 +16814,14 @@ var CLAUDE_MODELS = [
     isDefault: true,
     thinkingOptions: [...CLAUDE_THINKING_OPTIONS]
   },
+  {
+    provider: "claude",
+    id: "claude-sonnet-4-6[1m]",
+    label: "Sonnet 4.6 1M",
+    description: "Sonnet 4.6 with 1M context window",
+    thinkingOptions: [...CLAUDE_THINKING_OPTIONS],
+    betas: ["context-1m-2025-08-07"]
+  },
   {
     provider: "claude",
     id: "claude-sonnet-4-6",
@@ -16545,6 +16839,9 @@ var CLAUDE_MODELS = [
 function getClaudeModels() {
   return CLAUDE_MODELS.map((model) => ({ ...model }));
 }
+function getClaudeModelBetas(modelId) {
+  return CLAUDE_MODELS.find((m) => m.id === modelId)?.betas;
+}
 function normalizeClaudeRuntimeModelId(value) {
   const trimmed = typeof value === "string" ? value.trim() : "";
   if (!trimmed) {
@@ -19127,11 +19424,18 @@ var ClaudeAgentSession = class {
     }
     if (this.config.model) {
       base.model = this.config.model;
+      const modelBetas = getClaudeModelBetas(this.config.model);
+      if (modelBetas?.length) {
+        base.betas = [...base.betas ?? [], ...modelBetas];
+      }
     }
     this.lastOptionsModel = base.model ?? null;
     if (this.claudeSessionId) {
       base.resume = this.claudeSessionId;
     }
+    if (this.config.allowedTools?.length) {
+      base.allowedTools = [...base.allowedTools ?? [], ...this.config.allowedTools];
+    }
     if (this.runtimeSettings?.disallowedTools?.length) {
       base.disallowedTools = [
         ...base.disallowedTools ?? [],
@@ -21362,14 +21666,14 @@ function codexApplyPatchToUnifiedDiff(text) {
   for (const line of lines) {
     const directive = parseCodexApplyPatchDirective(line);
     if (directive) {
-      const path30 = normalizeDiffHeaderPath(directive.path);
-      if (path30.length > 0) {
+      const path33 = normalizeDiffHeaderPath(directive.path);
+      if (path33.length > 0) {
         if (output.length > 0 && output[output.length - 1] !== "") {
           output.push("");
         }
-        const left = directive.kind === "add" ? "/dev/null" : `a/${path30}`;
-        const right = directive.kind === "delete" ? "/dev/null" : `b/${path30}`;
-        output.push(`diff --git a/${path30} b/${path30}`);
+        const left = directive.kind === "add" ? "/dev/null" : `a/${path33}`;
+        const right = directive.kind === "delete" ? "/dev/null" : `b/${path33}`;
+        output.push(`diff --git a/${path33} b/${path33}`);
         output.push(`--- ${left}`);
         output.push(`+++ ${right}`);
         sawDiffContent = true;
@@ -21439,9 +21743,9 @@ function asEditTextFields(text) {
 function normalizeRolloutEditInput(input) {
   if (typeof input === "string") {
     const textFields2 = asEditTextFields(input);
-    const path30 = extractPatchPrimaryFilePath(input);
+    const path33 = extractPatchPrimaryFilePath(input);
     return {
-      ...path30 ? { path: path30 } : {},
+      ...path33 ? { path: path33 } : {},
       ...textFields2.unifiedDiff ? { patch: textFields2.unifiedDiff } : {},
       ...textFields2.newString ? { content: textFields2.newString } : {}
     };
@@ -21589,12 +21893,12 @@ function parseFileChangeDiff(entry) {
   ]);
 }
 function toFileChangeEntry(entry, options, fallbackPath) {
-  const path30 = parseFileChangePath(entry, options, fallbackPath);
-  if (!path30) {
+  const path33 = parseFileChangePath(entry, options, fallbackPath);
+  if (!path33) {
     return null;
   }
   return {
-    path: path30,
+    path: path33,
     kind: parseFileChangeKind(entry),
     diff: parseFileChangeDiff(entry)
   };
@@ -21616,12 +21920,12 @@ function parseFileChangeEntries(changes, options) {
   if (singleEntry) {
     return [singleEntry];
   }
-  return Object.entries(changes).map(([path30, value]) => {
+  return Object.entries(changes).map(([path33, value]) => {
     if (isRecord2(value)) {
-      return toFileChangeEntry(value, options, path30);
+      return toFileChangeEntry(value, options, path33);
     }
     if (typeof value === "string") {
-      const normalizedPath = normalizeCodexFilePath(path30.trim(), options?.cwd);
+      const normalizedPath = normalizeCodexFilePath(path33.trim(), options?.cwd);
       if (!normalizedPath) {
         return null;
       }
@@ -22366,16 +22670,16 @@ function isObjectSchemaNode(schema) {
   const type = schema.type;
   return isSchemaRecord(schema.properties) || type === "object" || Array.isArray(type) && type.includes("object");
 }
-function normalizeCodexOutputSchemaNode(schema, path30) {
+function normalizeCodexOutputSchemaNode(schema, path33) {
   if (Array.isArray(schema)) {
-    return schema.map((entry, index) => normalizeCodexOutputSchemaNode(entry, `${path30}[${index}]`));
+    return schema.map((entry, index) => normalizeCodexOutputSchemaNode(entry, `${path33}[${index}]`));
   }
   if (!isSchemaRecord(schema)) {
     return schema;
   }
   const normalized = {};
   for (const [key, value] of Object.entries(schema)) {
-    normalized[key] = normalizeCodexOutputSchemaNode(value, `${path30}.${key}`);
+    normalized[key] = normalizeCodexOutputSchemaNode(value, `${path33}.${key}`);
   }
   if (!isObjectSchemaNode(normalized)) {
     return normalized;
@@ -22384,7 +22688,7 @@ function normalizeCodexOutputSchemaNode(schema, path30) {
     normalized.additionalProperties = false;
   } else if (normalized.additionalProperties !== false) {
     throw new Error(
-      `Codex structured outputs require ${path30} to set additionalProperties to false for object schemas.`
+      `Codex structured outputs require ${path33} to set additionalProperties to false for object schemas.`
     );
   }
   const properties = isSchemaRecord(normalized.properties) ? normalized.properties : null;
@@ -23146,8 +23450,8 @@ function parseCodexPatchChanges(changes) {
       }
     ];
   }
-  return Object.entries(recordChanges).map(([path30, value]) => {
-    const normalizedPath = path30.trim();
+  return Object.entries(recordChanges).map(([path33, value]) => {
+    const normalizedPath = path33.trim();
     if (!normalizedPath) {
       return null;
     }
@@ -30908,8 +31212,8 @@ function buildZodValidator(schema, schemaName) {
         return { ok: true, value: result.data };
       }
       const errors = result.error.issues.map((issue) => {
-        const path30 = issue.path.length > 0 ? issue.path.join(".") : "(root)";
-        return `${path30}: ${issue.message}`;
+        const path33 = issue.path.length > 0 ? issue.path.join(".") : "(root)";
+        return `${path33}: ${issue.message}`;
       });
       return { ok: false, errors };
     }
@@ -30927,9 +31231,9 @@ function buildJsonSchemaValidator(schema) {
         return { ok: true, value };
       }
       const errors = (validate.errors ?? []).map((error) => {
-        const path30 = error.instancePath && error.instancePath.length > 0 ? error.instancePath : "(root)";
+        const path33 = error.instancePath && error.instancePath.length > 0 ? error.instancePath : "(root)";
         const message = error.message ?? "is invalid";
-        return `${path30}: ${message}`;
+        return `${path33}: ${message}`;
       });
       return { ok: false, errors };
     }
@@ -31968,6 +32272,12 @@ var IMAGE_MIME_TYPES = {
   ".webp": "image/webp",
   ".svg": "image/svg+xml"
 };
+var FONT_MIME_TYPES = {
+  ".ttf": "font/ttf",
+  ".otf": "font/otf",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2"
+};
 async function listDirectoryEntries({
   root,
   relativePath = "."
@@ -32078,6 +32388,23 @@ async function deleteFile({ root, relativePath }) {
   }
   await fs6.unlink(filePath);
 }
+async function deleteEntry({ root, relativePath }) {
+  const entryPath = await resolveScopedPath({ root, relativePath });
+  await fs6.rm(entryPath, { recursive: true, force: false });
+}
+async function createDirectory({ root, relativePath }) {
+  const dirPath = await resolveScopedPath({ root, relativePath });
+  await fs6.mkdir(dirPath, { recursive: true });
+}
+async function moveEntry({
+  root,
+  sourcePath,
+  destinationPath
+}) {
+  const src = await resolveScopedPath({ root, relativePath: sourcePath });
+  const dest = await resolveScopedPath({ root, relativePath: destinationPath });
+  await fs6.rename(src, dest);
+}
 async function getDownloadableFileInfo({ root, relativePath }) {
   const filePath = await resolveScopedPath({ root, relativePath });
   const stats = await fs6.stat(filePath);
@@ -32087,7 +32414,9 @@ async function getDownloadableFileInfo({ root, relativePath }) {
   const ext = path11.extname(filePath).toLowerCase();
   let mimeType = "application/octet-stream";
   if (ext in IMAGE_MIME_TYPES) {
-    mimeType = IMAGE_MIME_TYPES[ext];
+    mimeType = IMAGE_MIME_TYPES[ext] ?? mimeType;
+  } else if (ext in FONT_MIME_TYPES) {
+    mimeType = FONT_MIME_TYPES[ext] ?? mimeType;
   } else {
     const handle = await fs6.open(filePath, "r");
     const sample = Buffer.alloc(8192);
@@ -32508,15 +32837,15 @@ async function getProjectIcon(projectDir) {
 
 // ../server/src/utils/path.ts
 import os5 from "os";
-function expandTilde(path30) {
-  if (path30.startsWith("~/")) {
+function expandTilde(path33) {
+  if (path33.startsWith("~/")) {
     const homeDir3 = process.env.HOME || os5.homedir();
-    return path30.replace("~", homeDir3);
+    return path33.replace("~", homeDir3);
   }
-  if (path30 === "~") {
+  if (path33 === "~") {
     return process.env.HOME || os5.homedir();
   }
-  return path30;
+  return path33;
 }
 
 // ../server/src/server/skills/scanner.ts
@@ -34023,7 +34352,7 @@ function buildChatMentionNotification(input) {
   ].join("\n");
 }
 
-// ../server/src/server/agents/scanner.ts
+// ../server/src/server/roles/scanner.ts
 import fs9 from "node:fs/promises";
 import os7 from "node:os";
 import path16 from "node:path";
@@ -34036,11 +34365,41 @@ function resolveScopeDir2(scope, workspaceRoot) {
     if (!workspaceRoot) {
       throw new Error('workspaceRoot is required for scope "project"');
     }
-    return path16.join(workspaceRoot, ".agents");
+    return path16.join(workspaceRoot, ".roles");
+  }
+  return path16.join(homeDir2(), ".appostle", ".roles");
+}
+function allowedRoots2(workspaceRoot) {
+  const roots = [path16.join(homeDir2(), ".appostle", ".roles")];
+  if (workspaceRoot) {
+    roots.push(path16.join(workspaceRoot, ".roles"));
   }
-  return path16.join(homeDir2(), ".appostle", ".agents");
+  return roots.map((r) => path16.resolve(r));
+}
+function isInsideAllowedRoot2(absPath, workspaceRoot) {
+  const resolved = path16.resolve(absPath);
+  for (const root of allowedRoots2(workspaceRoot)) {
+    const rel = path16.relative(root, resolved);
+    if (rel === "" || !rel.startsWith("..") && !path16.isAbsolute(rel)) {
+      return true;
+    }
+  }
+  return false;
 }
 var FRONTMATTER_RE2 = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+function parseRoleFile(text) {
+  const match = FRONTMATTER_RE2.exec(text);
+  if (!match) {
+    return { rawFrontmatterLines: [], body: text, hadFrontmatter: false };
+  }
+  const yamlBlock = match[1] ?? "";
+  const body = match[2] ?? "";
+  return {
+    rawFrontmatterLines: yamlBlock.split(/\r?\n/),
+    body,
+    hadFrontmatter: true
+  };
+}
 function unquote(value) {
   if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
     return value.slice(1, -1);
@@ -34048,36 +34407,165 @@ function unquote(value) {
   return value;
 }
 function parseFrontmatter(text) {
-  const match = FRONTMATTER_RE2.exec(text);
   const empty = {
     description: "",
-    provider: null,
-    model: null,
-    mode: null
-  };
-  if (!match) {
-    return empty;
-  }
-  const lines = (match[1] ?? "").split(/\r?\n/);
+    triggerWords: [],
+    allowedTools: [],
+    provider: "",
+    model: "",
+    mode: ""
+  };
+  const { rawFrontmatterLines: lines, hadFrontmatter } = parseRoleFile(text);
+  if (!hadFrontmatter) return empty;
   const out = { ...empty };
-  for (const line of lines) {
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i] ?? "";
     const m = /^([A-Za-z][A-Za-z0-9_-]*)\s*:\s*(.*)$/.exec(line);
-    if (!m) continue;
+    if (!m) {
+      i++;
+      continue;
+    }
     const key = m[1];
     const value = unquote((m[2] ?? "").trim());
     if (key === "description") {
       out.description = value;
     } else if (key === "provider") {
-      out.provider = value || null;
+      out.provider = value;
     } else if (key === "model") {
-      out.model = value || null;
+      out.model = value;
     } else if (key === "mode") {
-      out.mode = value || null;
+      out.mode = value;
+    } else if (key === "trigger-words" || key === "allowed-tools") {
+      const target = key === "trigger-words" ? "triggerWords" : "allowedTools";
+      if (value) {
+        out[target] = value.replace(/^\[|\]$/g, "").split(",").map((s) => unquote(s.trim())).filter((s) => s.length > 0);
+      } else {
+        const items = [];
+        let j = i + 1;
+        while (j < lines.length) {
+          const next = lines[j] ?? "";
+          const itemMatch = /^\s+-\s+(.+)$/.exec(next);
+          if (!itemMatch) break;
+          items.push(unquote(itemMatch[1].trim()));
+          j++;
+        }
+        out[target] = items;
+        i = j;
+        continue;
+      }
     }
+    i++;
   }
   return out;
 }
-async function readRolesFromDir(scope, dir) {
+var OWNED_KEYS = [
+  "name",
+  "category",
+  "description",
+  "trigger-words",
+  "allowed-tools",
+  "provider",
+  "model",
+  "mode"
+];
+function findOwnedSpans2(lines) {
+  const spans = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i] ?? "";
+    const keyMatch = /^([A-Za-z][A-Za-z0-9_-]*)\s*:\s*(.*)$/.exec(line);
+    if (!keyMatch) {
+      i++;
+      continue;
+    }
+    const key = keyMatch[1];
+    const value = keyMatch[2];
+    if (!OWNED_KEYS.includes(key)) {
+      i++;
+      continue;
+    }
+    let end = i + 1;
+    if (value === "") {
+      while (end < lines.length) {
+        const next = lines[end] ?? "";
+        if (/^\s+-\s+/.test(next) || /^\s*$/.test(next)) {
+          end++;
+        } else {
+          break;
+        }
+      }
+    }
+    spans.push({ key, startLine: i, endLine: end });
+    i = end;
+  }
+  return spans;
+}
+function emitFrontmatterValue2(key, value) {
+  if (key === "trigger-words" || key === "allowed-tools") {
+    if (!Array.isArray(value) || value.length === 0) return [];
+    return [`${key}:`, ...value.map((v) => `  - ${v}`)];
+  }
+  const text = typeof value === "string" ? value : "";
+  if (text.length === 0) return [];
+  const needsQuote = /[:#\n]/.test(text) || text.startsWith(" ") || text.endsWith(" ");
+  const formatted = needsQuote ? `"${text.replace(/"/g, '\\"')}"` : text;
+  return [`${key}: ${formatted}`];
+}
+function rewriteFrontmatter2(originalLines, next) {
+  const spans = findOwnedSpans2(originalLines);
+  const ownedKeys = new Set(spans.map((s) => s.key));
+  const replacements = /* @__PURE__ */ new Map();
+  if (next.name !== void 0) {
+    replacements.set("name", emitFrontmatterValue2("name", next.name));
+  }
+  if (next.category !== void 0) {
+    replacements.set("category", emitFrontmatterValue2("category", next.category));
+  }
+  if (next.description !== void 0) {
+    replacements.set("description", emitFrontmatterValue2("description", next.description));
+  }
+  if (next.triggerWords !== void 0) {
+    replacements.set("trigger-words", emitFrontmatterValue2("trigger-words", next.triggerWords));
+  }
+  if (next.allowedTools !== void 0) {
+    replacements.set("allowed-tools", emitFrontmatterValue2("allowed-tools", next.allowedTools));
+  }
+  if (next.provider !== void 0) {
+    replacements.set("provider", emitFrontmatterValue2("provider", next.provider));
+  }
+  if (next.model !== void 0) {
+    replacements.set("model", emitFrontmatterValue2("model", next.model));
+  }
+  if (next.mode !== void 0) {
+    replacements.set("mode", emitFrontmatterValue2("mode", next.mode));
+  }
+  const out = [];
+  let i = 0;
+  while (i < originalLines.length) {
+    const span = spans.find((s) => s.startLine === i);
+    if (span) {
+      if (replacements.has(span.key)) {
+        out.push(...replacements.get(span.key) ?? []);
+      } else {
+        for (let j = span.startLine; j < span.endLine; j++) {
+          out.push(originalLines[j] ?? "");
+        }
+      }
+      i = span.endLine;
+      continue;
+    }
+    out.push(originalLines[i] ?? "");
+    i++;
+  }
+  for (const key of OWNED_KEYS) {
+    if (replacements.has(key) && !ownedKeys.has(key)) {
+      out.push(...replacements.get(key) ?? []);
+    }
+  }
+  return out;
+}
+async function readRolesFromDir(scope, dir, category) {
   let entries;
   try {
     entries = await fs9.readdir(dir, { withFileTypes: true });
@@ -34103,13 +34591,23 @@ async function readRolesFromDir(scope, dir) {
       const text = await fs9.readFile(fullPath, "utf8");
       parsed = parseFrontmatter(text);
     } catch {
-      parsed = { description: "", provider: null, model: null, mode: null };
+      parsed = {
+        description: "",
+        triggerWords: [],
+        allowedTools: [],
+        provider: "",
+        model: "",
+        mode: ""
+      };
     }
+    const id = category ? `${scope}:${category}/${name}` : `${scope}:${name}`;
     results.push({
-      id: `${scope}:${name}`,
+      id,
       scope,
+      category,
       name,
       description: parsed.description,
+      triggerWords: parsed.triggerWords,
       provider: parsed.provider,
       model: parsed.model,
       mode: parsed.mode,
@@ -34118,16 +34616,635 @@ async function readRolesFromDir(scope, dir) {
       size: stat10.size
     });
   }
+  results.sort((a, b) => a.name.localeCompare(b.name));
   return results;
 }
-async function listAgentRoles(args) {
-  const project = args.workspaceRoot ? await readRolesFromDir("project", resolveScopeDir2("project", args.workspaceRoot)) : [];
-  const global = await readRolesFromDir("global", resolveScopeDir2("global"));
-  const projectNames = new Set(project.map((r) => r.name));
-  const merged = [...project, ...global.filter((r) => !projectNames.has(r.name))];
-  merged.sort((a, b) => a.name.localeCompare(b.name));
+async function readRolesFromScopeDir(scope, scopeDir) {
+  let topEntries;
+  try {
+    topEntries = await fs9.readdir(scopeDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const flat = await readRolesFromDir(scope, scopeDir, null);
+  const categoryResults = await Promise.all(
+    topEntries.filter((e) => e.isDirectory() && NAME_REGEX2.test(e.name)).map((e) => readRolesFromDir(scope, path16.join(scopeDir, e.name), e.name))
+  );
+  const all = [...flat, ...categoryResults.flat()];
+  all.sort((a, b) => {
+    const catA = a.category ?? "";
+    const catB = b.category ?? "";
+    if (catA !== catB) return catA.localeCompare(catB);
+    return a.name.localeCompare(b.name);
+  });
+  return all;
+}
+async function listRoles(args) {
+  if (args.scope === "project") {
+    return readRolesFromScopeDir("project", resolveScopeDir2("project", args.workspaceRoot));
+  }
+  if (args.scope === "global") {
+    return readRolesFromScopeDir("global", resolveScopeDir2("global"));
+  }
+  const project = args.workspaceRoot ? await readRolesFromScopeDir("project", resolveScopeDir2("project", args.workspaceRoot)) : [];
+  const global = await readRolesFromScopeDir("global", resolveScopeDir2("global"));
+  const projectIds = new Set(project.map((r) => r.id));
+  const merged = [...project, ...global.filter((r) => !projectIds.has(r.id))];
+  merged.sort((a, b) => {
+    const catA = a.category ?? "";
+    const catB = b.category ?? "";
+    if (catA !== catB) return catA.localeCompare(catB);
+    return a.name.localeCompare(b.name);
+  });
   return merged;
 }
+async function resolveRole(args) {
+  const roles = await listRoles({ workspaceRoot: args.workspaceRoot });
+  const match = roles.find((r) => r.name === args.roleName);
+  if (!match) return null;
+  try {
+    const text = await fs9.readFile(match.path, "utf8");
+    const parsed = parseRoleFile(text);
+    const fm = parseFrontmatter(text);
+    const body = parsed.body.trim();
+    if (!body && fm.allowedTools.length === 0) return null;
+    return { body, allowedTools: fm.allowedTools };
+  } catch {
+    return null;
+  }
+}
+async function createRole(args) {
+  if (!NAME_REGEX2.test(args.name)) {
+    throw new Error(
+      `Invalid role name "${args.name}". Use letters, digits, dot, underscore, dash.`
+    );
+  }
+  if (args.name.includes("/") || args.name.includes("\\") || args.name.includes("..")) {
+    throw new Error(`Role name must not contain path separators or "..".`);
+  }
+  const scopeDir = resolveScopeDir2(args.scope, args.workspaceRoot);
+  const dir = args.category ? path16.join(scopeDir, args.category) : scopeDir;
+  await fs9.mkdir(dir, { recursive: true });
+  const filePath = path16.join(dir, `${args.name}.md`);
+  try {
+    await fs9.access(filePath);
+    throw new Error(`A role named "${args.name}" already exists at ${filePath}`);
+  } catch (err) {
+    if (err && typeof err === "object" && "code" in err && err.code !== "ENOENT") {
+      throw err;
+    }
+    if (err instanceof Error && err.message.includes("already exists")) {
+      throw err;
+    }
+  }
+  const initial = buildStarterRole(args.name);
+  await fs9.writeFile(filePath, initial, "utf8");
+  return { path: filePath };
+}
+function buildStarterRole(name) {
+  return `---
+name: ${name}
+description: ""
+trigger-words: []
+allowed-tools: []
+provider: claude/opus
+mode: default
+---
+
+# ${name}
+
+You are a ${name}. Describe the role's behavior, scope, and any constraints
+here. The body of this file is loaded as the agent's system prompt when
+the role is invoked.
+`;
+}
+async function writeRoleFrontmatter(args, workspaceRoot) {
+  if (!path16.isAbsolute(args.path)) {
+    throw new Error(`writeRoleFrontmatter expects an absolute path; got "${args.path}"`);
+  }
+  if (!isInsideAllowedRoot2(args.path, workspaceRoot)) {
+    throw new Error(`Path "${args.path}" is not inside an allowlisted role root`);
+  }
+  let original;
+  try {
+    original = await fs9.readFile(args.path, "utf8");
+  } catch (err) {
+    throw new Error(
+      `Failed to read role file: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  const parsed = parseRoleFile(original);
+  const newLines = rewriteFrontmatter2(parsed.rawFrontmatterLines, args.frontmatter);
+  const nextFrontmatter = ["---", ...newLines, "---"].join("\n");
+  const nextContent = parsed.hadFrontmatter ? `${nextFrontmatter}
+${parsed.body}` : `${nextFrontmatter}
+
+${original}`;
+  await fs9.writeFile(args.path, nextContent, "utf8");
+}
+async function moveRole(args, workspaceRoot) {
+  if (!path16.isAbsolute(args.path)) {
+    throw new Error(`moveRole expects an absolute path; got "${args.path}"`);
+  }
+  if (!isInsideAllowedRoot2(args.path, workspaceRoot)) {
+    throw new Error(`Path "${args.path}" is not inside an allowlisted role root`);
+  }
+  const oldDir = path16.dirname(args.path);
+  const oldFilename = path16.basename(args.path, ".md");
+  const roots = allowedRoots2(workspaceRoot);
+  const rolesRoot = roots.find((r) => path16.resolve(args.path).startsWith(r));
+  if (!rolesRoot) {
+    throw new Error(`Cannot determine roles root for "${args.path}"`);
+  }
+  const relFromRoot = path16.relative(rolesRoot, path16.dirname(args.path));
+  const currentCategory = relFromRoot && relFromRoot !== "." ? relFromRoot : "";
+  const newName = args.newName ?? oldFilename;
+  const newCategory = args.newCategory !== void 0 ? args.newCategory : currentCategory;
+  if (!NAME_REGEX2.test(newName)) {
+    throw new Error(`Invalid role name: "${newName}"`);
+  }
+  if (newCategory && !NAME_REGEX2.test(newCategory)) {
+    throw new Error(`Invalid category name: "${newCategory}"`);
+  }
+  const newDir = newCategory ? path16.join(rolesRoot, newCategory) : rolesRoot;
+  const newPath = path16.join(newDir, `${newName}.md`);
+  if (path16.resolve(newPath) === path16.resolve(args.path)) {
+    return { path: args.path };
+  }
+  await fs9.mkdir(newDir, { recursive: true });
+  try {
+    await fs9.access(newPath);
+    throw new Error(`A role already exists at "${newPath}"`);
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  await fs9.rename(args.path, newPath);
+  const frontmatterPatch = {};
+  if (newName !== oldFilename) {
+    frontmatterPatch.description = void 0;
+  }
+  await writeRoleFrontmatter(
+    {
+      path: newPath,
+      frontmatter: {
+        ...newName !== oldFilename ? { name: newName } : {}
+      }
+    },
+    workspaceRoot
+  );
+  if (oldDir !== rolesRoot) {
+    try {
+      const remaining = await fs9.readdir(oldDir);
+      if (remaining.length === 0) {
+        await fs9.rmdir(oldDir);
+      }
+    } catch {
+    }
+  }
+  return { path: newPath };
+}
+
+// ../server/src/server/brands/scanner.ts
+import fs10 from "node:fs/promises";
+import path17 from "node:path";
+var NAME_REGEX3 = /^[a-z0-9][a-z0-9._-]*$/i;
+function resolveScopeDir3(scope, workspaceRoot) {
+  if (scope === "project") {
+    if (!workspaceRoot) {
+      throw new Error('workspaceRoot is required for scope "project"');
+    }
+    return path17.join(workspaceRoot, ".brand");
+  }
+  throw new Error(`Unknown scope: ${scope}`);
+}
+function allowedRoots3(workspaceRoot) {
+  const roots = [];
+  if (workspaceRoot) {
+    roots.push(path17.join(workspaceRoot, ".brand"));
+  }
+  return roots.map((r) => path17.resolve(r));
+}
+function isInsideAllowedRoot3(absPath, workspaceRoot) {
+  const resolved = path17.resolve(absPath);
+  for (const root of allowedRoots3(workspaceRoot)) {
+    const rel = path17.relative(root, resolved);
+    if (rel === "" || !rel.startsWith("..") && !path17.isAbsolute(rel)) {
+      return true;
+    }
+  }
+  return false;
+}
+var FRONTMATTER_RE3 = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+function parseBrandFile(text) {
+  const match = FRONTMATTER_RE3.exec(text);
+  if (!match) {
+    return { rawFrontmatterLines: [], body: text, hadFrontmatter: false };
+  }
+  return {
+    rawFrontmatterLines: (match[1] ?? "").split(/\r?\n/),
+    body: match[2] ?? "",
+    hadFrontmatter: true
+  };
+}
+function unquote2(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function quoteIfNeeded(value) {
+  if (/[:#\n\[\]]/.test(value) || value.startsWith(" ") || value.endsWith(" ")) {
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+  }
+  return value;
+}
+function parseFrontmatter2(lines) {
+  const result = {
+    description: "",
+    tags: [],
+    variables: []
+  };
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i] ?? "";
+    const keyMatch = /^([A-Za-z][A-Za-z0-9_-]*)\s*:\s*(.*)$/.exec(line);
+    if (!keyMatch) {
+      i++;
+      continue;
+    }
+    const key = keyMatch[1];
+    const rawValue = (keyMatch[2] ?? "").trim();
+    if (key === "description") {
+      result.description = unquote2(rawValue);
+      i++;
+    } else if (key === "tags") {
+      if (rawValue) {
+        result.tags = rawValue.replace(/^\[|\]$/g, "").split(",").map((s) => unquote2(s)).filter((s) => s.length > 0);
+      } else {
+        const items = [];
+        let j = i + 1;
+        while (j < lines.length) {
+          const next = lines[j] ?? "";
+          const m = /^\s+-\s+(.+)$/.exec(next);
+          if (!m) break;
+          items.push(unquote2(m[1]));
+          j++;
+        }
+        result.tags = items;
+        i = j;
+        continue;
+      }
+      i++;
+    } else if (key === "variables") {
+      const vars = [];
+      let j = i + 1;
+      while (j < lines.length) {
+        const next = lines[j] ?? "";
+        if (/^\s+-\s+key\s*:\s*/.test(next)) {
+          const keyVal = unquote2((/^\s+-\s+key\s*:\s*(.*)$/.exec(next) ?? [])[1] ?? "");
+          const varObj = { key: keyVal, type: "text", label: "", value: "" };
+          j++;
+          while (j < lines.length) {
+            const sub = lines[j] ?? "";
+            if (/^\s+-\s+/.test(sub) && !/^\s{4,}-\s+/.test(sub)) break;
+            const subMatch = /^\s+(\w+)\s*:\s*(.*)$/.exec(sub);
+            if (!subMatch) {
+              j++;
+              break;
+            }
+            const subKey = subMatch[1];
+            const subVal = unquote2(subMatch[2] ?? "");
+            if (subKey === "type") {
+              varObj.type = subVal;
+            } else if (subKey === "label") {
+              varObj.label = subVal;
+            } else if (subKey === "value") {
+              varObj.value = subVal;
+            } else if (subKey === "section") {
+              varObj.section = subVal;
+            } else if (subKey === "options") {
+              varObj.options = subVal.replace(/^\[|\]$/g, "").split(",").map((s) => unquote2(s)).filter((s) => s.length > 0);
+            } else if (subKey === "fileRef") {
+              varObj.fileRef = subVal;
+            }
+            j++;
+          }
+          vars.push(varObj);
+        } else if (/^[A-Za-z]/.test(next)) {
+          break;
+        } else {
+          j++;
+        }
+      }
+      result.variables = vars;
+      i = j;
+      continue;
+    } else {
+      i++;
+    }
+  }
+  return result;
+}
+function serializeVariables(variables) {
+  if (variables.length === 0) return ["variables: []"];
+  const lines = ["variables:"];
+  for (const v of variables) {
+    lines.push(`  - key: ${quoteIfNeeded(v.key)}`);
+    lines.push(`    type: ${v.type}`);
+    lines.push(`    label: ${quoteIfNeeded(v.label)}`);
+    lines.push(`    value: ${quoteIfNeeded(v.value)}`);
+    if (v.section) {
+      lines.push(`    section: ${v.section}`);
+    }
+    if (v.options && v.options.length > 0) {
+      lines.push(`    options: [${v.options.map(quoteIfNeeded).join(", ")}]`);
+    }
+    if (v.fileRef) {
+      lines.push(`    fileRef: ${quoteIfNeeded(v.fileRef)}`);
+    }
+  }
+  return lines;
+}
+var OWNED_KEYS2 = ["description", "tags", "variables"];
+function findOwnedSpans3(lines) {
+  const spans = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i] ?? "";
+    const keyMatch = /^([A-Za-z][A-Za-z0-9_-]*)\s*:\s*(.*)$/.exec(line);
+    if (!keyMatch) {
+      i++;
+      continue;
+    }
+    const key = keyMatch[1];
+    const rawValue = keyMatch[2] ?? "";
+    if (!OWNED_KEYS2.includes(key)) {
+      i++;
+      continue;
+    }
+    let end = i + 1;
+    if (rawValue.trim() === "" || rawValue.trim() === "[]") {
+      while (end < lines.length) {
+        const next = lines[end] ?? "";
+        if (/^\s+/.test(next)) {
+          end++;
+        } else {
+          break;
+        }
+      }
+    }
+    spans.push({ key, startLine: i, endLine: end });
+    i = end;
+  }
+  return spans;
+}
+function rewriteFrontmatter3(originalLines, next) {
+  const spans = findOwnedSpans3(originalLines);
+  const ownedKeys = new Set(spans.map((s) => s.key));
+  const replacements = /* @__PURE__ */ new Map();
+  if (next.description !== void 0) {
+    const v = next.description;
+    replacements.set("description", v.length > 0 ? [`description: ${quoteIfNeeded(v)}`] : []);
+  }
+  if (next.tags !== void 0) {
+    if (next.tags.length === 0) {
+      replacements.set("tags", []);
+    } else {
+      replacements.set("tags", [`tags: [${next.tags.map(quoteIfNeeded).join(", ")}]`]);
+    }
+  }
+  if (next.variables !== void 0) {
+    replacements.set("variables", serializeVariables(next.variables));
+  }
+  const out = [];
+  let i = 0;
+  while (i < originalLines.length) {
+    const span = spans.find((s) => s.startLine === i);
+    if (span) {
+      if (replacements.has(span.key)) {
+        out.push(...replacements.get(span.key) ?? []);
+      } else {
+        for (let j = span.startLine; j < span.endLine; j++) {
+          out.push(originalLines[j] ?? "");
+        }
+      }
+      i = span.endLine;
+      continue;
+    }
+    out.push(originalLines[i] ?? "");
+    i++;
+  }
+  for (const key of OWNED_KEYS2) {
+    if (replacements.has(key) && !ownedKeys.has(key)) {
+      out.push(...replacements.get(key) ?? []);
+    }
+  }
+  return out;
+}
+async function readBrandsFromDir(scope, dir) {
+  let entries;
+  try {
+    entries = await fs10.readdir(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const results = [];
+  for (const entry of entries) {
+    if (!entry.isFile()) continue;
+    if (!entry.name.endsWith(".md")) continue;
+    const name = entry.name.slice(0, -".md".length);
+    if (!name || !NAME_REGEX3.test(name)) continue;
+    const fullPath = path17.join(dir, entry.name);
+    let stat10;
+    try {
+      const s = await fs10.stat(fullPath);
+      stat10 = { mtime: s.mtime, size: s.size };
+    } catch {
+      continue;
+    }
+    let parsed;
+    try {
+      const text = await fs10.readFile(fullPath, "utf8");
+      const { rawFrontmatterLines, hadFrontmatter } = parseBrandFile(text);
+      parsed = hadFrontmatter ? parseFrontmatter2(rawFrontmatterLines) : { description: "", tags: [], variables: [] };
+    } catch {
+      parsed = { description: "", tags: [], variables: [] };
+    }
+    results.push({
+      id: `${scope}:${name}`,
+      scope,
+      name,
+      description: parsed.description,
+      tags: parsed.tags,
+      variables: parsed.variables,
+      path: fullPath,
+      modifiedAt: stat10.mtime.toISOString(),
+      size: stat10.size
+    });
+  }
+  results.sort((a, b) => a.name.localeCompare(b.name));
+  return results;
+}
+async function listBrands(args) {
+  return readBrandsFromDir("project", resolveScopeDir3("project", args.workspaceRoot));
+}
+async function createBrand(args) {
+  if (!NAME_REGEX3.test(args.name)) {
+    throw new Error(
+      `Invalid brand name "${args.name}". Use letters, digits, dot, underscore, dash.`
+    );
+  }
+  if (args.name.includes("/") || args.name.includes("\\") || args.name.includes("..")) {
+    throw new Error(`Brand name must not contain path separators or "..".`);
+  }
+  const dir = resolveScopeDir3("project", args.workspaceRoot);
+  await fs10.mkdir(dir, { recursive: true });
+  const filePath = path17.join(dir, `${args.name}.md`);
+  try {
+    await fs10.access(filePath);
+    throw new Error(`A brand named "${args.name}" already exists at ${filePath}`);
+  } catch (err) {
+    if (err && typeof err === "object" && "code" in err && err.code !== "ENOENT") {
+      throw err;
+    }
+    if (err instanceof Error && err.message.includes("already exists")) {
+      throw err;
+    }
+  }
+  await fs10.writeFile(filePath, buildStarterBrand(args.name), "utf8");
+  return { path: filePath };
+}
+function buildStarterBrand(name) {
+  return `---
+name: ${name}
+description: ""
+tags: []
+variables:
+  - key: color.primary
+    type: color
+    label: Primary Color
+    value: "#000000"
+  - key: color.accent
+    type: color
+    label: Accent Color
+    value: "#ffffff"
+  - key: font.heading
+    type: font
+    label: Heading Font
+    value: ""
+  - key: font.body
+    type: font
+    label: Body Font
+    value: ""
+  - key: logo
+    type: asset
+    label: Logo
+    value: ""
+  - key: tone
+    type: text
+    label: Tone of Voice
+    value: ""
+---
+
+# ${name}
+
+Describe this brand's identity, design philosophy, and usage guidelines here.
+`;
+}
+var TARGET_NAME_REGEX = /^[a-z0-9][a-z0-9._-]*$/i;
+async function copyBrandAsset(args) {
+  if (!args.workspaceRoot) {
+    throw new Error("workspaceRoot is required to copy a brand asset");
+  }
+  if (!args.sourcePath || !path17.isAbsolute(args.sourcePath)) {
+    throw new Error(`copyBrandAsset expects an absolute sourcePath; got "${args.sourcePath}"`);
+  }
+  if (!TARGET_NAME_REGEX.test(args.targetName) || args.targetName.includes("..")) {
+    throw new Error(
+      `Invalid targetName "${args.targetName}". Use letters, digits, dot, underscore, dash.`
+    );
+  }
+  const stats = await fs10.stat(args.sourcePath);
+  if (!stats.isFile()) {
+    throw new Error(`Source path is not a regular file: ${args.sourcePath}`);
+  }
+  const ext = path17.extname(args.sourcePath).toLowerCase();
+  const fileName = `${args.targetName}${ext}`;
+  const assetsDir = path17.join(args.workspaceRoot, ".brand", "assets");
+  const destAbs = path17.resolve(assetsDir, fileName);
+  const rel = path17.relative(path17.resolve(assetsDir), destAbs);
+  if (rel.startsWith("..") || path17.isAbsolute(rel)) {
+    throw new Error(`Refusing to write outside of .brand/assets: ${destAbs}`);
+  }
+  await fs10.mkdir(assetsDir, { recursive: true });
+  await fs10.copyFile(args.sourcePath, destAbs);
+  return {
+    relativePath: `assets/${fileName}`,
+    absolutePath: destAbs
+  };
+}
+async function uploadBrandAsset(args) {
+  if (!args.workspaceRoot) {
+    throw new Error("workspaceRoot is required to upload a brand asset");
+  }
+  if (!TARGET_NAME_REGEX.test(args.targetName) || args.targetName.includes("..")) {
+    throw new Error(
+      `Invalid targetName "${args.targetName}". Use letters, digits, dot, underscore, dash.`
+    );
+  }
+  if (!args.dataBase64 || args.dataBase64.trim().length === 0) {
+    throw new Error("No file data provided for brand asset upload");
+  }
+  const extFromSource = args.sourceName ? path17.extname(args.sourceName).toLowerCase() : "";
+  const ext = extFromSource || ".png";
+  const fileName = `${args.targetName}${ext}`;
+  const assetsDir = path17.join(args.workspaceRoot, ".brand", "assets");
+  const destAbs = path17.resolve(assetsDir, fileName);
+  const rel = path17.relative(path17.resolve(assetsDir), destAbs);
+  if (rel.startsWith("..") || path17.isAbsolute(rel)) {
+    throw new Error(`Refusing to write outside of .brand/assets: ${destAbs}`);
+  }
+  let data;
+  try {
+    data = Buffer.from(args.dataBase64, "base64");
+  } catch {
+    throw new Error("Failed to decode uploaded brand asset");
+  }
+  if (data.length === 0) {
+    throw new Error("Uploaded brand asset is empty");
+  }
+  await fs10.mkdir(assetsDir, { recursive: true });
+  await fs10.writeFile(destAbs, data);
+  return {
+    relativePath: `assets/${fileName}`,
+    absolutePath: destAbs
+  };
+}
+async function writeBrandFrontmatter(args, workspaceRoot) {
+  if (!path17.isAbsolute(args.path)) {
+    throw new Error(`writeBrandFrontmatter expects an absolute path; got "${args.path}"`);
+  }
+  if (!isInsideAllowedRoot3(args.path, workspaceRoot)) {
+    throw new Error(`Path "${args.path}" is not inside an allowlisted brand root`);
+  }
+  let original;
+  try {
+    original = await fs10.readFile(args.path, "utf8");
+  } catch (err) {
+    throw new Error(
+      `Failed to read brand file: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  const parsed = parseBrandFile(original);
+  const newLines = rewriteFrontmatter3(parsed.rawFrontmatterLines, args.frontmatter);
+  const nextFrontmatter = ["---", ...newLines, "---"].join("\n");
+  const nextContent = parsed.hadFrontmatter ? `${nextFrontmatter}
+${parsed.body}` : `${nextFrontmatter}
+
+${original}`;
+  await fs10.writeFile(args.path, nextContent, "utf8");
+}
 
 // ../server/src/services/oauth-service.ts
 import { createHash as createHash3, randomBytes as randomBytes2 } from "node:crypto";
@@ -34374,57 +35491,57 @@ async function fetchGitLabUsername(fetchImpl, accessToken) {
     return null;
   }
 }
-async function readCredential(path30, log) {
+async function readCredential(path33, log) {
   try {
-    const raw = await readFile3(path30, "utf8");
+    const raw = await readFile3(path33, "utf8");
     const parsed = JSON.parse(raw);
     return parsed.gitlab ?? null;
   } catch (error) {
     if (isNotFound(error)) return null;
-    log.warn({ err: error, path: path30 }, "oauth.credentials.read_failed");
+    log.warn({ err: error, path: path33 }, "oauth.credentials.read_failed");
     return null;
   }
 }
-async function persistCredential(path30, credential, log) {
-  await mkdir4(dirname4(path30), { recursive: true });
+async function persistCredential(path33, credential, log) {
+  await mkdir4(dirname4(path33), { recursive: true });
   let current = {};
   try {
-    const raw = await readFile3(path30, "utf8");
+    const raw = await readFile3(path33, "utf8");
     current = JSON.parse(raw);
   } catch (error) {
     if (!isNotFound(error)) {
-      log.warn({ err: error, path: path30 }, "oauth.credentials.read_failed_overwriting");
+      log.warn({ err: error, path: path33 }, "oauth.credentials.read_failed_overwriting");
     }
   }
   const next = { ...current, gitlab: credential };
-  const tmpPath = `${path30}.tmp-${process.pid}-${Date.now()}`;
+  const tmpPath = `${path33}.tmp-${process.pid}-${Date.now()}`;
   await writeFile4(tmpPath, JSON.stringify(next, null, 2), { mode: 384 });
-  await rename(tmpPath, path30);
+  await rename(tmpPath, path33);
 }
-async function deleteCredential(path30, log) {
+async function deleteCredential(path33, log) {
   let current = {};
   try {
-    const raw = await readFile3(path30, "utf8");
+    const raw = await readFile3(path33, "utf8");
     current = JSON.parse(raw);
   } catch (error) {
     if (isNotFound(error)) return;
-    log.warn({ err: error, path: path30 }, "oauth.credentials.delete_read_failed");
+    log.warn({ err: error, path: path33 }, "oauth.credentials.delete_read_failed");
     return;
   }
   delete current.gitlab;
   if (Object.keys(current).length === 0) {
     try {
-      await unlink(path30);
+      await unlink(path33);
     } catch (error) {
       if (!isNotFound(error)) {
-        log.warn({ err: error, path: path30 }, "oauth.credentials.unlink_failed");
+        log.warn({ err: error, path: path33 }, "oauth.credentials.unlink_failed");
       }
     }
     return;
   }
-  const tmpPath = `${path30}.tmp-${process.pid}-${Date.now()}`;
+  const tmpPath = `${path33}.tmp-${process.pid}-${Date.now()}`;
   await writeFile4(tmpPath, JSON.stringify(current, null, 2), { mode: 384 });
-  await rename(tmpPath, path30);
+  await rename(tmpPath, path33);
 }
 function defaultGlabConfigPath() {
   const home = homedir4();
@@ -34439,15 +35556,15 @@ function defaultGlabConfigPath() {
   const xdg = process.env.XDG_CONFIG_HOME;
   return join9(xdg && xdg.length > 0 ? xdg : join9(home, ".config"), "glab-cli", "config.yml");
 }
-async function writeGlabConfig(path30, credential, log) {
-  await mkdir4(dirname4(path30), { recursive: true });
+async function writeGlabConfig(path33, credential, log) {
+  await mkdir4(dirname4(path33), { recursive: true });
   let doc;
   try {
-    const raw = await readFile3(path30, "utf8");
+    const raw = await readFile3(path33, "utf8");
     doc = YAML.parseDocument(raw);
     if (doc.errors.length > 0) {
       log.warn(
-        { errors: doc.errors.map((e) => e.message), path: path30 },
+        { errors: doc.errors.map((e) => e.message), path: path33 },
         "oauth.glab.parse_errors_replacing"
       );
       doc = YAML.parseDocument("{}");
@@ -34456,7 +35573,7 @@ async function writeGlabConfig(path30, credential, log) {
     if (isNotFound(error)) {
       doc = YAML.parseDocument("{}");
     } else {
-      log.warn({ err: error, path: path30 }, "oauth.glab.read_failed_replacing");
+      log.warn({ err: error, path: path33 }, "oauth.glab.read_failed_replacing");
       doc = YAML.parseDocument("{}");
     }
   }
@@ -34469,18 +35586,18 @@ async function writeGlabConfig(path30, credential, log) {
   if (credential.username) {
     hostEntry.set("user", credential.username);
   }
-  const tmpPath = `${path30}.tmp-${process.pid}-${Date.now()}`;
+  const tmpPath = `${path33}.tmp-${process.pid}-${Date.now()}`;
   await writeFile4(tmpPath, doc.toString(), { mode: 384 });
-  await rename(tmpPath, path30);
+  await rename(tmpPath, path33);
 }
-async function removeGlabHost(path30, log) {
+async function removeGlabHost(path33, log) {
   let doc;
   try {
-    const raw = await readFile3(path30, "utf8");
+    const raw = await readFile3(path33, "utf8");
     doc = YAML.parseDocument(raw);
   } catch (error) {
     if (isNotFound(error)) return;
-    log.warn({ err: error, path: path30 }, "oauth.glab.remove_read_failed");
+    log.warn({ err: error, path: path33 }, "oauth.glab.remove_read_failed");
     return;
   }
   const hosts = doc.get("hosts");
@@ -34489,9 +35606,9 @@ async function removeGlabHost(path30, log) {
   if (hosts.items.length === 0) {
     doc.delete("hosts");
   }
-  const tmpPath = `${path30}.tmp-${process.pid}-${Date.now()}`;
+  const tmpPath = `${path33}.tmp-${process.pid}-${Date.now()}`;
   await writeFile4(tmpPath, doc.toString(), { mode: 384 });
-  await rename(tmpPath, path30);
+  await rename(tmpPath, path33);
 }
 function ensureMap(doc, key) {
   const existing = doc.get(key);
@@ -35602,7 +36719,7 @@ var Session = class _Session {
       chatService,
       scheduleService,
       loopService,
-      workflowService,
+      questService,
       checkoutDiffManager,
       github,
       gitlab,
@@ -35649,7 +36766,7 @@ var Session = class _Session {
     this.chatService = chatService;
     this.scheduleService = scheduleService;
     this.loopService = loopService;
-    this.workflowService = workflowService;
+    this.questService = questService;
     this.checkoutDiffManager = checkoutDiffManager;
     this.github = github ?? createGitHubService();
     this.gitlab = gitlab ?? createGitLabService();
@@ -36228,7 +37345,13 @@ var Session = class _Session {
             await this.handleCloseItemsRequest(msg);
             break;
           case "update_agent_request":
-            await this.handleUpdateAgentRequest(msg.agentId, msg.name, msg.labels, msg.requestId);
+            await this.handleUpdateAgentRequest(
+              msg.agentId,
+              msg.name,
+              msg.labels,
+              msg.requestId,
+              msg.internal
+            );
             break;
           case "set_voice_mode":
             await this.handleSetVoiceMode(msg.enabled, msg.agentId, msg.requestId);
@@ -36458,6 +37581,15 @@ var Session = class _Session {
           case "file_delete_request":
             await this.handleFileDeleteRequest(msg);
             break;
+          case "file_explorer_delete_request":
+            await this.handleFileExplorerDeleteRequest(msg);
+            break;
+          case "file_mkdir_request":
+            await this.handleFileMkdirRequest(msg);
+            break;
+          case "file_move_request":
+            await this.handleFileMoveRequest(msg);
+            break;
           case "project_icon_request":
             await this.handleProjectIconRequest(msg);
             break;
@@ -36618,20 +37750,47 @@ var Session = class _Session {
           case "loop/stop":
             await this.handleLoopStopRequest(msg);
             break;
-          case "workflow/run":
-            await this.handleWorkflowRunRequest(msg);
+          case "quest/run":
+            await this.handleQuestRunRequest(msg);
             break;
-          case "workflow/list":
-            await this.handleWorkflowListRequest(msg);
+          case "quest/list":
+            await this.handleQuestListRequest(msg);
             break;
-          case "workflow/inspect":
-            await this.handleWorkflowInspectRequest(msg);
+          case "quest/inspect":
+            await this.handleQuestInspectRequest(msg);
             break;
-          case "workflow/stop":
-            await this.handleWorkflowStopRequest(msg);
+          case "quest/stop":
+            await this.handleQuestStopRequest(msg);
             break;
-          case "agents/list":
-            await this.handleAgentsListRequest(msg);
+          case "roles/list":
+            await this.handleRolesListRequest(msg);
+            break;
+          case "roles/list-scope":
+            await this.handleRolesListScopeRequest(msg);
+            break;
+          case "roles/create":
+            await this.handleRoleCreateRequest(msg);
+            break;
+          case "roles/write-frontmatter":
+            await this.handleRoleWriteFrontmatterRequest(msg);
+            break;
+          case "roles/move":
+            await this.handleRoleMoveRequest(msg);
+            break;
+          case "brands/list-scope":
+            await this.handleBrandsListScopeRequest(msg);
+            break;
+          case "brands/create":
+            await this.handleBrandCreateRequest(msg);
+            break;
+          case "brands/write-frontmatter":
+            await this.handleBrandWriteFrontmatterRequest(msg);
+            break;
+          case "brands/asset-copy":
+            await this.handleBrandAssetCopyRequest(msg);
+            break;
+          case "brands/asset-upload":
+            await this.handleBrandAssetUploadRequest(msg);
             break;
         }
       } catch (error) {
@@ -37063,26 +38222,27 @@ var Session = class _Session {
     }
     await unarchiveAgentState(this.agentStorage, this.agentManager, matched.id);
   }
-  async handleUpdateAgentRequest(agentId, name, labels, requestId) {
+  async handleUpdateAgentRequest(agentId, name, labels, requestId, internal) {
     this.sessionLogger.info(
       {
         agentId,
         requestId,
         hasName: typeof name === "string",
-        labelCount: labels ? Object.keys(labels).length : 0
+        labelCount: labels ? Object.keys(labels).length : 0,
+        internal
       },
       "session: update_agent_request"
     );
     const normalizedName = name?.trim();
     const normalizedLabels = labels && Object.keys(labels).length > 0 ? labels : void 0;
-    if (!normalizedName && !normalizedLabels) {
+    if (!normalizedName && !normalizedLabels && internal === void 0) {
       this.emit({
         type: "update_agent_response",
         payload: {
           requestId,
           agentId,
           accepted: false,
-          error: "Nothing to update (provide name and/or labels)"
+          error: "Nothing to update (provide name, labels, and/or internal)"
         }
       });
       return;
@@ -37090,7 +38250,8 @@ var Session = class _Session {
     try {
       await this.agentManager.updateAgentMetadata(agentId, {
         ...normalizedName ? { title: normalizedName } : {},
-        ...normalizedLabels ? { labels: normalizedLabels } : {}
+        ...normalizedLabels ? { labels: normalizedLabels } : {},
+        ...internal !== void 0 ? { internal } : {}
       });
       this.emit({
         type: "update_agent_response",
@@ -38985,7 +40146,7 @@ var Session = class _Session {
         homeDir: process.env.HOME ?? homedir5(),
         query: query2,
         limit
-      })).map((path30) => ({ path: path30, kind: "directory" }));
+      })).map((path33) => ({ path: path33, kind: "directory" }));
       const directories = entries.filter((entry) => entry.kind === "directory").map((entry) => entry.path);
       this.emit({
         type: "directory_suggestions_response",
@@ -39882,6 +41043,104 @@ ${details}`.trim());
       });
     }
   }
+  async handleFileExplorerDeleteRequest(request) {
+    const { cwd: workspaceCwd, path: requestedPath, requestId } = request;
+    const cwd = workspaceCwd.trim();
+    if (!cwd) {
+      this.emit({
+        type: "file_explorer_delete_response",
+        payload: { cwd: workspaceCwd, path: requestedPath, error: "cwd is required", requestId }
+      });
+      return;
+    }
+    try {
+      await deleteEntry({ root: cwd, relativePath: requestedPath });
+      this.emit({
+        type: "file_explorer_delete_response",
+        payload: { cwd, path: requestedPath, error: null, requestId }
+      });
+    } catch (error) {
+      this.sessionLogger.error(
+        { err: error, cwd, path: requestedPath },
+        `Failed to delete entry ${requestedPath} in workspace ${cwd}`
+      );
+      this.emit({
+        type: "file_explorer_delete_response",
+        payload: { cwd, path: requestedPath, error: error?.message ?? "delete failed", requestId }
+      });
+    }
+  }
+  async handleFileMkdirRequest(request) {
+    const { cwd: workspaceCwd, path: requestedPath, requestId } = request;
+    const cwd = workspaceCwd.trim();
+    if (!cwd) {
+      this.emit({
+        type: "file_mkdir_response",
+        payload: { cwd: workspaceCwd, path: requestedPath, error: "cwd is required", requestId }
+      });
+      return;
+    }
+    try {
+      await createDirectory({ root: cwd, relativePath: requestedPath });
+      this.emit({
+        type: "file_mkdir_response",
+        payload: { cwd, path: requestedPath, error: null, requestId }
+      });
+    } catch (error) {
+      this.sessionLogger.error(
+        { err: error, cwd, path: requestedPath },
+        `Failed to create directory ${requestedPath} in workspace ${cwd}`
+      );
+      this.emit({
+        type: "file_mkdir_response",
+        payload: {
+          cwd,
+          path: requestedPath,
+          error: error?.message ?? "mkdir failed",
+          requestId
+        }
+      });
+    }
+  }
+  async handleFileMoveRequest(request) {
+    const { cwd: workspaceCwd, sourcePath, destinationPath, requestId } = request;
+    const cwd = workspaceCwd.trim();
+    if (!cwd) {
+      this.emit({
+        type: "file_move_response",
+        payload: {
+          cwd: workspaceCwd,
+          sourcePath,
+          destinationPath,
+          error: "cwd is required",
+          requestId
+        }
+      });
+      return;
+    }
+    try {
+      await moveEntry({ root: cwd, sourcePath, destinationPath });
+      this.emit({
+        type: "file_move_response",
+        payload: { cwd, sourcePath, destinationPath, error: null, requestId }
+      });
+    } catch (error) {
+      this.sessionLogger.error(
+        { err: error, cwd, sourcePath, destinationPath },
+        `Failed to move ${sourcePath} to ${destinationPath} in workspace ${cwd}`
+      );
+      this.emit({
+        type: "file_move_response",
+        payload: {
+          cwd,
+          sourcePath,
+          destinationPath,
+          error: error?.message ?? "move failed",
+          requestId
+        }
+      });
+    }
+  }
   /**
    * Handle project icon request for a given cwd
    */
@@ -42543,17 +43802,17 @@ ${details}`.trim());
       this.emitLoopRpcError(request, error);
     }
   }
-  emitWorkflowRpcError(request, error) {
+  emitQuestRpcError(request, error) {
     const message = error instanceof Error ? error.message : String(error);
     const responseType = `${request.type}/response`;
-    if (responseType === "workflow/list/response") {
+    if (responseType === "quest/list/response") {
       this.emit({
         type: responseType,
-        payload: { requestId: request.requestId, workflows: [], error: message }
+        payload: { requestId: request.requestId, quests: [], error: message }
       });
       return;
     }
-    if (responseType === "agents/list/response") {
+    if (responseType === "roles/list/response") {
       this.emit({
         type: responseType,
         payload: { requestId: request.requestId, roles: [], error: message }
@@ -42562,12 +43821,12 @@ ${details}`.trim());
     }
     this.emit({
       type: responseType,
-      payload: { requestId: request.requestId, workflow: null, error: message }
+      payload: { requestId: request.requestId, quest: null, error: message }
     });
   }
-  async handleWorkflowRunRequest(request) {
+  async handleQuestRunRequest(request) {
     try {
-      const workflow = await this.workflowService.run({
+      const quest = await this.questService.run({
         kind: request.kind,
         cwd: request.cwd,
         prompt: request.prompt,
@@ -42578,16 +43837,16 @@ ${details}`.trim());
         summarizerEnabled: request.summarizerEnabled
       });
       this.emit({
-        type: "workflow/run/response",
-        payload: { requestId: request.requestId, workflow, error: null }
+        type: "quest/run/response",
+        payload: { requestId: request.requestId, quest, error: null }
       });
     } catch (error) {
-      this.emitWorkflowRpcError(request, error);
+      this.emitQuestRpcError(request, error);
     }
   }
-  async handleWorkflowListRequest(request) {
+  async handleQuestListRequest(request) {
     try {
-      const workflows = this.workflowService.list().map((w) => ({
+      const quests = this.questService.list().map((w) => ({
         id: w.id,
         kind: w.kind,
         status: w.status,
@@ -42597,44 +43856,247 @@ ${details}`.trim());
         updatedAt: w.updatedAt
       }));
       this.emit({
-        type: "workflow/list/response",
-        payload: { requestId: request.requestId, workflows, error: null }
+        type: "quest/list/response",
+        payload: { requestId: request.requestId, quests, error: null }
       });
     } catch (error) {
-      this.emitWorkflowRpcError(request, error);
+      this.emitQuestRpcError(request, error);
     }
   }
-  async handleWorkflowInspectRequest(request) {
+  async handleQuestInspectRequest(request) {
     try {
-      const workflow = this.workflowService.inspect(request.id);
+      const quest = this.questService.inspect(request.id);
       this.emit({
-        type: "workflow/inspect/response",
-        payload: { requestId: request.requestId, workflow, error: null }
+        type: "quest/inspect/response",
+        payload: { requestId: request.requestId, quest, error: null }
       });
     } catch (error) {
-      this.emitWorkflowRpcError(request, error);
+      this.emitQuestRpcError(request, error);
     }
   }
-  async handleWorkflowStopRequest(request) {
+  async handleQuestStopRequest(request) {
     try {
-      const workflow = await this.workflowService.stop(request.id);
+      const quest = await this.questService.stop(request.id);
       this.emit({
-        type: "workflow/stop/response",
-        payload: { requestId: request.requestId, workflow, error: null }
+        type: "quest/stop/response",
+        payload: { requestId: request.requestId, quest, error: null }
       });
     } catch (error) {
-      this.emitWorkflowRpcError(request, error);
+      this.emitQuestRpcError(request, error);
     }
   }
-  async handleAgentsListRequest(request) {
+  async handleRolesListRequest(request) {
     try {
-      const roles = await listAgentRoles({ workspaceRoot: request.workspaceRoot });
+      const roles = await listRoles({ workspaceRoot: request.workspaceRoot });
       this.emit({
-        type: "agents/list/response",
+        type: "roles/list/response",
         payload: { requestId: request.requestId, roles, error: null }
       });
     } catch (error) {
-      this.emitWorkflowRpcError(request, error);
+      this.emitQuestRpcError(request, error);
+    }
+  }
+  async handleRolesListScopeRequest(request) {
+    const { scope, workspaceRoot, requestId } = request;
+    try {
+      const roles = await listRoles({
+        scope,
+        ...workspaceRoot ? { workspaceRoot: expandTilde(workspaceRoot) } : {}
+      });
+      this.emit({
+        type: "roles/list-scope/response",
+        payload: { requestId, roles, error: null }
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.sessionLogger.error({ err: error, scope }, "Failed to list roles by scope");
+      this.emit({
+        type: "roles/list-scope/response",
+        payload: { requestId, roles: [], error: message }
+      });
+    }
+  }
+  async handleRoleCreateRequest(request) {
+    const { scope, name, category, workspaceRoot, requestId } = request;
+    try {
+      const result = await createRole({
+        scope,
+        name,
+        ...category ? { category } : {},
+        ...workspaceRoot ? { workspaceRoot: expandTilde(workspaceRoot) } : {}
+      });
+      this.emit({
+        type: "roles/create/response",
+        payload: { requestId, path: result.path, error: null }
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.sessionLogger.error({ err: error, scope, name }, "Failed to create role");
+      this.emit({
+        type: "roles/create/response",
+        payload: { requestId, path: "", error: message }
+      });
+    }
+  }
+  async handleRoleWriteFrontmatterRequest(request) {
+    const { path: rolePath, workspaceRoot, frontmatter, requestId } = request;
+    try {
+      await writeRoleFrontmatter(
+        { path: rolePath, frontmatter },
+        workspaceRoot ? expandTilde(workspaceRoot) : void 0
+      );
+      this.emit({
+        type: "roles/write-frontmatter/response",
+        payload: { requestId, path: rolePath, error: null }
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.sessionLogger.error({ err: error, path: rolePath }, "Failed to write role frontmatter");
+      this.emit({
+        type: "roles/write-frontmatter/response",
+        payload: { requestId, path: rolePath, error: message }
+      });
+    }
+  }
+  async handleRoleMoveRequest(request) {
+    const { path: rolePath, newName, newCategory, workspaceRoot, requestId } = request;
+    try {
+      const result = await moveRole(
+        { path: rolePath, newName, newCategory },
+        workspaceRoot ? expandTilde(workspaceRoot) : void 0
+      );
+      this.emit({
+        type: "roles/move/response",
+        payload: { requestId, path: result.path, error: null }
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.sessionLogger.error({ err: error, path: rolePath }, "Failed to move role");
+      this.emit({
+        type: "roles/move/response",
+        payload: { requestId, path: rolePath, error: message }
+      });
+    }
+  }
+  async handleBrandsListScopeRequest(request) {
+    const { workspaceRoot, requestId } = request;
+    try {
+      const brands = await listBrands({
+        ...workspaceRoot ? { workspaceRoot: expandTilde(workspaceRoot) } : {}
+      });
+      this.emit({
+        type: "brands/list-scope/response",
+        payload: { requestId, brands, error: null }
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.sessionLogger.error({ err: error }, "Failed to list brands");
+      this.emit({
+        type: "brands/list-scope/response",
+        payload: { requestId, brands: [], error: message }
+      });
+    }
+  }
+  async handleBrandCreateRequest(request) {
+    const { name, workspaceRoot, requestId } = request;
+    try {
+      const result = await createBrand({
+        name,
+        ...workspaceRoot ? { workspaceRoot: expandTilde(workspaceRoot) } : {}
+      });
+      this.emit({
+        type: "brands/create/response",
+        payload: { requestId, path: result.path, error: null }
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.sessionLogger.error({ err: error, name }, "Failed to create brand");
+      this.emit({
+        type: "brands/create/response",
+        payload: { requestId, path: "", error: message }
+      });
+    }
+  }
+  async handleBrandWriteFrontmatterRequest(request) {
+    const { path: brandPath, workspaceRoot, frontmatter, requestId } = request;
+    try {
+      await writeBrandFrontmatter(
+        { path: brandPath, frontmatter },
+        workspaceRoot ? expandTilde(workspaceRoot) : void 0
+      );
+      this.emit({
+        type: "brands/write-frontmatter/response",
+        payload: { requestId, path: brandPath, error: null }
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.sessionLogger.error(
+        { err: error, path: brandPath },
+        "Failed to write brand frontmatter"
+      );
+      this.emit({
+        type: "brands/write-frontmatter/response",
+        payload: { requestId, path: brandPath, error: message }
+      });
+    }
+  }
+  async handleBrandAssetCopyRequest(request) {
+    const { workspaceRoot, sourcePath, targetName, requestId } = request;
+    try {
+      const result = await copyBrandAsset({
+        workspaceRoot: expandTilde(workspaceRoot),
+        sourcePath: expandTilde(sourcePath),
+        targetName
+      });
+      this.emit({
+        type: "brands/asset-copy/response",
+        payload: {
+          requestId,
+          relativePath: result.relativePath,
+          absolutePath: result.absolutePath,
+          error: null
+        }
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.sessionLogger.error(
+        { err: error, sourcePath, targetName },
+        "Failed to copy brand asset"
+      );
+      this.emit({
+        type: "brands/asset-copy/response",
+        payload: { requestId, relativePath: "", absolutePath: "", error: message }
+      });
+    }
+  }
+  async handleBrandAssetUploadRequest(request) {
+    const { workspaceRoot, targetName, sourceName, dataBase64, requestId } = request;
+    try {
+      const result = await uploadBrandAsset({
+        workspaceRoot: expandTilde(workspaceRoot),
+        targetName,
+        sourceName,
+        dataBase64
+      });
+      this.emit({
+        type: "brands/asset-upload/response",
+        payload: {
+          requestId,
+          relativePath: result.relativePath,
+          absolutePath: result.absolutePath,
+          error: null
+        }
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.sessionLogger.error(
+        { err: error, targetName, sourceName },
+        "Failed to upload brand asset"
+      );
+      this.emit({
+        type: "brands/asset-upload/response",
+        payload: { requestId, relativePath: "", absolutePath: "", error: message }
+      });
     }
   }
   emitTerminalsChangedSnapshot(input) {
@@ -43974,7 +45436,7 @@ var MissingDaemonVersionError = class extends Error {
   }
 };
 var VoiceAssistantWebSocketServer = class {
-  constructor(server, logger, serverId, agentManager, agentStorage, downloadTokenStore, appostleHome, daemonConfigStore, mcpBaseUrl, wsConfig, speech, terminalManager, dictation, agentProviderRuntimeSettings, providerOverrides, daemonVersion, onLifecycleIntent, projectRegistry, workspaceRegistry, chatService, loopService, workflowService, scheduleService, checkoutDiffManager, scriptRouteStore, scriptRuntimeStore, onBranchChanged, getDaemonTcpPort, getDaemonTcpHost, resolveScriptHealth, workspaceGitService, github, gitlab) {
+  constructor(server, logger, serverId, agentManager, agentStorage, downloadTokenStore, appostleHome, daemonConfigStore, mcpBaseUrl, wsConfig, speech, terminalManager, dictation, agentProviderRuntimeSettings, providerOverrides, daemonVersion, onLifecycleIntent, projectRegistry, workspaceRegistry, chatService, loopService, questService, scheduleService, checkoutDiffManager, scriptRouteStore, scriptRuntimeStore, onBranchChanged, getDaemonTcpPort, getDaemonTcpHost, resolveScriptHealth, workspaceGitService, github, gitlab) {
     this.pendingConnections = /* @__PURE__ */ new Map();
     this.sessions = /* @__PURE__ */ new Map();
     this.externalSessionsByKey = /* @__PURE__ */ new Map();
@@ -44029,10 +45491,10 @@ var VoiceAssistantWebSocketServer = class {
       throw new Error("VoiceAssistantWebSocketServer requires a loop service.");
     }
     this.loopService = loopService;
-    if (!workflowService) {
-      throw new Error("VoiceAssistantWebSocketServer requires a workflow service.");
+    if (!questService) {
+      throw new Error("VoiceAssistantWebSocketServer requires a quest service.");
     }
-    this.workflowService = workflowService;
+    this.questService = questService;
     if (!scheduleService) {
       throw new Error("VoiceAssistantWebSocketServer requires a schedule service.");
     }
@@ -44333,7 +45795,7 @@ var VoiceAssistantWebSocketServer = class {
       workspaceRegistry: this.workspaceRegistry,
       chatService: this.chatService,
       loopService: this.loopService,
-      workflowService: this.workflowService,
+      questService: this.questService,
       scheduleService: this.scheduleService,
       checkoutDiffManager: this.checkoutDiffManager,
       github: this.github,
@@ -45153,7 +46615,7 @@ import { join as join12 } from "node:path";
 // ../server/src/server/speech/providers/local/sherpa/model-downloader.ts
 import { createWriteStream } from "node:fs";
 import { mkdir as mkdir5, rename as rename2, rm as rm2, stat as stat5 } from "node:fs/promises";
-import path17 from "node:path";
+import path18 from "node:path";
 import { Readable as Readable2 } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { spawn as spawn7 } from "node:child_process";
@@ -45289,11 +46751,11 @@ function getSherpaOnnxModelSpec(id) {
 // ../server/src/server/speech/providers/local/sherpa/model-downloader.ts
 function getSherpaOnnxModelDir(modelsDir, modelId) {
   const spec = getSherpaOnnxModelSpec(modelId);
-  return path17.join(modelsDir, spec.extractedDir);
+  return path18.join(modelsDir, spec.extractedDir);
 }
 async function hasRequiredFiles(modelDir, requiredFiles) {
   for (const rel of requiredFiles) {
-    const abs = path17.join(modelDir, rel);
+    const abs = path18.join(modelDir, rel);
     try {
       const s = await stat5(abs);
       if (s.isDirectory()) {
@@ -45319,7 +46781,7 @@ async function downloadToFile(options) {
     throw new Error(`Failed to download ${url}: missing response body`);
   }
   const tmpPath = `${outputPath}.tmp-${Date.now()}`;
-  await mkdir5(path17.dirname(outputPath), { recursive: true });
+  await mkdir5(path18.dirname(outputPath), { recursive: true });
   const nodeStream = Readable2.fromWeb(res.body);
   try {
     await pipeline(nodeStream, createWriteStream(tmpPath));
@@ -45356,16 +46818,16 @@ async function ensureSherpaOnnxModel(options) {
     modelId: options.modelId
   });
   const spec = getSherpaOnnxModelSpec(options.modelId);
-  const modelDir = path17.join(options.modelsDir, spec.extractedDir);
+  const modelDir = path18.join(options.modelsDir, spec.extractedDir);
   if (await hasRequiredFiles(modelDir, spec.requiredFiles)) {
     return modelDir;
   }
   logger.info({ modelsDir: options.modelsDir }, "Starting model download");
   try {
     if (spec.archiveUrl) {
-      const downloadsDir = path17.join(options.modelsDir, ".downloads");
-      const archiveFilename = path17.basename(new URL(spec.archiveUrl).pathname);
-      const archivePath = path17.join(downloadsDir, archiveFilename);
+      const downloadsDir = path18.join(options.modelsDir, ".downloads");
+      const archiveFilename = path18.basename(new URL(spec.archiveUrl).pathname);
+      const archivePath = path18.join(downloadsDir, archiveFilename);
       if (!await isNonEmptyFile(archivePath)) {
         await downloadToFile({
           url: spec.archiveUrl,
@@ -45410,7 +46872,7 @@ async function ensureSherpaOnnxModel(options) {
     if (spec.downloadFiles && spec.downloadFiles.length > 0) {
       await mkdir5(modelDir, { recursive: true });
       for (const file of spec.downloadFiles) {
-        const dst = path17.join(modelDir, file.relPath);
+        const dst = path18.join(modelDir, file.relPath);
         if (await isNonEmptyFile(dst)) {
           continue;
         }
@@ -45473,13 +46935,13 @@ import { existsSync as existsSync13 } from "node:fs";
 
 // ../server/src/server/speech/providers/local/sherpa/sherpa-onnx-node-loader.ts
 import { createRequire as createRequire4 } from "node:module";
-import path19 from "node:path";
+import path20 from "node:path";
 import { existsSync as existsSync12 } from "node:fs";
 import { spawnSync } from "node:child_process";
 
 // ../server/src/server/speech/providers/local/sherpa/sherpa-runtime-env.ts
 import { createRequire as createRequire3 } from "node:module";
-import path18 from "node:path";
+import path19 from "node:path";
 function sherpaPlatformArch(platform = process.platform, arch = process.arch) {
   const normalizedPlatform = platform === "win32" ? "win" : platform;
   return `${normalizedPlatform}-${arch}`;
@@ -45500,11 +46962,11 @@ function sherpaLoaderEnvKey(platform = process.platform) {
   return null;
 }
 function prependEnvPath(existing, value) {
-  const parts = (existing ?? "").split(path18.delimiter).filter(Boolean);
+  const parts = (existing ?? "").split(path19.delimiter).filter(Boolean);
   if (parts.includes(value)) {
-    return parts.join(path18.delimiter);
+    return parts.join(path19.delimiter);
   }
-  return [value, ...parts].join(path18.delimiter);
+  return [value, ...parts].join(path19.delimiter);
 }
 function resolveSherpaLoaderEnv(platform = process.platform, arch = process.arch) {
   const key = sherpaLoaderEnvKey(platform);
@@ -45517,7 +46979,7 @@ function resolveSherpaLoaderEnv(platform = process.platform, arch = process.arch
     const pkgJson = require4.resolve(`${packageName}/package.json`);
     return {
       key,
-      libDir: path18.dirname(pkgJson),
+      libDir: path19.dirname(pkgJson),
       packageName
     };
   } catch {
@@ -45626,7 +47088,7 @@ function loadSherpaOnnxNode() {
   const platformPkgDir = resolvedEnv?.libDir ?? null;
   if (platformPkgDir) {
     applySherpaLoaderEnv(process.env);
-    const addonPath = path19.join(platformPkgDir, "sherpa-onnx.node");
+    const addonPath = path20.join(platformPkgDir, "sherpa-onnx.node");
     if (existsSync12(addonPath)) {
       const byPath = loadWithRequire(require4, addonPath, attempts);
       if (byPath) {
@@ -46398,7 +47860,7 @@ var SherpaOnnxTTS = class {
 
 // ../server/src/server/speech/providers/local/sherpa/silero-vad-provider.ts
 import { copyFile, mkdir as mkdir6, stat as stat6 } from "node:fs/promises";
-import path20 from "node:path";
+import path21 from "node:path";
 
 // ../server/src/server/speech/providers/local/sherpa/silero-vad-session.ts
 import { EventEmitter as EventEmitter6 } from "node:events";
@@ -46590,8 +48052,8 @@ var SherpaSileroVadSession = class extends EventEmitter6 {
 var SILERO_VAD_DIR = "silero-vad";
 var SILERO_VAD_FILE = "silero_vad.onnx";
 async function ensureSileroVadModel(modelsDir, logger) {
-  const destDir = path20.join(modelsDir, SILERO_VAD_DIR);
-  const destPath = path20.join(destDir, SILERO_VAD_FILE);
+  const destDir = path21.join(modelsDir, SILERO_VAD_DIR);
+  const destPath = path21.join(destDir, SILERO_VAD_FILE);
   try {
     const s = await stat6(destPath);
     if (s.isFile() && s.size > 0) return destPath;
@@ -47245,7 +48707,7 @@ var OpenAISTT = class {
       const supportsLogprobs = modelToUse === "gpt-4o-transcribe" || modelToUse === "gpt-4o-mini-transcribe";
       const includeLogprobs = ["logprobs"];
       const response = await this.openaiClient.audio.transcriptions.create({
-        file: await import("fs").then((fs13) => fs13.createReadStream(tempFilePath)),
+        file: await import("fs").then((fs14) => fs14.createReadStream(tempFilePath)),
         language,
         model: modelToUse,
         ...supportsLogprobs ? { include: includeLogprobs } : {},
@@ -49213,6 +50675,11 @@ var AgentManager = class {
       if (updates.labels) {
         await this.setLabels(agentId, updates.labels);
       }
+      if (updates.internal !== void 0) {
+        liveAgent.internal = updates.internal;
+        await this.persistSnapshot(liveAgent, { internal: updates.internal });
+        this.dispatch({ type: "agent_state", agent: { ...liveAgent } });
+      }
       return;
     }
     const registry = this.requireRegistry();
@@ -50649,8 +52116,8 @@ var AgentManager = class {
 
 // ../server/src/server/agent/agent-storage.ts
 import { randomUUID as randomUUID11 } from "node:crypto";
-import { promises as fs10 } from "node:fs";
-import path21 from "node:path";
+import { promises as fs11 } from "node:fs";
+import path22 from "node:path";
 import { z as z37 } from "zod";
 var SERIALIZABLE_CONFIG_SCHEMA = z37.object({
   title: z37.string().nullable().optional(),
@@ -50737,12 +52204,12 @@ var AgentStorage = class {
       }
       const nextPath = this.buildRecordPath(record);
       const previousPath = this.pathById.get(agentId);
-      await fs10.mkdir(path21.dirname(nextPath), { recursive: true });
+      await fs11.mkdir(path22.dirname(nextPath), { recursive: true });
       await writeFileAtomically(nextPath, JSON.stringify(record, null, 2));
       this.addIndexedPath(agentId, nextPath);
       if (previousPath && previousPath !== nextPath) {
         try {
-          await fs10.unlink(previousPath);
+          await fs11.unlink(previousPath);
         } catch {
         }
         this.removeIndexedPath(agentId, previousPath);
@@ -50770,7 +52237,7 @@ var AgentStorage = class {
     const paths = Array.from(this.pathsById.get(agentId) ?? []);
     for (const filePath of paths) {
       try {
-        await fs10.unlink(filePath);
+        await fs11.unlink(filePath);
       } catch (error) {
         const code = error.code;
         if (code && code !== "ENOENT") {
@@ -50844,7 +52311,7 @@ var AgentStorage = class {
     const records = [];
     let entries = [];
     try {
-      entries = await fs10.readdir(this.baseDir, { withFileTypes: true });
+      entries = await fs11.readdir(this.baseDir, { withFileTypes: true });
     } catch (error) {
       if (error.code === "ENOENT") {
         return [];
@@ -50853,7 +52320,7 @@ var AgentStorage = class {
     }
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".json")) {
-        const rootPath = path21.join(this.baseDir, entry.name);
+        const rootPath = path22.join(this.baseDir, entry.name);
         const rootRecord = await this.readRecordFile(rootPath);
         if (!rootRecord) {
           continue;
@@ -50867,10 +52334,10 @@ var AgentStorage = class {
       if (!entry.isDirectory()) {
         continue;
       }
-      const projectDir = path21.join(this.baseDir, entry.name);
+      const projectDir = path22.join(this.baseDir, entry.name);
       let files = [];
       try {
-        files = await fs10.readdir(projectDir, { withFileTypes: true });
+        files = await fs11.readdir(projectDir, { withFileTypes: true });
       } catch {
         continue;
       }
@@ -50878,7 +52345,7 @@ var AgentStorage = class {
         if (!file.isFile() || !file.name.endsWith(".json")) {
           continue;
         }
-        const filePath = path21.join(projectDir, file.name);
+        const filePath = path22.join(projectDir, file.name);
         const record = await this.readRecordFile(filePath);
         if (!record) {
           continue;
@@ -50893,7 +52360,7 @@ var AgentStorage = class {
   }
   async readRecordFile(filePath) {
     try {
-      const content = await fs10.readFile(filePath, "utf8");
+      const content = await fs11.readFile(filePath, "utf8");
       const parsed = JSON.parse(content);
       return parseStoredAgentRecord(parsed);
     } catch (error) {
@@ -50903,7 +52370,7 @@ var AgentStorage = class {
   }
   buildRecordPath(record) {
     const projectDir = projectDirNameFromCwd(record.cwd);
-    return path21.join(this.baseDir, projectDir, `${record.id}.json`);
+    return path22.join(this.baseDir, projectDir, `${record.id}.json`);
   }
   addIndexedPath(agentId, filePath) {
     const paths = this.pathsById.get(agentId) ?? /* @__PURE__ */ new Set();
@@ -50925,7 +52392,7 @@ var AgentStorage = class {
   }
 };
 function projectDirNameFromCwd(cwd) {
-  const { root } = path21.win32.parse(cwd);
+  const { root } = path22.win32.parse(cwd);
   const withoutRoot = cwd.slice(root.length).replace(/[\\/]+$/, "");
   const sanitizedRoot = root.replace(/[:\\/]+/g, "-").replace(/^-+|-+$/g, "");
   const prefix = sanitizedRoot ? sanitizedRoot + "-" : "";
@@ -50935,10 +52402,10 @@ function projectDirNameFromCwd(cwd) {
   return prefix + withoutRoot.replace(/[\\/]+/g, "-");
 }
 async function writeFileAtomically(targetPath, payload) {
-  const directory = path21.dirname(targetPath);
-  const tempPath = path21.join(directory, `.agent.tmp-${process.pid}-${Date.now()}-${randomUUID11()}`);
-  await fs10.writeFile(tempPath, payload, "utf8");
-  await fs10.rename(tempPath, targetPath);
+  const directory = path22.dirname(targetPath);
+  const tempPath = path22.join(directory, `.agent.tmp-${process.pid}-${Date.now()}-${randomUUID11()}`);
+  await fs11.writeFile(tempPath, payload, "utf8");
+  await fs11.rename(tempPath, targetPath);
 }
 
 // ../server/src/server/agent/mcp-server.ts
@@ -52444,7 +53911,7 @@ async function createMcpWorktree(options) {
 }
 
 // ../server/src/server/workspace-registry-bootstrap.ts
-import path22 from "node:path";
+import path23 from "node:path";
 function minIsoDate(left, right) {
   if (!left) {
     return right;
@@ -52541,8 +54008,8 @@ async function bootstrapWorkspaceRegistries(options) {
   }
   options.logger.info(
     {
-      projectsFile: path22.join(options.appostleHome, "projects", "projects.json"),
-      workspacesFile: path22.join(options.appostleHome, "projects", "workspaces.json"),
+      projectsFile: path23.join(options.appostleHome, "projects", "projects.json"),
+      workspacesFile: path23.join(options.appostleHome, "projects", "workspaces.json"),
       materializedProjects: projectRanges.size,
       materializedWorkspaces: recordsByWorkspaceId.size
     },
@@ -52738,8 +54205,8 @@ var CheckoutDiffManager = class {
 
 // ../server/src/server/loop-service.ts
 import { randomUUID as randomUUID12 } from "node:crypto";
-import { promises as fs11 } from "node:fs";
-import path23 from "node:path";
+import { promises as fs12 } from "node:fs";
+import path24 from "node:path";
 import { z as z39 } from "zod";
 var LOOP_ID_LENGTH = 8;
 var DEFAULT_LOOP_PROVIDER = "claude";
@@ -52945,7 +54412,7 @@ var LoopService = class {
     this.loops = /* @__PURE__ */ new Map();
     this.persistQueue = Promise.resolve();
     this.running = /* @__PURE__ */ new Map();
-    this.storePath = path23.join(options.appostleHome, "loops", "loops.json");
+    this.storePath = path24.join(options.appostleHome, "loops", "loops.json");
     this.logger = options.logger.child({ module: "loop-service" });
   }
   async initialize() {
@@ -52954,7 +54421,7 @@ var LoopService = class {
     }
     this.loops.clear();
     try {
-      const raw = await fs11.readFile(this.storePath, "utf8");
+      const raw = await fs12.readFile(this.storePath, "utf8");
       const parsed = StoredLoopsSchema.parse(JSON.parse(raw));
       for (const record of parsed) {
         if (record.status === "running") {
@@ -53014,7 +54481,7 @@ var LoopService = class {
       id: createLoopId(),
       name: normalizeName(input.name),
       prompt,
-      cwd: path23.resolve(input.cwd),
+      cwd: path24.resolve(input.cwd),
       provider: input.provider ?? DEFAULT_LOOP_PROVIDER,
       model: normalizePrompt(input.model, "model"),
       workerProvider: input.workerProvider ?? null,
@@ -53462,11 +54929,11 @@ ${output}` : `exit ${result.exitCode}`
   }
   async persist() {
     const nextPersist = this.persistQueue.then(async () => {
-      await fs11.mkdir(path23.dirname(this.storePath), { recursive: true });
+      await fs12.mkdir(path24.dirname(this.storePath), { recursive: true });
       const records = Array.from(this.loops.values()).sort(
         (left, right) => left.createdAt.localeCompare(right.createdAt)
       );
-      await fs11.writeFile(this.storePath, JSON.stringify(records, null, 2), "utf8");
+      await fs12.writeFile(this.storePath, JSON.stringify(records, null, 2), "utf8");
     });
     this.persistQueue = nextPersist.catch(() => {
     });
@@ -54003,25 +55470,25 @@ var ScheduleService = class {
   }
 };
 
-// ../server/src/server/workflow/service.ts
+// ../server/src/server/quest/service.ts
 import { randomUUID as randomUUID14 } from "node:crypto";
 
-// ../server/src/server/workflow/store.ts
-import { promises as fs12 } from "node:fs";
-import path24 from "node:path";
+// ../server/src/server/quest/store.ts
+import { promises as fs13 } from "node:fs";
+import path25 from "node:path";
 import { z as z40 } from "zod";
-var StoredWorkflowsSchema = z40.array(WorkflowRecordSchema);
-var WorkflowStore = class {
+var StoredQuestsSchema = z40.array(QuestRecordSchema);
+var QuestStore = class {
   constructor(options) {
-    this.filePath = path24.join(options.appostleHome, "workflows", "workflows.json");
+    this.filePath = path25.join(options.appostleHome, "quests", "quests.json");
     this.logger = options.logger;
     this.records = /* @__PURE__ */ new Map();
     this.persistQueue = Promise.resolve();
   }
   async initialize() {
     try {
-      const raw = await fs12.readFile(this.filePath, "utf8");
-      const parsed = StoredWorkflowsSchema.parse(JSON.parse(raw));
+      const raw = await fs13.readFile(this.filePath, "utf8");
+      const parsed = StoredQuestsSchema.parse(JSON.parse(raw));
       this.records = new Map(parsed.map((r) => [r.id, r]));
     } catch (err) {
       const code = err && typeof err === "object" && "code" in err ? err.code : null;
@@ -54031,15 +55498,13 @@ var WorkflowStore = class {
       }
       this.logger.warn(
         { err: err instanceof Error ? err.message : String(err) },
-        "workflow-store: failed to read workflows.json \u2014 starting empty"
+        "quest-store: failed to read quests.json \u2014 starting empty"
       );
       this.records = /* @__PURE__ */ new Map();
     }
   }
   list() {
-    return [...this.records.values()].sort(
-      (a, b) => a.createdAt.localeCompare(b.createdAt)
-    );
+    return [...this.records.values()].sort((a, b) => a.createdAt.localeCompare(b.createdAt));
   }
   get(id) {
     return this.records.get(id) ?? null;
@@ -54056,20 +55521,20 @@ var WorkflowStore = class {
   }
   async persist() {
     this.persistQueue = this.persistQueue.then(async () => {
-      await fs12.mkdir(path24.dirname(this.filePath), { recursive: true });
+      await fs13.mkdir(path25.dirname(this.filePath), { recursive: true });
       const payload = JSON.stringify([...this.records.values()], null, 2);
-      await fs12.writeFile(this.filePath, payload, "utf8");
+      await fs13.writeFile(this.filePath, payload, "utf8");
     }).catch((err) => {
       this.logger.error(
         { err: err instanceof Error ? err.message : String(err) },
-        "workflow-store: persist failed"
+        "quest-store: persist failed"
       );
     });
     return this.persistQueue;
   }
 };
 
-// ../server/src/server/workflow/rules.ts
+// ../server/src/server/quest/rules.ts
 var LOOP_RULES = {
   perCardRole: "inherit",
   perCardModel: "inherit",
@@ -54086,28 +55551,65 @@ var RALPH_RULES = {
   summarizerCard: "off",
   cardExpansion: "tool-calls"
 };
+var RUN_RULES = {
+  perCardRole: "free",
+  perCardModel: "free",
+  perCardPrompt: "locked",
+  cardsEditableWhileRunning: false,
+  summarizerCard: "off",
+  cardExpansion: "tool-calls"
+};
+var ORCHESTRATE_RULES = {
+  perCardRole: "free",
+  perCardModel: "free",
+  perCardPrompt: "locked",
+  cardsEditableWhileRunning: false,
+  summarizerCard: "off",
+  cardExpansion: "tool-calls"
+};
 function getRulesForKind(kind) {
   switch (kind) {
     case "loop":
       return { ...LOOP_RULES };
     case "ralph":
       return { ...RALPH_RULES };
+    case "run":
+      return { ...RUN_RULES };
+    case "orchestrate":
+      return { ...ORCHESTRATE_RULES };
   }
 }
 
-// ../server/src/server/workflow/service.ts
-var WORKFLOW_ID_LENGTH = 8;
+// ../server/src/server/quest/service.ts
+var QUEST_ID_LENGTH = 8;
 var DEFAULT_PROVIDER = "claude";
 function nowIso2() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
-function createWorkflowId() {
-  return randomUUID14().replace(/-/g, "").slice(0, WORKFLOW_ID_LENGTH);
+function createQuestId() {
+  return randomUUID14().replace(/-/g, "").slice(0, QUEST_ID_LENGTH);
 }
 function defaultWiring() {
   return { inputs: "user-prompt", outputs: "none" };
 }
 function buildInitialCards(options, rulesAllowOverride) {
+  if (options.kind === "orchestrate") {
+    const overrides2 = options.cards ?? [];
+    return overrides2.map(
+      (override, i) => QuestCardSchema.parse({
+        index: i + 1,
+        role: rulesAllowOverride.role ? override.role ?? null : null,
+        model: rulesAllowOverride.model ? override.model ?? null : null,
+        prompt: rulesAllowOverride.prompt ? override.prompt ?? null : null,
+        wiring: defaultWiring(),
+        status: "queued",
+        agentId: null,
+        startedAt: null,
+        completedAt: null,
+        verify: null
+      })
+    );
+  }
   if (options.termination.type !== "count") {
     return [];
   }
@@ -54117,7 +55619,7 @@ function buildInitialCards(options, rulesAllowOverride) {
   for (let i = 0; i < n; i++) {
     const override = overrides[i] ?? {};
     cards.push(
-      WorkflowCardSchema.parse({
+      QuestCardSchema.parse({
         index: i + 1,
         role: rulesAllowOverride.role ? override.role ?? null : null,
         model: rulesAllowOverride.model ? override.model ?? null : null,
@@ -54140,7 +55642,7 @@ function buildSummarizerCard(options) {
   if (!options.summarizerEnabled) {
     return null;
   }
-  return WorkflowCardSchema.parse({
+  return QuestCardSchema.parse({
     index: 0,
     // sentinel — summarizer is not in the cards array
     role: null,
@@ -54154,14 +55656,14 @@ function buildSummarizerCard(options) {
     verify: null
   });
 }
-var WorkflowService = class {
+var QuestService = class {
   constructor(options) {
     this.options = options;
     this.running = /* @__PURE__ */ new Map();
     this.subscribers = /* @__PURE__ */ new Set();
     this.loaded = false;
-    this.logger = options.logger.child({ module: "workflow-service" });
-    this.store = new WorkflowStore({
+    this.logger = options.logger.child({ module: "quest-service" });
+    this.store = new QuestStore({
       appostleHome: options.appostleHome,
       logger: this.logger
     });
@@ -54179,7 +55681,7 @@ var WorkflowService = class {
   get agentManager() {
     return this.options.agentManager;
   }
-  /** Subscribe to workflow state changes. Returns an unsubscribe function. */
+  /** Subscribe to quest state changes. Returns an unsubscribe function. */
   subscribe(callback) {
     this.subscribers.add(callback);
     return () => {
@@ -54195,7 +55697,7 @@ var WorkflowService = class {
       if (record.status !== "running") {
         continue;
       }
-      const recovered = WorkflowRecordSchema.parse({
+      const recovered = QuestRecordSchema.parse({
         ...record,
         status: "stopped",
         updatedAt: nowIso2(),
@@ -54204,12 +55706,13 @@ var WorkflowService = class {
         cards: record.cards.map(
           (card) => card.status === "running" ? { ...card, status: "stopped", completedAt: nowIso2() } : card
         ),
-        summarizerCard: record.summarizerCard && record.summarizerCard.status === "running" ? { ...record.summarizerCard, status: "stopped", completedAt: nowIso2() } : record.summarizerCard
+        summarizerCard: record.summarizerCard && record.summarizerCard.status === "running" ? { ...record.summarizerCard, status: "stopped", completedAt: nowIso2() } : record.summarizerCard,
+        queenCard: record.queenCard && record.queenCard.status === "running" ? { ...record.queenCard, status: "stopped", completedAt: nowIso2() } : record.queenCard
       });
       await this.store.upsert(recovered);
       this.logger.info(
-        { workflowId: recovered.id },
-        "workflow-service: recovered running workflow \u2192 stopped"
+        { questId: recovered.id },
+        "quest-service: recovered running quest \u2192 stopped"
       );
     }
     this.loaded = true;
@@ -54223,9 +55726,15 @@ var WorkflowService = class {
     if (options.kind === "loop" && options.termination.type !== "count") {
       throw new Error('kind "loop" requires termination.type === "count"');
     }
+    if (options.kind === "run" && options.termination.type !== "count") {
+      throw new Error('kind "run" requires termination.type === "count"');
+    }
     if (options.kind === "ralph" && options.termination.type !== "verify") {
       throw new Error('kind "ralph" requires termination.type === "verify"');
     }
+    if (options.kind === "orchestrate" && options.termination.type !== "orchestrate") {
+      throw new Error('kind "orchestrate" requires termination.type === "orchestrate"');
+    }
     const rules = getRulesForKind(options.kind);
     const overrideAllowed = {
       role: rules.perCardRole !== "locked",
@@ -54233,8 +55742,8 @@ var WorkflowService = class {
       prompt: rules.perCardPrompt !== "locked"
     };
     const createdAt = nowIso2();
-    const record = WorkflowRecordSchema.parse({
-      id: createWorkflowId(),
+    const record = QuestRecordSchema.parse({
+      id: createQuestId(),
       kind: options.kind,
       rules,
       cwd: options.cwd,
@@ -54255,7 +55764,7 @@ var WorkflowService = class {
     this.publish(record);
     const runner = this.runners[options.kind];
     if (!runner) {
-      const failed = WorkflowRecordSchema.parse({
+      const failed = QuestRecordSchema.parse({
         ...record,
         status: "failed",
         updatedAt: nowIso2(),
@@ -54263,21 +55772,18 @@ var WorkflowService = class {
       });
       await this.store.upsert(failed);
       this.publish(failed);
-      throw new Error(`No runner registered for workflow kind "${options.kind}"`);
+      throw new Error(`No runner registered for quest kind "${options.kind}"`);
     }
     const abortController = new AbortController();
     const promise = (async () => {
       try {
         await runner.execute({
-          workflowId: record.id,
+          questId: record.id,
           signal: abortController.signal,
           service: this
         });
       } catch (err) {
-        this.logger.error(
-          { err, workflowId: record.id },
-          "workflow-service: runner threw"
-        );
+        this.logger.error({ err, questId: record.id }, "quest-service: runner threw");
         const current = this.store.get(record.id);
         if (current && current.status === "running") {
           await this.markStatus(record.id, "failed");
@@ -54298,13 +55804,13 @@ var WorkflowService = class {
   async stop(id) {
     const current = this.store.get(id);
     if (!current) {
-      throw new Error(`Workflow "${id}" not found`);
+      throw new Error(`Quest "${id}" not found`);
     }
     if (current.status !== "running") {
       return current;
     }
     const stopRequestedAt = nowIso2();
-    const updated = WorkflowRecordSchema.parse({
+    const updated = QuestRecordSchema.parse({
       ...current,
       stopRequestedAt,
       updatedAt: stopRequestedAt
@@ -54325,45 +55831,76 @@ var WorkflowService = class {
   // Mutation helpers (used by runners)
   // -------------------------------------------------------------------------
   /** Updates a single card by index (1-based). Throws if not found. */
-  async updateCard(workflowId, cardIndex, patch) {
-    const record = this.store.get(workflowId);
+  async updateCard(questId, cardIndex, patch) {
+    const record = this.store.get(questId);
     if (!record) {
-      throw new Error(`Workflow "${workflowId}" not found`);
+      throw new Error(`Quest "${questId}" not found`);
     }
     const cards = record.cards.map(
-      (card) => card.index === cardIndex ? WorkflowCardSchema.parse({ ...card, ...patch }) : card
+      (card) => card.index === cardIndex ? QuestCardSchema.parse({ ...card, ...patch }) : card
     );
     return this.persistAndPublish(record, { cards });
   }
   /** Append a card (used by ralph runner as iterations execute). */
-  async appendCard(workflowId, card) {
-    const record = this.store.get(workflowId);
+  async appendCard(questId, card) {
+    const record = this.store.get(questId);
     if (!record) {
-      throw new Error(`Workflow "${workflowId}" not found`);
+      throw new Error(`Quest "${questId}" not found`);
     }
-    const cards = [...record.cards, WorkflowCardSchema.parse(card)];
+    const cards = [...record.cards, QuestCardSchema.parse(card)];
     return this.persistAndPublish(record, { cards });
   }
   /** Set the summarizer card (creates or updates). */
-  async updateSummarizer(workflowId, patch) {
-    const record = this.store.get(workflowId);
+  async updateSummarizer(questId, patch) {
+    const record = this.store.get(questId);
     if (!record) {
-      throw new Error(`Workflow "${workflowId}" not found`);
+      throw new Error(`Quest "${questId}" not found`);
     }
     if (!record.summarizerCard) {
-      throw new Error(`Workflow "${workflowId}" has no summarizer card`);
+      throw new Error(`Quest "${questId}" has no summarizer card`);
     }
-    const summarizerCard = WorkflowCardSchema.parse({
+    const summarizerCard = QuestCardSchema.parse({
       ...record.summarizerCard,
       ...patch
     });
     return this.persistAndPublish(record, { summarizerCard });
   }
-  /** Mark the workflow's terminal status. Idempotent — running→stopped is fine. */
-  async markStatus(workflowId, status) {
-    const record = this.store.get(workflowId);
+  /** Set or replace the queen-bee card on an orchestrate quest. */
+  async setQueenCard(questId, card) {
+    const record = this.store.get(questId);
+    if (!record) {
+      throw new Error(`Quest "${questId}" not found`);
+    }
+    return this.persistAndPublish(record, { queenCard: QuestCardSchema.parse(card) });
+  }
+  /** Patch the queen-bee card. Throws if no queen card exists. */
+  async updateQueenCard(questId, patch) {
+    const record = this.store.get(questId);
+    if (!record) {
+      throw new Error(`Quest "${questId}" not found`);
+    }
+    if (!record.queenCard) {
+      throw new Error(`Quest "${questId}" has no queen card`);
+    }
+    const queenCard = QuestCardSchema.parse({
+      ...record.queenCard,
+      ...patch
+    });
+    return this.persistAndPublish(record, { queenCard });
+  }
+  /** Record the hivemind doc absolute path for an orchestrate quest. */
+  async setHivemindPath(questId, hivemindPath) {
+    const record = this.store.get(questId);
+    if (!record) {
+      throw new Error(`Quest "${questId}" not found`);
+    }
+    return this.persistAndPublish(record, { hivemindPath });
+  }
+  /** Mark the quest's terminal status. Idempotent — running→stopped is fine. */
+  async markStatus(questId, status) {
+    const record = this.store.get(questId);
     if (!record) {
-      throw new Error(`Workflow "${workflowId}" not found`);
+      throw new Error(`Quest "${questId}" not found`);
     }
     const completedAt = status === "running" ? null : record.completedAt ?? nowIso2();
     return this.persistAndPublish(record, { status, completedAt });
@@ -54372,7 +55909,7 @@ var WorkflowService = class {
   // Internals
   // -------------------------------------------------------------------------
   async persistAndPublish(record, patch) {
-    const updated = WorkflowRecordSchema.parse({
+    const updated = QuestRecordSchema.parse({
       ...record,
       ...patch,
       updatedAt: nowIso2()
@@ -54388,25 +55925,36 @@ var WorkflowService = class {
       } catch (err) {
         this.logger.warn(
           { err: err instanceof Error ? err.message : String(err) },
-          "workflow-service: subscriber threw"
+          "quest-service: subscriber threw"
         );
       }
     }
   }
 };
 
-// ../server/src/server/workflow/runner-loop.ts
+// ../server/src/server/quest/runner-loop.ts
 function nowIso3() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
-function buildAgentConfig(record, card, titleSuffix) {
+async function buildAgentConfig(record, card, titleSuffix) {
   const modeId = getProviderFullAccessModeId(record.defaultProvider) ?? void 0;
+  let systemPrompt;
+  let allowedTools;
+  if (card.role) {
+    const role = await resolveRole({ roleName: card.role, workspaceRoot: record.cwd });
+    if (role) {
+      if (role.body) systemPrompt = role.body;
+      if (role.allowedTools.length > 0) allowedTools = role.allowedTools;
+    }
+  }
   return {
     provider: record.defaultProvider,
     cwd: record.cwd,
     model: card.model ?? record.defaultModel ?? void 0,
     modeId,
-    title: `workflow ${record.id} ${titleSuffix}`,
+    systemPrompt,
+    allowedTools,
+    title: `quest ${record.id} ${titleSuffix}`,
     internal: true
   };
 }
@@ -54427,21 +55975,21 @@ function resolveFinalTextFromRun(run) {
 }
 var LoopRunner = class {
   constructor(options) {
-    this.logger = options.logger.child({ module: "workflow-runner-loop" });
+    this.logger = options.logger.child({ module: "quest-runner-loop" });
   }
   async execute(args) {
-    const { workflowId, signal, service } = args;
-    const initial = service.getRecord(workflowId);
+    const { questId, signal, service } = args;
+    const initial = service.getRecord(questId);
     if (!initial) {
-      throw new Error(`Workflow "${workflowId}" not found`);
+      throw new Error(`Quest "${questId}" not found`);
     }
-    if (initial.kind !== "loop") {
-      throw new Error(`LoopRunner cannot execute workflow of kind "${initial.kind}"`);
+    if (initial.kind !== "loop" && initial.kind !== "run") {
+      throw new Error(`LoopRunner cannot execute quest of kind "${initial.kind}"`);
     }
     const completedFinalTexts = [];
     let aborted = false;
     for (const card of initial.cards) {
-      const current = service.getRecord(workflowId);
+      const current = service.getRecord(questId);
       if (!current || current.status !== "running") {
         aborted = true;
         break;
@@ -54467,32 +56015,32 @@ var LoopRunner = class {
         break;
       }
       if (result.status === "failed") {
-        await service.markStatus(workflowId, "failed");
+        await service.markStatus(questId, "failed");
         return;
       }
     }
     if (aborted) {
-      const current = service.getRecord(workflowId);
+      const current = service.getRecord(questId);
       if (current) {
         for (const card of current.cards) {
           if (card.status === "queued" || card.status === "running") {
-            await service.updateCard(workflowId, card.index, {
+            await service.updateCard(questId, card.index, {
               status: "stopped",
               completedAt: nowIso3()
             });
           }
         }
         if (current.summarizerCard && current.summarizerCard.status === "queued") {
-          await service.updateSummarizer(workflowId, {
+          await service.updateSummarizer(questId, {
             status: "stopped",
             completedAt: nowIso3()
           });
         }
       }
-      await service.markStatus(workflowId, "stopped");
+      await service.markStatus(questId, "stopped");
       return;
     }
-    const beforeSummary = service.getRecord(workflowId);
+    const beforeSummary = service.getRecord(questId);
     if (beforeSummary?.summarizerCard) {
       const summaryPrompt = buildSummaryPrompt(initial.prompt, completedFinalTexts);
       const summaryResult = await this.runSummarizer({
@@ -54502,21 +56050,21 @@ var LoopRunner = class {
         signal
       });
       if (summaryResult.status === "failed") {
-        await service.markStatus(workflowId, "failed");
+        await service.markStatus(questId, "failed");
         return;
       }
       if (summaryResult.status === "stopped") {
-        await service.markStatus(workflowId, "stopped");
+        await service.markStatus(questId, "stopped");
         return;
       }
     }
-    await service.markStatus(workflowId, "succeeded");
+    await service.markStatus(questId, "succeeded");
   }
   async runCard(args) {
     const { record, card, prompt, titleSuffix, service, signal } = args;
     const startedAt = nowIso3();
     const agent = await service.agentManager.createAgent(
-      buildAgentConfig(record, card, titleSuffix)
+      await buildAgentConfig(record, card, titleSuffix)
     );
     await service.updateCard(record.id, card.index, {
       status: "running",
@@ -54545,7 +56093,7 @@ var LoopRunner = class {
       return { status: "succeeded", finalText };
     } catch (err) {
       this.logger.error(
-        { err, workflowId: record.id, cardIndex: card.index },
+        { err, questId: record.id, cardIndex: card.index },
         "loop-runner: card failed"
       );
       await service.updateCard(record.id, card.index, {
@@ -54569,7 +56117,7 @@ var LoopRunner = class {
     }
     const startedAt = nowIso3();
     const agent = await service.agentManager.createAgent(
-      buildAgentConfig(record, summarizer, "summary")
+      await buildAgentConfig(record, summarizer, "summary")
     );
     await service.updateSummarizer(record.id, {
       status: "running",
@@ -54597,10 +56145,7 @@ var LoopRunner = class {
       });
       return { status: "succeeded", finalText };
     } catch (err) {
-      this.logger.error(
-        { err, workflowId: record.id },
-        "loop-runner: summarizer failed"
-      );
+      this.logger.error({ err, questId: record.id }, "loop-runner: summarizer failed");
       await service.updateSummarizer(record.id, {
         status: "failed",
         completedAt: nowIso3()
@@ -54620,23 +56165,555 @@ function buildSummaryPrompt(taskPrompt, priorOutputs) {
 
 ${text || "(no output)"}`).join("\n\n");
   return [
-    "You are a summarizer. The original task was:",
+    "Summarise in 2 plain english paragraphs that are easily understandable for the user and not technical giberish.",
     "",
-    taskPrompt,
+    "Original task:",
     "",
-    "Below are the outputs of each preceding card in the workflow.",
-    "Produce a concise summary of what was accomplished and any open issues.",
+    taskPrompt,
     "",
     sections
   ].join("\n");
 }
 
-// ../server/src/server/workflow/runner-ralph.ts
+// ../server/src/server/quest/runner-orchestrator.ts
+import { appendFile, mkdir as mkdir8, readFile as readFile5, writeFile as writeFile7 } 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") {
+        return {
+          ok: false,
+          reason: `wave ${i + 1}: every dispatch needs string \`role\` and string \`prompt\``
+        };
+      }
+      const role = d.role.trim();
+      const prompt = d.prompt;
+      if (!knownRoles.has(role)) {
+        return { ok: false, reason: `wave ${i + 1}: unknown role \`${role}\`` };
+      }
+      if (seenRoles.has(role)) {
+        return {
+          ok: false,
+          reason: `wave ${i + 1}: role \`${role}\` was already scheduled in an earlier wave`
+        };
+      }
+      seenRoles.add(role);
+      dispatches.push({ role, prompt });
+    }
+    waves.push({ dispatches });
+  }
+  return { ok: true, plan: waves };
+}
+function resolveFinalTextFromRun2(run) {
+  if (run.finalText.trim()) {
+    return run.finalText;
+  }
+  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 "";
+}
+function resolveHivemindPaths(cwd, questId) {
+  const dir = path26.join(cwd, ".hiveminds", "orchestrator");
+  return {
+    dir,
+    filePath: path26.join(dir, `orchestrator-${questId}.md`)
+  };
+}
+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");
+}
+async function appendHivemind(filePath, chunk) {
+  await appendFile(filePath, chunk, "utf8");
+}
+async function readHivemind(filePath) {
+  try {
+    return await readFile5(filePath, "utf8");
+  } catch {
+    return "";
+  }
+}
+function buildQueenAgentConfig(args) {
+  const modeId = getProviderFullAccessModeId(args.record.defaultProvider) ?? void 0;
+  return {
+    provider: args.record.defaultProvider,
+    cwd: args.record.cwd,
+    model: args.record.defaultModel ?? void 0,
+    modeId,
+    systemPrompt: args.systemPrompt,
+    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" });
+  }
+  async execute(args) {
+    const { questId, signal, service } = args;
+    const initial = service.getRecord(questId);
+    if (!initial) {
+      throw new Error(`Quest "${questId}" not found`);
+    }
+    if (initial.kind !== "orchestrate") {
+      throw new Error(`OrchestratorRunner cannot execute quest of kind "${initial.kind}"`);
+    }
+    if (initial.termination.type !== "orchestrate") {
+      throw new Error('OrchestratorRunner expects termination.type === "orchestrate"');
+    }
+    if (initial.cards.length === 0) {
+      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);
+      }
+    }
+    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 })
+    );
+    const queenCard = QuestCardSchema.parse({
+      index: 0,
+      role: "queen",
+      model: initial.defaultModel,
+      prompt: null,
+      wiring: { inputs: "user-prompt", outputs: "next-card" },
+      status: "running",
+      agentId: queenAgent.id,
+      startedAt: queenStartedAt,
+      completedAt: null,
+      verify: null
+    });
+    await service.setQueenCard(questId, queenCard);
+    const onAbort = () => {
+      void service.agentManager.cancelAgentRun(queenAgent.id).catch(() => {
+      });
+    };
+    signal.addEventListener("abort", onAbort);
+    let plan;
+    try {
+      const queenRun = await service.agentManager.runAgent(queenAgent.id, initial.prompt);
+      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;
+    } 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;
+    } 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 };
+      }
+      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);
+    }
+  }
+};
+
+// ../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 path27 from "node:path";
 var execFileAsync3 = promisify4(execFile3);
 var MAX_VERIFY_OUTPUT_BYTES2 = 64 * 1024;
-function nowIso4() {
+function nowIso5() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
 function platformShell2() {
@@ -54672,12 +56749,82 @@ function buildWorkerConfig(record, iteration) {
     cwd: record.cwd,
     model: record.defaultModel ?? void 0,
     modeId,
-    title: `workflow ${record.id} ralph #${iteration}`,
+    title: `quest ${record.id} ralph #${iteration}`,
     internal: true
   };
 }
+function buildRalphIterationPrompt(args) {
+  const checks = args.verifyChecks.length > 0 ? args.verifyChecks.map((c) => `- ${c}`).join("\n") : "- (none)";
+  return [
+    args.basePrompt,
+    "",
+    "Ralph loop completion contract (strict):",
+    `- You may only declare completion when all verify checks pass:`,
+    checks,
+    `- When complete, output this exact token verbatim: ${args.completionPromise}`,
+    "- If not complete yet, continue making changes and do not output the token."
+  ].join("\n");
+}
+function resolveFinalTextFromRun3(run) {
+  if (run.finalText.trim()) {
+    return run.finalText;
+  }
+  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 "";
+}
+function runContainsPromise(run, completionPromise) {
+  const finalText = resolveFinalTextFromRun3(run);
+  return finalText.includes(completionPromise);
+}
+function resolveRalphStatePaths(cwd) {
+  const dir = path27.join(cwd, ".hiveminds", "ralph loop");
+  return {
+    dir,
+    logPath: ""
+  };
+}
+async function initializeRalphState(args) {
+  const base = resolveRalphStatePaths(args.record.cwd);
+  const paths = {
+    dir: base.dir,
+    logPath: path27.join(base.dir, `ralphloop_${args.record.id}.md`)
+  };
+  await mkdir9(paths.dir, { recursive: true });
+  await writeFile8(
+    paths.logPath,
+    [
+      `# Ralph Loop ${args.record.id}`,
+      "",
+      `- createdAt: ${args.record.createdAt}`,
+      `- prompt: ${args.record.prompt}`,
+      `- completionPromise: ${args.completionPromise}`,
+      `- maxIterations: ${args.maxIterations}`,
+      "",
+      "## Verify Checks",
+      ...args.verifyChecks.length > 0 ? args.verifyChecks.map((check) => `- ${check}`) : ["- (none)"],
+      "",
+      "## Progress"
+    ].join("\n") + "\n",
+    "utf8"
+  );
+  await appendFile2(paths.logPath, `- [${nowIso5()}] started
+`, "utf8");
+  return paths;
+}
+async function appendRalphProgress(paths, message) {
+  await appendFile2(paths.logPath, `- [${nowIso5()}] ${message}
+`, "utf8");
+}
 function newCard(index) {
-  return WorkflowCardSchema.parse({
+  return QuestCardSchema.parse({
     index,
     role: null,
     model: null,
@@ -54698,46 +56845,51 @@ function newCard(index) {
 }
 var RalphRunner = class {
   constructor(options) {
-    this.logger = options.logger.child({ module: "workflow-runner-ralph" });
+    this.logger = options.logger.child({ module: "quest-runner-ralph" });
   }
   async execute(args) {
-    const { workflowId, signal, service } = args;
-    const initial = service.getRecord(workflowId);
+    const { questId, signal, service } = args;
+    const initial = service.getRecord(questId);
     if (!initial) {
-      throw new Error(`Workflow "${workflowId}" not found`);
+      throw new Error(`Quest "${questId}" not found`);
     }
     if (initial.kind !== "ralph") {
-      throw new Error(`RalphRunner cannot execute workflow of kind "${initial.kind}"`);
+      throw new Error(`RalphRunner cannot execute quest of kind "${initial.kind}"`);
     }
     if (initial.termination.type !== "verify") {
       throw new Error(`RalphRunner expects termination.type === "verify"`);
     }
-    const { verifyPrompt, verifyChecks, maxIterations } = initial.termination;
+    const { verifyPrompt, verifyChecks, completionPromise, maxIterations } = initial.termination;
+    const statePaths = await initializeRalphState({
+      record: initial,
+      verifyChecks,
+      completionPromise,
+      maxIterations
+    });
     if (verifyPrompt) {
       this.logger.warn(
-        { workflowId },
+        { questId },
         "ralph-runner: verifyPrompt is set but verifier-agent support is not yet implemented in v1 \u2014 relying on verifyChecks only"
       );
     }
     if (verifyChecks.length === 0) {
-      await service.markStatus(workflowId, "failed");
-      throw new Error(
-        "Ralph workflow requires at least one verifyCheck (verifier-agent path is v2)"
-      );
+      await service.markStatus(questId, "failed");
+      throw new Error("Ralph quest requires at least one verifyCheck (verifier-agent path is v2)");
     }
     for (let iteration = 1; iteration <= maxIterations; iteration += 1) {
-      const current = service.getRecord(workflowId);
+      const current = service.getRecord(questId);
       if (!current || current.status !== "running" || signal.aborted) {
-        await service.markStatus(workflowId, "stopped");
+        await service.markStatus(questId, "stopped");
         return;
       }
       const card = newCard(iteration);
-      let recordWithCard = await service.appendCard(workflowId, card);
-      const startedAt = nowIso4();
+      let recordWithCard = await service.appendCard(questId, card);
+      await appendRalphProgress(statePaths, `iteration=${iteration} status=started`);
+      const startedAt = nowIso5();
       const agent = await service.agentManager.createAgent(
         buildWorkerConfig(recordWithCard, iteration)
       );
-      await service.updateCard(workflowId, iteration, {
+      await service.updateCard(questId, iteration, {
         status: "running",
         agentId: agent.id,
         startedAt
@@ -54748,25 +56900,39 @@ var RalphRunner = class {
       };
       signal.addEventListener("abort", onAbort, { once: true });
       let workerOk = false;
+      let workerRun = null;
       try {
-        const run = await service.agentManager.runAgent(agent.id, recordWithCard.prompt);
+        const run = await service.agentManager.runAgent(
+          agent.id,
+          buildRalphIterationPrompt({
+            basePrompt: recordWithCard.prompt,
+            completionPromise,
+            verifyChecks
+          })
+        );
         if (run.canceled) {
-          await service.updateCard(workflowId, iteration, {
+          await appendRalphProgress(
+            statePaths,
+            `iteration=${iteration} status=stopped reason=canceled`
+          );
+          await service.updateCard(questId, iteration, {
             status: "stopped",
-            completedAt: nowIso4()
+            completedAt: nowIso5()
           });
-          await service.markStatus(workflowId, "stopped");
+          await service.markStatus(questId, "stopped");
           return;
         }
+        workerRun = run;
         workerOk = true;
       } catch (err) {
-        this.logger.error(
-          { err, workflowId, iteration },
-          "ralph-runner: worker errored"
+        await appendRalphProgress(
+          statePaths,
+          `iteration=${iteration} status=failed reason=worker_error`
         );
-        await service.updateCard(workflowId, iteration, {
+        this.logger.error({ err, questId, iteration }, "ralph-runner: worker errored");
+        await service.updateCard(questId, iteration, {
           status: "failed",
-          completedAt: nowIso4()
+          completedAt: nowIso5()
         });
       } finally {
         signal.removeEventListener("abort", onAbort);
@@ -54778,12 +56944,30 @@ var RalphRunner = class {
       if (!workerOk) {
         continue;
       }
-      const verifyStartedAt = nowIso4();
+      if (!workerRun || !runContainsPromise(workerRun, completionPromise)) {
+        await appendRalphProgress(
+          statePaths,
+          `iteration=${iteration} status=failed reason=missing_completion_promise`
+        );
+        await service.updateCard(questId, iteration, {
+          status: "failed",
+          completedAt: nowIso5(),
+          verify: {
+            verifierAgentId: null,
+            passed: false,
+            reason: `missing completion promise: ${completionPromise}`,
+            startedAt: null,
+            completedAt: nowIso5()
+          }
+        });
+        continue;
+      }
+      const verifyStartedAt = nowIso5();
       let allPassed = true;
       const reasons = [];
       for (const command of verifyChecks) {
         if (signal.aborted) {
-          await service.markStatus(workflowId, "stopped");
+          await service.markStatus(questId, "stopped");
           return;
         }
         const outcome = await runVerifyCheck2({
@@ -54796,10 +56980,10 @@ var RalphRunner = class {
           break;
         }
       }
-      const verifyCompletedAt = nowIso4();
-      await service.updateCard(workflowId, iteration, {
+      const verifyCompletedAt = nowIso5();
+      await service.updateCard(questId, iteration, {
         status: allPassed ? "succeeded" : "failed",
-        completedAt: nowIso4(),
+        completedAt: nowIso5(),
         verify: {
           verifierAgentId: null,
           passed: allPassed,
@@ -54809,12 +56993,18 @@ var RalphRunner = class {
         }
       });
       if (allPassed) {
-        await service.markStatus(workflowId, "succeeded");
+        await appendRalphProgress(statePaths, `iteration=${iteration} status=succeeded`);
+        await service.markStatus(questId, "succeeded");
         return;
       }
-      recordWithCard = service.getRecord(workflowId) ?? recordWithCard;
+      await appendRalphProgress(
+        statePaths,
+        `iteration=${iteration} status=failed reason=verify_checks`
+      );
+      recordWithCard = service.getRecord(questId) ?? recordWithCard;
     }
-    await service.markStatus(workflowId, "failed");
+    await appendRalphProgress(statePaths, "quest status=failed reason=max_iterations_exhausted");
+    await service.markStatus(questId, "failed");
   }
 };
 
@@ -54840,8 +57030,8 @@ function deepMerge(current, patch) {
   }
   return next;
 }
-function getValueAtPath(config, path30) {
-  return path30.split(".").reduce((value, segment) => isRecord3(value) ? value[segment] : void 0, config);
+function getValueAtPath(config, path33) {
+  return path33.split(".").reduce((value, segment) => isRecord3(value) ? value[segment] : void 0, config);
 }
 function isEqualValue(a, b) {
   return JSON.stringify(a) === JSON.stringify(b);
@@ -54860,20 +57050,20 @@ var DaemonConfigStore = class {
   patch(partial) {
     const parsedPatch = MutableDaemonConfigPatchSchema.parse(partial);
     const next = MutableDaemonConfigSchema.parse(deepMerge(this.current, parsedPatch));
-    const changedFieldPaths = Array.from(this.fieldChangeHandlers.keys()).filter((path30) => {
-      return !isEqualValue(getValueAtPath(this.current, path30), getValueAtPath(next, path30));
+    const changedFieldPaths = Array.from(this.fieldChangeHandlers.keys()).filter((path33) => {
+      return !isEqualValue(getValueAtPath(this.current, path33), getValueAtPath(next, path33));
     });
     if (changedFieldPaths.length === 0 && isEqualValue(this.current, next)) {
       return this.current;
     }
     this.persistConfig(next);
     this.current = next;
-    for (const path30 of changedFieldPaths) {
-      const handlers = this.fieldChangeHandlers.get(path30);
+    for (const path33 of changedFieldPaths) {
+      const handlers = this.fieldChangeHandlers.get(path33);
       if (!handlers) {
         continue;
       }
-      const value = getValueAtPath(next, path30);
+      const value = getValueAtPath(next, path33);
       for (const handler of handlers) {
         handler(value);
       }
@@ -54883,18 +57073,18 @@ var DaemonConfigStore = class {
     }
     return next;
   }
-  onFieldChange(path30, handler) {
-    const handlers = this.fieldChangeHandlers.get(path30) ?? /* @__PURE__ */ new Set();
+  onFieldChange(path33, handler) {
+    const handlers = this.fieldChangeHandlers.get(path33) ?? /* @__PURE__ */ new Set();
     handlers.add(handler);
-    this.fieldChangeHandlers.set(path30, handlers);
+    this.fieldChangeHandlers.set(path33, handlers);
     return () => {
-      const currentHandlers = this.fieldChangeHandlers.get(path30);
+      const currentHandlers = this.fieldChangeHandlers.get(path33);
       if (!currentHandlers) {
         return;
       }
       currentHandlers.delete(handler);
       if (currentHandlers.size === 0) {
-        this.fieldChangeHandlers.delete(path30);
+        this.fieldChangeHandlers.delete(path33);
       }
     };
   }
@@ -54934,7 +57124,7 @@ function mergeMutableConfigIntoPersistedConfig(params) {
 
 // ../server/src/server/workspace-git-service.ts
 import { watch } from "node:fs";
-import { readFile as readFile5, readdir as readdir5 } from "node:fs/promises";
+import { readFile as readFile6, readdir as readdir5 } from "node:fs/promises";
 import { join as join17, resolve as resolve12 } from "node:path";
 var WORKSPACE_GIT_WATCH_DEBOUNCE_MS = 500;
 var BACKGROUND_GIT_FETCH_INTERVAL_MS = 18e4;
@@ -55164,7 +57354,7 @@ var WorkspaceGitServiceImpl = class {
   }
   async resolveWorkspaceGitRefsRoot(gitDir) {
     try {
-      const commonDir = (await readFile5(join17(gitDir, "commondir"), "utf8")).trim();
+      const commonDir = (await readFile6(join17(gitDir, "commondir"), "utf8")).trim();
       if (commonDir.length > 0) {
         return resolve12(gitDir, commonDir);
       }
@@ -56391,7 +58581,7 @@ function createAuthServerClient(options) {
 
 // ../server/src/server/package-version.ts
 import { existsSync as existsSync17, readFileSync as readFileSync9 } from "node:fs";
-import path25 from "node:path";
+import path28 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 var PackageVersionResolutionError = class extends Error {
   constructor(params) {
@@ -56401,9 +58591,9 @@ var PackageVersionResolutionError = class extends Error {
 };
 function resolvePackageVersion(params) {
   const moduleUrl = params.moduleUrl ?? import.meta.url;
-  let currentDir = path25.dirname(fileURLToPath3(moduleUrl));
+  let currentDir = path28.dirname(fileURLToPath3(moduleUrl));
   while (true) {
-    const packageJsonPath = path25.join(currentDir, "package.json");
+    const packageJsonPath = path28.join(currentDir, "package.json");
     if (existsSync17(packageJsonPath)) {
       try {
         const packageJson = JSON.parse(readFileSync9(packageJsonPath, "utf8"));
@@ -56422,7 +58612,7 @@ function resolvePackageVersion(params) {
         }
       }
     }
-    const parentDir = path25.dirname(currentDir);
+    const parentDir = path28.dirname(currentDir);
     if (parentDir === currentDir) {
       break;
     }
@@ -56925,11 +59115,11 @@ async function createAppostleDaemon(config, rootLogger) {
     httpServer.on("upgrade", scriptProxyUpgradeHandler);
     const agentStorage = new AgentStorage(config.agentStoragePath, logger);
     const projectRegistry = new FileBackedProjectRegistry(
-      path26.join(config.appostleHome, "projects", "projects.json"),
+      path29.join(config.appostleHome, "projects", "projects.json"),
       logger
     );
     workspaceRegistry = new FileBackedWorkspaceRegistry(
-      path26.join(config.appostleHome, "projects", "workspaces.json"),
+      path29.join(config.appostleHome, "projects", "workspaces.json"),
       logger
     );
     const chatService = new FileBackedChatService({
@@ -56991,15 +59181,17 @@ async function createAppostleDaemon(config, rootLogger) {
     });
     await loopService.initialize();
     logger.info({ elapsed: elapsed() }, "Loop service initialized");
-    const workflowService = new WorkflowService({
+    const questService = new QuestService({
       appostleHome: config.appostleHome,
       logger,
       agentManager
     });
-    workflowService.registerRunner("loop", new LoopRunner({ logger }));
-    workflowService.registerRunner("ralph", new RalphRunner({ logger }));
-    await workflowService.initialize();
-    logger.info({ elapsed: elapsed() }, "Workflow service initialized");
+    questService.registerRunner("loop", new LoopRunner({ logger }));
+    questService.registerRunner("ralph", new RalphRunner({ logger }));
+    questService.registerRunner("run", new LoopRunner({ logger }));
+    questService.registerRunner("orchestrate", new OrchestratorRunner({ logger }));
+    await questService.initialize();
+    logger.info({ elapsed: elapsed() }, "Quest service initialized");
     const scheduleService = new ScheduleService({
       appostleHome: config.appostleHome,
       logger,
@@ -57225,7 +59417,7 @@ async function createAppostleDaemon(config, rootLogger) {
               workspaceRegistry,
               chatService,
               loopService,
-              workflowService,
+              questService,
               scheduleService,
               checkoutDiffManager,
               scriptRouteStore,
@@ -57333,16 +59525,16 @@ async function closeAllAgents(logger, agentManager) {
 }
 
 // ../server/src/server/config.ts
-import path28 from "node:path";
+import path31 from "node:path";
 import { z as z45 } from "zod";
 
 // ../server/src/server/speech/speech-config-resolver.ts
 import { z as z44 } from "zod";
 
 // ../server/src/server/speech/providers/local/config.ts
-import path27 from "node:path";
+import path30 from "node:path";
 import { z as z42 } from "zod";
-var DEFAULT_LOCAL_MODELS_SUBDIR = path27.join("models", "local-speech");
+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();
@@ -57369,7 +59561,7 @@ function resolveLocalSpeechConfig(params) {
   const includeProviderConfig = shouldIncludeLocalProviderConfig(params);
   const parsed = LocalSpeechResolutionSchema.parse({
     includeProviderConfig,
-    modelsDir: params.env.APPOSTLE_LOCAL_MODELS_DIR ?? params.persisted.providers?.local?.modelsDir ?? path27.join(params.appostleHome, DEFAULT_LOCAL_MODELS_SUBDIR),
+    modelsDir: params.env.APPOSTLE_LOCAL_MODELS_DIR ?? params.persisted.providers?.local?.modelsDir ?? path30.join(params.appostleHome, DEFAULT_LOCAL_MODELS_SUBDIR),
     dictationLocalSttModel: params.env.APPOSTLE_DICTATION_LOCAL_STT_MODEL ?? persistedLocalFeatureModel(
       params.providers.dictationStt.provider,
       params.providers.dictationStt.enabled,
@@ -57625,7 +59817,7 @@ function loadConfig(appostleHome, options) {
     chromeEnabled,
     mcpDebug: env.MCP_DEBUG === "1",
     daemonIcon,
-    agentStoragePath: path28.join(appostleHome, "agents"),
+    agentStoragePath: path31.join(appostleHome, "agents"),
     staticDir: "public",
     agentClients: {},
     relayEnabled,
@@ -57644,7 +59836,7 @@ function loadConfig(appostleHome, options) {
 
 // ../server/src/server/logger.ts
 import { existsSync as existsSync19, mkdirSync as mkdirSync7, readdirSync as readdirSync2, renameSync as renameSync3, unlinkSync as unlinkSync2 } from "node:fs";
-import path29 from "node:path";
+import path32 from "node:path";
 import pino from "pino";
 import pretty from "pino-pretty";
 import { createStream as createRotatingFileStream } from "rotating-file-stream";
@@ -57687,14 +59879,14 @@ function parsePositiveInteger(value) {
   return parsed;
 }
 function resolveFilePath(appostleHome, configuredPath) {
-  const fallback = path29.join(appostleHome, DEFAULT_DAEMON_LOG_FILENAME);
+  const fallback = path32.join(appostleHome, DEFAULT_DAEMON_LOG_FILENAME);
   if (!configuredPath) {
     return fallback;
   }
-  if (path29.isAbsolute(configuredPath)) {
+  if (path32.isAbsolute(configuredPath)) {
     return configuredPath;
   }
-  return path29.resolve(appostleHome, configuredPath);
+  return path32.resolve(appostleHome, configuredPath);
 }
 function minLogLevel(levels) {
   let minLevel = levels[0];
@@ -57731,20 +59923,20 @@ function normalizeLoggerConfigInput(config) {
 }
 function rotateOnRestart(filePath, maxFiles) {
   if (!existsSync19(filePath)) return;
-  const dir = path29.dirname(filePath);
-  const base = path29.basename(filePath);
+  const dir = path32.dirname(filePath);
+  const base = path32.basename(filePath);
   const now = /* @__PURE__ */ new Date();
   const pad = (n) => String(n).padStart(2, "0");
   const ts = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}`;
   try {
-    renameSync3(filePath, path29.join(dir, `${ts}-00-${base}`));
+    renameSync3(filePath, path32.join(dir, `${ts}-00-${base}`));
   } catch {
     return;
   }
   const rotatedFiles = readdirSync2(dir).filter((f) => f.endsWith(`-${base}`) && f !== base).sort().reverse();
   for (const file of rotatedFiles.slice(maxFiles)) {
     try {
-      unlinkSync2(path29.join(dir, file));
+      unlinkSync2(path32.join(dir, file));
     } catch {
     }
   }
@@ -57793,15 +59985,15 @@ function resolveLogConfig(configInput, options) {
 }
 function createRootLogger(configInput, options) {
   const config = resolveLogConfig(configInput, options);
-  mkdirSync7(path29.dirname(config.file.path), { recursive: true });
+  mkdirSync7(path32.dirname(config.file.path), { recursive: true });
   const consoleStream = config.console.format === "pretty" ? pretty({
     colorize: true,
     singleLine: true,
     ignore: "pid,hostname"
   }) : pino.destination({ dest: 1, sync: false });
   rotateOnRestart(config.file.path, config.file.rotate.maxFiles);
-  const fileStream = createRotatingFileStream(path29.basename(config.file.path), {
-    path: path29.dirname(config.file.path),
+  const fileStream = createRotatingFileStream(path32.basename(config.file.path), {
+    path: path32.dirname(config.file.path),
     size: toRotatingFileStreamSize(config.file.rotate.maxSize),
     maxFiles: config.file.rotate.maxFiles
   });
@@ -57815,7 +60007,7 @@ function createRootLogger(configInput, options) {
 }
 
 // ../server/src/server/pid-lock.ts
-import { open, readFile as readFile6, unlink as unlink3, mkdir as mkdir8 } from "node:fs/promises";
+import { open, readFile as readFile7, unlink as unlink3, mkdir as mkdir10 } from "node:fs/promises";
 import { existsSync as existsSync20 } from "node:fs";
 import { join as join18 } from "node:path";
 import { hostname } from "node:os";
@@ -57846,11 +60038,11 @@ function resolveOwnerPid(ownerPid) {
 async function acquirePidLock(appostleHome, listen, options) {
   const pidPath = getPidFilePath(appostleHome);
   if (!existsSync20(appostleHome)) {
-    await mkdir8(appostleHome, { recursive: true });
+    await mkdir10(appostleHome, { recursive: true });
   }
   let existingLock = null;
   try {
-    const content = await readFile6(pidPath, "utf-8");
+    const content = await readFile7(pidPath, "utf-8");
     existingLock = JSON.parse(content);
   } catch {
   }
@@ -57883,7 +60075,7 @@ async function acquirePidLock(appostleHome, listen, options) {
   } catch (err) {
     if (err.code === "EEXIST") {
       try {
-        const content = await readFile6(pidPath, "utf-8");
+        const content = await readFile7(pidPath, "utf-8");
         const raceLock = JSON.parse(content);
         throw new PidLockError(
           `Another Appostle daemon is already running (PID ${raceLock.pid})`,
@@ -57902,7 +60094,7 @@ async function acquirePidLock(appostleHome, listen, options) {
 async function updatePidLock(appostleHome, patch, options) {
   const pidPath = getPidFilePath(appostleHome);
   const lockOwnerPid = resolveOwnerPid(options?.ownerPid);
-  const content = await readFile6(pidPath, "utf-8");
+  const content = await readFile7(pidPath, "utf-8");
   const existingLock = JSON.parse(content);
   if (existingLock.pid !== lockOwnerPid) {
     throw new PidLockError(`Cannot update PID lock owned by PID ${existingLock.pid}`, existingLock);
@@ -57923,7 +60115,7 @@ async function releasePidLock(appostleHome, options) {
   const pidPath = getPidFilePath(appostleHome);
   const lockOwnerPid = resolveOwnerPid(options?.ownerPid);
   try {
-    const content = await readFile6(pidPath, "utf-8");
+    const content = await readFile7(pidPath, "utf-8");
     const lock = JSON.parse(content);
     if (lock.pid === lockOwnerPid) {
       await unlink3(pidPath);