@prismer/runtime 1.9.9 → 1.9.22

package/dist/index.cjs

@@ -33,7 +33,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/cli/ui.ts
 function thisDirname() {
   try {
-    return path8.dirname((0, import_node_url2.fileURLToPath)(import_meta2.url));
+    return path6.dirname((0, import_node_url.fileURLToPath)(import_meta2.url));
   } catch {
     return process.cwd();
   }
@@ -43,18 +43,18 @@ function findIconPath(size = "big") {
   const here = thisDirname();
   const candidates = [
     // npm-installed: node_modules/@prismer/runtime/dist/cli.js → ../assets
-    path8.resolve(here, "../assets", name),
+    path6.resolve(here, "../assets", name),
     // alternate dist layout (sub-bundle): dist/bin/cli.js → ../../assets
-    path8.resolve(here, "../../assets", name),
+    path6.resolve(here, "../../assets", name),
     // source/typecheck: src/cli/ui.ts → ../../assets
-    path8.resolve(here, "../../assets", name),
+    path6.resolve(here, "../../assets", name),
     // dev mode: cwd happens to be runtime root
-    path8.resolve(process.cwd(), "assets", name),
-    path8.resolve(process.cwd(), "sdk/prismer-cloud/runtime/assets", name)
+    path6.resolve(process.cwd(), "assets", name),
+    path6.resolve(process.cwd(), "sdk/prismer-cloud/runtime/assets", name)
   ];
   for (const candidate of candidates) {
     try {
-      if (fs5.existsSync(candidate)) return candidate;
+      if (fs4.existsSync(candidate)) return candidate;
     } catch {
     }
   }
@@ -95,13 +95,13 @@ function applyCommonFlags(argv) {
   }
   return { mode, color: color2, restArgv: rest };
 }
-var fs5, path8, import_node_url2, import_meta2, BRAILLE_FRAMES, COMPACT_BANNER, UI, _ui;
+var fs4, path6, import_node_url, import_meta2, BRAILLE_FRAMES, COMPACT_BANNER, UI, _ui;
 var init_ui = __esm({
   "src/cli/ui.ts"() {
     "use strict";
-    fs5 = __toESM(require("fs"), 1);
-    path8 = __toESM(require("path"), 1);
-    import_node_url2 = require("url");
+    fs4 = __toESM(require("fs"), 1);
+    path6 = __toESM(require("path"), 1);
+    import_node_url = require("url");
     import_meta2 = {};
     BRAILLE_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
     COMPACT_BANNER = ["\u25C7 PRISMER", "  Runtime CLI"];
@@ -182,7 +182,7 @@ var init_ui = __esm({
         const iconPath = findIconPath("small");
         if (iconPath !== null) {
           try {
-            const raw = fs5.readFileSync(iconPath, "utf-8").replace(/\n+$/, "");
+            const raw = fs4.readFileSync(iconPath, "utf-8").replace(/\n+$/, "");
             for (const line of raw.split("\n")) {
               this.write(this.cyan(line) + "\n");
             }
@@ -205,7 +205,7 @@ var init_ui = __esm({
         const shouldUseFull = opts?.full === true || width >= 120;
         if (shouldUseFull && iconPath !== null) {
           try {
-            const raw = fs5.readFileSync(iconPath, "utf-8");
+            const raw = fs4.readFileSync(iconPath, "utf-8");
             const lines = raw.split("\n");
             for (const line of lines) {
               const brandedLine = line.replace("Prismer Cloud SDK", "Prismer Runtime CLI");
@@ -469,7 +469,7 @@ __export(util_exports, {
   info: () => info,
   normalizeCloudUrl: () => normalizeCloudUrl,
   ok: () => ok,
-  pidAlive: () => pidAlive2,
+  pidAlive: () => pidAlive,
   pidFilePath: () => pidFilePath,
   printBanner: () => printBanner,
   printJson: () => printJson,
@@ -544,10 +544,10 @@ function runAction(fn, opts = {}) {
 function printBanner(opts = {}) {
   const ui = getUI();
   if (opts.compact) {
-    ui.smallHeader("Runtime CLI v1.9.7");
+    ui.smallHeader("Runtime CLI v${VERSION}");
     return;
   }
-  ui.banner("Runtime CLI v1.9.7", { full: true });
+  ui.banner("Runtime CLI v${VERSION}", { full: true });
 }
 function ok(label, detail) {
   getUI().ok(label, detail);
@@ -573,29 +573,29 @@ function table(rows, columns) {
   getUI().table(rows, { columns });
 }
 function pidFilePath(paths) {
-  return (0, import_node_path11.join)(paths.root, "daemon.pid");
+  return (0, import_node_path8.join)(paths.root, "daemon.pid");
 }
 function writePidFile(paths, pid) {
-  (0, import_node_fs15.writeFileSync)(pidFilePath(paths), `${pid}
+  (0, import_node_fs12.writeFileSync)(pidFilePath(paths), `${pid}
 `, "utf8");
 }
 function readPidFile(paths) {
   const p = pidFilePath(paths);
-  if (!(0, import_node_fs15.existsSync)(p)) return void 0;
-  const raw = (0, import_node_fs15.readFileSync)(p, "utf8").trim();
+  if (!(0, import_node_fs12.existsSync)(p)) return void 0;
+  const raw = (0, import_node_fs12.readFileSync)(p, "utf8").trim();
   const pid = Number.parseInt(raw, 10);
   return Number.isFinite(pid) ? pid : void 0;
 }
 function clearPidFile(paths) {
   const p = pidFilePath(paths);
-  if ((0, import_node_fs15.existsSync)(p)) {
+  if ((0, import_node_fs12.existsSync)(p)) {
     try {
-      (0, import_node_fs15.unlinkSync)(p);
+      (0, import_node_fs12.unlinkSync)(p);
     } catch {
     }
   }
 }
-function pidAlive2(pid) {
+function pidAlive(pid) {
   try {
     process.kill(pid, 0);
     return true;
@@ -603,12 +603,12 @@ function pidAlive2(pid) {
     return false;
   }
 }
-var import_node_fs15, import_node_path11, DEFAULT_CLOUD_BASE_URL, ANSI;
+var import_node_fs12, import_node_path8, DEFAULT_CLOUD_BASE_URL, ANSI;
 var init_util = __esm({
   "src/cli/util.ts"() {
     "use strict";
-    import_node_fs15 = require("fs");
-    import_node_path11 = require("path");
+    import_node_fs12 = require("fs");
+    import_node_path8 = require("path");
     init_ui();
     DEFAULT_CLOUD_BASE_URL = "https://prismer.cloud";
     ANSI = {
@@ -729,35 +729,14 @@ var AdapterRegistry = class {
 // src/adapters/hermes/index.ts
 var import_node_child_process = require("child_process");
 var import_node_fs = require("fs");
-var import_node_module = require("module");
 var import_node_os = require("os");
 var import_node_path = require("path");
-var import_node_url = require("url");
 var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
 var YAML = __toESM(require("yaml"), 1);
 var import_zod = require("zod");
 var import_meta = {};
 var PRISMER_IM_SKILL_NAME = "prismer-im-collab";
-var PRISMER_IM_SKILL_CONTENT = `---
-name: prismer-im-collab
-description: Coordinate reliably in Prismer conversations, use workspace assets through bounded MCP tools, and keep task work on the board.
-allowed-tools: prismer.agent.send prismer.conversation.listAgents prismer.task.create prismer.task.update prismer.task.complete prismer.approval.request_human_approval prismer.asset.search prismer.asset.describe prismer.asset.read
-metadata:
-  prismer:
-    version: "1.0.0"
-    mcp_tools:
-      - prismer.agent.send
-      - prismer.conversation.listAgents
-      - prismer.task.create
-      - prismer.task.update
-      - prismer.task.complete
-      - prismer.approval.request_human_approval
-      - prismer.asset.search
-      - prismer.asset.describe
-      - prismer.asset.read
----
-
-# Prismer IM Collaboration
+var PRISMER_IM_SKILL_CONTENT = `# Prismer IM Collaboration
 
 You are an agent in a Prismer multi-agent workspace. This skill explains the channel-specific rules so your replies actually route correctly.
 
@@ -787,19 +766,6 @@ You will receive a \`[Channel context]\` block at the top of each prompt indicat
 | Address another agent so the platform dispatches your message to them | Call \`prismer.agent.send\` (from the \`prismer-tasks\` MCP server). |
 | Look up which agents you can talk to | Call \`prismer.conversation.listAgents\` before guessing usernames. |
 | Create / update tasks on the workspace board | \`prismer.task.create\` / \`prismer.task.update\` from \`prismer-tasks\` MCP. |
-| Ask for structured human sign-off | \`prismer.approval.request_human_approval\`. |
-| Find uploaded workspace files | \`prismer.asset.search\`. |
-| Inspect file metadata before reading bytes | \`prismer.asset.describe\`. |
-| Read a bounded byte range from a file | \`prismer.asset.read\`. |
-
-## Workspace asset rules
-
-- Web-uploaded workspace files are available as asset metadata first; bytes are fetched lazily by the local daemon.
-- When a task needs file content, call \`prismer.asset.describe\` first, then read only the needed range with \`prismer.asset.read\`.
-- For many files, call \`prismer.asset.search\` to find candidates. Do not ask the user to paste file contents already present in workspace assets.
-- Do not claim you read a file unless an asset tool call succeeded.
-- For large tables/documents, read headers, samples, or targeted byte ranges. Never try to load the whole file into a reply.
-- Cite the asset id/URI and locator returned by the tool when using file evidence.
 
 ### When to use \`prismer.agent.send\` vs inline \`@\`
 
@@ -813,7 +779,6 @@ You will receive a \`[Channel context]\` block at the top of each prompt indicat
 2. **Don't fabricate usernames.** If \`prismer.conversation.listAgents\` doesn't return a name, that agent doesn't exist; use plain text and address them by displayName (no @).
 3. **Don't pretend to call a tool.** If you write "I sent a message via the tool" without actually invoking the tool, the message doesn't exist; the human will see the inconsistency.
 4. **Check tool return values.** \`prismer.agent.send\` may return \`{ ok: false, error: 'agent_not_found' }\`; surface the error rather than pretending it worked.
-5. **Use structured approvals.** For destructive, irreversible, external, spend, access, or publish operations, call \`prismer.approval.request_human_approval\`; do not inline-mention a human asking for approval.
 
 ## Example: group discussion handoff
 
@@ -901,23 +866,7 @@ var HermesProfileConfigSchema = import_zod.z.object({
   hermesSourceDir: import_zod.z.string().optional(),
   nativeMirrorTimeoutMs: import_zod.z.number().int().positive().default(2e3),
   /** Task authority level: executor (default) or orchestrator. */
-  taskAuthority: import_zod.z.enum(["executor", "orchestrator"]).optional().default("executor"),
-  /** Human approval escalation policy. Enforcement is currently prompt/cloud-side. */
-  approvalPolicy: import_zod.z.enum(["strict", "auto-low-risk", "autonomous"]).optional().default("auto-low-risk"),
-  /** Agent-level MCP tool allowlist. Empty/null means all tools. Supports exact names and trailing * wildcards. */
-  mcpAllowlist: import_zod.z.array(import_zod.z.string()).nullable().optional(),
-  /** Agent-level operating principles injected through /v1/runs instructions. */
-  operatingPrinciples: import_zod.z.union([import_zod.z.string(), import_zod.z.record(import_zod.z.string())]).optional(),
-  /**
-   * Role-template snapshot carried in AgentProfile.config by cloud ACP.
-   * Expected fields used here:
-   *   - roleTemplate.mcpServers[].toolsAllowlist
-   *   - roleTemplate.operatingPrinciples
-   */
-  roleTemplate: import_zod.z.object({
-    mcpServers: import_zod.z.array(import_zod.z.object({ toolsAllowlist: import_zod.z.array(import_zod.z.string()).optional() }).passthrough()).optional(),
-    operatingPrinciples: import_zod.z.union([import_zod.z.string(), import_zod.z.record(import_zod.z.string())]).optional()
-  }).passthrough().optional()
+  taskAuthority: import_zod.z.enum(["executor", "orchestrator"]).optional().default("executor")
 });
 var hermesAdapter = {
   name: "hermes",
@@ -932,22 +881,14 @@ var hermesAdapter = {
       errors: r.error.issues.map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`)
     };
   },
-  async prepareProfile(profile) {
-    const config = HermesProfileConfigSchema.parse(profile.config);
-    if (config.configurePrismerProvider) {
-      const profileName = getHermesProfileName(profile);
-      const agentUsername = profile.agentUsername || profileName;
-      configurePrismerProvider(profileName, config, agentUsername, profile.workspaceId);
-    }
-  },
   async ensureService(profile) {
     const config = HermesProfileConfigSchema.parse(profile.config);
-    const profileName = getHermesProfileName(profile);
-    const portOverride = config.port !== 8642 ? config.port : portForProfile(`${profileName}:${config.apiKey}`, 8642);
+    const profileName = config.hermesProfileName && config.hermesProfileName !== "default" ? config.hermesProfileName : profile.agentUsername || profile.id.slice(0, 8);
+    const portOverride = config.port !== 8642 ? config.port : portForProfile(profileName, 8642);
     const baseUrl = `http://127.0.0.1:${portOverride}`;
     const agentUsername = profile.agentUsername || profileName;
     if (config.configurePrismerProvider) {
-      configurePrismerProvider(profileName, config, agentUsername, profile.workspaceId);
+      configurePrismerProvider(profileName, config, agentUsername);
     }
     if (!await checkHealth(baseUrl, config.apiKey)) {
       if (!config.autoStart) {
@@ -957,7 +898,6 @@ var hermesAdapter = {
 (set autoStart: true on the AgentProfile to spawn it automatically)`
         );
       }
-      await stopStaleHermesGateways(profileName, portOverride, config.startupTimeoutMs);
       (0, import_node_child_process.spawn)("hermes", ["-p", profileName, "gateway", "run"], {
         detached: false,
         stdio: "ignore",
@@ -1017,8 +957,6 @@ var HermesService = class {
     const startedAt = Date.now();
     let runId;
     const sysPrompt = typeof task.metadata?.systemPrompt === "string" ? task.metadata.systemPrompt : void 0;
-    const operatingPrinciples = typeof task.metadata?.operatingPrinciples === "string" ? task.metadata.operatingPrinciples : void 0;
-    const instructions = [sysPrompt, operatingPrinciples].filter(Boolean).join("\n\n");
     if (sysPrompt) {
       try {
         const profileDir = getHermesProfileDir(this.profileName);
@@ -1055,7 +993,7 @@ var HermesService = class {
         // sent `messages: [...]` which Hermes 0.12 rejects with 400.
         body: JSON.stringify({
           input: task.prompt,
-          instructions: instructions || void 0,
+          instructions: sysPrompt,
           session_id: typeof task.metadata?.conversationId === "string" ? task.metadata.conversationId : void 0,
           stream: true
         }),
@@ -1340,7 +1278,7 @@ function formatHermesGoalText(goals) {
     return `${index + 1}. ${priority}${goal.title}${description}`;
   }).join("\n");
 }
-function configurePrismerProvider(profileName, config, agentUsername, workspaceId) {
+function configurePrismerProvider(profileName, config, agentUsername) {
   const baseUrl = resolvePrismerProviderBaseUrl(config);
   const apiKey = resolvePrismerApiKey(config);
   if (!baseUrl || !apiKey) {
@@ -1383,16 +1321,9 @@ function configurePrismerProvider(profileName, config, agentUsername, workspaceI
         PRISMER_API_KEY: apiKey,
         PRISMER_BASE_URL: baseUrl.replace(/\/api\/v1\/?$/, "")
       };
-      if (workspaceId) {
-        mcpEnv.PRISMER_WORKSPACE_ID = workspaceId;
-      }
       if (agentUsername) {
         mcpEnv.PRISMER_AGENT_USERNAME = agentUsername;
       }
-      const allowlist = resolveMcpAllowlist(config);
-      if (allowlist) {
-        mcpEnv.PRISMER_MCP_ALLOWLIST = allowlist.join(",");
-      }
       mcpServers["prismer-tasks"] = {
         command: "node",
         args: [serverPath],
@@ -1413,17 +1344,20 @@ function resolvePrismerMcpServerPath(config) {
   if (config.prismerMcpServerPath) return config.prismerMcpServerPath;
   if (process.env.PRISMER_MCP_SERVER) return process.env.PRISMER_MCP_SERVER;
   try {
-    const req = (0, import_node_module.createRequire)(import_meta.url);
+    const { createRequire } = require("module");
+    const req = createRequire(import_meta.url);
     return req.resolve("@prismer/mcp-server");
   } catch {
   }
   try {
-    const here = (0, import_node_path.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
-    const candidate = (0, import_node_path.join)(here, "../../mcp/dist/index.js");
+    const { fileURLToPath: fileURLToPath2 } = require("url");
+    const { join: join15, dirname: dirname8 } = require("path");
+    const here = dirname8(fileURLToPath2(import_meta.url));
+    const candidate = join15(here, "../../mcp/dist/index.js");
     if ((0, import_node_fs.existsSync)(candidate)) return candidate;
-    const candidate2 = (0, import_node_path.join)(here, "../../../mcp/dist/index.js");
+    const candidate2 = join15(here, "../../../mcp/dist/index.js");
     if ((0, import_node_fs.existsSync)(candidate2)) return candidate2;
-    const candidate3 = (0, import_node_path.join)(here, "../../../../mcp/dist/index.js");
+    const candidate3 = join15(here, "../../../../mcp/dist/index.js");
     if ((0, import_node_fs.existsSync)(candidate3)) return candidate3;
   } catch {
   }
@@ -1592,29 +1526,25 @@ function runPythonJson(args, env, timeoutMs) {
     });
   });
 }
-function readHermesConfig(path9) {
-  if (!(0, import_node_fs.existsSync)(path9)) return {};
+function readHermesConfig(path7) {
+  if (!(0, import_node_fs.existsSync)(path7)) return {};
   try {
-    return YAML.parse((0, import_node_fs.readFileSync)(path9, "utf8")) ?? {};
+    return YAML.parse((0, import_node_fs.readFileSync)(path7, "utf8")) ?? {};
   } catch (err) {
-    throw new Error(`Failed to parse Hermes config at ${path9}: ${err.message}`);
+    throw new Error(`Failed to parse Hermes config at ${path7}: ${err.message}`);
   }
 }
-function writeEnvValue(path9, key, value) {
-  (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(path9), { recursive: true });
-  const lines = (0, import_node_fs.existsSync)(path9) ? (0, import_node_fs.readFileSync)(path9, "utf8").split(/\r?\n/) : [];
+function writeEnvValue(path7, key, value) {
+  (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(path7), { recursive: true });
+  const lines = (0, import_node_fs.existsSync)(path7) ? (0, import_node_fs.readFileSync)(path7, "utf8").split(/\r?\n/) : [];
   const next = lines.filter((line) => !line.startsWith(`${key}=`) && line.trim() !== "");
   next.push(`${key}=${quoteEnv(value)}`);
-  (0, import_node_fs.writeFileSync)(path9, `${next.join("\n")}
+  (0, import_node_fs.writeFileSync)(path7, `${next.join("\n")}
 `, "utf8");
 }
 function quoteEnv(value) {
   return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
 }
-function getHermesProfileName(profile) {
-  const configured = profile.config && typeof profile.config.hermesProfileName === "string" ? profile.config.hermesProfileName : void 0;
-  return configured && configured !== "default" ? configured : profile.agentUsername || profile.id.slice(0, 8);
-}
 function getHermesProfileDir(profileName) {
   const root = process.env.HERMES_HOME || (0, import_node_path.join)((0, import_node_os.homedir)(), ".hermes");
   if (!profileName || profileName === "default") return root;
@@ -1636,18 +1566,6 @@ function resolvePrismerProviderBaseUrl(config) {
 function resolvePrismerApiKey(config) {
   return process.env[config.prismerApiKeyEnv] || process.env.PRISMER_API_KEY || "";
 }
-function resolveMcpAllowlist(config) {
-  if (Array.isArray(config.mcpAllowlist)) return normalizeAllowlist(config.mcpAllowlist);
-  const prismerServer = config.roleTemplate?.mcpServers?.find((server) => {
-    const record = server;
-    return record.package === "@prismer/mcp-server" || record.name === "prismer-tasks";
-  });
-  if (!prismerServer) return null;
-  return Array.isArray(prismerServer.toolsAllowlist) ? normalizeAllowlist(prismerServer.toolsAllowlist) : null;
-}
-function normalizeAllowlist(values) {
-  return values.map((value) => value.trim()).filter(Boolean);
-}
 function normalizeProviderName(value) {
   return value.trim().toLowerCase().replace(/\s+/g, "-");
 }
@@ -1753,66 +1671,6 @@ async function waitForHealthy(baseUrl, apiKey, timeoutMs) {
   }
   throw new Error(`Hermes did not become healthy at ${baseUrl} within ${timeoutMs}ms`);
 }
-async function stopStaleHermesGateways(profileName, port, timeoutMs) {
-  const pids = findHermesGatewayPids(profileName, port);
-  for (const pid of pids) {
-    try {
-      process.kill(pid, "SIGTERM");
-    } catch {
-      continue;
-    }
-  }
-  const deadline = Date.now() + Math.min(timeoutMs, 5e3);
-  while (Date.now() < deadline) {
-    const alive = pids.filter(pidAlive);
-    if (alive.length === 0) return;
-    await new Promise((r) => setTimeout(r, 100));
-  }
-  for (const pid of pids) {
-    if (!pidAlive(pid)) continue;
-    try {
-      process.kill(pid, "SIGKILL");
-    } catch {
-    }
-  }
-}
-function findHermesGatewayPids(profileName, port) {
-  try {
-    const out = (0, import_node_child_process.execFileSync)("ps", ["-axo", "pid=,command="], { encoding: "utf8" });
-    const current = process.pid;
-    const escapedProfile = escapeRegExp(profileName);
-    const profilePattern = new RegExp(`(?:^|\\s)-p\\s+${escapedProfile}(?:\\s|$)`);
-    const portPattern = new RegExp(`(?:^|\\s)API_SERVER_PORT=${port}(?:\\s|$)`);
-    return out.split(/\r?\n/).map((line) => {
-      const trimmed = line.trim();
-      const match = /^(\d+)\s+(.+)$/.exec(trimmed);
-      if (!match) return null;
-      const pid = Number.parseInt(match[1], 10);
-      const command = match[2];
-      if (!Number.isFinite(pid) || pid === current) return null;
-      if (!isHermesGatewayCommand(command)) return null;
-      if (!profilePattern.test(command) && !portPattern.test(command)) return null;
-      return pid;
-    }).filter((pid) => pid !== null);
-  } catch {
-    return [];
-  }
-}
-function isHermesGatewayCommand(command) {
-  if (!/\bgateway\b/.test(command) || !/\brun\b/.test(command)) return false;
-  return /(^|\s)(?:\S*\/)?hermes(?:\s|$)/.test(command);
-}
-function pidAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 
 // src/daemon/ws-client.ts
 var import_node_events = require("events");
@@ -2052,11 +1910,11 @@ var MIGRATIONS = [
 function runSql(db, sql) {
   db["exec"](sql);
 }
-function openLocalDb(path9) {
-  if (path9 !== ":memory:" && !(0, import_node_fs2.existsSync)((0, import_node_path2.dirname)(path9))) {
-    (0, import_node_fs2.mkdirSync)((0, import_node_path2.dirname)(path9), { recursive: true });
+function openLocalDb(path7) {
+  if (path7 !== ":memory:" && !(0, import_node_fs2.existsSync)((0, import_node_path2.dirname)(path7))) {
+    (0, import_node_fs2.mkdirSync)((0, import_node_path2.dirname)(path7), { recursive: true });
   }
-  const db = new import_better_sqlite32.default(path9);
+  const db = new import_better_sqlite32.default(path7);
   db.pragma("journal_mode = WAL");
   db.pragma("foreign_keys = ON");
   runMigrations(db);
@@ -2374,12 +2232,11 @@ function deriveWsUrl(httpBase) {
 }
 
 // src/daemon-id.ts
-var import_node_crypto = require("crypto");
 var import_node_os3 = require("os");
 var PREFIX = "daemon-";
 function newDaemonId() {
   const host = (0, import_node_os3.hostname)().replace(/[^a-zA-Z0-9_-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "") || "unknown";
-  return `${PREFIX}${host}-${(0, import_node_crypto.randomBytes)(6).toString("hex")}`;
+  return `${PREFIX}${host}`;
 }
 function isDaemonId(s) {
   return s.startsWith(PREFIX) && s.length > PREFIX.length;
@@ -2394,8 +2251,8 @@ var CloudClient = class {
   opts;
   fetchImpl;
   /** Low-level request. Caller decides on retry; sync-worker handles backoff. */
-  async request(method, path9, init) {
-    const url = this.urlFor(path9);
+  async request(method, path7, init) {
+    const url = this.urlFor(path7);
     const headers = {
       "Content-Type": "application/json",
       Accept: "application/json",
@@ -2454,8 +2311,8 @@ var CloudClient = class {
     return { ok: true, status: res.status, data: body ?? void 0 };
   }
   /** Convenience: GET expecting `{ ok, data }` envelope. Returns `data` or throws. */
-  async get(path9, opts) {
-    const res = await this.request("GET", path9, opts);
+  async get(path7, opts) {
+    const res = await this.request("GET", path7, opts);
     if (!res.ok) throw new CloudError(res.status, res.error?.code ?? "unknown", res.error?.message ?? "request failed");
     if (res.data && typeof res.data === "object" && "ok" in res.data) {
       const env = res.data;
@@ -2464,14 +2321,14 @@ var CloudClient = class {
     }
     return res.data;
   }
-  urlFor(path9) {
+  urlFor(path7) {
     const trimmedBase = this.opts.baseUrl.replace(/\/$/, "");
-    const trimmedPath = path9.startsWith("/") ? path9 : `/${path9}`;
+    const trimmedPath = path7.startsWith("/") ? path7 : `/${path7}`;
     return `${trimmedBase}${trimmedPath}`;
   }
   /** Raw byte download (for asset cache). Returns response so caller can stream body. */
-  async fetchRaw(path9, init) {
-    const url = this.urlFor(path9);
+  async fetchRaw(path7, init) {
+    const url = this.urlFor(path7);
     const headers = {
       Authorization: `Bearer ${this.opts.apiKey}`,
       ...init?.headers ?? {}
@@ -2520,7 +2377,6 @@ function envelope(type, payload, requestId) {
 }
 
 // src/asset-cache.ts
-var import_node_crypto2 = require("crypto");
 var import_node_fs4 = require("fs");
 var import_node_path4 = require("path");
 function rowToCached(row) {
@@ -2614,17 +2470,11 @@ var AssetCache = class {
       throw new Error(`Asset bytes fetch failed for ${hash} (id=${assetId}): HTTP ${res.status}`);
     }
     const buf = Buffer.from(await res.arrayBuffer());
-    const actualHash = sha256(buf);
-    if (actualHash !== hash) {
-      throw new Error(`Asset hash mismatch for ${hash}: downloaded ${actualHash}`);
-    }
     const localPath = this.pathFor(hash);
     if (!(0, import_node_fs4.existsSync)((0, import_node_path4.dirname)(localPath))) {
       (0, import_node_fs4.mkdirSync)((0, import_node_path4.dirname)(localPath), { recursive: true });
     }
-    const tmpPath = `${localPath}.${process.pid}.${Date.now()}.tmp`;
-    (0, import_node_fs4.writeFileSync)(tmpPath, buf);
-    (0, import_node_fs4.renameSync)(tmpPath, localPath);
+    (0, import_node_fs4.writeFileSync)(localPath, buf);
     const mime = res.headers.get("content-type");
     const now = Date.now();
     this.db.prepare(
@@ -2645,10 +2495,6 @@ var AssetCache = class {
   }
   /** Insert an already-on-disk asset into the cache (e.g., asset just produced by adapter). */
   registerLocal(hash, localPath, mime) {
-    const actualHash = sha256(readFileBuffer(localPath));
-    if (actualHash !== hash) {
-      throw new Error(`Asset hash mismatch for ${hash}: local file is ${actualHash}`);
-    }
     const size = (0, import_node_fs4.statSync)(localPath).size;
     const now = Date.now();
     this.db.prepare(
@@ -2688,12 +2534,6 @@ var AssetCache = class {
     return { removed, freed };
   }
 };
-function sha256(buf) {
-  return (0, import_node_crypto2.createHash)("sha256").update(buf).digest("hex");
-}
-function readFileBuffer(path9) {
-  return (0, import_node_fs4.readFileSync)(path9);
-}
 
 // src/daemon/asset/mirror.ts
 var import_node_fs5 = require("fs");
@@ -2790,8 +2630,8 @@ var WorkspaceMirror = class {
     return { applied, cursor: envelope2.cursor };
   }
   /** Lookup the active binding for a workspace path. Returns undefined if not mirrored. */
-  lookupByPath(path9) {
-    const row = this.db.prepare("SELECT * FROM workspace_files_mirror WHERE workspace_id = ? AND path = ?").get(this.workspaceId, path9);
+  lookupByPath(path7) {
+    const row = this.db.prepare("SELECT * FROM workspace_files_mirror WHERE workspace_id = ? AND path = ?").get(this.workspaceId, path7);
     return row ? rowToBinding(row) : void 0;
   }
   /** Find an asset's contentHash via any path binding (asset may map to many paths). */
@@ -3053,20 +2893,20 @@ var UriResolver = class {
     }
     return { texts: all, resolvedHashes: dedupe(allHashes) };
   }
-  async lookupFile(workspaceId, path9, signal) {
+  async lookupFile(workspaceId, path7, signal) {
     const local = this.db.prepare(
       "SELECT asset_id, content_hash, version FROM workspace_files_mirror WHERE workspace_id = ? AND path = ?"
-    ).get(workspaceId, path9);
+    ).get(workspaceId, path7);
     if (local) return local;
     const remote = await this.cloud.get(
-      `/api/im/workspaces/${encodeURIComponent(workspaceId)}/files?path=${encodeURIComponent(path9)}`,
+      `/api/im/workspaces/${encodeURIComponent(workspaceId)}/files?path=${encodeURIComponent(path7)}`,
       { signal }
     );
     this.db.prepare(
       `INSERT OR REPLACE INTO workspace_files_mirror
          (workspace_id, path, asset_id, content_hash, version, synced_at, dirty)
          VALUES (?, ?, ?, ?, ?, ?, 0)`
-    ).run(workspaceId, path9, remote.assetId, remote.contentHash, remote.version, Date.now());
+    ).run(workspaceId, path7, remote.assetId, remote.contentHash, remote.version, Date.now());
     return { asset_id: remote.assetId, content_hash: remote.contentHash, version: remote.version };
   }
 };
@@ -3075,244 +2915,11 @@ function dedupe(xs) {
 }
 
 // src/daemon/dispatch.ts
-var import_node_fs7 = require("fs");
-var path = __toESM(require("path"), 1);
-
-// src/daemon/skill-sync.ts
 var import_node_fs6 = require("fs");
-var import_node_path7 = require("path");
-var import_node_crypto3 = require("crypto");
-
-// src/adapters/openclaw/index.ts
-var import_zod3 = require("zod");
-var import_node_os4 = require("os");
-var import_node_path6 = require("path");
-var OpenClawProfileConfigSchema = import_zod3.z.object({
-  /** OpenClaw chat-completions HTTP port. */
-  port: import_zod3.z.number().int().min(1).max(65535).default(18789),
-  /** Bearer token expected by the gateway (from gateway.auth.bearerTokens). */
-  apiKey: import_zod3.z.string().min(1),
-  /**
-   * Model field passed to OpenClaw's /v1/chat/completions. OpenClaw
-   * intercepts this differently from a vanilla OpenAI server: the value
-   * MUST be `openclaw` (or `openclaw/<agentId>`) — it picks which
-   * OpenClaw agent answers, NOT the underlying LLM. The LLM is selected
-   * by `agents.defaults.model.primary` in openclaw.json (e.g.
-   * `prismer/us-kimi-k2.5`, set by the bootstrap).
-   */
-  model: import_zod3.z.string().min(1).default("openclaw"),
-  mcpAllowlist: import_zod3.z.array(import_zod3.z.string()).nullable().optional(),
-  approvalPolicy: import_zod3.z.enum(["strict", "auto-low-risk", "autonomous"]).optional().default("auto-low-risk"),
-  roleTemplate: import_zod3.z.object({
-    mcpServers: import_zod3.z.array(import_zod3.z.object({ toolsAllowlist: import_zod3.z.array(import_zod3.z.string()).optional() }).passthrough()).optional()
-  }).passthrough().optional(),
-  skillsDir: import_zod3.z.string().optional()
-});
-var openclawAdapter = {
-  name: "openclaw",
-  kind: "long-running",
-  capabilities: ["chat", "code", "multi-channel"],
-  workspaceSchema: OpenClawProfileConfigSchema,
-  validate(config) {
-    const r = OpenClawProfileConfigSchema.safeParse(config);
-    if (r.success) return { ok: true };
-    return {
-      ok: false,
-      errors: r.error.issues.map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`)
-    };
-  },
-  async ensureService(profile) {
-    const config = OpenClawProfileConfigSchema.parse(profile.config);
-    const baseUrl = `http://127.0.0.1:${config.port}`;
-    if (!await checkHealth2(baseUrl, config.apiKey)) {
-      throw new Error(
-        `OpenClaw gateway not reachable at ${baseUrl}. Start it with:
-  openclaw gateway --port ${config.port}`
-      );
-    }
-    return new OpenClawService(baseUrl, config.apiKey, config.model, resolveOpenClawSkillsDir(profile, config));
-  },
-  async health() {
-    return { available: true };
-  }
-};
-var OpenClawService = class {
-  constructor(baseUrl, apiKey, model, skillsDir) {
-    this.baseUrl = baseUrl;
-    this.apiKey = apiKey;
-    this.model = model;
-    this.skillsDir = skillsDir;
-    this.id = baseUrl;
-  }
-  baseUrl;
-  apiKey;
-  model;
-  skillsDir;
-  id;
-  async healthy() {
-    return checkHealth2(this.baseUrl, this.apiKey);
-  }
-  async dispatch(task) {
-    const startedAt = Date.now();
-    const systemPrompt = typeof task.metadata?.systemPrompt === "string" ? task.metadata.systemPrompt : void 0;
-    const messages = [];
-    if (systemPrompt) messages.push({ role: "system", content: systemPrompt });
-    messages.push({ role: "user", content: task.prompt });
-    try {
-      const res = await fetch(`${this.baseUrl}/v1/chat/completions`, {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${this.apiKey}`,
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          model: this.model,
-          messages,
-          stream: false
-        }),
-        signal: task.signal
-      });
-      if (!res.ok) {
-        const body = await res.text().catch(() => "") ?? "";
-        return {
-          ok: false,
-          error: {
-            code: res.status === 401 || res.status === 403 ? "auth_invalid" : "adapter_dispatch_failed",
-            message: `OpenClaw ${res.status}: ${body.slice(0, 400)}`
-          }
-        };
-      }
-      const json = await res.json();
-      let output = json.choices?.[0]?.message?.content ?? "";
-      const ERR_PREFIX_RE = /^Cannot read properties of undefined \(reading '[^']+'\)\s*\n+/;
-      if (ERR_PREFIX_RE.test(output)) {
-        process.stderr.write(
-          `[openclaw-adapter] stripping known stderr-bleed prefix from chat output (OpenClaw 2026.4.x bug)
-`
-        );
-        output = output.replace(ERR_PREFIX_RE, "");
-      }
-      return {
-        ok: true,
-        output,
-        metrics: { durationMs: Date.now() - startedAt }
-      };
-    } catch (err) {
-      if (task.signal?.aborted || err?.name === "AbortError") {
-        return { ok: false, error: { code: "task_cancelled", message: "Task cancelled by client" } };
-      }
-      return {
-        ok: false,
-        error: { code: "adapter_dispatch_failed", message: err.message }
-      };
-    }
-  }
-};
-function getOpenClawSkillsDir(profile) {
-  const config = OpenClawProfileConfigSchema.parse(profile.config);
-  return resolveOpenClawSkillsDir(profile, config);
-}
-function resolveOpenClawSkillsDir(profile, config) {
-  if (config.skillsDir) return config.skillsDir;
-  const name = profile.agentUsername || profile.id.slice(0, 8);
-  return (0, import_node_path6.join)(process.env.OPENCLAW_HOME || (0, import_node_path6.join)((0, import_node_os4.homedir)(), ".openclaw"), "profiles", name, "skills");
-}
-async function checkHealth2(baseUrl, apiKey) {
-  try {
-    const res = await fetch(`${baseUrl}/health`, {
-      headers: { Authorization: `Bearer ${apiKey}` },
-      signal: AbortSignal.timeout(2e3)
-    });
-    return res.ok;
-  } catch {
-    return false;
-  }
-}
-
-// src/daemon/skill-sync.ts
-async function syncInstalledSkillsForDispatch(profile, agentImUserId, cloud, signal) {
-  if (!agentImUserId) return { synced: 0, skipped: 0, unchanged: 0 };
-  const data = await cloud.get(
-    `/api/im/skills/installed?agentId=${encodeURIComponent(agentImUserId)}`,
-    { signal }
-  );
-  const entries = normalizeInstalledSkills(data);
-  const skillsRoot = resolveSkillsRoot(profile);
-  if (!skillsRoot) return { synced: 0, skipped: 0, unchanged: 0 };
-  let synced = 0;
-  let skipped = 0;
-  let unchanged = 0;
-  for (const entry of entries) {
-    const slug = sanitizeSlug(trimmedStringFrom(entry.skill?.slug) ?? trimmedStringFrom(entry.slug));
-    const content = contentStringFrom(entry.skill?.content) ?? contentStringFrom(entry.content);
-    if (!slug || !content) {
-      skipped++;
-      if (slug && !content) {
-        process.stderr.write(`[daemon] skill sync skipped ${slug}: missing content
-`);
-      }
-      continue;
-    }
-    const skillDir = (0, import_node_path7.join)(skillsRoot, slug);
-    await import_node_fs6.promises.mkdir(skillDir, { recursive: true });
-    const target = (0, import_node_path7.join)(skillDir, "SKILL.md");
-    const existing = await import_node_fs6.promises.readFile(target, "utf8").catch(() => null);
-    if (existing != null && sha2562(existing) === sha2562(content)) {
-      unchanged++;
-      continue;
-    }
-    await import_node_fs6.promises.writeFile(target, content, "utf8");
-    synced++;
-  }
-  return { synced, skipped, unchanged };
-}
-function resolveSkillsRoot(profile) {
-  if (profile.adapterName === "hermes") return (0, import_node_path7.join)(getHermesProfileDir(getHermesProfileName(profile)), "skills");
-  if (profile.adapterName === "openclaw") return getOpenClawSkillsDir(profile);
-  return null;
-}
-function sha2562(value) {
-  return (0, import_node_crypto3.createHash)("sha256").update(value).digest("hex");
-}
-function normalizeInstalledSkills(data) {
-  if (Array.isArray(data)) return data.filter(isInstalledSkillEntry);
-  if (!data || typeof data !== "object" || Array.isArray(data)) return [];
-  const record = data;
-  const nested = record.data;
-  if (Array.isArray(nested)) return nested.filter(isInstalledSkillEntry);
-  if (nested && typeof nested === "object" && !Array.isArray(nested)) {
-    const skills2 = nested.skills;
-    if (Array.isArray(skills2)) return skills2.filter(isInstalledSkillEntry);
-  }
-  const skills = record.skills;
-  if (Array.isArray(skills)) return skills.filter(isInstalledSkillEntry);
-  return [];
-}
-function isInstalledSkillEntry(value) {
-  return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-function trimmedStringFrom(value) {
-  return typeof value === "string" && value.trim() ? value.trim() : void 0;
-}
-function contentStringFrom(value) {
-  return typeof value === "string" && value.trim() ? value : void 0;
-}
-function sanitizeSlug(value) {
-  if (!value) return void 0;
-  const safe = value.replace(/[^a-zA-Z0-9_-]/g, "");
-  return safe || void 0;
-}
-
-// src/daemon/dispatch.ts
+var path = __toESM(require("path"), 1);
 var DEFAULT_CONTEXT_MAX = 8e3;
 var GOAL_CONTEXT_MAX = 4;
 var MEMORY_DIGEST_MAX_BYTES = 4e3;
-var DEFAULT_OPERATING_PRINCIPLES = [
-  "- Decide and act; only request human approval for destructive operations or irreversible external effects.",
-  "- Assignable work should become explicit tasks; do not leave concrete work as chat discussion only.",
-  "- Use workspace asset tools for uploaded files: search/describe first, then read bounded ranges; do not claim file contents unless a tool call succeeded.",
-  "- Keep users informed with concise status and concrete next steps."
-].join("\n");
 var ASSET_INLINE_FULL_MAX_BYTES = 64 * 1024;
 var ASSET_INLINE_TRUNCATE_BYTES = 16 * 1024;
 async function handleDispatch(payload, requestId, deps) {
@@ -3323,7 +2930,7 @@ async function handleDispatch(payload, requestId, deps) {
   const outboxDir = outboxBase ? path.join(outboxBase, "_outbox") : null;
   if (outboxDir) {
     try {
-      await import_node_fs7.promises.mkdir(outboxDir, { recursive: true });
+      await import_node_fs6.promises.mkdir(outboxDir, { recursive: true });
     } catch (err) {
       process.stderr.write(
         `[daemon] outbox provision failed task=${taskId} dir=${outboxDir}: ${err.message}
@@ -3350,18 +2957,6 @@ async function handleDispatch(payload, requestId, deps) {
       sendReply(deps.ws, reply, requestId);
       return reply;
     }
-    try {
-      const skillSync = await syncInstalledSkillsForDispatch(profile, agentImUserId, deps.cloud, deps.signal);
-      if (skillSync.synced > 0 || skillSync.skipped > 0) {
-        process.stderr.write(
-          `[daemon] skill sync profile=${profile.id} adapter=${profile.adapterName} synced=${skillSync.synced} skipped=${skillSync.skipped}
-`
-        );
-      }
-    } catch (err) {
-      process.stderr.write(`[daemon] skill sync skipped profile=${profile.id}: ${err.message}
-`);
-    }
     let hashRefResult = { text: payload.prompt, resolutions: [] };
     if (deps.assetMetadataIndexes && profile.workspaceId) {
       const assetIndex = deps.assetMetadataIndexes.get(profile.workspaceId);
@@ -3411,7 +3006,6 @@ async function handleDispatch(payload, requestId, deps) {
 `
       );
     }
-    const operatingPrinciples = resolveOperatingPrinciples(profile.config);
     const taskInput = {
       taskId,
       prompt: adapterPrompt,
@@ -3420,7 +3014,6 @@ async function handleDispatch(payload, requestId, deps) {
         conversationId: payload.conversationId,
         prismerGoals: goalContext.map(toGoalMirrorPayload),
         ...profileSystemPrompt ? { systemPrompt: profileSystemPrompt } : {},
-        ...operatingPrinciples ? { operatingPrinciples } : {},
         // Wave-9: spawn-style adapters (claude-code, codex, openclaw) read
         // this and inject `PRISMER_OUTBOX_DIR=<abs>` into the child env so
         // the LLM tool can resolve the path even if it doesn't read the
@@ -3691,7 +3284,7 @@ async function resolveAssetRefs(refs, cache) {
     const inlineCandidate = isTextLikeMime(effectiveMime);
     if (inlineCandidate) {
       try {
-        const buf = (0, import_node_fs7.readFileSync)(cached.localPath);
+        const buf = (0, import_node_fs6.readFileSync)(cached.localPath);
         let strategy;
         let body;
         if (buf.byteLength <= ASSET_INLINE_FULL_MAX_BYTES) {
@@ -3765,36 +3358,6 @@ ${memory.digest.trim()}
 
 ${prompt}`;
 }
-function resolveOperatingPrinciples(config) {
-  const cfg = readRecord(config);
-  const roleTemplate = readRecord(cfg.roleTemplate);
-  const principles = stringifyPrinciples(cfg.operatingPrinciples) ?? stringifyPrinciples(roleTemplate.operatingPrinciples) ?? DEFAULT_OPERATING_PRINCIPLES;
-  const policy = typeof cfg.approvalPolicy === "string" ? cfg.approvalPolicy : roleTemplate.approvalPolicy;
-  if (policy === "strict") {
-    return `${principles}
-- Approval policy: strict. Request human approval before destructive, external, spend, access, or publish operations.`;
-  }
-  if (policy === "autonomous") {
-    return `${principles}
-- Approval policy: autonomous. Do not request human approval unless a platform policy explicitly requires it.`;
-  }
-  return `${principles}
-- Approval policy: auto-low-risk. Proceed on reversible low-risk work; request human approval for destructive or irreversible operations.`;
-}
-function stringifyPrinciples(value) {
-  if (typeof value === "string" && value.trim()) return value.trim();
-  if (value && typeof value === "object" && !Array.isArray(value)) {
-    const record = value;
-    for (const key of ["en", "zh"]) {
-      const text = record[key];
-      if (typeof text === "string" && text.trim()) return text.trim();
-    }
-    for (const text of Object.values(record)) {
-      if (typeof text === "string" && text.trim()) return text.trim();
-    }
-  }
-  return void 0;
-}
 function appendOutboxInstruction(prompt, outboxDir, profileConfig) {
   if (!outboxDir) return prompt;
   if (profileConfig?.disableOutboxHints === true) return prompt;
@@ -3813,9 +3376,6 @@ function appendChannelContext(prompt, payload, profile) {
   const type = payload.conversationType === "direct" || payload.conversationType === "group" ? payload.conversationType : "unknown";
   const youAre = profile.agentUsername || payload.agentImUserId || "this agent";
   const lines = ["[Channel context]", `Conversation type: ${type}`, `You are: ${youAre}`];
-  if (payload.conversationId) {
-    lines.push(`Conversation ID: ${payload.conversationId}`);
-  }
   const participants = Array.isArray(payload.participants) ? payload.participants : [];
   if (participants.length > 0) {
     if (type === "direct") {
@@ -4085,8 +3645,8 @@ var ServicePool = class {
 
 // src/daemon/local-server.ts
 var import_node_http = require("http");
-var import_node_crypto4 = require("crypto");
-var import_node_fs8 = require("fs");
+var import_node_crypto = require("crypto");
+var import_node_fs7 = require("fs");
 var path2 = __toESM(require("path"), 1);
 var LocalServer = class {
   constructor(opts) {
@@ -4239,7 +3799,7 @@ var LocalServer = class {
   async handleSnapshot(req, res) {
     const root = this.opts.snapshotRoot ?? "/workspace";
     try {
-      const st = await import_node_fs8.promises.stat(root);
+      const st = await import_node_fs7.promises.stat(root);
       if (!st.isDirectory()) {
         respond(res, 400, { error: "snapshot_root_not_directory", rootPath: root });
         return;
@@ -4315,7 +3875,7 @@ var LocalServer = class {
       respond(res, 400, { error: "missing_taskId" });
       return;
     }
-    const runId = (0, import_node_crypto4.randomUUID)();
+    const runId = (0, import_node_crypto.randomUUID)();
     try {
       this.opts.onDispatch?.(payload, runId);
     } catch (err) {
@@ -4370,7 +3930,7 @@ async function walkAndDigest(root, current) {
   const out = [];
   let entries;
   try {
-    entries = await import_node_fs8.promises.readdir(current);
+    entries = await import_node_fs7.promises.readdir(current);
   } catch (err) {
     if (err.code === "ENOENT") return out;
     throw err;
@@ -4381,7 +3941,7 @@ async function walkAndDigest(root, current) {
     const rel = path2.relative(root, full);
     let st;
     try {
-      st = await import_node_fs8.promises.stat(full);
+      st = await import_node_fs7.promises.stat(full);
     } catch {
       continue;
     }
@@ -4392,11 +3952,11 @@ async function walkAndDigest(root, current) {
       continue;
     }
     if (!st.isFile()) continue;
-    const buf = await import_node_fs8.promises.readFile(full);
-    const sha2564 = (0, import_node_crypto4.createHash)("sha256").update(buf).digest("hex");
+    const buf = await import_node_fs7.promises.readFile(full);
+    const sha2562 = (0, import_node_crypto.createHash)("sha256").update(buf).digest("hex");
     out.push({
       path: rel,
-      sha256: sha2564,
+      sha256: sha2562,
       sizeBytes: st.size,
       mtime: Math.floor(st.mtimeMs)
     });
@@ -4406,14 +3966,12 @@ async function walkAndDigest(root, current) {
 
 // src/daemon/runner.ts
 var import_node_events3 = require("events");
-var import_node_fs14 = require("fs");
-var import_promises = require("fs/promises");
-var import_node_os6 = require("os");
-var import_node_path10 = require("path");
+var import_node_fs11 = require("fs");
+var import_node_os4 = require("os");
 
 // src/adapters/claude-code/index.ts
 var import_node_child_process2 = require("child_process");
-var import_zod4 = require("zod");
+var import_zod3 = require("zod");
 
 // src/adapters/claude-code/output-parser.ts
 var MAX_OUTPUT_CHARS = 64 * 1024;
@@ -4445,28 +4003,28 @@ function parseHeadlessOutput(stdout) {
 }
 
 // src/adapters/claude-code/index.ts
-var McpServerSchema = import_zod4.z.object({
-  name: import_zod4.z.string(),
-  command: import_zod4.z.string(),
-  args: import_zod4.z.array(import_zod4.z.string()).optional(),
-  env: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.string()).optional()
+var McpServerSchema = import_zod3.z.object({
+  name: import_zod3.z.string(),
+  command: import_zod3.z.string(),
+  args: import_zod3.z.array(import_zod3.z.string()).optional(),
+  env: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.string()).optional()
 });
-var CCConfigSchema = import_zod4.z.object({
-  cwd: import_zod4.z.string().min(1),
+var CCConfigSchema = import_zod3.z.object({
+  cwd: import_zod3.z.string().min(1),
   // claude 2.x accepts aliases ('sonnet', 'haiku', 'opus') and full ids
   // (e.g. 'claude-sonnet-4-6'). The 1.x default 'claude-3-5-sonnet' is no
   // longer a valid model id under the current CLI.
-  model: import_zod4.z.string().default("sonnet"),
-  systemPrompt: import_zod4.z.string().optional(),
-  envVars: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.string()).optional(),
-  mcpServers: import_zod4.z.array(McpServerSchema).optional(),
-  allowedTools: import_zod4.z.array(import_zod4.z.string()).optional(),
-  maxTurns: import_zod4.z.number().int().positive().default(20),
+  model: import_zod3.z.string().default("sonnet"),
+  systemPrompt: import_zod3.z.string().optional(),
+  envVars: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.string()).optional(),
+  mcpServers: import_zod3.z.array(McpServerSchema).optional(),
+  allowedTools: import_zod3.z.array(import_zod3.z.string()).optional(),
+  maxTurns: import_zod3.z.number().int().positive().default(20),
   // External-model route (1.9.x extension — optional, no breaking change)
-  baseURL: import_zod4.z.string().url().optional(),
-  apiKeyRef: import_zod4.z.string().regex(/^(env|keychain):[A-Za-z0-9_][A-Za-z0-9_.\-]*$/).optional(),
+  baseURL: import_zod3.z.string().url().optional(),
+  apiKeyRef: import_zod3.z.string().regex(/^(env|keychain):[A-Za-z0-9_][A-Za-z0-9_.\-]*$/).optional(),
   // informational tag — dispatch does not branch on this value yet
-  route: import_zod4.z.enum(["default", "prismer", "omniroute"]).default("default")
+  route: import_zod3.z.enum(["default", "prismer", "omniroute"]).default("default")
 });
 var claudeCodeAdapter = {
   name: "claude-code",
@@ -4620,7 +4178,7 @@ function resolveKeyRef(ref) {
 
 // src/adapters/codex/index.ts
 var import_node_child_process3 = require("child_process");
-var import_zod5 = require("zod");
+var import_zod4 = require("zod");
 
 // src/skills/memory-curation.ts
 var MEMORY_CURATION_SKILL_TEXT = `---
@@ -4753,31 +4311,31 @@ If the answer is no, do not save.
 `;
 
 // src/adapters/codex/index.ts
-var CodexConfigSchema = import_zod5.z.object({
+var CodexConfigSchema = import_zod4.z.object({
   /** Working directory for the codex subprocess. */
-  cwd: import_zod5.z.string().min(1),
+  cwd: import_zod4.z.string().min(1),
   /**
    * Model identifier passed to --model (e.g. 'codex-mini-latest', 'o4-mini').
    * Default matches the Codex CLI built-in default as of 2026-05.
    */
-  model: import_zod5.z.string().default("codex-mini-latest"),
+  model: import_zod4.z.string().default("codex-mini-latest"),
   /**
    * Sandbox level for the codex subprocess.
    *   read-only         — analysis only; code-gen tasks will stall
    *   workspace-write   — write inside cwd, read-only outside (recommended)
    *   danger-full-access — no restrictions; safe only inside isolated containers
    */
-  sandbox: import_zod5.z.enum(["read-only", "workspace-write", "danger-full-access"]).default("workspace-write"),
+  sandbox: import_zod4.z.enum(["read-only", "workspace-write", "danger-full-access"]).default("workspace-write"),
   /** Optional system prompt prepended to the user prompt as a preamble (see U4). */
-  systemPrompt: import_zod5.z.string().optional(),
+  systemPrompt: import_zod4.z.string().optional(),
   /** Extra env vars merged into the codex subprocess environment. */
-  envVars: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.string()).optional(),
+  envVars: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.string()).optional(),
   /**
    * Name of the env var holding the OpenAI API key. Defaults to
    * 'OPENAI_API_KEY' (Codex CLI default). Override if using a workspace-
    * scoped key under a different name.
    */
-  apiKeyEnv: import_zod5.z.string().default("OPENAI_API_KEY")
+  apiKeyEnv: import_zod4.z.string().default("OPENAI_API_KEY")
 });
 function buildCodexPrompt(config, taskPrompt) {
   const preambleParts = [MEMORY_CURATION_SKILL_TEXT.trim()];
@@ -4925,21 +4483,148 @@ var codexAdapter = {
   }
 };
 
-// src/daemon/memory/runtime.ts
-var os = __toESM(require("os"), 1);
-var path4 = __toESM(require("path"), 1);
-
-// src/daemon/memory/store.ts
-var import_better_sqlite33 = __toESM(require("better-sqlite3"), 1);
-var fs2 = __toESM(require("fs"), 1);
-var path3 = __toESM(require("path"), 1);
-var import_node_crypto5 = require("crypto");
-
-// src/daemon/memory/crypto.ts
-function sealPlaintext(content) {
-  return { kind: "inline", content };
-}
-
+// src/adapters/openclaw/index.ts
+var import_zod5 = require("zod");
+var OpenClawProfileConfigSchema = import_zod5.z.object({
+  /** OpenClaw chat-completions HTTP port. */
+  port: import_zod5.z.number().int().min(1).max(65535).default(18789),
+  /** Bearer token expected by the gateway (from gateway.auth.bearerTokens). */
+  apiKey: import_zod5.z.string().min(1),
+  /**
+   * Model field passed to OpenClaw's /v1/chat/completions. OpenClaw
+   * intercepts this differently from a vanilla OpenAI server: the value
+   * MUST be `openclaw` (or `openclaw/<agentId>`) — it picks which
+   * OpenClaw agent answers, NOT the underlying LLM. The LLM is selected
+   * by `agents.defaults.model.primary` in openclaw.json (e.g.
+   * `prismer/us-kimi-k2.5`, set by the bootstrap).
+   */
+  model: import_zod5.z.string().min(1).default("openclaw")
+});
+var openclawAdapter = {
+  name: "openclaw",
+  kind: "long-running",
+  capabilities: ["chat", "code", "multi-channel"],
+  workspaceSchema: OpenClawProfileConfigSchema,
+  validate(config) {
+    const r = OpenClawProfileConfigSchema.safeParse(config);
+    if (r.success) return { ok: true };
+    return {
+      ok: false,
+      errors: r.error.issues.map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`)
+    };
+  },
+  async ensureService(profile) {
+    const config = OpenClawProfileConfigSchema.parse(profile.config);
+    const baseUrl = `http://127.0.0.1:${config.port}`;
+    if (!await checkHealth2(baseUrl, config.apiKey)) {
+      throw new Error(
+        `OpenClaw gateway not reachable at ${baseUrl}. Start it with:
+  openclaw gateway --port ${config.port}`
+      );
+    }
+    return new OpenClawService(baseUrl, config.apiKey, config.model);
+  },
+  async health() {
+    return { available: true };
+  }
+};
+var OpenClawService = class {
+  constructor(baseUrl, apiKey, model) {
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
+    this.model = model;
+    this.id = baseUrl;
+  }
+  baseUrl;
+  apiKey;
+  model;
+  id;
+  async healthy() {
+    return checkHealth2(this.baseUrl, this.apiKey);
+  }
+  async dispatch(task) {
+    const startedAt = Date.now();
+    const systemPrompt = typeof task.metadata?.systemPrompt === "string" ? task.metadata.systemPrompt : void 0;
+    const messages = [];
+    if (systemPrompt) messages.push({ role: "system", content: systemPrompt });
+    messages.push({ role: "user", content: task.prompt });
+    try {
+      const res = await fetch(`${this.baseUrl}/v1/chat/completions`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          model: this.model,
+          messages,
+          stream: false
+        }),
+        signal: task.signal
+      });
+      if (!res.ok) {
+        const body = await res.text().catch(() => "") ?? "";
+        return {
+          ok: false,
+          error: {
+            code: res.status === 401 || res.status === 403 ? "auth_invalid" : "adapter_dispatch_failed",
+            message: `OpenClaw ${res.status}: ${body.slice(0, 400)}`
+          }
+        };
+      }
+      const json = await res.json();
+      let output = json.choices?.[0]?.message?.content ?? "";
+      const ERR_PREFIX_RE = /^Cannot read properties of undefined \(reading '[^']+'\)\s*\n+/;
+      if (ERR_PREFIX_RE.test(output)) {
+        process.stderr.write(
+          `[openclaw-adapter] stripping known stderr-bleed prefix from chat output (OpenClaw 2026.4.x bug)
+`
+        );
+        output = output.replace(ERR_PREFIX_RE, "");
+      }
+      return {
+        ok: true,
+        output,
+        metrics: { durationMs: Date.now() - startedAt }
+      };
+    } catch (err) {
+      if (task.signal?.aborted || err?.name === "AbortError") {
+        return { ok: false, error: { code: "task_cancelled", message: "Task cancelled by client" } };
+      }
+      return {
+        ok: false,
+        error: { code: "adapter_dispatch_failed", message: err.message }
+      };
+    }
+  }
+};
+async function checkHealth2(baseUrl, apiKey) {
+  try {
+    const res = await fetch(`${baseUrl}/health`, {
+      headers: { Authorization: `Bearer ${apiKey}` },
+      signal: AbortSignal.timeout(2e3)
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+// src/daemon/memory/runtime.ts
+var os = __toESM(require("os"), 1);
+var path4 = __toESM(require("path"), 1);
+
+// src/daemon/memory/store.ts
+var import_better_sqlite33 = __toESM(require("better-sqlite3"), 1);
+var fs2 = __toESM(require("fs"), 1);
+var path3 = __toESM(require("path"), 1);
+var import_node_crypto2 = require("crypto");
+
+// src/daemon/memory/crypto.ts
+function sealPlaintext(content) {
+  return { kind: "inline", content };
+}
+
 // src/daemon/memory/store.ts
 var SCHEMA_VERSION2 = 1;
 var SCHEMA_V1_STATEMENTS = [
@@ -5084,9 +4769,9 @@ var MemoryStore = class {
     const row = db.prepare("SELECT * FROM memory_pages WHERE workspaceId = ? AND id = ?").get(this.opts.workspaceId, pageId);
     return row ? this.rowToPage(row) : null;
   }
-  loadContent(pageId, version) {
+  loadContent(pageId, version2) {
     const db = this.requireDb();
-    const targetVersion = version ?? db.prepare("SELECT version FROM memory_pages WHERE workspaceId = ? AND id = ?").get(this.opts.workspaceId, pageId)?.version;
+    const targetVersion = version2 ?? db.prepare("SELECT version FROM memory_pages WHERE workspaceId = ? AND id = ?").get(this.opts.workspaceId, pageId)?.version;
     if (targetVersion === void 0) return null;
     const row = db.prepare(
       `SELECT c.pageId, c.version, c.payloadKind, c.payloadValue
@@ -5124,7 +4809,7 @@ var MemoryStore = class {
     }
     const db = this.requireDb();
     const now = Date.now();
-    const contentHash = sha2563(input.content);
+    const contentHash = sha256(input.content);
     const payload = sealPlaintext(input.content);
     if (payload.kind !== "inline") {
       throw new Error("MemoryStore.write: non-inline payload not yet supported in phase-0");
@@ -5135,7 +4820,7 @@ var MemoryStore = class {
     const existing = db.prepare(
       "SELECT id, version, createdAt FROM memory_pages WHERE workspaceId = ? AND path = ?"
     ).get(this.opts.workspaceId, input.path);
-    const pageId = existing?.id ?? `page_${(0, import_node_crypto5.randomUUID)().replace(/-/g, "").slice(0, 22)}`;
+    const pageId = existing?.id ?? `page_${(0, import_node_crypto2.randomUUID)().replace(/-/g, "").slice(0, 22)}`;
     const newVersion = (existing?.version ?? 0) + 1;
     const createdAt = existing?.createdAt ?? now;
     const staleFlag = input.stale ? 1 : 0;
@@ -5318,8 +5003,8 @@ var MemoryStore = class {
     };
   }
 };
-function sha2563(s) {
-  return (0, import_node_crypto5.createHash)("sha256").update(s, "utf8").digest("hex");
+function sha256(s) {
+  return (0, import_node_crypto2.createHash)("sha256").update(s, "utf8").digest("hex");
 }
 
 // src/daemon/memory/search.ts
@@ -5425,7 +5110,7 @@ function clamp(n, lo, hi) {
 }
 
 // src/daemon/memory/outbox.ts
-var import_node_crypto6 = require("crypto");
+var import_node_crypto3 = require("crypto");
 
 // src/daemon/memory/envelope.ts
 var import_zod6 = require("zod");
@@ -5558,7 +5243,7 @@ var MemoryOutbox = class {
     const now = Date.now();
     const parsed = MemoryOutboxEnvelope.safeParse(event);
     if (!parsed.success) {
-      const dlId = `dl_${(0, import_node_crypto6.randomUUID)()}`;
+      const dlId = `dl_${(0, import_node_crypto3.randomUUID)()}`;
       db.prepare(
         `INSERT INTO memory_outbox_dead_letter (id, eventType, rawJson, errorJson, createdAt)
          VALUES (?, ?, ?, ?, ?)`
@@ -5575,7 +5260,7 @@ var MemoryOutbox = class {
     if (validated.eventType === "memory.feedback") {
       const check = validateFeedbackTarget(validated);
       if (!check.ok) {
-        const dlId = `dl_${(0, import_node_crypto6.randomUUID)()}`;
+        const dlId = `dl_${(0, import_node_crypto3.randomUUID)()}`;
         db.prepare(
           `INSERT INTO memory_outbox_dead_letter (id, eventType, rawJson, errorJson, createdAt)
            VALUES (?, ?, ?, ?, ?)`
@@ -5589,7 +5274,7 @@ var MemoryOutbox = class {
         return { id: dlId, deadLetter: true };
       }
     }
-    const rowId = `out_${(0, import_node_crypto6.randomUUID)()}`;
+    const rowId = `out_${(0, import_node_crypto3.randomUUID)()}`;
     try {
       db.prepare(
         `INSERT INTO memory_outbox (id, eventType, envelopeJson, idempotencyKey, status, createdAt)
@@ -6169,7 +5854,7 @@ function clamp2(n, lo, hi) {
 }
 
 // src/daemon/memory/fork/tracing.ts
-var import_node_crypto7 = require("crypto");
+var import_node_crypto4 = require("crypto");
 
 // src/daemon/memory/fork/runner.ts
 var DEFAULT_SNIPPET_MAX_BYTES = 500;
@@ -6177,8 +5862,8 @@ function finalizeSelected(runtime, workspaceId, paths, snippetMaxBytes = DEFAULT
   const slot = runtime.peek(workspaceId);
   if (!slot) return [];
   const out = [];
-  for (const path9 of paths) {
-    const page = slot.store.loadByPath(path9);
+  for (const path7 of paths) {
+    const page = slot.store.loadByPath(path7);
     if (!page) continue;
     const content = slot.store.loadContent(page.id)?.content ?? "";
     out.push({
@@ -6453,14 +6138,14 @@ function parsePrismerUri(uri) {
   const memoryIdx = rest.indexOf(segMemory);
   if (memoryIdx <= 0) return null;
   const workspaceId = rest.slice(0, memoryIdx);
-  const path9 = rest.slice(memoryIdx + segMemory.length);
-  if (!workspaceId || !path9) return null;
-  return { workspaceId, path: path9 };
+  const path7 = rest.slice(memoryIdx + segMemory.length);
+  if (!workspaceId || !path7) return null;
+  return { workspaceId, path: path7 };
 }
 
 // src/daemon/asset/metadata-index.ts
-var import_node_fs9 = require("fs");
-var import_node_path8 = require("path");
+var import_node_fs8 = require("fs");
+var import_node_path6 = require("path");
 var DEFAULT_LIMIT = 8;
 var PULL_PAGE_SIZE = 500;
 var THROTTLE_MS = 3e4;
@@ -6488,16 +6173,16 @@ var AssetMetadataIndex = class {
     this.db = opts.db;
     this.cloud = opts.cloud;
     this.workspaceId = opts.workspaceId;
-    if (!(0, import_node_fs9.existsSync)(opts.workspaceStateDir)) {
-      (0, import_node_fs9.mkdirSync)(opts.workspaceStateDir, { recursive: true });
+    if (!(0, import_node_fs8.existsSync)(opts.workspaceStateDir)) {
+      (0, import_node_fs8.mkdirSync)(opts.workspaceStateDir, { recursive: true });
     }
-    this.cursorPath = (0, import_node_path8.join)(opts.workspaceStateDir, "asset-metadata-cursor.json");
+    this.cursorPath = (0, import_node_path6.join)(opts.workspaceStateDir, "asset-metadata-cursor.json");
   }
   /** Persisted cursor for this workspace, or 0 on first run / corrupted file. */
   readCursor() {
-    if (!(0, import_node_fs9.existsSync)(this.cursorPath)) return 0;
+    if (!(0, import_node_fs8.existsSync)(this.cursorPath)) return 0;
     try {
-      const parsed = JSON.parse((0, import_node_fs9.readFileSync)(this.cursorPath, "utf8"));
+      const parsed = JSON.parse((0, import_node_fs8.readFileSync)(this.cursorPath, "utf8"));
       if (parsed.workspaceId !== this.workspaceId) return 0;
       return parsed.cursor;
     } catch {
@@ -6510,7 +6195,7 @@ var AssetMetadataIndex = class {
       cursor,
       writtenAt: Date.now()
     };
-    (0, import_node_fs9.writeFileSync)(this.cursorPath, JSON.stringify(payload, null, 2));
+    (0, import_node_fs8.writeFileSync)(this.cursorPath, JSON.stringify(payload, null, 2));
   }
   /**
    * Pull incremental asset metadata changes since the persisted cursor and
@@ -6550,13 +6235,9 @@ var AssetMetadataIndex = class {
     let applied = 0;
     const tx = this.db.transaction((items) => {
       for (const item of items) {
-        const assetId = item.assetId ?? item.id;
-        if (!assetId) {
-          throw new Error("Asset metadata index item missing assetId/id");
-        }
         upsert.run(
           this.workspaceId,
-          assetId,
+          item.assetId,
           item.contentHash,
           item.filename ?? null,
           item.folderPath ?? null,
@@ -6601,14 +6282,6 @@ var AssetMetadataIndex = class {
     const row = this.db.prepare("SELECT * FROM asset_metadata_index WHERE workspace_id = ? AND filename = ?").get(this.workspaceId, filename);
     return row ? rowToMetadata(row) : void 0;
   }
-  resolveByAssetId(assetId) {
-    const row = this.db.prepare("SELECT * FROM asset_metadata_index WHERE workspace_id = ? AND asset_id = ?").get(this.workspaceId, assetId);
-    return row ? rowToMetadata(row) : void 0;
-  }
-  resolveByContentHash(contentHash) {
-    const row = this.db.prepare("SELECT * FROM asset_metadata_index WHERE workspace_id = ? AND content_hash = ?").get(this.workspaceId, contentHash);
-    return row ? rowToMetadata(row) : void 0;
-  }
   /** Batch exact match — returns Map for O(1) access. */
   resolveByFilenames(filenames) {
     if (filenames.length === 0) return /* @__PURE__ */ new Map();
@@ -6627,10 +6300,7 @@ var AssetMetadataIndex = class {
 };
 
 // src/daemon/asset/rpc.ts
-var import_node_fs10 = require("fs");
 var ASSET_PATH_PREFIX = "/local/asset/";
-var MAX_READ_BYTES = 256 * 1024;
-var MAX_SEARCH_BYTES = 1024 * 1024;
 function attachAssetRpc(opts) {
   return async (req, res) => {
     const url = req.url ?? "/";
@@ -6641,17 +6311,10 @@ function attachAssetRpc(opts) {
     try {
       if (method === "POST" && subpath === "search") {
         const body = await readJson3(req);
-        return await handleSearch2(opts, body, res);
-      }
-      if (method === "POST" && subpath === "describe") {
-        const body = await readJson3(req);
-        return handleDescribe(opts, body, res);
+        return handleSearch2(opts.resolveIndex, body, res);
       }
-      if (method === "POST" && subpath === "read") {
-        const body = await readJson3(req);
-        return await handleRead(opts, body, res);
-      }
-      return false;
+      respond3(res, 404, { error: "asset_route_not_found", path: url });
+      return true;
     } catch (err) {
       respond3(res, 500, {
         error: "asset_rpc_failed",
@@ -6661,21 +6324,18 @@ function attachAssetRpc(opts) {
     }
   };
 }
-async function handleSearch2(opts, body, res) {
+function handleSearch2(resolveIndex, body, res) {
   if (!body || typeof body !== "object") {
     return respond4002(res, "request body must be a JSON object");
   }
   const b = body;
-  if (typeof b.query !== "string" || !b.query.trim()) {
-    return respond4002(res, "query is required (non-empty string)");
-  }
-  if (typeof b.uri === "string" && b.uri.trim()) {
-    return searchAssetContent(opts, b.uri.trim(), b.query.trim(), res);
-  }
   if (typeof b.workspaceId !== "string" || !b.workspaceId) {
     return respond4002(res, "workspaceId is required (string)");
   }
-  const index = opts.resolveIndex(b.workspaceId);
+  if (typeof b.query !== "string" || !b.query.trim()) {
+    return respond4002(res, "query is required (non-empty string)");
+  }
+  const index = resolveIndex(b.workspaceId);
   if (!index) {
     respond3(res, 404, {
       error: "workspace_index_not_found",
@@ -6689,124 +6349,6 @@ async function handleSearch2(opts, body, res) {
   respond3(res, 200, { items });
   return true;
 }
-function handleDescribe(opts, body, res) {
-  const resolved = resolveAssetRef(opts, body);
-  if ("error" in resolved) return respond4002(res, resolved.error);
-  const cached = opts.assetCache?.get(resolved.row.contentHash);
-  respond3(res, 200, {
-    asset: resolved.row,
-    uri: `prismer://workspace/${resolved.workspaceId}/asset/${resolved.row.contentHash}`,
-    cache: cached ? { status: "hit", localPath: cached.localPath, sizeBytes: cached.sizeBytes, lastUsedAt: cached.lastUsedAt } : { status: "miss" },
-    tools: ["asset.describe", "asset.read", "asset.search"]
-  });
-  return true;
-}
-async function handleRead(opts, body, res) {
-  const resolved = resolveAssetRef(opts, body);
-  if ("error" in resolved) return respond4002(res, resolved.error);
-  if (!opts.assetCache) {
-    respond3(res, 503, { error: "asset_cache_unavailable" });
-    return true;
-  }
-  const b = body;
-  const offset = typeof b.offset === "number" && b.offset > 0 ? Math.floor(b.offset) : 0;
-  const requested = typeof b.length === "number" && b.length > 0 ? Math.floor(b.length) : MAX_READ_BYTES;
-  const length = Math.min(requested, MAX_READ_BYTES);
-  const cached = await opts.assetCache.getOrFetch(resolved.row.contentHash, {
-    workspaceIdHint: resolved.workspaceId,
-    assetId: resolved.row.assetId
-  });
-  const chunk = readFileRange(cached.localPath, offset, length);
-  const textLike = isTextLike(resolved.row);
-  respond3(res, 200, {
-    asset: resolved.row,
-    locator: { byteOffset: offset, byteLength: chunk.bytesRead },
-    truncated: requested > MAX_READ_BYTES || offset + chunk.bytesRead < chunk.sizeBytes,
-    encoding: textLike ? "utf8" : "base64",
-    content: textLike ? chunk.buffer.toString("utf8") : chunk.buffer.toString("base64")
-  });
-  return true;
-}
-async function searchAssetContent(opts, uri, query, res) {
-  const resolved = resolveAssetRef(opts, { uri });
-  if ("error" in resolved) return respond4002(res, resolved.error);
-  if (!opts.assetCache) {
-    respond3(res, 503, { error: "asset_cache_unavailable" });
-    return true;
-  }
-  if (!isTextLike(resolved.row)) {
-    respond3(res, 200, {
-      items: [],
-      unsupported: true,
-      reason: "content search currently supports text-like assets only",
-      asset: resolved.row
-    });
-    return true;
-  }
-  const cached = await opts.assetCache.getOrFetch(resolved.row.contentHash, {
-    workspaceIdHint: resolved.workspaceId,
-    assetId: resolved.row.assetId
-  });
-  const chunk = readFileRange(cached.localPath, 0, MAX_SEARCH_BYTES);
-  const text = chunk.buffer.toString("utf8");
-  const needle = query.toLowerCase();
-  const lines = text.split(/\r?\n/);
-  const items = [];
-  let byteOffset = 0;
-  for (let i = 0; i < lines.length && items.length < 20; i += 1) {
-    const line = lines[i] ?? "";
-    if (line.toLowerCase().includes(needle)) {
-      items.push({ line: i + 1, byteOffset, preview: line.slice(0, 500) });
-    }
-    byteOffset += Buffer.byteLength(line) + 1;
-  }
-  respond3(res, 200, {
-    items,
-    asset: resolved.row,
-    searched: { byteOffset: 0, byteLength: chunk.bytesRead, truncated: chunk.bytesRead < chunk.sizeBytes }
-  });
-  return true;
-}
-function resolveAssetRef(opts, body) {
-  if (!body || typeof body !== "object") return { error: "request body must be a JSON object" };
-  const b = body;
-  let workspaceId = typeof b.workspaceId === "string" ? b.workspaceId : "";
-  let assetId = typeof b.assetId === "string" ? b.assetId : "";
-  let contentHash = typeof b.contentHash === "string" ? b.contentHash : "";
-  if (typeof b.uri === "string" && b.uri.trim()) {
-    const [uri] = parseUris(b.uri.trim());
-    if (!uri) return { error: "uri must be prismer://workspace/<workspaceId>/asset/<hash>" };
-    if (uri.type !== "asset") return { error: "file uri lookup is not available in this RPC yet; pass asset uri or assetId" };
-    workspaceId = uri.workspaceId ?? workspaceId;
-    contentHash = uri.rest;
-  }
-  if (!workspaceId) return { error: "workspaceId is required (string)" };
-  const index = opts.resolveIndex(workspaceId);
-  if (!index) return { error: "workspace asset index is not synced yet" };
-  const row = assetId ? index.resolveByAssetId(assetId) : contentHash ? index.resolveByContentHash(contentHash) : void 0;
-  if (!row) return { error: "asset not found in local metadata index" };
-  return { workspaceId, row };
-}
-function isTextLike(row) {
-  const mime = row.mime ?? "";
-  const name = row.filename ?? "";
-  return mime.startsWith("text/") || mime.includes("json") || mime.includes("xml") || mime.includes("markdown") || mime.includes("csv") || /\.(md|markdown|txt|json|csv|tsv|ndjson|js|jsx|ts|tsx|py|go|rs|java|kt|swift|rb|php|css|html|htm|xhtml|sql|yaml|yml|toml|log)$/i.test(
-    name
-  );
-}
-function readFileRange(path9, offset, length) {
-  const sizeBytes = (0, import_node_fs10.statSync)(path9).size;
-  if (offset >= sizeBytes) return { buffer: Buffer.alloc(0), bytesRead: 0, sizeBytes };
-  const fd = (0, import_node_fs10.openSync)(path9, "r");
-  try {
-    const target = Math.min(length, sizeBytes - offset);
-    const buffer = Buffer.alloc(target);
-    const bytesRead = (0, import_node_fs10.readSync)(fd, buffer, 0, target, offset);
-    return { buffer: buffer.subarray(0, bytesRead), bytesRead, sizeBytes };
-  } finally {
-    (0, import_node_fs10.closeSync)(fd);
-  }
-}
 function respond3(res, status, body) {
   res.statusCode = status;
   res.setHeader("Content-Type", "application/json");
@@ -6828,532 +6370,9 @@ async function readJson3(req) {
   }
 }
 
-// src/daemon/asset/origin/drop-folder.ts
-var import_node_fs11 = require("fs");
-var import_node_os5 = require("os");
-var path5 = __toESM(require("path"), 1);
-var DropFolderAdapter = class {
-  kind = "drop-folder";
-  workspaceDir;
-  rootDir;
-  constructor(opts = {}) {
-    this.workspaceDir = opts.workspaceDir;
-    this.rootDir = opts.rootDir ?? path5.join(opts.homeDir ?? (0, import_node_os5.homedir)(), ".prismer");
-  }
-  /**
-   * Long-lived async iterable wrapping `scanOnce` on a 1s polling interval.
-   * Stops when the iterator is broken (e.g. consumer returns / throws).
-   */
-  async *observe(workspaceId) {
-    while (true) {
-      const batch = await this.scanOnce(workspaceId);
-      for (const obs of batch) yield obs;
-      await sleep(1e3);
-    }
-  }
-  /**
-   * Single-tick scan exposed for tests and one-shot CLI usage. Reads every
-   * file currently under the workspace's drop directory, returning one
-   * observation per file. The caller is expected to feed each into the
-   * outbox; idempotency on the outbox side collapses re-observations of
-   * unchanged files.
-   */
-  async scanOnce(workspaceId) {
-    const drop = this.dropDir(workspaceId);
-    let entries = [];
-    try {
-      entries = await import_node_fs11.promises.readdir(drop);
-    } catch (err) {
-      if (err.code === "ENOENT") return [];
-      throw err;
-    }
-    const out = [];
-    for (const name of entries) {
-      if (name.startsWith(".")) continue;
-      const fullPath = path5.join(drop, name);
-      const stat = await import_node_fs11.promises.lstat(fullPath).catch(() => null);
-      if (!stat) continue;
-      if (stat.isSymbolicLink()) continue;
-      if (stat.isDirectory()) {
-        for (const nested of await walk(fullPath)) {
-          const nstat = await import_node_fs11.promises.lstat(nested).catch(() => null);
-          if (!nstat || !nstat.isFile()) continue;
-          out.push(makeObservation(workspaceId, nested, drop, nstat.size, Math.floor(nstat.mtimeMs)));
-        }
-        continue;
-      }
-      if (!stat.isFile()) continue;
-      out.push(makeObservation(workspaceId, fullPath, drop, stat.size, Math.floor(stat.mtimeMs)));
-    }
-    return out;
-  }
-  async identifySource(obs) {
-    const detail = obs.detail;
-    const rel = path5.relative(detail.watchDir, detail.path);
-    const folderDir = path5.dirname(rel);
-    return {
-      sourceRef: `folder://${obs.workspaceId}/${rel.split(path5.sep).join("/")}`,
-      hints: {
-        filename: path5.basename(detail.path),
-        folderPath: folderDir === "." ? "" : folderDir.split(path5.sep).join("/")
-      }
-    };
-  }
-  async fetch(obs) {
-    const detail = obs.detail;
-    const bytes = await import_node_fs11.promises.readFile(detail.path);
-    return {
-      bytes,
-      mime: mimeFromExtension(detail.path),
-      size: bytes.length
-    };
-  }
-  /** Hook called by UploadRunner after a successful upload of one observation. */
-  async onUploadSuccess(obs) {
-    await this.moveTo(obs, this.uploadedDir(obs.workspaceId));
-  }
-  /** Hook called by UploadRunner after attempts hit maxAttempts. */
-  async onUploadFailure(obs) {
-    await this.moveTo(obs, this.failedDir(obs.workspaceId));
-  }
-  async moveTo(obs, destDir) {
-    const detail = obs.detail;
-    if (!detail || typeof detail.path !== "string") return;
-    try {
-      const rel = typeof detail.watchDir === "string" ? path5.relative(detail.watchDir, detail.path) : path5.basename(detail.path);
-      const safeRel = rel && !rel.startsWith("..") && !path5.isAbsolute(rel) ? rel : path5.basename(detail.path);
-      const destPath = path5.join(destDir, safeRel);
-      await import_node_fs11.promises.mkdir(path5.dirname(destPath), { recursive: true });
-      await import_node_fs11.promises.rename(detail.path, destPath);
-    } catch (err) {
-      if (err.code === "ENOENT") return;
-      throw err;
-    }
-  }
-  dropDir(workspaceId) {
-    if (this.workspaceDir) return path5.join(this.workspaceDir, "drop");
-    return path5.join(this.rootDir, "workspaces", workspaceId, "drop");
-  }
-  uploadedDir(workspaceId) {
-    if (this.workspaceDir) return path5.join(this.workspaceDir, "uploaded");
-    return path5.join(this.rootDir, "workspaces", workspaceId, "uploaded");
-  }
-  failedDir(workspaceId) {
-    if (this.workspaceDir) return path5.join(this.workspaceDir, "upload-failed");
-    return path5.join(this.rootDir, "workspaces", workspaceId, "upload-failed");
-  }
-};
-function makeObservation(workspaceId, filePath, watchDir, size, mtime) {
-  return {
-    workspaceId,
-    detail: { path: filePath, watchDir, size, mtime },
-    observedAt: mtime
-  };
-}
-async function walk(root) {
-  const out = [];
-  const entries = await import_node_fs11.promises.readdir(root).catch(() => []);
-  for (const name of entries) {
-    if (name.startsWith(".")) continue;
-    const full = path5.join(root, name);
-    const stat = await import_node_fs11.promises.lstat(full).catch(() => null);
-    if (!stat) continue;
-    if (stat.isSymbolicLink()) continue;
-    if (stat.isDirectory()) {
-      out.push(...await walk(full));
-    } else if (stat.isFile()) {
-      out.push(full);
-    }
-  }
-  return out;
-}
-var MIME_BY_EXT = {
-  ".txt": "text/plain",
-  ".md": "text/markdown",
-  ".csv": "text/csv",
-  ".json": "application/json",
-  ".yaml": "application/yaml",
-  ".yml": "application/yaml",
-  ".pdf": "application/pdf",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".webp": "image/webp",
-  ".svg": "image/svg+xml",
-  ".html": "text/html",
-  ".htm": "text/html",
-  ".xhtml": "application/xhtml+xml",
-  ".xml": "application/xml",
-  ".zip": "application/zip",
-  ".tar": "application/x-tar",
-  ".gz": "application/gzip",
-  ".mp3": "audio/mpeg",
-  ".mp4": "video/mp4",
-  ".mov": "video/quicktime",
-  ".wav": "audio/wav"
-};
-function mimeFromExtension(p) {
-  const ext = path5.extname(p).toLowerCase();
-  return MIME_BY_EXT[ext] ?? null;
-}
-function sleep(ms) {
-  return new Promise((r) => setTimeout(r, ms));
-}
-
-// src/daemon/asset/origin/outbox.ts
-var import_better_sqlite34 = __toESM(require("better-sqlite3"), 1);
-var import_node_crypto8 = require("crypto");
-var import_zod7 = require("zod");
-var OriginObservationRecordSchema = import_zod7.z.object({
-  workspaceId: import_zod7.z.string().min(1),
-  originKind: import_zod7.z.enum(["upload", "drop-folder", "agent-gen"]),
-  sourceRef: import_zod7.z.string().min(1),
-  payloadJson: import_zod7.z.string().min(2),
-  hintsJson: import_zod7.z.string().min(2),
-  observedAt: import_zod7.z.number().int().nonnegative()
-});
-var DDL_STATEMENTS = [
-  `CREATE TABLE IF NOT EXISTS asset_origin_outbox (
-    id TEXT PRIMARY KEY,
-    workspaceId TEXT NOT NULL,
-    originKind TEXT NOT NULL,
-    sourceRef TEXT NOT NULL,
-    payloadJson TEXT NOT NULL,
-    hintsJson TEXT NOT NULL,
-    observedAt INTEGER NOT NULL,
-    idempotencyKey TEXT NOT NULL UNIQUE,
-    status TEXT NOT NULL CHECK (status IN ('pending', 'claimed', 'uploaded')),
-    attempts INTEGER NOT NULL DEFAULT 0,
-    lastError TEXT,
-    assetId TEXT,
-    contentHash TEXT,
-    createdAt INTEGER NOT NULL,
-    updatedAt INTEGER NOT NULL
-  )`,
-  `CREATE INDEX IF NOT EXISTS idx_asset_origin_outbox_status
-    ON asset_origin_outbox(status, createdAt)`,
-  `CREATE TABLE IF NOT EXISTS asset_origin_outbox_dead_letter (
-    id TEXT PRIMARY KEY,
-    workspaceId TEXT NOT NULL,
-    originKind TEXT NOT NULL,
-    sourceRef TEXT NOT NULL,
-    payloadJson TEXT NOT NULL,
-    hintsJson TEXT NOT NULL,
-    observedAt INTEGER NOT NULL,
-    errorJson TEXT NOT NULL,
-    attempts INTEGER NOT NULL,
-    createdAt INTEGER NOT NULL
-  )`
-];
-var OriginOutbox = class {
-  db;
-  constructor(opts) {
-    this.db = new import_better_sqlite34.default(opts.dbPath);
-    this.db.pragma("journal_mode = WAL");
-    for (const ddl of DDL_STATEMENTS) this.db.prepare(ddl).run();
-  }
-  /**
-   * Validate + persist an observation. Schema-invalid input lands in
-   * `asset_origin_outbox_dead_letter` (never silently dropped). Re-enqueue
-   * with the same {originKind, workspaceId, sourceRef, observedAt} returns
-   * the existing row id without inserting again.
-   */
-  enqueue(record) {
-    const now = Date.now();
-    const parsed = OriginObservationRecordSchema.safeParse(record);
-    if (!parsed.success) {
-      const dlId = `dl_${(0, import_node_crypto8.randomUUID)()}`;
-      const raw = record && typeof record === "object" ? record : {};
-      this.db.prepare(
-        `INSERT INTO asset_origin_outbox_dead_letter
-           (id, workspaceId, originKind, sourceRef, payloadJson, hintsJson, observedAt, errorJson, attempts, createdAt)
-           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-      ).run(
-        dlId,
-        coerceToString(raw.workspaceId, ""),
-        coerceToString(raw.originKind, ""),
-        coerceToString(raw.sourceRef, ""),
-        coerceToJson(raw.payloadJson),
-        coerceToJson(raw.hintsJson),
-        typeof raw.observedAt === "number" ? raw.observedAt : 0,
-        JSON.stringify(parsed.error.errors),
-        0,
-        now
-      );
-      return { id: dlId, deadLetter: true };
-    }
-    const validated = parsed.data;
-    const idempotencyKey = computeIdempotencyKey(validated);
-    const rowId = `out_${(0, import_node_crypto8.randomUUID)()}`;
-    try {
-      this.db.prepare(
-        `INSERT INTO asset_origin_outbox
-           (id, workspaceId, originKind, sourceRef, payloadJson, hintsJson, observedAt,
-            idempotencyKey, status, attempts, createdAt, updatedAt)
-           VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'pending', 0, ?, ?)`
-      ).run(
-        rowId,
-        validated.workspaceId,
-        validated.originKind,
-        validated.sourceRef,
-        validated.payloadJson,
-        validated.hintsJson,
-        validated.observedAt,
-        idempotencyKey,
-        now,
-        now
-      );
-      return { id: rowId, deadLetter: false };
-    } catch (err) {
-      const code = err.code;
-      if (code === "SQLITE_CONSTRAINT_UNIQUE") {
-        const existing = this.db.prepare("SELECT id FROM asset_origin_outbox WHERE idempotencyKey = ?").get(idempotencyKey);
-        if (existing) return { id: existing.id, deadLetter: false };
-      }
-      throw err;
-    }
-  }
-  /**
-   * Atomically claim the oldest pending row, transition status to 'claimed',
-   * and return it. Returns null when the queue is empty. The caller MUST
-   * follow up with `markUploaded` (success) or `recordFailure` (error) so
-   * the row doesn't sit in 'claimed' forever — Phase-0 is a single worker
-   * so we don't need a claim-expiry sweeper yet.
-   */
-  claimNext() {
-    const pickAndClaim = this.db.transaction(() => {
-      const row = this.db.prepare(
-        `SELECT id, workspaceId, originKind, sourceRef, payloadJson, hintsJson,
-                  observedAt, attempts, lastError, createdAt
-             FROM asset_origin_outbox
-            WHERE status = 'pending'
-            ORDER BY createdAt ASC
-            LIMIT 1`
-      ).get();
-      if (!row) return null;
-      this.db.prepare("UPDATE asset_origin_outbox SET status = 'claimed', updatedAt = ? WHERE id = ?").run(Date.now(), row.id);
-      return row;
-    });
-    const claimed = pickAndClaim();
-    if (!claimed) return null;
-    return {
-      id: claimed.id,
-      row: rawToRow(claimed)
-    };
-  }
-  markUploaded(id, meta) {
-    this.db.prepare(
-      `UPDATE asset_origin_outbox
-            SET status = 'uploaded', assetId = ?, contentHash = ?, updatedAt = ?
-          WHERE id = ?`
-    ).run(meta.assetId, meta.contentHash, Date.now(), id);
-  }
-  /**
-   * Record one failed upload attempt. Increments `attempts`, stores the
-   * latest error, and either re-queues for retry (status -> 'pending') or
-   * spills to dead-letter once attempts hit maxAttempts.
-   */
-  recordFailure(id, error, opts) {
-    const now = Date.now();
-    const updated = this.db.transaction(() => {
-      const row = this.db.prepare(
-        `SELECT id, workspaceId, originKind, sourceRef, payloadJson, hintsJson,
-                  observedAt, attempts, createdAt
-             FROM asset_origin_outbox
-            WHERE id = ?`
-      ).get(id);
-      if (!row) return;
-      const nextAttempts = row.attempts + 1;
-      if (nextAttempts >= opts.maxAttempts) {
-        this.db.prepare(
-          `INSERT INTO asset_origin_outbox_dead_letter
-             (id, workspaceId, originKind, sourceRef, payloadJson, hintsJson, observedAt, errorJson, attempts, createdAt)
-             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-        ).run(
-          `dl_${(0, import_node_crypto8.randomUUID)()}`,
-          row.workspaceId,
-          row.originKind,
-          row.sourceRef,
-          row.payloadJson,
-          row.hintsJson,
-          row.observedAt,
-          JSON.stringify({ message: error, attempts: nextAttempts }),
-          nextAttempts,
-          now
-        );
-        this.db.prepare("DELETE FROM asset_origin_outbox WHERE id = ?").run(id);
-      } else {
-        this.db.prepare(
-          `UPDATE asset_origin_outbox
-                SET status = 'pending', attempts = ?, lastError = ?, updatedAt = ?
-              WHERE id = ?`
-        ).run(nextAttempts, error, now, id);
-      }
-    });
-    updated();
-  }
-  /**
-   * Re-promote any rows orphaned in `'claimed'` state back to `'pending'`.
-   *
-   * Why this exists: claimNext() transitions a row to 'claimed' under a
-   * transaction, but the upload that follows runs OUTSIDE the transaction
-   * (network call). If the daemon dies between the claim and the
-   * markUploaded/recordFailure call, the row is stuck — claimNext() only
-   * selects status='pending', so it would never be picked up again.
-   *
-   * Phase-0 single-worker safety: there is at most one in-flight claim at
-   * any time, so on next process startup ANY 'claimed' row is by definition
-   * orphaned. We promote it back to 'pending' (preserving attempts /
-   * lastError) so the next drainOnce can retry it.
-   *
-   * If we ever go multi-worker, this naive sweep becomes unsafe and must be
-   * replaced with a lease/heartbeat scheme.
-   *
-   * Returns the number of rows recovered (for logging / observability).
-   */
-  resetClaimed() {
-    const result = this.db.prepare(
-      "UPDATE asset_origin_outbox SET status = 'pending', updatedAt = ? WHERE status = 'claimed'"
-    ).run(Date.now());
-    return Number(result.changes);
-  }
-  pendingCount() {
-    return this.db.prepare("SELECT COUNT(*) AS n FROM asset_origin_outbox WHERE status = 'pending'").get().n;
-  }
-  uploadedCount() {
-    return this.db.prepare("SELECT COUNT(*) AS n FROM asset_origin_outbox WHERE status = 'uploaded'").get().n;
-  }
-  deadLetterCount() {
-    return this.db.prepare("SELECT COUNT(*) AS n FROM asset_origin_outbox_dead_letter").get().n;
-  }
-  close() {
-    this.db.close();
-  }
-};
-function computeIdempotencyKey(record) {
-  return (0, import_node_crypto8.createHash)("sha256").update(record.originKind).update("|").update(record.workspaceId).update("|").update(record.sourceRef).update("|").update(String(record.observedAt)).digest("hex");
-}
-function coerceToString(value, fallback) {
-  if (typeof value === "string") return value;
-  if (value == null) return fallback;
-  return String(value);
-}
-function coerceToJson(value) {
-  if (typeof value === "string") return value;
-  if (value == null) return "{}";
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return "{}";
-  }
-}
-function rawToRow(raw) {
-  return {
-    id: raw.id,
-    workspaceId: raw.workspaceId,
-    originKind: raw.originKind,
-    sourceRef: raw.sourceRef,
-    payloadJson: raw.payloadJson,
-    hintsJson: raw.hintsJson,
-    observedAt: raw.observedAt,
-    attempts: raw.attempts,
-    lastError: raw.lastError,
-    createdAt: raw.createdAt
-  };
-}
-
-// src/daemon/asset/origin/upload-runner.ts
-var UploadRunner = class {
-  constructor(opts) {
-    this.opts = opts;
-    opts.outbox.resetClaimed();
-  }
-  opts;
-  /**
-   * Process every currently-pending outbox row exactly once. Failed rows
-   * stay 'pending' (with attempts+1) for the next drainOnce call; rows
-   * that hit maxAttempts spill to dead-letter and trigger onUploadFailure.
-   *
-   * Returns the count of rows processed (success + failure).
-   */
-  async drainOnce() {
-    let count = 0;
-    while (true) {
-      const claim = this.opts.outbox.claimNext();
-      if (!claim) break;
-      count += 1;
-      const row = claim.row;
-      const adapter = this.opts.adapters[row.originKind];
-      if (!adapter) {
-        this.opts.outbox.recordFailure(claim.id, `no adapter registered for kind=${row.originKind}`, {
-          maxAttempts: 1
-          // unrecoverable — fast-fail to dead-letter
-        });
-        continue;
-      }
-      try {
-        const obs = rowToObservation(row);
-        const bytes = await adapter.fetch(obs);
-        const id = await adapter.identifySource(obs);
-        const filename = id.hints?.filename ?? path6.basename(row.sourceRef);
-        const metadata = {
-          sourceRef: row.sourceRef,
-          sourceKind: row.originKind
-        };
-        if (id.hints?.description) metadata.description = id.hints.description;
-        if (id.hints?.sourceAgentImUserId) {
-          metadata.sourceAgentImUserId = id.hints.sourceAgentImUserId;
-        }
-        const folderPath = id.hints?.folderPath || void 0;
-        const result = await this.opts.cloud.uploadAsset({
-          workspaceId: row.workspaceId,
-          filename,
-          bytes: bytes.bytes,
-          mime: bytes.mime,
-          size: bytes.size,
-          metadata,
-          folderPath
-        });
-        this.opts.outbox.markUploaded(claim.id, result);
-        await adapter.onUploadSuccess?.(obs);
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        const before = this.opts.outbox.deadLetterCount();
-        this.opts.outbox.recordFailure(claim.id, message, { maxAttempts: this.opts.maxAttempts });
-        const after = this.opts.outbox.deadLetterCount();
-        if (after > before) {
-          const obs = rowToObservation(row);
-          await adapter.onUploadFailure?.(obs, err);
-        }
-      }
-    }
-    return count;
-  }
-};
-function rowToObservation(row) {
-  let detail = {};
-  try {
-    const parsed = JSON.parse(row.payloadJson);
-    if (parsed && typeof parsed === "object") detail = parsed;
-  } catch {
-  }
-  return {
-    workspaceId: row.workspaceId,
-    detail,
-    observedAt: row.observedAt
-  };
-}
-var path6 = {
-  basename(p) {
-    const idx = Math.max(p.lastIndexOf("/"), p.lastIndexOf("\\"));
-    return idx === -1 ? p : p.slice(idx + 1);
-  }
-};
-
 // src/daemon/outbox-watcher.ts
-var import_node_fs12 = require("fs");
-var path7 = __toESM(require("path"), 1);
+var import_node_fs9 = require("fs");
+var path5 = __toESM(require("path"), 1);
 var DEFAULT_INTERVAL_MS = 2e3;
 var RESERVED_SUBDIR = "_uploaded";
 var OutboxWatcher = class {
@@ -7520,7 +6539,7 @@ var OutboxWatcher = class {
   async scanDir(dir, kind, task) {
     let entries = [];
     try {
-      entries = await import_node_fs12.promises.readdir(dir);
+      entries = await import_node_fs9.promises.readdir(dir);
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT") return;
@@ -7530,10 +6549,10 @@ var OutboxWatcher = class {
     for (const name of entries) {
       if (name.startsWith(".")) continue;
       if (name === RESERVED_SUBDIR) continue;
-      const full = path7.join(dir, name);
+      const full = path5.join(dir, name);
       let st;
       try {
-        st = await import_node_fs12.promises.stat(full);
+        st = await import_node_fs9.promises.stat(full);
       } catch {
         continue;
       }
@@ -7558,8 +6577,8 @@ var OutboxWatcher = class {
       this.log("warn", `skip ${filePath}: no active taskId (no dispatch/handoff received yet)`);
       return;
     }
-    const bytes = await import_node_fs12.promises.readFile(filePath);
-    const fileName = path7.basename(filePath);
+    const bytes = await import_node_fs9.promises.readFile(filePath);
+    const fileName = path5.basename(filePath);
     const blob = new Blob([new Uint8Array(bytes)]);
     const form = new FormData();
     form.append("workspaceId", wsId);
@@ -7608,8 +6627,8 @@ var OutboxWatcher = class {
 
 // src/daemon/shell-executor.ts
 var import_node_child_process4 = require("child_process");
-var import_node_fs13 = require("fs");
-var import_node_path9 = require("path");
+var import_node_fs10 = require("fs");
+var import_node_path7 = require("path");
 var DEFAULT_OUTPUT_LIMIT = 256 * 1024;
 var DEFAULT_TIMEOUT = 6e4;
 var HARD_MAX_TIMEOUT = 30 * 6e4;
@@ -7645,7 +6664,7 @@ async function executeShellDispatch(payload, deps) {
   const command = readCommand(payload, execution);
   if (!command.trim()) return fail(payload.taskId, "shell_command_required", "Shell command is required");
   const cwd = resolveCwd(execution.cwd, deps.config.defaultCwd);
-  if (!(0, import_node_fs13.existsSync)(cwd)) return fail(payload.taskId, "shell_cwd_missing", `cwd does not exist: ${cwd}`);
+  if (!(0, import_node_fs10.existsSync)(cwd)) return fail(payload.taskId, "shell_cwd_missing", `cwd does not exist: ${cwd}`);
   const timeoutMs = Math.min(
     typeof payload.timeoutMs === "number" && payload.timeoutMs > 0 ? payload.timeoutMs : deps.config.maxTimeoutMs,
     deps.config.maxTimeoutMs
@@ -7747,8 +6766,8 @@ function readCommand(payload, execution) {
   return payload.prompt;
 }
 function resolveCwd(raw, fallback) {
-  if (typeof raw !== "string" || raw.trim() === "") return (0, import_node_path9.resolve)(fallback);
-  return (0, import_node_path9.resolve)(raw);
+  if (typeof raw !== "string" || raw.trim() === "") return (0, import_node_path7.resolve)(fallback);
+  return (0, import_node_path7.resolve)(raw);
 }
 function clampNumber(value, fallback, min, max) {
   const n = typeof value === "number" ? value : typeof value === "string" ? Number(value) : NaN;
@@ -7798,15 +6817,6 @@ var Runner = class extends import_node_events3.EventEmitter {
   outboxWatcher;
   memoryWiring;
   assetMetadataIndexes = /* @__PURE__ */ new Map();
-  workspaceMirrors = /* @__PURE__ */ new Map();
-  assetOriginOutbox;
-  dropFolderAdapter;
-  dropFolderUploadRunner;
-  dropFolderTimer;
-  dropFolderWorkspaceId = "";
-  dropFolderWorkspaceDir = "";
-  dropFolderTickInFlight = false;
-  dropFolderStable = /* @__PURE__ */ new Map();
   state = "idle";
   startedAt = 0;
   workspaceId = "";
@@ -7848,7 +6858,6 @@ var Runner = class extends import_node_events3.EventEmitter {
     this.servicePool = new ServicePool();
     this.installStaticHostedAgentFromEnv();
     this.loadAgentsFromDb();
-    await this.prepareLocalProfiles();
     this.syncQueue = new SyncQueue(this.db);
     this.syncWorker = new SyncWorker({ queue: this.syncQueue, flush: (row) => this.flushSyncRow(row) });
     this.syncWorker.start();
@@ -7870,10 +6879,9 @@ var Runner = class extends import_node_events3.EventEmitter {
       );
     }
     if (this.workspaceId) {
-      this.syncAssetState(this.workspaceId).catch(
-        (err) => console.error("[Daemon] Initial asset sync failed:", err.message)
+      this.syncAssetMetadata(this.workspaceId).catch(
+        (err) => console.error("[Daemon] Initial asset metadata sync failed:", err.message)
       );
-      await this.ensureDropFolderRuntime(this.workspaceId);
     }
     const containerId = process.env.PRISMER_CONTAINER_ID;
     const isContainer = !!containerId || process.env.PRISMER_RUNTIME_MODE === "container";
@@ -7924,8 +6932,7 @@ var Runner = class extends import_node_events3.EventEmitter {
         // an actual agent process.
         attachMemory: this.memoryWiring ? attachMemoryRpc({ runtime: this.memoryWiring.runtime }) : void 0,
         attachAsset: attachAssetRpc({
-          resolveIndex: (workspaceId) => this.assetMetadataIndexes.get(workspaceId),
-          assetCache: this.assetCache
+          resolveIndex: (workspaceId) => this.assetMetadataIndexes.get(workspaceId)
         })
       });
       await this.localServer.start();
@@ -7974,7 +6981,6 @@ var Runner = class extends import_node_events3.EventEmitter {
     this.memoryWiring = void 0;
     this.ws?.close();
     this.outboxWatcher?.stop();
-    this.stopDropFolderRuntime();
     await this.servicePool?.shutdown();
     await this.localServer?.stop();
     try {
@@ -8031,7 +7037,6 @@ var Runner = class extends import_node_events3.EventEmitter {
       runningTaskIds: Array.from(this.runningTasks.keys()),
       observability: {
         adapters: this.snapshotAdapterObservability(),
-        assetSync: this.snapshotAssetSyncObservability(),
         ...this.lastTaskError ? { lastTaskError: this.lastTaskError } : {}
       }
     };
@@ -8067,35 +7072,6 @@ var Runner = class extends import_node_events3.EventEmitter {
       });
     }
   }
-  async prepareLocalProfiles() {
-    const rows = this.db.prepare(
-      `SELECT id, workspace_id, agent_im_user_id, adapter_name, name, config, version, synced_at
-         FROM agent_profiles
-         WHERE deleted_at IS NULL`
-    ).all();
-    for (const row of rows) {
-      const adapter = this.registry.get(row.adapter_name);
-      if (!adapter?.prepareProfile) continue;
-      try {
-        await adapter.prepareProfile({
-          id: row.id,
-          workspaceId: row.workspace_id,
-          agentImUserId: row.agent_im_user_id,
-          adapterName: row.adapter_name,
-          name: row.name,
-          config: parseProfileConfig(row.config),
-          version: row.version,
-          createdAt: new Date(row.synced_at ?? Date.now()),
-          updatedAt: new Date(row.synced_at ?? Date.now())
-        });
-      } catch (err) {
-        process.stderr.write(
-          `[daemon] local profile preflight skipped agent=${row.agent_im_user_id} profile=${row.id}: ${err.message}
-`
-        );
-      }
-    }
-  }
   /**
    * Register an in-process AgentProfile snapshot (called by agent CLI / sync layer).
    * Used to populate the `agents` list in agent.host.declare.
@@ -8153,10 +7129,10 @@ var Runner = class extends import_node_events3.EventEmitter {
     const rawJson = process.env.PRISMER_HOSTED_AGENT_JSON;
     let raw;
     if (rawFile) {
-      if (!(0, import_node_fs14.existsSync)(rawFile)) {
+      if (!(0, import_node_fs11.existsSync)(rawFile)) {
         throw new Error(`PRISMER_HOSTED_AGENT_FILE not found: ${rawFile}`);
       }
-      raw = (0, import_node_fs14.readFileSync)(rawFile, "utf8");
+      raw = (0, import_node_fs11.readFileSync)(rawFile, "utf8");
     } else if (rawJson) {
       raw = rawJson;
     }
@@ -8252,13 +7228,13 @@ var Runner = class extends import_node_events3.EventEmitter {
     const payload = {
       daemonId: this.config.daemon_id,
       daemonVersion: this.opts.daemonVersion ?? "0.0.0",
-      platform: (0, import_node_os6.platform)() === "win32" ? "win32" : (0, import_node_os6.platform)() === "linux" ? "linux" : "darwin",
+      platform: (0, import_node_os4.platform)() === "win32" ? "win32" : (0, import_node_os4.platform)() === "linux" ? "linux" : "darwin",
       agents: Array.from(this.hostedAgents.values()).map((a) => ({
         imUserId: a.imUserId,
         name: a.name,
         adapterName: a.adapterName,
         capabilities: a.capabilities,
-        profiles: Array.from(a.profiles.entries()).map(([id, version]) => ({ id, version }))
+        profiles: Array.from(a.profiles.entries()).map(([id, version2]) => ({ id, version: version2 }))
       }))
     };
     this.ws.send(envelope("agent.host.declare", payload, this.config.daemon_id));
@@ -8300,29 +7276,17 @@ var Runner = class extends import_node_events3.EventEmitter {
         (err) => console.error("[Daemon] Initial memory sync failed:", err.message)
       );
     }
-    this.syncAssetState(this.workspaceId).catch(
-      (err) => console.error("[Daemon] Asset sync failed:", err.message)
+    this.syncAssetMetadata(this.workspaceId).catch(
+      (err) => console.error("[Daemon] Asset metadata sync failed:", err.message)
     );
-    await this.ensureDropFolderRuntime(this.workspaceId);
     for (const id of payload.profilesToSync) {
       try {
-        await this.servicePool.drop(id);
         await this.syncProfileFromCloud(id);
       } catch (err) {
         this.emit("sync-error", err);
       }
     }
-    for (const id of payload.profilesToDelete ?? []) {
-      const row = this.db.prepare("SELECT agent_im_user_id FROM agent_profiles WHERE id = ?").get(id);
-      this.db.prepare("DELETE FROM agent_profiles WHERE id = ?").run(id);
-      if (row) {
-        this.db.prepare("DELETE FROM agents WHERE im_user_id = ?").run(row.agent_im_user_id);
-      }
-      process.stderr.write(`[daemon] tombstone profile=${id}
-`);
-    }
-    if (payload.profilesToDelete?.length) this.loadAgentsFromDb();
-    if ((payload.profilesToSync.length > 0 || (payload.profilesToDelete?.length ?? 0) > 0) && this.wsConnected) this.sendDeclare();
+    if (payload.profilesToSync.length > 0 && this.wsConnected) this.sendDeclare();
     this.emit("host-acked", payload);
   }
   async onTaskDispatch(payload, requestId) {
@@ -8363,14 +7327,8 @@ var Runner = class extends import_node_events3.EventEmitter {
           }
         });
         this.ws.send(envelope("task.dispatch.reply", reply, requestId));
-        if (!reply.ok) {
-          const code = reply.error?.code ?? "unknown";
-          const message = reply.error?.message ?? "unknown error";
-          process.stderr.write(`[daemon] dispatch failed task=${payload.taskId} code=${code} message=${message}
-`);
-        }
       } else {
-        const reply = await handleDispatch(payload, requestId, {
+        await handleDispatch(payload, requestId, {
           registry: this.registry,
           cloud: this.cloud,
           uriResolver: this.uriResolver,
@@ -8386,12 +7344,6 @@ var Runner = class extends import_node_events3.EventEmitter {
             if (running) running.lastProgressAt = Date.now();
           }
         });
-        if (!reply.ok) {
-          const code = reply.error?.code ?? "unknown";
-          const message = reply.error?.message ?? "unknown error";
-          process.stderr.write(`[daemon] dispatch failed task=${payload.taskId} code=${code} message=${message}
-`);
-        }
       }
       process.stdout.write(`[daemon] dispatch done task=${payload.taskId}
 `);
@@ -8419,7 +7371,6 @@ var Runner = class extends import_node_events3.EventEmitter {
   }
   async onAgentProfileChanged(payload) {
     try {
-      await this.servicePool.drop(payload.profileId);
       await this.syncProfileFromCloud(payload.profileId);
       if (this.wsConnected) this.sendDeclare();
     } catch (err) {
@@ -8427,21 +7378,7 @@ var Runner = class extends import_node_events3.EventEmitter {
     }
   }
   async syncProfileFromCloud(profileId) {
-    let profile;
-    try {
-      profile = await this.cloud.get(`/api/im/agent_profiles/${encodeURIComponent(profileId)}`);
-    } catch (err) {
-      if (err instanceof CloudError && err.status === 404) {
-        const row = this.db.prepare("SELECT agent_im_user_id FROM agent_profiles WHERE id = ?").get(profileId);
-        this.db.prepare("DELETE FROM agent_profiles WHERE id = ?").run(profileId);
-        if (row) {
-          this.db.prepare("DELETE FROM agents WHERE im_user_id = ?").run(row.agent_im_user_id);
-        }
-        this.loadAgentsFromDb();
-        return;
-      }
-      throw err;
-    }
+    const profile = await this.cloud.get(`/api/im/agent_profiles/${encodeURIComponent(profileId)}`);
     const agent = await this.resolveOwnedAgent(profile.agentImUserId);
     const adapter = this.registry.get(profile.adapterName);
     const capabilities = agent?.card?.capabilities?.length ? agent.card.capabilities : adapter?.capabilities ?? [];
@@ -8476,14 +7413,6 @@ var Runner = class extends import_node_events3.EventEmitter {
       );
     });
     tx();
-    try {
-      await adapter?.prepareProfile?.(profile);
-    } catch (err) {
-      process.stderr.write(
-        `[daemon] profile preflight skipped agent=${profile.agentImUserId} profile=${profile.id}: ${err.message}
-`
-      );
-    }
     this.loadAgentsFromDb();
     process.stdout.write(
       `[daemon] profile synced agent=${profile.agentImUserId} profile=${profile.id} adapter=${profile.adapterName}
@@ -8512,10 +7441,15 @@ var Runner = class extends import_node_events3.EventEmitter {
   }
   async onAssetChanged(payload) {
     if (!payload.workspaceId) return;
+    const index = this.assetMetadataIndexes.get(payload.workspaceId);
+    if (!index) return;
     try {
-      await this.syncAssetState(payload.workspaceId);
+      const result = await index.pullDelta();
+      if (result.applied > 0) {
+        console.log(`[Daemon] asset.changed workspace=${payload.workspaceId} applied=${result.applied}`);
+      }
     } catch (err) {
-      console.error(`[Daemon] asset.changed sync failed workspace=${payload.workspaceId}:`, err.message);
+      console.error(`[Daemon] asset.changed pullDelta failed workspace=${payload.workspaceId}:`, err.message);
     }
   }
   onWorkspaceFileChanged(payload) {
@@ -8553,163 +7487,28 @@ var Runner = class extends import_node_events3.EventEmitter {
       }
     };
   }
-  snapshotAssetSyncObservability() {
-    return {
-      workspaceId: this.dropFolderWorkspaceId || null,
-      rootDir: this.dropFolderWorkspaceDir || null,
-      dropDir: this.dropFolderWorkspaceDir ? (0, import_node_path10.join)(this.dropFolderWorkspaceDir, "drop") : null,
-      uploadedDir: this.dropFolderWorkspaceDir ? (0, import_node_path10.join)(this.dropFolderWorkspaceDir, "uploaded") : null,
-      failedDir: this.dropFolderWorkspaceDir ? (0, import_node_path10.join)(this.dropFolderWorkspaceDir, "upload-failed") : null
-    };
-  }
   /**
    * Ensure an AssetMetadataIndex exists for the given workspace and pull
    * delta from cloud. Idempotent — creates the index on first call, reuses
-   * it on subsequent calls. Same cursor-catch-up semantics as WorkspaceMirror.
-   */
-  async syncAssetMetadata(workspaceId) {
-    let index = this.assetMetadataIndexes.get(workspaceId);
-    if (!index) {
-      const stateDir = `${this.paths.root}/${workspaceId}`;
-      index = new AssetMetadataIndex({
-        db: this.db,
-        cloud: this.cloud,
-        workspaceId,
-        workspaceStateDir: stateDir
-      });
-      this.assetMetadataIndexes.set(workspaceId, index);
-    }
-    const result = await index.pullDelta();
-    if (result.applied > 0) {
-      console.log(`[AssetMeta] workspace=${workspaceId}: ${result.applied} applied, cursor=${result.cursor}`);
-    }
-  }
-  /**
-   * Ensure a WorkspaceMirror exists for the workspace and pull path→asset
-   * bindings from cloud. Cold-start daemons previously only had this table
-   * populated by WS push or per-path URI fallback, so local asset state looked
-   * empty even though cloud files existed.
+   * it on subsequent calls. Same cursor-catch-up semantics as WorkspaceMirror.
    */
-  async syncWorkspaceFiles(workspaceId) {
-    let mirror = this.workspaceMirrors.get(workspaceId);
-    if (!mirror) {
+  async syncAssetMetadata(workspaceId) {
+    let index = this.assetMetadataIndexes.get(workspaceId);
+    if (!index) {
       const stateDir = `${this.paths.root}/${workspaceId}`;
-      mirror = new WorkspaceMirror({
+      index = new AssetMetadataIndex({
         db: this.db,
         cloud: this.cloud,
         workspaceId,
         workspaceStateDir: stateDir
       });
-      this.workspaceMirrors.set(workspaceId, mirror);
+      this.assetMetadataIndexes.set(workspaceId, index);
     }
-    const result = await mirror.pullDelta();
+    const result = await index.pullDelta();
     if (result.applied > 0) {
-      console.log(`[WorkspaceFiles] workspace=${workspaceId}: ${result.applied} applied, cursor=${result.cursor ?? "null"}`);
-    }
-  }
-  async syncAssetState(workspaceId) {
-    if (!this.paths?.root) return;
-    await Promise.all([
-      this.syncAssetMetadata(workspaceId),
-      this.syncWorkspaceFiles(workspaceId)
-    ]);
-  }
-  /**
-   * Desktop asset ingress: watch a user-visible local asset folder
-   * and upload new files as IMAssets, preserving nested relative dirs in
-   * IMAsset.folderPath. The lower-level adapter/outbox/uploader already
-   * existed; this method wires them into the real daemon lifecycle.
-   */
-  async ensureDropFolderRuntime(workspaceId) {
-    if (!workspaceId || !this.paths?.root) return;
-    if (this.dropFolderWorkspaceId === workspaceId && this.dropFolderTimer) return;
-    this.stopDropFolderRuntime();
-    this.dropFolderWorkspaceId = workspaceId;
-    const workspaceRoot = resolveUserAssetWorkspaceDir(workspaceId);
-    this.dropFolderWorkspaceDir = workspaceRoot;
-    await (0, import_promises.mkdir)((0, import_node_path10.join)(workspaceRoot, "drop"), { recursive: true });
-    await (0, import_promises.mkdir)((0, import_node_path10.join)(workspaceRoot, "uploaded"), { recursive: true });
-    await (0, import_promises.mkdir)((0, import_node_path10.join)(workspaceRoot, "upload-failed"), { recursive: true });
-    this.assetOriginOutbox = new OriginOutbox({ dbPath: (0, import_node_path10.join)(this.paths.root, "asset-origin.db") });
-    this.dropFolderAdapter = new DropFolderAdapter({ workspaceDir: workspaceRoot });
-    this.dropFolderUploadRunner = new UploadRunner({
-      outbox: this.assetOriginOutbox,
-      cloud: new DaemonAssetUploadClient(this.config),
-      adapters: { "drop-folder": this.dropFolderAdapter },
-      maxAttempts: 3
-    });
-    const tick = () => {
-      this.runDropFolderTick().catch((err) => {
-        process.stderr.write(`[daemon] drop-folder sync failed: ${err.message}
-`);
-      });
-    };
-    this.dropFolderTimer = setInterval(tick, 1e3);
-    tick();
-    process.stdout.write(`[daemon] drop-folder asset sync watching ${(0, import_node_path10.join)(workspaceRoot, "drop")}
-`);
-  }
-  stopDropFolderRuntime() {
-    if (this.dropFolderTimer) {
-      clearInterval(this.dropFolderTimer);
-      this.dropFolderTimer = void 0;
-    }
-    try {
-      this.assetOriginOutbox?.close();
-    } catch {
-    }
-    this.assetOriginOutbox = void 0;
-    this.dropFolderAdapter = void 0;
-    this.dropFolderUploadRunner = void 0;
-    this.dropFolderWorkspaceId = "";
-    this.dropFolderWorkspaceDir = "";
-    this.dropFolderTickInFlight = false;
-    this.dropFolderStable.clear();
-  }
-  async runDropFolderTick() {
-    if (this.dropFolderTickInFlight) return;
-    const workspaceId = this.dropFolderWorkspaceId;
-    const adapter = this.dropFolderAdapter;
-    const outbox = this.assetOriginOutbox;
-    const runner = this.dropFolderUploadRunner;
-    if (!workspaceId || !adapter || !outbox || !runner) return;
-    this.dropFolderTickInFlight = true;
-    try {
-      const observations = await adapter.scanOnce(workspaceId);
-      for (const obs of observations) {
-        const id = await adapter.identifySource(obs);
-        if (!this.isDropFolderObservationStable(id.sourceRef, obs.detail)) continue;
-        outbox.enqueue({
-          workspaceId: obs.workspaceId,
-          originKind: "drop-folder",
-          sourceRef: id.sourceRef,
-          payloadJson: JSON.stringify(obs.detail),
-          hintsJson: JSON.stringify(id.hints ?? {}),
-          observedAt: obs.observedAt
-        });
-      }
-      const processed = await runner.drainOnce();
-      if (processed > 0) {
-        this.dropFolderStable.clear();
-        process.stdout.write(`[daemon] drop-folder uploaded/processed ${processed} asset(s)
-`);
-        await this.syncAssetState(workspaceId).catch(
-          (err) => process.stderr.write(`[daemon] drop-folder post-sync failed: ${err.message}
-`)
-        );
-      }
-    } finally {
-      this.dropFolderTickInFlight = false;
+      console.log(`[AssetMeta] workspace=${workspaceId}: ${result.applied} applied, cursor=${result.cursor}`);
     }
   }
-  isDropFolderObservationStable(sourceRef, detail) {
-    const raw = detail && typeof detail === "object" ? detail : {};
-    const size = typeof raw.size === "number" ? raw.size : -1;
-    const mtime = typeof raw.mtime === "number" ? raw.mtime : -1;
-    const previous = this.dropFolderStable.get(sourceRef);
-    this.dropFolderStable.set(sourceRef, { size, mtime });
-    return Boolean(previous && previous.size === size && previous.mtime === mtime);
-  }
   /**
    * SyncWorker FlushFn — pushes local writes to cloud.
    *
@@ -8746,44 +7545,44 @@ var Runner = class extends import_node_events3.EventEmitter {
     const id = encodeURIComponent(row.resource_id);
     const body = row.operation === "delete" ? void 0 : safeJsonParse(row.payload);
     let method;
-    let path9;
+    let path7;
     switch (op) {
       case "workspace.create":
         method = "POST";
-        path9 = "/api/im/workspaces";
+        path7 = "/api/im/workspaces";
         break;
       case "workspace.update":
         method = "PATCH";
-        path9 = `/api/im/workspaces/${id}`;
+        path7 = `/api/im/workspaces/${id}`;
         break;
       case "workspace.delete":
         method = "DELETE";
-        path9 = `/api/im/workspaces/${id}`;
+        path7 = `/api/im/workspaces/${id}`;
         break;
       // agent.create must use /register — POST /api/im/agents is not exposed.
       case "agent.create":
         method = "POST";
-        path9 = "/api/im/register";
+        path7 = "/api/im/register";
         break;
       case "agent.update":
         method = "PATCH";
-        path9 = `/api/im/agents/${id}`;
+        path7 = `/api/im/agents/${id}`;
         break;
       case "agent.delete":
         method = "DELETE";
-        path9 = `/api/im/agents/${id}`;
+        path7 = `/api/im/agents/${id}`;
         break;
       case "agent_profile.create":
         method = "POST";
-        path9 = "/api/im/agent_profiles";
+        path7 = "/api/im/agent_profiles";
         break;
       case "agent_profile.update":
         method = "PATCH";
-        path9 = `/api/im/agent_profiles/${id}`;
+        path7 = `/api/im/agent_profiles/${id}`;
         break;
       case "agent_profile.delete":
         method = "DELETE";
-        path9 = `/api/im/agent_profiles/${id}`;
+        path7 = `/api/im/agent_profiles/${id}`;
         break;
       default:
         process.stderr.write(`[daemon] sync flush op=${op} id=${row.id} result=drop (unknown op)
@@ -8792,7 +7591,7 @@ var Runner = class extends import_node_events3.EventEmitter {
     }
     let res;
     try {
-      res = await this.cloud.request(method, path9, { body });
+      res = await this.cloud.request(method, path7, { body });
     } catch (err) {
       process.stderr.write(
         `[daemon] sync flush op=${op} id=${row.id} result=retry (threw: ${err.message})
@@ -8815,89 +7614,6 @@ var Runner = class extends import_node_events3.EventEmitter {
     return { ok: res.ok, status: res.status, message: res.error?.message };
   }
 };
-var DaemonAssetUploadClient = class {
-  constructor(config) {
-    this.config = config;
-  }
-  config;
-  async uploadAsset(req) {
-    const form = new FormData();
-    form.set("workspaceId", req.workspaceId);
-    form.set("kind", "file");
-    form.set("metadata", JSON.stringify(req.metadata));
-    if (req.folderPath !== void 0) form.set("folderPath", req.folderPath);
-    form.set("file", new Blob([req.bytes], { type: req.mime ?? "application/octet-stream" }), req.filename);
-    const url = `${this.config.cloud_api_base.replace(/\/$/, "")}/api/im/assets`;
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), 6e4);
-    let res;
-    try {
-      res = await fetch(url, {
-        method: "POST",
-        headers: { Authorization: `Bearer ${this.config.api_key}` },
-        body: form,
-        signal: controller.signal
-      });
-    } catch (err) {
-      if (err.name === "AbortError") {
-        throw new Error("asset upload timed out after 60000ms");
-      }
-      throw err;
-    } finally {
-      clearTimeout(timer);
-    }
-    const text = await res.text();
-    let body;
-    try {
-      body = text ? JSON.parse(text) : void 0;
-    } catch {
-      body = text;
-    }
-    if (!res.ok || isCloudErrorEnvelope(body)) {
-      throw new Error(`asset upload failed (${res.status}): ${cloudUploadErrorMessage(body)}`);
-    }
-    const data = unwrapCloudData(body);
-    const assetId = stringValue(data, "id");
-    const contentHash = stringValue(data, "contentHash");
-    if (!assetId || !contentHash) {
-      throw new Error("asset upload response missing id/contentHash");
-    }
-    return { assetId, contentHash };
-  }
-};
-function isCloudErrorEnvelope(raw) {
-  return Boolean(raw && typeof raw === "object" && "ok" in raw && raw.ok === false);
-}
-function cloudUploadErrorMessage(raw) {
-  if (raw && typeof raw === "object") {
-    const error = raw.error;
-    if (typeof error === "string") return error;
-    if (error && typeof error === "object") {
-      const message = error.message;
-      if (typeof message === "string") return message;
-    }
-  }
-  return typeof raw === "string" ? raw : "request failed";
-}
-function unwrapCloudData(raw) {
-  if (raw && typeof raw === "object") {
-    const data = raw.data;
-    if (data && typeof data === "object" && !Array.isArray(data)) return data;
-  }
-  return {};
-}
-function stringValue(obj, key) {
-  const value = obj[key];
-  return typeof value === "string" && value.length > 0 ? value : void 0;
-}
-function resolveUserAssetWorkspaceDir(workspaceId) {
-  const override = process.env.PRISMER_ASSET_SYNC_ROOT;
-  if (override) return (0, import_node_path10.join)(override, workspaceId);
-  const home = (0, import_node_os6.homedir)();
-  const desktop = (0, import_node_path10.join)(home, "Desktop");
-  const base = (0, import_node_fs14.existsSync)(desktop) ? desktop : home;
-  return (0, import_node_path10.join)(base, "Prismer Assets", workspaceId);
-}
 function readTargetDaemonId(payload) {
   if (typeof payload.targetDaemonId === "string" && payload.targetDaemonId.length > 0) {
     return payload.targetDaemonId;
@@ -8948,14 +7664,6 @@ function validateStaticHostedAgent(raw) {
     }
   };
 }
-function parseProfileConfig(raw) {
-  try {
-    const parsed = JSON.parse(raw);
-    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
-  } catch {
-    return {};
-  }
-}
 function safeJsonParse(raw) {
   try {
     return JSON.parse(raw);
@@ -8965,9 +7673,9 @@ function safeJsonParse(raw) {
 }
 
 // src/pair.ts
-var import_node_crypto9 = require("crypto");
-var import_node_os7 = require("os");
-var import_promises2 = require("timers/promises");
+var import_node_crypto5 = require("crypto");
+var import_node_os5 = require("os");
+var import_promises = require("timers/promises");
 var import_qrcode = __toESM(require("qrcode"), 1);
 async function pair(opts) {
   const paths = opts.paths ?? resolvePaths();
@@ -8983,7 +7691,7 @@ async function pair(opts) {
       "pair: --as-user requires LOCAL_ONLY=1. Without that gate, this would skip mobile approval and silently mint a key for the named user."
     );
   }
-  const { publicKey } = (0, import_node_crypto9.generateKeyPairSync)("ed25519");
+  const { publicKey } = (0, import_node_crypto5.generateKeyPairSync)("ed25519");
   const devicePub = publicKey.export({ format: "der", type: "spki" }).toString("base64");
   const cloud = new CloudClient({
     baseUrl: opts.cloudBaseUrl,
@@ -8996,7 +7704,7 @@ async function pair(opts) {
     "/api/im/pair/offer",
     {
       auth: false,
-      body: { devicePub, deviceName: opts.deviceName ?? (0, import_node_os7.hostname)() }
+      body: { devicePub, deviceName: opts.deviceName ?? (0, import_node_os5.hostname)() }
     }
   );
   if (!offerRes.ok) {
@@ -9036,7 +7744,7 @@ Scan with Lumin to approve, or open: ${offer.qrUrl}
   const pollIntervalMs = opts.pollIntervalMs ?? 5e3;
   for (let i = 0; i < maxAttempts; i += 1) {
     if (i > 0 || !localOnlyMode) {
-      await (0, import_promises2.setTimeout)(pollIntervalMs);
+      await (0, import_promises.setTimeout)(pollIntervalMs);
     }
     const res = await cloud.request(
       "GET",
@@ -9073,13 +7781,13 @@ function unwrapEnvelope(raw) {
 }
 
 // src/cli/index.ts
-var import_commander19 = require("commander");
+var import_commander18 = require("commander");
 
 // src/cli/commands/adapter.ts
 var import_node_child_process5 = require("child_process");
-var import_node_fs16 = require("fs");
-var import_node_os8 = require("os");
-var import_node_path12 = require("path");
+var import_node_fs13 = require("fs");
+var import_node_os6 = require("os");
+var import_node_path9 = require("path");
 var import_commander = require("commander");
 init_util();
 init_ui();
@@ -9092,7 +7800,7 @@ var INSTALL_SPECS = {
     binary: "claude",
     hint: "Set ANTHROPIC_API_KEY in your shell profile, or rely on Claude Code OAuth login. Run `claude login` to sign in.",
     authHints: ["ANTHROPIC_API_KEY or Claude Code OAuth login (`claude login`)"],
-    hookTarget: { path: (0, import_node_path12.join)((0, import_node_os8.homedir)(), ".claude", "hooks.json"), kind: "json-file" }
+    hookTarget: { path: (0, import_node_path9.join)((0, import_node_os6.homedir)(), ".claude", "hooks.json"), kind: "json-file" }
   },
   openclaw: {
     name: "openclaw",
@@ -9101,7 +7809,7 @@ var INSTALL_SPECS = {
     binary: "openclaw",
     hint: "OpenClaw runs as a gateway. Configure ~/.openclaw/openclaw.json and start it with `openclaw gateway` before tasks dispatch.",
     authHints: ["~/.openclaw/openclaw.json gateway.auth.bearerTokens", "Prismer daemon api_key"],
-    hookTarget: { path: (0, import_node_path12.join)((0, import_node_os8.homedir)(), ".openclaw", "hooks"), kind: "directory" }
+    hookTarget: { path: (0, import_node_path9.join)((0, import_node_os6.homedir)(), ".openclaw", "hooks"), kind: "directory" }
   },
   codex: {
     name: "codex",
@@ -9110,7 +7818,7 @@ var INSTALL_SPECS = {
     binary: "codex",
     hint: "Set OPENAI_API_KEY in your shell profile. Verify with `codex --help`.",
     authHints: ["OPENAI_API_KEY or Codex CLI account login"],
-    hookTarget: { path: (0, import_node_path12.join)((0, import_node_os8.homedir)(), ".codex", "hooks.json"), kind: "json-file" }
+    hookTarget: { path: (0, import_node_path9.join)((0, import_node_os6.homedir)(), ".codex", "hooks.json"), kind: "json-file" }
   },
   hermes: {
     name: "hermes",
@@ -9119,7 +7827,7 @@ var INSTALL_SPECS = {
     binary: "hermes",
     hint: "Hermes runs as a long-lived HTTP gateway in your own Python venv. Start with `hermes -p <profile> gateway` after configuring ~/.hermes/.env.",
     authHints: ["~/.hermes/.env API_SERVER_KEY", "Hermes profile provider credentials"],
-    hookTarget: { path: (0, import_node_path12.join)((0, import_node_os8.homedir)(), ".hermes", "hooks.json"), kind: "json-file" }
+    hookTarget: { path: (0, import_node_path9.join)((0, import_node_os6.homedir)(), ".hermes", "hooks.json"), kind: "json-file" }
   }
 };
 function buildAdapterCommand() {
@@ -9207,8 +7915,8 @@ function buildAdapterCommand() {
   });
   return cmd;
 }
-function runInstall(spec, version, dryRun) {
-  const { argv0, args } = installCommand(spec, version);
+function runInstall(spec, version2, dryRun) {
+  const { argv0, args } = installCommand(spec, version2);
   getUI().line(`> ${argv0} ${args.join(" ")}`);
   if (dryRun) {
     getUI().line("(dry-run \u2014 not executing)");
@@ -9334,15 +8042,15 @@ function runHooks(spec, opts) {
   }
   let backup;
   if (planned.kind === "directory") {
-    (0, import_node_fs16.mkdirSync)(planned.path, { recursive: true });
-    const markerPath = (0, import_node_path12.join)(planned.path, "prismer.json");
+    (0, import_node_fs13.mkdirSync)(planned.path, { recursive: true });
+    const markerPath = (0, import_node_path9.join)(planned.path, "prismer.json");
     backup = backupIfExists(markerPath);
-    (0, import_node_fs16.writeFileSync)(markerPath, JSON.stringify(prismerHookMarker(spec), null, 2) + "\n", "utf8");
+    (0, import_node_fs13.writeFileSync)(markerPath, JSON.stringify(prismerHookMarker(spec), null, 2) + "\n", "utf8");
   } else {
-    (0, import_node_fs16.mkdirSync)((0, import_node_path12.dirname)(planned.path), { recursive: true });
+    (0, import_node_fs13.mkdirSync)((0, import_node_path9.dirname)(planned.path), { recursive: true });
     backup = backupIfExists(planned.path);
     const merged = mergeHookJson(planned.path, spec);
-    (0, import_node_fs16.writeFileSync)(planned.path, JSON.stringify(merged, null, 2) + "\n", "utf8");
+    (0, import_node_fs13.writeFileSync)(planned.path, JSON.stringify(merged, null, 2) + "\n", "utf8");
   }
   return {
     ok: true,
@@ -9352,16 +8060,16 @@ function runHooks(spec, opts) {
     hook: inspectHook(spec)
   };
 }
-function installCommand(spec, version) {
-  const ref = version === "latest" ? spec.package : `${spec.package}@${version}`;
+function installCommand(spec, version2) {
+  const ref = version2 === "latest" ? spec.package : `${spec.package}@${version2}`;
   switch (spec.manager) {
     case "npm":
       return { argv0: "npm", args: ["install", "-g", ref] };
     case "pipx":
-      const pyRef = version === "latest" ? spec.package : `${spec.package}==${version}`;
+      const pyRef = version2 === "latest" ? spec.package : `${spec.package}==${version2}`;
       return { argv0: "pipx", args: ["install", pyRef] };
     case "pip":
-      const pipRef = version === "latest" ? spec.package : `${spec.package}==${version}`;
+      const pipRef = version2 === "latest" ? spec.package : `${spec.package}==${version2}`;
       return { argv0: "pip", args: ["install", "--user", pipRef] };
   }
 }
@@ -9409,23 +8117,23 @@ function inspectAuthEnv(spec) {
         hints: spec.authHints ?? []
       };
     case "hermes": {
-      const envFile = (0, import_node_path12.join)((0, import_node_os8.homedir)(), ".hermes", ".env");
+      const envFile = (0, import_node_path9.join)((0, import_node_os6.homedir)(), ".hermes", ".env");
       return {
-        ok: (0, import_node_fs16.existsSync)(envFile) || Boolean(process.env.HERMES_API_KEY || process.env.API_SERVER_KEY),
+        ok: (0, import_node_fs13.existsSync)(envFile) || Boolean(process.env.HERMES_API_KEY || process.env.API_SERVER_KEY),
         present: [
           ...["HERMES_API_KEY", "API_SERVER_KEY"].filter((k) => Boolean(process.env[k])),
-          ...(0, import_node_fs16.existsSync)(envFile) ? [envFile] : []
+          ...(0, import_node_fs13.existsSync)(envFile) ? [envFile] : []
         ],
         hints: spec.authHints ?? []
       };
     }
     case "openclaw": {
-      const cfgFile = (0, import_node_path12.join)((0, import_node_os8.homedir)(), ".openclaw", "openclaw.json");
+      const cfgFile = (0, import_node_path9.join)((0, import_node_os6.homedir)(), ".openclaw", "openclaw.json");
       return {
-        ok: (0, import_node_fs16.existsSync)(cfgFile) || Boolean(process.env.OPENCLAW_API_KEY),
+        ok: (0, import_node_fs13.existsSync)(cfgFile) || Boolean(process.env.OPENCLAW_API_KEY),
         present: [
           ...["OPENCLAW_API_KEY"].filter((k) => Boolean(process.env[k])),
-          ...(0, import_node_fs16.existsSync)(cfgFile) ? [cfgFile] : []
+          ...(0, import_node_fs13.existsSync)(cfgFile) ? [cfgFile] : []
         ],
         hints: spec.authHints ?? []
       };
@@ -9440,32 +8148,32 @@ function inspectHook(spec) {
     return { supported: false, markerPresent: false };
   }
   if (spec.name === "openclaw") {
-    const jsonPath = (0, import_node_path12.join)((0, import_node_os8.homedir)(), ".openclaw", "hooks.json");
-    const markerPath = (0, import_node_path12.join)(target.path, "prismer.json");
-    const jsonMarkerPresent = (0, import_node_fs16.existsSync)(jsonPath) && fileContainsPrismerMarker(jsonPath);
-    const dirMarkerPresent = (0, import_node_fs16.existsSync)(markerPath) && fileContainsPrismerMarker(markerPath);
+    const jsonPath = (0, import_node_path9.join)((0, import_node_os6.homedir)(), ".openclaw", "hooks.json");
+    const markerPath = (0, import_node_path9.join)(target.path, "prismer.json");
+    const jsonMarkerPresent = (0, import_node_fs13.existsSync)(jsonPath) && fileContainsPrismerMarker(jsonPath);
+    const dirMarkerPresent = (0, import_node_fs13.existsSync)(markerPath) && fileContainsPrismerMarker(markerPath);
     return {
       supported: true,
       kind: "json-file-or-directory",
       path: target.path,
       jsonPath,
-      exists: (0, import_node_fs16.existsSync)(target.path) || (0, import_node_fs16.existsSync)(jsonPath),
+      exists: (0, import_node_fs13.existsSync)(target.path) || (0, import_node_fs13.existsSync)(jsonPath),
       markerPath,
       markerPresent: jsonMarkerPresent || dirMarkerPresent
     };
   }
   if (target.kind === "directory") {
-    const markerPath = (0, import_node_path12.join)(target.path, "prismer.json");
+    const markerPath = (0, import_node_path9.join)(target.path, "prismer.json");
     return {
       supported: true,
       kind: target.kind,
       path: target.path,
-      exists: (0, import_node_fs16.existsSync)(target.path),
+      exists: (0, import_node_fs13.existsSync)(target.path),
       markerPath,
-      markerPresent: (0, import_node_fs16.existsSync)(markerPath) && fileContainsPrismerMarker(markerPath)
+      markerPresent: (0, import_node_fs13.existsSync)(markerPath) && fileContainsPrismerMarker(markerPath)
     };
   }
-  const exists = (0, import_node_fs16.existsSync)(target.path);
+  const exists = (0, import_node_fs13.existsSync)(target.path);
   if (!exists) {
     return {
       supported: true,
@@ -9499,21 +8207,21 @@ function prismerHookMarker(spec) {
     installed_at: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-function mergeHookJson(path9, spec) {
+function mergeHookJson(path7, spec) {
   const marker = prismerHookMarker(spec);
-  if (!(0, import_node_fs16.existsSync)(path9)) {
+  if (!(0, import_node_fs13.existsSync)(path7)) {
     return {
       prismer: marker
     };
   }
   let parsed;
   try {
-    parsed = JSON.parse((0, import_node_fs16.readFileSync)(path9, "utf8"));
+    parsed = JSON.parse((0, import_node_fs13.readFileSync)(path7, "utf8"));
   } catch (err) {
-    throw new Error(`Cannot parse ${path9} as JSON: ${err.message}`);
+    throw new Error(`Cannot parse ${path7} as JSON: ${err.message}`);
   }
   if (!isRecord(parsed)) {
-    throw new Error(`Cannot merge ${path9}: expected a JSON object`);
+    throw new Error(`Cannot merge ${path7}: expected a JSON object`);
   }
   const next = { ...parsed };
   next.prismer = marker;
@@ -9531,18 +8239,18 @@ function mergeHookJson(path9, spec) {
   }
   return next;
 }
-function backupIfExists(path9) {
-  if (!(0, import_node_fs16.existsSync)(path9)) return null;
+function backupIfExists(path7) {
+  if (!(0, import_node_fs13.existsSync)(path7)) return null;
   const suffix = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const backup = `${path9}.bak.${suffix}`;
-  const stat = (0, import_node_fs16.statSync)(path9);
+  const backup = `${path7}.bak.${suffix}`;
+  const stat = (0, import_node_fs13.statSync)(path7);
   if (stat.isDirectory()) return null;
-  (0, import_node_fs16.copyFileSync)(path9, backup);
+  (0, import_node_fs13.copyFileSync)(path7, backup);
   return backup;
 }
-function fileContainsPrismerMarker(path9) {
+function fileContainsPrismerMarker(path7) {
   try {
-    return (0, import_node_fs16.readFileSync)(path9, "utf8").includes("prismer-daemon-runtime");
+    return (0, import_node_fs13.readFileSync)(path7, "utf8").includes("prismer-daemon-runtime");
   } catch {
     return false;
   }
@@ -9560,7 +8268,7 @@ function readAdapterConfig() {
     return {};
   }
 }
-function recordInstallInConfig(spec, binPath, version) {
+function recordInstallInConfig(spec, binPath, version2) {
   const paths = resolvePaths();
   if (!configExists(paths)) {
     process.stderr.write(
@@ -9582,7 +8290,7 @@ function recordInstallInConfig(spec, binPath, version) {
     package_manager: spec.manager,
     package_name: spec.package,
     binary: binPath,
-    version,
+    version: version2,
     installed_at: (/* @__PURE__ */ new Date()).toISOString()
   };
   saveConfig({ ...cfg, adapters }, paths);
@@ -9962,7 +8670,7 @@ async function fetchCloudProfiles(cloud, imUserId) {
 async function fetchLocalServer() {
   const paths = resolvePaths();
   const pid = readPidFile(paths);
-  if (!pid || !pidAlive2(pid)) return { ok: false, error: "daemon process is not running", agents: [] };
+  if (!pid || !pidAlive(pid)) return { ok: false, error: "daemon process is not running", agents: [] };
   try {
     const [healthRes, agentsRes] = await Promise.all([
       fetch(`${LOCAL_SERVER}/healthz`, { signal: AbortSignal.timeout(1e3) }),
@@ -9986,38 +8694,19 @@ function whichBinary2(bin) {
 
 // src/cli/commands/asset.ts
 var import_commander3 = require("commander");
-var import_node_fs17 = require("fs");
-var import_node_path13 = require("path");
+var import_node_fs14 = require("fs");
+var import_node_path10 = require("path");
 init_util();
 init_ui();
 function buildAssetCommand() {
   const cmd = new import_commander3.Command("asset").description("Inspect IM assets");
-  cmd.command("sync").description("Sync remote asset indexes into the local daemon DB; optionally prefetch bytes").requiredOption("--workspace-id <id>", "Workspace id").option("--bytes", "Also prefetch asset bytes into ~/.prismer/cache").option("--limit <n>", "Maximum number of assets to prefetch when --bytes is set", parsePositiveInt).option("--json", "Output machine-readable JSON").action(runAction(async (opts) => {
-    const result = await syncAssets(opts);
-    if (opts.json) {
-      printJson({ ok: true, data: result });
-      return;
-    }
-    getUI().line(`Synced asset metadata: ${result.metadata.applied} applied (cursor=${result.metadata.cursor})`);
-    getUI().line(`Synced workspace files: ${result.workspaceFiles.applied} applied (cursor=${result.workspaceFiles.cursor ?? "null"})`);
-    if (opts.bytes) {
-      getUI().line(
-        `Prefetched bytes: ${result.prefetch.fetched}/${result.prefetch.considered} assets, ${result.prefetch.bytes} bytes`
-      );
-      if (result.prefetch.failed.length > 0) {
-        getUI().line(`Prefetch failures: ${result.prefetch.failed.length}`);
-      }
-    } else {
-      getUI().line("Asset bytes were not prefetched; they are downloaded lazily on first use. Run with --bytes to fill ~/.prismer/cache.");
-    }
-  }, { code: "asset_sync_failed" }));
   cmd.command("list").description("List assets for a workspace, optionally filtered by task").option("--workspace-id <id>", "Workspace id").option("--task-id <id>", "Task id filter").option("--json", "Output machine-readable JSON").action(runAction(async (opts) => {
     const cloud = mkCloud();
     const query = new URLSearchParams();
     if (opts.workspaceId) query.set("workspaceId", opts.workspaceId);
     if (opts.taskId) query.set("taskId", opts.taskId);
-    const path9 = `/api/im/assets${query.toString() ? `?${query.toString()}` : ""}`;
-    const res = await cloud.request("GET", path9);
+    const path7 = `/api/im/assets${query.toString() ? `?${query.toString()}` : ""}`;
+    const res = await cloud.request("GET", path7);
     if (!res.ok) exitWithError(`asset list failed (${res.status}): ${res.error?.message ?? "request failed"}`, { code: res.error?.code ?? "asset_list_failed" });
     const body = res.data;
     if (isErrorEnvelope(body)) {
@@ -10029,20 +8718,13 @@ function buildAssetCommand() {
     }
     printAssetList(body);
   }, { code: "asset_list_failed" }));
-  cmd.command("upload <path>").description("Upload a local file or directory as IM assets").requiredOption("--workspace-id <id>", "Workspace id").option("--kind <kind>", "Asset kind", "file").option("--folder-path <path>", "Cloud folderPath prefix for the uploaded file(s)").option("--task-id <id>", "Source task id").option("--agent-id <id>", "Source agent IM user id").option("--container-id <id>", "Container id; also added to metadata for sandbox-output assets").option("--metadata <json>", "Additional JSON metadata").option("--mime <type>", "Override file MIME type").option("--json", "Output machine-readable JSON").action(runAction(async (inputPath, opts) => {
-    const body = await uploadAssetPath(inputPath, opts);
+  cmd.command("upload <file>").description("Upload a local file as an IM asset").requiredOption("--workspace-id <id>", "Workspace id").option("--kind <kind>", "Asset kind", "file").option("--task-id <id>", "Source task id").option("--agent-id <id>", "Source agent IM user id").option("--container-id <id>", "Container id; also added to metadata for sandbox-output assets").option("--metadata <json>", "Additional JSON metadata").option("--mime <type>", "Override file MIME type").option("--json", "Output machine-readable JSON").action(runAction(async (file, opts) => {
+    const body = await uploadAsset(file, opts);
     if (opts.json) {
       printJson(body ?? null);
       return;
     }
-    if (isUploadManyResult(body)) {
-      getUI().line(`Uploaded ${body.data.count} assets`);
-      for (const item of body.data.items) {
-        printAssetDetail("Uploaded asset", item.file, item.response);
-      }
-    } else {
-      printAssetDetail("Uploaded asset", inputPath, body);
-    }
+    printAssetDetail("Uploaded asset", file, body);
   }, { code: "asset_upload_failed" }));
   cmd.command("download <assetId>").description("Download asset bytes").requiredOption("--out <path>", "Destination file path").action(runAction(async (assetId, opts) => {
     await downloadAsset(assetId, opts.out);
@@ -10062,12 +8744,12 @@ function buildAssetCommand() {
     }
     printAssetDetail("Asset", assetId, body);
   }, { code: "asset_get_failed" }));
-  cmd.command("by-hash <sha256>").description("Fetch asset metadata by content hash").option("--workspace-id <id>", "Workspace id (required by the cloud API)").option("--json", "Output machine-readable JSON").action(runAction(async (sha2564, opts) => {
+  cmd.command("by-hash <sha256>").description("Fetch asset metadata by content hash").option("--workspace-id <id>", "Workspace id (required by the cloud API)").option("--json", "Output machine-readable JSON").action(runAction(async (sha2562, opts) => {
     const cloud = mkCloud();
     const query = new URLSearchParams();
     if (opts.workspaceId) query.set("wsId", opts.workspaceId);
-    const path9 = `/api/im/assets/by-hash/${encodeURIComponent(sha2564)}${query.toString() ? `?${query.toString()}` : ""}`;
-    const res = await cloud.request("GET", path9);
+    const path7 = `/api/im/assets/by-hash/${encodeURIComponent(sha2562)}${query.toString() ? `?${query.toString()}` : ""}`;
+    const res = await cloud.request("GET", path7);
     if (!res.ok) exitWithError(`asset by-hash failed (${res.status}): ${res.error?.message ?? "request failed"}`, { code: res.error?.code ?? "asset_by_hash_failed" });
     const body = res.data;
     if (isErrorEnvelope(body)) {
@@ -10077,7 +8759,7 @@ function buildAssetCommand() {
       printJson(body ?? null);
       return;
     }
-    printAssetDetail("Asset hash", sha2564, body);
+    printAssetDetail("Asset hash", sha2562, body);
   }, { code: "asset_by_hash_failed" }));
   return cmd;
 }
@@ -10085,102 +8767,10 @@ function mkCloud() {
   const cfg = loadConfig(resolvePaths());
   return new CloudClient({ baseUrl: cfg.cloud_api_base, apiKey: cfg.api_key });
 }
-async function syncAssets(opts) {
-  const paths = resolvePaths();
-  const cfg = loadConfig(paths);
-  const cloud = new CloudClient({ baseUrl: cfg.cloud_api_base, apiKey: cfg.api_key });
-  const db = openLocalDb(paths.localDb);
-  try {
-    const stateDir = `${paths.root}/${opts.workspaceId}`;
-    const metadataIndex = new AssetMetadataIndex({
-      db,
-      cloud,
-      workspaceId: opts.workspaceId,
-      workspaceStateDir: stateDir
-    });
-    const mirror = new WorkspaceMirror({
-      db,
-      cloud,
-      workspaceId: opts.workspaceId,
-      workspaceStateDir: stateDir
-    });
-    const [metadata, workspaceFiles] = await Promise.all([
-      metadataIndex.pullDelta(),
-      mirror.pullDelta()
-    ]);
-    const prefetch = opts.bytes ? await prefetchAssetBytes({
-      db,
-      cloud,
-      workspaceId: opts.workspaceId,
-      cacheDir: paths.cacheDir,
-      maxBytes: cfg.cache?.max_bytes,
-      limit: opts.limit
-    }) : { considered: 0, fetched: 0, bytes: 0, failed: [] };
-    return { workspaceId: opts.workspaceId, metadata, workspaceFiles, prefetch };
-  } finally {
-    db.close();
-  }
-}
-async function prefetchAssetBytes(opts) {
-  const limitClause = opts.limit ? " LIMIT ?" : "";
-  const params = [opts.workspaceId];
-  if (opts.limit) params.push(opts.limit);
-  const rows = opts.db.prepare(
-    `SELECT asset_id, content_hash, mime, size_bytes
-       FROM asset_metadata_index
-       WHERE workspace_id = ?
-       ORDER BY asset_index_seq DESC${limitClause}`
-  ).all(...params);
-  const cache = new AssetCache({
-    db: opts.db,
-    cloud: opts.cloud,
-    cacheDir: opts.cacheDir,
-    maxBytes: opts.maxBytes
-  });
-  let fetched = 0;
-  let bytes = 0;
-  const failed = [];
-  for (const row of rows) {
-    try {
-      const cached = await cache.getOrFetch(row.content_hash, {
-        workspaceIdHint: opts.workspaceId,
-        assetId: row.asset_id
-      });
-      fetched += 1;
-      bytes += cached.sizeBytes;
-    } catch (err) {
-      failed.push({
-        assetId: row.asset_id,
-        contentHash: row.content_hash,
-        error: err.message
-      });
-    }
-  }
-  return { considered: rows.length, fetched, bytes, failed };
-}
-async function uploadAssetPath(inputPath, opts) {
-  if (!(0, import_node_fs17.existsSync)(inputPath)) exitWithError(`path not found: ${inputPath}`);
-  const stat = (0, import_node_fs17.lstatSync)(inputPath);
-  if (stat.isSymbolicLink()) exitWithError(`refusing to upload symlink: ${inputPath}`);
-  if (stat.isFile()) {
-    return uploadAsset(inputPath, { ...opts, folderPath: normalizeFolderPath(opts.folderPath) });
-  }
-  if (!stat.isDirectory()) exitWithError(`path is not a file or directory: ${inputPath}`);
-  const files = listFilesRecursive(inputPath);
-  if (files.length === 0) exitWithError(`directory has no uploadable files: ${inputPath}`);
-  const items = [];
-  for (const file of files) {
-    const relDir = (0, import_node_path13.dirname)((0, import_node_path13.relative)(inputPath, file));
-    const folderPath = combineFolderPath(opts.folderPath, relDir === "." ? "" : relDir);
-    const response = await uploadAsset(file, { ...opts, folderPath });
-    items.push({ file, folderPath: folderPath ?? null, response });
-  }
-  return { ok: true, data: { count: items.length, items } };
-}
 async function uploadAsset(file, opts) {
-  if (!(0, import_node_fs17.existsSync)(file)) exitWithError(`file not found: ${file}`);
+  if (!(0, import_node_fs14.existsSync)(file)) exitWithError(`file not found: ${file}`);
   const cfg = loadConfig(resolvePaths());
-  const bytes = (0, import_node_fs17.readFileSync)(file);
+  const bytes = (0, import_node_fs14.readFileSync)(file);
   const metadata = parseMetadata(opts.metadata);
   if (opts.taskId && metadata.taskId === void 0) metadata.taskId = opts.taskId;
   if (opts.containerId && metadata.containerId === void 0) metadata.containerId = opts.containerId;
@@ -10189,9 +8779,8 @@ async function uploadAsset(file, opts) {
   form.set("kind", opts.kind);
   if (opts.agentId) form.set("sourceAgentImUserId", opts.agentId);
   if (opts.taskId) form.set("sourceTaskId", opts.taskId);
-  if (opts.folderPath !== void 0) form.set("folderPath", opts.folderPath);
   if (Object.keys(metadata).length > 0) form.set("metadata", JSON.stringify(metadata));
-  form.set("file", new Blob([bytes], { type: opts.mime ?? "application/octet-stream" }), (0, import_node_path13.basename)(file));
+  form.set("file", new Blob([bytes], { type: opts.mime ?? "application/octet-stream" }), (0, import_node_path10.basename)(file));
   const url = `${cfg.cloud_api_base.replace(/\/$/, "")}/api/im/assets`;
   let res;
   try {
@@ -10209,37 +8798,6 @@ async function uploadAsset(file, opts) {
   }
   return body;
 }
-function listFilesRecursive(root) {
-  const out = [];
-  for (const name of (0, import_node_fs17.readdirSync)(root)) {
-    if (name.startsWith(".")) continue;
-    const full = (0, import_node_path13.join)(root, name);
-    const stat = (0, import_node_fs17.lstatSync)(full);
-    if (stat.isSymbolicLink()) continue;
-    if (stat.isDirectory()) {
-      out.push(...listFilesRecursive(full));
-    } else if (stat.isFile()) {
-      out.push(full);
-    }
-  }
-  return out.sort();
-}
-function combineFolderPath(prefix, relDir) {
-  const normalizedPrefix = normalizeFolderPath(prefix);
-  const normalizedRel = normalizeFolderPath(relDir);
-  if (normalizedPrefix && normalizedRel) return `${normalizedPrefix}/${normalizedRel}`;
-  return normalizedPrefix ?? normalizedRel;
-}
-function normalizeFolderPath(value) {
-  if (value === void 0) return void 0;
-  const normalized = value.trim().replace(/\\/g, "/").replace(/^\/+/, "").replace(/\/+$/, "");
-  return normalized.length > 0 ? normalized : "";
-}
-function isUploadManyResult(raw) {
-  return Boolean(
-    raw && typeof raw === "object" && raw.ok === true && raw.data && Array.isArray(raw.data.items)
-  );
-}
 async function downloadAsset(assetId, outPath) {
   const cloud = mkCloud();
   const res = await cloud.fetchRaw(`/api/im/assets/${encodeURIComponent(assetId)}`);
@@ -10248,7 +8806,7 @@ async function downloadAsset(assetId, outPath) {
     exitWithError(`asset download failed (${res.status}): ${errorMessage(body)}`);
   }
   const bytes = Buffer.from(await res.arrayBuffer());
-  (0, import_node_fs17.writeFileSync)(outPath, bytes);
+  (0, import_node_fs14.writeFileSync)(outPath, bytes);
 }
 function parseMetadata(raw) {
   if (!raw) return {};
@@ -10333,13 +8891,6 @@ function stringField(obj, key) {
   const value = obj?.[key];
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
-function parsePositiveInt(raw) {
-  const n = Number(raw);
-  if (!Number.isInteger(n) || n <= 0) {
-    throw new Error("--limit must be a positive integer");
-  }
-  return n;
-}
 
 // src/cli/commands/banner.ts
 var import_commander4 = require("commander");
@@ -10395,7 +8946,7 @@ ${name} (${role})`);
     getUI().line(`Group created ${data.groupId ?? "(unknown)"}
 ${data.title ?? opts.name} (${memberCount} members)`);
   });
-  group.command("messages <groupId>").description("List group messages").option("--limit <n>", "Max messages", parsePositiveInt2).option("--before <id>", "Return messages before this message id").option("--json", "Print raw JSON response").action(async (groupId, opts) => {
+  group.command("messages <groupId>").description("List group messages").option("--limit <n>", "Max messages", parsePositiveInt).option("--before <id>", "Return messages before this message id").option("--json", "Print raw JSON response").action(async (groupId, opts) => {
     const data = await requestOrExit(
       "GET",
       withQuery(`/api/im/groups/${encodeURIComponent(groupId)}/messages`, {
@@ -10433,7 +8984,7 @@ ${data.title ?? opts.name} (${memberCount} members)`);
     getUI().line(`Removed ${memberId} from group ${groupId}`);
   });
   cmd.addCommand(group);
-  cmd.command("messages <conversationId>").description("List conversation messages").option("--limit <n>", "Max messages", parsePositiveInt2).option("--before <id>", "Return messages before this message id").option("--json", "Print raw JSON response").action(async (conversationId, opts) => {
+  cmd.command("messages <conversationId>").description("List conversation messages").option("--limit <n>", "Max messages", parsePositiveInt).option("--before <id>", "Return messages before this message id").option("--json", "Print raw JSON response").action(async (conversationId, opts) => {
     const data = await requestOrExit(
       "GET",
       withQuery(`/api/im/messages/${encodeURIComponent(conversationId)}`, {
@@ -10449,15 +9000,15 @@ ${data.title ?? opts.name} (${memberCount} members)`);
   });
   return cmd;
 }
-async function requestOrExit(method, path9, body) {
+async function requestOrExit(method, path7, body) {
   let res;
   try {
-    res = await mkCloud2().request(method, path9, body === void 0 ? void 0 : { body });
+    res = await mkCloud2().request(method, path7, body === void 0 ? void 0 : { body });
   } catch (err) {
     exitWithError(sanitizeError(err.message));
   }
   if (!res.ok) {
-    exitWithError(`${method} ${path9} failed (${res.status}): ${sanitizeError(res.error?.message ?? "unknown")}`);
+    exitWithError(`${method} ${path7} failed (${res.status}): ${sanitizeError(res.error?.message ?? "unknown")}`);
   }
   return unwrapEnvelope2(res.data);
 }
@@ -10489,20 +9040,20 @@ function unwrapEnvelope2(raw) {
 function parseCsv(value) {
   return value.split(",").map((v) => v.trim()).filter(Boolean);
 }
-function parsePositiveInt2(value) {
+function parsePositiveInt(value) {
   const parsed = Number.parseInt(value, 10);
   if (!Number.isInteger(parsed) || parsed < 1) {
     throw new Error("expected a positive integer");
   }
   return parsed;
 }
-function withQuery(path9, params) {
+function withQuery(path7, params) {
   const query = new URLSearchParams();
   for (const [key, value] of Object.entries(params)) {
     if (value !== void 0) query.set(key, String(value));
   }
   const suffix = query.toString();
-  return suffix ? `${path9}?${suffix}` : path9;
+  return suffix ? `${path7}?${suffix}` : path7;
 }
 function printMessageSummary(label, data) {
   const msg = data.message ?? {};
@@ -10629,7 +9180,7 @@ init_util();
 init_ui();
 function buildCookbookCommand() {
   const cmd = new import_commander7.Command("cookbook").description("Run CLI-only 54release MVP regression suites");
-  cmd.command("run").description("Run one or more cookbook smoke suites using the configured API key").option("--suite <name>", "status|im|task|group|asset|sandbox|all, comma-separated", "all").option("--workspace-id <id>", "Workspace id for workspace-scoped suites").option("--agent-id <id>", "Agent IM user id for task create smoke").option("--group-id <id>", "Group/conversation id for group message history smoke").option("--sandbox-id <id>", "Sandbox id for sandbox status smoke").option("--prompt <text>", "Prompt for optional task create smoke").option("--timeout-ms <ms>", "Request/task timeout", parsePositiveInt3, 6e4).option("--strict", "Treat skipped optional checks as failure").option("--json", "Output machine-readable JSON").action(runAction(async (opts) => {
+  cmd.command("run").description("Run one or more cookbook smoke suites using the configured API key").option("--suite <name>", "status|im|task|group|asset|sandbox|all, comma-separated", "all").option("--workspace-id <id>", "Workspace id for workspace-scoped suites").option("--agent-id <id>", "Agent IM user id for task create smoke").option("--group-id <id>", "Group/conversation id for group message history smoke").option("--sandbox-id <id>", "Sandbox id for sandbox status smoke").option("--prompt <text>", "Prompt for optional task create smoke").option("--timeout-ms <ms>", "Request/task timeout", parsePositiveInt2, 6e4).option("--strict", "Treat skipped optional checks as failure").option("--json", "Output machine-readable JSON").action(runAction(async (opts) => {
     const suites = parseSuites(opts.suite);
     const cloud = mkCloud3(opts.timeoutMs);
     const checks = [];
@@ -10671,8 +9222,8 @@ async function runStatusSuite(cloud) {
     await check("status", "cloud health", "GET", "/api/health"),
     await check("status", "current IM identity", "GET", "/api/im/me", void 0, cloud)
   ];
-  async function check(suite, name, method, path9, body, client = cloud) {
-    return requestCheck(client, suite, name, method, path9, body);
+  async function check(suite, name, method, path7, body, client = cloud) {
+    return requestCheck(client, suite, name, method, path7, body);
   }
 }
 async function runIMSuite(cloud) {
@@ -10746,27 +9297,27 @@ async function runSandboxSuite(cloud, opts) {
   }
   return checks;
 }
-async function requestCheck(cloud, suite, name, method, path9, body) {
+async function requestCheck(cloud, suite, name, method, path7, body) {
   let res;
   try {
-    res = await cloud.request(method, path9, body === void 0 ? void 0 : { body });
+    res = await cloud.request(method, path7, body === void 0 ? void 0 : { body });
   } catch (err) {
-    return { suite, name, status: "fail", endpoint: path9, detail: sanitize(err.message) };
+    return { suite, name, status: "fail", endpoint: path7, detail: sanitize(err.message) };
   }
   if (!res.ok) {
     return {
       suite,
       name,
       status: "fail",
-      endpoint: path9,
+      endpoint: path7,
       detail: sanitize(`${res.status}: ${res.error?.message ?? "request failed"}`)
     };
   }
   const data = unwrap(res.data);
   if (isApiError(res.data)) {
-    return { suite, name, status: "fail", endpoint: path9, detail: sanitize(apiErrorMessage(res.data)), data: res.data };
+    return { suite, name, status: "fail", endpoint: path7, detail: sanitize(apiErrorMessage(res.data)), data: res.data };
   }
-  return { suite, name, status: "pass", endpoint: path9, detail: summarizeData(data), data };
+  return { suite, name, status: "pass", endpoint: path7, detail: summarizeData(data), data };
 }
 async function pollTask(cloud, taskId, timeoutMs) {
   const started = Date.now();
@@ -10873,7 +9424,7 @@ function taskFrom(data) {
 function sanitize(message) {
   return message.replace(/sk-prismer-[A-Za-z0-9_-]+/g, "sk-prismer-***");
 }
-function parsePositiveInt3(value) {
+function parsePositiveInt2(value) {
   const parsed = Number.parseInt(value, 10);
   if (!Number.isFinite(parsed) || parsed <= 0) {
     throw new Error("expected a positive integer");
@@ -10884,9 +9435,9 @@ function parsePositiveInt3(value) {
 // src/cli/commands/daemon.ts
 var import_commander8 = require("commander");
 var import_node_child_process7 = require("child_process");
-var import_node_fs18 = require("fs");
-var import_promises3 = require("timers/promises");
-var import_node_path14 = require("path");
+var import_node_fs15 = require("fs");
+var import_promises2 = require("timers/promises");
+var import_node_path11 = require("path");
 init_util();
 init_ui();
 function buildDaemonCommand() {
@@ -10904,7 +9455,7 @@ function buildDaemonCommand() {
   async function runForeground(opts) {
     const paths = resolvePaths();
     const existingPid = readPidFile(paths);
-    if (existingPid && pidAlive2(existingPid)) {
+    if (existingPid && pidAlive(existingPid)) {
       exitWithError(`Daemon already running (pid ${existingPid}). Use \`prismer daemon stop\` first.`);
     }
     writePidFile(paths, process.pid);
@@ -10928,7 +9479,7 @@ function buildDaemonCommand() {
     while (!configExists(paths)) {
       if (stopRequested) return;
       getUI().info(`[daemon] waiting for ${paths.configFile} \u2014 run \`prismer setup\` to create it`);
-      await (0, import_promises3.setTimeout)(5e3);
+      await (0, import_promises2.setTimeout)(5e3);
     }
     runner = new Runner({
       startLocalServer: opts.localServer !== false,
@@ -10957,12 +9508,12 @@ function buildDaemonCommand() {
   async function startBackground(opts) {
     const paths = resolvePaths();
     const existingPid = readPidFile(paths);
-    if (existingPid && pidAlive2(existingPid)) {
+    if (existingPid && pidAlive(existingPid)) {
       exitWithError(`Daemon already running (pid ${existingPid}). Use \`prismer daemon stop\` first.`);
     }
-    if (!(0, import_node_fs18.existsSync)(paths.logsDir)) (0, import_node_fs18.mkdirSync)(paths.logsDir, { recursive: true });
-    const logFile = (0, import_node_path14.join)(paths.logsDir, "daemon.log");
-    const fd = (0, import_node_fs18.openSync)(logFile, "a");
+    if (!(0, import_node_fs15.existsSync)(paths.logsDir)) (0, import_node_fs15.mkdirSync)(paths.logsDir, { recursive: true });
+    const logFile = (0, import_node_path11.join)(paths.logsDir, "daemon.log");
+    const fd = (0, import_node_fs15.openSync)(logFile, "a");
     const args = [process.argv[1], "daemon", "run"];
     if (opts.port) args.push("--port", String(opts.port));
     if (opts.localServer === false) args.push("--no-local-server");
@@ -10974,9 +9525,9 @@ function buildDaemonCommand() {
     child.unref();
     const deadline = Date.now() + 5e3;
     while (Date.now() < deadline) {
-      await (0, import_promises3.setTimeout)(200);
+      await (0, import_promises2.setTimeout)(200);
       const pid = readPidFile(paths);
-      if (pid && pidAlive2(pid)) {
+      if (pid && pidAlive(pid)) {
         if (opts.json) printJson({ ok: true, pid, logFile });
         else getUI().ok("Daemon started", `pid ${pid} \xB7 logs ${logFile}`);
         return;
@@ -10991,7 +9542,7 @@ function buildDaemonCommand() {
     const paths = resolvePaths();
     const pid = readPidFile(paths);
     if (!pid) exitWithError("No daemon.pid found \u2014 daemon does not appear to be running.");
-    if (!pidAlive2(pid)) {
+    if (!pidAlive(pid)) {
       clearPidFile(paths);
       getUI().warn("Daemon was not alive", `pid ${pid}; cleared stale pid file`);
       return;
@@ -11003,12 +9554,12 @@ function buildDaemonCommand() {
     }
     const deadline = Date.now() + (opts.timeout ?? 5e3);
     while (Date.now() < deadline) {
-      if (!pidAlive2(pid)) {
+      if (!pidAlive(pid)) {
         clearPidFile(paths);
         getUI().ok("Daemon stopped", `pid ${pid}`);
         return;
       }
-      await (0, import_promises3.setTimeout)(200);
+      await (0, import_promises2.setTimeout)(200);
     }
     process.stderr.write(`Daemon did not exit within timeout; pid ${pid} may still be alive.
 `);
@@ -11028,7 +9579,7 @@ function buildDaemonCommand() {
   cmd.command("status").description("Show daemon process + WS state").option("--json", "Output JSON (default)").action(async () => {
     const paths = resolvePaths();
     const pid = readPidFile(paths);
-    const alive = pid ? pidAlive2(pid) : false;
+    const alive = pid ? pidAlive(pid) : false;
     if (!pid || !alive) {
       printJson({ running: false, pid: pid ?? null, paths: { config: paths.configFile } });
       return;
@@ -11045,8 +9596,8 @@ function buildDaemonCommand() {
   });
   cmd.command("logs").description("Show daemon logs").option("--tail <n>", "Number of lines to show", (v) => Number.parseInt(v, 10), 80).option("--follow", "Follow log output").option("--json", "Accept --json for global flag compatibility (raw log bytes are streamed)").action(async (opts) => {
     const paths = resolvePaths();
-    const logFile = (0, import_node_path14.join)(paths.logsDir, "daemon.log");
-    if (!(0, import_node_fs18.existsSync)(logFile)) {
+    const logFile = (0, import_node_path11.join)(paths.logsDir, "daemon.log");
+    if (!(0, import_node_fs15.existsSync)(logFile)) {
       exitWithError(`No daemon log found at ${logFile}. Start the daemon with \`prismer daemon start\`.`);
     }
     const lines = Math.max(1, opts.tail);
@@ -11056,9 +9607,9 @@ function buildDaemonCommand() {
   });
   return cmd;
 }
-async function tailFromEnd(path9, lines) {
+async function tailFromEnd(path7, lines) {
   const { open } = await import("fs/promises");
-  const handle = await open(path9, "r");
+  const handle = await open(path7, "r");
   try {
     const stat = await handle.stat();
     let size = stat.size;
@@ -11086,14 +9637,14 @@ async function tailFromEnd(path9, lines) {
     await handle.close();
   }
 }
-async function followFile(path9) {
-  let offset = (0, import_node_fs18.statSync)(path9).size;
+async function followFile(path7) {
+  let offset = (0, import_node_fs15.statSync)(path7).size;
   for (; ; ) {
-    await (0, import_promises3.setTimeout)(1e3);
-    const size = (0, import_node_fs18.statSync)(path9).size;
+    await (0, import_promises2.setTimeout)(1e3);
+    const size = (0, import_node_fs15.statSync)(path7).size;
     if (size < offset) offset = 0;
     if (size === offset) continue;
-    const stream = (0, import_node_fs18.createReadStream)(path9, { start: offset, end: size - 1, encoding: "utf8" });
+    const stream = (0, import_node_fs15.createReadStream)(path7, { start: offset, end: size - 1, encoding: "utf8" });
     for await (const chunk of stream) process.stdout.write(chunk);
     offset = size;
   }
@@ -11101,16 +9652,16 @@ async function followFile(path9) {
 
 // src/cli/commands/events.ts
 var import_commander9 = require("commander");
-var import_node_fs19 = require("fs");
-var import_node_os9 = require("os");
-var import_node_path15 = require("path");
+var import_node_fs16 = require("fs");
+var import_node_os7 = require("os");
+var import_node_path12 = require("path");
 var import_node_readline = require("readline");
 init_util();
 var DEFAULT_LIMIT2 = 50;
 function buildEventsCommand() {
   return addEventOptions(new import_commander9.Command("events").description("Read local PARA events from ~/.prismer/para/events.jsonl")).action(async (opts) => {
     const file = eventsPath();
-    if (!(0, import_node_fs19.existsSync)(file)) {
+    if (!(0, import_node_fs16.existsSync)(file)) {
       printJson(unavailable(file));
       process.exitCode = 1;
       return;
@@ -11127,7 +9678,7 @@ function buildEventsCommand() {
 function buildEventsStatsCommand() {
   return addEventOptions(new import_commander9.Command("events:stats").description("Summarize local PARA events from ~/.prismer/para/events.jsonl")).action(async (opts) => {
     const file = eventsPath();
-    if (!(0, import_node_fs19.existsSync)(file)) {
+    if (!(0, import_node_fs16.existsSync)(file)) {
       printJson(unavailable(file));
       process.exitCode = 1;
       return;
@@ -11142,10 +9693,10 @@ function buildEventsStatsCommand() {
   });
 }
 function addEventOptions(cmd) {
-  return cmd.option("--limit <n>", "Max events to return/read", parsePositiveInt4, DEFAULT_LIMIT2).option("--agent-id <id>", "Filter by agent id").option("--session-id <id>", "Filter by session id").option("--family <name>", "Filter by event family").option("--type <name>", "Filter by event type").option("--json", "Output JSON (default)");
+  return cmd.option("--limit <n>", "Max events to return/read", parsePositiveInt3, DEFAULT_LIMIT2).option("--agent-id <id>", "Filter by agent id").option("--session-id <id>", "Filter by session id").option("--family <name>", "Filter by event family").option("--type <name>", "Filter by event type").option("--json", "Output JSON (default)");
 }
 function eventsPath() {
-  return (0, import_node_path15.join)(process.env.PRISMER_HOME ?? (0, import_node_path15.join)((0, import_node_os9.homedir)(), ".prismer"), "para", "events.jsonl");
+  return (0, import_node_path12.join)(process.env.PRISMER_HOME ?? (0, import_node_path12.join)((0, import_node_os7.homedir)(), ".prismer"), "para", "events.jsonl");
 }
 function unavailable(file) {
   return {
@@ -11161,7 +9712,7 @@ function unavailable(file) {
 async function readEvents(file, filters) {
   const out = [];
   const rl = (0, import_node_readline.createInterface)({
-    input: (0, import_node_fs19.createReadStream)(file, { encoding: "utf8" }),
+    input: (0, import_node_fs16.createReadStream)(file, { encoding: "utf8" }),
     crlfDelay: Infinity
   });
   for await (const line of rl) {
@@ -11223,15 +9774,15 @@ function normalizeFilters(opts) {
 function cleanFilters(filters) {
   return Object.fromEntries(Object.entries(filters).filter(([, value]) => value !== void 0));
 }
-function parsePositiveInt4(v) {
+function parsePositiveInt3(v) {
   const n = Number.parseInt(v, 10);
   return Number.isFinite(n) && n > 0 ? n : DEFAULT_LIMIT2;
 }
 
 // src/cli/commands/memory.ts
-var import_better_sqlite35 = __toESM(require("better-sqlite3"), 1);
+var import_better_sqlite34 = __toESM(require("better-sqlite3"), 1);
 var import_commander10 = require("commander");
-var import_node_fs20 = require("fs");
+var import_node_fs17 = require("fs");
 init_util();
 var LOCAL_BASE = process.env.PRISMER_DAEMON_URL ?? "http://127.0.0.1:3210";
 function buildMemoryCommand() {
@@ -11257,7 +9808,7 @@ function buildMemoryCommand() {
     }));
     process.exitCode = 1;
   });
-  cmd.command("list").description("List memory records, or local cache records when gateway is unavailable").option("--workspace-id <id>", "Workspace to list (required for daemon RPC)").option("--page-type <type>", "Filter by pageType (hub/leaf/decision/glossary/archive)").option("--limit <n>", "Max items", parsePositiveInt5, 20).option("--json", "Output JSON (default)").action(async (opts) => {
+  cmd.command("list").description("List memory records, or local cache records when gateway is unavailable").option("--workspace-id <id>", "Workspace to list (required for daemon RPC)").option("--page-type <type>", "Filter by pageType (hub/leaf/decision/glossary/archive)").option("--limit <n>", "Max items", parsePositiveInt4, 20).option("--json", "Output JSON (default)").action(async (opts) => {
     const limit = clampLimit(opts.limit);
     const daemonPaths = [];
     if (opts.workspaceId) {
@@ -11276,7 +9827,7 @@ function buildMemoryCommand() {
     printJson(unavailable2("list", snapshot, { items: snapshot.items, limit }));
     process.exitCode = 1;
   });
-  cmd.command("search").description("Search memory records, or local cache metadata when gateway is unavailable").argument("[query]", "Search text").option("--query <text>", "Search text").option("--workspace-id <id>", "Workspace to search (required for daemon RPC)").option("--limit <n>", "Max items", parsePositiveInt5, 20).option("--json", "Output JSON (default)").action(async (argQuery, opts) => {
+  cmd.command("search").description("Search memory records, or local cache metadata when gateway is unavailable").argument("[query]", "Search text").option("--query <text>", "Search text").option("--workspace-id <id>", "Workspace to search (required for daemon RPC)").option("--limit <n>", "Max items", parsePositiveInt4, 20).option("--json", "Output JSON (default)").action(async (argQuery, opts) => {
     const query = opts.query ?? argQuery ?? "";
     const limit = clampLimit(opts.limit);
     const encoded = encodeURIComponent(query);
@@ -11320,9 +9871,9 @@ function buildMemoryCommand() {
 }
 async function tryDaemon(methods, paths) {
   for (const method of methods) {
-    for (const path9 of paths) {
+    for (const path7 of paths) {
       try {
-        const res = await fetch(`${LOCAL_BASE}${path9}`, { method, signal: AbortSignal.timeout(1500) });
+        const res = await fetch(`${LOCAL_BASE}${path7}`, { method, signal: AbortSignal.timeout(1500) });
         if (res.status === 404) continue;
         const body = await readJson4(res);
         if (!res.ok) {
@@ -11330,12 +9881,12 @@ async function tryDaemon(methods, paths) {
             ok: false,
             error: {
               code: `daemon_http_${res.status}`,
-              message: messageFromBody(body) ?? `Daemon endpoint ${method} ${path9} returned HTTP ${res.status}`
+              message: messageFromBody(body) ?? `Daemon endpoint ${method} ${path7} returned HTTP ${res.status}`
             },
-            checks: { daemon: { url: LOCAL_BASE, endpoint: path9, reachable: true } }
+            checks: { daemon: { url: LOCAL_BASE, endpoint: path7, reachable: true } }
           };
         }
-        return normalizeDaemonBody(body, { method, path: path9 });
+        return normalizeDaemonBody(body, { method, path: path7 });
       } catch {
         continue;
       }
@@ -11383,7 +9934,7 @@ function readCacheSnapshot(limit) {
   const paths = resolvePaths();
   const empty = {
     dbPath: paths.localDb,
-    dbExists: (0, import_node_fs20.existsSync)(paths.localDb),
+    dbExists: (0, import_node_fs17.existsSync)(paths.localDb),
     tables: {
       cached_assets: { exists: false, count: 0, sizeBytes: 0 },
       workspace_files_mirror: { exists: false, count: 0 }
@@ -11393,7 +9944,7 @@ function readCacheSnapshot(limit) {
   if (!empty.dbExists) return empty;
   let db;
   try {
-    db = new import_better_sqlite35.default(paths.localDb, { readonly: true, fileMustExist: true });
+    db = new import_better_sqlite34.default(paths.localDb, { readonly: true, fileMustExist: true });
     const hasAssets = tableExists(db, "cached_assets");
     const hasFiles = tableExists(db, "workspace_files_mirror");
     const assets = hasAssets ? db.prepare("SELECT COUNT(*) AS count, COALESCE(SUM(size_bytes), 0) AS sizeBytes FROM cached_assets").get() : { count: 0, sizeBytes: 0 };
@@ -11482,7 +10033,7 @@ function searchableText(item) {
     item.localPath
   ].filter(Boolean).join(" ");
 }
-function parsePositiveInt5(v) {
+function parsePositiveInt4(v) {
   const n = Number.parseInt(v, 10);
   return Number.isFinite(n) && n > 0 ? n : 20;
 }
@@ -11547,9 +10098,9 @@ function buildPairCommand() {
 
 // src/cli/commands/profile.ts
 var import_commander12 = require("commander");
-var import_node_fs21 = require("fs");
-var import_node_os10 = require("os");
-var import_node_path16 = require("path");
+var import_node_fs18 = require("fs");
+var import_node_os8 = require("os");
+var import_node_path13 = require("path");
 var import_node_child_process8 = require("child_process");
 init_util();
 function buildProfileCommand() {
@@ -11597,12 +10148,12 @@ function buildProfileCommand() {
     const profile = await cloud.get(
       `/api/im/agent_profiles/${encodeURIComponent(profileId)}`
     );
-    const tmpFile = (0, import_node_path16.join)((0, import_node_os10.tmpdir)(), `prismer-profile-${profileId}.json`);
-    (0, import_node_fs21.writeFileSync)(tmpFile, JSON.stringify(profile.config, null, 2), "utf8");
+    const tmpFile = (0, import_node_path13.join)((0, import_node_os8.tmpdir)(), `prismer-profile-${profileId}.json`);
+    (0, import_node_fs18.writeFileSync)(tmpFile, JSON.stringify(profile.config, null, 2), "utf8");
     const editor = process.env.EDITOR || "vi";
     const ed = (0, import_node_child_process8.spawnSync)(editor, [tmpFile], { stdio: "inherit" });
     if (ed.status !== 0) exitWithError(`editor exited ${ed.status}`, { code: "editor_failed" });
-    const newConfig = JSON.parse((0, import_node_fs21.readFileSync)(tmpFile, "utf8"));
+    const newConfig = JSON.parse((0, import_node_fs18.readFileSync)(tmpFile, "utf8"));
     const res = await cloud.request("PATCH", `/api/im/agent_profiles/${encodeURIComponent(profileId)}`, {
       body: { config: newConfig, version: profile.version }
     });
@@ -11623,9 +10174,9 @@ function mkCloud4() {
 }
 function readJsonArg(arg) {
   if (arg.startsWith("@")) {
-    const path9 = arg.slice(1);
-    if (!(0, import_node_fs21.existsSync)(path9)) throw new Error(`File not found: ${path9}`);
-    return JSON.parse((0, import_node_fs21.readFileSync)(path9, "utf8"));
+    const path7 = arg.slice(1);
+    if (!(0, import_node_fs18.existsSync)(path7)) throw new Error(`File not found: ${path7}`);
+    return JSON.parse((0, import_node_fs18.readFileSync)(path7, "utf8"));
   }
   return JSON.parse(arg);
 }
@@ -11636,200 +10187,13 @@ async function resolveDefaultWorkspaceId(cloud) {
   return def.id;
 }
 
-// src/cli/commands/reset.ts
-var import_commander13 = require("commander");
-var import_node_child_process9 = require("child_process");
-var import_node_fs22 = require("fs");
-var import_node_os11 = require("os");
-var import_node_path17 = require("path");
-var import_promises4 = require("timers/promises");
-init_util();
-init_ui();
-function buildResetCommand() {
-  return new import_commander13.Command("reset").description("Stop daemon and reset local runtime state so setup can bind another account").option("--yes", "Actually perform the reset").option("--check", "Print the reset plan without changing files").option("--wipe", "Delete local state instead of archiving it").option("--timeout <ms>", "Time to wait for daemon shutdown (default 5000)", (v) => Number.parseInt(v, 10), 5e3).option("--json", "Output machine-readable JSON").action(runAction(async (opts) => {
-    const paths = resolvePaths();
-    const pid = readPidFile(paths);
-    const runningPid = pid && pidAlive2(pid) ? pid : null;
-    const archivePath = opts.wipe ? null : `${paths.root}.reset.${timestamp()}`;
-    const assetSyncRoot = resolveAssetSyncRoot();
-    const assetSyncArchivePath = opts.wipe ? null : `${assetSyncRoot}.reset.${timestamp()}`;
-    const hermesHome = resolveHermesHome();
-    const hermesArchivePath = opts.wipe ? null : `${hermesHome}.reset.${timestamp()}`;
-    const hermesGatewayPids = findHermesGatewayPids2();
-    const plan = {
-      root: paths.root,
-      exists: (0, import_node_fs22.existsSync)(paths.root),
-      runningPid,
-      mode: opts.wipe ? "wipe" : "archive",
-      archivePath,
-      assetSyncRoot,
-      assetSyncExists: (0, import_node_fs22.existsSync)(assetSyncRoot),
-      assetSyncArchivePath,
-      hermesHome,
-      hermesExists: (0, import_node_fs22.existsSync)(hermesHome),
-      hermesArchivePath,
-      hermesGatewayPids,
-      willStopDaemon: runningPid !== null,
-      nextStep: "prismer setup"
-    };
-    if (opts.check) {
-      printPlan(plan, opts.json);
-      return;
-    }
-    if (!opts.yes) {
-      exitWithError("Refusing to reset without --yes. Run `prismer reset --check` to preview.", {
-        code: "confirmation_required"
-      });
-    }
-    if (runningPid !== null) {
-      await stopDaemon(runningPid, opts.timeout ?? 5e3);
-      clearPidFile(paths);
-    } else if (pid) {
-      clearPidFile(paths);
-    }
-    for (const gatewayPid of hermesGatewayPids) {
-      await stopProcess(gatewayPid, opts.timeout ?? 5e3, "Hermes gateway");
-    }
-    if ((0, import_node_fs22.existsSync)(paths.root)) {
-      if (opts.wipe) {
-        (0, import_node_fs22.rmSync)(paths.root, { recursive: true, force: true });
-      } else {
-        if (!archivePath) throw new Error("internal: archivePath missing");
-        if (!(0, import_node_fs22.existsSync)((0, import_node_path17.dirname)(archivePath))) {
-          (0, import_node_fs22.mkdirSync)((0, import_node_path17.dirname)(archivePath), { recursive: true });
-        }
-        (0, import_node_fs22.renameSync)(paths.root, archivePath);
-      }
-    }
-    if ((0, import_node_fs22.existsSync)(assetSyncRoot)) {
-      if (opts.wipe) {
-        (0, import_node_fs22.rmSync)(assetSyncRoot, { recursive: true, force: true });
-      } else {
-        if (!assetSyncArchivePath) throw new Error("internal: assetSyncArchivePath missing");
-        if (!(0, import_node_fs22.existsSync)((0, import_node_path17.dirname)(assetSyncArchivePath))) {
-          (0, import_node_fs22.mkdirSync)((0, import_node_path17.dirname)(assetSyncArchivePath), { recursive: true });
-        }
-        (0, import_node_fs22.renameSync)(assetSyncRoot, assetSyncArchivePath);
-      }
-    }
-    if ((0, import_node_fs22.existsSync)(hermesHome)) {
-      if (opts.wipe) {
-        (0, import_node_fs22.rmSync)(hermesHome, { recursive: true, force: true });
-      } else {
-        if (!hermesArchivePath) throw new Error("internal: hermesArchivePath missing");
-        if (!(0, import_node_fs22.existsSync)((0, import_node_path17.dirname)(hermesArchivePath))) {
-          (0, import_node_fs22.mkdirSync)((0, import_node_path17.dirname)(hermesArchivePath), { recursive: true });
-        }
-        (0, import_node_fs22.renameSync)(hermesHome, hermesArchivePath);
-      }
-    }
-    (0, import_node_fs22.mkdirSync)(paths.root, { recursive: true });
-    if (opts.json) {
-      printJson({ ok: true, reset: true, plan });
-      return;
-    }
-    const ui = getUI();
-    ui.ok("Runtime reset complete", paths.root);
-    if (archivePath) ui.line(`  archived: ${archivePath}`);
-    if (assetSyncArchivePath && plan.assetSyncExists) ui.line(`  asset sync archived: ${assetSyncArchivePath}`);
-    if (hermesArchivePath && plan.hermesExists) ui.line(`  Hermes archived: ${hermesArchivePath}`);
-    if (hermesGatewayPids.length > 0) ui.line(`  stopped Hermes gateway pid(s): ${hermesGatewayPids.join(", ")}`);
-    ui.line("  next: prismer setup");
-  }, { code: "reset_failed" }));
-}
-function printPlan(plan, json) {
-  if (json) {
-    printJson({ ok: true, check: true, plan });
-    return;
-  }
-  const ui = getUI();
-  ui.header("Runtime reset plan");
-  ui.blank();
-  ui.line(`  root:        ${plan.root}`);
-  ui.line(`  exists:      ${plan.exists ? "yes" : "no"}`);
-  ui.line(`  daemon:      ${plan.runningPid ? `running pid ${plan.runningPid}` : "not running"}`);
-  ui.line(`  mode:        ${plan.mode}`);
-  if (plan.archivePath) ui.line(`  archive:     ${plan.archivePath}`);
-  ui.line(`  asset sync:  ${plan.assetSyncExists ? plan.assetSyncRoot : `${plan.assetSyncRoot} (not found)`}`);
-  if (plan.assetSyncArchivePath) ui.line(`  asset archive: ${plan.assetSyncArchivePath}`);
-  ui.line(`  Hermes:     ${plan.hermesExists ? plan.hermesHome : `${plan.hermesHome} (not found)`}`);
-  if (plan.hermesArchivePath) ui.line(`  Hermes archive: ${plan.hermesArchivePath}`);
-  ui.line(
-    `  Hermes gateway: ${plan.hermesGatewayPids.length > 0 ? `running pid(s) ${plan.hermesGatewayPids.join(", ")}` : "not running"}`
-  );
-  ui.blank();
-  ui.line("Run `prismer reset --yes` to apply, then `prismer setup` to bind a new account.");
-}
-async function stopDaemon(pid, timeoutMs) {
-  await stopProcess(pid, timeoutMs, "daemon");
-}
-async function stopProcess(pid, timeoutMs, label) {
-  try {
-    process.kill(pid, "SIGTERM");
-  } catch (err) {
-    throw new Error(`SIGTERM failed for ${label} pid ${pid}: ${err.message}`);
-  }
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    if (!pidAlive2(pid)) return;
-    await (0, import_promises4.setTimeout)(100);
-  }
-  try {
-    process.kill(pid, "SIGKILL");
-  } catch (err) {
-    throw new Error(`SIGKILL failed for ${label} pid ${pid}: ${err.message}`);
-  }
-  const killDeadline = Date.now() + 1e3;
-  while (Date.now() < killDeadline) {
-    if (!pidAlive2(pid)) return;
-    await (0, import_promises4.setTimeout)(100);
-  }
-  throw new Error(`${label} pid ${pid} did not exit within ${timeoutMs + 1e3}ms`);
-}
-function timestamp() {
-  return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-}
-function resolveAssetSyncRoot() {
-  const override = process.env.PRISMER_ASSET_SYNC_ROOT;
-  if (override) return override;
-  const home = (0, import_node_os11.homedir)();
-  const desktop = (0, import_node_path17.join)(home, "Desktop");
-  const base = (0, import_node_fs22.existsSync)(desktop) ? desktop : home;
-  return (0, import_node_path17.join)(base, "Prismer Assets");
-}
-function resolveHermesHome() {
-  return process.env.HERMES_HOME || (0, import_node_path17.join)((0, import_node_os11.homedir)(), ".hermes");
-}
-function findHermesGatewayPids2() {
-  try {
-    const out = (0, import_node_child_process9.execFileSync)("ps", ["-axo", "pid=,command="], { encoding: "utf8" });
-    const current = process.pid;
-    return out.split(/\r?\n/).map((line) => {
-      const trimmed = line.trim();
-      const match = /^(\d+)\s+(.+)$/.exec(trimmed);
-      if (!match) return null;
-      const pid = Number.parseInt(match[1], 10);
-      const command = match[2];
-      if (!Number.isFinite(pid) || pid === current) return null;
-      if (!isHermesGatewayCommand2(command)) return null;
-      return pid;
-    }).filter((pid) => pid !== null);
-  } catch {
-    return [];
-  }
-}
-function isHermesGatewayCommand2(command) {
-  if (!/\bgateway\b/.test(command) || !/\brun\b/.test(command)) return false;
-  return /(^|\s)(?:\S*\/)?hermes(?:\s|$)/.test(command);
-}
-
 // src/cli/commands/sandbox.ts
-var import_commander14 = require("commander");
+var import_commander13 = require("commander");
 init_util();
 init_ui();
 function buildSandboxCommand() {
-  const cmd = new import_commander14.Command("sandbox").description("Inspect and smoke-test sandbox lifecycle");
-  cmd.command("list").description("List sandbox containers in a workspace").requiredOption("--workspace-id <id>", "Workspace id").option("--status <status>", "Status filter").option("--limit <n>", "Max rows", parsePositiveInt6, 50).option("--json", "Output machine-readable JSON").action(runAction(async (opts) => {
+  const cmd = new import_commander13.Command("sandbox").description("Inspect and smoke-test sandbox lifecycle");
+  cmd.command("list").description("List sandbox containers in a workspace").requiredOption("--workspace-id <id>", "Workspace id").option("--status <status>", "Status filter").option("--limit <n>", "Max rows", parsePositiveInt5, 50).option("--json", "Output machine-readable JSON").action(runAction(async (opts) => {
     const query = new URLSearchParams({ workspaceId: opts.workspaceId, limit: String(opts.limit) });
     if (opts.status) query.set("status", opts.status);
     const body = await cloudRequest("GET", `/api/sandboxes?${query.toString()}`);
@@ -11888,7 +10252,7 @@ function buildSandboxCommand() {
     }
     printSnapshotResult(id, body);
   }, { code: "sandbox_snapshot_failed" }));
-  cmd.command("runCmd <id> <command...>").description("Run a command in a sandbox container").option("--timeout-ms <ms>", "Command timeout", parsePositiveInt6, 6e4).option("--json", "Output machine-readable JSON").allowUnknownOption(true).action(runAction(async (id, command, opts) => {
+  cmd.command("runCmd <id> <command...>").description("Run a command in a sandbox container").option("--timeout-ms <ms>", "Command timeout", parsePositiveInt5, 6e4).option("--json", "Output machine-readable JSON").allowUnknownOption(true).action(runAction(async (id, command, opts) => {
     if (!Array.isArray(command) || command.length === 0) exitWithError("runCmd requires a command after --", { code: "invalid_argument" });
     const body = await cloudRequest("POST", `/api/sandboxes/${encodeURIComponent(id)}/runCmd`, {
       command,
@@ -11929,12 +10293,12 @@ function errorMessage2(raw) {
   if (typeof raw.error === "string") return raw.error;
   return raw.error?.message ?? "request failed";
 }
-async function cloudRequest(method, path9, body) {
+async function cloudRequest(method, path7, body) {
   const cloud = mkCloud5();
-  const res = await cloud.request(method, path9, body === void 0 ? void 0 : { body });
-  if (!res.ok) exitWithError(`${method} ${path9} failed (${res.status}): ${res.error?.message ?? "request failed"}`);
+  const res = await cloud.request(method, path7, body === void 0 ? void 0 : { body });
+  if (!res.ok) exitWithError(`${method} ${path7} failed (${res.status}): ${res.error?.message ?? "request failed"}`);
   const responseBody = res.data;
-  if (isErrorEnvelope2(responseBody)) exitWithError(`${method} ${path9} failed (${res.status}): ${errorMessage2(responseBody)}`);
+  if (isErrorEnvelope2(responseBody)) exitWithError(`${method} ${path7} failed (${res.status}): ${errorMessage2(responseBody)}`);
   return responseBody;
 }
 function printSandboxList(raw) {
@@ -12009,7 +10373,7 @@ function writeLine2(label, value) {
   if (value === void 0 || value === null || value === "") return;
   getUI().line(`  ${label}: ${String(value)}`);
 }
-function parsePositiveInt6(value) {
+function parsePositiveInt5(value) {
   const parsed = Number.parseInt(value, 10);
   if (!Number.isFinite(parsed) || parsed <= 0) {
     throw new Error("expected a positive integer");
@@ -12027,16 +10391,16 @@ async function safeParseResponse(res) {
 }
 
 // src/cli/commands/setup.ts
-var import_commander15 = require("commander");
-var import_node_os12 = require("os");
-var import_node_child_process10 = require("child_process");
-var import_node_crypto10 = require("crypto");
-var import_node_fs23 = require("fs");
+var import_commander14 = require("commander");
+var import_node_os9 = require("os");
+var import_node_child_process9 = require("child_process");
+var import_node_crypto6 = require("crypto");
+var import_node_fs19 = require("fs");
 var import_node_http2 = require("http");
 init_util();
 init_ui();
 function buildSetupCommand() {
-  return new import_commander15.Command("setup").description("Set up this local runtime and bind it to Prismer Cloud").argument("[api-key]", "Prismer daemon API key; primarily for manual recovery and automation").option(
+  return new import_commander14.Command("setup").description("Set up this local runtime and bind it to Prismer Cloud").argument("[api-key]", "Prismer daemon API key; primarily for manual recovery and automation").option(
     "--cloud <url>",
     `Cloud base URL (default: ${DEFAULT_CLOUD_BASE_URL}; bare host:port is auto-prefixed http://)`,
     (v) => v
@@ -12049,7 +10413,7 @@ function buildSetupCommand() {
     } catch (err) {
       exitWithError(err.message, { code: "invalid_cloud_url" });
     }
-    let apiKey = apiKeyArg ?? (opts.force ? void 0 : process.env.PRISMER_API_KEY);
+    let apiKey = apiKeyArg ?? process.env.PRISMER_API_KEY;
     const authToken = opts.token ?? process.env.PRISMER_AUTH_TOKEN;
     if (!opts.json) {
       printBanner({ compact: true });
@@ -12057,6 +10421,7 @@ function buildSetupCommand() {
       getUI().blank();
     }
     const shouldStart = opts.start !== false;
+    stopRunningDaemon(paths);
     if (opts.pair || opts.asUser) {
       if (!opts.json) warn("Legacy pair setup path", "plain `prismer setup --start` is the canonical runtime binding flow");
       if (opts.asUser && process.env.LOCAL_ONLY !== "1") {
@@ -12073,7 +10438,7 @@ function buildSetupCommand() {
       }
       const result = await pair({
         cloudBaseUrl,
-        deviceName: opts.deviceName ?? (0, import_node_os12.hostname)(),
+        deviceName: opts.deviceName ?? (0, import_node_os9.hostname)(),
         force: opts.force,
         paths,
         asUserEmail: opts.asUser
@@ -12090,13 +10455,13 @@ function buildSetupCommand() {
         apiKey = await mintDaemonApiKey({
           cloudBaseUrl,
           token: authToken,
-          deviceName: opts.deviceName ?? (0, import_node_os12.hostname)()
+          deviceName: opts.deviceName ?? (0, import_node_os9.hostname)()
         });
       }
       if (!apiKey && !authToken && !opts.check && opts.browser !== false) {
         apiKey = await runBrowserSetup({
           cloudBaseUrl,
-          deviceName: opts.deviceName ?? (0, import_node_os12.hostname)(),
+          deviceName: opts.deviceName ?? (0, import_node_os9.hostname)(),
           json: Boolean(opts.json)
         });
       }
@@ -12147,11 +10512,10 @@ function buildSetupCommand() {
         return;
       }
       const previousConfig = configExists(paths) ? loadConfig(paths) : null;
-      const daemonId = previousConfig && previousConfig.api_key === apiKey && previousConfig.cloud_api_base === cloudBaseUrl ? previousConfig.daemon_id : newDaemonId();
       const config = {
         api_key: apiKey,
         cloud_api_base: cloudBaseUrl,
-        daemon_id: daemonId
+        daemon_id: newDaemonId()
       };
       if (previousConfig && shouldArchiveLocalDb(previousConfig, config)) {
         archiveLocalDb(paths.localDb);
@@ -12181,7 +10545,7 @@ function buildSetupCommand() {
   }, { code: "setup_failed" }));
 }
 async function runBrowserSetup(input) {
-  const state = (0, import_node_crypto10.randomBytes)(18).toString("base64url");
+  const state = (0, import_node_crypto6.randomBytes)(18).toString("base64url");
   const server = (0, import_node_http2.createServer)();
   const apiKeyPromise = waitForSetupCallback(server, state);
   await new Promise((resolve3, reject) => {
@@ -12244,7 +10608,7 @@ function waitForSetupCallback(server, expectedState) {
 function openBrowser(url) {
   const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
   const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
-  const child = (0, import_node_child_process10.spawn)(command, args, { stdio: "ignore", detached: true });
+  const child = (0, import_node_child_process9.spawn)(command, args, { stdio: "ignore", detached: true });
   child.on("error", () => {
   });
   child.unref();
@@ -12271,20 +10635,42 @@ function withTimeout(promise, ms, message) {
   });
 }
 function startDaemonDetached(home) {
-  const child = (0, import_node_child_process10.spawn)(process.execPath, [process.argv[1], "daemon", "start"], {
+  const child = (0, import_node_child_process9.spawn)(process.execPath, [process.argv[1], "daemon", "start"], {
     env: { ...process.env, PRISMER_HOME: home },
     stdio: "ignore",
     detached: true
   });
   child.unref();
 }
+function stopRunningDaemon(paths) {
+  const pid = readPidFile(paths);
+  if (!pid || !pidAlive(pid)) {
+    if (pid) clearPidFile(paths);
+    return;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    return;
+  }
+  const deadline = Date.now() + 5e3;
+  while (Date.now() < deadline) {
+    if (!pidAlive(pid)) {
+      clearPidFile(paths);
+      return;
+    }
+    const start = Date.now();
+    while (Date.now() - start < 200) {
+    }
+  }
+}
 function shouldArchiveLocalDb(previous, next) {
   return previous.api_key !== next.api_key || previous.cloud_api_base !== next.cloud_api_base || previous.daemon_id !== next.daemon_id;
 }
 function archiveLocalDb(localDbPath) {
-  if (!(0, import_node_fs23.existsSync)(localDbPath)) return;
+  if (!(0, import_node_fs19.existsSync)(localDbPath)) return;
   const archived = `${localDbPath}.${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.bak`;
-  (0, import_node_fs23.renameSync)(localDbPath, archived);
+  (0, import_node_fs19.renameSync)(localDbPath, archived);
 }
 async function mintDaemonApiKey(input) {
   const label = `Daemon: ${input.deviceName} ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}`;
@@ -12304,12 +10690,11 @@ async function mintDaemonApiKey(input) {
 }
 
 // src/cli/commands/status.ts
-var import_commander16 = require("commander");
-var import_node_os13 = require("os");
+var import_commander15 = require("commander");
 init_util();
 init_ui();
 function buildStatusCommand() {
-  return new import_commander16.Command("status").description("Show daemon + config + cloud status").option("--json", "Output machine-readable JSON").action(async (opts) => {
+  return new import_commander15.Command("status").description("Show daemon + config + cloud status").option("--json", "Output machine-readable JSON").action(async (opts) => {
     const paths = resolvePaths();
     if (!configExists(paths)) {
       const report2 = { configured: false, paired: false, paths: { config: paths.configFile } };
@@ -12377,7 +10762,11 @@ function buildStatusCommand() {
         info: daemonStatus.info ?? {}
       },
       cloud: { base: cfg.cloud_api_base, reachable: cloudOk, me, devices, agents },
-      local
+      local,
+      binding: {
+        daemonId: cfg.daemon_id,
+        apiKey: cfg.api_key
+      }
     };
     if (opts.json) {
       printJson(report);
@@ -12400,8 +10789,8 @@ async function readDaemonStatus() {
   const paths = resolvePaths();
   const pid = readPidFile(paths);
   if (pid) {
-    const { pidAlive: pidAlive3 } = await Promise.resolve().then(() => (init_util(), util_exports));
-    if (pidAlive3(pid)) return { running: true, pid };
+    const { pidAlive: pidAlive2 } = await Promise.resolve().then(() => (init_util(), util_exports));
+    if (pidAlive2(pid)) return { running: true, pid };
   }
   return { running: false };
 }
@@ -12429,9 +10818,8 @@ function printPretty(report) {
   ui.blank();
   ok("Config", report.paths.config);
   if (report.daemon.running) {
-    const daemonName = report.cloud.me && typeof report.cloud.me === "object" ? report.cloud.me.user?.username ?? (0, import_node_os13.hostname)() : (0, import_node_os13.hostname)();
     const ws = report.daemon.wsConnected ? "connected" : "pending";
-    ok("Daemon", `${daemonName}  pid=${report.daemon.pid}  ws=${ws}`);
+    ok("Daemon", `pid=${report.daemon.pid}  ws=${ws}`);
     if (report.daemon.info) {
       const info2 = report.daemon.info;
       if (info2.version) ui.line(`  Version:  ${info2.version}`);
@@ -12446,7 +10834,8 @@ function printPretty(report) {
     ok("Cloud", report.cloud.base);
     const me = report.cloud.me;
     if (me?.user) {
-      ui.line(`  User:     ${me.user.displayName ?? me.user.username ?? "?"}`);
+      const roleTag = me.user.role ? `  role=${me.user.role}` : "";
+      ui.line(`  Account:  ${me.user.displayName ?? me.user.username ?? "?"}${roleTag}`);
     }
     if (me?.credits) {
       ui.line(`  Credits:  ${typeof me.credits.balance === "number" ? me.credits.balance.toLocaleString() : "?"}`);
@@ -12455,6 +10844,12 @@ function printPretty(report) {
     fail2("Cloud", `${report.cloud.base} unreachable or unauthorized`);
     tip("prismer setup --force");
   }
+  if (report.binding) {
+    ui.blank();
+    ui.line(`  Daemon ID:  ${report.binding.daemonId}`);
+    const masked = report.binding.apiKey.slice(0, 14) + "\u2022\u2022\u2022\u2022" + report.binding.apiKey.slice(-4);
+    ui.line(`  API Key:    ${masked}`);
+  }
   if (Array.isArray(report.cloud.devices) && report.cloud.devices.length > 0) {
     const devs = report.cloud.devices;
     ui.blank();
@@ -12465,6 +10860,8 @@ function printPretty(report) {
       const declared = d.hostedAgentSummary?.declared ?? 0;
       ui.line(`    ${statusIcon} ${d.podName?.replace(/^daemon:/, "")?.slice(0, 28) ?? "?"}  kind=${kind}  agents=${declared}`);
     }
+  } else {
+    ui.line(`  Workspace Devices: none`);
   }
   if (Array.isArray(report.cloud.agents) && report.cloud.agents.length > 0) {
     ui.line(`  Hosted agents: ${report.cloud.agents.length}`);
@@ -12480,14 +10877,14 @@ function printPretty(report) {
 }
 
 // src/cli/commands/task.ts
-var import_commander17 = require("commander");
-var import_promises5 = require("timers/promises");
+var import_commander16 = require("commander");
+var import_promises3 = require("timers/promises");
 init_util();
 function describeStatus(status) {
   return status === 0 ? "network error" : `HTTP ${status}`;
 }
 function buildTaskCommand() {
-  const cmd = new import_commander17.Command("task").description("Manage tasks");
+  const cmd = new import_commander16.Command("task").description("Manage tasks");
   cmd.command("create").description("Create + dispatch a task to the given agent and wait for completion").requiredOption("--agent <imUserId>", "Assignee agent IMUser.id").requiredOption("--prompt <text>", "Prompt to send to the adapter").option("--profile <profileId>", "AgentProfile id (cloud picks first if omitted)").option("--capability <name>", "Capability tag", "chat").option("--title <text>", "Task title (defaults to prompt prefix)").option("--timeout-ms <ms>", "Per-task timeout", (v) => Number.parseInt(v, 10)).option("--no-wait", "Just create + print task id; don't poll").option("--json", "Output JSON (default)").action(runAction(async (opts) => {
     const cloud = mkCloud6();
     const body = {
@@ -12564,7 +10961,7 @@ function unwrap2(raw) {
 async function pollUntilTerminal(cloud, taskId, timeoutMs) {
   const deadline = Date.now() + (timeoutMs ?? 5 * 6e4);
   while (Date.now() < deadline) {
-    await (0, import_promises5.setTimeout)(1e3);
+    await (0, import_promises3.setTimeout)(1e3);
     const res = await cloud.request(
       "GET",
       `/api/im/tasks/${encodeURIComponent(taskId)}`
@@ -12601,11 +10998,11 @@ function taskFrom2(raw) {
 }
 
 // src/cli/commands/workspace.ts
-var import_commander18 = require("commander");
+var import_commander17 = require("commander");
 init_util();
 init_ui();
 function buildWorkspaceCommand() {
-  const cmd = new import_commander18.Command("workspace").description("Manage workspaces, runtime snapshots, and workspace files");
+  const cmd = new import_commander17.Command("workspace").description("Manage workspaces, runtime snapshots, and workspace files");
   cmd.command("list").description("List workspaces").option("--json", "Output machine-readable JSON").action(runAction(async (opts) => {
     const cloud = mkCloud7();
     const data = await cloud.get("/api/im/workspaces");
@@ -12839,15 +11236,18 @@ async function readResponseError(res) {
 
 // src/cli/index.ts
 init_ui();
-var VERSION = "1.9.7";
+
+// package.json
+var version = "1.9.22";
+
+// src/cli/index.ts
 function buildProgram() {
-  const program = new import_commander19.Command("prismer").description("Prismer Cloud daemon CLI (TS-only).").version(VERSION);
+  const program = new import_commander18.Command("prismer").description("Prismer Cloud daemon CLI (TS-only).").version(version);
   program.addCommand(buildBannerCommand());
   program.addCommand(buildSetupCommand());
   program.addCommand(buildConfigCommand());
   program.addCommand(buildDaemonCommand());
   program.addCommand(buildPairCommand());
-  program.addCommand(buildResetCommand());
   program.addCommand(buildStatusCommand());
   program.addCommand(buildAdapterCommand());
   program.addCommand(buildAgentCommand());