@tea-agent/loop-agent 0.1.0-fe-test.0

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

@@ -0,0 +1,570 @@
+/**
+ * Generation-time frontend project capability discovery (M5/M6).
+ * 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 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";
+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);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 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;
+}
+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 + "/"));
+    };
+    for (const specDir of 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.
+    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)).sort();
+        }
+        catch {
+            return;
+        }
+        for (const name of entries) {
+            const full = path.join(dir, name);
+            try {
+                const info = await stat(full);
+                if (info.isDirectory())
+                    await walk(full, depth + 1);
+                else if (OPENSPEC_SPEC_EXT_RE.test(name)) {
+                    const rel = path.relative(repoRoot, full).replace(/\\/g, "/");
+                    if (isExcluded(rel)) {
+                        excludedGovernanceCount++;
+                    }
+                    else {
+                        collected.push(rel);
+                    }
+                }
+            }
+            catch {
+                // skip
+            }
+        }
+    }
+}
+/**
+ * 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)",
+        `Framework: ${capability.framework}${capability.frameworkVersion ? `@${capability.frameworkVersion}` : ""}`,
+        `Evidence: ${capability.evidencePaths.join(", ") || "(none)"}`,
+        "Rules: openspec specs and task sources outrank adapter tips; do not invent APIs for unknown versions; lockfile-only is not enough.",
+    ];
+    if (capability.framework === "react") {
+        lines.push("React adapter: prefer function components + hooks; reuse existing Testing Library / Vitest patterns; do not introduce new state libs without authorization.");
+    }
+    else if (capability.framework === "next") {
+        lines.push("Next.js adapter: respect App vs Pages router from evidence; keep server/client boundaries explicit; avoid guessing cache/navigation APIs across major versions.");
+    }
+    else if (capability.framework === "vue") {
+        lines.push("Vue adapter: prefer Composition API if project already uses it; reuse Pinia/Vue Router/Vue Query only when evidenced; Vitest + Vue Test Utils when present.");
+    }
+    else {
+        lines.push("Unknown framework: use generic frontend-implementation skill only; do not assume React/Vue/Next APIs.");
+    }
+    if (capability.a11y.status === "present") {
+        lines.push(`A11y tools present: ${capability.a11y.tools.join(", ")}. Report static/component-level evidence only; Browser a11y remains not-run.`);
+    }
+    else {
+        lines.push("A11y tools: absent/unknown — mark a11y checks unavailable/not-run; do not install tools.");
+    }
+    if (capability.designEvidence.normativePaths.length) {
+        lines.push(`Normative design paths: ${capability.designEvidence.normativePaths.slice(0, 8).join(", ")}`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Discover frontend project capability from repo root.
+ * Strong evidence: package.json direct deps + config/bootstrap files.
+ */
+export async function discoverFrontendProjectCapability(repoRoot) {
+    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 designEvidence = buildDesignEvidence(discovery.paths);
+        const base = {
+            schemaVersion: 1,
+            framework: "unknown",
+            state: [],
+            dataFetching: [],
+            componentLibrary: [],
+            style: [],
+            testRunner: [],
+            mock: [],
+            a11y: { status: "unknown", tools: [], evidencePaths: [] },
+            evidencePaths: discovery.paths.slice(0, 5),
+            reasons: ["package.json missing or unreadable"],
+            designEvidence,
+            openspecDiscovery: toOpenspecDiscovery(discovery, designEvidence),
+        };
+        if (discovery.paths.length) {
+            base.reasons.push(`openspec spec files discovered: ${discovery.paths.slice(0, 5).join(", ")}`);
+        }
+        return { ...base, adapterGuidance: buildAdapterGuidance(base) };
+    }
+    evidencePaths.push("package.json");
+    const deps = allDeps(pkgRaw);
+    // Lockfile alone does not activate
+    for (const lock of ["package-lock.json", "pnpm-lock.yaml", "yarn.lock"]) {
+        if (await exists(path.join(repoRoot, lock))) {
+            reasons.push(`${lock} present but not used as sole activation evidence`);
+        }
+    }
+    let framework = "unknown";
+    let frameworkVersion;
+    const configHits = [];
+    const nextConfig = ["next.config.js", "next.config.mjs", "next.config.ts"];
+    for (const name of nextConfig) {
+        if (await exists(path.join(repoRoot, name))) {
+            configHits.push(name);
+            evidencePaths.push(name);
+        }
+    }
+    if (hasDep(deps, "next") && configHits.some((c) => c.startsWith("next"))) {
+        framework = "next";
+        frameworkVersion = deps.next?.replace(/^[^\d]*/, "");
+        reasons.push("next dependency + next.config*");
+    }
+    else if (hasDep(deps, "next") && configHits.length === 0) {
+        // dep without config: still weak if only transitive — require direct dep
+        framework = "next";
+        frameworkVersion = deps.next?.replace(/^[^\d]*/, "");
+        reasons.push("next direct dependency (config not found)");
+        evidencePaths.push("package.json#dependencies.next");
+    }
+    if (framework === "unknown") {
+        const vueConfig = ["vite.config.ts", "vite.config.js", "vue.config.js"];
+        let vueCfg = false;
+        for (const name of vueConfig) {
+            if (await exists(path.join(repoRoot, name))) {
+                vueCfg = true;
+                evidencePaths.push(name);
+            }
+        }
+        if (hasDep(deps, "vue") && (vueCfg || hasDep(deps, "nuxt"))) {
+            framework = "vue";
+            frameworkVersion = deps.vue?.replace(/^[^\d]*/, "");
+            reasons.push("vue direct dependency + config/tooling");
+        }
+    }
+    if (framework === "unknown" && hasDep(deps, "react")) {
+        // Need config or jsx tooling — not lockfile-only
+        const reactCfg = (await exists(path.join(repoRoot, "vite.config.ts"))) ||
+            (await exists(path.join(repoRoot, "vite.config.js"))) ||
+            (await exists(path.join(repoRoot, "webpack.config.js"))) ||
+            hasDep(deps, "react-scripts") ||
+            hasDep(deps, "vite");
+        if (reactCfg) {
+            framework = "react";
+            frameworkVersion = deps.react?.replace(/^[^\d]*/, "");
+            reasons.push("react direct dependency + bundler/tooling evidence");
+            evidencePaths.push("package.json#dependencies.react");
+        }
+        else {
+            reasons.push("react listed but no strong config/bundler evidence — framework=unknown");
+        }
+    }
+    const state = [];
+    for (const lib of [
+        "redux",
+        "@reduxjs/toolkit",
+        "zustand",
+        "jotai",
+        "recoil",
+        "pinia",
+        "vuex",
+    ]) {
+        if (hasDep(deps, lib))
+            state.push(lib);
+    }
+    const dataFetching = [];
+    for (const lib of [
+        "@tanstack/react-query",
+        "swr",
+        "axios",
+        "@tanstack/vue-query",
+        "ofetch",
+    ]) {
+        if (hasDep(deps, lib))
+            dataFetching.push(lib);
+    }
+    const componentLibrary = [];
+    for (const lib of [
+        "antd",
+        "@mui/material",
+        "element-plus",
+        "vuetify",
+        "@chakra-ui/react",
+    ]) {
+        if (hasDep(deps, lib))
+            componentLibrary.push(lib);
+    }
+    const style = [];
+    for (const lib of [
+        "tailwindcss",
+        "sass",
+        "less",
+        "styled-components",
+        "@emotion/react",
+    ]) {
+        if (hasDep(deps, lib))
+            style.push(lib);
+    }
+    const testRunner = [];
+    for (const lib of [
+        "vitest",
+        "jest",
+        "@testing-library/react",
+        "@testing-library/vue",
+        "@playwright/test",
+    ]) {
+        if (hasDep(deps, lib))
+            testRunner.push(lib);
+    }
+    const mock = [];
+    for (const lib of ["msw", "nock", "miragejs"]) {
+        if (hasDep(deps, lib))
+            mock.push(lib);
+    }
+    const a11yTools = [];
+    const a11yEvidence = [];
+    for (const lib of [
+        "eslint-plugin-jsx-a11y",
+        "@axe-core/react",
+        "jest-axe",
+        "vitest-axe",
+        "axe-core",
+    ]) {
+        if (hasDep(deps, lib)) {
+            a11yTools.push(lib);
+            a11yEvidence.push(`package.json#${lib}`);
+        }
+    }
+    const a11y = {
+        status: (a11yTools.length > 0 ? "present" : "absent"),
+        tools: a11yTools,
+        evidencePaths: a11yEvidence,
+    };
+    let router;
+    if (hasDep(deps, "react-router-dom") || hasDep(deps, "react-router")) {
+        router = "react-router";
+    }
+    if (framework === "next")
+        router = router ?? "next-router";
+    if (hasDep(deps, "vue-router"))
+        router = "vue-router";
+    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,
+        frameworkVersion,
+        router,
+        state,
+        dataFetching,
+        componentLibrary,
+        style,
+        testRunner,
+        mock,
+        a11y,
+        packageManager: (await exists(path.join(repoRoot, "pnpm-lock.yaml")))
+            ? "pnpm"
+            : (await exists(path.join(repoRoot, "yarn.lock")))
+                ? "yarn"
+                : "npm",
+        evidencePaths: [...new Set(evidencePaths)],
+        reasons,
+        designEvidence,
+        openspecDiscovery: toOpenspecDiscovery(discovery, designEvidence),
+    };
+    return { ...base, adapterGuidance: buildAdapterGuidance(base) };
+}

