@tiinex/app 0.1.1

package/src/tooling/portable/adapters/cli/cli.run.case.mjs

@@ -0,0 +1,372 @@
+import assert from 'node:assert/strict';
+import { access, copyFile, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { runPortableCli } from '@tiinex/core/tooling/portable/adapters/cli/cli.run.js';
+import { acceptGroundHostResult, hostToolProfile } from '@tiinex/core/tooling/portable/adapters/cli/cli.ground-recovery.js';
+import { runPortableOperation } from '@tiinex/core/tooling/portable/operation.catalog.js';
+import { materializeHandoffManufactureCliOutput, prepareHandoffManufactureCliCommand } from '@tiinex/core/tooling/portable/adapters/cli/cli.handoff-manufacture.js';
+import { portableCanonicalBootstrapRuntime } from '@tiinex/core/tooling/portable/schema/bootstrap/canonical.pack.js';
+
+{
+  const lines = [];
+  const io = { log: (value) => lines.push(value), error: (value) => lines.push(value) };
+  assert.equal(await runPortableCli(['--help'], io), 0);
+  const help = lines.at(-1);
+  assert.match(help, /Common path \(same command for humans and LLMs\):/);
+  assert.match(help, / ground <handoff-package\.zip> --route <Continue-from>/);
+  assert.match(help, / author <workspace-dir>/);
+  assert.match(help, / handoff <workspace-dir>/);
+  assert.match(help, /Advanced\/internal catalog: .* operations/);
+  assert.doesNotMatch(help, /prepare-task|accept-host-receipt|manufacture-handoff-package|build-runtime-package/, 'default help must not eagerly disclose the advanced/internal operation catalog');
+}
+console.log('✓ CLI default help keeps the common lifecycle visible while advanced operations remain deliberate discovery passed');
+
+{
+  for (const surfaceCommand of ['author', 'handoff']) {
+    const lines = [];
+    const io = { log: (value) => lines.push(value), error: (value) => lines.push(value) };
+    assert.equal(await runPortableCli([surfaceCommand, '--help'], io), 0);
+    const help = lines.at(-1);
+    assert.match(help, new RegExp(`Tiinex portable tooling — ${surfaceCommand}`));
+    assert.match(help, new RegExp(` ${surfaceCommand} <workspace-dir>`));
+    assert.match(help, /Advanced\/internal catalog: .* operations/);
+    if (surfaceCommand === 'handoff') {
+      assert.match(help, /exactly one Handoff package plus the adjacent exact routing text/);
+      assert.match(help, /fenced code block/);
+      assert.match(help, /do not emit canonical Workspace Evidence\/Handoff markdown as additional loose transport files/);
+    }
+    assert.doesNotMatch(help, /prepare-task|accept-host-receipt|manufacture-handoff-package|build-runtime-package/, `${surfaceCommand} --help must remain command-focused instead of dumping the advanced catalog`);
+  }
+}
+console.log('✓ common subcommand help is focused and preserves deliberate advanced discovery passed');
+
+const root = await mkdtemp(path.join(os.tmpdir(), 'tiinex-cli-turn-binding-'));
+try {
+  const transaction = path.join(root, 'turn.json');
+  const output = path.join(root, 'state.json');
+  await writeFile(transaction, `${JSON.stringify({
+    sessionId: 'session-cli-binding',
+    turn: {
+      id: 'dialogue:turn-0001',
+      sequence: 1,
+      userMessage: 'Exact current user message.',
+      messageSha256: 'a'.repeat(64),
+      summary: 'Caller supplied a mismatched digest.'
+    },
+    changes: []
+  }, null, 2)}\n`, 'utf8');
+  const lines = [];
+  const io = { log: (value) => lines.push(value), error: (value) => lines.push(value) };
+  const code = await runPortableCli(['process-live-turn', '--turn', transaction, '--output', output], io);
+  assert.equal(code, 2);
+  const result = JSON.parse(lines.at(-1));
+  assert.equal(result.status, 'blocked');
+  assert.equal('cliPhaseTiming' in result, false, 'default CLI output must remain unchanged when --phase-timing is absent');
+  assert.deepEqual(result.findings.map((entry) => entry.code), ['live-lineage.turn.message-digest-mismatch']);
+  await assert.rejects(access(output), /ENOENT/, 'blocked turn binding must not rewrite the persisted state file');
+} finally {
+  await rm(root, { recursive: true, force: true });
+}
+console.log('✓ CLI blocks mismatched turn binding without persisting state passed');
+
+{
+  const lines = [];
+  const io = { log: (value) => lines.push(value), error: (value) => lines.push(value) };
+  const code = await runPortableCli(['describe-cold-start-ingress', 'routed-handoff-package', '--phase-timing'], io);
+  assert.equal(code, 0);
+  const result = JSON.parse(lines.at(-1));
+  assert.equal(result.cliPhaseTiming.schema, 'tiinex.portable.cli.phase-timing.v1');
+  assert.equal(result.cliPhaseTiming.command, 'describe-cold-start-ingress');
+  assert.equal('totalElapsedMs' in result.cliPhaseTiming, false, 'pre-serialization elapsed time must not be presented as total CLI elapsed time');
+  assert.equal(result.cliPhaseTiming.measuredElapsedBeforeFinalSerializationMs >= 0, true);
+  assert.equal(result.cliPhaseTiming.phases.inputPreparationMs >= 0, true);
+  assert.equal(result.cliPhaseTiming.phases.operationExecutionMs >= 0, true);
+  assert.equal(result.cliPhaseTiming.phases.outputMaterializationMs >= 0, true);
+  assert.equal(result.cliPhaseTiming.measurementBoundary, 'immediately-before-final-json-serialization');
+  assert.deepEqual(result.cliPhaseTiming.unmeasured, { finalJsonSerialization: true, finalEmission: true });
+  assert.match(result.cliPhaseTiming.boundary, /final JSON serialization and emission are explicitly unmeasured/);
+  assert.match(result.cliPhaseTiming.boundary, /excludes host review\/queue latency/);
+}
+console.log('✓ CLI opt-in in-process phase timing passed');
+
+
+{
+  const lines = [];
+  const io = { log: (value) => lines.push(value), error: (value) => lines.push(value) };
+  const code = await runPortableCli(['describe-cold-start-ingress', 'routed-handoff-package'], io);
+  assert.equal(code, 0);
+  const expected = await runPortableOperation('describe-cold-start-ingress', { ingressKind: 'routed-handoff-package' }, {});
+  assert.equal(lines.at(-1), JSON.stringify(expected, null, 2), 'default CLI output must remain byte-equivalent to ordinary pretty JSON operation output');
+}
+console.log('✓ CLI default output byte-equivalence without phase timing passed');
+
+{
+  const lines = [];
+  const io = { log: (value) => lines.push(value), error: (value) => lines.push(value) };
+  const code = await runPortableCli(['discover-tooling', '--phase-timing'], io);
+  assert.equal(code, 0);
+  const serialized = lines.at(-1);
+  assert.equal(Buffer.byteLength(serialized, 'utf8') > 4096, true, 'focused timing regression must exercise a non-trivial JSON serialization/output path');
+  const result = JSON.parse(serialized);
+  assert.equal('totalElapsedMs' in result.cliPhaseTiming, false);
+  assert.equal(result.cliPhaseTiming.measurementBoundary, 'immediately-before-final-json-serialization');
+  assert.equal(result.cliPhaseTiming.unmeasured.finalJsonSerialization, true);
+  assert.equal(result.cliPhaseTiming.unmeasured.finalEmission, true);
+}
+console.log('✓ CLI phase timing truthfully bounds non-trivial final serialization/output passed');
+
+
+{
+  const root = await mkdtemp(path.join(os.tmpdir(), 'tiinex-cli-ground-host-result-'));
+  try {
+    const firstPath = path.join(root, 'first.md');
+    const secondPath = path.join(root, 'second.md');
+    await writeFile(firstPath, '# First recovered Parent\n', 'utf8');
+    await writeFile(secondPath, '# Second recovered Parent\n', 'utf8');
+    const host = hostToolProfile({}, 'GitHub.fetch_file');
+    const recoveryResult = (repoPath) => Object.freeze({
+      continuity: Object.freeze({
+        recovery: Object.freeze({
+          state: 'host-action-available',
+          hostAction: Object.freeze({
+            action: 'repository-read',
+            request: Object.freeze({
+              repository: 'Tiinex/site',
+              ref: '56ba75025b7a8fd44b5318d2560d2ec63eb0106f',
+              path: repoPath,
+              purpose: 'recover exact declared Parent for cold-start continuity proof',
+              nextOperation: 'ground'
+            }),
+            selectedTool: Object.freeze({ id: 'GitHub.fetch_file', name: 'GitHub.fetch_file' })
+          })
+        })
+      })
+    });
+    const first = await acceptGroundHostResult(recoveryResult('.topics/tooling/first.trace.md'), { host, recoveryAcceptance: {} }, { 'host-result': firstPath });
+    assert.equal(first.acceptance.status, 'accepted');
+    assert.equal(first.acceptance.cumulativeRecovery.repositoryFiles, 1);
+    const second = await acceptGroundHostResult(recoveryResult('.topics/tooling/second.trace.md'), { host, recoveryAcceptance: first.acceptance }, { 'host-result': secondPath });
+    assert.equal(second.acceptance.status, 'accepted');
+    assert.equal(second.acceptance.cumulativeRecovery.priorAccepted, true);
+    assert.equal(second.acceptance.cumulativeRecovery.repositoryFiles, 2);
+    assert.deepEqual(second.acceptance.providerResponses[0].files.map((file) => file.source.path), [
+      '.topics/tooling/first.trace.md',
+      '.topics/tooling/second.trace.md'
+    ]);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+}
+console.log('✓ common ground host-result façade owns receipt normalization and cumulative prior recovery without protocol files passed');
+
+
+{
+  const root = await mkdtemp(path.join(os.tmpdir(), 'tiinex-cli-common-author-'));
+  try {
+    const parentRelativePath = '.topics/tooling/006-1-1-1-1-1-1-1-1-1-1-1-anchor-to-loom-authoring-return-common-path-ergonomics-handoff.trace.md';
+    const evidenceSource = path.resolve('.topics/tooling/006-1-1-1-1-1-1-loom-post-ground-common-path-ergonomics-correction-evidence.trace.md');
+    const parentSource = path.resolve(parentRelativePath);
+    const parentTarget = path.join(root, parentRelativePath);
+    await mkdir(path.dirname(parentTarget), { recursive: true });
+    await copyFile(parentSource, parentTarget);
+    const evidenceMarkdown = await readFile(evidenceSource, 'utf8');
+    const evidenceBody = evidenceMarkdown.split('\n---\n')[1].trim();
+    const bodyPath = path.join(root, 'body.md');
+    await writeFile(bodyPath, `${evidenceBody}\n`, 'utf8');
+    await mkdir(path.join(root, '.tiinex'), { recursive: true });
+    await writeFile(path.join(root, '.tiinex/continuation.json'), `${JSON.stringify({
+      schema: 'tiinex.portable.ground-continuation-state.v1',
+      version: 1,
+      selectedHandoffPath: parentRelativePath,
+      roleLabel: 'Loom'
+    }, null, 2)}\n`, 'utf8');
+    const artifactRelativePath = '.topics/tooling/common-author-regression-evidence.trace.md';
+    const lines = [];
+    const io = { log: (value) => lines.push(value), error: (value) => lines.push(value) };
+    const code = await runPortableCli([
+      'author', root,
+      '--schema', 'tiinex.evidence.v1',
+      '--path', artifactRelativePath,
+      '--body', bodyPath,
+      '--title', 'Common Author Regression Evidence',
+      '--summary', 'Regression coverage for the ordinary post-ground author surface.',
+      '--why', 'Prove continuity inference, c14n-v2 sealing, runtime audit, staging, and continuation-state carry-forward.',
+      '--compact'
+    ], io, portableCanonicalBootstrapRuntime);
+    assert.equal(code, 0);
+    const result = JSON.parse(lines.at(-1));
+    assert.equal(result.status, 'qualified');
+    assert.equal(result.artifact.parentPath, parentRelativePath);
+    assert.equal(result.artifact.selfIntegrity, 'verified');
+    assert.equal(result.qualification.stage, 'staged');
+    assert.equal(result.findingSummary.counts.error, 0);
+    const state = JSON.parse(await readFile(path.join(root, '.tiinex/continuation.json'), 'utf8'));
+    assert.equal(state.lastAuthoredPath, artifactRelativePath);
+    assert.equal(state.lastAuthoredSchemaId, 'tiinex.evidence.v1');
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+}
+console.log('✓ common author façade infers Parent and owns sealing, audit, staging, and continuation carry-forward passed');
+
+
+{
+  const root = await mkdtemp(path.join(os.tmpdir(), 'tiinex-cli-common-author-chain-'));
+  try {
+    const bundledDecisionSchemaPath = 'src/schemas/core/decision/tiinex.decision.v1.schema.md';
+    const decisionSchemaTarget = path.join(root, bundledDecisionSchemaPath);
+    await mkdir(path.dirname(decisionSchemaTarget), { recursive: true });
+    await copyFile(path.resolve(bundledDecisionSchemaPath), decisionSchemaTarget);
+    await mkdir(path.join(root, '.tiinex'), { recursive: true });
+    await writeFile(path.join(root, '.tiinex/continuation.json'), `${JSON.stringify({
+      schema: 'tiinex.portable.ground-continuation-state.v1',
+      version: 1,
+      roleLabel: 'Loom'
+    }, null, 2)}\n`, 'utf8');
+
+    const bodyFromArtifact = async (sourcePath, targetName) => {
+      const markdown = await readFile(path.resolve(sourcePath), 'utf8');
+      const body = markdown.split('\n---\n')[1].trim();
+      const target = path.join(root, targetName);
+      await writeFile(target, `${body}\n`, 'utf8');
+      return target;
+    };
+    const runAuthor = async (args) => {
+      const lines = [];
+      const io = { log: (value) => lines.push(value), error: (value) => lines.push(value) };
+      const code = await runPortableCli(['author', root, ...args, '--compact'], io, portableCanonicalBootstrapRuntime);
+      return { code, result: JSON.parse(lines.at(-1)) };
+    };
+
+    const decisionBody = await bodyFromArtifact('.topics/tooling/017-1-sigma-foundation-major-plan-approval-decision.trace.md', 'decision-body.md');
+    const handoffBody = await bodyFromArtifact('.topics/tooling/016-3-anchor-to-loom-common-author-continuation-repair-handoff.trace.md', 'handoff-body.md');
+    const taskBody = await bodyFromArtifact('.topics/tooling/016-common-author-continuation-schema-authority-repair.task.trace.md', 'task-body.md');
+    const evidenceBody = await bodyFromArtifact('.topics/tooling/016-1-anchor-fresh-common-author-continuation-failure-evidence.trace.md', 'evidence-body.md');
+
+    const decisionPath = '.topics/tooling/common-author-chain-decision.trace.md';
+    const decision = await runAuthor([
+      '--schema', 'tiinex.decision.v1', '--path', decisionPath, '--body', decisionBody,
+      '--title', 'Common Author Chain Decision', '--summary', 'Common Author Chain Decision', '--why', 'Exercise bare-ID Decision continuation.', '--no-parent'
+    ]);
+    assert.equal(decision.code, 0);
+    assert.equal(decision.result.status, 'qualified');
+    const decisionMarkdown = await readFile(path.join(root, decisionPath), 'utf8');
+    assert.match(decisionMarkdown, /Current Schema: tiinex\.decision\.v1\n/, 'accepted-local unpublished Decision remains a bare semantic schema id');
+
+    const handoffPath = '.topics/tooling/common-author-chain-handoff.trace.md';
+    const handoff = await runAuthor([
+      '--schema', 'tiinex.handoff.v1', '--path', handoffPath, '--body', handoffBody,
+      '--title', 'Common Author Chain Handoff', '--summary', 'Common Author Chain Handoff', '--why', 'Prove Decision to Handoff continuation.', '--parent', decisionPath
+    ]);
+    assert.equal(handoff.code, 0);
+    assert.equal(handoff.result.status, 'qualified');
+    assert.equal(handoff.result.artifact.parentPath, decisionPath);
+    assert.equal(handoff.result.artifact.selfIntegrity, 'verified');
+    const handoffMarkdown = await readFile(path.join(root, handoffPath), 'utf8');
+    assert.match(handoffMarkdown, /Parent Schema: \[tiinex\.decision\.v1\]\(\.\.\/\.\.\/src\/schemas\/core\/decision\/tiinex\.decision\.v1\.schema\.md\)/, 'bare parent schema id must recover an exact child-relative bundled schema locator');
+
+    const taskPath = '.topics/tooling/common-author-chain-task.trace.md';
+    const task = await runAuthor([
+      '--schema', 'tiinex.task.v1', '--path', taskPath, '--body', taskBody,
+      '--title', 'Common Author Chain Task', '--summary', 'Common Author Chain Task', '--why', 'Exercise an additional ordinary schema pair.', '--no-parent'
+    ]);
+    assert.equal(task.code, 0);
+    assert.equal(task.result.status, 'qualified');
+
+    const evidencePath = '.topics/tooling/common-author-chain-evidence.trace.md';
+    const evidence = await runAuthor([
+      '--schema', 'tiinex.evidence.v1', '--path', evidencePath, '--body', evidenceBody,
+      '--title', 'Common Author Chain Evidence', '--summary', 'Common Author Chain Evidence', '--why', 'Prove Task to Evidence continuation is schema-generic.', '--parent', taskPath
+    ]);
+    assert.equal(evidence.code, 0);
+    assert.equal(evidence.result.status, 'qualified');
+    assert.equal(evidence.result.artifact.parentPath, taskPath);
+    assert.equal(evidence.result.artifact.selfIntegrity, 'verified');
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+}
+console.log('✓ common author chains Decision→Handoff and Task→Evidence without manual schema-authority repair passed');
+
+
+{
+  const root = await mkdtemp(path.join(os.tmpdir(), 'tiinex-cli-common-author-schema-authority-fail-closed-'));
+  try {
+    const bundledDecisionSchemaPath = 'src/schemas/core/decision/tiinex.decision.v1.schema.md';
+    const decisionSchemaTarget = path.join(root, bundledDecisionSchemaPath);
+    await mkdir(path.dirname(decisionSchemaTarget), { recursive: true });
+    await writeFile(decisionSchemaTarget, '# tampered local schema material\n', 'utf8');
+    await mkdir(path.join(root, '.tiinex'), { recursive: true });
+    await writeFile(path.join(root, '.tiinex/continuation.json'), `${JSON.stringify({ schema: 'tiinex.portable.ground-continuation-state.v1', version: 1, roleLabel: 'Loom' }, null, 2)}\n`, 'utf8');
+    const bodyFromArtifact = async (sourcePath, targetName) => {
+      const markdown = await readFile(path.resolve(sourcePath), 'utf8');
+      const target = path.join(root, targetName);
+      await writeFile(target, `${markdown.split('\n---\n')[1].trim()}\n`, 'utf8');
+      return target;
+    };
+    const decisionBody = await bodyFromArtifact('.topics/tooling/017-1-sigma-foundation-major-plan-approval-decision.trace.md', 'decision-body.md');
+    const handoffBody = await bodyFromArtifact('.topics/tooling/016-3-anchor-to-loom-common-author-continuation-repair-handoff.trace.md', 'handoff-body.md');
+    const decisionPath = '.topics/tooling/common-author-unresolved-decision.trace.md';
+    const firstLines = [];
+    assert.equal(await runPortableCli([
+      'author', root, '--schema', 'tiinex.decision.v1', '--path', decisionPath, '--body', decisionBody,
+      '--title', 'Unresolved Decision', '--summary', 'Unresolved Decision', '--why', 'Set up fail-closed Parent authority regression.', '--no-parent', '--compact'
+    ], { log: (value) => firstLines.push(value), error: (value) => firstLines.push(value) }, portableCanonicalBootstrapRuntime), 0);
+
+    const childPath = '.topics/tooling/common-author-unresolved-handoff.trace.md';
+    const lines = [];
+    const code = await runPortableCli([
+      'author', root, '--schema', 'tiinex.handoff.v1', '--path', childPath, '--body', handoffBody,
+      '--title', 'Unresolved Handoff', '--summary', 'Unresolved Handoff', '--why', 'Must fail closed without exact local schema bytes.', '--parent', decisionPath, '--compact'
+    ], { log: (value) => lines.push(value), error: (value) => lines.push(value) }, portableCanonicalBootstrapRuntime);
+    assert.equal(code, 1);
+    assert.equal(JSON.parse(lines.at(-1)).error, 'portable.cli.author.parent.schema-authority.required');
+    await assert.rejects(access(path.join(root, childPath)), /ENOENT/, 'failed Parent schema-authority recovery must not retain a child artifact');
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+}
+console.log('✓ common author Parent schema-authority recovery fails closed on mismatched bundled schema bytes passed');
+
+
+{
+  const root = await mkdtemp(path.join(os.tmpdir(), 'tiinex-cli-low-level-handoff-'));
+  try {
+    await mkdir(path.join(root, '.tiinex'), { recursive: true });
+    await writeFile(path.join(root, '.tiinex/continuation.json'), `${JSON.stringify({
+      schema: 'tiinex.portable.ground-continuation-state.v1',
+      packageParentPath: path.join(root, 'missing-parent.handoff-package.zip')
+    }, null, 2)}\n`, 'utf8');
+    await assert.rejects(
+      () => prepareHandoffManufactureCliCommand({
+        surfaceCommand: 'manufacture-handoff-package',
+        positionals: [root],
+        flags: { 'package-major': true }
+      }),
+      /portable\.cli\.handoff-carrier\.package-major\.parent-required/,
+      'advanced manufacture must not silently consume common-path continuation state'
+    );
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+}
+console.log('✓ advanced manufacture remains explicit even when common-path continuation state is present passed');
+
+
+{
+  const output = await materializeHandoffManufactureCliOutput({
+    schema: 'tiinex.portable.operation.result.v1',
+    operation: 'manufacture-handoff-package',
+    status: 'blocked',
+    transportExecutable: false,
+    carrierProjection: { status: 'ready', mode: 'single', routes: [], workspace: {}, workspaces: [], selection: {} },
+    findings: [{ severity: 'error', code: 'portable.handoff-material.required.unresolved', message: 'Exact required material is not currently resolvable or materialized.' }],
+    findingSummary: { status: 'invalid', counts: { error: 1, warning: 0, info: 0, total: 1 } }
+  }, { 'output-dir': '/tmp' });
+  assert.equal(output.status, 'blocked');
+  assert.equal(output.primaryOutput, null);
+  assert.equal(output.findingSummary.counts.error, 1);
+  assert.equal(output.findings[0].code, 'portable.handoff-material.required.unresolved');
+}
+console.log('✓ blocked manufacture façade preserves actionable findings instead of attempting an invalid carrier write passed');

package/src/tooling/portable/adapters/cli/cli.summaryProjection.case.mjs

@@ -0,0 +1,46 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { runPortableCli } from '@tiinex/core/tooling/portable/adapters/cli/cli.run.js';
+
+const root = await mkdtemp(path.join(os.tmpdir(), 'tiinex-cli-summary-'));
+try {
+  const source = await readFile('src/artifacts/fixtures/topic.trace.md', 'utf8');
+  const materialDir = path.join(root, 'material');
+  await mkdir(materialDir, { recursive: true });
+  for (let index = 0; index < 20; index += 1) {
+    await writeFile(path.join(materialDir, `topic-${String(index + 1).padStart(2, '0')}.trace.md`), source, 'utf8');
+  }
+
+  const fullInspect = await runJson(['inspect', materialDir, '--compact']);
+  assert.equal(Array.isArray(fullInspect.records), true);
+  assert.equal(fullInspect.records.length, 20);
+  assert.equal('projection' in fullInspect, false, 'default inspect projection must remain unchanged');
+
+  const summaryInspect = await runJson(['inspect', materialDir, '--summary', '--phase-timing', '--compact']);
+  assert.equal(summaryInspect.projection, 'bounded-summary');
+  assert.deepEqual(summaryInspect.counts, { files: 20, records: 20, assets: 0, workspaceEntries: 0, findings: 0 });
+  assert.equal('records' in summaryInspect, false);
+  assert.equal(summaryInspect.actionableFindings.length, 0);
+  assert.equal(summaryInspect.cliPhaseTiming.command, 'inspect');
+  assert.equal(JSON.stringify(summaryInspect).length < JSON.stringify(fullInspect).length / 5, true);
+
+  const summaryAudit = await runJson(['audit', materialDir, '--summary', '--compact'], 0);
+  assert.equal(summaryAudit.projection, 'bounded-summary');
+  assert.equal(summaryAudit.counts.audits, 20);
+  assert.equal('audits' in summaryAudit, false);
+  assert.equal(summaryAudit.actionableFindings.every((finding) => finding.severity === 'error' || finding.severity === 'warning'), true);
+} finally {
+  await rm(root, { recursive: true, force: true });
+}
+
+console.log('✓ CLI bounded inspect/audit summary projection preserves full default output and omits body-scale payloads');
+
+async function runJson(argv, expectedCode = 0) {
+  const lines = [];
+  const errors = [];
+  const code = await runPortableCli(argv, { log: (value) => lines.push(value), error: (value) => errors.push(value) });
+  assert.equal(code, expectedCode, errors.join('\n'));
+  return JSON.parse(lines.at(-1));
+}

package/src/tooling/portable/audit/audit.capability.case.mjs

@@ -0,0 +1,45 @@
+import assert from 'node:assert/strict';
+import { loadNodePortableInput } from '@tiinex/core/tooling/portable/input/node.input.js';
+import { normalizePortableInput } from '@tiinex/core/tooling/portable/input/portable.input.js';
+import { auditPortableMaterial } from '@tiinex/core/tooling/portable/engine.facade.js';
+import { buildWorkspaceAuditView } from '../../../workspaces/workspace.auditView.js';
+import { auditPortableRecord, auditPortableRecords } from '@tiinex/core/tooling/portable/audit/audit.capability.js';
+
+const source = await loadNodePortableInput(['.topics/tooling/010-safe-reduction-and-shared-capability-parity-coordination-task.trace.md']);
+const material = normalizePortableInput(source);
+assert.equal(material.records.length, 1);
+const record = material.records[0];
+
+const recordAudit = auditPortableRecord(record);
+assert.equal(recordAudit.schema, 'tiinex.portable.shared-audit-record.v1');
+assert.equal(recordAudit.path, record.path);
+assert.equal(recordAudit.capabilityBoundary.adapterNeutral, true);
+assert(recordAudit.findings.length > 0);
+for (const finding of recordAudit.findings) {
+  assert.match(finding.findingIdentity, /::/);
+  assert.equal(finding.artifactBoundary.path, record.path);
+  assert.equal(finding.ownership.kind, 'implementation-source');
+  assert(finding.ownership.owner);
+}
+
+const batchAudit = auditPortableRecords([record]);
+assert.equal(batchAudit.audits.length, 1);
+assert.equal(batchAudit.boundary.sharedConsumers.includes('Viewer'), true);
+assert.equal(batchAudit.boundary.sharedConsumers.includes('CLI'), true);
+assert.equal(batchAudit.boundary.sourceMutation, false);
+assert.equal(batchAudit.boundary.remoteWrite, false);
+
+const cliAudit = auditPortableMaterial(source);
+const viewerAudit = buildWorkspaceAuditView({ id: 'audit-parity', title: 'Audit parity' }, { records: [record] });
+assert.equal(cliAudit.audits.length, 1);
+assert.equal(viewerAudit.items.length, 1);
+const sharedProjection = (audit) => (audit.findings || []).map((finding) => ({
+  code: finding.code,
+  severity: finding.severity,
+  findingIdentity: finding.findingIdentity,
+  owner: finding.ownership?.owner || '',
+  artifactPath: finding.artifactBoundary?.path || ''
+}));
+assert.deepEqual(sharedProjection(cliAudit.audits[0]), sharedProjection(viewerAudit.items[0]));
+
+console.log('✓ Shared portable audit capability keeps CLI/LLM and Viewer finding identity, severity, ownership, and artifact boundaries in parity');

package/src/tooling/portable/fixtures/legacy-artifacts/collaboration/dogfood/001-tiinex-development-dogfood-collaboration-model.trace.fixture.txt

@@ -0,0 +1,37 @@
+# Continuity Context
+
+- Envelope Schema: [tiinex.root.v1](https://github.com/Tiinex/docs/blob/053d46ce082d4ec261b82abc44ecca403d61e240/.topics/.schemas/tiinex.root.v1.schema.md)
+- Repairs:
+  - Historical canonical representation repair
+    - Target: [pre-repair published representation](https://github.com/Tiinex/site/blob/32c7c291101b2a6a72c12241f3107d4a56af81fc/.topics/development/collaboration/dogfood/001-tiinex-development-dogfood-collaboration-model.trace.md)
+    - Note: Canonically repaired after v475-v478 qualified the authoring/validation/reference/integrity oracles; pre-repair Git blob 8db25b99346cec48439a641f490c9954f3d89aa7.
+    - Reason: Preserve original body/work-result meaning and historical Current Created At while replacing false-PASS envelope, schema-reference, continuity, and integrity representation.
+- Current
+  - Current Schema: [tiinex.topic.v1](https://github.com/Tiinex/docs/blob/053d46ce082d4ec261b82abc44ecca403d61e240/.topics/.schemas/core/topic/tiinex.topic.v1.schema.md)
+  - Created At: 2026-08-21 16:33:00
+  - Authors: Tiinusen; Architect
+  - Summary: Tiinex development dogfood collaboration model
+
+---
+
+# Tiinex development dogfood collaboration model
+
+This topic captures the current direction for Tiinex development dogfood collaboration model.
+
+## Current Read
+
+The Tiinex project has begun using its own artifact/tooling model for Architect, Tooling, Dev, and human handoffs. A repository/worktree ZIP is transported between workers; the ZIP mirrors the real Site tree and excludes .git rather than wrapping project truth in a separate transport envelope. The included Site tooling is expected to be sufficient when full source is present. bootstrap.zip remains the portable/minified tooling distribution for cases where full Site source is intentionally absent. Git remains source history/publication and is not replaced by the ZIP.
+
+## Design Direction
+
+Treat chat sessions as replaceable workers and Tiinex artifacts as durable collaboration context. Human handoff text should carry only the routing delta needed for the session: role when a fresh session needs it, the exact controlling artifact, and expected return shape. WHAT, WHY, acceptance, lineage, and durable decisions belong in Tiinex artifacts. Discovery placement follows workspace configuration; .topics is a configurable convention/default rather than semantic authority. Only qualified Tiinex artifacts are cross-read semantically; remote Schema, Companion, and Transition material is declarative data, never remotely executable code. Record real authorship separately from transport/provenance: Tiinusen is the human collaborator nickname to use when he is an author or co-author.
+
+## Next Artifacts
+
+Continue dogfooding with Tooling and then a fresh Dev session using the same repo-mirror ZIP pattern. Observe whether LLM workers can discover bounded current work without hidden conversational context and whether Tiinusen can follow the lineage in the viewer as a human. Record friction rather than silently routing around it, especially authorship authoring/presentation, current-work discovery, lineage readability, export size, and viewer/local discovery behavior.
+
+# Continuity Integrity
+
+- [sha256-base64url-c14n-v2](https://github.com/Tiinex/docs/blob/053d46ce082d4ec261b82abc44ecca403d61e240/.topics/.validators/sha256-base64url-c14n-v2.validator.md)
+  - Towards: self
+  - Value: 2zmo_kpYfcR_3-9LZAd4DNjCDVDU-XDOCucl1yWHw54

package/src/tooling/portable/fixtures/legacy-artifacts/handoff/tooling/001-v480-tooling-workflow-schema-enablement-handoff.trace.fixture.txt

@@ -0,0 +1,108 @@
+# Continuity Context
+
+- Envelope Schema: [tiinex.root.v1](https://github.com/Tiinex/docs/blob/053d46ce082d4ec261b82abc44ecca403d61e240/.topics/.schemas/tiinex.root.v1.schema.md)
+- Current
+  - Current Schema: [tiinex.handoff.v1](https://github.com/Tiinex/docs/blob/e713557f8be630967571d11a73f9ecd05ae329ce/.topics/.schemas/coordination/handoff/tiinex.handoff.v1.schema.md)
+  - Created At: 2026-08-22 03:05:12
+  - Authors: Architect
+  - Why: Transfer the bounded v480 Tooling tranche through a durable Tiinex Handoff rather than a chat-level implementation briefing.
+  - Summary: Handoff of v480 workflow schema enablement and creation-contract projection closure to Tooling
+  - Status: draft/local
+
+---
+
+# v480 Tooling workflow schema enablement handoff
+
+## Handoff Parties
+
+- Purpose: transfer bounded execution of the v480 workflow-schema enablement and generic creation-contract projection closure while retaining architecture review and subsequent Dev routing with Architect
+- From: Architect
+- From Kind: role
+- To: Tooling
+- To Kind: role
+
+## Transfers
+
+- v480-work-and-responsibility
+  - Transfer Kind: work-and-responsibility
+  - Description: implement, validate, and durably report the bounded v480 tranche defined by the controlling Task
+  - Controlling Artifact: [v480 workflow schema enablement and creation-contract projection closure](../../tooling/dogfood/007-site-tooling-v480-workflow-schema-enablement-creation-projection-closure.trace.md)
+  - Boundary: Tooling owns execution and truthful result/evidence for this tranche; it does not acquire architecture/product authority outside the controlling Task
+
+## Required Context
+
+- current-site-workspace
+  - Material: the complete Tiinex/site repository/worktree supplied with this Handoff
+  - Purpose: current source/material authority for implementation and validation
+  - Availability: available
+
+- controlling-task
+  - Material: v480 workflow schema enablement and creation-contract projection closure Task
+  - Material Reference: [controlling Task](../../tooling/dogfood/007-site-tooling-v480-workflow-schema-enablement-creation-projection-closure.trace.md)
+  - Purpose: owns scope, Done Criteria, immutable schema authorities, non-goals, and terminal result expectations
+  - Availability: available
+
+- published-handoff-schema
+  - Material: canonical maintained Tiinex Handoff schema published in Tiinex/docs
+  - Material Reference: [tiinex.handoff.v1](https://github.com/Tiinex/docs/blob/e713557f8be630967571d11a73f9ecd05ae329ce/.topics/.schemas/coordination/handoff/tiinex.handoff.v1.schema.md)
+  - Purpose: defines this artifact's transfer/context/retention semantics independently of packaging mechanics
+  - Availability: available
+
+## Reference Context
+
+- workspace-config-direction
+  - Material: Site workspace-config bootstrap/discovery design direction
+  - Material Reference: [workspace config direction](../../collaboration/dogfood/002-site-workspace-config-bootstrap-discovery-direction.trace.md)
+  - Purpose: nearby collaboration direction that motivates richer durable workflow artifacts but is not required to implement v480
+  - Availability: available
+
+- historical-repair-result
+  - Material: v479 historical dogfood canonical repair result
+  - Material Reference: [v479 result](../../tooling/dogfood/006-1-v479-historical-dogfood-canonical-repair-closure-result.trace.md)
+  - Purpose: prior synchronization evidence and regression context
+  - Availability: available
+
+## Retained Responsibilities
+
+- architecture-review
+  - Retained By: Architect
+  - Responsibility: independently audit the returned worktree, reconcile architectural consequences, and decide whether the tranche is accepted
+  - Boundary: Tooling must report evidence truthfully but does not self-authorize the next architectural milestone
+
+- next-role-routing
+  - Retained By: Architect
+  - Responsibility: decide and author any subsequent Handoff to Dev, Schemer, or another role
+  - Boundary: fresh Dev remains outside this transfer
+
+## Exclusions And Dependencies
+
+- fresh-dev-execution
+  - Kind: excluded-scope
+  - Description: do not start or simulate the fresh Dev tranche as part of v480
+  - Responsible Party Or Role: Architect
+
+- handoff-package-redesign
+  - Kind: excluded-scope
+  - Description: do not redesign ZIP/package/export semantics or infer transferred responsibility from package membership
+
+- pre-master-cleanup
+  - Kind: excluded-scope
+  - Description: legacy docs/workspace reduction before master merge remains a later explicit cleanup gate
+  - Responsible Party Or Role: Architect
+
+## Completion Expectation
+
+- Signal Kind: result
+- Signal Meaning: return one durable Tooling result/evidence artifact for v480 plus the complete updated Tiinex/site repository/worktree ZIP, with blockers disclosed rather than hidden by degraded claims
+- Return To: Architect
+
+## Interpretation Limits
+
+- Does Not Mean: Tooling owns unrelated Site work, architecture decisions, future Dev execution, or everything physically present in the workspace ZIP
+- Must Not Be Used To Claim: recipient acceptance before execution, successful completion before a result exists, package completeness as responsibility transfer, or authority beyond the controlling v480 Task
+
+# Continuity Integrity
+
+- [sha256-base64url-c14n-v2](https://github.com/Tiinex/docs/blob/053d46ce082d4ec261b82abc44ecca403d61e240/.topics/.validators/sha256-base64url-c14n-v2.validator.md)
+  - Towards: self
+  - Value:3ofXrWmZxu10BSCeydM6SXXQp0MpSH-Jow2SJs3n-pk