@tea-agent/loop-agent 0.43.0-next.17 → 0.43.0-next.3

package/dist/worker/console/workspace-initialization.js

@@ -1,209 +0,0 @@
-import { lstat, readFile } from "node:fs/promises";
-import path from "node:path";
-import { acquireUpdateLock, updateLockPath } from "../../shared/update/state.js";
-import os from "node:os";
-import { TERMINAL_OPERATION_STATES } from "../../infrastructure/console/operation-store.js";
-import { readInitRuntimeActivity } from "../observability/init-runtime-activity.js";
-const record = (value) => {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        throw new Error("初始化检查返回了无效数据");
-    return value;
-};
-const entries = (value) => {
-    if (!Array.isArray(value))
-        throw new Error("初始化检查缺少状态清单");
-    return value.map(record);
-};
-/** A single registered workspace owns checks, CLI cwd and durable operations. */
-export class WorkspaceInitializationService {
-    options;
-    cached;
-    pending;
-    activeOperationId;
-    generation = 0;
-    constructor(options) {
-        this.options = options;
-    }
-    snapshot(state, message, pendingPaths = []) {
-        const { workspaceId, name, repoRoot } = this.options;
-        return { workspaceId, name, displayPath: repoRoot, state, message, pendingPaths, canUpdate: false, pendingItems: [] };
-    }
-    async jsonFile(relative) {
-        const file = path.join(this.options.repoRoot, relative);
-        try {
-            const stat = await lstat(file);
-            if (!stat.isFile() || stat.isSymbolicLink())
-                throw new Error(`${relative} 不是普通配置文件`);
-            return record(JSON.parse(await readFile(file, "utf8")));
-        }
-        catch (error) {
-            if (error.code === "ENOENT")
-                return undefined;
-            throw new Error(`${relative} 无法读取，请检查文件内容与权限`);
-        }
-    }
-    async command(args, name) {
-        const result = await this.options.client.run(args, {
-            cwd: this.options.repoRoot, artifactName: `workspace-init-${name}`,
-            expectJson: true, timeoutMs: 120_000,
-        });
-        if (!result.ok || result.exitCode !== 0 || result.timedOut || result.parseFailure) {
-            throw new Error(`工作区配置${name === "check" ? "检查" : "操作"}失败，请查看操作记录或检查模型与初始化配置`);
-        }
-        return record(result.json);
-    }
-    async catalog() {
-        const catalog = await this.command(["init", "model-catalog", "--json"], "models");
-        return entries(catalog.models).filter(item => item.eligibleForHarness === true && typeof item.reference === "string")
-            .map(item => ({ reference: item.reference, name: typeof item.name === "string" ? item.name : item.reference }));
-    }
-    async inspect() {
-        try {
-            try {
-                const harnessDir = await lstat(path.join(this.options.repoRoot, ".harness"));
-                if (!harnessDir.isDirectory() || harnessDir.isSymbolicLink())
-                    throw new Error(".harness 必须是仓库内的普通目录");
-            }
-            catch (error) {
-                if (error.code !== "ENOENT")
-                    throw error;
-            }
-            const surface = await this.jsonFile(".harness/init-surface.json");
-            const harness = await this.jsonFile("harness.json");
-            if (surface && (surface.schemaVersion !== 1 || !surface.files || typeof surface.files !== "object" || Array.isArray(surface.files))) {
-                throw new Error("初始化记录不完整，请检查 .harness/init-surface.json");
-            }
-            if (!surface && !harness) {
-                const snapshot = this.snapshot("uninitialized", "此仓库尚未初始化。初始化后可使用项目任务与工作流配置。");
-                try {
-                    snapshot.models = await this.catalog();
-                }
-                catch {
-                    snapshot.message = "此仓库尚未初始化；可用模型读取失败，请检查模型设置后重新检查。";
-                }
-                return snapshot;
-            }
-            const report = await this.command(["init", "check-update", "--json"], "check");
-            if (!["recorded", "inferred-baseline", "missing"].includes(String(report.surfaceState)) || typeof report.ok !== "boolean") {
-                throw new Error("初始化检查返回了未知状态");
-            }
-            const actions = entries(report.deterministicActions);
-            const merges = entries(report.modelMergeTasks);
-            const decisions = entries(report.humanDecisions);
-            const pendingItems = [];
-            for (const [kind, list] of [["safe-update", actions], ["merge", merges], ["confirmation", decisions]]) {
-                for (const item of list) {
-                    if (typeof item.path !== "string")
-                        continue;
-                    const detail = typeof item.reason === "string" ? item.reason : undefined;
-                    const baseline = item.type === "bootstrap-surface";
-                    const itemKind = baseline ? "confirmation" : kind;
-                    const reason = baseline ? "缺少可靠的初始化记录，不能直接判断哪些内容可覆盖。"
-                        : kind === "safe-update" ? "此项可由程序安全更新，保留项目自定义内容。"
-                            : kind === "merge" ? "现有内容与新版初始化模板不同，需要保留项目配置后合并。"
-                                : /not a directory/.test(detail ?? "") ? "这里需要一个目录，但当前路径被文件占用。"
-                                    : /removed.*local changes/.test(detail ?? "") ? "新版不再使用此文件，但它包含本地修改，需要决定保留还是删除。"
-                                        : /target path.*already exists/.test(detail ?? "") ? "迁移目标已有不同内容，需要确认两份文件如何保留。"
-                                            : "此项无法安全自动处理，请先核对检查详情，再确定处理方式。";
-                    pendingItems.push({ path: item.path, kind: itemKind, reason,
-                        nextStep: itemKind === "safe-update" ? "点击更新按钮即可处理。"
-                            : itemKind === "merge" ? "可将下方处理说明交给智能体合并；只有需求冲突时才需你确认。"
-                                : "将处理说明交给智能体检查；需要取舍时确认方案，处理后重新检查。",
-                        ...(detail ? { detail } : {}) });
-                }
-            }
-            const modelsReady = record(report.modelReadiness).status === "ready";
-            if (!modelsReady)
-                pendingItems.push({ path: "模型配置", kind: "model",
-                    reason: "当前模型配置或认证尚未就绪，更新文件不能解决此问题。",
-                    nextStep: "检查模型定义及提供商认证，保留仍可用的模型配置，完成后重新检查。" });
-            const canUpdate = pendingItems.some(item => item.kind === "safe-update");
-            const needsAttention = pendingItems.some(item => item.kind !== "safe-update") || !report.ok || report.surfaceState !== "recorded" && !canUpdate;
-            if (needsAttention || canUpdate) {
-                const safeCount = pendingItems.filter(item => item.kind === "safe-update").length;
-                const message = canUpdate
-                    ? `有 ${safeCount} 项可在此更新。${needsAttention ? "其余待处理项的原因和下一步见下方。" : "更新会保留项目自定义内容。"}`
-                    : "暂无可直接更新的内容。请按下方原因处理，完成后重新检查。";
-                if (!pendingItems.length)
-                    pendingItems.push({ path: "初始化配置", kind: "confirmation",
-                        reason: "检查尚未通过，但没有返回可自动更新的项目。",
-                        nextStep: "复制处理说明交给智能体检查初始化记录，完成后重新检查。" });
-                return { ...this.snapshot(needsAttention ? "needs-attention" : "update-available", message, [...new Set(pendingItems.map(item => item.path))]), canUpdate, pendingItems };
-            }
-            return this.snapshot("ready", "工作区配置已就绪");
-        }
-        catch (error) {
-            return this.snapshot("error", error instanceof Error ? error.message : "初始化状态检查失败");
-        }
-    }
-    async check(refresh = false) {
-        const latest = (await this.options.operations.list()).filter(op => op.action === "workspaceInitialize").at(-1);
-        const running = latest && !TERMINAL_OPERATION_STATES.has(latest.state) && latest.state !== "needs-reconcile";
-        if (!running && (refresh || !this.cached || Date.now() - this.cached.at > 30_000)) {
-            const generation = this.generation;
-            this.pending ??= this.inspect().then(value => { if (generation === this.generation)
-                this.cached = { value, at: Date.now() }; return value; }).finally(() => { this.pending = undefined; });
-            await this.pending;
-        }
-        const value = this.cached?.value ?? this.snapshot("uninitialized", "正在初始化工作区…");
-        return { ...value, ...(latest ? { operation: { operationId: latest.operationId, state: latest.state, ...(latest.errorMessage ? { message: latest.errorMessage } : {}) } } : {}) };
-    }
-    async start(clientRequestId, model) {
-        const created = await this.options.operations.create({ clientRequestId, action: "workspaceInitialize", actionParams: { ...(model ? { model } : {}) } });
-        if (created.kind !== "created")
-            return created;
-        const operationId = created.operation.operationId;
-        if (this.activeOperationId) {
-            await this.options.operations.update(operationId, { state: "failed", finishedAt: new Date().toISOString(), errorCode: "WORKSPACE_INIT_BUSY", errorMessage: "此工作区已有初始化操作正在运行" });
-            return created;
-        }
-        this.activeOperationId = operationId;
-        this.generation += 1;
-        queueMicrotask(() => { void this.execute(operationId, model); });
-        return created;
-    }
-    async execute(operationId, model) {
-        let release;
-        try {
-            await this.options.operations.update(operationId, { state: "running", startedAt: new Date().toISOString() });
-            this.options.events.append(operationId, { at: new Date().toISOString(), kind: "state", state: "running", message: `正在检查并配置 ${this.options.name}` });
-            release = await (this.options.acquireLock ?? (() => acquireUpdateLock(updateLockPath(os.homedir()))))();
-            if (!release)
-                throw new Error("程序更新或其他初始化操作正在进行，请稍后重试");
-            const activity = await (this.options.readActivity ?? readInitRuntimeActivity)(this.options.repoRoot);
-            if (activity.workerProjectionError || activity.activeDagRunIds.length || activity.activeWorkerTasks || activity.activeWorkerBatches || this.options.activeChatTurnCount())
-                throw new Error("当前工作区有任务或对话正在运行，请结束后重试");
-            const operations = await this.options.operations.list();
-            if (operations.some(op => op.operationId !== operationId && !TERMINAL_OPERATION_STATES.has(op.state) && op.state !== "needs-reconcile"))
-                throw new Error("当前工作区有其他操作正在运行，请稍后重试");
-            const before = await this.inspect();
-            if (before.state === "error")
-                throw new Error(before.message);
-            if (before.state === "uninitialized") {
-                if (!model || !before.models?.some(item => item.reference === model))
-                    throw new Error("请选择一个可用的初始模型；可在模型设置中完成认证后重新检查");
-                await this.command(["init", "--profile", "full", "--merge", "--client-recovery", "project", "--model", model, "--json"], "apply");
-            }
-            else if (before.canUpdate) {
-                await this.command(["init", "update", "--apply-safe", "--client-recovery", "project", "--json"], "apply");
-            }
-            else if (before.state !== "ready")
-                throw new Error("没有可安全更新的内容；请查看待处理项的原因和下一步。");
-            const after = await this.inspect();
-            this.cached = { value: after, at: Date.now() };
-            const state = after.state === "ready" ? "succeeded" : "needs-reconcile";
-            await this.options.operations.update(operationId, { state, finishedAt: new Date().toISOString(), result: { initialization: after }, ...(state !== "succeeded" ? { errorCode: "INIT_NEEDS_RECONCILE", errorMessage: after.message } : {}) });
-            this.options.events.append(operationId, { at: new Date().toISOString(), kind: "state", state, message: after.message });
-        }
-        catch (error) {
-            this.cached = undefined;
-            const message = error instanceof Error ? error.message : "工作区初始化失败";
-            await this.options.operations.update(operationId, { state: "failed", finishedAt: new Date().toISOString(), errorCode: "WORKSPACE_INIT_FAILED", errorMessage: message });
-            this.options.events.append(operationId, { at: new Date().toISOString(), kind: "error", state: "failed", message });
-        }
-        finally {
-            this.activeOperationId = undefined;
-            await release?.().catch(() => undefined);
-        }
-    }
-}

