@tea-agent/loop-agent 0.16.25 → 0.17.0

package/dist/worker/console/dag-confirmation.js

@@ -0,0 +1,313 @@
+import { createHash, randomBytes } from "node:crypto";
+import path from "node:path";
+import { readJsonIfExists, sha256Utf8, writeSecureJson, } from "./app-data.js";
+export const ALL_CONFIRMATION_CHALLENGES = [
+    "source",
+    "writer-scope",
+    "verification",
+    "human-gates",
+];
+export const DEFAULT_CONFIRMATION_TTL_MS = 30 * 60 * 1000;
+function confirmationPath(appData, confirmationId) {
+    return path.join(appData.confirmations, `${confirmationId}.json`);
+}
+export function newConfirmationId() {
+    return `conf_${randomBytes(12).toString("hex")}`;
+}
+export function hashDagBytes(bytes) {
+    return createHash("sha256").update(bytes).digest("hex");
+}
+export function resolveRequiredCurrentBindings(current) {
+    if (!current) {
+        return {
+            ok: false,
+            message: "server-derived current bindings are required (dagSha256, sourceBindingSha256, taskContractBinding, controllerFingerprint, validationResultSha256)",
+        };
+    }
+    const dagSha256 = typeof current.dagSha256 === "string" ? current.dagSha256.trim() : "";
+    const sourceBindingSha256 = typeof current.sourceBindingSha256 === "string"
+        ? current.sourceBindingSha256.trim()
+        : "";
+    const controllerFingerprint = typeof current.controllerFingerprint === "string"
+        ? current.controllerFingerprint.trim()
+        : "";
+    const validationResultSha256 = typeof current.validationResultSha256 === "string"
+        ? current.validationResultSha256.trim()
+        : "";
+    const taskContractBinding = current.taskContractBinding;
+    const missing = [];
+    if (!dagSha256)
+        missing.push("dagSha256");
+    if (!sourceBindingSha256)
+        missing.push("sourceBindingSha256");
+    if (!controllerFingerprint)
+        missing.push("controllerFingerprint");
+    if (!validationResultSha256)
+        missing.push("validationResultSha256");
+    if (!taskContractBinding ||
+        typeof taskContractBinding !== "object" ||
+        typeof taskContractBinding.taskId !== "string" ||
+        !taskContractBinding.taskId.trim()) {
+        missing.push("taskContractBinding");
+    }
+    if (missing.length > 0) {
+        return {
+            ok: false,
+            message: `missing server-derived current bindings: ${missing.join(", ")}`,
+        };
+    }
+    return {
+        ok: true,
+        value: {
+            dagSha256,
+            sourceBindingSha256,
+            controllerFingerprint,
+            validationResultSha256,
+            taskContractBinding: taskContractBinding,
+        },
+    };
+}
+function detectBindingDrift(rec, current) {
+    if (current.dagSha256 !== rec.dagSha256) {
+        return "dagSha256 binding drift";
+    }
+    if (current.sourceBindingSha256 !== rec.sourceBindingSha256) {
+        return "sourceBindingSha256 binding drift";
+    }
+    if (current.controllerFingerprint !== rec.controllerFingerprint) {
+        return "controllerFingerprint binding drift";
+    }
+    if (current.validationResultSha256 !== rec.validationResultSha256) {
+        return "validationResultSha256 binding drift";
+    }
+    const a = sha256Utf8(JSON.stringify(rec.taskContractBinding));
+    const b = sha256Utf8(JSON.stringify(current.taskContractBinding));
+    if (a !== b)
+        return "taskContractBinding drift";
+    return undefined;
+}
+export class DagConfirmationStore {
+    appData;
+    constructor(appData) {
+        this.appData = appData;
+    }
+    async get(confirmationId) {
+        const rec = await readJsonIfExists(confirmationPath(this.appData, confirmationId));
+        if (!rec)
+            return undefined;
+        return this.materializeExpiry(rec);
+    }
+    async materializeExpiry(rec, now = Date.now()) {
+        if ((rec.state === "prepared" || rec.state === "confirmed") &&
+            Date.parse(rec.expiresAt) <= now) {
+            const expired = {
+                ...rec,
+                state: "expired",
+                staleReason: rec.staleReason ?? "ttl exceeded (30min default)",
+            };
+            await writeSecureJson(confirmationPath(this.appData, rec.confirmationId), expired);
+            return expired;
+        }
+        return rec;
+    }
+    async prepare(input) {
+        const now = input.now ?? new Date();
+        const ttl = input.ttlMs ?? DEFAULT_CONFIRMATION_TTL_MS;
+        const confirmationId = newConfirmationId();
+        const rec = {
+            schemaVersion: 1,
+            confirmationId,
+            state: "prepared",
+            preparedAt: now.toISOString(),
+            expiresAt: new Date(now.getTime() + ttl).toISOString(),
+            operatorSessionId: input.operatorSessionId,
+            dagHandle: input.dagHandle,
+            dagSha256: hashDagBytes(input.dagBytes),
+            dagBytesPath: input.dagBytesPath,
+            sourceBindingSha256: input.sourceBindingSha256,
+            taskContractBinding: input.taskContractBinding,
+            controllerFingerprint: input.controllerFingerprint,
+            validationResultSha256: input.validationResultSha256,
+            confirmedWriterScopes: input.confirmedWriterScopes ?? [],
+            confirmedChallenges: [],
+            reviewPacket: input.reviewPacket,
+        };
+        await writeSecureJson(confirmationPath(this.appData, confirmationId), rec);
+        return rec;
+    }
+    async confirm(input) {
+        const resolved = resolveRequiredCurrentBindings(input.current);
+        if (!resolved.ok) {
+            return {
+                ok: false,
+                code: "INVALID_INPUT",
+                message: resolved.message,
+            };
+        }
+        const current = resolved.value;
+        const rec = await this.get(input.confirmationId);
+        if (!rec) {
+            return {
+                ok: false,
+                code: "NOT_FOUND",
+                message: `confirmation not found: ${input.confirmationId}`,
+            };
+        }
+        if (rec.state === "expired") {
+            return {
+                ok: false,
+                code: "CONFIRMATION_EXPIRED",
+                message: "confirmation expired",
+                confirmation: rec,
+            };
+        }
+        if (rec.state === "consumed") {
+            return {
+                ok: false,
+                code: "CONFIRMATION_CONSUMED",
+                message: "confirmation already consumed",
+                confirmation: rec,
+            };
+        }
+        if (rec.state === "stale") {
+            return {
+                ok: false,
+                code: "CONFIRMATION_STALE",
+                message: rec.staleReason ?? "confirmation is stale",
+                confirmation: rec,
+            };
+        }
+        if (rec.operatorSessionId !== input.operatorSessionId) {
+            return {
+                ok: false,
+                code: "HUMAN_CONFIRMATION_REQUIRED",
+                message: "operatorSessionId mismatch; re-run human challenge after session rebuild",
+                confirmation: rec,
+            };
+        }
+        const drift = detectBindingDrift(rec, current);
+        if (drift) {
+            const stale = await this.markStale(rec.confirmationId, drift);
+            return {
+                ok: false,
+                code: "CONFIRMATION_STALE",
+                message: drift,
+                confirmation: stale,
+            };
+        }
+        const required = new Set(ALL_CONFIRMATION_CHALLENGES);
+        for (const c of input.challenges)
+            required.delete(c);
+        if (required.size > 0) {
+            return {
+                ok: false,
+                code: "HUMAN_CONFIRMATION_REQUIRED",
+                message: `missing confirmation challenges: ${[...required].join(", ")}`,
+                confirmation: rec,
+            };
+        }
+        const now = input.now ?? new Date();
+        const confirmed = {
+            ...rec,
+            state: "confirmed",
+            confirmedAt: now.toISOString(),
+            confirmedChallenges: [...ALL_CONFIRMATION_CHALLENGES],
+        };
+        await writeSecureJson(confirmationPath(this.appData, rec.confirmationId), confirmed);
+        return { ok: true, confirmation: confirmed };
+    }
+    /**
+     * Atomic single-use consume for runDag. Revalidates bindings first.
+     */
+    async consume(input) {
+        const rec = await this.get(input.confirmationId);
+        if (!rec) {
+            return {
+                ok: false,
+                code: "NOT_FOUND",
+                message: `confirmation not found: ${input.confirmationId}`,
+            };
+        }
+        if (rec.state === "expired") {
+            return {
+                ok: false,
+                code: "CONFIRMATION_EXPIRED",
+                message: "confirmation expired",
+                confirmation: rec,
+            };
+        }
+        if (rec.state === "consumed") {
+            return {
+                ok: false,
+                code: "CONFIRMATION_CONSUMED",
+                message: "confirmation already consumed (single-use)",
+                confirmation: rec,
+            };
+        }
+        if (rec.state === "stale") {
+            return {
+                ok: false,
+                code: "CONFIRMATION_STALE",
+                message: rec.staleReason ?? "confirmation is stale",
+                confirmation: rec,
+            };
+        }
+        if (rec.state !== "confirmed") {
+            return {
+                ok: false,
+                code: "HUMAN_CONFIRMATION_REQUIRED",
+                message: `confirmation is ${rec.state}; human confirm required before runDag`,
+                confirmation: rec,
+            };
+        }
+        if (rec.operatorSessionId !== input.operatorSessionId) {
+            return {
+                ok: false,
+                code: "HUMAN_CONFIRMATION_REQUIRED",
+                message: "session mismatch; re-confirm after boot/session rebuild",
+                confirmation: rec,
+            };
+        }
+        const drift = detectBindingDrift(rec, input.current);
+        if (drift) {
+            const stale = await this.markStale(rec.confirmationId, drift);
+            return {
+                ok: false,
+                code: "CONFIRMATION_STALE",
+                message: drift,
+                confirmation: stale,
+            };
+        }
+        // Re-check dag hash matches staged bytes path contract
+        if (rec.dagSha256 !== input.current.dagSha256) {
+            const stale = await this.markStale(rec.confirmationId, "dagSha256 mismatch on consume");
+            return {
+                ok: false,
+                code: "CONFIRMATION_STALE",
+                message: "dagSha256 mismatch on consume",
+                confirmation: stale,
+            };
+        }
+        const now = input.now ?? new Date();
+        const consumed = {
+            ...rec,
+            state: "consumed",
+            consumedAt: now.toISOString(),
+        };
+        await writeSecureJson(confirmationPath(this.appData, rec.confirmationId), consumed);
+        return { ok: true, confirmation: consumed };
+    }
+    async markStale(confirmationId, reason) {
+        const rec = await this.get(confirmationId);
+        if (!rec) {
+            throw new Error(`confirmation not found: ${confirmationId}`);
+        }
+        const stale = {
+            ...rec,
+            state: "stale",
+            staleReason: reason,
+        };
+        await writeSecureJson(confirmationPath(this.appData, confirmationId), stale);
+        return stale;
+    }
+}

