@diffexai/diffex 0.2.6 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## [0.3.0] - 2026-09-20
+
+### New Features
+
+- Added nonblocking `agent_status` for immediate child-status and result inspection, with automatic coordination for child completion. See [Automatic Sub-agent Coordination](docs/usage.md#automatic-sub-agent-coordination) ([#234](https://github.com/diffexai/diffex/pull/234)).
+- Added automatic subagent supervision with renewable work allowances and parent-deadline bounds. See [SDK tools](docs/sdk.md#tools) ([#233](https://github.com/diffexai/diffex/pull/233)).
+
+### Breaking Changes
+
+- Replaced the blocking `wait_for_agents` tool with nonblocking `agent_status`; rely on automatic child-result coordination instead of tool-managed waits ([#234](https://github.com/diffexai/diffex/pull/234)).
+
+### Fixed
+
+- Fixed automatic compaction to check complete tool-result batches ([#233](https://github.com/diffexai/diffex/pull/233)).
+- Fixed subagent completion and cancellation, including renewable work-allowance supervision ([#233](https://github.com/diffexai/diffex/pull/233)).
+- Fixed session and subagent cancellation to terminate owned background shell processes ([#233](https://github.com/diffexai/diffex/pull/233)).
+
+## [0.2.7] - 2026-09-18
+
+### Fixed
+
+- Improved stability and fixed UI issues.
+
 ## [0.2.6] - 2026-09-18
 
 ### Fixed

package/dist/core/agent-session.d.ts

@@ -263,6 +263,8 @@ export declare class AgentSession {
     private readonly _bashAbortControllers;
     private _pendingBashMessages;
     private readonly _ownedOperations;
+    private readonly _shellProcesses;
+    private readonly _bashOperations;
     private _extensionRunner;
     private _turnIndex;
     private _resourceLoader;
@@ -561,6 +563,9 @@ export declare class AgentSession {
      */
     abort(): Promise<void>;
     private _abort;
+    /** Stop and verify all shell processes owned by this session, including background jobs. */
+    terminateOwnedShellProcesses(): Promise<void>;
+    get ownedShellProcessCount(): number;
     waitForIdle(): Promise<void>;
     private _emitModelSelect;
     /**

package/dist/core/agent-session.js

@@ -18,6 +18,7 @@ import { NOOP_TELEMETRY_CONTEXT, uuidv7, } from "@diffexai/diffex-agent-core";
 import { contentText } from "@diffexai/diffex-ai";
 import { clampThinkingLevel, cleanupSessionResources, getSupportedThinkingLevels, isContextOverflow, isRecoverableLength, isRetryableAssistantError, modelsAreEqual, resetApiProviders, streamSimple, } from "@diffexai/diffex-ai/compat";
 import { getThemeByName, theme } from "../modes/interactive/theme/theme.js";
+import { OwnedShellProcesses } from "../utils/owned-shell-processes.js";
 import { canonicalizePath, resolvePath } from "../utils/paths.js";
 import { sleep } from "../utils/sleep.js";
 import { normalizeToolResultImages } from "../utils/tool-result-images.js";
@@ -161,6 +162,8 @@ export class AgentSession {
     _bashAbortControllers = new Set();
     _pendingBashMessages = [];
     _ownedOperations = new Set();
+    _shellProcesses = new OwnedShellProcesses();
+    _bashOperations = new Set();
     // Extension system
     _extensionRunner;
     _turnIndex = 0;
@@ -402,10 +405,25 @@ export class AgentSession {
         this.agent.prepareNextTurnWithContext = async (turn, signal) => {
             const previousSnapshot = await previousPrepareNextTurnWithContext?.(turn, signal);
             const previousContext = previousSnapshot?.context ?? turn.context;
+            let messages = previousContext.messages;
+            // Tool output is part of the next request even though the model's usage
+            // only describes the request before that output. Check every complete batch.
+            if (turn.toolResults.length > 0 && !signal?.aborted && this.model) {
+                const settings = this.settingsManager.getCompactionSettings();
+                if (shouldCompact(estimateContextTokens(messages).tokens, this.model.contextWindow, settings)) {
+                    const beforeCompaction = this.agent.state.messages;
+                    await this._runAutoCompaction("threshold", true, signal);
+                    if (this.agent.state.messages !== beforeCompaction) {
+                        messages = this.agent.state.messages;
+                    }
+                }
+            }
+            signal?.throwIfAborted();
             return {
                 ...previousSnapshot,
                 context: {
                     ...previousContext,
+                    messages,
                     systemPrompt: this._activeRunCollaborationState?.effectiveSystemPrompt ??
                         this._deriveEffectivePrompt(this._systemPromptOverride ?? this._baseSystemPrompt, this._activeRunCollaborationMode ?? this._collaborationMode),
                     tools: (this._activeRunCollaborationState?.tools ?? this.agent.state.tools).slice(),
@@ -836,7 +854,7 @@ export class AgentSession {
             failures.push(error);
         }
         const ownedOperationsIdle = this._waitForOwnedOperations();
-        const cleanupResults = await Promise.allSettled([childCleanup, rootIdle, ownedOperationsIdle].filter((promise) => promise !== undefined));
+        const cleanupResults = await Promise.allSettled([childCleanup, rootIdle, ownedOperationsIdle, this.terminateOwnedShellProcesses()].filter((promise) => promise !== undefined));
         for (const result of cleanupResults) {
             if (result.status !== "rejected")
                 continue;
@@ -1429,7 +1447,10 @@ export class AgentSession {
                 else
                     await this.agent.continue();
                 firstRun = false;
-                if (await this._handlePostAgentRun()) {
+                const next = await this._handlePostAgentRun();
+                if (next === "failed")
+                    break;
+                if (next === "continue") {
                     if (this._agentRunAborted) {
                         const coordination = this._subagentCoordination;
                         if (coordination) {
@@ -1605,10 +1626,10 @@ export class AgentSession {
         const msg = this._lastAssistantMessage;
         this._lastAssistantMessage = undefined;
         if (!msg) {
-            return false;
+            return "settled";
         }
         if (this._isRetryableError(msg) && (await this._prepareRetry(msg))) {
-            return true;
+            return "continue";
         }
         if (msg.stopReason === "error" && this._retryAttempt > 0) {
             this._emit({
@@ -1620,12 +1641,27 @@ export class AgentSession {
             this._retryAttempt = 0;
         }
         if (await this._checkCompaction(msg)) {
-            return true;
+            return "continue";
+        }
+        if (msg.stopReason === "error") {
+            // Recovery may have removed the failed response before giving up.
+            if (!this.agent.state.messages.includes(msg))
+                this.agent.state.messages.push(msg);
+            while (true) {
+                const coordination = this._getOrCreateSubagentCoordination();
+                if (!coordination)
+                    break;
+                this._exitSubagentCoordination("cancellation");
+                await this._waitForSubagentCoordination(coordination);
+            }
+            // Queued reports and input must not bypass an exhausted recovery budget.
+            // Leave them available for an explicit prompt or queue recovery by the caller.
+            return "failed";
         }
         // Reports already queued by this run must enter context before a new batch is frozen
         // or an escalation-suspended coordination resumes waiting.
         if (this.agent.hasQueuedMessages())
-            return true;
+            return "continue";
         while (true) {
             const coordination = this._getOrCreateSubagentCoordination();
             if (!coordination)
@@ -1633,28 +1669,44 @@ export class AgentSession {
             if (coordination.exitReason === "cancellation" || this._agentRunAborted) {
                 this._exitSubagentCoordination("cancellation");
             }
+            else if (!coordination.completionChecked) {
+                coordination.completionChecked = true;
+                const active = this.getSubagents().filter((child) => coordination.names.includes(child.name) && (child.status === "running" || child.status === "queued"));
+                if (active.length > 0) {
+                    await this.sendCustomMessage({
+                        customType: "subagent_completion_check",
+                        content: JSON.stringify({
+                            type: "subagent_completion_check",
+                            agents: active,
+                            instruction: "Review active children before finishing: cancel obsolete work with agent_action interrupt. If needed work remains, end your response to wait automatically. Renew only justified work.",
+                        }),
+                        display: false,
+                    }, { deliverAs: "steer" });
+                    return "continue";
+                }
+            }
             const delivery = await this._waitForSubagentCoordination(coordination);
             if (delivery.reason === "cancellation")
-                return false;
+                return "settled";
             if (delivery.reason === "escalation") {
                 if (coordination.exitReason === "cancellation" || this._agentRunAborted) {
                     this._exitSubagentCoordination("cancellation");
                     await this._waitForSubagentCoordination(coordination);
-                    return false;
+                    return "settled";
                 }
-                return true;
+                return "continue";
             }
             if (delivery.results.length > 0) {
                 const message = this._createSubagentResultMessage(delivery.results);
                 await this.sendCustomMessage(message, { deliverAs: "steer" });
-                return true;
+                return "continue";
             }
             // Explicit agents consumption can empty this batch while the same continuation
             // starts another coordinated child. Freeze that pending run before settling.
         }
         // The agent loop drains both queues before emitting agent_end. Any messages
         // here were queued by agent_end extension handlers and need a continuation.
-        return this.agent.hasQueuedMessages();
+        return this.agent.hasQueuedMessages() ? "continue" : "settled";
     }
     /**
      * Send a prompt to the agent.
@@ -2336,11 +2388,21 @@ export class AgentSession {
     }
     async _abort() {
         this.abortRetry();
+        this.abortCompaction();
+        this.abortBranchSummary();
+        this.abortBash();
         if (this._isAgentRunActive)
             this._agentRunAborted = true;
         this._exitSubagentCoordination("cancellation");
         this.agent.abort();
-        await this.waitForIdle();
+        await Promise.all([this.waitForIdle(), this.terminateOwnedShellProcesses(), ...this._bashOperations]);
+    }
+    /** Stop and verify all shell processes owned by this session, including background jobs. */
+    async terminateOwnedShellProcesses() {
+        await this._shellProcesses.terminateAll();
+    }
+    get ownedShellProcessCount() {
+        return this._shellProcesses.count;
     }
     async waitForIdle() {
         if (this.isIdle) {
@@ -2798,7 +2860,9 @@ export class AgentSession {
             contextTokens = directContextTokens;
         }
         if (shouldCompact(contextTokens, contextWindow, settings)) {
-            return await this._runAutoCompaction("threshold", false, signal, deferCommit);
+            const queuedContinuation = await this._runAutoCompaction("threshold", false, signal, deferCommit);
+            // Threshold compaction does not recover a provider failure.
+            return assistantMessage.stopReason !== "error" && queuedContinuation;
         }
         return false;
     }
@@ -2827,6 +2891,9 @@ export class AgentSession {
                 return false;
             }
             this._autoCompactionAbortController = new AbortController();
+            const compactionSignal = signal
+                ? AbortSignal.any([signal, this._autoCompactionAbortController.signal])
+                : this._autoCompactionAbortController.signal;
             this._emit({ type: "compaction_start", reason });
             started = true;
             let extensionCompaction;
@@ -2839,7 +2906,7 @@ export class AgentSession {
                     customInstructions: undefined,
                     reason,
                     willRetry,
-                    signal: this._autoCompactionAbortController.signal,
+                    signal: compactionSignal,
                 }));
                 if (extensionResult?.cancel) {
                     this._emit({
@@ -2871,14 +2938,14 @@ export class AgentSession {
             }
             else {
                 // Generate compaction result
-                const compactResult = await compact(preparation, requestModel, apiKey, headers, undefined, this._autoCompactionAbortController.signal, this.thinkingLevel, this.agent.streamFunction, env, this.settingsManager.getRetrySettings(), this._summarizationRetryCallbacks({ source: "compaction", reason }, telemetryContext), telemetryContext);
+                const compactResult = await compact(preparation, requestModel, apiKey, headers, undefined, compactionSignal, this.thinkingLevel, this.agent.streamFunction, env, this.settingsManager.getRetrySettings(), this._summarizationRetryCallbacks({ source: "compaction", reason }, telemetryContext), telemetryContext);
                 summary = compactResult.summary;
                 firstKeptEntryId = compactResult.firstKeptEntryId;
                 tokensBefore = compactResult.tokensBefore;
                 usage = compactResult.usage;
                 details = compactResult.details;
             }
-            if (this._autoCompactionAbortController.signal.aborted) {
+            if (compactionSignal.aborted) {
                 this._emit({
                     type: "compaction_end",
                     reason,
@@ -3237,7 +3304,7 @@ export class AgentSession {
             : {
                 ...createAllToolDefinitions(this._cwd, {
                     read: { autoResizeImages },
-                    bash: { commandPrefix: shellCommandPrefix, shellPath },
+                    bash: { commandPrefix: shellCommandPrefix, shellPath, owner: this._shellProcesses },
                 }),
                 update_plan: createSessionUpdatePlanToolDefinition(this.sessionManager),
             };
@@ -3438,7 +3505,7 @@ export class AgentSession {
      * @param options.operations Custom BashOperations for remote execution
      */
     executeBash(command, onChunk, options) {
-        return this._runOwnedOperation(() => this._traceOperation("bash", () => startCodingAgentSpan(this.agent.telemetryContext, "diffex.coding_agent.terminal", { "diffex.session.id": this.sessionId }, async (span) => {
+        const operation = this._runOwnedOperation(() => this._traceOperation("bash", () => startCodingAgentSpan(this.agent.telemetryContext, "diffex.coding_agent.terminal", { "diffex.session.id": this.sessionId }, async (span) => {
             const result = await this._executeBash(command, onChunk, options);
             const outcome = result.cancelled ? "cancelled" : result.exitCode === 0 ? "completed" : "failed";
             span.setAttributes({
@@ -3449,6 +3516,9 @@ export class AgentSession {
                 span.setStatus({ status: "error" });
             return result;
         })));
+        this._bashOperations.add(operation);
+        void operation.then(() => this._bashOperations.delete(operation), () => this._bashOperations.delete(operation));
+        return operation;
     }
     async _executeBash(command, onChunk, options) {
         const abortController = new AbortController();
@@ -3458,7 +3528,7 @@ export class AgentSession {
         const shellPath = this.settingsManager.getShellPath();
         const resolvedCommand = prefix ? `${prefix}\n${command}` : command;
         try {
-            const result = await executeBashWithOperations(resolvedCommand, this.sessionManager.getCwd(), options?.operations ?? createLocalBashOperations({ shellPath }), {
+            const result = await executeBashWithOperations(resolvedCommand, this.sessionManager.getCwd(), options?.operations ?? createLocalBashOperations({ shellPath, owner: this._shellProcesses }), {
                 onChunk: (delta) => {
                     onChunk?.(delta);
                     this._emit({ type: "bash_execution_update", id: options?.id, delta });

package/dist/core/compaction/compaction.js

@@ -322,7 +322,9 @@ export function findCutPoint(entries, startIndex, endIndex, keepRecentTokens) {
         accumulatedTokens += messageTokens;
         // Check if we've exceeded the budget
         if (accumulatedTokens >= keepRecentTokens) {
-            // Find the closest valid cut point at or after this entry
+            // A completed tool batch can end the transcript. If no cut point follows
+            // its results, keep the batch's assistant message and all paired results.
+            cutIndex = cutPoints[cutPoints.length - 1];
             for (let c = 0; c < cutPoints.length; c++) {
                 if (cutPoints[c] >= i) {
                     cutIndex = cutPoints[c];

package/dist/core/model-runtime.js

@@ -453,7 +453,7 @@ export class ModelRuntime {
         return lazyStream(model, async () => {
             const prepared = await this.prepareRequest(model, options);
             return prepared.provider.stream(prepared.model, context, prepared.options);
-        });
+        }, options?.signal);
     }
     complete(model, context, options) {
         return this.stream(model, context, options).result();
@@ -462,7 +462,7 @@ export class ModelRuntime {
         return lazyStream(model, async () => {
             const prepared = await this.prepareRequest(model, options);
             return prepared.provider.streamSimple(prepared.model, context, prepared.options);
-        });
+        }, options?.signal);
     }
     completeSimple(model, context, options) {
         return this.streamSimple(model, context, options).result();
@@ -474,7 +474,7 @@ export class ModelRuntime {
                 throw new ModelsError("provider", `Provider ${model.provider} does not support deferred responses`);
             }
             return prepared.provider.fetchDeferred(prepared.model, handle, prepared.options);
-        }).result();
+        }, options?.signal).result();
     }
     async cancelDeferred(model, handle, options) {
         const prepared = await this.prepareRequest(model, options);

package/dist/core/provider-composer.js

@@ -321,7 +321,7 @@ export function composeModelProvider(providerId, base, modelConfig, extension) {
         return simple
             ? api.streamSimple(model, context, options)
             : api.stream(model, context, options);
-    });
+    }, options?.signal);
     const provider = {
         id: providerId,
         name: extension?.name ?? config?.name ?? base?.name ?? extension?.oauth?.name ?? providerId,

package/dist/core/sdk.d.ts

@@ -8,8 +8,9 @@ import { ModelRuntime } from "./model-runtime.ts";
 import type { ResourceLoader } from "./resource-loader.ts";
 import { SessionManager } from "./session-manager.ts";
 import { SettingsManager } from "./settings-manager.ts";
+import type { SubagentSupervisionOptions } from "./subagents/types.ts";
 import { createBashTool, createCodingTools, createEditTool, createFindTool, createGrepTool, createLsTool, createReadOnlyTools, createReadTool, createUpdatePlanTool, createWriteTool, withFileMutationQueue } from "./tools/index.ts";
-export interface SubagentOptions {
+export interface SubagentOptions extends SubagentSupervisionOptions {
     /** Maximum number of child agents that may run concurrently. Default: 4 */
     maxConcurrent?: number;
 }

package/dist/core/sdk.js

@@ -29,7 +29,7 @@ import { createBashTool, createCodingTools, createEditTool, createFindTool, crea
 // provider-agnostic and does not import Diffex AI compat itself.
 setDefaultStreamFn(streamSimple);
 const DEFAULT_SUBAGENT_CONCURRENCY = 4;
-const RESERVED_SUBAGENT_TOOL_NAMES = new Set(["spawn_agent", "agent_action", "wait_for_agents", "escalate_to_parent"]);
+const RESERVED_SUBAGENT_TOOL_NAMES = new Set(["spawn_agent", "agent_action", "agent_status", "escalate_to_parent"]);
 // Re-exports
 export * from "./agent-session-runtime.js";
 export { withFileMutationQueue, 
@@ -48,7 +48,7 @@ function normalizeSubagentOptions(value) {
     const options = value;
     if (options) {
         for (const key of Object.keys(options)) {
-            if (key !== "maxConcurrent") {
+            if (!["maxConcurrent", "leaseMs", "supervisionIntervalMs", "parentDeadline"].includes(key)) {
                 throw new Error(`Unknown subagents option: ${key}`);
             }
         }
@@ -57,7 +57,19 @@ function normalizeSubagentOptions(value) {
     if (!Number.isInteger(maxConcurrent) || maxConcurrent <= 0) {
         throw new RangeError("subagents.maxConcurrent must be a positive integer");
     }
-    return { maxConcurrent };
+    return {
+        maxConcurrent,
+        leaseMs: options?.leaseMs ??
+            (process.env.DIFFEX_SUBAGENT_LEASE_MS === undefined
+                ? undefined
+                : Number(process.env.DIFFEX_SUBAGENT_LEASE_MS)),
+        supervisionIntervalMs: options?.supervisionIntervalMs ??
+            (process.env.DIFFEX_SUBAGENT_SUPERVISION_MS === undefined
+                ? undefined
+                : Number(process.env.DIFFEX_SUBAGENT_SUPERVISION_MS)),
+        parentDeadline: options?.parentDeadline ??
+            (process.env.DIFFEX_TASK_DEADLINE_MS === undefined ? undefined : Number(process.env.DIFFEX_TASK_DEADLINE_MS)),
+    };
 }
 function assertNoReservedSubagentTools(customTools) {
     for (const tool of customTools ?? []) {
@@ -66,10 +78,10 @@ function assertNoReservedSubagentTools(customTools) {
         }
     }
 }
-function createRootSubagentController(maxConcurrent, agentDir, telemetryContext, parentSessionManager) {
+function createRootSubagentController(options, agentDir, telemetryContext, parentSessionManager) {
     const sessionManagerFactory = new RootLocalEphemeralSubagentSessionManagerFactory();
     return new SubagentController({
-        maxConcurrent,
+        ...options,
         telemetryContext,
         restoreRoster: (controller, parent) => restoreRootSubagents(controller, parent, agentDir, parentSessionManager),
         captureSession: (parent, childName, origin) => {
@@ -239,7 +251,7 @@ export async function createInternalAgentSession(options = {}, internalCustomToo
     const sessionManager = options.sessionManager ?? SessionManager.create(cwd, getDefaultSessionDir(cwd, agentDir));
     const subagentController = subagentOptions === false
         ? undefined
-        : createRootSubagentController(subagentOptions.maxConcurrent, agentDir, telemetryContext, sessionManager);
+        : createRootSubagentController(subagentOptions, agentDir, telemetryContext, sessionManager);
     const customTools = [
         ...(options.customTools ?? []),
         ...(subagentController?.createToolDefinitions() ?? []),

package/dist/core/subagents/controller.d.ts

@@ -2,14 +2,14 @@ import { type TelemetryContext } from "@diffexai/diffex-agent-core";
 import type { AgentSession } from "../agent-session.ts";
 import type { ToolDefinition } from "../extensions/types.ts";
 import type { ChildSnapshotV1 } from "./persistence.ts";
-import type { CapturedSubagentSession, CaptureSubagentSession, CreateSubagentSession, SubagentActionResult, SubagentBatchResult, SubagentBatchWaitOptions, SubagentControllerSnapshot, SubagentDeliveryBatch, SubagentLifecycleListener, SubagentPermit, SubagentQueryOptions, SubagentQueryResult, SubagentSpawnOrigin, SubagentSummary, SubagentWaitOptions, SubagentWaitResult } from "./types.ts";
+import type { CapturedSubagentSession, CaptureSubagentSession, CreateSubagentSession, SubagentActionResult, SubagentBatchResult, SubagentBatchWaitOptions, SubagentControllerSnapshot, SubagentDeliveryBatch, SubagentLifecycleListener, SubagentPermit, SubagentQueryOptions, SubagentQueryResult, SubagentSpawnOrigin, SubagentSummary, SubagentSupervisionOptions, SubagentWaitOptions, SubagentWaitResult } from "./types.ts";
 export interface PreparedSubagentWake extends CapturedSubagentSession {
     readonly warning?: string;
 }
 export type PrepareSubagentWake = () => Promise<PreparedSubagentWake>;
 export declare class SubagentController {
     #private;
-    constructor(options: {
+    constructor(options: SubagentSupervisionOptions & {
         maxConcurrent: number;
         captureSession?: CaptureSubagentSession;
         telemetryContext?: TelemetryContext;
@@ -23,8 +23,9 @@ export declare class SubagentController {
     restore(snapshot: ChildSnapshotV1, prepareWake: PrepareSubagentWake, isolationError?: string): void;
     restoreIsolated(name: string, error: string, prepareWake: PrepareSubagentWake): void;
     spawn(name: string, task: string, createSession: CreateSubagentSession, origin?: SubagentSpawnOrigin, telemetryContext?: TelemetryContext, captured?: CapturedSubagentSession): void;
-    message(name: string, message: string, wake?: boolean, coordinated?: boolean): Promise<SubagentActionResult>;
+    message(name: string, message: string, wake?: boolean, coordinated?: boolean, delivery?: "steer" | "follow_up"): Promise<SubagentActionResult>;
     interrupt(name: string): Promise<SubagentActionResult>;
+    renew(name: string, reason: string): Promise<SubagentActionResult>;
     attachSession(name: string, session: AgentSession): void;
     trackRun(name: string, run: Promise<void>): void;
     markRunning(name: string): void;