@tea-agent/loop-agent 0.1.0 → 0.2.0

package/dist/infrastructure/harness/artifact-store.js

@@ -0,0 +1,72 @@
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+import { writeJsonAtomic, writeTextAtomic, } from "./atomic-write.js";
+function resolveRepoRootFromDagRunDir(runDir) {
+    const normalized = path.resolve(runDir);
+    const lifecycleDir = path.dirname(normalized);
+    const dagRunsDir = path.dirname(lifecycleDir);
+    const harnessDir = path.dirname(dagRunsDir);
+    const repoRoot = path.dirname(harnessDir);
+    if (path.basename(harnessDir) !== ".harness" ||
+        path.basename(dagRunsDir) !== "dag-runs") {
+        return undefined;
+    }
+    return repoRoot;
+}
+function resolveRepoRootFromHarnessPath(targetPath) {
+    const normalized = path.resolve(targetPath);
+    const parts = normalized.split(path.sep);
+    const harnessIndex = parts.indexOf(".harness");
+    if (harnessIndex <= 0) {
+        return undefined;
+    }
+    return parts.slice(0, harnessIndex).join(path.sep);
+}
+function dagWriteOptions(runDir, options) {
+    return {
+        repoRoot: options?.repoRoot ?? resolveRepoRootFromDagRunDir(runDir),
+        allowCompletedFactsWrite: options?.allowCompletedFactsWrite,
+    };
+}
+function pathWriteOptions(targetPath, options) {
+    return {
+        repoRoot: options?.repoRoot ?? resolveRepoRootFromHarnessPath(targetPath),
+        allowCompletedFactsWrite: options?.allowCompletedFactsWrite,
+    };
+}
+function completedRelocationWriteOptions(runDir) {
+    return {
+        ...dagWriteOptions(runDir),
+        allowCompletedFactsWrite: true,
+    };
+}
+export function dagCursorSdkArtifactDir(runDir, nodeId) {
+    return path.join(runDir, "artifacts", nodeId);
+}
+export async function writeDagNodeTextArtifact(runDir, nodeId, fileName, content, options) {
+    const targetPath = path.join(runDir, nodeId, fileName);
+    await writeTextAtomic(targetPath, content, dagWriteOptions(runDir, options));
+    return targetPath;
+}
+export async function writeDagNodeJsonArtifact(runDir, nodeId, fileName, value, options) {
+    const targetPath = path.join(runDir, nodeId, fileName);
+    await writeJsonAtomic(targetPath, value, dagWriteOptions(runDir, options));
+    return targetPath;
+}
+export async function writeDagRunJsonArtifact(runDir, relativePath, value, options) {
+    const targetPath = path.join(runDir, relativePath);
+    await writeJsonAtomic(targetPath, value, dagWriteOptions(runDir, options));
+    return targetPath;
+}
+export async function ensureDagNodeArtifactDir(runDir, nodeId) {
+    const artifactDir = dagCursorSdkArtifactDir(runDir, nodeId);
+    await mkdir(artifactDir, { recursive: true });
+    return artifactDir;
+}
+export async function writeTextArtifactFile(targetPath, content, options) {
+    await writeTextAtomic(targetPath, content, pathWriteOptions(targetPath, options));
+}
+/** Rewrite node records after active/paused -> completed run-dir transfer. */
+export async function writeRelocatedDagNodeRecord(runDir, nodeId, record) {
+    await writeDagRunJsonArtifact(runDir, `${nodeId}.json`, record, completedRelocationWriteOptions(runDir));
+}

package/dist/infrastructure/harness/atomic-write.js

