@tea-agent/loop-agent 0.16.25 → 0.17.0

package/dist/worker/console/pi-readiness.js

@@ -0,0 +1,94 @@
+/**
+ * Pi readiness gate for Official Console Happy Path.
+ * setup-required | ready | degraded — no pure form fallback.
+ */
+const SETUP_BLOCKED = Object.freeze([
+    "newTask",
+    "importPrd",
+    "contractApply",
+    "contractAdopt",
+    "dagRunTask",
+    "runDag",
+    "prepareDagConfirmation",
+    "interviewStart",
+    "interviewTurn",
+]);
+const DEGRADED_BLOCKED = Object.freeze([
+    "contractApply",
+    "contractAdopt",
+    "dagRunTask",
+    "runDag",
+    // new Interview may resume; brand-new apply/run still blocked
+]);
+export function classifyPiReadiness(probe) {
+    if (!probe.sdkAvailable ||
+        !probe.authReady ||
+        !probe.modelsAvailable ||
+        !probe.interviewSessionOk) {
+        // Temporary provider issues after prior readiness → degraded when only
+        // session fails but sdk/auth/models were previously ok is hard to know;
+        // rule: missing core setup → setup-required; only session flaky → degraded.
+        if (!probe.sdkAvailable || !probe.authReady || !probe.modelsAvailable) {
+            return "setup-required";
+        }
+        return "degraded";
+    }
+    return "ready";
+}
+export function buildPiReadinessReport(probe, now = new Date().toISOString()) {
+    const state = classifyPiReadiness(probe);
+    const blockedActions = state === "setup-required"
+        ? SETUP_BLOCKED
+        : state === "degraded"
+            ? DEGRADED_BLOCKED
+            : Object.freeze([]);
+    return {
+        state,
+        probe,
+        generatedAt: now,
+        blockedActions,
+    };
+}
+export function isActionBlockedByReadiness(state, action) {
+    if (state === "ready")
+        return false;
+    if (state === "setup-required") {
+        return SETUP_BLOCKED.includes(action);
+    }
+    return DEGRADED_BLOCKED.includes(action);
+}
+/**
+ * Default probe for process boot. Without a real Pi ModelRuntime injection,
+ * Official Console is setup-required (no form fallback).
+ * Tests and server may inject a readiness probe override.
+ */
+export async function probePiReadiness(options) {
+    if (options?.override) {
+        return buildPiReadinessReport(options.override);
+    }
+    // Phase 2: real Pi SDK/auth/model discovery is optional injection.
+    // Default fail-closed to setup-required so Happy Path cannot skip Interview.
+    const probe = {
+        sdkAvailable: false,
+        authReady: false,
+        modelsAvailable: false,
+        interviewSessionOk: false,
+        details: {
+            sdkMessage: "Pi SDK/ModelRuntime not injected; configure Interview model/auth (setup-required)",
+            authMessage: "no credential probe configured",
+            modelsMessage: "no model list available",
+            sessionMessage: "Interview session preflight not run",
+        },
+    };
+    return buildPiReadinessReport(probe);
+}
+export function readinessGateFailure(report, action) {
+    if (!isActionBlockedByReadiness(report.state, action))
+        return undefined;
+    return {
+        code: "PI_SETUP_REQUIRED",
+        message: `action "${action}" is blocked while pi readiness is ${report.state} (no pure form fallback)`,
+        state: report.state,
+        action,
+    };
+}

package/dist/worker/console/recovery-cta.js

