@tea-agent/loop-agent 0.41.1-beta.0 → 0.42.0-next.2

package/dist/executors/pi-read-budget-policy.js

@@ -1,239 +0,0 @@
-import { access, open, readFile, stat, } from "node:fs/promises";
-import path from "node:path";
-class PiReadBudgetSoftLimitError extends Error {
-}
-class PiReadAccessDeniedError extends Error {
-}
-class PiReadBudgetGuard {
-    budget;
-    files = new Set();
-    violations = [];
-    bytes = 0;
-    operations = 0;
-    startedAt = Date.now();
-    allowedReadPaths;
-    allowedReadRoots;
-    constructor(budget, readAccess) {
-        this.budget = budget;
-        this.allowedReadPaths = readAccess?.allowedReadPaths
-            ? new Set(readAccess.allowedReadPaths.map((candidate) => path.resolve(candidate)))
-            : undefined;
-        this.allowedReadRoots = (readAccess?.allowedReadRoots ?? []).map((candidate) => path.resolve(candidate));
-    }
-    issues() {
-        return [...this.violations];
-    }
-    report(message) {
-        if (!this.violations.includes(message))
-            this.violations.push(message);
-    }
-    exhaust(message) {
-        if (this.budget.onExhaustion === "return-guidance") {
-            throw new PiReadBudgetSoftLimitError(message);
-        }
-        this.report(message);
-        throw new Error(message);
-    }
-    assertElapsed() {
-        if (this.budget.maxMs === undefined)
-            return;
-        const elapsedMs = Date.now() - this.startedAt;
-        if (elapsedMs > this.budget.maxMs) {
-            const message = `read budget exhausted: ${elapsedMs}ms (budget ${this.budget.maxMs}ms)`;
-            this.exhaust(message);
-        }
-    }
-    beforeToolOperation() {
-        this.assertElapsed();
-        if (this.budget.maxOperations === undefined)
-            return true;
-        if (this.operations >= this.budget.maxOperations) {
-            const message = `read budget exhausted: operation ${this.operations + 1} would exceed ${this.budget.maxOperations} read-only tool calls`;
-            if (this.budget.onExhaustion === "return-guidance")
-                return false;
-            this.exhaust(message);
-        }
-        this.operations += 1;
-        return true;
-    }
-    operationLimitGuidance() {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: "[read limit reached: no repository data was read. Do not call discovery tools again; use injected facts, commit remaining record_* facts, then call finalize_plan exactly once.]",
-                },
-            ],
-        };
-    }
-    readAccessGuidance() {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: "[read denied: this node may read only named upstream artifacts or Scout-confirmed paths. Do not explore a new repository path; use committed facts or record an evidence gap, then finish the required terminal protocol.]",
-                },
-            ],
-        };
-    }
-    assertReadablePath(absolutePath) {
-        if (!this.allowedReadPaths)
-            return;
-        const resolved = path.resolve(absolutePath);
-        if (this.allowedReadPaths.has(resolved))
-            return;
-        if (this.allowedReadRoots.some((root) => resolved === root || resolved.startsWith(`${root}${path.sep}`)))
-            return;
-        throw new PiReadAccessDeniedError(`read access denied: ${resolved}`);
-    }
-    reserveFile(absolutePath) {
-        this.assertElapsed();
-        if (this.files.has(absolutePath))
-            return;
-        if (this.files.size >= this.budget.maxFiles) {
-            const message = `read budget exhausted: file ${absolutePath} would exceed ${this.budget.maxFiles} files`;
-            this.exhaust(message);
-        }
-        this.files.add(absolutePath);
-    }
-    reserveBytes(bytes) {
-        this.assertElapsed();
-        const remaining = Math.max(0, this.budget.maxBytes - this.bytes);
-        if (remaining === 0) {
-            const message = `read budget exhausted: ${this.bytes} bytes (budget ${this.budget.maxBytes})`;
-            this.exhaust(message);
-        }
-        const granted = Math.min(bytes, remaining);
-        if (granted < bytes && this.budget.onExhaustion === "return-guidance") {
-            this.exhaust(`read budget exhausted: ${bytes} requested bytes would exceed ${this.budget.maxBytes} bytes`);
-        }
-        this.bytes += granted;
-        if (granted < bytes) {
-            this.report(`read budget truncated: ${bytes} requested bytes at ${this.bytes}/${this.budget.maxBytes} bytes`);
-        }
-        return granted;
-    }
-    async readFile(absolutePath) {
-        this.assertReadablePath(absolutePath);
-        this.reserveFile(absolutePath);
-        const metadata = await stat(absolutePath);
-        const granted = this.reserveBytes(metadata.size);
-        if (granted === metadata.size)
-            return await readFile(absolutePath);
-        const handle = await open(absolutePath, "r");
-        try {
-            const buffer = Buffer.allocUnsafe(granted);
-            const { bytesRead } = await handle.read(buffer, 0, granted, 0);
-            return buffer.subarray(0, bytesRead);
-        }
-        finally {
-            await handle.close();
-        }
-    }
-    async access(absolutePath) {
-        this.assertReadablePath(absolutePath);
-        this.reserveFile(absolutePath);
-        await access(absolutePath);
-    }
-    limitToolResult(result) {
-        if (!result || typeof result !== "object" || !Array.isArray(result.content)) {
-            return result;
-        }
-        const content = result.content.map((item) => {
-            if (!item || item.type !== "text" || typeof item.text !== "string") {
-                this.report("read budget truncated: non-text tool result omitted");
-                return {
-                    type: "text",
-                    text: "[read budget reached: non-text result omitted]",
-                };
-            }
-            const granted = this.reserveBytes(Buffer.byteLength(item.text));
-            return {
-                ...item,
-                text: truncateUtf8(item.text, granted),
-            };
-        });
-        return { ...result, content };
-    }
-}
-function truncateUtf8(text, maxBytes) {
-    if (Buffer.byteLength(text) <= maxBytes)
-        return text;
-    const marker = "\n[read result truncated by node budget]";
-    const markerBytes = Buffer.byteLength(marker);
-    if (maxBytes <= markerBytes)
-        return truncateUtf8Prefix(marker, maxBytes);
-    const contentBudget = maxBytes - markerBytes;
-    return `${truncateUtf8Prefix(text, contentBudget)}${marker}`;
-}
-function truncateUtf8Prefix(text, maxBytes) {
-    let result = "";
-    let bytes = 0;
-    for (const codePoint of text) {
-        const size = Buffer.byteLength(codePoint);
-        if (bytes + size > maxBytes)
-            break;
-        result += codePoint;
-        bytes += size;
-    }
-    return result;
-}
-function wrapTool(definition, guard, consumeResult) {
-    return {
-        ...definition,
-        async execute(...args) {
-            try {
-                if (!guard.beforeToolOperation())
-                    return guard.operationLimitGuidance();
-                const result = await definition.execute(...args);
-                return consumeResult ? guard.limitToolResult(result) : result;
-            }
-            catch (error) {
-                if (error instanceof PiReadBudgetSoftLimitError) {
-                    return guard.operationLimitGuidance();
-                }
-                if (error instanceof PiReadAccessDeniedError) {
-                    return guard.readAccessGuidance();
-                }
-                throw error;
-            }
-        },
-    };
-}
-/**
- * Override Pi's built-in read-only tools with SDK definitions that meter the
- * content before it reaches the model. The read tool caps filesystem bytes at
- * the operation boundary; grep/find/ls have their returned payload clipped
- * before the agent receives it. This is SDK-only by design: the CLI backend
- * cannot inject same-name built-in overrides safely.
- */
-export async function createPiReadBudgetCustomTools(input) {
-    const sdk = (await import("@earendil-works/pi-coding-agent"));
-    const createReadToolDefinition = sdk.createReadToolDefinition;
-    const createGrepToolDefinition = sdk.createGrepToolDefinition;
-    const createFindToolDefinition = sdk.createFindToolDefinition;
-    const createLsToolDefinition = sdk.createLsToolDefinition;
-    if (typeof createReadToolDefinition !== "function" ||
-        typeof createGrepToolDefinition !== "function" ||
-        typeof createFindToolDefinition !== "function" ||
-        typeof createLsToolDefinition !== "function") {
-        throw new Error("pi read budget policy unavailable: SDK read/grep/find/ls tool factories missing");
-    }
-    const guard = new PiReadBudgetGuard(input.budget, input.readAccess);
-    const read = wrapTool(createReadToolDefinition(input.repoRoot, {
-        operations: {
-            readFile: (absolutePath) => guard.readFile(absolutePath),
-            access: (absolutePath) => guard.access(absolutePath),
-        },
-    }), guard, false);
-    const grep = wrapTool(createGrepToolDefinition(input.repoRoot), guard, true);
-    const find = wrapTool(createFindToolDefinition(input.repoRoot), guard, true);
-    const ls = wrapTool(createLsToolDefinition(input.repoRoot), guard, true);
-    if (read.name !== "read" ||
-        grep.name !== "grep" ||
-        find.name !== "find" ||
-        ls.name !== "ls") {
-        throw new Error("pi read budget policy unavailable: SDK tool name mismatch");
-    }
-    return { customTools: [read, grep, find, ls], issues: () => guard.issues() };
-}