package/dist/worker/console/doctor.js

@@ -0,0 +1,169 @@
+import { mkdtemp } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { LoopAgentClient } from "../loop-agent/loop-agent-client.js";
+import { preflightTargetRepo } from "../preflight.js";
+import { probePiReadiness, } from "./pi-readiness.js";
+import { DEFAULT_OBSERVE_BASE_URL, OBSERVE_START_COMMAND, probeAndClassifyObserve, } from "./observe-health-match.js";
+import { repoFingerprintV1 } from "./repo-fingerprint.js";
+import { resolveSiblingLoopAgentBin } from "./sibling-controller.js";
+async function probeObserve(url, localFingerprint, fetchImpl) {
+    const classified = await probeAndClassifyObserve({
+        baseUrl: url,
+        localFingerprint,
+        fetchImpl,
+    });
+    if (classified.status === "unavailable") {
+        return {
+            status: "unavailable",
+            url: classified.url,
+            message: classified.message,
+            match: "unavailable",
+            startCommand: OBSERVE_START_COMMAND,
+        };
+    }
+    if (classified.status === "mismatch") {
+        return {
+            status: "mismatch",
+            url: classified.url,
+            body: classified.body,
+            match: "mismatch",
+            message: classified.message,
+            startCommand: OBSERVE_START_COMMAND,
+        };
+    }
+    // match — keep status "ok" for backward compatibility; also expose match
+    return {
+        status: "ok",
+        url: classified.url,
+        body: classified.body,
+        match: "match",
+        startCommand: OBSERVE_START_COMMAND,
+        message: classified.message,
+    };
+}
+/**
+ * Run console doctor checks. Observe unavailability never fails the report.
+ */
+export async function runConsoleDoctor(options) {
+    const repoRoot = path.resolve(options.repoRoot);
+    let fingerprint;
+    try {
+        fingerprint = repoFingerprintV1(repoRoot);
+    }
+    catch (error) {
+        fingerprint = `error:${error instanceof Error ? error.message : String(error)}`;
+    }
+    let siblingBin;
+    let controllerIdentity;
+    if (options.identity) {
+        controllerIdentity = options.identity;
+    }
+    else {
+        try {
+            siblingBin = options.loopAgentBin ?? resolveSiblingLoopAgentBin();
+            const artifactRoot = await mkdtemp(path.join(os.tmpdir(), "console-doctor-"));
+            const client = new LoopAgentClient({
+                loopAgentBin: siblingBin,
+                artifactRoot,
+                resolveIdentity: true,
+            });
+            controllerIdentity = client.getIdentity();
+        }
+        catch (error) {
+            controllerIdentity = {
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    let preflight;
+    if (options.preflight) {
+        const p = options.preflight;
+        preflight = p.ok
+            ? { ok: true, summary: `version=${p.version}` }
+            : { ok: false, code: p.code, message: p.message };
+    }
+    else if (siblingBin) {
+        try {
+            const artifactRoot = await mkdtemp(path.join(os.tmpdir(), "console-doctor-preflight-"));
+            const client = new LoopAgentClient({
+                loopAgentBin: siblingBin,
+                artifactRoot,
+                resolveIdentity: true,
+            });
+            const result = await preflightTargetRepo({
+                repoRoot,
+                client,
+                runCheckRepo: false,
+            });
+            preflight = result.ok
+                ? { ok: true, summary: `version=${result.version}` }
+                : { ok: false, code: result.code, message: result.message };
+        }
+        catch (error) {
+            preflight = {
+                ok: false,
+                code: "preflight-error",
+                message: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    else {
+        preflight = {
+            ok: false,
+            code: "sibling-unavailable",
+            message: "cannot run preflight without sibling loop-agent bin",
+        };
+    }
+    const observeBase = options.observeBaseUrl ?? DEFAULT_OBSERVE_BASE_URL;
+    const observe = await probeObserve(observeBase, fingerprint, options.fetchImpl ?? fetch);
+    const pi = await probePiReadiness({
+        override: options.piReadinessProbe,
+        siblingControllerOk: Boolean(controllerIdentity && "packageVersion" in controllerIdentity),
+    });
+    return {
+        ok: true,
+        product: "loop-operator-console",
+        productName: "Loop Operator Console",
+        repoRoot,
+        repoFingerprint: fingerprint,
+        controllerIdentity,
+        siblingLoopAgentBin: siblingBin,
+        preflight,
+        piReadiness: pi.state,
+        pi,
+        observe,
+        generatedAt: new Date().toISOString(),
+    };
+}
+export function formatConsoleDoctorHuman(report) {
+    const lines = [
+        "Loop Operator Console — doctor",
+        `repoRoot: ${report.repoRoot}`,
+        `repoFingerprint: ${report.repoFingerprint}`,
+        `piReadiness: ${report.piReadiness}`,
+        `pi.sdk: ${report.pi.probe.sdkAvailable}`,
+        `pi.auth: ${report.pi.probe.authReady}`,
+        `pi.models: ${report.pi.probe.modelsAvailable}`,
+        `pi.interviewSession: ${report.pi.probe.interviewSessionOk}`,
+        `preflight: ${report.preflight.ok ? `ok (${report.preflight.summary})` : `fail ${report.preflight.code}: ${report.preflight.message}`}`,
+        `observe: ${report.observe.status}${report.observe.status === "unavailable" || report.observe.status === "mismatch" ? ` (${report.observe.message})` : ""}`,
+    ];
+    if (report.observe.status === "unavailable" ||
+        report.observe.status === "mismatch") {
+        lines.push(`observe.startCommand: ${report.observe.startCommand ?? OBSERVE_START_COMMAND}`);
+    }
+    if (report.siblingLoopAgentBin) {
+        lines.push(`siblingLoopAgentBin: ${report.siblingLoopAgentBin}`);
+    }
+    if (report.controllerIdentity &&
+        "packageVersion" in report.controllerIdentity) {
+        const id = report.controllerIdentity;
+        lines.push(`controller: ${id.packageName}@${id.packageVersion} fingerprint=${id.packageFingerprint.value}`);
+    }
+    else if (report.controllerIdentity &&
+        "error" in report.controllerIdentity) {
+        lines.push(`controller: error ${report.controllerIdentity.error}`);
+    }
+    return `${lines.join("\n")}\n`;
+}

package/dist/worker/console/draft-store.js

@@ -0,0 +1,80 @@
+import path from "node:path";
+import { readJsonIfExists, sha256Json, writeSecureJson, } from "./app-data.js";
+function draftPath(appData, taskId) {
+    const safe = taskId.replace(/[^a-zA-Z0-9._-]+/g, "_");
+    return path.join(appData.drafts, `${safe}.json`);
+}
+export function computeDraftSha256(draft) {
+    // Hash a stable projection excluding updatedAt so pure timestamp churn
+    // does not invalidate assessments — still any field change does.
+    const { updatedAt: _u, ...rest } = draft;
+    return sha256Json(rest);
+}
+export class DraftStore {
+    appData;
+    constructor(appData) {
+        this.appData = appData;
+    }
+    getAppData() {
+        return this.appData;
+    }
+    /** Absolute drafts directory (must not be under repo .harness). */
+    draftsDir() {
+        return this.appData.drafts;
+    }
+    async get(taskId) {
+        const file = draftPath(this.appData, taskId);
+        const draft = await readJsonIfExists(file);
+        if (!draft)
+            return undefined;
+        return {
+            draft,
+            draftSha256: computeDraftSha256(draft),
+            path: file,
+        };
+    }
+    async save(draft) {
+        if (!draft.taskId?.trim()) {
+            throw new Error("draft.taskId is required");
+        }
+        if (draft.schemaVersion !== 1) {
+            throw new Error("unsupported draft schemaVersion");
+        }
+        const next = {
+            ...draft,
+            schemaVersion: 1,
+            updatedAt: new Date().toISOString(),
+        };
+        const file = draftPath(this.appData, next.taskId);
+        await writeSecureJson(file, next);
+        return {
+            draft: next,
+            draftSha256: computeDraftSha256(next),
+            path: file,
+        };
+    }
+    async update(taskId, patch) {
+        const current = await this.get(taskId);
+        const base = current?.draft ??
+            {
+                schemaVersion: 1,
+                taskId,
+                title: taskId,
+            };
+        const merged = {
+            ...base,
+            ...patch,
+            schemaVersion: 1,
+            taskId,
+        };
+        return this.save(merged);
+    }
+}
+export function assertDraftNotInHarness(draftFilePath, repoRoot) {
+    const normalizedDraft = path.resolve(draftFilePath);
+    const harness = path.resolve(repoRoot, ".harness");
+    const prefix = harness.endsWith(path.sep) ? harness : harness + path.sep;
+    if (normalizedDraft === harness || normalizedDraft.startsWith(prefix)) {
+        throw new Error(`Draft path must not be under repo .harness: ${normalizedDraft}`);
+    }
+}

package/dist/worker/console/index.js

@@ -0,0 +1,15 @@
+export { createConsoleServer, defaultConsoleStaticDir } from "./server.js";
+export { runConsoleDoctor, formatConsoleDoctorHuman } from "./doctor.js";
+export { isLoopbackHost } from "./loopback.js";
+export { repoFingerprintV1, normalizeWorktreeRealpath, } from "./repo-fingerprint.js";
+export { buildObserveDeepLink } from "./observe-link.js";
+export { classifyObserveHealth, probeAndClassifyObserve, capabilityForObserveTarget, OBSERVE_START_COMMAND, DEFAULT_OBSERVE_BASE_URL, } from "./observe-health-match.js";
+export { allowedRecoveryCtas, classifyRecoveryFact, recoveryMatrixInvariants, } from "./recovery-cta.js";
+export { createClosedResourceLoader, createInterviewResourceLoader, tryActivateTool, assertOfficialToolAllowed, listOfficialTools, OFFICIAL_DENIED_TOOL_IDS, INTERVIEW_ALLOWED_TOOLS, INTERVIEW_DENIED_TOOLS, authorizeInterviewTool, } from "./resource-loader.js";
+export { resolveSiblingLoopAgentBin } from "./sibling-controller.js";
+export { openConsoleAppData, defaultConsoleAppDataRoot } from "./app-data.js";
+export { OperationStore } from "./operation-store.js";
+export { createOperationEventStore } from "./operation-sse.js";
+export { DagConfirmationStore } from "./dag-confirmation.js";
+export { DraftStore } from "./draft-store.js";
+export { probePiReadiness, classifyPiReadiness, isActionBlockedByReadiness, } from "./pi-readiness.js";

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

@@ -0,0 +1,67 @@
+import { randomBytes } from "node:crypto";
+import path from "node:path";
+import { readJsonIfExists, writeSecureJson, } from "../app-data.js";
+import { computeDraftSha256, } from "../draft-store.js";
+function assessmentPath(appData, assessmentId) {
+    return path.join(appData.assessments, `${assessmentId}.json`);
+}
+export function newAssessmentId() {
+    return `assessment_${randomBytes(10).toString("hex")}`;
+}
+export class AssessmentStore {
+    appData;
+    constructor(appData) {
+        this.appData = appData;
+    }
+    async get(assessmentId) {
+        return readJsonIfExists(assessmentPath(this.appData, assessmentId));
+    }
+    async save(assessment) {
+        await writeSecureJson(assessmentPath(this.appData, assessment.assessmentId), assessment);
+        return assessment;
+    }
+    async create(input) {
+        const assessment = {
+            schemaVersion: 1,
+            assessmentId: newAssessmentId(),
+            draftSha256: computeDraftSha256(input.draft),
+            sourceManifestSha256: input.sourceManifestSha256,
+            instructionVersion: input.instructionVersion,
+            provider: input.provider,
+            model: input.model,
+            sessionId: input.sessionId,
+            turnId: input.turnId,
+            assessedAt: new Date().toISOString(),
+            outcome: input.outcome,
+        };
+        return this.save(assessment);
+    }
+}
+/**
+ * Fresh complete assessment must bind current draftSha256 (and optional source).
+ * Any draft field change → stale (no semantic-equivalence escape hatch).
+ */
+export function isAssessmentFreshForDraft(assessment, draft, options) {
+    if (assessment.outcome !== "complete") {
+        return {
+            fresh: false,
+            reason: `assessment outcome is ${assessment.outcome}, need complete`,
+        };
+    }
+    const currentHash = computeDraftSha256(draft);
+    if (assessment.draftSha256 !== currentHash) {
+        return {
+            fresh: false,
+            reason: "draftSha256 mismatch; assessment is stale after Draft change",
+        };
+    }
+    if (options?.sourceManifestSha256 !== undefined &&
+        assessment.sourceManifestSha256 !== undefined &&
+        assessment.sourceManifestSha256 !== options.sourceManifestSha256) {
+        return {
+            fresh: false,
+            reason: "sourceManifestSha256 mismatch; assessment is stale",
+        };
+    }
+    return { fresh: true };
+}