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

package/dist/task/source-prepare/reference-integrity.js

@@ -5,7 +5,16 @@ import { getTaskPaths } from "../runtime.js";
 import { readSourceManifest, } from "../source-references.js";
 import { PREPARE_MAX_FILE_BYTES, PREPARE_MAX_PARSE_DOCS, PREPARE_MAX_TOTAL_BYTES, } from "./types.js";
 const PARSEABLE_EXTENSIONS = new Set([".md", ".markdown", ".txt"]);
+/** Roles that contribute requirement facts (objective/AC/scope). */
 const PARSEABLE_ROLES = new Set(["requirement", "acceptance"]);
+/** Roles whose body is loaded for artifact meta / diagnostics (not fact extraction). */
+const CONTENT_LOAD_ROLES = new Set([
+    "requirement",
+    "acceptance",
+    "analysis",
+    "clarification",
+    "design",
+]);
 function isSafeRelativeReferencePath(materializedPath) {
     const normalized = materializedPath.replace(/\\/g, "/").trim();
     if (!normalized)
@@ -52,6 +61,12 @@ function isParseableDoc(doc) {
         return false;
     return PARSEABLE_ROLES.has(doc.role);
 }
+function shouldLoadContent(doc) {
+    const ext = path.extname(doc.materializedPath).toLowerCase();
+    if (!PARSEABLE_EXTENSIONS.has(ext))
+        return false;
+    return CONTENT_LOAD_ROLES.has(doc.role) || PARSEABLE_ROLES.has(doc.role);
+}
 /**
  * Validate source-manifest + reference files before deriving a draft.
  * Fail-closed on taskId/path/hash/symlink/size issues.
@@ -170,6 +185,7 @@ export async function validateImportedPrdReferences(input) {
             continue;
         }
         const parseable = isParseableDoc(doc);
+        const loadContent = shouldLoadContent(doc);
         if (parseable) {
             parseableCount += 1;
             if (parseableCount > PREPARE_MAX_PARSE_DOCS) {
@@ -183,7 +199,7 @@ export async function validateImportedPrdReferences(input) {
         }
         let hashResult;
         try {
-            hashResult = await streamSha256AndBytes(absolutePath, parseable ? PREPARE_MAX_FILE_BYTES : undefined);
+            hashResult = await streamSha256AndBytes(absolutePath, loadContent ? PREPARE_MAX_FILE_BYTES : undefined);
         }
         catch (error) {
             if (error &&
@@ -223,7 +239,7 @@ export async function validateImportedPrdReferences(input) {
             });
         }
         let content;
-        if (parseable) {
+        if (loadContent) {
             totalParseBytes += hashResult.bytes;
             if (totalParseBytes > PREPARE_MAX_TOTAL_BYTES) {
                 issues.push({

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

@@ -0,0 +1,404 @@
+/**
+ * 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,
+        };
+    }
+}

package/dist/worker/console/app-data.js

@@ -36,6 +36,7 @@ export function openConsoleAppData(options) {
         drafts: path.join(repoNamespace, "drafts"),
         operations: path.join(repoNamespace, "operations"),
         confirmations: path.join(repoNamespace, "confirmations"),
+        dagReceipts: path.join(repoNamespace, "dag-receipts"),
         staged: path.join(repoNamespace, "staged"),
         assessments: path.join(repoNamespace, "assessments"),
         interviews: path.join(repoNamespace, "interviews"),
@@ -47,6 +48,7 @@ export function openConsoleAppData(options) {
         paths.drafts,
         paths.operations,
         paths.confirmations,
+        paths.dagReceipts,
         paths.staged,
         paths.assessments,
         paths.interviews,