@tea-agent/loop-agent 0.39.0-beta.2 → 0.39.0-beta.3

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

@@ -3,13 +3,13 @@
  * Strong evidence only: package.json deps, config files, source imports.
  * Lockfile-only or directory-name-only must NOT activate adapters.
  */
-import { readFile, readdir, stat } from "node:fs/promises";
+import { lstat, readFile, readdir, realpath, stat } from "node:fs/promises";
 import path from "node:path";
 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";
+import { DEFAULT_OPENSPEC_GOVERNANCE_ROOT, MAX_OPENSPEC_CANDIDATE_PATHS, OPENSPEC_SPEC_DIRS, OPENSPEC_SPEC_EXT_RE, isGovernanceSubtreePath, } 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/");
+    .refine((candidate) => OPENSPEC_SPEC_EXT_RE.test(candidate), "classified path must be a repo-relative supported spec file");
 /**
  * Stable semantic partition of `designEvidence.normativePaths`. Keys are a
  * generic directory convention (not project-specific file names); the same
@@ -81,6 +81,34 @@ async function exists(filePath) {
         return false;
     }
 }
+/**
+ * Resolve only unambiguous symlink-root aliases. The physical target is never
+ * emitted as a candidate path: it merely lets task-source wording such as
+ * `ai_doc/rules.md` resolve to the stable repo-local path `ai_workspace/rules.md`.
+ */
+export async function resolveFrontendSpecRootAliases(repoRoot, specRoots) {
+    const candidates = [];
+    for (const logicalRoot of specRoots) {
+        const full = path.join(repoRoot, logicalRoot);
+        try {
+            if (!(await lstat(full)).isSymbolicLink())
+                continue;
+            const alias = path.basename(await realpath(full));
+            if (alias && alias !== path.basename(logicalRoot)) {
+                candidates.push({ alias, logicalRoot });
+            }
+        }
+        catch {
+            // Missing/broken links are handled by normal candidate discovery drift.
+        }
+    }
+    const counts = new Map();
+    for (const item of candidates)
+        counts.set(item.alias, (counts.get(item.alias) ?? 0) + 1);
+    return candidates
+        .filter((item) => counts.get(item.alias) === 1)
+        .sort((a, b) => a.alias.localeCompare(b.alias));
+}
 /**
  * Resolve the governance subtree root from harness.json.governanceRoot.
  * Falls back to DEFAULT_OPENSPEC_GOVERNANCE_ROOT when the manifest is missing,
@@ -110,22 +138,20 @@ export async function listOpenspecDiscovery(repoRoot, options = {}) {
             return true;
         return extraExcludedPrefixes.some((prefix) => rel === prefix || rel.startsWith(prefix + "/"));
     };
-    for (const specDir of OPENSPEC_SPEC_DIRS) {
+    for (const specDir of options.specRoots ?? [...OPENSPEC_SPEC_DIRS]) {
         const root = path.join(repoRoot, specDir);
         if (!(await exists(root)))
             continue;
         await walk(root, 0);
     }
-    // openspec/schemas/** and openspec/project-specs/** sort first; remaining
-    // ai_workspace/** business files follow. Dedupe preserves discovery order.
+    // Keep the established default-root priority for deterministic compatibility;
+    // configured extra roots are appended in lexical order.
     const unique = [...new Set(collected)];
-    const openspecPaths = unique
-        .filter((candidate) => candidate.startsWith("openspec/"))
-        .sort();
-    const aiWorkspacePaths = unique
-        .filter((candidate) => candidate.startsWith("ai_workspace/"))
+    const defaultPaths = OPENSPEC_SPEC_DIRS.flatMap((root) => unique.filter((candidate) => candidate.startsWith(root + "/")).sort());
+    const customPaths = unique
+        .filter((candidate) => !defaultPaths.includes(candidate))
         .sort();
-    const deduped = [...openspecPaths, ...aiWorkspacePaths];
+    const deduped = [...defaultPaths, ...customPaths];
     const truncated = deduped.length > MAX_OPENSPEC_CANDIDATE_PATHS;
     const paths = truncated
         ? deduped.slice(0, MAX_OPENSPEC_CANDIDATE_PATHS)
@@ -260,7 +286,7 @@ function classifyOpenspecPaths(paths) {
         return "other";
     };
     for (const candidate of paths) {
-        if (!isOpenspecSpecFilePath(candidate))
+        if (!OPENSPEC_SPEC_EXT_RE.test(candidate))
             continue;
         const segments = candidate.split("/");
         const basename = segments[segments.length - 1] ?? "";
@@ -361,13 +387,13 @@ export function buildAdapterGuidance(capability) {
  * Discover frontend project capability from repo root.
  * Strong evidence: package.json direct deps + config/bootstrap files.
  */
