@loucompanion/forge-bridge 0.1.3-dev.f66395c3ac21 → 0.1.4-dev.1ff37038366e

package/dist/session/provider-cli/provider-usage.d.ts

@@ -1,17 +1,24 @@
 import type { RunOnceDispatchPacket, RunnerDispatchEvent } from "../session.types.js";
 export type UsageSource = "provider_reported" | "cli_reported" | "estimated" | "unknown";
+export type InputTokenSemantics = "includes_cached_input" | "excludes_cache_tokens" | "unknown";
+export declare const PROVIDER_USAGE_SCHEMA_VERSION = 1;
 /**
  * Normalized, provider-agnostic token usage accumulated for a dispatch. Cost is never computed
  * here; the API recomputes cost from these tokens x model rates (ADR-0006).
  */
 export interface ProviderUsage {
+    /** Normalized total input. Cached input is a subset, never an additive peer. */
     readonly inputTokens: number;
+    readonly uncachedInputTokens: number | null;
     readonly outputTokens: number;
     readonly cacheReadTokens: number;
     readonly cacheCreationTokens: number;
     readonly reasoningOutputTokens: number;
     readonly providerDurationMs: number | null;
     readonly source: UsageSource;
+    readonly inputTokenSemantics: InputTokenSemantics;
+    /** Exact provider usage objects retained for audit/re-normalization. */
+    readonly rawUsage: readonly Record<string, unknown>[];
 }
 export declare function emptyUsage(source?: UsageSource): ProviderUsage;
 export declare function addUsage(base: ProviderUsage, next: Partial<ProviderUsage>): ProviderUsage;

package/dist/session/provider-cli/provider-usage.js

