@tea-agent/loop-agent 0.35.1-beta.2 → 0.35.1

package/dist/worker/console/operator-actions.js

@@ -17,6 +17,9 @@ import { toCanonicalDraftForCli, } from "./draft-store.js";
 import { normalizeConsoleWorkflowKind } from "./workflow-kinds.js";
 import { deriveTaskIdentityFromPrd, nextTaskIdRevision, } from "./prd-identity.js";
 import { appendEngineeringCliArgs, buildDraftFromTaskIntake, parseEngineeringBoundaryFromParams, } from "./prd-intake-bridge.js";
+import { discoverPrdReferences } from "./prd-reference-discovery.js";
+import { clearSemanticIntakeAttempt } from "../../task/source-prepare/semantic-intake.js";
+import nodePath from "node:path";
 import { resolveSiblingAgentWorkerBin } from "./sibling-controller.js";
 import { projectOperationEventSummary, projectOperationForChat, } from "./chat/chat-event-store.js";
 import { MutationGateReceiptStore } from "./mutation-gate-receipt-store.js";
@@ -1364,7 +1367,9 @@ export async function dispatchOperatorAction(ctx, req) {
             if (!taskId || !content) {
                 return invalid(action, "taskId and content are required");
             }
-            const taskKind = normalizeConsoleWorkflowKind(str(p.taskKind), "standard");
+            const taskKindRaw = str(p.taskKind)?.trim();
+            const taskKind = normalizeConsoleWorkflowKind(taskKindRaw, "standard");
+            const taskKindExplicit = Boolean(taskKindRaw);
             const engineering = parseEngineeringBoundaryFromParams(p);
             const identity = deriveTaskIdentityFromPrd(content);
             const title = str(p.title) ?? identity.title;
@@ -1407,7 +1412,7 @@ export async function dispatchOperatorAction(ctx, req) {
                 };
             }
             const intakeArgs = ["task", "advance", taskId, "--json"];
-            if (taskKind && taskKind !== "standard") {
+            if (taskKindExplicit) {
                 intakeArgs.push("--task-kind", taskKind);
             }
             appendEngineeringCliArgs(intakeArgs, engineering);
@@ -1424,6 +1429,7 @@ export async function dispatchOperatorAction(ctx, req) {
                 taskId,
                 title,
                 taskKind,
+                taskKindExplicit,
                 advanceJson: intakeJson,
                 engineering,
             });
@@ -2495,7 +2501,38 @@ async function dispatchBootstrapFromPrd(ctx, p) {
         return invalid("bootstrapFromPrd", parsedDocs.message);
     }
     const documents = parsedDocs.documents;
-    const taskKind = normalizeConsoleWorkflowKind(str(p.taskKind), "standard");
+    // B1: free-form prose that references repo-local markdown paths (e.g.
+    // "请参照这三个prd路径 docs/product-analysis/foo.md …") only materializes
+    // the sentence itself. Discover the referenced files and import them as
+    // additional documents so intake has real requirement facts to structure.
+    let autoImportedReferences = [];
+    let unresolvedReferences = [];
+    const autoDocs = [];
+    if (!documents) {
+        const discovery = await discoverPrdReferences({
+            prose: content,
+            repoRoot: ctx.repoRoot,
+        });
+        autoImportedReferences = discovery.references.map((r) => ({
+            repoRelative: r.repoRelative,
+            role: r.role,
+        }));
+        unresolvedReferences = discovery.unresolved;
+        for (const ref of discovery.references) {
+            const absolute = nodePath.resolve(ctx.repoRoot, ref.repoRelative);
+            const refContent = await readFile(absolute, "utf-8").catch(() => "");
+            if (!refContent.trim())
+                continue;
+            autoDocs.push({
+                name: ref.repoRelative.split("/").pop() ?? ref.repoRelative,
+                content: refContent,
+                fileName: ref.repoRelative,
+            });
+        }
+    }
+    const taskKindRaw = str(p.taskKind)?.trim();
+    const taskKind = normalizeConsoleWorkflowKind(taskKindRaw, "standard");
+    const taskKindExplicit = Boolean(taskKindRaw);
     const engineering = parseEngineeringBoundaryFromParams(p);
     const identity = deriveTaskIdentityFromPrd(content);
     let taskId;
@@ -2547,7 +2584,7 @@ async function dispatchBootstrapFromPrd(ctx, p) {
     }
     const succeededImports = [];
     const importResults = [];
