@tea-agent/loop-agent 0.41.1 → 0.42.0-next.10

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/task/task-demand-routing.js

@@ -76,6 +76,7 @@ const SPECIAL_TEMPLATE_BY_TASK_KIND = {
     "frontend-implementation": "frontend-implementation",
     "frontend-test": "frontend-test-dag",
     "backend-test": "backend-test-dag",
+    "backend-test-analysis": "backend-test-analysis-dag",
     "knowledge-sync": "knowledge-sync-dag",
     "knowledge-graph-bootstrap": "knowledge-graph-bootstrap-dag",
 };
@@ -83,6 +84,7 @@ const TASK_KIND_ROUTING_REASON = {
     "frontend-implementation": 'taskKind "frontend-implementation" selects the dedicated frontend DAG template',
     "frontend-test": 'taskKind "frontend-test" selects the dedicated frontend test DAG template',
     "backend-test": 'taskKind "backend-test" selects the dedicated backend test DAG template',
+    "backend-test-analysis": 'taskKind "backend-test-analysis" selects the read-only backend test analysis DAG template',
     "knowledge-sync": 'taskKind "knowledge-sync" selects the dedicated knowledge-sync DAG template',
     "knowledge-graph-bootstrap": 'taskKind "knowledge-graph-bootstrap" selects the dedicated knowledge-graph bootstrap DAG template',
 };
@@ -90,6 +92,7 @@ const SPECIAL_REQUESTED_TEMPLATES = new Set([
     "frontend-implementation",
     "frontend-test-dag",
     "backend-test-dag",
+    "backend-test-analysis-dag",
     "knowledge-sync-dag",
     "knowledge-graph-bootstrap-dag",
 ]);

package/dist/worker/console/chat/chat-event-store.js

@@ -19,8 +19,8 @@
 import { createHash } from "node:crypto";
 import { existsSync, readFileSync, rmSync } from "node:fs";
 import path from "node:path";
