@tea-agent/loop-agent 0.40.0-next.1 → 0.40.0-next.10

package/dist/worker/console/workspace-context.js

@@ -0,0 +1,234 @@
+/**
+ * Repo-scoped Workspace Context (2026-08-22 multi-workspace foundation, W1).
+ *
+ * One lazily-created ConsoleContext per workspaceId. Each context INDEPENDENTLY
+ * owns the full operator runtime for its repo root: fingerprint-isolated
+ * appData (via openConsoleAppData), operation/event stores, draft /
+ * confirmation / receipt / interview / assessment stores, Chat session store +
+ * events + deferred Turn registry + ConsolePiRuntime(cwd=repoRoot),
+ * OperatorActionContext, Observe route context, and readiness.
+ *
+ * Invariants:
+ *   - Selecting (viewing) another workspace NEVER disposes a context; running
+ *     Turns / Operations / DAGs continue in the background.
+ *   - dispose() is invoked exactly once per context by the owning server's
+ *     close().
+ *   - bootToken is shared per Console boot: it binds the startup fingerprint
+ *     and bind host, and its confirmationToken signs human-gate tokens for all
+ *     workspaces in this process (single Console security domain).
+ */
+import { randomBytes } from "node:crypto";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { LoopAgentClient } from "../loop-agent/loop-agent-client.js";
+import { openConsoleAppData } from "./app-data.js";
+import { DagConfirmationStore } from "./dag-confirmation.js";
+import { DagExecutionReceiptStore } from "./dag-execution-receipt.js";
+import { DraftStore } from "./draft-store.js";
+import { AssessmentStore } from "./interview/assessment.js";
+import { InterviewSessionStore } from "./interview/session.js";
+import { ChatSessionStore } from "./chat/session-store.js";
+import { createChatEventStore, createChatOperationLinker, } from "./chat/chat-event-store.js";
+import { createChatTurnExecutionRegistry } from "./chat/turn-execution-registry.js";
+import { ConsolePiRuntime } from "./chat/pi-runtime.js";
+import { UserQuestionRegistry } from "./chat/user-questions.js";
+import { TodoListRegistry } from "./chat/todos.js";
+import { createOperationEventStore, } from "./operation-sse.js";
+import { OperationStore } from "./operation-store.js";
+import { probePiReadiness, } from "./pi-readiness.js";
+import { resolveSiblingLoopAgentBin } from "./sibling-controller.js";
+import { NightAuxTicker } from "./night-aux-ticker.js";
+import { createObserveRouteContext, } from "../observe/routes.js";
+import { WorkspaceRegistry } from "./workspace-registry.js";
+import { resolveConsoleDefaultTimeoutMs } from "./server.js";
+/**
+ * Lazily create the full repo-scoped Console context for a registered
+ * workspace record. Pure factory — no global registry; the caller owns
+ * lifecycle (single creation per workspaceId, dispose on server close).
+ */
+export async function createWorkspaceContext(record, deps) {
+    const repoRoot = record.repoRoot;
+    const appData = openConsoleAppData({
+        repoRoot,
+        ...(deps.appDataRoot ? { appDataRoot: deps.appDataRoot } : {}),
+    });
+    const registry = new WorkspaceRegistry(appData);
+    const readiness = await probePiReadiness({
+        override: deps.piReadinessProbe,
+        repoRoot,
+    });
+    let readinessCache = readiness;
+    const artifactRoot = path.join(appData.root, "client-artifacts", appData.fingerprint);
+    const client = deps.createClient?.(artifactRoot) ??
+        new LoopAgentClient({
+            loopAgentBin: resolveSiblingLoopAgentBin(),
+            artifactRoot,
+            resolveIdentity: true,
+            defaultTimeoutMs: resolveConsoleDefaultTimeoutMs(deps.defaultTimeoutMs),
+        });
+    const operations = new OperationStore(appData);
+    const events = createOperationEventStore({
+        persistenceDir: path.join(appData.operations, "events"),
+    });
+    const drafts = new DraftStore(appData);
+    const confirmations = new DagConfirmationStore(appData, deps.bootToken.confirmationToken);
+    const dagExecutionReceipts = new DagExecutionReceiptStore(appData);
+    const interviews = new InterviewSessionStore(appData);
+    const assessments = new AssessmentStore(appData);
+    if (!deps.skipReconcile) {
+        await operations.reconcileOnBoot();
+    }
+    const getReadiness = () => readinessCache;
+    const refreshReadiness = async () => {
+        readinessCache = await probePiReadiness({
+            override: deps.piReadinessProbe,
+            repoRoot,
+        });
+        actionContext.readiness = readinessCache;
+        return readinessCache;
+    };
+    const actionContext = {
+        repoRoot,
+        appData,
+        operatorSessionId: deps.operatorSessionId,
+        client,
+        operations,
+        events,
+        drafts,
+        confirmations,
+        dagExecutionReceipts,
+        humanGateSecret: deps.bootToken.confirmationToken,
+        interviews,
+        assessments,
+        readiness: readinessCache,
+        getReadiness,
+        refreshReadiness,
+        observeBaseUrl: deps.observeBaseUrl,
+        fetchImpl: deps.fetchImpl,
+        getConsoleOrigin: deps.getConsoleOrigin,
+    };
+    const chatStore = new ChatSessionStore(appData);
+    const chatEventEpoch = randomBytes(12).toString("hex");
+    const chatEvents = createChatEventStore({
+        appData,
+        epoch: chatEventEpoch,
+    });
+    const chatTurnExecutions = createChatTurnExecutionRegistry();
+    const questionRegistry = new UserQuestionRegistry(path.join(appData.chats, "user-questions"));
+    const todoRegistry = new TodoListRegistry();
+    questionRegistry.subscribe((change) => {
+        const question = change.question;
+        chatEvents.append(question.sessionId, question.turnId ?? `${question.sessionId}:question`, {
+            kind: `question_${change.type}`,
+            data: { question },
+        });
+    });
+    todoRegistry.subscribe((change) => {
+        chatEvents.append(change.sessionId, change.turnId ?? `${change.sessionId}:todo`, {
+            kind: change.type === "updated" ? "todo_updated" : "todo_cleared",
+            data: {
+                todos: change.todos,
+                ...(change.toolCallId ? { toolCallId: change.toolCallId } : {}),
+            },
+        });
+    });
+    const chatOperationLinker = createChatOperationLinker({
+        chatEvents,
+        operations,
+        operationEvents: events,
+    });
+    const chatRuntime = new ConsolePiRuntime({
+        cwd: repoRoot,
+        sessionDir: appData.chatSessions,
+        resourcePreferencesPath: appData.resourcePreferences,
+        actionContext,
+        questionRegistry,
+        todoRegistry,
+    });
+    const chatRouteDeps = {
+        runtime: chatRuntime,
+        store: chatStore,
+        events: chatEvents,
+        turnExecutions: chatTurnExecutions,
+        questionRegistry,
+        todoRegistry,
+        operationLinker: chatOperationLinker,
+        appData,
+        bootToken: deps.bootToken,
+        getConsoleOrigin: deps.getConsoleOrigin,
+        allowNonLoopbackAccess: deps.allowNonLoopbackAccess,
+    };
+    const { recoverDeferredTurns } = await import("./chat/routes.js");
+    const nightAuxTicker = new NightAuxTicker({ repoRoot, client });
+    const observeRouteContext = createObserveRouteContext(repoRoot, {
+        staticDir: deps.inspectStaticDir,
+    });
+    let disposed = false;
+    const context = {
+        workspaceId: record.workspaceId,
+        record,
+        repoRoot,
+        appData,
+        registry,
+        client,
+        operations,
+        events,
+        drafts,
+        confirmations,
+        dagExecutionReceipts,
+        interviews,
+        assessments,
+        chatRouteDeps,
+        chatOperationLinker,
+        chatRuntime,
+        nightAuxTicker,
+        actionContext,
+        observeRouteContext,
+        getReadiness,
+        refreshReadiness,
+        recoverDeferredTurns: () => recoverDeferredTurns(chatRouteDeps),
+        dispose: () => {
+            if (disposed)
+                return;
+            disposed = true;
+            try {
+                chatOperationLinker.dispose();
+            }
+            catch {
+                // best-effort
+            }
+            try {
+                chatRuntime.disposeAll();
+            }
+            catch {
+                // best-effort
+            }
+            try {
+                nightAuxTicker.dispose();
+            }
+            catch {
+                // best-effort
+            }
+        },
+    };
+    return context;
+}
+/** Inspect-facing readiness/capability summary for a registry record. */
+export async function summarizeWorkspaceRecord(record, deps) {
+    let state;
+    try {
+        const report = await probePiReadiness({
+            override: deps.piReadinessProbe,
+            repoRoot: record.repoRoot,
+        });
+        state = report.state;
+    }
+    catch {
+        state = "setup-required";
+    }
+    return {
+        state,
+        summary: `pi=${state}; inspect=${deps.inspectReady ? "ready" : "unavailable"}`,
+    };
+}
+void existsSync;

