@tea-agent/loop-agent 0.42.0-next.1 → 0.42.0-next.11

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

@@ -5,6 +5,9 @@ import { ContractMutationError, applyTaskContract, logicalRevisionForState, obse
 import { TASK_CONTRACT_DRAFT_SCHEMA_VERSION } from "../contract/constants.js";
 import { getTaskContractPaths } from "../contract/paths.js";
 import { loadTaskConfig } from "../runtime.js";
+import { discoverFrontendProjectCapability, resolveFrontendSpecRootAliases, } from "../frontend-project-capability.js";
+import { classifyTaskDemand } from "../task-demand-routing.js";
+import { DEFAULT_FRONTEND_SPEC_ROOTS, extractDeclaredFrontendSpecRoots, } from "../../shared/openspec-spec.js";
 import { buildPrepareDraft } from "./build-draft.js";
 import { hasBlockingGaps, hasBlockingRisks, isFreshLegacyUnversioned, listPrepareGaps, appendLedgerGaps, } from "./completeness.js";
 import { detectProductArtifactMeta, isIntakeSoftGapCode, } from "./artifact-meta.js";
@@ -681,7 +684,7 @@ export async function prepareTaskSource(input) {
             facts = importedFacts ?? mergedSupplemental;
         }
     }
-    const built = buildPrepareDraft({
+    let built = buildPrepareDraft({
         taskId,
         existingTaskConfig,
         baseDraft,
@@ -689,6 +692,91 @@ export async function prepareTaskSource(input) {
         flags: input.flags,
         references,
     });
+    // Resolve an implicit frontend workflow before the first managed contract is
+    // projected. Explicit taskKind (including explicit standard) remains a hard
+    // contract; only a standard task with strong source/path/project evidence may
+    // be promoted here. This keeps task.json, contract.json, and the first DAG
+    // generation on the same workflow without a later hash-changing re-projection.
+    if (built.draft.taskKind === "standard" &&
+        !built.draft.taskKindExplicit) {
+        const routingRequirement = [
+            ...(sourceIntegrity?.documents ?? [])
+                .map((document) => document.content)
+                .filter((content) => Boolean(content?.trim())),
+            ...(input.intent.kind === "facts" && input.intent.text
+                ? [input.intent.text]
+                : []),
+            built.draft.requirement.objective,
+            ...built.draft.requirement.scope,
+            ...built.draft.requirement.acceptanceCriteria.map((item) => item.text),
+        ].join("\n");
+        let frontendProject;
+        try {
+            frontendProject = await discoverFrontendProjectCapability(repoRoot);
+        }
+        catch {
+            // Capability discovery is advisory for routing. A failed probe must not
+            // turn an otherwise valid standard contract preparation into an error.
+        }
+        const classification = classifyTaskDemand({
+            title: built.draft.title,
+            requirementMarkdown: routingRequirement,
+            allowedPaths: built.draft.constraints.allowedPaths,
+            frontendProject: frontendProject
+                ? {
+                    framework: frontendProject.framework,
+                    evidencePaths: frontendProject.evidencePaths,
+                }
+                : undefined,
+        });
+        if (classification.kind === "frontend") {
+            built = buildPrepareDraft({
+                taskId,
+                existingTaskConfig,
+                baseDraft,
+                facts,
+                flags: {
+                    ...input.flags,
+                    taskKind: "frontend-implementation",
+                },
+                references,
+            });
+        }
+    }
+    // A user can explicitly name a non-default normative directory in the task
+    // prompt (for example “规范目录 `design-system`”). Freeze that root into
+    // the managed task config before the DAG exists; normal DAG selection consumes
+    // the already-resolved task kind instead of mutating task.json later.
+    if (built.draft.taskKind === "frontend-implementation") {
+        // An imported PRD is materialized under sourceIntegrity rather than copied
+        // into intent.text. Use both inputs so a `--prd` invocation can declare a
+        // task-owned spec root just like supplemental free-form text can.
+        const sourceText = [
+            ...(sourceIntegrity?.documents ?? []).flatMap((document) => document.content ? [document.content] : []),
+            ...(input.intent.kind === "facts" && input.intent.text
+                ? [input.intent.text]
+                : []),
+        ].join("\n");
+        const inferredRoots = extractDeclaredFrontendSpecRoots(sourceText);
+        if (inferredRoots.length > 0) {
+            const current = existingTaskConfig?.frontendOpenspec;
+            const configuredRoots = current?.specRoots ?? [...DEFAULT_FRONTEND_SPEC_ROOTS];
+            // Include roots declared by this source before resolving physical-target
+            // aliases. A newly declared root may itself be a symlink (for example
+            // `project-specs -> .../ai_doc`), so resolving aliases against only the
+            // previous config cannot map `ai_doc/rules.md` back to project-specs.
+            const provisionalRoots = [
+                ...new Set([...configuredRoots, ...inferredRoots]),
+            ].sort();
+            const aliases = await resolveFrontendSpecRootAliases(repoRoot, provisionalRoots);
+            const aliasMap = new Map(aliases.map(({ alias, logicalRoot }) => [alias, logicalRoot]));
+            built.draft.frontendOpenspec = {
+                policy: current?.policy ?? "cited",
+                specRoots: [...new Set([...configuredRoots, ...inferredRoots.map((root) => aliasMap.get(root) ?? root)])].sort(),
+                requiredReadPaths: current?.requiredReadPaths ?? [],
+            };
+        }
+    }
     const { gaps, risks } = listPrepareGaps({
         draft: built.draft,
         state,
@@ -708,29 +796,46 @@ export async function prepareTaskSource(input) {
     // -------------------------------------------------------------------
     let ledger;
     let ledgerSummary;
-    if (hasImportedPrd &&
-        sourceIntegrity &&
-        sourceIntegrity.parseableDocuments.some((doc) => doc.role === "requirement" || doc.role === "acceptance")) {
+    const hasAuthoritativeImportedDocs = Boolean(hasImportedPrd &&
+        sourceIntegrity?.parseableDocuments.some((doc) => doc.role === "requirement" || doc.role === "acceptance"));
+    // Frontend tasks created from text still need the same source-fidelity
+    // contract as imported-PRD tasks.  In that case the projected requirement
+    // document is the canonical, task-owned source that the DAG can bind to;
+    // without it init-hybrid would silently emit a v1 binding and the first
+    // frontend-contract node would fail before making a model call.
+    if (built.draft.taskKind === "frontend-implementation" &&
+        (hasAuthoritativeImportedDocs ||
+            (input.intent.kind === "facts" && Boolean(input.intent.text)))) {
         try {
-            const authoritativeDocs = sourceIntegrity.parseableDocuments.filter((doc) => (doc.role === "requirement" || doc.role === "acceptance") &&
+            const authoritativeDocs = sourceIntegrity?.parseableDocuments.filter((doc) => (doc.role === "requirement" || doc.role === "acceptance") &&
                 typeof doc.content === "string" &&
-                doc.content.trim().length > 0);
-            const sourceDocuments = authoritativeDocs.map((doc) => {
-                // Canonical source identity 单一边界（AC-001 / AC-FIDELITY-REPAIR-001）：
-                // ledger sourceDocuments[].path 与 DAG 侧 serializeDagTaskSourcePath /
-                // resolveDagTaskSourcePath 一致（repo-root relative POSIX），路径转换只
-                // 发生在该边界，不再二次转换进入 digest 计算。
-                const absolute = path.resolve(contractPaths.sourceDir, doc.materializedPath);
-                return {
-                    path: path
-                        .relative(repoRoot, absolute)
-                        .split(path.sep)
-                        .join("/"),
-                    content: doc.content,
-                };
-            });
+                doc.content.trim().length > 0) ?? [];
+            const requirementProjection = projectRequirementMarkdown(built.draft);
+            const sourceDocuments = authoritativeDocs.length > 0
+                ? authoritativeDocs.map((doc) => {
+                    // Canonical source identity 单一边界（AC-001 / AC-FIDELITY-REPAIR-001）：
+                    // ledger sourceDocuments[].path 与 DAG 侧 serializeDagTaskSourcePath /
+                    // resolveDagTaskSourcePath 一致（repo-root relative POSIX），路径转换只
+                    // 发生在该边界，不再二次转换进入 digest 计算。
+                    const absolute = path.resolve(contractPaths.sourceDir, doc.materializedPath);
+                    return {
+                        path: path
+                            .relative(repoRoot, absolute)
+                            .split(path.sep)
+                            .join("/"),
+                        content: doc.content,
+                    };
+                })
+                : [
+                    {
+                        path: path
+                            .relative(repoRoot, contractPaths.requirementPath)
+                            .split(path.sep)
+                            .join("/"),
+                        content: requirementProjection,
+                    },
+                ];
             if (sourceDocuments.length > 0) {
-                const requirementProjection = projectRequirementMarkdown(built.draft);
                 ledger = await buildRequirementLedger({
                     taskId,
                     requirementSha256: sha256Utf8(requirementProjection),

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

@@ -457,8 +457,12 @@ async function buildPrompt(input) {
         "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 / …)",
+        "- verifyCommands as real package scripts (e.g. pnpm -C source test); when acceptance criteria name a specific test file to run (e.g. 定向 vitest（test/.../xxx.test.ts）), emit the corresponding targeted command as its own entry (e.g. npx vitest run test/.../xxx.test.ts) instead of only the full-suite script — targeted commands are what a frontend implementation plan maps to behavior verification targets",
+        "- taskKind when clearly implied, choosing from {standard / frontend-implementation / frontend-test / backend-test / knowledge-sync}:",
+        "  - frontend-implementation: the deliverable is a frontend component/page/UI feature (even when it ships with its own tests)",
+        "  - frontend-test: the deliverable is a browser/UI automation test suite for EXISTING functionality (no implementation work)",
+        "  - backend-test: pytest/backend test suite; standard: general repo implementation",
+        "  A task that IMPLEMENTS a component and adds tests for it is frontend-implementation, never frontend-test.",
         "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.",

package/dist/task/source-references.js

@@ -22,6 +22,18 @@ function slugifyName(value) {
         .replace(/-{2,}/g, "-");
     return slug || "requirement";
 }
+/** Stable identity of a manifest document for change detection. Timestamps and
+ * byte sizes are excluded: identical content re-imported later must not appear
+ * "changed" (the canonical hash includes manifest bytes). */
+function documentIdentity(doc) {
+    return `${doc.role}|${doc.name}|${doc.materializedPath}|${doc.sha256}`;
+}
+function sameDocumentSet(left, right) {
+    if (left.length !== right.length)
+        return false;
+    const rightIds = new Set(right.map(documentIdentity));
+    return left.every((doc) => rightIds.has(documentIdentity(doc)));
+}
 function ensureUniqueReferenceName(existing, baseName, extension) {
     const used = new Set(existing);
     const candidate = `${baseName}${extension}`;
@@ -149,10 +161,19 @@ export async function importPrdDocument(input) {
     const documents = [...(existingManifest?.documents ?? [])].filter((entry) => entry.materializedPath !== materializedRelativePath);
     documents.push(document);
     documents.sort((left, right) => left.materializedPath.localeCompare(right.materializedPath));
+    // Keep `updatedAt` stable across re-imports of the same content: the
+    // canonical contract hash includes the manifest bytes, so a fresh
+    // timestamp on every identical re-import would make the observed
+    // canonical hash drift and fail task verification. Only bump it when the
+    // document set actually changed (a new/changed materialized file).
+    const documentSetChanged = !existingManifest ||
+        !sameDocumentSet(existingManifest.documents, documents);
     const manifest = {
         schemaVersion: 1,
         taskId: input.taskId,
-        updatedAt: importedAt,
+        updatedAt: documentSetChanged
+            ? importedAt
+            : (existingManifest?.updatedAt ?? importedAt),
         documents,
     };
     await writeSourceManifest(paths.sourceDir, manifest);

package/dist/worker/console/chat/chat-ui-policy.js

@@ -19,7 +19,9 @@ export function shouldPlayCompletionSound(input) {
 export function copyTextForMessage(input) {
     return input.code ?? input.text;
 }
-/** Empty sandbox means scripts, same-origin access, navigation and popups are denied. */
+/** Project HTML may run its own UI scripts, but remains an opaque origin with
+ * forms, popups and top-level navigation denied by omission. */
+export const HTML_PREVIEW_SANDBOX = "allow-scripts";
 export function previewSandbox() {
-    return { sandbox: "" };
+    return { sandbox: HTML_PREVIEW_SANDBOX };
 }

package/dist/worker/console/chat/model-resolver.js

@@ -125,11 +125,14 @@ function resolveTierDescriptor(selection, available) {
         });
         return {
             provider: selection.provider,
-            resolved: Boolean(entry),
+            resolved: Boolean(entry && entry.hasCredentials !== false),
         };
     }
     const entry = findProviderForModelId(selection.modelId, available);
-    return { provider: entry?.provider, resolved: Boolean(entry) };
+    return {
+        provider: entry?.provider,
+        resolved: Boolean(entry && entry.hasCredentials !== false),
+    };
 }
 /**
  * Resolve harness executors.pi tiers (LOW/MED/HIGH) to provider descriptors.
@@ -196,7 +199,7 @@ export async function resolveDefaultChatModel(repoRoot, available, options) {
         const entry = findProviderForModelId(selection.modelId, available, {
             preferredProvider: selection.provider,
         });
-        if (!entry)
+        if (!entry || entry.hasCredentials === false)
             return undefined;
         return {
             provider: selection.provider,
@@ -205,7 +208,7 @@ export async function resolveDefaultChatModel(repoRoot, available, options) {
         };
     }
     const entry = findProviderForModelId(selection.modelId, available);
-    if (!entry)
+    if (!entry || entry.hasCredentials === false)
         return undefined;
     return {
         provider: entry.provider,