neoctl 0.2.35 → 0.2.36

package/dist/web/index.d.ts

@@ -6,11 +6,12 @@ import { type ModelProviderName } from "../model/config.js";
 import { CommunicationLogger, LoggingModelGateway } from "../model/communication-logger.js";
 import type { ModelUsage, ReasoningConfig } from "../model/model-gateway.js";
 import { ToolRegistry } from "../tools/registry.js";
-import type { Tool } from "../tools/tool.js";
+import type { Tool, ToolUseContext } from "../tools/tool.js";
 import { type ToolPresentation } from "../tools/tool-catalog.js";
 import { ExecProcessManager } from "../tools/builtins/exec-process-manager.js";
 import { type AgentToolRuntime } from "../agents/agent-tool.js";
 import { TaskStore } from "../tasks/task-store.js";
+import type { TaskNotificationSource } from "../core/query.js";
 import type { CompactionReport } from "../context/compaction.js";
 import type { PromptSection } from "../context/prompts.js";
 import type { NeoPluginResource } from "../plugins/plugin-system.js";
@@ -302,6 +303,11 @@ type WebLineOperation = {
 };
 export declare function runWebServer(argv?: string[], runtimeOptions?: RunWebServerOptions): Promise<void>;
 export declare function createWebRuntime(options?: CreateWebRuntimeOptions): Promise<WebRuntime>;
