@tea-agent/loop-agent 0.1.0

package/dist/executors/dag-pi-executor.js

@@ -0,0 +1,322 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { executePiStep, } from "./pi-executor.js";
+import { redactPromptForLog, truncateOutput } from "./cursor-executor.js";
+import { readGitStatusPorcelain, runPostRunWriteGuard, } from "./shell-write-guard.js";
+export const DAG_PI_READONLY_TOOLS = ["read", "grep", "find", "ls"];
+export const DAG_PI_WRITE_TOOLS = [
+    "read",
+    "bash",
+    "edit",
+    "write",
+    "grep",
+    "find",
+    "ls",
+];
+export const DEFAULT_DAG_PI_PROVIDER = "wizard-local";
+export const DAG_PI_MODEL_PROVIDERS = {
+    "gpt-5.3-codex-spark": "wizard-local",
+    "gpt-5.5": "wizard-local",
+    "glm-5.2": "wizard-local",
+};
+const SAFE_PI_STEPS = new Set([
+    "analyze",
+    "plan",
+    "verify",
+    "retrospective",
+    "spec",
+]);
+const PI_WRITE_STEPS = new Set([...SAFE_PI_STEPS, "implement"]);
+const ROLE_TO_PERSONA = {
+    planner: "planner",
+    scout: "scout",
+    implementer: "planner",
+    reviewer: "reviewer",
+    supervisor: "supervisor",
+    verifier: "verifier",
+    closeout: "closeout",
+};
+const PI_STEP_PERSONA_ALIASES = {
+    analyze: "scout",
+    plan: "planner",
+    verify: "verifier",
+    retrospective: "closeout",
+    spec: "planner",
+    generic: "planner",
+    scout: "scout",
+    planner: "planner",
+    reviewer: "reviewer",
+    supervisor: "supervisor",
+    verifier: "verifier",
+    closeout: "closeout",
+};
+const PERSONA_TO_EXECUTOR_STEP = {
+    closeout: "retrospective",
+    planner: "plan",
+    reviewer: "analyze",
+    scout: "analyze",
+    supervisor: "analyze",
+    verifier: "verify",
+};
+const PI_WRITE_ROLE_TO_STEP = {
+    planner: "plan",
+    scout: "analyze",
+    implementer: "implement",
+    reviewer: "analyze",
+    supervisor: "analyze",
+    verifier: "verify",
+    closeout: "retrospective",
+};
+const PI_WRITE_STEP_ALIASES = {
+    analyze: "analyze",
+    plan: "plan",
+    verify: "verify",
+    retrospective: "retrospective",
+    spec: "spec",
+    generic: "plan",
+    scout: "analyze",
+    planner: "plan",
+    reviewer: "analyze",
+    supervisor: "analyze",
+    verifier: "verify",
+    closeout: "retrospective",
+    implement: "implement",
+    implementer: "implement",
+};
+/** Map DAG `piStep` / `role` to a DAG persona for read-only Pi nodes. */
+export function resolveDagPiPersona(task) {
+    if (task.piStep) {
+        const mapped = PI_STEP_PERSONA_ALIASES[task.piStep.trim().toLowerCase()];
+        if (mapped)
+            return mapped;
+    }
+    if (task.role) {
+        return ROLE_TO_PERSONA[task.role];
+    }
+    return "planner";
+}
+function resolvePiExecutorStep(persona) {
+    return PERSONA_TO_EXECUTOR_STEP[persona];
+}
+function isDagPiWriteTask(task) {
+    return task.executor === "pi" && task.toolProfile === "write";
+}
+/** Map DAG `piStep` / `role` to a safe workflow step for read-only Pi or bounded write. */
+export function resolveDagPiStepName(task) {
+    if (isDagPiWriteTask(task)) {
+        if (task.piStep) {
+            const mapped = PI_WRITE_STEP_ALIASES[task.piStep.trim().toLowerCase()];
+            if (mapped)
+                return mapped;
+        }
+        if (task.role) {
+            return PI_WRITE_ROLE_TO_STEP[task.role];
+        }
+        return "implement";
+    }
+    return resolvePiExecutorStep(resolveDagPiPersona(task));
+}
+/** Pi DAG nodes are read-only unless they explicitly opt into the bounded write tool profile. */
+export function resolveDagPiToolNames(task) {
+    if (isDagPiWriteTask(task)) {
+        return [...DAG_PI_WRITE_TOOLS];
+    }
+    return [...DAG_PI_READONLY_TOOLS];
+}
+export function buildDagPiUserMessage(task, persona, step) {
+    const role = task.role ?? "unspecified";
+    const writePolicy = task.writePolicy ?? "read-only (default)";
+    if (isDagPiWriteTask(task)) {
+        return [
+            `You are executing hybrid DAG node "${task.id}" (role=${role}, piStep=${step}, writePolicy=${writePolicy}).`,
+            "The system prompt contains the full DAG envelope: objective, constraints, upstream context, and task.",
+            "Use write tools only for the bounded implementation requested by this node.",
+            `Allowed paths: ${(task.allowedPaths ?? []).join(", ") || "(none declared)"}.`,
+            `Write set: ${(task.writeSet ?? []).join(", ") || "(none declared)"}.`,
+            `Forbidden paths: ${(task.forbiddenPaths ?? []).join(", ") || "(none declared)"}.`,
+            "Preserve unrelated files. Do not edit outside allowedPaths/writeSet. Never write forbiddenPaths, .harness/dag-runs/**, or undeclared root artifacts/**.",
+            "Return concise Markdown with changed files, verification performed or still required, and residual risks.",
+            "Do not wrap the output in code fences and do not add conversational preamble.",
+        ].join(" ");
+    }
+    return [
+        `You are executing hybrid DAG node "${task.id}" (role=${role}, piPersona=${persona}, piStep=${step}, writePolicy=${writePolicy}).`,
+        "The system prompt contains the full DAG envelope: objective, constraints, upstream context, and task.",
+        "Use read-only tools only. Do not edit, write, or commit repository files.",
+        "Return your conclusion as plain Markdown text suitable for downstream DAG nodes.",
+        "Do not wrap the output in code fences and do not add conversational preamble.",
+    ].join(" ");
+}
+function resolveDagPiModelConfig(model) {
+    return { provider: DAG_PI_MODEL_PROVIDERS[model] ?? DEFAULT_DAG_PI_PROVIDER, model };
+}
+const SUMMARY_STDOUT_MAX = 4_000;
+const SUMMARY_STDERR_MAX = 2_000;
+export function buildPiPromptRedactedMarkdown(prompt) {
+    const redacted = redactPromptForLog(prompt);
+    return [
+        "# Pi prompt (redacted)",
+        "",
+        `- ${redacted}`,
+        "",
+        "Full prompt text is not stored. See node `result.summary.md` for execution metadata.",
+        "",
+    ].join("\n");
+}
+export function buildPiResultSummaryMarkdown(input) {
+    const stdout = truncateOutput(input.result.stdout, SUMMARY_STDOUT_MAX);
+    const stderr = truncateOutput(input.result.stderr || "", SUMMARY_STDERR_MAX);
+    const lines = [
+        "# Pi execution summary",
+        "",
+        "## Run metadata",
+        "",
+        "| Field | Value |",
+        "|-------|-------|",
+        `| channel | ${input.context.channel} |`,
+        `| dagRunId | ${input.context.dagRunId} |`,
+        `| dagNodeId | ${input.context.dagNodeId} |`,
+        `| cwd | ${input.context.cwd} |`,
+        `| model | ${input.model} |`,
+        `| piPersona | ${input.persona} |`,
+        `| piStep | ${input.step} |`,
+        `| ok | ${input.result.ok} |`,
+        `| failureCategory | ${input.result.failureCategory} |`,
+        `| backend | ${input.result.backend ?? "(unknown)"} |`,
+        `| sdkAttempted | ${input.result.sdkAttempted ?? false} |`,
+        `| durationMs | ${input.result.durationMs} |`,
+        `| tokensUsed | ${input.result.tokensUsed} |`,
+        `| parsedEvents | ${input.result.parsedEvents} |`,
+        "",
+        "## Prompt reference",
+        "",
+        `- ${redactPromptForLog(input.prompt)}`,
+        "",
+        "## Assistant output",
+        "",
+    ];
+    if (input.result.assistantText.trim()) {
+        lines.push("```markdown", input.result.assistantText, "```", "");
+    }
+    if (stdout.text.trim()) {
+        lines.push("### raw stdout", "", "```text", stdout.text, "```", "");
+        if (stdout.truncated)
+            lines.push("_(stdout truncated)_", "");
+    }
+    if (stderr.text.trim()) {
+        lines.push("### stderr", "", "```text", stderr.text, "```", "");
+        if (stderr.truncated)
+            lines.push("_(stderr truncated)_", "");
+    }
+    return lines.join("\n");
+}
+export async function writePiExecutorArtifacts(artifactsDir, input) {
+    await mkdir(artifactsDir, { recursive: true });
+    const promptPath = path.join(artifactsDir, "prompt.redacted.md");
+    const summaryPath = path.join(artifactsDir, "result.summary.md");
+    await writeFile(promptPath, buildPiPromptRedactedMarkdown(input.prompt), "utf-8");
+    await writeFile(summaryPath, buildPiResultSummaryMarkdown(input), "utf-8");
+    return { promptPath, summaryPath };
+}
+export async function executeDagPiNode(input, meta, piStepFn = executePiStep) {
+    const started = Date.now();
+    const persona = resolveDagPiPersona(input.task);
+    const step = resolveDagPiStepName(input.task);
+    const isWriteTask = isDagPiWriteTask(input.task);
+    const allowedSteps = isWriteTask ? PI_WRITE_STEPS : SAFE_PI_STEPS;
+    if (!allowedSteps.has(step)) {
+        return {
+            ok: false,
+            stdout: "",
+            stderr: `unsafe pi step mapping: ${step}`,
+            failureCategory: "invalid-output",
+            durationMs: 0,
+        };
+    }
+    let beforeStatus;
+    if (isWriteTask) {
+        try {
+            beforeStatus = await readGitStatusPorcelain(input.cwd);
+        }
+        catch {
+            beforeStatus = undefined;
+        }
+    }
+    const result = await piStepFn({
+        attachedFiles: [],
+        modelConfig: resolveDagPiModelConfig(input.model),
+        prompt: input.prompt,
+        repoRoot: input.cwd,
+        step,
+        toolNames: resolveDagPiToolNames(input.task),
+        userMessage: buildDagPiUserMessage(input.task, persona, step),
+    });
+    const context = {
+        channel: "dag",
+        cwd: input.cwd,
+        dagRunId: meta.runId,
+        dagNodeId: input.task.id,
+    };
+    await writePiExecutorArtifacts(path.join(meta.runDir, input.task.id), {
+        prompt: input.prompt,
+        model: input.model,
+        context,
+        result,
+        persona,
+        step,
+    });
+    const mapped = mapPiResultToDagNodeResult(result);
+    if (!isWriteTask) {
+        return mapped;
+    }
+    let writeGuardOk = true;
+    let writeGuardViolations = [];
+    if (beforeStatus !== undefined) {
+        try {
+            const guard = await runPostRunWriteGuard({
+                rootCwd: input.cwd,
+                beforeStatus,
+                writePolicy: input.task.writePolicy,
+                writeSet: input.task.writeSet,
+                allowedPaths: input.task.allowedPaths,
+                forbiddenPaths: input.task.forbiddenPaths,
+                concurrentSiblingWriteSets: meta.concurrentSiblingWriteSets,
+            });
+            writeGuardOk = guard.ok;
+            writeGuardViolations = guard.violations;
+        }
+        catch {
+            writeGuardOk = false;
+            writeGuardViolations = ["write guard failed: git status unavailable"];
+        }
+    }
+    if (writeGuardOk) {
+        return mapped;
+    }
+    const stderrParts = [mapped.stderr];
+    stderrParts.push(`write guard failed: ${writeGuardViolations.join(", ")}`);
+    if (meta.writeGuardAttribution === "best-effort") {
+        stderrParts.push("write guard note: concurrent rank writers use best-effort per-node attribution; keep same-rank writeSet entries disjoint");
+    }
+    return {
+        ...mapped,
+        ok: false,
+        stderr: stderrParts.filter(Boolean).join("\n\n"),
+        failureCategory: mapped.ok ? "write-guard" : mapped.failureCategory,
+        durationMs: mapped.durationMs || Date.now() - started,
+    };
+}
+export function mapPiResultToDagNodeResult(result) {
+    return {
+        ok: result.ok,
+        stdout: result.assistantText || result.stdout,
+        stderr: result.stderr,
+        failureCategory: result.failureCategory,
+        durationMs: result.durationMs,
+        assistantText: result.assistantText,
+        backend: result.backend,
+        sdkAttempted: result.sdkAttempted,
+        tokensUsed: result.tokensUsed,
+        parsedEvents: result.parsedEvents,
+    };
+}

