@moretea-labs/forge 1.7.2 → 1.8.0

package/src/runtime/standalone-recovery/mcp-server.ts

@@ -0,0 +1,243 @@
+import { randomUUID } from 'crypto';
+import type { IncomingMessage, ServerResponse } from 'http';
+import { Server, type Tool } from '@modelcontextprotocol/server';
+import { NodeStreamableHTTPServerTransport } from '@modelcontextprotocol/node';
+import { McpSessionRegistry, type McpSessionRoute, type McpSessionSnapshot } from '../../../adapters/mcp/transports/session-registry';
+import { FORGE_VERSION } from '../../version';
+
+export const RECOVERY_MCP_SESSION_ROUTE: McpSessionRoute = '/recovery/mcp';
+const RECOVERY_MCP_PRINCIPAL_ID = 'standalone-recovery-oauth-client';
+const RECOVERY_MCP_CONNECTION_ID = 'forge-standalone-recovery';
+
+export interface RecoveryMcpRequestContext {
+  remoteAddress: string;
+}
+
+export interface RecoveryMcpSessionServerOptions {
+  tools: readonly Tool[];
+  dispatchTool(name: string, args: Record<string, unknown>, context: RecoveryMcpRequestContext): Promise<unknown>;
+}
+
+type RecoveryMcpSessionContext = RecoveryMcpRequestContext;
+type RecoveryMcpRegistry = McpSessionRegistry<NodeStreamableHTTPServerTransport, RecoveryMcpSessionContext>;
+
+function sessionId(request: IncomingMessage): string | undefined {
+  const value = request.headers['mcp-session-id'];
+  return Array.isArray(value) ? value[0] : value;
+}
+
+function isInitialize(body: unknown): boolean {
+  return Boolean(body && typeof body === 'object' && !Array.isArray(body) && (body as { method?: unknown }).method === 'initialize');
+}
+
+function initializeClientIdentity(body: unknown): string {
+  if (!body || typeof body !== 'object' || Array.isArray(body)) return 'unknown-client';
+  const params = (body as { params?: unknown }).params;
+  if (!params || typeof params !== 'object' || Array.isArray(params)) return 'unknown-client';
+  const clientInfo = (params as { clientInfo?: unknown }).clientInfo;
+  if (!clientInfo || typeof clientInfo !== 'object' || Array.isArray(clientInfo)) return 'unknown-client';
+  const name = typeof (clientInfo as { name?: unknown }).name === 'string' ? (clientInfo as { name: string }).name.trim() : 'unknown';
+  const version = typeof (clientInfo as { version?: unknown }).version === 'string' ? (clientInfo as { version: string }).version.trim() : 'unknown';
+  return `${name || 'unknown'}/${version || 'unknown'}`.slice(0, 200);
+}
+
+function sendSessionLookupError(response: ServerResponse, id: string | undefined): void {
+  const missing = !id?.trim();
+  response.statusCode = missing ? 400 : 404;
+  response.setHeader('content-type', 'application/json; charset=utf-8');
+  response.setHeader('cache-control', 'no-store');
+  response.setHeader('Mcp-Session-Reset', 'reinitialize');
+  response.setHeader('x-forge-session-reset', 'reinitialize');
+  response.end(JSON.stringify(missing ? {
+    error: 'missing_session',
+    code: 'MCP_SESSION_REQUIRED',
+    message: 'Mcp-Session-Id header is required for this request.',
+    recoverable: true,
+    action: 'reinitialize',
+  } : {
+    error: 'session_not_found',
+    code: 'MCP_SESSION_EXPIRED',
+    message: 'MCP session not found or expired; initialize a new session.',
+    recoverable: true,
+    action: 'reinitialize',
+  }));
+}
+
+export class RecoveryMcpSessionServer {
+  private readonly registry: RecoveryMcpRegistry;
+
+  constructor(private readonly options: RecoveryMcpSessionServerOptions) {
+    this.registry = new McpSessionRegistry<NodeStreamableHTTPServerTransport, RecoveryMcpSessionContext>({
+      maximumSessions: 16,
+      maximumSessionsPerPrincipal: 16,
+    });
+  }
+
+  snapshot(): McpSessionSnapshot {
+    return this.registry.snapshot();
+  }
+
+  async close(): Promise<void> {
+    await this.registry.closeAll('shutdown');
+  }
+
+  async handle(request: IncomingMessage, response: ServerResponse, body?: unknown): Promise<void> {
+    await this.registry.prune();
+    if (request.method === 'POST') {
+      await this.handlePost(request, response, body);
+      return;
+    }
+    if (request.method === 'GET') {
+      await this.handleGet(request, response);
+      return;
+    }
+    if (request.method === 'DELETE') {
+      await this.handleDelete(request, response);
+      return;
+    }
+    response.statusCode = 405;
+    response.end();
+  }
+
+  private createServer(context: RecoveryMcpSessionContext): Server {
+    const server = new Server(
+      { name: 'forge-standalone-recovery', version: FORGE_VERSION },
+      { capabilities: { tools: {} } },
+    );
+    server.setRequestHandler('tools/list', async () => ({ tools: [...this.options.tools] }));
+    server.setRequestHandler('tools/call', async (request) => {
+      const name = request.params.name;
+      const args = request.params.arguments && typeof request.params.arguments === 'object' && !Array.isArray(request.params.arguments)
+        ? request.params.arguments as Record<string, unknown>
+        : {};
+      try {
+        const payload = await this.options.dispatchTool(name, args, context);
+        const structuredContent = payload && typeof payload === 'object' && !Array.isArray(payload)
+          ? payload as Record<string, unknown>
+          : { value: payload };
+        return {
+          content: [{ type: 'text' as const, text: JSON.stringify(payload) }],
+          structuredContent,
+        };
+      } catch (error) {
+        return {
+          isError: true,
+          content: [{ type: 'text' as const, text: error instanceof Error ? error.message : 'Recovery request rejected' }],
+        };
+      }
+    });
+    return server;
+  }
+
+  private async handlePost(request: IncomingMessage, response: ServerResponse, body: unknown): Promise<void> {
+    const currentSessionId = sessionId(request);
+    if (isInitialize(body)) {
+      if (currentSessionId) {
+        response.setHeader('Mcp-Session-Reset', 'reinitialized');
+        response.setHeader('x-forge-session-reset', 'reinitialized');
+      }
+      const reservationId = await this.registry.reserveForInitialize({
+        principalId: RECOVERY_MCP_PRINCIPAL_ID,
+        connectionId: RECOVERY_MCP_CONNECTION_ID,
+        route: RECOVERY_MCP_SESSION_ROUTE,
+        ...(currentSessionId ? { supersedeSessionId: currentSessionId } : {}),
+      });
+      if (!reservationId) {
+        response.statusCode = 503;
+        response.setHeader('retry-after', '1');
+        response.setHeader('content-type', 'application/json; charset=utf-8');
+        response.end(JSON.stringify({
+          error: 'session_capacity',
+          code: 'MCP_SESSION_CAPACITY',
+          recoverable: true,
+          retryable: true,
+          action: 'retry',
+        }));
+        return;
+      }
+      const context: RecoveryMcpSessionContext = { remoteAddress: request.socket.remoteAddress ?? 'unknown' };
+      let transport: NodeStreamableHTTPServerTransport | undefined;
+      let initializedSessionId: string | undefined;
+      try {
+        transport = new NodeStreamableHTTPServerTransport({
+          sessionIdGenerator: () => randomUUID(),
+          onsessioninitialized: (newSessionId: string): void => {
+            this.registry.commitInitialize(reservationId, {
+              sessionId: newSessionId,
+              transport: transport!,
+              toolContext: context,
+              route: RECOVERY_MCP_SESSION_ROUTE,
+              principalId: RECOVERY_MCP_PRINCIPAL_ID,
+              connectionId: RECOVERY_MCP_CONNECTION_ID,
+              clientIdentity: initializeClientIdentity(body),
+            });
+            initializedSessionId = newSessionId;
+          },
+        });
+        transport.onclose = () => {
+          if (transport?.sessionId) this.registry.detach(transport.sessionId);
+        };
+        const server = this.createServer(context);
+        await server.connect(transport);
+        await transport.handleRequest(request, response, body);
+      } finally {
+        if (initializedSessionId) this.registry.endPost(initializedSessionId);
+        this.registry.releaseInitialize(reservationId);
+        if (!transport?.sessionId) await transport?.close().catch(() => undefined);
+      }
+      return;
+    }
+
+    if (!currentSessionId) {
+      sendSessionLookupError(response, currentSessionId);
+      return;
+    }
+    const managed = this.registry.get(currentSessionId);
+    if (!managed || managed.route !== RECOVERY_MCP_SESSION_ROUTE || managed.principalId !== RECOVERY_MCP_PRINCIPAL_ID) {
+      sendSessionLookupError(response, currentSessionId);
+      return;
+    }
+    this.registry.beginPost(currentSessionId);
+    try {
+      await managed.transport.handleRequest(request, response, body);
+    } finally {
+      this.registry.endPost(currentSessionId);
+    }
+  }
+
+  private async handleGet(request: IncomingMessage, response: ServerResponse): Promise<void> {
+    const currentSessionId = sessionId(request);
+    const managed = currentSessionId ? this.registry.get(currentSessionId) : undefined;
+    if (!managed || managed.route !== RECOVERY_MCP_SESSION_ROUTE || managed.principalId !== RECOVERY_MCP_PRINCIPAL_ID) {
+      sendSessionLookupError(response, currentSessionId);
+      return;
+    }
+    this.registry.beginStream(currentSessionId!);
+    let released = false;
+    const release = (): void => {
+      if (released) return;
+      released = true;
+      this.registry.endStream(currentSessionId!);
+    };
+    request.once('aborted', release);
+    response.once('close', release);
+    try {
+      await managed.transport.handleRequest(request, response);
+    } catch (error) {
+      release();
+      throw error;
+    }
+  }
+
+  private async handleDelete(request: IncomingMessage, response: ServerResponse): Promise<void> {
+    const currentSessionId = sessionId(request);
+    const managed = currentSessionId ? this.registry.get(currentSessionId) : undefined;
+    if (!managed || managed.route !== RECOVERY_MCP_SESSION_ROUTE || managed.principalId !== RECOVERY_MCP_PRINCIPAL_ID) {
+      sendSessionLookupError(response, currentSessionId);
+      return;
+    }
+    this.registry.setPendingCloseReason(currentSessionId!, 'client_delete');
+    await managed.transport.handleRequest(request, response);
+    if (this.registry.get(currentSessionId!)) await this.registry.close(currentSessionId!, 'client_delete');
+  }
+}

