fix(approvals): close trusted runtime lifecycle gaps

Author: 777genius

.github/workflows/ci.yml

@@ -99,6 +99,9 @@ jobs:
       - name: Verify runtime lock
         run: node ./scripts/ci/verify-runtime-lock.mjs
 
+      - name: Verify hosted approval runtime authority golden
+        run: node ./scripts/verify-hosted-approval-runtime-admission-authority.mjs --verify-golden
+
       - name: Resolve and fetch architecture baseline
         id: architecture-baseline
         env:

package.json

@@ -83,6 +83,7 @@
     "guard:feature-architecture:baseline": "node ./scripts/ci/update-feature-architecture-baseline.mjs --write",
     "guard:hosted-phase0-evidence": "node ./scripts/ci/verify-hosted-phase0-evidence-integrity.mjs",
     "guard:runtime-artifacts": "node ./scripts/ci/forbid-runtime-artifacts.cjs",
+    "guard:hosted-approval-runtime-authority": "node ./scripts/verify-hosted-approval-runtime-admission-authority.mjs --verify-golden",
     "guard:source-file-size": "node ./scripts/ci/check-source-file-size.mjs",
     "guard:source-file-size:ci": "node ./scripts/ci/verify-source-file-size.mjs --require-baseline",
     "guard:team-provisioning-architecture": "node ./scripts/ci/check-team-provisioning-architecture.mjs",

scripts/verify-hosted-approval-runtime-admission-authority.mjs

@@ -1,68 +1,125 @@
 #!/usr/bin/env node
-import { execFile } from 'node:child_process';
 import { createHash } from 'node:crypto';
