@volter/twin-standard 1.0.90 → 1.0.92

package/dist/src/consumer.js

@@ -0,0 +1,190 @@
+// The installed customer entry into a pack's life. The CLI owns World lifetime; these are caller steps.
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, statSync, writeFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { basename, dirname, isAbsolute, join, resolve } from 'node:path';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { standardPackageFile } from "./package-file.js";
+/** Bind behavior inputs on both source and packed layouts; compiled outputs and score caches are not inputs. */
+export function consumerSourceDigest(pack) {
+    const entries = [];
+    const cache = new Set(['journeys/score.json', 'journeys/coverage.json']);
+    const scan = (path) => {
+        if (cache.has(path))
+            return;
+        const at = join(pack, path);
+        if (statSync(at).isDirectory()) {
+            for (const name of readdirSync(at).sort())
+                if (name !== 'node_modules')
+                    scan(`${path}/${name}`);
+        }
+        else
+            entries.push([path, createHash('sha256').update(readFileSync(at)).digest('hex')]);
+    };
+    for (const name of readdirSync(pack).sort()) {
+        const at = join(pack, name);
+        if (['src', 'spec', 'journeys', 'vendor', 'assets', 'static'].includes(name) || statSync(at).isDirectory() && existsSync(join(at, 'src/manifest.ts')))
+            scan(name);
+    }
+    return createHash('sha256').update(JSON.stringify(entries)).digest('hex');
+}
+/** A pack supplies its own entry journey; older immutable releases use a versioned standard fixture. */
+export function consumerRecipe(vendor, packDir) {
+    if (!/^[a-z][a-z0-9-]*$/.test(vendor))
+        throw new Error('Invalid consumer vendor identity');
+    const root = dirname(fileURLToPath(standardPackageFile('package.json')));
+    const supplied = packDir ? join(packDir, 'journeys/first-use.json') : undefined;
+    const path = supplied && existsSync(supplied) ? supplied : join(root, 'src/clients', `${vendor}.first-use.json`);
+    if (!existsSync(path))
+        throw new Error(`${vendor} has no installed customer workflow in this standard`);
+    const recipe = JSON.parse(readFileSync(path, 'utf8'));
+    const command = (value) => Array.isArray(value) && value.length > 0 && value.every((part) => typeof part === 'string' && part.length > 0);
+    if (recipe.schemaVersion !== 1 || typeof recipe.source !== 'string' || !recipe.source || typeof recipe.about !== 'string' || !recipe.about || !recipe.files || typeof recipe.files !== 'object' || Array.isArray(recipe.files) || !recipe.files['package.json'] || typeof recipe.files['.env.example'] !== 'string' || !command(recipe.run))
+        throw new Error('Incomplete installed customer workflow');
+    if (!recipe.retention || ('none' in recipe.retention) === ('readback' in recipe.retention) || ('none' in recipe.retention ? typeof recipe.retention.none !== 'string' || !recipe.retention.none.trim() : !command(recipe.retention.readback)))
+        throw new Error('Workflow needs retained-state readback or a stateless explanation');
+    if (recipe.clock && (!Number.isFinite(Date.parse(recipe.clock.at)) || recipe.clock.advanceAfterRun !== undefined && (!/^\d+(?:\.\d+)?[smhd]$/.test(recipe.clock.advanceAfterRun) || !('readback' in recipe.retention))))
+        throw new Error('Consumer clock needs an instant and, for a stored result, an optional advance before inspection');
+    return recipe;
+}
+/** Materialize only a new caller-owned app. Normal dependency installation happens before offline assessment. */
+export function prepareConsumerApp(packDir, appDir) {
+    const facts = JSON.parse(readFileSync(join(packDir, 'generated/pack-facts.json'), 'utf8'));
+    const vendor = Object.keys(facts.packs ?? {})[0];
+    if (!vendor || Object.keys(facts.packs).length !== 1)
+        throw new Error('Consumer preparation requires one artifact vendor identity');
+    const recipe = consumerRecipe(vendor, packDir);
+    if (existsSync(appDir))
+        throw new Error('Consumer app must be a new directory');
+    const app = JSON.parse(recipe.files['package.json']);
+    if (app.scripts || app.workspaces)
+        throw new Error('Consumer fixture supplies direct SDK commands, not install scripts or workspace links');
+    for (const [name, version] of Object.entries({ ...app.dependencies, ...app.devDependencies, ...app.optionalDependencies })) {
+        if (typeof version !== 'string' || !/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(version))
+            throw new Error(`${name}: customer SDK dependencies require exact registry versions`);
+    }
+    const files = Object.entries(recipe.files).map(([path, content]) => {
+        if (isAbsolute(path) || path.includes('\\') || path.split('/').some((part) => !part || part === '.' || part === '..') || path.split('/').includes('node_modules') || ['.env', '.npmrc', '.volter/world.json'].includes(path))
+            throw new Error(`Invalid consumer file: ${path}`);
+        if (typeof content !== 'string')
+            throw new Error('Consumer files must contain text');
+        return [path, content];
+    });
+    mkdirSync(appDir, { recursive: true });
+    for (const [path, content] of files) {
+        mkdirSync(dirname(join(appDir, path)), { recursive: true });
+        writeFileSync(join(appDir, path), content);
+    }
+    return { recipeSha256: createHash('sha256').update(JSON.stringify(recipe)).digest('hex'), dependencies: app.dependencies ?? {} };
+}
+export async function runConsumerWorkflow(packDir, options) {
+    if (!isAbsolute(options.appDir) || !isAbsolute(options.cli) || !/^sha512-[A-Za-z0-9+/]{86}==$/.test(options.artifactIntegrity))
+        throw new Error('Consumer requires absolute prepared paths and candidate SHA-512 integrity');
+    if (existsSync(join(options.appDir, '.volter/world.json')))
+        throw new Error('Consumer app already has a World; prepare a new app rather than reusing prior state');
+    const packageVersion = (entry, name) => {
+        let directory = dirname(entry);
+        while (true) {
+            const file = join(directory, 'package.json');
+            if (existsSync(file)) {
+                const pkg = JSON.parse(readFileSync(file, 'utf8'));
+                if (pkg.name === name)
+                    return pkg.version;
+            }
+            const parent = dirname(directory);
+            if (parent === directory)
+                throw new Error(`${name} has no installed package identity`);
+            directory = parent;
+        }
+    };
+    const cliEntry = realpathSync(options.cli);
+    const cliRequire = createRequire(cliEntry);
+    const tools = {
+        '@volter/world': packageVersion(cliEntry, '@volter/world'),
+        '@volter/world-core': packageVersion(cliRequire.resolve('@volter/world-core/runtime'), '@volter/world-core'),
+        '@volter/world-runtime': packageVersion(cliRequire.resolve('@volter/world-runtime'), '@volter/world-runtime'),
+    };
+    const metadata = JSON.parse(readFileSync(join(packDir, 'package.json'), 'utf8'));
+    const facts = JSON.parse(readFileSync(join(packDir, 'generated/pack-facts.json'), 'utf8'));
+    const vendor = Object.keys(facts.packs ?? {})[0];
+    if (!vendor || Object.keys(facts.packs).length !== 1)
+        throw new Error('Consumer workflow requires one selected artifact identity');
+    const recipe = consumerRecipe(vendor, packDir);
+    const commands = [];
+    const failures = [];
+    const run = async (label, args) => {
+        const result = await new Promise((done) => {
+            const child = spawn(options.cli, ['world', ...args], { cwd: options.appDir, env: process.env, stdio: ['ignore', 'pipe', 'pipe'] });
+            let stdout = '', stderr = '';
+            child.stdout.on('data', (chunk) => { stdout += chunk; });
+            child.stderr.on('data', (chunk) => { stderr += chunk; });
+            child.on('error', (error) => done({ exitCode: 1, stdout, stderr: `${stderr}\n${error.message}` }));
+            child.on('close', (exitCode) => done({ exitCode, stdout, stderr }));
+        });
+        commands.push({ label, argv: [options.cli, 'world', ...args], ...result });
+        if (result.exitCode !== 0)
+            throw new Error(`${label} exited ${result.exitCode}: ${result.stderr.trim().split('\n')[0] ?? ''}`);
+        return result.stdout;
+    };
+    let upAttempted = false;
+    let retainedReadback = false;
+    let teardownVerified = false;
+    try {
+        await run('init', ['init', '--twins', vendor]);
+        const config = JSON.parse(readFileSync(join(options.appDir, '.volter/world.json'), 'utf8'));
+        if (!config.services?.some((service) => service.source?.package === metadata.name && service.source?.version === metadata.version))
+            throw new Error('World init did not select the installed candidate package and exact version');
+        upAttempted = true;
+        await run('up', ['up']);
+        if (recipe.clock)
+            await run('clock-set', ['clock', 'set', recipe.clock.at]);
+        await run('sdk', ['run', '--', ...recipe.run]);
+        if ('readback' in recipe.retention) {
+            if (recipe.clock?.advanceAfterRun) {
+                await run('clock-advance', ['clock', 'advance', recipe.clock.advanceAfterRun]);
+                await run('inspect-timed-result', ['run', '--', ...recipe.retention.readback]);
+            }
+            const before = JSON.parse(await run('log-before-stop', ['log', '--json']));
+            await run('stop', ['down']);
+            await run('resume', ['up']);
+            const resumed = JSON.parse(await run('log-after-resume', ['log', '--json']));
+            if (JSON.stringify(before) !== JSON.stringify(resumed))
+                throw new Error('Resume changed recorded application state before readback');
+            await run('retained-readback', ['run', '--', ...recipe.retention.readback]);
+            const after = JSON.parse(await run('log-after-readback', ['log', '--json']));
+            if (JSON.stringify(before) !== JSON.stringify(after))
+                throw new Error('Retained readback added mutations; it must only inspect existing state');
+            retainedReadback = true;
+        }
+    }
+    catch (error) {
+        failures.push(error.message);
+    }
+    finally {
+        if (upAttempted) {
+            try {
+                await run('final-stop', ['down']);
+                const status = JSON.parse(await run('final-status', ['status', '--json']));
+                if (status.running || Object.values(status.services ?? {}).some((service) => service.running))
+                    throw new Error('Consumer World still reports running compute');
+                teardownVerified = true;
+            }
+            catch (error) {
+                failures.push(error.message);
+            }
+        }
+    }
+    return {
+        measured: true, passed: failures.length === 0 && teardownVerified,
+        scope: 'Exact installed artifact; normal CLI initialization, unchanged SDK, result assertions and retained-state read-only resume where applicable',
+        package: metadata.name, version: metadata.version, integrity: options.artifactIntegrity,
+        tools,
+        sourceInputsSha256: consumerSourceDigest(packDir), recipeSha256: createHash('sha256').update(JSON.stringify(recipe)).digest('hex'),
+        fixture: existsSync(join(packDir, 'journeys/first-use.json')) ? 'journeys/first-use.json' : `standard/clients/${vendor}.first-use.json`, appDir: resolve(options.appDir), appName: basename(options.appDir),
+        commands, failures, teardownVerified, retainedReadback,
+        clock: recipe.clock ?? { mode: 'wall' },
+        ...('none' in recipe.retention ? { retentionNotApplicable: recipe.retention.none } : {}),
+        node: process.versions.node, at: new Date().toISOString(),
+    };
+}

