@tea-agent/loop-agent 0.2.1 → 0.4.0

package/dist/worker/run-task/run-task.js

@@ -0,0 +1,359 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { formatDuration, noopProgressReporter } from "../progress-reporter.js";
+import { materializeTaskSpec, } from "../materialize/harness-task-materializer.js";
+import { preflightTargetRepo } from "../preflight.js";
+export const DEFAULT_RUN_DAG_TIMEOUT_MS = 1_800_000;
+export const MAX_WORKER_TIMEOUT_MS = 7_200_000;
+export async function runTaskSpec(options) {
+    const now = options.now ?? new Date();
+    const workerRunId = options.workerRunId ?? buildWorkerRunId(options.taskSpec.id, now);
+    const commands = [];
+    const client = new RecordingRunTaskClient(options.client, commands);
+    const progress = options.progress ?? noopProgressReporter;
+    if (options.preflight !== false) {
+        progress.step("preflight: version + inspect + docs-audit + git-status" + (options.preflight && typeof options.preflight === "object" && options.preflight.runCheckRepo ? " + check-repo" : ""));
+        const preflightStartedAt = Date.now();
+        const preflight = await preflightTargetRepo({
+            repoRoot: options.repoRoot,
+            client,
+            ...(typeof options.preflight === "object" ? options.preflight : {}),
+        });
+        if (!preflight.ok) {
+            progress.note(`preflight FAILED: ${preflight.code}`);
+            throw new Error(`target repo preflight failed: ${preflight.code}: ${preflight.message}`);
+        }
+        progress.step(`preflight ok in ${formatDuration(Date.now() - preflightStartedAt)}`);
+    }
+    progress.step("materialize harness task");
+    const materializeStartedAt = Date.now();
+    const materializeManifest = await materializeTaskSpec({
+        repoRoot: options.repoRoot,
+        taskSpec: options.taskSpec,
+        taskSpecPath: options.taskSpecPath,
+        client,
+        now,
+    });
+    progress.step(`materialized ${materializeManifest.harnessTaskId} in ${formatDuration(Date.now() - materializeStartedAt)}`);
+    const taskArtifactsDir = path.join(options.repoRoot, ".harness", "tasks", materializeManifest.harnessTaskId, "artifacts");
+    await mkdir(taskArtifactsDir, { recursive: true });
+    const dagPath = path.join(taskArtifactsDir, `${workerRunId}-dag.json`);
+    const runRecordPath = path.join(taskArtifactsDir, "worker-run-record.json");
+    progress.step("dag run-task: generate DAG");
+    const dagGenStartedAt = Date.now();
+    await runRequiredCommand(options.repoRoot, client, "dag-run-task", [
+        "dag",
+        "run-task",
+        materializeManifest.harnessTaskId,
+        "--profile",
+        materializeManifest.loopAgentProfile,
+        "--strict-models",
+        "--output",
+        dagPath,
+        "--cwd",
+        options.repoRoot,
+        ...noCursorArgs(options.taskSpec),
+    ]);
+    progress.step(`dag generated in ${formatDuration(Date.now() - dagGenStartedAt)}`);
+    if (options.piModel) {
+        progress.step(`pi-model override: rewriting executorModels.pi → ${options.piModel}`);
+        await applyPiModelOverride(dagPath, options.piModel);
+    }
+    progress.step("dag validate");
+    const validateStartedAt = Date.now();
+    await runRequiredCommand(options.repoRoot, client, "dag-validate", [
+        "dag",
+        "validate",
+        "--dag",
+        dagPath,
+        ...strictModelsArgs(options.piModel),
+        "--strict-governance",
+        "--spine-task",
+        materializeManifest.harnessTaskId,
+        ...forbidCursorArgs(options.taskSpec),
+    ]);
+    progress.step(`dag validated in ${formatDuration(Date.now() - validateStartedAt)}`);
+    progress.step("run-dag: executing DAG nodes (this is the long step)");
+    const runDagStartedAt = Date.now();
+    await runRequiredCommand(options.repoRoot, client, "run-dag", [
+        "run-dag",
+        "--dag",
+        dagPath,
+        "--cwd",
+        options.repoRoot,
+        "--run-id",
+        workerRunId,
+        ...maxConcurrentArgs(options.taskSpec),
+        ...noCursorArgs(options.taskSpec),
+    ], true, resolveRunDagTimeoutMs(options.taskSpec));
+    progress.step(`run-dag finished in ${formatDuration(Date.now() - runDagStartedAt)}`);
+    const reportJson = await client.run([
+        "dag",
+        "report",
+        "--run-id",
+        workerRunId,
+        "--lifecycle",
+        "all",
+        "--json",
+    ], {
+        cwd: options.repoRoot,
+        artifactName: "dag-report-json",
+        expectJson: true,
+    });
+    const reportDecision = decideFromReport(workerRunId, reportJson);
+    await client.run([
+        "dag",
+        "report",
+        "--run-id",
+        workerRunId,
+        "--lifecycle",
+        "all",
+        "--markdown",
+    ], {
+        cwd: options.repoRoot,
+        artifactName: "dag-report-markdown",
+    });
+    const status = reportDecision.succeeded ? "succeeded" : "failed";
+    progress.step(`report decision: ${status} (${reportDecision.reason}${reportDecision.runStatus ? `, status=${reportDecision.runStatus}` : ""})`);
+    const failureArtifacts = reportDecision.succeeded
+        ? undefined
+        : await collectFailureArtifacts({
+            client,
+            repoRoot: options.repoRoot,
+            workerRunId,
+            taskArtifactsDir,
+        });
+    if (reportDecision.succeeded) {
+        progress.step("promote + closeout");
+        await runRequiredCommand(options.repoRoot, client, "promote-run", ["promote-run", materializeManifest.harnessTaskId, "--run-id", workerRunId], true);
+        await runRequiredCommand(options.repoRoot, client, "closeout-task", ["closeout", "task", materializeManifest.harnessTaskId], true);
+    }
+    const record = {
+        schemaVersion: 1,
+        status,
+        workerRunId,
+        businessId: options.taskSpec.id,
+        harnessTaskId: materializeManifest.harnessTaskId,
+        featureId: options.taskSpec.feature_id,
+        loopAgentProfile: materializeManifest.loopAgentProfile,
+        dagPath,
+        runRecordPath,
+        materializeManifest,
+        reportDecision,
+        commands,
+        ...(failureArtifacts ? { failureArtifacts } : {}),
+    };
+    await writeFile(runRecordPath, `${JSON.stringify(record, null, 2)}\n`, "utf-8");
+    return {
+        status,
+        workerRunId,
+        businessId: options.taskSpec.id,
+        harnessTaskId: materializeManifest.harnessTaskId,
+        runRecordPath,
+        dagPath,
+        reportDecision,
+        ...(failureArtifacts ? { failureArtifacts } : {}),
+    };
+}
+export function buildWorkerRunId(businessId, now) {
+    const date = now.toISOString().slice(0, 10).replace(/-/g, "");
+    const hash = createHash("sha256")
+        .update(`${businessId}:${now.toISOString()}`)
+        .digest("hex")
+        .slice(0, 6);
+    return `wr-${date}-${businessId}-${hash}`;
+}
+async function runRequiredCommand(repoRoot, client, artifactName, args, expectJson = true, timeoutMs) {
+    const result = await client.run(args, {
+        cwd: repoRoot,
+        artifactName,
+        expectJson,
+        ...(timeoutMs === undefined ? {} : { timeoutMs }),
+    });
+    if (!result.ok) {
+        throw new Error(`loop-agent command failed: ${args.join(" ")}`);
+    }
+    return result;
+}
+function resolveRunDagTimeoutMs(taskSpec) {
+    return Math.min(taskSpec.worker.timeout_ms ?? DEFAULT_RUN_DAG_TIMEOUT_MS, MAX_WORKER_TIMEOUT_MS);
+}
+async function collectFailureArtifacts(input) {
+    const doctor = await input.client.run(["dag", "doctor", "--run-id", input.workerRunId, "--markdown"], {
+        cwd: input.repoRoot,
+        artifactName: "dag-doctor-markdown",
+    });
+    const closeoutDraftPath = path.join(input.repoRoot, ".task-pool", "failure-handoffs", `${input.workerRunId}-failure-closeout-draft.md`);
+    await input.client.run([
+        "dag",
+        "closeout-draft",
+        "--run-id",
+        input.workerRunId,
+        "--output",
+        closeoutDraftPath,
+    ], {
+        cwd: input.repoRoot,
+        artifactName: "dag-closeout-draft",
+    });
+    const reportMarkdown = input.client instanceof RecordingRunTaskClient
+        ? input.client.findArtifact("dag-report-markdown")
+        : undefined;
+    return {
+        reportMarkdownArtifactPath: reportMarkdown?.result.artifacts.stdoutPath ?? "",
+        doctorMarkdownArtifactPath: doctor.artifacts.stdoutPath,
+        closeoutDraftPath,
+    };
+}
+function decideFromReport(workerRunId, result) {
+    if (!result.ok || !result.json) {
+        return {
+            succeeded: false,
+            reason: "report-json-unavailable",
+        };
+    }
+    const runs = readObjectArray(result.json, "runs");
+    const run = runs.find((candidate) => readString(candidate, "runId") === workerRunId) ??
+        runs[0];
+    if (!run) {
+        return {
+            succeeded: false,
+            reason: "report-run-missing",
+        };
+    }
+    const runStatus = readString(run, "status");
+    const nodes = readObjectArray(run, "nodes");
+    const failedNode = nodes.find((node) => {
+        const status = readString(node, "status");
+        const failureCategory = readString(node, "failureCategory");
+        return (status === "ERROR" ||
+            status === "SKIPPED" ||
+            (Boolean(failureCategory) && failureCategory !== "success"));
+    });
+    if (runStatus !== "completed" && runStatus !== "finished") {
+        return {
+            succeeded: false,
+            reason: "run-not-completed",
+            runStatus,
+            primaryFailure: readProperty(run, "primaryFailure"),
+        };
+    }
+    if (failedNode) {
+        return {
+            succeeded: false,
+            reason: "node-failure",
+            runStatus,
+            primaryFailure: readProperty(run, "primaryFailure") ?? failedNode,
+        };
+    }
+    return {
+        succeeded: true,
+        reason: "report-completed",
+        runStatus,
+        primaryFailure: readProperty(run, "primaryFailure"),
+    };
+}
+class RecordingRunTaskClient {
+    delegate;
+    records;
+    constructor(delegate, records) {
+        this.delegate = delegate;
+        this.records = records;
+    }
+    async run(args, options) {
+        const result = await this.delegate.run(args, options);
+        this.records.push({
+            name: commandRecordName(args, options.artifactName),
+            artifactName: options.artifactName,
+            args,
+            result: {
+                ok: result.ok,
+                exitCode: result.exitCode,
+                durationMs: result.durationMs,
+                timedOut: result.timedOut,
+                artifacts: result.artifacts,
+                ...(result.parseFailure ? { parseFailure: result.parseFailure } : {}),
+            },
+        });
+        return result;
+    }
+    async runExternal(command, args, options) {
+        const result = await this.delegate.runExternal(command, args, options);
+        this.records.push({
+            name: options.artifactName,
+            artifactName: options.artifactName,
+            args: [command, ...args],
+            result: {
+                ok: result.ok,
+                exitCode: result.exitCode,
+                durationMs: result.durationMs,
+                timedOut: result.timedOut,
+                artifacts: result.artifacts,
+                ...(result.parseFailure ? { parseFailure: result.parseFailure } : {}),
+            },
+        });
+        return result;
+    }
+    findArtifact(artifactName) {
+        return this.records.find((record) => record.artifactName === artifactName);
+    }
+}
+function commandRecordName(args, artifactName) {
+    if (args[0] === "new-task")
+        return "new-task";
+    return artifactName;
+}
+function noCursorArgs(taskSpec) {
+    return taskSpec.loop_agent.no_cursor ? ["--no-cursor"] : [];
+}
+function forbidCursorArgs(taskSpec) {
+    return taskSpec.loop_agent.no_cursor ? ["--forbid-executor", "cursor"] : [];
+}
+function maxConcurrentArgs(taskSpec) {
+    return ["--max-concurrent", String(taskSpec.loop_agent.max_concurrent)];
+}
+/**
+ * When a smoke `piModel` override is active, drop `--strict-models` so the
+ * non-canonical `executorModels.pi` rewrite passes `dag validate`. Governance,
+ * forbidden-executor and spine audits are still enforced by their own flags.
+ */
+function strictModelsArgs(piModel) {
+    return piModel ? [] : ["--strict-models"];
+}
+/**
+ * Rewrite `executorModels.pi.{LOW,MED,HIGH}` in an already-generated DAG JSON
+ * so every pi executor node resolves to the smoke override model. Cursor / shell
+ * slots are left untouched.
+ */
+export async function applyPiModelOverride(dagPath, piModel) {
+    const raw = await readFile(dagPath, "utf-8");
+    const spec = JSON.parse(raw);
+    spec.executorModels = {
+        ...(spec.executorModels?.cursor ? { cursor: spec.executorModels.cursor } : {}),
+        pi: {
+            LOW: piModel,
+            MED: piModel,
+            HIGH: piModel,
+        },
+    };
+    await writeFile(dagPath, `${JSON.stringify(spec, null, 2)}\n`, "utf-8");
+}
+function readObjectArray(value, key) {
+    if (!value || typeof value !== "object")
+        return [];
+    const child = value[key];
+    if (!Array.isArray(child))
+        return [];
+    return child.filter((item) => Boolean(item) && typeof item === "object" && !Array.isArray(item));
+}
+function readString(value, key) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const child = value[key];
+    return typeof child === "string" ? child : undefined;
+}
+function readProperty(value, key) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    return value[key];
+}