@@ -0,0 +1,49 @@
+import { copyFile, mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { assertHarnessWriteAllowed, } from "./completed-facts-guard.js";
+async function writeAtomic(targetPath, content, options) {
+    assertHarnessWriteAllowed(targetPath, options);
+    const resolved = options?.repoRoot && !path.isAbsolute(targetPath)
+        ? path.resolve(options.repoRoot, targetPath)
+        : path.resolve(targetPath);
+    await mkdir(path.dirname(resolved), { recursive: true });
+    const tempPath = `${resolved}.${process.pid}.tmp`;
+    try {
+        await writeFile(tempPath, content, "utf-8");
+        try {
+            await rename(tempPath, resolved);
+        }
+        catch {
+            await copyFile(tempPath, resolved);
+            await unlink(tempPath).catch(() => { });
+        }
+    }
+    catch (error) {
+        await unlink(tempPath).catch(() => { });
+        throw error;
+    }
+}
+export async function writeJsonAtomic(targetPath, value, options) {
+    const json = `${JSON.stringify(value, null, 2)}\n`;
+    await writeAtomic(targetPath, json, options);
+}
+export async function writeTextAtomic(targetPath, text, options) {
+    await writeAtomic(targetPath, text, options);
+}
+export function serializeJsonl(entries) {
+    if (entries.length === 0)
+        return "";
+    return `${entries.map((entry) => JSON.stringify(entry)).join("\n")}\n`;
+}
+export async function writeJsonlAtomic(targetPath, entries, options) {
+    await writeAtomic(targetPath, serializeJsonl(entries), options);
+}
+export async function appendJsonlLineAtomic(targetPath, entry, options) {
+    assertHarnessWriteAllowed(targetPath, options);
+    const resolved = options?.repoRoot && !path.isAbsolute(targetPath)
+        ? path.resolve(options.repoRoot, targetPath)
+        : path.resolve(targetPath);
+    const existing = await readFile(resolved, "utf-8").catch(() => "");
+    const prefix = existing.length === 0 || existing.endsWith("\n") ? existing : `${existing}\n`;
+    await writeAtomic(targetPath, `${prefix}${JSON.stringify(entry)}\n`, options);
+}

package/dist/infrastructure/harness/completed-facts-guard.js

@@ -0,0 +1,40 @@
+import path from "node:path";
+const COMPLETED_DAG_RUNS_PREFIX = ".harness/dag-runs/completed/";
+const COMPLETED_RUNS_PREFIX = ".harness/runs/completed/";
+/** Normalize a target path to a repo-relative POSIX path for guard checks. */
+export function normalizeHarnessRelativePath(targetPath, repoRoot) {
+    const posixInput = targetPath.split(path.sep).join("/");
+    if (!repoRoot) {
+        const normalized = posixInput.replace(/^\.\/+/, "");
+        const harnessIndex = normalized.indexOf("/.harness/");
+        if (harnessIndex >= 0) {
+            return normalized.slice(harnessIndex + 1);
+        }
+        return normalized;
+    }
+    const resolvedRoot = path.resolve(repoRoot);
+    const resolvedTarget = path.isAbsolute(targetPath)
+        ? path.resolve(targetPath)
+        : path.resolve(resolvedRoot, targetPath);
+    const relative = path.relative(resolvedRoot, resolvedTarget);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+        return posixInput.replace(/^\.\/+/, "");
+    }
+    return relative.split(path.sep).join("/");
+}
+function isCompletedFactsPath(relativePath) {
+    return (relativePath.startsWith(COMPLETED_DAG_RUNS_PREFIX) ||
+        relativePath === ".harness/dag-runs/completed" ||
+        relativePath.startsWith(COMPLETED_RUNS_PREFIX) ||
+        relativePath === ".harness/runs/completed");
+}
+/** Throw when a write would mutate completed DAG or one-shot run facts. */
+export function assertHarnessWriteAllowed(targetPath, options) {
+    if (options?.allowCompletedFactsWrite) {
+        return;
+    }
+    const relative = normalizeHarnessRelativePath(targetPath, options?.repoRoot);
+    if (isCompletedFactsPath(relative)) {
+        throw new Error(`harness write guard: refusing to mutate completed run facts: ${relative}`);
+    }
+}

package/dist/infrastructure/harness/loop-action-store.js

@@ -0,0 +1,23 @@
+import path from "node:path";
+import { writeJsonAtomic, writeTextAtomic, } from "./atomic-write.js";
+function loopActionFile(repoRoot, taskId, subdir, filename) {
+    return path.join(repoRoot, ".harness", "tasks", taskId, "loop", subdir, filename);
+}
+function loopActionWriteOptions(repoRoot) {
+    return { repoRoot };
+}
+export async function writeLoopShellVerifyRecord(repoRoot, taskId, round, record) {
+    await writeJsonAtomic(loopActionFile(repoRoot, taskId, "verification", `round-${round}.json`), record, loopActionWriteOptions(repoRoot));
+}
+export async function writeLoopCursorFixRecord(repoRoot, taskId, round, record) {
+    await writeJsonAtomic(loopActionFile(repoRoot, taskId, "reviews", `round-${round}-cursor-fix.json`), record, loopActionWriteOptions(repoRoot));
+}
+export async function writeLoopDagRecord(repoRoot, taskId, round, record) {
+    await writeJsonAtomic(loopActionFile(repoRoot, taskId, "dag", `round-${round}.json`), record, loopActionWriteOptions(repoRoot));
+}
+export async function writeLoopPiReviewRecord(repoRoot, taskId, round, record) {
+    await writeJsonAtomic(loopActionFile(repoRoot, taskId, "reviews", `round-${round}.json`), record, loopActionWriteOptions(repoRoot));
+}
+export async function writeLoopPiReviewPrompt(repoRoot, taskId, round, prompt) {
+    await writeTextAtomic(loopActionFile(repoRoot, taskId, "reviews", `round-${round}-prompt.md`), prompt, loopActionWriteOptions(repoRoot));
+}

