@tiinex/app 0.1.1

package/src/tooling/portable/input/node.input.case.mjs

@@ -0,0 +1,293 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, readFile, rm, symlink, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { loadNodePortableInput } from '@tiinex/core/tooling/portable/input/node.input.js';
+import { runPortableCli } from '@tiinex/core/tooling/portable/adapters/cli/cli.run.js';
+import { openPortableSession } from '@tiinex/core/tooling/portable/session/portable.session.js';
+
+const root = await mkdtemp(path.join(os.tmpdir(), 'tiinex-portable-'));
+try {
+  const nested = path.join(root, 'received');
+  await mkdir(nested, { recursive: true });
+  await writeFile(path.join(nested, 'artifact.md'), topicMarkdown(), 'utf8');
+  await writeFile(path.join(nested, 'asset.bin'), Buffer.from([1, 2, 3, 4]));
+  await writeFile(path.join(nested, 'preview.png'), Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]));
+  try { await symlink(path.join(nested, 'artifact.md'), path.join(nested, 'linked.md')); } catch {}
+
+  const directoryInput = await loadNodePortableInput(nested);
+  assert.equal(directoryInput.files.some((file) => file.path === 'artifact.md'), true);
+  assert.equal(directoryInput.files.some((file) => file.path === 'artifact.md' && file.locator?.kind === 'node-file' && file.locator.localPath === path.join(nested, 'artifact.md')), true);
+  assert.equal(directoryInput.files.some((file) => file.path === 'asset.bin' && file.kind === 'asset'), true);
+  assert.equal(directoryInput.files.some((file) => file.path === 'preview.png' && file.locator?.kind === 'node-file'), true);
+  assert.equal(directoryInput.files.some((file) => file.path === 'linked.md'), false);
+
+  const zipPath = path.join(root, 'received.zip');
+  await writeFile(zipPath, storedZip([
+    { name: 'zip-artifact.md', data: Buffer.from(topicMarkdown(), 'utf8') },
+    { name: 'assets/pixel.bin', data: Buffer.from([9, 8, 7]) }
+  ]));
+  const zipInput = await loadNodePortableInput(zipPath);
+  assert.equal(zipInput.files.some((file) => file.path === 'zip-artifact.md' && typeof file.content === 'string'), true);
+  assert.equal(zipInput.files.some((file) => file.path === 'zip-artifact.md' && file.locator?.kind === 'node-zip-entry' && file.locator.archivePath === zipPath && file.locator.entryPath === 'zip-artifact.md'), true);
+  assert.equal(zipInput.files.some((file) => file.path === 'assets/pixel.bin' && file.kind === 'asset'), true);
+  assert.equal(zipInput.findings.some((finding) => finding.severity === 'error'), false);
+
+  const packageControlPath = path.join(root, 'package-control.zip');
+  const largePackageControl = JSON.stringify({ schema: 'tiinex.portable.large-package-control.fixture.v1', padding: 'x'.repeat(140 * 1024) });
+  await writeFile(packageControlPath, storedZip([{ name: 'tiinex.package/handoff-closure.json', data: Buffer.from(largePackageControl, 'utf8') }]));
+  const packageControlInput = await loadNodePortableInput(packageControlPath);
+  const hydratedPackageControl = packageControlInput.files.find((file) => file.path === 'tiinex.package/handoff-closure.json');
+  assert.equal(typeof hydratedPackageControl?.content, 'string', true, 'package control JSON above generic archive preview size must remain readable within portable maxTextBytes');
+  assert.equal(JSON.parse(hydratedPackageControl.content).schema, 'tiinex.portable.large-package-control.fixture.v1');
+  const boundedPackageControlInput = await loadNodePortableInput(packageControlPath, { maxTextBytes: 64 * 1024 });
+  assert.equal(typeof boundedPackageControlInput.files.find((file) => file.path === 'tiinex.package/handoff-closure.json')?.content, 'undefined');
+  assert.equal(boundedPackageControlInput.findings.some((finding) => finding.code === 'portable.node.zip-text-too-large'), true);
+
+  const output = [];
+  const errors = [];
+  const exitCode = await runPortableCli(['inspect', nested], {
+    log(value) { output.push(value); },
+    error(value) { errors.push(value); }
+  });
+  assert.equal(exitCode, 0);
+  assert.equal(errors.length, 0);
+  const cliResult = JSON.parse(output.at(-1));
+  assert.equal(cliResult.operation, 'inspect');
+  assert.equal(cliResult.records.length, 1);
+
+  const operationOutput = [];
+  assert.equal(await runPortableCli(['operations', '--compact'], { log(value) { operationOutput.push(value); }, error() {} }), 0);
+  const operations = JSON.parse(operationOutput[0]).operations;
+  assert.equal(operations.some((operation) => operation.name === 'make-writer-brief'), true);
+  assert.equal(operations.some((operation) => operation.name === 'schema-guide'), true);
+  assert.equal(operations.some((operation) => operation.name === 'search-lineage'), true);
+  assert.equal(operations.some((operation) => operation.name === 'create-checkpoint'), true);
+  assert.equal(operations.some((operation) => operation.name === 'build-runtime-package'), true);
+
+  assert.equal(operations.some((operation) => operation.name === 'describe-checkpoint-gate'), true);
+  assert.equal(operations.some((operation) => operation.name === 'qualify-checkpoint'), true);
+  const gateOutput = [];
+  assert.equal(await runPortableCli(['describe-checkpoint-gate', '--profile', 'portable'], { log(value) { gateOutput.push(value); }, error() {} }), 0);
+  const gateResult = JSON.parse(gateOutput[0]);
+  assert.equal(gateResult.profile, 'portable');
+  assert.equal(gateResult.gates.length, 2);
+  const qualificationInputPath = path.join(root, 'qualification-input.json');
+  await writeFile(qualificationInputPath, JSON.stringify({
+    profile: 'portable',
+    siteIdentity: { name: 'tiinex-site', version: '0.0.1-v1' },
+    portableIdentity: { sourceFingerprint: 'sha256:source', operationFingerprint: 'sha256:catalog' },
+    receipts: gateResult.gates.map((gate) => ({ schema: 'tiinex.portable.validation-receipt.v1', gateId: gate.id, command: gate.command, status: 'passed', exitCode: 0 })),
+    reproducibility: { dependencies: {}, lockfiles: ['package-lock.json'], installer: 'npm ci' },
+    continuity: { parityCheckpoint: 'v1' }
+  }), 'utf8');
+  const qualificationOutput = [];
+  assert.equal(await runPortableCli(['qualify-checkpoint', qualificationInputPath], { log(value) { qualificationOutput.push(value); }, error() {} }), 0);
+  assert.equal(JSON.parse(qualificationOutput[0]).status, 'qualified');
+
+  const searchOutput = [];
+  assert.equal(await runPortableCli(['search-lineage', nested, '--query', 'portable local'], { log(value) { searchOutput.push(value); }, error() {} }), 0);
+  assert.equal(JSON.parse(searchOutput[0]).matches.some((match) => match.path === 'artifact.md'), true);
+
+  const schemaDir = path.join(root, 'schemas');
+  await mkdir(schemaDir, { recursive: true });
+  await writeFile(path.join(schemaDir, 'tiinex.topic.v1.schema.md'), await readFile(new URL('../../../schemas/core/topic/tiinex.topic.v1.schema.md', import.meta.url), 'utf8'), 'utf8');
+  const guideOutput = [];
+  assert.equal(await runPortableCli(['schema-guide', schemaDir, '--schema', 'tiinex.topic.v1', '--task', 'create'], { log(value) { guideOutput.push(value); }, error() {} }), 0);
+  assert.equal(JSON.parse(guideOutput[0]).guide.schema, 'tiinex.llm.schema-guide.v1');
+
+  await writeFile(path.join(schemaDir, 'tiinex.evidence.v1.schema.md'), await readFile(new URL('../../../schemas/core/evidence/tiinex.evidence.v1.schema.md', import.meta.url), 'utf8'), 'utf8');
+  await writeFile(path.join(schemaDir, 'tiinex.preservation.v1.schema.md'), await readFile(new URL('../../../schemas/core/preservation/tiinex.preservation.v1.schema.md', import.meta.url), 'utf8'), 'utf8');
+  await writeFile(path.join(schemaDir, 'tiinex.root.v1.schema.md'), await readFile(new URL('../../../schemas/tiinex.root.v1.schema.md', import.meta.url), 'utf8'), 'utf8');
+  const hostPath = path.join(root, 'host.json');
+  await writeFile(hostPath, JSON.stringify({ tools: [
+    { name: 'GitHub.search', description: 'Search repository files.' },
+    { name: 'GitHub.fetch_file', description: 'Read repository files.' },
+    { name: 'vision.open_image', description: 'Open image for multimodal analysis.' },
+    { name: 'archive.extract', description: 'Extract zip archive entries.' }
+  ] }), 'utf8');
+  const actionRequestPath = path.join(root, 'action-request.json');
+  await writeFile(actionRequestPath, JSON.stringify({ schemaId: 'tiinex.remote.v1', repository: 'Tiinex/docs', ref: 'master', searchQueries: ['tiinex.remote.v1.schema.md'], nextOperation: 'resolve-schema-material' }), 'utf8');
+  const actionOutput = [];
+  assert.equal(await runPortableCli(['plan-host-action', 'repository-schema-resolution', '--host', hostPath, '--request', actionRequestPath], { log(value) { actionOutput.push(value); }, error() {} }), 0);
+  const actionPlan = JSON.parse(actionOutput[0]);
+  assert.equal(actionPlan.status, 'ready');
+  assert.equal(actionPlan.steps[0].tool.name, 'GitHub.search');
+  assert.equal(actionPlan.steps[1].tool.name, 'GitHub.fetch_file');
+
+  const resolveOutput = [];
+  assert.equal(await runPortableCli(['resolve-schema-material', schemaDir, '--schema', 'tiinex.evidence.v1', '--host', hostPath], { log(value) { resolveOutput.push(value); }, error() {} }), 0);
+  assert.equal(JSON.parse(resolveOutput[0]).status, 'resolved');
+
+  const valuesPath = path.join(root, 'values.json');
+  await writeFile(valuesPath, JSON.stringify({
+    'Supported Claim Or Question': 'whether overflow was observed',
+    'Evidence Role': 'supports observation',
+    'Known Source': 'explicit local fixture',
+    'Preservation Basis': 'test fixture',
+    'Provenance Limits': 'no surrounding context',
+    'Material': 'Overflow was observed.',
+    'Material Kind': 'excerpt',
+    'Preservation State': 'readable markdown',
+    'Fidelity Notes': 'test representation',
+    'Known Losses': 'device details',
+    'Does Not Prove': 'cause or fix',
+    'Must Not Be Treated As': 'completion or consent'
+  }), 'utf8');
+  const parentPath = path.join(root, 'parent.json');
+  await writeFile(parentPath, JSON.stringify({ id: 'parent-record', path: 'parent.md', schemaId: 'tiinex.preservation.v1', boundary: 'portable local material; no GitHub provenance inferred' }), 'utf8');
+  const createOutput = [];
+  assert.equal(await runPortableCli(['create-local-draft', schemaDir, '--schema', 'tiinex.evidence.v1', '--values', valuesPath, '--parent', parentPath, '--title', 'CLI Evidence'], { log(value) { createOutput.push(value); }, error() {} }), 2, 'legacy readable-schema parent draft must remain materialized but semantic validation errors make the CLI nonzero');
+  const createdDraft = JSON.parse(createOutput[0]);
+  assert.equal(createdDraft.status, 'blocked', 'exact Evidence creation must fail closed when the supplied Parent authority is not coherent');
+  assert.equal(createdDraft.qualification.exactCreateToolingAvailable, true);
+  assert.equal(createdDraft.qualification.parentAuthorityQualification, 'invalid');
+  assert.equal(createdDraft.draft, null);
+
+  const packageValuesPath = path.join(root, 'package-topic-values.json');
+  await writeFile(packageValuesPath, JSON.stringify({
+    Summary: 'CLI package topic',
+    'Current Read': 'Portable package fixture.',
+    'Design Direction': 'Exercise package transport with a contract-valid local root.',
+    'Next Artifacts': 'None.'
+  }), 'utf8');
+  const packageDraftOutput = [];
+  assert.equal(await runPortableCli(['create-local-draft', schemaDir, '--schema', 'tiinex.topic.v1', '--values', packageValuesPath, '--title', 'CLI package topic'], { log(value) { packageDraftOutput.push(value); }, error() {} }), 0);
+  const packageDraft = JSON.parse(packageDraftOutput[0]);
+  assert.equal(packageDraft.status, 'created-clean');
+  const packageStaged = { ...packageDraft.draft, qualification: packageDraft.qualification, lifecycleStatus: 'draft', sourceMode: 'local-portable-staged' };
+
+  const sessionPath = path.join(root, 'session.json');
+  const staged = { ...packageDraft.draft, qualification: packageDraft.qualification, lifecycleStatus: 'draft', sourceMode: 'local-portable-staged' };
+  await writeFile(sessionPath, JSON.stringify(openPortableSession({ files: directoryInput.files, stagedArtifacts: [staged], currentFocus: staged.path }).snapshot()), 'utf8');
+  const checkpointOutput = [];
+  assert.equal(await runPortableCli(['create-checkpoint', sessionPath, '--created-at', '2026-07-23T04:00:00.000Z'], { log(value) { checkpointOutput.push(value); }, error() {} }), 0);
+  const checkpoint = JSON.parse(checkpointOutput[0]);
+  assert.equal(checkpoint.operation, 'create-checkpoint');
+  assert.equal(checkpoint.boundary.canonicalHandoffArtifact, false);
+  const checkpointPath = path.join(root, 'checkpoint.json');
+  await writeFile(checkpointPath, JSON.stringify({ schema: checkpoint.resultSchema, version: checkpoint.version, checkpointId: checkpoint.checkpointId, createdAt: checkpoint.createdAt, status: checkpoint.status, summary: checkpoint.summary, session: checkpoint.session, integrity: checkpoint.integrity, boundary: checkpoint.boundary, findings: checkpoint.findings, findingSummary: checkpoint.findingSummary }), 'utf8');
+  const restoreCheckpointOutput = [];
+  assert.equal(await runPortableCli(['restore-checkpoint', checkpointPath], { log(value) { restoreCheckpointOutput.push(value); }, error() {} }), 0);
+  assert.equal(JSON.parse(restoreCheckpointOutput[0]).status, 'restored');
+
+  const stagedPath = path.join(root, 'staged.json');
+  await writeFile(stagedPath, JSON.stringify([packageStaged]), 'utf8');
+  const packageOutput = [];
+  assert.equal(await runPortableCli(['build-runtime-package', '--staged', stagedPath, '--title', 'CLI package'], { log(value) { packageOutput.push(value); }, error() {} }), 0);
+  const runtimePackage = JSON.parse(packageOutput[0]);
+  assert.equal(runtimePackage.operation, 'build-runtime-package');
+  assert.equal(runtimePackage.qualification.canonicalPackageSchemaLocked, false);
+  const bundlePath = path.join(root, 'bundle.json');
+  await writeFile(bundlePath, JSON.stringify(runtimePackage.bundle), 'utf8');
+  const packageInspectionOutput = [];
+  assert.equal(await runPortableCli(['inspect-runtime-package', bundlePath], { log(value) { packageInspectionOutput.push(value); }, error() {} }), 0);
+  assert.equal(JSON.parse(packageInspectionOutput[0]).status, 'valid');
+  const packageZipPath = path.join(root, 'runtime-package.zip');
+  const packageWriteOutput = [];
+  assert.equal(await runPortableCli(['build-runtime-package', '--staged', stagedPath, '--output', packageZipPath], { log(value) { packageWriteOutput.push(value); }, error() {} }), 0);
+  assert.equal(JSON.parse(packageWriteOutput[0]).writeReceipt.status, 'written');
+  const packageZipInput = await loadNodePortableInput(packageZipPath);
+  assert.equal(packageZipInput.files.some((file) => file.path === 'tiinex.package/manifest.json'), true);
+  const rehydrateOutput = [];
+  assert.equal(await runPortableCli(['rehydrate-runtime-package', packageZipPath], { log(value) { rehydrateOutput.push(value); }, error() {} }), 0);
+  assert.equal(JSON.parse(rehydrateOutput[0]).status, 'rehydrated');
+  const serializedRoundTripOutput = [];
+  assert.equal(await runPortableCli(['roundtrip-runtime-package', packageZipPath], { log(value) { serializedRoundTripOutput.push(value); }, error() {} }), 0);
+  assert.equal(JSON.parse(serializedRoundTripOutput[0]).comparison.status, 'match');
+
+  const assetOutput = [];
+  assert.equal(await runPortableCli(['inspect-assets', nested], { log(value) { assetOutput.push(value); }, error() {} }), 0);
+  assert.equal(JSON.parse(assetOutput[0]).counts.images, 1);
+  const assetPrepareOutput = [];
+  assert.equal(await runPortableCli(['prepare-asset-analysis', nested, '--asset', 'preview.png', '--host', hostPath], { log(value) { assetPrepareOutput.push(value); }, error() {} }), 0);
+  assert.equal(JSON.parse(assetPrepareOutput[0]).status, 'host-action-ready');
+} finally {
+  await rm(root, { recursive: true, force: true });
+}
+
+console.log('✓ portable Node file/directory/zip input and CLI adapter passed');
+
+function topicMarkdown() {
+  return `# Continuity Context
+
+- Envelope Schema: [tiinex.root.v1](tiinex.root.v1.schema.md)
+- Current
+  - Current Schema: [tiinex.topic.v1](tiinex.topic.v1.schema.md)
+  - Created At: 2026-07-22 00:00:00
+  - Summary: Node input test
+
+---
+
+# Node Input Test
+
+## Content
+
+Portable local material.
+`;
+}
+
+function storedZip(entries) {
+  const localParts = [];
+  const centralParts = [];
+  let offset = 0;
+  for (const entry of entries) {
+    const name = Buffer.from(entry.name, 'utf8');
+    const data = Buffer.from(entry.data);
+    const crc = crc32(data);
+    const local = Buffer.alloc(30);
+    local.writeUInt32LE(0x04034b50, 0);
+    local.writeUInt16LE(20, 4);
+    local.writeUInt16LE(0x0800, 6);
+    local.writeUInt16LE(0, 8);
+    local.writeUInt16LE(0, 10);
+    local.writeUInt16LE(0, 12);
+    local.writeUInt32LE(crc, 14);
+    local.writeUInt32LE(data.length, 18);
+    local.writeUInt32LE(data.length, 22);
+    local.writeUInt16LE(name.length, 26);
+    local.writeUInt16LE(0, 28);
+    localParts.push(local, name, data);
+
+    const central = Buffer.alloc(46);
+    central.writeUInt32LE(0x02014b50, 0);
+    central.writeUInt16LE(20, 4);
+    central.writeUInt16LE(20, 6);
+    central.writeUInt16LE(0x0800, 8);
+    central.writeUInt16LE(0, 10);
+    central.writeUInt16LE(0, 12);
+    central.writeUInt16LE(0, 14);
+    central.writeUInt32LE(crc, 16);
+    central.writeUInt32LE(data.length, 20);
+    central.writeUInt32LE(data.length, 24);
+    central.writeUInt16LE(name.length, 28);
+    central.writeUInt16LE(0, 30);
+    central.writeUInt16LE(0, 32);
+    central.writeUInt16LE(0, 34);
+    central.writeUInt16LE(0, 36);
+    central.writeUInt32LE(0, 38);
+    central.writeUInt32LE(offset, 42);
+    centralParts.push(central, name);
+    offset += local.length + name.length + data.length;
+  }
+  const centralDirectory = Buffer.concat(centralParts);
+  const end = Buffer.alloc(22);
+  end.writeUInt32LE(0x06054b50, 0);
+  end.writeUInt16LE(0, 4);
+  end.writeUInt16LE(0, 6);
+  end.writeUInt16LE(entries.length, 8);
+  end.writeUInt16LE(entries.length, 10);
+  end.writeUInt32LE(centralDirectory.length, 12);
+  end.writeUInt32LE(offset, 16);
+  end.writeUInt16LE(0, 20);
+  return Buffer.concat([...localParts, centralDirectory, end]);
+}
+
+function crc32(buffer) {
+  let crc = 0xffffffff;
+  for (const byte of buffer) {
+    crc ^= byte;
+    for (let i = 0; i < 8; i += 1) crc = (crc >>> 1) ^ (0xedb88320 & -(crc & 1));
+  }
+  return (crc ^ 0xffffffff) >>> 0;
+}

