@tea-agent/loop-agent 0.16.26 → 0.17.0

package/dist/worker/console/interview/session.js

@@ -0,0 +1,100 @@
+import { randomBytes } from "node:crypto";
+import path from "node:path";
+import { readJsonIfExists, writeSecureJson, } from "../app-data.js";
+import { createInterviewResourceLoader, } from "./tools.js";
+function sessionPath(appData, sessionId) {
+    return path.join(appData.interviews, `${sessionId}.json`);
+}
+export function newInterviewSessionId() {
+    return `iv_${randomBytes(12).toString("hex")}`;
+}
+export class InterviewSessionStore {
+    appData;
+    loader;
+    constructor(appData) {
+        this.appData = appData;
+        this.loader = createInterviewResourceLoader();
+    }
+    async get(sessionId) {
+        return readJsonIfExists(sessionPath(this.appData, sessionId));
+    }
+    async create(input) {
+        const now = new Date().toISOString();
+        const session = {
+            schemaVersion: 1,
+            sessionId: newInterviewSessionId(),
+            taskId: input.taskId,
+            state: "not-started",
+            operatorSessionId: input.operatorSessionId,
+            createdAt: now,
+            updatedAt: now,
+            answers: [],
+            instructionVersion: input.instructionVersion ?? "grill-me@1",
+        };
+        await writeSecureJson(sessionPath(this.appData, session.sessionId), session);
+        return session;
+    }
+    async save(session) {
+        const next = { ...session, updatedAt: new Date().toISOString() };
+        await writeSecureJson(sessionPath(this.appData, next.sessionId), next);
+        return next;
+    }
+    /**
+     * grill-me: open exactly one question (or clear when complete).
+     */
+    async setCurrentQuestion(sessionId, question, state = "eliciting") {
+        const session = await this.get(sessionId);
+        if (!session)
+            throw new Error(`interview session not found: ${sessionId}`);
+        return this.save({
+            ...session,
+            currentQuestion: question,
+            state: question ? state : session.state,
+        });
+    }
+    async recordAnswer(sessionId, answer) {
+        const session = await this.get(sessionId);
+        if (!session)
+            throw new Error(`interview session not found: ${sessionId}`);
+        if (session.currentQuestion &&
+            session.currentQuestion.id !== answer.questionId) {
+            throw new Error("answer does not match current open question");
+        }
+        return this.save({
+            ...session,
+            answers: [...session.answers, answer],
+            currentQuestion: undefined,
+            state: "awaiting-user-answer",
+        });
+    }
+    async markDraftReady(sessionId, draft, draftSha256) {
+        const session = await this.get(sessionId);
+        if (!session)
+            throw new Error(`interview session not found: ${sessionId}`);
+        if (session.taskId !== draft.taskId) {
+            throw new Error("draft taskId does not match interview session");
+        }
+        return this.save({
+            ...session,
+            state: "draft-ready",
+            draftSha256,
+            currentQuestion: undefined,
+        });
+    }
+    async markAwaitingConfirmation(sessionId, assessmentId) {
+        const session = await this.get(sessionId);
+        if (!session)
+            throw new Error(`interview session not found: ${sessionId}`);
+        return this.save({
+            ...session,
+            state: "awaiting-confirmation",
+            assessmentId,
+        });
+    }
+    async markApplied(sessionId) {
+        const session = await this.get(sessionId);
+        if (!session)
+            throw new Error(`interview session not found: ${sessionId}`);
+        return this.save({ ...session, state: "applied" });
+    }
+}

package/dist/worker/console/interview/tools.js