package/src/runtime/standalone-recovery/mutation-identity-contract.ts

@@ -0,0 +1,21 @@
+/** Canonical external mutation identity contract for Standalone Recovery.
+ *
+ * Both the runtime fencing implementation and the MCP tool schema derive from
+ * this single authority. Keep target-identity field names and validation shape
+ * here so an upgraded Recovery cannot require fields that its own connector
+ * schema forgot to expose.
+ */
+export const RECOVERY_MUTATION_IDENTITY_CONTRACT = {
+  expected_host: { type: 'string', minLength: 1, maxLength: 255 },
+  expected_platform: { type: 'string', minLength: 1, maxLength: 64 },
+  expected_controller_home: { type: 'string', minLength: 1, maxLength: 2048 },
+  expected_recovery_release: { type: 'string', minLength: 1, maxLength: 256 },
+  expected_target_runtime: { type: 'string', minLength: 1, maxLength: 1024 },
+} as const;
+
+export const RECOVERY_MUTATION_IDENTITY_FIELDS = Object.freeze(
+  Object.keys(RECOVERY_MUTATION_IDENTITY_CONTRACT),
+) as readonly (keyof typeof RECOVERY_MUTATION_IDENTITY_CONTRACT)[];
+
+export type RecoveryMutationIdentityField = (typeof RECOVERY_MUTATION_IDENTITY_FIELDS)[number];
+export type RecoveryMutationIdentityArguments = Record<RecoveryMutationIdentityField, string>;

