@loucompanion/forge-bridge 0.1.3-dev.d1ca67076aa9 → 0.1.3-dev.e7b62d8fdd33

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

@@ -1,13 +1,19 @@
 import type { RunOnceDispatchPacket, RunnerDispatchArtifact, RunnerDispatchEvent, RunnerDispatchSpec } from "../session.types.js";
 import type { WorktreeHandle } from "../../worktree/worktree.types.js";
+import type { ProviderProcessRunner } from "./provider-cli.process.js";
 export interface ProviderCliRunContext {
     readonly dispatch: RunOnceDispatchPacket;
     readonly worktree: WorktreeHandle;
+    readonly runtimeEnvironment?: Readonly<Record<string, string>>;
+    readonly processRunner?: ProviderProcessRunner;
     readonly signal?: AbortSignal;
     emit(event: RunnerDispatchEvent): Promise<void>;
 }
 export interface ProviderCliDraftContext {
     readonly dispatch: RunOnceDispatchPacket;
+    readonly worktree: WorktreeHandle;
+    readonly runtimeEnvironment?: Readonly<Record<string, string>>;
+    readonly processRunner?: ProviderProcessRunner;
     readonly signal?: AbortSignal;
     emit(event: RunnerDispatchEvent): Promise<void>;
 }

package/dist/session/provider-cli/provider-output-state.d.ts