package/dist/executors/dag-static-executor.js

@@ -0,0 +1,45 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+export function buildStaticResultSummaryMarkdown(input) {
+    const lines = [
+        "# Static execution summary",
+        "",
+        "## Run metadata",
+        "",
+        "| Field | Value |",
+        "|-------|-------|",
+        `| dagRunId | ${input.runId} |`,
+        `| dagNodeId | ${input.nodeId} |`,
+        `| status | ${input.status} |`,
+        "",
+        "## Result",
+        "",
+        input.resultMarkdown.trim(),
+        "",
+    ];
+    return `${lines.join("\n")}\n`;
+}
+export async function executeDagStaticNode(input, meta) {
+    const staticConfig = input.task.static;
+    if (!staticConfig) {
+        throw new Error(`static task ${input.task.id} requires static config`);
+    }
+    const status = staticConfig.status ?? "success";
+    const started = Date.now();
+    const nodeDir = path.join(meta.runDir, input.task.id);
+    await mkdir(nodeDir, { recursive: true });
+    const summary = buildStaticResultSummaryMarkdown({
+        nodeId: input.task.id,
+        runId: meta.runId,
+        resultMarkdown: staticConfig.resultMarkdown,
+        status,
+    });
+    await writeFile(path.join(nodeDir, "result.summary.md"), summary, "utf-8");
+    return {
+        ok: status === "success",
+        stdout: staticConfig.resultMarkdown,
+        stderr: status === "error" ? staticConfig.resultMarkdown : "",
+        failureCategory: status === "error" ? "static-error" : "success",
+        durationMs: Date.now() - started,
+    };
+}