package/dist/worker/console/workspace-registry.js

@@ -0,0 +1,214 @@
+/**
+ * User-level Workspace Registry (2026-08-22 multi-workspace foundation, W1).
+ *
+ * Persists the set of registered Console workspaces at
+ * `<appDataRoot>/workspaces.json` (user level, shared across Console boots),
+ * independent of per-repo fingerprint namespaces.
+ *
+ * Invariants:
+ *   - workspaceId is stable per normalized realpath: it is derived from
+ *     sha256("loop-console-workspace-v1\0" + realpath) and never minted twice.
+ *   - REMOVE is soft (hidden=true); on-disk directories, AppData namespaces,
+ *     Sessions, Operations and DAGs are never deleted.
+ *   - Re-adding a previously removed workspace RESTORES the original record
+ *     (same workspaceId + repoFingerprint; only lastAccessedAt advances).
+ *   - Duplicate visible realpath is rejected; add failures leave the registry
+ *     byte-identical (same ids and order).
+ */
+import { createHash, randomBytes } from "node:crypto";
+import { realpathSync, statSync } from "node:fs";
+import path from "node:path";
+import { readJsonIfExists, writeSecureJson, } from "./app-data.js";
+import { normalizeWorktreeRealpath, repoFingerprintV1, } from "./repo-fingerprint.js";
+export const WORKSPACE_REGISTRY_SCHEMA_VERSION = 1;
+/** Stable workspaceId: sha256("loop-console-workspace-v1\0" + normalizedRealpath). */
+export function workspaceIdForRealpath(normalizedRealpath) {
+    return createHash("sha256")
+        .update(`loop-console-workspace-v1\0${normalizedRealpath}`, "utf8")
+        .digest("hex");
+}
+export class WorkspaceRegistry {
+    appData;
+    options;
+    file;
+    cache;
+    constructor(appData, options = {}) {
+        this.appData = appData;
+        this.options = options;
+        this.file = path.join(appData.root, "workspaces.json");
+    }
+    /** Auto-register the startup repoRoot (idempotent). */
+    async ensureStartupWorkspace(repoRoot) {
+        const record = await this.add(repoRoot);
+        if (record.ok)
+            return record.record;
+        // Startup root may already be visible (duplicate) or previously hidden —
+        // re-adding a hidden record restores it via add(); the only expected
+        // failure left is DUPLICATE (already visible), which returns the existing.
+        const existing = await this.findByRealpath(repoRoot);
+        if (existing)
+            return existing;
+        throw new Error(`workspace registry: startup root rejected: ${record.code}`);
+    }
+    /**
+     * Register (or restore) a workspace directory.
+     * Failures never mutate the persisted registry.
+     * `options.name` overrides the default directory-name label.
+     */
+    async add(rawPath, options = {}) {
+        const trimmed = rawPath.trim();
+        if (!trimmed) {
+            return {
+                ok: false,
+                code: "INVALID_PATH",
+                message: "path is required",
+            };
+        }
+        let real;
+        try {
+            real = realpathSync(path.resolve(trimmed));
+        }
+        catch {
+            return {
+                ok: false,
+                code: "NOT_A_DIRECTORY",
+                message: `path does not exist: ${trimmed}`,
+            };
+        }
+        let st;
+        try {
+            st = statSync(real);
+        }
+        catch {
+            return {
+                ok: false,
+                code: "UNREADABLE",
+                message: `path is not readable: ${trimmed}`,
+            };
+        }
+        if (!st.isDirectory()) {
+            return {
+                ok: false,
+                code: "NOT_A_DIRECTORY",
+                message: `path is not a directory: ${trimmed}`,
+            };
+        }
+        const normalized = normalizeWorktreeRealpath(real);
+        const existing = await this.findByRealpathNormalized(normalized);
+        if (existing && !existing.hidden) {
+            return {
+                ok: false,
+                code: "DUPLICATE",
+                message: `workspace already registered: ${existing.displayPath}`,
+            };
+        }
+        const nowIso = (this.options.now ?? (() => new Date()))().toISOString();
+        if (existing) {
+            // Restore the soft-removed record; identity (workspaceId,
+            // repoFingerprint, createdAt, order) is preserved.
+            existing.hidden = undefined;
+            existing.lastAccessedAt = nowIso;
+            if (options.name && options.name.trim()) {
+                existing.name = options.name.trim();
+            }
+            const registry = await this.load();
+            await this.persist(registry);
+            return { ok: true, record: existing, registryUnchanged: false };
+        }
+        const record = {
+            workspaceId: workspaceIdForRealpath(normalized),
+            name: options.name?.trim() || path.basename(normalized) || normalized,
+            displayPath: normalized,
+            repoRoot: real,
+            repoFingerprint: repoFingerprintV1(real),
+            createdAt: nowIso,
+            lastAccessedAt: nowIso,
+        };
+        const registry = await this.load();
+        registry.workspaces.push(record);
+        await this.persist(registry);
+        return { ok: true, record, registryUnchanged: false };
+    }
+    /** Visible list in canonical insertion order. */
+    async listVisible() {
+        const registry = await this.load();
+        return registry.workspaces.filter((workspace) => {
+            if (workspace.hidden)
+                return false;
+            try {
+                return statSync(workspace.repoRoot).isDirectory();
+            }
+            catch {
+                // Keep historical registry data, but do not project stale test roots
+                // into the Workspace browser after their directories disappear.
+                return false;
+            }
+        });
+    }
+    async get(workspaceId) {
+        const registry = await this.load();
+        return registry.workspaces.find((w) => w.workspaceId === workspaceId);
+    }
+    /** Get a VISIBLE workspace by id (removed workspaces are not operable). */
+    async getVisible(workspaceId) {
+        const record = await this.get(workspaceId);
+        if (!record || record.hidden)
+            return undefined;
+        try {
+            return statSync(record.repoRoot).isDirectory() ? record : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /** Soft-remove: hides the record; never touches directories or AppData. */
+    async remove(workspaceId) {
+        const registry = await this.load();
+        const record = registry.workspaces.find((w) => w.workspaceId === workspaceId);
+        if (!record || record.hidden)
+            return false;
+        record.hidden = true;
+        await this.persist(registry);
+        return true;
+    }
+    async findByRealpath(rawPath) {
+        let normalized;
+        try {
+            normalized = normalizeWorktreeRealpath(path.resolve(rawPath.trim()));
+        }
+        catch {
+            return undefined;
+        }
+        return this.findByRealpathNormalized(normalized);
+    }
+    async findByRealpathNormalized(normalized) {
+        const registry = await this.load();
+        return registry.workspaces.find((w) => w.displayPath === normalized);
+    }
+    async load() {
+        if (this.cache)
+            return this.cache;
+        const raw = await readJsonIfExists(this.file).catch(() => undefined);
+        const registry = {
+            schemaVersion: 1,
+            workspaces: raw && Array.isArray(raw.workspaces)
+                ? raw.workspaces.filter((w) => Boolean(w) &&
+                    typeof w === "object" &&
+                    typeof w.workspaceId === "string" &&
+                    typeof w.displayPath === "string" &&
+                    typeof w.repoRoot === "string")
+                : [],
+        };
+        this.cache = registry;
+        return registry;
+    }
+    async persist(registry) {
+        // writeSecureJson is atomic; a reader mid-write sees the previous bytes.
+        await writeSecureJson(this.file, registry);
+        this.cache = registry;
+    }
+}
+/** Deterministic-looking nonce reserved for tests requiring unique roots. */
+export function mintWorkspaceNonce() {
+    return randomBytes(8).toString("hex");
+}

package/dist/worker/observability/init-runtime-activity.js

@@ -0,0 +1,26 @@
+import { readdir } from "node:fs/promises";
+import path from "node:path";
+import { buildGlobalSnapshot } from "./read-model.js";
+/**
+ * Read-only runtime guard shared by Console maintenance and init-surface
+ * writes. Worker activity remains owned by the Observe projection so both
+ * callers use one canonical liveness interpretation.
+ */
+export async function readInitRuntimeActivity(repoRoot) {
+    const resolvedRoot = path.resolve(repoRoot);
+    const activeDagRoot = path.join(resolvedRoot, ".harness", "dag-runs", "active");
+    const entries = await readdir(activeDagRoot, { withFileTypes: true }).catch(() => []);
+    const activeDagRunIds = entries
+        .filter((entry) => entry.isDirectory() && entry.name !== ".gitkeep")
+        .map((entry) => entry.name)
+        .sort();
+    const snapshot = await buildGlobalSnapshot({ repoRoot: resolvedRoot });
+    return {
+        activeDagRunIds,
+        activeWorkerBatches: snapshot.health.worker.activeBatches,
+        activeWorkerTasks: snapshot.health.worker.activeTasks,
+        ...(snapshot.projectionError
+            ? { workerProjectionError: snapshot.projectionError.message }
+            : {}),
+    };
+}

package/dist/worker/observe/node-input.js

@@ -31,6 +31,7 @@ function unavailableBody(dagRunId, nodeId, reason, warnings = []) {
         summary: null,
         dependency: null,
         prompt: null,
+        promptCandidates: [],
         executorInput: null,
         boundaries: null,
         promptFingerprint: null,
@@ -139,7 +140,7 @@ function resolveModelHint(spec, task) {
     }
     return null;
 }
-function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, piExtensionRunFacts, warnings) {
+function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, piExtensionRunFacts, promptCandidates, warnings) {
     const defaults = spec.defaults && typeof spec.defaults === "object"
         ? spec.defaults
         : undefined;
@@ -267,6 +268,7 @@ function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, piExt
             maxBytes: promptBody.maxBytes,
             source: promptSource,
         },
+        promptCandidates,
         executorInput: {
             kind,
             skills,
@@ -292,6 +294,89 @@ function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, piExt
         warnings,
     };
 }