package/dist/infrastructure/harness/loop-store.js

@@ -0,0 +1,41 @@
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+import { appendJsonlLineAtomic, writeJsonAtomic, writeJsonlAtomic, writeTextAtomic, } from "./atomic-write.js";
+function loopDir(repoRoot, taskId) {
+    return path.join(repoRoot, ".harness", "tasks", taskId, "loop");
+}
+function loopFile(repoRoot, taskId, filename) {
+    return path.join(loopDir(repoRoot, taskId), filename);
+}
+function loopWriteOptions(repoRoot) {
+    return { repoRoot };
+}
+export async function ensureLoopDir(repoRoot, taskId) {
+    const dir = loopDir(repoRoot, taskId);
+    await mkdir(dir, { recursive: true });
+    return dir;
+}
+export async function writeLoopState(repoRoot, taskId, state) {
+    await writeJsonAtomic(loopFile(repoRoot, taskId, "state.json"), state, loopWriteOptions(repoRoot));
+}
+export async function writeLoopObjective(repoRoot, taskId, text) {
+    await writeTextAtomic(loopFile(repoRoot, taskId, "objective.md"), text, loopWriteOptions(repoRoot));
+}
+export async function writeLoopContext(repoRoot, taskId, text) {
+    await writeTextAtomic(loopFile(repoRoot, taskId, "context.md"), text, loopWriteOptions(repoRoot));
+}
+export async function writeLoopCloseout(repoRoot, taskId, text) {
+    await writeTextAtomic(loopFile(repoRoot, taskId, "closeout.md"), text, loopWriteOptions(repoRoot));
+}
+export async function writeLoopRounds(repoRoot, taskId, entries) {
+    await writeJsonlAtomic(loopFile(repoRoot, taskId, "rounds.jsonl"), entries, loopWriteOptions(repoRoot));
+}
+export async function writeLoopSignals(repoRoot, taskId, entries) {
+    await writeJsonlAtomic(loopFile(repoRoot, taskId, "signals.jsonl"), entries, loopWriteOptions(repoRoot));
+}
+export async function writeLoopEvents(repoRoot, taskId, entries) {
+    await writeJsonlAtomic(loopFile(repoRoot, taskId, "events.jsonl"), entries, loopWriteOptions(repoRoot));
+}
+export async function appendLoopEventLine(repoRoot, taskId, entry) {
+    await appendJsonlLineAtomic(loopFile(repoRoot, taskId, "events.jsonl"), entry, loopWriteOptions(repoRoot));
+}

package/dist/infrastructure/harness/one-shot-run-store.js