@@ -0,0 +1,109 @@
+/**
+ * Requirement Interview closed tool registry (design §7.5).
+ * Server-side enforcement only — UI hiding is not enough.
+ */
+export const INTERVIEW_ALLOWED_TOOLS = Object.freeze([
+    "draft_read",
+    "draft_update",
+    "contract_validate",
+    "contract_diff",
+    "repo_explore_readonly",
+    "reference_read",
+]);
+/** Explicit denials for mutation / coding tools (AC-C2-02). */
+export const INTERVIEW_DENIED_TOOLS = Object.freeze([
+    "edit",
+    "write",
+    "bash",
+    "shell",
+    "full-tools",
+    "full_tools",
+    "apply_patch",
+    "apply-patch",
+    "contractApply",
+    "contract_apply",
+    "runDag",
+    "run_dag",
+    "reconcile",
+    "dagAbandon",
+    "dag_approve",
+    "dagApprove",
+    "dagReject",
+    "dagResume",
+    "importPrd",
+    "newTask",
+    "contractAdopt",
+]);
+const ALLOWED = new Set(INTERVIEW_ALLOWED_TOOLS.map((t) => t.toLowerCase()));
+const DENIED = new Set(INTERVIEW_DENIED_TOOLS.map((t) => t.toLowerCase()));
+export function isInterviewToolAllowed(toolId) {
+    return ALLOWED.has(toolId.trim().toLowerCase());
+}
+export function isInterviewToolDenied(toolId) {
+    const id = toolId.trim().toLowerCase();
+    if (DENIED.has(id))
+        return true;
+    // normalize snake/camel: contractApply already listed; catch run-dag variants
+    const compact = id.replace(/[-_]/g, "");
+    for (const d of DENIED) {
+        if (d.replace(/[-_]/g, "") === compact)
+            return true;
+    }
+    return false;
+}
+/**
+ * Gate 1/2/3: session create, setActiveTools, and each tool call.
+ */
+export function authorizeInterviewTool(toolId) {
+    const id = toolId.trim();
+    if (!id) {
+        return {
+            ok: false,
+            code: "tool-denied",
+            toolId: id,
+            message: "empty tool id is not allowed in Requirement Interview",
+        };
+    }
+    if (isInterviewToolDenied(id) || !isInterviewToolAllowed(id)) {
+        return {
+            ok: false,
+            code: "tool-denied",
+            toolId: id,
+            message: `tool "${id}" is not permitted in Requirement Interview (no contractApply/runDag/reconcile/edit/write/bash)`,
+        };
+    }
+    return { ok: true, toolId: id };
+}
+export function filterActiveInterviewTools(requested) {
+    const allowed = [];
+    const denied = [];
+    for (const toolId of requested) {
+        const decision = authorizeInterviewTool(toolId);
+        if (decision.ok)
+            allowed.push(decision.toolId);
+        else
+            denied.push(toolId);
+    }
+    return { allowed, denied };
+}
+export function createInterviewResourceLoader() {
+    let active = new Set();
+    return {
+        mode: "requirement-interview",
+        allowedToolIds: INTERVIEW_ALLOWED_TOOLS,
+        deniedToolIds: INTERVIEW_DENIED_TOOLS,
+        listTools: () => INTERVIEW_ALLOWED_TOOLS,
+        tryActivateTool: (toolId) => {
+            const decision = authorizeInterviewTool(toolId);
+            if (decision.ok)
+                active.add(decision.toolId);
+            return decision;
+        },
+        setActiveToolsByName: (names) => {
+            const { allowed, denied } = filterActiveInterviewTools(names);
+            active = new Set(allowed);
+            return { active: [...active], denied };
+        },
+        allowsEnvToolRestore: false,
+    };
+}

package/dist/worker/console/loopback.js

@@ -0,0 +1,16 @@
+/**
+ * Console-local loopback host check. Non-loopback binds fail closed
+ * (unlike Observe, which only warns).
+ */
+export function isLoopbackHost(host) {
+    const normalized = host.trim().toLowerCase();
+    if (!normalized)
+        return false;
+    if (normalized === "localhost" ||
+        normalized === "::1" ||
+        normalized === "[::1]") {
+        return true;
+    }
+    // 127.0.0.0/8
+    return /^127(?:\.\d{1,3}){3}$/.test(normalized);
+}

package/dist/worker/console/observe-health-match.js