package/dist/src/index.d.ts

@@ -11,3 +11,4 @@ export { compilePackFacts, renderPackFacts, type PackFacts, type PackFactsFile }
 export { assessPack, type AssessmentOptions } from './assessment.js';
 export { createPack } from './create-pack.js';
 export { verifyBrowserTransport } from './browser-verification.js';
+export { consumerRecipe, prepareConsumerApp, runConsumerWorkflow, consumerSourceDigest, type ConsumerRecipe, type ConsumerOptions } from './consumer.js';

package/dist/src/index.js

@@ -15,3 +15,4 @@ export { compilePackFacts, renderPackFacts } from "./pack-facts.js";
 export { assessPack } from "./assessment.js";
 export { createPack } from "./create-pack.js";
 export { verifyBrowserTransport } from "./browser-verification.js";
+export { consumerRecipe, prepareConsumerApp, runConsumerWorkflow, consumerSourceDigest } from "./consumer.js";

package/dist/src/protocol-3.js

@@ -145,7 +145,7 @@ function srcFileInForm(unit, name) {
 const SEMANTICS_FIXED = new Set(['answer-views.ts', 'states.ts', 'index.ts', 'shared.ts', 'doors.ts', 'seed.ts', 'around.ts', 'events.ts', 'clock.ts', 'tenant.ts', 'scenario.ts', 'gap.ts', 'graphql.ts', 'sockets.ts', 'board.ts']);
 /** journeys/'s closed set. */
 const JOURNEY_FILES = new Set(['customer-life.outline.md', 'customer-life.outline.verdict.json', 'customer-life.json', 'customer-life.verdict.json', 'decisions.json',
-    'vendor-examples.json', 'vendor-examples.verdict.json', 'demand.json', 'unreachable.json', 'score.json', 'coverage.json',
+    'vendor-examples.json', 'vendor-examples.verdict.json', 'demand.json', 'unreachable.json', 'score.json', 'coverage.json', 'first-use.json',
     // a generative pack's life names the World's scenario it walks under (architecture, "Writing a life")
     'scenario.json']);
 /** Only scenario basenames the two walks explicitly declare extend the closed layout. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/twin-standard",
-  "version": "1.0.90",
+  "version": "1.0.92",
   "description": "The Protocol 3 standard for Volter twin packs: the criteria a pack is graded by, the grader, the gate a pack repository and the twin catalog run on every change and submission, and the spec derivation the grade checks against. Pin a version: every place a pack is judged judges by that standard.",
   "keywords": [
     "twin",
@@ -75,7 +75,7 @@
     "yaml": "2.9.0"
   },
   "peerDependencies": {
-    "@volter/world-core": "3.0.98",
+    "@volter/world-core": "3.0.100",
     "@volter/world-runtime": "*",
     "playwright": "^1.63.0"
   },

package/src/assessment.ts

@@ -8,12 +8,13 @@ import { conformance } from './conformance.ts';
 import { inMemoryWorld, walk, withPinnedWorldDraws, usePacks, type ServedTwin } from './walk/behavior-journey.ts';
 import { compilePackFacts } from './pack-facts.ts';
 import { expandFills, type Journey } from './walk/journey-kit.ts';
+import { runConsumerWorkflow, type ConsumerOptions } from './consumer.ts';
 
 const canonical = (value: unknown): unknown => value && typeof value === 'object' ? Array.isArray(value) ? value.map(canonical) : Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => [key, canonical(item)])) : value;
 const json = (value: unknown) => JSON.stringify(canonical(value));
 const hash = (value: unknown) => createHash('sha256').update(json(value)).digest('hex');
 const read = (file: string) => JSON.parse(readFileSync(file, 'utf8'));
-export type AssessmentOptions = { browser?: boolean; conformance?: boolean };
+export type AssessmentOptions = { browser?: boolean; conformance?: boolean; consumer?: ConsumerOptions };
 
 /** Surface coverage counts actual kernel dispatch, and retains every declared gap in the denominator. */
 export async function assessPack(packDir: string, options: AssessmentOptions = {}) {
@@ -88,6 +89,9 @@ export async function assessPack(packDir: string, options: AssessmentOptions = {
     } finally { await transport.stop(); }
   }
   const conform = options.conformance === false ? null : await conformance(packDir);
-  const ready = gates.length > 0 && gates.every((gate) => !gate.failures.length) && !quick.failures.length && replayEqual && conform !== null && conform.length > 0 && conform.every((result) => !result.failures.length) && (!options.browser || !httpOnly || browser.measured === true && (browser.failures as unknown[]).length === 0 && (browser.replay as { equal: boolean }).equal);
-  return { schemaVersion: 1, vendor, package: manifest.name, version: manifest.version, ready, gates: gates.map((gate) => ({ ...gate, unit: gate.unit === packDir ? vendor : `${vendor}/${gate.unit.slice(packDir.length + 1)}` })), quick, browser, conformance: conform };
+  let consumer;
+  try { consumer = options.consumer ? await runConsumerWorkflow(packDir, options.consumer) : { measured: false, passed: false, failures: ['Installed customer workflow was not prepared'] }; }
+  catch (error) { consumer = { measured: false, passed: false, failures: [(error as Error).message] }; }
+  const ready = gates.length > 0 && gates.every((gate) => !gate.failures.length) && !quick.failures.length && replayEqual && conform !== null && conform.length > 0 && conform.every((result) => !result.failures.length) && consumer.measured && consumer.passed && (!options.browser || !httpOnly || browser.measured === true && (browser.failures as unknown[]).length === 0 && (browser.replay as { equal: boolean }).equal);
+  return { schemaVersion: 1, vendor, package: manifest.name, version: manifest.version, ready, gates: gates.map((gate) => ({ ...gate, unit: gate.unit === packDir ? vendor : `${vendor}/${gate.unit.slice(packDir.length + 1)}` })), quick, browser, conformance: conform, consumer };
 }

package/src/cli.ts

@@ -24,7 +24,7 @@ import { gatePublished } from './published.ts';
 
 const [command, ...args] = process.argv.slice(2);
 const usage = (): never => {
-  console.error('usage: twin-standard gate <repo> [units…] | gate-published <name>@<version>… [--registry <url>] | grade <unit>… [--static] [--form] | derive <unit> [--out <dir>] | read-page <url> [--raw] | check-sources <unit> [--recheck] | conform <pack dir> | <name>@<version> [--registry <url>] | create <dir> --init <vendor> --package <@scope/name> | create <unit> --index | facts <pack dir> [--out <file>] | assess <pack dir> [--browser] [--out <file>] | --version');
+  console.error('usage: twin-standard gate <repo> [units…] | gate-published <name>@<version>… [--registry <url>] | grade <unit>… [--static] [--form] | derive <unit> [--out <dir>] | read-page <url> [--raw] | check-sources <unit> [--recheck] | conform <pack dir> | <name>@<version> [--registry <url>] | create <dir> --init <vendor> --package <@scope/name> | create <unit> --index | facts <pack dir> [--out <file>] | prepare-consumer <pack dir> --app <new dir> --cli <volter executable> --integrity <sha512> --out <json> | assess <pack dir> --prepared-consumer <json> [--browser] [--out <file>] | --version');
   process.exit(2);
 };
 
@@ -73,10 +73,27 @@ if (command === '--version') {
 } else if (command === 'create') {
   if (args.includes('--init') && !args.includes('--package')) throw new Error('Name your scoped package with --package');
   await (await import('./create-pack.ts')).createPack(args);
+} else if (command === 'prepare-consumer') {
+  if (!args[0]) usage();
+  const value = (name: string) => { const at = args.indexOf(name); if (at < 0 || !args[at + 1]) usage(); return args[at + 1]!; };
+  const appDir = resolve(value('--app'));
+  const cli = resolve(value('--cli'));
+  const artifactIntegrity = value('--integrity');
+  if (!/^sha512-[A-Za-z0-9+/]{86}==$/.test(artifactIntegrity)) throw new Error('Consumer preparation requires candidate SHA-512 integrity');
+  const out = resolve(value('--out'));
+  if (existsSync(out)) throw new Error('Prepared consumer output already exists');
+  const { prepareConsumerApp } = await import('./consumer.ts');
+  const fixture = prepareConsumerApp(resolve(args[0]!), appDir);
+  const { writeFileSync } = await import('node:fs');
+  writeFileSync(out, JSON.stringify({ appDir, cli, artifactIntegrity }, null, 2) + '\n');
+  console.log(JSON.stringify({ appDir, fixture, preparedConsumer: out, next: 'Install the app SDK dependencies with scripts disabled before assessing inside a World' }));
 } else if (command === 'assess') {
   if (!args[0]) usage();
   const { assessPack } = await import('./assessment.ts');
-  const report = await assessPack(resolve(args[0]!), { browser: args.includes('--browser') });
+  const consumerAt = args.indexOf('--prepared-consumer');
+  if (consumerAt >= 0 && !args[consumerAt + 1]) usage();
+  const consumer = consumerAt >= 0 ? JSON.parse(readFileSync(resolve(args[consumerAt + 1]!), 'utf8')) : undefined;
+  const report = await assessPack(resolve(args[0]!), { browser: args.includes('--browser'), ...(consumer ? { consumer } : {}) });
   const at = args.indexOf('--out');
   if (at >= 0) {
     if (!args[at + 1]) usage();

package/src/clients/anthropic.first-use.json

@@ -0,0 +1,17 @@
+{
+  "schemaVersion": 1,
+  "source": "https://www.npmjs.com/package/@anthropic-ai/sdk/v/0.131.0",
+  "about": "Use the official SDK for Messages and streaming, checking the explicitly labeled model stub.",
+  "files": {
+    "package.json": "{\n  \"name\": \"anthropic-installed-customer\",\n  \"private\": true,\n  \"type\": \"module\",\n  \"dependencies\": {\n    \"@anthropic-ai/sdk\": \"0.131.0\"\n  }\n}\n",
+    ".env.example": "ANTHROPIC_API_KEY=\n",
+    "app.mjs": "import Anthropic from '@anthropic-ai/sdk';\nimport assert from 'node:assert/strict';\nimport { writeFileSync } from 'node:fs';\nassert.ok(process.env.VOLTER_WORLD, 'must run in the World');\nconst client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY, maxRetries:0 });\nconst input = {model:'claude-sonnet-4-5', max_tokens:128, messages:[{role:'user',content:'first-user deterministic fixture'}]};\nconst response = await client.messages.create(input);\nconst text = response.content.filter(x=>x.type==='text').map(x=>x.text).join('');\nassert.match(text,/\\[twin-stub:/);\nassert.equal(response.role,'assistant');\nassert.equal(response.stop_reason,'end_turn');\nlet streamed='';\nfor await (const event of await client.messages.create({...input,stream:true})) if (event.type==='content_block_delta' && event.delta.type==='text_delta') streamed+=event.delta.text;\nassert.equal(streamed,text);\nconst receipt={passed:true,scope:'unchanged official Anthropic SDK non-streamed and streamed Messages; labeled deterministic stub, no prose quality claim',};\nwriteFileSync('first-use-receipt.json',JSON.stringify(receipt,null,2)+'\\n');console.log(JSON.stringify(receipt));\n"
+  },
+  "run": [
+    "node",
+    "app.mjs"
+  ],
+  "retention": {
+    "none": "This workflow requests an unstored message and stream; it creates no vendor resource to read after restart."
+  }
+}

package/src/clients/clerk.first-use.json

@@ -0,0 +1,21 @@
+{
+  "schemaVersion": 1,
+  "source": "https://www.npmjs.com/package/@clerk/backend/v/2.33.3",
+  "about": "A first user creates a user and organization, adds a member, verifies a signed session token and removes the member; after resume the original owner and membership remain.",
+  "files": {
+    "package.json": "{\n  \"name\": \"clerk-installed-customer\",\n  \"private\": true,\n  \"type\": \"module\",\n  \"dependencies\": {\n    \"@clerk/backend\": \"2.33.3\"\n  }\n}\n",
+    ".env.example": "CLERK_SECRET_KEY=\nCLERK_PUBLISHABLE_KEY=\nCLERK_JWT_KEY=\n",
+    "workflow.mjs": "import assert from 'node:assert/strict';\nimport { writeFileSync } from 'node:fs';\nimport { createClerkClient, verifyToken } from '@clerk/backend';\n\nassert.ok(process.env.VOLTER_WORLD);\nconst clerk = createClerkClient({ secretKey: process.env.CLERK_SECRET_KEY });\nawait clerk.instance.updateOrganizationSettings({ enabled: true });\nconst owner = await clerk.users.createUser({ emailAddress: ['owner@catalog-clerk.example'], firstName: 'First', skipPasswordRequirement: true });\nconst org = await clerk.organizations.createOrganization({ name: 'Catalog first user', createdBy: owner.id });\nconst guest = await clerk.users.createUser({ emailAddress: ['member@catalog-clerk.example'], firstName: 'Member', skipPasswordRequirement: true });\nawait clerk.organizations.createOrganizationMembership({ organizationId: org.id, userId: guest.id, role: 'org:member' });\nconst before = await clerk.organizations.getOrganizationMembershipList({ organizationId: org.id, limit: 100 });\nassert.equal(before.totalCount, 2);\nassert.ok(before.data.some(member => member.publicUserData.userId === guest.id));\nconst session = await clerk.sessions.createSession({ userId: guest.id });\nconst { jwt } = await clerk.sessions.getToken(session.id);\nconst payload = await verifyToken(jwt, { secretKey: process.env.CLERK_SECRET_KEY });\nassert.equal(payload.sub, guest.id);\nassert.equal(payload.sid, session.id);\nawait clerk.users.deleteUser(guest.id);\nconst after = await clerk.organizations.getOrganizationMembershipList({ organizationId: org.id, limit: 100 });\nassert.equal(after.totalCount, 1);\nassert.equal(after.data[0].publicUserData.userId, owner.id);\nwriteFileSync('workflow-receipt.json', JSON.stringify({ owner: owner.id, organization: org.id, deletedMember: guest.id, remainingMemberships: after.totalCount, tokenVerified: true }, null, 2) + '\\n');\nconsole.log('Clerk SDK user, membership, signed token and deletion journey passed');\n",
+    "readback.mjs": "import assert from 'node:assert/strict';\nimport { readFileSync } from 'node:fs';\nimport { createClerkClient } from '@clerk/backend';\n\nassert.ok(process.env.VOLTER_WORLD);\nconst previous = JSON.parse(readFileSync('workflow-receipt.json', 'utf8'));\nconst clerk = createClerkClient({ secretKey: process.env.CLERK_SECRET_KEY });\nconst owner = await clerk.users.getUser(previous.owner);\nassert.equal(owner.emailAddresses[0].emailAddress, 'owner@catalog-clerk.example');\nconst memberships = await clerk.organizations.getOrganizationMembershipList({ organizationId: previous.organization, limit: 100 });\nassert.equal(memberships.totalCount, 1);\nassert.equal(memberships.data[0].publicUserData.userId, previous.owner);\nassert.ok(memberships.data.every(member => member.publicUserData.userId !== previous.deletedMember));\nconsole.log(JSON.stringify({ retained: true, organization: previous.organization, remainingMemberships: memberships.totalCount }));\n"
+  },
+  "run": [
+    "node",
+    "workflow.mjs"
+  ],
+  "retention": {
+    "readback": [
+      "node",
+      "readback.mjs"
+    ]
+  }
+}

package/src/clients/cloudflare.first-use.json

@@ -0,0 +1,21 @@
+{
+  "schemaVersion": 1,
+  "source": "https://www.npmjs.com/package/cloudflare/v/7.2.0",
+  "about": "Create a zone and DNS record through the official SDK, then read the retained record after restart.",
+  "files": {
+    "package.json": "{\n  \"name\": \"cloudflare-installed-customer\",\n  \"private\": true,\n  \"type\": \"module\",\n  \"dependencies\": {\n    \"cloudflare\": \"7.2.0\"\n  }\n}\n",
+    ".env.example": "CLOUDFLARE_API_TOKEN=\nCLOUDFLARE_ACCOUNT_ID=\n",
+    "resume.mjs": "import assert from 'node:assert/strict';\nimport { readFileSync, writeFileSync } from 'node:fs';\nimport Cloudflare from 'cloudflare';\nassert.ok(process.env.VOLTER_WORLD);\nconst held = JSON.parse(readFileSync('first-use-receipt.json', 'utf8'));\nconst client = new Cloudflare({ apiToken: process.env.CLOUDFLARE_API_TOKEN, maxRetries: 0 });\nconst saved = await client.dns.records.get(held.record, { zone_id: held.zone });\nassert.equal(saved.content, '192.0.2.10');\nconst receipt = { passed: true, scope: 'down/up retains DNS record and World-issued credentials remain usable',     };\nwriteFileSync('resume-receipt.json', JSON.stringify(receipt, null, 2) + '\\n');\nconsole.log(JSON.stringify(receipt));\n",
+    "app.mjs": "import assert from 'node:assert/strict';\nimport { writeFileSync } from 'node:fs';\nimport Cloudflare from 'cloudflare';\nassert.ok(process.env.VOLTER_WORLD);\nconst client = new Cloudflare({ apiToken: process.env.CLOUDFLARE_API_TOKEN, maxRetries: 0 });\nconst zone = await client.zones.create({ account: { id: process.env.CLOUDFLARE_ACCOUNT_ID }, name: 'first-user.example', type: 'full' });\nconst record = await client.dns.records.create({ zone_id: zone.id, type: 'A', name: 'www.first-user.example', content: '192.0.2.10', ttl: 1, proxied: true });\nconst saved = await client.dns.records.get(record.id, { zone_id: zone.id });\nassert.equal(saved.name, 'www.first-user.example');\nassert.equal(saved.content, '192.0.2.10');\nassert.equal(saved.proxied, true);\nconst receipt = { passed: true, scope: 'fresh published CLI init/up/run/log/down; unchanged official Cloudflare SDK zone create and DNS write/read',     zone: zone.id, record: record.id,  };\nwriteFileSync('first-use-receipt.json', JSON.stringify(receipt, null, 2) + '\\n');\nconsole.log(JSON.stringify(receipt));\n"
+  },
+  "run": [
+    "node",
+    "app.mjs"
+  ],
+  "retention": {
+    "readback": [
+      "node",
+      "resume.mjs"
+    ]
+  }
+}

package/src/clients/github.first-use.json

@@ -0,0 +1,21 @@
+{
+  "schemaVersion": 1,
+  "source": "https://www.npmjs.com/package/@octokit/rest/v/22.0.1",
+  "about": "Create a repository and issue through Octokit, inspect a missing issue refusal, then read the retained issue after restart.",
+  "files": {
+    "package.json": "{\n  \"name\": \"github-installed-customer\",\n  \"private\": true,\n  \"type\": \"module\",\n  \"dependencies\": {\n    \"@octokit/rest\": \"22.0.1\"\n  }\n}\n",
+    ".env.example": "GITHUB_TOKEN=\n",
+    "resume.mjs": "import assert from 'node:assert/strict';\nimport { readFileSync, writeFileSync } from 'node:fs';\nimport { Octokit } from '@octokit/rest';\nassert.ok(process.env.VOLTER_WORLD);\nconst prior = JSON.parse(readFileSync('first-use-receipt.json', 'utf8'));\nconst client = new Octokit({ auth: process.env.GITHUB_TOKEN });\nconst saved = (await client.rest.issues.get({ owner: prior.owner, repo: prior.repo, issue_number: prior.issue })).data;\nassert.equal(saved.title, prior.title);\nconst receipt = { passed: true, scope: 'ordinary down then up retains stored GitHub issue and usable throwaway credentials',   title: saved.title, issue: saved.number, };\nwriteFileSync('resume-receipt.json', JSON.stringify(receipt, null, 2) + '\\n');\nconsole.log(JSON.stringify(receipt));\n",
+    "app.mjs": "import assert from 'node:assert/strict';\nimport { writeFileSync } from 'node:fs';\nimport { Octokit } from '@octokit/rest';\nassert.ok(process.env.VOLTER_WORLD, 'Run the app through its World');\nassert.ok(process.env.GITHUB_TOKEN, 'The World supplies a throwaway token');\nconst client = new Octokit({ auth: process.env.GITHUB_TOKEN });\nconst created = await client.graphql('mutation($name: String!) { createRepository(input: { name: $name, visibility: PUBLIC }) { repository { nameWithOwner } } }', { name: 'first-catalog-app' });\nconst [owner, repo] = created.createRepository.repository.nameWithOwner.split('/');\nconst made = (await client.rest.issues.create({ owner, repo, title: 'First local issue', body: 'Created through the real Octokit SDK inside a World.' })).data;\nconst saved = (await client.rest.issues.get({ owner, repo, issue_number: made.number })).data;\nassert.equal(saved.title, made.title);\nassert.equal(saved.body, made.body);\nassert.equal(saved.state, 'open');\nawait assert.rejects(() => client.rest.issues.get({ owner, repo, issue_number: 99999 }), error => error.status === 404);\nconst receipt = { passed: true, scope: 'fresh published CLI init/up/run/log/down with unmodified Octokit; repository create and issue write/read/missing read',     owner, repo, issue: saved.number, title: saved.title,  };\nwriteFileSync('first-use-receipt.json', JSON.stringify(receipt, null, 2) + '\\n');\nconsole.log(JSON.stringify(receipt));\n"
+  },
+  "run": [
+    "node",
+    "app.mjs"
+  ],
+  "retention": {
+    "readback": [
+      "node",
+      "resume.mjs"
+    ]
+  }
+}

package/src/clients/openai.first-use.json

@@ -0,0 +1,17 @@
+{
+  "schemaVersion": 1,
+  "source": "https://www.npmjs.com/package/openai/v/7.28.0",
+  "about": "Use the official SDK for Chat Completions and SSE streaming, checking the explicitly labeled model stub.",
+  "files": {
+    "package.json": "{\n  \"name\": \"openai-installed-customer\",\n  \"private\": true,\n  \"type\": \"module\",\n  \"dependencies\": {\n    \"openai\": \"7.28.0\"\n  }\n}\n",
+    ".env.example": "OPENAI_API_KEY=\n",
+    "app.mjs": "import OpenAI from 'openai';\nimport assert from 'node:assert/strict';\nimport {writeFileSync} from 'node:fs';\nassert.ok(process.env.VOLTER_WORLD,'run through the World');\nconst client=new OpenAI({apiKey:process.env.OPENAI_API_KEY,maxRetries:0});\nconst input={model:'gpt-4o',messages:[{role:'user',content:'first-user deterministic fixture'}]};\nconst answer=await client.chat.completions.create(input);\nconst text=answer.choices[0].message.content;\nassert.match(text,/\\[twin-stub:/);\nassert.equal(answer.choices[0].message.role,'assistant');\nassert.equal(answer.choices[0].finish_reason,'stop');\nlet streamed='';\nfor await(const event of await client.chat.completions.create({...input,stream:true})) streamed+=event.choices[0]?.delta?.content??'';\nassert.equal(streamed,text);\nconst receipt={passed:true,scope:'unchanged official OpenAI SDK Chat Completions and SSE stream; labeled default model stub; no generated prose quality or Realtime/browser claim',};\nwriteFileSync('first-use-receipt.json',JSON.stringify(receipt,null,2)+'\\n');console.log(JSON.stringify(receipt));\n"
+  },
+  "run": [
+    "node",
+    "app.mjs"
+  ],
+  "retention": {
+    "none": "This workflow requests an unstored completion and stream; it creates no vendor resource to read after restart."
+  }
+}

package/src/clients/resend.first-use.json

@@ -0,0 +1,25 @@
+{
+  "schemaVersion": 1,
+  "source": "https://www.npmjs.com/package/resend/v/6.6.0",
+  "about": "Send a synthetic sign-in email through the official SDK and inspect the retained message and local inbox after restart. Advance the frozen World clock to settle synthetic delivery before retained-state inspection.",
+  "files": {
+    "package.json": "{\n  \"name\": \"resend-installed-customer\",\n  \"private\": true,\n  \"type\": \"module\",\n  \"dependencies\": {\n    \"resend\": \"6.6.0\"\n  }\n}\n",
+    ".env.example": "RESEND_API_KEY=\n",
+    "inspect-email.mjs": "import assert from 'node:assert/strict';\nimport { readFileSync } from 'node:fs';\nimport { Resend } from 'resend';\n\nassert.ok(process.env.VOLTER_WORLD, 'run this script through the World');\nconst { id } = JSON.parse(readFileSync('last-email.json', 'utf8'));\nconst resend = new Resend(process.env.RESEND_API_KEY);\nconst saved = await resend.emails.get(id);\nassert.equal(saved.error, null);\nassert.equal(saved.data.last_event, 'delivered');\nconst response = await fetch(`${process.env.RESEND_TWIN_URL}/_twin/mail?to=owner%40world.test`);\nassert.equal(response.status, 200);\nconst inbox = await response.json();\nconst email = inbox.mail.find((message) => message.id === id);\nassert.ok(email, 'the delivered message must be in the local inbox');\nassert.equal(email.subject, 'Your local sign-in code');\nassert.match(email.text, /123456/);\nassert.match(email.html, /<strong>123456<\\/strong>/);\nconsole.log('local inbox contains the delivered email and sign-in code');\n",
+    "send-email.mjs": "import assert from 'node:assert/strict';\nimport { writeFileSync } from 'node:fs';\nimport { Resend } from 'resend';\n\nassert.ok(process.env.VOLTER_WORLD, 'run this script through the World');\nconst resend = new Resend(process.env.RESEND_API_KEY);\nconst email = {\n  from: 'Example app <onboarding@resend.dev>',\n  to: ['owner@world.test'],\n  subject: 'Your local sign-in code',\n  text: 'Your synthetic sign-in code is 123456.',\n  html: '<p>Your synthetic sign-in code is <strong>123456</strong>.</p>'\n};\nconst sent = await resend.emails.send(email);\nassert.equal(sent.error, null);\nassert.ok(sent.data.id);\nconst saved = await resend.emails.get(sent.data.id);\nassert.equal(saved.error, null);\nassert.equal(saved.data.id, sent.data.id);\nassert.equal(saved.data.subject, email.subject);\nassert.equal(saved.data.text, email.text);\nassert.deepEqual(saved.data.to, email.to);\nwriteFileSync('last-email.json', JSON.stringify({ id: sent.data.id }) + '\\n');\nconsole.log('email sent and read back locally');\n"
+  },
+  "run": [
+    "node",
+    "send-email.mjs"
+  ],
+  "retention": {
+    "readback": [
+      "node",
+      "inspect-email.mjs"
+    ]
+  },
+  "clock": {
+    "at": "2026-10-06T12:00:00Z",
+    "advanceAfterRun": "10s"
+  }
+}

package/src/clients/run.ts

@@ -9,6 +9,7 @@ import { clientContext, worldProxy, type ClientCase } from './harness.ts';
 
 const job = JSON.parse(readFileSync(process.argv[2]!, 'utf8')) as { vendor: string; port: number; host: string; env: Record<string, string>; scenarioPath: string; packFacts: string };
 const { cases } = (await import(`./${job.vendor}${extname(fileURLToPath(import.meta.url))}`)) as { cases: ClientCase[] };
+if (!Array.isArray(cases) || cases.length === 0) throw new Error(`${job.vendor} client module declares no cases; there is no SDK execution evidence`);
 // every connection a case makes goes through the World's proxy, as an application's does in a World
 const proxy = await worldProxy(job.port);
 // Bind only this artifact's declared vendor hosts to the assessed server. The enclosing World's

package/src/clients/slack.first-use.json

@@ -0,0 +1,21 @@
+{
+  "schemaVersion": 1,
+  "source": "https://www.npmjs.com/package/@slack/web-api/v/7.19.0",
+  "about": "Create a Slack Connect invitation through the official SDK, then inspect the retained invitation after restart.",
+  "files": {
+    "package.json": "{\n  \"name\": \"slack-installed-customer\",\n  \"private\": true,\n  \"type\": \"module\",\n  \"dependencies\": {\n    \"@slack/web-api\": \"7.19.0\"\n  }\n}\n",
+    ".env.example": "SLACK_BOT_TOKEN=\nSLACK_APP_TOKEN=\nSLACK_SIGNING_SECRET=\n",
+    "readback.mjs": "import assert from 'node:assert/strict';\nimport {readFileSync} from 'node:fs';\nimport {WebClient} from '@slack/web-api';\nconst old=JSON.parse(readFileSync('workflow-receipt.json','utf8'));\nconst slack=new WebClient(process.env.SLACK_BOT_TOKEN);\nconst identity=await slack.auth.test();\nassert.equal(identity.team,'World');\nconst pending=await slack.conversations.listConnectInvites({count:1});\nassert.equal(pending.invites[0].invite.id,old.invitation);\nassert.equal(pending.invites[0].channel.id,old.channel);\nconsole.log(JSON.stringify({retained:true,workspace:identity.team,invitation:old.invitation}));\n",
+    "workflow.mjs": "import assert from 'node:assert/strict';\nimport { writeFileSync } from 'node:fs';\nimport { WebClient } from '@slack/web-api';\nassert.ok(process.env.VOLTER_WORLD);\nconst slack = new WebClient(process.env.SLACK_BOT_TOKEN);\nconst identity = await slack.auth.test();\nconst channel = await slack.conversations.create({ name: 'catalog-first-user-support' });\nconst invitation = await slack.conversations.inviteShared({ channel: channel.channel.id, emails: ['customer@outside.test'], external_limited: true });\nconst pending = await slack.conversations.listConnectInvites({ count: 1 });\nassert.equal(pending.invites[0].invite.id, invitation.invite_id);\nassert.equal(pending.invites[0].channel.id, channel.channel.id);\nwriteFileSync('workflow-receipt.json', JSON.stringify({ identity: { team_id: identity.team_id, team: identity.team }, channel: channel.channel.id, invitation: invitation.invite_id, pending: true }, null, 2) + '\\n');\n"
+  },
+  "run": [
+    "node",
+    "workflow.mjs"
+  ],
+  "retention": {
+    "readback": [
+      "node",
+      "readback.mjs"
+    ]
+  }
+}

package/src/clients/stripe.first-use.json

@@ -0,0 +1,21 @@
+{
+  "schemaVersion": 1,
+  "source": "https://www.npmjs.com/package/stripe/v/17.7.0",
+  "about": "Create and retrieve a customer through the official SDK. Read the retained customer after restart.",
+  "files": {
+    "package.json": "{\n  \"name\": \"stripe-installed-customer\",\n  \"private\": true,\n  \"type\": \"module\",\n  \"dependencies\": {\n    \"stripe\": \"17.7.0\"\n  }\n}\n",
+    ".env.example": "STRIPE_SECRET_KEY=\n",
+    "signup.mjs": "import { writeFileSync } from 'node:fs';\nimport assert from 'node:assert/strict';\nimport Stripe from 'stripe';\n\nassert.ok(process.env.VOLTER_WORLD);\nconst stripe = new Stripe(process.env.STRIPE_SECRET_KEY);\nconst customer = await stripe.customers.create({ email: 'ada@example.com', name: 'Ada' });\nconst saved = await stripe.customers.retrieve(customer.id);\nassert.equal(saved.email, 'ada@example.com');\nassert.equal(saved.name, 'Ada');\nconsole.log(`created ${customer.id}`);\nconsole.log('customer read-back passed');\nwriteFileSync('customer.json', JSON.stringify({ id: customer.id }) + '\\n');\n",
+    "readback.mjs": "import assert from 'node:assert/strict';\nimport { readFileSync } from 'node:fs';\nimport Stripe from 'stripe';\nassert.ok(process.env.VOLTER_WORLD);\nconst { id } = JSON.parse(readFileSync('customer.json', 'utf8'));\nconst stripe = new Stripe(process.env.STRIPE_SECRET_KEY);\nconst saved = await stripe.customers.retrieve(id);\nassert.equal(saved.email, 'ada@example.com');\nassert.equal(saved.name, 'Ada');\nconsole.log('retained customer read-back passed');\n"
+  },
+  "run": [
+    "node",
+    "signup.mjs"
+  ],
+  "retention": {
+    "readback": [
+      "node",
+      "readback.mjs"
+    ]
+  }
+}

package/src/clients/supabase.first-use.json

@@ -0,0 +1,21 @@
+{
+  "schemaVersion": 1,
+  "source": "https://www.npmjs.com/package/pg/v/8.16.3",
+  "about": "Use the issued Supabase database connection with unchanged node-postgres: schema, write and read, then read retained data after restart. This does not establish Supabase HTTP client compatibility.",
+  "files": {
+    "package.json": "{\n  \"name\": \"supabase-installed-customer\",\n  \"private\": true,\n  \"type\": \"module\",\n  \"dependencies\": {\n    \"pg\": \"8.16.3\"\n  }\n}\n",
+    ".env.example": "SUPABASE_DB_URL=\n",
+    "app.mjs": "import pg from 'pg';\nimport assert from 'node:assert/strict';\nimport {writeFileSync} from 'node:fs';\nassert.ok(process.env.VOLTER_WORLD,'run through the World');\nassert.ok(process.env.SUPABASE_DB_URL,'the World must issue the database URL');\nconst client=new pg.Client({connectionString:process.env.SUPABASE_DB_URL});\nawait client.connect();\ntry {\n if(process.argv[2]!=='resumed'){\n await client.query('CREATE TABLE IF NOT EXISTS catalog_signup (id text PRIMARY KEY, email text NOT NULL)');\n await client.query('INSERT INTO catalog_signup (id,email) VALUES ($1,$2) ON CONFLICT (id) DO NOTHING',['new-user','new-user@example.test']);\n }\n const {rows}=await client.query('SELECT id,email FROM catalog_signup WHERE id=$1',['new-user']);\n assert.deepEqual(rows,[{id:'new-user',email:'new-user@example.test'}]);\n const receipt={passed:true,phase:process.argv[2]??'first-boot',scope:'unchanged node-postgres client; project credential issuance and native PostgreSQL schema, insert and readback; no Supabase HTTP data-plane claim',};\n writeFileSync(`first-use-${receipt.phase}.json`,JSON.stringify(receipt,null,2)+'\\n');console.log(JSON.stringify(receipt));\n} finally {await client.end();}\n"
+  },
+  "run": [
+    "node",
+    "app.mjs"
+  ],
+  "retention": {
+    "readback": [
+      "node",
+      "app.mjs",
+      "resumed"
+    ]
+  }
+}

package/src/clients/tavily.first-use.json

@@ -0,0 +1,17 @@
+{
+  "schemaVersion": 1,
+  "source": "https://www.npmjs.com/package/@tavily/core/v/0.7.14",
+  "about": "Seed an explicitly synthetic World page through its existing door, then search and extract through the official SDK. No public web or model runs.",
+  "files": {
+    "package.json": "{\n  \"name\": \"tavily-installed-customer\",\n  \"private\": true,\n  \"type\": \"module\",\n  \"dependencies\": {\n    \"@tavily/core\": \"0.7.14\"\n  }\n}\n",
+    ".env.example": "TAVILY_API_KEY=\n",
+    "workflow.mjs": "import assert from 'node:assert/strict';\nimport { tavily } from '@tavily/core';\nassert.ok(process.env.VOLTER_WORLD);\nconst page = { url: 'https://schedule.example/yoga', title: 'Yoga schedule', content: 'Yoga on Tuesdays at 18:00.' };\nconst setup = await fetch('https://api.tavily.com/_twin/pages', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(page) });\nassert.equal(setup.status, 201);\nconst client = tavily({ apiKey: process.env.TAVILY_API_KEY });\nconst search = await client.search('Yoga schedule', { includeAnswer: true });\nassert.equal(search.results[0].url, page.url);\nassert.match(search.answer, /\\[twin-stub\\]/);\nconst extract = await client.extract([page.url]);\nassert.equal(extract.results[0].url, page.url);\nassert.match(extract.results[0].rawContent, /Yoga on Tuesdays/);\nconsole.log('Official Tavily SDK search and extract over the synthetic World corpus passed');\n"
+  },
+  "run": [
+    "node",
+    "workflow.mjs"
+  ],
+  "retention": {
+    "none": "Search and extraction create no stored Tavily resource; the pages door supplies synthetic World corpus, not vendor state."
+  }
+}

package/src/clients/upstash.first-use.json

@@ -0,0 +1,21 @@
+{
+  "schemaVersion": 1,
+  "source": "https://www.npmjs.com/package/@upstash/redis/v/1.38.2",
+  "about": "Store and read a profile and counter through the Redis SDK, then inspect both after restart.",
+  "files": {
+    "package.json": "{\n  \"name\": \"upstash-installed-customer\",\n  \"private\": true,\n  \"type\": \"module\",\n  \"dependencies\": {\n    \"@upstash/redis\": \"1.38.2\"\n  }\n}\n",
+    ".env.example": "UPSTASH_REDIS_REST_URL=\nUPSTASH_REDIS_REST_TOKEN=\n",
+    "resume.mjs": "import assert from 'node:assert/strict';\nimport { writeFileSync } from 'node:fs';\nimport { Redis } from '@upstash/redis';\nassert.ok(process.env.VOLTER_WORLD);\nconst redis = Redis.fromEnv();\nassert.deepEqual(await redis.get('first-user:profile'), { email: 'first-user@example.test', plan: 'free' });\nassert.equal(await redis.get('first-user:visits'), 1);\nconst receipt = { passed: true, scope: 'down/up retains Redis data and throwaway credentials remain usable',     };\nwriteFileSync('resume-receipt.json', JSON.stringify(receipt, null, 2) + '\\n');\nconsole.log(JSON.stringify(receipt));\n",
+    "app.mjs": "import assert from 'node:assert/strict';\nimport { writeFileSync } from 'node:fs';\nimport { Redis } from '@upstash/redis';\nassert.ok(process.env.VOLTER_WORLD);\nconst redis = Redis.fromEnv();\nconst value = { email: 'first-user@example.test', plan: 'free' };\nassert.equal(await redis.set('first-user:profile', value), 'OK');\nassert.deepEqual(await redis.get('first-user:profile'), value);\nassert.equal(await redis.incr('first-user:visits'), 1);\nassert.equal(await redis.get('first-user:missing'), null);\nconst receipt = { passed: true, scope: 'fresh published CLI init/up/run/log/down; unchanged official Redis SDK set/get/incr/missing read',      };\nwriteFileSync('first-use-receipt.json', JSON.stringify(receipt, null, 2) + '\\n');\nconsole.log(JSON.stringify(receipt));\n"
+  },
+  "run": [
+    "node",
+    "app.mjs"
+  ],
+  "retention": {
+    "readback": [
+      "node",
+      "resume.mjs"
+    ]
+  }
+}

package/src/conformance.ts

@@ -404,6 +404,7 @@ async function clientCases(pack: string, scratch: string): Promise<{ failures: s
       child.on('close', (code) => { clearTimeout(timer); resolve(code === 0 ? text : `${text}\n${JSON.stringify({ id: 'runner', asks: 'the cases run', failures: [`node exited ${code}: ${errors.trim().split('\n').slice(0, 12).join(' ')}`] })}`); });
     });
     const results = out.split('\n').filter((l) => l.startsWith('{')).map((l) => JSON.parse(l) as { id: string; asks: string; failures: string[] });
+    if (results.length === 0) return { failures: [`${vendor} client runner returned no case results; there is no SDK execution evidence`] };
     return { failures: results.flatMap((r) => r.failures.map((f) => `${r.id} (${r.asks}): ${f}`)), note: `${results.length} case(s) through the vendor's client` };
   } finally { await server.stop(); }
 }