@tea-agent/loop-agent 0.1.0-fe-test.0

package/dist/commands/closeout.js

@@ -0,0 +1,13 @@
+import { closeoutTask } from '../records/promotion.js';
+export function parseCloseoutArgs(args) {
+    const [subcommand, taskId, ...rest] = args;
+    if (subcommand !== 'task' || !taskId || rest.length > 0) {
+        throw new Error('usage: closeout task <task-id>');
+    }
+    return { taskId };
+}
+export async function runCloseout(repoRoot, args) {
+    const parsed = parseCloseoutArgs(args);
+    const result = await closeoutTask(repoRoot, parsed.taskId);
+    console.log(JSON.stringify(result, null, 2));
+}

package/dist/commands/coverage-audit.js

@@ -0,0 +1,14 @@
+import { formatRequirementCoverageJson, formatRequirementCoverageMarkdown, runRequirementCoverageAudit, } from '../governance/requirement-coverage.js';
+export async function runCoverageAudit(repoRoot, taskId, options = {}) {
+    const audit = await runRequirementCoverageAudit(repoRoot, taskId);
+    if (options.json) {
+        process.stdout.write(formatRequirementCoverageJson(audit));
+    }
+    else if (options.markdown) {
+        process.stdout.write(formatRequirementCoverageMarkdown(audit));
+    }
+    else {
+        process.stdout.write(`${formatRequirementCoverageJson(audit)}`);
+    }
+    return audit.ok ? 0 : 1;
+}

package/dist/commands/coverage-report.js

@@ -0,0 +1,50 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { formatCoverageMarkdown, readCoverageArtifact } from "../workflows/dag/backend-test-coverage-contract.js";
+function value(args, flag) {
+    const index = args.findIndex((arg) => arg === flag || arg.startsWith(`${flag}=`));
+    if (index < 0)
+        return undefined;
+    const token = args[index];
+    return token.startsWith(`${flag}=`) ? token.slice(flag.length + 1) : args[index + 1];
+}
+function values(args, flag) {
+    return args.flatMap((arg, index) => {
+        if (arg === flag)
+            return args[index + 1] ? [args[index + 1]] : [];
+        return arg.startsWith(`${flag}=`) ? [arg.slice(flag.length + 1)] : [];
+    });
+}
+export async function runCoverageReport(repoRoot, args) {
+    if (args[0] !== "report" || args.includes("--help")) {
+        console.log("usage: coverage report --language python|java --input <coverage.json|jacoco.xml> [--output <path>] [--json|--markdown] --requirement-id <AC-id> --source-scope <path[,path]> [--commit <sha>] [--expected-sha256 <sha256>]");
+        return;
+    }
+    const input = value(args, "--input");
+    const language = value(args, "--language");
+    if (!input || (language !== "python" && language !== "java"))
+        throw new Error("coverage report requires --language python|java and --input");
+    const expectedSha = value(args, "--expected-sha256");
+    const sourcePaths = (value(args, "--source-scope") ?? "").split(",").map((item) => item.trim()).filter(Boolean);
+    const contract = await readCoverageArtifact(path.resolve(repoRoot, input), {
+        sourceScope: { requirementIds: values(args, "--requirement-id"), paths: sourcePaths },
+        commitSha: value(args, "--commit") ?? null,
+        toolVersion: value(args, "--tool-version") ?? null,
+        artifactPath: input,
+    });
+    if ((language === "python" && contract.language !== "python") || (language === "java" && contract.language !== "java"))
+        throw new Error("coverage artifact format does not match --language");
+    if (expectedSha && expectedSha !== contract.artifact.sha256)
+        throw new Error(`artifact SHA-256 mismatch: expected ${expectedSha}, got ${contract.artifact.sha256}`);
+    const markdown = args.includes("--markdown");
+    const output = value(args, "--output");
+    const rendered = markdown ? formatCoverageMarkdown(contract) : `${JSON.stringify(contract, null, 2)}\n`;
+    if (output) {
+        const outputPath = path.resolve(repoRoot, output);
+        await mkdir(path.dirname(outputPath), { recursive: true });
+        await writeFile(outputPath, rendered, "utf8");
+    }
+    else {
+        process.stdout.write(rendered);
+    }
+}