package/dist/task/goal-audit.js

@@ -0,0 +1,51 @@
+import { readFile } from 'node:fs/promises';
+import { extractRequirementsFromMarkdown, requirementCoverageFailureReasons, runRequirementCoverageAudit, } from '../governance/requirement-coverage.js';
+import { getTaskPaths, getTaskStatus } from './runtime.js';
+const GOAL_SCOPE_START = /<!--\s*goal-scope\s*-->/i;
+const GOAL_SCOPE_END = /<!--\s*\/goal-scope\s*-->/i;
+export function extractGoalAuditScope(text) {
+    const start = text.search(GOAL_SCOPE_START);
+    const end = text.search(GOAL_SCOPE_END);
+    if (start >= 0 && end > start) {
+        const scoped = text.slice(start, end);
+        return scoped.replace(GOAL_SCOPE_START, '').trim();
+    }
+    return text;
+}
+export function findUncheckedChecklistItems(text) {
+    return /-\s*\[\s\]/.test(text);
+}
+export async function runGoalCompletionAudit(repoRoot, taskId) {
+    const state = await getTaskStatus(repoRoot, taskId);
+    const reasons = [];
+    if (!state.artifacts.verifyResult) {
+        reasons.push('missing verify artifact');
+    }
+    if (!state.completedSteps.includes('verify')) {
+        reasons.push('verify step is not marked completed');
+    }
+    const requirementIssues = await scanUncheckedRequirementItems(repoRoot, taskId);
+    reasons.push(...requirementIssues);
+    const coverageAudit = await runRequirementCoverageAudit(repoRoot, taskId);
+    reasons.push(...requirementCoverageFailureReasons(coverageAudit));
+    return {
+        ok: reasons.length === 0,
+        reasons,
+    };
+}
+async function scanUncheckedRequirementItems(repoRoot, taskId) {
+    const requirementPath = `${getTaskPaths(repoRoot, taskId).sourceDir}/需求.md`;
+    let text = '';
+    try {
+        text = await readFile(requirementPath, 'utf-8');
+    }
+    catch {
+        return [];
+    }
+    const { requirements } = extractRequirementsFromMarkdown(text);
+    const uncheckedInScope = requirements.filter((item) => item.source === 'checklist' && item.checked === false);
+    if (uncheckedInScope.length === 0) {
+        return [];
+    }
+    return uncheckedInScope.map((item) => `source/需求.md has unchecked in-scope checklist item: ${item.label}`);
+}

