gate-evm-tools 1.2.0 → 1.2.2

package/runtime/delivery/planning.ts

@@ -59,6 +59,7 @@ export interface PlanningIdentityPort {
   ): Promise<{ chainId: string; blockNumber: number; blockHash: string }>;
 }
 export interface DeliveryRuntimeEvidence {
+  views?: unknown[];
   /** Validated during this collection only; never hashed or compared as canonical replay content. */
   pendingUupsReuse: { stepId: string; binding: PendingReuseBinding }[];
   forkAudit: ForkAuditEvidence;
@@ -230,6 +231,7 @@ async function collectOwned(input:DeliveryPlanningOptions,staging:boolean):Promi
     const callReviews = new Map<string, CalldataTransactionReview>();
     const operationIds = new DeliveryOperationIdentities();
     const references: DeliveryRuntimeEvidence["references"] = [];
+    const views:unknown[]=[];
     const customBindings: CustomEvidence[] = [],
       executed: WorkflowStep[] = [];
     const session = sourceSteps.some((step) => step.kind === "custom")
@@ -241,6 +243,11 @@ async function collectOwned(input:DeliveryPlanningOptions,staging:boolean):Promi
               params: context.targetParams,
               target: context.target,
               state: () => context.state.snapshot(),
+              query: async query => {
+                const request=(method:string,params:unknown[])=>context.runtime.hre.network.provider.request({method,params}) as Promise<any>;
+                const block:any=await request('eth_getBlockByNumber',['latest',false]);
+                return require('./query').readScriptContract(query,{request,chainId:header.chainId,block:{number:block.number,hash:block.hash},caller:header.operator,source:pinned});
+              },
             }),
           context.root,
           context.taskDir
@@ -249,6 +256,7 @@ async function collectOwned(input:DeliveryPlanningOptions,staging:boolean):Promi
     const pendingUupsReuse = context.pendingUupsReuse;
     const stepContext: DeliveryStepContext = {
       ...context,
+      reporter:{event:(...args:any[])=>context.reporter.event(...args as [any,any]),result:(kind:any,data:any)=>{if(kind==='view')views.push(strictData(data));context.reporter.result(kind,data);}},
       deploymentRecorder: undefined,
       bindings,
       preparations,
@@ -373,7 +381,7 @@ async function collectOwned(input:DeliveryPlanningOptions,staging:boolean):Promi
       throw new Error("Replayed verification evidence differs");
     session?.closeReads();
     const interval=await audit.capture({transactions,completedTransactions:input.completedTransactions??[]});
-    const stagedSnapshot=deepFreeze({payload,calldata,preparations:prepared,verification:observations,runtimeEvidence:{pendingUupsReuse:pendingObservations,forkAudit:interval.snapshot,references}});
+    const stagedSnapshot=deepFreeze({payload,calldata,preparations:prepared,verification:observations,runtimeEvidence:{pendingUupsReuse:pendingObservations,forkAudit:interval.snapshot,references,...(views.length?{views}:{})}});
     const invariantHash=semanticHash(stagedSnapshot);
     let state:'staged'|'bound'|'failed'|'closed'='staged';
     const open=()=>{if(state!=='staged')throw new Error('Staged collection closed or already bound');};
@@ -383,7 +391,7 @@ async function collectOwned(input:DeliveryPlanningOptions,staging:boolean):Promi
       if(expected&&plan.planHash!==expected.planHash)throw new Error('Replayed delivery plan differs from expected plan');
       const forkAudit=interval.bind(plan.planHash);
       const result=deepFreeze(canonicalData({plan,calldata,preparations:prepared,verification:observations,
-        runtimeEvidence:{pendingUupsReuse:pendingObservations,forkAudit,references}}) as unknown as DeliveryCollection);
+        runtimeEvidence:{pendingUupsReuse:pendingObservations,forkAudit,references,...(views.length?{views}:{})}}) as unknown as DeliveryCollection);
       if(collectionInvariantHash(result)!==invariantHash)throw new Error('Binding changed staged collection payload');
       state='bound';return result;
     };

package/runtime/delivery/production-finalization.ts

@@ -1,3 +1,4 @@
+import {interactionCoverageRegistry} from './existing-code';
 /** Static production acceptance. No project module, HRE, compiler process or signing port is loaded. */
 import path from 'node:path';
 import {getCreate2Address,Interface} from 'ethers';
