@tea-agent/loop-agent 0.1.0

package/dist/workflows/dag/types.js

@@ -0,0 +1,275 @@
+import { z } from "zod";
+import { assertDagPromptSourceRule } from "./prompt-source.js";
+export const dagComplexitySchema = z.enum(["HIGH", "MED", "LOW"]);
+export const dagNodeExecutorSchema = z.enum([
+    "cursor",
+    "pi",
+    "shell",
+    "static",
+]);
+export const dagToolProfileSchema = z.enum(["read-only", "write"]);
+export const dagShellPresetSchema = z.enum(["loop-agent-standard-verify"]);
+export const dagVerifyQuotaSchema = z.enum(["1", "3", "full"]);
+export const dagVerifyStrategySchema = z
+    .object({
+    intermediateQuota: dagVerifyQuotaSchema.optional(),
+    finalQuota: z.literal("full").optional().default("full"),
+    focusedCommandSource: z
+        .literal("adapter")
+        .optional()
+        .default("adapter"),
+})
+    .optional();
+export const dagShellVerifyEvidenceSchema = z.object({
+    phase: z.enum(["intermediate", "final"]),
+    quota: dagVerifyQuotaSchema,
+    commandSource: z.enum(["adapter", "inline"]),
+    commandCount: z.number().int().nonnegative(),
+    commandLabels: z.array(z.string()).default([]),
+    finalFullRequired: z.boolean().optional(),
+});
+export const dagRepairArtifactGateSchema = z.object({
+    fromNodeId: z
+        .string()
+        .regex(/^[a-z][a-z0-9-]*$/, "fromNodeId must be kebab-case"),
+});
+export const dagVerdictGateSchema = z.object({
+    fromNodeId: z
+        .string()
+        .regex(/^[a-z][a-z0-9-]*$/, "fromNodeId must be kebab-case"),
+    accept: z.array(z.string().min(1)).min(1),
+    lineMode: z.enum(["first-non-empty", "first-verdict-line"]).optional(),
+    label: z.string().min(1).optional(),
+});
+export const ENV_VAR_NAME_PATTERN = /^[A-Z_][A-Z0-9_]*$/;
+export const dagVersionSchema = z
+    .union([z.literal(1), z.literal(2)])
+    .default(1);
+export const dagRoleSchema = z.enum([
+    "planner",
+    "scout",
+    "implementer",
+    "reviewer",
+    "supervisor",
+    "verifier",
+    "closeout",
+]);
+export const dagWritePolicySchema = z.enum([
+    "read-only",
+    "docs-only",
+    "exclusive",
+    "none",
+]);
+export const dagDefaultsSchema = z
+    .object({
+    executor: dagNodeExecutorSchema.optional(),
+    model: z.string().optional(),
+    piBackend: z.enum(["sdk-first", "cli-only"]).optional(),
+    contextProfile: z.string().optional(),
+    skills: z.array(z.string()).optional(),
+    writePolicy: dagWritePolicySchema.optional(),
+})
+    .optional();
+export const dagNodeStatusSchema = z.enum([
+    "PENDING",
+    "RUNNING",
+    "FINISHED",
+    "ERROR",
+    "SKIPPED",
+]);
+export const dagShellConfigSchema = z.object({
+    commands: z.array(z.string()).default([]),
+    preset: dagShellPresetSchema.optional(),
+    verdictGate: dagVerdictGateSchema.optional(),
+    verifyEvidence: dagShellVerifyEvidenceSchema.optional(),
+    repairArtifactGate: dagRepairArtifactGateSchema.optional(),
+    envAllowlist: z.array(z.string()).optional(),
+    timeoutMs: z.number().optional(),
+    cwd: z.string().optional(),
+});
+export const dagStaticConfigSchema = z.object({
+    resultMarkdown: z.string().min(1),
+    status: z.enum(["success", "error"]).optional(),
+});
+export const dagDynamicExpansionChildTaskSchema = z.object({
+    executor: dagNodeExecutorSchema.default("pi"),
+    role: dagRoleSchema.optional(),
+    complexity: dagComplexitySchema.default("LOW"),
+    subtaskPromptTemplate: z.string().min(1),
+    outputContract: z.string().optional(),
+    staticResultTemplate: z.string().optional(),
+    toolProfile: dagToolProfileSchema.optional(),
+    writePolicy: dagWritePolicySchema.optional(),
+    allowedPaths: z.array(z.string()).optional().default([]),
+    forbiddenPaths: z.array(z.string()).optional().default([]),
+    writeSet: z.array(z.string()).optional(),
+});
+export const dagDynamicExpansionSchema = z.object({
+    type: z.enum(["map_agent", "verify_agent"]),
+    workflowNodeId: z
+        .string()
+        .regex(/^[a-z][a-z0-9-]*$/, "workflowNodeId must be kebab-case"),
+    itemsFrom: z.string().min(1),
+    itemName: z.string().min(1).default("item"),
+    maxItems: z.number().int().positive(),
+    maxExpandedNodes: z.number().int().positive(),
+    workspaceTemplate: z.string().min(1).optional(),
+    childIdPrefix: z
+        .string()
+        .regex(/^[a-z][a-z0-9-]*$/, "childIdPrefix must be kebab-case"),
+    childTask: dagDynamicExpansionChildTaskSchema,
+});
+export const dagDynamicReductionSchema = z.object({
+    type: z.literal("verified_findings_report"),
+    workflowNodeId: z
+        .string()
+        .regex(/^[a-z][a-z0-9-]*$/, "workflowNodeId must be kebab-case"),
+    findingsFrom: z.string().min(1),
+    verificationsFrom: z.string().min(1),
+    refutedFindingsArtifactName: z
+        .string()
+        .min(1)
+        .default("refuted-findings.json"),
+});
+export const dagDynamicConditionSchema = z.object({
+    workflowNodeId: z
+        .string()
+        .regex(/^[a-z][a-z0-9-]*$/, "workflowNodeId must be kebab-case"),
+    cases: z.array(z.object({
+        when: z.string().min(1),
+        then: z
+            .string()
+            .regex(/^[a-z][a-z0-9-]*$/, "then must be a kebab-case task id"),
+    })),
+    default: z
+        .string()
+        .regex(/^[a-z][a-z0-9-]*$/, "default must be a kebab-case task id")
+        .optional(),
+});
+export const dagDynamicLoopBodyTaskSchema = z.object({
+    id: z
+        .string()
+        .regex(/^[a-z][a-z0-9-]*$/, "body task id must be kebab-case"),
+    dependsOn: z.array(z.string()).default([]),
+    executor: dagNodeExecutorSchema.default("pi"),
+    role: dagRoleSchema.optional(),
+    complexity: dagComplexitySchema.default("LOW"),
+    subtaskPromptTemplate: z.string().min(1),
+    outputContract: z.string().optional(),
+    staticResultTemplate: z.string().optional(),
+    toolProfile: dagToolProfileSchema.optional(),
+    writePolicy: dagWritePolicySchema.optional(),
+    allowedPaths: z.array(z.string()).optional().default([]),
+    forbiddenPaths: z.array(z.string()).optional().default([]),
+    writeSet: z.array(z.string()).optional(),
+});
+export const dagDynamicLoopUntilSchema = z.object({
+    workflowNodeId: z
+        .string()
+        .regex(/^[a-z][a-z0-9-]*$/, "workflowNodeId must be kebab-case"),
+    maxIterations: z.number().int().positive(),
+    stopWhenAny: z.array(z.string().min(1)).default([]),
+    bodyTasks: z.array(dagDynamicLoopBodyTaskSchema).min(1),
+});
+export const dagDecisionGateModeSchema = z.enum([
+    "record-only",
+    "pause-on-human",
+]);
+export const dagDecisionGateSchema = z.object({
+    enabled: z.boolean(),
+    schemaVersion: z.literal(1).optional(),
+    mode: dagDecisionGateModeSchema.optional().default("record-only"),
+});
+export const dagConvergenceSpecSchema = z
+    .object({
+    enabled: z.boolean().optional().default(false),
+    maxPasses: z.number().int().positive().optional().default(3),
+    stopOnVerdictPass: z.boolean().optional().default(true),
+    stopOnHardVerifyPass: z.boolean().optional().default(true),
+    pauseOnRegression: z.boolean().optional().default(true),
+})
+    .optional();
+export const dagTaskSchema = z.object({
+    id: z.string().regex(/^[a-z][a-z0-9-]*$/, "task id must be kebab-case"),
+    depends_on: z.array(z.string()).default([]),
+    complexity: dagComplexitySchema,
+    subtask_prompt: z.string().min(1),
+    subtask_prompt_source: z
+        .object({
+        type: z.literal("markdown"),
+        path: z.string().min(1),
+        sha256: z.string().min(1),
+    })
+        .optional(),
+    executor: dagNodeExecutorSchema.optional().default("pi"),
+    role: dagRoleSchema.optional(),
+    skills: z.array(z.string()).optional(),
+    toolProfile: dagToolProfileSchema.optional(),
+    writePolicy: dagWritePolicySchema.optional(),
+    writeSet: z.array(z.string()).optional(),
+    piStep: z.string().optional(),
+    shell: dagShellConfigSchema.optional(),
+    static: dagStaticConfigSchema.optional(),
+    outputContract: z.string().optional(),
+    allowedPaths: z.array(z.string()).optional().default([]),
+    forbiddenPaths: z.array(z.string()).optional().default([]),
+    decisionGate: dagDecisionGateSchema.optional(),
+    dynamicExpansion: dagDynamicExpansionSchema.optional(),
+    dynamicReduction: dagDynamicReductionSchema.optional(),
+    dynamicCondition: dagDynamicConditionSchema.optional(),
+    dynamicLoopUntil: dagDynamicLoopUntilSchema.optional(),
+});
+export const dagModelsSchema = z
+    .object({
+    HIGH: z.string().optional(),
+    MED: z.string().optional(),
+    LOW: z.string().optional(),
+})
+    .partial();
+export const dagExecutorModelsSchema = z
+    .object({
+    cursor: dagModelsSchema.optional(),
+    pi: dagModelsSchema.optional(),
+})
+    .partial();
+export const dagSpecSchema = z.object({
+    version: dagVersionSchema,
+    title: z.string().min(1),
+    objective: z.string().optional(),
+    successCriteria: z.array(z.string()).optional(),
+    globalConstraints: z.array(z.string()).optional(),
+    convergence: dagConvergenceSpecSchema,
+    verifyStrategy: dagVerifyStrategySchema,
+    defaults: dagDefaultsSchema,
+    skillsByRole: z.record(z.string(), z.array(z.string())).optional(),
+    executorModels: dagExecutorModelsSchema.optional(),
+    tasks: z.array(dagTaskSchema).min(1),
+});
+export const DEFAULT_DAG_EXECUTOR_MODELS = {
+    cursor: {
+        LOW: "composer-2.5",
+        MED: "composer-2.5",
+        HIGH: "composer-2.5",
+    },
+    pi: {
+        LOW: "gpt-5.3-codex-spark",
+        MED: "glm-5.2",
+        HIGH: "gpt-5.5",
+    },
+};
+export const DEFAULT_DAG_PI_MODELS = DEFAULT_DAG_EXECUTOR_MODELS.pi;
+export const LEGACY_TOP_LEVEL_MODELS_ERROR = 'top-level "models" is no longer supported; use "executorModels"';
+export function parseDagSpec(raw) {
+    assertDagPromptSourceRule(raw, { allowMarkdown: false });
+    if (typeof raw === "object" && raw !== null && "models" in raw) {
+        throw new Error(LEGACY_TOP_LEVEL_MODELS_ERROR);
+    }
+    return dagSpecSchema.parse(raw);
+}
+export function resolveModelForTask(task, executorModels) {
+    if (task.executor === "shell" || task.executor === "static") {
+        return undefined;
+    }
+    return (executorModels?.[task.executor]?.[task.complexity] ??
+        DEFAULT_DAG_EXECUTOR_MODELS[task.executor][task.complexity]);
+}