-import { ensureSecureDir, writeSecureJsonSync, } from "../app-data.js";
-import { isTerminalOperationState, } from "../operation-store.js";
+import { ensureSecureDir, writeSecureJsonSync, } from "../../../infrastructure/console/app-data.js";
+import { isTerminalOperationState, } from "../../../infrastructure/console/operation-store.js";
 import { scrubSecrets } from "./explore-tools.js";
 const OPERATION_PREVIEW_MAX_CHARS = 1200;
 function boundedRedactedText(value, maxChars = OPERATION_PREVIEW_MAX_CHARS) {

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,

package/dist/worker/console/chat/pi-runtime.js

@@ -26,7 +26,7 @@
  * `createDefaultPiSdkBindings()`.
  */
 import { createHash, randomBytes } from "node:crypto";
-import { access, stat } from "node:fs/promises";
+import { access, mkdir, rm, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { extractAssistantContentBlocks, extractAssistantText, isAssistantSdkMessage, } from "./assistant-content.js";
 import { parseProviderError, } from "./provider-error.js";
@@ -43,6 +43,7 @@ import { filterActiveInterviewTools } from "../interview/tools.js";
 import { RUNTIME_CONTEXT_TEXT_MAX, redactRuntimeText, } from "./runtime-context.js";
 import { buildTodoContinuationContext, } from "./todos.js";
 import { buildGoalContinuationContext, } from "./goals.js";
+import { injectWizardLocalHeaders, } from "./sdd-data-alignment.js";
 /**
  * Base system prompt fragment every General Operator Chat session receives.
  *
@@ -298,6 +299,24 @@ export function createGoalCompactionContextExtension(options) {
         },
     };
 }
+export function createWizardLocalHeadersExtension(options) {
+    return {
+        name: "operator-chat-wizard-local-headers",
+        hidden: true,
+        factory: (api) => {
+            api.on("before_provider_headers", async (rawEvent, context) => {
+                if (!context || !rawEvent.headers || typeof rawEvent.headers !== "object")
+                    return;
+                await injectWizardLocalHeaders({
+                    headers: rawEvent.headers,
+                    context,
+                    sessionId: options.sessionId,
+                    service: options.service,
+                });
+            });
+        },
+    };
+}
 /**
  * Build Pi custom ToolDefinition objects for every whitelisted operator action.
  * Each tool's execute() routes into the operator action dispatcher (Gate 3).
@@ -1061,10 +1080,17 @@ export class ConsolePiRuntime {
                 registry: this.options.goalRegistry,
             })
             : undefined;
+        const wizardLocalHeadersExtension = sessionId && this.options.sddDataAlignment
+            ? createWizardLocalHeadersExtension({
+                sessionId,
+                service: this.options.sddDataAlignment,
+            })
+            : undefined;
         const extraFactories = [
             todoContextExtension,
             goalContextExtension,
             pressureExtension,
+            wizardLocalHeadersExtension,
         ].filter((item) => Boolean(item));
         return {
             ...base,
@@ -1305,6 +1331,15 @@ export class ConsolePiRuntime {
         if (!sessionFile) {
             throw new Error(`chat session shell missing sessionFile for ${sessionId}`);
         }
+        // Pi's SessionManager.create deliberately postpones writing a JSONL until
+        // an assistant response. Materialize a valid header now, otherwise Console
+        // could persist a path that disappears on a restart before first reply.
+        await this.bindings.materializeSessionShell({
+            sessionManager,
+            sessionId,
+            sessionFile,
+            cwd: this.options.cwd,
+        });
         this.sessionManagers.set(sessionId, sessionManager);
         this.thinkingSelections.set(sessionId, "auto");
         // Detached single-flight materialization; dependent routes await the same promise.
@@ -2312,6 +2347,16 @@ export class ConsolePiRuntime {
             });
         }
         catch (error) {
+            const code = error && typeof error === "object" && "code" in error
+                ? String(error.code ?? "")
+                : "";
+            if (code === "SESSION_FILE_MISSING" || code === "ENOENT") {
+                return {
+                    ok: false,
+                    code: "NO_SESSION_FILE",
+                    message: `Pi session file missing or not openable: ${init.sessionFile}`,
+                };
+            }
             return {
                 ok: false,
                 code: "REOPEN_FAILED",
@@ -3147,6 +3192,36 @@ export function createDefaultPiSdkBindings() {
                 id: opts.sessionId,
             });
         },
+        materializeSessionShell: async (opts) => {
+            const sdk = (await loadSdk());
+            const manager = opts.sessionManager;
+            if (typeof manager.setSessionFile !== "function") {
+                throw new Error("Pi SessionManager cannot materialize a session file");
+            }
+            let created = false;
+            try {
+                await mkdir(path.dirname(opts.sessionFile), { recursive: true });
+                // Match Pi's documented session header. Rebinding through the public
+                // SessionManager API marks it flushed, so Pi appends the first user
+                // entry instead of trying to create the already-present file later.
+                await writeFile(opts.sessionFile, `${JSON.stringify({
+                    type: "session",
+                    version: typeof sdk.CURRENT_SESSION_VERSION === "number"
+                        ? sdk.CURRENT_SESSION_VERSION
+                        : 3,
+                    id: opts.sessionId,
+                    timestamp: new Date().toISOString(),
+                    cwd: opts.cwd,
+                })}\n`, { encoding: "utf8", flag: "wx", mode: 0o600 });
+                created = true;
+                manager.setSessionFile(opts.sessionFile);
+            }
+            catch (error) {
+                if (created)
+                    await rm(opts.sessionFile, { force: true }).catch(() => undefined);
+                throw error;
+            }
+        },
         createInMemorySessionManager: async (opts) => {
             const sdk = (await loadSdk());
             return sdk.SessionManager.inMemory(opts.cwd);
@@ -3163,13 +3238,19 @@ export function createDefaultPiSdkBindings() {
                 // wrong conversation under the durable Console sessionId. Fail closed
                 // before open when the persisted file is absent.
                 await access(opts.sessionFile);
-                return sdk.SessionManager.open(opts.sessionFile);
             }
-            catch {
-                // Missing/corrupt session file — caller fails closed rather than
-                // silently creating a fresh session and losing prior context.
+            catch (error) {
+                const code = error && typeof error === "object" && "code" in error
+                    ? String(error.code ?? "")
+                    : "";
+                if (code === "ENOENT") {
+                    throw Object.assign(new Error(`SESSION_FILE_MISSING: ${opts.sessionFile}`), { code: "SESSION_FILE_MISSING", cause: error });
+                }
+                // File exists but is unreadable (permissions / I/O) — caller maps
+                // undefined to 503 rather than silently creating a fresh session.
                 return undefined;
             }
+            return sdk.SessionManager.open(opts.sessionFile);
         },
         resolveModel: (opts) => {
             const rt = opts.modelRuntime;

package/dist/worker/console/chat/resource-preferences-store.js

@@ -7,7 +7,7 @@
  */
 import { createHash } from "node:crypto";
 import { existsSync, lstatSync } from "node:fs";
-import { readJsonIfExists, writeSecureJson, } from "../app-data.js";
+import { readJsonIfExists, writeSecureJson, } from "../../../infrastructure/console/app-data.js";
 export const RESOURCE_PREFERENCES_SCHEMA_VERSION = 1;
 export class ResourcePreferencesError extends Error {
     code;