package/dist/workflows/dag/frontend-capacity.js

@@ -1,9 +0,0 @@
-/** Shared Contract/Plan bound. Permissions and directory globs are not files. */
-export const FRONTEND_MAX_IMPLEMENTATION_FILES = 15;
-export function frontendConcreteDeliveryFiles(files) {
-    if (!Array.isArray(files))
-        return [];
-    return [...new Set(files.filter((file) => typeof file === "string")
-            .map(file => file.trim().replace(/\\/g, "/").replace(/^(\.\/)+/, ""))
-            .filter(file => file.length > 0 && !/[*?{}]/.test(file) && !file.endsWith("/")))];
-}

package/dist/workflows/dag/frontend-plan-completeness.js

@@ -1,186 +0,0 @@
-import { collectCanonicalStateFlowNames } from "./frontend-contract-facts.js";
-export function committedFactFromPlanRecord(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return undefined;
-    const record = value;
-    if (record.phase !== undefined && record.phase !== "committed")
-        return undefined;
-    const fact = record.fact;
-    return fact && typeof fact === "object" && !Array.isArray(fact)
-        ? fact
-        : typeof record.kind === "string"
-            ? record
-            : undefined;
-}
-export function planFactStringList(value) {
-    if (!Array.isArray(value))
-        return [];
-    return value.filter((item) => typeof item === "string" && item.trim().length > 0);
-}
-export function planFactScopeIntersects(fact, requirementIds) {
-    return planFactStringList(fact.scopeRequirementIds).some((id) => requirementIds.has(id));
-}
-/** Compute the authoritative coverage queue from the committed plan ledger. */
-export function collectFrontendPlanMissingFacts(input) {
-    const requirements = new Map();
-    const standaloneEvidenceGaps = new Set();
-    const verificationTargetIds = new Set();
-    const verificationTargetRequirements = new Map();
-    for (const value of input.committedFacts) {
-        const fact = committedFactFromPlanRecord(value);
-        if (!fact || fact.origin !== "plan")
-            continue;
-        if (fact.kind === "plan-requirement" && fact.entry && typeof fact.entry === "object") {
-            const entry = fact.entry;
-            if (typeof entry.id === "string" && entry.id.trim())
-                requirements.set(entry.id, entry);
-        }
-        if (fact.kind === "plan-verification-target" && fact.entry && typeof fact.entry === "object") {
-            const entry = fact.entry;
-            const id = entry.id;
-            if (typeof id === "string" && id.trim()) {
-                verificationTargetIds.add(id);
-                verificationTargetRequirements.set(id, new Set(Array.isArray(entry.requirementIds)
-                    ? entry.requirementIds.filter((value) => typeof value === "string")
-                    : []));
-            }
-        }
-        if (fact.kind === "plan-evidence-gap" && fact.entry && typeof fact.entry === "object") {
-            const entry = fact.entry;
-            const requirementId = entry.requirementId;
-            const description = entry.description;
-            if (typeof requirementId === "string" && requirementId.trim() && typeof description === "string" && description.trim()) {
-                standaloneEvidenceGaps.add(requirementId);
-            }
-        }
-    }
-    const missing = [];
-    for (const id of input.requirementIds) {
-        const entry = requirements.get(id);
-        if (!entry) {
-            missing.push({
-                kind: "plan-requirement",
-                id,
-                requirementIds: [id],
-                reason: `requirement ${id} has no committed plan-requirement fact`,
-            });
-            continue;
-        }
-        const targetIds = Array.isArray(entry.verificationTargetIds)
-            ? entry.verificationTargetIds.filter((value) => typeof value === "string" && value.trim().length > 0)
-            : [];
-        const gap = entry.evidenceGap && typeof entry.evidenceGap === "object"
-            ? entry.evidenceGap
-            : undefined;
-        const hasEvidenceGap = (typeof gap?.description === "string" && gap.description.trim().length > 0) ||
-            standaloneEvidenceGaps.has(id);
-        if (targetIds.length === 0 && !hasEvidenceGap) {
-            missing.push({
-                kind: "plan-verification-target",
-                requirementIds: [id],
-                reason: `requirement ${id} declares neither a verification target nor a non-empty evidenceGap`,
-            });
-            continue;
-        }
-        for (const targetId of targetIds) {
-            if (!verificationTargetIds.has(targetId) ||
-                !verificationTargetRequirements.get(targetId)?.has(id)) {
-                missing.push({
-                    kind: "plan-verification-target",
-                    id: targetId,
-                    requirementIds: [id],
-                    reason: `requirement ${id} references verification target ${targetId}, but that target is not committed`,
-                });
-            }
-        }
-    }
-    return missing;
-}
-/** Completeness checks for phases whose facts are committed incrementally. */
-export function collectFrontendPlanPhaseMissingFacts(input) {
-    const facts = input.committedFacts
-        .map(committedFactFromPlanRecord)
-        .filter((fact) => Boolean(fact && fact.origin === "plan"));
-    if (input.phase === "ux-registry") {
-        return facts.some((fact) => fact.kind === "state-registry")
-            ? []
-            : [
-                {
-                    kind: "state-registry",
-                    requirementIds: [...input.requirementIds],
-                    reason: "global UX vocabulary phase has no committed state-registry fact",
-                },
-            ];
-    }
-    if (input.phase === "ux-local") {
-        // One snapshot per check: no cross-revision cache to invalidate.
-        const required = new Set(input.behaviorRequiredRequirementIds ?? []);
-        const requested = new Set(input.requirementIds.filter(id => required.has(id)));
-        if (!requested.size)
-            return [];
-        const byRequirement = new Map();
-        for (const fact of facts) {
-            for (const id of new Set(planFactStringList(fact.scopeRequirementIds))) {
-                if (!requested.has(id))
-                    continue;
-                const entries = byRequirement.get(id) ?? [];
-                entries.push(fact);
-                byRequirement.set(id, entries);
-            }
-        }
-        const liveStateFlow = collectCanonicalStateFlowNames(facts);
-        const missing = [];
-        for (const id of input.requirementIds) {
-            if (!required.has(id))
-                continue;
-            const scopedFacts = byRequirement.get(id) ?? [];
-            const hasChoice = scopedFacts.some((fact) => fact.kind === "component-choice" &&
-                Array.isArray(fact.uiComponentChoices) &&
-                fact.uiComponentChoices.length > 0);
-            const canonicalStateFlow = collectCanonicalStateFlowNames(scopedFacts);
-            const hasStateFlow = [...canonicalStateFlow.uiStateNames].some(name => liveStateFlow.uiStateNames.has(name)) ||
-                [...canonicalStateFlow.interactionNames].some(name => liveStateFlow.interactionNames.has(name));
-            if (!hasChoice) {
-                missing.push({
-                    kind: "component-choice",
-                    requirementIds: [id],
-                    reason: "behaviour-required UX slice has no committed component-choice fact",
-                });
-            }
-            if (!hasStateFlow) {
-                missing.push({
-                    kind: "state-flow",
-                    requirementIds: [id],
-                    reason: "behaviour-required UX slice has no committed state-flow fact",
-                });
-            }
-        }
-        return missing;
-    }
-    const hasMockApi = facts.some((fact) => fact.kind === "mock-api");
-    const allInteractions = collectCanonicalStateFlowNames(facts).interactionNames;
-    const requested = new Set(input.requirementIds);
-    const liveInteractions = new Set([...collectCanonicalStateFlowNames(facts.filter(f => !planFactStringList(f.scopeRequirementIds).length || planFactScopeIntersects(f, requested))).interactionNames].filter(name => allInteractions.has(name)));
-    const coveredInteractions = new Set(facts
-        .filter((fact) => fact.kind === "data-flow")
-        .flatMap((fact) => planFactStringList(fact.interactions)));
-    const missing = [];
-    if (!hasMockApi) {
-        missing.push({
-            kind: "mock-api",
-            requirementIds: [...input.requirementIds],
-            reason: "global Mock/data phase has no committed mock-api fact",
-        });
-    }
-    for (const interaction of liveInteractions) {
-        if (coveredInteractions.has(interaction))
-            continue;
-        missing.push({
-            kind: "data-flow",
-            id: interaction,
-            requirementIds: [...input.requirementIds],
-            reason: `interaction ${interaction} has no committed data-flow fact`,
-        });
-    }
-    return missing;
-}

package/dist/workflows/dag/frontend-plan-recovery-policy.js

@@ -1,18 +0,0 @@
-/** Precise failures own their recovery. A stale transport length marker must
- * never turn cancellation, provider rejection or policy failure into progress. */
-export function classifyFrontendPlanRecovery(result) {
-    const category = result.failureCategory ?? "";
-    if (result.timedOut || result.stopReason === "aborted" ||
-        /interrupt|termination-unconfirmed|budget_breach/.test(category) ||
-        ["cancelled", "auth", "missing-api-key", "rate-limit", "quota", "timeout", "tool-policy", "write-guard", "path-violation", "governance-blocked", "human-rejected"].includes(category))
-        return "stop";
-    if (result.ok)
-        return "none";
-    if (category === "output-limit")
-        return "output";
-    if (["context-overflow", "context-budget-exhausted"].includes(category))
-        return "context";
-    if (result.stopReason === "length" && ["", "empty-output", "network", "nonzero-exit", "unknown"].includes(category))
-        return "output";
-    return "none";
-}