@botlearn-course/daemon 0.0.6 → 0.0.8

package/dist/runtimes/engine.js

@@ -88,7 +88,15 @@ export function wrapEngineAdapter(id, engine, opts) {
         id,
         async run(run, sink, signal) {
             const payload = run.payload;
-            const text = renderConversationInput(payload);
+            // DeepSeek persists and replays the native thread history. The durable Course Service
+            // conversation is recovery/bootstrap data, not a second history to inject on every turn.
+            // Agent Service activations intentionally start a fresh local server because their model
+            // credential expires with the turn, so a cached thread id cannot suppress durable context.
+            const managedActivation = Boolean(run.runtimeEnv?.BOTLEARN_AGENT_SERVICE_ACTIVATION_ID?.trim());
+            const resumesDeepseekThread = id === "deepseek-tui" && !managedActivation && Boolean(run.nativeSessionId?.trim());
+            const text = resumesDeepseekThread
+                ? (payload.input.text ?? "")
+                : renderConversationInput(payload);
             if (!text.trim()) {
                 throw new RuntimeExecutionError("empty task brief");
             }
@@ -131,10 +139,22 @@ export function wrapEngineAdapter(id, engine, opts) {
                         return;
                     }
                     const kind = BLOCK_KIND_MAP[block.kind] ?? "status";
-                    queueBlock({ kind, raw: block.raw });
+                    queueBlock({
+                        kind,
+                        raw: block.raw,
+                        ...(block.text !== undefined ? { text: block.text } : {}),
+                        ...(block.name !== undefined ? { name: block.name } : {}),
+                        ...(block.status !== undefined ? { status: block.status } : {}),
+                    });
                 },
                 onStatus: (event) => {
                     consoleLogger.debug(`${id} status`, { kind: event.kind, phase: event.phase });
+                    if (event.kind === "thinking") {
+                        queueBlock({
+                            kind: "thinking",
+                            phase: event.phase === "stopped" ? "completed" : "in_progress",
+                        });
+                    }
                 },
             });
             // Preserve provider event order through durable run.block before the final run.message.

package/dist/runtimes/fake.js

