neoctl 0.2.34 → 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;
@@ -378,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;
@@ -408,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;
@@ -543,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 {
-        collectUnnotifiedCompletions() {
-            return taskStore.collectUnnotifiedCompletions().map((task) => ({
+        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(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,
@@ -441,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,
@@ -751,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");
@@ -768,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");
@@ -1011,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) => ({
@@ -1102,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;
@@ -1424,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"));
@@ -3020,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);