@@ -0,0 +1,133 @@
+/**
+ * Recovery UI CTA matrix (design §5.5.3).
+ * Pure table-driven policy — no Cancel, no primary "edit code" CTA.
+ */
+const CTA = {
+    report: {
+        id: "report",
+        label: "查看报告",
+        action: "status",
+        commandHint: "loop-agent dag report --run-id <run-id>",
+    },
+    doctor: {
+        id: "doctor",
+        label: "Doctor 诊断",
+        action: "doctor",
+        commandHint: "agent-worker console doctor --repo .",
+    },
+    decision: {
+        id: "decision",
+        label: "人工决策",
+        commandHint: "loop-agent dag doctor --run-id <run-id> --markdown",
+    },
+    resume: {
+        id: "resume",
+        label: "恢复运行",
+        commandHint: "loop-agent run-dag --resume --run-id <run-id>",
+    },
+    reconcile: {
+        id: "reconcile",
+        label: "对账 / reconcile",
+        requiresReason: true,
+        commandHint: "loop-agent dag reconcile-run --run-id <run-id> --reason <structured-reason>",
+    },
+    regenerate: {
+        id: "regenerate",
+        label: "重新生成契约/计划",
+        commandHint: "loop-agent dag run-task <task-id> --profile auto",
+    },
+    observeLink: {
+        id: "observeLink",
+        label: "打开 Observe 深链",
+        action: "observeLink",
+        commandHint: "agent-worker observe serve --repo . --port 8787",
+    },
+};
+const MATRIX = {
+    "validation-failed": ["report", "doctor", "regenerate"],
+    "contract-drift": ["report", "doctor", "decision", "reconcile", "regenerate"],
+    "runtime-mismatch": ["report", "doctor", "reconcile", "regenerate"],
+    "pause-on-human": ["decision", "resume", "report", "doctor"],
+    "verification-failed": ["report", "doctor", "resume", "regenerate"],
+    "orphan-unknown": ["report", "doctor", "reconcile"],
+    "terminal-failed": ["report", "doctor", "resume", "regenerate"],
+    "terminal-succeeded": ["report", "observeLink"],
+    "needs-reconcile": ["report", "doctor", "reconcile", "regenerate"],
+};
+const FORBIDDEN_LABELS = [
+    "直接改代码",
+    "edit code",
+    "Cancel",
+    "cancel operation",
+];
+/**
+ * Return allowed recovery CTAs for a fact/failure class.
+ * Never includes Cancel or primary "edit code".
+ */
+export function allowedRecoveryCtas(factClass) {
+    const ids = MATRIX[factClass] ?? MATRIX["orphan-unknown"];
+    return ids.map((id) => CTA[id]);
+}
+/**
+ * Negative product invariants for recovery matrix (test + docs).
+ */
+export function recoveryMatrixInvariants() {
+    const allCtaIds = Object.keys(CTA);
+    const factClasses = Object.keys(MATRIX);
+    return {
+        forbiddenLabels: FORBIDDEN_LABELS,
+        allCtaIds,
+        factClasses,
+    };
+}
+/**
+ * Best-effort classification from operation/DAG surface strings for MVP UI.
+ * Prefer structured fields when available; unknown → orphan-unknown.
+ */
+export function classifyRecoveryFact(input) {
+    if (input.needsReconcile)
+        return "needs-reconcile";
+    const code = (input.errorCode ?? "").toLowerCase();
+    const state = (input.operationState ?? "").toLowerCase();
+    const dag = (input.dagStatus ?? "").toLowerCase();
+    if (code.includes("validation") ||
+        code.includes("invalid") ||
+        state.includes("validation")) {
+        return "validation-failed";
+    }
+    if (code.includes("contract") ||
+        code.includes("drift") ||
+        code.includes("binding")) {
+        return "contract-drift";
+    }
+    if (code.includes("runtime") ||
+        code.includes("mismatch") ||
+        code.includes("fingerprint")) {
+        return "runtime-mismatch";
+    }
+    if (code.includes("human") ||
+        state.includes("paused") ||
+        dag.includes("paused") ||
+        state.includes("awaiting")) {
+        return "pause-on-human";
+    }
+    if (code.includes("verif") || state.includes("verif")) {
+        return "verification-failed";
+    }
+    if (state === "succeeded" ||
+        state === "completed" ||
+        dag === "succeeded" ||
+        dag === "completed") {
+        return "terminal-succeeded";
+    }
+    if (state === "failed" ||
+        state.includes("fail") ||
+        dag === "failed" ||
+        code.includes("fail")) {
+        return "terminal-failed";
+    }
+    if (code.includes("reconcil") || state.includes("reconcil")) {
+        return "needs-reconcile";
+    }
+    return "orphan-unknown";
+}

package/dist/worker/console/repo-fingerprint.js

@@ -0,0 +1,29 @@
+import { createHash } from "node:crypto";
+import { realpathSync } from "node:fs";
+import path from "node:path";
+/**
+ * Normalize a worktree root for repoFingerprintV1:
+ * realpath → Windows drive letter uppercased → `/` separators → strip trailing `/`
+ * (except a bare root). No extra case-folding on macOS/Windows.
+ */
+export function normalizeWorktreeRealpath(repoRoot) {
+    let resolved = realpathSync(path.resolve(repoRoot));
+    if (/^[a-zA-Z]:/.test(resolved)) {
+        resolved = resolved[0].toUpperCase() + resolved.slice(1);
+    }
+    resolved = resolved.replace(/\\/g, "/");
+    if (resolved.length > 1 && resolved.endsWith("/")) {
+        resolved = resolved.replace(/\/+$/, "");
+    }
+    return resolved;
+}
+/**
+ * Design §5.1: sha256("loop-console-repo-v1\0" + normalizedWorktreeRealpath)
+ * Returns lowercase hex digest (no sha256: prefix).
+ */
+export function repoFingerprintV1(repoRoot) {
+    const normalized = normalizeWorktreeRealpath(repoRoot);
+    return createHash("sha256")
+        .update(`loop-console-repo-v1\0${normalized}`, "utf8")
+        .digest("hex");
+}

