@botlearn-course/daemon 0.0.20-beta.1 → 0.0.20-beta.10

package/dist/agent-service-ws-protocol.d.ts

@@ -1,9 +1,9 @@
-export declare const AGENT_SERVICE_WS_SCHEMA: "botlearn-agent-sandbox-ws/0.2";
-export declare const AGENT_SERVICE_WS_SUBPROTOCOL: "botlearn-agent-sandbox.v2";
+export declare const AGENT_SERVICE_WS_SCHEMA: "botlearn-agent-sandbox-ws/0.4";
+export declare const AGENT_SERVICE_WS_SUBPROTOCOL: "botlearn-agent-sandbox.v4";
 export declare const WORKSPACE_FILE_READ_BINARY_CAPABILITY: "workspace_file_read_binary_v1";
 export declare const WORKSPACE_FILE_CHUNK_BYTES: number;
 export declare const WORKSPACE_FILE_CHUNK_HEADER_BYTES = 29;
-export type SandboxFrameType = "sandbox.hello" | "sandbox.sync" | "session.open" | "session.activate" | "turn.start" | "turn.cancel" | "session.close" | "sandbox.drain" | "sandbox.shutdown" | "event.ack" | "auth.rotate" | "workspace.file.read" | "ping" | "sandbox.ready" | "sandbox.heartbeat" | "command.ack" | "session.opened" | "session.open_failed" | "session.closed" | "turn.event" | "turn.file.report" | "workspace.file.result" | "sandbox.drained" | "sandbox.log" | "pong" | "protocol.error";
+export type SandboxFrameType = "sandbox.hello" | "sandbox.sync" | "session.open" | "session.activate" | "turn.start" | "turn.cancel" | "session.close" | "sandbox.drain" | "sandbox.shutdown" | "event.ack" | "auth.rotate" | "workspace.file.read" | "workspace.checkpoint" | "workspace.thaw" | "ping" | "sandbox.ready" | "sandbox.heartbeat" | "command.ack" | "session.opened" | "session.open_failed" | "session.closed" | "turn.event" | "turn.file.report" | "workspace.file.result" | "sandbox.drained" | "sandbox.log" | "pong" | "protocol.error";
 export declare class UnsupportedSandboxProtocolError extends Error {
     readonly schemaVersion: unknown;
     constructor(schemaVersion: unknown);

package/dist/agent-service-ws-protocol.js

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
-export const AGENT_SERVICE_WS_SCHEMA = "botlearn-agent-sandbox-ws/0.2";
-export const AGENT_SERVICE_WS_SUBPROTOCOL = "botlearn-agent-sandbox.v2";
+export const AGENT_SERVICE_WS_SCHEMA = "botlearn-agent-sandbox-ws/0.4";
+export const AGENT_SERVICE_WS_SUBPROTOCOL = "botlearn-agent-sandbox.v4";
 export const WORKSPACE_FILE_READ_BINARY_CAPABILITY = "workspace_file_read_binary_v1";
 export const WORKSPACE_FILE_CHUNK_BYTES = 64 * 1024;
 export const WORKSPACE_FILE_CHUNK_HEADER_BYTES = 29;
@@ -18,6 +18,8 @@ const FRAME_TYPES = new Set([
     "event.ack",
     "auth.rotate",
     "workspace.file.read",
+    "workspace.checkpoint",
+    "workspace.thaw",
     "ping",
     "sandbox.ready",
     "sandbox.heartbeat",
@@ -42,6 +44,7 @@ const SESSION_TYPES = new Set([
     "session.open_failed",
     "session.closed",
     "workspace.file.read",
+    "workspace.checkpoint",
     "workspace.file.result",
 ]);
 /** TURN 帧：必须带 runtime_session_id + agent_run_id + worker_attempt + activation_id 四元组。 */

package/dist/cli.js

@@ -372,7 +372,25 @@ async function cmdAgentServiceSession(args) {
         deepseekTuiVersion: process.env.BOTLEARN_MANAGED_DEEPSEEK_TUI_VERSION?.trim() || undefined,
     });
     clearAgentServiceControlEnv();
-    await client.run();
+    let stopping = false;
+    const stop = () => {
+        if (stopping)
+            return;
+        stopping = true;
+        void client.stopGracefully().catch((error) => {
+            console.error(error instanceof Error ? error.message : "sandbox shutdown failed");
+            client.stop();
+        });
+    };
+    process.once("SIGTERM", stop);
+    process.once("SIGINT", stop);
+    try {
+        await client.run();
+    }
+    finally {
+        process.removeListener("SIGTERM", stop);
+        process.removeListener("SIGINT", stop);
+    }
     return 0;
 }
 // ---------------------------------------------------------------

package/dist/file-candidates.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { createReadStream } from "node:fs";
+import { constants } from "node:fs";
 import { open, readdir } from "node:fs/promises";
 import path from "node:path";
 import { performance } from "node:perf_hooks";
@@ -20,30 +20,50 @@ function isSafeRelativePath(rel) {
     const segments = rel.split("/");
     return segments.every((seg) => seg !== "" && seg !== "..");
 }
-async function sha256File(absPath) {
+async function sha256File(handle) {
     const hash = createHash("sha256");
-    const stream = createReadStream(absPath);
+    const stream = handle.createReadStream({ autoClose: false, start: 0 });
     for await (const chunk of stream)
         hash.update(chunk);
     return hash.digest("hex");
 }
-async function readPreview(absPath, maxPreviewChars) {
-    const handle = await open(absPath, "r");
+async function readPreview(handle, maxPreviewChars) {
+    const sniff = Buffer.alloc(TEXT_SNIFF_BYTES);
+    const { bytesRead } = await handle.read(sniff, 0, TEXT_SNIFF_BYTES, 0);
+    if (sniff.subarray(0, bytesRead).includes(0))
+        return null;
+    // 预览最多 maxPreviewChars 字符；UTF-8 下 4 字节/字符封顶，读够即可。
+    const want = maxPreviewChars * 4;
+    let buf = sniff.subarray(0, bytesRead);
+    if (bytesRead === TEXT_SNIFF_BYTES && want > TEXT_SNIFF_BYTES) {
+        const more = Buffer.alloc(want - TEXT_SNIFF_BYTES);
+        const extra = await handle.read(more, 0, more.length, TEXT_SNIFF_BYTES);
+        buf = Buffer.concat([buf, more.subarray(0, extra.bytesRead)]);
+    }
+    const text = buf.toString("utf8").replace(/�+$/, "");
+    return redactSecretString(text.slice(0, maxPreviewChars));
+}
+function sameFileVersion(left, right) {
+    return left.dev === right.dev && left.ino === right.ino && left.size === right.size &&
+        left.mtimeNs === right.mtimeNs && left.ctimeNs === right.ctimeNs;
+}
+async function scanStableFile(absPath, maxPreviewChars, maxFileBytes) {
+    const handle = await open(absPath, constants.O_RDONLY | constants.O_NOFOLLOW);
     try {
-        const sniff = Buffer.alloc(TEXT_SNIFF_BYTES);
-        const { bytesRead } = await handle.read(sniff, 0, TEXT_SNIFF_BYTES, 0);
-        if (sniff.subarray(0, bytesRead).includes(0))
-            return null;
-        // 预览最多 maxPreviewChars 字符；UTF-8 下 4 字节/字符封顶，读够即可。
-        const want = maxPreviewChars * 4;
-        let buf = sniff.subarray(0, bytesRead);
-        if (bytesRead === TEXT_SNIFF_BYTES && want > TEXT_SNIFF_BYTES) {
-            const more = Buffer.alloc(want - TEXT_SNIFF_BYTES);
-            const extra = await handle.read(more, 0, more.length, TEXT_SNIFF_BYTES);
-            buf = Buffer.concat([buf, more.subarray(0, extra.bytesRead)]);
+        const before = await handle.stat({ bigint: true });
+        if (!before.isFile() || before.size > BigInt(Number.MAX_SAFE_INTEGER)) {
+            throw new Error("workspace_candidate_invalid_file");
         }
-        const text = buf.toString("utf8").replace(/�+$/, "");
-        return redactSecretString(text.slice(0, maxPreviewChars));
+        const sizeBytes = Number(before.size);
+        if (sizeBytes > maxFileBytes)
+            return { sizeBytes, tooLarge: true };
+        const sha256 = await sha256File(handle);
+        const previewText = await readPreview(handle, maxPreviewChars);
+        const after = await handle.stat({ bigint: true });
+        if (!sameFileVersion(before, after)) {
+            throw new Error("workspace_candidate_changed_during_scan");
+        }
+        return { sizeBytes, tooLarge: false, sha256, previewText };
     }
     finally {
         await handle.close();
@@ -92,23 +112,18 @@ export async function scanWorkspaceFiles(workspaceDir, limits = {}) {
             const rel = path.relative(workspaceDir, absPath).split(path.sep).join("/");
             if (!isSafeRelativePath(rel))
                 continue;
-            let sizeBytes;
+            let scanned;
             try {
-                const handle = await open(absPath, "r");
-                try {
-                    sizeBytes = (await handle.stat()).size;
-                }
-                finally {
-                    await handle.close();
-                }
+                scanned = await scanStableFile(absPath, maxPreviewChars, maxFileBytes);
             }
             catch {
                 truncated = true;
                 continue;
             }
+            const { sizeBytes } = scanned;
             observedFileCount += 1;
             observedTotalBytes += sizeBytes;
-            if (sizeBytes > maxFileBytes) {
+            if (scanned.tooLarge) {
                 truncated = true;
                 continue;
             }
@@ -116,24 +131,16 @@ export async function scanWorkspaceFiles(workspaceDir, limits = {}) {
                 truncated = true;
                 continue;
             }
-            let sha256;
-            let previewText;
-            try {
-                sha256 = await sha256File(absPath);
-                previewText = await readPreview(absPath, maxPreviewChars);
-            }
-            catch {
-                truncated = true;
-                continue;
-            }
             files.push({
                 absPath,
                 event: "created",
                 path: rel,
                 name: entry.name,
                 size_bytes: sizeBytes,
-                sha256,
-                ...(previewText !== null && previewText !== "" ? { preview_text: previewText } : {}),
+                sha256: scanned.sha256,
+                ...(scanned.previewText !== null && scanned.previewText !== ""
+                    ? { preview_text: scanned.previewText }
+                    : {}),
             });
         }
     }

package/dist/index.d.ts

@@ -14,6 +14,8 @@ export * from "./workspace.js";
 export * from "./workspace-entry-set.js";
 export * from "./workspace-materialization.js";
 export * from "./workspace-snapshot-staging.js";
+export * from "./workspace-snapshot-policy.js";
+export * from "./workspace-snapshot-control.js";
 export * from "./workspace-restore.js";
 export * from "./transcript.js";
 export * from "./file-candidates.js";

package/dist/index.js

@@ -14,6 +14,8 @@ export * from "./workspace.js";
 export * from "./workspace-entry-set.js";
 export * from "./workspace-materialization.js";
 export * from "./workspace-snapshot-staging.js";
+export * from "./workspace-snapshot-policy.js";
+export * from "./workspace-snapshot-control.js";
 export * from "./workspace-restore.js";
 export * from "./transcript.js";
 export * from "./file-candidates.js";

package/dist/run-dispatcher.d.ts

@@ -23,7 +23,7 @@ export interface PreparedPersistentTurn {
 export interface PersistentSessionExecution {
     prepareTurn(payload: RunStartPayload): PreparedPersistentTurn;
     persistNativeSession(sessionId: string): void;
-    finishTurn(payload: RunStartPayload): void;
+    finishTurn(payload: RunStartPayload): Promise<void>;
 }
 export interface RunReportingClient {
     postEvent(agentRunId: string, event: RunEvent): Promise<void | RunEventReceipt>;

package/dist/run-dispatcher.js

@@ -13,6 +13,7 @@ import { buildToolObservation } from "./tool-observation.js";
 import { buildReasoningTracePayload, extractReasoningText, REASONING_TRACE_MAX_CHARS, } from "./trace-projection.js";
 import { RuntimeExecutionError, } from "./types.js";
 import { ensureRunWorkspace, transcriptPath } from "./workspace.js";
+import { isWorkspaceQuotaExceededError } from "./workspace-filesystem.js";
 // 与 runtimes/index.ts 的 DEFAULT_RUNTIME_ID 保持一致（此处不 import registry，避免拉入全部 adapter）。
 const DEFAULT_RUNTIME_ID = "codex";
 const DEFAULT_TIMEOUT_SECONDS = 900;
@@ -951,13 +952,15 @@ export class RunDispatcher {
                 }
                 else {
                     const info = errorInfo(err);
-                    const errorType = err instanceof RuntimeProfileApplyError
-                        ? err.code
-                        : err instanceof InputAttachmentMaterializationError
+                    const errorType = isWorkspaceQuotaExceededError(err)
+                        ? "workspace_user_quota_exceeded"
+                        : err instanceof RuntimeProfileApplyError
                             ? err.code
-                            : err instanceof RuntimeExecutionError
-                                ? err.errorType
-                                : "runtime_error";
+                            : err instanceof InputAttachmentMaterializationError
+                                ? err.code
+                                : err instanceof RuntimeExecutionError
+                                    ? err.errorType
+                                    : "runtime_error";
                     await sendFailure(errorType, info.error_message, err, err instanceof RuntimeProfileApplyError
                         ? { code: err.code, profile_apply_status: "failed" }
                         : {});
@@ -979,7 +982,7 @@ export class RunDispatcher {
                 });
             }
             try {
-                this.persistentSession?.finishTurn(payload);
+                await this.persistentSession?.finishTurn(payload);
             }
             finally {
                 this.inflight.delete(runId);

package/dist/runtime-env.js

@@ -42,11 +42,15 @@ export function clearAgentServiceControlEnv(env = process.env) {
 export function runtimeChildEnv(env = process.env) {
     const childEnv = { ...env };
     const runtimeHome = childEnv.BOTLEARN_RUNTIME_HOME;
+    const activationId = childEnv.BOTLEARN_AGENT_SERVICE_ACTIVATION_ID;
     clearAgentServiceControlEnv(childEnv);
     for (const key of AGENT_SERVICE_SUPERVISOR_ENV_KEYS)
         delete childEnv[key];
     if (runtimeHome)
         childEnv.HOME = runtimeHome;
+    if (activationId && /^[A-Za-z0-9_-]{1,120}$/u.test(activationId)) {
+        childEnv.BOTLEARN_RUNTIME_ACTIVATION_SCOPE = activationId;
+    }
     return childEnv;
 }
 /**
@@ -146,10 +150,6 @@ export function runtimeChildLaunch(binary, args, env = process.env, options = {}
             "-n",
             "-H",
             "-E",
-            "-u",
-            runtimeUser,
-            "-g",
-            runtimeGroup,
             "--",
             MANAGED_RUNTIME_LAUNCHER,
             binary,

package/dist/runtime-quiescence.d.ts

@@ -0,0 +1,19 @@
+export interface WorkspaceWriterFreezeProof {
+    readonly proofVersion: "workspace-writer-freeze-proof/1";
+    readonly sandboxId: string;
+    readonly sandboxGeneration: number;
+    readonly runtimeSessionId: string;
+    readonly checkpointId: string;
+    readonly allWritersFrozen: true;
+}
+export declare function freezeRuntimeWriters(): Promise<void>;
+export declare function thawRuntimeWriters(): Promise<void>;
+export declare function assertWorkspaceWriterFreezeSupported(): void;
+export declare function quiesceRuntimeWriters(activationId: string | null): Promise<void>;
+export declare function issueWorkspaceWriterFreezeProof(scope: {
+    sandboxId: string;
+    sandboxGeneration: number;
+    runtimeSessionId: string;
+    checkpointId: string;
+}): WorkspaceWriterFreezeProof;
+export declare function isWorkspaceWriterFreezeProof(value: object): value is WorkspaceWriterFreezeProof;

package/dist/runtime-quiescence.js

@@ -0,0 +1,130 @@
+import { execFile } from "node:child_process";
+import { accessSync, constants as fsConstants } from "node:fs";
+import { readFile, readdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+const RUNTIME_LAUNCHER = "/opt/botlearn/bin/botlearn-runtime-launcher";
+const RUNTIME_CGROUP_ROOT = "/sys/fs/cgroup/botlearn-runtime";
+const RUNTIME_CGROUP_UNAVAILABLE = "/run/botlearn-runtime-cgroup-unavailable";
+const proofs = new WeakSet();
+const sleep = (milliseconds) => new Promise((resolve) => {
+    setTimeout(resolve, milliseconds);
+});
+async function setDirectCgroupsFrozen(frozen) {
+    try {
+        accessSync(RUNTIME_CGROUP_UNAVAILABLE, fsConstants.F_OK);
+        await execFileAsync(RUNTIME_LAUNCHER, [frozen ? "--freeze-all" : "--thaw-all"], {
+            timeout: 10_000,
+        });
+        return;
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    let entries;
+    try {
+        entries = await readdir(RUNTIME_CGROUP_ROOT, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return;
+        throw error;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const directory = path.join(RUNTIME_CGROUP_ROOT, entry.name);
+        await writeFile(path.join(directory, "cgroup.freeze"), frozen ? "1" : "0");
+        for (let attempt = 0; attempt < 100; attempt += 1) {
+            const events = await readFile(path.join(directory, "cgroup.events"), "utf8");
+            if (events.includes(`frozen ${frozen ? 1 : 0}`))
+                break;
+            if (attempt === 99)
+                throw new Error("workspace_runtime_freeze_timeout");
+            await sleep(50);
+        }
+    }
+}
+async function setRuntimeWritersFrozen(frozen) {
+    const mode = process.env.BOTLEARN_RUNTIME_LAUNCH_MODE;
+    if (mode === "direct-uid") {
+        await setDirectCgroupsFrozen(frozen);
+        return;
+    }
+    if (mode === "sudo") {
+        await execFileAsync("/usr/bin/sudo", ["-n", "--", RUNTIME_LAUNCHER, frozen ? "--freeze-all" : "--thaw-all"], { timeout: 10_000 });
+        return;
+    }
+    if (process.env.BOTLEARN_DAEMON_ENABLE_FAKE_RUNTIME === "1" || process.env.NODE_ENV === "test") {
+        return;
+    }
+    throw new Error("workspace_runtime_cgroup_unavailable");
+}
+export async function freezeRuntimeWriters() {
+    await setRuntimeWritersFrozen(true);
+}
+export async function thawRuntimeWriters() {
+    await setRuntimeWritersFrozen(false);
+}
+export function assertWorkspaceWriterFreezeSupported() {
+    const mode = process.env.BOTLEARN_RUNTIME_LAUNCH_MODE;
+    if (mode === "direct-uid") {
+        try {
+            accessSync(RUNTIME_CGROUP_UNAVAILABLE, fsConstants.F_OK);
+            accessSync(RUNTIME_LAUNCHER, fsConstants.X_OK);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+            accessSync(RUNTIME_CGROUP_ROOT, fsConstants.R_OK | fsConstants.W_OK);
+        }
+        return;
+    }
+    if (mode === "sudo") {
+        accessSync(RUNTIME_LAUNCHER, fsConstants.X_OK);
+        return;
+    }
+    if (process.env.BOTLEARN_DAEMON_ENABLE_FAKE_RUNTIME === "1" || process.env.NODE_ENV === "test") {
+        return;
+    }
+    throw new Error("workspace_runtime_cgroup_unavailable");
+}
+function managedQuiescenceCommand(activationId) {
+    const mode = process.env.BOTLEARN_RUNTIME_LAUNCH_MODE;
+    if (mode === "direct-uid") {
+        return [RUNTIME_LAUNCHER, [activationId ? "--quiesce" : "--quiesce-all", ...(activationId ? [activationId] : [])]];
+    }
+    if (mode === "sudo") {
+        return [
+            "/usr/bin/sudo",
+            ["-n", "--", RUNTIME_LAUNCHER, activationId ? "--quiesce" : "--quiesce-all", ...(activationId ? [activationId] : [])],
+        ];
+    }
+    return null;
+}
+export async function quiesceRuntimeWriters(activationId) {
+    const command = managedQuiescenceCommand(activationId);
+    if (command === null) {
+        // Local/BYOA runtimes execute as the daemon user and are not eligible for the managed
+        // durable capability. Unit/e2e fake runtimes have no descendant writer to reap.
+        if (process.env.BOTLEARN_DAEMON_ENABLE_FAKE_RUNTIME === "1" || process.env.NODE_ENV === "test") {
+            return;
+        }
+        throw new Error("workspace_runtime_cgroup_unavailable");
+    }
+    await execFileAsync(command[0], command[1], { timeout: 10_000 });
+}
+export function issueWorkspaceWriterFreezeProof(scope) {
+    const proof = Object.freeze({
+        proofVersion: "workspace-writer-freeze-proof/1",
+        ...scope,
+        allWritersFrozen: true,
+    });
+    proofs.add(proof);
+    return proof;
+}
+export function isWorkspaceWriterFreezeProof(value) {
+    return proofs.has(value);
+}

package/dist/runtimes/deepseek-tui.js

@@ -1000,6 +1000,17 @@ function normalizeDeepseekEvent(eventName, payload, seq) {
             status: deepseekToolFailed(payload) ? "error" : "completed",
         };
     }
+    if (eventName === "item.delta" && isDeepseekReasoningEvent(eventName, payload)) {
+        const text = extractDeepseekDelta(payload);
+        return text
+            ? {
+                raw: { event: eventName, payload },
+                kind: "thinking",
+                seq,
+                text,
+            }
+            : null;
+    }
     if (eventName === "item.delta" && isAgentMessageDelta(payload)) {
         return {
             raw: { event: eventName, payload },

package/dist/tool-observation.d.ts

@@ -13,12 +13,13 @@ export interface ToolObservationPayload extends Record<string, unknown> {
     redacted: boolean;
 }
 /**
- * Project a provider tool envelope into durable teacher evidence.
+ * Project a provider tool envelope into durable learner-preview and teaching-audit evidence.
  *
  * Only allowlisted operational argument/result fields survive, credentials are removed,
- * and host paths become workspace-relative. `detail_preview` stays a bounded feed-sized
- * excerpt; `detail_full` carries the same allowlisted projection at audit fidelity (deeper
- * walk, larger arrays, 64k chars). Message text, request IDs, and arbitrary envelope
- * metadata never cross this boundary.
+ * and paths inside the current workspace become workspace-relative. Other semantic content,
+ * including execution-host paths outside that workspace, stays intact. `detail_preview` is
+ * a bounded feed-sized excerpt; `detail_full` carries the same allowlisted projection at
+ * audit fidelity (deeper walk, larger arrays, 64k chars). Message text, request IDs, and
+ * arbitrary envelope metadata never cross this boundary.
  */
 export declare function buildToolObservation(block: RuntimeBlock, runtime: string, workspaceDir: string): ToolObservationPayload | null;

package/dist/tool-observation.js

@@ -39,13 +39,14 @@ const RESULT_FIELDS = new Set([
     "bytes",
 ]);
 /**
- * Project a provider tool envelope into durable teacher evidence.
+ * Project a provider tool envelope into durable learner-preview and teaching-audit evidence.
  *
  * Only allowlisted operational argument/result fields survive, credentials are removed,
- * and host paths become workspace-relative. `detail_preview` stays a bounded feed-sized
- * excerpt; `detail_full` carries the same allowlisted projection at audit fidelity (deeper
- * walk, larger arrays, 64k chars). Message text, request IDs, and arbitrary envelope
- * metadata never cross this boundary.
+ * and paths inside the current workspace become workspace-relative. Other semantic content,
+ * including execution-host paths outside that workspace, stays intact. `detail_preview` is
+ * a bounded feed-sized excerpt; `detail_full` carries the same allowlisted projection at
+ * audit fidelity (deeper walk, larger arrays, 64k chars). Message text, request IDs, and
+ * arbitrary envelope metadata never cross this boundary.
  */
 export function buildToolObservation(block, runtime, workspaceDir) {
     if (block.kind !== "tool_call" && block.kind !== "tool_result")

package/dist/trace-projection.d.ts

@@ -17,5 +17,5 @@ export interface ReasoningTracePayload extends Record<string, unknown> {
  * envelope stays local to the sandbox transcript.
  */
 export declare function extractReasoningText(raw: unknown): string;
-/** Project accumulated reasoning text into one durable, redacted, bounded trace payload. */
+/** Project reasoning into one bounded payload that filters credentials and preserves semantics. */
 export declare function buildReasoningTracePayload(text: string, runtime: string, alreadyTruncated?: boolean): ReasoningTracePayload;

package/dist/trace-projection.js

@@ -40,7 +40,7 @@ function collectReasoningStrings(value, depth, out) {
         collectReasoningStrings(item, depth + 1, out);
     }
 }
-/** Project accumulated reasoning text into one durable, redacted, bounded trace payload. */
+/** Project reasoning into one bounded payload that filters credentials and preserves semantics. */
 export function buildReasoningTracePayload(text, runtime, alreadyTruncated = false) {
     const redactedText = redactSecretString(text);
     const truncated = alreadyTruncated || redactedText.length > REASONING_TRACE_MAX_CHARS;

package/dist/types.d.ts

@@ -233,9 +233,9 @@ export interface CourseRuntime {
 }
 /** runtime 执行失败（dispatcher 折叠为 run.failed）。 */
 export declare class RuntimeExecutionError extends Error {
-    readonly errorType: "runtime_error" | "runtime_unavailable" | "timeout";
+    readonly errorType: "runtime_error" | "runtime_unavailable" | "timeout" | "workspace_user_quota_exceeded";
     readonly failure?: Partial<RuntimeFailureSummary> | undefined;
-    constructor(message: string, errorType?: "runtime_error" | "runtime_unavailable" | "timeout", failure?: Partial<RuntimeFailureSummary> | undefined);
+    constructor(message: string, errorType?: "runtime_error" | "runtime_unavailable" | "timeout" | "workspace_user_quota_exceeded", failure?: Partial<RuntimeFailureSummary> | undefined);
 }
 /**
  * 本地诊断用的失败摘要。完整结构只进脱敏日志/transcript；wire 仅允许

package/dist/workspace-filesystem.d.ts

@@ -0,0 +1,20 @@
+export declare const WORKSPACE_IMAGE_FORMAT: "botlearn-workspace-image/1";
+export declare const WORKSPACE_IMAGE_LOGICAL_BYTES: number;
+interface MountInfoEntry {
+    target: string;
+    filesystemType: string;
+    source: string;
+    mountOptions: Set<string>;
+    superOptions: Set<string>;
+}
+export interface WorkspaceCapacityProbes {
+    statfsBytes(workspaceRoot: string): bigint;
+    backingFileBytes(imagePath: string): bigint;
+}
+export declare function parseWorkspaceMountInfo(text: string): MountInfoEntry[];
+export declare function nasWorkspaceEnabled(env?: NodeJS.ProcessEnv): boolean;
+export declare function workspaceFilesystemFlushCommand(env?: NodeJS.ProcessEnv): [string, string[]] | null;
+export declare function flushWorkspaceFilesystem(env?: NodeJS.ProcessEnv): Promise<void>;
+export declare function isWorkspaceQuotaExceededError(error: unknown): boolean;
+export declare function assertWorkspaceFilesystem(workspaceRoot: string, env?: NodeJS.ProcessEnv, mountInfo?: string, capacityProbes?: WorkspaceCapacityProbes): void;
+export {};