appostle-installer 0.0.4 → 0.0.6

package/dist/appostle.js

@@ -454,18 +454,18 @@ function resolveNodePtyPackageRoot() {
     return null;
   }
 }
-function ensureExecutableBit(path23) {
-  if (!existsSync2(path23)) {
+function ensureExecutableBit(path24) {
+  if (!existsSync2(path24)) {
     return;
   }
-  const stat5 = statSync(path23);
+  const stat5 = statSync(path24);
   if (!stat5.isFile()) {
     return;
   }
   if ((stat5.mode & 73) === 73) {
     return;
   }
-  chmodSync(path23, stat5.mode | 73);
+  chmodSync(path24, stat5.mode | 73);
 }
 function ensureNodePtySpawnHelperExecutableForCurrentPlatform(options = {}) {
   const platform2 = options.platform ?? process.platform;
@@ -547,11 +547,11 @@ function parseGitRevParsePath(stdout) {
   if (lines.length !== 1) {
     return null;
   }
-  const path23 = lines[0]?.trim() ?? "";
-  if (!path23 || path23.startsWith("--")) {
+  const path24 = lines[0]?.trim() ?? "";
+  if (!path24 || path24.startsWith("--")) {
     return null;
   }
-  return path23;
+  return path24;
 }
 function resolveGitRevParsePath(cwd, stdout) {
   const parsed = parseGitRevParsePath(stdout);
@@ -1324,9 +1324,9 @@ async function deleteAppostleWorktree({
     }
   }
 }
-async function pathExists(path23) {
+async function pathExists(path24) {
   try {
-    await stat(path23);
+    await stat(path24);
     return true;
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -1335,8 +1335,8 @@ async function pathExists(path23) {
     throw error;
   }
 }
-async function removeDirectoryWithRetries(path23) {
-  if (!await pathExists(path23)) {
+async function removeDirectoryWithRetries(path24) {
+  if (!await pathExists(path24)) {
     return;
   }
   const delaysMs = [0, 100, 300, 700, 1500];
@@ -1346,17 +1346,17 @@ async function removeDirectoryWithRetries(path23) {
       await new Promise((resolve12) => setTimeout(resolve12, delay));
     }
     try {
-      await rm(path23, { recursive: true, force: true });
-      if (!await pathExists(path23)) {
+      await rm(path24, { recursive: true, force: true });
+      if (!await pathExists(path24)) {
         return;
       }
-      lastError = new Error(`Directory still present after rm: ${path23}`);
+      lastError = new Error(`Directory still present after rm: ${path24}`);
     } catch (error) {
       lastError = error;
     }
   }
-  if (await pathExists(path23)) {
-    throw lastError instanceof Error ? lastError : new Error(`Failed to remove worktree directory: ${path23}`);
+  if (await pathExists(path24)) {
+    throw lastError instanceof Error ? lastError : new Error(`Failed to remove worktree directory: ${path24}`);
   }
 }
 var createWorktree = async ({
@@ -2545,14 +2545,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,
@@ -2576,79 +2576,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(),
@@ -2656,107 +2678,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 RoleMoveResponseSchema = z9.object({
+  type: z9.literal("roles/move/response"),
+  payload: z9.object({
+    requestId: z9.string(),
+    path: z9.string(),
+    error: z9.string().nullable()
+  })
 });
-var AgentRoleEntrySchema = z9.object({
+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 AgentRolesListResponseSchema = z9.object({
-  type: z9.literal("agents/list/response"),
+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 BrandCreateResponseSchema = z9.object({
+  type: z9.literal("brands/create/response"),
   payload: z9.object({
     requestId: z9.string(),
-    roles: z9.array(AgentRoleEntrySchema),
+    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(),
+    path: z9.string(),
     error: z9.string().nullable()
   })
 });
@@ -3310,6 +3518,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({
@@ -4099,6 +4308,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())]),
@@ -4371,6 +4599,9 @@ var SessionInboundMessageSchema = z10.discriminatedUnion("type", [
   FileExplorerRequestSchema,
   FileWriteRequestSchema,
   FileDeleteRequestSchema,
+  FileExplorerDeleteRequestSchema,
+  FileMkdirRequestSchema,
+  FileMoveRequestSchema,
   ProjectIconRequestSchema,
   FileDownloadTokenRequestSchema,
   ClearAgentAttentionMessageSchema,
@@ -4380,6 +4611,15 @@ var SessionInboundMessageSchema = z10.discriminatedUnion("type", [
   ListSkillsRequestSchema,
   CreateSkillRequestSchema,
   WriteSkillFrontmatterRequestSchema,
+  RolesListScopeRequestSchema,
+  RoleCreateRequestSchema,
+  RoleWriteFrontmatterRequestSchema,
+  RoleMoveRequestSchema,
+  BrandsListScopeRequestSchema,
+  BrandCreateRequestSchema,
+  BrandWriteFrontmatterRequestSchema,
+  BrandAssetCopyRequestSchema,
+  BrandAssetUploadRequestSchema,
   RegisterPushTokenMessageSchema,
   RegisterWebPushSubscriptionMessageSchema,
   UnregisterWebPushSubscriptionMessageSchema,
@@ -4414,11 +4654,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(),
@@ -5544,6 +5784,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()
@@ -5876,6 +6144,9 @@ var SessionOutboundMessageSchema = z10.discriminatedUnion("type", [
   FileExplorerResponseSchema,
   FileWriteResponseSchema,
   FileDeleteResponseSchema,
+  FileExplorerDeleteResponseSchema,
+  FileMkdirResponseSchema,
+  FileMoveResponseSchema,
   ProjectIconResponseSchema,
   FileDownloadTokenResponseSchema,
   ListProviderModelsResponseMessageSchema,
@@ -5890,6 +6161,10 @@ var SessionOutboundMessageSchema = z10.discriminatedUnion("type", [
   ListSkillsResponseSchema,
   CreateSkillResponseSchema,
   WriteSkillFrontmatterResponseSchema,
+  RolesListScopeResponseSchema,
+  RoleCreateResponseSchema,
+  RoleWriteFrontmatterResponseSchema,
+  RoleMoveResponseSchema,
   ListTerminalsResponseSchema,
   TerminalsChangedSchema,
   CreateTerminalResponseSchema,
@@ -5916,11 +6191,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
 ]);
@@ -7887,6 +8167,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]
@@ -8318,14 +8604,14 @@ var DictationStreamManager = class {
       PCM_CHANNELS,
       PCM_BITS_PER_SAMPLE
     );
-    const path23 = await maybePersistDictationDebugAudio(
+    const path24 = await maybePersistDictationDebugAudio(
       wavBuffer,
       { sessionId: state.sessionId, dictationId: state.dictationId, format: "audio/wav" },
       this.logger,
       state.debugChunkWriter?.folder
     );
-    state.debugRecordingPath = path23;
-    return path23;
+    state.debugRecordingPath = path24;
+    return path24;
   }
   failDictationStream(dictationId, error, retryable) {
     this.emit({
@@ -9571,14 +9857,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 path23 = "unknown";
+    let path24 = "unknown";
     const pathMatch = firstLine.match(/a\/(.*?) b\//);
     if (pathMatch) {
-      path23 = pathMatch[1];
+      path24 = pathMatch[1];
     } else {
       const newFileMatch = firstLine.match(/b\/(.+)$/);
       if (newFileMatch) {
-        path23 = newFileMatch[1];
+        path24 = newFileMatch[1];
       }
     }
     const hunks = [];
@@ -9622,7 +9908,7 @@ function parseDiff(diffText) {
     if (currentHunk) {
       hunks.push(currentHunk);
     }
-    files.push({ path: path23, isNew, isDeleted, additions, deletions, hunks });
+    files.push({ path: path24, isNew, isDeleted, additions, deletions, hunks });
   }
   return files;
 }
@@ -9678,9 +9964,9 @@ function buildTokenLookup(lineMap, highlighted) {
   }
   return lookup2;
 }
-function buildFullFileTokenLookup(fileContent, path23) {
+function buildFullFileTokenLookup(fileContent, path24) {
   const lookup2 = /* @__PURE__ */ new Map();
-  const highlighted = highlightCode(fileContent, path23);
+  const highlighted = highlightCode(fileContent, path24);
   for (let i = 0; i < highlighted.length; i++) {
     lookup2.set(i + 1, highlighted[i]);
   }
@@ -11381,11 +11667,11 @@ async function listCheckoutFileChanges(cwd, ref, ignoreWhitespace = false) {
       }
       continue;
     }
-    const path23 = tabParts[1];
-    if (!path23) continue;
+    const path24 = tabParts[1];
+    if (!path24) continue;
     const code = rawStatus[0];
     changes.push({
-      path: path23,
+      path: path24,
       status: rawStatus,
       isNew: code === "A",
       isDeleted: code === "D"
@@ -11420,9 +11706,9 @@ async function listCheckoutFileChanges(cwd, ref, ignoreWhitespace = false) {
   }
   return Array.from(byPath.values());
 }
-async function readGitFileContentAtRef(cwd, ref, path23) {
+async function readGitFileContentAtRef(cwd, ref, path24) {
   try {
-    const { stdout } = await runGitCommand(["show", `${ref}:${path23}`], {
+    const { stdout } = await runGitCommand(["show", `${ref}:${path24}`], {
       cwd,
       env: READ_ONLY_GIT_ENV2
     });
@@ -11483,21 +11769,21 @@ async function getTrackedNumstatByPath(cwd, ref, ignoreWhitespace = false) {
     const additionsField = parts[0] ?? "";
     const deletionsField = parts[1] ?? "";
     const rawPath = parts.slice(2).join("	");
-    const path23 = normalizeNumstatPath(rawPath);
-    if (!path23) {
+    const path24 = normalizeNumstatPath(rawPath);
+    if (!path24) {
       continue;
     }
     if (additionsField === "-" || deletionsField === "-") {
-      stats.set(path23, { additions: 0, deletions: 0, isBinary: true });
+      stats.set(path24, { 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(path23, null);
+      stats.set(path24, null);
       continue;
     }
-    stats.set(path23, { additions, deletions, isBinary: false });
+    stats.set(path24, { additions, deletions, isBinary: false });
   }
   return stats;
 }
@@ -12082,10 +12368,10 @@ async function listUncommittedFiles(cwd) {
         if (dest) results.push({ path: dest, changeType: code });
         continue;
       }
-      const path23 = parts[1];
-      if (!path23) continue;
+      const path24 = parts[1];
+      if (!path24) continue;
       if (code === "A" || code === "M" || code === "D") {
-        results.push({ path: path23, changeType: code });
+        results.push({ path: path24, changeType: code });
       }
     }
   } catch {
@@ -15129,6 +15415,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",
@@ -15146,6 +15440,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) {
@@ -17728,11 +18025,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 ?? [],
@@ -19963,14 +20267,14 @@ function codexApplyPatchToUnifiedDiff(text) {
   for (const line of lines) {
     const directive = parseCodexApplyPatchDirective(line);
     if (directive) {
-      const path23 = normalizeDiffHeaderPath(directive.path);
-      if (path23.length > 0) {
+      const path24 = normalizeDiffHeaderPath(directive.path);
+      if (path24.length > 0) {
         if (output.length > 0 && output[output.length - 1] !== "") {
           output.push("");
         }
-        const left = directive.kind === "add" ? "/dev/null" : `a/${path23}`;
-        const right = directive.kind === "delete" ? "/dev/null" : `b/${path23}`;
-        output.push(`diff --git a/${path23} b/${path23}`);
+        const left = directive.kind === "add" ? "/dev/null" : `a/${path24}`;
+        const right = directive.kind === "delete" ? "/dev/null" : `b/${path24}`;
+        output.push(`diff --git a/${path24} b/${path24}`);
         output.push(`--- ${left}`);
         output.push(`+++ ${right}`);
         sawDiffContent = true;
@@ -20040,9 +20344,9 @@ function asEditTextFields(text) {
 function normalizeRolloutEditInput(input) {
   if (typeof input === "string") {
     const textFields2 = asEditTextFields(input);
-    const path23 = extractPatchPrimaryFilePath(input);
+    const path24 = extractPatchPrimaryFilePath(input);
     return {
-      ...path23 ? { path: path23 } : {},
+      ...path24 ? { path: path24 } : {},
       ...textFields2.unifiedDiff ? { patch: textFields2.unifiedDiff } : {},
       ...textFields2.newString ? { content: textFields2.newString } : {}
     };
@@ -20190,12 +20494,12 @@ function parseFileChangeDiff(entry) {
   ]);
 }
 function toFileChangeEntry(entry, options, fallbackPath) {
-  const path23 = parseFileChangePath(entry, options, fallbackPath);
-  if (!path23) {
+  const path24 = parseFileChangePath(entry, options, fallbackPath);
+  if (!path24) {
     return null;
   }
   return {
-    path: path23,
+    path: path24,
     kind: parseFileChangeKind(entry),
     diff: parseFileChangeDiff(entry)
   };
@@ -20217,12 +20521,12 @@ function parseFileChangeEntries(changes, options) {
   if (singleEntry) {
     return [singleEntry];
   }
-  return Object.entries(changes).map(([path23, value]) => {
+  return Object.entries(changes).map(([path24, value]) => {
     if (isRecord2(value)) {
-      return toFileChangeEntry(value, options, path23);
+      return toFileChangeEntry(value, options, path24);
     }
     if (typeof value === "string") {
-      const normalizedPath = normalizeCodexFilePath(path23.trim(), options?.cwd);
+      const normalizedPath = normalizeCodexFilePath(path24.trim(), options?.cwd);
       if (!normalizedPath) {
         return null;
       }
@@ -20967,16 +21271,16 @@ function isObjectSchemaNode(schema) {
   const type = schema.type;
   return isSchemaRecord(schema.properties) || type === "object" || Array.isArray(type) && type.includes("object");
 }
-function normalizeCodexOutputSchemaNode(schema, path23) {
+function normalizeCodexOutputSchemaNode(schema, path24) {
   if (Array.isArray(schema)) {
-    return schema.map((entry, index) => normalizeCodexOutputSchemaNode(entry, `${path23}[${index}]`));
+    return schema.map((entry, index) => normalizeCodexOutputSchemaNode(entry, `${path24}[${index}]`));
   }
   if (!isSchemaRecord(schema)) {
     return schema;
   }
   const normalized = {};
   for (const [key, value] of Object.entries(schema)) {
-    normalized[key] = normalizeCodexOutputSchemaNode(value, `${path23}.${key}`);
+    normalized[key] = normalizeCodexOutputSchemaNode(value, `${path24}.${key}`);
   }
   if (!isObjectSchemaNode(normalized)) {
     return normalized;
@@ -20985,7 +21289,7 @@ function normalizeCodexOutputSchemaNode(schema, path23) {
     normalized.additionalProperties = false;
   } else if (normalized.additionalProperties !== false) {
     throw new Error(
-      `Codex structured outputs require ${path23} to set additionalProperties to false for object schemas.`
+      `Codex structured outputs require ${path24} to set additionalProperties to false for object schemas.`
     );
   }
   const properties = isSchemaRecord(normalized.properties) ? normalized.properties : null;
@@ -21747,8 +22051,8 @@ function parseCodexPatchChanges(changes) {
       }
     ];
   }
-  return Object.entries(recordChanges).map(([path23, value]) => {
-    const normalizedPath = path23.trim();
+  return Object.entries(recordChanges).map(([path24, value]) => {
+    const normalizedPath = path24.trim();
     if (!normalizedPath) {
       return null;
     }
@@ -29497,8 +29801,8 @@ function buildZodValidator(schema, schemaName) {
         return { ok: true, value: result.data };
       }
       const errors = result.error.issues.map((issue) => {
-        const path23 = issue.path.length > 0 ? issue.path.join(".") : "(root)";
-        return `${path23}: ${issue.message}`;
+        const path24 = issue.path.length > 0 ? issue.path.join(".") : "(root)";
+        return `${path24}: ${issue.message}`;
       });
       return { ok: false, errors };
     }
@@ -29516,9 +29820,9 @@ function buildJsonSchemaValidator(schema) {
         return { ok: true, value };
       }
       const errors = (validate.errors ?? []).map((error) => {
-        const path23 = error.instancePath && error.instancePath.length > 0 ? error.instancePath : "(root)";
+        const path24 = error.instancePath && error.instancePath.length > 0 ? error.instancePath : "(root)";
         const message = error.message ?? "is invalid";
-        return `${path23}: ${message}`;
+        return `${path24}: ${message}`;
       });
       return { ok: false, errors };
     }
@@ -30440,6 +30744,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 = "."
@@ -30550,6 +30860,23 @@ async function deleteFile({ root, relativePath }) {
   }
   await fs5.unlink(filePath);
 }
+async function deleteEntry({ root, relativePath }) {
+  const entryPath = await resolveScopedPath({ root, relativePath });
+  await fs5.rm(entryPath, { recursive: true, force: false });
+}
+async function createDirectory({ root, relativePath }) {
+  const dirPath = await resolveScopedPath({ root, relativePath });
+  await fs5.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 fs5.rename(src, dest);
+}
 async function getDownloadableFileInfo({ root, relativePath }) {
   const filePath = await resolveScopedPath({ root, relativePath });
   const stats = await fs5.stat(filePath);
@@ -30559,7 +30886,9 @@ async function getDownloadableFileInfo({ root, relativePath }) {
   const ext = path10.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 fs5.open(filePath, "r");
     const sample = Buffer.alloc(8192);
@@ -30980,15 +31309,15 @@ async function getProjectIcon(projectDir) {
 
 // ../server/src/utils/path.ts
 import os5 from "os";
-function expandTilde(path23) {
-  if (path23.startsWith("~/")) {
+function expandTilde(path24) {
+  if (path24.startsWith("~/")) {
     const homeDir3 = process.env.HOME || os5.homedir();
-    return path23.replace("~", homeDir3);
+    return path24.replace("~", homeDir3);
   }
-  if (path23 === "~") {
+  if (path24 === "~") {
     return process.env.HOME || os5.homedir();
   }
-  return path23;
+  return path24;
 }
 
 // ../server/src/server/skills/scanner.ts
@@ -32166,7 +32495,7 @@ function buildChatMentionNotification(input) {
   ].join("\n");
 }
 
-// ../server/src/server/agents/scanner.ts
+// ../server/src/server/roles/scanner.ts
 import fs7 from "node:fs/promises";
 import os7 from "node:os";
 import path14 from "node:path";
@@ -32179,11 +32508,41 @@ function resolveScopeDir2(scope, workspaceRoot) {
     if (!workspaceRoot) {
       throw new Error('workspaceRoot is required for scope "project"');
     }
-    return path14.join(workspaceRoot, ".agents");
+    return path14.join(workspaceRoot, ".roles");
   }
-  return path14.join(homeDir2(), ".appostle", ".agents");
+  return path14.join(homeDir2(), ".appostle", ".roles");
+}
+function allowedRoots2(workspaceRoot) {
+  const roots = [path14.join(homeDir2(), ".appostle", ".roles")];
+  if (workspaceRoot) {
+    roots.push(path14.join(workspaceRoot, ".roles"));
+  }
+  return roots.map((r) => path14.resolve(r));
+}
+function isInsideAllowedRoot2(absPath, workspaceRoot) {
+  const resolved = path14.resolve(absPath);
+  for (const root of allowedRoots2(workspaceRoot)) {
+    const rel = path14.relative(root, resolved);
+    if (rel === "" || !rel.startsWith("..") && !path14.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);
@@ -32191,36 +32550,165 @@ function unquote(value) {
   return value;
 }
 function parseFrontmatter(text) {
-  const match = FRONTMATTER_RE2.exec(text);
   const empty = {
     description: "",
-    provider: null,
-    model: null,
-    mode: null
+    triggerWords: [],
+    allowedTools: [],
+    provider: "",
+    model: "",
+    mode: ""
   };
-  if (!match) {
-    return empty;
-  }
-  const lines = (match[1] ?? "").split(/\r?\n/);
+  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;
+}
+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) {
+async function readRolesFromDir(scope, dir, category) {
   let entries;
   try {
     entries = await fs7.readdir(dir, { withFileTypes: true });
@@ -32246,13 +32734,23 @@ async function readRolesFromDir(scope, dir) {
       const text = await fs7.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,
@@ -32261,16 +32759,620 @@ async function readRolesFromDir(scope, dir) {
       size: stat5.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 fs7.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, path14.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 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 ? path14.join(scopeDir, args.category) : scopeDir;
+  await fs7.mkdir(dir, { recursive: true });
+  const filePath = path14.join(dir, `${args.name}.md`);
+  try {
+    await fs7.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 fs7.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 (!path14.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 fs7.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 fs7.writeFile(args.path, nextContent, "utf8");
+}
+async function moveRole(args, workspaceRoot) {
+  if (!path14.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 = path14.dirname(args.path);
+  const oldFilename = path14.basename(args.path, ".md");
+  const roots = allowedRoots2(workspaceRoot);
+  const rolesRoot = roots.find((r) => path14.resolve(args.path).startsWith(r));
+  if (!rolesRoot) {
+    throw new Error(`Cannot determine roles root for "${args.path}"`);
+  }
+  const relFromRoot = path14.relative(rolesRoot, path14.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 ? path14.join(rolesRoot, newCategory) : rolesRoot;
+  const newPath = path14.join(newDir, `${newName}.md`);
+  if (path14.resolve(newPath) === path14.resolve(args.path)) {
+    return { path: args.path };
+  }
+  await fs7.mkdir(newDir, { recursive: true });
+  try {
+    await fs7.access(newPath);
+    throw new Error(`A role already exists at "${newPath}"`);
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  await fs7.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 fs7.readdir(oldDir);
+      if (remaining.length === 0) {
+        await fs7.rmdir(oldDir);
+      }
+    } catch {
+    }
+  }
+  return { path: newPath };
+}
+
+// ../server/src/server/brands/scanner.ts
+import fs8 from "node:fs/promises";
+import path15 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 path15.join(workspaceRoot, ".brand");
+  }
+  throw new Error(`Unknown scope: ${scope}`);
+}
+function allowedRoots3(workspaceRoot) {
+  const roots = [];
+  if (workspaceRoot) {
+    roots.push(path15.join(workspaceRoot, ".brand"));
+  }
+  return roots.map((r) => path15.resolve(r));
+}
+function isInsideAllowedRoot3(absPath, workspaceRoot) {
+  const resolved = path15.resolve(absPath);
+  for (const root of allowedRoots3(workspaceRoot)) {
+    const rel = path15.relative(root, resolved);
+    if (rel === "" || !rel.startsWith("..") && !path15.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 fs8.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 = path15.join(dir, entry.name);
+    let stat5;
+    try {
+      const s = await fs8.stat(fullPath);
+      stat5 = { mtime: s.mtime, size: s.size };
+    } catch {
+      continue;
+    }
+    let parsed;
+    try {
+      const text = await fs8.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: stat5.mtime.toISOString(),
+      size: stat5.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 fs8.mkdir(dir, { recursive: true });
+  const filePath = path15.join(dir, `${args.name}.md`);
+  try {
+    await fs8.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 fs8.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 || !path15.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 fs8.stat(args.sourcePath);
+  if (!stats.isFile()) {
+    throw new Error(`Source path is not a regular file: ${args.sourcePath}`);
+  }
+  const ext = path15.extname(args.sourcePath).toLowerCase();
+  const fileName = `${args.targetName}${ext}`;
+  const assetsDir = path15.join(args.workspaceRoot, ".brand", "assets");
+  const destAbs = path15.resolve(assetsDir, fileName);
+  const rel = path15.relative(path15.resolve(assetsDir), destAbs);
+  if (rel.startsWith("..") || path15.isAbsolute(rel)) {
+    throw new Error(`Refusing to write outside of .brand/assets: ${destAbs}`);
+  }
+  await fs8.mkdir(assetsDir, { recursive: true });
+  await fs8.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 ? path15.extname(args.sourceName).toLowerCase() : "";
+  const ext = extFromSource || ".png";
+  const fileName = `${args.targetName}${ext}`;
+  const assetsDir = path15.join(args.workspaceRoot, ".brand", "assets");
+  const destAbs = path15.resolve(assetsDir, fileName);
+  const rel = path15.relative(path15.resolve(assetsDir), destAbs);
+  if (rel.startsWith("..") || path15.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 fs8.mkdir(assetsDir, { recursive: true });
+  await fs8.writeFile(destAbs, data);
+  return {
+    relativePath: `assets/${fileName}`,
+    absolutePath: destAbs
+  };
+}
+async function writeBrandFrontmatter(args, workspaceRoot) {
+  if (!path15.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 fs8.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 fs8.writeFile(args.path, nextContent, "utf8");
+}
 
 // ../server/src/services/oauth-service.ts
 import { createHash as createHash3, randomBytes as randomBytes2 } from "node:crypto";
@@ -32517,57 +33619,57 @@ async function fetchGitLabUsername(fetchImpl, accessToken) {
     return null;
   }
 }
-async function readCredential(path23, log2) {
+async function readCredential(path24, log2) {
   try {
-    const raw = await readFile3(path23, "utf8");
+    const raw = await readFile3(path24, "utf8");
     const parsed = JSON.parse(raw);
     return parsed.gitlab ?? null;
   } catch (error) {
     if (isNotFound(error)) return null;
-    log2.warn({ err: error, path: path23 }, "oauth.credentials.read_failed");
+    log2.warn({ err: error, path: path24 }, "oauth.credentials.read_failed");
     return null;
   }
 }
-async function persistCredential(path23, credential, log2) {
-  await mkdir4(dirname4(path23), { recursive: true });
+async function persistCredential(path24, credential, log2) {
+  await mkdir4(dirname4(path24), { recursive: true });
   let current = {};
   try {
-    const raw = await readFile3(path23, "utf8");
+    const raw = await readFile3(path24, "utf8");
     current = JSON.parse(raw);
   } catch (error) {
     if (!isNotFound(error)) {
-      log2.warn({ err: error, path: path23 }, "oauth.credentials.read_failed_overwriting");
+      log2.warn({ err: error, path: path24 }, "oauth.credentials.read_failed_overwriting");
     }
   }
   const next = { ...current, gitlab: credential };
-  const tmpPath = `${path23}.tmp-${process.pid}-${Date.now()}`;
+  const tmpPath = `${path24}.tmp-${process.pid}-${Date.now()}`;
   await writeFile4(tmpPath, JSON.stringify(next, null, 2), { mode: 384 });
-  await rename(tmpPath, path23);
+  await rename(tmpPath, path24);
 }
-async function deleteCredential(path23, log2) {
+async function deleteCredential(path24, log2) {
   let current = {};
   try {
-    const raw = await readFile3(path23, "utf8");
+    const raw = await readFile3(path24, "utf8");
     current = JSON.parse(raw);
   } catch (error) {
     if (isNotFound(error)) return;
-    log2.warn({ err: error, path: path23 }, "oauth.credentials.delete_read_failed");
+    log2.warn({ err: error, path: path24 }, "oauth.credentials.delete_read_failed");
     return;
   }
   delete current.gitlab;
   if (Object.keys(current).length === 0) {
     try {
-      await unlink(path23);
+      await unlink(path24);
     } catch (error) {
       if (!isNotFound(error)) {
-        log2.warn({ err: error, path: path23 }, "oauth.credentials.unlink_failed");
+        log2.warn({ err: error, path: path24 }, "oauth.credentials.unlink_failed");
       }
     }
     return;
   }
-  const tmpPath = `${path23}.tmp-${process.pid}-${Date.now()}`;
+  const tmpPath = `${path24}.tmp-${process.pid}-${Date.now()}`;
   await writeFile4(tmpPath, JSON.stringify(current, null, 2), { mode: 384 });
-  await rename(tmpPath, path23);
+  await rename(tmpPath, path24);
 }
 function defaultGlabConfigPath() {
   const home = homedir4();
@@ -32582,15 +33684,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(path23, credential, log2) {
-  await mkdir4(dirname4(path23), { recursive: true });
+async function writeGlabConfig(path24, credential, log2) {
+  await mkdir4(dirname4(path24), { recursive: true });
   let doc;
   try {
-    const raw = await readFile3(path23, "utf8");
+    const raw = await readFile3(path24, "utf8");
     doc = YAML.parseDocument(raw);
     if (doc.errors.length > 0) {
       log2.warn(
-        { errors: doc.errors.map((e) => e.message), path: path23 },
+        { errors: doc.errors.map((e) => e.message), path: path24 },
         "oauth.glab.parse_errors_replacing"
       );
       doc = YAML.parseDocument("{}");
@@ -32599,7 +33701,7 @@ async function writeGlabConfig(path23, credential, log2) {
     if (isNotFound(error)) {
       doc = YAML.parseDocument("{}");
     } else {
-      log2.warn({ err: error, path: path23 }, "oauth.glab.read_failed_replacing");
+      log2.warn({ err: error, path: path24 }, "oauth.glab.read_failed_replacing");
       doc = YAML.parseDocument("{}");
     }
   }
@@ -32612,18 +33714,18 @@ async function writeGlabConfig(path23, credential, log2) {
   if (credential.username) {
     hostEntry.set("user", credential.username);
   }
-  const tmpPath = `${path23}.tmp-${process.pid}-${Date.now()}`;
+  const tmpPath = `${path24}.tmp-${process.pid}-${Date.now()}`;
   await writeFile4(tmpPath, doc.toString(), { mode: 384 });
-  await rename(tmpPath, path23);
+  await rename(tmpPath, path24);
 }
-async function removeGlabHost(path23, log2) {
+async function removeGlabHost(path24, log2) {
   let doc;
   try {
-    const raw = await readFile3(path23, "utf8");
+    const raw = await readFile3(path24, "utf8");
     doc = YAML.parseDocument(raw);
   } catch (error) {
     if (isNotFound(error)) return;
-    log2.warn({ err: error, path: path23 }, "oauth.glab.remove_read_failed");
+    log2.warn({ err: error, path: path24 }, "oauth.glab.remove_read_failed");
     return;
   }
   const hosts = doc.get("hosts");
@@ -32632,9 +33734,9 @@ async function removeGlabHost(path23, log2) {
   if (hosts.items.length === 0) {
     doc.delete("hosts");
   }
-  const tmpPath = `${path23}.tmp-${process.pid}-${Date.now()}`;
+  const tmpPath = `${path24}.tmp-${process.pid}-${Date.now()}`;
   await writeFile4(tmpPath, doc.toString(), { mode: 384 });
-  await rename(tmpPath, path23);
+  await rename(tmpPath, path24);
 }
 function ensureMap(doc, key) {
   const existing = doc.get(key);
@@ -33735,7 +34837,7 @@ var Session = class _Session {
       chatService,
       scheduleService,
       loopService,
-      workflowService,
+      questService,
       checkoutDiffManager,
       github,
       gitlab,
@@ -33782,7 +34884,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();
@@ -34361,7 +35463,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);
@@ -34591,6 +35699,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;
@@ -34751,20 +35868,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 "quest/list":
+            await this.handleQuestListRequest(msg);
+            break;
+          case "quest/inspect":
+            await this.handleQuestInspectRequest(msg);
+            break;
+          case "quest/stop":
+            await this.handleQuestStopRequest(msg);
+            break;
+          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 "workflow/list":
-            await this.handleWorkflowListRequest(msg);
+          case "brands/create":
+            await this.handleBrandCreateRequest(msg);
             break;
-          case "workflow/inspect":
-            await this.handleWorkflowInspectRequest(msg);
+          case "brands/write-frontmatter":
+            await this.handleBrandWriteFrontmatterRequest(msg);
             break;
-          case "workflow/stop":
-            await this.handleWorkflowStopRequest(msg);
+          case "brands/asset-copy":
+            await this.handleBrandAssetCopyRequest(msg);
             break;
-          case "agents/list":
-            await this.handleAgentsListRequest(msg);
+          case "brands/asset-upload":
+            await this.handleBrandAssetUploadRequest(msg);
             break;
         }
       } catch (error) {
@@ -35196,26 +36340,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;
@@ -35223,7 +36368,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",
@@ -37118,7 +38264,7 @@ var Session = class _Session {
         homeDir: process.env.HOME ?? homedir5(),
         query: query2,
         limit
-      })).map((path23) => ({ path: path23, kind: "directory" }));
+      })).map((path24) => ({ path: path24, kind: "directory" }));
       const directories = entries.filter((entry) => entry.kind === "directory").map((entry) => entry.path);
       this.emit({
         type: "directory_suggestions_response",
@@ -38015,6 +39161,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
    */
@@ -40676,17 +41920,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 }
@@ -40695,12 +41939,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,
@@ -40711,16 +41955,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,
@@ -40730,44 +41974,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) {
@@ -41593,11 +43040,11 @@ var LoopRecordSchema2 = z39.object({
 });
 var StoredLoopsSchema = z39.array(LoopRecordSchema2);
 
-// ../server/src/server/workflow/store.ts
+// ../server/src/server/quest/store.ts
 import { z as z40 } from "zod";
-var StoredWorkflowsSchema = z40.array(WorkflowRecordSchema);
+var StoredQuestsSchema = z40.array(QuestRecordSchema);
 
-// ../server/src/server/workflow/runner-ralph.ts
+// ../server/src/server/quest/runner-ralph.ts
 import { promisify as promisify4 } from "node:util";
 import { execFile as execFile3 } from "node:child_process";
 var execFileAsync3 = promisify4(execFile3);
@@ -41643,16 +43090,16 @@ function isRelayClientWebSocketUrl(url) {
 }
 
 // ../server/src/server/config.ts
-import path16 from "node:path";
+import path17 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 path15 from "node:path";
+import path16 from "node:path";
 import { z as z42 } from "zod";
-var DEFAULT_LOCAL_MODELS_SUBDIR = path15.join("models", "local-speech");
+var DEFAULT_LOCAL_MODELS_SUBDIR = path16.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();
@@ -41679,7 +43126,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 ?? path15.join(params.appostleHome, DEFAULT_LOCAL_MODELS_SUBDIR),
+    modelsDir: params.env.APPOSTLE_LOCAL_MODELS_DIR ?? params.persisted.providers?.local?.modelsDir ?? path16.join(params.appostleHome, DEFAULT_LOCAL_MODELS_SUBDIR),
     dictationLocalSttModel: params.env.APPOSTLE_DICTATION_LOCAL_STT_MODEL ?? persistedLocalFeatureModel(
       params.providers.dictationStt.provider,
       params.providers.dictationStt.enabled,
@@ -41935,7 +43382,7 @@ function loadConfig(appostleHome, options) {
     chromeEnabled,
     mcpDebug: env.MCP_DEBUG === "1",
     daemonIcon,
-    agentStoragePath: path16.join(appostleHome, "agents"),
+    agentStoragePath: path17.join(appostleHome, "agents"),
     staticDir: "public",
     agentClients: {},
     relayEnabled,
@@ -43153,12 +44600,12 @@ var DaemonClient = class {
       timeout: 1e4
     });
   }
-  async openInEditor(path23, editorId, requestId) {
+  async openInEditor(path24, editorId, requestId) {
     return this.sendCorrelatedSessionRequest({
       requestId,
       message: {
         type: "open_in_editor_request",
-        path: path23,
+        path: path24,
         editorId
       },
       responseType: "open_in_editor_response",
@@ -43367,6 +44814,7 @@ var DaemonClient = class {
       agentId,
       ...updates.name !== void 0 ? { name: updates.name } : {},
       ...updates.labels && Object.keys(updates.labels).length > 0 ? { labels: updates.labels } : {},
+      ...updates.internal !== void 0 ? { internal: updates.internal } : {},
       requestId
     });
     const payload = await this.sendRequest({
@@ -44419,13 +45867,13 @@ var DaemonClient = class {
   // ============================================================================
   // File Explorer
   // ============================================================================
-  async exploreFileSystem(cwd, path23, mode = "list", requestId) {
+  async exploreFileSystem(cwd, path24, mode = "list", requestId) {
     return this.sendCorrelatedSessionRequest({
       requestId,
       message: {
         type: "file_explorer_request",
         cwd,
-        path: path23,
+        path: path24,
         mode
       },
       responseType: "file_explorer_response",
@@ -44437,13 +45885,13 @@ var DaemonClient = class {
    * allowlists extensions (currently `.md` only) — callers don't need to
    * re-check. Used by the plan-todos UI to rewrite plan-file frontmatter.
    */
-  async writeFile(cwd, path23, content, requestId) {
+  async writeFile(cwd, path24, content, requestId) {
     return this.sendCorrelatedSessionRequest({
       requestId,
       message: {
         type: "file_write_request",
         cwd,
-        path: path23,
+        path: path24,
         content
       },
       responseType: "file_write_response",
@@ -44456,30 +45904,54 @@ var DaemonClient = class {
    * action is the only consumer). Returns the daemon's structured response
    * so callers can surface the error in the UI.
    */
-  async deleteFile(cwd, path23, requestId) {
+  async deleteFile(cwd, path24, requestId) {
     return this.sendCorrelatedSessionRequest({
       requestId,
       message: {
         type: "file_delete_request",
         cwd,
-        path: path23
+        path: path24
       },
       responseType: "file_delete_response",
       timeout: 1e4
     });
   }
-  async requestDownloadToken(cwd, path23, requestId) {
+  async requestDownloadToken(cwd, path24, requestId) {
     return this.sendCorrelatedSessionRequest({
       requestId,
       message: {
         type: "file_download_token_request",
         cwd,
-        path: path23
+        path: path24
       },
       responseType: "file_download_token_response",
       timeout: 1e4
     });
   }
+  async explorerDeleteEntry(cwd, path24, requestId) {
+    return this.sendCorrelatedSessionRequest({
+      requestId,
+      message: { type: "file_explorer_delete_request", cwd, path: path24 },
+      responseType: "file_explorer_delete_response",
+      timeout: 1e4
+    });
+  }
+  async explorerMkdir(cwd, path24, requestId) {
+    return this.sendCorrelatedSessionRequest({
+      requestId,
+      message: { type: "file_mkdir_request", cwd, path: path24 },
+      responseType: "file_mkdir_response",
+      timeout: 1e4
+    });
+  }
+  async explorerMoveEntry(cwd, sourcePath, destinationPath, requestId) {
+    return this.sendCorrelatedSessionRequest({
+      requestId,
+      message: { type: "file_move_request", cwd, sourcePath, destinationPath },
+      responseType: "file_move_response",
+      timeout: 1e4
+    });
+  }
   async requestProjectIcon(cwd, requestId) {
     return this.sendCorrelatedSessionRequest({
       requestId,
@@ -45214,61 +46686,177 @@ var DaemonClient = class {
       timeout: 1e4
     });
   }
-  async workflowRun(options) {
+  async questRun(options) {
     return this.sendCorrelatedSessionRequest({
       requestId: options.requestId,
       message: {
-        type: "workflow/run",
+        type: "quest/run",
         kind: options.kind,
         cwd: options.cwd,
         prompt: options.prompt,
         ...options.defaultProvider ? { defaultProvider: options.defaultProvider } : {},
-        ...options.defaultModel !== void 0 ? { defaultModel: options.defaultModel } : {},
+        ...options.defaultModel ? { defaultModel: options.defaultModel } : {},
         termination: options.termination,
         ...options.cards ? { cards: [...options.cards] } : {},
         ...typeof options.summarizerEnabled === "boolean" ? { summarizerEnabled: options.summarizerEnabled } : {}
       },
-      responseType: "workflow/run/response",
+      responseType: "quest/run/response",
       timeout: 15e3
     });
   }
-  async workflowList(requestId) {
+  async questList(requestId) {
     return this.sendCorrelatedSessionRequest({
       requestId,
-      message: { type: "workflow/list" },
-      responseType: "workflow/list/response",
+      message: { type: "quest/list" },
+      responseType: "quest/list/response",
       timeout: 1e4
     });
   }
-  async workflowInspect(options) {
+  async questInspect(options) {
     const normalized = typeof options === "string" ? { id: options } : options;
     return this.sendCorrelatedSessionRequest({
       requestId: normalized.requestId,
-      message: { type: "workflow/inspect", id: normalized.id },
-      responseType: "workflow/inspect/response",
+      message: { type: "quest/inspect", id: normalized.id },
+      responseType: "quest/inspect/response",
       timeout: 1e4
     });
   }
-  async workflowStop(options) {
+  async questStop(options) {
     const normalized = typeof options === "string" ? { id: options } : options;
     return this.sendCorrelatedSessionRequest({
       requestId: normalized.requestId,
-      message: { type: "workflow/stop", id: normalized.id },
-      responseType: "workflow/stop/response",
+      message: { type: "quest/stop", id: normalized.id },
+      responseType: "quest/stop/response",
+      timeout: 1e4
+    });
+  }
+  async rolesList(options = {}) {
+    return this.sendCorrelatedSessionRequest({
+      requestId: options.requestId,
+      message: {
+        type: "roles/list",
+        ...options.workspaceRoot ? { workspaceRoot: options.workspaceRoot } : {}
+      },
+      responseType: "roles/list/response",
       timeout: 1e4
     });
   }
-  async agentsList(options = {}) {
+  async rolesListScope(options) {
     return this.sendCorrelatedSessionRequest({
       requestId: options.requestId,
       message: {
-        type: "agents/list",
+        type: "roles/list-scope",
+        scope: options.scope,
         ...options.workspaceRoot ? { workspaceRoot: options.workspaceRoot } : {}
       },
-      responseType: "agents/list/response",
+      responseType: "roles/list-scope/response",
       timeout: 1e4
     });
   }
+  async rolesCreate(options) {
+    return this.sendCorrelatedSessionRequest({
+      requestId: options.requestId,
+      message: {
+        type: "roles/create",
+        scope: options.scope,
+        name: options.name,
+        ...options.category ? { category: options.category } : {},
+        ...options.workspaceRoot ? { workspaceRoot: options.workspaceRoot } : {}
+      },
+      responseType: "roles/create/response",
+      timeout: 1e4
+    });
+  }
+  async rolesWriteFrontmatter(options) {
+    return this.sendCorrelatedSessionRequest({
+      requestId: options.requestId,
+      message: {
+        type: "roles/write-frontmatter",
+        path: options.path,
+        frontmatter: options.frontmatter,
+        ...options.workspaceRoot ? { workspaceRoot: options.workspaceRoot } : {}
+      },
+      responseType: "roles/write-frontmatter/response",
+      timeout: 1e4
+    });
+  }
+  async rolesMove(options) {
+    return this.sendCorrelatedSessionRequest({
+      requestId: options.requestId,
+      message: {
+        type: "roles/move",
+        path: options.path,
+        ...options.newName ? { newName: options.newName } : {},
+        ...options.newCategory !== void 0 ? { newCategory: options.newCategory } : {},
+        ...options.workspaceRoot ? { workspaceRoot: options.workspaceRoot } : {}
+      },
+      responseType: "roles/move/response",
+      timeout: 1e4
+    });
+  }
+  async brandsListScope(options) {
+    return this.sendCorrelatedSessionRequest({
+      requestId: options.requestId,
+      message: {
+        type: "brands/list-scope",
+        ...options.workspaceRoot ? { workspaceRoot: options.workspaceRoot } : {}
+      },
+      responseType: "brands/list-scope/response",
+      timeout: 1e4
+    });
+  }
+  async brandsCreate(options) {
+    return this.sendCorrelatedSessionRequest({
+      requestId: options.requestId,
+      message: {
+        type: "brands/create",
+        name: options.name,
+        ...options.workspaceRoot ? { workspaceRoot: options.workspaceRoot } : {}
+      },
+      responseType: "brands/create/response",
+      timeout: 1e4
+    });
+  }
+  async brandsWriteFrontmatter(options) {
+    return this.sendCorrelatedSessionRequest({
+      requestId: options.requestId,
+      message: {
+        type: "brands/write-frontmatter",
+        path: options.path,
+        frontmatter: options.frontmatter,
+        ...options.workspaceRoot ? { workspaceRoot: options.workspaceRoot } : {}
+      },
+      responseType: "brands/write-frontmatter/response",
+      timeout: 1e4
+    });
+  }
+  async brandsAssetCopy(options) {
+    return this.sendCorrelatedSessionRequest({
+      requestId: options.requestId,
+      message: {
+        type: "brands/asset-copy",
+        workspaceRoot: options.workspaceRoot,
+        sourcePath: options.sourcePath,
+        targetName: options.targetName
+      },
+      responseType: "brands/asset-copy/response",
+      timeout: 15e3
+    });
+  }
+  async brandsAssetUpload(options) {
+    return this.sendCorrelatedSessionRequest({
+      requestId: options.requestId,
+      message: {
+        type: "brands/asset-upload",
+        workspaceRoot: options.workspaceRoot,
+        targetName: options.targetName,
+        ...options.sourceName ? { sourceName: options.sourceName } : {},
+        dataBase64: options.dataBase64
+      },
+      responseType: "brands/asset-upload/response",
+      timeout: 2e4
+    });
+  }
   onTerminalStreamEvent(handler) {
     this.terminalStreamListeners.add(handler);
     return () => {
@@ -45741,7 +47329,7 @@ function resolveAgentConfig(options) {
 }
 
 // ../cli/src/utils/client.ts
-import path17 from "node:path";
+import path18 from "node:path";
 import WebSocket3 from "ws";
 
 // ../cli/src/utils/client-id.ts
@@ -45817,7 +47405,7 @@ function isTcpDaemonHost(host) {
   return host !== null && !isIpcDaemonHost(host);
 }
 function readPidSocketTarget(appostleHome) {
-  const pidPath = path17.join(appostleHome, PID_FILENAME);
+  const pidPath = path18.join(appostleHome, PID_FILENAME);
   if (!existsSync10(pidPath)) {
     return null;
   }
@@ -46286,12 +47874,12 @@ function relativeTime(date) {
   if (seconds < 86400) return `${Math.floor(seconds / 3600)} hours ago`;
   return `${Math.floor(seconds / 86400)} days ago`;
 }
-function shortenPath(path23) {
+function shortenPath(path24) {
   const home = process.env.HOME;
-  if (home && path23.startsWith(home)) {
-    return "~" + path23.slice(home.length);
+  if (home && path24.startsWith(home)) {
+    return "~" + path24.slice(home.length);
   }
-  return path23;
+  return path24;
 }
 function normalizeModelId(modelId) {
   if (typeof modelId !== "string") return null;
@@ -47148,10 +48736,10 @@ function addSendOptions(cmd) {
 }
 async function readImageFiles(imagePaths) {
   const images = [];
-  for (const path23 of imagePaths) {
+  for (const path24 of imagePaths) {
     try {
-      const buffer = await readFile5(path23);
-      const ext = extname3(path23).toLowerCase();
+      const buffer = await readFile5(path24);
+      const ext = extname3(path24).toLowerCase();
       let mimeType = "image/jpeg";
       switch (ext) {
         case ".png":
@@ -47179,7 +48767,7 @@ async function readImageFiles(imagePaths) {
       const message = err instanceof Error ? err.message : String(err);
       const error = {
         code: "IMAGE_READ_ERROR",
-        message: `Failed to read image file: ${path23}`,
+        message: `Failed to read image file: ${path24}`,
         details: message
       };
       throw error;
@@ -47352,12 +48940,12 @@ function createInspectSchema(agent) {
     serialize: (_item) => agent
   };
 }
-function shortenPath2(path23) {
+function shortenPath2(path24) {
   const home = process.env.HOME;
-  if (home && path23.startsWith(home)) {
-    return "~" + path23.slice(home.length);
+  if (home && path24.startsWith(home)) {
+    return "~" + path24.slice(home.length);
   }
-  return path23;
+  return path24;
 }
 function formatCost(costUsd) {
   if (costUsd === 0) return "$0.00";
@@ -48325,7 +49913,7 @@ import chalk3 from "chalk";
 import { spawn as spawn7, spawnSync } from "node:child_process";
 import { existsSync as existsSync11, readFileSync as readFileSync8 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
-import path18 from "node:path";
+import path19 from "node:path";
 import { fileURLToPath } from "node:url";
 var DETACHED_STARTUP_GRACE_MS = 1200;
 var PID_POLL_INTERVAL_MS = 100;
@@ -48376,7 +49964,7 @@ function buildChildEnv(options) {
 function resolveDaemonRunnerEntry() {
   try {
     const here = fileURLToPath(import.meta.url);
-    const sibling = path18.join(path18.dirname(here), "supervisor-entrypoint.js");
+    const sibling = path19.join(path19.dirname(here), "supervisor-entrypoint.js");
     if (existsSync11(sibling)) {
       return sibling;
     }
@@ -48390,23 +49978,23 @@ function resolveDaemonRunnerEntry() {
       "Unable to resolve @appostle/server package root for daemon runner (and no sibling supervisor-entrypoint.js was bundled)"
     );
   }
-  let currentDir = path18.dirname(serverExportPath);
+  let currentDir = path19.dirname(serverExportPath);
   while (true) {
-    const packageJsonPath = path18.join(currentDir, "package.json");
+    const packageJsonPath = path19.join(currentDir, "package.json");
     if (existsSync11(packageJsonPath)) {
       try {
         const packageJson = JSON.parse(readFileSync8(packageJsonPath, "utf-8"));
         if (packageJson.name === "@appostle/server") {
-          const distRunner = path18.join(currentDir, "dist", "scripts", "supervisor-entrypoint.js");
+          const distRunner = path19.join(currentDir, "dist", "scripts", "supervisor-entrypoint.js");
           if (existsSync11(distRunner)) {
             return distRunner;
           }
-          return path18.join(currentDir, "scripts", "supervisor-entrypoint.ts");
+          return path19.join(currentDir, "scripts", "supervisor-entrypoint.ts");
         }
       } catch {
       }
     }
-    const parentDir = path18.dirname(currentDir);
+    const parentDir = path19.dirname(currentDir);
     if (parentDir === currentDir) {
       break;
     }
@@ -48415,7 +50003,7 @@ function resolveDaemonRunnerEntry() {
   throw new Error("Unable to resolve @appostle/server package root for daemon runner");
 }
 function pidFilePath(appostleHome) {
-  return path18.join(appostleHome, DAEMON_PID_FILENAME);
+  return path19.join(appostleHome, DAEMON_PID_FILENAME);
 }
 function readPidFile(pidPath) {
   try {
@@ -48557,7 +50145,7 @@ function resolveLocalDaemonState(options = {}) {
   const home = resolveAppostleHome(env);
   const config = loadConfig(home, { env });
   const pidPath = pidFilePath(home);
-  const logPath = path18.join(home, DAEMON_LOG_FILENAME);
+  const logPath = path19.join(home, DAEMON_LOG_FILENAME);
   const pidInfo = existsSync11(pidPath) ? readPidFile(pidPath) : null;
   const running = pidInfo ? isProcessRunning(pidInfo.pid) : false;
   const listen = pidInfo?.listen ?? config.listen;
@@ -48572,7 +50160,7 @@ function resolveLocalDaemonState(options = {}) {
   };
 }
 function tailDaemonLog(home, lines = 30) {
-  const logPath = path18.join(resolveLocalAppostleHome(home), DAEMON_LOG_FILENAME);
+  const logPath = path19.join(resolveLocalAppostleHome(home), DAEMON_LOG_FILENAME);
   return tailFile(logPath, lines);
 }
 async function startLocalDaemonDetached(options) {
@@ -48581,7 +50169,7 @@ async function startLocalDaemonDetached(options) {
   }
   const childEnv = buildChildEnv(options);
   const appostleHome = resolveAppostleHome(childEnv);
-  const logPath = path18.join(appostleHome, DAEMON_LOG_FILENAME);
+  const logPath = path19.join(appostleHome, DAEMON_LOG_FILENAME);
   const daemonRunnerEntry = resolveDaemonRunnerEntry();
   const child = spawn7(
     process.execPath,
@@ -51307,15 +52895,15 @@ import { Command as Command13 } from "commander";
 // ../cli/src/commands/worktree/ls.ts
 import { homedir as homedir7 } from "node:os";
 import { basename as basename7, join as join11, sep as sep3 } from "node:path";
-function shortenPath3(path23) {
+function shortenPath3(path24) {
   const home = process.env.HOME;
-  if (home && path23.startsWith(home)) {
-    return "~" + path23.slice(home.length);
+  if (home && path24.startsWith(home)) {
+    return "~" + path24.slice(home.length);
   }
-  return path23;
+  return path24;
 }
-function extractWorktreeName(path23) {
-  return basename7(path23);
+function extractWorktreeName(path24) {
+  return basename7(path24);
 }
 function resolveAppostleHomePath() {
   return process.env.APPOSTLE_HOME ?? join11(homedir7(), ".appostle");
@@ -51395,7 +52983,7 @@ async function runLsCommand7(options, _command) {
 }
 
 // ../cli/src/commands/worktree/archive.ts
-import path19 from "path";
+import path20 from "path";
 var archiveSchema2 = {
   idField: "name",
   columns: [
@@ -51439,7 +53027,7 @@ async function runArchiveCommand2(nameArg, options, _command) {
       throw error;
     }
     const worktree = listResponse.worktrees.find((wt) => {
-      const name = path19.basename(wt.worktreePath);
+      const name = path20.basename(wt.worktreePath);
       return name === nameArg || wt.branchName === nameArg;
     });
     if (!worktree) {
@@ -51461,7 +53049,7 @@ async function runArchiveCommand2(nameArg, options, _command) {
       };
       throw error;
     }
-    const worktreeName = path19.basename(worktree.worktreePath) || nameArg;
+    const worktreeName = path20.basename(worktree.worktreePath) || nameArg;
     return {
       type: "single",
       data: {
@@ -51502,7 +53090,7 @@ function createWorktreeCommand() {
 import { cancel, confirm, intro, isCancel, log, note, outro, spinner } from "@clack/prompts";
 import { Command as Command14, Option as Option4 } from "commander";
 import { writeFileSync as writeFileSync5 } from "node:fs";
-import path20 from "node:path";
+import path21 from "node:path";
 var DEFAULT_READY_TIMEOUT_MS = 10 * 60 * 1e3;
 var OnboardCancelledError = class extends Error {
 };
@@ -51545,7 +53133,7 @@ function toCliOverrides(options) {
   return cliOverrides;
 }
 function savePersistedConfig2(appostleHome, config) {
-  const configPath = path20.join(appostleHome, "config.json");
+  const configPath = path21.join(appostleHome, "config.json");
   writeFileSync5(configPath, `${JSON.stringify(config, null, 2)}
 `);
 }
@@ -51666,7 +53254,7 @@ ${recentLogs}` : null
   );
 }
 function printNextSteps(pairingUrl, appostleHome, richUi) {
-  const daemonLogPath = path20.join(appostleHome, "daemon.log");
+  const daemonLogPath = path21.join(appostleHome, "daemon.log");
   const nextStepsLines = [
     pairingUrl ? "1. Open Appostle and scan the QR code above, or paste the pairing link." : "1. Open Appostle and connect to your daemon.",
     "2. Web app: https://appostle.app",
@@ -51920,18 +53508,18 @@ function createCli() {
 // ../cli/src/classify.ts
 import { existsSync as existsSync12, statSync as statSync3 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
-import path21 from "node:path";
+import path22 from "node:path";
 function expandUserPath2(inputPath) {
   if (inputPath === "~") {
     return homedir8();
   }
   if (inputPath.startsWith("~/")) {
-    return path21.join(homedir8(), inputPath.slice(2));
+    return path22.join(homedir8(), inputPath.slice(2));
   }
   return inputPath;
 }
 function isExistingDirectory(input) {
-  const resolvedPath = path21.resolve(input.cwd, expandUserPath2(input.pathArg));
+  const resolvedPath = path22.resolve(input.cwd, expandUserPath2(input.pathArg));
   if (!existsSync12(resolvedPath)) {
     return false;
   }
@@ -51951,7 +53539,7 @@ function classifyInvocation(input) {
   if (isExistingDirectory({ pathArg: firstArg, cwd: input.cwd })) {
     return {
       kind: "open-project",
-      resolvedPath: path21.resolve(input.cwd, expandUserPath2(firstArg))
+      resolvedPath: path22.resolve(input.cwd, expandUserPath2(firstArg))
     };
   }
   return { kind: "cli", argv: input.argv };
@@ -51961,12 +53549,12 @@ function classifyInvocation(input) {
 import { existsSync as existsSync13 } from "node:fs";
 import { spawn as spawn8 } from "node:child_process";
 import { homedir as homedir9 } from "node:os";
-import path22 from "node:path";
+import path23 from "node:path";
 function findDesktopApp() {
   if (process.platform === "darwin") {
     const candidates = [
       "/Applications/Appostle.app",
-      path22.join(homedir9(), "Applications", "Appostle.app")
+      path23.join(homedir9(), "Applications", "Appostle.app")
     ];
     for (const candidate of candidates) {
       if (existsSync13(candidate)) {
@@ -51979,7 +53567,7 @@ function findDesktopApp() {
     const candidates = [
       "/usr/bin/Appostle",
       "/opt/Appostle/Appostle",
-      path22.join(homedir9(), "Applications", "Appostle.AppImage")
+      path23.join(homedir9(), "Applications", "Appostle.AppImage")
     ];
     for (const candidate of candidates) {
       if (existsSync13(candidate)) {
@@ -51993,7 +53581,7 @@ function findDesktopApp() {
     if (!localAppData) {
       return null;
     }
-    const candidate = path22.join(localAppData, "Programs", "Appostle", "Appostle.exe");
+    const candidate = path23.join(localAppData, "Programs", "Appostle", "Appostle.exe");
     return existsSync13(candidate) ? candidate : null;
   }
   return null;