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

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) {
@@ -65,6 +69,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 +81,7 @@ class CursorStreamJsonState {
                 }
             }
             if (subtype === "completed") {
+                this.activeToolCallCount = Math.max(0, this.activeToolCallCount - 1);
                 const completed = formatCursorToolCallCompleted(toolCall);
                 if (completed) {
                     return [{
@@ -224,18 +230,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) {
@@ -265,7 +276,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 +298,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,6 +310,23 @@ 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) {

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,23 @@
+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, ...payload } = result;
+    return {
+        ...redactSecrets(payload, exactSecrets),
+        events: events.map(event => redactRunnerDispatchEvent(event, exactSecrets)),
+    };
+}

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