@ryanfw/prompt-orchestration-pipeline 1.3.0 → 1.3.2

package/src/core/__tests__/task-runner.test.ts

@@ -211,3 +211,107 @@ describe("task-runner writes correct task-level state transitions", () => {
     expect(task!.error).toBe("stage exploded");
   });
 });
+
+describe("runPipeline runAgent injection", () => {
+  it("passes runAgent to stages and delegates to the supplied override", async () => {
+    const root = await makeTempRoot();
+    const workDir = path.join(root, "job-agent");
+    await mkdir(workDir, { recursive: true });
+    await writeFile(
+      path.join(workDir, "tasks-status.json"),
+      JSON.stringify({ id: "job-agent", tasks: {} }),
+    );
+
+    const modulePath = path.join(root, "agent-task.mjs");
+    await writeFile(
+      modulePath,
+      [
+        "export const ingestion = async ({ runAgent, flags }) => {",
+        "  const r = await runAgent({ harness: 'claude', prompt: 'hello agent' });",
+        "  return { output: r, flags };",
+        "};",
+      ].join("\n"),
+    );
+
+    const calls: unknown[] = [];
+    const result = await runPipeline(modulePath, {
+      workDir,
+      taskName: "agent-task",
+      statusPath: path.join(workDir, "tasks-status.json"),
+      jobId: "job-agent",
+      envLoaded: true,
+      seed: { data: {} },
+      pipelineTasks: ["agent-task"],
+      llm: {} as never,
+      runAgent: async (options) => {
+        calls.push(options);
+        return {
+          ok: true,
+          finalMessage: "did it",
+          artifactsWritten: ["x.md"],
+          usage: { inputTokens: 12, outputTokens: 7, totalTokens: 19 },
+          costUsd: 0.03,
+        };
+      },
+    });
+
+    expect(result.ok).toBe(true);
+    expect(calls).toEqual([{ harness: "claude", prompt: "hello agent" }]);
+    if (result.ok) {
+      expect(result.context.data["ingestion"]).toMatchObject({
+        ok: true,
+        finalMessage: "did it",
+      });
+    }
+
+    const status = JSON.parse(await readFile(path.join(workDir, "tasks-status.json"), "utf8")) as StatusSnapshot;
+    expect(status.tasks["agent-task"]?.tokenUsage).toEqual([
+      ["claude:default", 12, 7, 0.03],
+    ]);
+  });
+
+  it("records runAgent cost when normalized usage is absent", async () => {
+    const root = await makeTempRoot();
+    const workDir = path.join(root, "job-agent-cost");
+    await mkdir(workDir, { recursive: true });
+    await writeFile(
+      path.join(workDir, "tasks-status.json"),
+      JSON.stringify({ id: "job-agent-cost", tasks: {} }),
+    );
+
+    const modulePath = path.join(root, "agent-cost-task.mjs");
+    await writeFile(
+      modulePath,
+      [
+        "export const ingestion = async ({ runAgent, flags }) => {",
+        "  const r = await runAgent({ harness: 'opencode', model: 'gpt-4o', prompt: 'hello agent' });",
+        "  return { output: r, flags };",
+        "};",
+      ].join("\n"),
+    );
+
+    const result = await runPipeline(modulePath, {
+      workDir,
+      taskName: "agent-cost-task",
+      statusPath: path.join(workDir, "tasks-status.json"),
+      jobId: "job-agent-cost",
+      envLoaded: true,
+      seed: { data: {} },
+      pipelineTasks: ["agent-cost-task"],
+      llm: {} as never,
+      runAgent: async () => ({
+        ok: true,
+        finalMessage: "did it",
+        artifactsWritten: [],
+        costUsd: 0.12,
+      }),
+    });
+
+    expect(result.ok).toBe(true);
+
+    const status = JSON.parse(await readFile(path.join(workDir, "tasks-status.json"), "utf8")) as StatusSnapshot;
+    expect(status.tasks["agent-cost-task"]?.tokenUsage).toEqual([
+      ["opencode:gpt-4o", 0, 0, 0.12],
+    ]);
+  });
+});

package/src/core/agent-step.ts

@@ -1,18 +1,33 @@
 import { randomUUID } from "node:crypto";