package/dist/worker/console/resource-loader.js

@@ -0,0 +1,95 @@
+/**
+ * Official Console ResourceLoader (Phase 2).
+ * Closed surface: no edit/write/bash/full-tools business tools.
+ * Runtime env MUST NOT restore denied tools.
+ * Requirement Interview uses a stricter allowlist (see interview/tools.ts).
+ */
+import { createInterviewResourceLoader, INTERVIEW_ALLOWED_TOOLS, INTERVIEW_DENIED_TOOLS, authorizeInterviewTool, } from "./interview/tools.js";
+export const OFFICIAL_DENIED_TOOL_IDS = Object.freeze([
+    "edit",
+    "write",
+    "bash",
+    "full-tools",
+    "full_tools",
+    "coding-chat",
+    "coding_chat",
+    "shell",
+    "apply_patch",
+    "apply-patch",
+    // Interview / operator mutation tools must never appear as free coding tools
+    "contractApply",
+    "contract_apply",
+    "runDag",
+    "run_dag",
+    "reconcile",
+]);
+/** Official Console surface allows Interview-scoped tools only when Interview session is active. */
+export const OFFICIAL_ALLOWED_TOOL_IDS = Object.freeze([
+    ...INTERVIEW_ALLOWED_TOOLS,
+]);
+const DENIED = new Set(OFFICIAL_DENIED_TOOL_IDS.map((id) => id.toLowerCase()));
+const ALLOWED = new Set(OFFICIAL_ALLOWED_TOOL_IDS.map((id) => id.toLowerCase()));
+/** Official allowed tools: Interview closed set (no mutation operator tools). */
+export function listOfficialTools() {
+    return OFFICIAL_ALLOWED_TOOL_IDS;
+}
+export function isOfficialToolDenied(toolId) {
+    const id = toolId.trim().toLowerCase();
+    if (DENIED.has(id))
+        return true;
+    const compact = id.replace(/[-_]/g, "");
+    for (const d of DENIED) {
+        if (d.replace(/[-_]/g, "") === compact)
+            return true;
+    }
+    return false;
+}
+/**
+ * Attempt to activate a tool on the Official Console surface.
+ * Write-class, full-tools, and Interview-forbidden mutation ids are always rejected.
+ */
+export function tryActivateTool(toolId) {
+    const id = toolId.trim();
+    if (!id) {
+        return {
+            ok: false,
+            code: "tool-denied",
+            toolId: id,
+            message: "empty tool id is not allowed on Official Console surface",
+        };
+    }
+    if (isOfficialToolDenied(id)) {
+        return {
+            ok: false,
+            code: "tool-denied",
+            toolId: id,
+            message: `tool "${id}" is denied on Official Loop Operator Console (no edit/write/bash/full-tools/contractApply/runDag/reconcile)`,
+        };
+    }
+    if (!ALLOWED.has(id.toLowerCase())) {
+        return {
+            ok: false,
+            code: "tool-denied",
+            toolId: id,
+            message: `tool "${id}" is not registered on Official Console ResourceLoader`,
+        };
+    }
+    return { ok: true, toolId: id };
+}
+export function assertOfficialToolAllowed(toolId) {
+    const result = tryActivateTool(toolId);
+    if (!result.ok) {
+        throw new Error(result.message);
+    }
+}
+export function createClosedResourceLoader() {
+    return {
+        mode: "official-closed",
+        deniedToolIds: OFFICIAL_DENIED_TOOL_IDS,
+        allowedToolIds: OFFICIAL_ALLOWED_TOOL_IDS,
+        listTools: listOfficialTools,
+        tryActivateTool,
+        allowsEnvToolRestore: false,
+    };
+}
+export { createInterviewResourceLoader, INTERVIEW_ALLOWED_TOOLS, INTERVIEW_DENIED_TOOLS, authorizeInterviewTool, };