+async function loadFailedPromptCandidates(repoRoot, dagRunId, nodeId, warnings) {
+    const stateResolved = resolveDagRunArtifact(repoRoot, dagRunId, ["state.json"]);
+    if (!stateResolved.ok)
+        return [];
+    let state;
+    try {
+        state = JSON.parse(await readFile(stateResolved.result.absolutePath, "utf-8"));
+    }
+    catch {
+        warnings.push("state.json could not be read for failed prompt candidates.");
+        return [];
+    }
+    const nodes = state.nodes && typeof state.nodes === "object" && !Array.isArray(state.nodes)
+        ? state.nodes
+        : null;
+    const node = nodes?.[nodeId] &&
+        typeof nodes[nodeId] === "object" &&
+        !Array.isArray(nodes[nodeId])
+        ? nodes[nodeId]
+        : null;
+    if (!node)
+        return [];
+    const failedAttempts = new Set();
+    if (Array.isArray(node.attempts)) {
+        for (const entry of node.attempts) {
+            if (!entry || typeof entry !== "object" || Array.isArray(entry))
+                continue;
+            const record = entry;
+            if (record.ok === false &&
+                typeof record.attempt === "number" &&
+                Number.isSafeInteger(record.attempt) &&
+                record.attempt > 0) {
+                failedAttempts.add(record.attempt);
+            }
+        }
+    }
+    if (node.status === "ERROR" &&
+        typeof node.currentAttempt === "number" &&
+        Number.isSafeInteger(node.currentAttempt) &&
+        node.currentAttempt > 0) {
+        failedAttempts.add(node.currentAttempt);
+    }
+    const candidates = [];
+    for (const attempt of [...failedAttempts].sort((a, b) => a - b)) {
+        const fileName = `prompt-candidate-attempt-${attempt}.json`;
+        const artifact = path.posix.join(nodeId, fileName);
+        const resolved = resolveDagRunArtifact(repoRoot, dagRunId, [nodeId, fileName]);
+        if (!resolved.ok) {
+            warnings.push(`Failed prompt candidate missing for attempt ${attempt}.`);
+            continue;
+        }
+        try {
+            const raw = JSON.parse(await readFile(resolved.result.absolutePath, "utf-8"));
+            if (raw.schemaVersion !== 1 ||
+                raw.attempt !== attempt ||
+                typeof raw.failureCategory !== "string" ||
+                typeof raw.prompt !== "string" ||
+                typeof raw.truncated !== "boolean" ||
+                typeof raw.maxBytes !== "number" ||
+                !Number.isSafeInteger(raw.maxBytes) ||
+                raw.maxBytes < 1 ||
+                raw.maxBytes > NODE_INPUT_PREVIEW_MAX_BYTES ||
+                typeof raw.sha256 !== "string" ||
+                !/^([a-f0-9]{64})$/.test(raw.sha256)) {
+                throw new Error("invalid candidate schema");
+            }
+            const prompt = truncatedField(raw.prompt, raw.maxBytes);
+            candidates.push({
+                attempt,
+                failureCategory: redactSecrets(raw.failureCategory),
+                prompt: prompt.text,
+                truncated: raw.truncated || prompt.truncated,
+                maxBytes: raw.maxBytes,
+                sha256Prefix: raw.sha256.slice(0, 12),
+                artifact,
+            });
+        }
+        catch {
+            warnings.push(`Failed prompt candidate is invalid for attempt ${attempt}.`);
+        }
+    }
+    return candidates;
+}
 /**
  * Load run-time Pi extension facts from <node>/pi-extensions.json (plan
  * 2026-08-22 R2). Returns null when the node declares no piExtensions
@@ -486,8 +571,9 @@ export async function buildDagNodeInput(repoRoot, dagRunId, nodeId) {
         ? task.piExtensions.filter((item) => typeof item === "string")
         : [];
     const piExtensionRunFacts = await loadPiExtensionRunFacts(repoRoot, dagRunId, nodeId, declaredPiExtensions, warnings);
+    const promptCandidates = await loadFailedPromptCandidates(repoRoot, dagRunId, nodeId, warnings);
     // Reject unknown nested leakage by projecting only through allowlist helpers.
-    const body = projectTask(dagRunId, nodeId, runResolved.result.lifecycle, spec, task, fingerprint, piExtensionRunFacts, warnings);
+    const body = projectTask(dagRunId, nodeId, runResolved.result.lifecycle, spec, task, fingerprint, piExtensionRunFacts, promptCandidates, warnings);
     // Defense-in-depth: ensure raw task never sneaks in.
     if ("task" in body) {
         return {