-import { existsSync } from "node:fs";
-import { mkdir } from "node:fs/promises";
+import { chmodSync, existsSync } from "node:fs";
+import { cp, mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
 import { createTaskFileIO, generateLogName } from "./file-io.ts";
 import { LogEvent, LogFileExtension } from "../config/log-events.ts";
-import { runHarnessTask } from "../harness/executor.ts";
+import { run } from "../harness/index.ts";
 import { startMcpIoServer } from "../harness/mcp-io-server.ts";
 import type { McpIoServerHandle } from "../harness/mcp-io-server.ts";
+import type { AgentEntryConfig, AgentStepResult } from "./agent-types.ts";
 import type {
-  AgentEntryConfig,
-  AgentStepResult,
+  RunOptions,
+  HarnessRun,
   HarnessEvent,
-} from "../harness/types.ts";
+  HarnessName,
+  McpServerConfig,
+  RunResult,
+} from "../harness/index.ts";
 import type { TaskFileIO } from "./file-io.ts";
 
+type EnvSnapshot = Record<string, string | undefined>;
+let compatibilityEnvQueue: Promise<void> = Promise.resolve();
+
+interface HarnessCompatibility {
+  mcpServers?: McpServerConfig[];
+  env?: Record<string, string>;
+  cleanup?: () => Promise<void>;
+}
+
 function gitSync(args: string[], cwd: string): { exitCode: number; stdout: string; stderr: string } {
   const result = Bun.spawnSync(["git", ...args], {
     cwd,
@@ -65,78 +80,284 @@ async function captureDiff(io: TaskFileIO, cwd: string): Promise<boolean> {
   }
 }
 
-export async function runAgentStep(
+function asRecord(value: unknown): Record<string, unknown> | null {
+  return typeof value === "object" && value !== null ? value as Record<string, unknown> : null;
+}
+
+function expandHome(path: string): string {
+  return path.startsWith("~/") ? join(process.env.HOME ?? "", path.slice(2)) : path;
+}
+
+function findExecutable(name: string, candidateDirs: string[]): string | null {
+  const pathEntries = (process.env.PATH ?? "").split(":").filter(Boolean);
+  for (const dir of [...pathEntries, ...candidateDirs.map(expandHome)]) {
+    const candidate = join(dir, name);
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+
+function existingBinOverride(harness: HarnessName): string | undefined {
+  const upper = harness.toUpperCase();
+  return process.env[`LLM_ADAPTER_${upper}_BIN`] ?? process.env[`POP_${upper}_BIN`];
+}
+
+function snapshotEnv(keys: string[]): EnvSnapshot {
+  return Object.fromEntries(keys.map((key) => [key, process.env[key]]));
+}
+
+function applyEnv(values: Record<string, string>): EnvSnapshot {
+  const previous = snapshotEnv(Object.keys(values));
+  for (const [key, value] of Object.entries(values)) {
+    process.env[key] = value;
+  }
+  return previous;
+}
+
+function restoreEnv(previous: EnvSnapshot): void {
+  for (const [key, value] of Object.entries(previous)) {
+    if (value === undefined) {
+      delete process.env[key];
+    } else {
+      process.env[key] = value;
+    }
+  }
+}
+
+async function withCompatibilityEnv<T>(
+  compatibility: HarnessCompatibility,
+  runWithEnv: () => Promise<T>,
+): Promise<T> {
+  if (!compatibility.env) {
+    try {
+      return await runWithEnv();
+    } finally {
+      await compatibility.cleanup?.();
+    }
+  }
+
+  const previousTurn = compatibilityEnvQueue;
+  let releaseTurn!: () => void;
+  compatibilityEnvQueue = new Promise<void>((resolve) => {
+    releaseTurn = resolve;
+  });
+  await previousTurn;
+
+  const previousEnv = applyEnv(compatibility.env);
+  try {
+    return await runWithEnv();
+  } finally {
+    restoreEnv(previousEnv);
+    try {
+      await compatibility.cleanup?.();
+    } finally {
+      releaseTurn();
+    }
+  }
+}
+
+function defaultOpencodeConfigDir(): string {
+  return join(process.env.HOME ?? homedir(), ".config", "opencode");
+}
+
+function opencodeConfigDir(): string {
+  return process.env.OPENCODE_CONFIG_DIR ?? defaultOpencodeConfigDir();
+}
+
+async function readJsonObject(path: string): Promise<Record<string, unknown>> {
+  if (!existsSync(path)) return {};
+  const parsed = JSON.parse(await readFile(path, "utf8")) as unknown;
+  return asRecord(parsed) ?? {};
+}
+
+function codexConfigValue(key: string, value: string): string {
+  return `${key}=${JSON.stringify(value)}`;
+}
+
+async function prepareHarnessCompatibility(
+  harness: HarnessName,
+  mcpHandle: McpIoServerHandle | undefined,
+): Promise<HarnessCompatibility> {
+  if (!mcpHandle) return {};
+
+  const mcpServer: McpServerConfig = {
+    name: "popio",
+    url: mcpHandle.connection.url,
+    headers: { Authorization: `Bearer ${mcpHandle.connection.token}` },
+  };
+
+  if (harness === "claude") {
+    return { mcpServers: [mcpServer] };
+  }
+
+  if (harness === "opencode") {
+    const configDir = await mkdtemp(join(tmpdir(), "opencode-mcp-"));
+    const sourceConfigDir = opencodeConfigDir();
+    if (existsSync(sourceConfigDir)) {
+      await cp(sourceConfigDir, configDir, { recursive: true, force: true });
+    }
+    const configPath = join(configDir, "opencode.json");
+    const existingConfig = await readJsonObject(configPath);
+    const existingMcp = asRecord(existingConfig["mcp"]) ?? {};
+    await writeFile(
+      configPath,
+      JSON.stringify({
+        ...existingConfig,
+        mcp: {
+          ...existingMcp,
+          popio: {
+            type: "remote",
+            url: mcpHandle.connection.url,
+            headers: { Authorization: `Bearer ${mcpHandle.connection.token}` },
+            enabled: true,
+          },
+        },
+      }, null, 2),
+    );
+    return {
+      env: { OPENCODE_CONFIG_DIR: configDir },
+      cleanup: async () => {
+        await rm(configDir, { recursive: true, force: true });
+      },
+    };
+  }
+
+  if (harness === "codex") {
+    const wrapperDir = await mkdtemp(join(tmpdir(), "codex-mcp-"));
+    const wrapperPath = join(wrapperDir, "codex");
+    const realBin =
+      existingBinOverride("codex") ??
+      findExecutable("codex", ["/opt/homebrew/bin", "~/.local/bin"]) ??
+      "codex";
+    await writeFile(
+      wrapperPath,
+      [
+        "#!/bin/sh",
+        'exec "$POP_REAL_CODEX_BIN" "$@" \\',
+        '  -c "$POP_MCP_URL_CONFIG" \\',
+        '  -c \'mcp_servers.popio.bearer_token_env_var="POP_MCP_TOKEN"\'',
+        "",
+      ].join("\n"),
+    );
+    chmodSync(wrapperPath, 0o700);
+    return {
+      env: {
+        LLM_ADAPTER_CODEX_BIN: wrapperPath,
+        POP_REAL_CODEX_BIN: realBin,
+        POP_MCP_URL_CONFIG: codexConfigValue("mcp_servers.popio.url", mcpHandle.connection.url),
+        POP_MCP_TOKEN: mcpHandle.connection.token,
+      },
+      cleanup: async () => {
+        await rm(wrapperDir, { recursive: true, force: true });
+      },
+    };
+  }
+
+  return {};
+}
+
+function costFromRaw(raw: unknown): number | undefined {
+  const record = asRecord(raw);
+  if (!record) return undefined;
+  if (typeof record["total_cost_usd"] === "number") return record["total_cost_usd"];
+  if (typeof record["costUsd"] === "number") return record["costUsd"];
+  const info = asRecord(record["info"]);
+  if (typeof info?.["costUsd"] === "number") return info["costUsd"];
+  return undefined;
+}
+
+function extractCostUsd(events: HarnessEvent[]): number | undefined {
+  for (let i = events.length - 1; i >= 0; i--) {
+    const cost = costFromRaw(events[i]!.raw);
+    if (cost !== undefined) return cost;
+  }
+  return undefined;
+}
+
+/** Dependency seam shared by the agent runners (injected in tests). */
+interface AgentRunDeps {
+  run?: typeof run;
+  startMcpIoServer?: typeof startMcpIoServer;
+}
+
+/**
+ * Runs a single CLI-agent harness step against an existing task `io`.
+ *
+ * This is the shared core behind both pipeline `agent:` entries (via
+ * {@link runAgentStep}) and the `runAgent()` helper injected into standard
+ * JavaScript task stages (via the task runner). The caller owns the `io`, so
+ * the agent reads and writes the same task artifacts the surrounding task sees.
+ */
+export async function executeAgent(
   args: {
+    io: TaskFileIO;
     entry: AgentEntryConfig & { name: string };
-    workDir: string;
-    statusPath: string;
-    jobId: string | undefined;
-    getStage: () => string;
-  },
-  deps?: {
-    runHarnessTask?: typeof runHarnessTask;
-    startMcpIoServer?: typeof startMcpIoServer;
-    createTaskFileIO?: typeof createTaskFileIO;
   },
+  deps?: AgentRunDeps,
 ): Promise<AgentStepResult> {
-  const _runHarnessTask = deps?.runHarnessTask ?? runHarnessTask;
+  const _run = deps?.run ?? run;
   const _startMcpIoServer = deps?.startMcpIoServer ?? startMcpIoServer;
-  const _createTaskFileIO = deps?.createTaskFileIO ?? createTaskFileIO;
-
-  const io = _createTaskFileIO({
-    workDir: args.workDir,
-    taskName: args.entry.name,
-    getStage: args.getStage,
-    statusPath: args.statusPath,
-  });
+  const { io, entry } = args;
+  const observedEvents: HarnessEvent[] = [];
+  let completedResult: RunResult | undefined;
 
-  const cwd = args.entry.cwd ?? io.getTaskDir();
+  const cwd = entry.cwd ?? io.getTaskDir();
   // The harness spawns with this cwd before any artifact is written, so the task
   // dir may not exist yet — posix_spawn ENOENTs on a missing working directory.
   await mkdir(cwd, { recursive: true });
 
   let prompt: string;
-  if (args.entry.prompt !== undefined) {
-    prompt = args.entry.prompt;
-  } else if (args.entry.promptFrom !== undefined) {
-    prompt = await io.readArtifact(args.entry.promptFrom);
+  if (entry.prompt !== undefined) {
+    prompt = entry.prompt;
+  } else if (entry.promptFrom !== undefined) {
+    prompt = await io.readArtifact(entry.promptFrom);
   } else {
     throw new Error(
-      `Agent entry "${args.entry.name}" must specify either "prompt" or "promptFrom"`,
+      `Agent entry "${entry.name}" must specify either "prompt" or "promptFrom"`,
     );
   }
 
   let mcpHandle: McpIoServerHandle | undefined;
-  if (args.entry.io !== false) {
+  if (entry.io !== false) {
     mcpHandle = await _startMcpIoServer(io);
   }
 
   try {
     const logName = generateLogName(
-      args.entry.name,
+      entry.name,
       "agent",
       LogEvent.DEBUG,
       LogFileExtension.TEXT,
     );
-
-    const result = await _runHarnessTask({
-      harness: args.entry.harness,
+    const compatibility = await prepareHarnessCompatibility(entry.harness, mcpHandle);
+    const options: RunOptions = {
+      harness: entry.harness,
       prompt,
       cwd,
-      model: args.entry.model,
-      mcp: mcpHandle?.connection,
-      timeoutMs: args.entry.timeoutMs,
+      model: entry.model,
+      ...(compatibility.mcpServers ? { mcpServers: compatibility.mcpServers } : {}),
+      timeoutMs: entry.timeoutMs,
+      ...(entry.idleTimeoutMs !== undefined ? { idleTimeoutMs: entry.idleTimeoutMs } : {}),
+      permissionMode: "bypass",
       onEvent: (event: HarnessEvent) => {
+        observedEvents.push(event);
         void io.writeLog(logName, JSON.stringify(event.raw) + "\n", {
           mode: "append",
         });
       },
+    };
+
+    const result = await withCompatibilityEnv(compatibility, async () => {
+      const harnessRun: HarnessRun = _run(options);
+      const harnessResult = await harnessRun.result;
+      completedResult = harnessResult;
+      return harnessResult;
     });
 
     await io.writeArtifact("agent-result.md", result.finalMessage);
 
     let patchWritten = false;
-    if (args.entry.captureDiff) {
+    if (entry.captureDiff) {
       patchWritten = await captureDiff(io, cwd);
     }
 
@@ -150,7 +371,7 @@ export async function runAgentStep(
       finalMessage: result.finalMessage,
       artifactsWritten: allArtifacts,
       usage: result.usage,
-      costUsd: result.costUsd,
+      costUsd: result.costUsd ?? extractCostUsd(observedEvents),
       sessionId: result.sessionId,
     };
   } catch (err) {
@@ -163,6 +384,9 @@ export async function runAgentStep(
       ok: false,
       finalMessage: "",
       artifactsWritten: allArtifacts,
+      usage: completedResult?.usage,
+      costUsd: completedResult?.costUsd ?? extractCostUsd(observedEvents),
+      sessionId: completedResult?.sessionId,
       error: err instanceof Error ? err.message : String(err),
     };
   } finally {
@@ -171,3 +395,33 @@ export async function runAgentStep(
     }
   }
 }
+
+/**
+ * Runs a CLI-agent harness step for a pipeline `agent:` entry.
+ *
+ * Creates a task-scoped `io` from the run paths, then delegates to
+ * {@link executeAgent}. Used by the pipeline runner for `agent` entries.
+ */
+export async function runAgentStep(
+  args: {
+    entry: AgentEntryConfig & { name: string };
+    workDir: string;
+    statusPath: string;
+    jobId: string | undefined;
+    getStage: () => string;
+  },
+  deps?: AgentRunDeps & {
+    createTaskFileIO?: typeof createTaskFileIO;
+  },
+): Promise<AgentStepResult> {
+  const _createTaskFileIO = deps?.createTaskFileIO ?? createTaskFileIO;
+
+  const io = _createTaskFileIO({
+    workDir: args.workDir,
+    taskName: args.entry.name,
+    getStage: args.getStage,
+    statusPath: args.statusPath,
+  });
+
+  return executeAgent({ io, entry: args.entry }, deps);
+}

package/src/core/agent-types.ts

@@ -0,0 +1,61 @@
+import type { HarnessName, Usage } from "../harness/index.ts";
+
+export interface McpServerConnection {
+  url: string;
+  token: string;
+}
+
+export interface AgentEntryConfig {
+  harness: HarnessName;
+  model?: string;
+  prompt?: string;
+  promptFrom?: string;
+  cwd?: string;
+  io?: boolean;
+  timeoutMs?: number;
+  idleTimeoutMs?: number;
+  captureDiff?: boolean;
+}
+
+export interface AgentStepResult {
+  ok: boolean;
+  finalMessage: string;
+  artifactsWritten: string[];
+  usage?: Usage;
+  costUsd?: number;
+  sessionId?: string;
+  error?: string;
+}
+
+/**
+ * Options for the `runAgent()` helper injected into standard JavaScript task
+ * stages. Mirrors {@link AgentEntryConfig} but requires an inline `prompt`
+ * (a task builds the prompt programmatically rather than reading it from an
+ * artifact via `promptFrom`).
+ */
+export interface TaskAgentOptions {
+  /** Which CLI agent to run: `"claude" | "codex" | "opencode"`. */
+  harness: HarnessName;
+  /** The instruction handed to the agent. */
+  prompt: string;
+  /** Optional model id passed through to the harness verbatim. */
+  model?: string;
+  /** Working directory for the agent. Defaults to the task directory. */
+  cwd?: string;
+  /**
+   * Bridge POP file I/O into the agent (read_artifact/write_artifact tools).
+   * Defaults to `true` so the agent shares the task's artifacts.
+   */
+  io?: boolean;
+  /** Overall wall-clock cap in milliseconds. */
+  timeoutMs?: number;
+  /** No-output cap in milliseconds. Defaults to the adapter's idle timeout. */
+  idleTimeoutMs?: number;
+  /** Capture a git diff of the working tree as an `agent.patch` artifact. */
+  captureDiff?: boolean;
+}
+
+/** The `runAgent()` function injected into JavaScript task stages. */
+export type TaskAgentRunner = (
+  options: TaskAgentOptions,
+) => Promise<AgentStepResult>;

package/src/core/file-io.ts

@@ -1,9 +1,10 @@
 import { mkdir, rename, appendFile } from "node:fs/promises";
-import { existsSync, mkdirSync, readFileSync, writeFileSync, appendFileSync, renameSync } from "node:fs";
+import { existsSync, mkdirSync, writeFileSync, appendFileSync, renameSync } from "node:fs";
 import { dirname, join, basename } from "node:path";
 import { Database } from "bun:sqlite";
 import { LogFileExtension, isValidLogEvent, isValidLogFileExtension } from "../config/log-events";
-import { writeJobStatus } from "./status-writer";
+import { writeJobStatus, flushJobStatus } from "./status-writer";
+import { createJobLogger } from "./logger";
 import { executeBatch, validateBatchOptions } from "./batch-runner";
 import type { BatchOptions, BatchResult } from "./batch-runner";
 
@@ -169,34 +170,6 @@ export async function trackFile(
   });
 }
 
-/**
- * @internal Synchronous status writer for writeLogSync and getDB.
- * Reads tasks-status.json, applies updater, writes back as pretty-printed JSON.
- * Falls back to a minimal default snapshot on missing or invalid JSON.
- * No temp-file-rename, no async queue participation.
- */
-export function writeJobStatusSync(
-  jobDir: string,
-  updater: (snapshot: Record<string, unknown>) => void,
-): void {
-  const statusPath = join(jobDir, "tasks-status.json");
-  let snapshot: Record<string, unknown>;
-  try {
-    const raw = readFileSync(statusPath, "utf-8");
-    snapshot = JSON.parse(raw) as Record<string, unknown>;
-  } catch {
-    snapshot = {
-      id: basename(jobDir),
-      state: "pending",
-      tasks: {},
-      files: { artifacts: [], logs: [], tmp: [] },
-    };
-  }
-  updater(snapshot);
-  mkdirSync(jobDir, { recursive: true });
-  writeFileSync(statusPath, JSON.stringify(snapshot, null, 2));
-}
-
 export function createTaskFileIO(config: TaskFileIOConfig): TaskFileIO {
   const { workDir, taskName, statusPath, getStage } = config;
   const trackTaskFilesEnabled = config.trackTaskFiles ?? true;
@@ -234,28 +207,8 @@ export function createTaskFileIO(config: TaskFileIOConfig): TaskFileIO {
     const db = new Database(dbPath);
     db.exec("PRAGMA journal_mode = WAL;");
 
-    writeJobStatusSync(jobDir, (snapshot: Record<string, unknown>) => {
-      const files = (snapshot["files"] ?? {}) as FilesRecord;
-      snapshot["files"] = files;
-      const artifactsList = (files.artifacts ?? []) as string[];
-      files.artifacts = artifactsList;
-      if (!artifactsList.includes("run.db")) {
-        artifactsList.push("run.db");
-      }
-
-      if (trackTaskFilesEnabled) {
-        const tasks = (snapshot["tasks"] ?? {}) as Record<string, TaskRecord>;
-        snapshot["tasks"] = tasks;
-        const task = (tasks[taskName] ?? {}) as TaskRecord;
-        tasks[taskName] = task;
-        const taskFiles = (task.files ?? {}) as FilesRecord;
-        task.files = taskFiles;
-        const taskArtifactsList = (taskFiles.artifacts ?? []) as string[];
-        taskFiles.artifacts = taskArtifactsList;
-        if (!taskArtifactsList.includes("run.db")) {
-          taskArtifactsList.push("run.db");
-        }
-      }
+    void trackFile(jobDir, "artifacts", "run.db", taskName, trackTaskFilesEnabled).catch((err) => {
+      createJobLogger("file-io", basename(jobDir)).warn("getDB: manifest tracking failed", err);
     });
 
     return db;
@@ -314,28 +267,8 @@ export function createTaskFileIO(config: TaskFileIOConfig): TaskFileIO {
         renameSync(tmpPath, filePath);
       }
 
-      writeJobStatusSync(jobDir, (snapshot: Record<string, unknown>) => {
-        const files = (snapshot["files"] ?? {}) as FilesRecord;
-        snapshot["files"] = files;
-        const logsList = (files.logs ?? []) as string[];
-        files.logs = logsList;
-        if (!logsList.includes(name)) {
-          logsList.push(name);
-        }
-
-        if (trackTaskFilesEnabled) {
-          const tasks = (snapshot["tasks"] ?? {}) as Record<string, TaskRecord>;
-          snapshot["tasks"] = tasks;
-          const task = (tasks[taskName] ?? {}) as TaskRecord;
-          tasks[taskName] = task;
-          const taskFiles = (task.files ?? {}) as FilesRecord;
-          task.files = taskFiles;
-          const taskLogsList = (taskFiles.logs ?? []) as string[];
-          taskFiles.logs = taskLogsList;
-          if (!taskLogsList.includes(name)) {
-            taskLogsList.push(name);
-          }
-        }
+      void trackFile(jobDir, "logs", name, taskName, trackTaskFilesEnabled).catch((err) => {
+        createJobLogger("file-io", basename(jobDir)).warn("writeLogSync: manifest tracking failed", err);
       });
     },
 
@@ -348,6 +281,7 @@ export function createTaskFileIO(config: TaskFileIOConfig): TaskFileIO {
         return await executeBatch(db, options);
       } finally {
         db.close();
+        await flushJobStatus(jobDir);
       }
     },
   };