package/dist/commands/cursor-prompt.js

@@ -0,0 +1,182 @@
+/**
+ * Cursor Prompt — one-shot CLI for Cursor SDK tasks (sidecar).
+ *
+ * Usage:
+ *   cursor-prompt "Fix lint errors"                    # one-shot
+ *   cursor-prompt --stdin                               # read task from stdin
+ *   cursor-prompt --file task.md                        # read task from file
+ *   cursor-prompt --stream "Analyze this code"          # stream output
+ *   cursor-prompt --model gpt-5.5 "Deep analysis"       # pick model
+ *   cursor-prompt --cwd /path --timeout 120000 "task"   # cwd + timeout
+ */
+import { executeCursorTask, executeCursorPromptStream, DEFAULT_CURSOR_MODEL, DEFAULT_CURSOR_TIMEOUT_MS, } from "../sidecars/cursor-prompt/index.js";
+import { createOneShotPromptParseAccum, formatUnknownFlagError, parseOneShotCommonFlag, printOneShotHelpAndExit, resolveOneShotCwd, resolveOneShotTask, } from "../shared/one-shot-prompt-args.js";
+import { persistCursorRunLog, computeRunDir } from "../records/one-shot-runs.js";
+const CURSOR_PROMPT_USAGE = [
+    "usage: cursor-prompt [options] [task]",
+    "",
+    '  cursor-prompt "Fix lint errors in src/"              One-shot task',
+    "  cursor-prompt --stdin                                 Read task from stdin",
+    "  cursor-prompt --file task.md                          Read task from a file",
+    '  cursor-prompt --stream "Analyze this"                 Stream output in real-time',
+    '  cursor-prompt --model gpt-5.5 "Deep analysis"         Use a specific model',
+    '  cursor-prompt --cwd /path --timeout 60000 "task"      Custom cwd + timeout',
+    "  cursor-prompt --list-models                           List commonly used models",
+    "",
+    "options:",
+    "  --stdin              Read task from stdin (ignores positional task)",
+    "  --file <path>        Read task from a file",
+    "  --stream             Stream agent output in real-time",
+    "  --model <id>         Model id (default: account default)",
+    "  --cwd <path>         Working directory (default: cwd)",
+    "  --timeout <ms>       Timeout in ms (default: 1,800,000 = 30min)",
+    "  --list-models        List commonly used models",
+    "  --no-stream          Force non-streaming output (default for non-tty)",
+].join("\n");
+const COMMON_MODELS = {
+    "composer-2.5": "Cursor Composer 2.5 (fast, small tasks)",
+    "composer-3": "Cursor Composer 3",
+    default: "Account default",
+    "gpt-5.5": "GPT 5.5 (deep reasoning)",
+    "gpt-5": "GPT 5",
+    "claude-sonnet-4": "Claude Sonnet 4",
+    "claude-opus-4": "Claude Opus 4",
+    "gemini-3-flash": "Gemini 3 Flash (fast/cheap)",
+    "gemini-3-pro": "Gemini 3 Pro",
+};
+export function listModels() {
+    console.log("Common Cursor models:\n");
+    for (const [id, desc] of Object.entries(COMMON_MODELS)) {
+        console.log(`  ${id.padEnd(22)} ${desc}`);
+    }
+}
+export function parseCursorPromptArgs(args) {
+    const accum = createOneShotPromptParseAccum();
+    let model;
+    let stream;
+    for (let i = 0; i < args.length; i += 1) {
+        const common = parseOneShotCommonFlag(args, i, accum);
+        if (common.kind === "help") {
+            printOneShotHelpAndExit(CURSOR_PROMPT_USAGE);
+        }
+        if (common.kind === "consumed") {
+            i = common.nextIndex;
+            continue;
+        }
+        const arg = args[i];
+        if (arg === "--stream") {
+            stream = true;
+        }
+        else if (arg === "--no-stream") {
+            stream = false;
+        }
+        else if (arg === "--list-models") {
+            return { listModels: true };
+        }
+        else if (arg === "--model") {
+            model = args[i + 1];
+            if (!model)
+                throw new Error("--model requires a model id");
+            i += 1;
+        }
+        else {
+            throw formatUnknownFlagError(arg, CURSOR_PROMPT_USAGE);
+        }
+    }
+    const task = resolveOneShotTask(accum, CURSOR_PROMPT_USAGE);
+    // Default: stream if stdout is a TTY
+    if (stream === undefined) {
+        stream = process.stdout.isTTY === true;
+    }
+    return {
+        task,
+        cwd: resolveOneShotCwd(accum.cwd),
+        model,
+        timeoutMs: accum.timeoutMs,
+        stream,
+    };
+}
+export async function runCursorPrompt(args) {
+    const effectiveCwd = args.cwd ?? process.cwd();
+    const model = args.model ?? DEFAULT_CURSOR_MODEL;
+    const timeoutMs = args.timeoutMs ?? DEFAULT_CURSOR_TIMEOUT_MS;
+    if (args.stream) {
+        await runCursorPromptStreaming(args.task, effectiveCwd, model, timeoutMs);
+    }
+    else {
+        await runCursorPromptBatch(args.task, effectiveCwd, model, timeoutMs);
+    }
+}
+async function runCursorPromptBatch(task, cwd, model, timeoutMs) {
+    const startedAt = Date.now();
+    process.stderr.write(`[cursor-prompt] running "${task.slice(0, 80)}${task.length > 80 ? "..." : ""}" (model=${model}, cwd=${cwd})\n`);
+    const runDir = (await computeRunDir(cwd, task)) ?? undefined;
+    const result = await executeCursorTask({
+        task,
+        cwd,
+        model,
+        timeoutMs,
+        runDir,
+    });
+    await persistCursorRunLog(cwd, {
+        task,
+        model,
+        channel: "tool",
+        cwd,
+        result,
+        runDir,
+    });
+    const elapsed = ((Date.now() - startedAt) / 1000).toFixed(1);
+    if (result.ok) {
+        process.stderr.write(`[cursor-prompt] done in ${elapsed}s, status=${result.status}\n`);
+        process.stdout.write(result.stdout);
+        if (!result.stdout.endsWith("\n"))
+            process.stdout.write("\n");
+    }
+    else {
+        const stderr = result.stderr || result.stdout || "(no output)";
+        process.stderr.write(`[cursor-prompt] FAILED in ${elapsed}s (${result.failureCategory}):\n${stderr}\n`);
+        process.exit(1);
+    }
+}
+async function runCursorPromptStreaming(task, cwd, model, timeoutMs) {
+    const startedAt = Date.now();
+    process.stderr.write(`[cursor-prompt] streaming (model=${model}, cwd=${cwd})
+`);
+    const runDir = (await computeRunDir(cwd, task)) ?? undefined;
+    const result = await executeCursorPromptStream({
+        task,
+        cwd,
+        model,
+        timeoutMs,
+        runDir,
+        callbacks: {
+            onAssistantText: (text) => process.stdout.write(text),
+        },
+    });
+    await persistCursorRunLog(cwd, {
+        task,
+        model,
+        channel: "tool",
+        cwd,
+        result,
+        runDir,
+    });
+    const elapsed = ((Date.now() - startedAt) / 1000).toFixed(1);
+    if (result.ok) {
+        process.stderr.write(`
+[cursor-prompt] done in ${elapsed}s, status=${result.status}
+`);
+    }
+    else {
+        const stderr = result.stderr || "(no output)";
+        process.stderr.write(`
+[cursor-prompt] FAILED in ${elapsed}s (${result.failureCategory}):
+${stderr}
+`);
+        process.exit(1);
+    }
+}
+export function printCursorPromptUsage() {
+    console.log(CURSOR_PROMPT_USAGE);
+}