@@ -0,0 +1,94 @@
+import { access, cp, mkdir, rename, rm, unlink } from "node:fs/promises";
+import path from "node:path";
+import { writeJsonAtomic, writeTextAtomic } from "./atomic-write.js";
+import { assertHarnessWriteAllowed } from "./completed-facts-guard.js";
+function runsDir(repoRoot, lifecycle) {
+    return path.join(repoRoot, ".harness", "runs", lifecycle);
+}
+function activeWriteOptions(repoRoot) {
+    return { repoRoot };
+}
+function completedTransferWriteOptions(repoRoot) {
+    return { repoRoot, allowCompletedFactsWrite: true };
+}
+export async function ensureOneShotRunDirs(repoRoot) {
+    for (const lifecycle of ["active", "completed", "failed"]) {
+        await mkdir(runsDir(repoRoot, lifecycle), { recursive: true });
+    }
+}
+/**
+ * If `baseName` already exists in the lifecycle dir, append `-2`, `-3`, etc.
+ */
+export async function resolveUniqueOneShotRunPath(repoRoot, lifecycle, baseName) {
+    const dir = runsDir(repoRoot, lifecycle);
+    let candidate = path.join(dir, baseName);
+    let counter = 1;
+    while (true) {
+        try {
+            await access(candidate);
+            counter += 1;
+            const ext = path.extname(baseName);
+            const stem = path.basename(baseName, ext);
+            candidate = path.join(dir, `${stem}-${counter}${ext}`);
+        }
+        catch {
+            return candidate;
+        }
+    }
+}
+export async function createOneShotActiveRunDir(repoRoot, baseName) {
+    await ensureOneShotRunDirs(repoRoot);
+    const runDir = await resolveUniqueOneShotRunPath(repoRoot, "active", baseName);
+    await mkdir(runDir, { recursive: true });
+    return runDir;
+}
+export async function writeOneShotRunMarkdown(repoRoot, runDir, content) {
+    await writeTextAtomic(path.join(runDir, "run.md"), content, activeWriteOptions(repoRoot));
+}
+export async function writeOneShotActiveLogAtPath(repoRoot, logPath, content) {
+    await writeTextAtomic(logPath, content, activeWriteOptions(repoRoot));
+}
+export async function writeOneShotRunMeta(repoRoot, runDir, meta) {
+    await writeJsonAtomic(path.join(runDir, "meta.json"), meta, activeWriteOptions(repoRoot));
+}
+async function moveRunDirectory(fromDir, toDir) {
+    await mkdir(path.dirname(toDir), { recursive: true });
+    try {
+        await rename(fromDir, toDir);
+    }
+    catch {
+        await cp(fromDir, toDir, { recursive: true });
+        await rm(fromDir, { recursive: true, force: true });
+    }
+}
+export async function transferOneShotRunToCompleted(repoRoot, activeRunDir, destBaseName) {
+    await ensureOneShotRunDirs(repoRoot);
+    const completedPath = await resolveUniqueOneShotRunPath(repoRoot, "completed", destBaseName);
+    assertHarnessWriteAllowed(completedPath, completedTransferWriteOptions(repoRoot));
+    await moveRunDirectory(activeRunDir, completedPath);
+    return completedPath;
+}
+export async function transferOneShotRunToFailed(repoRoot, activeRunDir, destBaseName) {
+    await ensureOneShotRunDirs(repoRoot);
+    const failedPath = await resolveUniqueOneShotRunPath(repoRoot, "failed", destBaseName);
+    assertHarnessWriteAllowed(failedPath, activeWriteOptions(repoRoot));
+    await moveRunDirectory(activeRunDir, failedPath);
+    return failedPath;
+}
+/**
+ * Legacy `.md`-only finalize path: move or rewrite a flat log into completed/.
+ * Completed writes use the guarded transfer bypass inside this store.
+ */
+export async function finalizeLegacyRunLogToCompleted(repoRoot, logPath, content) {
+    await ensureOneShotRunDirs(repoRoot);
+    const completedDir = runsDir(repoRoot, "completed");
+    const completedPath = path.join(completedDir, path.basename(logPath));
+    try {
+        await rename(logPath, completedPath);
+    }
+    catch {
+        await writeTextAtomic(completedPath, content, completedTransferWriteOptions(repoRoot));
+        await unlink(logPath).catch(() => { });
+    }
+    return completedPath;
+}

package/dist/infrastructure/harness/task-store.js