package/dist/executors/dag.js

@@ -0,0 +1,4 @@
+export * from "./dag-cursor-executor.js";
+export * from "../workflows/dag/executor-registry.js";
+export * from "./dag-pi-executor.js";
+export * from "./dag-static-executor.js";

package/dist/executors/index.js

@@ -0,0 +1,8 @@
+export * from "./pi.js";
+export * from "./pi-sdk.js";
+export * from "./cursor.js";
+export * from "./cursor-worker.js";
+export * from "./shell.js";
+export * from "./static.js";
+export * from "./dag.js";
+export * from "./config.js";

package/dist/executors/model-routing.js

@@ -0,0 +1,60 @@
+export const DEFAULT_DAG_CURSOR_MODEL = "composer-2.5";
+export const DEFAULT_DAG_MODELS = {
+    HIGH: "gpt-5.5",
+    MED: "composer-2.5",
+    LOW: "composer-2.5",
+};
+export function resolveModelSelection(manifest, taskConfig, step, options) {
+    const retryAttempt = options?.retryAttempt ?? 0;
+    if (Object.keys(manifest.modelProfiles ?? {}).length === 0) {
+        return {
+            modelConfig: manifest.models?.[step],
+        };
+    }
+    const profileName = resolveProfileName(manifest, taskConfig.complexity, step, retryAttempt);
+    const profile = profileName ? manifest.modelProfiles?.[profileName] : undefined;
+    if (!profile) {
+        return {
+            modelConfig: manifest.models?.[step],
+            profileName,
+        };
+    }
+    return {
+        modelConfig: {
+            provider: profile.provider,
+            model: profile.model,
+            thinking: profile.thinking,
+            timeoutMs: profile.timeoutMs ?? manifest.models?.[step]?.timeoutMs,
+            fallback: profile.fallback,
+        },
+        profileName,
+    };
+}
+function resolveProfileName(manifest, complexity, step, retryAttempt) {
+    if (step === 'implement' && retryAttempt > 0 && manifest.modelRouting?.implementRetry) {
+        return manifest.modelRouting.implementRetry;
+    }
+    const route = manifest.modelRouting?.[step];
+    if (!route) {
+        return undefined;
+    }
+    return route[complexity];
+}
+export function formatModelSelectionLabel(modelConfig, profileName) {
+    if (!modelConfig) {
+        return profileName ? `${profileName}` : 'default';
+    }
+    const base = modelConfig.provider && modelConfig.model
+        ? `${modelConfig.provider}/${modelConfig.model}`
+        : modelConfig.model ?? 'default';
+    return profileName ? `${profileName}:${base}` : base;
+}
+export function formatFallbackLabel(profile) {
+    if (!profile?.fallback) {
+        return undefined;
+    }
+    const fallback = profile.fallback;
+    return fallback.provider && fallback.model
+        ? `${fallback.provider}/${fallback.model}`
+        : fallback.model;
+}

