@mcoda/codali 0.1.134 → 0.1.135-codali.4

package/dist/runtime/Runner.js

@@ -38,196 +38,240 @@ export class Runner {
         this.onToken = options.onToken;
         this.streamFlushMs = options.streamFlushMs;
         this.timeoutMs = options.timeoutMs;
+        this.continueAfterFinal = options.continueAfterFinal;
+        this.onMessages = options.onMessages;
         this.logger = options.logger;
+        this.signal = options.signal ?? options.context.signal;
     }
     async run(initialMessages) {
-        const messages = [...initialMessages];
-        let toolCallsExecuted = 0;
-        let usageTotals;
-        const deadline = this.timeoutMs ? Date.now() + this.timeoutMs : undefined;
-        const emitEvent = (event) => {
-            if (this.onEvent) {
-                this.onEvent(event);
-                return;
-            }
-            if (event.type === "token") {
-                this.onToken?.(event.content);
-            }
-        };
-        const emitStatus = (phase, message) => {
-            this.onEvent?.({ type: "status", phase, message });
-        };
-        const recordUsage = (usage) => {
-            if (!usage)
-                return;
-            if (!usageTotals)
-                usageTotals = {};
-            if (usage.inputTokens !== undefined) {
-                usageTotals.inputTokens = (usageTotals.inputTokens ?? 0) + usage.inputTokens;
-            }
-            if (usage.outputTokens !== undefined) {
-                usageTotals.outputTokens = (usageTotals.outputTokens ?? 0) + usage.outputTokens;
-            }
-            if (usage.totalTokens !== undefined) {
-                usageTotals.totalTokens = (usageTotals.totalTokens ?? 0) + usage.totalTokens;
-            }
-        };
-        const timeRemaining = () => {
-            if (!deadline)
-                return undefined;
-            return deadline - Date.now();
-        };
-        const throwBudgetError = async (code, step) => {
-            const error = new RunnerBudgetError(code, {
-                step,
-                tool_calls_executed: toolCallsExecuted,
-                max_steps: this.maxSteps,
-                max_tool_calls: this.maxToolCalls,
-                timeout_ms: this.timeoutMs,
-            });
-            if (this.logger) {
-                await this.logger.log("runner_budget_failure", error.metadata);
-            }
-            throw error;
-        };
-        const withTimeout = async (promise, label) => {
-            const remaining = timeRemaining();
-            if (remaining === undefined)
-                return promise;
-            if (remaining <= 0) {
-                await throwBudgetError("runner_timeout_exceeded", -1);
-            }
-            let timeoutId;
-            const timeoutPromise = new Promise((_, reject) => {
-                timeoutId = setTimeout(() => reject(new Error("Runner timeout exceeded")), remaining);
-            });
-            try {
-                return await Promise.race([promise, timeoutPromise]);
-            }
-            catch (error) {
-                if (error instanceof Error && /Runner timeout exceeded/i.test(error.message)) {
-                    await throwBudgetError("runner_timeout_exceeded", -1);
+        this.signal?.throwIfAborted();
+        const abortController = new AbortController();
+        const onAbort = () => abortController.abort(this.signal?.reason);
+        this.signal?.addEventListener("abort", onAbort, { once: true });
+        const timeout = this.timeoutMs ? setTimeout(() => abortController.abort(new Error("Runner timeout exceeded")), this.timeoutMs) : undefined;
+        const signal = abortController.signal;
+        try {
+            const messages = [...initialMessages];
+            let toolCallsExecuted = 0;
+            let usageTotals;
+            const deadline = this.timeoutMs ? Date.now() + this.timeoutMs : undefined;
+            const emitEvent = (event) => {
+                if (signal.aborted)
+                    return;
+                if (this.onEvent) {
+                    this.onEvent(event);
+                    return;
+                }
+                if (event.type === "token") {
+                    this.onToken?.(event.content);
+                }
+            };
+            const emitStatus = (phase, message) => {
+                this.onEvent?.({ type: "status", phase, message });
+            };
+            const recordUsage = (usage) => {
+                if (!usage)
+                    return;
+                if (!usageTotals)
+                    usageTotals = {};
+                if (usage.inputTokens !== undefined) {
+                    usageTotals.inputTokens = (usageTotals.inputTokens ?? 0) + usage.inputTokens;
+                }
+                if (usage.outputTokens !== undefined) {
+                    usageTotals.outputTokens = (usageTotals.outputTokens ?? 0) + usage.outputTokens;
+                }
+                if (usage.totalTokens !== undefined) {
+                    usageTotals.totalTokens = (usageTotals.totalTokens ?? 0) + usage.totalTokens;
+                }
+            };
+            const timeRemaining = () => {
+                if (!deadline)
+                    return undefined;
+                return deadline - Date.now();
+            };
+            const throwBudgetError = async (code, step) => {
+                const error = new RunnerBudgetError(code, {
+                    step,
+                    tool_calls_executed: toolCallsExecuted,
+                    max_steps: this.maxSteps,
+                    max_tool_calls: this.maxToolCalls,
+                    timeout_ms: this.timeoutMs,
+                });
+                if (this.logger) {
+                    await this.logger.log("runner_budget_failure", error.metadata);
                 }
                 throw error;
-            }
-            finally {
-                if (timeoutId)
-                    clearTimeout(timeoutId);
-            }
-        };
-        for (let step = 0; step < this.maxSteps; step += 1) {
-            if (deadline && timeRemaining() <= 0) {
-                await throwBudgetError("runner_timeout_exceeded", step);
-            }
-            const toolSpecs = this.tools.describe().map((tool) => ({
-                name: tool.name,
-                description: tool.description,
-                inputSchema: tool.inputSchema,
-            }));
-            const finalSummaryStep = this.finalStepWithoutTools && step > 0 && step === this.maxSteps - 1;
-            const allowTools = toolSpecs.length > 0 && this.toolChoice !== "none" && !finalSummaryStep;
-            emitStatus("thinking");
-            if (this.logger) {
-                await this.logger.log("provider_request", {
-                    provider: this.provider.name,
-                    messages,
-                    tools: allowTools ? toolSpecs : [],
-                    toolChoice: allowTools ? this.toolChoice ?? "auto" : "none",
-                    responseFormat: this.responseFormat,
-                    temperature: this.temperature,
-                    maxTokens: this.maxTokens,
-                    stream: this.stream ?? false,
+            };
+            const withTimeout = async (promise, label) => {
+                const remaining = timeRemaining();
+                if (remaining !== undefined && remaining <= 0) {
+                    await throwBudgetError("runner_timeout_exceeded", -1);
+                }
+                let timeoutId;
+                const timeoutPromise = new Promise((_, reject) => {
+                    if (remaining !== undefined)
+                        timeoutId = setTimeout(() => reject(new Error("Runner timeout exceeded")), remaining);
                 });
-            }
-            const response = await withTimeout(this.provider.generate({
-                messages,
-                tools: allowTools ? toolSpecs : undefined,
-                toolChoice: allowTools ? this.toolChoice ?? "auto" : finalSummaryStep ? "none" : undefined,
-                maxTokens: this.maxTokens,
-                temperature: this.temperature,
-                responseFormat: this.responseFormat,
-                stream: this.stream,
-                onEvent: emitEvent,
-                onToken: (token) => emitEvent({ type: "token", content: token }),
-                streamFlushMs: this.streamFlushMs,
-            }), "provider");
-            recordUsage(response.usage);
-            messages.push({
-                ...response.message,
-                ...(response.toolCalls?.length ? { toolCalls: response.toolCalls } : {}),
-            });
-            if (this.logger) {
-                await this.logger.log("provider_response", {
-                    message: response.message,
-                    toolCalls: response.toolCalls,
-                    usage: response.usage,
+                let onCancel;
+                const cancelled = new Promise((_, reject) => {
+                    // Provider streams may not honor AbortSignal; never accept their late reply.
+                    // Tools are allowed to finish their cancellation cleanup before unlocking.
+                    if (label === "provider") {
+                        onCancel = () => reject(signal.reason ?? new Error("Cancelled"));
+                        signal.addEventListener("abort", onCancel, { once: true });
+                        if (signal.aborted)
+                            onCancel();
+                    }
                 });
-            }
-            if (!response.toolCalls || response.toolCalls.length === 0) {
-                return {
-                    finalMessage: response.message,
-                    messages,
-                    toolCallsExecuted,
-                    usage: usageTotals,
-                };
-            }
-            for (const call of response.toolCalls) {
-                if (toolCallsExecuted >= this.maxToolCalls) {
-                    await throwBudgetError("runner_tool_call_limit_exceeded", step);
+                try {
+                    return await Promise.race([promise, timeoutPromise, cancelled]);
                 }
-                toolCallsExecuted += 1;
-                emitStatus("executing", call.name);
-                this.onEvent?.({ type: "tool_call", name: call.name, args: call.args });
-                const result = await withTimeout(this.tools.execute(call.name, call.args, this.context), "tool");
-                const toolError = result.error;
-                let content = result.ok
-                    ? result.output
-                    : `ERROR[${toolError?.code ?? "tool_execution_failed"}]: ${toolError?.message ?? "tool failed"}`;
-                if (result.ok && this.maxToolResultChars && this.maxToolResultChars > 0) {
-                    const limit = Math.max(1, Math.floor(this.maxToolResultChars / response.toolCalls.length));
-                    let structured = result.data;
-                    if (structured === undefined) {
-                        try {
-                            structured = JSON.parse(content);
-                        }
-                        catch { /* Plain-text tool output. */ }
+                catch (error) {
+                    if (error instanceof Error && /Runner timeout exceeded/i.test(error.message)) {
+                        await throwBudgetError("runner_timeout_exceeded", -1);
                     }
-                    content = truncateToolResult(structured, content, limit).text;
+                    throw error;
+                }
+                finally {
+                    if (timeoutId)
+                        clearTimeout(timeoutId);
+                    if (onCancel)
+                        signal.removeEventListener("abort", onCancel);
+                }
+            };
+            for (let step = 0; step < this.maxSteps; step += 1) {
+                signal.throwIfAborted();
+                if (deadline && timeRemaining() <= 0) {
+                    await throwBudgetError("runner_timeout_exceeded", step);
+                }
+                const toolSpecs = this.tools.describe().map((tool) => ({
+                    name: tool.name,
+                    description: tool.description,
+                    inputSchema: tool.inputSchema,
+                }));
+                const finalSummaryStep = this.finalStepWithoutTools && step > 0 && step === this.maxSteps - 1;
+                const allowTools = toolSpecs.length > 0 && this.toolChoice !== "none" && !finalSummaryStep;
+                emitStatus("thinking");
+                if (this.logger) {
+                    await this.logger.log("provider_request", {
+                        provider: this.provider.name,
+                        messages,
+                        tools: allowTools ? toolSpecs : [],
+                        toolChoice: allowTools ? this.toolChoice ?? "auto" : "none",
+                        responseFormat: this.responseFormat,
+                        temperature: this.temperature,
+                        maxTokens: this.maxTokens,
+                        stream: this.stream ?? false,
+                    });
                 }
-                messages.push(buildToolMessage(call, content));
-                this.onEvent?.({
-                    type: "tool_result",
-                    name: call.name,
-                    output: content,
-                    ok: result.ok,
-                    errorCode: toolError?.code,
-                    retryable: toolError?.retryable,
+                const response = await withTimeout(this.provider.generate({
+                    signal,
+                    messages,
+                    tools: allowTools ? toolSpecs : undefined,
+                    toolChoice: allowTools ? this.toolChoice ?? "auto" : finalSummaryStep ? "none" : undefined,
+                    maxTokens: this.maxTokens,
+                    temperature: this.temperature,
+                    responseFormat: this.responseFormat,
+                    stream: this.stream,
+                    onEvent: emitEvent,
+                    onToken: (token) => emitEvent({ type: "token", content: token }),
+                    streamFlushMs: this.streamFlushMs,
+                }), "provider");
+                recordUsage(response.usage);
+                signal.throwIfAborted();
+                messages.push({
+                    ...response.message,
+                    ...(response.toolCalls?.length ? { toolCalls: response.toolCalls } : {}),
                 });
+                await this.onMessages?.([...messages]);
                 if (this.logger) {
-                    await this.logger.log("tool_call", {
+                    await this.logger.log("provider_response", {
+                        message: response.message,
+                        toolCalls: response.toolCalls,
+                        usage: response.usage,
+                    });
+                }
+                if (!response.toolCalls || response.toolCalls.length === 0) {
+                    const continuation = await this.continueAfterFinal?.(response.message);
+                    if (continuation) {
+                        messages.push({ role: "user", content: continuation });
+                        continue;
+                    }
+                    return {
+                        finalMessage: response.message,
+                        messages,
+                        toolCallsExecuted,
+                        usage: usageTotals,
+                    };
+                }
+                for (const call of response.toolCalls) {
+                    signal.throwIfAborted();
+                    if (toolCallsExecuted >= this.maxToolCalls) {
+                        await throwBudgetError("runner_tool_call_limit_exceeded", step);
+                    }
+                    toolCallsExecuted += 1;
+                    emitStatus("executing", call.name);
+                    this.onEvent?.({ type: "tool_call", name: call.name, args: call.args });
+                    const result = await withTimeout(this.tools.execute(call.name, call.args, { ...this.context, signal }), "tool");
+                    const toolError = result.error;
+                    let content = result.ok
+                        ? result.output
+                        : `ERROR[${toolError?.code ?? "tool_execution_failed"}]: ${toolError?.message ?? "tool failed"}`;
+                    if (result.ok && this.maxToolResultChars && this.maxToolResultChars > 0) {
+                        const limit = Math.max(1, Math.floor(this.maxToolResultChars / response.toolCalls.length));
+                        let structured = result.data;
+                        if (structured === undefined) {
+                            try {
+                                structured = JSON.parse(content);
+                            }
+                            catch { /* Plain-text tool output. */ }
+                        }
+                        content = truncateToolResult(structured, content, limit).text;
+                    }
+                    if (result.invocationReceipt) {
+                        content += `\n\n[Tool metadata: invocation receipt ID ${result.invocationReceipt.id}; receiptRef=${result.invocationReceipt.reference}]`;
+                    }
+                    messages.push(buildToolMessage(call, content));
+                    await this.onMessages?.([...messages]);
+                    this.onEvent?.({
+                        type: "tool_result",
                         name: call.name,
+                        output: content,
                         ok: result.ok,
-                        error: toolError?.message,
-                        error_code: toolError?.code,
-                        error_category: toolError?.category,
-                        error_retryable: toolError?.retryable,
-                        error_details: toolError?.details,
+                        errorCode: toolError?.code,
+                        retryable: toolError?.retryable,
                     });
-                    if (toolError) {
-                        await this.logger.logSafetyEvent({
-                            phase: "act",
-                            category: "tool",
-                            code: toolError.code,
-                            disposition: toolError.retryable ? "retryable" : "non_retryable",
-                            tool: call.name,
-                            message: toolError.message,
-                            details: toolError.details,
+                    if (this.logger) {
+                        await this.logger.log("tool_call", {
+                            name: call.name,
+                            ok: result.ok,
+                            error: toolError?.message,
+                            error_code: toolError?.code,
+                            error_category: toolError?.category,
+                            error_retryable: toolError?.retryable,
+                            error_details: toolError?.details,
                         });
+                        if (toolError) {
+                            await this.logger.logSafetyEvent({
+                                phase: "act",
+                                category: "tool",
+                                code: toolError.code,
+                                disposition: toolError.retryable ? "retryable" : "non_retryable",
+                                tool: call.name,
+                                message: toolError.message,
+                                details: toolError.details,
+                            });
+                        }
                     }
                 }
             }
+            await throwBudgetError("runner_step_limit_exceeded", this.maxSteps);
+            throw new Error("unreachable_runner_budget_path");
+        }
+        finally {
+            if (timeout)
+                clearTimeout(timeout);
+            this.signal?.removeEventListener("abort", onAbort);
         }
-        await throwBudgetError("runner_step_limit_exceeded", this.maxSteps);
-        throw new Error("unreachable_runner_budget_path");
     }
 }

package/dist/runtime/SecretRedaction.d.ts

@@ -0,0 +1,11 @@
+/** Register credentials when resolved; do not scan or expose unrelated environment values. */
+export declare const registerSecretValue: (value: string) => void;
+export declare const redactSecretValues: (value: string) => string;
+/** Hold incomplete credential-shaped words so split chunks cannot expose a prefix or tail. */
+export declare class StreamingSecretRedactor {
+    private pending;
+    private droppingWord;
+    write(chunk: string): string;
+    finish(): string;
+}
+//# sourceMappingURL=SecretRedaction.d.ts.map

package/dist/runtime/SecretRedaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SecretRedaction.d.ts","sourceRoot":"","sources":["../../src/runtime/SecretRedaction.ts"],"names":[],"mappings":"AAaA,8FAA8F;AAC9F,eAAO,MAAM,mBAAmB,GAAI,OAAO,MAAM,KAAG,IAEnD,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,OAAO,MAAM,KAAG,MAKlD,CAAC;AAEF,8FAA8F;AAC9F,qBAAa,uBAAuB;IAClC,OAAO,CAAC,OAAO,CAAM;IACrB,OAAO,CAAC,YAAY,CAAS;IAC7B,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IA4B5B,MAAM,IAAI,MAAM;CAUjB"}

package/dist/runtime/SecretRedaction.js

@@ -0,0 +1,85 @@
+const knownSecrets = new Set();
+const patterns = [
+    /\bBearer\s+[A-Za-z0-9._~+/=-]{12,}/gi,
+    /\bsk-[A-Za-z0-9_-]{16,}\b/g,
+    /\bsk_[A-Za-z0-9]+_[A-Za-z0-9_]{8,}\b/g,
+    /\bgh[pousr]_[A-Za-z0-9_]{20,}\b/g,
+    /\bglpat-[A-Za-z0-9_-]{16,}\b/g,
+    /\bxox[abprs]-[A-Za-z0-9-]{10,}\b/g,
+    /\bAKIA[0-9A-Z]{16}\b/g,
+    /\bAIza[0-9A-Za-z_-]{30,}\b/g,
+    /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g,
+];
+/** Register credentials when resolved; do not scan or expose unrelated environment values. */
+export const registerSecretValue = (value) => {
+    if (value.length >= 4) {
+        knownSecrets.add(value);
+        knownSecrets.add(JSON.stringify(value).slice(1, -1));
+    }
+};
+export const redactSecretValues = (value) => {
+    let output = value;
+    for (const secret of [...knownSecrets].sort((a, b) => b.length - a.length))
+        output = output.split(secret).join("[redacted]");
+    for (const pattern of patterns)
+        output = output.replace(pattern, "[redacted]");
+    return output;
+};
+/** Hold incomplete credential-shaped words so split chunks cannot expose a prefix or tail. */
+export class StreamingSecretRedactor {
+    constructor() {
+        this.pending = "";
+        this.droppingWord = false;
+    }
+    write(chunk) {
+        if (this.droppingWord) {
+            const boundary = chunk.search(/[^A-Za-z0-9._~+/=-]/);
+            if (boundary < 0)
+                return "";
+            chunk = chunk.slice(boundary);
+            this.droppingWord = false;
+        }
+        this.pending += chunk;
+        let cutoff = this.pending.search(/[A-Za-z0-9._~+/=-]*$/);
+        const bearer = /\bBearer\s+[A-Za-z0-9._~+/=-]*$/i.exec(this.pending);
+        if (bearer)
+            cutoff = Math.min(cutoff, bearer.index);
+        for (const secret of knownSecrets) {
+            // An exact credential may contain spaces/punctuation, unlike a bearer word.
+            for (let at = this.pending.indexOf(secret); at >= 0; at = this.pending.indexOf(secret, at + 1)) {
+                if (at < cutoff && at + secret.length > cutoff)
+                    cutoff = at;
+            }
+            for (let size = Math.min(secret.length - 1, this.pending.length); size > 0; size--) {
+                if (this.pending.endsWith(secret.slice(0, size))) {
+                    cutoff = Math.min(cutoff, this.pending.length - size);
+                    break;
+                }
+            }
+        }
+        let output = redactSecretValues(this.pending.slice(0, cutoff));
+        this.pending = this.pending.slice(cutoff);
+        // Never release a truncated prefix; discard an oversized unbroken token.
+        const longestCredential = Math.max(0, ...[...knownSecrets].map(secret => secret.length));
+        if (this.pending.length > Math.max(65536, longestCredential)) {
+            output += "[redacted oversized token]";
+            this.pending = "";
+            this.droppingWord = true;
+        }
+        return output;
+    }
+    finish() {
+        let output = redactSecretValues(this.pending);
+        for (const secret of knownSecrets) {
+            for (let size = Math.min(secret.length - 1, output.length); size >= 4; size--) {
+                if (output.endsWith(secret.slice(0, size))) {
+                    output = `${output.slice(0, -size)}[redacted]`;
+                    break;
+                }
+            }
+        }
+        this.pending = "";
+        this.droppingWord = false;
+        return output;
+    }
+}

package/dist/runtime/SessionController.d.ts

@@ -0,0 +1,148 @@
+import { SessionStore } from "../session/SessionStore.js";
+import type { WorkState } from "../session/WorkTypes.js";
+import type { Provider } from "../providers/ProviderTypes.js";
+import { type EffortLevel, type ResolvedOrchestrationConfig } from "../config/OrchestrationConfig.js";
+import { PermissionGate, type PermissionProfile, type PermissionPrompt } from "../permissions/PermissionGate.js";
+import { ToolRegistry } from "../tools/ToolRegistry.js";
+import { type ToolDefinition } from "../tools/ToolTypes.js";
+import { MediaJobStore } from "../connectors/media/MediaJobStore.js";
+import { type RunContext } from "../runcontext/RunContextResolver.js";
+import type { ProjectTaskAuthority } from "@mcoda/shared";
+export interface SessionEvent {
+    schemaVersion: 1;
+    id: string;
+    sessionId: string;
+    sequence: number;
+    at: string;
+    type: string;
+    data: Record<string, unknown>;
+}
+export interface SessionControllerOptions {
+    workspaceRoot: string;
+    resolved: ResolvedOrchestrationConfig;
+    effort?: EffortLevel;
+    permissions?: PermissionProfile;
+    approve?: PermissionPrompt;
+    onEvent?: (event: SessionEvent) => void;
+    storageRoot?: string;
+    provider?: Provider;
+    tools?: ToolDefinition[];
+    docdexUrl?: string;
+    docdex?: boolean;
+    allowWeb?: boolean;
+    allowMemory?: boolean;
+    allowMedia?: boolean;
+    allowNetwork?: boolean;
+    /** Authenticated host context; repository settings can only narrow tools. */
+    runContext?: RunContext;
+    projectTaskAuthority?: ProjectTaskAuthority;
+    projectTaskKey?: string;
+}
+interface SessionUsage {
+    modelCalls: number;
+    toolCalls: number;
+    tokens: number;
+    inputTokens: number;
+    outputTokens: number;
+    estimated: boolean;
+    embeddingCalls?: number;
+    embeddingTokens?: number;
+}
+export declare class SessionController {
+    private readonly options;
+    private projectHandoff;
+    readonly store: SessionStore;
+    readonly gate: PermissionGate;
+    readonly registry: ToolRegistry;
+    readonly isolation: import("../tools/shell/IsolatedExecutor.js").ExecutorStatus;
+    readonly workspaceRoot: string;
+    sessionId?: string;
+    state?: WorkState;
+    effort: EffortLevel;
+    private active?;
+    private sequence;
+    private messages;
+    private receipts;
+    private observed;
+    private touched;
+    private currentReceipt?;
+    private persistence;
+    private persistenceError?;
+    private usage;
+    private reservations;
+    private modelSettlements;
+    private closingModelTurn?;
+    private baseline?;
+    private previousSnapshot?;
+    private instructions;
+    private finalAttempts;
+    private docdex?;
+    private managedDocdex?;
+    private docdexNames;
+    private docdexReady;
+    private memoryContext;
+    private lastRequestEstimate;
+    private repeatedFailures;
+    private progressTracker;
+    private connectorRegistry?;
+    private connectorNames;
+    private connectorHealth;
+    private outputStreams;
+    private runContext?;
+    private enabledTools;
+    private get fencePath();
+    private resetSessionState;
+    private attachConnectors;
+    private closeConnectors;
+    private clearFence;
+    constructor(options: SessionControllerOptions);
+    private usesManagedDocdex;
+    private attachDocdexTools;
+    private startManagedDocdex;
+    get busy(): boolean;
+    status(): Record<string, unknown>;
+    usageSnapshot(): SessionUsage;
+    mediaStore(): MediaJobStore;
+    private workspaceLedger;
+    artifacts(): Promise<Record<string, unknown>[]>;
+    private flushOutputStreams;
+    private emit;
+    private update;
+    private checkProjectTask;
+    private completionInputs;
+    private completeGoal;
+    private reconcileProjectHandoff;
+    start(objective: string): Promise<void>;
+    resume(id: string): Promise<void>;
+    cancel(): void;
+    steer(instruction: string): Promise<void>;
+    checkpoint(note?: string): Promise<void>;
+    private compactMessages;
+    compact(): Promise<void>;
+    clearPermissionGrants(): Promise<void>;
+    fork(): Promise<string>;
+    reloadConfiguration(resolved: ResolvedOrchestrationConfig): Promise<void>;
+    deleteSession(id: string): Promise<void>;
+    reconcile(invocationId: string, outcome: "success" | "failed", note: string): Promise<void>;
+    diff(): Promise<string>;
+    private hashes;
+    private assertEditEvidence;
+    private shellWritePaths;
+    private validationReserve;
+    private validationContext;
+    private provider;
+    private beforeTool;
+    private afterTool;
+    private prepareEditTool;
+    private receiptRef;
+    private resolveReceipt;
+    private workTools;
+    private helperTool;
+    private verify;
+    run(prompt?: string): Promise<{
+        content: string;
+        completed: boolean;
+    }>;
+}
+export {};
+//# sourceMappingURL=SessionController.d.ts.map