package/dist/commands/dag-approve.js

@@ -0,0 +1,142 @@
+import path from "node:path";
+import { access } from "node:fs/promises";
+import { assertDagRunTransferTargetAvailable, getDagRunDir, readHumanEscalation, requirePausedDagRun, transferDagRunDir, writeDagRunState, writeHumanApprovalArtifact, } from "../workflows/dag/lifecycle.js";
+import { assertSkillSnapshotCoversSpec, readSkillSnapshot, SKILL_SNAPSHOT_REL_PATH, } from "../workflows/dag/skill-snapshot.js";
+export function parseDagApproveArgs(args) {
+    if (args.length === 0) {
+        throw new Error("usage: dag approve --run-id <id> --option <A|B|...> [--notes \"...\"]");
+    }
+    let runId;
+    let option;
+    let notes;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--run-id") {
+            runId = args[++i];
+            continue;
+        }
+        if (arg.startsWith("--run-id=")) {
+            runId = arg.slice("--run-id=".length);
+            continue;
+        }
+        if (arg === "--option") {
+            option = args[++i];
+            continue;
+        }
+        if (arg.startsWith("--option=")) {
+            option = arg.slice("--option=".length);
+            continue;
+        }
+        if (arg === "--notes") {
+            notes = args[++i];
+            continue;
+        }
+        if (arg.startsWith("--notes=")) {
+            notes = arg.slice("--notes=".length);
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            throw new Error(`unknown dag approve flag: ${arg}`);
+        }
+        throw new Error(`unexpected positional argument: ${arg}`);
+    }
+    if (!runId) {
+        throw new Error("dag approve requires --run-id <id>");
+    }
+    if (!option) {
+        throw new Error("dag approve requires --option <id>");
+    }
+    return { runId, option, notes };
+}
+export async function runDagApprove(repoRoot, rawArgs) {
+    const parsed = parseDagApproveArgs(rawArgs);
+    const { runDir, state, spec } = await requirePausedDagRun(repoRoot, parsed.runId);
+    // Phase 0.5 migration matrix: paused v3 cannot approve new writer paths.
+    const { assertDagSpecAllowsNewWriterExecution, assertTaskContractBindingConsistent, } = await import("../workflows/dag/task-contract-binding.js");
+    assertDagSpecAllowsNewWriterExecution(spec);
+    await assertTaskContractBindingConsistent({ repoRoot, spec });
+    const nodeId = state.pausedByNodeId;
+    const node = state.nodes[nodeId];
+    if (!node) {
+        throw new Error(`paused node ${nodeId} not found in run state`);
+    }
+    const escalation = await readHumanEscalation(runDir, nodeId);
+    const optionIds = new Set(escalation.humanEscalation.options.map((entry) => entry.id));
+    if (!optionIds.has(parsed.option)) {
+        throw new Error(`option ${parsed.option} is not valid; expected one of: ${[...optionIds].join(", ")}`);
+    }
+    // Fail closed before any approval/state/lifecycle mutation. Snapshot-backed
+    // runs must validate fully. A true pre-snapshot legacy run (no ref and no
+    // artifact) may still be approved so resume can perform the established
+    // legacy-resume-backfill. An artifact without a ref is an orphan and cannot
+    // be trusted or silently adopted.
+    if (state.skillSnapshotRef) {
+        try {
+            const snapshot = await readSkillSnapshot(runDir, state.skillSnapshotRef, {
+                expectedRunId: state.runId,
+            });
+            assertSkillSnapshotCoversSpec(snapshot, spec, state);
+        }
+        catch (error) {
+            throw new Error(`skill snapshot pre-approval validation failed: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+        }
+    }
+    else {
+        const snapshotPath = path.join(runDir, ...SKILL_SNAPSHOT_REL_PATH.split("/"));
+        try {
+            await access(snapshotPath);
+            throw new Error("skill snapshot artifact exists without a state ref; refusing approval");
+        }
+        catch (error) {
+            if (!isNotFound(error)) {
+                throw new Error(`skill snapshot pre-approval validation failed: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+            }
+        }
+    }
+    const activeRunDir = getDagRunDir(repoRoot, "active", state.runId);
+    await assertDagRunTransferTargetAvailable(activeRunDir);
+    const approvedAt = new Date().toISOString();
+    const artifact = {
+        schemaVersion: 1,
+        runId: state.runId,
+        nodeId,
+        decision: "approved",
+        selectedOption: parsed.option,
+        approvedAt,
+        escalationArtifactPath: node.escalationArtifactPath,
+    };
+    if (parsed.notes) {
+        artifact.notes = parsed.notes;
+    }
+    const approvalPath = await writeHumanApprovalArtifact({
+        runDir,
+        nodeId,
+        artifact,
+    });
+    node.pauseReason = undefined;
+    node.humanApprovalArtifactPath = approvalPath;
+    state.status = "running";
+    state.humanDecisionNodeId = nodeId;
+    delete state.pausedAt;
+    delete state.pausedByNodeId;
+    delete state.pauseReason;
+    await writeDagRunState(runDir, state);
+    const nextRunDir = await transferDagRunDir(runDir, activeRunDir);
+    console.log(JSON.stringify({
+        action: "approve",
+        runId: state.runId,
+        nodeId,
+        selectedOption: parsed.option,
+        approvalPath: path.relative(repoRoot, approvalPath),
+        runDir: nextRunDir,
+        title: spec.title,
+        status: state.status,
+        nextRecommendedAction: "Run is approved; use dag resume to continue.",
+    }, null, 2));
+}
+function isNotFound(error) {
+    return Boolean(error
+        && typeof error === "object"
+        && "code" in error
+        && error.code === "ENOENT");
+}

