forgeos 0.1.0-alpha.63 → 0.1.0-alpha.64

package/scripts/field-test-forgeos.mjs

@@ -66,7 +66,16 @@ function normalizeForgeSpec(spec) {
 }
 
 function commandName(command) {
-  return process.platform === "win32" ? `${command}.cmd` : command;
+  if (process.platform !== "win32") return command;
+  return command === "bun" ? command : `${command}.cmd`;
+}
+
+function fieldScratchRoot() {
+  const runnerTemp = process.env.RUNNER_TEMP;
+  if (process.platform === "win32" && runnerTemp && isAbsolute(runnerTemp)) {
+    return runnerTemp;
+  }
+  return tmpdir();
 }
 
 function commandLine(command, args) {
@@ -944,7 +953,7 @@ async function main() {
     return;
   }
 
-  const appRoot = await mkdtemp(join(tmpdir(), "forgeos-field-"));
+  const appRoot = await mkdtemp(join(fieldScratchRoot(), "forgeos-field-"));
   const results = [];
   try {
     for (const testCase of cases) {

package/src/forge/_generated/releaseManifest.json

@@ -1 +1 @@
-{"defaultProvider":"local","diagnostics":[],"env":{"deployEnv":"FORGE_DEPLOY_ENV","deployId":"FORGE_DEPLOY_ID","publicReleaseId":"NEXT_PUBLIC_FORGE_RELEASE_ID","releaseId":"FORGE_RELEASE_ID"},"gitSha":"unknown","optionalProviders":["local","sentry-compatible","sentry","glitchtip","bugsink","otel","custom"],"packageName":"forgeos","packageVersion":"0.1.0-alpha.63","releaseId":"forgeos@0.1.0-alpha.63+unknown","schemaVersion":"0.1.0"}
+{"defaultProvider":"local","diagnostics":[],"env":{"deployEnv":"FORGE_DEPLOY_ENV","deployId":"FORGE_DEPLOY_ID","publicReleaseId":"NEXT_PUBLIC_FORGE_RELEASE_ID","releaseId":"FORGE_RELEASE_ID"},"gitSha":"unknown","optionalProviders":["local","sentry-compatible","sentry","glitchtip","bugsink","otel","custom"],"packageName":"forgeos","packageVersion":"0.1.0-alpha.64","releaseId":"forgeos@0.1.0-alpha.64+unknown","schemaVersion":"0.1.0"}

package/src/forge/_generated/releaseManifest.ts

@@ -1,4 +1,4 @@
-// @forge-generated generator=0.1.0-alpha.63 input=6671cc4ce9f1aeab62768f037489379d8303a79d2681b1fae4cb42a84e818b30 content=407b2f82bfffde0fd6fec96fc9130364878d1f2a6d0945e40da2b05d49aea75a
+// @forge-generated generator=0.1.0-alpha.64 input=5bea3de626e4a7db3a5bbe226a820619b19a6e1347922b0a4f97fedf6654c489 content=805acd8e59d13986e509830825226246b9aa99c68f254c7879db5648cec66b9f
 export const releaseManifest = {
   "defaultProvider": "local",
   "diagnostics": [],
@@ -19,7 +19,7 @@ export const releaseManifest = {
     "custom"
   ],
   "packageName": "forgeos",
-  "packageVersion": "0.1.0-alpha.63",
-  "releaseId": "forgeos@0.1.0-alpha.63+unknown",
+  "packageVersion": "0.1.0-alpha.64",
+  "releaseId": "forgeos@0.1.0-alpha.64+unknown",
   "schemaVersion": "0.1.0"
 } as const;

package/src/forge/agent-adapters/index.ts

@@ -998,6 +998,8 @@ function eventIsNativeHookEvent(event: AgentMemoryEventRecord): boolean {
   return (
     !eventIsForgeHookCanary(event) &&
     !eventIsForgeHookProbe(event) &&
+    typeof event.externalSessionId === "string" &&
+    event.externalSessionId !== "forge-hook-probe" &&
     event.integrationKind === "native-hook" &&
     event.trustLevel === "direct-hook"
   );
@@ -1009,7 +1011,7 @@ function hookApprovalStatusFor(
   nativeSignals: number,
   observableSignals = 0,
   memoryReadable = true,
-): "not-required" | "waiting-for-user-trust" | "accepted" | "trusted" | "memory-unavailable" {
+): "not-required" | "waiting-for-user-trust" | "unverified" | "trusted" | "memory-unavailable" {
   if (target !== "codex" || !installed) {
     return "not-required";
   }
@@ -1019,7 +1021,9 @@ function hookApprovalStatusFor(
   if (nativeSignals > 0) {
     return "trusted";
   }
-  return observableSignals > 0 ? "accepted" : "waiting-for-user-trust";
+  // A Forge-generated canary proves only the local ingest path. It cannot
+  // establish that the user trusted the hook definition in Codex Desktop.
+  return observableSignals > 0 ? "unverified" : "waiting-for-user-trust";
 }
 
 function hookNativeTrustStatusFor(
@@ -1044,12 +1048,12 @@ function codexHookApprovalMessage(
 ): string {
   if (approvalStatus === "waiting-for-user-trust") {
     if (canarySignals > 0) {
-      return "ForgeOS can see the Codex smoke canary; hook approval is accepted, but trusted native Codex signal proof is still pending";
+      return "ForgeOS can see a smoke canary, but Codex hook approval is unverified; review the hook in Codex Desktop and wait for a native signal";
     }
     return "ForgeOS has not seen a trusted native Codex hook signal yet; approve the Codex Desktop hook prompt if shown, then continue a Codex session in this workspace";
   }
-  if (approvalStatus === "accepted" && nativeTrustStatus === "waiting-for-native-signal") {
-    return "Codex hook approval is accepted for local editing; ForgeOS is still waiting for a trusted native Codex signal for stronger provenance";
+  if (approvalStatus === "unverified" && nativeTrustStatus === "waiting-for-native-signal") {
+    return "Codex hook approval is unverified; smoke canaries do not prove user trust or native execution";
   }
   if (approvalStatus === "trusted") {
     return "Codex Desktop hook trust is confirmed by a native hook signal";
@@ -1368,7 +1372,7 @@ async function readAgentHookStatus(options: AgentCommandOptions): Promise<AgentH
   const observableSignals = Math.max(usefulSignals, canarySignals);
   const approvalStatus = hookApprovalStatusFor(target, installed, nativeSignals, observableSignals, deltaWritable);
   const nativeTrustStatus = hookNativeTrustStatusFor(target, installed, nativeSignals, deltaWritable);
-  const approvalRequired = approvalStatus === "waiting-for-user-trust";
+  const approvalRequired = approvalStatus === "waiting-for-user-trust" || approvalStatus === "unverified";
   const codexHookInspection = installTarget === "codex"
     ? inspectCodexHookCommands(options.workspaceRoot)
     : undefined;
@@ -1481,14 +1485,14 @@ async function readAgentHookStatus(options: AgentCommandOptions): Promise<AgentH
       },
       {
         name: "native-hook-signal",
-        ok: target !== "codex" || !deltaWritable || nativeSignals > 0 || approvalStatus === "accepted",
+        ok: target !== "codex" || !deltaWritable || nativeSignals > 0,
         message: target !== "codex"
           ? "native Codex hook approval is not required for this target"
           : !deltaWritable
             ? "trusted Codex native hook signals cannot be verified until Agent Memory is readable"
           : nativeSignals > 0
             ? `${nativeSignals} trusted Codex native hook signal(s) visible or queued`
-            : "hook approval is accepted, but Codex has not emitted a trusted native hook signal yet",
+            : "only canary signals are visible; Codex has not emitted a trusted native hook signal",
         evidence: {
           nativeSignals,
           canarySignals,
@@ -1612,7 +1616,7 @@ export async function runAgentDoctor(options: AgentCommandOptions): Promise<Agen
     memoryReadable,
   );
   const nativeTrustStatus = hookNativeTrustStatusFor(target, Boolean(installTarget && installed), nativeSignals, memoryReadable);
-  const approvalRequired = approvalStatus === "waiting-for-user-trust";
+  const approvalRequired = approvalStatus === "waiting-for-user-trust" || approvalStatus === "unverified";
   const hookBridgeState = !installTarget
     ? "not-supported"
     : !memoryReadable
@@ -1690,14 +1694,14 @@ export async function runAgentDoctor(options: AgentCommandOptions): Promise<Agen
     },
     {
       name: "native-hook-signal",
-      ok: !installTarget || target !== "codex" || !memoryReadable || nativeSignals > 0 || approvalStatus === "accepted",
+      ok: !installTarget || target !== "codex" || !memoryReadable || nativeSignals > 0,
       message: !installTarget || target !== "codex"
         ? "native Codex hook approval is not required for this target"
         : !memoryReadable
           ? "trusted Codex native hook signals cannot be verified until Agent Memory is readable"
         : nativeSignals > 0
           ? `${nativeSignals} trusted Codex native hook signal(s) visible or queued`
-          : "hook approval is accepted, but Codex has not emitted a trusted native hook signal yet",
+          : "only canary signals are visible; Codex has not emitted a trusted native hook signal",
       evidence: {
         nativeSignals,
         canarySignals,
@@ -1911,8 +1915,8 @@ export async function runAgentOnboard(options: AgentCommandOptions): Promise<Age
               ? "Codex hook trust cannot be verified until Agent Memory is readable"
             : doctor.summary.approvalStatus === "trusted"
               ? "Codex hook trust is confirmed by a native hook signal"
-            : doctor.summary.approvalStatus === "accepted"
-              ? "Codex hook approval is accepted; trusted native signal proof is still pending"
+            : doctor.summary.approvalStatus === "unverified"
+              ? "Codex hook approval is unverified; a smoke canary is not native proof"
               : "hook approval is not required for this target",
         }]
       : []),
@@ -2171,7 +2175,7 @@ export async function runAgentHooksSmoke(options: AgentCommandOptions): Promise<
       ? [createDiagnostic({
           severity: "warning",
           code: "FORGE_AGENT_HOOK_APPROVAL_REQUIRED",
-          message: "Codex Desktop hook approval is still pending because ForgeOS has not seen a canary, useful hook event, or trusted native hook signal yet. Approve the hook prompt if Codex shows one, then continue a Codex session in this workspace.",
+          message: "Codex Desktop hook approval cannot be inferred from a smoke canary. Review the exact hook definition in Codex Desktop, then continue a session and verify a native hook signal.",
           suggestedCommands: hookApprovalNextActions(target, status.canarySignals),
         })]
       : []),

package/src/forge/agent-adapters/types.ts

@@ -140,7 +140,7 @@ export interface AgentPrintContextResult {
 }
 
 export type AgentHookBridgeState = "ready" | "missing" | "not-supported" | "waiting-for-user-trust" | "memory-unavailable";
-export type AgentHookApprovalStatus = "not-required" | "waiting-for-user-trust" | "accepted" | "trusted" | "memory-unavailable";
+export type AgentHookApprovalStatus = "not-required" | "waiting-for-user-trust" | "unverified" | "trusted" | "memory-unavailable";
 export type AgentHookNativeTrustStatus = "not-required" | "waiting-for-native-signal" | "trusted" | "memory-unavailable";
 export type AgentHookReadinessLevel = "none" | "canary" | "trusted-native";
 

package/src/forge/agent-fabric/adapter.ts

@@ -0,0 +1,131 @@
+import { AgentFabricError } from "./errors.ts";
+import type {
+  AdapterManifest,
+  AdapterOutcomeResult,
+  AdapterStartResult,
+  AgentAdapter,
+  AttemptExecutionPermit,
+  Digest,
+  RuntimeObservation,
+  WorkerResultReport,
+} from "./types.ts";
+
+export interface DeterministicAdapterFixture {
+  effectiveRunSpecDigest: Digest;
+  outcomeStatus: "succeeded" | "failed";
+  resultDigest: Digest;
+  evidenceDigests?: readonly Digest[];
+}
+
+interface AttemptRecord {
+  permit: AttemptExecutionPermit;
+  startedAt: number;
+  cancelled: boolean;
+}
+
+export class DeterministicTestAdapter implements AgentAdapter {
+  private readonly fixtures = new Map<Digest, DeterministicAdapterFixture>();
+  private readonly attempts = new Map<string, AttemptRecord>();
+
+  constructor(
+    fixtures: readonly DeterministicAdapterFixture[],
+    private readonly now: () => number,
+  ) {
+    for (const fixture of fixtures) this.fixtures.set(fixture.effectiveRunSpecDigest, fixture);
+  }
+
+  manifest(): AdapterManifest {
+    return {
+      adapterId: "forge-agent-fabric/deterministic-test-adapter",
+      version: "0.1.0",
+      capabilities: ["deterministic_fixture_execution", "observation", "cancellation"],
+      supportsCancellation: true,
+      supportsObservation: true,
+    };
+  }
+
+  async startAttempt(permit: AttemptExecutionPermit): Promise<AdapterStartResult> {
+    const existing = this.attempts.get(permit.attemptId);
+    if (existing) {
+      if (existing.permit.permitId !== permit.permitId) {
+        throw new AgentFabricError(
+          "AF_CONFLICT",
+          `Attempt ${permit.attemptId} was started with a different permit`,
+        );
+      }
+      return {
+        status: "started",
+        report: {
+          startupReportId: `startup:${permit.attemptId}`,
+          attemptId: permit.attemptId,
+          observedSpecDigest: permit.effectiveRunSpecDigest,
+          startedAt: existing.startedAt,
+        },
+      };
+    }
+    if (!this.fixtures.has(permit.effectiveRunSpecDigest)) {
+      return { status: "unknown", reason: "fixture_not_found" };
+    }
+    const startedAt = this.now();
+    this.attempts.set(permit.attemptId, { permit, startedAt, cancelled: false });
+    return {
+      status: "started",
+      report: {
+        startupReportId: `startup:${permit.attemptId}`,
+        attemptId: permit.attemptId,
+        observedSpecDigest: permit.effectiveRunSpecDigest,
+        startedAt,
+      },
+    };
+  }
+
+  async observeAttempt(attemptId: string): Promise<readonly RuntimeObservation[]> {
+    const attempt = this.attempts.get(attemptId);
+    if (!attempt) return [];
+    return [
+      {
+        observationId: `observation:${attemptId}:adapter-state`,
+        attemptId,
+        sourceClass: "adapter_observation",
+        claim: attempt.cancelled ? "cancelled" : "running_or_completed",
+        observedAt: this.now(),
+      },
+    ];
+  }
+
+  async collectOutcome(attemptId: string): Promise<AdapterOutcomeResult> {
+    const attempt = this.attempts.get(attemptId);
+    if (!attempt) return { status: "unknown", reason: "attempt_not_observed" };
+    if (attempt.cancelled) return { status: "unknown", reason: "attempt_cancelled" };
+    const fixture = this.fixtures.get(attempt.permit.effectiveRunSpecDigest);
+    if (!fixture) return { status: "unknown", reason: "fixture_not_found" };
+    const permit = attempt.permit;
+    const report: WorkerResultReport = {
+      reportId: `report:${attemptId}`,
+      attemptId,
+      permitId: permit.permitId,
+      intentId: permit.intentId,
+      planRevisionId: permit.planRevisionId,
+      effectiveRunSpecDigest: permit.effectiveRunSpecDigest,
+      fencingToken: permit.fencingToken,
+      status: fixture.outcomeStatus,
+      resultDigest: fixture.resultDigest,
+      evidenceDigests: fixture.evidenceDigests ?? [],
+      reportedAt: this.now(),
+    };
+    return { status: "reported", report };
+  }
+
+  async requestCancellation(attemptId: string): Promise<{ acknowledged: boolean }> {
+    const attempt = this.attempts.get(attemptId);
+    if (!attempt) return { acknowledged: false };
+    attempt.cancelled = true;
+    return { acknowledged: true };
+  }
+
+  async observeTermination(attemptId: string): Promise<"terminated" | "running" | "unknown"> {
+    const attempt = this.attempts.get(attemptId);
+    if (!attempt) return "unknown";
+    return attempt.cancelled ? "terminated" : "running";
+  }
+}

package/src/forge/agent-fabric/authority.ts

@@ -0,0 +1,298 @@
+import { getOwn, setOwn } from "./dictionary.ts";
+import { AgentFabricError } from "./errors.ts";
+import { ResourceLedger } from "./resource-ledger.ts";
+import type {
+  AuthorityResolution,
+  ControlState,
+  DerivedGrantRequest,
+  EffectClass,
+  ExecutionGrant,
+  OwnerAuthorization,
+} from "./types.ts";
+
+function isSubset<T>(child: readonly T[], parent: readonly T[]): boolean {
+  const allowed = new Set(parent);
+  return child.every((value) => allowed.has(value));
+}
+
+function reject(...reasonCodes: string[]): AuthorityResolution {
+  return { outcome: "rejected", reasonCodes, limitations: [] };
+}
+
+export function rootGrantAuthorizationViolations(
+  authorization: OwnerAuthorization,
+  grant: ExecutionGrant,
+): readonly string[] {
+  const violations: string[] = [];
+  if (grant.parentGrantId !== null) violations.push("root_grant_has_parent");
+  if (grant.rootAuthorizationId !== authorization.authorizationId) {
+    violations.push("root_authorization_mismatch");
+  }
+  if (authorization.rootExecutionId.length === 0) violations.push("authorization_missing_execution");
+  if (!authorization.subjectIds.includes(grant.subjectId)) violations.push("subject_not_authorized");
+  if (!isSubset(grant.capabilities, authorization.capabilities)) violations.push("capability_scope_expanded");
+  if (!isSubset(grant.sourceIds, authorization.sourceIds)) violations.push("source_scope_expanded");
+  if (!isSubset(grant.targetIds, authorization.targetIds)) violations.push("target_scope_expanded");
+  if (!isSubset<EffectClass>(grant.effectClasses, authorization.effectClasses)) {
+    violations.push("effect_scope_expanded");
+  }
+  if (grant.notBefore < authorization.notBefore || grant.expiresAt > authorization.expiresAt) {
+    violations.push("time_scope_expanded");
+  }
+  if (grant.expiresAt <= grant.notBefore) violations.push("invalid_time_window");
+  if (grant.maximumAttempts <= 0 || grant.maximumAttempts > authorization.maximumAttempts) {
+    violations.push("attempt_limit_expanded");
+  }
+  if (
+    grant.delegationDepthRemaining < 0 ||
+    grant.delegationDepthRemaining > authorization.maximumDelegationDepth
+  ) {
+    violations.push("delegation_depth_expanded");
+  }
+  for (const [resource, amount] of Object.entries(grant.resourceCeilings)) {
+    const ceiling = getOwn(authorization.resourceCeilings, resource);
+    if (!Number.isFinite(amount) || amount <= 0 || ceiling === undefined || amount > ceiling) {
+      violations.push(`resource_ceiling_expanded:${resource}`);
+    }
+  }
+  return violations;
+}
+
+export function assertRootGrantAuthorized(
+  authorization: OwnerAuthorization,
+  grant: ExecutionGrant,
+): void {
+  const violations = rootGrantAuthorizationViolations(authorization, grant);
+  if (violations.length > 0) {
+    throw new AgentFabricError(
+      "AF_GRANT_REJECTED",
+      `Root grant ${grant.grantId} exceeds authorization ${authorization.authorizationId}`,
+      { violations },
+    );
+  }
+}
+
+export function grantAttenuationViolations(
+  parent: ExecutionGrant,
+  child: ExecutionGrant,
+): readonly string[] {
+  const violations: string[] = [];
+  if (child.parentGrantId !== parent.grantId) violations.push("parent_grant_mismatch");
+  if (child.rootAuthorizationId !== parent.rootAuthorizationId) {
+    violations.push("root_authorization_changed");
+  }
+  if (!child.reservationId) violations.push("derived_grant_missing_reservation");
+  if (!isSubset(child.capabilities, parent.capabilities)) violations.push("capability_scope_expanded");
+  if (!isSubset(child.sourceIds, parent.sourceIds)) violations.push("source_scope_expanded");
+  if (!isSubset(child.targetIds, parent.targetIds)) violations.push("target_scope_expanded");
+  if (!isSubset<EffectClass>(child.effectClasses, parent.effectClasses)) {
+    violations.push("effect_scope_expanded");
+  }
+  if (child.notBefore < parent.notBefore || child.expiresAt > parent.expiresAt) {
+    violations.push("time_scope_expanded");
+  }
+  if (child.expiresAt <= child.notBefore) violations.push("invalid_time_window");
+  if (child.maximumAttempts <= 0 || child.maximumAttempts > parent.maximumAttempts) {
+    violations.push("attempt_limit_expanded");
+  }
+  if (
+    child.delegationDepthRemaining < 0 ||
+    child.delegationDepthRemaining >= parent.delegationDepthRemaining
+  ) {
+    violations.push("delegation_depth_not_attenuated");
+  }
+  for (const [resource, amount] of Object.entries(child.resourceCeilings)) {
+    const ceiling = getOwn(parent.resourceCeilings, resource);
+    if (!Number.isFinite(amount) || amount <= 0 || ceiling === undefined || amount > ceiling) {
+      violations.push(`resource_ceiling_expanded:${resource}`);
+    }
+  }
+  return violations;
+}
+
+export function assertGrantAttenuated(
+  parent: ExecutionGrant,
+  child: ExecutionGrant,
+): void {
+  const violations = grantAttenuationViolations(parent, child);
+  if (violations.length > 0) {
+    throw new AgentFabricError(
+      "AF_GRANT_REJECTED",
+      `Derived grant ${child.grantId} is not attenuated from ${parent.grantId}`,
+      { violations },
+    );
+  }
+}
+
+export function deriveExecutionGrant(
+  parent: ExecutionGrant,
+  request: DerivedGrantRequest,
+  ledger: ResourceLedger,
+  now: number,
+): AuthorityResolution {
+  if (now < parent.notBefore || now >= parent.expiresAt) {
+    return reject("parent_grant_not_current");
+  }
+
+  const aggregatedResourceRequests = Object.entries(
+    request.resourceRequests.reduce<Record<string, number>>((totals, resourceRequest) => {
+      setOwn(totals, resourceRequest.resource, (getOwn(totals, resourceRequest.resource) ?? 0) + resourceRequest.amount);
+      return totals;
+    }, {}),
+  ).map(([resource, amount]) => ({ resource, amount }));
+
+  const candidate: ExecutionGrant = {
+    grantId: request.grantId,
+    rootAuthorizationId: parent.rootAuthorizationId,
+    subjectId: request.subjectId,
+    parentGrantId: parent.grantId,
+    capabilities: [...request.capabilities],
+    sourceIds: [...request.sourceIds],
+    targetIds: [...request.targetIds],
+    effectClasses: [...request.effectClasses],
+    notBefore: request.notBefore,
+    expiresAt: request.expiresAt,
+    maximumAttempts: request.maximumAttempts,
+    delegationDepthRemaining: request.delegationDepthRemaining,
+    resourceCeilings: Object.fromEntries(
+      aggregatedResourceRequests.map((item) => [item.resource, item.amount]),
+    ),
+    reservationId: request.reservationId,
+  };
+  const violations = grantAttenuationViolations(parent, candidate);
+  if (violations.length > 0) return reject(...violations);
+
+  try {
+    const reserved = ledger.reserve(
+      request.reservationId,
+      parent.grantId,
+      aggregatedResourceRequests,
+      parent.resourceCeilings,
+    );
+    return {
+      outcome: "allowed",
+      reasonCodes: [],
+      limitations: [],
+      grant: {
+        ...candidate,
+        resourceCeilings: Object.fromEntries(
+          reserved.requests.map((item) => [item.resource, item.amount]),
+        ),
+      },
+    };
+  } catch (error) {
+    if (error instanceof AgentFabricError) {
+      return reject(error.code.toLowerCase());
+    }
+    return { outcome: "unknown", reasonCodes: ["resource_reservation_unknown"], limitations: [] };
+  }
+}
+
+export function assertAuthorizationCurrent(
+  authorization: OwnerAuthorization,
+  now: number,
+  revokedReason?: string,
+): void {
+  if (revokedReason) {
+    throw new AgentFabricError(
+      "AF_GRANT_REJECTED",
+      `Owner authorization ${authorization.authorizationId} is revoked`,
+      { revokedReason },
+    );
+  }
+  if (now < authorization.notBefore || now >= authorization.expiresAt) {
+    throw new AgentFabricError(
+      "AF_GRANT_REJECTED",
+      `Owner authorization ${authorization.authorizationId} is outside its validity window`,
+    );
+  }
+}
+
+export function assertGrantCurrent(
+  grant: ExecutionGrant,
+  now: number,
+  revokedReason?: string,
+): void {
+  if (revokedReason) {
+    throw new AgentFabricError(
+      "AF_GRANT_REJECTED",
+      `Grant ${grant.grantId} is revoked`,
+      { revokedReason },
+    );
+  }
+  if (now < grant.notBefore || now >= grant.expiresAt) {
+    throw new AgentFabricError(
+      "AF_GRANT_REJECTED",
+      `Grant ${grant.grantId} is outside its validity window`,
+    );
+  }
+}
+
+export function assertGrantLineageCurrent(
+  state: Pick<
+    ControlState,
+    | "authorizations"
+    | "revokedAuthorizations"
+    | "grants"
+    | "revokedGrants"
+    | "resourceReservations"
+  >,
+  grantId: string,
+  now: number,
+): void {
+  const seen = new Set<string>();
+  const selected = getOwn(state.grants, grantId);
+  if (!selected) throw new AgentFabricError("AF_NOT_FOUND", `Unknown grant: ${grantId}`);
+  let current: ExecutionGrant = selected;
+
+  while (true) {
+    if (seen.has(current.grantId)) {
+      throw new AgentFabricError("AF_GRANT_REJECTED", "Grant ancestry contains a cycle");
+    }
+    seen.add(current.grantId);
+    assertGrantCurrent(current, now, getOwn(state.revokedGrants, current.grantId));
+
+    if (current.parentGrantId) {
+      if (!current.reservationId) {
+        throw new AgentFabricError(
+          "AF_GRANT_REJECTED",
+          `Derived grant ${current.grantId} has no resource reservation`,
+        );
+      }
+      const reservation = getOwn(state.resourceReservations, current.reservationId);
+      if (!reservation || reservation.status === "released") {
+        throw new AgentFabricError(
+          "AF_GRANT_REJECTED",
+          `Derived grant ${current.grantId} has no current resource reservation`,
+        );
+      }
+    }
+
+    if (!current.parentGrantId) {
+      const authorization = getOwn(state.authorizations, current.rootAuthorizationId);
+      if (!authorization) {
+        throw new AgentFabricError(
+          "AF_GRANT_REJECTED",
+          `Root grant ${current.grantId} has no registered owner authorization`,
+        );
+      }
+      assertAuthorizationCurrent(
+        authorization,
+        now,
+        getOwn(state.revokedAuthorizations, authorization.authorizationId),
+      );
+      assertRootGrantAuthorized(authorization, current);
+      return;
+    }
+
+    const parent: ExecutionGrant | undefined = getOwn(state.grants, current.parentGrantId);
+    if (!parent) {
+      throw new AgentFabricError(
+        "AF_GRANT_REJECTED",
+        `Grant ${current.grantId} references missing parent ${current.parentGrantId}`,
+      );
+    }
+    assertGrantAttenuated(parent, current);
+    current = parent;
+  }
+}