package/dist/worker/console/frontend-human-decision-adapter.js

@@ -1,19 +0,0 @@
-import { parseFrontendHumanDecisionProjection } from "../../workflows/dag/frontend-human-decision.js";
-/** Worker/Console persistence seam. Canonical validation and freshness remain in the workflow service. */
-export function createFrontendHumanDecisionAdapter(store) {
-    return {
-        async load(operationId) {
-            const record = await store.get(operationId);
-            if (!record || record.revision === undefined || !record.frontendHumanDecision)
-                return undefined;
-            return { revision: record.revision, projection: parseFrontendHumanDecisionProjection(record.frontendHumanDecision) };
-        },
-        materialize(input) {
-            return store.materializeFrontendHumanDecision(input);
-        },
-        consume(input) {
-            return store.consumeFrontendHumanDecision(input);
-        },
-        initializeSplit: store.initializeFrontendHumanApprovedSplit.bind(store),
-    };
-}

package/dist/worker/console/frontend-split-operation-adapter.js

@@ -1,20 +0,0 @@
-import { FrontendSplitOrchestrator, frontendSplitProjectionSchema, } from "../../workflows/dag/frontend-split-application-service.js";
-/** Worker/Console boundary adapter. All orchestration policy remains canonical. */
-export function createFrontendSplitOperationAdapter(dependencies) {
-    const ports = {
-        load: async (operationId) => {
-            const record = await dependencies.store.get(operationId);
-            return record?.frontendSplit === undefined ? undefined : frontendSplitProjectionSchema.parse(record.frontendSplit);
-        },
-        compareAndSwap: (input) => dependencies.store.compareAndSwapFrontendSplit(input),
-        materialize: async (request) => {
-            const result = await dependencies.materializer.materialize(request);
-            return { taskId: result.taskId, operationId: result.operationId };
-        },
-        schedule: dependencies.schedule,
-        auditStale: dependencies.auditStale,
-        loadChildCloseoutFacts: (input) => dependencies.store.loadChildCloseoutFacts(input),
-        settleAggregate: (input) => dependencies.store.settleFrontendSplitAggregate({ ...input, prepareAggregate: dependencies.prepareAggregate }),
-    };
-    return new FrontendSplitOrchestrator(ports);
-}

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