@@ -0,0 +1,174 @@
+/**
+ * Observe health match classification (Phase 3).
+ * Fail-closed deep links: only same-repo + schema + required capability.
+ */
+export const OBSERVE_START_COMMAND = "agent-worker observe serve --repo . --port 8787";
+export const DEFAULT_OBSERVE_BASE_URL = "http://127.0.0.1:8787";
+export function capabilityForObserveTarget(target) {
+    switch (target.kind) {
+        case "dag":
+            return "dagRun";
+        case "task":
+            return "task";
+        case "feature":
+            return "feature";
+        case "worker":
+            return "workerRun";
+        case "batch":
+            return "batch";
+        default: {
+            const _exhaustive = target;
+            throw new Error(`capabilityForObserveTarget: unsupported ${JSON.stringify(_exhaustive)}`);
+        }
+    }
+}
+/**
+ * Classify Observe /api/health body against local repo fingerprint + required capability.
+ * Pure function — no I/O.
+ */
+export function classifyObserveHealth(input) {
+    const url = input.healthUrl ?? `${DEFAULT_OBSERVE_BASE_URL}/api/health`;
+    const startCommand = OBSERVE_START_COMMAND;
+    const body = input.healthBody;
+    if (body === null || body === undefined || typeof body !== "object") {
+        return {
+            status: "unavailable",
+            url,
+            message: "Observe health body missing or not JSON object",
+            startCommand,
+            body,
+            localFingerprint: input.localFingerprint,
+            requiredCapability: input.requiredCapability,
+        };
+    }
+    const health = body;
+    if (health.ok !== true) {
+        return {
+            status: "unavailable",
+            url,
+            message: "Observe health ok !== true",
+            startCommand,
+            body,
+            localFingerprint: input.localFingerprint,
+            requiredCapability: input.requiredCapability,
+        };
+    }
+    const schemaVersion = typeof health.schemaVersion === "number" ? health.schemaVersion : undefined;
+    if (schemaVersion !== 1) {
+        return {
+            status: "mismatch",
+            url,
+            message: `Observe schemaVersion mismatch (expected 1, got ${String(health.schemaVersion)})`,
+            startCommand,
+            body,
+            localFingerprint: input.localFingerprint,
+            schemaVersion,
+            requiredCapability: input.requiredCapability,
+        };
+    }
+    const remoteFingerprint = typeof health.repoFingerprint === "string"
+        ? health.repoFingerprint
+        : undefined;
+    if (!remoteFingerprint || remoteFingerprint !== input.localFingerprint) {
+        return {
+            status: "mismatch",
+            url,
+            message: "Observe repoFingerprint does not match local worktree",
+            startCommand,
+            body,
+            localFingerprint: input.localFingerprint,
+            remoteFingerprint,
+            schemaVersion,
+            requiredCapability: input.requiredCapability,
+        };
+    }
+    if (input.requiredCapability) {
+        const caps = health.routeCapabilities ?? {};
+        const capabilityOk = caps[input.requiredCapability] === true;
+        if (!capabilityOk) {
+            return {
+                status: "mismatch",
+                url,
+                message: `Observe missing route capability: ${input.requiredCapability}`,
+                startCommand,
+                body,
+                localFingerprint: input.localFingerprint,
+                remoteFingerprint,
+                schemaVersion,
+                requiredCapability: input.requiredCapability,
+                capabilityOk: false,
+            };
+        }
+        return {
+            status: "match",
+            url,
+            message: "Observe health matches local repo and required capability",
+            startCommand,
+            body,
+            localFingerprint: input.localFingerprint,
+            remoteFingerprint,
+            schemaVersion,
+            requiredCapability: input.requiredCapability,
+            capabilityOk: true,
+        };
+    }
+    return {
+        status: "match",
+        url,
+        message: "Observe health matches local repo",
+        startCommand,
+        body,
+        localFingerprint: input.localFingerprint,
+        remoteFingerprint,
+        schemaVersion,
+    };
+}
+/**
+ * Probe Observe /api/health and classify against local fingerprint.
+ * Network failure → unavailable (non-blocking for Console doctor).
+ */
+export async function probeAndClassifyObserve(input) {
+    const base = input.baseUrl.replace(/\/+$/, "");
+    const healthUrl = `${base}/api/health`;
+    const fetchImpl = input.fetchImpl ?? fetch;
+    const timeoutMs = input.timeoutMs ?? 1500;
+    try {
+        const response = await fetchImpl(healthUrl, {
+            method: "GET",
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        if (!response.ok) {
+            return {
+                status: "unavailable",
+                url: healthUrl,
+                message: `HTTP ${response.status}`,
+                startCommand: OBSERVE_START_COMMAND,
+                localFingerprint: input.localFingerprint,
+                requiredCapability: input.requiredCapability,
+            };
+        }
+        let body;
+        try {
+            body = await response.json();
+        }
+        catch {
+            body = undefined;
+        }
+        return classifyObserveHealth({
+            localFingerprint: input.localFingerprint,
+            healthBody: body,
+            requiredCapability: input.requiredCapability,
+            healthUrl,
+        });
+    }
+    catch (error) {
+        return {
+            status: "unavailable",
+            url: healthUrl,
+            message: error instanceof Error ? error.message : String(error),
+            startCommand: OBSERVE_START_COMMAND,
+            localFingerprint: input.localFingerprint,
+            requiredCapability: input.requiredCapability,
+        };
+    }
+}

package/dist/worker/console/observe-link.js

@@ -0,0 +1,33 @@
+/**
+ * Observe hash-route deep-link builder (Phase 1 skeleton).
+ * Does not mount/proxy Observe or fetch its snapshot.
+ */
+function stripTrailingSlash(baseUrl) {
+    return baseUrl.replace(/\/+$/, "");
+}
+/**
+ * Build a browser URL into an independent Observe instance.
+ * Shape mirrors Observe hash routes (`#/dag/...`, `#/task/...`, …).
+ */
+export function buildObserveDeepLink(baseUrl, target) {
+    const base = stripTrailingSlash(baseUrl.trim());
+    if (!base) {
+        throw new Error("buildObserveDeepLink: baseUrl is required");
+    }
+    switch (target.kind) {
+        case "dag":
+            return `${base}/#/dag/${encodeURIComponent(target.dagRunId)}`;
+        case "task":
+            return `${base}/#/task/${encodeURIComponent(target.taskId)}`;
+        case "feature":
+            return `${base}/#/feature/${encodeURIComponent(target.featureId)}`;
+        case "worker":
+            return `${base}/#/run/${encodeURIComponent(target.workerRunId)}`;
+        case "batch":
+            return `${base}/#/batch/${encodeURIComponent(target.batchRunId)}`;
+        default: {
+            const _exhaustive = target;
+            throw new Error(`buildObserveDeepLink: unsupported target ${JSON.stringify(_exhaustive)}`);
+        }
+    }
+}

package/dist/worker/console/operation-runner.js

@@ -0,0 +1,166 @@
+import { clipPreview, } from "./operation-store.js";
+import { stateEvent } from "./operation-sse.js";
+/**
+ * Execute a queued operation via LoopAgentClient (or inject).
+ * Timeout without proven exit → needs-reconcile (never Cancel).
+ */
+export async function runOperation(operationId, deps) {
+    const op = await deps.store.get(operationId);
+    if (!op) {
+        throw new Error(`operation not found: ${operationId}`);
+    }
+    if (op.state !== "queued" && op.state !== "needs-reconcile") {
+        return op;
+    }
+    const args = op.cliArgs;
+    if (!args || args.length === 0) {
+        const failed = await deps.store.update(operationId, {
+            state: "failed",
+            finishedAt: new Date().toISOString(),
+            errorCode: "INVALID_INPUT",
+            errorMessage: "operation has no cliArgs to execute",
+        });
+        stateEvent(deps.events, failed, "failed", failed.errorMessage);
+        return failed;
+    }
+    await deps.store.update(operationId, {
+        state: "starting",
+        startedAt: new Date().toISOString(),
+        controllerIdentity: deps.client.getIdentity?.(),
+    });
+    stateEvent(deps.events, op, "starting", "spawning sibling loop-agent");
+    const run = deps.runCommand ??
+        ((cliArgs, options) => deps.client.run(cliArgs, options));
+    let finished;
+    try {
+        const result = await run(args, {
+            cwd: deps.repoRoot,
+            artifactName: `operation-${operationId}`,
+            expectJson: true,
+            timeoutMs: deps.defaultTimeoutMs,
+            onSpawn: (info) => {
+                void deps.store.update(operationId, {
+                    state: "running",
+                    pid: info.pid,
+                    processStartIdentity: info.startedAt,
+                });
+                stateEvent(deps.events, op, "running", `pid=${info.pid ?? "?"}`);
+            },
+            onStdout: (chunk) => {
+                deps.events.append(operationId, {
+                    at: new Date().toISOString(),
+                    kind: "stdout",
+                    message: chunk,
+                });
+            },
+            onStderr: (chunk) => {
+                deps.events.append(operationId, {
+                    at: new Date().toISOString(),
+                    kind: "stderr",
+                    message: chunk,
+                });
+            },
+        });
+        finished = await finalizeFromWorkerResult(operationId, result, deps);
+    }
+    catch (error) {
+        // Cannot prove CLI exit classification → needs-reconcile (not Cancel)
+        finished = await deps.store.update(operationId, {
+            state: "needs-reconcile",
+            finishedAt: new Date().toISOString(),
+            errorCode: "OPERATION_NEEDS_RECONCILE",
+            errorMessage: error instanceof Error ? error.message : String(error),
+        });
+        stateEvent(deps.events, finished, "needs-reconcile", finished.errorMessage);
+        deps.events.append(operationId, {
+            at: new Date().toISOString(),
+            kind: "error",
+            message: finished.errorMessage,
+            state: "needs-reconcile",
+        });
+    }
+    return finished;
+}
+async function finalizeFromWorkerResult(operationId, result, deps) {
+    const previewStdout = clipPreview(result.stdout ?? "");
+    const previewStderr = clipPreview(result.stderr ?? "");
+    const artifactRefs = {
+        stdoutPath: result.artifacts.stdoutPath,
+        stderrPath: result.artifacts.stderrPath,
+        resultPath: result.artifacts.resultPath,
+        dir: result.artifacts.dir,
+    };
+    if (result.timedOut) {
+        // Supervisory timeout without classified CLI timeout → needs-reconcile
+        // Only mark timed-out when we have a machine timeout result after exit.
+        const state = result.exitCode !== null ? "timed-out" : "needs-reconcile";
+        const updated = await deps.store.update(operationId, {
+            state,
+            finishedAt: new Date().toISOString(),
+            artifactRefs,
+            stdoutPreview: previewStdout,
+            stderrPreview: previewStderr,
+            errorCode: state === "timed-out" ? "INTERNAL_ERROR" : "OPERATION_NEEDS_RECONCILE",
+            errorMessage: state === "timed-out"
+                ? "CLI timed out with process exit"
+                : "timeout reached without proven process exit; needs reconcile (not cancelled)",
+            result: coerceEnvelope(result),
+        });
+        stateEvent(deps.events, updated, state, updated.errorMessage);
+        return updated;
+    }
+    const envelope = coerceEnvelope(result);
+    const ok = envelope?.ok === true || (result.ok && result.exitCode === 0);
+    const state = ok ? "succeeded" : "failed";
+    const updated = await deps.store.update(operationId, {
+        state,
+        finishedAt: new Date().toISOString(),
+        artifactRefs,
+        stdoutPreview: previewStdout,
+        stderrPreview: previewStderr,
+        result: envelope ?? {
+            exitCode: result.exitCode,
+            ok: result.ok,
+            stdout: previewStdout,
+            stderr: previewStderr,
+        },
+        errorCode: ok ? undefined : (envelope?.error?.code ?? "INTERNAL_ERROR"),
+        errorMessage: ok
+            ? undefined
+            : (envelope?.error?.message ??
+                `command failed with exit ${result.exitCode}`),
+    });
+    stateEvent(deps.events, updated, state);
+    deps.events.append(operationId, {
+        at: new Date().toISOString(),
+        kind: "result",
+        state,
+        data: { ok, exitCode: result.exitCode },
+    });
+    return updated;
+}
+function coerceEnvelope(result) {
+    const json = result.json;
+    if (!json || typeof json !== "object")
+        return undefined;
+    const rec = json;
+    if (rec.schemaVersion === 1 && typeof rec.ok === "boolean") {
+        return json;
+    }
+    return undefined;
+}
+/** Fire-and-forget scheduler for accepted operations. */
+export function scheduleOperation(operationId, deps) {
+    void runOperation(operationId, deps).catch((error) => {
+        void deps.store
+            .update(operationId, {
+            state: "needs-reconcile",
+            finishedAt: new Date().toISOString(),
+            errorCode: "OPERATION_NEEDS_RECONCILE",
+            errorMessage: error instanceof Error ? error.message : String(error),
+        })
+            .catch(() => {
+            // ignore secondary failures
+        });
+    });
+}