newmark-agent 0.5.14 → 0.5.15

package/dist/core/conversationListEvent.d.ts

@@ -0,0 +1,6 @@
+import type { Agent } from './agent';
+import type { AgentWorkEvent } from './types';
+import type { WorkspaceInfo } from './workspace';
+/** Directory changes are workspace metadata, never a turn or selection command. */
+export declare function conversationListEvent(agent: Pick<Agent, 'listWorkspaceConversationStates'>, workspace: WorkspaceInfo): AgentWorkEvent;
+//# sourceMappingURL=conversationListEvent.d.ts.map

package/dist/core/conversationListEvent.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.conversationListEvent = conversationListEvent;
+const crypto_1 = require("crypto");
+/** Directory changes are workspace metadata, never a turn or selection command. */
+function conversationListEvent(agent, workspace) {
+    return {
+        id: (0, crypto_1.randomUUID)(), type: 'conversation_list', stateScope: 'workspace',
+        workspaceId: String(workspace.id || workspace.path), conversationId: '',
+        conversations: agent.listWorkspaceConversationStates(workspace),
+        content: '', mode: '', model: '', timestamp: new Date().toISOString(),
+    };
+}
+//# sourceMappingURL=conversationListEvent.js.map

package/dist/core/electronUtilityAgentClient.d.ts