@@ -78,7 +79,7 @@ export async function finalizeProductionExecution(input:{root:string;ready:Produ
  const deployed=[...changes.values()],unchangedAliases=new Set<string>();
  const registrationContext={base,target:plan.target,deploymentId:plan.deploymentId,executionId:plan.executionId,recordPath:recordPath(ready),updatedAt:new Date(Number(BigInt(anchor.timestamp))*1000).toISOString(),changes:deployed,preparations};
  // Apply the same validated upgrade replacement before resolving code coverage.
- const candidate=mergeDevelopmentRegistration({...base,...registrationContext}),registry=candidate.registry[plan.target],metadata=candidate.metadata.networks[plan.target];
+ const candidate=mergeDevelopmentRegistration({...base,...registrationContext}),registry=interactionCoverageRegistry(ready.collection,candidate.registry,plan.target)[plan.target],metadata=candidate.metadata.networks[plan.target];
  const requiredAddresses=new Set([...deployed.map(c=>c.address.toLowerCase()),...ready.collection.verification.map(a=>a.address.toLowerCase()),...plan.transactionBindings.filter(b=>b.role==='call').map(b=>plan.transactions.find(t=>t.transactionId===b.transactionId)!.to.toLowerCase())]);
  for(const address of requiredAddresses){
   const rows=Object.entries(registry).filter(([,a])=>a.toLowerCase()===address);if(rows.length!==1)throw Error('Production code target requires unique frozen registration');
@@ -131,7 +132,7 @@ export async function finalizeProductionExecution(input:{root:string;ready:Produ
  function verifyCommitted(journal:any){
   const reg=validateContractInfo(JSON.parse(fileBytes(root,'contractInfo.json')??'{}')),meta=validateDeploymentInfo(JSON.parse(fileBytes(root,'deploymentInfo.json')??'{}'));
   const oldReg=validateContractInfo(JSON.parse(journal.files.find((f:any)=>f.path==='contractInfo.json').after)),oldMeta=validateDeploymentInfo(JSON.parse(journal.files.find((f:any)=>f.path==='deploymentInfo.json').after));
-  for(const key of Object.keys(effective[plan.target])){const alias=key.split(':')[0];same(resolveDeployment(reg,plan.target,alias),resolveDeployment(oldReg,plan.target,alias),'Committed production registration');same(meta.networks[plan.target]?.[alias]??null,oldMeta.networks[plan.target]?.[alias]??null,'Committed production metadata');}
+  for(const key of Object.keys(effective[plan.target])){const alias=key.split(':')[0];same(resolveDeployment(reg,plan.target,alias)??null,resolveDeployment(oldReg,plan.target,alias)??null,'Committed production registration');same(meta.networks[plan.target]?.[alias]??null,oldMeta.networks[plan.target]?.[alias]??null,'Committed production metadata');}
   for(const f of journal.files){
    if(['contractInfo.json','deploymentInfo.json'].includes(f.path))continue;
    const owned=candidates.filter(c=>c.path===f.path);

package/runtime/delivery/production.ts

@@ -39,13 +39,14 @@ function inspect(raw: ProductionOptions, command: ProductionCommand) {
     const input = deepFreeze(strictData(raw));
     exactObject(input, keys, 'production options');
     safeId(input.executionId, 'executionId');
-    const mode = command === 'prepare' ? 'simulate' : command;
-    const request = parseDeliveryRequest({ version: 1, environment: 'prod', purpose: 'prod-execution', mode, network: input.target, operator: input.operator, releaseRef: input.releaseRef, sourceRef: { path: input.handoff, taskId: input.taskId, planKey: input.planKey, rev: input.rev } });
     const release = inspectDeliveryRelease(input);
     if (release.status === 'pending')
         return { status: 'pending' as const, input };
+    const mode = command === 'prepare' ? 'simulate' : command;
+    const native= (require('./release-graph') as typeof import('./release-graph')).standaloneReleaseDefinition(input);
+    const request = parseDeliveryRequest({ version: native?2:1, environment: 'prod', purpose: 'prod-execution', mode, network: input.target, operator: input.operator, releaseRef: input.releaseRef, sourceRef: native?{kind:'standalone',path:input.handoff,deploymentId:input.deploymentId}:{ path: input.handoff, taskId: input.taskId, planKey: input.planKey, rev: input.rev } });
     const source = readOwnedDeliverySource({ workspaceRoot: input.workspaceRoot, projectRoot: input.projectRoot, request });
-    if ((source.invocation.task.scope!.deployment as any).deploymentId !== input.deploymentId)
+    if ((source.scope as any).deploymentId !== input.deploymentId)
         throw Error('Production deployment mismatch');
     const target = release.release.targets.find((t: any) => t.id === input.target);
     if (!target)
@@ -69,7 +70,7 @@ export function inspectDeliveryProduction(raw: ProductionOptions, command: Produ
     if(canonicalJson(deliveryCalls)!==canonicalJson(record.deliveryCalls))throw Error('Frozen production public projection mismatch');
     if (record.releaseHash !== current.releaseHash || plan.inputsHash !== current.release.inputsHash || plan.sourceDefinitionHash !== current.release.sourceDefinitionHash || plan.executionId !== current.input.executionId || plan.target !== current.input.target || plan.operator !== current.input.operator.toLowerCase() || plan.environment !== 'prod' || plan.chainId !== String(current.target.chainId))
         throw Error('Production artifact context mismatch');
-    return deepFreeze({ status: 'ready' as const, plan, collection: record.collection as DeliveryCollection, deliveryCalls, operations: current.release.operations as any[], finalization: record.finalization, releaseHash: current.releaseHash, artifactHash, sha256: byteHash(bytes), path: artifactPath(current.input.executionId), ...(current.target.safe ? { safeTarget: current.target.safe } : {}) });
+    return deepFreeze({ status: 'ready' as const, plan, collection: record.collection as DeliveryCollection, deliveryCalls, parameters:current.release.parameters.find((p:any)=>p.target===current.input.target)?.resolved.values, operations: current.release.operations as any[], finalization: record.finalization, releaseHash: current.releaseHash, artifactHash, sha256: byteHash(bytes), path: artifactPath(current.input.executionId), ...(current.target.safe ? { safeTarget: current.target.safe } : {}) });
 }
 /** Instantiate the delivered business operations, never accept replacement operations or parameters. */
 export async function prepareDeliveryProduction(raw: ProductionOptions) {

package/runtime/delivery/project-files.ts

@@ -35,7 +35,10 @@ export function readFile(root: string, relative: string): string | undefined {
   return stat(file) ? fs.readFileSync(file, 'utf8') : undefined;
 }
 export function deliveryProjectMarker(root: string): void {
-  parseDeliveryProjectMarker(readFile(root, '.gate-template.json') ?? 'null');
+  const marker = readFile(root, '.gate-template.json');
+  // Existing Hardhat projects have no generator provenance. Setup validates their
+  // real configuration and local capabilities without inventing a template identity.
+  if (marker !== undefined) parseDeliveryProjectMarker(marker);
 }
 /** Validate the same captured marker bytes whose digest is bound to current inputs. */
 export function parseDeliveryProjectMarker(bytes: string | Buffer): void {
@@ -52,6 +55,7 @@ export function parseDeliveryProjectMarker(bytes: string | Buffer): void {
   const optional = ['README.md', 'AGENTS.md', '.gitignore'];
   const assets = ['package.json', 'package-lock.json', 'hardhat.config.ts', 'rpc.env', '.env.example', 'tsconfig.json', ...optional, 'contracts/.gitkeep', 'test/.gitkeep',
     'foundry.toml', 'config.yaml',
+    ...(Object.hasOwn(files, 'hardhat.zk.config.ts') ? ['hardhat.zk.config.ts'] : []),
     ...(Object.hasOwn(files, 'vendor/gate-evm-tools-1.2.0.tgz') ? ['vendor/gate-evm-tools-1.2.0.tgz'] : []),
     ...(inputs.examples === true ? ['contracts/Counter.sol', 'test/Counter.ts', 'test/Counter.t.sol'] : [])];
   if (typeof inputs.projectName !== 'string' || !inputs.projectName || !Array.isArray(inputs.networks)

package/runtime/delivery/project-rpc.ts

@@ -10,7 +10,7 @@ export const PROJECT_ENV_BOOTSTRAP = `for (const file of ["rpc.env", ".env"]) {
       process.loadEnvFile(envFile);
     } catch (error) {
       if (file !== ".env" || !["ENOENT", "EPERM", "EACCES"].includes((error as NodeJS.ErrnoException).code ?? "")) throw error;
-      console.warn("Project credentials are unavailable; compilation and public checks can continue. Use the application host for credential-bearing delivery operations.");
+      console.warn("Project credentials are unavailable; compilation and public checks can continue. Use the terminal or App delivery host for credential-bearing operations.");
     }
   }
 }`;
@@ -30,7 +30,11 @@ function statement(source: string): string {
   const file = ts.createSourceFile('rpc.ts', source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
   return syntax(file.statements[0], file);
 }
-const bootstrapSyntax = statement(PROJECT_ENV_BOOTSTRAP), helperSyntax = statement(PROJECT_RPC_HELPER);
+// Retain the previous public diagnostic spelling used by migrated projects;
+// the loader's file access, precedence and error handling remain exact.
+const bootstrapSyntax = new Set([PROJECT_ENV_BOOTSTRAP,
+  PROJECT_ENV_BOOTSTRAP.replace('the terminal or App delivery host for credential-bearing operations', 'the application host for credential-bearing delivery operations'),
+].map(statement)), helperSyntax = statement(PROJECT_RPC_HELPER);
 
 export function projectRpcSyntax(file: ts.SourceFile): { statements: Set<ts.Statement>; bootstrap: boolean; helper: boolean } {
   const statements = new Set<ts.Statement>();
@@ -46,7 +50,7 @@ export function projectRpcSyntax(file: ts.SourceFile): { statements: Set<ts.Stat
         || clause.namedBindings.elements.length !== 1 || clause.namedBindings.elements[0].name.text !== wanted
         || clause.namedBindings.elements[0].propertyName) throw Error('Unsupported project RPC import');
       imports.add(name); statements.add(node);
-    } else if (ts.isForOfStatement(node) && syntax(node, file) === bootstrapSyntax) {
+    } else if (ts.isForOfStatement(node) && bootstrapSyntax.has(syntax(node, file))) {
       if (bootstrap) throw Error('Duplicate project RPC loader');
       bootstrap = true; statements.add(node);
     } else if (ts.isFunctionDeclaration(node) && node.name?.text === 'rpcUrl') {
@@ -97,7 +101,9 @@ function projectEnvironment(root: string, source: string, env: NodeJS.ProcessEnv
       for (const [key, value] of Object.entries(parseEnv(contents))) if (effective[key] === undefined) effective[key] = value;
     } catch (error) {
       if (name === '.env' && ['EPERM', 'EACCES'].includes((error as NodeJS.ErrnoException).code ?? '')) {
-        throw Error('Project credential environment is protected; run credential-bearing delivery operations through the trusted application host. Configure public RPCs in rpc.env.');
+        // Match the canonical Hardhat bootstrap: public RPC configuration can proceed
+        // without a protected credential file. Signing hosts load credentials separately.
+        continue;
       }
       throw Error(`Cannot read local project RPC environment (${name})`);
     }

package/runtime/delivery/protocol.ts

@@ -3,12 +3,12 @@ import { validateNetworkAlias } from './policy';
 export type DeliveryEnvironment = 'dev' | 'prod';
 export type DeliveryMode = 'simulate' | 'execute' | 'export-calldata' | 'reconcile' | 'verify';
 export interface DeliveryRequest {
-  version: 1;
+  version: 1 | 2;
   environment: DeliveryEnvironment;
   purpose: 'dev-execution' | 'prod-qualification' | 'prod-execution';
   mode: DeliveryMode;
   network: string;
-  sourceRef: { path: string; taskId: string; planKey: string; rev: number };
+  sourceRef: { kind?: 'gateflow' | 'standalone'; path: string; taskId?: string; planKey?: string; rev?: number; deploymentId?: string };
   releaseRef?: { path: string; releaseId: string; inputsHash: string };
   fork?: { blockNumber: number; blockHash: string; readOnly: true };
   devSigner?: string;
@@ -43,7 +43,7 @@ export function positiveInteger(value: unknown, label: string): number {
 }
 export function parseDeliveryRequest(input: unknown): DeliveryRequest {
   const value = object(input, 'delivery request', ['version', 'environment', 'purpose', 'mode', 'network', 'sourceRef', 'releaseRef', 'fork', 'devSigner', 'operator']);
-  if (value.version !== 1) throw new Error('Unsupported delivery request version');
+  if (value.version !== 1 && value.version !== 2) throw new Error('Unsupported delivery request version');
   if (typeof value.environment !== 'string' || !['dev', 'prod'].includes(value.environment)) throw new Error('environment must be dev or prod');
   if (typeof value.purpose !== 'string' || !['dev-execution', 'prod-qualification', 'prod-execution'].includes(value.purpose)) throw new Error('Invalid purpose');
   const dev = value.purpose === 'dev-execution';
@@ -51,8 +51,16 @@ export function parseDeliveryRequest(input: unknown): DeliveryRequest {
   const modes = dev ? ['simulate', 'execute', 'reconcile', 'verify'] : value.purpose === 'prod-qualification' ? ['simulate', 'verify'] : ['simulate', 'execute', 'export-calldata', 'reconcile', 'verify'];
   if (typeof value.mode !== 'string' || !modes.includes(value.mode)) throw new Error('Explicit valid mode is required for purpose');
   validateNetworkAlias(value.network, 'network', false);
-  const source = object(value.sourceRef, 'sourceRef', ['path', 'taskId', 'planKey', 'rev']);
-  portablePath(source.path, 'sourceRef.path'); safeId(source.taskId, 'taskId'); safeId(source.planKey, 'planKey'); positiveInteger(source.rev, 'rev');
+  const source = object(value.sourceRef, 'sourceRef', ['kind', 'path', 'taskId', 'planKey', 'rev', 'deploymentId']);
+  portablePath(source.path, 'sourceRef.path');
+  if (value.version === 2 && !['standalone','gateflow'].includes(String(source.kind))) throw Error('v2 requires explicit source kind');
+  if (source.kind === 'standalone') {
+    if (value.version !== 2 || Object.keys(source).some(k=>!['kind','path','deploymentId'].includes(k))) throw Error('Invalid standalone source reference');
+    safeId(source.deploymentId, 'source deploymentId');
+  } else {
+    if (source.kind !== undefined && source.kind !== 'gateflow' || source.deploymentId !== undefined) throw Error('Invalid GateFlow source reference');
+    safeId(source.taskId, 'taskId'); safeId(source.planKey, 'planKey'); positiveInteger(source.rev, 'rev');
+  }
   if (dev) {
     address(value.devSigner, 'devSigner');
     if ('operator' in value) throw new Error('devSigner and prod operator are separate roles');

package/runtime/delivery/query.ts

@@ -0,0 +1,34 @@
+/** Bounded read-only ABI query; no provider or signer is exposed to a business module. */
+import { Interface } from 'ethers';
+import { address, object } from './protocol';
+import { validateAbiArguments, validateAbiValue, normalizeRuntimeValue, compareAbiResults } from './abi';
+import { strictData } from './data';
+import { deepFreeze } from '../workflow/lib/canonicalData';
+import type { ContractQuery } from './scripts';
+export function parseContractQueryEvidence(raw:unknown){
+  const e=object(strictData(raw),'contract query evidence',['chainId','block','source','address','abi','method','args','caller','result','returnTypes']);
+  if(typeof e.chainId!=='string'||!(/^[1-9][0-9]*$/).test(e.chainId))throw Error('Invalid query chain');
+  const block=object(e.block,'query block',['number','hash']),source=object(e.source,'query source',['blockNumber','blockHash']);
+  if(typeof block.number!=='string'||!/^0x[\da-f]+$/i.test(block.number)||typeof block.hash!=='string'||!/^0x[\da-f]{64}$/i.test(block.hash)
+    ||!Number.isSafeInteger(source.blockNumber)||Number(source.blockNumber)<0||typeof source.blockHash!=='string'||!/^0x[\da-f]{64}$/i.test(source.blockHash))throw Error('Invalid query block identity');
+  address(e.address,'query');address(e.caller,'query caller');
+  if(!Array.isArray(e.abi)||e.abi.length!==1||typeof e.abi[0]!=='string')throw Error('Invalid query ABI');
+  const fn=new Interface(e.abi).getFunction(e.method as string);
+  if(!fn||!['view','pure'].includes(fn.stateMutability)||fn.format('sighash')!==e.method)throw Error('Invalid read-only query method');
+  validateAbiArguments(e.abi,fn.format('sighash'),e.args);
+  if(JSON.stringify(fn.outputs.map(p=>p.format('full')))!==JSON.stringify(e.returnTypes))throw Error('Query return types mismatch');
+  if(fn.outputs.length===1)validateAbiValue(fn.outputs[0],e.result,'query result');
+  else {if(!Array.isArray(e.result)||e.result.length!==fn.outputs.length)throw Error('Invalid query result count');fn.outputs.forEach((p,i)=>validateAbiValue(p,(e.result as unknown[])[i],'query result'));}
+  return deepFreeze(e);
+}
+export async function readScriptContract(query: ContractQuery, input:{request(method:string,params:unknown[]):Promise<any>;chainId:string;block:{number:string;hash:string};caller:string;source:{blockNumber:number;blockHash:string}}){
+  const q=object(strictData(query),'contract query',['address','abi','method','args','caller']);
+  address(q.address,'query');if(!Array.isArray(q.abi)||q.abi.some(x=>typeof x!=='string'))throw Error('Query ABI must use function strings');
+  const iface=new Interface(q.abi),fn=iface.getFunction(q.method as string);if(!fn||!['view','pure'].includes(fn.stateMutability))throw Error('readContract requires a view/pure function ABI');
+  const caller=address(q.caller??input.caller,'query caller'),args=q.args??[];validateAbiArguments(q.abi,fn.format('sighash'),args);
+  const data=iface.encodeFunctionData(fn,args as any[]),raw=await input.request('eth_call',[{to:q.address,from:caller,data},input.block.number]);
+  const decoded=iface.decodeFunctionResult(fn,raw),value=normalizeRuntimeValue(fn.outputs.length===1?decoded[0]:decoded);
+  const block=await input.request('eth_getBlockByNumber',[input.block.number,false]);if(block?.hash!==input.block.hash)throw Error('Query block changed');
+  return deepFreeze({value,evidence:parseContractQueryEvidence({chainId:input.chainId,block:input.block,source:input.source,address:(q.address as string).toLowerCase(),abi:[fn.format('full')],method:fn.format('sighash'),args,caller:caller.toLowerCase(),result:value,returnTypes:fn.outputs.map(p=>p.format('full'))})});
+}
+export function requireQueryResult(query:ContractQuery & {expect:unknown},actual:unknown){const c=compareAbiResults(query.abi,query.method,actual,query.expect);if(c.actual!==c.expected)throw Error(`Unmet live dependency ${query.method}: expected ${c.expected}, got ${c.actual}`);}

package/runtime/delivery/release-graph.ts

@@ -1,3 +1,4 @@
+import {readStandaloneTask} from './standalone-source';
 /** Actual-file release graph classification. No caller-selected roots or target subsets. */
 import {parseCanonicalPlan,projectCanonicalDefinitions,deploymentPurpose} from './source';
 import {projectRoot} from './project-files';
@@ -31,7 +32,23 @@ export function readReleaseUniverse(input:Omit<ReleaseGraphOptions,'releaseRef'>
  const upstream=projectCanonicalDefinitions(text,{roots:qualifications.map(t=>t.planKey),mode:'upstream'});
  return {workspace,root,text,plan,entries,relevant,targets,qualifications,upstream,developmentNetwork:task.developmentNetwork as string};
 }
+export function standaloneReleaseDefinition(input:Omit<ReleaseGraphOptions,'releaseRef'>){
+ const root=projectRoot(input.workspaceRoot,input.projectRoot),relative=`scripts/tasks/${safeId(input.deploymentId,'deploymentId')}/task.yaml`;
+ if(input.handoff!==relative)return undefined;
+ const task=object(parseInputDocument(readInputBytes(root,relative),'yaml'),'task');
+ if(task.source!=='standalone')return undefined;
+ if(input.handoff!==relative||input.taskId!==input.deploymentId)throw Error('Native release source mismatch');
+ return readStandaloneTask(root,relative);
+}
+export function selectedReleaseTargets(input:Omit<ReleaseGraphOptions,'releaseRef'>){return standaloneReleaseDefinition(input)?.releaseTargetNetworks??readReleaseUniverse(input).targets;}
 export function readReleaseGraph(input:ReleaseGraphOptions){
+ const native=standaloneReleaseDefinition(input);
+ if(native){
+  safeId(input.releaseRef.releaseId,'releaseId');if(input.releaseRef.path!==`scripts/tasks/${input.deploymentId}/releases/${input.releaseRef.releaseId}/release.json`||!/^[a-f0-9]{64}$/.test(input.releaseRef.inputsHash))throw Error('Invalid native release reference');
+  const graph={schema:'gate-delivery-standalone-release',version:1,definition:native,releaseRef:input.releaseRef,targets:native.releaseTargetNetworks,stages:['qualify','prepare','execute-or-export','reconcile','verify']};
+  return deepFreeze({targets:native.releaseTargetNetworks,graph,prodTaskGraphHash:semanticHash(graph)});
+ }
+
  const u=readReleaseUniverse(input);safeId(input.releaseRef.releaseId,'releaseId');portablePath(input.releaseRef.path,'releaseRef.path');if(!/^[a-f0-9]{64}$/.test(input.releaseRef.inputsHash))throw Error('Invalid release input hash');
  // Classify ALL relevant production tasks first. Filtering a good ref first conceals split/wrong bindings.
  const groups=new Map<string,typeof u.relevant>();

package/runtime/delivery/release-history-capture.ts

@@ -1,32 +1,43 @@
-/** Narrow R1→R2 handoff: capture the currently installed producer and changing containers BEFORE prod edits. */
+/** Preserve accepted development inputs and one shared, compressed producer snapshot. */
 import fs from 'node:fs';
 import path from 'node:path';
 import {gzipSync} from 'node:zlib';
 import {readInputBytes} from './input-files';
 import {confinedFile,projectRoot} from './project-files';
-import {atomicDevelopmentWrite,byteHash,developmentPath} from './materialization';
+import {byteHash,developmentPath} from './materialization';
 import {canonicalJson,semanticHash} from '../workflow/lib/canonicalData';
 import {parseDeliveryPlan} from './plan';
 import {safeId} from './protocol';
+import {persistDevelopmentInputs,writeImmutableDeliveryFile} from './development-inputs';
 import type {DeliveryAggregate,DeliveryAggregateOptions} from './aggregate';
 import type {HistoricalDevelopmentFiles} from './release-history';
 export function captureDevelopmentReleaseHistory(input:{root:string;source:DeliveryAggregateOptions;aggregate:DeliveryAggregate}):HistoricalDevelopmentFiles {
  const root=fs.realpathSync(input.root),a=input.aggregate,plan=parseDeliveryPlan(a.collections[0]?.plan);
  if(input.source.selection!=='development'||a.collections.length!==1||plan.environment!=='dev'||projectRoot(input.source.workspaceRoot,input.source.projectRoot)!==root)throw Error('Historical capture requires original development source');
  safeId(plan.executionId,'executionId');
- const base=`.gate-delivery/history/${plan.executionId}`,readyPath=`${base}/READY.json`;
+ const base=`.gate-delivery/history/${plan.executionId}`,readyFile=`${base}/READY.json`;
  const acceptanceFile=`.gate-delivery/development/${plan.executionId}.acceptance.json`,acceptance=JSON.parse(readInputBytes(root,acceptanceFile).toString());
  if(acceptance.status!=='accepted'||acceptance.planHash!==plan.planHash||acceptance.inputsHash!==a.inputsHash||semanticHash(acceptance.runtimeIdentity)!==semanticHash(plan.runtimeIdentity))throw Error('Historical capture requires actual accepted development');
  const original=a.inputs.runtime.package;if(original.name!=='gate-evm-tools'||original.lockLocation!=='node_modules/gate-evm-tools')throw Error('Unsupported historical producer location');
+ // A completed capture can be reused after the installed producer changes.
+ if(fs.existsSync(developmentPath(root,readyFile))){
+  const ready=JSON.parse(readInputBytes(root,readyFile).toString());
+  if(ready.schema!=='gate-delivery-history-ready'||ready.version!==2||ready.generation!=='complete'||ready.planHash!==plan.planHash||ready.aggregateHash!==semanticHash(a)||ready.sourceHash!==semanticHash(input.source)||ready.descriptor?.version!==2||ready.descriptor.readyFile!==readyFile||!Array.isArray(ready.files)||!ready.files.length)throw Error('Conflicting historical capture');
+  for(const f of ready.files)if(byteHash(readInputBytes(root,f.path))!==f.sha256)throw Error('Captured historical file drift');
+  return ready.descriptor;
+ }
  const files:Array<{path:string;digest:string;base64:string}>=[];
  const visit=(relative:string)=>{const dir=confinedFile(root,`${original.lockLocation}/${relative}`.replace(/\/$/,''),'directory');for(const name of fs.readdirSync(dir).sort()){const rel=relative?`${relative}/${name}`:name;const stat=fs.lstatSync(path.join(dir,name));if(stat.isDirectory()){if(name==='node_modules')continue;visit(rel);}else{const bytes=readInputBytes(root,`${original.lockLocation}/${rel}`);files.push({path:rel,digest:byteHash(bytes),base64:bytes.toString('base64')});}}};visit('');files.sort((a,b)=>a.path<b.path?-1:a.path>b.path?1:0);
  if(semanticHash(files.map(({path,digest})=>({path,digest})))!==semanticHash(original.payload))throw Error('Historical capture must precede producer/runtime replacement');
- const descriptor:HistoricalDevelopmentFiles={aggregateFile:`${base}/aggregate.json`,sourceFile:`${base}/source.json`,acceptanceFile,packageRoot:`${base}/package`,inputsRoot:`${base}/inputs`,archiveFile:`${base}/package.snapshot.json.gz`};
- if(fs.existsSync(developmentPath(root,readyPath))){const ready=JSON.parse(readInputBytes(root,readyPath).toString());if(ready.schema!=='gate-delivery-history-ready'||ready.generation!=='complete'||ready.planHash!==plan.planHash||ready.aggregateHash!==semanticHash(a))throw Error('Conflicting historical capture');for(const f of ready.files)if(byteHash(readInputBytes(root,f.path))!==f.sha256)throw Error('Captured historical file drift');return descriptor;}
+ const archive=gzipSync(Buffer.from(canonicalJson({schema:'gate-delivery-package-snapshot',version:2,runtimeIdentity:plan.runtimeIdentity,observedPackage:original,files})));
+ const archiveFile=`.gate-delivery/packages/${byteHash(archive)}.json.gz`;
  const saved:Array<{path:string;sha256:string}>=[];
- const write=(relative:string,bytes:Buffer)=>{const file=developmentPath(root,relative);fs.mkdirSync(path.dirname(file),{recursive:true,mode:0o700});if(fs.existsSync(file)&&!readInputBytes(root,relative).equals(bytes))throw Error('Partial historical capture conflict');const fd=fs.openSync(file,'w',0o600);try{fs.writeFileSync(fd,bytes);fs.fsyncSync(fd);}finally{fs.closeSync(fd);}saved.push({path:relative,sha256:byteHash(bytes)});};
- for(const file of files)write(`${base}/package/${file.path}`,Buffer.from(file.base64,'base64'));
- for(const name of [`${a.inputs.business.businessRoot}/task.yaml`,`${a.inputs.business.businessRoot}/parameters.yaml`,`${a.inputs.business.businessRoot}/parameters.provenance.json`,'config.yaml','hardhat.config.ts','package-lock.json','contractInfo.json','deploymentInfo.json'])write(`${base}/inputs/${name}`,readInputBytes(root,name));
- write(descriptor.aggregateFile,Buffer.from(canonicalJson(a)+'\n'));write(descriptor.sourceFile,Buffer.from(canonicalJson(input.source)+'\n'));write(descriptor.archiveFile,gzipSync(Buffer.from(canonicalJson({schema:'gate-delivery-package-snapshot',version:1,runtimeIdentity:plan.runtimeIdentity,observedPackage:original,files}))));
- atomicDevelopmentWrite(root,readyPath,canonicalJson({schema:'gate-delivery-history-ready',version:1,generation:'complete',planHash:plan.planHash,aggregateHash:semanticHash(a),descriptor,files:saved})+'\n');return descriptor;
+ const write=(relative:string,bytes:Buffer)=>saved.push(writeImmutableDeliveryFile(root,relative,bytes));
+ const {sourcePath:sourceFile,aggregatePath:aggregateFile}=persistDevelopmentInputs(input);
+ const descriptor:HistoricalDevelopmentFiles={version:2,aggregateFile,sourceFile,acceptanceFile,readyFile,inputsRoot:`${base}/inputs`,archiveFile};
+ for(const relative of [sourceFile,aggregateFile,acceptanceFile])saved.push({path:relative,sha256:byteHash(readInputBytes(root,relative))});
+ const snapshot=JSON.parse(readInputBytes(root,`.gate-delivery/development/${plan.executionId}.inputs.snapshot.json`).toString());
+ for(const name of [`${a.inputs.business.businessRoot}/task.yaml`,`${a.inputs.business.businessRoot}/parameters.yaml`,`${a.inputs.business.businessRoot}/parameters.provenance.json`,'config.yaml','hardhat.config.ts','package-lock.json','contractInfo.json','deploymentInfo.json']){const original=snapshot.files.find((f:any)=>f.path===name);write(`${base}/inputs/${name}`,original?Buffer.from(original.base64,'base64'):readInputBytes(root,name));}
+ write(archiveFile,archive);
+ writeImmutableDeliveryFile(root,readyFile,Buffer.from(canonicalJson({schema:'gate-delivery-history-ready',version:2,generation:'complete',planHash:plan.planHash,aggregateHash:semanticHash(a),sourceHash:semanticHash(input.source),descriptor,files:saved})+'\n'));return descriptor;
 }

package/runtime/delivery/release-history.ts

@@ -1,19 +1,18 @@
 /** Read-only consumption of R1 evidence. Historical runtime is verified, never executed or relabelled. */
-import {existingCodeCoverage,requiredExistingAddresses} from './existing-code';
+import {existingCodeCoverage,requiredExistingAddresses,interactionCoverageRegistry} from './existing-code';
 import fs from 'node:fs';
 import {aggregateInputHash} from './execution-identity';
 export {aggregateInputHash} from './execution-identity';
 import path from 'node:path';
-import {createHash} from 'node:crypto';
-import {gzipSync,gunzipSync} from 'node:zlib';
 import {Contract,JsonRpcProvider} from 'ethers';
 import {BytecodeChecker,TRANSPARENT_PROXY_ARTIFACT,PROXY_ADMIN_ARTIFACT,ERC1967_ADMIN_SLOT,PROXY_ADMIN_INTERFACE,transparentAdminAddress,assertTransparentAdminImmutable} from 'gate-evm-tools/workflow';
 import {readInputBytes,inputDigest,parseInputDocument} from './input-files';
-import {confinedFile,projectRoot} from './project-files';
+import {projectRoot} from './project-files';
 import {parseCanonicalPlan,projectCanonicalDefinitions} from './source';
 import {parseConfigurationDefinition} from './configuration-definition';
 import {parseDeliveryPublicTargets} from './config';
-import {object} from './protocol';
+import {object,safeId} from './protocol';
+import {readHistoricalPackage} from './history-package';
 import {readProjectNetworkSnapshots} from './project';
 import {parseDeliveryPlan} from './plan';
 import {parsePreparationJournal} from './journal';
@@ -33,35 +32,32 @@ import {resolveParameterTargets} from './parameter-defaults';
 import {validateHistoricalParameterExtension,type ParameterInputs} from './parameters';
 import {validateHistoricalBusinessExtension} from './business-extension';
 import {parseNativeOperation} from './custom';
-export interface HistoricalDevelopmentFiles {aggregateFile:string;sourceFile:string;acceptanceFile:string;packageRoot:string;inputsRoot:string;archiveFile:string}
+export interface HistoricalDevelopmentFiles {version:2;aggregateFile:string;sourceFile:string;acceptanceFile:string;readyFile:string;inputsRoot:string;archiveFile:string}
 function decode(raw:any):any{const v=parseTypedValue(raw);switch(v.type){case 'bigint':return BigInt(v.value);case 'number':return Number(v.value);case 'array':return v.value.map(decode);case 'object':return Object.fromEntries(Object.entries(v.value).map(([k,x])=>[k,decode(x)]));default:return v.value;}}
 /** Every mutable historical container is retained with its ORIGINAL digest; allowed deltas are explicit. */
 export function validateHistoricalDevelopmentFiles(input:{root:string;workspaceRoot:string;projectRoot:string;history:HistoricalDevelopmentFiles}){
  const workspace=projectRoot(input.workspaceRoot,'.'),root=projectRoot(workspace,input.projectRoot),{history}=input,files=new Map<string,string>();
  if(fs.realpathSync(input.root)!==root)throw Error('Historical current project root mismatch');
+ object(history,'historical descriptor',['version','aggregateFile','sourceFile','acceptanceFile','readyFile','inputsRoot','archiveFile']);
+ if(history.version!==2)throw Error('Unsupported historical descriptor version');
  const read=(relative:string)=>{const bytes=readInputBytes(root,relative);files.set(relative,inputDigest(bytes));return bytes;};
  const aggregate=JSON.parse(read(history.aggregateFile).toString()) as DeliveryAggregate,source=JSON.parse(read(history.sourceFile).toString()) as DeliveryAggregateOptions,acceptance=JSON.parse(read(history.acceptanceFile).toString());
  if(source.projectRoot!==input.projectRoot)throw Error('Historical relative project scope mismatch');
  if(source.selection!=='development'||source.targets.length!==1||aggregate.collections.length!==1||aggregate.inputs.business.targets.length!==1)throw Error('Historical development scope mismatch');
  same(aggregateInputHash(aggregate),aggregate.inputsHash,'Historical aggregate inputs');same(semanticHash(aggregate.inputs.sourceDefinitions),aggregate.sourceDefinitionHash,'Historical source hash');
  const collection=aggregate.collections[0],plan=parseDeliveryPlan(collection.plan),target=aggregate.inputs.business.targets[0];
+ const id=safeId(plan.executionId,'executionId'),base=`.gate-delivery/history/${id}`;
+ if(history.aggregateFile!==`.gate-delivery/development/${id}.aggregate.json`||history.sourceFile!==`.gate-delivery/development/${id}.source.json`||history.acceptanceFile!==`.gate-delivery/development/${id}.acceptance.json`||history.readyFile!==`${base}/READY.json`||history.inputsRoot!==`${base}/inputs`||!/^\.gate-delivery\/packages\/[a-f0-9]{64}\.json\.gz$/.test(history.archiveFile))throw Error('Noncanonical historical descriptor');
  if(plan.environment!=='dev'||plan.target!==target.id||source.targets[0].request.network!==plan.target||source.targets[0].executionId!==plan.executionId)throw Error('Historical development identity mismatch');
  for(const key of ['executionId','planHash','target','inputsHash','sourceDefinitionHash','runtimeIdentity'] as const)same(acceptance[key],plan[key],`Historical acceptance ${key}`);
  if(acceptance.version!==1||acceptance.status!=='accepted')throw Error('Missing historical acceptance');
- const readyPath=path.posix.dirname(history.aggregateFile)+'/READY.json',ready=JSON.parse(read(readyPath).toString());
- if(ready.schema!=='gate-delivery-history-ready'||ready.version!==1||ready.generation!=='complete'||ready.planHash!==plan.planHash||ready.aggregateHash!==semanticHash(aggregate)||!Array.isArray(ready.files)||!ready.files.length)throw Error('Historical snapshot generation is not READY');
+ const ready=JSON.parse(read(history.readyFile).toString());
+ if(ready.schema!=='gate-delivery-history-ready'||ready.version!==2||ready.generation!=='complete'||ready.planHash!==plan.planHash||ready.aggregateHash!==semanticHash(aggregate)||ready.sourceHash!==semanticHash(source)||!Array.isArray(ready.files)||!ready.files.length)throw Error('Historical snapshot generation is not READY');
  same(ready.descriptor,history,'Historical READY descriptor');for(const file of ready.files)if(byteHash(read(file.path))!==file.sha256)throw Error('Historical READY file binding mismatch');
  const original=aggregate.inputs.runtime.package;
  same(aggregate.inputs.runtime.declared,plan.runtimeIdentity,'Historical runtime identity');
  if(original.name!=='gate-evm-tools'||original.version!==plan.runtimeIdentity.version||original.source.identity!==original.integrity)throw Error('Historical producer provenance mismatch');
- const archive=read(history.archiveFile),snapshot=JSON.parse(gunzipSync(archive).toString());
- if(snapshot.schema!=='gate-delivery-package-snapshot'||snapshot.version!==1||!Array.isArray(snapshot.files))throw Error('Invalid historical package snapshot archive');
- const archived=snapshot.files.map((f:any)=>{const bytes=Buffer.from(f.base64,'base64');if(bytes.toString('base64')!==f.base64||byteHash(bytes)!==f.digest)throw Error('Historical snapshot archive bytes mismatch');return {path:f.path,digest:f.digest};});
- same(archived,original.payload,'Historical archive complete payload');same(snapshot.observedPackage,original,'Historical snapshot provenance');same(snapshot.runtimeIdentity,plan.runtimeIdentity,'Historical snapshot runtime');
- const payload:Array<{path:string;digest:string}>=[];
- const visit=(relative:string)=>{const dir=confinedFile(root,`${history.packageRoot}/${relative}`.replace(/\/$/,''),'directory');for(const name of fs.readdirSync(dir).sort()){if(name==='node_modules')throw Error('Historical producer nested package unsupported');const rel=relative?`${relative}/${name}`:name,p=confinedFile(root,`${history.packageRoot}/${rel}`,fs.lstatSync(path.join(dir,name)).isDirectory()?'directory':'file');if(fs.lstatSync(p).isDirectory())visit(rel);else payload.push({path:rel,digest:inputDigest(read(`${history.packageRoot}/${rel}`))});}};
- visit('');payload.sort((a,b)=>a.path<b.path?-1:a.path>b.path?1:0);same(payload,original.payload,'Historical producer actual payload');same(byteHash(payload.map(f=>`${f.path}\0${f.digest}\n`).join('')),original.payloadDigest,'Historical payload digest');
- const digest=createHash('sha256');const hashDir=(dir:string)=>{for(const name of fs.readdirSync(confinedFile(root,`${history.packageRoot}/${dir}`,'directory')).sort()){const rel=`${dir}/${name}`,file=confinedFile(root,`${history.packageRoot}/${rel}`,fs.lstatSync(path.join(root,history.packageRoot,rel)).isDirectory()?'directory':'file');if(fs.lstatSync(file).isDirectory())hashDir(rel);else if(/\.(?:c?js)$/.test(rel)){digest.update(rel);digest.update(read(`${history.packageRoot}/${rel}`));}}};for(const dir of ['dist-runtime','dist','dist-cjs','bin'])hashDir(dir);same(digest.digest('hex'),plan.runtimeIdentity.digest,'Historical executable runtime digest');
+ const archive=read(history.archiveFile),packageFiles=readHistoricalPackage(archive,history.archiveFile,aggregate);
  const business=aggregate.inputs.business.businessRoot,mutable=new Set([`${business}/task.yaml`,`${business}/parameters.yaml`,`${business}/parameters.provenance.json`,'config.yaml','hardhat.config.ts']);
  const old=(file:string)=>read(`${history.inputsRoot}/${file}`),now=(file:string)=>read(file);
  const evolving=new Set([`${business}/manifest.yaml`,`${business}/parameters.schema.json`].filter(file=>{
@@ -81,7 +77,7 @@ export function validateHistoricalDevelopmentFiles(input:{root:string;workspaceR
  }
  const ownPayload=new Set(original.payload.map(file=>`${original.lockLocation}/${file.path}`));
  // The entire old frozen file union is verified. Only owned producer bytes and bounded containers have historical locations.
- for(const file of aggregate.inputs.files){if(evolving.has(file.path))continue;const bytes=ownPayload.has(file.path)?read(`${history.packageRoot}/${file.path.slice(original.lockLocation.length+1)}`):mutable.has(file.path)?old(file.path):now(file.path);if(inputDigest(bytes)!==file.digest)throw Error(`Historical immutable input drift: ${file.path}`);}
+ for(const file of aggregate.inputs.files){if(evolving.has(file.path))continue;const bytes=ownPayload.has(file.path)?packageFiles.get(file.path.slice(original.lockLocation.length+1))!:mutable.has(file.path)?old(file.path):now(file.path);if(inputDigest(bytes)!==file.digest)throw Error(`Historical immutable input drift: ${file.path}`);}
  const oldTask=parseInputDocument(old(`${business}/task.yaml`),'yaml') as any,newTask=parseInputDocument(now(`${business}/task.yaml`),'yaml') as any;
  const {productionRequirementRef:_production,...newBase}=newTask;
  same({...newBase,releaseTargetNetworks:oldTask.releaseTargetNetworks,...(oldTask.productionRequirementRef===undefined?{}:{productionRequirementRef:oldTask.productionRequirementRef})},oldTask,'Historical development task container');
@@ -114,10 +110,15 @@ export function validateHistoricalDevelopmentFiles(input:{root:string;workspaceR
  // A custom script reading a whole changed container makes the relaxed projection unsafe.
  const dependencyFiles=[...aggregate.inputs.targets.flatMap(t=>t.custom?.files??[]),...aggregate.inputs.business.parameters.flatMap(p=>p.closure?.files??[])];
  for(const file of dependencyFiles)if(inputDigest(now(file.path))!==file.digest)throw Error('Historical custom/producer dependency changed');
+ if(source.targets[0].request.sourceRef.kind==='standalone'){
+  const native=require('./standalone-source').readStandaloneTask(root,source.targets[0].request.sourceRef.path);
+  const historical=(aggregate.inputs.sourceDefinitions as any[]);same({...native,releaseTargetNetworks:oldTask.releaseTargetNetworks},historical[0]?.definition,'Historical native scope with bounded prod expansion');
+ } else {
  const handoff=source.targets[0].request.sourceRef.path,text=readInputBytes(workspace,handoff).toString(),actual=parseCanonicalPlan(text);if(actual.taskId!==source.targets[0].request.sourceRef.taskId)throw Error('Historical task source identity mismatch');
- const projection=projectCanonicalDefinitions(text,{roots:[source.targets[0].request.sourceRef.planKey],mode:'upstream'}).snapshot;
+ const projection=projectCanonicalDefinitions(text,{roots:[source.targets[0].request.sourceRef.planKey!],mode:'upstream'}).snapshot;
  const normalize=(v:any)=>{const copy=JSON.parse(canonicalJson(v));for(const t of copy.tasks)if(t.scope?.deployment&&Object.hasOwn(t.scope.deployment,'releaseTargetNetworks'))t.scope.deployment.releaseTargetNetworks=oldTask.releaseTargetNetworks;return copy;};
  const historical=(aggregate.inputs.sourceDefinitions as any[]);if(historical.length!==1||historical[0].path!==handoff)throw Error('Historical source document mismatch');same(normalize(projection),historical[0].definition,'Historical upstream definition with bounded prod expansion');
+ }
  const expected=expectedDevelopmentAssertions(collection,aggregate.inputs.business.steps);
  if(!Array.isArray(acceptance.assertions)||acceptance.assertions.length!==expected.length)throw Error('Missing development business assertions');
  for(const [index,raw] of acceptance.assertions.entries()){const assertion=parseVerificationObservation(raw);same({...assertion,actual:expected[index].actual},expected[index],'Historical complete typed assertion');const comparable=compareAbiResults(assertion.abi,assertion.method,decode(assertion.actual),decode(assertion.expected));if(comparable.actual!==comparable.expected)throw Error('Historical business assertion failed');}
@@ -140,7 +141,7 @@ export function validateHistoricalDevelopmentFiles(input:{root:string;workspaceR
  if(!Array.isArray(record.changes))throw Error('Missing development registry changes');
  const expectedCode:ExpectedDevelopmentCode[]=[],effective:any={[plan.target]:{}};
  for(const change of record.changes){effective[plan.target][change.contractInfoKey]=change.address;const key=change.contractInfoKey.split(':')[0];expectedCode.push({key,contract:change.actualContract,address:change.implementationAddress??change.address});if(change.proxyKind)expectedCode.push({key:`${key}_Proxy`,contract:change.proxyKind==='transparent'?'TransparentUpgradeableProxy':'ERC1967Proxy',address:change.address});if(change.proxyKind==='transparent')expectedCode.push({key:`${key}_ProxyAdmin`,contract:'ProxyAdmin',address:change.proxyAdminAddress});}
- const pure=!preparations.length?existingCodeCoverage({target:plan.target,addresses:requiredExistingAddresses(collection),registry:JSON.parse(historicalRegistration('contractInfo.json').toString()),metadata:JSON.parse(historicalRegistration('deploymentInfo.json').toString()),compiler:aggregate.inputs.targets.find(t=>t.target===plan.target)!.compiler,manifests:(acceptance.materialization.manifests??[]).map((m:any)=>({path:m.file,contents:now(m.file).toString()}))}):null;
+ const pure=!preparations.length?existingCodeCoverage({target:plan.target,addresses:requiredExistingAddresses(collection),registry:interactionCoverageRegistry(collection,JSON.parse(historicalRegistration('contractInfo.json').toString()),plan.target),metadata:JSON.parse(historicalRegistration('deploymentInfo.json').toString()),compiler:aggregate.inputs.targets.find(t=>t.target===plan.target)!.compiler,manifests:(acceptance.materialization.manifests??[]).map((m:any)=>({path:m.file,contents:now(m.file).toString()}))}):null;
  if(pure){if(record.changes.length)throw Error('Pure-call history cannot invent deployment changes');Object.assign(effective,pure.effective);expectedCode.push(...pure.expected);same(acceptance.materialization.manifests,pure.manifests,'Historical existing manifests');}
  const code=acceptance.checkCode;if(code?.version!==1||code.executionId!==plan.executionId||code.planHash!==plan.planHash||code.target!==plan.target||typeof code.rawFile!=='string'||!code.rawFile.startsWith(`.gate-delivery/check-code/${plan.executionId}/`))throw Error('Missing real CheckCode identity');
  same(byteHash(historicalRegistration('contractInfo.json')),code.registryHash,'Historical registry');same(byteHash(historicalRegistration('deploymentInfo.json')),code.metadataHash,'Historical deployment metadata');same(byteHash(canonicalJson(effective)+'\n'),code.effectiveHash,'Historical CheckCode effective registry');

package/runtime/delivery/release.ts

@@ -13,7 +13,7 @@ import {parsePreparationJournal} from './journal';
 import {expectedDevelopmentAssertions} from './development';
 import {verifyCapturedForkAudit} from './forkAudit';
 import {parseCanonicalPlan,projectCanonicalDefinitions} from './source';
-import {readReleaseUniverse,currentReleasePrerequisites,readReleaseGraph,isDevelopmentAcceptancePrerequisite,sameReleaseData as same,type ReleaseGraphOptions} from './release-graph';
+import {readReleaseUniverse,standaloneReleaseDefinition,selectedReleaseTargets,currentReleasePrerequisites,readReleaseGraph,isDevelopmentAcceptancePrerequisite,sameReleaseData as same,type ReleaseGraphOptions} from './release-graph';
 import {aggregateInputHash,validateHistoricalDevelopmentFiles,verifyHistoricalDevelopmentChain,type HistoricalDevelopmentFiles} from './release-history';
 import {atomicDevelopmentWrite,fileBytes,withDevelopmentFileLock,byteHash} from './materialization';
 import {canonicalJson,deepFreeze,semanticHash,exactObject} from '../workflow/lib/canonicalData';
@@ -49,6 +49,8 @@ function taskEvidence(input:Scope&{planKey:string}){
 export function recordDeliveryPrerequisite(input:Scope&{planKey:string}){const {root,envelope}=taskEvidence(input);atomicDevelopmentWrite(root,prerequisitePath(input.taskId,input.planKey),encode(envelope));return deepFreeze(envelope);}
 export function validateDeliveryPrerequisite(input:Scope&{planKey:string}){const {root,envelope}=taskEvidence(input),actual=JSON.parse(readInputBytes(root,prerequisitePath(input.taskId,input.planKey)).toString());same(actual,envelope,'Current prerequisite report/artifact binding');return deepFreeze(actual);}
 function prerequisites(scope:Scope,history:ReturnType<typeof validateHistoricalDevelopmentFiles>){
+ const native=standaloneReleaseDefinition(scope);
+ if(native){if(history.source.targets[0].request.sourceRef.kind!=='standalone'||history.plan.deploymentId!==native.deploymentId||history.plan.target!==native.developmentNetwork)throw Error('Native release requires its own real accepted development');return [{source:'standalone',executionId:history.plan.executionId,planHash:history.plan.planHash,acceptanceHash:semanticHash(history.acceptance)}];}
  const current=currentReleasePrerequisites(scope),receipts=[];
  for(const {task} of current.required){if(isDevelopmentAcceptancePrerequisite(task)){const d=task.scope?.deployment as any;if(d?.environment!=='dev'||d.targetNetwork!==history.plan.target||d.deploymentId!==history.plan.deploymentId)throw Error('Development prerequisite scope mismatch');if(!verificationOnly(task)&&(task.planKey!==history.source.targets[0].request.sourceRef.planKey||task.rev!==history.source.targets[0].request.sourceRef.rev))throw Error('Stale development prerequisite revision');const evidence=task.result?.evidence;if(!Array.isArray(evidence)||!evidence.some((e:any)=>e.ref===scopePath(history,verificationOnly(task))))throw Error('Development prerequisite must reference actual acceptance/CheckCode');receipts.push({planKey:task.planKey,rev:task.rev,definitionHash:semanticHash(projectCanonicalDefinitions(current.text,{roots:[task.planKey],mode:'full'}).snapshot),evidenceHash:semanticHash(verificationOnly(task)?history.acceptance.checkCode:history.acceptance)});}
   else receipts.push(validateDeliveryPrerequisite({...scope,planKey:task.planKey}));}
@@ -83,16 +85,17 @@ function currentCandidate(scope:Scope,c:any,requireCommittedSources=false){
  same(openAggregateSources({workspaceRoot:scope.workspaceRoot,projectRoot:scope.projectRoot,requests:c.targets.map((t:any)=>t.request)}).definitions,c.aggregate.inputs.sourceDefinitions,'Current full upstream source');
  const h=validateHistoricalDevelopmentFiles({root,workspaceRoot:scope.workspaceRoot,projectRoot:scope.projectRoot,history:c.development});same(h.association,c.historical.association,'Historical development association');same(prerequisites(scope,h),c.prerequisites,'Current prerequisite evidence');
  same(h.files.filter(f=>historicalRegistrationFile(f.path)),c.historical.files.filter((f:any)=>historicalRegistrationFile(f.path)),'Original historical registry baseline');
- same(readReleaseUniverse(scope).targets,c.aggregate.inputs.business.targets.map((t:any)=>t.id),'Current full selected target set');
+ same(selectedReleaseTargets(scope),c.aggregate.inputs.business.targets.map((t:any)=>t.id),'Current full selected target set');
  return {root,source,history:h};
 }
 /** Qualification is generated by the actual owned aggregate, never accepted from caller JSON. */
 export async function prepareDeliveryRelease(raw:ReleasePreparationOptions){
  const input=strictData(raw);exactObject(input,['workspaceRoot','projectRoot','handoff','taskId','deploymentId','releaseId','targets','development'],'release preparation');safeId(input.releaseId,'releaseId');
- const {workspaceRoot,projectRoot:relative,handoff,taskId,deploymentId}=input,scope={workspaceRoot,projectRoot:relative,handoff,taskId,deploymentId},u=readReleaseUniverse(scope),root=u.root;
+ const {workspaceRoot,projectRoot:relative,handoff,taskId,deploymentId}=input,scope={workspaceRoot,projectRoot:relative,handoff,taskId,deploymentId},native=standaloneReleaseDefinition(scope),u=native?undefined:readReleaseUniverse(scope),root=projectRoot(workspaceRoot,relative);
  if(path.resolve(process.cwd())!==root)throw Error('Release preparation must run from actual project root');
  if(fileBytes(root,`scripts/tasks/${deploymentId}/releases/${input.releaseId}/release.json`)!==null)throw Error('Release already has a ready marker');
- same(input.targets.map(t=>({network:t.request.network,sourceRef:t.request.sourceRef,purpose:t.request.purpose,environment:t.request.environment,mode:t.request.mode})),u.qualifications.map(t=>({network:(t.scope!.deployment as any).targetNetwork,sourceRef:{path:handoff,taskId,planKey:t.planKey,rev:t.rev},purpose:'prod-qualification',environment:'prod',mode:'simulate'})),'Exact current qualification tasks');
+ if(native){same(input.targets.map(t=>({network:t.request.network,kind:t.request.sourceRef.kind,path:t.request.sourceRef.path,deploymentId:t.request.sourceRef.deploymentId,purpose:t.request.purpose})),native.releaseTargetNetworks.map(network=>({network,kind:'standalone',path:handoff,deploymentId,purpose:'prod-qualification'})),'Native exact qualification targets');}
+ else same(input.targets.map(t=>({network:t.request.network,sourceRef:t.request.sourceRef,purpose:t.request.purpose,environment:t.request.environment,mode:t.request.mode})),u!.qualifications.map(t=>({network:(t.scope!.deployment as any).targetNetwork,sourceRef:{path:handoff,taskId,planKey:t.planKey,rev:t.rev},purpose:'prod-qualification',environment:'prod',mode:'simulate'})),'Exact current qualification tasks');
  const history=validateHistoricalDevelopmentFiles({root,workspaceRoot,projectRoot:relative,history:input.development}),prerequisiteEvidence=prerequisites(scope,history);
  const committedBefore=captureCommittedContractSource(root,history.aggregate);
  await verifyHistoricalDevelopmentChain(history,root);