@xdsjs/dossierx-daemon 0.1.2 → 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 path8 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(path9, body, schema) {
-    const response = await this.fetchImpl(`${this.serverUrl}${path9}`, {
+  async post(path11, body, schema) {
+    const response = await this.fetchImpl(`${this.serverUrl}${path11}`, {
       method: "POST",
       headers: {
         authorization: `Bearer ${this.machineKey}`,
@@ -495,9 +495,103 @@ function createCodexRunnerFromOptions(options, env = process.env) {
   });
 }
 
+// src/git-mirror.ts
+import path2 from "path";
+import {
+  publishCompanySnapshot
+} from "@xdsjs/dossierx-git-mirror";
+
+// src/local-config.ts
+import { chmod, mkdir, readFile, writeFile } from "fs/promises";
+import os from "os";
+import path 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(),
+  gitMirrorRoot: z.string().optional(),
+  gitMirrorRemote: z.string().optional(),
+  gitMirrorBranch: z.string().optional(),
+  gitCommand: z.string().optional(),
+  localApiPort: z.number().int().positive().optional()
+});
+function expandHomePath(input) {
+  if (input === "~") {
+    return os.homedir();
+  }
+  if (input.startsWith("~/")) {
+    return path.join(os.homedir(), input.slice(2));
+  }
+  return input;
+}
+function getDaemonConfigDir(env = process.env) {
+  return path.resolve(
+    expandHomePath(env.DOSSIERX_CONFIG_DIR ?? DOSSIERX_CONFIG_DIR)
+  );
+}
+function daemonConfigPath(configDir = getDaemonConfigDir()) {
+  return path.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/git-mirror.ts
+function createGitMirrorFromOptions(options) {
+  if (!options.gitMirrorRoot && !options.gitMirrorRemote) {
+    return null;
+  }
+  const mirrorRoot = path2.resolve(
+    expandHomePath(
+      options.gitMirrorRoot ?? path2.join(getDaemonConfigDir(), "git-mirror")
+    )
+  );
+  return {
+    publishCompanySnapshot(input) {
+      return publishCompanySnapshot({
+        ...input,
+        mirrorRoot,
+        remoteUrl: options.gitMirrorRemote,
+        branch: options.gitMirrorBranch,
+        gitCommand: options.gitCommand
+      });
+    }
+  };
+}
+
 // src/invest-wiki/runner.ts
 import { access } from "fs/promises";
-import path from "path";
+import path3 from "path";
 import { execa as execa2 } from "execa";
 
 // src/invest-wiki/config.ts
@@ -591,7 +685,7 @@ function createLocalRepoRunner(config) {
   return {
     kind: "local-repo",
     async run(args, options) {
-      const cliPath = path.join(config.localRepo, "dist", "cli.js");
+      const cliPath = path3.join(config.localRepo, "dist", "cli.js");
       await assertFileExists(cliPath);
       const result = await runInvestWikiCommand(
         process.execPath,
@@ -638,73 +732,13 @@ 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 path5 from "path";
 import { execa as execa3 } from "execa";
 import {
+  readCoverageContractBundle,
   resolveInsideWorkspace as resolveInsideWorkspace2,
   scanCompanyManifest
 } from "@xdsjs/dossierx-workspace";
@@ -712,7 +746,7 @@ import {
 // src/task-archive.ts
 import { randomUUID } from "crypto";
 import { appendFile, mkdir as mkdir2, readFile as readFile2 } from "fs/promises";
-import path3 from "path";
+import path4 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) {
@@ -724,7 +758,7 @@ function taskDirectory(workspaceRoot, taskId) {
   assertTaskId(taskId);
   return resolveInsideWorkspace(
     workspaceRoot,
-    path3.posix.join(".dossierx", "tasks", taskId)
+    path4.posix.join(".dossierx", "tasks", taskId)
   );
 }
 async function ensureTaskDirectory(workspaceRoot, taskId) {
@@ -757,7 +791,7 @@ function createTaskArchive(options) {
         created_at: now().toISOString()
       };
       await appendFile(
-        path3.join(directory, "events.jsonl"),
+        path4.join(directory, "events.jsonl"),
         `${JSON.stringify(archivedEvent)}
 `,
         "utf8"
@@ -766,13 +800,13 @@ function createTaskArchive(options) {
     },
     async appendRawOutput(taskId, stream, chunk) {
       const directory = await ensureTaskDirectory(options.workspaceRoot, taskId);
-      await appendFile(path3.join(directory, `${stream}.log`), chunk, "utf8");
+      await appendFile(path4.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");
+        content = await readFile2(path4.join(directory, "events.jsonl"), "utf8");
       } catch (error) {
         if (error.code === "ENOENT") {
           return [];
@@ -786,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;
@@ -813,7 +847,7 @@ function requestUrl(request) {
   return new URL(request.url ?? "/", "http://127.0.0.1");
 }
 async function readWorkspaceFile(options) {
-  const extension = path4.extname(options.relativePath).toLowerCase();
+  const extension = path5.extname(options.relativePath).toLowerCase();
   if (!ALLOWED_EXTENSIONS.has(extension)) {
     throw new Error("Only markdown, text, and json files can be previewed");
   }
@@ -865,7 +899,7 @@ function uniqueProbes(probes) {
 }
 async function resolveCommand(command) {
   const normalizedCommand = command.trim();
-  if (path4.isAbsolute(normalizedCommand)) {
+  if (path5.isAbsolute(normalizedCommand)) {
     return realpath(normalizedCommand).catch(() => normalizedCommand);
   }
   const result = await execa3("which", [normalizedCommand], {
@@ -1158,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;
@@ -1213,6 +1275,7 @@ import {
   TaskEventInputSchema,
   TaskSchema
 } from "@xdsjs/dossierx-shared";
+import { GitMirrorError } from "@xdsjs/dossierx-git-mirror";
 
 // src/errors.ts
 function failTaskError(error, code = "UNKNOWN", step) {
@@ -1426,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";
-import path5 from "path";
+// 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 {
@@ -1464,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(
@@ -1545,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",
@@ -1592,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",
@@ -1611,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(path5.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
@@ -1628,9 +2035,10 @@ async function runInitCompanyVault(task, context) {
     generatedFiles: [
       vaultRelativePath,
       markerRelativePath,
-      companyManifestPath2(ticker)
+      companyManifestPath3(ticker)
     ],
-    manifestPath: companyManifestPath2(ticker),
+    blockingReasons: [],
+    manifestPath: companyManifestPath3(ticker),
     manifest
   };
 }
@@ -1654,7 +2062,8 @@ async function runStatus(task, context) {
   );
   return {
     generatedFiles: [],
-    manifestPath: companyManifestPath2(ticker)
+    blockingReasons: [],
+    manifestPath: companyManifestPath3(ticker)
   };
 }
 async function runSync(task, context) {
@@ -1669,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
   };
 }
@@ -1698,13 +2108,13 @@ async function runInvestWikiTask(task, context) {
 }
 
 // src/executors/mockWriteCompanyReport.ts
-import { mkdir as mkdir4, writeFile as writeFile3 } from "fs/promises";
-import path6 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
@@ -1738,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(path6.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) {
@@ -1756,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({
@@ -1780,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
@@ -1796,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
   };
 }
@@ -1810,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;
   }
@@ -1873,11 +2287,12 @@ async function runTask(ctx, task, agent) {
   }
   await appendEvent(ctx, task.id, "Task claimed");
   try {
-    const result = await executor(task, {
+    let result = await executor(task, {
       workspaceRoot: ctx.workspaceRoot,
       dryRun: ctx.dryRun,
       codex: codexRunnerForTask(ctx, agent),
       investWiki: ctx.investWiki,
+      financialReports: ctx.financialReports,
       appendEvent: async (event) => {
         await appendLocalEvent(ctx, task.id, TaskEventInputSchema.parse(event));
       },
@@ -1885,6 +2300,31 @@ async function runTask(ctx, task, agent) {
         await appendLocalRawOutput(ctx, task.id, stream, chunk);
       }
     });
+    if (ctx.gitMirror && result.manifest) {
+      const gitSnapshot = await ctx.gitMirror.publishCompanySnapshot({
+        workspaceRoot: ctx.workspaceRoot,
+        company: {
+          ticker: result.manifest.ticker,
+          market: result.manifest.market
+        },
+        taskId: task.id
+      });
+      await appendLocalEvent(ctx, task.id, {
+        level: "info",
+        message: gitSnapshot.status === "published" ? "Git mirror snapshot published" : "Git mirror snapshot unchanged",
+        data: {
+          commitSha: gitSnapshot.commitSha,
+          treeHash: gitSnapshot.treeHash,
+          branch: gitSnapshot.branch,
+          pushed: gitSnapshot.pushed
+        }
+      });
+      result = {
+        ...result,
+        commitSha: gitSnapshot.commitSha ?? result.commitSha,
+        gitSnapshot
+      };
+    }
     await appendEvent(ctx, task.id, "Task completed");
     await ctx.api.completeTask(task.id, { result });
   } catch (error) {
@@ -1920,6 +2360,38 @@ 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",
+        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",
@@ -2025,6 +2497,9 @@ async function detectCapabilities() {
     git,
     node: true,
     python: python3 || python,
+    financialReports: true,
+    financialReportsNotebookLm: false,
+    financialReportsSecHtmlRenderer: false,
     investWikiRuntime,
     codex,
     claude
@@ -2101,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 path7 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;");
@@ -2112,10 +2587,10 @@ function shellQuote(value) {
   return `'${value.replaceAll("'", "'\\''")}'`;
 }
 function launchAgentsDir() {
-  return path7.join(os2.homedir(), "Library", "LaunchAgents");
+  return path9.join(os2.homedir(), "Library", "LaunchAgents");
 }
 function launchAgentPlistPath(label = LAUNCH_AGENT_LABEL, dir = launchAgentsDir()) {
-  return path7.join(dir, `${label}.plist`);
+  return path9.join(dir, `${label}.plist`);
 }
 function resolveDaemonProgramArguments(input) {
   if (input.daemonCommand?.trim()) {
@@ -2126,14 +2601,14 @@ function resolveDaemonProgramArguments(input) {
   if (!entry) {
     throw new Error("Unable to resolve daemon entrypoint for LaunchAgent");
   }
-  if (path7.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,
-    path7.resolve(entry),
+    path9.resolve(entry),
     "--log-level",
     input.logLevel ?? "info"
   ];
@@ -2180,6 +2655,10 @@ function runtimeOptionsFrom(input) {
     codexCommand: input.codexCommand,
     codexModel: input.codexModel,
     codexSandbox: input.codexSandbox,
+    gitMirrorRoot: input.gitMirrorRoot,
+    gitMirrorRemote: input.gitMirrorRemote,
+    gitMirrorBranch: input.gitMirrorBranch,
+    gitCommand: input.gitCommand,
     localApiPort: input.localApiPort
   };
 }
@@ -2188,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 = path7.resolve(
+  const configDir = path9.resolve(
     expandHomePath(options.configDir ?? getDaemonConfigDir())
   );
   const config = await readDaemonLocalConfig(configDir);
@@ -2208,8 +2687,8 @@ async function installLaunchAgent(options = {}) {
     );
   }
   const plistPath = launchAgentPlistPath(label, options.launchAgentsDir);
-  const stdoutPath = path7.join(configDir, "daemon.out.log");
-  const stderrPath = path7.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,
@@ -2217,9 +2696,9 @@ async function installLaunchAgent(options = {}) {
     argv: options.argv,
     execPath: options.execPath
   });
-  await mkdir5(path7.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,
@@ -2260,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");
@@ -2309,11 +2788,11 @@ function buildProgram() {
   ).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) => {
+  ).option("--git-mirror-root <path>", "local Git mirror repository path").option("--git-mirror-remote <url>", "remote Git mirror repository URL").option("--git-mirror-branch <branch>", "Git mirror branch name").option("--git-command <command>", "installed Git command").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) => {
+  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("--git-mirror-root <path>", "local Git mirror repository path").option("--git-mirror-remote <url>", "remote Git mirror repository URL").option("--git-mirror-branch <branch>", "Git mirror branch name").option("--git-command <command>", "installed Git command").option("--local-api-port <port>", "local workspace preview API port").action(async (options) => {
     const result = await installLaunchAgent({
       ...options,
       localApiPort: parsePort(options.localApiPort)
@@ -2347,6 +2826,10 @@ async function runDaemon(options) {
     codexCommand: options.codexCommand ?? localConfig?.codexCommand,
     codexModel: options.codexModel ?? localConfig?.codexModel,
     codexSandbox: options.codexSandbox ?? localConfig?.codexSandbox,
+    gitMirrorRoot: options.gitMirrorRoot ?? localConfig?.gitMirrorRoot,
+    gitMirrorRemote: options.gitMirrorRemote ?? localConfig?.gitMirrorRemote,
+    gitMirrorBranch: options.gitMirrorBranch ?? localConfig?.gitMirrorBranch,
+    gitCommand: options.gitCommand ?? localConfig?.gitCommand,
     localApiPort: parsePort(options.localApiPort) ?? localConfig?.localApiPort ?? parsePort(process.env.DOSSIERX_LOCAL_API_PORT) ?? DOSSIERX_DEFAULT_LOCAL_API_PORT
   };
   if (!serverUrl || !supabaseUrl || !supabaseAnonKey || !machineKey) {
@@ -2354,11 +2837,12 @@ async function runDaemon(options) {
       "Missing daemon connection config. Run the generated daemon command from DossierX first."
     );
   }
-  const workspaceRoot = path8.resolve(expandHomePath(workspacePath3));
+  const workspaceRoot = path10.resolve(expandHomePath(workspacePath3));
   await ensureWorkspaceDirectory(workspaceRoot);
   const capabilities = await detectCapabilities();
   const investWiki = createInvestWikiRunnerFromOptions(runtimeOptions);
   const codex = createCodexRunnerFromOptions(runtimeOptions);
+  const gitMirror = createGitMirrorFromOptions(runtimeOptions);
   const taskArchive = createTaskArchive({ workspaceRoot });
   const api = new ApiClient({
     serverUrl,
@@ -2384,6 +2868,10 @@ async function runDaemon(options) {
     codexCommand: runtimeOptions.codexCommand,
     codexModel: runtimeOptions.codexModel,
     codexSandbox: runtimeOptions.codexSandbox,
+    gitMirrorRoot: runtimeOptions.gitMirrorRoot,
+    gitMirrorRemote: runtimeOptions.gitMirrorRemote,
+    gitMirrorBranch: runtimeOptions.gitMirrorBranch,
+    gitCommand: runtimeOptions.gitCommand,
     localApiPort: runtimeOptions.localApiPort
   });
   const state = { running: false, pending: false };
@@ -2397,6 +2885,7 @@ async function runDaemon(options) {
     codex,
     codexOptions: runtimeOptions,
     investWiki,
+    gitMirror,
     taskArchive
   };
   async function heartbeat(status) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xdsjs/dossierx-daemon",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -28,8 +28,10 @@
     "execa": "^9.0.0",
     "pino": "^10.0.0",
     "zod": "^4.0.0",
-    "@xdsjs/dossierx-workspace": "^0.1.0",
-    "@xdsjs/dossierx-shared": "^0.1.1"
+    "@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",