-import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join, resolve } from 'node:path';
-import { promisify } from 'node:util';
+import { readFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
 
-const run = promisify(execFile);
-const [gitDirectoryInput, commit, admissionInput] = process.argv.slice(2);
-if (!gitDirectoryInput || !/^[0-9a-f]{40}$/u.test(commit ?? '') || !admissionInput) {
-  throw new Error('usage: verify-hosted-approval-runtime-admission-authority <git-dir> <commit> <admission-json>');
+const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const goldenPath = resolve(
+  root,
+  'test/fixtures/hosted-approval-runtime-admission-v1.release-golden.json'
+);
+const runtimeLockPath = resolve(root, 'runtime.lock.json');
+const [admissionInput] = process.argv.slice(2);
+const golden = JSON.parse(await readFile(goldenPath, 'utf8'));
+const runtimeLock = JSON.parse(await readFile(runtimeLockPath, 'utf8'));
+
+const exactKeys = (value, expected) =>
+  value !== null &&
+  typeof value === 'object' &&
+  !Array.isArray(value) &&
+  Object.keys(value).length === expected.length &&
+  expected.every((key) => Object.hasOwn(value, key));
+const sha256 = (value) => createHash('sha256').update(value).digest('hex');
+const SHA256 = /^[0-9a-f]{64}$/u;
+const COMMIT = /^[0-9a-f]{40}$/u;
+
+function invalid(reason) {
+  throw new Error(`hosted-approval-runtime-release-golden-invalid:${reason}`);
+}
+
+function verifyReleaseGolden() {
+  if (!exactKeys(golden, ['schemaVersion', 'source', 'release', 'canonicalJson', 'sha256'])) {
+    invalid('schema');
+  }
+  if (
+    golden.schemaVersion !== 2 ||
+    golden.source !== 'agent-teams-orchestrator/hosted-approval-runtime-admission.v1'
+  ) {
+    invalid('identity');
+  }
+  if (
+    !exactKeys(golden.release, [
+      'sourceRepository',
+      'releaseRepository',
+      'releaseTag',
+      'sourceCommit',
+      'manifestAttestation',
+    ]) ||
+    golden.release.sourceRepository !== '777genius/agent_teams_orchestrator' ||
+    golden.release.releaseRepository !== '777genius/agent_teams_orchestrator_binaries' ||
+    golden.release.releaseTag !== runtimeLock.releaseTag ||
+    golden.release.sourceCommit !== '1f9a7ffc00715e2434eb7549ac2c53880d9f6f83' ||
+    !COMMIT.test(golden.release.sourceCommit)
+  ) {
+    invalid('release-pin');
+  }
+  const attestation = golden.release.manifestAttestation;
+  if (
+    !exactKeys(attestation, ['kind', 'releaseId', 'assetId', 'assetName', 'assetSha256']) ||
+    attestation.kind !== 'github-release-asset-digest/v1' ||
+    attestation.releaseId !== 363595793 ||
+    attestation.assetId !== 498146437 ||
+    attestation.assetName !== `agent-teams-runtime-manifest-${runtimeLock.sourceRef}.json` ||
+    attestation.assetSha256 !==
+      '0b1036e1f110eefeed5b12c9637a7efa3bf35d6b09a8eb20519909e86bed2bcb' ||
+    !SHA256.test(attestation.assetSha256)
+  ) {
+    invalid('manifest-attestation-pin');
+  }
+  if (
+    typeof golden.canonicalJson !== 'string' ||
+    golden.sha256 !== `sha256:${sha256(golden.canonicalJson)}`
+  ) {
+    invalid('canonical-digest');
+  }
+  const snapshot = JSON.parse(golden.canonicalJson);
+  if (
+    !exactKeys(snapshot, ['schemaVersion', 'approvalGeneration', 'authorities']) ||
+    snapshot.schemaVersion !== 1 ||
+    snapshot.approvalGeneration !== 1 ||
+    !Array.isArray(snapshot.authorities) ||
+    snapshot.authorities.length === 0
+  ) {
+    invalid('authority-snapshot');
+  }
+}
+
+verifyReleaseGolden();
+if (admissionInput === '--verify-golden') {
+  process.stdout.write(`${JSON.stringify({ verified: true, releaseGolden: goldenPath })}\n`);
+  process.exit(0);
+}
+if (!admissionInput) {
+  throw new Error('usage: verify-hosted-approval-runtime-admission-authority <admission-json>');
 }
 
-const gitDirectory = resolve(gitDirectoryInput);
 const admissionPath = resolve(admissionInput);
-const root = await mkdtemp(join(tmpdir(), 'hosted-approval-authority-'));
-const authorityFiles = [
-  'HostedApprovalRuntimeAdmission.ts',
-  'HostedApprovalWire.ts',
-  'ownerProof.ts',
-  'protocol.ts',
-];
+const admissionBytes = await readFile(admissionPath);
+const admission = JSON.parse(admissionBytes.toString('utf8'));
+const match = /^approval-admission-generation_([1-9][0-9]*)_owner_[1-9][0-9]*$/u.exec(
+  admission.admissionGeneration ?? ''
+);
+if (!match || !Array.isArray(admission.routes)) invalid('admission-shape');
+const snapshot = {
+  schemaVersion: 1,
+  approvalGeneration: Number(match[1]),
+  authorities: [...admission.routes]
+    .toSorted((left, right) => left.routeId.localeCompare(right.routeId))
+    .map((route) => route.authority),
+};
+const canonicalJson = JSON.stringify(snapshot);
+if (canonicalJson !== golden.canonicalJson) invalid('cross-repository-authority-mismatch');
 
-try {
-  for (const file of authorityFiles) {
-    const objectPath = `src/services/hostedControl/${file}`;
-    const { stdout } = await run('/usr/bin/git', [
-      `--git-dir=${gitDirectory}`,
-      'show',
-      `${commit}:${objectPath}`,
-    ]);
-    await writeFile(join(root, file), stdout, { mode: 0o600 });
-  }
-  const admission = JSON.parse(await readFile(admissionPath, 'utf8'));
-  const runner = `
-    import { PrivateFileHostedApprovalRuntimeAdmissionStore } from './HostedApprovalRuntimeAdmission.ts';
-    import { readFile } from 'node:fs/promises';
-    void (async () => {
-    const admission = JSON.parse(await readFile(${JSON.stringify(admissionPath)}, 'utf8'));
-    const outer = admission.outerAuthority;
-    const loaded = await new PrivateFileHostedApprovalRuntimeAdmissionStore(${JSON.stringify(admissionPath)}).load({
-      deploymentId: outer.deploymentId,
-      bootId: outer.bootId,
-      workspaceId: outer.workspaceId,
-      teamId: outer.teamId,
-      restoreGeneration: outer.restoreGeneration,
-      mountBinding: outer.mountBinding,
-    });
-    if (!(await loaded.isCurrent())) throw new Error('external-authority-drift');
-    })();
-  `;
-  await writeFile(join(root, 'verify.ts'), runner, { mode: 0o600 });
-  await run(process.execPath, ['--import', 'tsx', join(root, 'verify.ts')], {
-    cwd: process.cwd(),
-  });
-  const source = await readFile(join(root, 'HostedApprovalRuntimeAdmission.ts'));
-  const admissionBytes = await readFile(admissionPath);
-  process.stdout.write(`${JSON.stringify({
+process.stdout.write(
+  `${JSON.stringify({
     verified: true,
-    authorityCommit: commit,
-    authorityBlobSha256: createHash('sha256').update(source).digest('hex'),
-    admissionSha256: createHash('sha256').update(admissionBytes).digest('hex'),
-    approvalGeneration: admission.admissionGeneration,
-  })}\n`);
-} finally {
-  await rm(root, { recursive: true, force: true });
-}
+    sourceRepository: golden.release.sourceRepository,
+    releaseRepository: golden.release.releaseRepository,
+    releaseTag: golden.release.releaseTag,
+    sourceCommit: golden.release.sourceCommit,
+    manifestAttestationSha256: golden.release.manifestAttestation.assetSha256,
+    admissionSha256: sha256(admissionBytes),
+    approvalGeneration: snapshot.approvalGeneration,
+  })}\n`
+);

src/main/composition/team/createProductTeamProvisioning.ts

@@ -4,6 +4,7 @@ import {
   observeHostedApprovalRuntimeTeamChange,
   stopAllTeamsWithHostedApprovalRuntime,
 } from '@main/services/team/provisioning/HostedApprovalRuntimeDesktopLifecycle';
+import { createHostedApprovalRuntimeLifecycleOwner } from '@main/services/team/provisioning/HostedApprovalRuntimeLifecycleOwner';
 import { createProductOwnedTeamProvisioningService } from '@main/services/team/provisioning/HostedApprovalRuntimeProductionComposition';
 import { getAppDataPath, getTeamsBasePath } from '@main/utils/pathDecoder';
 
@@ -21,9 +22,13 @@ export function createProductTeamProvisioning() {
     composition.service,
     composition.hostedApprovalRuntime
   );
+  const trustedLifecycleOwner = createHostedApprovalRuntimeLifecycleOwner(
+    composition.hostedApprovalRuntime
+  );
   return Object.freeze({
     service: composition.service,
     capabilities,
+    trustedLifecycleOwner,
     ensureAdmissionAbsent: (teamName: string, reason: string) =>
       composition.hostedApprovalRuntime.ensureAbsent(teamName, reason),
     observeFailure: (

src/main/index.ts

@@ -2126,8 +2126,8 @@ async function initializeServices(): Promise<void> {
     addNotification: (payload) => notificationManager.addTeamNotification(payload),
     logger: createLogger('Feature:TeamRuntimeRecovery'),
   });
-  teamProvisioningService.setRuntimeRecoveryFailureObserver((failure) => {
-    productTeamProvisioning?.observeFailure(failure, logger);
+  teamProvisioningService.setRuntimeRecoveryFailureObserver(async (failure) => {
+    await productTeamProvisioning?.observeFailure(failure, logger);
     teamRuntimeRecoveryFeature?.observeLeadFailure(failure);
   });
   teamProvisioningService.setMemberRuntimeAdvisoryInvalidator((teamName, memberName) => {
@@ -2296,8 +2296,8 @@ async function initializeServices(): Promise<void> {
       );
     }
   );
-  const teamChangeEmitter = (event: TeamChangeEvent): void => {
-    productTeamProvisioning?.observeTeamChange(event, logger);
+  const teamChangeEmitter = async (event: TeamChangeEvent): Promise<void> => {
+    await productTeamProvisioning?.observeTeamChange(event, logger);
     notifyTeamChangeObserversSafely(
       event,
       [

src/main/ipc/desktopTeamFeatureCapabilitySources.ts

@@ -93,7 +93,14 @@ export function createDesktopTeamFeatureCapabilitySources(
       : runtime,
     memberLifecycle: hostedApprovalRuntime
       ? {
-          ...memberLifecycle,
+          getMemberSpawnStatuses: memberLifecycle.getMemberSpawnStatuses,
+          runLiveRosterMutation: (
+            teamName: string,
+            operation: Parameters<typeof memberLifecycle.runLiveRosterMutation>[1]
+          ) =>
+            hostedApprovalRuntime.beforeBindingChange(teamName, () =>
+              memberLifecycle.runLiveRosterMutation(teamName, operation)
+            ),
           attachLiveRosterMember: (
             ...args: Parameters<typeof memberLifecycle.attachLiveRosterMember>
           ) =>
@@ -110,6 +117,16 @@ export function createDesktopTeamFeatureCapabilitySources(
             hostedApprovalRuntime.beforeBindingChange(args[0], () =>
               memberLifecycle.restartMember(...args)
             ),
+          retryFailedOpenCodeSecondaryLanes: (
+            ...args: Parameters<typeof memberLifecycle.retryFailedOpenCodeSecondaryLanes>
+          ) =>
+            hostedApprovalRuntime.beforeBindingChange(args[0], () =>
+              memberLifecycle.retryFailedOpenCodeSecondaryLanes(...args)
+            ),
+          skipMemberForLaunch: (...args: Parameters<typeof memberLifecycle.skipMemberForLaunch>) =>
+            hostedApprovalRuntime.beforeBindingChange(args[0], () =>
+              memberLifecycle.skipMemberForLaunch(...args)
+            ),
         }
       : memberLifecycle,
     diagnostics: bindTeamDiagnosticsApi(teamProvisioningService),

src/main/services/team/index.ts

@@ -26,6 +26,10 @@ export {
   observeHostedApprovalRuntimeTeamChange,
   stopAllTeamsWithHostedApprovalRuntime,
 } from './provisioning/HostedApprovalRuntimeDesktopLifecycle';
+export {
+  createHostedApprovalRuntimeLifecycleOwner,
+  type HostedApprovalRuntimeLifecycleOwner,
+} from './provisioning/HostedApprovalRuntimeLifecycleOwner';
 export { createProductOwnedTeamProvisioningService } from './provisioning/HostedApprovalRuntimeProductionComposition';
 export type { HostedApprovalRuntimeTransitionService } from './provisioning/HostedApprovalRuntimeTransitionService';
 export { ReviewApplierService } from './ReviewApplierService';

src/main/services/team/provisioning/HostedApprovalRuntimeAdmissionPublisher.ts

@@ -1,6 +1,6 @@
 import { createHash } from 'node:crypto';
 
-import { parseRuntimePermissionApprovalIngressAuthority } from '@features/team-runtime-control/contracts';
+import { parseRuntimePermissionApprovalIngressAuthority } from '@features/team-approvals/contracts';
 
 import {
   descriptorAnchoredRead,
@@ -11,7 +11,7 @@ import {
 import { immutableHostedApprovalRuntimeBinding } from './HostedApprovalRuntimeImmutableBinding';
 
 import type { TrustedDirectoryCapability } from './HostedApprovalRuntimeDescriptorStorage';
-import type { RuntimePermissionApprovalIngressAuthority } from '@features/team-runtime-control/contracts';
+import type { RuntimePermissionApprovalIngressAuthority } from '@features/team-approvals/contracts';
 import type { OrchestratorSocketIdentity } from '@main/composition/hosted/hostedLifecycleOrchestratorReadiness';
 
 export {

src/main/services/team/provisioning/HostedApprovalRuntimeDesktopLifecycle.ts

@@ -15,35 +15,39 @@ export function observeHostedApprovalRuntimeFailure(
   runtime: HostedApprovalRuntimeTransitionService | null,
   failure: LeadRuntimeFailureObservation,
   logger: HostedApprovalRuntimeRevocationLogger
-): void {
-  void runtime
-    ?.beforeFailure(failure.teamName, async () => undefined)
-    .catch((error: unknown) =>
-      logger.error('Hosted approval runtime failure revocation failed:', error)
-    );
+): Promise<void> {
+  if (!runtime) return Promise.resolve();
+  return runtime
+    .beforeFailure(failure.teamName, async () => undefined)
+    .catch((error: unknown) => {
+      logger.error('Hosted approval runtime failure revocation failed:', error);
+      throw error;
+    });
 }
 
 export function observeHostedApprovalRuntimeTeamChange(
   runtime: HostedApprovalRuntimeTransitionService | null,
   event: TeamChangeEvent,
   logger: HostedApprovalRuntimeRevocationLogger
-): void {
+): Promise<void> {
   if (
     event.type !== 'process' ||
     (event.detail !== 'failed' &&
       event.detail !== 'disconnected' &&
       event.detail !== 'stopped' &&
       event.detail !== 'cancelled')
   ) {
-    return;
+    return Promise.resolve();
   }
   const revoke =
     event.detail === 'failed'
       ? runtime?.beforeFailure(event.teamName, async () => undefined)
       : runtime?.beforeOwnerLoss(event.teamName, async () => undefined);
-  void revoke?.catch((error: unknown) =>
-    logger.error('Hosted approval runtime owner-loss revocation failed:', error)
-  );
+  if (!revoke) return Promise.resolve();
+  return revoke.catch((error: unknown) => {
+    logger.error('Hosted approval runtime owner-loss revocation failed:', error);
+    throw error;
+  });
 }
 
 export function stopAllTeamsWithHostedApprovalRuntime(

src/main/services/team/provisioning/HostedApprovalRuntimeLifecycleOwner.ts

@@ -0,0 +1,24 @@
+import type { HostedApprovalRuntimePublication } from './HostedApprovalRuntimeAdmissionPublisher';
+import type { HostedApprovalRuntimeTransitionEvidence } from './HostedApprovalRuntimeAuthoritativeEvidenceAdapter';
+import type { HostedApprovalRuntimeTransitionService } from './HostedApprovalRuntimeTransitionService';
+
+/**
+ * Product-owned input port for the trusted launcher lifecycle owner. The caller cannot publish from
+ * ambient state: every transition carries the authoritative lease and installed-artifact reread.
+ */
+export interface HostedApprovalRuntimeLifecycleOwner {
+  transition(
+    teamName: string,
+    evidence: HostedApprovalRuntimeTransitionEvidence
+  ): Promise<HostedApprovalRuntimePublication>;
+}
+
+export function createHostedApprovalRuntimeLifecycleOwner(
+  runtime: HostedApprovalRuntimeTransitionService
+): HostedApprovalRuntimeLifecycleOwner {
+  return Object.freeze({
+    transition(teamName: string, evidence: HostedApprovalRuntimeTransitionEvidence) {
+      return runtime.transition(teamName, evidence.lifecycle, evidence);
+    },
+  });
+}