@tea-agent/loop-agent 0.38.0 → 0.38.2

package/dist/task/frontend-project-capability.js

@@ -5,7 +5,73 @@
  */
 import { readFile, readdir, stat } from "node:fs/promises";
 import path from "node:path";
-import { OPENSPEC_SPEC_DIRS, OPENSPEC_SPEC_EXT_RE } from "../shared/openspec-spec.js";
+import { z } from "zod";
+import { DEFAULT_OPENSPEC_GOVERNANCE_ROOT, MAX_OPENSPEC_CANDIDATE_PATHS, OPENSPEC_SPEC_DIRS, OPENSPEC_SPEC_EXT_RE, isGovernanceSubtreePath, isOpenspecSpecFilePath, } from "../shared/openspec-spec.js";
+const classifiedPathSchema = z
+    .string()
+    .refine((candidate) => isOpenspecSpecFilePath(candidate), "classified path must be a repo-relative supported spec file under openspec/schemas/, openspec/project-specs/, or ai_workspace/");
+/**
+ * Stable semantic partition of `designEvidence.normativePaths`. Keys are a
+ * generic directory convention (not project-specific file names); the same
+ * repository therefore yields the same classification on repeated probes.
+ */
+export const frontendDesignClassifiedSchema = z
+    .object({
+    schemas: z.array(classifiedPathSchema),
+    codeTemplate: z.array(classifiedPathSchema),
+    rule: z
+        .object({
+        api: z.array(classifiedPathSchema),
+        mock: z.array(classifiedPathSchema),
+        router: z.array(classifiedPathSchema),
+        hooks: z.array(classifiedPathSchema),
+        utils: z.array(classifiedPathSchema),
+        components: z.array(classifiedPathSchema),
+        other: z.array(classifiedPathSchema),
+    })
+        .strict(),
+    theme: z.array(classifiedPathSchema),
+    component: z.array(classifiedPathSchema),
+    uiOther: z.array(classifiedPathSchema),
+    advisoryOther: z.array(classifiedPathSchema),
+})
+    .strict();
+export const frontendDesignEvidenceSchema = z
+    .object({
+    normativePaths: z.array(z.string()),
+    advisoryPaths: z.array(z.string()),
+    conflicts: z.array(z.string()),
+    classified: frontendDesignClassifiedSchema,
+})
+    .strict()
+    .superRefine((evidence, ctx) => {
+    const classified = [
+        ...evidence.classified.schemas,
+        ...evidence.classified.codeTemplate,
+        ...evidence.classified.rule.api,
+        ...evidence.classified.rule.mock,
+        ...evidence.classified.rule.router,
+        ...evidence.classified.rule.hooks,
+        ...evidence.classified.rule.utils,
+        ...evidence.classified.rule.components,
+        ...evidence.classified.rule.other,
+        ...evidence.classified.theme,
+        ...evidence.classified.component,
+        ...evidence.classified.uiOther,
+        ...evidence.classified.advisoryOther,
+    ];
+    const classifiedSet = new Set(classified);
+    const normativeSet = new Set(evidence.normativePaths);
+    const onlyClassified = [...classifiedSet].filter((candidate) => !normativeSet.has(candidate));
+    const onlyNormative = [...normativeSet].filter((candidate) => !classifiedSet.has(candidate));
+    if (onlyClassified.length > 0 || onlyNormative.length > 0) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `classified must partition normativePaths exactly; extra in classified: ${onlyClassified.join(", ") || "(none)"}; missing from classified: ${onlyNormative.join(", ") || "(none)"}`,
+            path: ["classified"],
+        });
+    }
+});
 async function exists(filePath) {
     try {
         await stat(filePath);
@@ -15,39 +81,68 @@ async function exists(filePath) {
         return false;
     }
 }
-async function readJson(filePath) {
-    try {
-        return JSON.parse(await readFile(filePath, "utf8"));
-    }
-    catch {
-        return null;
+/**
+ * Resolve the governance subtree root from harness.json.governanceRoot.
+ * Falls back to DEFAULT_OPENSPEC_GOVERNANCE_ROOT when the manifest is missing,
+ * unreadable, malformed, or lacks a string governanceRoot. This intentionally
+ * does NOT apply init.ts's "docs" -> default migration (init-only behavior).
+ */
+export async function resolveOpenspecGovernanceRoot(repoRoot) {
+    const manifest = await readJson(path.join(repoRoot, "harness.json"));
+    if (manifest && typeof manifest === "object") {
+        const candidate = manifest.governanceRoot;
+        if (typeof candidate === "string" && candidate.trim()) {
+            return candidate.trim().replace(/\\/g, "/").replace(/\/+$/, "");
+        }
     }
+    return DEFAULT_OPENSPEC_GOVERNANCE_ROOT;
 }
-function allDeps(pkg) {
-    return {
-        ...(pkg.dependencies ?? {}),
-        ...(pkg.devDependencies ?? {}),
-        ...(pkg.peerDependencies ?? {}),
+export async function listOpenspecDiscovery(repoRoot, options = {}) {
+    const governanceRoot = options.governanceRootOverride ??
+        (await resolveOpenspecGovernanceRoot(repoRoot));
+    const extraExcludedPrefixes = (options.extraExcludedPrefixes ?? [])
+        .map((prefix) => prefix.replace(/\\/g, "/").replace(/\/+$/, ""))
+        .filter(Boolean);
+    const collected = [];
+    let excludedGovernanceCount = 0;
+    const isExcluded = (rel) => {
+        if (isGovernanceSubtreePath(rel, governanceRoot))
+            return true;
+        return extraExcludedPrefixes.some((prefix) => rel === prefix || rel.startsWith(prefix + "/"));
     };
-}
-function hasDep(deps, name) {
-    return Object.hasOwn(deps, name);
-}
-async function listOpenspec(repoRoot) {
-    const out = [];
     for (const specDir of OPENSPEC_SPEC_DIRS) {
         const root = path.join(repoRoot, specDir);
         if (!(await exists(root)))
             continue;
         await walk(root, 0);
     }
-    return out.slice(0, 40);
+    // openspec/schemas/** and openspec/project-specs/** sort first; remaining
+    // ai_workspace/** business files follow. Dedupe preserves discovery order.
+    const unique = [...new Set(collected)];
+    const openspecPaths = unique
+        .filter((candidate) => candidate.startsWith("openspec/"))
+        .sort();
+    const aiWorkspacePaths = unique
+        .filter((candidate) => candidate.startsWith("ai_workspace/"))
+        .sort();
+    const deduped = [...openspecPaths, ...aiWorkspacePaths];
+    const truncated = deduped.length > MAX_OPENSPEC_CANDIDATE_PATHS;
+    const paths = truncated
+        ? deduped.slice(0, MAX_OPENSPEC_CANDIDATE_PATHS)
+        : deduped;
+    return {
+        paths,
+        governanceRoot,
+        excludedGovernanceCount,
+        truncated,
+        maxCandidates: MAX_OPENSPEC_CANDIDATE_PATHS,
+    };
     async function walk(dir, depth) {
         if (depth > 4)
             return;
         let entries = [];
         try {
-            entries = await readdir(dir);
+            entries = (await readdir(dir)).sort();
         }
         catch {
             return;
@@ -59,7 +154,13 @@ async function listOpenspec(repoRoot) {
                 if (info.isDirectory())
                     await walk(full, depth + 1);
                 else if (OPENSPEC_SPEC_EXT_RE.test(name)) {
-                    out.push(path.relative(repoRoot, full).replace(/\\/g, "/"));
+                    const rel = path.relative(repoRoot, full).replace(/\\/g, "/");
+                    if (isExcluded(rel)) {
+                        excludedGovernanceCount++;
+                    }
+                    else {
+                        collected.push(rel);
+                    }
                 }
             }
             catch {
@@ -68,6 +169,164 @@ async function listOpenspec(repoRoot) {
         }
     }
 }
+/**
+ * Count spec-extension files under a governance subtree that candidate
+ * discovery would exclude. Bounded, read-only diagnostic helper used by the
+ * prewrite gate to reproduce exclusion stats at runtime.
+ */
+export async function countExcludedGovernanceSpecFiles(repoRoot, governanceRoot) {
+    const root = path.join(repoRoot, governanceRoot);
+    if (!(await exists(root)))
+        return 0;
+    let count = 0;
+    await walkGovernance(root, 0);
+    return count;
+    async function walkGovernance(dir, depth) {
+        if (depth > 4)
+            return;
+        let entries = [];
+        try {
+            entries = (await readdir(dir)).sort();
+        }
+        catch {
+            return;
+        }
+        for (const name of entries) {
+            const full = path.join(dir, name);
+            try {
+                const info = await stat(full);
+                if (info.isDirectory())
+                    await walkGovernance(full, depth + 1);
+                else if (OPENSPEC_SPEC_EXT_RE.test(name))
+                    count++;
+            }
+            catch {
+                // skip
+            }
+        }
+    }
+}
+async function readJson(filePath) {
+    try {
+        return JSON.parse(await readFile(filePath, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function allDeps(pkg) {
+    return {
+        ...(pkg.dependencies ?? {}),
+        ...(pkg.devDependencies ?? {}),
+        ...(pkg.peerDependencies ?? {}),
+    };
+}
+function hasDep(deps, name) {
+    return Object.hasOwn(deps, name);
+}
+function emptyClassified() {
+    return {
+        schemas: [],
+        codeTemplate: [],
+        rule: { api: [], mock: [], router: [], hooks: [], utils: [], components: [], other: [] },
+        theme: [],
+        component: [],
+        uiOther: [],
+        advisoryOther: [],
+    };
+}
+/**
+ * Classify discovered openspec paths by generic directory convention. Only
+ * `isOpenspecSpecFilePath` paths enter a bucket; the classifier never invents
+ * project-specific file names. Basename stems use word-boundary matching so
+ * e.g. `*api*` (case-insensitive) maps to `rule.api` without hardcoding names.
+ */
+function classifyOpenspecPaths(paths) {
+    const classified = emptyClassified();
+    const ruleStem = (basename) => {
+        const lower = basename.toLowerCase();
+        const stems = [
+            ["api", /\bapi\b/],
+            ["mock", /\bmock\b/],
+            ["router", /\brouter\b/],
+            ["hooks", /\bhooks?\b/],
+            ["utils", /\butils?\b/],
+            ["components", /\bcomponents?\b/],
+        ];
+        for (const [key, re] of stems) {
+            if (re.test(lower))
+                return key;
+        }
+        return "other";
+    };
+    for (const candidate of paths) {
+        if (!isOpenspecSpecFilePath(candidate))
+            continue;
+        const segments = candidate.split("/");
+        const basename = segments[segments.length - 1] ?? "";
+        if (candidate.startsWith("openspec/schemas/")) {
+            classified.schemas.push(candidate);
+        }
+        else if (candidate.startsWith("openspec/project-specs/templates/")) {
+            classified.codeTemplate.push(candidate);
+        }
+        else if (candidate.startsWith("openspec/project-specs/rules/")) {
+            classified.rule[ruleStem(basename)].push(candidate);
+        }
+        else if (candidate.startsWith("openspec/project-specs/ui/")) {
+            const lower = basename.toLowerCase();
+            if (/\btheme\b/.test(lower))
+                classified.theme.push(candidate);
+            else if (/\bcomponents?\b/.test(lower))
+                classified.component.push(candidate);
+            else
+                classified.uiOther.push(candidate);
+        }
+        else {
+            classified.advisoryOther.push(candidate);
+        }
+    }
+    const sortBucket = (bucket) => bucket.sort();
+    classified.schemas = sortBucket(classified.schemas);
+    classified.codeTemplate = sortBucket(classified.codeTemplate);
+    for (const key of [
+        "api",
+        "mock",
+        "router",
+        "hooks",
+        "utils",
+        "components",
+        "other",
+    ]) {
+        classified.rule[key] = sortBucket(classified.rule[key]);
+    }
+    classified.theme = sortBucket(classified.theme);
+    classified.component = sortBucket(classified.component);
+    classified.uiOther = sortBucket(classified.uiOther);
+    classified.advisoryOther = sortBucket(classified.advisoryOther);
+    return classified;
+}
+function buildDesignEvidence(openspec) {
+    // Preserve discovery priority order (openspec first, then ai_workspace)
+    // instead of re-sorting; the exact-partition schema identity is set-based.
+    const normativePaths = [...new Set(openspec)];
+    return frontendDesignEvidenceSchema.parse({
+        normativePaths,
+        advisoryPaths: [],
+        conflicts: [],
+        classified: classifyOpenspecPaths(normativePaths),
+    });
+}
+function toOpenspecDiscovery(discovery, designEvidence) {
+    return {
+        source: "auto-discovered",
+        governanceRoot: discovery.governanceRoot,
+        candidateCount: designEvidence.normativePaths.length,
+        excludedGovernanceCount: discovery.excludedGovernanceCount,
+        truncated: discovery.truncated,
+        maxCandidates: discovery.maxCandidates,
+    };
+}
 export function buildAdapterGuidance(capability) {
     const lines = [
         "## Frontend project capability (generation-time)",
@@ -108,7 +367,8 @@ export async function discoverFrontendProjectCapability(repoRoot) {
     const pkgPath = path.join(repoRoot, "package.json");
     const pkgRaw = await readJson(pkgPath);
     if (!pkgRaw || typeof pkgRaw !== "object") {
-        const openspec = await listOpenspec(repoRoot);
+        const discovery = await listOpenspecDiscovery(repoRoot);
+        const designEvidence = buildDesignEvidence(discovery.paths);
         const base = {
             schemaVersion: 1,
             framework: "unknown",
@@ -119,16 +379,13 @@ export async function discoverFrontendProjectCapability(repoRoot) {
             testRunner: [],
             mock: [],
             a11y: { status: "unknown", tools: [], evidencePaths: [] },
-            evidencePaths: openspec.slice(0, 5),
+            evidencePaths: discovery.paths.slice(0, 5),
             reasons: ["package.json missing or unreadable"],
-            designEvidence: {
-                normativePaths: openspec,
-                advisoryPaths: [],
-                conflicts: [],
-            },
+            designEvidence,
+            openspecDiscovery: toOpenspecDiscovery(discovery, designEvidence),
         };
-        if (openspec.length) {
-            base.reasons.push(`openspec spec files discovered: ${openspec.slice(0, 5).join(", ")}`);
+        if (discovery.paths.length) {
+            base.reasons.push(`openspec spec files discovered: ${discovery.paths.slice(0, 5).join(", ")}`);
         }
         return { ...base, adapterGuidance: buildAdapterGuidance(base) };
     }
@@ -283,14 +540,10 @@ export async function discoverFrontendProjectCapability(repoRoot) {
         router = router ?? "next-router";
     if (hasDep(deps, "vue-router"))
         router = "vue-router";
-    const openspec = await listOpenspec(repoRoot);
-    const designEvidence = {
-        normativePaths: openspec,
-        advisoryPaths: [],
-        conflicts: [],
-    };
-    if (openspec.length)
-        evidencePaths.push(...openspec.slice(0, 5));
+    const discovery = await listOpenspecDiscovery(repoRoot);
+    const designEvidence = buildDesignEvidence(discovery.paths);
+    if (discovery.paths.length)
+        evidencePaths.push(...discovery.paths.slice(0, 5));
     const base = {
         schemaVersion: 1,
         framework,
@@ -311,6 +564,7 @@ export async function discoverFrontendProjectCapability(repoRoot) {
         evidencePaths: [...new Set(evidencePaths)],
         reasons,
         designEvidence,
+        openspecDiscovery: toOpenspecDiscovery(discovery, designEvidence),
     };
     return { ...base, adapterGuidance: buildAdapterGuidance(base) };
 }

package/dist/worker/console/chat/deferred-turn.js

@@ -0,0 +1,91 @@
+import { createHash } from "node:crypto";
+const IMAGE_MIME_TYPES = new Set([
+    "image/png",
+    "image/jpeg",
+    "image/gif",
+    "image/webp",
+]);
+export function hashDeferredTurnPayload(input) {
+    return createHash("sha256")
+        .update(JSON.stringify({
+        text: input.text,
+        images: input.images.map(({ type, mimeType, data }) => ({
+            type,
+            mimeType,
+            data,
+        })),
+    }))
+        .digest("hex");
+}
+export function parseDeferredTurn(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const item = value;
+    if (item.schemaVersion !== 1 ||
+        !Number.isSafeInteger(item.revision) ||
+        (item.revision ?? 0) < 1 ||
+        typeof item.clientRequestId !== "string" ||
+        !item.clientRequestId.trim() ||
+        typeof item.payloadHash !== "string" ||
+        !/^[a-f0-9]{64}$/.test(item.payloadHash) ||
+        typeof item.blockedByTurnId !== "string" ||
+        !item.blockedByTurnId.trim() ||
+        typeof item.text !== "string" ||
+        !Array.isArray(item.images) ||
+        !["queued", "dispatching", "accepted", "failed"].includes(item.state) ||
+        typeof item.createdAt !== "string" ||
+        typeof item.updatedAt !== "string") {
+        return undefined;
+    }
+    const images = [];
+    for (const image of item.images) {
+        if (!image || typeof image !== "object")
+            return undefined;
+        const candidate = image;
+        if (typeof candidate.name !== "string" ||
+            candidate.type !== "image" ||
+            typeof candidate.mimeType !== "string" ||
+            !IMAGE_MIME_TYPES.has(candidate.mimeType) ||
+            typeof candidate.data !== "string") {
+            return undefined;
+        }
+        images.push(candidate);
+    }
+    return {
+        schemaVersion: 1,
+        revision: item.revision,
+        clientRequestId: item.clientRequestId.trim(),
+        payloadHash: item.payloadHash,
+        blockedByTurnId: item.blockedByTurnId.trim(),
+        text: item.text,
+        images,
+        state: item.state,
+        createdAt: item.createdAt,
+        updatedAt: item.updatedAt,
+        ...(typeof item.acceptedTurnId === "string" && item.acceptedTurnId
+            ? { acceptedTurnId: item.acceptedTurnId }
+            : {}),
+        ...(item.lastError &&
+            typeof item.lastError.code === "string" &&
+            typeof item.lastError.message === "string"
+            ? { lastError: { code: item.lastError.code, message: item.lastError.message } }
+            : {}),
+    };
+}
+export function projectDeferredTurnSummary(deferredTurn) {
+    if (!deferredTurn)
+        return null;
+    return {
+        revision: deferredTurn.revision,
+        clientRequestId: deferredTurn.clientRequestId,
+        blockedByTurnId: deferredTurn.blockedByTurnId,
+        state: deferredTurn.state,
+        updatedAt: deferredTurn.updatedAt,
+        textPreview: deferredTurn.text.replace(/\s+/g, " ").trim().slice(0, 120),
+        imageCount: deferredTurn.images.length,
+        ...(deferredTurn.acceptedTurnId
+            ? { acceptedTurnId: deferredTurn.acceptedTurnId }
+            : {}),
+        ...(deferredTurn.lastError ? { lastError: deferredTurn.lastError } : {}),
+    };
+}