@@ -1,27 +1,38 @@
+export const PROVIDER_USAGE_SCHEMA_VERSION = 1;
 export function emptyUsage(source = "unknown") {
     return {
         inputTokens: 0,
+        uncachedInputTokens: 0,
         outputTokens: 0,
         cacheReadTokens: 0,
         cacheCreationTokens: 0,
         reasoningOutputTokens: 0,
         providerDurationMs: null,
-        source
+        source,
+        inputTokenSemantics: "unknown",
+        rawUsage: []
     };
 }
 export function addUsage(base, next) {
+    const nextUncached = next.uncachedInputTokens;
+    const uncachedInputTokens = base.uncachedInputTokens === null || nextUncached === null
+        ? null
+        : base.uncachedInputTokens + nonNegative(nextUncached);
     return {
         inputTokens: base.inputTokens + nonNegative(next.inputTokens),
+        uncachedInputTokens,
         outputTokens: base.outputTokens + nonNegative(next.outputTokens),
         cacheReadTokens: base.cacheReadTokens + nonNegative(next.cacheReadTokens),
         cacheCreationTokens: base.cacheCreationTokens + nonNegative(next.cacheCreationTokens),
         reasoningOutputTokens: base.reasoningOutputTokens + nonNegative(next.reasoningOutputTokens),
         providerDurationMs: next.providerDurationMs ?? base.providerDurationMs,
-        source: next.source ?? base.source
+        source: next.source ?? base.source,
+        inputTokenSemantics: mergeSemantics(base.inputTokenSemantics, next.inputTokenSemantics),
+        rawUsage: [...base.rawUsage, ...(next.rawUsage ?? [])]
     };
 }
 export function totalTokens(usage) {
-    return usage.inputTokens + usage.outputTokens + usage.cacheReadTokens + usage.cacheCreationTokens;
+    return usage.inputTokens + usage.outputTokens;
 }
 export function hasUsage(usage) {
     return usage !== null && totalTokens(usage) > 0;
@@ -37,20 +48,26 @@ export function buildProviderUsageEvent(dispatch, usage) {
         lane: dispatch.execution.lane,
         phase: dispatch.cycleRun.phase,
         attempt: dispatch.cycleRun.attempt,
+        usage_schema_version: PROVIDER_USAGE_SCHEMA_VERSION,
+        input_token_semantics: usage.inputTokenSemantics,
         input_tokens: usage.inputTokens,
+        uncached_input_tokens: usage.uncachedInputTokens,
         output_tokens: usage.outputTokens,
         cache_read_tokens: usage.cacheReadTokens,
         cache_creation_tokens: usage.cacheCreationTokens,
         reasoning_output_tokens: usage.reasoningOutputTokens,
         metered: dispatch.execution.authKind === "api_key",
         usage_source: usage.source,
-        provider_duration_ms: usage.providerDurationMs
+        provider_duration_ms: usage.providerDurationMs,
+        normalized_total_tokens: totalTokens(usage),
+        normalized_total_formula: "total_input + output; cached_input is a subset of total_input",
+        raw_usage: usage.rawUsage
     };
     const total = totalTokens(usage);
     return {
         role: "runner",
         kind: "checkpoint",
-        content: `Provider usage: ${total} tokens (${usage.inputTokens} in / ${usage.outputTokens} out) for ${dispatch.execution.model}.`,
+        content: `Provider usage: ${total} tokens (${usage.inputTokens} total in, including ${usage.cacheReadTokens} cached / ${usage.outputTokens} out) for ${dispatch.execution.model}.`,
         eventType: "provider_usage",
         data: JSON.stringify(data)
     };
@@ -62,3 +79,9 @@ export function readUsageNumber(source, key) {
 function nonNegative(value) {
     return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
 }
+function mergeSemantics(base, next) {
+    if (!next || next === "unknown") {
+        return base;
+    }
+    return base === "unknown" || base === next ? next : "unknown";
+}

package/dist/session/session-redaction.d.ts

@@ -0,0 +1,3 @@
+import type { RunOnceResultPacket, RunnerDispatchEvent } from "./session.types.js";
+export declare function redactRunnerDispatchEvent(event: RunnerDispatchEvent, exactSecrets?: readonly string[]): RunnerDispatchEvent;
+export declare function redactRunOnceResultPacket(result: RunOnceResultPacket, exactSecrets?: readonly string[]): RunOnceResultPacket;

package/dist/session/session-redaction.js

@@ -0,0 +1,448 @@
+import { redactText, shouldRedactJsonProperty } from "../shared/redaction/redaction.js";
+import { TextDecoder } from "node:util";
+const integrityProtectedEventDataTypes = new Set(["sandbox_started"]);
+const structuralSecretMessage = "runner result structural metadata contains protected secret material and cannot be redacted without changing protocol identity.";
+const sidecarSecretMessage = "runner result sidecar contains protected secret material and cannot be redacted without invalidating integrity metadata.";
+const artifactJsonMessage = "runner result artifact JSON is invalid or exceeds safe inspection limits; transport was rejected.";
+const artifactJsonKeySecretMessage = "runner result artifact JSON property name contains protected secret material and cannot be redacted without changing protocol identity.";
+const artifactJsonPrimitiveSecretMessage = "runner result artifact JSON primitive contains protected secret material and cannot be redacted without changing protocol identity.";
+const maximumIntegrityJsonBytes = 8 * 1024 * 1024;
+const maximumIntegrityJsonDepth = 128;
+const maximumIntegrityJsonTokens = 262_144;
+export function redactRunnerDispatchEvent(event, exactSecrets = []) {
+    assertStructuralFieldsDoNotContainSecrets([
+        event.role,
+        event.kind,
+        event.eventType,
+        event.wait?.kind,
+        event.wait?.scope,
+        event.wait?.wakeCondition,
+        event.wait?.contractOrigin,
+        ...(event.wait?.resourceKeys ?? []),
+    ], exactSecrets);
+    if (event.data !== undefined
+        && event.data !== null
+        && integrityProtectedEventDataTypes.has(event.eventType)) {
+        // Integrity-protected data cannot be rewritten because the runtime lease repeats the
+        // dispatch fence. Check the complete serialized payload so current and future resource
+        // identity fields cannot carry pending secret material across this boundary.
+        assertSerializedJsonDoesNotContainSecrets(event.data, exactSecrets, structuralSecretMessage);
+    }
+    // sandbox_started data is runner-authored protocol metadata. Its runtime
+    // lease repeats the dispatch fence so the API can validate ownership. The
+    // transcript redactor treats any serialized `*Token` field as a secret and
+    // must not rewrite that identity before transport or result persistence.
+    return {
+        ...event,
+        content: redactContent(event.content, exactSecrets),
+        ...(event.wait === undefined
+            ? {}
+            : { wait: event.wait === null ? null : redactWait(event.wait, exactSecrets) }),
+        ...(event.data === undefined || event.data === null
+            ? {}
+            : {
+                data: integrityProtectedEventDataTypes.has(event.eventType)
+                    ? event.data
+                    : redactContent(event.data, exactSecrets),
+            }),
+    };
+}
+function redactWait(wait, exactSecrets) {
+    return {
+        ...wait,
+        ...(wait.blockerTitle === undefined || wait.blockerTitle === null
+            ? {}
+            : { blockerTitle: redactContent(wait.blockerTitle, exactSecrets).slice(0, 500) }),
+    };
+}
+export function redactRunOnceResultPacket(result, exactSecrets = []) {
+    assertStructuralFieldsDoNotContainSecrets([result.resultCommitSha, result.publishedCommitSha], exactSecrets);
+    return {
+        ...result,
+        summary: redactContent(result.summary, exactSecrets),
+        ...(result.failure !== undefined
+            ? { failure: result.failure === null ? null : redactFailure(result.failure, exactSecrets) }
+            : {}),
+        ...(result.spec !== undefined
+            ? { spec: result.spec === null ? null : redactSpec(result.spec, exactSecrets) }
+            : {}),
+        ...(result.artifact !== undefined
+            ? { artifact: result.artifact === null ? null : redactArtifact(result.artifact, exactSecrets) }
+            : {}),
+        ...(result.artifacts !== undefined
+            ? {
+                artifacts: result.artifacts === null
+                    ? null
+                    : result.artifacts.map(item => redactArtifact(item, exactSecrets)),
+            }
+            : {}),
+        events: result.events.map(event => redactRunnerDispatchEvent(event, exactSecrets)),
+    };
+}
+function redactFailure(failure, exactSecrets) {
+    assertStructuralFieldsDoNotContainSecrets([failure.code, ...failure.causalChain.map(cause => cause.code)], exactSecrets);
+    return {
+        ...failure,
+        message: redactContent(failure.message, exactSecrets),
+        causalChain: failure.causalChain.map(cause => ({
+            ...cause,
+            message: redactContent(cause.message, exactSecrets),
+        })),
+    };
+}
+function redactSpec(spec, exactSecrets) {
+    assertStructuralFieldsDoNotContainSecrets([spec.repoPath, spec.path, spec.producedBy, spec.status], exactSecrets);
+    return { ...spec, body: redactContent(spec.body, exactSecrets) };
+}
+function redactArtifact(artifact, exactSecrets) {
+    assertStructuralFieldsDoNotContainSecrets([artifact.repoPath, artifact.path, artifact.producedBy, artifact.status, artifact.phase], exactSecrets);
+    assertSidecarsDoNotContainSecrets(artifact.sidecars, exactSecrets);
+    return {
+        ...artifact,
+        verdictJson: redactArtifactJson(artifact.verdictJson, exactSecrets),
+        ...(artifact.planJson === undefined || artifact.planJson === null
+            ? {}
+            : { planJson: redactArtifactJson(artifact.planJson, exactSecrets) }),
+        ...(artifact.evidenceJson === undefined || artifact.evidenceJson === null
+            ? {}
+            : { evidenceJson: redactArtifactJson(artifact.evidenceJson, exactSecrets) }),
+        ...(artifact.findingsJson === undefined || artifact.findingsJson === null
+            ? {}
+            : { findingsJson: redactArtifactJson(artifact.findingsJson, exactSecrets) }),
+        ...(artifact.implementationPlanJson === undefined || artifact.implementationPlanJson === null
+            ? {}
+            : { implementationPlanJson: redactArtifactJson(artifact.implementationPlanJson, exactSecrets) }),
+        ...(artifact.qaPlanJson === undefined || artifact.qaPlanJson === null
+            ? {}
+            : { qaPlanJson: redactArtifactJson(artifact.qaPlanJson, exactSecrets) }),
+        report: redactContent(artifact.report, exactSecrets),
+        // These bytes already passed the QA path/hash/size checks. The generic
+        // redactor strips contentBase64 fields and must not corrupt the payload.
+        ...(artifact.sidecars !== undefined ? { sidecars: artifact.sidecars } : {}),
+    };
+}
+function redactArtifactJson(value, exactSecrets) {
+    // Validate the original before redaction. Replacing an invalid value must never
+    // turn a malformed evidence bundle into an apparently valid QA artifact.
+    inspectJsonStringTokens(value, [], artifactJsonMessage);
+    const chunks = [];
+    let unchangedStart = 0;
+    let index = 0;
+    const replace = (start, end, replacement) => {
+        if (value.slice(start, end) === replacement)
+            return;
+        chunks.push(value.slice(unchangedStart, start), replacement);
+        unchangedStart = end;
+    };
+    while (index < value.length) {
+        if (value.charCodeAt(index) !== 0x22) {
+            const code = value.charCodeAt(index);
+            if (isJsonWhitespace(code) || isJsonPunctuation(code)) {
+                index += 1;
+            }
+            else {
+                const end = jsonValueEnd(value, index);
+                // Numeric credentials and other exact primitive matches are still secrets.
+                // Fail closed instead of silently changing evidence types to strings.
+                assertJsonStringDoesNotContainSecrets(value.slice(index, end), exactSecrets, artifactJsonPrimitiveSecretMessage);
+                index = end;
+            }
+            continue;
+        }
+        const token = decodeJsonStringToken(value, index, artifactJsonMessage);
+        const afterToken = skipJsonWhitespace(value, token.nextIndex);
+        if (value.charCodeAt(afterToken) === 0x3a) {
+            assertJsonStringDoesNotContainSecrets(token.decoded, exactSecrets, artifactJsonKeySecretMessage);
+            if (redactText(token.decoded, exactSecrets) !== token.decoded)
+                throw new Error(artifactJsonKeySecretMessage);
+            if (shouldRedactJsonProperty(token.decoded)) {
+                const valueStart = skipJsonWhitespace(value, afterToken + 1);
+                const valueEnd = jsonValueEnd(value, valueStart);
+                if (value[valueStart] !== '"'
+                    || decodeJsonStringToken(value, valueStart, artifactJsonMessage).decoded !== "[REDACTED]") {
+                    replace(valueStart, valueEnd, '"[REDACTED]"');
+                }
+                index = valueEnd;
+                continue;
+            }
+        }
+        else {
+            const redacted = redactText(token.decoded, exactSecrets);
+            if (redacted !== token.decoded)
+                replace(index, token.nextIndex, JSON.stringify(redacted));
+        }
+        index = token.nextIndex;
+    }
+    if (chunks.length === 0)
+        return value;
+    chunks.push(value.slice(unchangedStart));
+    const redacted = chunks.join("");
+    // Retain the same bounded contract even when a short exact secret expands into
+    // a longer redaction marker. No raw JSON regex or parse/stringify round-trip:
+    // untouched escapes, whitespace, duplicate properties and numeric text survive.
+    inspectJsonStringTokens(redacted, [], artifactJsonMessage);
+    return redacted;
+}
+function skipJsonWhitespace(value, start) {
+    let index = start;
+    while (index < value.length && isJsonWhitespace(value.charCodeAt(index)))
+        index += 1;
+    return index;
+}
+// Called only after bounded JSON validation. Locate a credential property's whole
+// value (including objects/arrays) without decoding or rewriting adjacent data.
+function jsonValueEnd(value, start) {
+    if (value.charCodeAt(start) === 0x22) {
+        return decodeJsonStringToken(value, start, artifactJsonMessage).nextIndex;
+    }
+    if (value[start] === "{" || value[start] === "[") {
+        let depth = 0;
+        for (let index = start; index < value.length; index += 1) {
+            if (value[index] === '"') {
+                index = decodeJsonStringToken(value, index, artifactJsonMessage).nextIndex - 1;
+            }
+            else if (value[index] === "{" || value[index] === "[") {
+                depth += 1;
+            }
+            else if (value[index] === "}" || value[index] === "]") {
+                depth -= 1;
+                if (depth === 0)
+                    return index + 1;
+            }
+        }
+        throw new Error(artifactJsonMessage);
+    }
+    let index = start;
+    while (index < value.length
+        && !isJsonWhitespace(value.charCodeAt(index))
+        && value[index] !== "," && value[index] !== "}" && value[index] !== "]")
+        index += 1;
+    return index;
+}
+function redactContent(value, exactSecrets) {
+    return typeof value === "string" ? redactText(value, exactSecrets) : value;
+}
+function assertStructuralFieldsDoNotContainSecrets(fields, exactSecrets) {
+    for (const field of fields) {
+        if (field === undefined || field === null)
+            continue;
+        for (const secret of exactSecrets) {
+            if (secret.length > 0 && field.includes(secret)) {
+                throw new Error(structuralSecretMessage);
+            }
+        }
+    }
+}
+function assertSidecarsDoNotContainSecrets(sidecars, exactSecrets) {
+    if (!sidecars || exactSecrets.length === 0)
+        return;
+    for (const sidecar of sidecars) {
+        const decoded = Buffer.from(sidecar.contentBase64, "base64");
+        for (const secret of exactSecrets) {
+            if (secret.length === 0)
+                continue;
+            if (sidecar.path.includes(secret)
+                || sidecar.contentBase64.includes(secret)
+                || sidecar.contentHash.includes(secret)
+                || decoded.indexOf(Buffer.from(secret, "utf8")) >= 0) {
+                throw new Error(sidecarSecretMessage);
+            }
+        }
+        assertSidecarJsonDoesNotContainSecrets(decoded, sidecar.path, exactSecrets, sidecarSecretMessage);
+    }
+}
+function assertSerializedJsonDoesNotContainSecrets(value, exactSecrets, errorMessage) {
+    if (exactSecrets.length === 0)
+        return;
+    assertJsonStringDoesNotContainSecrets(value, exactSecrets, errorMessage);
+    inspectJsonStringTokens(value, exactSecrets, errorMessage);
+}
+function assertSidecarJsonDoesNotContainSecrets(value, path, exactSecrets, errorMessage) {
+    let decoded;
+    try {
+        decoded = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(value);
+    }
+    catch {
+        if (path.toLowerCase().endsWith(".json"))
+            throw new Error(errorMessage);
+        return;
+    }
+    if (!looksLikeJson(decoded, path))
+        return;
+    const hasUtf8Bom = value.length >= 3
+        && value[0] === 0xef
+        && value[1] === 0xbb
+        && value[2] === 0xbf;
+    if (hasUtf8Bom)
+        throw new Error(errorMessage);
+    inspectJsonStringTokens(decoded, exactSecrets, errorMessage);
+}
+function inspectJsonStringTokens(value, exactSecrets, errorMessage) {
+    if (Buffer.byteLength(value, "utf8") > maximumIntegrityJsonBytes) {
+        throw new Error(errorMessage);
+    }
+    const containers = [];
+    let index = 0;
+    let tokenCount = 0;
+    const countToken = () => {
+        tokenCount += 1;
+        if (tokenCount > maximumIntegrityJsonTokens)
+            throw new Error(errorMessage);
+    };
+    while (index < value.length) {
+        const code = value.charCodeAt(index);
+        if (code === 0x22) {
+            countToken();
+            const token = decodeJsonStringToken(value, index, errorMessage);
+            assertJsonStringDoesNotContainSecrets(token.decoded, exactSecrets, errorMessage);
+            index = token.nextIndex;
+            continue;
+        }
+        if (code === 0x7b || code === 0x5b) {
+            countToken();
+            containers.push(code);
+            if (containers.length > maximumIntegrityJsonDepth)
+                throw new Error(errorMessage);
+            index += 1;
+            continue;
+        }
+        if (code === 0x7d || code === 0x5d) {
+            countToken();
+            const expected = code === 0x7d ? 0x7b : 0x5b;
+            if (containers.pop() !== expected)
+                throw new Error(errorMessage);
+            index += 1;
+            continue;
+        }
+        if (code === 0x2c || code === 0x3a) {
+            index += 1;
+            continue;
+        }
+        if (isJsonWhitespace(code)) {
+            index += 1;
+            continue;
+        }
+        countToken();
+        do {
+            index += 1;
+        } while (index < value.length
+            && !isJsonWhitespace(value.charCodeAt(index))
+            && !isJsonPunctuation(value.charCodeAt(index)));
+    }
+    if (containers.length !== 0)
+        throw new Error(errorMessage);
+    try {
+        JSON.parse(value);
+    }
+    catch {
+        throw new Error(errorMessage);
+    }
+}
+function decodeJsonStringToken(value, openingQuoteIndex, errorMessage) {
+    const chunks = [];
+    let segmentStart = openingQuoteIndex + 1;
+    let index = segmentStart;
+    while (index < value.length) {
+        const code = value.charCodeAt(index);
+        if (code === 0x22) {
+            chunks.push(value.slice(segmentStart, index));
+            const decoded = chunks.join("");
+            if (!isWellFormedUnicode(decoded))
+                throw new Error(errorMessage);
+            return { decoded, nextIndex: index + 1 };
+        }
+        if (code < 0x20)
+            throw new Error(errorMessage);
+        if (code !== 0x5c) {
+            index += 1;
+            continue;
+        }
+        chunks.push(value.slice(segmentStart, index));
+        index += 1;
+        if (index >= value.length)
+            throw new Error(errorMessage);
+        const escaped = value[index];
+        switch (escaped) {
+            case "\"":
+                chunks.push("\"");
+                index += 1;
+                break;
+            case "\\":
+                chunks.push("\\");
+                index += 1;
+                break;
+            case "/":
+                chunks.push("/");
+                index += 1;
+                break;
+            case "b":
+                chunks.push("\b");
+                index += 1;
+                break;
+            case "f":
+                chunks.push("\f");
+                index += 1;
+                break;
+            case "n":
+                chunks.push("\n");
+                index += 1;
+                break;
+            case "r":
+                chunks.push("\r");
+                index += 1;
+                break;
+            case "t":
+                chunks.push("\t");
+                index += 1;
+                break;
+            case "u": {
+                const hex = value.slice(index + 1, index + 5);
+                if (!/^[0-9a-fA-F]{4}$/u.test(hex))
+                    throw new Error(errorMessage);
+                chunks.push(String.fromCharCode(Number.parseInt(hex, 16)));
+                index += 5;
+                break;
+            }
+            default: throw new Error(errorMessage);
+        }
+        segmentStart = index;
+    }
+    throw new Error(errorMessage);
+}
+function isWellFormedUnicode(value) {
+    for (let index = 0; index < value.length; index += 1) {
+        const code = value.charCodeAt(index);
+        if (code >= 0xd800 && code <= 0xdbff) {
+            if (index + 1 >= value.length)
+                return false;
+            const next = value.charCodeAt(index + 1);
+            if (next < 0xdc00 || next > 0xdfff)
+                return false;
+            index += 1;
+        }
+        else if (code >= 0xdc00 && code <= 0xdfff) {
+            return false;
+        }
+    }
+    return true;
+}
+function looksLikeJson(value, path) {
+    if (path.toLowerCase().endsWith(".json"))
+        return true;
+    const candidate = value.trimStart().replace(/^\uFEFF/u, "").trimStart();
+    return candidate.startsWith("{") || candidate.startsWith("[") || candidate.startsWith("\"");
+}
+function isJsonWhitespace(code) {
+    return code === 0x20 || code === 0x09 || code === 0x0a || code === 0x0d;
+}
+function isJsonPunctuation(code) {
+    return code === 0x7b || code === 0x7d || code === 0x5b || code === 0x5d
+        || code === 0x2c || code === 0x3a || code === 0x22;
+}
+function assertJsonStringDoesNotContainSecrets(value, exactSecrets, errorMessage) {
+    for (const secret of exactSecrets) {
+        if (secret.length > 0 && value.includes(secret)) {
+            throw new Error(errorMessage);
+        }
+    }
+}

package/dist/session/session.base.d.ts

@@ -1,7 +1,12 @@
-import type { RunOnceDispatchPacket, RunOnceResultPacket, RunnerDispatchEvent } from "./session.types.js";
+import type { HostRuntimeReadinessProbeRequest, HostRuntimeReadinessProbeResult, RunOnceDispatchPacket, RunOnceResultPacket, RunnerDispatchEvent } from "./session.types.js";
+import type { HostRuntimeCapacitySnapshot, HostRuntimeReapOptions, HostRuntimeReapReport } from "../runtime/host-runtime-lease.js";
 export interface SessionEventSink {
     emit(event: RunnerDispatchEvent): Promise<void>;
 }
 export interface SessionService {
     runOnce(dispatch: RunOnceDispatchPacket, sink: SessionEventSink, signal?: AbortSignal): Promise<RunOnceResultPacket>;
+    updateLease?(dispatchAttemptId: string, fencingToken: string, expiresAt: string): Promise<void>;
+    reapHostRuntime?(options: HostRuntimeReapOptions): Promise<HostRuntimeReapReport | null>;
+    runtimeCapacity?(): HostRuntimeCapacitySnapshot | null;
+    probeHostRuntime?(request: HostRuntimeReadinessProbeRequest, signal?: AbortSignal): Promise<HostRuntimeReadinessProbeResult>;
 }

package/dist/session/session.service.d.ts

@@ -1,10 +1,16 @@
 import type { ProviderCliService } from "./provider-cli/provider-cli.base.js";
 import type { SessionEventSink, SessionService } from "./session.base.js";
-import type { RunOnceDispatchPacket, RunOnceResultPacket } from "./session.types.js";
+import type { HostRuntimeReadinessProbeRequest, HostRuntimeReadinessProbeResult, RunOnceDispatchPacket, RunOnceResultPacket } from "./session.types.js";
 import type { WorktreeService } from "../worktree/worktree.base.js";
+import { type HostRuntimeCapacitySnapshot, type HostRuntimeLeaseRuntime, type HostRuntimeReapOptions, type HostRuntimeReapReport } from "../runtime/host-runtime-lease.js";
 export declare class BridgeSessionService implements SessionService {
     private readonly worktrees;
     private readonly providerCli;
-    constructor(worktrees?: WorktreeService, providerCli?: ProviderCliService);
+    private readonly hostRuntime?;
+    constructor(worktrees?: WorktreeService, providerCli?: ProviderCliService, hostRuntime?: HostRuntimeLeaseRuntime | undefined);
+    updateLease(dispatchAttemptId: string, fencingToken: string, expiresAt: string): Promise<void>;
+    reapHostRuntime(options: HostRuntimeReapOptions): Promise<HostRuntimeReapReport | null>;
+    runtimeCapacity(): HostRuntimeCapacitySnapshot | null;
+    probeHostRuntime(request: HostRuntimeReadinessProbeRequest, signal?: AbortSignal): Promise<HostRuntimeReadinessProbeResult>;
     runOnce(dispatch: RunOnceDispatchPacket, sink: SessionEventSink, signal?: AbortSignal): Promise<RunOnceResultPacket>;
 }