package/dist/commands/dag-final-verification.js

@@ -0,0 +1,76 @@
+import { defaultFinalVerificationDagOutputPath, initFinalVerificationDagFromTask, } from '../workflows/dag/final-verification.js';
+import { resolveCliPath } from '../shared/path-refs.js';
+export function parseDagFinalVerificationArgs(args) {
+    if (args.length === 0) {
+        throw new Error('usage: dag final-verification <task-id> [--output <path>] [--task-glob <pattern>] [--closeout <path>]');
+    }
+    let taskId;
+    let outputPath;
+    let taskGlob;
+    let closeoutPath;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === '--output' || arg === '-o') {
+            outputPath = requiredValue(args[++i], '--output');
+        }
+        else if (arg.startsWith('--output=')) {
+            outputPath = arg.slice('--output='.length);
+        }
+        else if (arg === '--task-glob') {
+            taskGlob = requiredValue(args[++i], '--task-glob');
+        }
+        else if (arg.startsWith('--task-glob=')) {
+            taskGlob = arg.slice('--task-glob='.length);
+        }
+        else if (arg === '--closeout') {
+            closeoutPath = requiredValue(args[++i], '--closeout');
+        }
+        else if (arg.startsWith('--closeout=')) {
+            closeoutPath = arg.slice('--closeout='.length);
+        }
+        else if (arg.startsWith('-')) {
+            throw new Error(`unknown dag final-verification flag: ${arg}`);
+        }
+        else if (taskId) {
+            throw new Error(`unexpected positional argument: ${arg}`);
+        }
+        else {
+            taskId = arg;
+        }
+    }
+    if (!taskId) {
+        throw new Error('dag final-verification requires <task-id>');
+    }
+    return {
+        taskId,
+        outputPath: outputPath ? resolveCliPath(outputPath) : undefined,
+        taskGlob,
+        closeoutPath: closeoutPath ? resolveCliPath(closeoutPath) : undefined,
+    };
+}
+export async function runDagFinalVerification(repoRoot, rawArgs) {
+    const parsed = parseDagFinalVerificationArgs(rawArgs);
+    const result = await initFinalVerificationDagFromTask(repoRoot, parsed.taskId, {
+        outputPath: parsed.outputPath,
+        taskGlob: parsed.taskGlob,
+        closeoutPath: parsed.closeoutPath,
+    });
+    console.log(JSON.stringify({
+        ok: true,
+        taskId: result.taskId,
+        outputPath: result.outputPath,
+        defaultOutputPath: defaultFinalVerificationDagOutputPath(parsed.taskId),
+        taskCount: result.taskCount,
+        nodeIds: result.nodeIds,
+        next: [
+            `Review ${result.outputPath}`,
+            `npm run dev -- dag validate --dag ${result.outputPath} --strict-models --strict-governance`,
+            `npm run dev -- dag execute --dag ${result.outputPath} --cwd ${repoRoot}`,
+        ],
+    }, null, 2));
+}
+function requiredValue(value, flag) {
+    if (!value)
+        throw new Error(`dag final-verification requires a value for ${flag}`);
+    return value;
+}

