@xdsjs/dossierx-daemon 0.1.3 → 0.1.4

package/dist/index.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { mkdir as mkdir6, stat as stat4 } from "fs/promises";
+import { mkdir as mkdir7, stat as stat4 } from "fs/promises";
 import os3 from "os";
-import path9 from "path";
+import path10 from "path";
 import { Command } from "commander";
 import { DOSSIERX_DEFAULT_WORKSPACE_PATH } from "@xdsjs/dossierx-workspace";
 
@@ -30,8 +30,8 @@ var ApiClient = class {
     this.machineKey = options.machineKey;
     this.fetchImpl = options.fetchImpl ?? fetch;
   }
-  async post(path10, body, schema) {
-    const response = await this.fetchImpl(`${this.serverUrl}${path10}`, {
+  async post(path11, body, schema) {
+    const response = await this.fetchImpl(`${this.serverUrl}${path11}`, {
       method: "POST",
       headers: {
         authorization: `Bearer ${this.machineKey}`,
@@ -738,6 +738,7 @@ import { readFile as readFile3, realpath, stat } from "fs/promises";
 import path5 from "path";
 import { execa as execa3 } from "execa";
 import {
+  readCoverageContractBundle,
   resolveInsideWorkspace as resolveInsideWorkspace2,
   scanCompanyManifest
 } from "@xdsjs/dossierx-workspace";
@@ -819,7 +820,7 @@ function createTaskArchive(options) {
 
 // src/version.ts
 var DAEMON_PACKAGE_NAME = "@xdsjs/dossierx-daemon";
-var DAEMON_VERSION = "0.1.2";
+var DAEMON_VERSION = "0.1.4";
 
 // src/local-api/server.ts
 var DEFAULT_MAX_FILE_BYTES = 5 * 1024 * 1024;
@@ -1191,6 +1192,34 @@ async function startWorkspaceReadServer(options) {
         }
         return;
       }
+      if (request.method === "GET" && url.pathname === "/coverage/bundle") {
+        const bundlePath = url.searchParams.get("path");
+        if (!bundlePath) {
+          json(response, 400, { error: "Missing coverage bundle path" }, origin);
+          return;
+        }
+        try {
+          json(
+            response,
+            200,
+            await readCoverageContractBundle({
+              workspaceRoot: options.workspaceRoot,
+              bundlePath
+            }),
+            origin
+          );
+        } catch (error) {
+          json(
+            response,
+            400,
+            {
+              error: error instanceof Error ? error.message : "Coverage bundle read failed"
+            },
+            origin
+          );
+        }
+        return;
+      }
       if (request.method !== "GET" || url.pathname !== "/workspace/read") {
         json(response, 404, { error: "Not found" }, origin);
         return;
@@ -1460,20 +1489,364 @@ async function runCodexTask(task, context) {
   });
   return {
     generatedFiles: [],
+    blockingReasons: [],
     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";
+// src/executors/financialReports.ts
+import { createHash } from "crypto";
+import { mkdir as mkdir3, readFile as readFile4, writeFile as writeFile2 } from "fs/promises";
 import path6 from "path";
+import {
+  FinancialReportManifestSchema,
+  assessReportCoverage,
+  downloadCninfoReports,
+  downloadSecReports,
+  primaryMarket,
+  primaryTicker,
+  runNotebookLmFinancialReportsIngest
+} from "@xdsjs/dossier-financial-reports";
 import {
   buildCompanyManifest as buildCompanyManifest2,
   companyManifestPath as companyManifestPath2,
+  financialReportsIndexPath,
+  resolveInsideWorkspace as resolveInsideWorkspace4
+} from "@xdsjs/dossierx-workspace";
+var FinancialReportsRuntimeError = class extends Error {
+  code;
+  step;
+  constructor(code, message, step) {
+    super(message);
+    this.name = "FinancialReportsRuntimeError";
+    this.code = code;
+    this.step = step;
+  }
+};
+function defaultFetch() {
+  return async (url, init) => fetch(url, init);
+}
+function defaultRenderHtmlToPdf() {
+  return async () => {
+    throw new FinancialReportsRuntimeError(
+      "RUNTIME_NOT_FOUND",
+      "SEC HTML-to-PDF renderer is not configured",
+      "financial_reports.render_html_to_pdf"
+    );
+  };
+}
+function requireNotebookLmClient(context) {
+  const client = context.financialReports?.notebookLmClient;
+  if (!client) {
+    throw new FinancialReportsRuntimeError(
+      "RUNTIME_NOT_FOUND",
+      "NotebookLM client is not configured",
+      "financial_reports.notebooklm.resolve"
+    );
+  }
+  return client;
+}
+function marketToAppMarket(market) {
+  if (market === "US") {
+    return "us";
+  }
+  if (market === "H") {
+    return "hk";
+  }
+  return "cn";
+}
+function sha256Json(value) {
+  return `sha256:${createHash("sha256").update(JSON.stringify(value)).digest("hex")}`;
+}
+function writeWorkspaceJson(context, relativePath, value) {
+  return writeWorkspaceBytes(
+    context,
+    relativePath,
+    new TextEncoder().encode(`${JSON.stringify(value, null, 2)}
+`)
+  );
+}
+async function writeWorkspaceBytes(context, relativePath, bytes) {
+  const absolutePath = resolveInsideWorkspace4(context.workspaceRoot, relativePath);
+  await mkdir3(path6.dirname(absolutePath), { recursive: true });
+  if (!context.dryRun) {
+    await writeFile2(absolutePath, bytes);
+  }
+}
+function createWorkspaceStorage(context) {
+  return {
+    async writeFile(relativePath, bytes) {
+      await writeWorkspaceBytes(context, relativePath, bytes);
+    }
+  };
+}
+function readWorkspaceJson(context, relativePath) {
+  const absolutePath = resolveInsideWorkspace4(context.workspaceRoot, relativePath);
+  return readFile4(absolutePath, "utf8").then((content) => JSON.parse(content));
+}
+function parseReportManifest(payload) {
+  const maybeRecord = typeof payload === "object" && payload !== null ? payload : {};
+  if (maybeRecord.schemaVersion === "financial-reports/manifest/v1") {
+    return FinancialReportManifestSchema.parse(payload);
+  }
+  return FinancialReportManifestSchema.parse(maybeRecord.manifest);
+}
+async function readReportManifest(context, manifestPath) {
+  try {
+    return parseReportManifest(await readWorkspaceJson(context, manifestPath));
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new FinancialReportsRuntimeError(
+        "VALIDATION_ERROR",
+        "Financial reports manifest is not valid JSON",
+        "financial_reports.manifest.read"
+      );
+    }
+    throw error;
+  }
+}
+function assertManifestIssuerMatchesTaskIssuer(manifestIssuer, taskIssuer) {
+  const mismatches = [];
+  if (manifestIssuer.issuerId !== taskIssuer.issuerId) {
+    mismatches.push("issuerId");
+  }
+  if (manifestIssuer.companyId !== taskIssuer.companyId) {
+    mismatches.push("companyId");
+  }
+  if (primaryTicker(manifestIssuer) !== primaryTicker(taskIssuer)) {
+    mismatches.push("primary ticker");
+  }
+  if (primaryMarket(manifestIssuer) !== primaryMarket(taskIssuer)) {
+    mismatches.push("primary market");
+  }
+  if (mismatches.length > 0) {
+    throw new FinancialReportsRuntimeError(
+      "VALIDATION_ERROR",
+      `Financial reports manifest issuer does not match task payload issuer: ${mismatches.join(", ")}`,
+      "financial_reports.manifest.validate"
+    );
+  }
+}
+function financialTaskResult(input) {
+  const ticker = primaryTicker(input.manifest.issuer);
+  const coverage = assessReportCoverage(input.manifest);
+  return {
+    schemaVersion: "financial-reports/task-result/v1",
+    issuerId: input.manifest.issuer.issuerId,
+    companyId: input.manifest.issuer.companyId,
+    ticker,
+    manifestPath: input.manifestPath,
+    manifestHash: input.manifestHash,
+    notebookPath: input.notebookPath,
+    factsBundlePath: input.factsBundlePath,
+    reportCount: input.manifest.reports.length,
+    coverageStatus: coverage.status,
+    blockingReasons: coverage.knownGaps
+  };
+}
+async function runSyncReports(task, context) {
+  const issuer = task.payload.issuer;
+  const market = primaryMarket(issuer);
+  const fetch2 = context.financialReports?.fetch ?? defaultFetch();
+  const storage = createWorkspaceStorage(context);
+  const now = context.financialReports?.now;
+  let result;
+  await context.appendEvent({
+    level: "info",
+    message: "Starting financial reports sync",
+    data: { issuerId: issuer.issuerId, market }
+  });
+  if (market === "US") {
+    result = await downloadSecReports({
+      issuer,
+      fiscalYears: task.payload.fiscalYears,
+      reportTypes: task.payload.reportTypes,
+      fetch: fetch2,
+      storage,
+      renderHtmlToPdf: context.financialReports?.renderHtmlToPdf ?? defaultRenderHtmlToPdf(),
+      now
+    });
+  } else {
+    result = await downloadCninfoReports({
+      issuer,
+      fiscalYears: task.payload.fiscalYears,
+      reportTypes: task.payload.reportTypes,
+      fetch: fetch2,
+      storage,
+      now
+    });
+  }
+  const ticker = primaryTicker(result.manifest.issuer);
+  const reportIndexPath = financialReportsIndexPath(ticker);
+  const manifestHash = sha256Json(result.manifest);
+  const reportIndex = {
+    schemaVersion: "financial-reports/report-index/v1",
+    generatedAt: result.manifest.generatedAt,
+    issuer: result.manifest.issuer,
+    manifestHash,
+    manifest: result.manifest,
+    coverage: result.coverage,
+    skippedReports: result.skippedReports,
+    missingReports: result.missingReports
+  };
+  await writeWorkspaceJson(context, reportIndexPath, reportIndex);
+  const companyManifest = context.dryRun ? void 0 : await buildCompanyManifest2({
+    workspaceRoot: context.workspaceRoot,
+    ticker,
+    market: marketToAppMarket(market)
+  });
+  await context.appendEvent({
+    level: "info",
+    message: "Financial reports sync completed",
+    data: {
+      issuerId: issuer.issuerId,
+      coverageStatus: result.coverage.status,
+      reportCount: result.manifest.reports.length,
+      manifestPath: reportIndexPath
+    }
+  });
+  return {
+    generatedFiles: [
+      ...result.manifest.reports.map((report) => report.localPath),
+      reportIndexPath,
+      companyManifestPath2(ticker)
+    ],
+    manifestPath: companyManifestPath2(ticker),
+    manifest: companyManifest,
+    blockingReasons: [],
+    financialReports: financialTaskResult({
+      manifest: result.manifest,
+      manifestPath: reportIndexPath,
+      manifestHash
+    })
+  };
+}
+async function runNotebookIngest(task, context) {
+  const client = requireNotebookLmClient(context);
+  const manifest = await readReportManifest(context, task.payload.manifestPath);
+  assertManifestIssuerMatchesTaskIssuer(manifest.issuer, task.payload.issuer);
+  const ticker = primaryTicker(manifest.issuer);
+  const manifestHash = sha256Json(manifest);
+  const factsAsOf = task.payload.factsAsOf ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  await context.appendEvent({
+    level: "info",
+    message: "Starting NotebookLM financial reports ingest",
+    data: { issuerId: manifest.issuer.issuerId, manifestPath: task.payload.manifestPath }
+  });
+  const ingest = await runNotebookLmFinancialReportsIngest({
+    manifest,
+    client,
+    manifestHash,
+    factsAsOf,
+    generatedAt: context.financialReports?.now?.(),
+    notebookTitle: task.payload.notebookTitle
+  });
+  const notebookPath = `companies/${ticker}/financial-reports/notebooklm/notebook.json`;
+  const factsBundlePath = `companies/${ticker}/financial-reports/ingest/facts-bundle.json`;
+  await writeWorkspaceJson(context, notebookPath, {
+    schemaVersion: "financial-reports/notebooklm-run/v1",
+    generatedAt: ingest.factsBundle.generatedAt,
+    manifestPath: task.payload.manifestPath,
+    notebooklm: ingest.notebooklm,
+    sourceIds: ingest.sourceIds
+  });
+  await writeWorkspaceJson(context, factsBundlePath, ingest.factsBundle);
+  const companyManifest = context.dryRun ? void 0 : await buildCompanyManifest2({
+    workspaceRoot: context.workspaceRoot,
+    ticker,
+    market: marketToAppMarket(primaryMarket(manifest.issuer))
+  });
+  await context.appendEvent({
+    level: "info",
+    message: "NotebookLM financial reports ingest completed",
+    data: {
+      issuerId: manifest.issuer.issuerId,
+      notebookPath,
+      factsBundlePath
+    }
+  });
+  return {
+    generatedFiles: [notebookPath, factsBundlePath, companyManifestPath2(ticker)],
+    manifestPath: companyManifestPath2(ticker),
+    manifest: companyManifest,
+    blockingReasons: [],
+    financialReports: financialTaskResult({
+      manifest,
+      manifestPath: task.payload.manifestPath,
+      manifestHash,
+      notebookPath,
+      factsBundlePath
+    })
+  };
+}
+async function runRefreshCompany(task, context) {
+  const syncResult = await runSyncReports(
+    {
+      id: task.id,
+      type: "financial_reports.sync_reports",
+      payload: {
+        issuer: task.payload.issuer,
+        fiscalYears: task.payload.fiscalYears,
+        reportTypes: task.payload.reportTypes
+      }
+    },
+    context
+  );
+  if (!context.financialReports?.notebookLmClient) {
+    return syncResult;
+  }
+  const manifestPath = syncResult.financialReports?.manifestPath;
+  if (!manifestPath) {
+    return syncResult;
+  }
+  const ingestResult = await runNotebookIngest(
+    {
+      id: task.id,
+      type: "financial_reports.ingest_notebook",
+      payload: {
+        issuer: task.payload.issuer,
+        manifestPath,
+        factsAsOf: task.payload.factsAsOf,
+        notebookTitle: task.payload.notebookTitle
+      }
+    },
+    context
+  );
+  return {
+    ...ingestResult,
+    generatedFiles: [
+      ...syncResult.generatedFiles,
+      ...ingestResult.generatedFiles
+    ]
+  };
+}
+async function runFinancialReportsTask(task, context) {
+  if (task.type === "financial_reports.sync_reports") {
+    return runSyncReports(task, context);
+  }
+  if (task.type === "financial_reports.ingest_notebook" || task.type === "financial_reports.extract_facts") {
+    return runNotebookIngest(task, context);
+  }
+  if (task.type === "financial_reports.refresh_company") {
+    return runRefreshCompany(task, context);
+  }
+  throw new FinancialReportsRuntimeError(
+    "VALIDATION_ERROR",
+    "Unsupported financial reports task type",
+    "financial_reports.dispatch"
+  );
+}
+
+// src/executors/investWiki.ts
+import { access as access2, mkdir as mkdir4, readFile as readFile5, stat as stat3, writeFile as writeFile3 } from "fs/promises";
+import path7 from "path";
+import {
+  buildCompanyManifest as buildCompanyManifest3,
+  companyManifestPath as companyManifestPath3,
   investWikiConfigPath,
   investWikiRoot as investWikiRoot2,
-  resolveInsideWorkspace as resolveInsideWorkspace4
+  resolveInsideWorkspace as resolveInsideWorkspace5
 } from "@xdsjs/dossierx-workspace";
 async function exists(absolutePath) {
   try {
@@ -1498,7 +1871,7 @@ function isWorkspaceGuardError2(error) {
 }
 function workspacePath2(workspaceRoot, relativePath, step) {
   try {
-    return resolveInsideWorkspace4(workspaceRoot, relativePath);
+    return resolveInsideWorkspace5(workspaceRoot, relativePath);
   } catch (error) {
     if (isWorkspaceGuardError2(error)) {
       throw new InvestWikiRuntimeError(
@@ -1579,11 +1952,11 @@ function isMarket(value) {
 async function readManifestMarket(workspaceRoot, ticker) {
   const manifestPath = workspacePath2(
     workspaceRoot,
-    companyManifestPath2(ticker),
+    companyManifestPath3(ticker),
     "invest_wiki.sync"
   );
   try {
-    const manifest = JSON.parse(await readFile4(manifestPath, "utf8"));
+    const manifest = JSON.parse(await readFile5(manifestPath, "utf8"));
     if (!isMarket(manifest.market)) {
       throw new InvestWikiRuntimeError(
         "VALIDATION_ERROR",
@@ -1626,7 +1999,7 @@ async function runInitCompanyVault(task, context) {
     `${vaultRelativePath}/.llm-wiki-invest/dossier-state.json`,
     "invest_wiki.init_company_vault"
   );
-  await mkdir3(vaultRoot, { recursive: true });
+  await mkdir4(vaultRoot, { recursive: true });
   await context.appendEvent({
     level: "info",
     message: "Initializing invest-wiki vault",
@@ -1645,10 +2018,10 @@ async function runInitCompanyVault(task, context) {
   const statusOutput = await runner.run(["dossier", "status"], { cwd: vaultRoot });
   await appendOutputEvent2(context, "Invest wiki dossier status completed", statusOutput);
   if (!await exists(markerPath)) {
-    await mkdir3(path6.dirname(markerPath), { recursive: true });
-    await writeFile2(markerPath, "# Created by dossierx-daemon\n");
+    await mkdir4(path7.dirname(markerPath), { recursive: true });
+    await writeFile3(markerPath, "# Created by dossierx-daemon\n");
   }
-  const manifest = await buildCompanyManifest2({
+  const manifest = await buildCompanyManifest3({
     workspaceRoot: context.workspaceRoot,
     ticker,
     market: task.payload.market
@@ -1662,9 +2035,10 @@ async function runInitCompanyVault(task, context) {
     generatedFiles: [
       vaultRelativePath,
       markerRelativePath,
-      companyManifestPath2(ticker)
+      companyManifestPath3(ticker)
     ],
-    manifestPath: companyManifestPath2(ticker),
+    blockingReasons: [],
+    manifestPath: companyManifestPath3(ticker),
     manifest
   };
 }
@@ -1688,7 +2062,8 @@ async function runStatus(task, context) {
   );
   return {
     generatedFiles: [],
-    manifestPath: companyManifestPath2(ticker)
+    blockingReasons: [],
+    manifestPath: companyManifestPath3(ticker)
   };
 }
 async function runSync(task, context) {
@@ -1703,14 +2078,15 @@ async function runSync(task, context) {
   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({
+  const manifest = await buildCompanyManifest3({
     workspaceRoot: context.workspaceRoot,
     ticker,
     market
   });
   return {
     generatedFiles: [],
-    manifestPath: companyManifestPath2(ticker),
+    blockingReasons: [],
+    manifestPath: companyManifestPath3(ticker),
     manifest
   };
 }
@@ -1732,13 +2108,13 @@ async function runInvestWikiTask(task, context) {
 }
 
 // src/executors/mockWriteCompanyReport.ts
-import { mkdir as mkdir4, writeFile as writeFile3 } from "fs/promises";
-import path7 from "path";
+import { mkdir as mkdir5, writeFile as writeFile4 } from "fs/promises";
+import path8 from "path";
 import {
-  buildCompanyManifest as buildCompanyManifest3,
-  companyManifestPath as companyManifestPath3,
+  buildCompanyManifest as buildCompanyManifest4,
+  companyManifestPath as companyManifestPath4,
   companyRoot,
-  resolveInsideWorkspace as resolveInsideWorkspace5,
+  resolveInsideWorkspace as resolveInsideWorkspace6,
   rightBusinessPath,
   rightPeoplePath,
   rightPricePath
@@ -1772,10 +2148,10 @@ var rightPrice = (ticker) => `# Right Price - ${ticker}
 This is a placeholder right-price analysis for ${ticker}.
 `;
 async function writeWorkspaceFile(context, relativePath, content) {
-  const absolutePath = resolveInsideWorkspace5(context.workspaceRoot, relativePath);
-  await mkdir4(path7.dirname(absolutePath), { recursive: true });
+  const absolutePath = resolveInsideWorkspace6(context.workspaceRoot, relativePath);
+  await mkdir5(path8.dirname(absolutePath), { recursive: true });
   if (!context.dryRun) {
-    await writeFile3(absolutePath, content);
+    await writeFile4(absolutePath, content);
   }
 }
 async function runMockWriteCompanyReport(task, context) {
@@ -1790,7 +2166,7 @@ async function runMockWriteCompanyReport(task, context) {
     message: "Creating company directory",
     data: { ticker }
   });
-  await mkdir4(resolveInsideWorkspace5(context.workspaceRoot, companyRoot(ticker)), {
+  await mkdir5(resolveInsideWorkspace6(context.workspaceRoot, companyRoot(ticker)), {
     recursive: true
   });
   await context.appendEvent({
@@ -1814,11 +2190,11 @@ async function runMockWriteCompanyReport(task, context) {
   await context.appendEvent({
     level: "info",
     message: "Generating manifest.json",
-    data: { path: companyManifestPath3(ticker) }
+    data: { path: companyManifestPath4(ticker) }
   });
   let manifest;
   if (!context.dryRun) {
-    manifest = await buildCompanyManifest3({
+    manifest = await buildCompanyManifest4({
       workspaceRoot: context.workspaceRoot,
       ticker,
       market: task.payload.market
@@ -1830,8 +2206,9 @@ async function runMockWriteCompanyReport(task, context) {
     data: { ticker }
   });
   return {
-    generatedFiles: [...generatedFiles, companyManifestPath3(ticker)],
-    manifestPath: companyManifestPath3(ticker),
+    generatedFiles: [...generatedFiles, companyManifestPath4(ticker)],
+    blockingReasons: [],
+    manifestPath: companyManifestPath4(ticker),
     manifest
   };
 }
@@ -1844,6 +2221,9 @@ function getExecutor(task) {
   if (task.type.startsWith("invest_wiki.")) {
     return runInvestWikiTask;
   }
+  if (task.type.startsWith("financial_reports.")) {
+    return runFinancialReportsTask;
+  }
   if (task.type === "mock.write_company_report") {
     return runMockWriteCompanyReport;
   }
@@ -1912,6 +2292,7 @@ async function runTask(ctx, task, agent) {
       dryRun: ctx.dryRun,
       codex: codexRunnerForTask(ctx, agent),
       investWiki: ctx.investWiki,
+      financialReports: ctx.financialReports,
       appendEvent: async (event) => {
         await appendLocalEvent(ctx, task.id, TaskEventInputSchema.parse(event));
       },
@@ -1979,6 +2360,22 @@ async function runTask(ctx, task, agent) {
       });
       return;
     }
+    if (error instanceof FinancialReportsRuntimeError) {
+      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 GitMirrorError) {
       await appendLocalEvent(ctx, task.id, {
         level: "error",
@@ -2100,6 +2497,9 @@ async function detectCapabilities() {
     git,
     node: true,
     python: python3 || python,
+    financialReports: true,
+    financialReportsNotebookLm: false,
+    financialReportsSecHtmlRenderer: false,
     investWikiRuntime,
     codex,
     claude
@@ -2176,9 +2576,9 @@ async function subscribeToTaskAvailable(options, onEvent, onInvalidEvent) {
 }
 
 // src/service.ts
-import { mkdir as mkdir5, unlink, writeFile as writeFile4 } from "fs/promises";
+import { mkdir as mkdir6, unlink, writeFile as writeFile5 } from "fs/promises";
 import os2 from "os";
-import path8 from "path";
+import path9 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;");
@@ -2187,10 +2587,10 @@ function shellQuote(value) {
   return `'${value.replaceAll("'", "'\\''")}'`;
 }
 function launchAgentsDir() {
-  return path8.join(os2.homedir(), "Library", "LaunchAgents");
+  return path9.join(os2.homedir(), "Library", "LaunchAgents");
 }
 function launchAgentPlistPath(label = LAUNCH_AGENT_LABEL, dir = launchAgentsDir()) {
-  return path8.join(dir, `${label}.plist`);
+  return path9.join(dir, `${label}.plist`);
 }
 function resolveDaemonProgramArguments(input) {
   if (input.daemonCommand?.trim()) {
@@ -2201,14 +2601,14 @@ function resolveDaemonProgramArguments(input) {
   if (!entry) {
     throw new Error("Unable to resolve daemon entrypoint for LaunchAgent");
   }
-  if (path8.extname(entry) === ".ts") {
+  if (path9.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,
-    path8.resolve(entry),
+    path9.resolve(entry),
     "--log-level",
     input.logLevel ?? "info"
   ];
@@ -2267,7 +2667,7 @@ async function installLaunchAgent(options = {}) {
     throw new Error("DossierX LaunchAgent service is only supported on macOS");
   }
   const label = options.label ?? LAUNCH_AGENT_LABEL;
-  const configDir = path8.resolve(
+  const configDir = path9.resolve(
     expandHomePath(options.configDir ?? getDaemonConfigDir())
   );
   const config = await readDaemonLocalConfig(configDir);
@@ -2287,8 +2687,8 @@ async function installLaunchAgent(options = {}) {
     );
   }
   const plistPath = launchAgentPlistPath(label, options.launchAgentsDir);
-  const stdoutPath = path8.join(configDir, "daemon.out.log");
-  const stderrPath = path8.join(configDir, "daemon.err.log");
+  const stdoutPath = path9.join(configDir, "daemon.out.log");
+  const stderrPath = path9.join(configDir, "daemon.err.log");
   const uid = typeof process.getuid === "function" ? process.getuid() : "<uid>";
   const programArguments = resolveDaemonProgramArguments({
     daemonCommand: options.daemonCommand,
@@ -2296,9 +2696,9 @@ async function installLaunchAgent(options = {}) {
     argv: options.argv,
     execPath: options.execPath
   });
-  await mkdir5(path8.dirname(plistPath), { recursive: true });
-  await mkdir5(configDir, { recursive: true, mode: 448 });
-  await writeFile4(
+  await mkdir6(path9.dirname(plistPath), { recursive: true });
+  await mkdir6(configDir, { recursive: true, mode: 448 });
+  await writeFile5(
     plistPath,
     buildLaunchAgentPlist({
       label,
@@ -2339,7 +2739,7 @@ async function uninstallLaunchAgent(options = {}) {
 
 // src/cli.ts
 async function ensureWorkspaceDirectory(workspace) {
-  await mkdir6(workspace, { recursive: true }).catch(async (error) => {
+  await mkdir7(workspace, { recursive: true }).catch(async (error) => {
     const stats2 = await stat4(workspace).catch(() => null);
     if (!stats2?.isDirectory()) {
       throw new Error("Workspace path is not a directory");
@@ -2437,7 +2837,7 @@ async function runDaemon(options) {
       "Missing daemon connection config. Run the generated daemon command from DossierX first."
     );
   }
-  const workspaceRoot = path9.resolve(expandHomePath(workspacePath3));
+  const workspaceRoot = path10.resolve(expandHomePath(workspacePath3));
   await ensureWorkspaceDirectory(workspaceRoot);
   const capabilities = await detectCapabilities();
   const investWiki = createInvestWikiRunnerFromOptions(runtimeOptions);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xdsjs/dossierx-daemon",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -28,9 +28,10 @@
     "execa": "^9.0.0",
     "pino": "^10.0.0",
     "zod": "^4.0.0",
-    "@xdsjs/dossierx-git-mirror": "^0.1.0",
-    "@xdsjs/dossierx-workspace": "^0.1.0",
-    "@xdsjs/dossierx-shared": "^0.1.2"
+    "@xdsjs/dossier-financial-reports": "^0.1.0",
+    "@xdsjs/dossierx-git-mirror": "^0.1.2",
+    "@xdsjs/dossierx-shared": "^0.1.3",
+    "@xdsjs/dossierx-workspace": "^0.1.1"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",