@xdsjs/dossierx-daemon 0.1.0

package/dist/index.js

@@ -0,0 +1,2327 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { stat as stat4 } from "fs/promises";
+import os3 from "os";
+import path8 from "path";
+import { Command } from "commander";
+import { DOSSIERX_DEFAULT_WORKSPACE_PATH } from "@xdsjs/dossierx-workspace";
+
+// src/api/client.ts
+import {
+  AppendTaskEventsRequestSchema,
+  AppendTaskEventsResponseSchema,
+  ClaimTaskResponseSchema,
+  CompleteTaskRequestSchema,
+  CompleteTaskResponseSchema,
+  DaemonBootstrapRequestSchema,
+  DaemonBootstrapResponseSchema,
+  DaemonHeartbeatRequestSchema,
+  DaemonHeartbeatResponseSchema,
+  FailTaskRequestSchema,
+  FailTaskResponseSchema
+} from "@xdsjs/dossierx-shared";
+var ApiClient = class {
+  serverUrl;
+  machineKey;
+  fetchImpl;
+  constructor(options) {
+    this.serverUrl = options.serverUrl.replace(/\/$/, "");
+    this.machineKey = options.machineKey;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+  }
+  async post(path9, body, schema) {
+    const response = await this.fetchImpl(`${this.serverUrl}${path9}`, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${this.machineKey}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+    const data = await response.json().catch(() => ({}));
+    if (!response.ok) {
+      const message = typeof data.error === "string" ? data.error : `HTTP ${response.status} ${response.statusText}`;
+      throw new Error(message);
+    }
+    return schema.parse(data);
+  }
+  async bootstrap(input) {
+    return this.post(
+      "/api/daemon/bootstrap",
+      DaemonBootstrapRequestSchema.parse(input),
+      DaemonBootstrapResponseSchema
+    );
+  }
+  async heartbeat(input) {
+    return this.post(
+      "/api/daemon/heartbeat",
+      DaemonHeartbeatRequestSchema.parse(input),
+      DaemonHeartbeatResponseSchema
+    );
+  }
+  async claimTask(input) {
+    return this.post("/api/tasks/claim", input, ClaimTaskResponseSchema);
+  }
+  async appendTaskEvents(taskId, input) {
+    await this.post(
+      `/api/tasks/${taskId}/events`,
+      AppendTaskEventsRequestSchema.parse(input),
+      AppendTaskEventsResponseSchema
+    );
+  }
+  async completeTask(taskId, input) {
+    await this.post(
+      `/api/tasks/${taskId}/complete`,
+      CompleteTaskRequestSchema.parse(input),
+      CompleteTaskResponseSchema
+    );
+  }
+  async failTask(taskId, input) {
+    await this.post(
+      `/api/tasks/${taskId}/fail`,
+      FailTaskRequestSchema.parse(input),
+      FailTaskResponseSchema
+    );
+  }
+};
+
+// src/codex/runner.ts
+import { execa } from "execa";
+var CodexSandboxModes = [
+  "workspace-write",
+  "danger-full-access"
+];
+var CodexRuntimeError = class extends Error {
+  code;
+  step;
+  constructor(code, message, step) {
+    super(message);
+    this.name = "CodexRuntimeError";
+    this.code = code;
+    this.step = step;
+  }
+};
+function truncateCodexOutput(output, maxLength = 2e3) {
+  return output.length > maxLength ? output.slice(0, maxLength) : output;
+}
+function resolveCodexCommand(options, env = process.env) {
+  return options.codexCommand?.trim() || env.DOSSIERX_CODEX_COMMAND?.trim() || "codex";
+}
+function resolveCodexModel(options, env = process.env) {
+  return options.codexModel?.trim() || env.DOSSIERX_CODEX_MODEL?.trim() || void 0;
+}
+function resolveCodexSandbox(options, env = process.env) {
+  const value = options.codexSandbox?.trim() || env.DOSSIERX_CODEX_SANDBOX?.trim() || "workspace-write";
+  if (CodexSandboxModes.includes(value)) {
+    return value;
+  }
+  throw new CodexRuntimeError(
+    "VALIDATION_ERROR",
+    `Invalid Codex sandbox: ${value}`,
+    "codex.runner.config"
+  );
+}
+function buildInvestWikiFlowPrompt(input) {
+  const identity = [
+    `ticker: ${input.ticker}`,
+    `market: ${input.market}`,
+    input.companyName ? `company_name: ${input.companyName}` : void 0,
+    input.cik ? `cik: ${input.cik}` : void 0,
+    input.exchange ? `exchange: ${input.exchange}` : void 0
+  ].filter((line) => Boolean(line));
+  return [
+    "\u4F60\u5728\u4E00\u4E2A\u5DF2\u7ECF\u521D\u59CB\u5316\u7684 llm-wiki-invest vault \u6839\u76EE\u5F55\u4E2D\u5DE5\u4F5C\u3002",
+    "\u8BF7\u4F7F\u7528 invest-wiki-flow skill\uFF0C\u6267\u884C invest-wiki-flow \u7EF4\u62A4\u6D41\u7A0B\u3002",
+    "",
+    "\u516C\u53F8\u8EAB\u4EFD\uFF1A",
+    ...identity.map((line) => `- ${line}`),
+    "",
+    "\u6267\u884C\u8981\u6C42\uFF1A",
+    "- \u5148\u8BFB\u53D6 AGENTS.md\u3001wiki-purpose.md\u3001wiki-schema.md\uFF1B\u5982\u5B58\u5728 wiki-agent.md \u4E5F\u8981\u8BFB\u53D6\u3002",
+    "- \u4E25\u683C\u9075\u5B88 invest-wiki-flow \u7684 sources -> wiki -> wiki/right \u987A\u5E8F\u3002",
+    "- \u4E0D\u8981\u624B\u5DE5\u4FEE\u6539 sources/ \u4E0B\u5DF2\u6709\u6765\u6E90\u6B63\u6587\u3002",
+    "- \u6267\u884C llm-wiki-invest\u3001Node fetch \u6216 SEC \u83B7\u53D6\u547D\u4EE4\u65F6\uFF0C\u547D\u4EE4\u524D\u5FC5\u987B\u663E\u5F0F\u52A0 NODE_USE_ENV_PROXY=1\u3002",
+    "- \u9996\u6B21\u83B7\u53D6 SEC submissions \u65F6\u5FC5\u987B\u4FDD\u5B58\u5230 .llm-wiki-invest/sec-submissions.json\uFF0C\u540E\u7EED\u6B65\u9AA4\u590D\u7528\u8BE5\u6587\u4EF6\uFF0C\u907F\u514D\u53CD\u590D\u8054\u7F51\u83B7\u53D6\u540C\u4E00 JSON\u3002",
+    "- \u5982\u679C\u6CA1\u6709\u65B0\u589E\u6216\u9700\u8981\u66F4\u65B0\u7684\u5185\u5BB9\uFF0C\u53EA\u8F93\u51FA no-op \u6458\u8981\u3002",
+    "- \u5982\u4EA7\u751F\u5B9E\u9645\u53D8\u66F4\uFF0C\u6309 vault \u89C4\u5219\u66F4\u65B0 wiki-log.md \u5E76\u8FD0\u884C llm-wiki-invest sync\u3002",
+    "",
+    `\u8BF7\u5F00\u59CB\u6267\u884C\uFF1Ainvest-wiki-flow ${input.ticker}`
+  ].join("\n");
+}
+function getStringProperty(error, property) {
+  if (!error || typeof error !== "object") {
+    return void 0;
+  }
+  const value = error[property];
+  return typeof value === "string" ? value : void 0;
+}
+function getNumberProperty(error, property) {
+  if (!error || typeof error !== "object") {
+    return void 0;
+  }
+  const value = error[property];
+  return typeof value === "number" ? value : void 0;
+}
+function extractCodexJsonFailure(stdout) {
+  if (!stdout) {
+    return void 0;
+  }
+  for (const line of stdout.split("\n")) {
+    if (!line.trim()) {
+      continue;
+    }
+    try {
+      const event = JSON.parse(line);
+      if (event.type === "error" && typeof event.message === "string") {
+        return event.message;
+      }
+      if (event.type === "turn.failed" && event.error && typeof event.error.message === "string") {
+        return event.error.message;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return void 0;
+}
+function commandFailureCode(error) {
+  const code = getStringProperty(error, "code");
+  return code === "ENOENT" ? "RUNTIME_NOT_FOUND" : "COMMAND_FAILED";
+}
+function commandFailureStep(error) {
+  return commandFailureCode(error) === "RUNTIME_NOT_FOUND" ? "codex.runner.resolve" : "codex.runner.run";
+}
+function commandFailureMessage(error) {
+  const stdout = getStringProperty(error, "stdout");
+  const stderr = getStringProperty(error, "stderr");
+  const exitCode = getNumberProperty(error, "exitCode");
+  const signal = getStringProperty(error, "signal");
+  const codexError = extractCodexJsonFailure(stdout);
+  const details = [
+    "Codex command failed",
+    codexError ? `reason: ${truncateCodexOutput(codexError, 1e3)}` : void 0,
+    exitCode === void 0 ? void 0 : `exitCode: ${exitCode}`,
+    signal ? `signal: ${signal}` : void 0,
+    stdout === void 0 ? void 0 : `stdoutChars: ${stdout.length}`,
+    stderr === void 0 ? void 0 : `stderrChars: ${stderr.length}`,
+    stdout === void 0 ? void 0 : `stdoutBytes: ${Buffer.byteLength(stdout)}`,
+    stderr === void 0 ? void 0 : `stderrBytes: ${Buffer.byteLength(stderr)}`,
+    stdout === void 0 ? void 0 : `stdoutTruncated: ${stdout.length > 2e3}`,
+    stderr === void 0 ? void 0 : `stderrTruncated: ${stderr.length > 2e3}`
+  ].filter((detail) => Boolean(detail));
+  return truncateCodexOutput(details.join("\n"), 2e3);
+}
+function hasCodexJsonEvent(stdout, eventType) {
+  return stdout.split("\n").filter(Boolean).some((line) => {
+    try {
+      const event = JSON.parse(line);
+      return event.type === eventType;
+    } catch {
+      return false;
+    }
+  });
+}
+function getRecordProperty(value, property) {
+  if (!value || typeof value !== "object") {
+    return void 0;
+  }
+  const nested = value[property];
+  return nested && typeof nested === "object" ? nested : void 0;
+}
+function getEventPayload(event) {
+  return getRecordProperty(event, "payload") ?? event;
+}
+function getEventType(event) {
+  const payload = getEventPayload(event);
+  const payloadType = payload.type;
+  if (typeof payloadType === "string") {
+    return payloadType;
+  }
+  const type = event.type;
+  return typeof type === "string" ? type : void 0;
+}
+function getText(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function truncateEventMessage(message) {
+  return message.length > 1e3 ? `${message.slice(0, 1e3)}...` : message;
+}
+function extractMessageText(content) {
+  if (typeof content === "string") {
+    return getText(content);
+  }
+  if (!Array.isArray(content)) {
+    return void 0;
+  }
+  const text = content.map((item) => {
+    if (typeof item === "string") {
+      return item;
+    }
+    if (!item || typeof item !== "object") {
+      return "";
+    }
+    const record = item;
+    return getText(record.text) ?? getText(record.content) ?? "";
+  }).filter(Boolean).join("\n").trim();
+  return text || void 0;
+}
+function codexJsonLineToTaskEvent(line) {
+  if (!line.trim()) {
+    return null;
+  }
+  let event;
+  try {
+    const parsed = JSON.parse(line);
+    if (!parsed || typeof parsed !== "object") {
+      return null;
+    }
+    event = parsed;
+  } catch {
+    return null;
+  }
+  const payload = getEventPayload(event);
+  const type = getEventType(event);
+  if (!type) {
+    return null;
+  }
+  const data = { codexType: type };
+  const item = getRecordProperty(event, "item");
+  const itemType = getText(item?.type);
+  const itemData = itemType ? { ...data, itemType } : data;
+  switch (type) {
+    case "thread.started":
+      return { level: "info", message: "Codex session started", data };
+    case "turn.started":
+    case "task_started":
+      return { level: "info", message: "Codex turn started", data };
+    case "turn.completed":
+    case "task_complete":
+      return { level: "info", message: "Codex turn completed", data };
+    case "turn.failed":
+    case "error": {
+      const errorRecord = getRecordProperty(payload, "error");
+      const message = getText(errorRecord?.message) ?? getText(payload.message) ?? "Codex turn failed";
+      return {
+        level: "error",
+        message: truncateEventMessage(message),
+        data
+      };
+    }
+    case "agent_message": {
+      const message = getText(payload.message);
+      return message ? { level: "info", message: truncateEventMessage(message), data } : null;
+    }
+    case "message": {
+      const message = extractMessageText(payload.content);
+      return message ? { level: "info", message: truncateEventMessage(message), data } : null;
+    }
+    case "function_call":
+    case "custom_tool_call": {
+      const name = getText(payload.name) ?? "tool";
+      return {
+        level: "info",
+        message: `Codex tool call: ${name}`,
+        data
+      };
+    }
+    case "function_call_output":
+    case "custom_tool_call_output":
+      return {
+        level: "debug",
+        message: "Codex tool output received",
+        data
+      };
+    case "item.started":
+      if (itemType === "command_execution") {
+        return {
+          level: "info",
+          message: "Codex command started",
+          data: itemData
+        };
+      }
+      if (itemType === "todo_list") {
+        return {
+          level: "info",
+          message: "Codex todo list started",
+          data: itemData
+        };
+      }
+      return null;
+    case "item.completed":
+      if (itemType === "agent_message") {
+        const message = getText(item?.text) ?? getText(item?.message);
+        return message ? {
+          level: "info",
+          message: truncateEventMessage(message),
+          data: itemData
+        } : null;
+      }
+      if (itemType === "command_execution") {
+        return {
+          level: "info",
+          message: "Codex command completed",
+          data: itemData
+        };
+      }
+      if (itemType === "todo_list") {
+        return {
+          level: "info",
+          message: "Codex todo list updated",
+          data: itemData
+        };
+      }
+      return null;
+    default:
+      return null;
+  }
+}
+function emitCodexEvent(callbacks, line, pendingCallbacks) {
+  const event = codexJsonLineToTaskEvent(line);
+  if (!event) {
+    return;
+  }
+  pendingCallbacks.push(
+    Promise.resolve(callbacks?.onEvent?.(event)).catch(() => void 0)
+  );
+}
+function emitRawOutput(callbacks, stream, chunk, pendingCallbacks) {
+  pendingCallbacks.push(
+    Promise.resolve(callbacks?.onRawOutput?.(stream, chunk)).catch(
+      () => void 0
+    )
+  );
+}
+function consumeStdoutChunk(callbacks, buffer, chunk, pendingCallbacks) {
+  emitRawOutput(callbacks, "stdout", chunk, pendingCallbacks);
+  buffer.value += chunk;
+  let newlineIndex = buffer.value.indexOf("\n");
+  while (newlineIndex >= 0) {
+    const line = buffer.value.slice(0, newlineIndex);
+    buffer.value = buffer.value.slice(newlineIndex + 1);
+    emitCodexEvent(callbacks, line, pendingCallbacks);
+    newlineIndex = buffer.value.indexOf("\n");
+  }
+}
+function assertCodexTurnCompleted(stdout) {
+  if (hasCodexJsonEvent(stdout, "turn.completed")) {
+    return;
+  }
+  if (hasCodexJsonEvent(stdout, "turn.failed") || hasCodexJsonEvent(stdout, "error")) {
+    throw new CodexRuntimeError(
+      "COMMAND_FAILED",
+      "Codex command reported a failed turn",
+      "codex.runner.run"
+    );
+  }
+  throw new CodexRuntimeError(
+    "COMMAND_FAILED",
+    "Codex command ended before turn.completed",
+    "codex.runner.run"
+  );
+}
+function createCodexRunner(config) {
+  return {
+    kind: "codex",
+    async runInvestWikiFlow(input, callbacks) {
+      const modelArgs = config.model ? ["-m", config.model] : [];
+      const sandbox = config.sandbox ?? "workspace-write";
+      let stdout = "";
+      let stderr = "";
+      const stdoutLineBuffer = { value: "" };
+      const pendingCallbacks = [];
+      try {
+        const subprocess = execa(
+          config.command,
+          [
+            "exec",
+            ...modelArgs,
+            "-C",
+            input.vaultRoot,
+            "--sandbox",
+            sandbox,
+            "--skip-git-repo-check",
+            "--json",
+            buildInvestWikiFlowPrompt(input)
+          ],
+          {
+            cwd: input.vaultRoot,
+            env: {
+              NODE_USE_ENV_PROXY: process.env.NODE_USE_ENV_PROXY?.trim() || "1"
+            },
+            stdin: "ignore",
+            shell: false,
+            reject: true
+          }
+        );
+        subprocess.stdout?.on("data", (chunk) => {
+          const text = chunk.toString();
+          stdout += text;
+          consumeStdoutChunk(callbacks, stdoutLineBuffer, text, pendingCallbacks);
+        });
+        subprocess.stderr?.on("data", (chunk) => {
+          const text = chunk.toString();
+          stderr += text;
+          emitRawOutput(callbacks, "stderr", text, pendingCallbacks);
+        });
+        const result = await subprocess;
+        if (stdoutLineBuffer.value.trim()) {
+          emitCodexEvent(callbacks, stdoutLineBuffer.value, pendingCallbacks);
+        }
+        await Promise.all(pendingCallbacks);
+        const finalStdout = stdout || result.stdout;
+        const finalStderr = stderr || result.stderr;
+        assertCodexTurnCompleted(finalStdout);
+        return {
+          stdout: truncateCodexOutput(finalStdout),
+          stderr: truncateCodexOutput(finalStderr)
+        };
+      } catch (error) {
+        await Promise.all(pendingCallbacks);
+        throw new CodexRuntimeError(
+          commandFailureCode(error),
+          commandFailureMessage(error),
+          commandFailureStep(error)
+        );
+      }
+    }
+  };
+}
+function createCodexRunnerFromOptions(options, env = process.env) {
+  return createCodexRunner({
+    command: resolveCodexCommand(options, env),
+    model: resolveCodexModel(options, env),
+    sandbox: resolveCodexSandbox(options, env)
+  });
+}
+
+// src/invest-wiki/runner.ts
+import { access } from "fs/promises";
+import path from "path";
+import { execa as execa2 } from "execa";
+
+// src/invest-wiki/config.ts
+function resolveInvestWikiConfig(options, env = process.env) {
+  const mode = options.investWikiMode ?? env.DOSSIERX_INVEST_WIKI_MODE;
+  const configuredCommand = options.investWikiCommand ?? env.DOSSIERX_INVEST_WIKI_COMMAND;
+  const command = configuredCommand?.trim() || "llm-wiki-invest";
+  if (mode === "local-repo") {
+    const localRepo = options.investWikiLocalRepo ?? env.DOSSIERX_INVEST_WIKI_LOCAL_REPO;
+    if (!localRepo) {
+      return { mode: void 0, command };
+    }
+    return { mode: "local-repo", localRepo, command };
+  }
+  if (mode === "package") {
+    return { mode: "package", command };
+  }
+  return { mode: void 0, command };
+}
+
+// src/invest-wiki/runner.ts
+var InvestWikiRuntimeError = class extends Error {
+  code;
+  step;
+  constructor(code, message, step) {
+    super(message);
+    this.name = "InvestWikiRuntimeError";
+    this.code = code;
+    this.step = step;
+  }
+};
+function truncateCommandOutput(output, maxLength = 2e3) {
+  return output.length > maxLength ? output.slice(0, maxLength) : output;
+}
+async function assertFileExists(filePath) {
+  try {
+    await access(filePath);
+  } catch {
+    throw new InvestWikiRuntimeError(
+      "RUNTIME_NOT_FOUND",
+      `llm-wiki-invest CLI not found at ${filePath}; build the sibling repo first`,
+      "invest_wiki.runner.resolve"
+    );
+  }
+}
+function getStringProperty2(error, property) {
+  if (!error || typeof error !== "object") {
+    return void 0;
+  }
+  const value = error[property];
+  return typeof value === "string" ? value : void 0;
+}
+function getNumberProperty2(error, property) {
+  if (!error || typeof error !== "object") {
+    return void 0;
+  }
+  const value = error[property];
+  return typeof value === "number" ? value : void 0;
+}
+function commandFailureMessage2(error) {
+  const shortMessage = getStringProperty2(error, "shortMessage") ?? "Unknown command failure";
+  const stdout = getStringProperty2(error, "stdout");
+  const stderr = getStringProperty2(error, "stderr");
+  const exitCode = getNumberProperty2(error, "exitCode");
+  const signal = getStringProperty2(error, "signal");
+  const details = [
+    `Invest wiki command failed: ${shortMessage}`,
+    exitCode === void 0 ? void 0 : `exitCode: ${exitCode}`,
+    signal ? `signal: ${signal}` : void 0,
+    stdout === void 0 ? void 0 : `stdoutChars: ${stdout.length}`,
+    stderr === void 0 ? void 0 : `stderrChars: ${stderr.length}`,
+    stdout === void 0 ? void 0 : `stdoutBytes: ${Buffer.byteLength(stdout)}`,
+    stderr === void 0 ? void 0 : `stderrBytes: ${Buffer.byteLength(stderr)}`,
+    stdout === void 0 ? void 0 : `stdoutTruncated: ${stdout.length > 2e3}`,
+    stderr === void 0 ? void 0 : `stderrTruncated: ${stderr.length > 2e3}`
+  ].filter((detail) => Boolean(detail));
+  return truncateCommandOutput(details.join("\n"), 2e3);
+}
+async function runInvestWikiCommand(command, args, options) {
+  try {
+    return await execa2(command, args, options);
+  } catch (error) {
+    throw new InvestWikiRuntimeError(
+      "COMMAND_FAILED",
+      commandFailureMessage2(error),
+      "invest_wiki.runner.run"
+    );
+  }
+}
+function createLocalRepoRunner(config) {
+  return {
+    kind: "local-repo",
+    async run(args, options) {
+      const cliPath = path.join(config.localRepo, "dist", "cli.js");
+      await assertFileExists(cliPath);
+      const result = await runInvestWikiCommand(
+        process.execPath,
+        [cliPath, ...args],
+        {
+          cwd: options.cwd,
+          shell: false,
+          reject: true
+        }
+      );
+      return {
+        stdout: truncateCommandOutput(result.stdout),
+        stderr: truncateCommandOutput(result.stderr)
+      };
+    }
+  };
+}
+function createPackageRunner(config) {
+  return {
+    kind: "package",
+    async run(args, options) {
+      const result = await runInvestWikiCommand(config.command, args, {
+        cwd: options.cwd,
+        shell: false,
+        reject: true
+      });
+      return {
+        stdout: truncateCommandOutput(result.stdout),
+        stderr: truncateCommandOutput(result.stderr)
+      };
+    }
+  };
+}
+function createInvestWikiRunner(config) {
+  if (config.mode === "local-repo") {
+    return createLocalRepoRunner(config);
+  }
+  if (config.mode === "package") {
+    return createPackageRunner(config);
+  }
+  return null;
+}
+function createInvestWikiRunnerFromOptions(options, env = process.env) {
+  return createInvestWikiRunner(resolveInvestWikiConfig(options, env));
+}
+
+// src/local-config.ts
+import { chmod, mkdir, readFile, writeFile } from "fs/promises";
+import os from "os";
+import path2 from "path";
+import { z } from "zod";
+import { DOSSIERX_CONFIG_DIR } from "@xdsjs/dossierx-workspace";
+var DaemonLocalConfigSchema = z.object({
+  machineId: z.string().uuid().optional(),
+  machineKey: z.string().startsWith("dx_machine_"),
+  serverUrl: z.string().min(1),
+  supabaseUrl: z.string().min(1),
+  supabaseAnonKey: z.string().min(1),
+  workspacePath: z.string().min(1),
+  investWikiMode: z.string().optional(),
+  investWikiLocalRepo: z.string().optional(),
+  investWikiCommand: z.string().optional(),
+  codexCommand: z.string().optional(),
+  codexModel: z.string().optional(),
+  codexSandbox: z.string().optional(),
+  localApiPort: z.number().int().positive().optional()
+});
+function expandHomePath(input) {
+  if (input === "~") {
+    return os.homedir();
+  }
+  if (input.startsWith("~/")) {
+    return path2.join(os.homedir(), input.slice(2));
+  }
+  return input;
+}
+function getDaemonConfigDir(env = process.env) {
+  return path2.resolve(
+    expandHomePath(env.DOSSIERX_CONFIG_DIR ?? DOSSIERX_CONFIG_DIR)
+  );
+}
+function daemonConfigPath(configDir = getDaemonConfigDir()) {
+  return path2.join(configDir, "config.json");
+}
+async function readDaemonLocalConfig(configDir = getDaemonConfigDir()) {
+  try {
+    return DaemonLocalConfigSchema.parse(
+      JSON.parse(await readFile(daemonConfigPath(configDir), "utf8"))
+    );
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+async function writeDaemonLocalConfig(config, configDir = getDaemonConfigDir()) {
+  const parsed = DaemonLocalConfigSchema.parse(config);
+  await mkdir(configDir, { recursive: true, mode: 448 });
+  const target = daemonConfigPath(configDir);
+  await writeFile(target, `${JSON.stringify(parsed, null, 2)}
+`, {
+    mode: 384
+  });
+  await chmod(target, 384);
+}
+
+// src/local-api/server.ts
+import { createServer } from "http";
+import { readFile as readFile3, realpath, stat } from "fs/promises";
+import path4 from "path";
+import { execa as execa3 } from "execa";
+import {
+  resolveInsideWorkspace as resolveInsideWorkspace2,
+  scanCompanyManifest
+} from "@xdsjs/dossierx-workspace";
+
+// src/task-archive.ts
+import { randomUUID } from "crypto";
+import { appendFile, mkdir as mkdir2, readFile as readFile2 } from "fs/promises";
+import path3 from "path";
+import { resolveInsideWorkspace } from "@xdsjs/dossierx-workspace";
+var TASK_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function assertTaskId(taskId) {
+  if (!TASK_ID_PATTERN.test(taskId)) {
+    throw new Error("Invalid task id");
+  }
+}
+function taskDirectory(workspaceRoot, taskId) {
+  assertTaskId(taskId);
+  return resolveInsideWorkspace(
+    workspaceRoot,
+    path3.posix.join(".dossierx", "tasks", taskId)
+  );
+}
+async function ensureTaskDirectory(workspaceRoot, taskId) {
+  const directory = taskDirectory(workspaceRoot, taskId);
+  await mkdir2(directory, { recursive: true });
+  return directory;
+}
+function parseEventLine(line) {
+  if (!line.trim()) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(line);
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function createTaskArchive(options) {
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  return {
+    async appendEvent(taskId, event) {
+      const directory = await ensureTaskDirectory(options.workspaceRoot, taskId);
+      const archivedEvent = {
+        id: randomUUID(),
+        task_id: taskId,
+        level: event.level,
+        message: event.message,
+        data: event.data,
+        created_at: now().toISOString()
+      };
+      await appendFile(
+        path3.join(directory, "events.jsonl"),
+        `${JSON.stringify(archivedEvent)}
+`,
+        "utf8"
+      );
+      return archivedEvent;
+    },
+    async appendRawOutput(taskId, stream, chunk) {
+      const directory = await ensureTaskDirectory(options.workspaceRoot, taskId);
+      await appendFile(path3.join(directory, `${stream}.log`), chunk, "utf8");
+    },
+    async listEvents(taskId) {
+      const directory = taskDirectory(options.workspaceRoot, taskId);
+      let content = "";
+      try {
+        content = await readFile2(path3.join(directory, "events.jsonl"), "utf8");
+      } catch (error) {
+        if (error.code === "ENOENT") {
+          return [];
+        }
+        throw error;
+      }
+      return content.split("\n").map(parseEventLine).filter((event) => event !== null);
+    }
+  };
+}
+
+// src/local-api/server.ts
+var DEFAULT_MAX_FILE_BYTES = 5 * 1024 * 1024;
+var ALLOWED_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".mdx", ".txt", ".json"]);
+var MARKETS = /* @__PURE__ */ new Set(["us", "hk", "cn"]);
+function json(response, status, body, origin) {
+  response.writeHead(status, {
+    "content-type": "application/json; charset=utf-8",
+    ...origin ? { "access-control-allow-origin": origin } : {},
+    "access-control-allow-methods": "GET, OPTIONS",
+    "access-control-allow-headers": "content-type",
+    vary: "Origin"
+  });
+  response.end(JSON.stringify(body));
+}
+function allowedOrigin(request, allowedOrigins) {
+  const origin = request.headers.origin;
+  if (!origin) {
+    return "";
+  }
+  return allowedOrigins.includes(origin) ? origin : null;
+}
+function requestUrl(request) {
+  return new URL(request.url ?? "/", "http://127.0.0.1");
+}
+async function readWorkspaceFile(options) {
+  const extension = path4.extname(options.relativePath).toLowerCase();
+  if (!ALLOWED_EXTENSIONS.has(extension)) {
+    throw new Error("Only markdown, text, and json files can be previewed");
+  }
+  const absolutePath = resolveInsideWorkspace2(
+    options.workspaceRoot,
+    options.relativePath
+  );
+  const stats = await stat(absolutePath);
+  if (!stats.isFile()) {
+    throw new Error("Path is not a file");
+  }
+  if (stats.size > options.maxFileBytes) {
+    throw new Error("File is too large to preview");
+  }
+  return {
+    path: options.relativePath,
+    content: await readFile3(absolutePath, "utf8"),
+    size: stats.size,
+    updatedAt: stats.mtime.toISOString()
+  };
+}
+async function readCompanyManifest(options) {
+  if (!MARKETS.has(options.market)) {
+    throw new Error("Invalid market");
+  }
+  return {
+    manifest: await scanCompanyManifest({
+      workspaceRoot: options.workspaceRoot,
+      ticker: options.ticker,
+      market: options.market
+    })
+  };
+}
+function uniqueProbes(probes) {
+  const seen = /* @__PURE__ */ new Set();
+  return probes.filter((probe) => {
+    const command = probe.command?.trim();
+    if (!command) {
+      return false;
+    }
+    const key = `${probe.source}:${command}`;
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    probe.command = command;
+    return true;
+  });
+}
+async function resolveCommand(command) {
+  const normalizedCommand = command.trim();
+  if (path4.isAbsolute(normalizedCommand)) {
+    return realpath(normalizedCommand).catch(() => normalizedCommand);
+  }
+  const result = await execa3("which", [normalizedCommand], {
+    stdin: "ignore",
+    reject: false,
+    timeout: 3e3
+  });
+  const resolved = result.stdout.trim().split("\n")[0];
+  if (!resolved || result.exitCode !== 0) {
+    return normalizedCommand;
+  }
+  return realpath(resolved).catch(() => resolved);
+}
+async function detectCodexCommand(probe) {
+  const command = probe.command?.trim();
+  if (!command) {
+    return null;
+  }
+  try {
+    const result = await execa3(command, ["--version"], {
+      stdin: "ignore",
+      timeout: 5e3,
+      reject: false
+    });
+    if (result.exitCode !== 0) {
+      return null;
+    }
+    const version = result.stdout.trim() || result.stderr.trim();
+    if (!version) {
+      return null;
+    }
+    return {
+      command,
+      version,
+      resolvedCommand: await resolveCommand(command),
+      source: probe.source,
+      recommended: probe.recommended ?? false
+    };
+  } catch {
+    return null;
+  }
+}
+async function detectCodexCommands(configuredCommand) {
+  const probes = uniqueProbes([
+    {
+      command: configuredCommand,
+      source: "configured",
+      recommended: true
+    },
+    {
+      command: process.env.DOSSIERX_CODEX_COMMAND,
+      source: "env",
+      recommended: true
+    },
+    {
+      command: "/opt/homebrew/bin/codex",
+      source: "homebrew",
+      recommended: true
+    },
+    {
+      command: "/Applications/Codex.app/Contents/Resources/codex",
+      source: "app"
+    },
+    {
+      command: "/usr/local/bin/codex",
+      source: "npm"
+    },
+    {
+      command: "codex",
+      source: "path"
+    }
+  ]);
+  const results = await Promise.all(probes.map(detectCodexCommand));
+  const candidates = results.filter(
+    (candidate) => candidate !== null
+  );
+  const seen = /* @__PURE__ */ new Set();
+  return candidates.filter((candidate) => {
+    const dedupeKey = candidate.resolvedCommand || candidate.command;
+    if (seen.has(dedupeKey)) {
+      return false;
+    }
+    seen.add(dedupeKey);
+    return true;
+  });
+}
+async function startWorkspaceReadServer(options) {
+  const host = options.host ?? "127.0.0.1";
+  const maxFileBytes = options.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES;
+  const taskArchive = options.taskArchive ?? createTaskArchive({ workspaceRoot: options.workspaceRoot });
+  const server = createServer((request, response) => {
+    void (async () => {
+      const origin = allowedOrigin(request, options.allowedOrigins);
+      if (origin === null) {
+        json(response, 403, { error: "Origin not allowed" });
+        return;
+      }
+      if (request.method === "OPTIONS") {
+        json(response, 204, {}, origin);
+        return;
+      }
+      const url = requestUrl(request);
+      if (request.method === "GET" && url.pathname === "/runtime/codex") {
+        json(
+          response,
+          200,
+          { candidates: await detectCodexCommands(options.codexCommand) },
+          origin
+        );
+        return;
+      }
+      if (request.method === "GET" && url.pathname === "/workspace/manifest") {
+        const ticker = url.searchParams.get("ticker");
+        const market = url.searchParams.get("market");
+        if (!ticker || !market) {
+          json(response, 400, { error: "Missing ticker or market" }, origin);
+          return;
+        }
+        try {
+          json(
+            response,
+            200,
+            await readCompanyManifest({
+              workspaceRoot: options.workspaceRoot,
+              ticker,
+              market
+            }),
+            origin
+          );
+        } catch (error) {
+          json(
+            response,
+            400,
+            {
+              error: error instanceof Error ? error.message : "Workspace manifest failed"
+            },
+            origin
+          );
+        }
+        return;
+      }
+      const taskEventsMatch = url.pathname.match(
+        /^\/tasks\/([^/]+)\/events$/
+      );
+      if (request.method === "GET" && taskEventsMatch) {
+        try {
+          json(
+            response,
+            200,
+            { events: await taskArchive.listEvents(taskEventsMatch[1] ?? "") },
+            origin
+          );
+        } catch (error) {
+          json(
+            response,
+            400,
+            {
+              error: error instanceof Error ? error.message : "Task event read failed"
+            },
+            origin
+          );
+        }
+        return;
+      }
+      if (request.method !== "GET" || url.pathname !== "/workspace/read") {
+        json(response, 404, { error: "Not found" }, origin);
+        return;
+      }
+      const relativePath = url.searchParams.get("path");
+      if (!relativePath) {
+        json(response, 400, { error: "Missing workspace-relative path" }, origin);
+        return;
+      }
+      try {
+        json(
+          response,
+          200,
+          await readWorkspaceFile({
+            workspaceRoot: options.workspaceRoot,
+            relativePath,
+            maxFileBytes
+          }),
+          origin
+        );
+      } catch (error) {
+        json(
+          response,
+          error instanceof Error && error.message.includes("large") ? 413 : 400,
+          { error: error instanceof Error ? error.message : "Read failed" },
+          origin
+        );
+      }
+    })();
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(options.port, host, () => {
+      server.off("error", reject);
+      resolve();
+    });
+  });
+  const address = server.address();
+  const port = typeof address === "object" && address ? address.port : options.port;
+  return {
+    url: `http://${host}:${port}`,
+    async close() {
+      await new Promise((resolve, reject) => {
+        server.close((error) => error ? reject(error) : resolve());
+      });
+    }
+  };
+}
+
+// src/loop.ts
+import { z as z2 } from "zod";
+import {
+  TaskEventInputSchema,
+  TaskSchema
+} from "@xdsjs/dossierx-shared";
+
+// src/errors.ts
+function failTaskError(error, code = "UNKNOWN", step) {
+  return {
+    error: {
+      code,
+      message: error instanceof Error ? error.message : String(error),
+      step,
+      recoverable: false
+    }
+  };
+}
+
+// src/executors/codex.ts
+import { readdir, stat as stat2 } from "fs/promises";
+import {
+  buildCompanyManifest,
+  companyManifestPath,
+  investWikiRoot,
+  resolveInsideWorkspace as resolveInsideWorkspace3
+} from "@xdsjs/dossierx-workspace";
+function isWorkspaceGuardError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  return [
+    "Workspace root must be absolute",
+    "Path must be relative to workspace",
+    "Path escapes workspace"
+  ].includes(error.message);
+}
+function workspacePath(workspaceRoot, relativePath, step) {
+  try {
+    return resolveInsideWorkspace3(workspaceRoot, relativePath);
+  } catch (error) {
+    if (isWorkspaceGuardError(error)) {
+      throw new CodexRuntimeError(
+        "WORKSPACE_ACCESS_DENIED",
+        error instanceof Error ? error.message : "Workspace path is not allowed",
+        step
+      );
+    }
+    throw error;
+  }
+}
+function requireRunner(context) {
+  if (!context.codex) {
+    throw new CodexRuntimeError(
+      "RUNTIME_NOT_FOUND",
+      "Codex runner is not configured",
+      "codex.runner.resolve"
+    );
+  }
+  return context.codex;
+}
+async function requireFile(filePath, step) {
+  try {
+    const fileStat = await stat2(filePath);
+    if (fileStat.isFile()) {
+      return;
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  throw new CodexRuntimeError(
+    "WORKSPACE_NOT_FOUND",
+    "Invest wiki vault is not initialized",
+    step
+  );
+}
+async function requireInitializedVault(workspaceRoot, ticker, step) {
+  const vaultRoot = workspacePath(workspaceRoot, investWikiRoot(ticker), step);
+  try {
+    const vaultStat = await stat2(vaultRoot);
+    if (!vaultStat.isDirectory()) {
+      throw new CodexRuntimeError(
+        "WORKSPACE_NOT_FOUND",
+        "Invest wiki vault is not a directory",
+        step
+      );
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+    throw new CodexRuntimeError(
+      "WORKSPACE_NOT_FOUND",
+      "Invest wiki vault does not exist",
+      step
+    );
+  }
+  await Promise.all([
+    requireFile(
+      workspacePath(
+        workspaceRoot,
+        `${investWikiRoot(ticker)}/.llm-wiki-invest/config.toml`,
+        step
+      ),
+      step
+    ),
+    requireFile(
+      workspacePath(workspaceRoot, `${investWikiRoot(ticker)}/AGENTS.md`, step),
+      step
+    ),
+    requireFile(
+      workspacePath(
+        workspaceRoot,
+        `${investWikiRoot(ticker)}/.agents/skills/invest-wiki-flow/SKILL.md`,
+        step
+      ),
+      step
+    )
+  ]).catch((error) => {
+    if (error.code === "ENOENT") {
+      throw new CodexRuntimeError(
+        "WORKSPACE_NOT_FOUND",
+        "Invest wiki vault is not initialized",
+        step
+      );
+    }
+    throw error;
+  });
+  return vaultRoot;
+}
+async function appendOutputEvent(context, message, output) {
+  await context.appendEvent({
+    level: "info",
+    message,
+    data: {
+      stdoutChars: output.stdout.length,
+      stderrChars: output.stderr.length,
+      stdoutBytes: Buffer.byteLength(output.stdout),
+      stderrBytes: Buffer.byteLength(output.stderr),
+      stdoutTruncated: output.stdout.length >= 2e3,
+      stderrTruncated: output.stderr.length >= 2e3
+    }
+  });
+}
+async function directoryHasFiles(root, relativePath) {
+  const directory = resolveInsideWorkspace3(root, relativePath);
+  let entries;
+  try {
+    entries = await readdir(directory, { withFileTypes: true });
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+  for (const entry of entries) {
+    if (entry.name.startsWith(".")) {
+      continue;
+    }
+    const childPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+    if (entry.isFile()) {
+      return true;
+    }
+    if (entry.isDirectory() && await directoryHasFiles(root, childPath)) {
+      return true;
+    }
+  }
+  return false;
+}
+async function assertProducedKnowledgeFiles(vaultRoot, step) {
+  const hasFiles = await directoryHasFiles(vaultRoot, "sources") || await directoryHasFiles(vaultRoot, "wiki");
+  if (hasFiles) {
+    return;
+  }
+  throw new CodexRuntimeError(
+    "COMMAND_FAILED",
+    "Codex invest-wiki flow produced no source or wiki files",
+    step
+  );
+}
+async function runCodexTask(task, context) {
+  const runner = requireRunner(context);
+  const ticker = task.payload.ticker;
+  const step = "codex.run_invest_wiki_flow";
+  const vaultRoot = await requireInitializedVault(
+    context.workspaceRoot,
+    ticker,
+    step
+  );
+  await context.appendEvent({
+    level: "info",
+    message: "Codex invest-wiki flow started",
+    data: { ticker, path: investWikiRoot(ticker) }
+  });
+  const output = await runner.runInvestWikiFlow(
+    {
+      vaultRoot,
+      ticker,
+      market: task.payload.market,
+      companyName: task.payload.companyName,
+      cik: task.payload.cik,
+      exchange: task.payload.exchange
+    },
+    {
+      onEvent: (event) => context.appendEvent(event),
+      onRawOutput: (stream, chunk) => context.appendRawOutput?.(stream, chunk)
+    }
+  );
+  await assertProducedKnowledgeFiles(vaultRoot, step);
+  await appendOutputEvent(context, "Codex invest-wiki flow completed", output);
+  const manifest = await buildCompanyManifest({
+    workspaceRoot: context.workspaceRoot,
+    ticker,
+    market: task.payload.market
+  });
+  return {
+    generatedFiles: [],
+    manifestPath: companyManifestPath(ticker),
+    manifest
+  };
+}
+
+// src/executors/investWiki.ts
+import { access as access2, mkdir as mkdir3, readFile as readFile4, stat as stat3, writeFile as writeFile2 } from "fs/promises";
+import path5 from "path";
+import {
+  buildCompanyManifest as buildCompanyManifest2,
+  companyManifestPath as companyManifestPath2,
+  investWikiConfigPath,
+  investWikiRoot as investWikiRoot2,
+  resolveInsideWorkspace as resolveInsideWorkspace4
+} from "@xdsjs/dossierx-workspace";
+async function exists(absolutePath) {
+  try {
+    await access2(absolutePath);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+function isWorkspaceGuardError2(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  return [
+    "Workspace root must be absolute",
+    "Path must be relative to workspace",
+    "Path escapes workspace"
+  ].includes(error.message);
+}
+function workspacePath2(workspaceRoot, relativePath, step) {
+  try {
+    return resolveInsideWorkspace4(workspaceRoot, relativePath);
+  } catch (error) {
+    if (isWorkspaceGuardError2(error)) {
+      throw new InvestWikiRuntimeError(
+        "WORKSPACE_ACCESS_DENIED",
+        error instanceof Error ? error.message : "Workspace path is not allowed",
+        step
+      );
+    }
+    throw error;
+  }
+}
+function requireRunner2(context) {
+  if (!context.investWiki) {
+    throw new InvestWikiRuntimeError(
+      "RUNTIME_NOT_FOUND",
+      "Invest wiki runner is not configured",
+      "invest_wiki.runner.resolve"
+    );
+  }
+  return context.investWiki;
+}
+async function requireVaultRoot(workspaceRoot, ticker, step) {
+  const vaultRoot = workspacePath2(workspaceRoot, investWikiRoot2(ticker), step);
+  try {
+    const vaultStat = await stat3(vaultRoot);
+    if (vaultStat.isDirectory()) {
+      return vaultRoot;
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  throw new InvestWikiRuntimeError(
+    "WORKSPACE_NOT_FOUND",
+    "Invest wiki vault does not exist",
+    step
+  );
+}
+async function appendOutputEvent2(context, message, output) {
+  const stdoutTruncated = output.stdout.length > 2e3;
+  const stderrTruncated = output.stderr.length > 2e3;
+  await context.appendEvent({
+    level: "info",
+    message,
+    data: {
+      stdoutChars: output.stdout.length,
+      stderrChars: output.stderr.length,
+      stdoutBytes: Buffer.byteLength(output.stdout),
+      stderrBytes: Buffer.byteLength(output.stderr),
+      stdoutTruncated,
+      stderrTruncated
+    }
+  });
+}
+function dossierInitArgs(payload) {
+  const args = [
+    "dossier",
+    "init",
+    "--market",
+    payload.market,
+    "--ticker",
+    payload.ticker,
+    "--company-name",
+    payload.companyName
+  ];
+  if (payload.cik) {
+    args.push("--cik", payload.cik);
+  }
+  if (payload.exchange) {
+    args.push("--exchange", payload.exchange);
+  }
+  return args;
+}
+function isMarket(value) {
+  return value === "us" || value === "hk" || value === "cn";
+}
+async function readManifestMarket(workspaceRoot, ticker) {
+  const manifestPath = workspacePath2(
+    workspaceRoot,
+    companyManifestPath2(ticker),
+    "invest_wiki.sync"
+  );
+  try {
+    const manifest = JSON.parse(await readFile4(manifestPath, "utf8"));
+    if (!isMarket(manifest.market)) {
+      throw new InvestWikiRuntimeError(
+        "VALIDATION_ERROR",
+        "Existing company manifest has missing or invalid market",
+        "invest_wiki.sync"
+      );
+    }
+    return manifest.market;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return "us";
+    }
+    if (error instanceof SyntaxError) {
+      throw new InvestWikiRuntimeError(
+        "VALIDATION_ERROR",
+        "Existing company manifest is not valid JSON",
+        "invest_wiki.sync"
+      );
+    }
+    throw error;
+  }
+}
+async function runInitCompanyVault(task, context) {
+  const runner = requireRunner2(context);
+  const ticker = task.payload.ticker;
+  const vaultRelativePath = investWikiRoot2(ticker);
+  const vaultRoot = workspacePath2(
+    context.workspaceRoot,
+    vaultRelativePath,
+    "invest_wiki.init_company_vault"
+  );
+  const markerRelativePath = investWikiConfigPath(ticker);
+  const markerPath = workspacePath2(
+    context.workspaceRoot,
+    markerRelativePath,
+    "invest_wiki.init_company_vault"
+  );
+  const dossierStatePath = workspacePath2(
+    context.workspaceRoot,
+    `${vaultRelativePath}/.llm-wiki-invest/dossier-state.json`,
+    "invest_wiki.init_company_vault"
+  );
+  await mkdir3(vaultRoot, { recursive: true });
+  await context.appendEvent({
+    level: "info",
+    message: "Initializing invest-wiki vault",
+    data: { ticker, path: vaultRelativePath }
+  });
+  if (!await exists(markerPath)) {
+    const output = await runner.run(["init"], { cwd: vaultRoot });
+    await appendOutputEvent2(context, "Invest wiki init completed", output);
+  }
+  if (!await exists(dossierStatePath)) {
+    const output = await runner.run(dossierInitArgs(task.payload), {
+      cwd: vaultRoot
+    });
+    await appendOutputEvent2(context, "Invest wiki dossier initialized", output);
+  }
+  const statusOutput = await runner.run(["dossier", "status"], { cwd: vaultRoot });
+  await appendOutputEvent2(context, "Invest wiki dossier status completed", statusOutput);
+  if (!await exists(markerPath)) {
+    await mkdir3(path5.dirname(markerPath), { recursive: true });
+    await writeFile2(markerPath, "# Created by dossierx-daemon\n");
+  }
+  const manifest = await buildCompanyManifest2({
+    workspaceRoot: context.workspaceRoot,
+    ticker,
+    market: task.payload.market
+  });
+  await context.appendEvent({
+    level: "info",
+    message: "Invest wiki company vault initialized",
+    data: { ticker }
+  });
+  return {
+    generatedFiles: [
+      vaultRelativePath,
+      markerRelativePath,
+      companyManifestPath2(ticker)
+    ],
+    manifestPath: companyManifestPath2(ticker),
+    manifest
+  };
+}
+async function runStatus(task, context) {
+  const runner = requireRunner2(context);
+  const ticker = task.payload.ticker;
+  const vaultRoot = await requireVaultRoot(
+    context.workspaceRoot,
+    ticker,
+    "invest_wiki.status"
+  );
+  const statusOutput = await runner.run(["status"], { cwd: vaultRoot });
+  await appendOutputEvent2(context, "Invest wiki status completed", statusOutput);
+  const dossierStatusOutput = await runner.run(["dossier", "status"], {
+    cwd: vaultRoot
+  });
+  await appendOutputEvent2(
+    context,
+    "Invest wiki dossier status completed",
+    dossierStatusOutput
+  );
+  return {
+    generatedFiles: [],
+    manifestPath: companyManifestPath2(ticker)
+  };
+}
+async function runSync(task, context) {
+  const runner = requireRunner2(context);
+  const ticker = task.payload.ticker;
+  const vaultRoot = await requireVaultRoot(
+    context.workspaceRoot,
+    ticker,
+    "invest_wiki.sync"
+  );
+  const market = await readManifestMarket(context.workspaceRoot, ticker);
+  const args = task.payload.dryRun ? ["sync", "--dry-run"] : ["sync"];
+  const output = await runner.run(args, { cwd: vaultRoot });
+  await appendOutputEvent2(context, "Invest wiki sync completed", output);
+  const manifest = await buildCompanyManifest2({
+    workspaceRoot: context.workspaceRoot,
+    ticker,
+    market
+  });
+  return {
+    generatedFiles: [],
+    manifestPath: companyManifestPath2(ticker),
+    manifest
+  };
+}
+async function runInvestWikiTask(task, context) {
+  if (task.type === "invest_wiki.init_company_vault") {
+    return runInitCompanyVault(task, context);
+  }
+  if (task.type === "invest_wiki.status") {
+    return runStatus(task, context);
+  }
+  if (task.type === "invest_wiki.sync") {
+    return runSync(task, context);
+  }
+  throw new InvestWikiRuntimeError(
+    "VALIDATION_ERROR",
+    "Unsupported invest wiki task type",
+    "invest_wiki.executor"
+  );
+}
+
+// src/executors/mockWriteCompanyReport.ts
+import { mkdir as mkdir4, writeFile as writeFile3 } from "fs/promises";
+import path6 from "path";
+import {
+  buildCompanyManifest as buildCompanyManifest3,
+  companyManifestPath as companyManifestPath3,
+  companyRoot,
+  resolveInsideWorkspace as resolveInsideWorkspace5,
+  rightBusinessPath,
+  rightPeoplePath,
+  rightPricePath
+} from "@xdsjs/dossierx-workspace";
+var rightBusiness = (ticker) => `# Right Business - ${ticker}
+
+> Mock output generated by dossierx-daemon.
+
+## One-line conclusion
+
+This is a placeholder right-business analysis for ${ticker}.
+
+## Evidence
+
+- No real source used in MVP mock executor.
+`;
+var rightPeople = (ticker) => `# Right People - ${ticker}
+
+> Mock output generated by dossierx-daemon.
+
+## One-line conclusion
+
+This is a placeholder right-people analysis for ${ticker}.
+`;
+var rightPrice = (ticker) => `# Right Price - ${ticker}
+
+> Mock output generated by dossierx-daemon.
+
+## One-line conclusion
+
+This is a placeholder right-price analysis for ${ticker}.
+`;
+async function writeWorkspaceFile(context, relativePath, content) {
+  const absolutePath = resolveInsideWorkspace5(context.workspaceRoot, relativePath);
+  await mkdir4(path6.dirname(absolutePath), { recursive: true });
+  if (!context.dryRun) {
+    await writeFile3(absolutePath, content);
+  }
+}
+async function runMockWriteCompanyReport(task, context) {
+  const ticker = task.payload.ticker;
+  const generatedFiles = [
+    rightBusinessPath(ticker),
+    rightPeoplePath(ticker),
+    rightPricePath(ticker)
+  ];
+  await context.appendEvent({
+    level: "info",
+    message: "Creating company directory",
+    data: { ticker }
+  });
+  await mkdir4(resolveInsideWorkspace5(context.workspaceRoot, companyRoot(ticker)), {
+    recursive: true
+  });
+  await context.appendEvent({
+    level: "info",
+    message: "Writing right-business.md",
+    data: { path: rightBusinessPath(ticker) }
+  });
+  await writeWorkspaceFile(context, rightBusinessPath(ticker), rightBusiness(ticker));
+  await context.appendEvent({
+    level: "info",
+    message: "Writing right-people.md",
+    data: { path: rightPeoplePath(ticker) }
+  });
+  await writeWorkspaceFile(context, rightPeoplePath(ticker), rightPeople(ticker));
+  await context.appendEvent({
+    level: "info",
+    message: "Writing right-price.md",
+    data: { path: rightPricePath(ticker) }
+  });
+  await writeWorkspaceFile(context, rightPricePath(ticker), rightPrice(ticker));
+  await context.appendEvent({
+    level: "info",
+    message: "Generating manifest.json",
+    data: { path: companyManifestPath3(ticker) }
+  });
+  let manifest;
+  if (!context.dryRun) {
+    manifest = await buildCompanyManifest3({
+      workspaceRoot: context.workspaceRoot,
+      ticker,
+      market: task.payload.market
+    });
+  }
+  await context.appendEvent({
+    level: "info",
+    message: "Mock company report completed",
+    data: { ticker }
+  });
+  return {
+    generatedFiles: [...generatedFiles, companyManifestPath3(ticker)],
+    manifestPath: companyManifestPath3(ticker),
+    manifest
+  };
+}
+
+// src/executors/index.ts
+function getExecutor(task) {
+  if (task.type.startsWith("codex.")) {
+    return runCodexTask;
+  }
+  if (task.type.startsWith("invest_wiki.")) {
+    return runInvestWikiTask;
+  }
+  if (task.type === "mock.write_company_report") {
+    return runMockWriteCompanyReport;
+  }
+  return null;
+}
+
+// src/loop.ts
+function taskIdFromUnknown(value) {
+  if (!value || typeof value !== "object" || !("id" in value)) {
+    return null;
+  }
+  const parsed = z2.string().uuid().safeParse(value.id);
+  return parsed.success ? parsed.data : null;
+}
+async function appendEvent(ctx, taskId, message) {
+  await appendLocalEvent(ctx, taskId, { level: "info", message, data: {} });
+}
+async function appendLocalEvent(ctx, taskId, event) {
+  if (!ctx.taskArchive) {
+    return;
+  }
+  try {
+    await ctx.taskArchive.appendEvent(taskId, event);
+  } catch (error) {
+    ctx.logger.warn({ err: error, taskId }, "failed to archive task event");
+  }
+}
+async function appendLocalRawOutput(ctx, taskId, stream, chunk) {
+  if (!ctx.taskArchive) {
+    return;
+  }
+  try {
+    await ctx.taskArchive.appendRawOutput(taskId, stream, chunk);
+  } catch (error) {
+    ctx.logger.warn({ err: error, taskId }, "failed to archive raw task output");
+  }
+}
+function codexRunnerForTask(ctx, agent) {
+  if (!agent || agent.runtime !== "codex_cli") {
+    return ctx.codex;
+  }
+  const codexCommand = agent.config.codexCommand === "codex" ? ctx.codexOptions?.codexCommand ?? agent.config.codexCommand : agent.config.codexCommand;
+  return createCodexRunnerFromOptions({
+    codexCommand,
+    codexModel: agent.model,
+    codexSandbox: agent.config.codexSandbox
+  });
+}
+async function runTask(ctx, task, agent) {
+  const executor = getExecutor(task);
+  if (!executor) {
+    await ctx.api.failTask(task.id, {
+      error: {
+        code: "VALIDATION_ERROR",
+        message: `Unsupported task type: ${task.type}`,
+        step: "executor.lookup",
+        recoverable: false
+      }
+    });
+    return;
+  }
+  await appendEvent(ctx, task.id, "Task claimed");
+  try {
+    const result = await executor(task, {
+      workspaceRoot: ctx.workspaceRoot,
+      dryRun: ctx.dryRun,
+      codex: codexRunnerForTask(ctx, agent),
+      investWiki: ctx.investWiki,
+      appendEvent: async (event) => {
+        await appendLocalEvent(ctx, task.id, TaskEventInputSchema.parse(event));
+      },
+      appendRawOutput: async (stream, chunk) => {
+        await appendLocalRawOutput(ctx, task.id, stream, chunk);
+      }
+    });
+    await appendEvent(ctx, task.id, "Task completed");
+    await ctx.api.completeTask(task.id, { result });
+  } catch (error) {
+    if (error instanceof InvestWikiRuntimeError) {
+      await appendLocalEvent(ctx, task.id, {
+        level: "error",
+        message: error.message,
+        data: { code: error.code, step: error.step }
+      });
+      await ctx.api.failTask(task.id, {
+        error: {
+          code: error.code,
+          message: error.message,
+          step: error.step,
+          recoverable: false
+        }
+      });
+      return;
+    }
+    if (error instanceof CodexRuntimeError) {
+      await appendLocalEvent(ctx, task.id, {
+        level: "error",
+        message: error.message,
+        data: { code: error.code, step: error.step }
+      });
+      await ctx.api.failTask(task.id, {
+        error: {
+          code: error.code,
+          message: error.message,
+          step: error.step,
+          recoverable: false
+        }
+      });
+      return;
+    }
+    await appendLocalEvent(ctx, task.id, {
+      level: "error",
+      message: error instanceof Error ? error.message : "Task failed",
+      data: { code: "UNKNOWN", step: "executor" }
+    });
+    await ctx.api.failTask(task.id, failTaskError(error, "UNKNOWN", "executor"));
+  }
+}
+async function claimAndRunClaimedTask(ctx) {
+  const response = await ctx.api.claimTask({
+    machineId: ctx.machineId,
+    maxTasks: 1
+  });
+  if (!response.task) {
+    return;
+  }
+  const parsedTask = TaskSchema.safeParse(response.task);
+  if (!parsedTask.success) {
+    const taskId = taskIdFromUnknown(response.task);
+    if (taskId) {
+      await ctx.api.failTask(taskId, {
+        error: {
+          code: "VALIDATION_ERROR",
+          message: "Claimed task payload failed schema validation",
+          step: "task.validation",
+          recoverable: false
+        }
+      });
+    }
+    return;
+  }
+  await runTask(ctx, parsedTask.data, response.agent ?? null);
+}
+async function claimAndRunOne(ctx) {
+  if (ctx.state.running) {
+    ctx.state.pending = true;
+    return;
+  }
+  ctx.state.running = true;
+  try {
+    do {
+      ctx.state.pending = false;
+      await claimAndRunClaimedTask(ctx);
+    } while (ctx.state.pending);
+  } finally {
+    ctx.state.running = false;
+  }
+}
+function startPollingClaimLoop(ctx, intervalMs) {
+  return setInterval(() => {
+    void claimAndRunOne(ctx).catch((error) => {
+      ctx.logger.warn({ err: error }, "fallback claim failed");
+    });
+  }, intervalMs);
+}
+
+// src/logger.ts
+import pino from "pino";
+function createLogger(level = "info", stream) {
+  return pino(
+    {
+      level,
+      redact: {
+        paths: [
+          "machineKey",
+          "machine_key",
+          "authorization",
+          "Authorization",
+          "headers.authorization"
+        ],
+        censor: "[redacted]"
+      }
+    },
+    stream
+  );
+}
+
+// src/runtime/detect.ts
+import { execa as execa4 } from "execa";
+async function commandResponds(command, args = ["--version"]) {
+  try {
+    await execa4(command, args, {
+      reject: true,
+      timeout: 2e3,
+      stdout: "ignore",
+      stderr: "ignore"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function detectCapabilities() {
+  const [git, python3, python, investWikiRuntime, codex, claude] = await Promise.all([
+    commandResponds("git"),
+    commandResponds("python3"),
+    commandResponds("python"),
+    commandResponds("invest-wiki-runtime"),
+    commandResponds("codex"),
+    commandResponds("claude")
+  ]);
+  return {
+    git,
+    node: true,
+    python: python3 || python,
+    investWikiRuntime,
+    codex,
+    claude
+  };
+}
+
+// src/realtime/client.ts
+import { createClient } from "@supabase/supabase-js";
+import {
+  RealtimeEventSchema
+} from "@xdsjs/dossierx-shared";
+function normalizeBroadcast(message) {
+  const value = message;
+  if (value.payload && typeof value.payload === "object" && "event" in value.payload) {
+    return value.payload;
+  }
+  return {
+    event: value.event,
+    payload: value.payload
+  };
+}
+async function waitForSubscribed(channel) {
+  await new Promise((resolve, reject) => {
+    const timeout = setTimeout(
+      () => reject(new Error("Realtime subscribe timeout")),
+      5e3
+    );
+    channel.subscribe((status) => {
+      if (status === "SUBSCRIBED") {
+        clearTimeout(timeout);
+        resolve();
+      }
+      if (status === "CHANNEL_ERROR" || status === "TIMED_OUT") {
+        clearTimeout(timeout);
+        reject(new Error(`Realtime subscribe failed: ${status}`));
+      }
+    });
+  });
+}
+async function subscribeToTaskAvailable(options, onEvent, onInvalidEvent) {
+  const client = createClient(options.supabaseUrl, options.supabaseAnonKey, {
+    auth: {
+      persistSession: false,
+      autoRefreshToken: false
+    }
+  });
+  const channel = client.channel(options.topic, {
+    config: {
+      private: options.privateChannel
+    }
+  });
+  channel.on("broadcast", { event: "task_available" }, async (message) => {
+    const parsed = RealtimeEventSchema.safeParse(normalizeBroadcast(message));
+    if (!parsed.success) {
+      onInvalidEvent?.(message);
+      return;
+    }
+    await onEvent(parsed.data);
+  });
+  channel.on("broadcast", { event: "task_cancelled" }, async (message) => {
+    const parsed = RealtimeEventSchema.safeParse(normalizeBroadcast(message));
+    if (!parsed.success) {
+      onInvalidEvent?.(message);
+      return;
+    }
+    await onEvent(parsed.data);
+  });
+  await waitForSubscribed(channel);
+  return {
+    async unsubscribe() {
+      await client.removeChannel(channel);
+    }
+  };
+}
+
+// src/service.ts
+import { mkdir as mkdir5, unlink, writeFile as writeFile4 } from "fs/promises";
+import os2 from "os";
+import path7 from "path";
+var LAUNCH_AGENT_LABEL = "com.xdsjs.dossierx-daemon";
+function xmlEscape(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+function shellQuote(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function launchAgentsDir() {
+  return path7.join(os2.homedir(), "Library", "LaunchAgents");
+}
+function launchAgentPlistPath(label = LAUNCH_AGENT_LABEL, dir = launchAgentsDir()) {
+  return path7.join(dir, `${label}.plist`);
+}
+function resolveDaemonProgramArguments(input) {
+  if (input.daemonCommand?.trim()) {
+    return ["/bin/zsh", "-lc", input.daemonCommand.trim()];
+  }
+  const argv = input.argv ?? process.argv;
+  const entry = argv[1];
+  if (!entry) {
+    throw new Error("Unable to resolve daemon entrypoint for LaunchAgent");
+  }
+  if (path7.extname(entry) === ".ts") {
+    throw new Error(
+      "LaunchAgent cannot run a TypeScript daemon entrypoint directly; pass --daemon-command when installing from source"
+    );
+  }
+  return [
+    input.execPath ?? process.execPath,
+    path7.resolve(entry),
+    "--log-level",
+    input.logLevel ?? "info"
+  ];
+}
+function buildLaunchAgentPlist(input) {
+  const args = input.programArguments.map((arg) => `    <string>${xmlEscape(arg)}</string>`).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${xmlEscape(input.label)}</string>
+  <key>ProgramArguments</key>
+  <array>
+${args}
+  </array>
+  <key>WorkingDirectory</key>
+  <string>${xmlEscape(input.workingDirectory)}</string>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>DOSSIERX_CONFIG_DIR</key>
+    <string>${xmlEscape(input.configDir)}</string>
+  </dict>
+  <key>StandardOutPath</key>
+  <string>${xmlEscape(input.stdoutPath)}</string>
+  <key>StandardErrorPath</key>
+  <string>${xmlEscape(input.stderrPath)}</string>
+</dict>
+</plist>
+`;
+}
+function hasRuntimeOption(options) {
+  return Object.values(options).some((value) => value !== void 0);
+}
+function runtimeOptionsFrom(input) {
+  return {
+    investWikiMode: input.investWikiMode,
+    investWikiLocalRepo: input.investWikiLocalRepo,
+    investWikiCommand: input.investWikiCommand,
+    codexCommand: input.codexCommand,
+    codexModel: input.codexModel,
+    codexSandbox: input.codexSandbox,
+    localApiPort: input.localApiPort
+  };
+}
+async function installLaunchAgent(options = {}) {
+  if (process.platform !== "darwin") {
+    throw new Error("DossierX LaunchAgent service is only supported on macOS");
+  }
+  const label = options.label ?? LAUNCH_AGENT_LABEL;
+  const configDir = path7.resolve(
+    expandHomePath(options.configDir ?? getDaemonConfigDir())
+  );
+  const config = await readDaemonLocalConfig(configDir);
+  if (!config) {
+    throw new Error(
+      `Missing local daemon config at ${daemonConfigPath(configDir)}. Run the generated daemon command once before installing the service.`
+    );
+  }
+  const runtimeOptions = runtimeOptionsFrom(options);
+  if (hasRuntimeOption(runtimeOptions)) {
+    await writeDaemonLocalConfig(
+      {
+        ...config,
+        ...runtimeOptions
+      },
+      configDir
+    );
+  }
+  const plistPath = launchAgentPlistPath(label, options.launchAgentsDir);
+  const stdoutPath = path7.join(configDir, "daemon.out.log");
+  const stderrPath = path7.join(configDir, "daemon.err.log");
+  const uid = typeof process.getuid === "function" ? process.getuid() : "<uid>";
+  const programArguments = resolveDaemonProgramArguments({
+    daemonCommand: options.daemonCommand,
+    logLevel: options.logLevel,
+    argv: options.argv,
+    execPath: options.execPath
+  });
+  await mkdir5(path7.dirname(plistPath), { recursive: true });
+  await mkdir5(configDir, { recursive: true, mode: 448 });
+  await writeFile4(
+    plistPath,
+    buildLaunchAgentPlist({
+      label,
+      programArguments,
+      configDir,
+      workingDirectory: os2.homedir(),
+      stdoutPath,
+      stderrPath
+    }),
+    { mode: 420 }
+  );
+  return {
+    label,
+    plistPath,
+    stdoutPath,
+    stderrPath,
+    loadCommand: `launchctl bootstrap gui/${uid} ${shellQuote(plistPath)} && launchctl kickstart -k gui/${uid}/${label}`,
+    unloadCommand: `launchctl bootout gui/${uid} ${shellQuote(plistPath)}`
+  };
+}
+async function uninstallLaunchAgent(options = {}) {
+  const label = options.label ?? LAUNCH_AGENT_LABEL;
+  const plistPath = launchAgentPlistPath(label, options.launchAgentsDir);
+  const uid = typeof process.getuid === "function" ? process.getuid() : "<uid>";
+  try {
+    await unlink(plistPath);
+  } catch (error) {
+    if (!error || typeof error !== "object" || !("code" in error) || error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  return {
+    label,
+    plistPath,
+    unloadCommand: `launchctl bootout gui/${uid} ${shellQuote(plistPath)}`
+  };
+}
+
+// src/cli.ts
+async function assertWorkspaceExists(workspace) {
+  const stats = await stat4(workspace);
+  if (!stats.isDirectory()) {
+    throw new Error("Workspace path is not a directory");
+  }
+}
+var DOSSIERX_DEFAULT_LOCAL_API_PORT = 48731;
+function parsePort(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const port = typeof value === "number" ? value : Number(value);
+  if (!Number.isInteger(port) || port <= 0 || port > 65535) {
+    throw new Error("Local API port must be an integer from 1 to 65535");
+  }
+  return port;
+}
+function originFromUrl(value) {
+  try {
+    return new URL(value).origin;
+  } catch {
+    return null;
+  }
+}
+function localApiAllowedOrigins(serverUrl) {
+  return Array.from(
+    new Set(
+      [
+        originFromUrl(serverUrl),
+        "http://localhost:3000",
+        "http://127.0.0.1:3000",
+        ...(process.env.DOSSIERX_LOCAL_API_ALLOWED_ORIGINS ?? "").split(",").map((origin) => origin.trim()).filter(Boolean)
+      ].filter((origin) => Boolean(origin))
+    )
+  );
+}
+function buildProgram() {
+  const program = new Command().name("dossierx-daemon").description("DossierX local task daemon").option("--server-url <url>").option("--supabase-url <url>").option("--supabase-anon-key <key>").option("--machine-key <key>").option("--workspace <path>").option("--log-level <level>", "log level", "info").option("--once", "claim once and exit").option("--no-realtime", "disable Supabase Realtime subscription").option("--dry-run", "run without writing files").option("--invest-wiki-mode <mode>", "invest wiki runner mode: local-repo or package").option("--invest-wiki-local-repo <path>", "local llm-wiki-invest repo path").option(
+    "--invest-wiki-command <command>",
+    "installed llm-wiki-invest command"
+  ).option("--codex-command <command>", "installed Codex CLI command").option("--codex-model <model>", "Codex model override for exec mode").option(
+    "--codex-sandbox <mode>",
+    "Codex sandbox mode: workspace-write or danger-full-access"
+  ).option("--local-api-port <port>", "local workspace preview API port").option("--no-local-api", "disable local workspace preview API").action(async (options) => {
+    await runDaemon(options);
+  });
+  const service = program.command("service").description("Manage the macOS LaunchAgent for dossierx-daemon");
+  service.command("install").description("Write a macOS LaunchAgent plist for persistent daemon runs").option("--label <label>", "LaunchAgent label").option("--daemon-command <command>", "custom command used by launchd").option("--log-level <level>", "daemon log level", "info").option("--invest-wiki-mode <mode>", "invest wiki runner mode").option("--invest-wiki-local-repo <path>", "local llm-wiki-invest repo path").option("--invest-wiki-command <command>", "installed llm-wiki-invest command").option("--codex-command <command>", "installed Codex CLI command").option("--codex-model <model>", "Codex model override for exec mode").option("--codex-sandbox <mode>", "Codex sandbox mode").option("--local-api-port <port>", "local workspace preview API port").action(async (options) => {
+    const result = await installLaunchAgent({
+      ...options,
+      localApiPort: parsePort(options.localApiPort)
+    });
+    console.log(`LaunchAgent written: ${result.plistPath}`);
+    console.log(`Start: ${result.loadCommand}`);
+    console.log(`Stop: ${result.unloadCommand}`);
+    console.log(`Logs: ${result.stdoutPath}`);
+    console.log(`Errors: ${result.stderrPath}`);
+  });
+  service.command("uninstall").description("Remove the macOS LaunchAgent plist").option("--label <label>", "LaunchAgent label").action(async (options) => {
+    const result = await uninstallLaunchAgent(options);
+    console.log(`LaunchAgent removed: ${result.plistPath}`);
+    console.log(`If it is loaded, stop it first or now with: ${result.unloadCommand}`);
+  });
+  return program;
+}
+async function runDaemon(options) {
+  const logger = createLogger(options.logLevel);
+  const localConfig = await readDaemonLocalConfig();
+  const serverUrl = options.serverUrl ?? localConfig?.serverUrl;
+  const supabaseUrl = options.supabaseUrl ?? localConfig?.supabaseUrl;
+  const supabaseAnonKey = options.supabaseAnonKey ?? localConfig?.supabaseAnonKey;
+  const machineKey = options.machineKey ?? localConfig?.machineKey;
+  const workspacePath3 = options.workspace ?? localConfig?.workspacePath ?? DOSSIERX_DEFAULT_WORKSPACE_PATH;
+  const runtimeOptions = {
+    ...options,
+    investWikiMode: options.investWikiMode ?? localConfig?.investWikiMode,
+    investWikiLocalRepo: options.investWikiLocalRepo ?? localConfig?.investWikiLocalRepo,
+    investWikiCommand: options.investWikiCommand ?? localConfig?.investWikiCommand,
+    codexCommand: options.codexCommand ?? localConfig?.codexCommand,
+    codexModel: options.codexModel ?? localConfig?.codexModel,
+    codexSandbox: options.codexSandbox ?? localConfig?.codexSandbox,
+    localApiPort: parsePort(options.localApiPort) ?? localConfig?.localApiPort ?? parsePort(process.env.DOSSIERX_LOCAL_API_PORT) ?? DOSSIERX_DEFAULT_LOCAL_API_PORT
+  };
+  if (!serverUrl || !supabaseUrl || !supabaseAnonKey || !machineKey) {
+    throw new Error(
+      "Missing daemon connection config. Run the generated daemon command from DossierX first."
+    );
+  }
+  const workspaceRoot = path8.resolve(expandHomePath(workspacePath3));
+  await assertWorkspaceExists(workspaceRoot);
+  const capabilities = await detectCapabilities();
+  const investWiki = createInvestWikiRunnerFromOptions(runtimeOptions);
+  const codex = createCodexRunnerFromOptions(runtimeOptions);
+  const taskArchive = createTaskArchive({ workspaceRoot });
+  const api = new ApiClient({
+    serverUrl,
+    machineKey
+  });
+  const bootstrap = await api.bootstrap({
+    hostname: os3.hostname(),
+    os: `${os3.platform()} ${os3.release()}`,
+    workspacePath: workspaceRoot,
+    daemonVersion: "0.1.0",
+    capabilities
+  });
+  await writeDaemonLocalConfig({
+    machineId: bootstrap.machineId,
+    machineKey,
+    serverUrl,
+    supabaseUrl,
+    supabaseAnonKey,
+    workspacePath: workspacePath3,
+    investWikiMode: runtimeOptions.investWikiMode,
+    investWikiLocalRepo: runtimeOptions.investWikiLocalRepo,
+    investWikiCommand: runtimeOptions.investWikiCommand,
+    codexCommand: runtimeOptions.codexCommand,
+    codexModel: runtimeOptions.codexModel,
+    codexSandbox: runtimeOptions.codexSandbox,
+    localApiPort: runtimeOptions.localApiPort
+  });
+  const state = { running: false, pending: false };
+  const ctx = {
+    api,
+    machineId: bootstrap.machineId,
+    workspaceRoot,
+    logger,
+    state,
+    dryRun: options.dryRun,
+    codex,
+    codexOptions: runtimeOptions,
+    investWiki,
+    taskArchive
+  };
+  async function heartbeat(status) {
+    await api.heartbeat({
+      machineId: bootstrap.machineId,
+      workspacePath: workspaceRoot,
+      status,
+      capabilities
+    });
+  }
+  await heartbeat("idle");
+  const localApiServer = options.once || options.localApi === false ? null : await startWorkspaceReadServer({
+    workspaceRoot,
+    port: runtimeOptions.localApiPort,
+    allowedOrigins: localApiAllowedOrigins(serverUrl),
+    codexCommand: runtimeOptions.codexCommand,
+    taskArchive
+  }).catch((error) => {
+    logger.warn({ err: error }, "local workspace preview API unavailable");
+    return null;
+  });
+  if (localApiServer) {
+    logger.info({ url: localApiServer.url }, "local workspace preview API ready");
+  }
+  const heartbeatTimer = options.once ? null : setInterval(() => {
+    void heartbeat(state.running ? "running" : "idle").catch((error) => {
+      logger.warn({ err: error }, "heartbeat failed");
+    });
+  }, 15e3);
+  const pollingTimer = options.once ? null : startPollingClaimLoop(ctx, bootstrap.polling.fallbackIntervalMs);
+  const subscription = options.realtime === false ? null : await subscribeToTaskAvailable(
+    {
+      supabaseUrl,
+      supabaseAnonKey,
+      topic: bootstrap.realtime.topic,
+      privateChannel: bootstrap.realtime.private
+    },
+    async (event) => {
+      if (event.event === "task_available") {
+        await claimAndRunOne(ctx);
+      }
+    },
+    (event) => logger.debug({ event }, "ignored invalid realtime event")
+  );
+  await claimAndRunOne(ctx);
+  if (options.once) {
+    if (heartbeatTimer) {
+      clearInterval(heartbeatTimer);
+    }
+    if (pollingTimer) {
+      clearInterval(pollingTimer);
+    }
+    await localApiServer?.close();
+    await subscription?.unsubscribe();
+    return;
+  }
+  await new Promise(() => void 0);
+}
+async function runCli(argv = process.argv) {
+  await buildProgram().parseAsync(argv);
+}
+
+// src/index.ts
+runCli().catch((error) => {
+  createLogger("error").error({ err: error }, "dossierx-daemon failed");
+  process.exitCode = 1;
+});