-    const runImportViaAdvance = async (label, text, name) => {
+    const runImportViaAdvance = async (label, text, name, role = "requirement") => {
         const staged = await stageUtf8Text(ctx.appData, text, {
             extension: ".md",
         });
@@ -2558,7 +2595,7 @@ async function dispatchBootstrapFromPrd(ctx, p) {
             "--prd",
             staged.path,
             "--role",
-            "requirement",
+            role,
             "--json",
         ], {
             cwd: ctx.repoRoot,
@@ -2599,6 +2636,23 @@ async function dispatchBootstrapFromPrd(ctx, p) {
         if (composedFailure)
             return composedFailure;
     }
+    else if (autoDocs.length > 0) {
+        // B1: discovered repo-local references become explicit imports (role
+        // inferred per document), then the prose itself imports as composed.
+        const roleByBase = new Map(autoImportedReferences.map((r) => {
+            const base = r.repoRelative.split("/").pop() ?? r.repoRelative;
+            return [base, r.role];
+        }));
+        for (const doc of autoDocs) {
+            const role = roleByBase.get(doc.name) ?? "requirement";
+            const failure = await runImportViaAdvance(doc.name, doc.content, doc.name, role);
+            if (failure)
+                return failure;
+        }
+        const composedFailure = await runImportViaAdvance("composed", content, "composed");
+        if (composedFailure)
+            return composedFailure;
+    }
     else {
         const staged = await stageUtf8Text(ctx.appData, content, {
             extension: ".md",
@@ -2625,11 +2679,16 @@ async function dispatchBootstrapFromPrd(ctx, p) {
         }
         importResults.push(imported.json ?? null);
     }
+    // C: a fresh import (manual or discovered) is new evidence; clear the
+    // one-shot semantic-intake attempt marker so intake may run again.
+    if (succeededImports.length > 0) {
+        await clearSemanticIntakeAttempt(ctx.repoRoot, taskId);
+    }
     // Phase 2 (design 2026-08-11): drive task advance intake after import so
     // deterministic parse + one-shot Semantic Intake run on archived references.
     // Timeout is longer than import: Pi MED may take minutes.
     const intakeArgs = ["task", "advance", taskId, "--json"];
-    if (taskKind && taskKind !== "standard") {
+    if (taskKindExplicit) {
         intakeArgs.push("--task-kind", taskKind);
     }
     appendEngineeringCliArgs(intakeArgs, engineering);
@@ -2646,6 +2705,7 @@ async function dispatchBootstrapFromPrd(ctx, p) {
         taskId,
         title,
         taskKind,
+        taskKindExplicit,
         advanceJson: intakeJson,
         engineering,
     });
@@ -2679,7 +2739,13 @@ async function dispatchBootstrapFromPrd(ctx, p) {
             imports: importResults,
             documentNames: documents && documents.length > 0
                 ? [...documents.map((d) => d.name), "composed"]
+                : autoDocs.length > 0
+                    ? [...autoDocs.map((d) => d.name), "composed"]
+                    : undefined,
+            autoImportedReferences: autoImportedReferences.length > 0
+                ? autoImportedReferences
                 : undefined,
+            unresolvedReferences: unresolvedReferences.length > 0 ? unresolvedReferences : undefined,
             draftPreview: {
                 objective: draftSaved.draft.requirement?.objective ?? null,
                 scope: draftSaved.draft.requirement?.scope ?? [],

package/dist/worker/console/prd-intake-bridge.js

@@ -215,6 +215,7 @@ export function applyEngineeringBoundaryToDraft(draft, boundary) {
 }
 export async function buildDraftFromTaskIntake(input) {
     const taskKind = normalizeConsoleWorkflowKind(input.taskKind, "standard");
+    const taskKindExplicit = Boolean(input.taskKindExplicit);
     const paths = getTaskPaths(input.repoRoot, input.taskId);
     const warnings = warningList(input.advanceJson);
     const lifecycleState = lifecycleFromAdvanceJson(input.advanceJson);
@@ -262,6 +263,14 @@ export async function buildDraftFromTaskIntake(input) {
         const semDraftConstraints = artifact?.draft?.constraints;
         const semDraftVerification = artifact?.draft?.verification;
         const semTaskKind = artifact?.draft?.taskKind?.trim();
+        // User-explicit Console taskKind is a hard contract: semantic intake
+        // must never overwrite it (it may recommend backend-test for prose like
+        // "削减单元测试数量" even when the operator picked standard/后端研发).
+        const resolvedTaskKind = taskKindExplicit
+            ? taskKind
+            : semTaskKind
+                ? normalizeConsoleWorkflowKind(semTaskKind, taskKind)
+                : taskKind;
         const mergedAllowed = filterPlaceholderPaths(semDraftConstraints?.allowedPaths);
         const mergedForbidden = filterPlaceholderPaths(semDraftConstraints?.forbiddenPaths);
         const mergedVerify = Array.isArray(semDraftVerification?.commands)
@@ -280,9 +289,7 @@ export async function buildDraftFromTaskIntake(input) {
         draft = {
             ...draft,
             title,
-            ...(semTaskKind
-                ? { taskKind: normalizeConsoleWorkflowKind(semTaskKind, taskKind) }
-                : {}),
+            taskKind: resolvedTaskKind,
             requirement: {
                 objective: semanticReq.objective.trim(),
                 scope: asStringList(semanticReq.scope),

package/dist/worker/console/prd-reference-discovery.js

@@ -0,0 +1,124 @@
+/**
+ * B1: discover repo-local markdown references inside free-form PRD prose.
+ *
+ * Console "文字录入" flows often paste one sentence like
+ * "请参照这三个prd路径 docs/product-analysis/foo/*.md 完成业务需求".
+ * The deterministic import only materializes the sentence itself; the
+ * referenced files never reach source/references/, so semantic intake has
+ * no requirement facts to structure. This module extracts candidate
+ * repo-relative .md paths from the prose, filters exclusions, and resolves
+ * each to an importable document (path + inferred role) so the caller can
+ * auto-import them before intake.
+ */
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { resolvePrdImportRole } from "../../task/source-prepare/artifact-meta.js";
+/** Repo paths that must never be auto-imported as PRD references. */
+const EXCLUDED_PREFIXES = [
+    ".harness/",
+    "node_modules/",
+    ".git/",
+    "ai_workspace/",
+    "dist/",
+    "build/",
+    "coverage/",
+];
+/** Derived contract files are never valid PRD inputs. */
+const EXCLUDED_BASENAMES = new Set(["需求.md", "执行约束.md"]);
+/** Markdown path tokens with unicode path segments (supports Chinese dirs/files). */
+const MD_PATH_TOKEN_RE = /(?:[\w\u4e00-\u9fff.-]+\/)+[\w\u4e00-\u9fff.-]+\.(?:md|markdown)\b/gu;
+/** Strip URLs so their path fragments are never treated as repo paths. */
+const URL_RE = /(?:https?|ftp|file):\/\/[^\s\u4e00-\u9fff\uff08\uff09]+/gu;
+const MAX_AUTO_IMPORT_BYTES = 512 * 1024;
+const MAX_AUTO_IMPORT_COUNT = 8;
+function isExcluded(repoRelative) {
+    const posix = repoRelative.replace(/\\/g, "/");
+    for (const prefix of EXCLUDED_PREFIXES) {
+        if (posix === prefix.slice(0, -1) || posix.startsWith(prefix)) {
+            return `excluded prefix ${prefix}`;
+        }
+    }
+    const base = posix.split("/").pop() ?? posix;
+    if (EXCLUDED_BASENAMES.has(base)) {
+        return `derived contract file ${base}`;
+    }
+    return null;
+}
+/**
+ * Extract candidate markdown path tokens from free-form prose.
+ * Returns unique tokens in first-occurrence order.
+ */
+export function extractPrdPathTokens(prose) {
+    const withoutUrls = prose.replace(URL_RE, " ");
+    const seen = new Set();
+    const out = [];
+    for (const match of withoutUrls.matchAll(MD_PATH_TOKEN_RE)) {
+        const token = match[0];
+        if (!token || token.length <= "x.md".length)
+            continue;
+        if (seen.has(token))
+            continue;
+        seen.add(token);
+        out.push(token);
+        if (out.length >= 32)
+            break;
+    }
+    return out;
+}
+/**
+ * Resolve prose path tokens against the repo root. Existing, non-excluded,
+ * size-bounded markdown files become importable references.
+ */
+export async function discoverPrdReferences(input) {
+    const tokens = extractPrdPathTokens(input.prose);
+    const references = [];
+    const unresolved = [];
+    for (const token of tokens) {
+        if (references.length >= MAX_AUTO_IMPORT_COUNT) {
+            unresolved.push({ token, reason: "auto-import limit reached" });
+            continue;
+        }
+        const repoRelative = token.replace(/\\/g, "/");
+        const excludedReason = isExcluded(repoRelative);
+        if (excludedReason) {
+            unresolved.push({ token, reason: excludedReason });
+            continue;
+        }
+        const absolute = path.resolve(input.repoRoot, repoRelative);
+        // Defense in depth: resolved candidates must stay under repoRoot.
+        const rel = path.relative(input.repoRoot, absolute);
+        if (rel.startsWith("..") || path.isAbsolute(rel)) {
+            unresolved.push({ token, reason: "outside repo root" });
+            continue;
+        }
+        let content;
+        try {
+            const fileStat = await stat(absolute);
+            if (!fileStat.isFile()) {
+                unresolved.push({ token, reason: "not a regular file" });
+                continue;
+            }
+            if (fileStat.size > MAX_AUTO_IMPORT_BYTES) {
+                unresolved.push({
+                    token,
+                    reason: `exceeds ${MAX_AUTO_IMPORT_BYTES} bytes`,
+                });
+                continue;
+            }
+            content = await readFile(absolute, "utf-8");
+        }
+        catch {
+            unresolved.push({ token, reason: "not found in repo" });
+            continue;
+        }
+        references.push({
+            repoRelative,
+            role: resolvePrdImportRole({
+                filePath: absolute,
+                markdown: content,
+            }),
+            sizeBytes: Buffer.byteLength(content, "utf-8"),
+        });
+    }
+    return { references, unresolved };
+}