@tea-agent/loop-agent 0.1.0

package/dist/shared/reference-context.js

@@ -0,0 +1,238 @@
+/**
+ * Feature-study reference indexing (compatibility-only).
+ * Used by `study init` and `reference index`.
+ */
+import { access, mkdir, readdir, readFile, stat, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+const DEFAULT_MAX_FILES_PER_REPO = 24;
+const DEFAULT_MAX_TOTAL_FILES = 48;
+const DEFAULT_MAX_FILE_BYTES = 512_000;
+export function isFeatureStudyTask(taskConfig) {
+    return taskConfig.taskKind === 'feature-study';
+}
+export function getReferenceManifestPath(repoRoot, taskId) {
+    return path.join(repoRoot, '.harness', 'tasks', taskId, 'source', 'references', 'index.json');
+}
+export async function readReferenceManifest(repoRoot, taskId) {
+    const manifestPath = getReferenceManifestPath(repoRoot, taskId);
+    try {
+        const raw = await readFile(manifestPath, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export async function buildReferenceIndex(repoRoot, taskId, taskConfig) {
+    const repos = taskConfig.referenceRepos ?? [];
+    const docs = taskConfig.referenceDocs ?? [];
+    if (repos.length === 0 && docs.length === 0) {
+        throw new Error('task.json has no referenceRepos or referenceDocs; add references before running reference index');
+    }
+    const maxPerRepo = taskConfig.referenceMaxFilesPerRepo ?? DEFAULT_MAX_FILES_PER_REPO;
+    const maxTotal = taskConfig.referenceMaxTotalFiles ?? DEFAULT_MAX_TOTAL_FILES;
+    let remaining = maxTotal;
+    const indexedRepos = [];
+    for (const repo of repos) {
+        const root = path.resolve(repo.path);
+        await assertReadableDirectory(root, `reference repo "${repo.name}"`);
+        const focusGlobs = repo.focusGlobs?.length ? repo.focusGlobs : ['**/*'];
+        const files = await collectRepoFiles(root, focusGlobs, Math.min(maxPerRepo, remaining));
+        remaining -= files.files.length;
+        indexedRepos.push({
+            name: repo.name,
+            root,
+            focusGlobs,
+            files: files.files,
+            truncated: files.truncated,
+        });
+        if (remaining <= 0)
+            break;
+    }
+    const indexedDocs = [];
+    for (const doc of docs) {
+        const absolutePath = path.resolve(doc.path);
+        await assertReadableFile(absolutePath, `reference doc "${doc.name ?? absolutePath}"`);
+        const fileStat = await stat(absolutePath);
+        indexedDocs.push({
+            name: doc.name ?? path.basename(absolutePath),
+            absolutePath,
+            sizeBytes: fileStat.size,
+        });
+    }
+    const index = {
+        generatedAt: new Date().toISOString(),
+        taskKind: taskConfig.taskKind,
+        repos: indexedRepos,
+        docs: indexedDocs,
+    };
+    const manifestPath = getReferenceManifestPath(repoRoot, taskId);
+    await mkdir(path.dirname(manifestPath), { recursive: true });
+    await writeFile(manifestPath, `${JSON.stringify(index, null, 2)}\n`, 'utf-8');
+    return index;
+}
+export async function getReferenceContextFiles(repoRoot, taskId, taskConfig) {
+    if (!isFeatureStudyTask(taskConfig)) {
+        return [];
+    }
+    const manifest = await readReferenceManifest(repoRoot, taskId);
+    if (!manifest) {
+        return [];
+    }
+    const files = [getReferenceManifestPath(repoRoot, taskId)];
+    for (const repo of manifest.repos) {
+        for (const file of repo.files) {
+            files.push(file.absolutePath);
+        }
+    }
+    for (const doc of manifest.docs) {
+        files.push(doc.absolutePath);
+    }
+    return uniqueKeepOrder(files);
+}
+function uniqueKeepOrder(items) {
+    const seen = new Set();
+    const result = [];
+    for (const item of items) {
+        if (seen.has(item))
+            continue;
+        seen.add(item);
+        result.push(item);
+    }
+    return result;
+}
+async function collectRepoFiles(root, focusGlobs, maxFiles) {
+    const candidates = await listFilesRecursive(root);
+    const matched = candidates
+        .map((absolutePath) => ({
+        absolutePath,
+        relativePath: path.relative(root, absolutePath).replace(/\\/g, '/'),
+    }))
+        .filter((entry) => focusGlobs.some((pattern) => matchGlob(pattern, entry.relativePath)))
+        .sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+    const files = [];
+    let truncated = false;
+    for (const entry of matched) {
+        if (files.length >= maxFiles) {
+            truncated = true;
+            break;
+        }
+        const fileStat = await stat(entry.absolutePath);
+        if (!fileStat.isFile())
+            continue;
+        if (fileStat.size > DEFAULT_MAX_FILE_BYTES)
+            continue;
+        const lower = entry.relativePath.toLowerCase();
+        if (lower.includes('/target/') || lower.includes('/node_modules/') || lower.includes('/.git/')) {
+            continue;
+        }
+        files.push({
+            relativePath: entry.relativePath,
+            absolutePath: entry.absolutePath,
+            sizeBytes: fileStat.size,
+        });
+    }
+    return { files, truncated };
+}
+async function listFilesRecursive(dir) {
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const nested = await Promise.all(entries.map(async (entry) => {
+        const target = path.join(dir, entry.name);
+        if (entry.isDirectory())
+            return listFilesRecursive(target);
+        return [target];
+    }));
+    return nested.flat();
+}
+export function matchGlob(pattern, relativePath) {
+    const normalizedPattern = pattern.replace(/\\/g, '/');
+    const normalizedPath = relativePath.replace(/\\/g, '/');
+    const regex = globToRegExp(normalizedPattern);
+    return regex.test(normalizedPath);
+}
+function globToRegExp(glob) {
+    let regex = '^';
+    for (let i = 0; i < glob.length; i += 1) {
+        const char = glob[i];
+        if (char === '*') {
+            const next = glob[i + 1];
+            if (next === '*') {
+                regex += '.*';
+                i += 1;
+                if (glob[i + 1] === '/') {
+                    i += 1;
+                }
+            }
+            else {
+                regex += '[^/]*';
+            }
+            continue;
+        }
+        if (char === '?') {
+            regex += '[^/]';
+            continue;
+        }
+        regex += char.replace(/[|\\{}()[\]^$+?.]/g, '\\$&');
+    }
+    regex += '$';
+    return new RegExp(regex);
+}
+async function assertReadableDirectory(target, label) {
+    try {
+        const fileStat = await stat(target);
+        if (!fileStat.isDirectory()) {
+            throw new Error(`${label} is not a directory: ${target}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes('is not a directory')) {
+            throw error;
+        }
+        throw new Error(`${label} not found or unreadable: ${target}`);
+    }
+}
+async function assertReadableFile(target, label) {
+    try {
+        await access(target);
+        const fileStat = await stat(target);
+        if (!fileStat.isFile()) {
+            throw new Error(`${label} is not a file: ${target}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes('is not a file')) {
+            throw error;
+        }
+        throw new Error(`${label} not found or unreadable: ${target}`);
+    }
+}
+export function parseReferenceRepoArg(value) {
+    const separator = value.indexOf(':');
+    if (separator <= 0) {
+        throw new Error(`invalid --reference-repo value "${value}"; expected name:/absolute/path`);
+    }
+    const name = value.slice(0, separator).trim();
+    const repoPath = value.slice(separator + 1).trim();
+    if (!name || !repoPath) {
+        throw new Error(`invalid --reference-repo value "${value}"; expected name:/absolute/path`);
+    }
+    return { name, path: repoPath, focusGlobs: [] };
+}
+export function parseReferenceDocArg(value) {
+    const separator = value.indexOf(':');
+    if (separator <= 0) {
+        return { name: path.basename(value), path: value };
+    }
+    const name = value.slice(0, separator).trim();
+    const docPath = value.slice(separator + 1).trim();
+    if (!name || !docPath) {
+        throw new Error(`invalid --reference-doc value "${value}"; expected name:/absolute/path or /absolute/path`);
+    }
+    return { name, path: docPath };
+}

package/dist/shared/timeout-policy.js

@@ -0,0 +1,19 @@
+import { DEFAULT_TIMEOUT_MS, MAX_ALLOWED_TIMEOUT_MS } from "../executors/pi-executor.js";
+export { MAX_ALLOWED_TIMEOUT_MS };
+/**
+ * Clamp timeout values for Pi steps. Undefined or non-positive values fall back to
+ * DEFAULT_TIMEOUT_MS so task-level invalid values do not disable Pi execution timeouts.
+ */
+export function clampTimeout(value, fallbackMs = DEFAULT_TIMEOUT_MS) {
+    const effective = value !== undefined && value > 0 ? value : fallbackMs;
+    return Math.min(effective, MAX_ALLOWED_TIMEOUT_MS);
+}
+/**
+ * Clamp only the maximum timeout while preserving 0/negative values.
+ *
+ * Verify commands historically treat timeoutMs <= 0 as "no timeout" in
+ * executeCommand(), so verify must not use clampTimeout()'s fallback semantics.
+ */
+export function clampTimeoutMaxOnly(value) {
+    return Math.min(value, MAX_ALLOWED_TIMEOUT_MS);
+}

package/dist/shared/timeout.js

@@ -0,0 +1 @@
+export * from "./timeout-policy.js";

package/dist/shared/types.js

@@ -0,0 +1,5 @@
+/** Compatibility barrel — prefer domain-specific type modules for new definitions. */
+export * from "../governance/manifest-types.js";
+export * from "../task/workflow-state-types.js";
+export * from "../task/config-types.js";
+export * from "../adapters/types.js";

package/dist/task/config-types.js

@@ -0,0 +1,97 @@
+import { z } from "zod";
+import { taskExecutorSchema } from "../governance/manifest-types.js";
+export const taskFlowSchema = z.enum([
+    "auto",
+    "micro",
+    "standard",
+    "spec",
+    "loop",
+    "feature-study",
+]);
+export const taskKindSchema = z.enum(["standard", "feature-study"]);
+export const referenceRepoConfigSchema = z.object({
+    name: z.string().min(1),
+    path: z.string().min(1),
+    focusGlobs: z.array(z.string().min(1)).optional().default([]),
+});
+export const referenceDocConfigSchema = z.object({
+    name: z.string().min(1).optional(),
+    path: z.string().min(1),
+});
+export const taskComplexitySchema = z.enum(["small", "medium", "large"]);
+export const contextProfileSchema = z.enum(["full", "slim"]);
+export const piSubagentModeSchema = z.enum(["off", "analyze-plan", "full"]);
+export const verifyModeSchema = z.enum(["parallel", "serial"]);
+export const verifyPresetSchema = z.enum(["auto", "quick", "standard", "full"]);
+export const verifyQuotaSchema = z.enum(["1", "3", "full"]);
+export const dagVerifyStrategySchema = z
+    .object({
+    intermediateQuota: verifyQuotaSchema.optional(),
+    finalQuota: z.literal("full").optional().default("full"),
+    focusedCommandSource: z
+        .literal("adapter")
+        .optional()
+        .default("adapter"),
+})
+    .optional();
+export const loopAutoWritePolicySchema = z.enum([
+    "off",
+    "approval-required",
+    "enabled",
+]);
+export const convergenceConfigSchema = z.object({
+    enabled: z.boolean().optional().default(false),
+    maxPasses: z.number().int().positive().optional().default(3),
+    stopOnVerdictPass: z.boolean().optional().default(true),
+    stopOnHardVerifyPass: z.boolean().optional().default(true),
+    pauseOnRegression: z.boolean().optional().default(true),
+});
+export const taskConfigSchema = z.object({
+    taskId: z.string(),
+    title: z.string(),
+    sourceFiles: z.array(z.string()),
+    /** standard: 本仓库需求实现；feature-study: 参考外部代码特性并在目标仓库落地 */
+    taskKind: taskKindSchema.optional().default("standard"),
+    referenceRepos: z.array(referenceRepoConfigSchema).optional().default([]),
+    referenceDocs: z.array(referenceDocConfigSchema).optional().default([]),
+    referenceMaxFilesPerRepo: z.number().int().positive().optional(),
+    referenceMaxTotalFiles: z.number().int().positive().optional(),
+    allowedPaths: z.array(z.string()).optional().default([]),
+    forbiddenPaths: z.array(z.string()).optional().default([]),
+    hardConstraints: z.array(z.string()).optional().default([]),
+    autoCommitAfterVerify: z.boolean().optional().default(true),
+    autoCommitMessage: z.string().optional().default(""),
+    /** Explicit reason that a medium/large task could not use DAG before loop cursor-fix. */
+    dagFallbackReason: z.string().optional(),
+    /** full: attach governance bundle; slim: analyze/plan 只带最少仓库上下文（source + harness 等） */
+    contextProfile: contextProfileSchema.optional().default("full"),
+    timeoutMs: z.number().int().positive().optional(),
+    flow: taskFlowSchema.optional().default("auto"),
+    complexity: taskComplexitySchema.optional().default("medium"),
+    verifyMode: verifyModeSchema.optional().default("parallel"),
+    verifyPreset: verifyPresetSchema.optional().default("auto"),
+    /** Verification selection policy. Intermediate loops may use quota; final gates still run full required verification. */
+    verifyQuota: verifyQuotaSchema.optional().default("full"),
+    /** DAG supervised verify strategy. Final quota is fixed to full; intermediate quota may reduce cost. */
+    dagVerifyStrategy: dagVerifyStrategySchema,
+    verifyRetryCount: z.number().int().min(0).optional().default(0),
+    verifyFailFast: z.boolean().optional().default(false),
+    contextMaxFiles: z.number().int().min(0).optional().default(0),
+    maxFixLoops: z.number().int().min(0).optional().default(2),
+    /** Supervised DAG convergence is opt-in until runtime smoke evidence is stronger. */
+    convergence: convergenceConfigSchema.optional().default({ enabled: false }),
+    /** Outer loop auto mode never writes by default; cursor-fix requires this policy plus bounded path guards. */
+    loopAutoWritePolicy: loopAutoWritePolicySchema.optional().default("off"),
+    requireRetrospective: z.boolean().optional().default(false),
+    /** inherit: use host shell env; clean: sanitized env for deterministic verify */
+    verifyEnv: z.enum(["inherit", "clean"]).optional().default("clean"),
+    /** Max legacy goal continuation attempts before auto-pausing an active goal */
+    maxGoalContinuationsPerRun: z.number().int().positive().optional().default(5),
+    /** Pi subagent assisted mode: 'off' (default), 'analyze-plan', or 'full' */
+    piSubagentMode: piSubagentModeSchema.optional().default("off"),
+    /** Leaf executor: default pi; cursor requires delegate + worktree isolation */
+    executor: taskExecutorSchema.optional().default("pi"),
+    /** Cursor model override (e.g. gpt-5.5); falls back to harness executors.cursor.defaultModel */
+    cursorModel: z.string().optional(),
+    notes: z.string().optional().default(""),
+});

package/dist/task/config.js

@@ -0,0 +1,2 @@
+export * from "./config-types.js";
+export * from "./workflow-state-types.js";

package/dist/task/delegate.js

@@ -0,0 +1,220 @@
+import { access, mkdir, readFile, symlink, unlink, writeFile } from 'node:fs/promises';
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { initializeArtifacts } from '../shared/artifacts-core.js';
+import { createWorktree } from './worktree.js';
+import { loadHarnessManifest } from '../governance/harness.js';
+import { getTaskPaths, loadTaskConfig } from './runtime.js';
+import { copyDir } from '../records/harvest.js';
+import { saveWorkflowState } from './state.js';
+import { workflowStateSchema } from '../shared/types.js';
+import { assertCursorExecutorAvailable, resolveTaskExecutor, validateCursorTaskPreflight } from '../executors/config-core.js';
+import { resolveDelegateExecutionMode } from '../executors/cursor-execution-log.js';
+/**
+ * Atomic delegation: validate source → check conflicts → create worktree →
+ * sync source → optionally symlink node_modules.
+ *
+ * Execution runs in-process for Cursor SDK; Pi worktrees are prepared for manual DAG follow-up.
+ */
+export async function delegateTask(repoRoot, manifest, taskId, opts = {}) {
+    const symlinkEnabled = opts.symlinkNodeModules !== false;
+    await validateSourceMaterials(repoRoot, taskId);
+    const taskConfig = await loadTaskConfig(repoRoot, taskId);
+    const effectiveManifest = manifest ?? (await loadHarnessManifest(repoRoot));
+    const executor = resolveTaskExecutor(taskConfig, opts.executor);
+    if (executor === 'cursor') {
+        assertCursorExecutorAvailable(effectiveManifest);
+        validateCursorTaskPreflight(taskConfig);
+    }
+    await validateNoConflicts(repoRoot, taskId, opts.branch);
+    const worktree = await createWorktree(repoRoot, effectiveManifest, {
+        taskId,
+        branch: opts.branch,
+        base: opts.base,
+    });
+    await syncSourceToWorktree(repoRoot, taskId, worktree.path, executor);
+    let symlinkedNodeModules = false;
+    if (symlinkEnabled) {
+        symlinkedNodeModules = await setupNodeModulesSymlink(repoRoot, worktree.path);
+    }
+    const sessionName = `task-${taskId}`;
+    return {
+        taskId,
+        sessionName,
+        worktreePath: worktree.path,
+        branch: worktree.branch,
+        baseBranch: worktree.base,
+        symlinkedNodeModules,
+        executor,
+        executionMode: resolveDelegateExecutionMode(executor),
+    };
+}
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+async function validateSourceMaterials(repoRoot, taskId) {
+    const { taskConfigPath, sourceDir } = getTaskPaths(repoRoot, taskId);
+    try {
+        await access(taskConfigPath);
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            throw new Error(`source validation failed: task.json not found at ${taskConfigPath}`);
+        }
+        throw err;
+    }
+    try {
+        await loadTaskConfig(repoRoot, taskId);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(`source validation failed: task.json is invalid at ${taskConfigPath}: ${msg}`);
+    }
+    await assertNonEmptyFile(path.join(sourceDir, '需求.md'), 'source validation failed: 需求.md');
+    await assertNonEmptyFile(path.join(sourceDir, '执行约束.md'), 'source validation failed: 执行约束.md');
+}
+async function assertNonEmptyFile(filePath, errPrefix) {
+    let content;
+    try {
+        content = await readFile(filePath, 'utf-8');
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            throw new Error(`${errPrefix}: file not found at ${filePath}`);
+        }
+        throw err;
+    }
+    if (content.trim().length === 0) {
+        throw new Error(`${errPrefix}: file is empty at ${filePath}`);
+    }
+}
+async function validateNoConflicts(repoRoot, taskId, branch) {
+    const targetBranch = branch ?? `task/${taskId}`;
+    const existing = await tryRunGit(repoRoot, ['branch', '--list', targetBranch]);
+    if (existing && existing.trim().length > 0) {
+        console.error(`[delegate] warning: branch "${targetBranch}" already exists; will reuse it for the worktree.`);
+    }
+}
+async function syncSourceToWorktree(repoRoot, taskId, worktreePath, executor) {
+    const srcPaths = getTaskPaths(repoRoot, taskId);
+    const destPaths = getTaskPaths(worktreePath, taskId);
+    const destTaskDir = destPaths.taskDir;
+    const destSourceDir = path.join(destTaskDir, 'source');
+    const destTaskConfigPath = path.join(destTaskDir, 'task.json');
+    await mkdir(destSourceDir, { recursive: true });
+    await copyDir(srcPaths.sourceDir, destSourceDir);
+    const rawJson = await readFile(srcPaths.taskConfigPath, 'utf-8');
+    const parsedTaskConfig = JSON.parse(rawJson);
+    parsedTaskConfig.executor = executor;
+    await mkdir(path.dirname(destTaskConfigPath), { recursive: true });
+    await writeFile(destTaskConfigPath, `${JSON.stringify(parsedTaskConfig, null, 2)}\n`, 'utf-8');
+    await mkdir(destPaths.logsDir, { recursive: true });
+    await initializeArtifacts(destTaskDir);
+    await writeFile(path.join(destPaths.logsDir, 'executor.jsonl'), '', 'utf-8');
+    await writeFile(path.join(destPaths.logsDir, 'decisions.jsonl'), '', 'utf-8');
+    const state = await loadOrCreateWorkflowState(srcPaths.statePath, taskId, executor);
+    await saveWorkflowState(destPaths.statePath, state);
+}
+async function loadOrCreateWorkflowState(statePath, taskId, executor) {
+    try {
+        const raw = await readFile(statePath, 'utf-8');
+        return workflowStateSchema.parse(JSON.parse(raw));
+    }
+    catch {
+        const now = new Date().toISOString();
+        return {
+            taskId,
+            status: 'draft',
+            currentStep: 'analyze',
+            completedSteps: [],
+            lastUpdated: now,
+            executor: {
+                name: executor,
+                mode: executor === 'cursor' ? 'sdk' : 'json',
+            },
+            artifacts: {
+                analysis: false,
+                plan: false,
+                modifyLog: false,
+                verifyResult: false,
+                retrospective: false,
+            },
+            sourceState: {
+                currentHash: '',
+                plannedHash: '',
+                trackedFiles: [],
+                lastCheckedAt: '',
+                lastPlannedAt: '',
+                lastPlannedStep: null,
+                stalePlan: false,
+            },
+            goal: {
+                objective: '',
+                status: 'paused',
+                tokenBudget: null,
+                tokensUsed: 0,
+                timeUsedSeconds: 0,
+                pendingObjectiveUpdatedNotice: false,
+                pendingBudgetLimitNotice: false,
+                continuationRuns: 0,
+                createdAt: '',
+                updatedAt: now,
+            },
+            decisionLog: [],
+        };
+    }
+}
+async function setupNodeModulesSymlink(repoRoot, worktreePath) {
+    let linkedAny = false;
+    const hostNodeModules = path.join(repoRoot, 'node_modules');
+    const worktreeNodeModules = path.join(worktreePath, 'node_modules');
+    const linkedLoopAgent = await linkIfExists(hostNodeModules, worktreeNodeModules, `[delegate] warning: host node_modules not found at ${hostNodeModules}; worktree may need npm install.`);
+    linkedAny = linkedAny || linkedLoopAgent;
+    return linkedAny;
+}
+async function linkIfExists(hostPath, worktreePath, missingWarning) {
+    try {
+        await access(hostPath);
+    }
+    catch {
+        console.error(missingWarning);
+        return false;
+    }
+    try {
+        await unlink(worktreePath);
+    }
+    catch (err) {
+        const code = err.code;
+        if (code !== 'ENOENT') {
+            try {
+                await access(worktreePath);
+                return true;
+            }
+            catch {
+                // fall through and attempt to create symlink
+            }
+        }
+    }
+    await mkdir(path.dirname(worktreePath), { recursive: true });
+    const relativeTarget = path.relative(path.dirname(worktreePath), hostPath);
+    await symlink(relativeTarget, worktreePath, process.platform === 'win32' ? 'junction' : 'dir');
+    return true;
+}
+async function tryRunGit(repoRoot, args) {
+    return new Promise((resolve) => {
+        const child = spawn('git', args, {
+            cwd: repoRoot,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        const out = [];
+        child.stdout?.on('data', (chunk) => out.push(chunk));
+        child.on('error', () => resolve(null));
+        child.on('close', (code) => {
+            if (code !== 0) {
+                resolve(null);
+                return;
+            }
+            resolve(Buffer.concat(out).toString('utf-8'));
+        });
+    });
+}

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,9 @@
+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";

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/paths.js

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