@@ -0,0 +1,77 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { appendJsonlLineAtomic, writeJsonAtomic, writeTextAtomic, } from "./atomic-write.js";
+function taskDir(repoRoot, taskId) {
+    return path.join(repoRoot, ".harness", "tasks", taskId);
+}
+function taskFile(repoRoot, taskId, filename) {
+    return path.join(taskDir(repoRoot, taskId), filename);
+}
+function taskWriteOptions(repoRoot) {
+    return { repoRoot };
+}
+export function resolveTaskContextFromDir(taskDir) {
+    const normalized = path.resolve(taskDir);
+    const taskId = path.basename(normalized);
+    const tasksDir = path.dirname(normalized);
+    const harnessDir = path.dirname(tasksDir);
+    const repoRoot = path.dirname(harnessDir);
+    if (path.basename(tasksDir) !== "tasks" || path.basename(harnessDir) !== ".harness") {
+        throw new Error(`invalid task dir: ${taskDir}`);
+    }
+    return { repoRoot, taskId };
+}
+export function resolveTaskStateContext(statePath) {
+    const normalized = path.resolve(statePath);
+    const filename = path.basename(normalized);
+    if (filename !== ".workflow_state.json") {
+        throw new Error(`invalid workflow state path: ${statePath}`);
+    }
+    const taskId = path.basename(path.dirname(normalized));
+    const tasksDir = path.dirname(path.dirname(normalized));
+    const harnessDir = path.dirname(tasksDir);
+    const repoRoot = path.dirname(harnessDir);
+    if (path.basename(tasksDir) !== "tasks" || path.basename(harnessDir) !== ".harness") {
+        throw new Error(`invalid workflow state path: ${statePath}`);
+    }
+    return { repoRoot, taskId };
+}
+export async function writeTaskConfig(repoRoot, taskId, config) {
+    await writeJsonAtomic(taskFile(repoRoot, taskId, "task.json"), config, taskWriteOptions(repoRoot));
+}
+export async function writeWorkflowState(repoRoot, taskId, state) {
+    const options = taskWriteOptions(repoRoot);
+    const stateFile = taskFile(repoRoot, taskId, ".workflow_state.json");
+    const bakFile = `${stateFile}.bak`;
+    await writeJsonAtomic(stateFile, state, options);
+    await writeJsonAtomic(bakFile, state, options);
+}
+export async function initializeTaskLogStubs(repoRoot, taskId) {
+    const options = taskWriteOptions(repoRoot);
+    const logsDir = path.join(taskDir(repoRoot, taskId), "logs");
+    await writeTextAtomic(path.join(logsDir, "executor.jsonl"), "", options);
+    await writeTextAtomic(path.join(logsDir, "decisions.jsonl"), "", options);
+}
+function taskArtifactFile(repoRoot, taskId, fileName) {
+    return path.join(taskDir(repoRoot, taskId), "artifacts", fileName);
+}
+function taskLogFile(repoRoot, taskId, fileName) {
+    return path.join(taskDir(repoRoot, taskId), "logs", fileName);
+}
+export async function writeTaskArtifactFile(repoRoot, taskId, fileName, content) {
+    await writeTextAtomic(taskArtifactFile(repoRoot, taskId, fileName), content, taskWriteOptions(repoRoot));
+}
+export async function appendTaskWorkflowLog(repoRoot, taskId, message) {
+    const options = taskWriteOptions(repoRoot);
+    const logPath = taskLogFile(repoRoot, taskId, "workflow.log");
+    const resolved = options.repoRoot && !path.isAbsolute(logPath)
+        ? path.resolve(options.repoRoot, logPath)
+        : path.resolve(logPath);
+    const existing = await readFile(resolved, "utf-8").catch(() => "");
+    const line = `[${new Date().toISOString()}] ${message}\n`;
+    const prefix = existing.length === 0 || existing.endsWith("\n") ? existing : `${existing}\n`;
+    await writeTextAtomic(logPath, `${prefix}${line}`, options);
+}
+export async function appendTaskLogJsonlRecord(repoRoot, taskId, fileName, record) {
+    await appendJsonlLineAtomic(taskLogFile(repoRoot, taskId, fileName), record, taskWriteOptions(repoRoot));
+}

package/dist/records/one-shot-runs.js