package/src/runtime/standalone-recovery/operation-lock.ts

@@ -0,0 +1,160 @@
+import { randomUUID } from 'crypto';
+import { spawnSync } from 'child_process';
+import { closeSync, mkdirSync, openSync, readFileSync, realpathSync, rmSync, writeFileSync } from 'fs';
+import { dirname, join, resolve } from 'path';
+import { isProcessAlive } from '../shared/process-tree';
+
+export interface RecoveryOperationLockRecord {
+  schemaVersion?: 1;
+  pid: number;
+  instanceId: string;
+  processStartTime?: string;
+  acquiredAt: string;
+  action?: string;
+  requestId?: string;
+}
+
+export interface RecoveryOperationLockHandle {
+  path: string;
+  record: RecoveryOperationLockRecord;
+  close: () => void;
+}
+
+export type RecoveryOperationLockAttempt =
+  | { acquired: true; handle: RecoveryOperationLockHandle }
+  | { acquired: false; owner: RecoveryOperationLockRecord };
+
+function processStartTime(pid: number): string | undefined {
+  const result = spawnSync('/bin/ps', ['-o', 'lstart=', '-p', String(pid)], {
+    encoding: 'utf8',
+    timeout: 2_000,
+    maxBuffer: 4_096,
+  });
+  if (result.status !== 0 || typeof result.stdout !== 'string') return undefined;
+  return result.stdout.trim() || undefined;
+}
+
+function readRecoveryOperationLockPath(path: string): RecoveryOperationLockRecord | undefined {
+  let raw: string;
+  try {
+    raw = readFileSync(path, 'utf8');
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return undefined;
+    throw error;
+  }
+  try {
+    const parsed = JSON.parse(raw) as RecoveryOperationLockRecord;
+    if (!Number.isInteger(parsed.pid) || parsed.pid <= 0) return undefined;
+    if (typeof parsed.instanceId !== 'string' || !parsed.instanceId.trim()) return undefined;
+    if (typeof parsed.acquiredAt !== 'string' || !parsed.acquiredAt.trim()) return undefined;
+    return parsed;
+  } catch {
+    return undefined;
+  }
+}
+
+export function recoveryOperationLockPath(controllerHome: string): string {
+  const resolved = resolve(controllerHome);
+  let canonical = resolved;
+  try {
+    canonical = realpathSync(resolved);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+  }
+  return join(canonical, 'recovery', 'locks', 'operation.lock');
+}
+
+export function readRecoveryOperationLock(controllerHome: string): RecoveryOperationLockRecord | undefined {
+  return readRecoveryOperationLockPath(recoveryOperationLockPath(controllerHome));
+}
+
+export function recoveryOperationLockOwnerAlive(lock: RecoveryOperationLockRecord): boolean {
+  if (!isProcessAlive(lock.pid)) return false;
+  if (!lock.processStartTime) return true;
+  const observed = processStartTime(lock.pid);
+  return observed === undefined || observed === lock.processStartTime;
+}
+
+export function acquireRecoveryOperationLock(input: {
+  controllerHome: string;
+  action: string;
+  requestId?: string;
+  instanceIdPrefix?: string;
+}, dependencies: {
+  writeRecord?: (fd: number, content: string) => void;
+} = {}): RecoveryOperationLockAttempt {
+  const path = recoveryOperationLockPath(input.controllerHome);
+  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  const instanceId = `${input.instanceIdPrefix ?? 'recovery-operation-'}${randomUUID()}`;
+  const requestId = input.requestId?.trim() || `internal:${input.action}:${instanceId}`;
+  const record: RecoveryOperationLockRecord = {
+    schemaVersion: 1,
+    pid: process.pid,
+    instanceId,
+    processStartTime: processStartTime(process.pid),
+    acquiredAt: new Date().toISOString(),
+    action: input.action,
+    requestId,
+  };
+
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    let fd: number | undefined;
+    try {
+      try {
+        fd = openSync(path, 'wx', 0o600);
+        try {
+          (dependencies.writeRecord ?? ((targetFd: number, content: string) => writeFileSync(targetFd, content)))(fd, JSON.stringify(record));
+        } catch (error) {
+          // O_EXCL proved this process created this exact path. A partial or failed
+          // owner-record write must never leave an unreadable lock that poisons
+          // every later Recovery/certification attempt.
+          try { rmSync(path, { force: true }); } finally {
+            try { closeSync(fd); } catch { /* best effort */ }
+            fd = undefined;
+          }
+          throw error;
+        }
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error;
+        const existing = readRecoveryOperationLockPath(path);
+        if (!existing) throw new Error('RECOVERY_OPERATION_LOCK_UNCERTAIN');
+        if (recoveryOperationLockOwnerAlive(existing)) return { acquired: false, owner: existing };
+        const latest = readRecoveryOperationLockPath(path);
+        if (!latest || latest.instanceId !== existing.instanceId) {
+          if (attempt === 1) {
+            if (latest && recoveryOperationLockOwnerAlive(latest)) return { acquired: false, owner: latest };
+            throw new Error('RECOVERY_OPERATION_LOCK_RACE');
+          }
+          continue;
+        }
+        if (recoveryOperationLockOwnerAlive(latest)) return { acquired: false, owner: latest };
+        try { writeFileSync(`${path}.stale-${Date.now()}-${existing.instanceId}`, readFileSync(path)); } catch { /* evidence best effort */ }
+        rmSync(path, { force: true });
+        continue;
+      }
+
+      if (fd === undefined) throw new Error('RECOVERY_OPERATION_LOCK_BUSY');
+      let closed = false;
+      return {
+        acquired: true,
+        handle: {
+          path,
+          record,
+          close: () => {
+            if (closed) return;
+            closed = true;
+            closeSync(fd!);
+            const current = readRecoveryOperationLockPath(path);
+            if (current?.instanceId === instanceId) rmSync(path, { force: true });
+          },
+        },
+      };
+    } catch (error) {
+      if (fd !== undefined) {
+        try { closeSync(fd); } catch { /* best effort */ }
+      }
+      throw error;
+    }
+  }
+  throw new Error('RECOVERY_OPERATION_LOCK_BUSY');
+}