package/dist/task/goal-policy.js

@@ -0,0 +1,8 @@
+export function isGoalsFeatureEnabled(manifest) {
+    return manifest.features?.goals !== false;
+}
+export function assertGoalsFeatureEnabled(manifest) {
+    if (!isGoalsFeatureEnabled(manifest)) {
+        throw new Error('goals feature is disabled in harness.json (features.goals=false)');
+    }
+}

package/dist/task/goal.js

@@ -0,0 +1,3 @@
+export { clearTaskGoal, consumeTaskGoalNotices, getTaskGoal, incrementGoalContinuationRuns, markTaskGoalComplete, recordTaskGoalProgress, setTaskGoal, updateTaskGoalStatus, } from "./runtime.js";
+export * from "./goal-audit.js";
+export * from "./goal-policy.js";

package/dist/task/ids.js

@@ -0,0 +1 @@
+export { CANONICAL_TASK_ID_PATTERN, formatLocalBusinessDate, formatLocalCompactDate, validateNewTaskId, } from "./runtime.js";

package/dist/task/index.js

@@ -0,0 +1,12 @@
+export * from "./ids.js";
+export * from "./paths.js";
+export * from "./source-state.js";
+export * from "./lifecycle.js";
+export * from "./goal.js";
+export * from "./subagent-guidance.js";
+export * from "./runtime.js";
+export * from "./config.js";
+export * from "./worktree.js";
+export * as taskContract from "./contract/index.js";
+export * as taskOperator from "./operator/index.js";
+export * from "./contract/index.js";