+/** Bind only the foreground view; never stop work owned by another session. */
+export declare function activateSession(runtime: Pick<WebRuntime, "engine" | "taskStore">): void;
+export declare function sessionAgentTasks(runtime: Pick<WebRuntime, "engine" | "taskStore">): import("../index.js").LocalAgentTask[];
+export declare function createResumeParentContext(engine: QueryEngine, tools: ToolUseContext["tools"], cwd?: string): ToolUseContext;
+export declare function createTaskNotificationSource(taskStore: TaskStore): TaskNotificationSource;
 export declare class WebRuntimeRouter {
     private readonly repls;
     private readonly createRuntime;
@@ -358,7 +364,6 @@ export declare class WebRepl {
     private pendingUserImageEchoMessageId;
     private runtimeContextRevision;
     private runtimeContextPublishQueue;
-    private pendingRuntimeConfiguration;
     private readonly backgroundSessionRuns;
     private readonly suppressReattachedStreaming;
     constructor(runtime: WebRuntime);
@@ -379,11 +384,48 @@ export declare class WebRepl {
             type: import("../index.js").LocalAgentTaskType;
             status: import("../index.js").LocalAgentTaskStatus;
             description: string;
-            prompt: string;
-            progress: import("../index.js").AgentProgressSnapshot;
-            outputFile: string;
+            runGeneration: number;
+            progress: {
+                lastActivity: string | undefined;
+                currentAction: string | undefined;
+                totalToolUseCount: number;
+                steps: {
+                    id: string;
+                    title: string;
+                    status: "completed" | "running" | "failed";
+                }[] | undefined;
+            };
+            pendingMessageCount: number;
+            deliveredRetainedThisRun: number | undefined;
+            messageReceipts: {
+                id: string;
+                status: "queued" | "delivered";
+                queuedAt: string;
+                deliveredAt: string | undefined;
+                runGeneration: number;
+            }[];
+            result: {
+                content: string;
+                truncated: boolean;
+                status: "completed" | "incomplete" | undefined;
+            } | undefined;
+            error: string | undefined;
+            errorTruncated: boolean;
+            runHistory: {
+                runGeneration: number;
+                status: import("../index.js").LocalAgentTaskStatus;
+                completedAt: string | undefined;
+                result: {
+                    content: string;
+                    truncated: boolean;
+                    status: "completed" | "incomplete" | undefined;
+                } | undefined;
+                error: string | undefined;
+                errorTruncated: boolean;
+            }[];
             createdAt: string;
             updatedAt: string;
+            completedAt: string | undefined;
         } | {
             kind: "terminal";
             taskId: string;
@@ -409,6 +451,57 @@ export declare class WebRepl {
             createdAt: number;
             sessionId: string;
         })[];
+        agentTaskHistory: {
+            kind: "agent";
+            taskId: string;
+            agentId: string;
+            agentType: string | undefined;
+            type: import("../index.js").LocalAgentTaskType;
+            status: import("../index.js").LocalAgentTaskStatus;
+            description: string;
+            runGeneration: number;
+            progress: {
+                lastActivity: string | undefined;
+                currentAction: string | undefined;
+                totalToolUseCount: number;
+                steps: {
+                    id: string;
+                    title: string;
+                    status: "completed" | "running" | "failed";
+                }[] | undefined;
+            };
+            pendingMessageCount: number;
+            deliveredRetainedThisRun: number | undefined;
+            messageReceipts: {
+                id: string;
+                status: "queued" | "delivered";
+                queuedAt: string;
+                deliveredAt: string | undefined;
+                runGeneration: number;
+            }[];
+            result: {
+                content: string;
+                truncated: boolean;
+                status: "completed" | "incomplete" | undefined;
+            } | undefined;
+            error: string | undefined;
+            errorTruncated: boolean;
+            runHistory: {
+                runGeneration: number;
+                status: import("../index.js").LocalAgentTaskStatus;
+                completedAt: string | undefined;
+                result: {
+                    content: string;
+                    truncated: boolean;
+                    status: "completed" | "incomplete" | undefined;
+                } | undefined;
+                error: string | undefined;
+                errorTruncated: boolean;
+            }[];
+            createdAt: string;
+            updatedAt: string;
+            completedAt: string | undefined;
+        }[];
         backgroundSessionRunCount: number;
         runningSessionIds: string[];
         session: import("../index.js").SessionStoreSnapshot | undefined;
@@ -480,7 +573,6 @@ export declare class WebRepl {
     private parseToolModes;
     private applySessionToolOverrides;
     private syncPluginToolRegistration;
-    private applyRuntimeConfiguration;
     private refreshToolConfiguration;
     private applySessionPluginOverrides;
     submit(text: string, attachments?: WebAttachmentPayload[]): Promise<{
@@ -545,6 +637,7 @@ export declare class WebRepl {
     private setStatus;
     private finalizeForegroundView;
     private stopForegroundRun;
+    private agentTaskSnapshot;
     private backgroundTasks;
     private detachRunningForeground;
     private reattachRunningSession;

package/dist/web/index.js

@@ -167,14 +167,10 @@ export async function createWebRuntime(options = {}) {
             tools.register(tool);
     const agentRuntime = { modelGateway, tools, taskStore };
     registerTool(createAgentTool(agentRuntime), { source: "builtin" });
+    let runtime;
     const resumeHandler = async (taskId, directive) => {
-        const dummyContext = {
-            agentId: "main",
-            tools,
-            appState: new InMemoryAppState("main", options.cwd),
-            emit: () => undefined,
-        };
-        return resumeAgentTask(taskId, directive, agentRuntime, taskStore, dummyContext);
+        const parentContext = createResumeParentContext(runtime.engine, tools, options.cwd);
+        return resumeAgentTask(taskId, directive, agentRuntime, taskStore, parentContext);
     };
     for (const tool of createSubagentTools(taskStore, resumeHandler))
         registerTool(tool, { source: "builtin" });
@@ -210,8 +206,9 @@ export async function createWebRuntime(options = {}) {
         },
     });
     await engine.initialize();
+    activateSession({ engine, taskStore });
     const initialMetrics = await engine.contextMetrics();
-    return {
+    runtime = {
         engine,
         appPromptStore,
         communicationLogger,
@@ -242,6 +239,7 @@ export async function createWebRuntime(options = {}) {
             resolveSession: options.resolveSessionToolOverrides,
         },
     };
+    return runtime;
 }
 function normalizeWebRuntimePlugins(value) {
     if (!Array.isArray(value))
@@ -274,10 +272,38 @@ function applyToolOverrides(registry, catalog, globalOverrides, sessionOverrides
     for (const tool of catalog)
         registry.setEnabled(tool.name, sessionOverrides[tool.name] ?? globalOverrides[tool.name] ?? true);
 }
-function createTaskNotificationSource(taskStore) {
+/** Bind only the foreground view; never stop work owned by another session. */
+export function activateSession(runtime) {
+    runtime.taskStore.bindSession?.(runtime.engine.snapshot().session?.sessionDir || undefined);
+}
+export function sessionAgentTasks(runtime) {
+    const dir = runtime.engine.snapshot().session?.sessionDir || undefined;
+    // Older embedders provide minimal TaskStore mocks with no persistence API.
+    return runtime.taskStore.list().filter((task) => !runtime.taskStore.bindSession
+        || task.ownerSessionDir === (dir ? path.resolve(dir) : undefined));
+}
+export function createResumeParentContext(engine, tools, cwd) {
+    const snapshot = engine.snapshot();
+    const session = snapshot.session;
+    return {
+        agentId: snapshot.agentId ?? "main",
+        tools,
+        appState: new InMemoryAppState(snapshot.agentId ?? "main", cwd),
+        session: session?.sessionDir ? {
+            sessionId: session.sessionId,
+            sessionDir: session.sessionDir,
+            rootDir: path.dirname(session.sessionDir),
+        } : undefined,
+        options: { mainLoopModel: snapshot.model, reasoning: snapshot.reasoning,
+            contextWindowTokensOverride: snapshot.contextWindowTokensOverride },
+        emit: () => undefined,
+    };
+}
+export function createTaskNotificationSource(taskStore) {
     return {
-        collectUnnotifiedCompletions() {
-            return taskStore.collectUnnotifiedCompletions().map((task) => ({
+        collectUnnotifiedCompletions(sessionDir) {
+            return taskStore.collectUnnotifiedCompletions(sessionDir).filter((task) => !taskStore.bindSession
+                || task.ownerSessionDir === (sessionDir ? path.resolve(sessionDir) : undefined)).map((task) => ({
                 taskId: task.taskId,
                 agentId: task.agentId,
                 status: task.status,
@@ -389,7 +415,6 @@ export class WebRepl {
     pendingUserImageEchoMessageId;
     runtimeContextRevision = 0;
     runtimeContextPublishQueue = Promise.resolve();
-    pendingRuntimeConfiguration = false;
     backgroundSessionRuns = new Map();
     suppressReattachedStreaming = new Set();
     constructor(runtime) {
@@ -442,6 +467,7 @@ export class WebRepl {
             queuedInput: this.queuedInput,
             backgroundTaskCount: backgroundTasks.length,
             backgroundTasks,
+            agentTaskHistory: sessionAgentTasks(this.runtime).filter((task) => this.runtime.taskStore.isTerminal(task)).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt)).slice(0, 20).map((task) => this.agentTaskSnapshot(task)),
             backgroundSessionRunCount: this.backgroundSessionRuns.size,
             runningSessionIds: [...this.backgroundSessionRuns.keys()],
             session: this.runtime.engine.snapshot().session,
@@ -514,6 +540,8 @@ export class WebRepl {
         };
     }
     async setGlobalTools(value) {
+        if (this.busy)
+            return actionFailure("TOOL_UPDATE_BLOCKED", "cannot change global tools while a response is running");
         if (!isRecord(value))
             return actionFailure("INVALID_REQUEST", "tool overrides must be an object");
         const support = this.runtime.toolSupport;
@@ -524,12 +552,10 @@ export class WebRepl {
             return normalized;
         try {
             support.globalOverrides = normalized.value;
+            this.syncPluginToolRegistration();
+            applyToolOverrides(this.runtime.tools, support.catalog, support.globalOverrides, support.sessionOverrides);
             if (support.persistGlobal)
                 await support.persistGlobal(support.globalOverrides);
-            if (this.busy)
-                this.pendingRuntimeConfiguration = true;
-            else
-                await this.applyRuntimeConfiguration();
             await this.refreshToolConfiguration();
             return { ok: true, state: this.globalTools() };
         }
@@ -538,6 +564,8 @@ export class WebRepl {
         }
     }
     async setSessionTools(value) {
+        if (this.busy)
+            return actionFailure("TOOL_UPDATE_BLOCKED", "cannot change session tools while a response is running");
         if (!isRecord(value))
             return actionFailure("INVALID_REQUEST", "tool overrides must be an object");
         const support = this.runtime.toolSupport;
@@ -561,6 +589,8 @@ export class WebRepl {
         await this.applySessionToolOverrides(await support.resolveSession(sessionId), false);
     }
     async setSessionPlugins(value) {
+        if (this.busy)
+            return actionFailure("PLUGIN_UPDATE_BLOCKED", "cannot change session plugins while a response is running");
         if (!isRecord(value))
             return actionFailure("INVALID_REQUEST", "plugin overrides must be an object");
         const support = this.runtime.pluginSupport;
@@ -624,13 +654,11 @@ export class WebRepl {
         if (!support)
             return;
         support.sessionOverrides = normalizeToolOverrides(overrides, support.catalog);
+        this.syncPluginToolRegistration();
+        applyToolOverrides(this.runtime.tools, support.catalog, support.globalOverrides, support.sessionOverrides);
         const sessionId = this.runtime.engine.snapshot().session?.sessionId;
         if (persist && sessionId && support.persistSession)
             await support.persistSession(sessionId, support.sessionOverrides);
-        if (this.busy)
-            this.pendingRuntimeConfiguration = true;
-        else
-            await this.applyRuntimeConfiguration();
         await this.refreshToolConfiguration();
     }
     syncPluginToolRegistration() {
@@ -645,18 +673,6 @@ export class WebRepl {
                 this.runtime.tools.register(tool);
         }
     }
-    async applyRuntimeConfiguration() {
-        this.syncPluginToolRegistration();
-        const pluginSupport = this.runtime.pluginSupport;
-        if (pluginSupport) {
-            const activePlugins = activeWebRuntimePlugins(pluginSupport.catalog, pluginSupport.overrides);
-            this.runtime.engine.setRuntimePlugins([...pluginSupport.basePluginIds, ...activePlugins.map((plugin) => plugin.id)], [...pluginSupport.basePromptSections, ...activePlugins.flatMap((plugin) => plugin.promptSections ?? [])]);
-        }
-        const toolSupport = this.runtime.toolSupport;
-        if (toolSupport)
-            applyToolOverrides(this.runtime.tools, toolSupport.catalog, toolSupport.globalOverrides, toolSupport.sessionOverrides);
-        this.pendingRuntimeConfiguration = false;
-    }
     async refreshToolConfiguration() {
         const metrics = await this.runtime.engine.contextMetrics();
         this.runtime.initialMetrics = metrics;
@@ -669,14 +685,21 @@ export class WebRepl {
         if (!support)
             return;
         const normalized = normalizePluginOverrides(overrides, support.catalog);
+        for (const plugin of support.catalog)
+            for (const tool of plugin.tools)
+                this.runtime.tools.unregister(tool.name);
+        const activePlugins = activeWebRuntimePlugins(support.catalog, normalized);
+        for (const plugin of activePlugins)
+            for (const tool of plugin.tools)
+                this.runtime.tools.register(tool);
         support.overrides = normalized;
+        const toolSupport = this.runtime.toolSupport;
+        if (toolSupport)
+            applyToolOverrides(this.runtime.tools, toolSupport.catalog, toolSupport.globalOverrides, toolSupport.sessionOverrides);
+        this.runtime.engine.setRuntimePlugins([...support.basePluginIds, ...activePlugins.map((plugin) => plugin.id)], [...support.basePromptSections, ...activePlugins.flatMap((plugin) => plugin.promptSections ?? [])]);
         const sessionId = this.runtime.engine.snapshot().session?.sessionId;
         if (persist && sessionId && support.persist)
             await support.persist(sessionId, normalized);
-        if (this.busy)
-            this.pendingRuntimeConfiguration = true;
-        else
-            await this.applyRuntimeConfiguration();
         const metrics = await this.runtime.engine.contextMetrics();
         this.runtime.initialMetrics = metrics;
         this.setStatus({ ...this.status, metrics, activityTick: this.status.activityTick + 1 });
@@ -727,11 +750,7 @@ export class WebRepl {
         this.queuedAttachments = [...(this.queuedAttachments ?? []), ...attachments].slice(0, 20);
     }
     startRun(text, attachments = []) {
-        const run = (async () => {
-            if (this.pendingRuntimeConfiguration)
-                await this.applyRuntimeConfiguration();
-            await this.handleCommandOrPrompt(text, attachments);
-        })().catch((error) => {
+        const run = this.handleCommandOrPrompt(text, attachments).catch((error) => {
             this.append({ kind: "error", text: error instanceof Error ? error.message : String(error) });
             this.setBusy(false);
             this.setStatus({ ...this.status, phase: "ready", detail: undefined });
@@ -759,6 +778,7 @@ export class WebRepl {
             await this.detachRunningForeground("session switch");
             this.runtime.engine = this.runtime.engine.forkForSession(sessionId, true);
             await this.runtime.engine.initialize();
+            activateSession(this.runtime);
             const snapshot = this.runtime.engine.snapshot().session;
             if (!snapshot)
                 throw new Error("session transcripts are disabled");
@@ -776,6 +796,7 @@ export class WebRepl {
             await this.detachRunningForeground("new session");
             this.runtime.engine = this.runtime.engine.forkForSession(undefined, false);
             await this.runtime.engine.initialize();
+            activateSession(this.runtime);
             const snapshot = this.runtime.engine.snapshot().session;
             if (!snapshot)
                 throw new Error("session transcripts are disabled");
@@ -892,6 +913,8 @@ export class WebRepl {
         }
     }
     async setContextWindowK(value) {
+        if (this.busy)
+            return actionFailure("CONTEXT_WINDOW_UPDATE_BLOCKED", "cannot change context window while a response is running");
         if (typeof value !== "string" || !/^\d+$/u.test(value) || Number(value) <= 0) {
             return actionFailure("CONTEXT_WINDOW_INVALID", "context window must be a positive integer in k");
         }
@@ -1017,23 +1040,28 @@ export class WebRepl {
         this.broadcastSync();
         return runWasActive;
     }
+    agentTaskSnapshot(task) {
+        const terminal = this.runtime.taskStore.isTerminal(task);
+        const result = (value, limit = 1500) => value ? { content: value.content.slice(0, limit), truncated: value.content.length > limit, status: value.status } : undefined;
+        return {
+            kind: "agent", taskId: task.taskId, agentId: task.agentId,
+            agentType: task.agentType, type: task.type, status: task.status,
+            description: task.description, runGeneration: task.runGeneration ?? 1,
+            progress: { lastActivity: task.progress.lastActivity, currentAction: task.progress.currentAction, totalToolUseCount: task.progress.totalToolUseCount, steps: task.progress.steps?.slice(-8).map((step) => ({ id: step.id, title: step.title, status: step.status })) },
+            pendingMessageCount: task.pendingMessages.length,
+            deliveredRetainedThisRun: task.messageReceipts?.filter((receipt) => receipt.status === "delivered" && receipt.runGeneration === task.runGeneration).length,
+            messageReceipts: (task.messageReceipts ?? []).slice(-20).map(({ id, status, queuedAt, deliveredAt, runGeneration }) => ({ id, status, queuedAt, deliveredAt, runGeneration })),
+            result: terminal ? result(task.result) : undefined,
+            error: terminal ? task.error?.slice(0, 1500) : undefined,
+            errorTruncated: terminal && (task.error?.length ?? 0) > 1500,
+            runHistory: (task.runHistory ?? []).slice(-3).map((run) => ({ runGeneration: run.runGeneration, status: run.status, completedAt: run.completedAt, result: result(run.result, 600), error: run.error?.slice(0, 600), errorTruncated: (run.error?.length ?? 0) > 600 })),
+            createdAt: task.createdAt, updatedAt: task.updatedAt, completedAt: task.completedAt,
+        };
+    }
     backgroundTasks() {
-        const agentTasks = this.runtime.taskStore.list()
+        const agentTasks = sessionAgentTasks(this.runtime)
             .filter((task) => !this.runtime.taskStore.isTerminal(task))
-            .map((task) => ({
-            kind: "agent",
-            taskId: task.taskId,
-            agentId: task.agentId,
-            agentType: task.agentType,
-            type: task.type,
-            status: task.status,
-            description: task.description,
-            prompt: task.prompt,
-            progress: task.progress,
-            outputFile: task.outputFile,
-            createdAt: task.createdAt,
-            updatedAt: task.updatedAt,
-        }));
+            .map((task) => this.agentTaskSnapshot(task));
         const terminalTasks = this.runtime.execProcessManager.list()
             .filter((terminal) => terminal.status === "running" && terminal.backgrounded)
             .map((terminal) => ({
@@ -1108,6 +1136,7 @@ export class WebRepl {
         await this.detachRunningForeground("session switch");
         this.backgroundSessionRuns.delete(run.sessionId);
         this.runtime.engine = run.engine;
+        activateSession(this.runtime);
         this.activeAbortController = run.abortController;
         this.interruptArmed = false;
         this.foregroundRun = run.promise;
@@ -1430,6 +1459,7 @@ export class WebRepl {
             return void this.append({ kind: "system", text: formatUsageTotals(this.runtime.usage.snapshot()), previewStyle: "summary" });
         if (command.type === "reset") {
             this.runtime.engine.reset();
+            activateSession(this.runtime);
             this.runtime.usage.reset();
             this.status = await resetStatus(this.runtime);
             this.append(systemLine("transcript reset"));
@@ -3026,6 +3056,13 @@ function buildToolResultDisplay(toolName, output, ok) {
     }
     else if (toolName.startsWith("subagent_") || toolName === "subagent_run") {
         subject = stringValue(data.description) || stringValue(data.task_id) || stringValue(data.agent_id);
+        pushToolFact(facts, "任务状态", data.status);
+        pushToolFact(facts, "轮次", data.run_generation);
+        pushToolFact(facts, "待交付", data.pending_messages);
+        if (toolName === "subagent_message")
+            pushToolFact(facts, "交付说明", "仅入队，不代表已交付或完成");
+        if (data.requires_resume === true)
+            pushToolFact(facts, "后续", "需要显式续跑");
     }
     else if (toolName === "subagent_message") {
         subject = stringValue(data.target);