package/dist/workflows/dag/upstream-artifacts.js

@@ -0,0 +1,95 @@
+import { createHash } from "node:crypto";
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { MAX_UPSTREAM_CHARS } from "./prompt.js";
+import { rewritePathPrefix } from "../../shared/path-refs.js";
+function sha256Text(text) {
+    return createHash("sha256").update(text).digest("hex");
+}
+export async function persistLongNodeOutputArtifacts(input) {
+    const previewChars = input.previewChars ?? MAX_UPSTREAM_CHARS;
+    const nodeRecordPath = path.join(input.runDir, `${input.nodeId}.json`);
+    const meta = { nodeRecordPath };
+    if (input.stdout && input.stdout.length > previewChars) {
+        const nodeDir = path.join(input.runDir, input.nodeId);
+        await mkdir(nodeDir, { recursive: true });
+        const stdoutPath = path.join(nodeDir, "stdout.md");
+        await writeFile(stdoutPath, input.stdout, "utf-8");
+        meta.stdoutArtifactPath = stdoutPath;
+        meta.stdoutChars = input.stdout.length;
+        meta.stdoutSha256 = sha256Text(input.stdout);
+    }
+    const assistant = input.assistantText;
+    if (assistant &&
+        assistant !== input.stdout &&
+        assistant.length > previewChars) {
+        const nodeDir = path.join(input.runDir, input.nodeId);
+        await mkdir(nodeDir, { recursive: true });
+        const assistantPath = path.join(nodeDir, "assistant.md");
+        await writeFile(assistantPath, assistant, "utf-8");
+        meta.assistantArtifactPath = assistantPath;
+        meta.assistantChars = assistant.length;
+        meta.assistantSha256 = sha256Text(assistant);
+    }
+    return meta;
+}
+export function relocateNodeArtifactPaths(node, oldRunDir, newRunDir) {
+    if (oldRunDir === newRunDir)
+        return;
+    const rewrite = (value) => {
+        if (!value)
+            return value;
+        const rewritten = rewritePathPrefix(value, oldRunDir, newRunDir);
+        if (rewritten !== value)
+            return rewritten;
+        if (value === oldRunDir || value.startsWith(`${oldRunDir}${path.sep}`)) {
+            return path.join(newRunDir, path.relative(oldRunDir, value));
+        }
+        return value;
+    };
+    node.stdoutArtifactPath = rewrite(node.stdoutArtifactPath);
+    node.assistantArtifactPath = rewrite(node.assistantArtifactPath);
+    node.nodeRecordPath = rewrite(node.nodeRecordPath);
+}
+export async function relocateRunArtifactPaths(input) {
+    const { runDir, oldRunDir, nodes } = input;
+    if (oldRunDir === runDir)
+        return;
+    for (const [nodeId, node] of Object.entries(nodes)) {
+        relocateNodeArtifactPaths(node, oldRunDir, runDir);
+        await writeFile(path.join(runDir, `${nodeId}.json`), `${JSON.stringify(node, null, 2)}\n`, "utf-8");
+    }
+}
+export function formatStdoutPreview(stdout, maxChars) {
+    if (stdout.length <= maxChars) {
+        return { preview: stdout, truncated: false };
+    }
+    return {
+        preview: `${stdout.slice(0, maxChars)}\n...[truncated]`,
+        truncated: true,
+    };
+}
+export function formatUpstreamArtifactPointerMap(record, artifactKind = "stdout") {
+    const artifactPath = artifactKind === "assistant"
+        ? record.assistantArtifactPath
+        : record.stdoutArtifactPath;
+    const chars = artifactKind === "assistant" ? record.assistantChars : record.stdoutChars;
+    const sha256 = artifactKind === "assistant" ? record.assistantSha256 : record.stdoutSha256;
+    const lines = [
+        "",
+        "Full output artifact (read-only runner evidence — use read tool to fetch; do not edit):",
+    ];
+    if (artifactPath) {
+        lines.push(`- ${artifactKind}: ${artifactPath}`);
+    }
+    if (record.nodeRecordPath) {
+        lines.push(`- node record: ${record.nodeRecordPath}`);
+    }
+    if (chars !== undefined) {
+        lines.push(`- chars: ${chars}`);
+    }
+    if (sha256) {
+        lines.push(`- sha256: ${sha256}`);
+    }
+    return lines.join("\n");
+}