package/dist/task/lifecycle.js

@@ -0,0 +1 @@
+export { createTask, getNextStep, getSupportedNextCommand, getTaskStatus, markStepCompleted, markTaskCompleted, markTaskFailed, markTaskRunning, markVerifyGoalPending, resolveTaskFlow, shouldRunRetrospective, } from "./runtime.js";

package/dist/task/operator/capabilities.js

@@ -0,0 +1,6 @@
+/**
+ * Compatibility re-export — canonical capabilities document lives in
+ * src/shared/operator (includes Console negotiation `dag` block).
+ * No independent projection / dual implementation.
+ */
+export { buildOperatorCapabilitiesDocument, } from "../../shared/operator/capabilities.js";

package/dist/task/operator/envelope.js

@@ -0,0 +1,2 @@
+/** Compatibility re-export — canonical envelope lives in src/shared/operator. */
+export { buildOperatorResult, operatorSucceeded, operatorFailed, writeOperatorJson, processExitCodeForOutcome, } from "../../shared/operator/envelope.js";

package/dist/task/operator/index.js

@@ -0,0 +1,5 @@
+/** Compatibility barrel — re-exports src/shared/operator for task-adjacent imports. */
+export * from "./types.js";
+export * from "./envelope.js";
+export * from "./registry.js";
+export * from "./capabilities.js";

package/dist/task/operator/registry.js

@@ -0,0 +1,2 @@
+/** Compatibility re-export — canonical registry lives in src/shared/operator. */
+export { OPERATOR_OUTCOMES_V1, OPERATOR_ERROR_CODES_V1, OPERATOR_ERROR_CODE_SET, isOperatorErrorCode, } from "../../shared/operator/registry.js";

package/dist/task/operator/types.js

@@ -0,0 +1 @@
+export {};

package/dist/task/paths.js

@@ -0,0 +1 @@
+export { getTaskDir, getTaskPaths, listTaskSourceFiles, } from "./runtime.js";