@@ -1,6 +1,7 @@
-import { access, cp, mkdir, readdir, readFile, rename, rm, unlink, writeFile } from 'node:fs/promises';
+import { access, readdir, readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { truncateOutput } from '../executors/cursor-executor.js';
+import { createOneShotActiveRunDir, ensureOneShotRunDirs, finalizeLegacyRunLogToCompleted, transferOneShotRunToCompleted, transferOneShotRunToFailed, writeOneShotActiveLogAtPath, writeOneShotRunMarkdown, writeOneShotRunMeta, } from '../infrastructure/harness/one-shot-run-store.js';
 /** Maximum chars for result summary in the run log. */
 export const RUN_LOG_RESULT_MAX = 4_000;
 /** Placeholder written to active logs before execution finishes. */
@@ -19,11 +20,7 @@ export async function computeRunDir(cwd, task) {
     }
     const datePrefix = new Date().toISOString().slice(0, 10);
     const slug = deriveRunSlug(task);
-    const activeDir = path.join(harnessDir, 'runs', 'active');
-    await mkdir(activeDir, { recursive: true });
-    const runDir = await resolveUniqueRunPath(activeDir, `${datePrefix}-${slug}`);
-    await mkdir(runDir, { recursive: true });
-    return runDir;
+    return createOneShotActiveRunDir(cwd, `${datePrefix}-${slug}`);
 }
 /**
  * Persist a human-readable run log under `.harness/runs/`.
@@ -46,44 +43,25 @@ export async function persistCursorRunLog(cwd, input) {
     const datePrefix = new Date().toISOString().slice(0, 10);
     const slug = deriveRunSlug(input.task);
     const baseName = `${datePrefix}-${slug}`;
-    const activeDir = path.join(harnessDir, 'runs', 'active');
-    const completedDir = path.join(harnessDir, 'runs', 'completed');
-    const failedDir = path.join(harnessDir, 'runs', 'failed');
-    await mkdir(activeDir, { recursive: true });
-    await mkdir(completedDir, { recursive: true });
-    await mkdir(failedDir, { recursive: true });
-    const activeRunDir = input.runDir ?? await resolveUniqueRunPath(activeDir, baseName);
-    await mkdir(activeRunDir, { recursive: true });
+    await ensureOneShotRunDirs(cwd);
+    const activeRunDir = input.runDir ?? await createOneShotActiveRunDir(cwd, baseName);
     const content = buildRunLogMarkdown(input);
-    const activePath = path.join(activeRunDir, 'run.md');
-    await writeFile(activePath, content, 'utf-8');
-    await writeRunMeta(activeRunDir, input);
+    await writeOneShotRunMarkdown(cwd, activeRunDir, content);
+    await writeRunMeta(cwd, activeRunDir, input);
     if (input.result.ok) {
-        const completedPath = await resolveUniqueRunPath(completedDir, path.basename(activeRunDir));
-        await moveRunDirectory(activeRunDir, completedPath);
+        const completedPath = await transferOneShotRunToCompleted(cwd, activeRunDir, path.basename(activeRunDir));
         return { logPath: path.join(completedPath, 'run.md'), completed: true };
     }
-    const failedPath = await resolveUniqueRunPath(failedDir, path.basename(activeRunDir));
     if (input.result.status === 'failed' || input.result.status === 'timeout' || input.result.status === 'cancelled') {
-        await moveRunDirectory(activeRunDir, failedPath);
+        const failedPath = await transferOneShotRunToFailed(cwd, activeRunDir, path.basename(activeRunDir));
         return { logPath: path.join(failedPath, 'run.md'), completed: false };
     }
-    return { logPath: activePath, completed: false };
+    return { logPath: path.join(activeRunDir, 'run.md'), completed: false };
 }
-async function moveRunDirectory(fromDir, toDir) {
-    await mkdir(path.dirname(toDir), { recursive: true });
-    try {
-        await rename(fromDir, toDir);
-    }
-    catch {
-        await cp(fromDir, toDir, { recursive: true });
-        await rm(fromDir, { recursive: true, force: true });
-    }
-}
-async function writeRunMeta(runDir, input, statusOverride) {
+async function writeRunMeta(repoRoot, runDir, input, statusOverride) {
     const runId = path.basename(runDir);
     const status = statusOverride ?? (input.result.ok ? 'completed' : input.result.status);
-    await writeFile(path.join(runDir, 'meta.json'), `${JSON.stringify({
+    await writeOneShotRunMeta(repoRoot, runDir, {
         runId,
         taskId: input.taskId,
         status,
@@ -95,7 +73,7 @@ async function writeRunMeta(runDir, input, statusOverride) {
         failureCategory: input.result.failureCategory,
         artifactsDir: 'artifacts',
         logPath: 'run.md',
-    }, null, 2)}\n`, 'utf-8');
+    });
 }
 function isRunMarkdownPath(logPath) {
     return path.basename(logPath) === 'run.md';
@@ -119,16 +97,10 @@ export async function createActiveCursorRun(cwd, input) {
     const datePrefix = new Date().toISOString().slice(0, 10);
     const slug = deriveRunSlug(input.task);
     const baseName = `${datePrefix}-${slug}`;
-    const activeDir = path.join(harnessDir, 'runs', 'active');
-    await mkdir(activeDir, { recursive: true });
-    await mkdir(path.join(harnessDir, 'runs', 'completed'), { recursive: true });
-    await mkdir(path.join(harnessDir, 'runs', 'failed'), { recursive: true });
-    const activeRunDir = await resolveUniqueRunPath(activeDir, baseName);
-    await mkdir(activeRunDir, { recursive: true });
-    const activePath = path.join(activeRunDir, 'run.md');
+    const activeRunDir = await createOneShotActiveRunDir(cwd, baseName);
     const content = buildActiveRunLogMarkdown(input);
-    await writeFile(activePath, content, 'utf-8');
-    await writeRunMeta(activeRunDir, {
+    await writeOneShotRunMarkdown(cwd, activeRunDir, content);
+    await writeRunMeta(cwd, activeRunDir, {
         taskId: input.taskId,
         task: input.task,
         model: input.model,
@@ -144,7 +116,7 @@ export async function createActiveCursorRun(cwd, input) {
             stderr: '',
         },
     }, 'running');
-    return { logPath: activePath, taskId: input.taskId };
+    return { logPath: path.join(activeRunDir, 'run.md'), taskId: input.taskId };
 }
 /**
  * Finalize an active run log with execution results.
@@ -157,30 +129,23 @@ export async function finalizeCursorRunLog(logPath, input) {
     const existing = await readFile(logPath, 'utf-8').catch(() => '');
     const taskId = existing ? parseCursorRunLog(existing, logPath).taskId : undefined;
     const content = buildRunLogMarkdown({ ...input, taskId });
-    await writeFile(logPath, content, 'utf-8');
     const activeRunDir = runDirForLogPath(logPath);
     if (activeRunDir) {
-        await writeRunMeta(activeRunDir, { ...input, taskId });
+        await writeOneShotRunMarkdown(input.cwd, activeRunDir, content);
+        await writeRunMeta(input.cwd, activeRunDir, { ...input, taskId });
+    }
+    else {
+        await writeOneShotActiveLogAtPath(input.cwd, logPath, content);
     }
-    const targetLifecycle = input.result.ok ? 'completed' : 'failed';
-    const targetDir = path.join(harnessDir, 'runs', targetLifecycle);
-    await mkdir(targetDir, { recursive: true });
     if (isRunMarkdownPath(logPath)) {
-        const completedPath = await resolveUniqueRunPath(targetDir, path.basename(path.dirname(logPath)));
-        await moveRunDirectory(path.dirname(logPath), completedPath);
-        return { logPath: path.join(completedPath, 'run.md'), completed: input.result.ok };
+        const transfer = input.result.ok ? transferOneShotRunToCompleted : transferOneShotRunToFailed;
+        const destDir = await transfer(input.cwd, path.dirname(logPath), path.basename(path.dirname(logPath)));
+        return { logPath: path.join(destDir, 'run.md'), completed: input.result.ok };
     }
     if (!input.result.ok) {
         return { logPath, completed: false };
     }
-    const completedPath = path.join(targetDir, path.basename(logPath));
-    try {
-        await rename(logPath, completedPath);
-    }
-    catch {
-        await writeFile(completedPath, content, 'utf-8');
-        await unlink(logPath).catch(() => { });
-    }
+    const completedPath = await finalizeLegacyRunLogToCompleted(input.cwd, logPath, content);
     return { logPath: completedPath, completed: true };
 }
 /**

package/dist/records/promotion.js

@@ -1,6 +1,6 @@
 import { mkdir, readFile, readdir, stat, writeFile } from 'node:fs/promises';
 import path from 'node:path';
-import { getArtifactPath } from '../shared/artifacts-core.js';
+import { getArtifactPath, writeArtifactForStep } from '../shared/artifacts-core.js';
 import { getDagRunDir, readDagRunState } from '../workflows/dag/lifecycle.js';
 import { parseCursorRunLog, resolveRunStatus } from './one-shot-runs.js';
 import { getTaskDir } from '../task/runtime.js';
@@ -52,9 +52,8 @@ async function writePromotion(repoRoot, taskId, runId, sourceKind, modifyLog, ve
     const taskDir = getTaskDir(repoRoot, taskId);
     const modifyLogPath = getArtifactPath(taskDir, 'implement');
     const verifyResultPath = getArtifactPath(taskDir, 'verify');
-    await mkdir(path.dirname(modifyLogPath), { recursive: true });
-    await writeFile(modifyLogPath, modifyLog, 'utf-8');
-    await writeFile(verifyResultPath, verifyResult, 'utf-8');
+    await writeArtifactForStep(taskDir, 'implement', modifyLog);
+    await writeArtifactForStep(taskDir, 'verify', verifyResult);
     return { taskId, runId, sourceKind, modifyLogPath, verifyResultPath };
 }
 async function loadCompletedDagEvidence(repoRoot, runId) {

package/dist/shared/artifacts-core.js

@@ -1,5 +1,5 @@
-import { mkdir, writeFile } from 'node:fs/promises';
 import path from 'node:path';
+import { resolveTaskContextFromDir, writeTaskArtifactFile, } from '../infrastructure/harness/task-store.js';
 export const ARTIFACTS_DIR = 'artifacts';
 const SPEC_ARTIFACT_STEPS = ['analyze', 'plan'];
 const DEFAULT_ARTIFACTS = {
@@ -42,15 +42,15 @@ const REQUIRED_HEADINGS = {
     retrospective: ['# 复盘报告', '## 1. 质量复盘'],
 };
 export async function initializeArtifacts(taskDir) {
-    const artifactsDir = path.join(taskDir, 'artifacts');
-    await mkdir(artifactsDir, { recursive: true });
-    await Promise.all(Object.entries(DEFAULT_ARTIFACTS).map(([name, content]) => writeFile(path.join(artifactsDir, name), content, 'utf-8')));
+    const { repoRoot, taskId } = resolveTaskContextFromDir(taskDir);
+    await Promise.all(Object.entries(DEFAULT_ARTIFACTS).map(([name, content]) => writeTaskArtifactFile(repoRoot, taskId, name, content)));
 }
 export function getArtifactPath(taskDir, step) {
     return path.join(taskDir, ARTIFACTS_DIR, getArtifactFileName(step));
 }
 export async function writeArtifactForStep(taskDir, step, content) {
-    await writeFile(getArtifactPath(taskDir, step), `${content.trim()}\n`, 'utf-8');
+    const { repoRoot, taskId } = resolveTaskContextFromDir(taskDir);
+    await writeTaskArtifactFile(repoRoot, taskId, getArtifactFileName(step), `${content.trim()}\n`);
 }
 function normalizeArtifactContent(content) {
     return content.replace(/\r/g, '').trim().replace(/\s+/g, ' ');

package/dist/shared/logger.js

@@ -1,23 +1,17 @@
-import { appendFile, mkdir } from 'node:fs/promises';
-import path from 'node:path';
+import { appendTaskLogJsonlRecord, appendTaskWorkflowLog, resolveTaskContextFromDir, } from '../infrastructure/harness/task-store.js';
 export async function appendWorkflowLog(taskDir, message) {
-    const logsDir = path.join(taskDir, 'logs');
-    await mkdir(logsDir, { recursive: true });
-    const line = `[${new Date().toISOString()}] ${message}\n`;
-    await appendFile(path.join(logsDir, 'workflow.log'), line, 'utf-8');
+    const { repoRoot, taskId } = resolveTaskContextFromDir(taskDir);
+    await appendTaskWorkflowLog(repoRoot, taskId, message);
 }
 export async function appendExecutorRecord(taskDir, record) {
-    const logsDir = path.join(taskDir, 'logs');
-    await mkdir(logsDir, { recursive: true });
-    await appendFile(path.join(logsDir, 'executor.jsonl'), `${JSON.stringify(record)}\n`, 'utf-8');
+    const { repoRoot, taskId } = resolveTaskContextFromDir(taskDir);
+    await appendTaskLogJsonlRecord(repoRoot, taskId, 'executor.jsonl', record);
 }
 export async function appendDecisionRecord(taskDir, record) {
-    const logsDir = path.join(taskDir, 'logs');
-    await mkdir(logsDir, { recursive: true });
-    await appendFile(path.join(logsDir, 'decisions.jsonl'), `${JSON.stringify(record)}\n`, 'utf-8');
+    const { repoRoot, taskId } = resolveTaskContextFromDir(taskDir);
+    await appendTaskLogJsonlRecord(repoRoot, taskId, 'decisions.jsonl', record);
 }
 export async function appendGoalEventRecord(taskDir, record) {
-    const logsDir = path.join(taskDir, 'logs');
-    await mkdir(logsDir, { recursive: true });
-    await appendFile(path.join(logsDir, 'goal-events.jsonl'), `${JSON.stringify(record)}\n`, 'utf-8');
+    const { repoRoot, taskId } = resolveTaskContextFromDir(taskDir);
+    await appendTaskLogJsonlRecord(repoRoot, taskId, 'goal-events.jsonl', record);
 }