@botlearn-course/daemon 0.0.13-beta.1 → 0.0.13

package/dist/agent-service-sandbox.d.ts

@@ -7,6 +7,7 @@ export interface AgentServiceSandboxOptions {
     sandboxToken: string;
     runtimes: Map<string, CourseRuntime>;
     daemonVersion: string;
+    deepseekTuiVersion?: string;
     log?: Logger;
     random?: () => number;
     sleep?: (ms: number) => Promise<void>;

package/dist/agent-service-sandbox.js

@@ -313,6 +313,7 @@ export class AgentServiceSandboxClient {
         return {
             workspaceDir: prepared.workspaceDir,
             transcriptFile: prepared.transcriptFile,
+            runtimeStateDir: prepared.rootDir,
             nativeSessionId: session.nativeSessionId,
             contextRevision,
             runtimeEnv,
@@ -678,6 +679,12 @@ export class AgentServiceSandboxClient {
         await this.sendControlFrame("sandbox.ready", {
             protocol_versions: [AGENT_SERVICE_WS_SCHEMA],
             daemon_version: this.options.daemonVersion,
+            runtime_versions: {
+                course_daemon: this.options.daemonVersion,
+                ...(this.options.deepseekTuiVersion
+                    ? { deepseek_tui: this.options.deepseekTuiVersion }
+                    : {}),
+            },
             resumed_sessions: Object.keys(this.state.sessions),
             spool_frames: this.spoolFrameCount(),
         });

package/dist/cli.d.ts

@@ -20,4 +20,5 @@ export interface PollLoopDeps {
     log?: Logger;
 }
 export declare function runPollLoop(deps: PollLoopDeps): Promise<PollLoopExit>;
+export declare function assertManagedCourseDaemonVersion(actualVersion: string, selectedVersion: string | undefined): void;
 export declare function runCli(argv: string[]): Promise<number>;

package/dist/cli.js

@@ -337,6 +337,11 @@ async function readSandboxBootstrapFromStdin() {
             chunk.fill(0);
     }
 }
+export function assertManagedCourseDaemonVersion(actualVersion, selectedVersion) {
+    if (selectedVersion && selectedVersion !== actualVersion) {
+        throw new Error("Managed Course Daemon version does not match the selected release");
+    }
+}
 async function cmdAgentServiceSession(args) {
     const bootstrap = args.flags["bootstrap-stdin"] === true
         ? await readSandboxBootstrapFromStdin()
@@ -350,6 +355,7 @@ async function cmdAgentServiceSession(args) {
         console.error("Agent Service sandbox environment is incomplete");
         return 1;
     }
+    assertManagedCourseDaemonVersion(pkg.version, process.env.BOTLEARN_MANAGED_COURSE_DAEMON_VERSION?.trim() || undefined);
     augmentProcessPath();
     const runtimes = new Map();
     for (const mod of RUNTIME_MODULES) {
@@ -363,6 +369,7 @@ async function cmdAgentServiceSession(args) {
         sandboxToken,
         runtimes,
         daemonVersion: pkg.version,
+        deepseekTuiVersion: process.env.BOTLEARN_MANAGED_DEEPSEEK_TUI_VERSION?.trim() || undefined,
     });
     clearAgentServiceControlEnv();
     await client.run();

package/dist/run-dispatcher.d.ts

@@ -12,6 +12,7 @@ export interface RunDispatcherOptions {
 export interface PreparedPersistentTurn {
     workspaceDir: string;
     transcriptFile: string;
+    runtimeStateDir?: string;
     nativeSessionId: string | null;
     contextRevision: number;
     runtimeEnv?: NodeJS.ProcessEnv;

package/dist/run-dispatcher.js

@@ -685,6 +685,9 @@ export class RunDispatcher {
                     inputAttachments,
                     ...(persistentTurn
                         ? {
+                            ...(persistentTurn.runtimeStateDir
+                                ? { runtimeStateDir: persistentTurn.runtimeStateDir }
+                                : {}),
                             nativeSessionId: persistentTurn.nativeSessionId,
                             contextRevision: persistentTurn.contextRevision,
                             ...(persistentTurn.runtimeEnv

package/dist/runtime-env.js

@@ -17,6 +17,8 @@ const AGENT_SERVICE_SUPERVISOR_ENV_KEYS = [
     "BOTLEARN_RUNTIME_HOME",
     "BOTLEARN_RUNTIME_LAUNCHER",
     "BOTLEARN_RUNTIME_LAUNCH_MODE",
+    "BOTLEARN_MANAGED_COURSE_DAEMON_VERSION",
+    "BOTLEARN_MANAGED_DEEPSEEK_TUI_VERSION",
     "BOTLEARN_AGENT_SERVICE_WORKSPACE_ROOT",
     "BOTLEARN_AGENT_SERVICE_PROFILE_ROOT",
 ];

package/dist/runtimes/deepseek-tui.d.ts

@@ -38,13 +38,20 @@ export declare class DeepseekTuiAdapter implements EngineAdapter {
     private resolveBinary;
     private acquireHandle;
     /**
-     * 不设置 DEEPSEEK_RUNTIME_DIR：BYOA server 可跨 run 池化，直接使用用户本机
-     * deepseek 默认状态目录（含已登录凭据）；Agent Service server 按 activation 回收。
+     * BYOA continues to use the user's default DeepSeek state directory. Managed mode
+     * pins the durable RuntimeThreadStore to the RuntimeSession workspace even though
+     * the credential-bearing server process is still reclaimed after every activation.
      */
     private spawnEnv;
+    private prepareManagedRuntimeDir;
+    private compactionMarkerPath;
+    private compactionRequired;
+    private markCompactionRequired;
+    private clearCompactionRequired;
     private managedActivationId;
     private createThread;
     private patchThreadSystemContext;
+    private compactThread;
     private startTurnAndReadEvents;
     private interruptTurn;
     private readEvents;

package/dist/runtimes/deepseek-tui.js

@@ -1,5 +1,5 @@
 import { spawn } from "node:child_process";
-import { chmodSync, existsSync, realpathSync, writeFileSync } from "node:fs";
+import { chmodSync, existsSync, lstatSync, mkdirSync, realpathSync, rmSync, writeFileSync, } from "node:fs";
 import path from "node:path";
 import net from "node:net";
 import { MAX_PROGRESS_EVENTS_PER_ATTEMPT } from "../mcp/report-progress.js";
@@ -27,6 +27,12 @@ const STARTUP_POLL_MS = 250;
 /** 单轮流式 assistant 文本字节上限。 */
 const SSE_TEXT_CAP = 1 * 1024 * 1024;
 const VISION_MODEL_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,159}$/;
+const MANAGED_RUNTIME_DIR_NAME = ".botlearn-deepseek-runtime";
+const COMPACTION_REQUIRED_MARKER = "deepseek-native-compaction-required";
+const DEFAULT_DEEPSEEK_CONTEXT_WINDOW_TOKENS = 1_000_000;
+const LEGACY_DEEPSEEK_CONTEXT_WINDOW_TOKENS = 128_000;
+const UNKNOWN_MODEL_COMPACTION_THRESHOLD_TOKENS = 102_400;
+const COMPACTION_THRESHOLD_PERCENT = 80;
 function createManagedVisionConfig(opts, progressMcpConfig) {
     const model = opts.env?.BOTLEARN_DEEPSEEK_VISION_MODEL?.trim();
     if (!model)
@@ -161,6 +167,8 @@ export class DeepseekTuiAdapter {
         let countedInFlight = false;
         let releaseTurn;
         const managedActivationId = this.managedActivationId(opts);
+        let threadId = opts.sessionId?.trim() || "";
+        let fallbackUsed = false;
         try {
             // The local server has a process-level kill fallback when turn-scoped interrupt
             // fails. Serialize turns so cancelling one run can never terminate another run.
@@ -176,10 +184,6 @@ export class DeepseekTuiAdapter {
             if (handle.idleTimer)
                 clearTimeout(handle.idleTimer);
             const headers = authHeaders(handle.token);
-            // Agent Service model credentials are activation-scoped. The local DeepSeek
-            // server reads them only at process startup, so its native thread cache cannot
-            // safely cross activations; durable Course context rebuilds the new thread.
-            let threadId = managedActivationId ? "" : (opts.sessionId?.trim() || "");
             if (threadId && !isValidThreadId(threadId)) {
                 return {
                     text: "",
@@ -187,39 +191,93 @@ export class DeepseekTuiAdapter {
                     error: "deepseek-tui: invalid sessionId",
                 };
             }
-            if (!threadId) {
-                threadId = await this.createThread(handle.baseUrl, headers, opts, turnAbort.signal);
+            const resumedThreadId = threadId;
+            let turnOpts = opts;
+            let runResult;
+            let maintenanceUsage;
+            while (true) {
+                try {
+                    if (!threadId) {
+                        threadId = await this.createThread(handle.baseUrl, headers, opts, turnAbort.signal);
+                    }
+                    else {
+                        if (opts.systemContext !== undefined) {
+                            await this.patchThreadSystemContext(handle.baseUrl, headers, threadId, opts.systemContext, turnAbort.signal);
+                        }
+                        if (managedActivationId && this.compactionRequired(opts)) {
+                            const compacted = await this.compactThread({
+                                baseUrl: handle.baseUrl,
+                                headers,
+                                threadId,
+                                opts,
+                                signal: turnAbort.signal,
+                                handle,
+                            });
+                            maintenanceUsage = compacted.usage;
+                            if (compacted.error) {
+                                throw new Error(`native compaction failed: ${compacted.error}`);
+                            }
+                        }
+                    }
+                    runResult = await this.startTurnAndReadEvents({
+                        baseUrl: handle.baseUrl,
+                        headers,
+                        threadId,
+                        opts: turnOpts,
+                        signal: turnAbort.signal,
+                        handle,
+                    });
+                    break;
+                }
+                catch (error) {
+                    // A persisted native thread is a recoverable cache over the authoritative Course
+                    // conversation. Rebuild it in the same learner turn only when DeepSeek explicitly
+                    // confirms that the old thread is missing or expired.
+                    if (!fallbackUsed
+                        && Boolean(resumedThreadId)
+                        && threadId === resumedThreadId
+                        && isMissingThreadHttpError(error)) {
+                        fallbackUsed = true;
+                        threadId = "";
+                        maintenanceUsage = undefined;
+                        if (managedActivationId)
+                            this.clearCompactionRequired(opts);
+                        turnOpts = {
+                            ...opts,
+                            text: opts.recoveryText ?? opts.text,
+                        };
+                        continue;
+                    }
+                    throw error;
+                }
             }
-            else if (opts.systemContext !== undefined) {
-                await this.patchThreadSystemContext(handle.baseUrl, headers, threadId, opts.systemContext, turnAbort.signal);
+            if (managedActivationId
+                && runResult.usage?.input_tokens !== undefined
+                && runResult.usage.input_tokens >= deepseekCompactionThreshold(runResult.model ?? parseDeepseekRuntimeSelection(opts.extraArgs).model)) {
+                this.markCompactionRequired(opts);
             }
-            const runResult = await this.startTurnAndReadEvents({
-                baseUrl: handle.baseUrl,
-                headers,
-                threadId,
-                opts,
-                signal: turnAbort.signal,
-                handle,
-            });
             const text = runResult.text;
             const error = runResult.error ?? (text === "" ? emptyCompletionError(handle.stderrTail) : undefined);
+            const usage = mergeRuntimeUsage(maintenanceUsage, runResult.usage);
             return {
                 text,
-                newSessionId: managedActivationId ? "" : threadId,
+                newSessionId: threadId,
                 ...(runResult.progressDispositions
                     ? { progressDispositions: runResult.progressDispositions }
                     : {}),
-                ...(runResult.usage ? { usage: runResult.usage } : {}),
+                ...(usage ? { usage } : {}),
                 ...(error ? { error } : {}),
             };
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
-            // 服务端明确确认线程不存在/已过期时才清空 sessionId，让下一轮从 durable context 重建。
-            const staleSession = Boolean(opts.sessionId) && isMissingThreadHttpError(err);
+            // Only an explicit 404/410 discards the native id. Transient failures preserve it.
+            const staleSession = Boolean(threadId) && isMissingThreadHttpError(err);
             return {
                 text: "",
-                newSessionId: managedActivationId || staleSession ? "" : (opts.sessionId ?? ""),
+                newSessionId: staleSession || (fallbackUsed && !threadId)
+                    ? ""
+                    : (threadId || opts.sessionId || ""),
                 error: `deepseek-tui: ${message}`,
             };
         }
@@ -355,8 +413,9 @@ export class DeepseekTuiAdapter {
         return handle;
     }
     /**
-     * 不设置 DEEPSEEK_RUNTIME_DIR：BYOA server 可跨 run 池化，直接使用用户本机
-     * deepseek 默认状态目录（含已登录凭据）；Agent Service server 按 activation 回收。
+     * BYOA continues to use the user's default DeepSeek state directory. Managed mode
+     * pins the durable RuntimeThreadStore to the RuntimeSession workspace even though
+     * the credential-bearing server process is still reclaimed after every activation.
      */
     spawnEnv(opts, progressMcpConfigPath, visionConfigPath) {
         const env = {
@@ -368,8 +427,40 @@ export class DeepseekTuiAdapter {
             env.DEEPSEEK_MCP_CONFIG = progressMcpConfigPath;
         if (visionConfigPath)
             env.DEEPSEEK_CONFIG_PATH = visionConfigPath;
+        if (this.managedActivationId(opts)) {
+            env.DEEPSEEK_RUNTIME_DIR = this.prepareManagedRuntimeDir(opts);
+        }
         return env;
     }
+    prepareManagedRuntimeDir(opts) {
+        const runtimeDir = path.join(opts.cwd, MANAGED_RUNTIME_DIR_NAME);
+        mkdirSync(runtimeDir, { recursive: true, mode: 0o770 });
+        const stat = lstatSync(runtimeDir);
+        if (!stat.isDirectory() || stat.isSymbolicLink()) {
+            throw new Error("deepseek-tui: managed runtime directory is not a real directory");
+        }
+        // The control process owns the directory; the fixed runtime group needs write access.
+        chmodSync(runtimeDir, 0o770);
+        return runtimeDir;
+    }
+    compactionMarkerPath(opts) {
+        if (!opts.runtimeStateDir) {
+            throw new Error("deepseek-tui: managed RuntimeSession state directory is unavailable");
+        }
+        return path.join(opts.runtimeStateDir, COMPACTION_REQUIRED_MARKER);
+    }
+    compactionRequired(opts) {
+        return existsSync(this.compactionMarkerPath(opts));
+    }
+    markCompactionRequired(opts) {
+        writeFileSync(this.compactionMarkerPath(opts), "required\n", {
+            encoding: "utf8",
+            mode: 0o600,
+        });
+    }
+    clearCompactionRequired(opts) {
+        rmSync(this.compactionMarkerPath(opts), { force: true });
+    }
     managedActivationId(opts) {
         if (this.explicitServerUrl)
             return null;
@@ -418,6 +509,74 @@ export class DeepseekTuiAdapter {
             signal,
         });
     }
+    async compactThread(args) {
+        const { baseUrl, headers, threadId, opts, signal, handle } = args;
+        const eventsUrl = `${baseUrl}/v1/threads/${encodeURIComponent(threadId)}/events?since_seq=0`;
+        const eventsAbort = new AbortController();
+        let turnId = "";
+        let interruptPromise;
+        const interrupt = () => {
+            if (!turnId)
+                return Promise.resolve();
+            interruptPromise ??= this.interruptTurn(baseUrl, headers, threadId, turnId).catch((error) => {
+                log.warn("deepseek-tui compaction interrupt failed", {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                if (!this.explicitServerUrl)
+                    shutdownHandle(handle, "compaction-interrupt-failed");
+            });
+            return interruptPromise;
+        };
+        const onAbort = () => {
+            eventsAbort.abort();
+            void interrupt();
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        let eventsError;
+        const quietOpts = {
+            ...opts,
+            onBlock: () => undefined,
+            onStatus: () => undefined,
+        };
+        const eventsReaderPromise = this.readEvents(eventsUrl, headers, quietOpts, eventsAbort.signal).catch((error) => {
+            eventsError = error;
+            return null;
+        });
+        try {
+            if (signal.aborted)
+                throw abortReason(signal);
+            const started = await this.requestJson(`${baseUrl}/v1/threads/${encodeURIComponent(threadId)}/compact`, {
+                method: "POST",
+                headers,
+                body: JSON.stringify({
+                    reason: "BotLearn automatic long-context compaction",
+                }),
+                signal: AbortSignal.timeout(5_000),
+            });
+            turnId = stringField(started?.turn, "id") ?? stringField(started, "turn_id") ?? "";
+            if (signal.aborted)
+                await interrupt();
+            const eventsReader = await eventsReaderPromise;
+            if (!eventsReader)
+                throw eventsError ?? new Error("compaction events stream failed");
+            const result = await eventsReader(turnId);
+            const model = stringField(started?.thread, "model");
+            return {
+                ...result,
+                ...(model ? { model } : {}),
+            };
+        }
+        finally {
+            if (signal.aborted) {
+                if (turnId)
+                    await interrupt();
+                else if (!this.explicitServerUrl)
+                    shutdownHandle(handle, "cancelled-before-compaction-id");
+            }
+            eventsAbort.abort();
+            signal.removeEventListener("abort", onAbort);
+        }
+    }
     async startTurnAndReadEvents(args) {
         const { baseUrl, headers, threadId, opts, signal, handle } = args;
         // 事件流必须先于 turn 打开，否则 turn 早期事件会丢。
@@ -476,7 +635,12 @@ export class DeepseekTuiAdapter {
             const eventsReader = await eventsReaderPromise;
             if (!eventsReader)
                 throw eventsError ?? new Error("events stream failed");
-            return await eventsReader(turnId);
+            const result = await eventsReader(turnId);
+            const model = stringField(started?.thread, "model");
+            return {
+                ...result,
+                ...(model ? { model } : {}),
+            };
         }
         finally {
             if (signal.aborted) {
@@ -754,6 +918,55 @@ export function extractDeepseekUsage(payload) {
         ...(requestId ? { provider_request_ids: [requestId] } : {}),
     };
 }
+/** Mirrors DeepSeek TUI 0.8.39's model-window compaction threshold selection. */
+function deepseekCompactionThreshold(model) {
+    if (!model)
+        return UNKNOWN_MODEL_COMPACTION_THRESHOLD_TOKENS;
+    const lower = model.toLowerCase();
+    let contextWindow;
+    if (lower.includes("deepseek")) {
+        const explicit = lower.match(/(?:^|[^a-z0-9])(\d{1,4})k(?:$|[^a-z0-9])/);
+        const kiloTokens = explicit?.[1] ? Number(explicit[1]) : Number.NaN;
+        if (Number.isInteger(kiloTokens) && kiloTokens >= 8 && kiloTokens <= 1024) {
+            contextWindow = kiloTokens * 1_000;
+        }
+        else {
+            contextWindow = lower.includes("v4")
+                ? DEFAULT_DEEPSEEK_CONTEXT_WINDOW_TOKENS
+                : LEGACY_DEEPSEEK_CONTEXT_WINDOW_TOKENS;
+        }
+    }
+    else if (lower.includes("claude")) {
+        contextWindow = 200_000;
+    }
+    if (contextWindow === undefined)
+        return UNKNOWN_MODEL_COMPACTION_THRESHOLD_TOKENS;
+    return Math.floor((contextWindow * COMPACTION_THRESHOLD_PERCENT) / 100);
+}
+function mergeRuntimeUsage(first, second) {
+    if (!first)
+        return second;
+    if (!second)
+        return first;
+    const sum = (left, right) => left !== undefined || right !== undefined ? (left ?? 0) + (right ?? 0) : undefined;
+    const requestIds = [...new Set([
+            ...(first.provider_request_ids ?? []),
+            ...(second.provider_request_ids ?? []),
+        ])];
+    const input = sum(first.input_tokens, second.input_tokens);
+    const cached = sum(first.cached_input_tokens, second.cached_input_tokens);
+    const output = sum(first.output_tokens, second.output_tokens);
+    const total = sum(first.total_tokens, second.total_tokens);
+    const cost = sum(first.cost_usd, second.cost_usd);
+    return {
+        ...(input !== undefined ? { input_tokens: input } : {}),
+        ...(cached !== undefined ? { cached_input_tokens: cached } : {}),
+        ...(output !== undefined ? { output_tokens: output } : {}),
+        ...(total !== undefined ? { total_tokens: total } : {}),
+        ...(cost !== undefined ? { cost_usd: cost } : {}),
+        ...(requestIds.length > 0 ? { provider_request_ids: requestIds } : {}),
+    };
+}
 function isToolStarted(eventName, payload) {
     const itemKind = payload?.payload?.item?.kind ?? payload?.item?.kind;
     return ((eventName === "item.started" &&

package/dist/runtimes/engine.d.ts

@@ -34,9 +34,13 @@ export type RuntimeStatusEvent = {
 };
 export interface EngineRunOptions {
     text: string;
+    /** Full durable conversation bootstrap, used only if a resumed native thread is missing. */
+    recoveryText?: string;
     /** runtime 原生会话 id（resume 用）；null 表示新会话。 */
     sessionId: string | null;
     cwd: string;
+    /** Daemon-owned state directory for runtime metadata that the model must not mutate. */
+    runtimeStateDir?: string;
     signal: AbortSignal;
     extraArgs?: string[];
     systemContext?: string;

package/dist/runtimes/engine.js

@@ -152,14 +152,14 @@ export function wrapEngineAdapter(id, engine, opts) {
             const payload = run.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 resumesDeepseekThread = id === "deepseek-tui" && Boolean(run.nativeSessionId?.trim());
             const learnerInput = resumesDeepseekThread
                 ? renderCurrentLearnerRequest(payload)
                 : renderConversationInput(payload);
             const text = renderInputAttachments(run, learnerInput);
+            const recoveryText = resumesDeepseekThread
+                ? renderInputAttachments(run, renderConversationInput(payload))
+                : undefined;
             if (!text.trim()) {
                 throw new RuntimeExecutionError("empty task brief");
             }
@@ -190,8 +190,10 @@ export function wrapEngineAdapter(id, engine, opts) {
             };
             const result = await engine.run({
                 text,
+                ...(recoveryText !== undefined ? { recoveryText } : {}),
                 sessionId: run.nativeSessionId ?? null,
                 cwd: run.workspaceDir,
+                ...(run.runtimeStateDir ? { runtimeStateDir: run.runtimeStateDir } : {}),
                 signal,
                 ...(run.runtimeEnv ? { env: run.runtimeEnv } : {}),
                 ...(extraArgs.length > 0 ? { extraArgs } : {}),

package/dist/types.d.ts

@@ -185,6 +185,8 @@ export interface RunExecution {
     payload: RunStartPayload;
     /** Runtime cwd. Managed persistent sessions reuse one session-scoped workspace. */
     workspaceDir: string;
+    /** Daemon-owned state directory for one managed RuntimeSession; never exposed to the model. */
+    runtimeStateDir?: string;
     /** Runtime-native thread/session id to resume; null creates the first native session. */
     nativeSessionId?: string | null;
     /** Monotonic Course Service context revision accepted for this turn. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botlearn-course/daemon",
-  "version": "0.0.13-beta.1",
+  "version": "0.0.13",
   "description": "Lightweight BotLearn Course daemon: run course tasks on your own machine with your own agent runtime (BYOA).",
   "type": "module",
   "bin": {