package/src/runtime/standalone-recovery/performance.ts

@@ -0,0 +1,135 @@
+import { spawnSync } from 'node:child_process';
+
+/** Release acceptance evidence, never a readiness/liveness or watchdog input. */
+export interface RuntimePerformanceIdentity {
+  releaseId: string;
+  authorityRevision: number;
+  runtimeInstanceId: string;
+  pid: number;
+  startedAt: string;
+}
+
+export interface RuntimePerformanceEvidence extends RuntimePerformanceIdentity {
+  policy: 'idle-cpu-v1';
+  measuredFrom: string;
+  measuredUntil: string;
+  warmupMs: number;
+  durationMs: number;
+  sampleCount: number;
+  meanCpuPercent: number;
+  p95CpuPercent: number;
+}
+
+export interface RuntimeCpuReading { cpuMs: number; processStartTime: string }
+
+/** Dependencies are in-process test seams; no transport accepts evidence or threshold overrides. */
+export interface RuntimePerformanceDependencies {
+  readCpu?: (pid: number) => RuntimeCpuReading;
+  monotonicNow?: () => number;
+  wallNow?: () => number;
+  sleep?: (ms: number) => Promise<void>;
+}
+
+export function readRuntimeCpu(pid: number): RuntimeCpuReading {
+  const result = spawnSync('/bin/ps', ['-p', String(pid), '-o', 'time=', '-o', 'lstart='], {
+    encoding: 'utf8', timeout: 2_000, maxBuffer: 4_096, env: { ...process.env, LC_ALL: 'C' },
+  });
+  const match = result.status === 0
+    ? result.stdout.trim().match(/^(?:(\d+)-)?(?:(\d+):)?(\d+):(\d+(?:\.\d+)?)\s+(.+)$/)
+    : undefined;
+  if (!match) throw new Error('RECOVERY_PERFORMANCE_UNKNOWN: process CPU measurement unavailable');
+  const cpuMs = (Number(match[1] ?? 0) * 86400 + Number(match[2] ?? 0) * 3600
+    + Number(match[3]) * 60 + Number(match[4])) * 1000;
+  return { cpuMs, processStartTime: match[5]! };
+}
+
+export function samePerformanceIdentity(a: RuntimePerformanceIdentity, b: RuntimePerformanceIdentity): boolean {
+  return a.releaseId === b.releaseId && a.authorityRevision === b.authorityRevision
+    && a.runtimeInstanceId === b.runtimeInstanceId && a.pid === b.pid && a.startedAt === b.startedAt;
+}
+
+export function assertRuntimePerformanceEvidence(
+  evidence: RuntimePerformanceEvidence,
+  identity: RuntimePerformanceIdentity,
+  now = Date.now(),
+): void {
+  const age = now - Date.parse(evidence.measuredUntil);
+  if (evidence.policy !== 'idle-cpu-v1' || !samePerformanceIdentity(evidence, identity)
+    || !Number.isFinite(age) || age < 0 || age > 60_000
+    || evidence.warmupMs < 60_000 || evidence.warmupMs > 90_000
+    || evidence.durationMs < 300_000 || evidence.durationMs > 450_000 || evidence.sampleCount !== 30
+    || !Number.isFinite(evidence.meanCpuPercent) || evidence.meanCpuPercent < 0
+    || !Number.isFinite(evidence.p95CpuPercent) || evidence.p95CpuPercent < 0) {
+    throw new Error('RECOVERY_PERFORMANCE_UNKNOWN: incomplete, stale or mismatched performance evidence');
+  }
+  if (evidence.meanCpuPercent > 5 || evidence.p95CpuPercent > 10) {
+    throw new Error(`RECOVERY_PERFORMANCE_REJECTED: mean=${evidence.meanCpuPercent.toFixed(2)}% p95=${evidence.p95CpuPercent.toFixed(2)}%`);
+  }
+}
+
+/** Observe 60 seconds of warmup followed by thirty 10-second CPU-time delta windows. */
+export async function measureRuntimePerformance(
+  observeIdentity: () => RuntimePerformanceIdentity,
+  dependencies: RuntimePerformanceDependencies = {},
+): Promise<RuntimePerformanceEvidence> {
+  const readCpu = dependencies.readCpu ?? readRuntimeCpu;
+  const monotonicNow = dependencies.monotonicNow ?? (() => performance.now());
+  const wallNow = dependencies.wallNow ?? Date.now;
+  const sleep = dependencies.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const identity = observeIdentity();
+  const initial = readCpu(identity.pid);
+  const observe = () => {
+    if (!samePerformanceIdentity(identity, observeIdentity())) {
+      throw new Error('RECOVERY_PERFORMANCE_UNKNOWN: Runtime or release authority changed');
+    }
+    const cpu = readCpu(identity.pid);
+    if (cpu.processStartTime !== initial.processStartTime || !Number.isFinite(cpu.cpuMs)) {
+      throw new Error('RECOVERY_PERFORMANCE_UNKNOWN: process identity changed');
+    }
+    return cpu;
+  };
+  const warmingAt = monotonicNow();
+  let previousWarmupAt = warmingAt;
+  for (let i = 0; i < 6; i++) {
+    await sleep(10_000);
+    observe();
+    const nextWarmupAt = monotonicNow();
+    const elapsed = nextWarmupAt - previousWarmupAt;
+    if (elapsed < 10_000 || elapsed > 15_000) {
+      throw new Error('RECOVERY_PERFORMANCE_UNKNOWN: interrupted CPU warmup window');
+    }
+    previousWarmupAt = nextWarmupAt;
+  }
+  const warmupMs = monotonicNow() - warmingAt;
+  const measuredFrom = new Date(wallNow()).toISOString();
+  let previousCpu = observe().cpuMs;
+  let previousAt = monotonicNow();
+  const startedAt = previousAt;
+  let totalCpuMs = 0;
+  const windows: number[] = [];
+  for (let i = 0; i < 30; i++) {
+    await sleep(10_000);
+    const nextCpu = observe().cpuMs;
+    const nextAt = monotonicNow();
+    const elapsed = nextAt - previousAt;
+    const cpuDelta = nextCpu - previousCpu;
+    // Suspended/overloaded collectors cannot pass as thirty ordinary windows.
+    if (elapsed < 10_000 || elapsed > 15_000 || cpuDelta < 0) {
+      throw new Error('RECOVERY_PERFORMANCE_UNKNOWN: interrupted CPU observation window');
+    }
+    windows.push(cpuDelta / elapsed * 100);
+    totalCpuMs += cpuDelta;
+    previousCpu = nextCpu;
+    previousAt = nextAt;
+  }
+  const durationMs = previousAt - startedAt;
+  windows.sort((a, b) => a - b);
+  const evidence: RuntimePerformanceEvidence = {
+    ...identity, policy: 'idle-cpu-v1', measuredFrom, measuredUntil: new Date(wallNow()).toISOString(),
+    warmupMs, durationMs, sampleCount: windows.length,
+    meanCpuPercent: totalCpuMs / durationMs * 100,
+    p95CpuPercent: windows[Math.ceil(windows.length * 0.95) - 1]!,
+  };
+  assertRuntimePerformanceEvidence(evidence, observeIdentity(), wallNow());
+  return evidence;
+}

