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

package/dist/task/source-prepare/semantic-intake.js

@@ -0,0 +1,717 @@
+/**
+ * P2 Semantic Intake: one-shot, read-only Pi structuring of imported PRDs
+ * into TaskContractDraftV1. Does not write source/需求.md directly — caller
+ * re-enters prepare with kind:"draft".
+ *
+ * Engineering boundary priority: explicit flags > existing task config >
+ * optional model recommendation (repo-layout-aware fallback for Console
+ * web-wizard flows that never collect human paths).
+ */
+import { mkdir, readdir, readFile, unlink, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+import { executePiStep } from "../../executors/pi-executor.js";
+import { resolveDagPiModelConfig } from "../../executors/dag-pi-executor.js";
+import { resolveExecutorModelMatrices } from "../../executors/model-routing.js";
+import { listPiSdkAvailableModels } from "../../executors/pi-sdk-executor.js";
+import { loadHarnessManifest } from "../../governance/harness.js";
+import { TASK_CONTRACT_DRAFT_SCHEMA_VERSION } from "../contract/constants.js";
+import { getTaskPaths } from "../runtime.js";
+import { detectProductArtifactMeta } from "./artifact-meta.js";
+import { filterPlaceholderPaths } from "./placeholder-paths.js";
+export const SEMANTIC_INTAKE_ARTIFACT_REL = "artifacts/intake/semantic-draft.json";
+export const SEMANTIC_INTAKE_ATTEMPT_MARKER = "artifacts/intake/semantic-intake-attempted.json";
+/** Per-model wall clock for one semantic-intake Pi attempt. */
+export const SEMANTIC_INTAKE_ATTEMPT_TIMEOUT_MS = 300_000;
+/** Extra Pi-catalog models after MED → HIGH → LOW. */
+export const SEMANTIC_INTAKE_MAX_EXTRA_MODELS = 5;
+/** Parent CLI budget covering harness tiers plus extra catalog models. */
+export const SEMANTIC_INTAKE_CLI_TIMEOUT_MS = SEMANTIC_INTAKE_ATTEMPT_TIMEOUT_MS *
+    (3 + SEMANTIC_INTAKE_MAX_EXTRA_MODELS);
+const NON_CHAT_MODEL = /embed|whisper|tts|dall-e|dalle|image|rerank|moderation/i;
+const productArtifactBlockers = new Set([
+    "PRODUCT_ANALYSIS_NOT_EXECUTABLE",
+    "PRODUCT_CLARIFICATION_NOT_EXECUTABLE",
+    "PRODUCT_REQUIREMENT_PENDING",
+    "PRODUCT_ARTIFACT_NOT_EXECUTABLE",
+]);
+const engineeringRecommendationSchema = z
+    .object({
+    taskKind: z.string().min(1).optional(),
+    allowedPaths: z.array(z.string()).optional(),
+    forbiddenPaths: z.array(z.string()).optional(),
+    verifyCommands: z
+        .array(z.object({
+        label: z.string().min(1),
+        command: z.string().min(1),
+        timeoutMs: z.number().int().positive().optional(),
+    }))
+        .optional(),
+})
+    .optional();
+const requirementDraftSchema = z.object({
+    objective: z.string().min(1),
+    scope: z.array(z.string()).default([]),
+    nonGoals: z.array(z.string()).default([]),
+    acceptanceCriteria: z
+        .array(z.object({
+        id: z.string().min(1),
+        text: z.string().min(1),
+        provenance: z
+            .enum(["explicit", "derived", "inferred"])
+            .optional()
+            .default("derived"),
+    }))
+        .min(1),
+    openQuestions: z.array(z.string()).optional(),
+    assumptions: z.array(z.string()).optional(),
+    title: z.string().optional(),
+    /** Optional model engineering recommendation (flags/existing still win). */
+    engineering: engineeringRecommendationSchema,
+});
+export function isSemanticIntakeDisabled(env = process.env) {
+    const raw = (env.LOOP_AGENT_SEMANTIC_INTAKE ?? "").trim().toLowerCase();
+    if (raw === "0" || raw === "false" || raw === "off" || raw === "no") {
+        return true;
+    }
+    return false;
+}
+/**
+ * When deterministic parse leaves soft intake gaps that look like "structure
+ * problem" (not product-analysis / pending), allow one Pi structuring pass.
+ */
+export function evaluateSemanticIntakeEligibility(input) {
+    if (input.disabled) {
+        return { eligible: false, reason: "semantic intake disabled" };
+    }
+    if (input.alreadyAttempted && !input.force) {
+        return { eligible: false, reason: "semantic intake already attempted" };
+    }
+    if (!input.hasImportedPrd && !input.force) {
+        return { eligible: false, reason: "no imported PRD" };
+    }
+    const blocking = input.gaps.filter((g) => g.level === "blocking");
+    const codes = new Set(input.gaps.map((g) => g.code));
+    const blockingCodes = new Set(blocking.map((g) => g.code));
+    for (const code of productArtifactBlockers) {
+        if (blockingCodes.has(code)) {
+            return {
+                eligible: false,
+                reason: `product-artifact blocker ${code} requires human product work, not LLM structuring`,
+            };
+        }
+    }
+    // Invalid-value engineering gaps are NOT fixed by semantic intake (the
+    // model cannot repair a rejected path policy or an illegal overlap).
+    // Missing-value engineering gaps (EMPTY_ALLOWED_PATHS / EMPTY_TASK_KIND)
+    // ARE the documented Console web-wizard case: the wizard never collects
+    // human paths, so the repo-layout-aware model recommendation is the
+    // designed fallback (see module header). Keep them eligible.
+    const invalidEngineering = blocking.length > 0 &&
+        blocking.every((g) => g.code === "MISSING_FEATURE_ID" ||
+            g.code === "PATH_POLICY" ||
+            g.code.startsWith("UNSAFE_") ||
+            g.code === "ALLOWED_FORBIDDEN_OVERLAP");
+    if (invalidEngineering) {
+        return {
+            eligible: false,
+            reason: "engineering boundary gaps carry invalid values; fix the flags/paths",
+        };
+    }
+    const structural = codes.has("SEMANTIC_INTAKE_RECOMMENDED") ||
+        blockingCodes.has("EMPTY_ACCEPTANCE") ||
+        blockingCodes.has("EMPTY_OBJECTIVE") ||
+        blockingCodes.has("NO_PARSEABLE_REQUIREMENT") ||
+        blockingCodes.has("EMPTY_ALLOWED_PATHS") ||
+        blockingCodes.has("EMPTY_TASK_KIND");
+    if (!structural && !input.force) {
+        return {
+            eligible: false,
+            reason: "no structural requirement gaps for semantic intake",
+        };
+    }
+    return {
+        eligible: true,
+        reason: "structural or engineering-boundary gaps with imported sources",
+    };
+}
+function intakeModelKey(ref) {
+    return ref.trim().replace(/\\/g, "/").toLowerCase();
+}
+function intakeModelRef(provider, id) {
+    const trimmedId = id.trim();
+    if (trimmedId.includes("/"))
+        return trimmedId.replace(/\\/g, "/");
+    return `${provider.trim()}/${trimmedId}`;
+}
+/**
+ * MED → HIGH → LOW from harness, then Pi-supported catalog models
+ * (credentialed first). Duplicates and non-chat ids are skipped.
+ */
+export function buildSemanticIntakeModelQueue(input) {
+    const seen = new Set();
+    const queue = [];
+    const push = (raw) => {
+        const ref = raw?.trim().replace(/\\/g, "/");
+        if (!ref)
+            return;
+        const key = intakeModelKey(ref);
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        queue.push(ref);
+    };
+    push(input.harness.MED);
+    push(input.harness.HIGH);
+    push(input.harness.LOW);
+    const extras = [...(input.available ?? [])]
+        .filter((entry) => {
+        const hay = `${entry.id} ${entry.name ?? ""} ${entry.provider}`;
+        return !NON_CHAT_MODEL.test(hay);
+    })
+        .sort((left, right) => {
+        const leftCred = left.hasCredentials === true ? 0 : 1;
+        const rightCred = right.hasCredentials === true ? 0 : 1;
+        if (leftCred !== rightCred)
+            return leftCred - rightCred;
+        return intakeModelRef(left.provider, left.id).localeCompare(intakeModelRef(right.provider, right.id));
+    });
+    let extraCount = 0;
+    for (const entry of extras) {
+        if (extraCount >= SEMANTIC_INTAKE_MAX_EXTRA_MODELS)
+            break;
+        const before = queue.length;
+        push(intakeModelRef(entry.provider, entry.id));
+        if (queue.length > before)
+            extraCount += 1;
+    }
+    return queue;
+}
+export function extractJsonObject(text) {
+    const fenced = /```(?:json)?\s*([\s\S]*?)```/iu.exec(text);
+    const candidate = fenced?.[1]?.trim() || text.trim();
+    const start = candidate.indexOf("{");
+    const end = candidate.lastIndexOf("}");
+    if (start < 0 || end <= start) {
+        throw new Error("no JSON object found in model output");
+    }
+    try {
+        return JSON.parse(candidate.slice(start, end + 1));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`invalid JSON object in model output: ${message}`);
+    }
+}
+export function parseSemanticRequirementDraft(text) {
+    const raw = extractJsonObject(text);
+    return requirementDraftSchema.parse(raw);
+}
+/** Reject drafts that invent product behavior when only inferred ACs exist. */
+export function assertSemanticDraftAcceptable(draft) {
+    const inferredOnly = draft.acceptanceCriteria.length > 0 &&
+        draft.acceptanceCriteria.every((ac) => ac.provenance === "inferred");
+    if (inferredOnly) {
+        throw new Error("semantic intake produced only inferred acceptance criteria; refuse to invent product behavior");
+    }
+    if (!draft.objective.trim()) {
+        throw new Error("semantic intake objective is empty");
+    }
+}
+export function buildDraftFromSemanticIntake(input) {
+    const modelEng = input.semantic.engineering ?? {};
+    const modelAllowed = filterPlaceholderPaths(modelEng.allowedPaths);
+    const modelForbidden = filterPlaceholderPaths(modelEng.forbiddenPaths);
+    const modelVerify = (modelEng.verifyCommands ?? []).filter((c) => c.label?.trim() && c.command?.trim());
+    // Priority: explicit flags > existing task config > model recommendation.
+    const flagAllowed = input.flags.allowedPaths ?? [];
+    const existingAllowed = input.existingAllowedPaths ?? [];
+    let allowedPaths;
+    if (flagAllowed.length > 0) {
+        allowedPaths = [...existingAllowed, ...flagAllowed];
+    }
+    else if (existingAllowed.length > 0) {
+        allowedPaths = existingAllowed;
+    }
+    else {
+        allowedPaths = modelAllowed;
+    }
+    const flagForbidden = input.flags.forbiddenPaths ?? [];
+    const existingForbidden = input.existingForbiddenPaths ?? [];
+    let forbiddenPaths;
+    if (flagForbidden.length > 0) {
+        forbiddenPaths = [...existingForbidden, ...flagForbidden];
+    }
+    else if (existingForbidden.length > 0) {
+        forbiddenPaths = existingForbidden;
+    }
+    else {
+        forbiddenPaths = modelForbidden;
+    }
+    let verifyCommands;
+    if (input.flags.verifyCommands?.length) {
+        verifyCommands = input.flags.verifyCommands;
+    }
+    else if (input.existingVerify?.length) {
+        verifyCommands = input.existingVerify;
+    }
+    else {
+        verifyCommands = modelVerify;
+    }
+    // flags.taskKind is hard; bare caller "standard" is a soft default and must
+    // not block a model recommendation for Console web-wizard flows.
+    const explicitTaskKind = input.flags.taskKind?.trim();
+    const callerTaskKind = input.taskKind?.trim();
+    const modelTaskKind = modelEng.taskKind?.trim();
+    const taskKind = explicitTaskKind ||
+        (callerTaskKind && callerTaskKind !== "standard"
+            ? callerTaskKind
+            : undefined) ||
+        modelTaskKind ||
+        callerTaskKind ||
+        "standard";
+    const draft = {
+        schemaVersion: TASK_CONTRACT_DRAFT_SCHEMA_VERSION,
+        taskId: input.taskId,
+        title: input.semantic.title?.trim() || input.title,
+        taskKind,
+        ...(explicitTaskKind || input.flags.taskKindExplicit
+            ? { taskKindExplicit: true }
+            : {}),
+        requirement: {
+            objective: input.semantic.objective.trim(),
+            scope: input.semantic.scope.map((s) => s.trim()).filter(Boolean),
+            nonGoals: input.semantic.nonGoals.map((s) => s.trim()).filter(Boolean),
+            acceptanceCriteria: input.semantic.acceptanceCriteria.map((ac) => ({
+                id: ac.id.trim(),
+                text: ac.text.trim(),
+            })),
+        },
+        constraints: {
+            invariants: input.flags.invariants ?? [],
+            allowedPaths: [
+                ...new Set(allowedPaths.map((p) => p.trim()).filter(Boolean)),
+            ],
+            forbiddenPaths: [
+                ...new Set(forbiddenPaths.map((p) => p.trim()).filter(Boolean)),
+            ],
+            ...(input.flags.allowedRoots
+                ? { allowedRoots: input.flags.allowedRoots }
+                : {}),
+        },
+        verification: {
+            commands: verifyCommands
+                .filter((c) => c.label && c.command)
+                .map((c) => ({
+                label: c.label,
+                command: c.command,
+                ...(c.timeoutMs !== undefined ? { timeoutMs: c.timeoutMs } : {}),
+            })),
+        },
+    };
+    if (input.featureId || input.flags.featureId) {
+        draft.featureId = input.flags.featureId ?? input.featureId;
+    }
+    if (input.references?.length)
+        draft.references = input.references;
+    if (input.semantic.openQuestions?.length) {
+        draft.openQuestions = input.semantic.openQuestions;
+    }
+    if (input.semantic.assumptions?.length) {
+        draft.assumptions = input.semantic.assumptions;
+    }
+    return draft;
+}
+/**
+ * Cheap repo-layout hint injected into the semantic intake prompt so the model
+ * can recommend minimal write boundaries and real verify commands when humans
+ * never fill Console form engineering fields.
+ */
+export async function buildRepoHint(repoRoot) {
+    const lines = ["Repo layout hint (best-effort, may be incomplete):"];
+    try {
+        const top = await readdir(repoRoot, { withFileTypes: true });
+        const dirs = top
+            .filter((entry) => entry.isDirectory() && !entry.name.startsWith("."))
+            .map((entry) => entry.name)
+            .slice(0, 24);
+        const files = top
+            .filter((entry) => entry.isFile())
+            .map((entry) => entry.name)
+            .slice(0, 24);
+        lines.push(`top-level dirs: ${dirs.join(", ") || "(none)"}`);
+        lines.push(`top-level files: ${files.join(", ") || "(none)"}`);
+        const packageCandidates = [
+            "package.json",
+            path.join("source", "package.json"),
+            path.join("packages", "package.json"),
+        ];
+        for (const rel of packageCandidates) {
+            const abs = path.join(repoRoot, rel);
+            try {
+                const raw = await readFile(abs, "utf-8");
+                const pkg = JSON.parse(raw);
+                const scripts = Object.keys(pkg.scripts ?? {}).slice(0, 20);
+                lines.push(`${rel} scripts: ${scripts.join(", ") || "(none)"}`);
+                if (pkg.workspaces !== undefined) {
+                    lines.push(`${rel} workspaces: ${JSON.stringify(pkg.workspaces).slice(0, 200)}`);
+                }
+            }
+            catch {
+                // optional
+            }
+        }
+        // Sample test-like files under common roots (bounded).
+        const testRoots = ["src", "source", "packages", "test", "tests"].filter((name) => dirs.includes(name));
+        const samples = [];
+        const counts = new Map();
+        const walk = async (dir, depth) => {
+            if (depth > 3 || samples.length >= 15)
+                return;
+            let entries;
+            try {
+                entries = await readdir(dir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const entry of entries) {
+                if (entry.name.startsWith(".") || entry.name === "node_modules")
+                    continue;
+                const abs = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    await walk(abs, depth + 1);
+                    continue;
+                }
+                if (!entry.isFile())
+                    continue;
+                if (!/\.(test|spec)\.(ts|tsx|js|jsx|mjs|cjs)$/i.test(entry.name))
+                    continue;
+                const rel = path.relative(repoRoot, abs).replace(/\\/g, "/");
+                const top = rel.split("/")[0] ?? rel;
+                counts.set(top, (counts.get(top) ?? 0) + 1);
+                if (samples.length < 15)
+                    samples.push(rel);
+            }
+        };
+        for (const root of testRoots) {
+            await walk(path.join(repoRoot, root), 0);
+        }
+        const total = [...counts.values()].reduce((sum, n) => sum + n, 0);
+        if (total > 0) {
+            const byTop = [...counts.entries()]
+                .map(([name, n]) => `${name}:${n}`)
+                .join(", ");
+            lines.push(`test-like files: total=${total} byTop=${byTop}`);
+            lines.push(`test samples: ${samples.join(", ")}`);
+        }
+    }
+    catch {
+        lines.push("(repo scan failed)");
+    }
+    return lines.join("\n");
+}
+async function buildPrompt(input) {
+    const bodies = input.documents
+        .map((doc, index) => {
+        const meta = detectProductArtifactMeta(doc.content);
+        const metaLine = meta.recognized
+            ? `artifact_type=${meta.artifactType} status=${meta.requirementStatus ?? meta.analysisStatus ?? "n/a"}`
+            : "artifact_type=unknown";
+        const clipped = doc.content.length > 24_000
+            ? `${doc.content.slice(0, 24_000)}\n\n[truncated]`
+            : doc.content;
+        return [
+            `### Document ${index + 1}`,
+            `role: ${doc.role}`,
+            `path: ${doc.materializedPath}`,
+            metaLine,
+            "```markdown",
+            clipped,
+            "```",
+        ].join("\n");
+    })
+        .join("\n\n");
+    const repoHint = input.repoRoot
+        ? await buildRepoHint(input.repoRoot)
+        : "(no repo layout hint)";
+    return [
+        "You are a read-only requirement structurer for loop-agent task intake.",
+        "Convert imported product documents into a thin requirement draft JSON.",
+        "Do NOT invent product behavior that is not supported by the documents.",
+        "You MAY recommend an optional engineering block when the repo layout hint supports it:",
+        "- allowedPaths / forbiddenPaths as minimal precise globs (e.g. source/packages/**/*.test.ts)",
+        "- verifyCommands as real package scripts (e.g. pnpm -C source test)",
+        "- taskKind when clearly implied (backend-test / frontend-test / standard / …)",
+        "Prefer smallest correct write boundary; do not invent product paths that are not in the layout hint.",
+        "Do NOT rewrite or suggest editing the original PRD files.",
+        "Prefer explicit text; use provenance derived for rephrasing; use inferred only when clearly implied — if you must invent ACs, leave acceptanceCriteria empty so the system can stop for clarification.",
+        "When documents embed formal AC headings (e.g. #### AC-FE-001 …), copy each AC verbatim under the SAME id with provenance explicit; do not rephrase or renumber them.",
+        "Return exactly one JSON object, no markdown prose outside optional fence:",
+        JSON.stringify({
+            title: "optional string",
+            objective: "required string",
+            scope: ["bullet"],
+            nonGoals: ["bullet"],
+            acceptanceCriteria: [
+                {
+                    id: "AC-001",
+                    text: "observable criterion",
+                    provenance: "explicit|derived|inferred",
+                },
+            ],
+            openQuestions: ["optional"],
+            assumptions: ["optional"],
+            engineering: {
+                taskKind: "optional string",
+                allowedPaths: ["optional globs"],
+                forbiddenPaths: ["optional globs"],
+                verifyCommands: [
+                    { label: "test", command: "pnpm -C source test" },
+                ],
+            },
+        }, null, 2),
+        `taskId: ${input.taskId}`,
+        `fallbackTitle: ${input.title}`,
+        repoHint,
+        "Documents:",
+        bodies,
+    ].join("\n\n");
+}
+export async function readSemanticIntakeAttempted(repoRoot, taskId) {
+    const paths = getTaskPaths(repoRoot, taskId);
+    const marker = path.join(paths.taskDir, SEMANTIC_INTAKE_ATTEMPT_MARKER);
+    try {
+        await readFile(marker, "utf-8");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * C: a new PRD import is new evidence — clear the one-shot attempt marker
+ * so semantic intake may run again for the refreshed sources.
+ */
+export async function clearSemanticIntakeAttempt(repoRoot, taskId) {
+    const paths = getTaskPaths(repoRoot, taskId);
+    const marker = path.join(paths.taskDir, SEMANTIC_INTAKE_ATTEMPT_MARKER);
+    try {
+        await unlink(marker);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function writeAttemptMarker(repoRoot, taskId, payload) {
+    const paths = getTaskPaths(repoRoot, taskId);
+    const dir = path.join(paths.taskDir, "artifacts", "intake");
+    await mkdir(dir, { recursive: true });
+    const marker = path.join(paths.taskDir, SEMANTIC_INTAKE_ATTEMPT_MARKER);
+    await writeFile(marker, `${JSON.stringify(payload, null, 2)}\n`, "utf-8");
+    return marker;
+}
+/**
+ * Run at most one semantic intake attempt for a task (caller must also latch
+ * per advance invocation). Writes artifacts under taskDir/artifacts/intake/.
+ */
+export async function runSemanticIntake(input) {
+    const paths = getTaskPaths(input.repoRoot, input.taskId);
+    const intakeDir = path.join(paths.taskDir, "artifacts", "intake");
+    await mkdir(intakeDir, { recursive: true });
+    const usableDocs = input.documents.filter((d) => d.content?.trim() && d.role !== "design");
+    if (usableDocs.length === 0) {
+        await writeAttemptMarker(input.repoRoot, input.taskId, {
+            ok: false,
+            code: "SEMANTIC_INTAKE_NO_DOCUMENTS",
+            at: new Date().toISOString(),
+        });
+        return {
+            ok: false,
+            code: "SEMANTIC_INTAKE_NO_DOCUMENTS",
+            message: "no imported document content available for semantic intake",
+        };
+    }
+    // Refuse pure analysis/clarification-only suites (no requirement body).
+    const onlyNonExecutable = usableDocs.every((d) => {
+        const meta = detectProductArtifactMeta(d.content);
+        return (meta.artifactType === "product-analysis" ||
+            meta.artifactType === "requirement-clarification" ||
+            d.role === "analysis" ||
+            d.role === "clarification");
+    });
+    if (onlyNonExecutable) {
+        await writeAttemptMarker(input.repoRoot, input.taskId, {
+            ok: false,
+            code: "SEMANTIC_INTAKE_REFUSED_NON_EXECUTABLE",
+            at: new Date().toISOString(),
+        });
+        return {
+            ok: false,
+            code: "SEMANTIC_INTAKE_REFUSED_NON_EXECUTABLE",
+            message: "documents are analysis/clarification only; use complete product-requirement.md",
+        };
+    }
+    let assistantText;
+    let attemptedModels = [];
+    if (input.fixtureAssistantText !== undefined) {
+        assistantText = input.fixtureAssistantText;
+    }
+    else {
+        const execute = input.executePi ?? executePiStep;
+        const manifest = await loadHarnessManifest(input.repoRoot);
+        const models = resolveExecutorModelMatrices(manifest);
+        let available = [];
+        try {
+            available = input.listAvailableModels
+                ? await input.listAvailableModels()
+                : await listPiSdkAvailableModels();
+        }
+        catch {
+            available = [];
+        }
+        const queue = buildSemanticIntakeModelQueue({
+            harness: models.pi,
+            available,
+        });
+        if (queue.length === 0) {
+            await writeAttemptMarker(input.repoRoot, input.taskId, {
+                ok: false,
+                code: "SEMANTIC_INTAKE_PI_FAILED",
+                failureCategory: "unavailable",
+                at: new Date().toISOString(),
+                attemptedModels: [],
+            });
+            return {
+                ok: false,
+                code: "SEMANTIC_INTAKE_PI_FAILED",
+                message: "semantic intake has no MED/HIGH/LOW or Pi-supported models to try",
+            };
+        }
+        const attached = usableDocs
+            .map((d) => d.absolutePath)
+            .filter((p) => Boolean(p));
+        const prompt = await buildPrompt({
+            taskId: input.taskId,
+            title: input.title,
+            documents: usableDocs,
+            repoRoot: input.repoRoot,
+        });
+        const attempted = [];
+        let lastFailure = "";
+        let chosenText;
+        for (const modelRef of queue) {
+            try {
+                const result = await execute({
+                    attachedFiles: attached,
+                    modelConfig: resolveDagPiModelConfig(modelRef),
+                    prompt,
+                    repoRoot: input.repoRoot,
+                    step: "analyze",
+                    toolNames: ["read", "grep", "find", "ls"],
+                    timeoutMs: SEMANTIC_INTAKE_ATTEMPT_TIMEOUT_MS,
+                    stallTimeoutMs: SEMANTIC_INTAKE_ATTEMPT_TIMEOUT_MS,
+                    userMessage: "Structure the imported requirement documents into the required JSON only.",
+                    validateOutput: (text) => {
+                        try {
+                            const parsed = parseSemanticRequirementDraft(text);
+                            assertSemanticDraftAcceptable(parsed);
+                            return [];
+                        }
+                        catch (error) {
+                            return [error instanceof Error ? error.message : String(error)];
+                        }
+                    },
+                });
+                attempted.push({
+                    model: result.modelDisplay || modelRef,
+                    ok: result.ok,
+                    failureCategory: result.failureCategory,
+                    timedOut: result.timedOut,
+                });
+                if (result.ok) {
+                    chosenText = result.assistantText;
+                    break;
+                }
+                lastFailure =
+                    `${result.failureCategory}: ${result.stderr || result.assistantText}`.slice(0, 2000);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                attempted.push({
+                    model: modelRef,
+                    ok: false,
+                    failureCategory: "unknown",
+                });
+                lastFailure = message.slice(0, 2000);
+            }
+        }
+        attemptedModels = attempted;
+        if (chosenText === undefined) {
+            await writeAttemptMarker(input.repoRoot, input.taskId, {
+                ok: false,
+                code: "SEMANTIC_INTAKE_PI_FAILED",
+                failureCategory: attempted.at(-1)?.failureCategory,
+                at: new Date().toISOString(),
+                attemptedModels: attempted,
+            });
+            return {
+                ok: false,
+                code: "SEMANTIC_INTAKE_PI_FAILED",
+                message: `semantic intake pi failed after ${attempted.length} model(s): ${lastFailure}`.slice(0, 2000),
+            };
+        }
+        assistantText = chosenText;
+    }
+    try {
+        const semantic = parseSemanticRequirementDraft(assistantText);
+        assertSemanticDraftAcceptable(semantic);
+        const draft = buildDraftFromSemanticIntake({
+            taskId: input.taskId,
+            title: input.title,
+            taskKind: input.taskKind ?? "standard",
+            featureId: input.featureId,
+            semantic,
+            flags: input.flags,
+            existingAllowedPaths: input.existingAllowedPaths,
+            existingForbiddenPaths: input.existingForbiddenPaths,
+            existingVerify: input.existingVerify,
+            references: usableDocs.map((d) => ({
+                role: d.role,
+                ref: d.materializedPath.replace(/\\/g, "/"),
+            })),
+        });
+        const artifactPath = path.join(paths.taskDir, SEMANTIC_INTAKE_ARTIFACT_REL);
+        await writeFile(artifactPath, `${JSON.stringify({
+            schemaVersion: 1,
+            kind: "semantic-intake-draft",
+            taskId: input.taskId,
+            createdAt: new Date().toISOString(),
+            semantic,
+            draft,
+        }, null, 2)}\n`, "utf-8");
+        await writeAttemptMarker(input.repoRoot, input.taskId, {
+            ok: true,
+            code: "SEMANTIC_INTAKE_OK",
+            artifactPath: SEMANTIC_INTAKE_ARTIFACT_REL,
+            at: new Date().toISOString(),
+            ...(attemptedModels.length > 0 ? { attemptedModels } : {}),
+        });
+        return { ok: true, draft, artifactPath, semantic };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        await writeAttemptMarker(input.repoRoot, input.taskId, {
+            ok: false,
+            code: "SEMANTIC_INTAKE_INVALID_OUTPUT",
+            message,
+            at: new Date().toISOString(),
+        });
+        return {
+            ok: false,
+            code: "SEMANTIC_INTAKE_INVALID_OUTPUT",
+            message,
+        };
+    }
+}