@tea-agent/loop-agent 0.41.0 → 0.42.0-next.1

package/dist/shared/context-transfer.js

@@ -0,0 +1,418 @@
+import { createHash } from "node:crypto";
+import { z } from "zod";
+export const CONTEXT_TRANSFER_REASON_CODES = [
+    "CONTEXT_RECEIPT_MISSING",
+    "CONTEXT_COMPONENT_UNAVAILABLE",
+    "CONTEXT_BUNDLE_INEXACT",
+    "CONTEXT_BUNDLE_TOO_LARGE",
+    "RAW_EXPORT_ACKNOWLEDGEMENT_REQUIRED",
+    "SECRET_SCAN_CONFIRMATION_REQUIRED",
+    "ARTIFACT_BINDING_UNAVAILABLE",
+    "ARTIFACT_NOT_REVISION_ELIGIBLE",
+    "ARTIFACT_IDENTITY_AMBIGUOUS",
+    "ARTIFACT_REVISION_SCHEMA_INVALID",
+    "ARTIFACT_REVISION_PATH_INVALID",
+    "ARTIFACT_REVISION_EXPIRED",
+    "ARTIFACT_REVISION_DRIFT",
+    "ARTIFACT_REVISION_QUOTA_EXCEEDED",
+    "ARTIFACT_CONSUMER_UNKNOWN",
+    "ARTIFACT_IMPACT_UNSAFE",
+    "RERUN_PLAN_DRIFT",
+    "WORKER_MANAGED_CONTINUATION_UNSUPPORTED",
+    "WORKER_CONTINUATION_AUTHORITY_MISMATCH",
+    "WORKER_CONTINUATION_NEEDS_RECONCILE",
+];
+export const contextTransferReasonCodeSchema = z.enum(CONTEXT_TRANSFER_REASON_CODES);
+export const CONTEXT_BUNDLE_LIMITS = Object.freeze({
+    previewBytes: 64 * 1024,
+    singleFileBytes: 16 * 1024 * 1024,
+    totalUncompressedBytes: 64 * 1024 * 1024,
+    fileCount: 2_048,
+});
+const sha256Schema = z.string().regex(/^[a-f0-9]{64}$/);
+const safeRelativePosixPathSchema = z
+    .string()
+    .min(1)
+    .refine((value) => !value.includes("\0"), "path must not contain NUL")
+    .refine((value) => !value.includes("\\"), "path must use POSIX separators")
+    .refine((value) => !value.startsWith("/") &&
+    !value.startsWith("//") &&
+    !/^[A-Za-z]:/.test(value), "path must be relative")
+    .refine((value) => value.split("/").every((segment) => segment !== ".." && segment !== ""), "path must not escape or contain empty segments");
+const contextComponentSchema = z
+    .object({
+    index: z.number().int().nonnegative(),
+    kind: z.enum([
+        "system-prompt",
+        "developer-prompt",
+        "user-prompt",
+        "task-contract",
+        "execution-constraint",
+        "context-file",
+        "upstream-artifact",
+        "tool-contract",
+        "runtime-fact",
+    ]),
+    logicalName: z.string().min(1),
+    source: z
+        .object({
+        type: z.string().min(1),
+        identity: z.string().min(1),
+        revision: z.string().min(1).optional(),
+    })
+        .strict(),
+    materializedPath: safeRelativePosixPathSchema.optional(),
+    sha256: sha256Schema,
+    bytes: z.number().int().nonnegative(),
+    mediaType: z.string().min(1),
+    inclusion: z.enum([
+        "full",
+        "excerpt",
+        "summary",
+        "reference-only",
+        "omitted",
+    ]),
+    authoritativeSource: z
+        .object({ identity: z.string().min(1), sha256: sha256Schema.optional() })
+        .strict()
+        .optional(),
+    omissionReason: z.string().min(1).optional(),
+})
+    .strict();
+export const effectiveNodeContextV1Schema = z
+    .object({
+    schemaVersion: z.literal(1),
+    identity: z
+        .object({
+        runId: z.string().min(1),
+        nodeId: z.string().min(1),
+        attempt: z.number().int().positive(),
+        capturedAt: z.string().min(1),
+    })
+        .strict(),
+    orderedComponents: z.array(contextComponentSchema),
+    promptAssembly: z
+        .object({
+        strategy: z.string().min(1),
+        finalPromptSha256: sha256Schema.optional(),
+        tokenEstimate: z.number().int().nonnegative().optional(),
+        truncations: z.array(z
+            .object({
+            componentIndex: z.number().int().nonnegative(),
+            reason: z.string().min(1),
+            retainedBytes: z.number().int().nonnegative().optional(),
+        })
+            .strict()),
+    })
+        .strict(),
+    boundaries: z
+        .object({
+        allowedPaths: z.array(z.string()),
+        forbiddenPaths: z.array(z.string()),
+        writeSet: z.array(z.string()),
+    })
+        .strict(),
+    runtime: z
+        .object({
+        executor: z.string().min(1),
+        modelHint: z.string().min(1).optional(),
+        resolvedModel: z.string().min(1).optional(),
+        skills: z.array(z.string()),
+        extensions: z.array(z.string()),
+        activeTools: z.array(z.string()),
+    })
+        .strict(),
+    contextDigest: sha256Schema,
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    value.orderedComponents.forEach((component, index) => {
+        if (component.index !== index) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["orderedComponents", index, "index"],
+                message: "component indexes must be contiguous and ordered",
+            });
+        }
+    });
+});
+const bundleFileSchema = z
+    .object({
+    path: safeRelativePosixPathSchema,
+    sha256: sha256Schema,
+    bytes: z.number().int().nonnegative(),
+    mediaType: z.string().min(1),
+    origin: z.string().min(1),
+    redaction: z.enum(["none", "redacted", "omitted"]),
+    sourceSha256: sha256Schema.optional(),
+})
+    .strict();
+export const contextBundleManifestV1Schema = z
+    .object({
+    schemaVersion: z.literal(1),
+    bundleId: z.string().min(1),
+    createdAt: z.string().min(1),
+    source: z
+        .object({
+        repoIdentity: z.string().min(1),
+        taskId: z.string().min(1).optional(),
+        runId: z.string().min(1),
+        nodeId: z.string().min(1),
+        attempt: z.number().int().positive(),
+        pass: z.number().int().positive().optional(),
+        parentRunId: z.string().min(1).optional(),
+    })
+        .strict(),
+    profile: z.enum(["redacted", "raw"]),
+    target: z.enum(["generic", "pi-session", "pi-handoff", "readable"]),
+    reproducibility: z
+        .object({
+        level: z.enum([
+            "exact-pi-session",
+            "semantic-handoff",
+            "readable-transcript",
+        ]),
+        reasons: z.array(z.string()),
+        limitations: z.array(z.string()),
+    })
+        .strict(),
+    bindings: z
+        .object({
+        frozenRunSpecSha256: sha256Schema,
+        contextReceiptSha256: sha256Schema,
+        contextDigest: sha256Schema,
+        taskContractSha256: sha256Schema.optional(),
+        sourceBindingSha256: sha256Schema.optional(),
+    })
+        .strict(),
+    runtime: z
+        .object({
+        executor: z.string().min(1),
+        model: z.string().min(1).optional(),
+        provider: z.string().min(1).optional(),
+        piVersion: z.string().min(1).optional(),
+        skills: z.array(z
+            .object({
+            id: z.string().min(1),
+            version: z.string().min(1).optional(),
+            sha256: sha256Schema.optional(),
+        })
+            .strict()),
+        extensions: z.array(z
+            .object({
+            id: z.string().min(1),
+            packageName: z.string().min(1).optional(),
+            version: z.string().min(1).optional(),
+            status: z.string().min(1),
+        })
+            .strict()),
+        tools: z.array(z
+            .object({
+            name: z.string().min(1),
+            contractSha256: sha256Schema.optional(),
+            available: z.boolean(),
+        })
+            .strict()),
+    })
+        .strict(),
+    files: z.array(bundleFileSchema),
+    omissions: z.array(z
+        .object({
+        subject: z.string().min(1),
+        reasonCode: z.string().min(1),
+        detail: z.string().min(1).optional(),
+    })
+        .strict()),
+    security: z
+        .object({
+        secretScan: z.enum(["pass", "warning", "not-run"]),
+        findingCounts: z.record(z.string(), z.number().int().nonnegative()),
+        rawAcknowledgement: z
+            .object({
+            requestId: z.string().min(1),
+            acknowledgedAt: z.string().min(1),
+        })
+            .strict()
+            .optional(),
+    })
+        .strict(),
+    bundleSha256: sha256Schema,
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    const seen = new Set();
+    for (const [index, file] of value.files.entries()) {
+        const folded = file.path.normalize("NFC").toLocaleLowerCase("en-US");
+        if (seen.has(folded)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["files", index, "path"],
+                message: "bundle file paths must be unique under case folding",
+            });
+        }
+        seen.add(folded);
+    }
+    if (value.profile === "raw" && !value.security.rawAcknowledgement) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["security", "rawAcknowledgement"],
+            message: "raw bundle requires explicit acknowledgement",
+        });
+    }
+});
+export const artifactRevisionV1Schema = z
+    .object({
+    schemaVersion: z.literal(1),
+    revisionId: z.string().min(1),
+    state: z.enum([
+        "staged",
+        "validated",
+        "rejected",
+        "expired",
+        "consumed",
+        "discarded",
+    ]),
+    parent: z
+        .object({
+        runId: z.string().min(1),
+        nodeId: z.string().min(1),
+        artifactPath: safeRelativePosixPathSchema,
+        artifactSha256: sha256Schema,
+        artifactSchemaId: z.string().min(1).optional(),
+    })
+        .strict(),
+    candidate: z
+        .object({
+        stagingPath: z.string().min(1),
+        sha256: sha256Schema,
+        bytes: z.number().int().nonnegative(),
+        mediaType: z.string().min(1),
+        uploadedAt: z.string().min(1),
+        uploadedBy: z.literal("operator"),
+    })
+        .strict(),
+    validation: z
+        .object({
+        status: z.enum(["pending", "pass", "fail"]),
+        checks: z.array(z
+            .object({
+            id: z.string().min(1),
+            status: z.enum(["pass", "warning", "fail"]),
+            detail: z.string().min(1).optional(),
+        })
+            .strict()),
+    })
+        .strict(),
+    diff: z
+        .object({
+        kind: z.enum(["text", "json", "binary"]),
+        summary: z.string(),
+        previewPath: safeRelativePosixPathSchema.optional(),
+        truncated: z.boolean(),
+    })
+        .strict(),
+    expiresAt: z.string().min(1),
+    /** Explicit staging lease (M4c): fresh lease blocks conflicting holders. */
+    lease: z
+        .object({
+        holder: z.string().min(1),
+        acquiredAt: z.string().min(1),
+        expiresAt: z.string().min(1),
+    })
+        .strict()
+        .optional(),
+})
+    .strict();
+export const artifactOverrideSetV1Schema = z
+    .object({
+    schemaVersion: z.literal(1),
+    overrides: z
+        .array(z
+        .object({
+        revisionId: z.string().min(1),
+        parentArtifact: z
+            .object({
+            runId: z.string().min(1),
+            nodeId: z.string().min(1),
+            path: safeRelativePosixPathSchema,
+            sha256: sha256Schema,
+        })
+            .strict(),
+        replacement: z
+            .object({
+            sha256: sha256Schema,
+            bytes: z.number().int().nonnegative(),
+            mediaType: z.string().min(1),
+        })
+            .strict(),
+        supersedes: z.string().min(1),
+    })
+        .strict())
+        .length(1),
+    overrideSetHash: sha256Schema,
+})
+    .strict();
+const workerContinuationIdSchema = z
+    .string()
+    .min(1)
+    .regex(/^[A-Za-z0-9._-]+$/);
+/**
+ * Console-to-kernel authority for a Worker-owned artifact continuation.
+ * Every field is immutable and plan-hash-bound; the child identity is derived
+ * from the parent Worker run plus the single-use revision id.
+ */
+export const workerContinuationAuthorityV1Schema = z
+    .object({
+    schemaVersion: z.literal(1),
+    parentWorkerRunId: workerContinuationIdSchema,
+    childWorkerRunId: workerContinuationIdSchema,
+    featureId: workerContinuationIdSchema,
+    taskId: workerContinuationIdSchema,
+    batchRunId: workerContinuationIdSchema,
+    revisionId: workerContinuationIdSchema,
+})
+    .strict()
+    .superRefine((authority, ctx) => {
+    const expected = deriveWorkerContinuationRunId(authority.parentWorkerRunId, authority.revisionId);
+    if (authority.childWorkerRunId !== expected) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["childWorkerRunId"],
+            message: `childWorkerRunId must equal ${expected}`,
+        });
+    }
+});
+export function deriveWorkerContinuationRunId(parentWorkerRunId, revisionId) {
+    const digest = createHash("sha256")
+        .update(`worker-continuation-v1\0${parentWorkerRunId}\0${revisionId}`)
+        .digest("hex")
+        .slice(0, 32);
+    return `wrc-${digest}`;
+}
+export function sortKeysDeep(value) {
+    if (Array.isArray(value))
+        return value.map(sortKeysDeep);
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([key, child]) => [key, sortKeysDeep(child)]));
+    }
+    return value;
+}
+export function canonicalSha256(value) {
+    return createHash("sha256")
+        .update(JSON.stringify(sortKeysDeep(value)))
+        .digest("hex");
+}
+export function computeContextDigest(context) {
+    return canonicalSha256(context);
+}
+export function computeBundleManifestSha256(manifest) {
+    return canonicalSha256(manifest);
+}
+export function computeOverrideSetHash(overrides) {
+    return canonicalSha256({ schemaVersion: 1, overrides });
+}
+export function isKnownContextTransferReasonCode(value) {
+    return contextTransferReasonCodeSchema.safeParse(value).success;
+}