@@ -92,7 +92,10 @@ export declare class ElectronUtilityAgentClient {
     start(): Promise<void>;
     private startNewChild;
     prompt(params: UtilityPromptRequest): Promise<UtilityAgentPromptResult>;
-    snapshot(): Promise<UtilityAgentSnapshotResult>;
+    snapshot(options?: {
+        window?: number;
+        before?: number;
+    }): Promise<UtilityAgentSnapshotResult>;
     rewind(messageIndex: number): Promise<UtilityConversationRewindResult>;
     requestStop(runId?: string): Promise<UtilityAgentStopResult>;
     enqueueGuide(envelope: ConversationInputEnvelope): Promise<GuideReceipt>;

package/dist/core/electronUtilityAgentClient.js

@@ -1010,9 +1010,9 @@ class ElectronUtilityAgentClient {
         await this.start();
         return await this.request('prompt', { ...params, target: this.checkedTarget(params.target) }, 0);
     }
-    async snapshot() {
+    async snapshot(options = {}) {
         await this.start();
-        return await this.requestTargetSnapshot();
+        return await this.requestTargetSnapshot(options);
     }
     async rewind(messageIndex) {
         await this.start();
@@ -1222,8 +1222,8 @@ class ElectronUtilityAgentClient {
         ]);
         return confirmed || this.child !== child;
     }
-    async requestTargetSnapshot() {
-        const snapshot = await this.request('snapshot', { target: this.target }, 15_000);
+    async requestTargetSnapshot(options = {}) {
+        const snapshot = await this.request('snapshot', { target: this.target, options }, 15_000);
         if (snapshot?.target?.runtimeKey !== this.target.runtimeKey) {
             throw new Error('Electron utility runtime snapshot target mismatch');
         }

package/dist/core/electronUtilityRuntimePool.d.ts

@@ -7,7 +7,10 @@ export interface ElectronTargetRuntimeClient {
     subscribe(listener: (event: AgentWorkEvent) => void): () => void;
     setHostToolHandler(handler: UtilityHostToolHandler | null): void;
     prompt(params: UtilityPromptRequest): Promise<UtilityAgentPromptResult>;
-    snapshot(): Promise<UtilityAgentSnapshotResult>;
+    snapshot(options?: {
+        window?: number;
+        before?: number;
+    }): Promise<UtilityAgentSnapshotResult>;
     rewind(messageIndex: number): Promise<UtilityConversationRewindResult>;
     requestStop(runId?: string): Promise<UtilityAgentStopResult>;
     enqueueGuide(envelope: ConversationInputEnvelope): Promise<GuideReceipt>;
@@ -69,7 +72,10 @@ export declare class ElectronUtilityRuntimePool {
     subscribe(listener: (event: AgentWorkEvent) => void): () => void;
     setHostToolHandler(handler: UtilityHostToolHandler | null): void;
     prompt(params: UtilityPromptRequest): Promise<UtilityAgentPromptResult>;
-    snapshot(target: ConversationRuntimeTarget): Promise<UtilityAgentSnapshotResult>;
+    snapshot(target: ConversationRuntimeTarget, options?: {
+        window?: number;
+        before?: number;
+    }): Promise<UtilityAgentSnapshotResult>;
     rewind(target: ConversationRuntimeTarget, messageIndex: number): Promise<UtilityConversationRewindResult>;
     requestStop(target: ConversationRuntimeTarget, runId?: string): Promise<ElectronPoolStopResult>;
     enqueueGuide(envelope: ConversationInputEnvelope): Promise<GuideReceipt>;

package/dist/core/electronUtilityRuntimePool.js

@@ -50,14 +50,20 @@ class ElectronUtilityRuntimePool {
             this.release(entry, true);
         }
     }
-    async snapshot(target) {
+    async snapshot(target, options = {}) {
         const entry = await this.acquire((0, conversationTarget_1.normalizeConversationTarget)(target));
         let scheduleIdle = false;
         try {
-            if (entry.stopIntent)
+            const customWindow = options.before != null || (options.window != null && options.window !== 200);
+            if (entry.stopIntent) {
+                if (customWindow)
+                    throw new Error('Earlier history is temporarily unavailable while this conversation is stopping. Retry after it stops.');
                 return this.supervisorSnapshot(entry);
-            const result = await entry.client.snapshot();
-            entry.lastSnapshot = result;
+            }
+            const result = await entry.client.snapshot(options);
+            // A fetched older page must not replace the latest supervisor snapshot.
+            if (!customWindow)
+                entry.lastSnapshot = result;
             if (result.runtime?.runId)
                 entry.lastRunId = result.runtime.runId;
             if (result.runtime?.generation)
@@ -185,7 +191,7 @@ class ElectronUtilityRuntimePool {
         }
     }
     async queueAction(target, action, input = {}) {
-        const entry = await this.acquireExisting(target);
+        const entry = await this.acquire((0, conversationTarget_1.normalizeConversationTarget)(target));
         if (!entry || !entry.client.queueAction)
             throw new Error('Target conversation is not running');
         try {

package/dist/core/installUpdate.js

@@ -601,11 +601,12 @@ function runMsiExec(args) {
 }
 function windowsCommandQuote(value) {
     const text = String(value);
-    return /\s/.test(text) ? `"${text.replace(/"/g, '\\"')}"` : text;
+    return `"${text.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/g, '$1$1')}"`;
 }
 function runElevatedMsiExec(args) {
     const argumentString = args.map(arg => windowsCommandQuote(arg)).join(' ');
     const script = [
+        '$ErrorActionPreference = "Stop"',
         `$argumentList = '${argumentString.replace(/'/g, "''")}'`,
         '$process = Start-Process -FilePath "msiexec.exe" -ArgumentList $argumentList -Verb RunAs -Wait -PassThru',
         'Write-Output ("EXITCODE:" + $process.ExitCode)',
@@ -614,7 +615,8 @@ function runElevatedMsiExec(args) {
     const stdout = String(result.stdout || '');
     const match = stdout.match(/EXITCODE:(\d+)/);
     return {
-        exitCode: match ? Number(match[1]) : (result.status === null ? -1 : result.status),
+        // A shell exit of 0 without the MSI completion marker is not installation.
+        exitCode: match ? Number(match[1]) : -1,
         stdout,
         stderr: String(result.stderr || ''),
     };
@@ -633,17 +635,39 @@ function uninstallNewmarkProduct(productCode, logPath) {
     };
 }
 function installMsiPackage(msiPath, options = {}) {
-    const logPath = path.join(options.logDir || os.tmpdir(), `newmark-msi-install-${process.pid}-${Date.now()}.log`);
-    const args = ['/i', path.resolve(msiPath), '/qn', '/norestart', '/l*v', logPath];
-    let result = runMsiExec(args);
-    if (result.exitCode !== 0 && result.exitCode !== 3010 && options.allowElevate !== false)
-        result = runElevatedMsiExec(args);
-    const ok = result.exitCode === 0 || result.exitCode === 3010;
+    const logDir = path.resolve(options.logDir || os.tmpdir());
+    fs.mkdirSync(logDir, { recursive: true });
+    const evidence = fs.mkdtempSync(path.join(logDir, 'newmark-msi-install-'));
+    const logPath = path.join(evidence, 'result.json');
+    // The same verified workflow owns CLI, GUI, and developer installs. MSI major
+    // upgrades handle old ProductCodes; only an already-installed exact ProductCode
+    // uses REINSTALL=ALL + vamus. Fresh installs must select ADDLOCAL=ALL instead.
+    const helperCandidates = [
+        path.join(process.resourcesPath || path.dirname(process.execPath), 'installer', 'install-windows-msi.ps1'),
+        path.resolve(__dirname, '..', '..', 'scripts', 'install-windows-msi.ps1'),
+    ];
+    const helper = helperCandidates.find(candidate => fs.existsSync(candidate) && !candidate.includes(`${path.sep}app.asar${path.sep}`));
+    if (!helper)
+        return { ok: false, exitCode: -1, logPath, error: 'Verified MSI installer helper is missing from this application.' };
+    const args = ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', helper,
+        '-MsiPath', path.resolve(msiPath), '-EvidenceDirectory', evidence];
+    if (options.allowElevate === false)
+        args.push('-NoElevate');
+    // Node passes argv directly; no Start-Process ArgumentList array re-parsing.
+    // Do not detach or impose a timeout which abandons an active MSI transaction.
+    const result = (0, child_process_1.spawnSync)('powershell.exe', args, { encoding: 'utf-8', windowsHide: true });
+    let completion = {};
+    try {
+        completion = JSON.parse(fs.readFileSync(logPath, 'utf-8').replace(/^\uFEFF/, ''));
+    }
+    catch { /* Missing evidence is failure. */ }
+    const ok = result.status === 0 && completion.Success === true;
+    const exitCode = ok ? (completion.Steps?.some(step => step.ExitCode === 3010) ? 3010 : 0) : (result.status || -1);
     return {
         ok,
-        exitCode: result.exitCode,
+        exitCode,
         logPath,
-        error: ok ? undefined : `msiexec install exited ${result.exitCode}`,
+        error: ok ? undefined : (completion.Error || result.error?.message || String(result.stderr || '').trim() || 'MSI installation has no verified completion receipt.'),
     };
 }
 function findLegacyNewmarkExecutables(excludeRoots = []) {
@@ -752,29 +776,17 @@ function executeManagedMsiInstall(msiPath, options = {}) {
         ? stopNewmarkProcesses(plan.runningProcesses.map(process => process.pid))
         : { stopped: [], errors: [] };
     const uninstalled = [];
-    if (options.uninstallPrevious !== false) {
-        for (const product of plan.installedProducts) {
-            const logPath = path.join(options.logDir || os.tmpdir(), `newmark-msi-uninstall-${product.productCode}-${process.pid}-${Date.now()}.log`);
-            const uninstallResult = uninstallNewmarkProduct(product.productCode, logPath);
-            if (!uninstallResult.ok) {
-                return {
-                    ok: false,
-                    plan,
-                    stopped: stopResult.stopped,
-                    uninstalled,
-                    removedLegacy: [],
-                    exitCode: uninstallResult.exitCode,
-                    logPath: uninstallResult.logPath,
-                    error: `Failed to uninstall previous Newmark version ${product.productCode}: ${uninstallResult.error}`,
-                };
-            }
-            uninstalled.push(product.productCode);
-        }
-    }
+    // AllowSameVersionUpgrades removes related old products within one MSI/UAC
+    // transaction. Pre-uninstalling here caused multiple prompts and a fresh
+    // product incorrectly sent through the old REINSTALL-only path.
     const removeResult = plan.legacyExecutables.length
         ? removeLegacyNewmarkExecutables(plan.legacyExecutables)
         : { removed: [], errors: [] };
     const installResult = installMsiPackage(plan.msiPath, { logDir: options.logDir, allowElevate: options.allowElevate });
+    if (installResult.ok) {
+        const remaining = new Set(listInstalledNewmarkProducts().map(product => product.productCode));
+        uninstalled.push(...plan.installedProducts.filter(product => !remaining.has(product.productCode)).map(product => product.productCode));
+    }
     return {
         ok: installResult.ok,
         plan,

package/dist/core/providerUsageAccounting.d.ts

@@ -0,0 +1,47 @@
+/** Measured provider counters. Missing values are tracked separately from zero. */
+export interface Counter {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+}
+export interface Reported {
+    input: boolean;
+    output: boolean;
+    cacheRead: boolean;
+    cacheWrite: boolean;
+}
+export type UsageInput = Partial<Counter> & {
+    reported?: Partial<Reported>;
+};
+/** JSON-persistable conversation coverage; totals remain owned by the caller. */
+export interface Accounting {
+    requests: number;
+    inputReportedRequests: number;
+    outputReportedRequests: number;
+    /** Requests with both input/cache read reported and cache read <= input. */
+    cacheReportedRequests: number;
+    cacheEligibleInputTokens: number;
+    cacheReadTokens: number;
+    hasLegacyTotals: boolean;
+    lastInputTokens: number | null;
+}
+/** Retain this handle for all cumulative usage events from one provider request. */
+export interface AccountingRequest {
+    usage: Counter;
+    reported: Reported;
+}
+export declare function createAccounting(legacyTotals?: Partial<Counter> | null): Accounting;
+export declare function beginAccountingRequest(accounting: Accounting): AccountingRequest;
+/**
+ * Provider stream usage is cumulative per request, including partial updates.
+ * Replacing each reported field contributes only its delta, including negative
+ * corrections. Unreported/invalid fields never erase a previous measurement.
+ */
+export declare function applyAccountingUsage(accounting: Accounting, totals: Counter, request: AccountingRequest, input: UsageInput): void;
+export declare function ratioSummary(accounting: Accounting): {
+    totalRatio: number | null;
+    knownRatio: number | null;
+    denominator: number;
+};
+//# sourceMappingURL=providerUsageAccounting.d.ts.map

package/dist/core/providerUsageAccounting.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAccounting = createAccounting;
+exports.beginAccountingRequest = beginAccountingRequest;
+exports.applyAccountingUsage = applyAccountingUsage;
+exports.ratioSummary = ratioSummary;
+const fields = ['input', 'output', 'cacheRead', 'cacheWrite'];
+function createAccounting(legacyTotals) {
+    return {
+        requests: 0,
+        inputReportedRequests: 0,
+        outputReportedRequests: 0,
+        cacheReportedRequests: 0,
+        cacheEligibleInputTokens: 0,
+        cacheReadTokens: 0,
+        // Old persisted zeros do not establish whether any cache fields were reported.
+        hasLegacyTotals: legacyTotals != null,
+        lastInputTokens: null,
+    };
+}
+function beginAccountingRequest(accounting) {
+    accounting.requests++;
+    return {
+        usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        reported: { input: false, output: false, cacheRead: false, cacheWrite: false },
+    };
+}
+function validCachePair(request) {
+    return request.reported.input && request.reported.cacheRead
+        && request.usage.cacheRead <= request.usage.input;
+}
+/**
+ * Provider stream usage is cumulative per request, including partial updates.
+ * Replacing each reported field contributes only its delta, including negative
+ * corrections. Unreported/invalid fields never erase a previous measurement.
+ */
+function applyAccountingUsage(accounting, totals, request, input) {
+    const hadInput = request.reported.input;
+    const hadOutput = request.reported.output;
+    const hadPair = validCachePair(request);
+    const previousEligibleInput = hadPair ? request.usage.input : 0;
+    const previousEligibleCache = hadPair ? request.usage.cacheRead : 0;
+    for (const field of fields) {
+        const value = input[field];
+        // Older internal callers supply actual numeric fields without metadata.
+        // Once metadata exists, only its explicit true flags represent reporting.
+        const reported = input.reported === undefined || input.reported[field] === true;
+        if (!reported || typeof value !== 'number' || !Number.isFinite(value) || value < 0)
+            continue;
+        totals[field] += value - request.usage[field];
+        request.usage[field] = value;
+        request.reported[field] = true;
+        if (field === 'input')
+            accounting.lastInputTokens = value;
+    }
+    accounting.inputReportedRequests += Number(request.reported.input) - Number(hadInput);
+    accounting.outputReportedRequests += Number(request.reported.output) - Number(hadOutput);
+    const hasPair = validCachePair(request);
+    accounting.cacheReportedRequests += Number(hasPair) - Number(hadPair);
+    accounting.cacheEligibleInputTokens += (hasPair ? request.usage.input : 0) - previousEligibleInput;
+    accounting.cacheReadTokens += (hasPair ? request.usage.cacheRead : 0) - previousEligibleCache;
+}
+function ratioSummary(accounting) {
+    const denominator = accounting.cacheEligibleInputTokens;
+    const knownRatio = denominator > 0 ? accounting.cacheReadTokens / denominator : null;
+    const complete = !accounting.hasLegacyTotals && accounting.requests > 0
+        && accounting.inputReportedRequests === accounting.requests
+        && accounting.cacheReportedRequests === accounting.requests;
+    return { totalRatio: complete ? knownRatio : null, knownRatio, denominator };
+}
+//# sourceMappingURL=providerUsageAccounting.js.map

package/dist/core/requestContextEstimate.d.ts

@@ -0,0 +1,18 @@
+/** A local estimate of the actual submitted prompt, never a billing/tokenizer claim. */
+export interface RequestContextEstimate {
+    requestId: string;
+    runId: string;
+    model: string;
+    at: string;
+    estimatedTokens: number;
+    longHistoryTokens: number;
+    buildBlockTokens: number;
+    systemPromptTokens: number;
+    toolSchemaTokens: number;
+    hasImages: boolean;
+    messageCount: number;
+    inputTokens?: number;
+    cacheReadTokens?: number;
+}
+export declare function estimateSubmittedContext(messages: Array<Record<string, unknown>>, systemPrompt: string, tools: unknown[], buildBlockStart: number): Omit<RequestContextEstimate, 'requestId' | 'runId' | 'model' | 'at'>;
+//# sourceMappingURL=requestContextEstimate.d.ts.map

package/dist/core/requestContextEstimate.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimateSubmittedContext = estimateSubmittedContext;
+function textTokens(text) {
+    const nonAscii = text.length - text.replace(/[\u0080-\uFFFF]/g, '').length;
+    return Math.ceil((text.length - nonAscii) / 4 + nonAscii);
+}
+function estimateSubmittedContext(messages, systemPrompt, tools, buildBlockStart) {
+    let longHistoryTokens = 0;
+    let buildBlockTokens = 0;
+    let hasImages = false;
+    const boundary = Math.max(0, Math.min(messages.length, buildBlockStart));
+    for (let index = 0; index < messages.length; index++) {
+        const message = messages[index];
+        let content = '';
+        if (typeof message.content === 'string')
+            content = message.content;
+        else if (Array.isArray(message.content)) {
+            for (const item of message.content) {
+                if (!item || typeof item !== 'object')
+                    continue;
+                const part = item;
+                if (part.type === 'image_url' || part.type === 'image' || part.type === 'input_image') {
+                    // Image tokens depend on provider/model/resolution. Base64 size is
+                    // not token usage; expose incomplete local estimation explicitly.
+                    hasImages = true;
+                }
+                else if (typeof part.text === 'string')
+                    content += part.text;
+                else
+                    content += JSON.stringify(part);
+            }
+        }
+        else if (message.content)
+            content = JSON.stringify(message.content);
+        const calls = Array.isArray(message.tool_calls) ? JSON.stringify(message.tool_calls) : '';
+        const count = 6 + textTokens(content) + textTokens(calls)
+            + (calls ? Math.ceil(calls.length / 6) : 0)
+            + textTokens(String(message.name || '') + String(message.tool_call_id || ''));
+        if (index < boundary)
+            longHistoryTokens += count;
+        else
+            buildBlockTokens += count;
+    }
+    const systemPromptTokens = systemPrompt ? 6 + textTokens(systemPrompt) : 0;
+    const toolText = tools.length ? JSON.stringify(tools) : '';
+    const toolSchemaTokens = toolText ? textTokens(toolText) + Math.ceil(toolText.length / 6) : 0;
+    return {
+        estimatedTokens: longHistoryTokens + buildBlockTokens + systemPromptTokens + toolSchemaTokens,
+        longHistoryTokens, buildBlockTokens, systemPromptTokens, toolSchemaTokens,
+        hasImages, messageCount: messages.length,
+    };
+}
+//# sourceMappingURL=requestContextEstimate.js.map

package/dist/core/subagent.d.ts

@@ -2,6 +2,7 @@ import { NewmarkToolResult } from './compat';
 import type { AgentMode } from './types';
 export type SubagentStatus = 'idle' | 'queued' | 'working' | 'completed' | 'closed' | 'error';
 export type SubagentMessageKind = 'directive' | 'question' | 'result' | 'handoff';
+export declare const SUBAGENT_RECOVERY_PROMPT = "[Peer runtime recovery] Continue the unfinished work from the persisted working history. Preserve completed tool results and follow the latest instruction; do not repeat completed work.";
 export interface SubagentMessage {
     id: string;
     conversationId: string;
@@ -10,6 +11,15 @@ export interface SubagentMessage {
     toAgentId: string;
     kind: SubagentMessageKind;
     body: string;
+    wakeup: boolean;
+    /** A message accepted by an existing job must survive that job settling. */
+    acceptedWhileActive: boolean;
+    /** Runtime-consumed control messages never become model continuation input. */
+    control?: {
+        action: 'stop';
+        runId: string;
+        force: boolean;
+    };
     correlationId?: string;
     replyTo?: string;
     createdAt: string;
@@ -23,8 +33,16 @@ export interface SubagentRootMessage {
     toAgentId: string;
     kind: SubagentMessageKind;
     body: string;
+    wakeup: boolean;
     createdAt: string;
     readAt?: string;
+    /** Only runtime-generated completion notices carry this provenance. */
+    source?: 'automatic-settlement';
+    settlementRevision?: number;
+}
+export interface SubagentSettlementReceipt {
+    peerId: string;
+    revision: number;
 }
 export interface SubagentMessageRecord {
     role: string;
@@ -69,6 +87,8 @@ export interface SubagentInstance {
     queueSequence?: number;
     messages: Array<SubagentMessageRecord>;
     result: string | null;
+    /** Monotonic per-peer result version, independent of timestamps/content. */
+    settlementRevision?: number;
     error?: string;
     createdAt: string;
     startedAt?: string;
@@ -94,6 +114,8 @@ export interface SubagentState {
     nextSequence: number;
     /** Cooperative root-run stop gate. Pending peers stay durable but cannot start until the next root run resumes scheduling. */
     schedulingPaused?: boolean;
+    /** Exact queued/in-flight inputs survive a restart between mailbox dispatch and child transcript persistence. */
+    jobs?: PendingJob[];
     records: SubagentInstance[];
     mailbox: SubagentMessage[];
     rootInbox: SubagentRootMessage[];
@@ -142,7 +164,7 @@ export interface SubagentReadSnapshot {
         inbound: number;
         outbound: number;
         unread: number;
-        latest: Array<Pick<SubagentMessage, 'id' | 'sequence' | 'fromAgentId' | 'toAgentId' | 'kind' | 'body' | 'createdAt' | 'readAt'>>;
+        latest: Array<Pick<SubagentMessage, 'id' | 'sequence' | 'fromAgentId' | 'toAgentId' | 'kind' | 'body' | 'wakeup' | 'acceptedWhileActive' | 'createdAt' | 'readAt'>>;
     };
     truncated: boolean;
 }
@@ -167,6 +189,14 @@ export interface SubagentManagerOptions {
     onRootInboxMessage?: (message: SubagentRootMessage) => boolean;
     onSettled?: (record: SubagentInstance) => void;
 }
+interface PendingJob {
+    id: string;
+    prompt: string;
+    flowName: string;
+    sequence: number;
+    reason: SubagentExecutionJob['reason'];
+    inputCommitted?: boolean;
+}
 /** Conversation-owned flat peer-agent coordinator with durable FIFO scheduling. */
 export declare class SubagentManager {
     private subs;
@@ -174,6 +204,7 @@ export declare class SubagentManager {
     private rootInbox;
     private pending;
     private running;
+    private activeJobs;
     private schedulingPaused;
     private nextSequence;
     private concurrency;
@@ -182,33 +213,46 @@ export declare class SubagentManager {
     private persist?;
     private onMailboxMessage?;
     private rootInboxListeners;
+    private bindingOwner?;
+    private ownerBindings;
     private onSettled?;
     private changedQueued;
     private settledWaiters;
     readonly conversationId: string;
     readonly rootAgentId: string;
     hasRecords(): boolean;
+    hasPendingWork(): boolean;
     reset(): void;
     constructor(options?: SubagentManagerOptions);
     bind(options: Pick<SubagentManagerOptions, 'concurrency' | 'executor' | 'onChange' | 'persist' | 'onMailboxMessage' | 'onRootInboxMessage' | 'onSettled'>): void;
+    ownsExecutionBinding(listener: (message: SubagentRootMessage) => boolean): boolean;
+    private rememberOwnerBinding;
     removeRootInboxListener(listener: (message: SubagentRootMessage) => boolean): void;
+    /** Detach one facade without clearing a newer owner's callbacks or live jobs. */
+    releaseOwnerBinding(listener: (message: SubagentRootMessage) => boolean): boolean;
     create(name: string, prompt: string, model?: string, inputMode?: string, agentMode?: AgentMode, createdByAgentId?: string, flowName?: string, goalObjective?: string, flowPc?: number, buildRunId?: string, intelligenceTier?: string): string;
     get(id: string): SubagentInstance | undefined;
-    send(id: string, prompt: string): boolean;
+    send(id: string, prompt: string, wakeup?: boolean): boolean;
+    broadcastStop(fromAgentId: string, runId: string, force?: boolean): {
+        count: number;
+        ids: string[];
+        peerIds: string[];
+    };
     sendMessage(fromAgentId: string, toAgentId: string, body: string, kind?: SubagentMessageKind, details?: {
         correlationId?: string;
         replyTo?: string;
-    }): {
+    }, wakeup?: boolean): {
         ok: boolean;
         message?: SubagentMessage;
         error?: string;
     };
-    sendRootMessage(fromAgentId: string, body: string, kind?: SubagentMessageKind): {
+    sendRootMessage(fromAgentId: string, body: string, kind?: SubagentMessageKind, settlementRevision?: number, wakeup?: boolean): {
         ok: boolean;
         message?: SubagentRootMessage;
         error?: string;
     };
     readRootInbox(): SubagentRootMessage[];
+    acknowledgeSettlementResults(receipts: SubagentSettlementReceipt[]): string[];
     acknowledgeRootInbox(messageId: string): boolean;
     consumeMailbox(agentId: string): SubagentMessage[];
     acknowledgeMailbox(agentId: string, messageId: string): boolean;
@@ -219,7 +263,8 @@ export declare class SubagentManager {
         error?: string;
     };
     appendAssistant(id: string, content: string): void;
-    replaceContext(id: string, history: Array<Record<string, unknown>>, compression: SubagentCompressionState | null): void;
+    replaceContext(id: string, history: Array<Record<string, unknown>>, compression: SubagentCompressionState | null, inputCommitted?: boolean): void;
+    patchMetadata(id: string, patch: Record<string, unknown>): void;
     complete(id: string, result: string): void;
     fail(id: string, error: string): void;
     markWorking(id: string): void;
@@ -235,6 +280,44 @@ export declare class SubagentManager {
     boundedResultTranscript(idOrName: string): string;
     listActive(): SubagentInstance[];
     listAll(): SubagentInstance[];
+    /** Model-facing list: detailed transcripts and request cache remain private. */
+    listSummaries(status?: string): {
+        id: string;
+        shortId: string;
+        natureSlug: string;
+        displayName: string;
+        qualifiedName: string;
+        name: string;
+        conversationId: string;
+        createdByAgentId: string;
+        buildRunId: string | undefined;
+        intelligenceTier: string | undefined;
+        prompt: string;
+        model: string;
+        inputMode: string;
+        agentMode: AgentMode;
+        mode: AgentMode;
+        status: SubagentStatus;
+        active: boolean;
+        goalObjective: string | undefined;
+        flowName: string | undefined;
+        flowPc: number | undefined;
+        queueSequence: number | undefined;
+        resultAvailable: boolean;
+        resultChars: number;
+        settlementRevision: number | undefined;
+        messageCount: number;
+        error: string | undefined;
+        createdAt: string;
+        startedAt: string | undefined;
+        updatedAt: string;
+        completedAt: string | undefined;
+        closedAt: string | undefined;
+        mailbox: {
+            total: number;
+            unread: number;
+        };
+    }[];
     activeCountForBuild(buildRunId: string): number;
     setConcurrencyLimit(value: number): void;
     concurrencyLimit(): number;
@@ -258,4 +341,5 @@ export declare class SubagentManager {
 }
 export declare function sharedSubagentManager(key: string, options: SubagentManagerOptions): SubagentManager;
 export declare function releaseSharedSubagentManager(key: string): void;
+export {};
 //# sourceMappingURL=subagent.d.ts.map