@tea-agent/loop-agent 0.17.0 → 0.17.2

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

@@ -2,9 +2,11 @@
  * 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",
+    "bootstrapFromPrd",
     "contractApply",
     "contractAdopt",
     "dagRunTask",
@@ -12,6 +14,7 @@ const SETUP_BLOCKED = Object.freeze([
     "prepareDagConfirmation",
     "interviewStart",
     "interviewTurn",
+    "interviewSkip",
 ]);
 const DEGRADED_BLOCKED = Object.freeze([
     "contractApply",
@@ -20,6 +23,13 @@ const DEGRADED_BLOCKED = Object.freeze([
     "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 ||
@@ -57,30 +67,194 @@ export function isActionBlockedByReadiness(state, 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;
+}
 /**
- * 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.
+ * 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 probePiReadiness(options) {
-    if (options?.override) {
-        return buildPiReadinessReport(options.override);
+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";
     }
-    // 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,
+    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/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",
+            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,
         },
     };
-    return buildPiReadinessReport(probe);
+}
+/**
+ * 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))

package/dist/worker/console/prd-identity.js

@@ -0,0 +1,102 @@
+/**
+ * Derive Console task title + canonical taskId from imported PRD markdown.
+ * Deterministic (no LLM): first ATX heading, else first meaningful line.
+ */
+import { createHash } from "node:crypto";
+import { formatLocalBusinessDate } from "../../task/runtime.js";
+const GENERIC_SLUGS = new Set([
+    "test",
+    "fix",
+    "tmp",
+    "new-task",
+    "requirement",
+    "req",
+    "prd",
+    "untitled",
+]);
+function cleanTitleLine(line) {
+    return line
+        .replace(/^#{1,6}\s+/, "")
+        .replace(/^>\s+/, "")
+        .replace(/^[*_\s]+|[*_\s]+$/g, "")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function isNoiseLine(line) {
+    const t = line.trim();
+    if (!t)
+        return true;
+    if (/^---+$/.test(t))
+        return true;
+    if (/^```/.test(t))
+        return true;
+    if (/^<!--/.test(t))
+        return true;
+    return false;
+}
+export function extractPrdTitle(content) {
+    const lines = content.split(/\r?\n/);
+    for (const raw of lines) {
+        const trimmed = raw.trim();
+        if (!/^#\s+\S/.test(trimmed))
+            continue;
+        const title = cleanTitleLine(trimmed);
+        if (title)
+            return { title: title.slice(0, 120), source: "heading" };
+    }
+    for (const raw of lines) {
+        if (isNoiseLine(raw))
+            continue;
+        const trimmed = raw.trim();
+        if (/^#{2,6}\s+/.test(trimmed))
+            continue;
+        const title = cleanTitleLine(trimmed);
+        if (title.length >= 2) {
+            return { title: title.slice(0, 120), source: "first-line" };
+        }
+    }
+    for (const raw of lines) {
+        const trimmed = raw.trim();
+        if (!/^#{2,6}\s+\S/.test(trimmed))
+            continue;
+        const title = cleanTitleLine(trimmed);
+        if (title)
+            return { title: title.slice(0, 120), source: "heading" };
+    }
+    const hash = createHash("sha256").update(content).digest("hex").slice(0, 8);
+    return { title: `需求任务 ${hash}`, source: "content-hash" };
+}
+export function asciiSlugFromTitle(title, contentForFallback) {
+    const ascii = title
+        .normalize("NFKD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .replace(/-{2,}/g, "-")
+        .slice(0, 48);
+    if (ascii.length >= 3 && !GENERIC_SLUGS.has(ascii))
+        return ascii;
+    const hash = createHash("sha256")
+        .update(contentForFallback || title)
+        .digest("hex")
+        .slice(0, 8);
+    return `req-${hash}`;
+}
+export function deriveTaskIdentityFromPrd(content, now = new Date()) {
+    const extracted = extractPrdTitle(content);
+    const slug = asciiSlugFromTitle(extracted.title, content);
+    const date = formatLocalBusinessDate(now);
+    return {
+        title: extracted.title,
+        slug,
+        taskId: `${date}-${slug}`,
+        source: extracted.source,
+    };
+}
+export function nextTaskIdRevision(taskId, revision) {
+    if (revision <= 1)
+        return taskId;
+    const base = taskId.replace(/-r\d+$/, "");
+    return `${base}-r${revision}`;
+}

package/dist/worker/console/resolve-dag-run-for-task.js

@@ -0,0 +1,76 @@
+/**
+ * Resolve the newest DAG run id for a harness task under `.harness/dag-runs`.
+ * Used by Console observeLink so task-scoped opens land on `#/dag/<runId>`.
+ */
+import { readdir, readFile, stat } from "node:fs/promises";
+import path from "node:path";
+const LIFECYCLE_ORDER = ["active", "paused", "completed"];
+async function readTaskIdFromRunDir(runDir) {
+    const runJsonPath = path.join(runDir, "run.json");
+    try {
+        const raw = JSON.parse(await readFile(runJsonPath, "utf8"));
+        const fromBinding = raw.taskContractBinding?.taskId?.trim() ||
+            raw.sourceBinding?.taskId?.trim();
+        if (fromBinding)
+            return fromBinding;
+        const title = raw.title?.trim() ?? "";
+        const hybrid = /^Hybrid DAG:\s*(.+)$/i.exec(title);
+        if (hybrid?.[1]?.trim())
+            return hybrid[1].trim();
+    }
+    catch {
+        /* missing/invalid run.json — skip */
+    }
+    return undefined;
+}
+/**
+ * Prefer active/paused over completed; within a lifecycle, newest mtime wins.
+ */
+export async function resolveLatestDagRunIdForTask(repoRoot, taskId) {
+    const wanted = taskId.trim();
+    if (!wanted)
+        return undefined;
+    const matches = [];
+    for (const lifecycle of LIFECYCLE_ORDER) {
+        const lifecycleDir = path.join(repoRoot, ".harness", "dag-runs", lifecycle);
+        let entries = [];
+        try {
+            entries = await readdir(lifecycleDir);
+        }
+        catch {
+            continue;
+        }
+        for (const name of entries) {
+            if (!name || name === ".gitkeep")
+                continue;
+            const runDir = path.join(lifecycleDir, name);
+            let st;
+            try {
+                st = await stat(runDir);
+            }
+            catch {
+                continue;
+            }
+            if (!st.isDirectory())
+                continue;
+            const boundTaskId = await readTaskIdFromRunDir(runDir);
+            if (boundTaskId !== wanted)
+                continue;
+            matches.push({
+                dagRunId: name,
+                lifecycle,
+                mtimeMs: st.mtimeMs,
+            });
+        }
+    }
+    if (matches.length === 0)
+        return undefined;
+    const lifecycleRank = (value) => LIFECYCLE_ORDER.indexOf(value);
+    matches.sort((a, b) => {
+        const life = lifecycleRank(a.lifecycle) - lifecycleRank(b.lifecycle);
+        if (life !== 0)
+            return life;
+        return b.mtimeMs - a.mtimeMs;
+    });
+    return matches[0];
+}

package/dist/worker/console/server.js

@@ -48,6 +48,7 @@ export async function createConsoleServer(options) {
     const readiness = await probePiReadiness({
         override: options.piReadinessProbe,
     });
+    let readinessCache = readiness;
     const artifactRoot = path.join(appData.root, "client-artifacts", appData.fingerprint);
     const client = options.createClient?.(artifactRoot) ??
         new LoopAgentClient({
@@ -58,7 +59,14 @@ export async function createConsoleServer(options) {
     if (!options.skipReconcile) {
         await operations.reconcileOnBoot();
     }
-    const getReadiness = () => readiness;
+    const getReadiness = () => readinessCache;
+    const refreshReadiness = async () => {
+        readinessCache = await probePiReadiness({
+            override: options.piReadinessProbe,
+        });
+        actionContext.readiness = readinessCache;
+        return readinessCache;
+    };
     const actionContext = {
         repoRoot,
         appData,
@@ -70,8 +78,9 @@ export async function createConsoleServer(options) {
         confirmations,
         interviews,
         assessments,
-        readiness,
+        readiness: readinessCache,
         getReadiness,
+        refreshReadiness,
         observeBaseUrl: options.observeBaseUrl,
         fetchImpl: options.fetchImpl,
     };