@@ -1,7 +1,35 @@
-import { writeFileSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import path from "node:path";
+import { RuntimeExecutionError } from "../types.js";
 /** message 里回显的任务简报截断长度。 */
 const BRIEF_PREVIEW_CHARS = 80;
+const RUNTIME_ERROR_SCENARIO = "[[e2e:runtime-error]]";
+const SLOW_RUNTIME_SCENARIO = "[[e2e:slow]]";
+function configuredStepDelayMs(brief) {
+    if (brief.includes(SLOW_RUNTIME_SCENARIO))
+        return 1_000;
+    const configured = Number(process.env.BOTLEARN_FAKE_RUNTIME_STEP_DELAY_MS ?? 0);
+    if (!Number.isFinite(configured))
+        return 0;
+    return Math.max(0, Math.min(5_000, Math.floor(configured)));
+}
+async function pauseBetweenSteps(signal, runtimeId, brief) {
+    const delayMs = configuredStepDelayMs(brief);
+    throwIfAborted(signal, runtimeId);
+    if (delayMs <= 0)
+        return;
+    await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            signal.removeEventListener("abort", onAbort);
+            resolve();
+        }, delayMs);
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(new Error(`${runtimeId} runtime aborted`));
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+}
 /**
  * 确定性假 runtime：不 spawn 任何进程，直接实现 CourseRuntime。
  * 仅供端到端联调/测试（registry 里 hidden，capabilities 需
@@ -15,18 +43,86 @@ export class FakeRuntime {
     }
     async run(run, sink, signal) {
         const brief = run.payload.input.text ?? "";
-        const finalText = `已根据任务完成草稿。\n\n任务：${brief.slice(0, BRIEF_PREVIEW_CHARS)}`;
+        const draftPath = path.join(run.workspaceDir, "draft.md");
+        const priorDraft = existsSync(draftPath) ? readFileSync(draftPath, "utf8") : "";
+        const isContinuation = priorDraft.length > 0;
+        if (isContinuation && run.contextRevision !== undefined && !run.nativeSessionId) {
+            throw new RuntimeExecutionError("E2E FakeRuntime lost its native session between turns", "runtime_unavailable");
+        }
+        if (!isContinuation && run.contextRevision !== undefined) {
+            await sink.runtimeSession?.(`fake-thread-${run.payload.course_run_id}`);
+        }
+        const draft = isContinuation
+            ? [
+                "# E2E 草稿",
+                "",
+                "第一段：这是由真实 Course Daemon 协议生成的初稿内容。",
+                "",
+                "第二段：本轮读取并延续了上一轮工作区中的 draft.md。",
+            ].join("\n")
+            : [
+                "# E2E 草稿",
+                "",
+                "第一段：这是由真实 Course Daemon 协议生成的初稿内容。",
+            ].join("\n");
+        const finalText = isContinuation
+            ? `已读取同一工作区的上一轮 draft.md，并补全为标题和两段正文。\n\n${draft}`
+            : `已生成包含标题和第一段正文的初稿，请检查后继续完善。\n\n${draft}\n\n任务：${brief.slice(0, BRIEF_PREVIEW_CHARS)}`;
         const blocks = [
-            { kind: "status", text: "fake runtime started", raw: { event: "started" } },
-            { kind: "thinking", text: "正在起草……", raw: { event: "thinking" } },
-            { kind: "text", text: finalText, raw: { event: "text" } },
+            {
+                kind: "status",
+                text: "deterministic runtime started",
+                raw: { event: "started" },
+            },
+            {
+                kind: "thinking",
+                phase: "in_progress",
+                text: "正在检查任务和工作区。",
+                raw: { event: "reasoning" },
+            },
+            {
+                kind: "tool_call",
+                name: "write_file",
+                text: "draft.md",
+                raw: { event: "tool_call" },
+            },
+            {
+                kind: "progress",
+                runtime: this.id,
+                summary: isContinuation ? "正在补全草稿" : "正在生成初稿",
+                status: "in_progress",
+            },
         ];
         for (const block of blocks) {
             throwIfAborted(signal, this.id);
             await sink.block(block);
+            await pauseBetweenSteps(signal, this.id, brief);
+        }
+        if (brief.includes(RUNTIME_ERROR_SCENARIO)) {
+            throw new RuntimeExecutionError("E2E deterministic runtime failure");
         }
         throwIfAborted(signal, this.id);
-        writeFileSync(path.join(run.workspaceDir, "draft.md"), finalText, "utf8");
+        writeFileSync(draftPath, draft, "utf8");
+        await sink.block({
+            kind: "tool_result",
+            name: "write_file",
+            status: "completed",
+            text: "draft.md",
+            raw: { event: "tool_result" },
+        });
+        await pauseBetweenSteps(signal, this.id, brief);
+        await sink.block({
+            kind: "thinking",
+            phase: "completed",
+            raw: { event: "reasoning" },
+        });
+        await sink.block({
+            kind: "progress",
+            runtime: this.id,
+            summary: isContinuation ? "草稿已补全" : "初稿已生成",
+            status: "completed",
+        });
+        await sink.block({ kind: "text_delta", text: finalText, raw: { event: "text" } });
         await sink.message(finalText);
     }
 }

package/dist/runtimes/gemini.js

@@ -238,7 +238,20 @@ function normalizeBlock(obj, seq) {
     else if (type === "init" || type === "result") {
         kind = "system";
     }
-    return { raw: obj, kind, seq };
+    return {
+        raw: obj,
+        kind,
+        seq,
+        ...(kind === "assistant_text" && typeof obj.content === "string"
+            ? { text: obj.content }
+            : {}),
+        ...(kind === "tool_use" && typeof obj.tool_name === "string"
+            ? { name: obj.tool_name }
+            : {}),
+        ...(kind === "tool_result"
+            ? { status: obj.status === "error" ? "error" : "completed" }
+            : {}),
+    };
 }
 export const geminiModule = {
     id: "gemini",

package/dist/runtimes/hermes-agent.js

@@ -123,7 +123,7 @@ export class HermesAgentAdapter extends AcpRuntimeAdapter {
             blockKind = "assistant_text";
         }
         else if (kind === "tool_call" || kind === "tool_call_update") {
-            blockKind = "tool_use";
+            blockKind = kind === "tool_call_update" ? "tool_result" : "tool_use";
         }
         else if (kind === "user_message_chunk") {
             blockKind = "other";
@@ -132,7 +132,24 @@ export class HermesAgentAdapter extends AcpRuntimeAdapter {
         const status = hermesStatusEvent(kind, update, assistantTextSeen);
         if (status)
             ctx.emitStatus(status);
-        ctx.emitBlock({ raw: params, kind: blockKind, seq: ctx.seq });
+        const tool = update.toolCall;
+        ctx.emitBlock({
+            raw: params,
+            kind: blockKind,
+            seq: ctx.seq,
+            ...(blockKind === "assistant_text" && kind === "agent_message_chunk"
+                ? {
+                    text: update.content?.text ?? "",
+                }
+                : {}),
+            ...((blockKind === "tool_use" || blockKind === "tool_result")
+                && typeof tool?.name === "string"
+                ? { name: tool.name }
+                : {}),
+            ...(blockKind === "tool_result"
+                ? { status: tool?.status === "failed" ? "error" : "completed" }
+                : {}),
+        });
     }
     /**
      * owner 信任：选第一个 `kind` 以 `allow_` 开头的选项，没有再退回第一个

package/dist/runtimes/kimi.js

@@ -323,7 +323,15 @@ function normalizeBlock(obj, seq) {
     else if (obj.category || obj.severity) {
         kind = "system";
     }
-    return { raw: obj, kind, seq };
+    const text = kind === "assistant_text" ? extractText(obj.content) : "";
+    return {
+        raw: obj,
+        kind,
+        seq,
+        ...(text ? { text } : {}),
+        ...(kind === "tool_use" ? { name: firstToolName(obj.tool_calls) } : {}),
+        ...(kind === "tool_result" ? { status: "completed" } : {}),
+    };
 }
 export const kimiCliModule = {
     id: "kimi-cli",

package/dist/runtimes/openclaw-acp.js

@@ -177,12 +177,30 @@ export class OpenclawAcpAdapter {
                 if (!text)
                     return;
                 seq += 1;
-                emitBlock({ raw: sanitizeAssistantChunk(note, text), kind: "assistant_text", seq });
+                emitBlock({
+                    raw: sanitizeAssistantChunk(note, text),
+                    kind: "assistant_text",
+                    seq,
+                    text,
+                });
                 return;
             }
             seq += 1;
             const kind = classifyAcpUpdate(note);
-            emitBlock({ raw: note, kind, seq });
+            const toolCall = update?.toolCall;
+            const toolName = toolCall && typeof toolCall.name === "string" ? toolCall.name : undefined;
+            const toolStatus = toolCall && typeof toolCall.status === "string" ? toolCall.status.toLowerCase() : "";
+            emitBlock({
+                raw: note,
+                kind,
+                seq,
+                ...((kind === "tool_use" || kind === "tool_result") && toolName
+                    ? { name: toolName }
+                    : {}),
+                ...(kind === "tool_result"
+                    ? { status: /fail|error/.test(toolStatus) ? "error" : "completed" }
+                    : {}),
+            });
         };
         let abortListener;
         try {
@@ -293,6 +311,7 @@ export class OpenclawAcpAdapter {
                         },
                         kind: "assistant_text",
                         seq,
+                        text: textForBlock,
                     });
                 }
             }

package/dist/runtimes/progress.d.ts

@@ -23,6 +23,11 @@ export interface ProgressMcpConfig {
 export interface ProgressMcpConfigOptions {
     /** undefined auto-discovers explicit/default config; null creates a progress-only config. */
     baseConfigPath?: string | null;