package/dist/commands/dag-init-hybrid.js

@@ -0,0 +1,57 @@
+import path from "node:path";
+import { initHybridDagFromTask } from "../workflows/dag/init-hybrid.js";
+import { getTaskPaths } from "../task/runtime.js";
+export function parseDagInitHybridArgs(args) {
+    if (args.length === 0) {
+        throw new Error("usage: dag init-hybrid <task-id> [--output <path>]");
+    }
+    let taskId;
+    let outputPath;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--output" || arg === "-o") {
+            outputPath = args[++i];
+            if (!outputPath) {
+                throw new Error("dag init-hybrid --output requires a path");
+            }
+            continue;
+        }
+        if (arg.startsWith("--output=")) {
+            outputPath = arg.slice("--output=".length);
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            throw new Error(`unknown dag init-hybrid flag: ${arg}`);
+        }
+        if (taskId) {
+            throw new Error(`unexpected positional argument: ${arg}`);
+        }
+        taskId = arg;
+    }
+    if (!taskId) {
+        throw new Error("dag init-hybrid requires <task-id>");
+    }
+    return {
+        taskId,
+        outputPath: outputPath ? path.resolve(outputPath) : undefined,
+    };
+}
+export async function runDagInitHybrid(repoRoot, rawArgs) {
+    const parsed = parseDagInitHybridArgs(rawArgs);
+    const result = await initHybridDagFromTask(repoRoot, parsed.taskId, {
+        outputPath: parsed.outputPath,
+    });
+    console.log(JSON.stringify({
+        ok: true,
+        taskId: result.taskId,
+        outputPath: result.outputPath,
+        defaultOutputPath: getTaskPaths(repoRoot, parsed.taskId).dagDraftPath,
+        taskCount: result.taskCount,
+        nodeIds: result.nodeIds,
+        next: [
+            `Review ${result.outputPath}`,
+            `npm run dev -- dag validate --dag ${result.outputPath}`,
+            "This command's outputPath is a DAG draft; only a later dag execute --dry-run returned runDir is the preview snapshot, outside the active overview and not a dag resume target.",
+        ],
+    }, null, 2));
+}

