@jc_stack/ez-agents 0.1.0-beta.12 → 0.1.0-beta.18

package/docs/upgrades.md

@@ -2,8 +2,9 @@
 
 Available in this beta. Earlier main upgrade/rollback VM QA passed; final-release
 fresh-host/reboot and live plugin upgrade acceptance remain pending. npm
-publication is not required to test this feature. Stable releases are the default
-automatic channel. The existing owner may select beta or manual policy per target.
+publication is not required to test this feature. The beta channel is the default
+automatic channel for core and plugins without a saved policy. Existing explicit
+stable or manual policies are preserved. The owner may select either per target.
 The main target and installed plugins version independently.
 
 The agent owns release review, policy decisions and communication. The host
@@ -109,8 +110,8 @@ live. A healthy container alone does not prove a Telegram or plugin reply.
 
 ```sh
 ez updates check
-ez updates policy main                 # defaults: automatic, stable
-ez updates policy whatsapp beta        # only under owner authorization
+ez updates policy main                 # defaults: automatic, beta
+ez updates policy whatsapp stable      # opt into stable-only updates
 ez updates policy main manual          # disable unattended upgrades
 ez updates prepare main --version 0.1.0-beta.4
 # Or a local candidate, independently of npm:
@@ -191,3 +192,22 @@ changes also need supervisor restart and requesting-process-exit tests. Run
 `node docker/upgrade-smoke.mjs` with a local `EZ_WHATSAPP_SOURCE` containing the
 WhatsApp fixture. The smoke uses synthetic transport only. VM installation,
 agent-led upgrades, restart and real account acceptance remain separate QA gates.
+
+Beta policy discovers the newer of npm latest and the legacy beta tag. Stable-only
+policy selects non-deprecated stable versions, even when latest is a prerelease.
+No eligible version is reported as available:null with newer:false. Older installed
+updaters need an exact-version core update to adopt this discovery behavior.
+
+## Shared agent guidance
+
+Ez includes `templates/agent-guidance.md` from the running package in every
+owner-worker prompt, including resumed CLI and desktop conversations and scheduled
+owner work. After the runtime upgrades, the next turn receives the new guidance.
+An already running turn keeps its original prompt. Restricted contact tasks and
+reply-only workers retain their separate, bounded instructions.
+
+Keep general operating defaults in this package-owned file. Keep agent purpose,
+preferences and local conventions in the workspace's `AGENTS.md`, `SOUL.md`,
+`USER.md` and memory files; upgrades preserve them. Shared guidance does not
+grant permissions, and explicit owner instructions take precedence over its
+defaults within existing execution permissions.

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@jc_stack/ez-agents",
-  "version": "0.1.0-beta.12",
+  "version": "0.1.0-beta.18",
   "private": false,
   "type": "module",
-  "description": "A minimal Telegram-to-CLI executor relay.",
+  "description": "A lightweight foundation for persistent business AI assistants using existing AI harnesses, workspaces and plugins.",
   "packageManager": "pnpm@10.30.3",
   "bin": {
+    "ezenciel-agents-schedule": "bin/ezenciel-agents-schedule.mjs",
     "ezenciel-agents-install": "bin/ezenciel-agents-install",
     "ezenciel-agents": "bin/ezenciel-agents.mjs",
     "ezenciel-agents-owner": "bin/ezenciel-agents-owner.mjs",
@@ -13,6 +14,7 @@
     "ezenciel-agents-react": "bin/ezenciel-agents-react.mjs",
     "ezenciel-agents-approval": "bin/ezenciel-agents-approval.mjs",
     "ezenciel-agents-setup": "bin/ezenciel-agents-setup.mjs",
+    "ezenciel-agents-task": "bin/ezenciel-agents-task.mjs",
     "ezenciel-agents-source": "bin/ezenciel-agents-source.mjs",
     "ezenciel-agents-docker": "bin/ezenciel-agents-docker",
     "ezenciel-agents-create": "bin/ezenciel-agents-create",
@@ -36,18 +38,23 @@
     "docker",
     "compose.whatsapp.yaml",
     "scripts/smoke.ts",
+    "scripts/smoke-scheduler.ts",
     "LICENSE",
     "CHANGELOG.md",
     "THIRD_PARTY_NOTICES.md",
     "scripts/release-check.mjs",
+    "scripts/stage-qa.mjs",
     "test",
     "tsconfig.json",
     "scripts/assert-local-registry.mjs",
-    ".dockerignore"
+    ".dockerignore",
+    "scripts/trusted-beta.mjs",
+    "scripts/generate-publish-caller.mjs",
+    "scripts/smoke-busy-reply.ts"
   ],
   "publishConfig": {
     "access": "public",
-    "tag": "beta"
+    "tag": "latest"
   },
   "scripts": {
     "setup": "tsx --env-file-if-exists=.env src/setup.ts",
@@ -59,6 +66,7 @@
     "build": "tsc --noEmit",
     "test": "tsx --test test/*.test.ts test/*.test.mjs",
     "verify": "pnpm test && pnpm build",
+    "smoke:scheduler": "tsx scripts/smoke-scheduler.ts",
     "smoke": "./bin/ezenciel-agents-docker run --rm --no-deps relay smoke",
     "prepublishOnly": "npm run verify",
     "registry:up": "docker compose -f registry/docker-compose.yml up -d",

package/scripts/generate-publish-caller.mjs

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+// Print a reviewed caller. Does not write repositories or enroll npm trust.
+import assert from 'node:assert/strict';
+import { pathToFileURL } from 'node:url';
+
+export function generateCaller({ repository, packageName, publisherSha, checks }) {
+  assert.match(repository, /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/, 'Invalid repository');
+  assert.match(packageName, /^@[a-z0-9_-]+\/[a-z0-9_.-]+$/, 'Expected scoped npm package');
+  assert.match(publisherSha, /^[a-f0-9]{40}$/, 'Pin the reviewed shared publisher to a full commit SHA');
+  assert(Array.isArray(checks) && checks.length > 0 && checks.every(c => typeof c === 'string' && /^[A-Za-z0-9 (),_.-]+$/.test(c)), 'Required CI check names are mandatory');
+  const core = repository === 'jdorado/ez-agents';
+  const reference = core ? './.github/workflows/npm-beta-shared.yml' : `jdorado/ez-agents/.github/workflows/npm-beta-shared.yml@${publisherSha}`;
+  return `# Generated by scripts/generate-publish-caller.mjs; review changes before merging.
+name: Publish verified npm beta
+on:
+  workflow_dispatch:
+    inputs:
+      release-id:
+        description: 'Numeric ID of the staged draft prerelease'
+        required: true
+        type: string
+      version:
+        description: 'Reviewed beta version staged as draft release vVERSION'
+        required: true
+        type: string
+      source-sha:
+        description: 'Full tested commit SHA; must be current main'
+        required: true
+        type: string
+      artifact-sha256:
+        description: 'SHA-256 of the exact independently verified candidate.tgz'
+        required: true
+        type: string
+permissions: {}
+jobs:
+  publish:
+    if: github.repository == '${repository}' && github.ref == 'refs/heads/main'
+    permissions:
+      contents: write
+      checks: read
+      actions: read
+      pull-requests: read
+      id-token: write
+    uses: ${reference}
+    with:
+      package: '${packageName}'
+      publisher-sha: ${core ? '${{ github.sha }}' : `'${publisherSha}'`}
+      required-checks: '${JSON.stringify(checks)}'
+      release-id: \${{ inputs.release-id }}
+      version: \${{ inputs.version }}
+      source-sha: \${{ inputs.source-sha }}
+      artifact-sha256: \${{ inputs.artifact-sha256 }}
+`;
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  const [repository, packageName, publisherSha, checksJson, ...extra] = process.argv.slice(2);
+  if (!checksJson || extra.length) throw new Error('Usage: node scripts/generate-publish-caller.mjs OWNER/REPO @SCOPE/PACKAGE SHARED_COMMIT_SHA \'["required CI name"]\'');
+  process.stdout.write(generateCaller({ repository, packageName, publisherSha, checks: JSON.parse(checksJson) }));
+}

package/scripts/smoke-busy-reply.ts

@@ -0,0 +1,58 @@
+// Real restricted Codex reply while a synthetic writer stays active. No Telegram network.
+import { mkdtemp, mkdir, writeFile, symlink } from 'node:fs/promises'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+import { spawn } from 'node:child_process'
+import { createRelay } from '../src/index.js'
+import { RunStore } from '../src/runs.js'
+import { ControlStore } from '../src/control-state.js'
+import { initialPreset } from '../src/ai.js'
+import { startExecutorJob } from '../src/executor.js'
+import { serveHostExecutor } from '../src/host-executor.js'
+import { fileURLToPath } from 'node:url'
+import { initializeWorkspace } from '../src/workspace.js'
+import type { Update } from 'grammy/types'
+if (process.argv.includes('--host')) {
+ const root=process.argv[process.argv.indexOf('--host')+1], abort=new AbortController()
+ process.once('SIGTERM',()=>abort.abort())
+ await serveHostExecutor({cli:'codex',agents:[{name:'fixture',workspace:join(root,'mind'),controlDir:join(root,'control'),binDir:fileURLToPath(new URL('../bin',import.meta.url)),sharedWorkspace:join(root,'mind')}]},abort.signal,async(texts,options)=>{
+  if((await new RunStore(options.controlDir).get(options.runId))?.replyOnly)return startExecutorJob(texts,options)
+  const child=spawn(process.execPath,['-e','setInterval(()=>{},1000)'],{detached:true,stdio:['pipe','pipe','pipe']})
+  return {child,stdout:'',cleanup:async()=>{}}
+ })
+ process.exit(0)
+}
+const root=await mkdtemp(join(tmpdir(),'ez-busy-reply-')), workspace=join(root,'mind'), controlDir=join(root,'control')
+await initializeWorkspace(workspace);await mkdir(controlDir,{recursive:true})
+if(process.env.EZ_REPLY_QA_AUTH){await mkdir(join(controlDir,'cli','codex'),{recursive:true});await symlink(process.env.EZ_REPLY_QA_AUTH,join(controlDir,'cli','codex','auth.json'))}
+const hostMode=process.argv.includes('--transport')
+const hostEnvironment={...process.env};delete hostEnvironment.EZ_EXECUTOR_TRANSPORT
+const host=hostMode?spawn(process.execPath,['--import',fileURLToPath(new URL('../node_modules/tsx/dist/loader.mjs',import.meta.url)),fileURLToPath(import.meta.url),'--host',root],{env:hostEnvironment,stdio:['ignore','inherit','inherit']}):undefined
+if(hostMode)process.env.EZ_EXECUTOR_TRANSPORT='host'
+const control=new ControlStore(controlDir,1000),runs=new RunStore(controlDir)
+await control.requestPairing(101,101);await control.approveOwner(101)
+let writer:any,replyEvents=''
+const relay=createRelay({workspace,controlDir,pairingTtlMs:1000,executorTimeoutMs:0,executorCli:'codex',telegramBotToken:'fixture'},async(texts,options)=>{
+ if(hostMode)return startExecutorJob(texts,options)
+ const run=await runs.get(options.runId)
+ if(run?.replyOnly){const job=await startExecutorJob(texts,options);job.child.stdout?.on('data',c=>{replyEvents+=c});return job}
+ const child=spawn(process.execPath,['-e','setInterval(()=>{},1000)'],{stdio:['pipe','pipe','pipe']});writer=child
+ return {child,stdout:'',cleanup:async()=>{}}
+})
+relay.bot.botInfo={id:999,is_bot:true,first_name:'Fixture',username:'fixture_bot'} as any
+const replies:string[]=[]
+relay.bot.api.config.use(async(_p,method,payload)=>{if(method==='sendMessage')replies.push((payload as any).text);return {ok:true,result:method==='sendMessage'?{message_id:replies.length,date:0,chat:{id:101,type:'private'},text:(payload as any).text}:true} as any})
+const msg=(id:number,text:string):Update=>({update_id:id,message:{message_id:id,date:0,text,from:{id:101,is_bot:false,first_name:'Fixture'},chat:{id:101,type:'private',first_name:'Fixture'}}})
+try{
+ await relay.bot.handleUpdate(msg(1,'Long work'));await relay.drainInbox(true)
+ await relay.bot.handleUpdate(msg(2,'What is running? Also calculate 17 times 19. Use your available reply tools. Do not queue any work.'));await relay.drainInbox(true)
+ const started=Date.now()
+ while(!replies.length && Date.now()-started<120000){await relay.drainOutbox();await new Promise(r=>setTimeout(r,250))}
+ if(!replies.some(s=>s.includes('323')))throw new Error('No verified arithmetic reply: '+JSON.stringify(replies))
+ if((await runs.get('tg_1'))?.status!=='running')throw new Error('Writer stopped')
+ while((await runs.get('tg_2'))?.status==='running' && Date.now()-started<120000)await new Promise(r=>setTimeout(r,250))
+ if((await runs.get('tg_2'))?.status!=='completed')throw new Error('Reply did not finish successfully')
+ const reply=await runs.get('tg_2');if(!reply?.replyOnly)throw new Error('No restricted reply lane')
+ await writeFile(join(root,'evidence.json'),JSON.stringify({replyMs:Date.now()-started,replies,writerRunning:(await runs.get('tg_1'))?.status==='running',replyEvents},null,2))
+ console.log(JSON.stringify({root,replyMs:Date.now()-started,replies,writerRunning:true}))
+}finally{await relay.stop();writer?.kill();host?.kill();delete process.env.EZ_EXECUTOR_TRANSPORT}

package/scripts/smoke-scheduler.ts

@@ -0,0 +1,90 @@
+// Opt-in token-consuming probe. Real executor and relay handlers; synthetic Telegram provider.
+// Run: node --import tsx scripts/smoke-scheduler.ts [seconds=1860] [cli=codex]
+import { mkdtemp, writeFile, readFile, readdir } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { createRelay } from '../src/index.js'
+import { ControlStore } from '../src/control-state.js'
+import { Scheduler } from '../src/scheduler.js'
+import { RunStore } from '../src/runs.js'
+import { initialPreset } from '../src/ai.js'
+import { initializeWorkspace } from '../src/workspace.js'
+import type { Update } from 'grammy/types'
+
+const duration=Number(process.argv[2] || 1860),cli=process.argv[3] || 'codex'
+const nativeGoal=process.argv[4]==='goal'
+if(!Number.isSafeInteger(duration) || duration<30)throw new Error('Duration must be at least 30 seconds')
+const root=await mkdtemp(join(tmpdir(),'ez-scheduler-smoke-')),workspace=join(root,'agent'),controlDir=join(root,'control')
+await initializeWorkspace(workspace)
+const control=new ControlStore(controlDir,1000),scheduler=new Scheduler(controlDir),runs=new RunStore(controlDir)
+await control.requestPairing(101,101);await control.approveOwner(101)
+const owner=(await control.status()).owner!,execution=await control.captureChoice(initialPreset(cli))
+const replies:{at:number;text:string}[]=[]
+const relay=createRelay({workspace,controlDir,pairingTtlMs:1000,executorTimeoutMs:0,executorCli:cli,telegramBotToken:'fixture'})
+relay.bot.botInfo={id:999,is_bot:true,first_name:'Fixture',username:'fixture_bot'} as typeof relay.bot.botInfo
+relay.bot.api.config.use(async(_previous,method,payload)=>{
+ if(method==='sendMessage') {const reply={at:Date.now(),text:(payload as {text:string}).text};replies.push(reply);console.log(JSON.stringify({reply}))}
+ return {ok:true,result:{message_id:replies.length}} as never
+})
+const due=Date.now()+2000
+const text=nativeGoal
+ ? `/goal Native multi-turn continuation QA: create phase1.txt containing ONE and phase2.txt containing TWO, then finished.txt containing DONE and deliver BACKGROUND_DONE. In the FIRST turn write only phase1.txt and END with final response FIRST_TURN_DONE, leaving this native goal active. Do not write phase2 or finished.txt or send BACKGROUND_DONE in the first turn. On a subsequent native automatic continuation, run a terminal sleep for ${duration} seconds and wait for it, write phase2.txt and finished.txt, read and verify all three files, send BACKGROUND_DONE through ezenciel-agents-message, verify delivery, and mark this goal complete. No extra schedule, user prompt or custom continuation loop. Keep progress.md updated.`
+ : `This is an authorized synthetic test. In your task directory write progress.md with WAITING. Run a terminal sleep for ${duration} seconds and wait for that command to finish. Then write finished.txt containing DONE and use ezenciel-agents-message --text 'BACKGROUND_DONE'. Do not reschedule or finish early. No external services are needed.`
+await scheduler.save({id:'sleep',name:'Long-running synthetic QA',text,trigger:{at:new Date(due).toISOString()},enabled:true,owner,execution})
+let draining=false
+const tick=setInterval(()=>{if(!draining){draining=true;void relay.drainSources().then(()=>relay.drainOutbox()).catch(console.error).finally(()=>{draining=false})}},250)
+const until=async(check:()=>Promise<boolean>,seconds:number)=>{
+ const deadline=Date.now()+seconds*1000
+ while(!await check()){if(Date.now()>deadline)throw new Error('Probe timed out');await new Promise(r=>setTimeout(r,250))}
+}
+console.log(JSON.stringify({root,duration,cli}))
+try{
+ await until(async()=>(await runs.list()).some(r=>r.scheduled && r.status==='running'),60)
+ const [background]=(await runs.list()).filter(r=>r.scheduled)
+ const message:Update={update_id:10,message:{message_id:10,date:0,text:"What is 17 times 19? Reply with the number using ezenciel-agents-message. This is a local test with a synthetic delivery provider.",from:{id:101,is_bot:false,first_name:'Fixture'},chat:{id:101,type:'private',first_name:'Fixture'}}}
+ const askedAt=Date.now();await relay.bot.handleUpdate(message);await relay.drainInbox(true)
+ await until(async()=>replies.some(r=>/323/.test(r.text)),180)
+ if((await runs.get(background.id))?.status!=='running')throw new Error('Background stopped before chat reply')
+ console.log(JSON.stringify({chatReplyMs:Date.now()-askedAt,backgroundState:'running'}))
+ if(duration>360){
+  await until(async()=>Date.now()-askedAt>360000,duration)
+  const followup={...message,update_id:11,message:{...message.message!,message_id:11,text:'Check ezenciel-agents-schedule runs. If the background task is actually running, send BACKGROUND_STATUS_RUNNING followed by its exact run ID. Otherwise report the problem.'}} as Update
+  const before=replies.length;await relay.bot.handleUpdate(followup);await relay.drainInbox(true)
+  await until(async()=>replies.slice(before).some(r=>r.text.includes('BACKGROUND_STATUS_RUNNING') && r.text.includes(background.id)),180)
+  if((await runs.get(background.id))?.status!=='running')throw new Error('Background stopped at six-minute check')
+  console.log(JSON.stringify({sixMinuteCheck:'passed',backgroundState:'running'}))
+ }
+ await until(async()=> (await runs.get(background.id))?.status!=='running',duration+180)
+ await relay.drainOutbox()
+ const status=(await runs.get(background.id))?.status
+ if(status!=='completed' || replies.filter(r=>r.text.includes('BACKGROUND_DONE')).length!==1)throw new Error('Missing completed run or exactly one delivered result')
+ const finished=await readFile(join(workspace,'work/tasks',background.id,'finished.txt'),'utf8')
+ if(finished.trim()!=='DONE')throw new Error('Missing finished.txt artifact')
+ if(nativeGoal){
+  for(const [file,expected] of [['phase1.txt','ONE'],['phase2.txt','TWO']])
+   if((await readFile(join(workspace,'work/tasks',background.id,file),'utf8')).trim()!==expected)throw new Error(`Missing native goal artifact: ${file}`)
+ }
+ const record=(await runs.get(background.id))!
+ if(Date.parse(record.endedAt!)-Date.parse(record.startedAt!) < duration*1000)throw new Error('Worker completed before requested duration')
+ let goalEvidence:unknown
+ if(nativeGoal){
+  const home=join(controlDir,'cli/codex/tasks',background.id),sessionId=record.nativeSessionId
+  if(!sessionId)throw new Error('Missing native session ID')
+  const files=await readdir(join(home,'sessions'),{recursive:true})
+  const file=files.find(f=>f.endsWith(`${sessionId}.jsonl`))
+  if(!file)throw new Error('Missing native transcript')
+  const events=(await readFile(join(home,'sessions',file),'utf8')).trim().split('\n').map(line=>JSON.parse(line)).filter(e=>e.type==='event_msg')
+  const turns=events.filter(e=>e.payload.type==='task_complete')
+  if(turns.length<2 || !turns[0].payload.last_agent_message?.includes('FIRST_TURN_DONE'))throw new Error('Native multi-turn continuation was not verified')
+  // Read Codex-owned evidence only; Ez never creates or manages this database.
+  const {DatabaseSync}=await import('node:sqlite'),db=new DatabaseSync(join(home,'goals_1.sqlite'),{readOnly:true})
+  try{
+   const goal=db.prepare('SELECT status FROM thread_goals WHERE thread_id = ?').get(sessionId)
+   if(goal?.status!=='complete')throw new Error('Native goal did not complete')
+   goalEvidence={status:goal.status,completedTurns:turns.map(e=>e.payload.turn_id)}
+  }finally{db.close()}
+ }
+ const evidence={duration,cli,nativeGoal,goalEvidence,status,replies,run:await runs.get(background.id)}
+ await writeFile(join(root,'evidence.json'),JSON.stringify(evidence,null,2),{mode:0o600})
+ console.log(JSON.stringify({passed:true,evidence:join(root,'evidence.json')}))
+}finally{clearInterval(tick);while(draining)await new Promise(r=>setTimeout(r,50));await relay.stop()}

package/scripts/stage-qa.mjs

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+// Developer packaging only. The existing agent-owned updater installs the result.
+import * as fs from 'node:fs/promises';
+import path from 'node:path';
+import {tmpdir} from 'node:os';
+import {execFileSync} from 'node:child_process';
+import {parseArgs} from 'node:util';
+import {digest, extract, version, newer} from '../src/updates/artifact.mjs';
+
+const {values:v}=parseArgs({options:Object.fromEntries(['source','catalog','label','version','flow'].map(k=>[k,{type:'string'}]))});
+if(!['source','catalog','label','version','flow'].every(k=>v[k]))throw Error('Required: --source CHECKOUT --catalog DIRECTORY --label beta-12 --version 0.1.0-beta.12.qa.1 --flow QA.md');
+if(!/^beta-[1-9]\d*$/.test(v.label))throw Error('Label must be beta-N');
+version(v.version);
+if(!/^\d+\.\d+\.\d+-beta\.\d+\.qa\.[1-9]\d*$/.test(v.version))throw Error('Use a distinct private version: X.Y.Z-beta.N.qa.BUILD');
+const source=await fs.realpath(v.source),catalog=path.resolve(v.catalog);
+const run=(cmd,args,cwd=source)=>execFileSync(cmd,args,{cwd,encoding:'utf8',stdio:['ignore','pipe','pipe']}).trim();
+if(run('git',['status','--porcelain']))throw Error('Commit the reviewed source before staging QA');
+const commit=run('git',['rev-parse','HEAD']),flow=await fs.readFile(v.flow,'utf8');
+if(!flow.trim())throw Error('A feature QA flow is required');
+await fs.mkdir(catalog,{recursive:true,mode:0o700});
+const destination=path.join(catalog,v.label);
+if(await fs.lstat(destination).then(()=>true,err=>{if(err.code==='ENOENT')return false;throw err;}))throw Error('QA label already exists; never replace a build. Choose the next beta label.');
+const temp=await fs.mkdtemp(path.join(tmpdir(),'ez-stage-qa-'));
+const staged=await fs.mkdtemp(path.join(catalog,'.staging-'));
+try {
+  const pack=(cwd,out)=>JSON.parse(run('npm',['pack','--ignore-scripts','--json','--pack-destination',out],cwd))[0];
+  const original=pack(source,temp);
+  await extract(await fs.readFile(path.join(temp,original.filename)),path.join(temp,'source'));
+  const root=path.join(temp,'source'),pkg=JSON.parse(await fs.readFile(path.join(root,'package.json'),'utf8'));
+  if(pkg.ezRelease?.kind!=='main')throw Error('This staging command accepts the main package only');
+  if(!newer(v.version,pkg.version))throw Error('Private QA version must be newer than source package version');
+  pkg.version=v.version;pkg.ezQa={label:v.label,commit,private:true};
+  await fs.writeFile(path.join(root,'package.json'),JSON.stringify(pkg,null,2)+'\n');
+  const packed=pack(root,staged),artifact=await fs.readFile(path.join(staged,packed.filename));
+  const receipt={label:v.label,version:v.version,package:pkg.name,commit,sha256:digest(artifact),file:packed.filename,private:true};
+  await fs.writeFile(path.join(staged,'manifest.json'),JSON.stringify(receipt,null,2)+'\n',{mode:0o600});
+  await fs.writeFile(path.join(staged,'QA.md'),flow,{mode:0o600});
+  await fs.chmod(path.join(staged,packed.filename),0o600);
+  // The published directory is nonempty, so competing staging cannot replace it.
+  await fs.rename(staged,destination);
+  console.log(JSON.stringify({...receipt,directory:destination},null,2));
+} finally {await fs.rm(temp,{recursive:true,force:true});await fs.rm(staged,{recursive:true,force:true});}