+    /**
+     * undefined auto-detects the managed runtime boundary, null forces a private BYOA
+     * config, and a path writes a sanitized runtime-readable config below that root.
+     */
+    managedRoot?: string | null;
     platform?: NodeJS.Platform;
 }
 export declare class ProgressMcpConfigError extends Error {
@@ -45,6 +50,13 @@ export declare function isDeepseekProgressCompletion(payload: unknown, state: De
  */
 export declare function progressMcpAutoInjectionSupported(platform?: NodeJS.Platform): boolean;
 export declare function resolveExistingDeepseekMcpConfig(env?: NodeJS.ProcessEnv, home?: string): string | null;
-/** Create an ephemeral config that preserves a user's existing MCP servers and settings. */
+/**
+ * Create an ephemeral DeepSeek MCP config.
+ *
+ * BYOA keeps the user's existing MCP settings in a private 0700/0600 directory. Managed
+ * Agent Service sessions instead write a progress-only 0750/0640 handoff below the
+ * supervisor-owned profile root so the separate runtime UID can read it without exposing
+ * control-plane configuration.
+ */
 export declare function createProgressMcpConfig(options?: ProgressMcpConfigOptions): ProgressMcpConfig;
 export declare function cleanupProgressMcpConfig(config: ProgressMcpConfig | undefined): void;

package/dist/runtimes/progress.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdtempSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { chmodSync, existsSync, lstatSync, mkdtempSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -10,6 +10,7 @@ export const DEEPSEEK_PROGRESS_TOOL_ALIASES = new Set([
 ]);
 export const DEEPSEEK_PROGRESS_SYSTEM_INSTRUCTION = [
     "BotLearn execution progress reporting:",
+    "- DeepSeek may defer this MCP tool. Before the first meaningful progress phase, if report_progress is not exposed, call tool_search_tool_regex once with query report_progress, then call the discovered progress tool.",
     "- Use report_progress only when a meaningful user-visible execution phase starts or completes.",
     "- Use status in_progress at phase start and completed only when that execution phase actually ends.",
     "- Short tasks need no progress report; do not report every command, file read, or retry.",
@@ -120,22 +121,37 @@ export function resolveExistingDeepseekMcpConfig(env = process.env, home = homed
     const defaultPath = path.join(home, ".deepseek", "mcp.json");
     return existsSync(defaultPath) ? defaultPath : null;
 }
-/** Create an ephemeral config that preserves a user's existing MCP servers and settings. */
+/**
+ * Create an ephemeral DeepSeek MCP config.
+ *
+ * BYOA keeps the user's existing MCP settings in a private 0700/0600 directory. Managed
+ * Agent Service sessions instead write a progress-only 0750/0640 handoff below the
+ * supervisor-owned profile root so the separate runtime UID can read it without exposing
+ * control-plane configuration.
+ */
 export function createProgressMcpConfig(options = {}) {
     const platform = options.platform ?? process.platform;
     if (!progressMcpAutoInjectionSupported(platform)) {
         throw new ProgressMcpConfigError("report_progress MCP auto-injection is unavailable on Windows because clean child env isolation cannot be guaranteed");
     }
+    const managedRoot = resolveManagedProgressRoot(options.managedRoot);
+    if (managedRoot
+        && options.baseConfigPath !== undefined
+        && options.baseConfigPath !== null) {
+        throw new ProgressMcpConfigError("managed progress MCP config cannot preserve an existing DeepSeek MCP config");
+    }
     const serverPath = fileURLToPath(new URL("../mcp/report-progress-server.js", import.meta.url));
-    const baseConfigPath = options.baseConfigPath === undefined
-        ? resolveExistingDeepseekMcpConfig()
-        : options.baseConfigPath;
+    const baseConfigPath = managedRoot
+        ? null
+        : options.baseConfigPath === undefined
+            ? resolveExistingDeepseekMcpConfig()
+            : options.baseConfigPath;
     const baseConfig = loadBaseMcpConfig(baseConfigPath);
     const baseServers = mergeMcpServerFields(baseConfig);
     if (Object.hasOwn(baseServers, "botlearn")) {
         throw new ProgressMcpConfigError("DeepSeek MCP server key 'botlearn' is reserved for BotLearn progress reporting");
     }
-    const dir = mkdtempSync(path.join(tmpdir(), "botlearn-progress-mcp-"));
+    const dir = mkdtempSync(path.join(managedRoot ?? tmpdir(), "botlearn-progress-mcp-"));
     const configPath = path.join(dir, "mcp.json");
     const stagingPath = path.join(dir, ".mcp.json.tmp");
     const minimalPath = "/usr/bin:/bin";
@@ -157,7 +173,11 @@ export function createProgressMcpConfig(options = {}) {
         },
     };
     try {
+        if (managedRoot)
+            chmodSync(dir, 0o750);
         writeFileSync(stagingPath, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
+        if (managedRoot)
+            chmodSync(stagingPath, 0o640);
         renameSync(stagingPath, configPath);
         return { dir, path: configPath };
     }
@@ -166,6 +186,41 @@ export function createProgressMcpConfig(options = {}) {
         throw error;
     }
 }
+function resolveManagedProgressRoot(explicit) {
+    if (explicit === null)
+        return null;
+    let root = explicit?.trim();
+    if (root === undefined) {
+        const managedRuntime = process.env.BOTLEARN_RUNTIME_USER?.trim();
+        if (!managedRuntime)
+            return null;
+        root = process.env.BOTLEARN_AGENT_SERVICE_PROFILE_ROOT?.trim();
+        if (!root) {
+            throw new ProgressMcpConfigError("managed runtime is missing BOTLEARN_AGENT_SERVICE_PROFILE_ROOT");
+        }
+    }
+    if (!root || !path.isAbsolute(root)) {
+        throw new ProgressMcpConfigError("managed progress MCP root must be an absolute path");
+    }
+    try {
+        const stat = lstatSync(root);
+        if (!stat.isDirectory() || stat.isSymbolicLink()) {
+            throw new Error("root is not a regular directory");
+        }
+        const currentUid = process.getuid?.();
+        if (currentUid !== undefined && stat.uid !== currentUid) {
+            throw new Error("root is not owned by the control process uid");
+        }
+        if ((stat.mode & 0o022) !== 0) {
+            throw new Error("root must not be group or world writable");
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new ProgressMcpConfigError(`managed progress MCP root is unavailable: ${message}`);
+    }
+    return root;
+}
 function loadBaseMcpConfig(configPath) {
     if (!configPath)
         return {};

package/dist/sandbox-supervisor.d.ts

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
-export declare function acquireSessionSupervisorLock(runtimeSessionId: string, lockRoot?: string): (() => void) | null;
+export declare function acquireSandboxSupervisorLock(sandboxId: string, lockRoot?: string): (() => void) | null;
 export declare function runSandboxSupervisor(argv: string[]): Promise<number>;
 export declare function isMainModule(entry?: string): boolean;

package/dist/sandbox-supervisor.js

@@ -49,8 +49,8 @@ async function readOneShotBootstrap() {
         throw new Error("sandbox supervisor bootstrap is empty");
     return Buffer.concat(chunks);
 }
-export function acquireSessionSupervisorLock(runtimeSessionId, lockRoot = SUPERVISOR_LOCK_ROOT) {
-    const lockDir = path.join(lockRoot, runtimeSessionId);
+export function acquireSandboxSupervisorLock(sandboxId, lockRoot = SUPERVISOR_LOCK_ROOT) {
+    const lockDir = path.join(lockRoot, sandboxId);
     const pidFile = path.join(lockDir, "pid");
     mkdirSync(lockRoot, { recursive: true, mode: 0o700 });
     try {
@@ -84,23 +84,23 @@ export function acquireSessionSupervisorLock(runtimeSessionId, lockRoot = SUPERV
         }
     };
 }
-function prepareDirectories(controlUid, controlGid, runtimeUid, runtimeSessionId, sessionGeneration) {
+function prepareDirectories(controlUid, controlGid) {
     mkdirSync(CONTROL_HOME, { recursive: true, mode: 0o700 });
     chownSync("/home/botlearn-control/.botlearn-course", controlUid, controlGid);
     chownSync(CONTROL_HOME, controlUid, controlGid);
     chmodSync(CONTROL_HOME, 0o700);
-    mkdirSync(RUNTIME_PROFILE_ROOT, { recursive: true, mode: 0o750 });
+    mkdirSync(RUNTIME_PROFILE_ROOT, { recursive: true, mode: 0o710 });
     chownSync(RUNTIME_PROFILE_ROOT, controlUid, controlGid);
-    chmodSync(RUNTIME_PROFILE_ROOT, 0o750);
-    mkdirSync(WORKSPACE, { recursive: true, mode: 0o770 });
-    chownSync(WORKSPACE, runtimeUid, controlGid);
-    chmodSync(WORKSPACE, 0o770);
-    const sessionWorkspace = path.join(WORKSPACE, runtimeSessionId, `generation-${sessionGeneration}`);
-    mkdirSync(sessionWorkspace, { recursive: true, mode: 0o770 });
-    chownSync(path.join(WORKSPACE, runtimeSessionId), runtimeUid, controlGid);
-    chownSync(sessionWorkspace, runtimeUid, controlGid);
-    chmodSync(path.join(WORKSPACE, runtimeSessionId), 0o770);
-    chmodSync(sessionWorkspace, 0o770);
+    // Runtime can traverse to the active run profile path named in its instructions,
+    // but cannot enumerate profiles belonging to other activations.
+    chmodSync(RUNTIME_PROFILE_ROOT, 0o710);
+    // /workspace 只准备根目录；per-session 子目录
+    // `<root>/<runtime_session_id>/generation-<sandbox_generation>` 由 daemon
+    // （botlearn-control）在 session.open 时创建。根目录只允许 runtime 组穿过，
+    // 不允许列举 session id；daemon 仅在 activation 期间开放目标子目录。
+    mkdirSync(WORKSPACE, { recursive: true, mode: 0o710 });
+    chownSync(WORKSPACE, controlUid, controlGid);
+    chmodSync(WORKSPACE, 0o710);
 }
 export async function runSandboxSupervisor(argv) {
     if (argv.length !== 2 || argv[0] !== "agent-service" || argv[1] !== "session") {
@@ -117,18 +117,18 @@ export async function runSandboxSupervisor(argv) {
     let releaseLock = null;
     try {
         const decoded = JSON.parse(bootstrap.toString("utf8"));
-        const runtimeSessionId = decoded.runtimeSessionId;
-        const sessionGeneration = Number(decoded.sessionGeneration ?? 0);
-        if (typeof runtimeSessionId !== "string" ||
-            !/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(runtimeSessionId) ||
-            !Number.isInteger(sessionGeneration) ||
-            sessionGeneration < 1) {
-            throw new Error("sandbox supervisor bootstrap session scope is invalid");
+        const sandboxId = decoded.sandboxId;
+        const sandboxGeneration = Number(decoded.sandboxGeneration ?? 0);
+        if (typeof sandboxId !== "string" ||
+            !/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(sandboxId) ||
+            !Number.isInteger(sandboxGeneration) ||
+            sandboxGeneration < 1) {
+            throw new Error("sandbox supervisor bootstrap sandbox scope is invalid");
         }
-        releaseLock = acquireSessionSupervisorLock(runtimeSessionId);
+        releaseLock = acquireSandboxSupervisorLock(sandboxId);
         if (releaseLock === null)
             return 0;
-        prepareDirectories(controlUid, controlGid, runtimeUid, runtimeSessionId, sessionGeneration);
+        prepareDirectories(controlUid, controlGid);
         child = spawn(NODE_BINARY, [
             DAEMON_ENTRY,
             "agent-service",

package/dist/types.d.ts

@@ -114,6 +114,11 @@ export interface AppliedRunRuntimeProfile {
 export interface RuntimeContentBlock {
     kind: "text_delta" | "text" | "thinking" | "tool_call" | "tool_result" | "status" | "error";
     text?: string;
+    /** Safe provider-normalized tool identifier. Raw arguments/results stay in the transcript only. */
+    name?: string;
+    /** Public lifecycle metadata; never carries provider reasoning or tool output. */
+    phase?: "in_progress" | "completed";
+    status?: "completed" | "error";
     raw?: unknown;
 }
 /** 已由 provider adapter 严格归一化、无 provider raw envelope 的进度遥测。 */

package/dist/workspace.d.ts

@@ -18,14 +18,37 @@ export declare function runWorkspaceDir(agentRunId: string): string;
 export declare function transcriptPath(agentRunId: string): string;
 export declare function runtimeProfileDir(agentRunId: string): string;
 export declare function runtimeProfileRunRootDir(agentRunId: string): string;
-export declare function runtimeSessionRootDir(runtimeSessionId: string, sessionGeneration: number): string;
-export declare function runtimeSessionWorkspaceDir(runtimeSessionId: string, sessionGeneration: number): string;
-export declare function runtimeSessionTranscriptPath(runtimeSessionId: string, sessionGeneration: number, agentRunId: string): string;
+export declare function runtimeSessionRootDir(runtimeSessionId: string, sandboxGeneration: number): string;
+/**
+ * per-session workspace（ADR-015 §7）：managed sandbox 下为
+ * `<BOTLEARN_AGENT_SERVICE_WORKSPACE_ROOT>/<runtime_session_id>/generation-<sandbox_generation>`，
+ * 由 daemon 在 session.open 时创建。
+ */
+export declare function runtimeSessionWorkspaceDir(runtimeSessionId: string, sandboxGeneration: number): string;
+export declare function runtimeSessionTranscriptPath(runtimeSessionId: string, sandboxGeneration: number, agentRunId: string): string;
 export declare function ensureRunWorkspace(agentRunId: string): {
     rootDir: string;
     workspaceDir: string;
 };
-export declare function ensureRuntimeSessionWorkspace(runtimeSessionId: string, sessionGeneration: number, agentRunId: string): {
+/**
+ * session.open 时创建 per-session 目录。managed workspace 默认保持 0700，只有当前
+ * activation 会通过 exposeRuntimeSessionWorkspace() 临时开放给 runtime 组。
+ */
+export declare function ensureRuntimeSessionDirectories(runtimeSessionId: string, sandboxGeneration: number): {
+    rootDir: string;
+    workspaceDir: string;
+};
+/**
+ * 暴露当前 activation 的 managed workspace。sandbox 根目录由 supervisor 设为
+ * 0710，因此 runtime 只能穿过根目录，不能列举其他 session id；未激活 session
+ * 的父目录与 workspace 始终为 0700。
+ */
+export declare function exposeRuntimeSessionWorkspace(runtimeSessionId: string, sandboxGeneration: number): void;
+/** Revoke a managed workspace without deleting the session's durable local materialization. */
+export declare function revokeRuntimeSessionWorkspace(runtimeSessionId: string, sandboxGeneration: number): void;
+/** session.close 时删除 workspace 与本地 session 物化状态（transcripts 等）。幂等。 */
+export declare function removeRuntimeSessionWorkspace(runtimeSessionId: string, sandboxGeneration: number): void;
+export declare function ensureRuntimeSessionWorkspace(runtimeSessionId: string, sandboxGeneration: number, agentRunId: string): {
     rootDir: string;
     workspaceDir: string;
     transcriptFile: string;