@tea-agent/loop-agent 0.16.26 → 0.17.1

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

@@ -0,0 +1,266 @@
+/**
+ * Pi readiness gate for Official Console Happy Path.
+ * setup-required | ready | degraded — no pure form fallback.
+ */
+import path from "node:path";
+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
+]);
+/** Default Interview / DAG model matrix (provider, modelId). */
+const INTERVIEW_MODEL_CANDIDATES = Object.freeze([
+    ["openai", "gpt-5.5"],
+    ["openai", "gpt-5.3-codex-spark"],
+    ["zai", "glm-5.2"],
+    ["zhipu", "glm-5.2"],
+]);
+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);
+}
+function countAvailableModels(snapshot) {
+    return Array.isArray(snapshot.available) ? snapshot.available.length : 0;
+}
+function hasProviderConfig(snapshot) {
+    const authKeys = snapshot.auth && typeof snapshot.auth === "object"
+        ? Object.keys(snapshot.auth).length
+        : 0;
+    const configured = snapshot.configuredProviders &&
+        typeof snapshot.configuredProviders === "object"
+        ? Object.keys(snapshot.configuredProviders).length
+        : 0;
+    const stored = snapshot.storedProviders && typeof snapshot.storedProviders === "object"
+        ? Object.keys(snapshot.storedProviders).length
+        : 0;
+    return authKeys > 0 || configured > 0 || stored > 0;
+}
+/**
+ * Discover live Pi SDK / auth / model readiness via ModelRuntime.
+ * Kept inside worker/console (dynamic import) so Worker does not depend on
+ * executors; contract matches pi-sdk-executor 0.80.10.
+ */
+export async function discoverPiReadinessProbe() {
+    let sdk;
+    try {
+        sdk = (await import("@earendil-works/pi-coding-agent"));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            sdkAvailable: false,
+            authReady: false,
+            modelsAvailable: false,
+            interviewSessionOk: false,
+            details: {
+                sdkMessage: `Pi SDK import failed: ${message}`,
+                authMessage: "skipped (sdk unavailable)",
+                modelsMessage: "skipped (sdk unavailable)",
+                sessionMessage: "skipped (sdk unavailable)",
+            },
+        };
+    }
+    const ModelRuntime = sdk.ModelRuntime;
+    if (typeof sdk.createAgentSession !== "function" ||
+        typeof sdk.getAgentDir !== "function" ||
+        typeof ModelRuntime?.create !== "function") {
+        return {
+            sdkAvailable: false,
+            authReady: false,
+            modelsAvailable: false,
+            interviewSessionOk: false,
+            details: {
+                sdkMessage: "Pi SDK incompatible: requires createAgentSession, getAgentDir, and ModelRuntime.create (0.80.10)",
+                authMessage: "skipped (sdk incompatible)",
+                modelsMessage: "skipped (sdk incompatible)",
+                sessionMessage: "skipped (sdk incompatible)",
+            },
+        };
+    }
+    let agentDir;
+    try {
+        agentDir = sdk.getAgentDir();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            sdkAvailable: false,
+            authReady: false,
+            modelsAvailable: false,
+            interviewSessionOk: false,
+            details: {
+                sdkMessage: `getAgentDir failed: ${message}`,
+                authMessage: "skipped",
+                modelsMessage: "skipped",
+                sessionMessage: "skipped",
+            },
+        };
+    }
+    let runtime;
+    try {
+        runtime = await ModelRuntime.create({
+            authPath: path.join(agentDir, "auth.json"),
+            modelsPath: path.join(agentDir, "models.json"),
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            sdkAvailable: true,
+            authReady: false,
+            modelsAvailable: false,
+            interviewSessionOk: false,
+            details: {
+                sdkMessage: "Pi SDK 0.80.10 contract available",
+                authMessage: `ModelRuntime.create failed: ${message}`,
+                modelsMessage: "skipped (runtime init failed)",
+                sessionMessage: "skipped (runtime init failed)",
+            },
+        };
+    }
+    const snapshot = runtime.snapshot ?? {};
+    const availableCount = countAvailableModels(snapshot);
+    const providerConfigured = hasProviderConfig(snapshot);
+    const resolvedInterviewModels = [];
+    if (typeof runtime.getModel === "function") {
+        for (const [provider, modelId] of INTERVIEW_MODEL_CANDIDATES) {
+            try {
+                if (runtime.getModel(provider, modelId)) {
+                    resolvedInterviewModels.push(`${provider}/${modelId}`);
+                }
+            }
+            catch {
+                // ignore per-model resolution errors
+            }
+        }
+    }
+    const authReady = availableCount > 0 || providerConfigured;
+    const modelsAvailable = availableCount > 0 || resolvedInterviewModels.length > 0;
+    let interviewSessionOk = false;
+    let sessionMessage;
+    if (!authReady || !modelsAvailable) {
+        sessionMessage =
+            "Interview session preflight skipped (auth/models not ready)";
+    }
+    else if (typeof sdk.SessionManager?.inMemory !== "function") {
+        sessionMessage =
+            "SessionManager.inMemory unavailable; Interview session preflight failed";
+    }
+    else {
+        try {
+            sdk.SessionManager.inMemory(process.cwd());
+            interviewSessionOk = true;
+            sessionMessage = `Interview session preflight ok (${availableCount} available model(s); matrix=${resolvedInterviewModels.join(",") || "none"})`;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            sessionMessage = `Interview session preflight failed: ${message}`;
+        }
+    }
+    return {
+        sdkAvailable: true,
+        authReady,
+        modelsAvailable,
+        interviewSessionOk,
+        details: {
+            sdkMessage: `Pi SDK 0.80.10 contract available (agentDir=${agentDir})`,
+            authMessage: authReady
+                ? `credentials/providers ready (available=${availableCount}, providerConfig=${providerConfigured})`
+                : "no available models and no stored/configured provider credentials (set Pi auth or provider API keys)",
+            modelsMessage: modelsAvailable
+                ? `models ready (available=${availableCount}, interviewMatrix=${resolvedInterviewModels.join(",") || "none"})`
+                : "no available models for Interview",
+            sessionMessage,
+        },
+    };
+}
+/**
+ * Default probe for process boot. Discovers live Pi ModelRuntime when no
+ * override is injected. Tests inject override for determinism.
+ */
+export async function probePiReadiness(options) {
+    if (options?.override) {
+        return buildPiReadinessReport(options.override);
+    }
+    try {
+        const probe = await discoverPiReadinessProbe();
+        if (options?.siblingControllerOk && !probe.details) {
+            probe.details = {};
+        }
+        if (options?.siblingControllerOk && probe.details) {
+            probe.details.sdkMessage = `${probe.details.sdkMessage ?? "sdk probed"}; sibling controller identity ok`;
+        }
+        return buildPiReadinessReport(probe);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return buildPiReadinessReport({
+            sdkAvailable: false,
+            authReady: false,
+            modelsAvailable: false,
+            interviewSessionOk: false,
+            details: {
+                sdkMessage: `Pi readiness discovery error: ${message}`,
+                authMessage: "no credential probe completed",
+                modelsMessage: "no model list available",
+                sessionMessage: "Interview session preflight not run",
+            },
+        });
+    }
+}
+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, };