@diffexai/diffex 0.2.7 → 0.3.1

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # Changelog
 
+## [0.3.1] - 2026-09-20
+
+### New Features
+
+- Added opt-in background services that survive CLI and subagent exit, with explicit environment ownership.
+  See [Background process lifetime](docs/background-processes.md) ([#242](https://github.com/diffexai/diffex/pull/242)).
+
+### Added
+
+- Added CLI and SDK options for environment-owned background processes on Linux and macOS, with durable ownership records and inherited policy for child sessions.
+  See [Background process lifetime](docs/background-processes.md) ([#242](https://github.com/diffexai/diffex/pull/242)).
+
+### Fixed
+
+- Fixed successful background services being terminated after ownership transfers to the environment, including on later failures, interruption, session replacement, and disposal ([#242](https://github.com/diffexai/diffex/pull/242)).
+- Fixed print-mode shutdown to await shared runtime disposal and handle SIGINT cleanup ([#242](https://github.com/diffexai/diffex/pull/242)).
+
+## [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

package/dist/cli/args.d.ts

@@ -6,6 +6,8 @@ import type { ExtensionFlag } from "../core/extensions/types.ts";
 import type { TuiMode } from "../core/settings-manager.ts";
 export type Mode = "text" | "json" | "rpc";
 export interface Args {
+    backgroundProcessLifetime?: "session" | "environment";
+    backgroundProcessOwnershipDir?: string;
     provider?: string;
     model?: string;
     apiKey?: string;

package/dist/cli/args.js

@@ -28,6 +28,29 @@ export function parseArgs(args) {
                 result.mode = mode;
             }
         }
+        else if (arg === "--background-process-lifetime" || arg.startsWith("--background-process-lifetime=")) {
+            const value = arg.includes("=") ? arg.slice(arg.indexOf("=") + 1) : args[i + 1];
+            if (!arg.includes("=") && value !== undefined && !value.startsWith("-"))
+                i++;
+            if (value === "session" || value === "environment")
+                result.backgroundProcessLifetime = value;
+            else
+                result.diagnostics.push({
+                    type: "error",
+                    message: "--background-process-lifetime requires session or environment",
+                });
+        }
+        else if (arg === "--background-process-ownership-dir" ||
+            arg.startsWith("--background-process-ownership-dir=")) {
+            const value = arg.includes("=") ? arg.slice(arg.indexOf("=") + 1) : args[i + 1];
+            if (value && !value.startsWith("-")) {
+                result.backgroundProcessOwnershipDir = value;
+                if (!arg.includes("="))
+                    i++;
+            }
+            else
+                result.diagnostics.push({ type: "error", message: "--background-process-ownership-dir requires a path" });
+        }
         else if (arg === "--continue" || arg === "-c") {
             result.continue = true;
         }
@@ -213,6 +236,18 @@ export function parseArgs(args) {
             result.messages.push(arg);
         }
     }
+    if (result.backgroundProcessLifetime === "environment" && !result.backgroundProcessOwnershipDir) {
+        result.diagnostics.push({
+            type: "error",
+            message: "Environment lifetime requires --background-process-ownership-dir",
+        });
+    }
+    if (result.backgroundProcessOwnershipDir && result.backgroundProcessLifetime !== "environment") {
+        result.diagnostics.push({
+            type: "error",
+            message: "--background-process-ownership-dir requires environment lifetime",
+        });
+    }
     return result;
 }
 export function printHelp(extensionFlags) {
@@ -248,6 +283,10 @@ ${chalk.bold("Options:")}
   --append-system-prompt <text>  Append text or file contents to the system prompt (can be used multiple times)
   --mode <mode>                  Output mode: text (default), json, or rpc
   --print, -p                    Non-interactive mode: process prompt and exit
+  --background-process-lifetime <session|environment>
+                                 Background shell ownership (default: session)
+  --background-process-ownership-dir <path>
+                                 Supervisor handoff records (required for environment lifetime)
   --continue, -c                 Continue previous session
   --resume, -r                   Select a session to resume
   --session <path|id>            Use specific session file or partial UUID

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

@@ -46,6 +46,7 @@ export interface CreateAgentSessionServicesOptions {
  * have been resolved against those services.
  */
 export interface CreateAgentSessionFromServicesOptions {
+    backgroundProcessPolicy?: CreateAgentSessionOptions["backgroundProcessPolicy"];
     services: AgentSessionServices;
     sessionManager: SessionManager;
     sessionStartEvent?: SessionStartEvent;

package/dist/core/agent-session-services.js

@@ -137,6 +137,7 @@ export async function createAgentSessionFromServices(options) {
 export async function createInternalAgentSessionFromServices(options, internalCustomTools = []) {
     registerSubagentRuntimeDiagnosticSink(options.sessionManager, options.services.diagnostics);
     return createInternalAgentSession({
+        backgroundProcessPolicy: options.backgroundProcessPolicy,
         cwd: options.services.cwd,
         agentDir: options.services.agentDir,
         modelRuntime: options.services.modelRuntime,

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

@@ -15,6 +15,7 @@
 import { type Agent, type AgentEvent, type AgentMessage, type AgentState, type AgentTool, type TelemetryContext, type ThinkingLevel } from "@diffexai/diffex-agent-core";
 import type { ImageContent, Model, TextContent } from "@diffexai/diffex-ai/compat";
 import type { HarnessStateStore, HarnessVersion, HarnessVersionBundle, HarnessVersionList, HarnessWorkspaceIdentity } from "@diffexai/diffex-harness-state";
+import { type BackgroundProcessPolicy } from "../utils/owned-shell-processes.ts";
 import type { AgentSessionLifecycleObserver } from "./agent-session-lifecycle.ts";
 import { type BashResult } from "./bash-executor.ts";
 import { CHANGE_COLLABORATION_MODE, type CollaborationMode, type CollaborationModeTransitionResult, GET_COLLABORATION_MODE, IS_COLLABORATION_MODE_BUSY, SUBSCRIBE_PROMPT_ADMISSION } from "./collaboration-mode.ts";
@@ -135,6 +136,8 @@ export type AgentSessionEvent = Exclude<AgentEvent, {
 /** Listener function for agent session events */
 export type AgentSessionEventListener = (event: AgentSessionEvent) => void;
 export interface AgentSessionConfig {
+    /** Lifetime of background groups launched by successful local shell commands. */
+    backgroundProcessPolicy?: BackgroundProcessPolicy;
     agent: Agent;
     sessionManager: SessionManager;
     settingsManager: SettingsManager;
@@ -263,6 +266,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 +566,10 @@ 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 backgroundProcessPolicy(): BackgroundProcessPolicy;
+    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;
+    _bashOperations = new Set();
     // Extension system
     _extensionRunner;
     _turnIndex = 0;
@@ -217,6 +220,7 @@ export class AgentSession {
     _agentRunAborted = false;
     _disposePromise;
     constructor(config) {
+        this._shellProcesses = new OwnedShellProcesses(config.backgroundProcessPolicy);
         this.agent = config.agent;
         this.sessionManager = config.sessionManager;
         this.settingsManager = config.settingsManager;
@@ -402,10 +406,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 +855,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;
@@ -1651,6 +1670,22 @@ 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 "settled";
@@ -2354,11 +2389,24 @@ 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 backgroundProcessPolicy() {
+        return this._shellProcesses.policy;
+    }
+    get ownedShellProcessCount() {
+        return this._shellProcesses.count;
     }
     async waitForIdle() {
         if (this.isIdle) {
@@ -2847,6 +2895,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;
@@ -2859,7 +2910,7 @@ export class AgentSession {
                     customInstructions: undefined,
                     reason,
                     willRetry,
-                    signal: this._autoCompactionAbortController.signal,
+                    signal: compactionSignal,
                 }));
                 if (extensionResult?.cancel) {
                     this._emit({
@@ -2891,14 +2942,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,
@@ -3257,7 +3308,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),
             };
@@ -3458,7 +3509,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({
@@ -3469,6 +3520,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();
@@ -3478,7 +3532,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/sdk.d.ts

@@ -1,6 +1,7 @@
 import { type TelemetryContext, type ThinkingLevel } from "@diffexai/diffex-agent-core";
 import { type Model } from "@diffexai/diffex-ai/compat";
 import type { HarnessStateStore, HarnessVersionBundle } from "@diffexai/diffex-harness-state";
+import type { BackgroundProcessPolicy } from "../utils/owned-shell-processes.ts";
 import { AgentSession } from "./agent-session.ts";
 import type { AgentSessionLifecycleObserver } from "./agent-session-lifecycle.ts";
 import type { LoadExtensionsResult, SessionStartEvent, ToolDefinition } from "./extensions/index.ts";
@@ -8,12 +9,15 @@ 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;
 }
 export interface CreateAgentSessionOptions {
+    /** Local shell background lifetime. Defaults to session-owned cleanup. */
+    backgroundProcessPolicy?: BackgroundProcessPolicy;
     /** Working directory for project-local discovery. Default: process.cwd() */
     cwd?: string;
     /** Global config directory. Default: ~/.diffex/agent */

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() ?? []),
@@ -424,6 +436,7 @@ export async function createInternalAgentSession(options = {}, internalCustomToo
         sessionManager.appendThinkingLevelChange(thinkingLevel);
     }
     const session = new AgentSession({
+        backgroundProcessPolicy: options.backgroundProcessPolicy,
         agent,
         sessionManager,
         settingsManager,

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;