package/dist/shared/operator/capabilities.js

@@ -2252,6 +2252,20 @@ export const OPERATOR_COMMAND_COVERAGE = Object.freeze([
         action: "dagFinalVerification",
         source: "loop-agent",
     },
+    {
+        command: "loop-agent dag context",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Context export can disclose raw execution bytes and requires a human-selected output path; Console uses dedicated gated actions instead of the generic CLI wrapper.",
+    },
+    {
+        command: "loop-agent dag artifact",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Artifact revision staging consumes a human-selected local file and remains on dedicated Console/CLI mutation gates.",
+    },
     {
         command: "loop-agent workflow list",
         coverage: "advanced",

package/dist/shared/operator/safe-run-summary.js

@@ -0,0 +1 @@
+export {};

package/dist/shared/path-safety.js

@@ -0,0 +1,93 @@
+import { constants as fsConstants } from "node:fs";
+import { lstat, open, realpath } from "node:fs/promises";
+import path from "node:path";
+function assertContained(root, target, label) {
+    if (target === root || !target.startsWith(`${root}${path.sep}`)) {
+        throw new Error(`${label}: path escapes boundary: ${target}`);
+    }
+}
+/**
+ * Reject any symlink on the path between `boundaryRoot` and `targetPath`.
+ * This is the lexical/path-walk phase; callers that consume file bytes must
+ * still use readFileBoundarySafe so the checked object is the opened object.
+ */
+export async function assertRealPathInsideBoundary(input) {
+    const root = path.resolve(input.boundaryRoot);
+    const target = path.resolve(input.targetPath);
+    assertContained(root, target, input.label);
+    const rootStat = await lstat(root).catch(() => undefined);
+    if (!rootStat) {
+        throw new Error(`${input.label}: boundary root is not a real directory`);
+    }
+    if (rootStat.isSymbolicLink()) {
+        throw new Error(`${input.label}: boundary root must not be a symlink`);
+    }
+    if (!rootStat.isDirectory()) {
+        throw new Error(`${input.label}: boundary root is not a real directory`);
+    }
+    const segments = path.relative(root, target).split(path.sep).filter(Boolean);
+    let current = root;
+    for (let index = 0; index < segments.length; index += 1) {
+        current = path.join(current, segments[index]);
+        const stat = await lstat(current).catch(() => undefined);
+        if (!stat) {
+            throw new Error(`${input.label}: path component missing: ${segments[index]}`);
+        }
+        if (stat.isSymbolicLink()) {
+            throw new Error(`${input.label}: symlink is forbidden on path: ${segments[index]}`);
+        }
+        if (index < segments.length - 1 && !stat.isDirectory()) {
+            throw new Error(`${input.label}: path ancestor is not a directory: ${segments[index]}`);
+        }
+    }
+    return target;
+}
+/** Reject a non-regular, symlinked, or hardlinked final entry before opening. */
+export async function assertReadableRegularFile(input) {
+    const target = await assertRealPathInsideBoundary(input);
+    const stat = await lstat(target).catch(() => undefined);
+    if (!stat)
+        throw new Error(`${input.label}: path component missing`);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1) {
+        throw new Error(`${input.label}: path must be a regular single-link file`);
+    }
+    return target;
+}
+/**
+ * Read one owned regular file without reopening an unchecked pathname.
+ *
+ * The preflight rejects normal FIFO/device/hardlink cases without opening
+ * them. O_NOFOLLOW rejects a final symlink introduced after preflight and
+ * O_NONBLOCK prevents a swapped FIFO from blocking. The post-open identity and
+ * realpath checks make an ancestor swap detectable before bytes are consumed.
+ */
+export async function readFileBoundarySafe(input) {
+    const target = await assertReadableRegularFile(input);
+    const flags = fsConstants.O_RDONLY |
+        (fsConstants.O_NOFOLLOW ?? 0) |
+        (fsConstants.O_NONBLOCK ?? 0);
+    const handle = await open(target, flags);
+    try {
+        const opened = await handle.stat();
+        if (!opened.isFile() || opened.nlink !== 1) {
+            throw new Error(`${input.label}: path must be a regular single-link file`);
+        }
+        const [resolvedRoot, resolvedTarget, current] = await Promise.all([
+            realpath(path.resolve(input.boundaryRoot)),
+            realpath(target),
+            lstat(target),
+        ]);
+        assertContained(resolvedRoot, resolvedTarget, input.label);
+        if (current.isSymbolicLink() ||
+            !current.isFile() ||
+            current.nlink !== 1 ||
+            current.dev !== opened.dev ||
+            current.ino !== opened.ino) {
+            throw new Error(`${input.label}: path changed while opening`);
+        }
+        return await handle.readFile();
+    }
+    finally {
+        await handle.close().catch(() => { });
+    }
+}

package/dist/shared/preview.js

@@ -1,10 +1,34 @@
 const ENCODER = new TextEncoder();
 const DECODER = new TextDecoder();
+export function redactSecretsWithFindings(text) {
+    let findingCount = 0;
+    const replaceChanged = (match, replacement) => {
+        if (match !== replacement)
+            findingCount += 1;
+        return replacement;
+    };
+    let redacted = text.replace(/(["']?(?:api[_-]?key|token|password|secret|authorization)["']?\s*[:=]\s*["']?)((?:Bearer\s+)?[^"'\s,}]+)/gi, (match, prefix) => replaceChanged(match, `${prefix}***`));
+    redacted = redacted.replace(/(\b[A-Z][A-Z0-9_]*=)[^\s]+/g, (match, prefix) => replaceChanged(match, `${prefix}***`));
+    redacted = redacted.replace(/\bBearer\s+[^\s"']+/gi, (match) => replaceChanged(match, "Bearer ***"));
+    // High-confidence provider-style tokens (OpenAI sk-, GitHub ghp_/gho_,
+    // Slack xox*, AWS AKIA) are credential-like even without a key=value
+    // prefix (exec-plan 2026-08-25 D4: credential-like 默认阻断).
+    redacted = redacted.replace(/\b(?:sk-[A-Za-z0-9_-]{16,}|gh[pos]_[A-Za-z0-9]{20,}|xox[baprs]-[A-Za-z0-9-]{10,}|AKIA[0-9A-Z]{16})\b/g, (match) => replaceChanged(match, "***"));
+    return { redacted, findingCount };
+}
+export function redactSensitivePathsWithFindings(text) {
+    let findingCount = 0;
+    const replaceHome = (match) => {
+        if (match !== "<redacted-home>")
+            findingCount += 1;
+        return "<redacted-home>";
+    };
+    let redacted = text.replace(/\/(?:Users|home)\/[^/\s"'\\]+/g, replaceHome);
+    redacted = redacted.replace(/\b[A-Za-z]:\\Users\\[^\\/\s"']+/gi, replaceHome);
+    return { redacted, findingCount };
+}
 export function redactSecrets(text) {
-    return text
-        .replace(/\bBearer\s+[^\s"']+/gi, "Bearer ***")
-        .replace(/(\b[A-Z][A-Z0-9_]*=)[^\s]+/g, "$1***")
-        .replace(/(["']?(?:api[_-]?key|token|password|secret|authorization)["']?\s*[:=]\s*["']?)([^"'\s,}]+)/gi, "$1***");
+    return redactSecretsWithFindings(text).redacted;
 }
 export function truncateUtf8Preview(text, maxBytes = 4096) {
     if (maxBytes <= 0)

package/dist/task/config-types.js

@@ -14,6 +14,7 @@ export const taskKindSchema = z.enum([
     "frontend-implementation",
     "frontend-test",
     "backend-test",
+    "backend-test-analysis",
     "knowledge-sync",
     "knowledge-graph-bootstrap",
 ]);
@@ -165,7 +166,7 @@ const taskConfigObjectSchema = z.object({
     taskId: z.string(),
     title: z.string(),
     sourceFiles: z.array(z.string()),
-    /** standard: 本仓库需求实现；feature-study: 参考外部代码特性并在目标仓库落地；frontend-implementation: 前端实现 DAG；backend-test: 后端测试 DAG；knowledge-sync: 最终验证后回写测试知识库 DAG；knowledge-graph-bootstrap: AI 辅助业务知识图谱初始化 */
+    /** standard: 本仓库需求实现；feature-study: 参考外部代码特性并在目标仓库落地；frontend-implementation: 前端实现 DAG；frontend-test: 前端浏览器测试 DAG；backend-test-analysis: 只读后端测试分析 DAG；backend-test: 后端测试 DAG；knowledge-sync: 最终验证后回写测试知识库 DAG；knowledge-graph-bootstrap: AI 辅助业务知识图谱初始化 */
     taskKind: taskKindSchema.optional().default("standard"),
     /** true = taskKind 由人类显式选择（含显式 standard）；DAG 路由必须尊重，不做语义改写。 */
     taskKindExplicit: z.boolean().optional(),

package/dist/task/task-demand-routing.js

@@ -76,6 +76,7 @@ const SPECIAL_TEMPLATE_BY_TASK_KIND = {
     "frontend-implementation": "frontend-implementation",
     "frontend-test": "frontend-test-dag",
     "backend-test": "backend-test-dag",
+    "backend-test-analysis": "backend-test-analysis-dag",
     "knowledge-sync": "knowledge-sync-dag",
     "knowledge-graph-bootstrap": "knowledge-graph-bootstrap-dag",
 };
@@ -83,6 +84,7 @@ const TASK_KIND_ROUTING_REASON = {
     "frontend-implementation": 'taskKind "frontend-implementation" selects the dedicated frontend DAG template',
     "frontend-test": 'taskKind "frontend-test" selects the dedicated frontend test DAG template',
     "backend-test": 'taskKind "backend-test" selects the dedicated backend test DAG template',
+    "backend-test-analysis": 'taskKind "backend-test-analysis" selects the read-only backend test analysis DAG template',
     "knowledge-sync": 'taskKind "knowledge-sync" selects the dedicated knowledge-sync DAG template',
     "knowledge-graph-bootstrap": 'taskKind "knowledge-graph-bootstrap" selects the dedicated knowledge-graph bootstrap DAG template',
 };
@@ -90,6 +92,7 @@ const SPECIAL_REQUESTED_TEMPLATES = new Set([
     "frontend-implementation",
     "frontend-test-dag",
     "backend-test-dag",
+    "backend-test-analysis-dag",
     "knowledge-sync-dag",
     "knowledge-graph-bootstrap-dag",
 ]);

package/dist/worker/console/chat/chat-event-store.js

@@ -19,8 +19,8 @@
 import { createHash } from "node:crypto";
 import { existsSync, readFileSync, rmSync } from "node:fs";
 import path from "node:path";
-import { ensureSecureDir, writeSecureJsonSync, } from "../app-data.js";
-import { isTerminalOperationState, } from "../operation-store.js";
+import { ensureSecureDir, writeSecureJsonSync, } from "../../../infrastructure/console/app-data.js";
+import { isTerminalOperationState, } from "../../../infrastructure/console/operation-store.js";
 import { scrubSecrets } from "./explore-tools.js";
 const OPERATION_PREVIEW_MAX_CHARS = 1200;
 function boundedRedactedText(value, maxChars = OPERATION_PREVIEW_MAX_CHARS) {

package/dist/worker/console/chat/resource-preferences-store.js

@@ -7,7 +7,7 @@
  */
 import { createHash } from "node:crypto";
 import { existsSync, lstatSync } from "node:fs";
-import { readJsonIfExists, writeSecureJson, } from "../app-data.js";
+import { readJsonIfExists, writeSecureJson, } from "../../../infrastructure/console/app-data.js";
 export const RESOURCE_PREFERENCES_SCHEMA_VERSION = 1;
 export class ResourcePreferencesError extends Error {
     code;

package/dist/worker/console/chat/routes.js

@@ -41,7 +41,7 @@ import { openSseResponse, writeSseEvent } from "../operation-sse.js";
 import { buildTodoCompactionInstructions, projectCurrentTodos } from "./todos.js";
 import { buildGoalCompactionInstructions, buildGoalContinuationContext, } from "./goals.js";
 import { classifyGoalRoundAdmission, } from "./goal-round-driver.js";
-import { isTerminalOperationState } from "../operation-store.js";
+import { isTerminalOperationState } from "../../../infrastructure/console/operation-store.js";
 /**
  * Reattach the durable event-ring order to session-store rows. The session
  * store remains the content authority; the ring only supplies chronology.

package/dist/worker/console/chat/session-store.js

@@ -12,7 +12,7 @@
  */
 import path from "node:path";
 import { readdir, rm } from "node:fs/promises";
-import { readJsonIfExists, writeSecureJson, } from "../app-data.js";
+import { readJsonIfExists, writeSecureJson, } from "../../../infrastructure/console/app-data.js";
 import { dispatchOperatorAction } from "../operator-actions.js";
 import { authorizeOperatorChatTool } from "./tools.js";
 import { projectOperationForChat } from "./chat-event-store.js";

package/dist/worker/console/chat/user-questions.js

@@ -1,6 +1,6 @@
 import { randomBytes } from "node:crypto";
 import path from "node:path";
-import { readJsonIfExists, writeSecureJson } from "../app-data.js";
+import { readJsonIfExists, writeSecureJson, } from "../../../infrastructure/console/app-data.js";
 function questionFile(root, sessionId) {
     const safe = sessionId.replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 180);
     return path.join(root, `${safe}.json`);

package/dist/worker/console/console-update-runtime.js

@@ -4,7 +4,7 @@ import { createNpmUpdateClient } from "../../shared/update/npm-client.js";
 import { acquireUpdateLock, updateLockPath } from "../../shared/update/state.js";
 import { readInitRuntimeActivity } from "../observability/init-runtime-activity.js";
 import { performConsoleUpdateAndInit, } from "./console-update-and-init.js";
-import { TERMINAL_OPERATION_STATES } from "./operation-store.js";
+import { TERMINAL_OPERATION_STATES } from "../../infrastructure/console/operation-store.js";
 export function createConsoleUpdateExecutor(input) {
     return async (channel) => {
         const currentVersion = readPackageVersion(input.packageRoot);