package/src/tooling/portable/lifecycle/lifecycle.readiness.case.mjs

@@ -0,0 +1,179 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { createRecordFromMarkdown } from '@tiinex/core/artifacts/artifact.record.js';
+import { sealC14nV2Self, validatedC14nV2PrimarySelfDigest } from '@tiinex/core/integrity/integrity.c14nV2.js';
+import { C14N_V2_VALIDATOR_TARGET } from '@tiinex/core/integrity/integrity.methodReference.js';
+import { projectPortableLifecycleReadiness } from '@tiinex/core/tooling/portable/lifecycle/lifecycle.readiness.js';
+import { runPortableOperation } from '@tiinex/core/tooling/portable/operation.catalog.js';
+import { runPortableCli } from '@tiinex/core/tooling/portable/adapters/cli/cli.run.js';
+
+const CONTROL = 'fixture/control.trace.md';
+const CHILD = 'fixture/child.trace.md';
+const RETEST = 'fixture/retest.trace.md';
+const CLOSURE = 'fixture/closure.trace.md';
+const REDUCTION = 'fixture/reduction.trace.md';
+const AUTHORITY = Object.freeze({ criteriaOwner: Object.freeze({ state: 'qualified', role: 'Reviewer', basis: 'qualified fixture criteria-owner authority' }) });
+
+const control = artifactTask(CONTROL, 'Controlling Task');
+const child = artifactTask(CHILD, 'Required Child Task', { parent: control });
+const retestArtifact = artifactValidation(RETEST);
+const closureArtifact = artifactDecision(CLOSURE);
+const reductionArtifact = artifactReduction(REDUCTION);
+const records = Object.freeze([control.record, child.record, retestArtifact.record, closureArtifact.record, reductionArtifact.record]);
+
+function project(facts = {}, extra = {}) {
+  return projectPortableLifecycleReadiness({ records, controllingTask: CONTROL, facts: { authority: AUTHORITY, ...facts }, ...extra });
+}
+function rep(overrides = {}) {
+  return { obligation: CHILD, representative: CHILD, state: 'resolved', currentness: 'current', qualification: 'qualified', retestInputState: 'available', basis: 'qualified current representative fact', ...overrides };
+}
+function retest(state = 'passed', overrides = {}) {
+  return { artifact: RETEST, state, currentness: 'current', qualification: 'qualified', target: CONTROL, criteriaCoverage: 'complete', methodState: 'qualified', authorityRole: 'Reviewer', authorityState: 'qualified', authorityBasis: 'qualified Reviewer authority', basis: 'qualified exact re-test outcome', ...overrides };
+}
+function closure(overrides = {}) {
+  return { artifact: CLOSURE, state: 'closed', explicit: true, currentness: 'current', qualification: 'qualified', target: CONTROL, authorityRole: 'Reviewer', authorityState: 'qualified', authorityBasis: 'qualified Reviewer closure authority', passBasisArtifact: RETEST, basis: 'qualified explicit closure decision', ...overrides };
+}
+
+{
+  const result = project({ representatives: [rep({ state: 'active' })] });
+  assert.equal(result.controllingTask.state, 'qualified');
+  assert.equal(result.currentRepresentatives.length, 1, 'qualified direct Task Parent continuity must create the required child obligation');
+  assert.equal(result.readiness.state, 'not-ready-for-retest');
+  assert(result.blockers.some((item) => item.code === 'required-work-current'));
+}
+console.log('✓ failed/incomplete criterion expansion plus active required descendant remains not-ready-for-retest');
+
+{
+  const result = project({ representatives: [rep()] });
+  assert.equal(result.readiness.state, 'ready-for-retest');
+  assert.equal(result.retest.state, 'not-observed');
+  assert.equal(result.closure.state, 'open');
+  assert.equal(result.nextAction.kind, 'invoke-authorized-retest');
+}
+console.log('✓ child convergence without parent re-test is ready-for-retest, not passed or closed');
+
+{
+  const result = project({ representatives: [rep()], retests: [retest('passed')] });
+  assert.equal(result.retest.state, 'passed');
+  assert.equal(result.closure.state, 'open');
+  assert.equal(result.readiness.state, 'ready-for-retest');
+  assert.equal(result.nextAction.kind, 'obtain-explicit-authoritative-closure');
+}
+console.log('✓ authoritative pass remains distinct from explicit closure');
+
+{
+  const result = project({ representatives: [rep()], retests: [retest('passed')], closures: [closure()] });
+  assert.equal(result.retest.state, 'passed');
+  assert.equal(result.closure.state, 'closed');
+  assert.equal(result.readiness.state, 'not-applicable');
+  assert.equal(result.nextAction.kind, 'none-unless-authoritatively-reopened');
+}
+console.log('✓ explicit authoritative closure makes readiness not-applicable');
+
+{
+  const result = project({ representatives: [rep({ state: 'active' })], retests: [retest('failed')] });
+  assert.equal(result.retest.state, 'failed');
+  assert.equal(result.closure.state, 'open');
+  assert.equal(result.readiness.state, 'not-ready-for-retest');
+  assert.equal(result.nextAction.kind, 'address-failed-criteria-with-bounded-work');
+}
+console.log('✓ failed re-test followed by bounded child work remains not-ready and open');
+
+{
+  const missing = project({ representatives: [] });
+  assert.equal(missing.readiness.state, 'unresolved');
+  assert(missing.missingEvidence.some((item) => item.code === 'current-representative-missing'));
+  const ambiguous = project({ representatives: [rep(), rep({ representative: REDUCTION, carryForwardState: 'sufficient', lossState: 'none', validationState: 'qualified' })] });
+  assert.equal(ambiguous.readiness.state, 'unresolved');
+  assert(ambiguous.ambiguities.some((item) => item.code === 'current-representative-ambiguous'));
+}
+console.log('✓ missing or ambiguous current representative fails closed as unresolved');
+
+{
+  const result = project({ representatives: [rep({ currentness: 'historical', state: 'active', basis: 'qualified historical fact' }), rep({ state: 'resolved' })] });
+  assert.equal(result.currentRepresentatives.length, 1);
+  assert.equal(result.currentRepresentatives[0].state, 'resolved');
+  assert.equal(result.readiness.state, 'ready-for-retest');
+}
+console.log('✓ qualified current evidence supersedes stale historical nonterminal evidence');
+
+{
+  const result = project({ representatives: [rep({ representative: REDUCTION, carryForwardState: 'sufficient', lossState: 'none', validationState: 'qualified' })] });
+  assert.equal(result.readiness.state, 'ready-for-retest');
+  assert.equal(result.currentRepresentatives[0].reduction.isReduction, true);
+  assert.equal(result.currentRepresentatives[0].reduction.completionProof, false);
+  assert.equal(result.retest.state, 'not-observed');
+  assert.equal(result.closure.state, 'open');
+}
+console.log('✓ qualified Reduction can preserve re-test inputs but is never completion proof');
+
+{
+  const result = project({ representatives: [rep({ representative: REDUCTION, carryForwardState: 'partial', lossState: 'unresolved', validationState: 'qualified' })] });
+  assert.equal(result.readiness.state, 'unresolved');
+  assert(result.ambiguities.some((item) => item.code === 'reduction-loss-unresolved'));
+}
+console.log('✓ Reduction with material unresolved loss stays unresolved rather than false-green');
+
+{
+  const result = project({ representatives: [rep()], retests: [retest('passed', { authorityRole: 'OtherRole' })] });
+  assert.equal(result.retest.state, 'unresolved');
+  assert.equal(result.readiness.state, 'unresolved');
+  assert(result.ambiguities.some((item) => item.code === 'retest-outcome-unqualified'));
+}
+console.log('✓ explicit re-test authority mismatch cannot become passed');
+
+{
+  const result = project({ representatives: [rep()], retests: [retest('passed', { currentness: 'unresolved' })] });
+  assert.equal(result.retest.state, 'unresolved');
+  assert.equal(result.readiness.state, 'unresolved');
+}
+console.log('✓ unresolved re-test currentness remains unresolved');
+
+{
+  const operation = await runPortableOperation('project-lifecycle-readiness', { records, controllingTask: CONTROL, facts: { authority: AUTHORITY, representatives: [rep()] } });
+  assert.equal(operation.operation, 'project-lifecycle-readiness');
+  assert.equal(operation.readiness.state, 'ready-for-retest');
+  assert.deepEqual(operation.boundary.sharedConsumers, ['CLI', 'LLM', 'Viewer', 'VS Code']);
+  assert.equal(operation.boundary.canonicalSchemaVocabularyChanged, false);
+}
+console.log('✓ shared operation catalog exposes one adapter-neutral normalized lifecycle projection');
+
+{
+  const root = await mkdtemp(path.join(os.tmpdir(), 'tiinex-lifecycle-cli-'));
+  try {
+    await mkdir(path.join(root, 'fixture'), { recursive: true });
+    for (const item of [control, child, retestArtifact, closureArtifact, reductionArtifact]) await writeFile(path.join(root, item.path), `${item.markdown}\n`, 'utf8');
+    const factsPath = path.join(root, 'facts.json');
+    await writeFile(factsPath, `${JSON.stringify({ authority: AUTHORITY, representatives: [rep()] }, null, 2)}\n`, 'utf8');
+    const lines = [];
+    const io = { log: (value) => lines.push(value), error: (value) => lines.push(value) };
+    const code = await runPortableCli(['project-lifecycle-readiness', root, '--controlling-task', CONTROL, '--facts', factsPath], io);
+    assert.equal(code, 0, lines.join('\n'));
+    const output = JSON.parse(lines.at(-1));
+    assert.equal(output.readiness.state, 'ready-for-retest');
+    assert.equal(output.retest.state, 'not-observed');
+    assert.equal(output.closure.state, 'open');
+  } finally { await rm(root, { recursive: true, force: true }); }
+}
+console.log('✓ CLI consumes the same lifecycle operation result without inventing adapter-local semantics');
+
+function artifactTask(filePath, title, { parent = null } = {}) {
+  const parentBlock = parent ? `- Parent\n  - Parent Schema: tiinex.task.v1\n  - Created At: 2026-09-06 00:00:00\n  - Trace: [Parent](${path.basename(parent.path)})\n  - Origin:\n    - [relative](${path.basename(parent.path)})\n` : '';
+  const parentIntegrity = parent ? `- [sha256-base64url-c14n-v2](${C14N_V2_VALIDATOR_TARGET})\n  - Towards: [Parent](${path.basename(parent.path)})\n  - Value: ${parent.digest}\n\n` : '';
+  return artifact(filePath, 'tiinex.task.v1', title, `## Objective\n\nExercise lifecycle readiness semantics.\n\n## Done Criteria\n\n- the exact governing criteria are satisfied only by authorized re-test and closure evidence\n\n## Scope\n\n- synthetic neutral regression\n\n## Dependencies\n\n- none`, parentBlock, parentIntegrity);
+}
+function artifactValidation(filePath) { return artifact(filePath, 'tiinex.validation.report.v1', 'Validation Report Fixture', `## Report Scope\n\n- Scope: exact controlling Task\n- Targets: fixture/control.trace.md\n\n## Validation Methods\n\n- Methods Used: synthetic exact assertion\n- Method Boundaries: fixture only\n\n## Findings Summary\n\n- Summary: normalized fact supplies outcome semantics\n- Overall State: evidence only without normalized authority fact\n\n## Finding List\n\n- Findings: none\n\n## Run Boundary\n\n- Run Context: permanent component regression\n- What Was Not Checked: external systems\n\n## Interpretation Limits\n\n- Does Not Prove: closure or authority by report existence\n- Must Not Hide: unresolved scope, currentness, criteria, or authority`); }
+function artifactDecision(filePath) { return artifact(filePath, 'tiinex.decision.v1', 'Closure Decision Fixture', `## Decision\n\n- State: accepted\n- Subject: exact controlling Task closure\n- Decision: normalized fact may qualify this artifact as explicit closure only with matching authority and pass basis\n\n## Basis\n\n- synthetic exact closure evidence\n\n## Consequences\n\n- no implicit closure from convergence or pass alone`); }
+function artifactReduction(filePath) { return artifact(filePath, 'tiinex.reduction.v1', 'Reduction Fixture', `## Source Context\n\n- Source: qualified child-work context\n\n## Carry-Forward State\n\n- normalized fact decides whether required re-test inputs are sufficiently carried\n\n## Loss And Uncertainty\n\n- normalized fact exposes material loss state\n\n## Validation\n\n- reduction existence alone never proves completion`); }
+function artifact(filePath, schemaId, title, body, parentBlock = '', parentIntegrity = '') {
+  const unsigned = `# Continuity Context\n\n- Envelope Schema: tiinex.root.v1\n${parentBlock}- Current\n  - Current Schema: ${schemaId}\n  - Created At: 2026-09-06 00:01:00\n  - Authors: Fixture\n  - Why: Exercise adapter-neutral lifecycle readiness semantics.\n  - Summary: ${title}.\n  - Status: local\n\n---\n\n# ${title}\n\n${body}\n\n---\n\n# Continuity Integrity\n\n${parentIntegrity}- [sha256-base64url-c14n-v2](${C14N_V2_VALIDATOR_TARGET})\n  - Towards: self\n  - Value: pending\n`;
+  const sealed = sealC14nV2Self(unsigned);
+  assert.equal(sealed.state, 'sealed');
+  const markdown = sealed.markdown;
+  const digest = validatedC14nV2PrimarySelfDigest(markdown);
+  assert.equal(digest.state, 'verified');
+  const record = Object.freeze({ ...createRecordFromMarkdown(markdown, { path: filePath, sourceMode: 'local-test' }), id: filePath, path: filePath });
+  return Object.freeze({ path: filePath, markdown, digest: digest.value, record });
+}