package/src/runtime/standalone-recovery/release.ts

@@ -32,6 +32,8 @@ export interface RecoveryReleaseManifest {
   sourceRoot: string;
   cleanWorkspace: boolean;
   builtAt: string;
+  /** Product version derived from the source package and bound by the manifest hash. */
+  productVersion?: string;
   legacy?: boolean;
   artifacts: Record<RecoveryReleaseBinary, { sha256: string }>;
 }
@@ -42,6 +44,7 @@ export interface RecoveryReleaseDescriptor {
   sourceCommit: string;
   sourceRoot: string;
   cleanWorkspace: boolean;
+  productVersion?: string;
   manifestSha256: string;
   artifacts: RecoveryReleaseManifest['artifacts'];
   legacy: boolean;
@@ -109,6 +112,7 @@ export function readRecoveryRelease(path: string | undefined): RecoveryReleaseDe
     if (typeof parsed.sourceCommit !== 'string' || !parsed.sourceCommit.trim()) return undefined;
     if (typeof parsed.sourceRoot !== 'string' || !parsed.sourceRoot.trim()) return undefined;
     if (typeof parsed.cleanWorkspace !== 'boolean') return undefined;
+    if (parsed.productVersion !== undefined && (typeof parsed.productVersion !== 'string' || !parsed.productVersion.trim())) return undefined;
     if (!parsed.artifacts || typeof parsed.artifacts !== 'object') return undefined;
     const artifacts = {} as RecoveryReleaseManifest['artifacts'];
     for (const binary of RECOVERY_RELEASE_BINARIES) {
@@ -123,6 +127,7 @@ export function readRecoveryRelease(path: string | undefined): RecoveryReleaseDe
       sourceCommit: parsed.sourceCommit,
       sourceRoot: resolve(parsed.sourceRoot),
       cleanWorkspace: parsed.cleanWorkspace,
+      productVersion: typeof parsed.productVersion === 'string' ? parsed.productVersion.trim() : undefined,
       manifestSha256: createHash('sha256').update(bytes).digest('hex'),
       artifacts,
       legacy: parsed.legacy === true,

package/src/runtime/watchdog/workflow-watchdog.ts

@@ -3,7 +3,7 @@ import { getLocalBridgeJobEventsSnapshot, listLocalBridgeJobSnapshots } from '..
 import type { RepositoryRecord } from '../../cli/repositories/types';
 import { listExecutionJobs } from '../execution/jobs/store';
 import { collectRuntimePerformanceDiagnostics, type RuntimePerformanceDiagnostics } from '../diagnostics/performance';
-import { listSchedules } from '../workflow/schedules/store';
+import { listSchedules } from '../../../packages/kernel/scheduler/api/index';
 
 const ACTIVE_AGENT_STATUSES = new Set(['queued', 'starting', 'running']);
 

package/src/runtime/workflow/schedules/chatgpt-automation-migration.ts

@@ -1,4 +1,4 @@
-import type { RepositorySchedule } from './types';
+import type { RepositorySchedule } from '../../../../packages/kernel/scheduler/api/index';
 
 export const CHATGPT_AUTOMATION_EXECUTION_PROFILE = 'chatgpt_browser_v1';
 export const CHATGPT_AUTOMATION_DEFAULT_MODEL = 'gpt-5.6';