package/dist/worker/runner/run-ready.js

@@ -0,0 +1,216 @@
+import { createHash } from "node:crypto";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import path from "node:path";
+import YAML from "yaml";
+import { deriveFailureRoute } from "../pool/failure-routing.js";
+import { findRunByWorkerRunId, getTaskPoolRoot, readAllTaskPoolStates, recordTaskPoolRun, writeTaskPoolState, } from "../pool/run-store.js";
+import { runTaskSpec, } from "../run-task/run-task.js";
+import { formatDuration, noopProgressReporter } from "../progress-reporter.js";
+import { computeReadyQueue } from "../task-graph/ready-queue.js";
+import { taskGraphSpecSchema } from "../task-graph/task-graph-schema.js";
+import { taskSpecSchema } from "../task-spec/schema.js";
+export async function runReadyTasks(options) {
+    const now = options.now ?? new Date();
+    const startedAt = now.toISOString();
+    const batchRunId = options.batchRunId ?? buildBatchRunId(now);
+    const graph = await loadTaskGraph(options.featureDir);
+    const states = await readAllTaskPoolStates(options.repoRoot);
+    const readyTaskIds = computeReadyQueue(graph, toGraphState(states)).filter((taskId) => isPoolReady(states[taskId]));
+    const limitedTaskIds = readyTaskIds.slice(0, options.limit ?? readyTaskIds.length);
+    const tasks = [];
+    const runner = options.runTask ?? runTaskSpec;
+    const progress = options.progress ?? noopProgressReporter;
+    const total = limitedTaskIds.length;
+    let index = 0;
+    const batchStartedAt = Date.now();
+    progress.batch(`batch ${batchRunId}: feature=${graph.feature_id}, ${total} task${total === 1 ? "" : "s"} ready → starting`);
+    for (const taskId of limitedTaskIds) {
+        index += 1;
+        const node = graph.nodes.find((candidate) => candidate.id === taskId);
+        const taskSpecPath = path.join(options.featureDir, "tasks", node?.task ?? `${taskId}.yaml`);
+        const taskSpec = await loadTaskSpec(taskSpecPath);
+        const workerRunId = options.workerRunIdForTask?.(taskId, taskSpec) ??
+            buildStableWorkerRunId(taskId, taskSpec, now);
+        if (workerRunId) {
+            const existing = await findRunByWorkerRunId(options.repoRoot, workerRunId);
+            if (existing) {
+                progress.task(`task ${index}/${total} ${taskId}: reuse existing run ${workerRunId}`);
+                tasks.push({
+                    taskId,
+                    workerRunId,
+                    status: "reused",
+                    runRecordPath: existing.runRecordPath,
+                });
+                continue;
+            }
+        }
+        const taskStartedAt = Date.now();
+        progress.task(`task ${index}/${total} ${taskId} "${taskSpec.title}" (${workerRunId})`);
+        progress.step(`preflight → materialize → dag-run-task → validate → run-dag → report`);
+        let result;
+        try {
+            await writeTaskPoolState(options.repoRoot, {
+                taskId,
+                status: "Running",
+                updatedAt: new Date().toISOString(),
+                workerRunId,
+            });
+            result = await runner({
+                repoRoot: options.repoRoot,
+                taskSpec,
+                taskSpecPath,
+                client: options.client,
+                now,
+                workerRunId,
+                preflight: {
+                    runCheckRepo: options.runCheckRepo,
+                    ...(options.checkRepoCommand ? { checkRepoCommand: options.checkRepoCommand } : {}),
+                },
+                progress,
+                ...(options.piModel ? { piModel: options.piModel } : {}),
+            });
+        }
+        catch (error) {
+            const message = errorMessage(error);
+            progress.note(`task ${taskId}: ERROR ${message}`);
+            try {
+                await recordTaskPoolRun({
+                    repoRoot: options.repoRoot,
+                    run: {
+                        schemaVersion: 1,
+                        batchRunId,
+                        workerRunId,
+                        taskId,
+                        featureId: taskSpec.feature_id,
+                        status: "run-error",
+                        recordedAt: new Date().toISOString(),
+                        error: message,
+                    },
+                });
+            }
+            catch (recordError) {
+                tasks.push({
+                    taskId,
+                    workerRunId,
+                    status: "record-error",
+                    error: errorMessage(recordError),
+                });
+                continue;
+            }
+            tasks.push({
+                taskId,
+                workerRunId,
+                status: "run-error",
+                error: message,
+            });
+            continue;
+        }
+        const failure = deriveFailureRoute(result);
+        if (result.status === "succeeded") {
+            progress.step(`✓ ${taskId} succeeded in ${formatDuration(Date.now() - taskStartedAt)} (promoted + closed out)`);
+        }
+        else {
+            progress.step(`✗ ${taskId} failed in ${formatDuration(Date.now() - taskStartedAt)} — see failure artifacts`);
+        }
+        const run = {
+            schemaVersion: 1,
+            batchRunId,
+            workerRunId: result.workerRunId,
+            taskId: result.businessId,
+            featureId: taskSpec.feature_id,
+            status: result.status,
+            harnessTaskId: result.harnessTaskId,
+            runRecordPath: result.runRecordPath,
+            dagPath: result.dagPath,
+            recordedAt: new Date().toISOString(),
+            ...(failure ? { failure } : {}),
+            ...(result.failureArtifacts ? { failureArtifacts: result.failureArtifacts } : {}),
+        };
+        try {
+            await recordTaskPoolRun({ repoRoot: options.repoRoot, run });
+            tasks.push({
+                taskId,
+                workerRunId: result.workerRunId,
+                status: result.status,
+                runRecordPath: result.runRecordPath,
+            });
+        }
+        catch (error) {
+            tasks.push({
+                taskId,
+                workerRunId: result.workerRunId,
+                status: "record-error",
+                error: errorMessage(error),
+                runRecordPath: result.runRecordPath,
+            });
+        }
+    }
+    const summary = summarize(tasks);
+    const batchRunPath = path.join(getTaskPoolRoot(options.repoRoot), "runs", `${batchRunId}.json`);
+    const output = {
+        schemaVersion: 1,
+        status: summary.recordErrors > 0 || summary.runErrors > 0 ? "failed" : "completed",
+        batchRunId,
+        featureId: graph.feature_id,
+        startedAt,
+        summary,
+        tasks,
+        batchRunPath,
+    };
+    await mkdir(path.dirname(batchRunPath), { recursive: true });
+    await writeFile(batchRunPath, `${JSON.stringify(output, null, 2)}\n`, "utf-8");
+    progress.batch(`batch ${batchRunId} ${output.status}: ${summary.succeeded} succeeded, ${summary.failed} failed, ${summary.reused} reused in ${formatDuration(Date.now() - batchStartedAt)} → ${batchRunPath}`);
+    return output;
+}
+export function buildBatchRunId(now) {
+    return `batch-${now.toISOString().replace(/[-:.]/g, "").slice(0, 15)}`;
+}
+export function buildStableWorkerRunId(taskId, taskSpec, now) {
+    const date = now.toISOString().slice(0, 10).replace(/-/g, "");
+    const slug = taskId
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    const hash = createHash("sha256")
+        .update(`${taskSpec.feature_id}:${taskSpec.id}:${taskSpec.title}`)
+        .digest("hex")
+        .slice(0, 10);
+    return `wr-${date}-${slug}-${hash}`;
+}
+async function loadTaskGraph(featureDir) {
+    const graphPath = path.join(featureDir, "tasks", "task-graph.yaml");
+    return taskGraphSpecSchema.parse(YAML.parse(await readFile(graphPath, "utf-8")));
+}
+async function loadTaskSpec(taskSpecPath) {
+    return taskSpecSchema.parse(YAML.parse(await readFile(taskSpecPath, "utf-8")));
+}
+function toGraphState(states) {
+    const graphState = {};
+    for (const [taskId, state] of Object.entries(states)) {
+        if (state.status === "Done")
+            graphState[taskId] = "completed";
+        if (state.status === "Running" || state.status === "Queued")
+            graphState[taskId] = "running";
+        if (state.status === "Failed")
+            graphState[taskId] = "failed";
+        if (state.status === "Blocked")
+            graphState[taskId] = "blocked";
+    }
+    return graphState;
+}
+function isPoolReady(state) {
+    return !state || state.status === "Ready";
+}
+function summarize(tasks) {
+    return {
+        total: tasks.length,
+        succeeded: tasks.filter((task) => task.status === "succeeded").length,
+        failed: tasks.filter((task) => task.status === "failed").length,
+        reused: tasks.filter((task) => task.status === "reused").length,
+        recordErrors: tasks.filter((task) => task.status === "record-error").length,
+        runErrors: tasks.filter((task) => task.status === "run-error").length,
+    };
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/worker/task-graph/acceptance-schema.js

@@ -0,0 +1,25 @@
+import { z } from "zod";
+export const acceptanceItemSchema = z
+    .object({
+    id: z.string().min(1),
+    title: z.string().min(1),
+    priority: z.enum(["must", "should", "could", "wont"]).optional().default("must"),
+    type: z.string().min(1),
+    given: z.string().min(1),
+    when: z.string().min(1),
+    then: z.string().min(1),
+    verification: z
+        .object({
+        expected_task_refs: z.array(z.string().min(1)).min(1),
+        suggested_tests: z.array(z.string().min(1)).optional().default([]),
+    })
+        .strict(),
+})
+    .strict();
+export const acceptanceSpecSchema = z
+    .object({
+    schema_version: z.literal(1),
+    feature_id: z.string().min(1),
+    acceptance: z.array(acceptanceItemSchema).min(1),
+})
+    .strict();

package/dist/worker/task-graph/ready-queue.js

@@ -0,0 +1,23 @@
+const TERMINAL_OR_ACTIVE = new Set([
+    "running",
+    "completed",
+    "failed",
+    "blocked",
+]);
+export function computeReadyQueue(graph, state) {
+    return graph.nodes
+        .filter((node) => {
+        const ownStatus = getStatus(state[node.id]);
+        if (ownStatus && TERMINAL_OR_ACTIVE.has(ownStatus))
+            return false;
+        return node.depends_on.every((dependencyId) => getStatus(state[dependencyId]) === "completed");
+    })
+        .map((node) => node.id);
+}
+function getStatus(value) {
+    if (!value)
+        return undefined;
+    if (typeof value === "string")
+        return value;
+    return value.status;
+}

package/dist/worker/task-graph/task-graph-schema.js

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import { taskSpecTypeSchema } from "../task-spec/schema.js";
+export const taskGraphNodeSchema = z
+    .object({
+    id: z.string().min(1),
+    task: z.string().min(1),
+    type: taskSpecTypeSchema,
+    depends_on: z.array(z.string().min(1)).optional().default([]),
+})
+    .strict();
+export const taskGraphSpecSchema = z
+    .object({
+    schema_version: z.literal(1),
+    feature_id: z.string().min(1),
+    nodes: z.array(taskGraphNodeSchema).min(1),
+    parallel_policy: z
+        .object({
+        max_parallel_tasks: z.number().int().positive().optional().default(1),
+        disallow_same_file_parallel_writes: z.boolean().optional().default(true),
+    })
+        .strict()
+        .optional()
+        .default({
+        max_parallel_tasks: 1,
+        disallow_same_file_parallel_writes: true,
+    }),
+})
+    .strict();

package/dist/worker/task-graph/types.js

@@ -0,0 +1 @@
+export {};