@loucompanion/forge-bridge 0.1.4-dev.1ff37038366e → 0.1.4-dev.41da3780c451

package/dist/runtime/attempt-process-supervisor.js

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { ForgeFailureError, sanitizeFailureError } from "../session/session.types.js";
+import { monotonicNowMs } from "../shared/time/monotonic.js";
 const terminalChildStatuses = new Set(["exited", "failed"]);
 const defaultMetadataReadyTimeoutMs = process.platform === "win32" ? 60_000 : 10_000;
 /**
@@ -248,8 +249,8 @@ export class AttemptProcessSupervisor {
         };
     }
     async observeChildReady(record) {
-        const deadline = Date.now() + this.metadataReadyTimeoutMs;
-        while (Date.now() <= deadline) {
+        const deadline = monotonicNowMs() + this.metadataReadyTimeoutMs;
+        while (monotonicNowMs() <= deadline) {
             if (await fileExists(record.metadataPath)) {
                 if (record.status === "starting") {
                     record.status = "running";

package/dist/runtime/host-diagnostics.js

@@ -6,6 +6,7 @@ import { assertCanonicalDirectory } from "./attempt-private-directory.js";
 import { runAttemptArchiveOperation, runAttemptPathOperation } from "./attempt-path-operation.js";
 import { readPinnedSourceDirectory } from "./pinned-source-directory.js";
 import { compactHostAttemptId } from "./host-execution-root.js";
+import { monotonicNowMs } from "../shared/time/monotonic.js";
 const maximumEvidenceBytes = 200 * 1024 * 1024;
 const diagnosticsRetentionDeadlineMs = 30_000;
 const diagnosticsHelperTerminationConfirmationMs = 2_000;
@@ -21,7 +22,7 @@ export async function retainHostDiagnostics(stateRoot, attemptRoot, attemptId, e
     const configuredDeadlineMs = Math.max(1, Math.min(diagnosticsRetentionDeadlineMs, Number.isFinite(requestedDeadlineMs) && (requestedDeadlineMs ?? 0) > 0
         ? Math.floor(requestedDeadlineMs)
         : diagnosticsRetentionDeadlineMs));
-    const retentionDeadline = Date.now() + configuredDeadlineMs;
+    const retentionDeadline = monotonicNowMs() + configuredDeadlineMs;
     const identity = attemptId.replaceAll("-", "").toLowerCase();
     const compactAttemptRoot = path.resolve(attemptOwnerRoot, "a", compactHostAttemptId(attemptId));
     const legacyAttemptRoot = path.resolve(stateRoot, "host-attempts", identity);
@@ -155,7 +156,7 @@ function remainingHelperTiming(retentionDeadline, configuredDeadlineMs) {
     return { operationTimeoutMs, terminationConfirmationMs };
 }
 function remainingRetentionMs(retentionDeadline, configuredDeadlineMs) {
-    const remainingMs = retentionDeadline - Date.now();
+    const remainingMs = retentionDeadline - monotonicNowMs();
     if (remainingMs <= 0)
         throw diagnosticsDeadlineError(configuredDeadlineMs);
     return remainingMs;
@@ -181,7 +182,7 @@ async function runWithinRetentionHelperDeadline(operation, retentionDeadline, co
         return await operation();
     }
     catch (error) {
-        if (Date.now() >= retentionDeadline)
+        if (monotonicNowMs() >= retentionDeadline)
             throw diagnosticsDeadlineError(configuredDeadlineMs);
         throw error;
     }

package/dist/runtime/node-host-runtime-adapter.js

@@ -2,6 +2,7 @@ import path from "node:path";
 import { ForgeFailureError } from "../session/session.types.js";
 import { withAspNetPrebuiltRunArguments } from "./aspnet-runtime-prebuild.js";
 import { hostPortEnvironment, } from "./host-runtime-contract.js";
+import { monotonicNowMs } from "../shared/time/monotonic.js";
 /**
  * Launches an explicitly configured HTTP project command beneath the caller's
  * attempt supervisor. It never shells a command and never promotes a project
@@ -53,12 +54,12 @@ export class NodeHostRuntimeAdapter {
         return { ...launched, request: activeRequest };
     }
     async waitUntilReady(value, request, launcher, signal) {
-        const startedAt = Date.now();
+        const startedAt = monotonicNowMs();
         const hardDeadline = startedAt + this.hardReadinessTimeoutMs;
         let idleDeadline = startedAt + this.readinessTimeoutMs;
         let outputRevision = -1;
         let observedOwnership = "unbound";
-        while (Date.now() <= idleDeadline && Date.now() <= hardDeadline) {
+        while (monotonicNowMs() <= idleDeadline && monotonicNowMs() <= hardDeadline) {
             if (signal?.aborted)
                 throw cancellationError(signal);
             const diagnostics = await launcher.readinessDiagnostics?.(value);
@@ -67,7 +68,7 @@ export class NodeHostRuntimeAdapter {
             }
             if (diagnostics?.outputRevision !== undefined && diagnostics.outputRevision > outputRevision) {
                 outputRevision = diagnostics.outputRevision;
-                idleDeadline = Math.min(hardDeadline, Date.now() + this.readinessTimeoutMs);
+                idleDeadline = Math.min(hardDeadline, monotonicNowMs() + this.readinessTimeoutMs);
             }
             const ownership = await launcher.inspectListener(value, request, signal);
             observedOwnership = ownership;
@@ -85,7 +86,7 @@ export class NodeHostRuntimeAdapter {
         const code = observedOwnership === "owned"
             ? "host_runtime_http_readiness_timeout"
             : "host_runtime_listener_timeout";
-        const reachedHardDeadline = Date.now() >= hardDeadline;
+        const reachedHardDeadline = monotonicNowMs() >= hardDeadline;
         const detail = observedOwnership === "owned"
             ? reachedHardDeadline
                 ? `the supervised process owned its assigned loopback port but HTTP readiness did not succeed within the ${this.hardReadinessTimeoutMs}ms hard limit`

package/dist/sandbox/repository-lock.js

@@ -4,6 +4,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { resolvePathIdentity } from "../shared/path/path.js";
 import { ForgeFailureError } from "../session/session.types.js";
+import { monotonicNowMs } from "../shared/time/monotonic.js";
 const LOCK_HEARTBEAT_INTERVAL_MS = 30_000;
 const LOCK_STALE_AFTER_MS = 2 * 60_000;
 export class RepositoryCoordinatorLock {
@@ -21,7 +22,7 @@ export class RepositoryCoordinatorLock {
         const target = path.join(root, `${key}.lock`);
         const token = randomUUID();
         await fs.mkdir(root, { recursive: true, mode: 0o700 });
-        const started = Date.now();
+        const started = monotonicNowMs();
         while (true) {
             if (signal?.aborted) {
                 throw new ForgeFailureError("sandbox_import_cancelled", "sandbox_import_cancelled: repository coordination was cancelled.", "sandbox");
@@ -44,7 +45,7 @@ export class RepositoryCoordinatorLock {
                     await fs.rm(target, { force: true });
                     continue;
                 }
-                if (Date.now() - started >= this.lockTimeoutMs) {
+                if (monotonicNowMs() - started >= this.lockTimeoutMs) {
                     throw new ForgeFailureError("sandbox_import_unavailable", "sandbox_import_unavailable: repository coordinator lock timed out.", "sandbox", { cause: error });
                 }
                 await abortableDelay(50, signal);

package/dist/sandbox/runtime.js

@@ -12,6 +12,7 @@ import { RepositoryCoordinatorLock } from "./repository-lock.js";
 import { redactText } from "../shared/redaction/redaction.js";
 import { createRuntimeIsolationLease, renewRuntimeIsolationLease, transitionRuntimeIsolationLease, validRuntimeIsolationLease, withRuntimeIsolationResources, } from "../runtime/runtime-isolation-lease.js";
 import { sandboxProviderAuthAdapterFor, sandboxProviderAuthUnavailableMessage } from "./provider-auth/codex.js";
+import { monotonicNowMs } from "../shared/time/monotonic.js";
 const managedLabel = "dev.forge.managed=true";
 const bridgeRuntimeDigestLabel = "dev.forge.bridge-runtime-digest";
 export class DockerSandboxRuntime {
@@ -554,10 +555,10 @@ export class DockerSandboxRuntime {
         const existing = this.builds.get(key);
         if (existing) {
             await sink.emit(event("sandbox_image_cache_miss", `Sandbox image ${key.slice(0, 12)} is being built by another dispatch.`, { cacheKey: key, singleflight: true }));
-            const waitStartedAt = Date.now();
+            const waitStartedAt = monotonicNowMs();
             const built = await existing;
             await sink.emit(event("sandbox_build_singleflight_wait", `Waited for the existing sandbox image build ${key.slice(0, 12)}.`, {
-                durationMs: Date.now() - waitStartedAt,
+                durationMs: Math.round(monotonicNowMs() - waitStartedAt),
                 imageDigest: built.imageDigest
             }));
             return built;
@@ -889,8 +890,8 @@ export class DockerSandboxRuntime {
         await sink.emit(event("sandbox_image_signature_warning", `Image signature enforcement is not configured for adoption-mode image ${image}.`));
     }
     async waitForServiceHealthy(name, signal) {
-        const deadline = Date.now() + 60_000;
-        while (Date.now() < deadline) {
+        const deadline = monotonicNowMs() + 60_000;
+        while (monotonicNowMs() < deadline) {
             if (signal?.aborted)
                 throw new Error(String(signal.reason ?? "sandbox service startup cancelled"));
             const status = (await this.docker(["container", "inspect", name, "--format", "{{.State.Health.Status}}"], 10_000, signal)).stdout.trim();

package/dist/session/managed-attempt-tools.js

@@ -11,6 +11,7 @@ import { ManagedBuildCoordinator } from "./managed-build-coordinator.js";
 import { managedBuildConfiguration, publishManagedBuildReceipt, verifyManagedBuildReceipt, } from "./managed-build-receipt.js";
 import { managedLongTierTimeoutMs, managedMaximumCommandTimeoutMs, managedVerificationTierTimeoutMs, } from "./managed-verification-timeouts.js";
 import { resolveWindowsCommandFromPath, StreamingProviderProcessRunner } from "./provider-cli/provider-cli.process.js";
+import { monotonicNowMs } from "../shared/time/monotonic.js";
 const managedCommandNames = new Set(["forge.run_managed_command", "run_managed_command"]);
 const startManagedCommandNames = new Set(["forge.start_managed_command", "start_managed_command"]);
 const getManagedCommandNames = new Set(["forge.get_managed_command", "get_managed_command"]);
@@ -612,7 +613,7 @@ async function waitManagedCommand(input) {
     const commandId = validatedCommandId(record);
     const requestedWaitTimeoutMs = optionalWaitTimeout(record.wait_timeout_ms);
     const waitTimeoutMs = Math.min(requestedWaitTimeoutMs, maximumSynchronousWaitMs);
-    const deadline = Date.now() + waitTimeoutMs;
+    const deadline = monotonicNowMs() + waitTimeoutMs;
     const receiptPath = managedCommandReceiptPath(requiredAttemptEnvironment("FORGE_LOG_DIR"), commandId);
     const task = managedCommandTasks.get(commandId);
     if (task) {
@@ -623,12 +624,12 @@ async function waitManagedCommand(input) {
         if (result)
             return result;
     }
-    while (Date.now() < deadline) {
+    while (monotonicNowMs() < deadline) {
         const result = await readManagedCommand({ command_id: commandId });
         if (terminalManagedCommandStatuses.has(String(result.structuredContent.status))) {
             return result;
         }
-        await delay(Math.min(managedCommandReceiptPollIntervalMs, Math.max(1, deadline - Date.now())));
+        await delay(Math.min(managedCommandReceiptPollIntervalMs, Math.max(1, deadline - monotonicNowMs())));
     }
     const receipt = await readManagedCommand({ command_id: commandId });
     // Only a running receipt is refreshed on a heartbeat; queued or starting receipts are

package/dist/session/managed-build-coordinator.js

@@ -2,6 +2,7 @@ import { createHash, randomUUID } from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { defaultWorktreeCoordinatorStateRoot } from "../worktree/worktree-paths.js";
+import { monotonicNowMs } from "../shared/time/monotonic.js";
 const heartbeatIntervalMs = 30_000;
 const staleAfterMs = 2 * 60_000;
 const acquisitionTimeoutMs = 2 * 60 * 60_000;
@@ -17,7 +18,7 @@ export class ManagedBuildCoordinator {
         const root = path.join(this.stateRoot, "managed-build-locks");
         const target = path.join(root, `${key}.lock`);
         const token = randomUUID();
-        const startedAt = Date.now();
+        const startedAt = monotonicNowMs();
         let waitingReported = false;
         await fs.mkdir(root, { recursive: true, mode: 0o700 });
         while (true) {
@@ -49,7 +50,7 @@ export class ManagedBuildCoordinator {
                     waitingReported = true;
                     await onWaiting?.();
                 }
-                if (Date.now() - startedAt >= acquisitionTimeoutMs) {
+                if (monotonicNowMs() - startedAt >= acquisitionTimeoutMs) {
                     throw new Error("managed_build_slot_timeout: another build held this worktree for more than two hours.", { cause: error });
                 }
                 await delay(pollIntervalMs);
@@ -58,7 +59,7 @@ export class ManagedBuildCoordinator {
         const heartbeat = setInterval(() => void refreshHeartbeat(target, token), heartbeatIntervalMs);
         heartbeat.unref?.();
         try {
-            return await action(Date.now() - startedAt);
+            return await action(Math.round(monotonicNowMs() - startedAt));
         }
         finally {
             clearInterval(heartbeat);

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

@@ -3,6 +3,12 @@ import type { ProviderCliRunContext } from "./provider-cli.types.js";
 import type { ProviderOutputState } from "./provider-output-state.js";
 import { type ProviderUsage } from "./provider-usage.js";
 export declare function providerProcessEnv(dispatch: RunOnceDispatchPacket, runtimeEnvironment?: Readonly<Record<string, string>>): Readonly<Record<string, string>>;
+/**
+ * Pre-publication validation runs the attempt's own checks, whose E2E fixtures log in to the
+ * brokered attempt database. Unlike the provider's shell, it receives that capability; the
+ * validator redacts it from every command's output.
+ */
+export declare function prePublicationValidationEnv(dispatch: RunOnceDispatchPacket, runtimeEnvironment?: Readonly<Record<string, string>>): Readonly<Record<string, string>>;
 export declare function providerRuntimeEnvironment(runtimeEnvironment?: Readonly<Record<string, string>>): Readonly<Record<string, string>>;
 export declare function providerCredentialEnv(dispatch: RunOnceDispatchPacket): Readonly<Record<string, string>>;
 /**

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

@@ -1,3 +1,4 @@
+import { attemptDatabaseCapabilityEnvironment } from "../../runtime/attempt-database-broker.js";
 import { completionRedactionEnv } from "../phase-completion.js";
 import { addUsage, buildProviderUsageEvent, emptyUsage, hasUsage } from "./provider-usage.js";
 export function providerProcessEnv(dispatch, runtimeEnvironment) {
@@ -12,6 +13,16 @@ export function providerProcessEnv(dispatch, runtimeEnvironment) {
     // Bridge environment, including credentials outside the provider contract.
     return env;
 }
+/**
+ * Pre-publication validation runs the attempt's own checks, whose E2E fixtures log in to the
+ * brokered attempt database. Unlike the provider's shell, it receives that capability; the
+ * validator redacts it from every command's output.
+ */
+export function prePublicationValidationEnv(dispatch, runtimeEnvironment) {
+    const env = providerProcessEnv(dispatch, runtimeEnvironment);
+    const capability = runtimeEnvironment?.[attemptDatabaseCapabilityEnvironment]?.trim();
+    return capability ? { ...env, [attemptDatabaseCapabilityEnvironment]: capability } : env;
+}
 export function providerRuntimeEnvironment(runtimeEnvironment) {
     if (!runtimeEnvironment)
         return {};

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

@@ -10,7 +10,7 @@ import { cleanupCompletionTools, commitWorktreeChanges, completionPhaseFromArtif
 import { DeterministicProviderCliService } from "./provider-cli.deterministic.js";
 import { buildArchitectPrompt, buildConflictResolvePrompt, buildDebugCyclePrompt, buildDevelopCyclePrompt, buildDraftPrompt, buildDraftSpec, buildImplementationPrompt, buildProviderCliPrompt, buildProviderCliCommand, durableDraftInput, buildPullRequestCheckRepairPrompt, buildPullRequestCommentsPrompt, buildQaPrompt, formatProviderCliCommandForCheckpoint, isDecomposeDraftDispatch, isPullRequestCheckRepairDispatch, isPullRequestCommentsDispatch } from "./provider-cli.prompts.js";
 import { isTransientCodexProviderNotFoundFailure, recoveringProviderProcessRunner, StreamingProviderProcessRunner } from "./provider-cli.process.js";
-import { emitProviderUsageEvent, providerProcessEnv } from "./provider-cli.runtime.js";
+import { emitProviderUsageEvent, prePublicationValidationEnv, providerProcessEnv } from "./provider-cli.runtime.js";
 import { clip, createProviderOutputState, parseJsonLine } from "./provider-output-state.js";
 import { writeCiRepairReadinessManifest } from "./ci-repair-readiness.js";
 import { assertRepairHeadEpoch } from "./provider-cli.repair-epoch.js";
@@ -1489,9 +1489,10 @@ export class ProcessBackedProviderCliService {
         const { dispatch, worktree } = context;
         const processRunner = recoveringProviderProcessRunner(context.processRunner ?? this.processRunner);
         const environment = providerProcessEnv(dispatch, repairEnvironment);
+        const validationEnvironment = prePublicationValidationEnv(dispatch, repairEnvironment);
         for (let repairTurn = 0;; repairTurn += 1) {
             try {
-                await this.prePublicationValidator.validate(worktree.worktreePath, validationProfile, publicationCapabilities(context, repairEnvironment), context.emit, context.signal, prePublicationExecution(context, environment, this.processRunner, preparedHeadSha));
+                await this.prePublicationValidator.validate(worktree.worktreePath, validationProfile, publicationCapabilities(context, repairEnvironment), context.emit, context.signal, prePublicationExecution(context, validationEnvironment, this.processRunner, preparedHeadSha));
                 if (repairTurn > 0) {
                     await context.emit({
                         role: "runner",

package/dist/shared/process/host-process-recovery.js

@@ -1,4 +1,5 @@
 import { captureHostProcessIdentity } from "./host-process-supervisor.js";
+import { monotonicNowMs } from "../time/monotonic.js";
 /** Exact, birth-marker-fenced recovery for a process tree left by an old bridge. */
 export class ExactHostProcessRecovery {
     platform;
@@ -71,8 +72,8 @@ function signalExactProcessGroup(pid, signal) {
     }
 }
 async function waitForExit(pid, timeoutMs) {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline && processExists(pid)) {
+    const deadline = monotonicNowMs() + timeoutMs;
+    while (monotonicNowMs() < deadline && processExists(pid)) {
         await new Promise(resolve => setTimeout(resolve, 25));
     }
 }

package/dist/shared/process/host-process-supervisor.js

@@ -3,6 +3,7 @@ import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { monotonicNowMs } from "../time/monotonic.js";
 const windowsJobSupervisorPath = fileURLToPath(new URL("../../../runtime/windows-job-supervisor.ps1", import.meta.url));
 export function resolveHostProcessSupervisedLaunch(request, resolvedCommand, resolvedArgs, platform = process.platform) {
     const env = request.env;
@@ -277,8 +278,8 @@ function unixProcessGroupExists(processGroupId) {
     }
 }
 async function waitForUnixProcessGroupExit(processGroupId, timeoutMs) {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline && unixProcessGroupExists(processGroupId)) {
+    const deadline = monotonicNowMs() + timeoutMs;
+    while (monotonicNowMs() < deadline && unixProcessGroupExists(processGroupId)) {
         await new Promise(resolve => setTimeout(resolve, 25));
     }
 }
@@ -307,8 +308,8 @@ function processExists(pid) {
     }
 }
 async function waitForExactProcessExit(pid, identity, timeoutMs, platform) {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline && exactProcessExists(pid, identity, platform)) {
+    const deadline = monotonicNowMs() + timeoutMs;
+    while (monotonicNowMs() < deadline && exactProcessExists(pid, identity, platform)) {
         await new Promise(resolve => setTimeout(resolve, 25));
     }
 }

package/dist/shared/time/monotonic.d.ts

@@ -0,0 +1 @@
+export declare function monotonicNowMs(): number;

package/dist/shared/time/monotonic.js

@@ -0,0 +1,8 @@
+// Elapsed time and local deadlines use the monotonic clock. The wall clock can step:
+// a WSL VM's clock is corrected in multi-second jumps, which would end a local wait
+// early or count time that never passed. Timestamps that are persisted or compared
+// across processes (lease expiry, receipts, file mtimes) stay on the wall clock.
+// Read through the global so test fake timers that replace `performance` apply.
+export function monotonicNowMs() {
+    return performance.now();
+}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const forgeBridgeVersion = "0.1.4-dev.1ff37038366e";
+export declare const forgeBridgeVersion = "0.1.4-dev.41da3780c451";

package/dist/version.js

@@ -1 +1 @@
-export const forgeBridgeVersion = "0.1.4-dev.1ff37038366e";
+export const forgeBridgeVersion = "0.1.4-dev.41da3780c451";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loucompanion/forge-bridge",
-  "version": "0.1.4-dev.1ff37038366e",
+  "version": "0.1.4-dev.41da3780c451",
   "description": "Forge runner bridge CLI for connecting local developer machines to Forge dispatch.",
   "license": "UNLICENSED",
   "type": "module",