@@ -5,6 +5,8 @@ export declare function clip(value: string, maxLength: number): string;
 export interface ProviderOutputState {
     readonly sessionLabel: string | null;
     finalMessage: string | null;
+    /** True only while the provider has reported a tool/command start without a matching completion. */
+    readonly hasActiveToolCall: boolean;
     /** Accumulated provider-reported token usage for this run, or null when none was reported. */
     readonly usage: ProviderUsage | null;
     consume(line: string): readonly RunnerDispatchEvent[];

package/dist/session/provider-cli/provider-output-state.js

@@ -25,12 +25,16 @@ class CursorStreamJsonState {
     finalMessage = null;
     emittedSession = false;
     accumulatedUsage = null;
+    activeToolCallCount = 0;
     get sessionLabel() {
         return this.sessionId ? `session ${this.sessionId}` : null;
     }
     get usage() {
         return this.accumulatedUsage;
     }
+    get hasActiveToolCall() {
+        return this.activeToolCallCount > 0;
+    }
     consume(line) {
         const event = parseJsonLine(line);
         if (!event) {
@@ -45,7 +49,8 @@ class CursorStreamJsonState {
                         role: "runner",
                         kind: "checkpoint",
                         content: `Cursor session started: ${this.sessionId}.`,
-                        eventType: "provider_thread_started"
+                        eventType: "provider_thread_started",
+                        data: JSON.stringify({ threadId: this.sessionId })
                     }];
             }
         }
@@ -65,6 +70,7 @@ class CursorStreamJsonState {
             const subtype = stringField(event, "subtype");
             const toolCall = objectField(event, "tool_call");
             if (subtype === "started") {
+                this.activeToolCallCount += 1;
                 const summary = formatCursorToolCallStarted(toolCall);
                 if (summary) {
                     return [{
@@ -76,6 +82,7 @@ class CursorStreamJsonState {
                 }
             }
             if (subtype === "completed") {
+                this.activeToolCallCount = Math.max(0, this.activeToolCallCount - 1);
                 const completed = formatCursorToolCallCompleted(toolCall);
                 if (completed) {
                     return [{
@@ -110,13 +117,19 @@ class CursorStreamJsonState {
         if (Object.keys(usage).length === 0 && durationMs === 0) {
             return;
         }
+        const uncachedInputTokens = readUsageNumber(usage, "inputTokens");
+        const cacheReadTokens = readUsageNumber(usage, "cacheReadTokens");
+        const cacheCreationTokens = readUsageNumber(usage, "cacheWriteTokens");
         this.accumulatedUsage = addUsage(this.accumulatedUsage ?? emptyUsage("provider_reported"), {
-            inputTokens: readUsageNumber(usage, "inputTokens"),
+            inputTokens: uncachedInputTokens + cacheReadTokens + cacheCreationTokens,
+            uncachedInputTokens,
             outputTokens: readUsageNumber(usage, "outputTokens"),
-            cacheReadTokens: readUsageNumber(usage, "cacheReadTokens"),
-            cacheCreationTokens: readUsageNumber(usage, "cacheWriteTokens"),
+            cacheReadTokens,
+            cacheCreationTokens,
             providerDurationMs: durationMs > 0 ? durationMs : null,
-            source: "provider_reported"
+            source: "provider_reported",
+            inputTokenSemantics: "excludes_cache_tokens",
+            rawUsage: [{ provider: "cursor", usage }]
         });
     }
 }
@@ -224,18 +237,23 @@ class CodexJsonState {
     finalMessage = null;
     emittedThread = false;
     accumulatedUsage = null;
+    activeToolCallCount = 0;
     get sessionLabel() {
         return this.threadId ? `thread ${this.threadId}` : null;
     }
     get usage() {
         return this.accumulatedUsage;
     }
+    get hasActiveToolCall() {
+        return this.activeToolCallCount > 0;
+    }
     consume(line) {
         const event = parseJsonLine(line);
         if (!event) {
             return [];
         }
         const type = stringField(event, "type") ?? "";
+        this.trackToolActivity(type, event);
         if (type === "thread.started") {
             this.threadId = stringField(event, "thread_id");
             if (this.threadId && !this.emittedThread) {
@@ -244,7 +262,8 @@ class CodexJsonState {
                         role: "runner",
                         kind: "checkpoint",
                         content: `Codex thread started: ${this.threadId}.`,
-                        eventType: "provider_thread_started"
+                        eventType: "provider_thread_started",
+                        data: JSON.stringify({ threadId: this.threadId })
                     }];
             }
         }
@@ -265,7 +284,7 @@ class CodexJsonState {
                     eventType: "provider_cli_error"
                 }];
         }
-        if (type === "item.completed" || type === "item.updated") {
+        if (type === "item.started" || type === "item.completed" || type === "item.updated") {
             const item = objectField(event, "item");
             const itemType = stringField(item, "type");
             if (itemType === "agent_message") {
@@ -287,7 +306,7 @@ class CodexJsonState {
                     return [{
                             role: "worker",
                             kind: "checkpoint",
-                            content: `Codex command ${status || "completed"}: ${clip(command, 500)}`,
+                            content: `Codex command ${status || (type === "item.started" ? "started" : "completed")}: ${clip(command, 500)}`,
                             eventType: "provider_command"
                         }];
                 }
@@ -299,17 +318,39 @@ class CodexJsonState {
         }
         return [];
     }
+    trackToolActivity(type, event) {
+        if (type !== "item.started" && type !== "item.completed") {
+            return;
+        }
+        const item = objectField(event, "item");
+        const itemType = (stringField(item, "type") ?? "").toLowerCase();
+        const toolName = mcpToolName(item);
+        const isTool = itemType === "command_execution"
+            || itemType.includes("mcp")
+            || Boolean(toolName);
+        if (!isTool) {
+            return;
+        }
+        this.activeToolCallCount = type === "item.started"
+            ? this.activeToolCallCount + 1
+            : Math.max(0, this.activeToolCallCount - 1);
+    }
     accumulateUsage(event) {
         const usage = objectField(event, "usage");
         if (Object.keys(usage).length === 0) {
             return;
         }
+        const inputTokens = readUsageNumber(usage, "input_tokens");
+        const cacheReadTokens = readUsageNumber(usage, "cached_input_tokens");
         this.accumulatedUsage = addUsage(this.accumulatedUsage ?? emptyUsage("provider_reported"), {
-            inputTokens: readUsageNumber(usage, "input_tokens"),
+            inputTokens,
+            uncachedInputTokens: Math.max(0, inputTokens - cacheReadTokens),
             outputTokens: readUsageNumber(usage, "output_tokens"),
-            cacheReadTokens: readUsageNumber(usage, "cached_input_tokens"),
+            cacheReadTokens,
             reasoningOutputTokens: readUsageNumber(usage, "reasoning_output_tokens"),
-            source: "provider_reported"
+            source: "provider_reported",
+            inputTokenSemantics: "includes_cached_input",
+            rawUsage: [{ provider: "codex", usage }]
         });
     }
 }
@@ -397,11 +438,45 @@ function mcpErrorSummary(item) {
     if (direct) {
         return clip(direct, 600);
     }
-    const error = objectField(item, "error");
-    return stringField(error, "message")
-        ?? stringField(error, "summary")
-        ?? stringField(objectField(item, "result"), "error")
-        ?? null;
+    const messages = uniqueErrorMessages([
+        item.error,
+        item.result,
+        item.content,
+    ]);
+    return messages.length > 0 ? clip(messages.join(" Caused by: "), 600) : null;
+}
+function uniqueErrorMessages(values) {
+    const messages = [];
+    const seenMessages = new Set();
+    const seenObjects = new Set();
+    const visit = (value, depth) => {
+        if (depth > 8 || value === null || value === undefined)
+            return;
+        if (typeof value === "string") {
+            const message = value.trim();
+            if (message.length > 0 && !seenMessages.has(message)) {
+                seenMessages.add(message);
+                messages.push(message);
+            }
+            return;
+        }
+        if (typeof value !== "object" || seenObjects.has(value))
+            return;
+        seenObjects.add(value);
+        if (Array.isArray(value)) {
+            for (const entry of value)
+                visit(entry, depth + 1);
+            return;
+        }
+        const record = value;
+        for (const key of ["message", "summary", "error", "cause", "data", "details", "result", "content"]) {
+            if (key in record)
+                visit(record[key], depth + 1);
+        }
+    };
+    for (const value of values)
+        visit(value, 0);
+    return messages;
 }
 function safeProviderMcpData(item, serverName, toolName, status) {
     const elapsedMs = numericField(item, "elapsed_ms") ?? numericField(item, "duration_ms");

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,38 @@
+import { redactSecrets } from "../shared/redaction/redaction.js";
+const integrityProtectedEventDataTypes = new Set(["sandbox_started"]);
+export function redactRunnerDispatchEvent(event, exactSecrets = []) {
+    if (!event.data || !integrityProtectedEventDataTypes.has(event.eventType)) {
+        return redactSecrets(event, exactSecrets);
+    }
+    // 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.
+    const { data, ...transcript } = event;
+    return {
+        ...redactSecrets(transcript, exactSecrets),
+        data,
+    };
+}
+export function redactRunOnceResultPacket(result, exactSecrets = []) {
+    const { events, artifact, artifacts, ...payload } = result;
+    return {
+        ...redactSecrets(payload, exactSecrets),
+        ...(artifact !== undefined
+            ? { artifact: artifact === null ? null : redactArtifact(artifact, exactSecrets) }
+            : {}),
+        ...(artifacts !== undefined
+            ? { artifacts: artifacts === null ? null : artifacts.map(item => redactArtifact(item, exactSecrets)) }
+            : {}),
+        events: events.map(event => redactRunnerDispatchEvent(event, exactSecrets)),
+    };
+}
+function redactArtifact(artifact, exactSecrets) {
+    const { sidecars, ...payload } = artifact;
+    return {
+        ...redactSecrets(payload, exactSecrets),
+        // These bytes already passed the QA path/hash/size checks. The generic
+        // redactor strips contentBase64 fields and must not corrupt the payload.
+        ...(sidecars !== undefined ? { sidecars } : {}),
+    };
+}

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>;
 }