@tea-agent/loop-agent 0.33.7-beta.0 → 0.34.1

package/dist/shared/operator/capabilities.js

@@ -586,13 +586,13 @@ export function buildOperatorCapabilitiesDocument() {
         },
         {
             action: "importPrd",
-            cli: "loop-agent task advance <id> --prd <server-staged-path> --json",
+            cli: "loop-agent task advance <id> --prd <server-staged-path> --json (+ intake bridge)",
             kind: "mutation",
             inputSchemaVersion: 1,
             resultSchemaVersion: 1,
             envelopeSchemaVersion: 1,
             requiredErrorCodes: [...COMMON_MUTATION_ERRORS, "PATH_OUTSIDE_REPO"],
-            description: "Archive immutable PRD via task advance (server-staged file).",
+            description: "Archive PRD via task advance, run intake bridge (deterministic/semantic), rewrite Console draft.",
             inputParams: [
                 {
                     name: "taskId",
@@ -606,6 +606,30 @@ export function buildOperatorCapabilitiesDocument() {
                     required: true,
                     description: "PRD markdown content",
                 },
+                {
+                    name: "taskKind",
+                    type: "string",
+                    required: false,
+                    description: "workflow kind (human-selected)",
+                },
+                {
+                    name: "allowedPaths",
+                    type: "array",
+                    required: false,
+                    description: "optional engineering allowedPaths (human-confirmed)",
+                },
+                {
+                    name: "forbiddenPaths",
+                    type: "array",
+                    required: false,
+                    description: "optional engineering forbiddenPaths",
+                },
+                {
+                    name: "verifyCommands",
+                    type: "array",
+                    required: false,
+                    description: "optional verify commands (label:command or shell)",
+                },
             ],
             modelCallable: "always",
             humanConfirmation: "none",
@@ -699,6 +723,36 @@ export function buildOperatorCapabilitiesDocument() {
             modelCallable: "always",
             humanConfirmation: "none",
         },
+        {
+            action: "prepareDagExecution",
+            cli: "console aggregate execution receipt (server-side G2 assessment)",
+            kind: "read",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: [
+                "INVALID_INPUT",
+                "BINDING_DRIFT",
+                "HUMAN_CONFIRMATION_REQUIRED",
+            ],
+            description: "Issue a session-bound single-use execution receipt after server-side G2 assessment (bounded writeSet ⊆ allowedPaths, no forbidden overlap, no broad/destructive risk, structured verification). The model never passes a raw DAG path.",
+            inputParams: [
+                {
+                    name: "taskId",
+                    type: "string",
+                    required: true,
+                    description: "task id",
+                },
+                {
+                    name: "profile",
+                    type: "string",
+                    required: false,
+                    description: "DAG profile (defaults to auto)",
+                },
+            ],
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
         {
             action: "confirmDagConfirmation",
             cli: "console aggregate confirmation human challenge (server-side)",
@@ -901,7 +955,7 @@ export function buildOperatorCapabilitiesDocument() {
         },
         {
             action: "runDag",
-            cli: "loop-agent task advance <taskId> --approve-gate <id:digest> --json | dag execute --dag <path>",
+            cli: "loop-agent task advance <taskId> --approve-gate <id:digest> --json | dag execute --dag <staged-path>",
             kind: "long-running",
             inputSchemaVersion: 1,
             resultSchemaVersion: 1,
@@ -911,19 +965,20 @@ export function buildOperatorCapabilitiesDocument() {
                 "CONTROLLER_MISMATCH",
                 "INVALID_INPUT",
             ],
-            description: "Execute reviewed DAG after human confirmation (prefer task advance --approve-gate when gate token present).",
+            description: "Consume a single-use execution receipt and execute the reviewed DAG (prefer task advance --approve-gate when gate token present). accepted/queued/running/operationId are NOT completion — supervise via operationGet/status/dagReport/dagDoctor.",
             inputParams: [
                 {
-                    name: "confirmationId",
+                    name: "executionId",
                     type: "string",
                     required: true,
-                    description: "confirmation id (from prepareDagConfirmation) — raw dag path is never accepted from the model",
+                    description: "execution id (from prepareDagExecution) — raw dag path is never accepted from the model",
                 },
             ],
-            // prepare-only: the model can invoke runDag but it MUST carry a
-            // confirmationId that was consumed by a human-origin confirm (M0-B).
-            modelCallable: "prepare-only",
-            humanConfirmation: "required",
+            // always: the model can invoke runDag with a server-issued executionId.
+            // The server re-validates staged bytes/hash + bindings at consume time
+            // (2026-08-11 autonomous DAG supervision; receipt replaces browser gate).
+            modelCallable: "always",
+            humanConfirmation: "none",
         },
         {
             action: "dagRerunPlan",
@@ -963,7 +1018,7 @@ export function buildOperatorCapabilitiesDocument() {
                 "BINDING_DRIFT",
                 "INVALID_INPUT",
             ],
-            description: "Execute R1 continuation from effective node. Requires planHash from a fresh dagRerunPlan (eligible=true). Prefer this over new task / standaloneTaskRerun for provider flake and safe downstream failures. Human Gate required.",
+            description: "Execute R1 continuation from effective node. Requires planHash from a fresh dagRerunPlan (eligible=true). Prefer this over new task / standaloneTaskRerun for provider flake and safe downstream failures. Server enforces planHash/binding/fingerprint freshness.",
             inputParams: [
                 {
                     name: "runId",
@@ -990,8 +1045,11 @@ export function buildOperatorCapabilitiesDocument() {
                     description: "why continue from this node (e.g. provider flake; resume from review-pi)",
                 },
             ],
-            modelCallable: "prepare-only",
-            humanConfirmation: "required",
+            // always: fresh eligible dagRerun plans are model-callable (2026-08-11).
+            // The CLI keeps enforcing parent lifecycle, fromNode, planHash,
+            // binding/fingerprint and request idempotency.
+            modelCallable: "always",
+            humanConfirmation: "none",
         },
         {
             action: "prepareMutationGate",
@@ -1001,13 +1059,13 @@ export function buildOperatorCapabilitiesDocument() {
             resultSchemaVersion: 1,
             envelopeSchemaVersion: 1,
             requiredErrorCodes: ["INVALID_INPUT", "NOT_FOUND"],
-            description: "Prepare a one-shot Human Gate receipt for standaloneTaskRerun / workerTaskRetry / Night Scheduler mutations. Model may prepare; only the browser mutation gate may consume.",
+            description: "Prepare a one-shot Human Gate receipt for Night Scheduler mutations. Model may prepare; only the browser mutation gate may consume.",
             inputParams: [
                 {
                     name: "action",
                     type: "string",
                     required: true,
-                    description: "target action: standaloneTaskRerun | workerTaskRetry | workerAdmissionPrepare | workerSchedulerAdd | workerSchedulerCancel | workerSchedulerHarvest | workerSchedulerDiscard",
+                    description: "target action: workerAdmissionPrepare | workerSchedulerAdd | workerSchedulerCancel | workerSchedulerHarvest | workerSchedulerDiscard",
                 },
                 {
                     name: "actionParams",
@@ -1259,7 +1317,7 @@ export function buildOperatorCapabilitiesDocument() {
                 "INVALID_INPUT",
                 "HUMAN_CONFIRMATION_REQUIRED",
             ],
-            description: "Full standalone task regenerate → validate → execute with parent lineage.",
+            description: "Full standalone task regenerate → validate → execute with parent lineage. Only when node rerun plan is ineligible or primaryRecovery recommends rerun-task; the server checks read-only run facts before accepting.",
             inputParams: [
                 {
                     name: "runId",
@@ -1274,20 +1332,22 @@ export function buildOperatorCapabilitiesDocument() {
                     description: "rerun reason",
                 },
                 {
-                    name: "confirmationId",
+                    name: "profile",
                     type: "string",
-                    required: true,
-                    description: "mutation-gate receipt id from prepareMutationGate",
+                    required: false,
+                    description: "DAG profile (defaults to auto)",
                 },
                 {
-                    name: "humanGateToken",
-                    type: "object",
-                    required: true,
-                    description: "server-signed human-gate token from prepareMutationGate",
+                    name: "taskId",
+                    type: "string",
+                    required: false,
+                    description: "original task id (must match the run's task binding; never invent a new task-id)",
                 },
             ],
-            modelCallable: "prepare-only",
-            humanConfirmation: "required",
+            // always: the server gate is the read-only run-facts check (2026-08-11);
+            // no browser Human Gate token is required for safe same-task rerun.
+            modelCallable: "always",
+            humanConfirmation: "none",
         },
         {
             action: "workerTaskRetry",
@@ -1301,7 +1361,7 @@ export function buildOperatorCapabilitiesDocument() {
                 "INVALID_INPUT",
                 "HUMAN_CONFIRMATION_REQUIRED",
             ],
-            description: "Requeue failed Task Pool task (Failed → Ready) via in-package pool store.",
+            description: "Requeue failed Task Pool task (Failed → Ready) via in-package pool store. Only when read-only validation confirms the task exists in Failed state; the server checks this before accepting.",
             inputParams: [
                 {
                     name: "taskId",
@@ -1321,21 +1381,11 @@ export function buildOperatorCapabilitiesDocument() {
                     required: true,
                     description: "retry reason",
                 },
-                {
-                    name: "confirmationId",
-                    type: "string",
-                    required: true,
-                    description: "mutation-gate receipt id from prepareMutationGate",
-                },
-                {
-                    name: "humanGateToken",
-                    type: "object",
-                    required: true,
-                    description: "server-signed human-gate token from prepareMutationGate",
-                },
             ],
-            modelCallable: "prepare-only",
-            humanConfirmation: "required",
+            // always: the server gate is the read-only worker task facts check
+            // (2026-08-11); no browser Human Gate token is required.
+            modelCallable: "always",
+            humanConfirmation: "none",
         },
         ...OFFICIAL_ACTIONS,
     ];
@@ -1411,9 +1461,10 @@ export const OPERATOR_COMMAND_COVERAGE = Object.freeze([
     },
     {
         command: "loop-agent dag execute",
-        coverage: "human-gated-required",
+        coverage: "model-callable",
         action: "runDag",
         source: "loop-agent",
+        note: "runDag consumes a server-issued single-use execution receipt (prepareDagExecution); browser Human Gate no longer required for bounded DAGs (2026-08-11).",
     },
     {
         command: "loop-agent cursor-prompt",
@@ -1829,15 +1880,17 @@ export const OPERATOR_COMMAND_COVERAGE = Object.freeze([
     },
     {
         command: "loop-agent dag rerun",
-        coverage: "human-gated-required",
+        coverage: "model-callable",
         action: "dagRerun",
         source: "loop-agent",
+        note: "fresh eligible dagRerunPlan (planHash) is model-callable; the CLI still enforces plan/binding/fingerprint freshness (2026-08-11).",
     },
     {
         command: "loop-agent dag rerun-task",
-        coverage: "human-gated-required",
+        coverage: "model-callable",
         action: "standaloneTaskRerun",
         source: "loop-agent",
+        note: "server-side read-only run-facts check (ineligible plan / explicit rerun-task recommendation) replaces the browser Human Gate (2026-08-11).",
     },
     {
         command: "loop-agent dag reconcile-tasks",
@@ -2069,9 +2122,10 @@ export const OPERATOR_COMMAND_COVERAGE = Object.freeze([
     },
     {
         command: "agent-worker task retry",
-        coverage: "human-gated-required",
+        coverage: "model-callable",
         action: "workerTaskRetry",
         source: "agent-worker",
+        note: "server-side read-only pool doctor facts check (Failed state) replaces the browser Human Gate (2026-08-11).",
     },
     {
         command: "agent-worker task draft-followup",

package/dist/shared/resilient-git.js

@@ -0,0 +1,133 @@
+import { spawn } from "node:child_process";
+import { access, constants } from "node:fs/promises";
+import path from "node:path";
+/** Thrown only for spawn/infrastructure failures or exhausted eligible startup retries. */
+export class ResilientGitCommandError extends Error {
+    diagnostics;
+    constructor(input) {
+        const last = input.attempts.at(-1);
+        super(`git ${input.command} unavailable after ${input.attempts.length} attempts (exit code=${last?.exitCode ?? "unavailable"}, exit code hex=${last?.exitCodeHex ?? "unavailable"}, signal=${last?.signal ?? "unavailable"}, cwd=${path.resolve(input.cwd)}): ${last?.detail ?? "unknown infrastructure error"}`);
+        this.name = "ResilientGitCommandError";
+        this.diagnostics = { schemaVersion: 1, ...input };
+    }
+}
+export function isResilientGitCommandError(error) {
+    return error instanceof ResilientGitCommandError;
+}
+export function formatWindowsExitCode(exitCode) {
+    return exitCode === undefined
+        ? undefined
+        : `0x${(exitCode >>> 0).toString(16).padStart(8, "0").toUpperCase()}`;
+}
+export function isWindowsDllInitializationFailure(platform, exitCode) {
+    return platform === "win32" && exitCode !== undefined && (exitCode >>> 0) === 0xc0000142;
+}
+/** Only returns the original executable and its sibling within the same Git installation. */
+export function deriveSameInstallationGitCandidates(primary) {
+    const normalized = path.win32.normalize(primary);
+    const lower = normalized.toLowerCase();
+    let sibling;
+    if (lower.endsWith("\\mingw64\\bin\\git.exe")) {
+        const root = path.win32.resolve(path.win32.dirname(normalized), "..", "..");
+        sibling = path.win32.join(root, "cmd", "git.exe");
+    }
+    else if (lower.endsWith("\\cmd\\git.exe")) {
+        const root = path.win32.resolve(path.win32.dirname(normalized), "..");
+        sibling = path.win32.join(root, "mingw64", "bin", "git.exe");
+    }
+    return [...new Set([normalized, ...(sibling ? [sibling] : [])])];
+}
+const windowsCandidateCache = new Map();
+export async function resolveGitExecutableCandidates(platform, env) {
+    if (platform !== "win32")
+        return ["git"];
+    const pathValue = env.PATH ?? env.Path ?? "";
+    const cached = windowsCandidateCache.get(pathValue);
+    if (cached)
+        return cached;
+    const resolved = resolveWindowsGitExecutableCandidates(pathValue);
+    windowsCandidateCache.set(pathValue, resolved);
+    return resolved;
+}
+async function resolveWindowsGitExecutableCandidates(pathValue) {
+    for (const raw of pathValue.split(path.delimiter)) {
+        const entry = raw.trim().replace(/^"|"$/g, "");
+        if (!entry)
+            continue;
+        const candidate = path.win32.join(entry, "git.exe");
+        try {
+            await access(candidate, constants.X_OK);
+            const candidates = [];
+            for (const executable of deriveSameInstallationGitCandidates(candidate)) {
+                try {
+                    await access(executable, constants.X_OK);
+                    candidates.push(executable);
+                }
+                catch { /* optional sibling */ }
+            }
+            if (candidates.length)
+                return candidates;
+        }
+        catch { /* continue PATH search */ }
+    }
+    return ["git"];
+}
+const DEFAULT_MAX_BUFFER = 16 * 1024 * 1024;
+const bounded = (text) => text.length <= 1000 ? text : `${text.slice(0, 1000)}...[truncated]`;
+/**
+ * Execute a read-only Git command with bounded recovery for Windows startup failures.
+ * Completed non-zero commands are deliberately returned to preserve caller semantics.
+ */
+export async function runResilientGitCommand(options, dependencies = {}) {
+    const platform = dependencies.platform ?? process.platform;
+    const env = { ...(dependencies.env ?? process.env), GIT_OPTIONAL_LOCKS: "0" };
+    const candidates = await (dependencies.resolveExecutableCandidates ?? resolveGitExecutableCandidates)(platform, env);
+    const executables = candidates.length ? candidates : ["git"];
+    const maxAttempts = Math.max(1, options.attempts ?? 3);
+    const delay = Math.max(0, options.retryDelayMs ?? 250);
+    const execute = dependencies.runAttempt ?? spawnGitAttempt;
+    const sleep = dependencies.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    const now = dependencies.now ?? Date.now;
+    const attemptDiagnostics = [];
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        const executable = executables[(attempt - 1) % executables.length];
+        const startedAt = now();
+        try {
+            const result = await execute({ executable, args: options.args, cwd: options.cwd, env, windowsHide: true, maxBuffer: options.maxBuffer ?? DEFAULT_MAX_BUFFER });
+            if (result.code === 0)
+                return result;
+            const dllFailure = isWindowsDllInitializationFailure(platform, result.code);
+            const emptyStartupFailure = result.stdout.length === 0 && result.stderr.length === 0;
+            const eligible = platform === "win32" && (dllFailure || emptyStartupFailure);
+            if (!eligible)
+                return result;
+            attemptDiagnostics.push({
+                attempt, executable, exitCode: result.code, ...(formatWindowsExitCode(result.code) ? { exitCodeHex: formatWindowsExitCode(result.code) } : {}), signal: result.signal,
+                durationMs: Math.max(0, now() - startedAt), detail: bounded("no stdout/stderr"),
+                transientKind: dllFailure ? "windows-dll-init-failed" : "empty-output-startup-failure",
+            });
+        }
+        catch (error) {
+            const detail = bounded(error instanceof Error ? error.message : String(error));
+            attemptDiagnostics.push({ attempt, executable, signal: null, durationMs: Math.max(0, now() - startedAt), detail });
+        }
+        if (attempt < maxAttempts && delay > 0)
+            await sleep(Math.min(4_000, delay * 2 ** (attempt - 1)));
+    }
+    throw new ResilientGitCommandError({ cwd: options.cwd, command: options.args.join(" "), platform, executableCandidates: executables, attempts: attemptDiagnostics });
+}
+function spawnGitAttempt(input) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(input.executable, input.args, { cwd: input.cwd, env: input.env, windowsHide: input.windowsHide, stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        const append = (current, chunk) => {
+            const next = current + String(chunk);
+            return next.length > input.maxBuffer ? next.slice(0, input.maxBuffer) : next;
+        };
+        child.stdout.on("data", (chunk) => { stdout = append(stdout, chunk); });
+        child.stderr.on("data", (chunk) => { stderr = append(stderr, chunk); });
+        child.on("error", reject);
+        child.on("close", (code, signal) => resolve({ code: code ?? 1, signal, stdout, stderr }));
+    });
+}

package/dist/task/source-prepare/artifact-meta.js

@@ -0,0 +1,137 @@
+/**
+ * Product Analysis / Product Requirement artifact frontmatter detection.
+ * Deterministic; no LLM. Used to route intake errors and parseable roles.
+ */
+const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/u;
+function parseYamlishScalar(raw) {
+    const trimmed = raw.trim();
+    if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+        (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+        return trimmed.slice(1, -1).trim();
+    }
+    return trimmed;
+}
+function parseSimpleFrontmatter(block) {
+    const out = {};
+    for (const line of block.split(/\r?\n/)) {
+        const match = /^([A-Za-z0-9_-]+)\s*:\s*(.+?)\s*$/u.exec(line);
+        if (!match)
+            continue;
+        out[match[1]] = parseYamlishScalar(match[2]);
+    }
+    return out;
+}
+function normalizeArtifactType(raw) {
+    if (!raw)
+        return "unknown";
+    const value = raw.trim().toLowerCase();
+    if (value === "product-requirement" || value === "product_requirement") {
+        return "product-requirement";
+    }
+    if (value === "product-analysis" || value === "product_analysis") {
+        return "product-analysis";
+    }
+    if (value === "requirement-clarification" ||
+        value === "requirement_clarification" ||
+        value === "product-clarification") {
+        return "requirement-clarification";
+    }
+    return "unknown";
+}
+/**
+ * Detect Product Analysis V3/V4 style artifact metadata from markdown body.
+ */
+export function detectProductArtifactMeta(markdown) {
+    const match = FRONTMATTER_RE.exec(markdown);
+    if (!match) {
+        return { artifactType: "unknown", recognized: false };
+    }
+    const fields = parseSimpleFrontmatter(match[1]);
+    const artifactType = normalizeArtifactType(fields.artifact_type);
+    const recognized = artifactType !== "unknown" || Boolean(fields.artifact_version);
+    return {
+        artifactType,
+        ...(fields.artifact_version
+            ? { artifactVersion: fields.artifact_version }
+            : {}),
+        ...(fields.requirement_status
+            ? { requirementStatus: fields.requirement_status }
+            : {}),
+        ...(fields.analysis_status
+            ? { analysisStatus: fields.analysis_status }
+            : {}),
+        ...(fields.requirement_id ? { requirementId: fields.requirement_id } : {}),
+        ...(fields.analysis_scope ? { analysisScope: fields.analysis_scope } : {}),
+        recognized,
+    };
+}
+/**
+ * Infer import role from file path basename when --role is omitted.
+ */
+export function inferPrdImportRoleFromPath(filePath) {
+    const base = filePath
+        .replace(/\\/g, "/")
+        .split("/")
+        .pop()
+        ?.toLowerCase()
+        .replace(/\.(md|markdown|txt)$/u, "") ?? "";
+    if (base === "product-analysis" ||
+        base.endsWith("-product-analysis") ||
+        base.includes("product-analysis")) {
+        return "analysis";
+    }
+    if (base === "requirement-clarification" ||
+        base.endsWith("-requirement-clarification") ||
+        base.includes("requirement-clarification") ||
+        base.includes("clarification")) {
+        return "clarification";
+    }
+    if (base === "product-requirement" ||
+        base.endsWith("-product-requirement") ||
+        base.includes("product-requirement")) {
+        return "requirement";
+    }
+    if (base.includes("acceptance"))
+        return "acceptance";
+    return "requirement";
+}
+/**
+ * Prefer path inference; if markdown frontmatter is available and more specific, use it.
+ */
+export function resolvePrdImportRole(input) {
+    if (input.explicitRole?.trim())
+        return input.explicitRole.trim();
+    if (input.markdown) {
+        const meta = detectProductArtifactMeta(input.markdown);
+        if (meta.artifactType === "product-analysis")
+            return "analysis";
+        if (meta.artifactType === "requirement-clarification") {
+            return "clarification";
+        }
+        if (meta.artifactType === "product-requirement")
+            return "requirement";
+    }
+    return inferPrdImportRoleFromPath(input.filePath);
+}
+/** Roles that may contribute requirement facts (objective/AC/scope). */
+export const REQUIREMENT_FACT_ROLES = new Set(["requirement", "acceptance"]);
+/** Roles that are archival references only (not fact sources). */
+export const REFERENCE_ONLY_ROLES = new Set(["analysis", "clarification", "design"]);
+export function isIntakeSoftGapCode(code) {
+    return (code === "EMPTY_ACCEPTANCE" ||
+        code === "EMPTY_OBJECTIVE" ||
+        code === "EMPTY_ALLOWED_PATHS" ||
+        code === "EMPTY_TASK_KIND" ||
+        code === "NO_PARSEABLE_REQUIREMENT" ||
+        code === "PRODUCT_ANALYSIS_NOT_EXECUTABLE" ||
+        code === "PRODUCT_REQUIREMENT_PENDING" ||
+        code === "PRODUCT_CLARIFICATION_NOT_EXECUTABLE" ||
+        code === "PRODUCT_ARTIFACT_NOT_EXECUTABLE" ||
+        code === "MISSING_FEATURE_ID" ||
+        code === "SEMANTIC_INTAKE_RECOMMENDED" ||
+        code === "SEMANTIC_INTAKE_FAILED" ||
+        code === "SEMANTIC_INTAKE_INVALID_OUTPUT" ||
+        code === "SEMANTIC_INTAKE_PI_FAILED" ||
+        code === "SEMANTIC_INTAKE_NO_DOCUMENTS" ||
+        code === "SEMANTIC_INTAKE_REFUSED_NON_EXECUTABLE");
+}

package/dist/task/source-prepare/index.js

@@ -1,6 +1,8 @@
 export * from "./types.js";
 export * from "./path-policy.js";
 export * from "./parse-intent.js";
+export * from "./artifact-meta.js";
+export * from "./semantic-intake.js";
 export * from "./reference-integrity.js";
 export * from "./completeness.js";
 export * from "./build-draft.js";