-export async function discoverFrontendProjectCapability(repoRoot) {
+export async function discoverFrontendProjectCapability(repoRoot, options = {}) {
     const evidencePaths = [];
     const reasons = [];
     const pkgPath = path.join(repoRoot, "package.json");
     const pkgRaw = await readJson(pkgPath);
     if (!pkgRaw || typeof pkgRaw !== "object") {
-        const discovery = await listOpenspecDiscovery(repoRoot);
+        const discovery = await listOpenspecDiscovery(repoRoot, options);
         const designEvidence = buildDesignEvidence(discovery.paths);
         const base = {
             schemaVersion: 1,
@@ -540,7 +566,7 @@ export async function discoverFrontendProjectCapability(repoRoot) {
         router = router ?? "next-router";
     if (hasDep(deps, "vue-router"))
         router = "vue-router";
-    const discovery = await listOpenspecDiscovery(repoRoot);
+    const discovery = await listOpenspecDiscovery(repoRoot, options);
     const designEvidence = buildDesignEvidence(discovery.paths);
     if (discovery.paths.length)
         evidencePaths.push(...discovery.paths.slice(0, 5));

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

@@ -35,8 +35,15 @@ const HEADING_ALIASES = {
     assumptions: new Set(["假设", "assumptions"]),
 };
 const OBJECTIVE_MAX_CHARS = 1200;
-/** Product Requirement V3/V4 style embedded AC heading, e.g. AC-FE-001 / AC-BE-12 / AC-001. */
-const EMBEDDED_AC_HEADING = /^(AC(?:[-_](?:FE|BE|UI|API))?[-_]?\d+(?:[-_]\d+)?)\s*[:：]?\s*(.*)$/iu;
+/**
+ * Product Requirement V3/V4 style embedded AC heading, e.g. AC-FE-001 /
+ * AC-BE-12 / AC-001 — and catalog-qualified feature segments such as
+ * AC-FE-INS-001 / AC-FE-CHAT-005 (uppercase letter/digit segments).
+ * Catalog ids embedded in bold (“**AC-FE-INS-001**：…”) must bind as-is;
+ * falling through to a minted AC-00N historically produced dual ids and
+ * acceptanceCoverage.missing noise (2026-08-23 fe-test loop finding 5).
+ */
+const EMBEDDED_AC_HEADING = /^(AC(?:[-_](?:FE|BE|UI|API))?[-_]?[A-Z0-9]+(?:[-_][A-Z0-9]+)*)\s*[:：]?\s*(.*)$/u;
 function stripFencedAndComments(text) {
     // Remove fenced code blocks and HTML comments so headings inside them are ignored.
     return text
@@ -52,12 +59,25 @@ function normalizeAcceptanceId(raw) {
         .replace(/^(AC)(FE|BE|UI|API)(?=-|\d)/u, "$1-$2");
 }
 function parseEmbeddedAcHeading(headingText) {
-    const normalized = headingText.trim().replace(/^(?:\d+(?:\.\d+)*[.．、]?\s*)+/u, "");
+    const normalized = headingText
+        .trim()
+        // Strip leading section numbers ("2.1、" style) and bold/emphasis
+        // wrappers ("**AC-FE-INS-001**") so embedded catalog ids bind.
+        .replace(/^(?:\d+(?:\.\d+)*[.．、]?\s*)+/u, "")
+        .replace(/^\*\*|\*\*$/g, "")
+        .replace(/^__|__$/g, "")
+        .trim();
     const match = EMBEDDED_AC_HEADING.exec(normalized);
     if (!match)
         return null;
     const id = normalizeAcceptanceId(match[1]);
-    const text = match[2]?.trim() || id;
+    // Bold-wrapped ids leave their closing marker inside the captured text
+    // ("**AC-FE-INS-001**：xxx" captures "**：xxx"); strip emphasis remnants
+    // and leading separators so the bound text is clean prose.
+    const text = (match[2] ?? "")
+        .replace(/^[*_]+\s*/, "")
+        .replace(/^\s*[:：]\s*/, "")
+        .trim() || id;
     return { id, text };
 }
 function normalizeHeadingText(raw) {

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

@@ -5,6 +5,8 @@ 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 { resolveFrontendSpecRootAliases } from "../frontend-project-capability.js";
+import { DEFAULT_FRONTEND_SPEC_ROOTS, extractDeclaredFrontendSpecRoots, } from "../../shared/openspec-spec.js";
 import { buildPrepareDraft } from "./build-draft.js";
 import { hasBlockingGaps, hasBlockingRisks, isFreshLegacyUnversioned, listPrepareGaps, } from "./completeness.js";
 import { detectProductArtifactMeta, isIntakeSoftGapCode, } from "./artifact-meta.js";
@@ -591,6 +593,40 @@ export async function prepareTaskSource(input) {
         flags: input.flags,
         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; runtime selectors never
+    // mutate task.json.
+    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,

package/dist/worker/cli.js

@@ -1,8 +1,11 @@
 #!/usr/bin/env node
 import { readFile } from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { Command } from "commander";
+import { createNpmUpdateClient } from "../shared/update/npm-client.js";
+import { runConsoleDailyUpdateCheck } from "../shared/update/console-notifier.js";
 import { readPackageVersion } from "../shared/package-metadata.js";
 import YAML from "yaml";
 import { LoopAgentClient } from "./loop-agent/loop-agent-client.js";
@@ -838,10 +841,33 @@ function parseOptionalTimeoutMs(raw) {
     return value;
 }
 /** Console HTTP entry for bare `agent-worker console` (listen first, then optional browser open). */
-async function runConsoleServe(options) {
+export async function runConsoleServe(options) {
     const { createConsoleServer } = await import("./console/server.js");
     const { maybeOpenConsoleBrowser } = await import("./console/open-browser.js");
     try {
+        try {
+            const packageRoot = path.dirname(path.dirname(path.dirname(fileURLToPath(import.meta.url))));
+            const currentVersion = readPackageVersion(packageRoot) ?? "0.0.0";
+            await runConsoleDailyUpdateCheck({
+                currentVersion,
+                packageRoot,
+                homeDir: os.homedir(),
+                cwd: options.repoRoot,
+                env: process.env,
+                stdinIsTTY: process.stdin.isTTY === true,
+                stderrIsTTY: process.stderr.isTTY === true,
+                client: createNpmUpdateClient({
+                    currentVersion,
+                    packageRoot,
+                    cwd: options.repoRoot,
+                    env: process.env,
+                }),
+            });
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            process.stderr.write(`loop-agent 更新检查已跳过：${detail}\n`);
+        }
         const server = await createConsoleServer({
             repoRoot: options.repoRoot,
             host: options.host,
@@ -857,6 +883,10 @@ async function runConsoleServe(options) {
             noOpen: options.noOpen === true,
             serverUrl: server.url,
         });
+        if (options.holdUntilSignal === false) {
+            await server.close();
+            return;
+        }
         await new Promise((resolve) => {
             const shutdown = () => resolve();
             process.once("SIGINT", shutdown);

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

@@ -1,6 +1,13 @@
 import { createHash, randomBytes } from "node:crypto";
 import { open, readFile, rename, writeFile } from "node:fs/promises";
 import path from "node:path";
+/** 新建模型时，未显式提供的字段使用的默认值（仅含 6 个定义参数）。 */
+const DEFAULT_MODEL_FIELDS = {
+    contextWindow: 32000,
+    maxTokens: 8192,
+    reasoning: false,
+    input: ["text"],
+};
 const revision = (raw) => createHash("sha256").update(raw).digest("hex");
 export async function readModelsConfig(agentDir) {
     let raw = "{}";
@@ -29,6 +36,18 @@ export async function readModelsConfig(agentDir) {
                     return {
                         id: String(item.id ?? ""),
                         name: typeof item.name === "string" ? item.name : undefined,
+                        contextWindow: typeof item.contextWindow === "number"
+                            ? item.contextWindow
+                            : undefined,
+                        maxTokens: typeof item.maxTokens === "number"
+                            ? item.maxTokens
+                            : undefined,
+                        input: Array.isArray(item.input)
+                            ? item.input.filter((entry) => typeof entry === "string")
+                            : undefined,
+                        reasoning: typeof item.reasoning === "boolean"
+                            ? item.reasoning
+                            : undefined,
                     };
                 })
                     .filter((model) => model.id)
@@ -81,19 +100,25 @@ export async function patchModelsConfig(agentDir, input) {
                 code: "INVALID_INPUT",
                 status: 400,
             });
+        const fields = validateModelFields(input.model);
+        const existingIndex = models.findIndex((model) => model.id === input.model.id);
+        const merged = {
+            // id/name 在前；新建模型用默认字段补齐（保证定义完整），更新保留已有值。
+            id: input.model.id,
+            ...(fields.name !== undefined ? { name: fields.name } : {}),
+            ...(existingIndex >= 0 ? models[existingIndex] : DEFAULT_MODEL_FIELDS),
+            ...fields,
+        };
         provider.models =
             input.action === "remove-model"
                 ? models.filter((model) => model.id !== input.model.id)
-                : [
-                    ...models.filter((model) => model.id !== input.model.id),
-                    {
-                        ...(models.find((model) => model.id === input.model.id) ?? {}),
-                        id: input.model.id,
-                        ...(input.model.name !== undefined
-                            ? { name: input.model.name }
-                            : {}),
-                    },
-                ];
+                : existingIndex >= 0
+                    ? [
+                        ...models.slice(0, existingIndex),
+                        merged,
+                        ...models.slice(existingIndex + 1),
+                    ]
+                    : [...models, merged];
     }
     const body = `${JSON.stringify(parsed, null, 2)}\n`;
     const tmp = path.join(agentDir, `.models.${process.pid}.${randomBytes(4).toString("hex")}.tmp`);
@@ -108,6 +133,52 @@ export async function patchModelsConfig(agentDir, input) {
     await rename(tmp, file);
     return readModelsConfig(agentDir);
 }
+/** Whitelist + validate model fields carried by a client upsert. Never accept
+ *  arbitrary keys; only known numeric/boolean/string-array shape fields. */
+function validateModelFields(model) {
+    const fields = {};
+    if (model.name !== undefined)
+        fields.name = String(model.name);
+    if (model.contextWindow !== undefined) {
+        if (typeof model.contextWindow !== "number" || model.contextWindow < 0)
+            throw invalid("contextWindow must be a non-negative number");
+        fields.contextWindow = model.contextWindow;
+    }
+    if (model.maxTokens !== undefined) {
+        if (typeof model.maxTokens !== "number" || model.maxTokens < 0)
+            throw invalid("maxTokens must be a non-negative number");
+        fields.maxTokens = model.maxTokens;
+    }
+    if (model.reasoning !== undefined) {
+        if (typeof model.reasoning !== "boolean")
+            throw invalid("reasoning must be a boolean");
+        fields.reasoning = model.reasoning;
+    }
+    if (model.input !== undefined) {
+        if (!Array.isArray(model.input) ||
+            !model.input.every((item) => typeof item === "string"))
+            throw invalid("input must be an array of strings");
+        fields.input = model.input.map((item) => String(item));
+    }
+    if (model.cost !== undefined) {
+        if (!model.cost || typeof model.cost !== "object")
+            throw invalid("cost must be an object");
+        const cost = {};
+        for (const key of ["input", "output", "cacheRead", "cacheWrite"]) {
+            const value = model.cost[key];
+            if (value !== undefined) {
+                if (typeof value !== "number" || value < 0)
+                    throw invalid(`cost.${key} must be a non-negative number`);
+                cost[key] = value;
+            }
+        }
+        fields.cost = cost;
+    }
+    return fields;
+}
+function invalid(message) {
+    return Object.assign(new Error(message), { code: "INVALID_INPUT", status: 400 });
+}
 /** Max bytes of a package.json we are willing to read (read-only, bounded). */
 export const MAX_PACKAGE_JSON_BYTES = 64 * 1024;
 /** Max directory levels walked upward from an owned resolved resource path. */

package/dist/worker/console/chat/routes.js

@@ -270,6 +270,7 @@ export function parseChatImages(value) {
 }
 function gateMutation(req, deps) {
     const failure = evaluateMutationGate(req, {
+        cookieName: deps.bootToken.cookieName,
         bootToken: deps.bootToken.value,
         confirmationToken: deps.bootToken.confirmationToken,
         consoleOrigin: deps.getConsoleOrigin(),

package/dist/worker/console/dag-execution-receipt.js

@@ -35,6 +35,32 @@ import { hashDagBytes, } from "./dag-confirmation.js";
  * framework invocations that don't embed the word "verify".
  */
 export const STRUCTURED_VERIFICATION_COMMAND_RE = /\b(vitest|jest|playwright|cypress|pytest|py-test|go\s+test|cargo\s+test|npm\s+run\s+(lint|typecheck|test|verify)|npm\s+(test|run\s+test)|check-repo\.sh|loop-agent-standard-verify)\b/i;
+/**
+ * Deterministic shell preset keys whose executors are themselves structured
+ * verification/gate materializers: their shell.commands[] is empty and the
+ * preset alone carries the verification authority (hash-bound artifact
+ * gates, evidence validators, report finalize). Mirrors the named-shell
+ * handler registry in shell-executor.ts so preset-only workflows
+ * (frontend-test finalize/reports, backend-test pipeline, verify-evidence
+ * gates) pass the G2 autonomous execution gate without depending on node-id
+ * naming conventions.
+ */
+export const STRUCTURED_VERIFICATION_SHELL_PRESETS = new Set([
+    "frontendTestCaseChecklist",
+    "frontendTestCaseManifest",
+    "frontendTestEvidenceValidation",
+    "frontendTestResultFinalize",
+    "frontendTestL5Report",
+    "frontendTestHtmlReport",
+    "frontendTestReports",
+    "backendTestPipeline",
+    "verifyEvidence",
+    "repairArtifactGate",
+    "jacocoCoverage",
+    "requirementCoverageGate",
+    "jsonArtifactGate",
+    "verdictGate",
+]);
 export const DEFAULT_EXECUTION_RECEIPT_TTL_MS = 30 * 60 * 1000;
 function normalizePathEntry(entry) {
     return entry.trim().replace(/\\/g, "/").replace(/^\.\//, "");
@@ -157,6 +183,13 @@ export function deriveEligibilityFactsFromDagSpec(input) {
             return false;
         if (/verify|verification/i.test(task.id ?? ""))
             return true;
+        // Preset-only verification shells (empty commands[]): the preset key is
+        // the verification authority (frontend-test finalize, backend-test
+        // pipeline, evidence/artifact gates).
+        const shellRecord = task.shell;
+        const hasVerificationPreset = Object.keys(shellRecord).some((key) => STRUCTURED_VERIFICATION_SHELL_PRESETS.has(key));
+        if (hasVerificationPreset)
+            return true;
         const commands = stringList(task.shell.commands);
         return commands.some((command) => STRUCTURED_VERIFICATION_COMMAND_RE.test(command));
     });

package/dist/worker/console/frontend-human-decision-adapter.js

@@ -0,0 +1,19 @@
+import { parseFrontendHumanDecisionProjection } from "../../workflows/dag/frontend-human-decision.js";
+/** Worker/Console persistence seam. Canonical validation and freshness remain in the workflow service. */
+export function createFrontendHumanDecisionAdapter(store) {
+    return {
+        async load(operationId) {
+            const record = await store.get(operationId);
+            if (!record || record.revision === undefined || !record.frontendHumanDecision)
+                return undefined;
+            return { revision: record.revision, projection: parseFrontendHumanDecisionProjection(record.frontendHumanDecision) };
+        },
+        materialize(input) {
+            return store.materializeFrontendHumanDecision(input);
+        },
+        consume(input) {
+            return store.consumeFrontendHumanDecision(input);
+        },
+        initializeSplit: store.initializeFrontendHumanApprovedSplit.bind(store),
+    };
+}

package/dist/worker/console/frontend-split-operation-adapter.js

@@ -0,0 +1,20 @@
+import { FrontendSplitOrchestrator, frontendSplitProjectionSchema, } from "../../workflows/dag/frontend-split-application-service.js";
+/** Worker/Console boundary adapter. All orchestration policy remains canonical. */
+export function createFrontendSplitOperationAdapter(dependencies) {
+    const ports = {
+        load: async (operationId) => {
+            const record = await dependencies.store.get(operationId);
+            return record?.frontendSplit === undefined ? undefined : frontendSplitProjectionSchema.parse(record.frontendSplit);
+        },
+        compareAndSwap: (input) => dependencies.store.compareAndSwapFrontendSplit(input),
+        materialize: async (request) => {
+            const result = await dependencies.materializer.materialize(request);
+            return { taskId: result.taskId, operationId: result.operationId };
+        },
+        schedule: dependencies.schedule,
+        auditStale: dependencies.auditStale,
+        loadChildCloseoutFacts: (input) => dependencies.store.loadChildCloseoutFacts(input),
+        settleAggregate: (input) => dependencies.store.settleFrontendSplitAggregate({ ...input, prepareAggregate: dependencies.prepareAggregate }),
+    };
+    return new FrontendSplitOrchestrator(ports);
+}

package/dist/worker/console/index.js

@@ -11,6 +11,9 @@ export { createClosedResourceLoader, createInterviewResourceLoader, tryActivateT
 export { resolveSiblingLoopAgentBin } from "./sibling-controller.js";
 export { openConsoleAppData, defaultConsoleAppDataRoot } from "./app-data.js";
 export { OperationStore } from "./operation-store.js";
+export { createFrontendSplitOperationAdapter } from "./frontend-split-operation-adapter.js";
+export { createFrontendHumanDecisionAdapter } from "./frontend-human-decision-adapter.js";
+export { FrontendSplitTaskMaterializer } from "../materialize/frontend-split-task-materializer.js";
 export { createOperationEventStore } from "./operation-sse.js";
 export { DagConfirmationStore } from "./dag-confirmation.js";
 export { DraftStore } from "./draft-store.js";