package/dist/commands/dag-reconcile-run.js

@@ -0,0 +1,5 @@
+import { executeDagReconcileRun, parseDagReconcileRunArgs, } from "../workflows/dag/reconcile-run.js";
+export { executeDagReconcileRun, parseDagReconcileRunArgs };
+export async function runDagReconcileRun(repoRoot, rawArgs) {
+    console.log(JSON.stringify(await executeDagReconcileRun(repoRoot, rawArgs), null, 2));
+}

package/dist/commands/dag-reconcile-tasks.js

@@ -0,0 +1,51 @@
+import { formatTaskReconcileJson, formatTaskReconcileMarkdown, runTaskReconcile, } from '../workflows/dag/reconcile-tasks.js';
+export async function runDagReconcileTasks(repoRoot, args) {
+    const options = parseDagReconcileTasksArgs(args);
+    const report = await runTaskReconcile(repoRoot, {
+        glob: options.glob,
+        patch: options.patch,
+    });
+    const output = options.markdown
+        ? formatTaskReconcileMarkdown(report)
+        : formatTaskReconcileJson(report);
+    process.stdout.write(output);
+    if (!report.ok) {
+        process.exitCode = 1;
+    }
+}
+export function parseDagReconcileTasksArgs(args) {
+    let glob = '*';
+    let patch = false;
+    let json = false;
+    let markdown = false;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === '--glob') {
+            glob = requiredValue(args[++i], '--glob');
+        }
+        else if (arg.startsWith('--glob=')) {
+            glob = arg.slice('--glob='.length);
+        }
+        else if (arg === '--patch') {
+            patch = true;
+        }
+        else if (arg === '--json') {
+            json = true;
+        }
+        else if (arg === '--markdown') {
+            markdown = true;
+        }
+        else {
+            throw new Error(`unknown dag reconcile-tasks flag: ${arg}`);
+        }
+    }
+    if (json && markdown) {
+        throw new Error('dag reconcile-tasks accepts only one of --json or --markdown');
+    }
+    return { glob, patch, json, markdown };
+}
+function requiredValue(value, flag) {
+    if (!value)
+        throw new Error(`dag reconcile-tasks requires a value for ${flag}`);
+    return value;
+}