@tea-agent/loop-agent 0.33.6 → 0.33.7-beta.1

package/dist/shared/resilient-git.js

@@ -1,133 +0,0 @@
-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

@@ -1,137 +0,0 @@
-/**
- * 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/semantic-intake.js

@@ -1,404 +0,0 @@
-/**
- * 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 paths/verify never come
- * from the model; only from flags / existing task config.
- */
-import { mkdir, readFile, 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 { 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";
-export const SEMANTIC_INTAKE_ARTIFACT_REL = "artifacts/intake/semantic-draft.json";
-export const SEMANTIC_INTAKE_ATTEMPT_MARKER = "artifacts/intake/semantic-intake-attempted.json";
-const productArtifactBlockers = new Set([
-    "PRODUCT_ANALYSIS_NOT_EXECUTABLE",
-    "PRODUCT_CLARIFICATION_NOT_EXECUTABLE",
-    "PRODUCT_REQUIREMENT_PENDING",
-    "PRODUCT_ARTIFACT_NOT_EXECUTABLE",
-]);
-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(),
-});
-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`,
-            };
-        }
-    }
-    // Engineering-only gaps are not fixed by semantic intake.
-    const onlyEngineering = blocking.length > 0 &&
-        blocking.every((g) => g.code === "EMPTY_ALLOWED_PATHS" ||
-            g.code === "EMPTY_TASK_KIND" ||
-            g.code === "MISSING_FEATURE_ID" ||
-            g.code === "PATH_POLICY" ||
-            g.code.startsWith("UNSAFE_") ||
-            g.code === "ALLOWED_FORBIDDEN_OVERLAP");
-    if (onlyEngineering) {
-        return {
-            eligible: false,
-            reason: "only engineering boundary gaps; provide --allowed-path / flags",
-        };
-    }
-    const structural = codes.has("SEMANTIC_INTAKE_RECOMMENDED") ||
-        blockingCodes.has("EMPTY_ACCEPTANCE") ||
-        blockingCodes.has("EMPTY_OBJECTIVE") ||
-        blockingCodes.has("NO_PARSEABLE_REQUIREMENT");
-    if (!structural && !input.force) {
-        return {
-            eligible: false,
-            reason: "no structural requirement gaps for semantic intake",
-        };
-    }
-    return { eligible: true, reason: "structural intake gaps with imported sources" };
-}
-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 allowedPaths = input.flags.allowedPaths?.length
-        ? [
-            ...(input.existingAllowedPaths ?? []),
-            ...input.flags.allowedPaths,
-        ]
-        : (input.existingAllowedPaths ?? input.flags.allowedPaths ?? []);
-    const forbiddenPaths = input.flags.forbiddenPaths?.length
-        ? [
-            ...(input.existingForbiddenPaths ?? []),
-            ...input.flags.forbiddenPaths,
-        ]
-        : (input.existingForbiddenPaths ?? input.flags.forbiddenPaths ?? []);
-    const verifyCommands = input.flags.verifyCommands?.length
-        ? input.flags.verifyCommands
-        : (input.existingVerify ?? []);
-    const draft = {
-        schemaVersion: TASK_CONTRACT_DRAFT_SCHEMA_VERSION,
-        taskId: input.taskId,
-        title: input.semantic.title?.trim() || input.title,
-        taskKind: input.flags.taskKind || input.taskKind || "standard",
-        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;
-}
-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");
-    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.",
-        "Do NOT emit engineering fields (allowedPaths, forbiddenPaths, verifyCommands, taskKind).",
-        "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.",
-        "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"],
-        }, null, 2),
-        `taskId: ${input.taskId}`,
-        `fallbackTitle: ${input.title}`,
-        "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;
-    }
-}
-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;
-    if (input.fixtureAssistantText !== undefined) {
-        assistantText = input.fixtureAssistantText;
-    }
-    else {
-        const execute = input.executePi ?? executePiStep;
-        const manifest = await loadHarnessManifest(input.repoRoot);
-        const models = resolveExecutorModelMatrices(manifest);
-        const model = models.pi.MED;
-        const attached = usableDocs
-            .map((d) => d.absolutePath)
-            .filter((p) => Boolean(p));
-        const result = await execute({
-            attachedFiles: attached,
-            modelConfig: resolveDagPiModelConfig(model),
-            prompt: buildPrompt({
-                taskId: input.taskId,
-                title: input.title,
-                documents: usableDocs,
-            }),
-            repoRoot: input.repoRoot,
-            step: "analyze",
-            toolNames: ["read", "grep", "find", "ls"],
-            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)];
-                }
-            },
-        });
-        if (!result.ok) {
-            await writeAttemptMarker(input.repoRoot, input.taskId, {
-                ok: false,
-                code: "SEMANTIC_INTAKE_PI_FAILED",
-                failureCategory: result.failureCategory,
-                at: new Date().toISOString(),
-            });
-            return {
-                ok: false,
-                code: "SEMANTIC_INTAKE_PI_FAILED",
-                message: `semantic intake pi failed: ${result.failureCategory}: ${result.stderr || result.assistantText}`.slice(0, 2000),
-            };
-        }
-        assistantText = result.assistantText;
-    }
-    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(),
-        });
-        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,
-        };
-    }
-}