package/dist/executors/pi-event-serializer.js

@@ -0,0 +1,43 @@
+/**
+ * Normalize Pi SDK session events into CLI-compatible JSONL lines
+ * so existing stdout extractors can be reused without modification.
+ */
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+/** Map SDK event shapes to the JSONL format emitted by `pi -p --mode json`. */
+export function normalizePiSessionEvent(event) {
+    const type = typeof event.type === 'string' ? event.type : undefined;
+    if (type === 'assistant_message' && isRecord(event.message)) {
+        return {
+            type: 'turn_end',
+            message: event.message,
+            usage: event.usage,
+        };
+    }
+    if (type === 'tool_start' && typeof event.toolName === 'string') {
+        return {
+            type: 'tool_execution_start',
+            toolName: event.toolName,
+            toolCallId: event.toolCallId,
+            input: event.input,
+        };
+    }
+    if (type === 'tool_end' && typeof event.toolName === 'string') {
+        return {
+            type: 'tool_execution_end',
+            toolName: event.toolName,
+            toolCallId: event.toolCallId,
+            isError: event.isError,
+        };
+    }
+    return event;
+}
+/** Serialize one SDK session event as a single JSONL line. */
+export function serializeSessionEvent(event) {
+    return JSON.stringify(normalizePiSessionEvent(event));
+}
+/** Serialize multiple events into newline-delimited JSON (no trailing newline). */
+export function serializeSessionEvents(events) {
+    return events.map(serializeSessionEvent).join('\n');
+}