@@ -1,389 +0,0 @@
-import { randomBytes } from "node:crypto";
-import path from "node:path";
-import { assertFrontendSplitProjectionSuccessor, frontendSplitProjectionSchema, } from "../../workflows/dag/frontend-split-application-service.js";
-import { buildFrontendHumanDecisionProjection, consumeFrontendHumanDecision, materializeFrontendHumanDecision, parseFrontendHumanDecisionProjection, parseFrontendHumanDecisionReceipt, } from "../../workflows/dag/frontend-human-decision.js";
-import { buildFrontendSplitAggregateCloseout, computeFrontendSplitDigest, finalizeFrontendSplitAggregate, frontendCommittedFactRefSchema, frontendSplitChildCloseoutFactsSchema, initializeFrontendSplitParent, } from "../../workflows/dag/frontend-split-orchestrator.js";
-import { frontendCloseoutFactsSchema, frontendTestHandoffSchema, } from "../../workflows/dag/frontend-closeout.js";
-import { listJsonFiles, readJsonIfExists, sha256Json, writeSecureJson, } from "./app-data.js";
-export const TERMINAL_OPERATION_STATES = new Set(["succeeded", "failed", "timed-out", "restarting"]);
-function operationFile(appData, operationId) {
-    return path.join(appData.operations, `${operationId}.json`);
-}
-function requestIndexFile(appData, clientRequestId) {
-    const safe = clientRequestId.replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 180);
-    return path.join(appData.operations, `req-${safe}.json`);
-}
-export function computeActionPayloadHash(action, actionParams) {
-    return sha256Json({ action, actionParams });
-}
-export function newOperationId() {
-    return `op_${randomBytes(12).toString("hex")}`;
-}
-const sharedWriteChains = new Map();
-export class OperationStore {
-    appData;
-    /** Shared per-store-root, per-key write lock. Multiple OperationStore instances
-     * in one worker process must observe the same CAS critical section. */
-    writeChains;
-    constructor(appData) {
-        this.appData = appData;
-        const root = path.resolve(appData.operations);
-        let chains = sharedWriteChains.get(root);
-        if (!chains) {
-            chains = new Map();
-            sharedWriteChains.set(root, chains);
-        }
-        this.writeChains = chains;
-    }
-    serialize(key, op) {
-        const prev = this.writeChains.get(key) ?? Promise.resolve();
-        const next = prev.then(op, op);
-        this.writeChains.set(key, next.then(() => undefined, () => undefined));
-        return next;
-    }
-    async create(input) {
-        const clientRequestId = input.clientRequestId.trim();
-        if (!clientRequestId) {
-            throw new Error("clientRequestId is required for mutation operations");
-        }
-        const payloadHash = computeActionPayloadHash(input.action, input.actionParams);
-        return this.serialize(`req:${clientRequestId}`, async () => {
-            const indexPath = requestIndexFile(this.appData, clientRequestId);
-            const existingIndex = await readJsonIfExists(indexPath);
-            if (existingIndex) {
-                const existing = await this.get(existingIndex.operationId);
-                if (existing) {
-                    if (existing.payloadHash === payloadHash) {
-                        return { kind: "idempotent", operation: existing };
-                    }
-                    return {
-                        kind: "conflict",
-                        code: "REQUEST_ID_REUSE_CONFLICT",
-                        message: `clientRequestId ${clientRequestId} was reused with a different payload`,
-                        existing,
-                    };
-                }
-            }
-            const operationId = newOperationId();
-            const now = new Date().toISOString();
-            const operation = {
-                schemaVersion: 1,
-                operationId,
-                clientRequestId,
-                action: input.action,
-                actionParams: input.actionParams,
-                payloadHash,
-                state: "queued",
-                createdAt: now,
-                revision: 1,
-                taskId: input.taskId,
-                cliArgs: input.cliArgs,
-                ...(input.externalCommand
-                    ? { externalCommand: input.externalCommand }
-                    : {}),
-            };
-            await writeSecureJson(operationFile(this.appData, operationId), operation);
-            await writeSecureJson(indexPath, { operationId, payloadHash });
-            return { kind: "created", operation };
-        });
-    }
-    /**
-     * Idempotently materialize a split child/integration operation with a
-     * caller-specified deterministic operationId (from the split manifest).
-     * Unlike create() (random op_<hex> id) and save/update (no create), this is
-     * the durable cross-restart idempotency boundary for the production
-     * FrontendSplitTaskMaterializer backend: an existing operation file with the
-     * same taskId + payloadHash is returned as {created:false}; any drift fails
-     * closed instead of overwriting or silently diverging.
-     */
-    async ensureSplitMaterializedOperation(input) {
-        return this.serialize(input.operationId, async () => {
-            const existing = await this.get(input.operationId);
-            if (existing) {
-                if (existing.taskId !== input.taskId ||
-                    existing.payloadHash !== input.payloadHash) {
-                    throw new Error("frontend split operation materialization payload drift");
-                }
-                return { operation: existing, created: false };
-            }
-            const now = new Date().toISOString();
-            const operation = {
-                schemaVersion: 1,
-                operationId: input.operationId,
-                clientRequestId: `split:${input.operationId}`,
-                action: input.action,
-                actionParams: input.actionParams,
-                payloadHash: input.payloadHash,
-                state: "queued",
-                createdAt: now,
-                revision: 1,
-                taskId: input.taskId,
-                ...(input.cliArgs ? { cliArgs: input.cliArgs } : {}),
-            };
-            await writeSecureJson(operationFile(this.appData, input.operationId), operation);
-            return { operation, created: true };
-        });
-    }
-    async get(operationId) {
-        return readJsonIfExists(operationFile(this.appData, operationId));
-    }
-    async save(operation) {
-        return this.serialize(operation.operationId, async () => {
-            const current = await this.get(operation.operationId);
-            if (current?.revision !== undefined && operation.revision !== current.revision)
-                throw new Error("operation revision may not be changed by save");
-            if (operation.frontendHumanDecision !== undefined || current?.frontendHumanDecision !== undefined) {
-                if (!current || JSON.stringify(operation) !== JSON.stringify(current))
-                    throw new Error("human-decision projection may only be mutated by canonical CAS");
-                return current;
-            }
-            if (operation.frontendSplit !== undefined || current?.frontendSplit !== undefined) {
-                if (!current || JSON.stringify(operation) !== JSON.stringify(current))
-                    throw new Error("split projection may only be mutated by compareAndSwapFrontendSplit");
-                return current;
-            }
-            await writeSecureJson(operationFile(this.appData, operation.operationId), operation);
-            return operation;
-        });
-    }
-    async update(operationId, patch) {
-        return this.serialize(operationId, async () => {
-            const current = await this.get(operationId);
-            if (!current) {
-                throw new Error(`operation not found: ${operationId}`);
-            }
-            if ("frontendHumanDecision" in patch || (current.frontendHumanDecision !== undefined && ("state" in patch || "frontendExecution" in patch)))
-                throw new Error("human-decision projection may only be mutated by canonical CAS");
-            if ("frontendSplit" in patch || "revision" in patch || (current.frontendSplit !== undefined && ("state" in patch || "frontendExecution" in patch)))
-                throw new Error("split projection may only be mutated by compareAndSwapFrontendSplit");
-            const next = {
-                ...current,
-                ...patch,
-                operationId: current.operationId,
-                schemaVersion: 1,
-                clientRequestId: current.clientRequestId,
-                payloadHash: current.payloadHash,
-                action: current.action,
-                createdAt: current.createdAt,
-            };
-            await writeSecureJson(operationFile(this.appData, operationId), next);
-            return next;
-        });
-    }
-    async materializeFrontendHumanDecision(input) {
-        return this.serialize(input.operationId, async () => {
-            const current = await this.get(input.operationId);
-            if (!current || current.revision === undefined || current.revision !== input.expectedRecordRevision) {
-                const fallback = current?.frontendHumanDecision ?? buildFrontendHumanDecisionProjection({ status: "active", operationId: input.operationId, runId: input.envelope.runId, revision: Math.max(1, input.expectedRecordRevision) });
-                return { outcome: "rejected", reason: "record revision conflict or legacy record", projection: fallback };
-            }
-            const projection = current.frontendHumanDecision ?? buildFrontendHumanDecisionProjection({ status: "active", operationId: current.operationId, runId: input.envelope.runId, revision: current.revision });
-            const result = materializeFrontendHumanDecision({ projection, envelope: input.envelope, expectedRecordRevision: input.expectedRecordRevision, expectedProjectionDigest: input.expectedProjectionDigest });
-            if (result.outcome !== "applied")
-                return result;
-            const record = { ...current, revision: result.projection.revision, frontendHumanDecision: result.projection, state: "running" };
-            await writeSecureJson(operationFile(this.appData, current.operationId), record);
-            return result;
-        });
-    }
-    async consumeFrontendHumanDecision(input) {
-        return this.serialize(input.operationId, async () => {
-            const current = await this.get(input.operationId);
-            if (!current || current.revision === undefined || !current.frontendHumanDecision) {
-                const fallback = buildFrontendHumanDecisionProjection({ status: "active", operationId: input.operationId, runId: input.receipt.runId, revision: Math.max(1, input.expectedRecordRevision) });
-                return { outcome: "rejected", reason: "record has no mutable human-decision projection", projection: fallback };
-            }
-            const projection = parseFrontendHumanDecisionProjection(current.frontendHumanDecision);
-            if (current.revision !== input.expectedRecordRevision)
-                return { outcome: "rejected", reason: "record revision conflict", projection };
-            const result = consumeFrontendHumanDecision({ projection, receipt: input.receipt, expectedRecordRevision: input.expectedRecordRevision, expectedProjectionDigest: input.expectedProjectionDigest, currentTargetDigest: input.currentTargetDigest, now: input.now });
-            if (result.outcome !== "applied")
-                return result;
-            const record = { ...current, revision: result.projection.revision, frontendHumanDecision: result.projection };
-            await writeSecureJson(operationFile(this.appData, current.operationId), record);
-            return result;
-        });
-    }
-    async initializeFrontendHumanApprovedSplit(input) {
-        return this.serialize(input.operationId, async () => {
-            const current = await this.get(input.operationId);
-            const fallback = current?.frontendHumanDecision ?? buildFrontendHumanDecisionProjection({ status: "active", operationId: input.operationId, runId: input.receipt.runId, revision: Math.max(1, input.expectedRecordRevision) });
-            if (!current || current.revision === undefined || current.revision !== input.expectedRecordRevision || !current.frontendHumanDecision || !current.frontendExecution || current.frontendSplit)
-                return { outcome: "rejected", reason: "record is not an authoritative pending single-task split", projection: fallback };
-            const humanProjection = parseFrontendHumanDecisionProjection(current.frontendHumanDecision);
-            if (humanProjection.status !== "blocked-human" || humanProjection.envelope.kind !== "split-materialization-approval" || humanProjection.digest !== input.expectedProjectionDigest)
-                return { outcome: "rejected", reason: "pending split envelope conflict", projection: humanProjection };
-            const receipt = parseFrontendHumanDecisionReceipt(input.receipt);
-            if (receipt.kind !== "split-materialization-approval")
-                return { outcome: "rejected", reason: "receipt is not a split approval", projection: humanProjection };
-            if (JSON.stringify(current.frontendExecution) !== JSON.stringify(input.execution) || input.execution.kind !== "single-task")
-                return { outcome: "rejected", reason: "single-task execution conflict", projection: humanProjection };
-            const consumed = consumeFrontendHumanDecision({ projection: humanProjection, receipt, expectedRecordRevision: input.expectedRecordRevision, expectedProjectionDigest: input.expectedProjectionDigest, currentTargetDigest: input.currentTargetDigest, now: input.now });
-            if (consumed.outcome !== "applied")
-                return consumed;
-            const initialized = initializeFrontendSplitParent({
-                execution: input.execution,
-                manifest: input.manifest,
-                expectedOperationRevision: input.execution.operationRevision,
-                successorOperationRevision: consumed.projection.revision,
-                envelopeTargetDigest: humanProjection.envelope.targetDigest,
-                activeWriterOperationId: input.activeWriterOperationId,
-                activeProviderOperationId: input.activeProviderOperationId,
-                authorization: { mode: "human", envelope: humanProjection.envelope, receipt },
-            });
-            if (initialized.outcome !== "applied")
-                return { outcome: "rejected", reason: initialized.reason, projection: humanProjection };
-            const splitProjection = frontendSplitProjectionSchema.parse({ revision: consumed.projection.revision, execution: initialized.execution, manifest: input.manifest, parent: initialized.parent });
-            const { frontendExecution: _singleTask, ...withoutSingleTask } = current;
-            const record = { ...withoutSingleTask, revision: consumed.projection.revision, frontendHumanDecision: consumed.projection, frontendSplit: splitProjection, state: "running" };
-            await writeSecureJson(operationFile(this.appData, current.operationId), record);
-            return { outcome: "applied", projection: splitProjection, humanDecision: consumed.projection };
-        });
-    }
-    async compareAndSwapFrontendSplit(input) {
-        return this.serialize(input.operationId, async () => {
-            const current = await this.get(input.operationId);
-            if (!current || current.revision === undefined || current.revision !== input.expectedRevision)
-                return { outcome: "conflict" };
-            const currentProjection = current.frontendSplit;
-            if (currentProjection) {
-                if (currentProjection.execution.digest !== input.expectedExecutionDigest || currentProjection.parent.digest !== input.expectedParentDigest)
-                    return { outcome: "conflict" };
-            }
-            else if (input.expectedExecutionDigest || input.expectedParentDigest)
-                return { outcome: "conflict" };
-            const next = currentProjection
-                ? assertFrontendSplitProjectionSuccessor(currentProjection, input.next)
-                : frontendSplitProjectionSchema.parse(input.next);
-            if (next.revision !== current.revision + 1 || next.parent.operationId !== input.operationId)
-                throw new Error("split CAS next revision or operation binding mismatch");
-            const state = next.parent.operationState === "success" ? "succeeded" : next.parent.operationTerminal !== undefined ? "failed" : current.state;
-            const record = { ...current, revision: next.revision, frontendSplit: next, state };
-            await writeSecureJson(operationFile(this.appData, input.operationId), record);
-            return { outcome: "applied", projection: next };
-        });
-    }
-    async loadChildCloseoutFacts(input) {
-        const factsDir = input.closeoutRef.ref;
-        const facts = await readJsonIfExists(path.join(factsDir, "frontend-closeout-facts.json"));
-        if (facts === undefined)
-            return frontendSplitChildCloseoutFactsSchema.parse({ childId: input.childId, residualRisks: [], frontendTestHandoffRef: undefined });
-        const parsedFacts = frontendCloseoutFactsSchema.parse(facts);
-        if (computeFrontendSplitDigest(parsedFacts) !== input.closeoutRef.digest)
-            throw new Error(`child closeout facts digest mismatch: ${input.childId}`);
-        const handoff = await readJsonIfExists(path.join(factsDir, "frontend-test-handoff.json"));
-        const frontendTestHandoffRef = handoff === undefined ? undefined : computeFrontendSplitDigest(frontendTestHandoffSchema.parse(handoff));
-        return frontendSplitChildCloseoutFactsSchema.parse({ childId: input.childId, residualRisks: parsedFacts.residualRisks ?? [], frontendTestHandoffRef });
-    }
-    async settleFrontendSplitAggregate(input) {
-        return this.serialize(input.operationId, async () => {
-            const record = await this.get(input.operationId);
-            if (!record || record.revision === undefined || record.revision !== input.expectedRevision || !record.frontendSplit)
-                return { outcome: "conflict" };
-            const authoritative = frontendSplitProjectionSchema.parse(record.frontendSplit);
-            if (authoritative.parent.operationId !== input.operationId
-                || authoritative.revision !== input.expectedRevision
-                || authoritative.execution.digest !== input.expectedExecutionDigest
-                || authoritative.parent.digest !== input.expectedParentDigest
-                || authoritative.manifest.digest !== input.expectedManifestDigest
-                || authoritative.candidateBinding?.digest !== input.expectedCandidateBindingDigest
-                || authoritative.integrationBinding?.digest !== input.expectedIntegrationBindingDigest)
-                return { outcome: "conflict" };
-            if (!authoritative.candidateBinding)
-                return { outcome: "conflict" };
-            const expectedAggregate = buildFrontendSplitAggregateCloseout(authoritative.parent, authoritative.manifest, authoritative.candidateBinding, authoritative.integrationBinding, input.childCloseoutFacts);
-            if (JSON.stringify(expectedAggregate) !== JSON.stringify(input.aggregate))
-                return { outcome: "conflict" };
-            const transaction = await input.prepareAggregate({
-                operationId: authoritative.parent.operationId,
-                aggregate: expectedAggregate,
-            });
-            try {
-                const committedRef = frontendCommittedFactRefSchema.parse(transaction.committedRef);
-                const finalized = finalizeFrontendSplitAggregate(authoritative.parent, expectedAggregate, committedRef);
-                const next = assertFrontendSplitProjectionSuccessor(authoritative, { ...authoritative, revision: authoritative.revision + 1, parent: finalized.parent, execution: finalized.execution, aggregateCloseout: { value: expectedAggregate, committedRef } });
-                const nextRecord = { ...record, revision: next.revision, frontendSplit: next, state: "succeeded" };
-                await transaction.commit({
-                    parentRecordPath: operationFile(this.appData, record.operationId),
-                    parentRecord: nextRecord,
-                });
-                return { outcome: "applied", projection: next };
-            }
-            catch (error) {
-                await transaction.rollback();
-                throw error;
-            }
-        });
-    }
-    async initializeFrontendSplit(expectedRevision, projectionValue) {
-        const projection = frontendSplitProjectionSchema.parse(projectionValue);
-        return this.serialize(projection.parent.operationId, async () => {
-            const current = await this.get(projection.parent.operationId);
-            if (!current || current.revision === undefined || current.revision !== expectedRevision || current.frontendSplit !== undefined || projection.revision !== expectedRevision + 1)
-                return { outcome: "conflict" };
-            const record = { ...current, revision: projection.revision, frontendSplit: projection };
-            await writeSecureJson(operationFile(this.appData, current.operationId), record);
-            return { outcome: "applied", projection };
-        });
-    }
-    async list() {
-        const files = await listJsonFiles(this.appData.operations);
-        const ops = [];
-        for (const file of files) {
-            const base = path.basename(file);
-            if (base.startsWith("req-"))
-                continue;
-            const rec = await readJsonIfExists(file);
-            if (rec?.operationId)
-                ops.push(rec);
-        }
-        ops.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
-        return ops;
-    }
-    /**
-     * On Console boot: any non-terminal operation that cannot be proven still
-     * running becomes needs-reconcile (never invent succeeded/failed).
-     */
-    async reconcileOnBoot(options) {
-        const isAlive = options?.isProcessAlive ??
-            ((pid) => {
-                try {
-                    process.kill(pid, 0);
-                    return true;
-                }
-                catch {
-                    return false;
-                }
-            });
-        const changed = [];
-        for (const op of await this.list()) {
-            if (TERMINAL_OPERATION_STATES.has(op.state))
-                continue;
-            if (op.state === "needs-reconcile")
-                continue;
-            let next;
-            if (op.state === "running" &&
-                typeof op.pid === "number" &&
-                isAlive(op.pid, op.processStartIdentity)) {
-                // still running — leave as-is
-                continue;
-            }
-            // queued/starting/running without proven process → needs-reconcile
-            next = await this.update(op.operationId, {
-                state: "needs-reconcile",
-                errorCode: "OPERATION_NEEDS_RECONCILE",
-                errorMessage: "Console restart or lost process evidence; operation needs reconcile (not cancelled)",
-            });
-            changed.push(next);
-        }
-        return changed;
-    }
-}
-export function isTerminalOperationState(state) {
-    return TERMINAL_OPERATION_STATES.has(state);
-}
-export function clipPreview(text, max = 4096) {
-    if (text.length <= max)
-        return text;
-    return `${text.slice(0, max)}\n…[truncated ${text.length - max} chars]`;
-}

package/dist/worker/console/static/assets/channel-bnXW0U3C.js

@@ -1 +0,0 @@
-import{ag as o,ah as n}from"./mermaid.core-Cxg8kX8V.js";const t=(a,r)=>o.lang.round(n.parse(a)[r]);export{t as c};