@tiinex/core 0.12.0 → 0.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiinex/core",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "description": "Shared host-neutral Tiinex implementation core for artifacts, schemas, validation, lineage, grounding, Handoffs, provenance and deterministic workflows.",
   "type": "module",
   "sideEffects": true,
@@ -134,6 +134,7 @@
     "./schema-bootstrap": "./src/tooling/portable/schema/bootstrap/canonical.pack.js",
     "./node/release": "./src/release/run.mjs",
     "./node/release-policy": "./src/release/policy.mjs",
+    "./tooling/portable/source/sourceEligibility.js": "./src/tooling/portable/source/sourceEligibility.js",
     "./tooling/portable/comparison/sourceFrontierComparison.js": "./src/tooling/portable/comparison/sourceFrontierComparison.js",
     "./tooling/portable/adapters/node/sourceFrontierComparison.js": "./src/tooling/portable/adapters/node/sourceFrontierComparison.js"
   },
@@ -167,12 +168,12 @@
     "type": "git",
     "url": "git+https://github.com/Tiinex/core.git"
   },
-  "gitHead": "a63df8c4736b3267ac0aefa769b1262f45b78dac",
+  "gitHead": "030669b6596196da946edb049d15af044bcd96c6",
   "tiinexRelease": {
     "policy": "tiinex.master-npm-release.v1",
-    "sourceCommit": "a63df8c4736b3267ac0aefa769b1262f45b78dac",
-    "sourceTree": "d502ba11f95bbaf29fb7b86015df3d7b63bc82eb",
+    "sourceCommit": "030669b6596196da946edb049d15af044bcd96c6",
+    "sourceTree": "090aaead28df51b2aeb6679018526f54260a1ca8",
     "repository": "Tiinex/core",
-    "previousVersion": "0.11.0"
+    "previousVersion": "0.13.0"
   }
 }

package/src/audit/audit.run.js

@@ -13,7 +13,7 @@ export function runAudit(scope = {}) {
   if (isPlainSupportingMarkdown(parsed, record)) return supportingMarkdownAuditResult(record, parsed, availability);
 
   const schemaId = parsed.envelope.current.schema.id || record?.schemaId || record?.currentSchemaId || '';
-  const validationResult = validateArtifact({ parsed, schemaId, record, markdown, schemaReferenceAuthorities: scope.schemaReferenceAuthorities || null, validationContractOverride: scope.validationContractOverride || null, schemaValidationAuthority: scope.schemaValidationAuthority || null });
+  const validationResult = validateArtifact({ parsed, schemaId, record, markdown, schemaReferenceAuthorities: scope.schemaReferenceAuthorities || null, schemaReferenceContext: scope.schemaReferenceContext || 'historical', validationContractOverride: scope.validationContractOverride || null, schemaValidationAuthority: scope.schemaValidationAuthority || null });
   const findings = validationResult.findings;
   return {
     status: findings.some((finding) => finding.severity === 'error') ? 'invalid-or-incomplete' : validationResult.resolution.fallbackUsed ? 'degraded' : 'readable',

package/src/public/index.js

@@ -24,6 +24,17 @@ export {
   secureTransportV1AuthenticatedMetadata
 } from '../transport/secureTransportV1.js';
 
+export {
+  PORTABLE_SOURCE_ELIGIBILITY_SCHEMA_ID,
+  PORTABLE_GENERATED_SOURCE_EXCLUDED_DIRECTORY_NAMES,
+  PORTABLE_GENERATED_SOURCE_EXCLUDED_FILE_SUFFIXES,
+  DEFAULT_PORTABLE_SOURCE_EXCLUDED_DIRECTORIES,
+  DEFAULT_PORTABLE_SOURCE_EXCLUDED_RELATIVE_PATHS,
+  qualifyPortableSourcePath,
+  isPortableSourceEligiblePath,
+  portableSourceEligibilityPolicy
+} from '../tooling/portable/source/sourceEligibility.js';
+
 export {
   PORTABLE_SOURCE_FRONTIER_SCHEMA_ID,
   PORTABLE_SOURCE_FRONTIER_COMPARISON_SCHEMA_ID,
@@ -35,3 +46,10 @@ export {
   compareOrReconcilePortableSourceFrontiers,
   projectPortableSourceFrontierComparisonSummary
 } from '../tooling/portable/comparison/sourceFrontierComparison.js';
+export {
+  PORTABLE_SOURCE_FRONTIER_RECONCILIATION_PROOF_SCHEMA_ID,
+  PORTABLE_SOURCE_FRONTIER_RECONCILIATION_SUMMARY_SCHEMA_ID,
+  provePortableSourceReconciliation,
+  projectPortableSourceReconciliationProofSummary,
+  qualifyPortableSourceReconciliationProofForManufacture
+} from '../tooling/portable/comparison/sourceFrontierReconciliationProof.js';

package/src/public/node.js

@@ -1,3 +1,4 @@
 export * from './index.js';
 export * from '../tooling/portable/index.js';
 export * from '../tooling/portable/adapters/node/sourceFrontierComparison.js';
+export * from '../tooling/portable/adapters/node/sourceFrontierReconciliationProof.js';

package/src/schemas/creation.contracts.js

@@ -179,7 +179,7 @@ export function validateArtifactCreationResult(draft = {}, parentRecord = {}, op
     findings.push(...(representation.findings || []).map((message, index) => error(`creation.continuation-representation.${index + 1}`, message)));
     findings.push(...validateParentTargetIntegrity(parsed, parentRecord, parentIntegrityTarget));
     const parentSchemaAuthority = parentRecord.schemaReferenceAuthority || {};
-    const parentSchemaReference = qualifySchemaReferenceValue(parent.schema?.raw || '', parentSchemaAuthority);
+    const parentSchemaReference = qualifySchemaReferenceValue(parent.schema?.raw || '', parentSchemaAuthority, { requireExactTargetWhenQualified: true });
     for (const [index, message] of (parentSchemaReference.findings || []).entries()) findings.push(error(`creation.parent-schema-reference.${index + 1}`, message));
     if (parentSchemaAuthority.resolutionState !== 'qualified') findings.push(error('creation.parent-schema-reference.unresolved', 'Exact continuation requires the declared Parent Schema reference authority to be resolver-qualified.'));
   } else if (!rootCreation) findings.push(error('creation.parent.required', 'Continuation creation requires an exact supplied Parent authority.'));

package/src/schemas/creation.schemaReferences.js

@@ -3,13 +3,9 @@ import { inspectCreationRepresentation } from './creation.representation.js';
 import { qualifySchemaReferenceMaterialCoherence, qualifySchemaReferenceValue, schemaReferenceAuthorityFromBinding } from './schema.reference.js';
 
 export function schemaReferenceAuthoritiesForCreation(targetModule = null, explicit = null) {
-  const root = resolveRegisteredSchemaModule({ schemaId: 'tiinex.root.v1' });
-  const rootModule = root?.fallbackUsed ? null : root?.module || null;
-  const rootQualification = qualifiedSourceQualification(rootModule);
-  const targetQualification = qualifiedSourceQualification(targetModule);
   const defaults = {
-    envelope: schemaReferenceAuthorityFromBinding('tiinex.root.v1', rootModule?.binding || {}, rootQualification?.authority || null, rootQualification),
-    current: schemaReferenceAuthorityFromBinding(String(targetModule?.id || ''), targetModule?.binding || {}, targetQualification?.authority || null, targetQualification)
+    envelope: schemaReferenceAuthorityForRegisteredSchema('tiinex.root.v1'),
+    current: schemaReferenceAuthorityForModule(targetModule)
   };
   return Object.freeze({
     envelope: explicitSchemaReferenceAuthority(explicit?.envelope, defaults.envelope),
@@ -17,6 +13,19 @@ export function schemaReferenceAuthoritiesForCreation(targetModule = null, expli
   });
 }
 
+export function schemaReferenceAuthorityForRegisteredSchema(schemaId = '') {
+  const id = String(schemaId || '').trim();
+  const resolution = resolveRegisteredSchemaModule({ schemaId: id });
+  const module = resolution?.fallbackUsed ? null : resolution?.module || null;
+  return schemaReferenceAuthorityForModule(module, id);
+}
+
+function schemaReferenceAuthorityForModule(module = null, fallbackSchemaId = '') {
+  const id = String(module?.id || fallbackSchemaId || '').trim();
+  const qualification = qualifiedSourceQualification(module);
+  return schemaReferenceAuthorityFromBinding(id, module?.binding || {}, qualification?.authority || null, qualification);
+}
+
 export function explicitSchemaReferenceAuthority(value = null, fallback = {}) {
   if (!value) return fallback;
   const schemaId = String(value.schemaId || fallback.schemaId || '').trim();
@@ -27,7 +36,7 @@ export function explicitSchemaReferenceAuthority(value = null, fallback = {}) {
   const preferredTarget = String(value.preferredTarget || value.target || exactTargets[0] || '').trim();
   const fallbackTargets = Object.freeze([...(fallback.exactTargets || [])]);
   const materialBoundTarget = Boolean(preferredTarget && fallback?.materialBoundTarget === true && fallbackTargets.includes(preferredTarget));
-  return Object.freeze({
+  const candidate = Object.freeze({
     ...fallback,
     schemaId,
     exactTargets: Object.freeze(exactTargets),
@@ -39,6 +48,17 @@ export function explicitSchemaReferenceAuthority(value = null, fallback = {}) {
     materialBoundTarget,
     semanticMaterialIdentity: fallback.semanticMaterialIdentity || Object.freeze({ state: 'unavailable' })
   });
+  if (!preferredTarget) return candidate;
+  const coherence = qualifySchemaReferenceMaterialCoherence(candidate);
+  if (coherence.state === 'qualified') return candidate;
+  return Object.freeze({
+    ...candidate,
+    exactTargets: Object.freeze([]),
+    preferredTarget: '',
+    resolutionState: 'unresolved',
+    rejectedExactTargets: Object.freeze(exactTargets),
+    resolutionFindings: Object.freeze([...(coherence.findings || [])])
+  });
 }
 
 export function qualifyCreationSchemaReferences(markdown = '', contract = {}) {
@@ -53,7 +73,7 @@ export function qualifyCreationSchemaReferences(markdown = '', contract = {}) {
 }
 
 function qualifyResolvedSchemaReference(value, authority) {
-  const lexical = qualifySchemaReferenceValue(value, authority);
+  const lexical = qualifySchemaReferenceValue(value, authority, { requireExactTargetWhenQualified: true });
   const material = qualifySchemaReferenceMaterialCoherence(authority);
   const findings = [...(lexical.findings || []), ...(material.findings || [])];
   return Object.freeze({ ...lexical, state: findings.length ? 'unavailable' : 'qualified', resolutionState: authority?.resolutionState || '', materialCoherence: material, findings: Object.freeze(findings) });

package/src/schemas/schema.reference.js

@@ -6,13 +6,14 @@ export const SCHEMA_REFERENCE_MATERIAL_COHERENCE_SCHEMA_ID = 'tiinex.site.schema
 export function schemaReferenceAuthorityFromBinding(schemaId = '', binding = {}, sourceAuthority = null, sourceQualification = null) {
   const id = String(schemaId || binding?.schemaId || '').trim();
   const localUnpublished = String(binding?.publicationState || '').toLowerCase().includes('unpublished');
-  const exactSourceTargets = localUnpublished
+  const referencePublished = qualifiedImmutableReferencePublication(binding, sourceQualification);
+  const exactSourceTargets = localUnpublished && !referencePublished
     ? Object.freeze({ state: 'unavailable', targets: Object.freeze([]), findings: Object.freeze(['Binding is explicitly unpublished; remote source targets are not creation reference authority.']) })
     : canonicalGithubSchemaSourceTargets(sourceAuthority);
   const exactTargets = exactSourceTargets.state === 'qualified' ? [...exactSourceTargets.targets] : [];
   const semanticMaterialIdentity = normalizeMaterialIdentity(sourceQualification?.materialIdentity || {});
   const sourceQualified = sourceQualification?.state === 'qualified' && semanticMaterialIdentity.state === 'qualified';
-  const materialBoundTarget = Boolean(exactTargets.length && sourceQualified && sourceQualification?.bindingMaterialCoherence?.state === 'qualified');
+  const materialBoundTarget = Boolean(exactTargets.length && sourceQualified && (sourceQualification?.bindingMaterialCoherence?.state === 'qualified' || referencePublished));
   const preferredTarget = exactTargets[0] || '';
   return Object.freeze({
     schema: SCHEMA_REFERENCE_AUTHORITY_SCHEMA_ID,
@@ -29,6 +30,17 @@ export function schemaReferenceAuthorityFromBinding(schemaId = '', binding = {},
   });
 }
 
+function qualifiedImmutableReferencePublication(binding = {}, sourceQualification = null) {
+  if (String(binding?.schemaReferencePublicationState || '').trim() !== 'published-immutable-canonical') return false;
+  if (sourceQualification?.state !== 'qualified' || sourceQualification?.materialIdentity?.state !== 'qualified') return false;
+  if (sourceQualification?.authority?.providerQualification?.state !== 'qualified') return false;
+  const bindingBlobSha = String(binding?.sourceBlobSha || '').trim().toLowerCase();
+  const loadedBlobSha = String(sourceQualification?.materialIdentity?.sourceBlobSha || '').trim().toLowerCase();
+  const expectedChecksum = String(binding?.checksum?.value || binding?.checksum || '').trim().toLowerCase();
+  const loadedChecksum = String(sourceQualification?.materialIdentity?.sha256 || '').trim().toLowerCase();
+  return Boolean(bindingBlobSha && loadedBlobSha && bindingBlobSha === loadedBlobSha && expectedChecksum && loadedChecksum && expectedChecksum === loadedChecksum);
+}
+
 export function qualifySchemaReferenceMaterialCoherence(authority = {}) {
   const semantic = normalizeMaterialIdentity(authority?.semanticMaterialIdentity || {});
   const target = String(authority?.preferredTarget || authority?.target || '').trim();
@@ -105,14 +117,24 @@ export function parseSchemaReferenceValue(value = '') {
 export function renderSchemaReference(authority = {}) {
   const schemaId = String(authority?.schemaId || '').trim();
   if (!schemaId) throw new Error('schema-reference-id-missing');
-  const target = String(authority?.preferredTarget || '').trim();
+  const target = qualifiedExactSchemaReferenceTarget(authority);
   return target ? `[${schemaId}](${target})` : schemaId;
 }
 
-export function qualifySchemaReferenceValue(value = '', authority = {}) {
+export function qualifiedExactSchemaReferenceTarget(authority = {}) {
+  const preferredTarget = String(authority?.preferredTarget || '').trim();
+  const exactTargets = new Set([...(authority?.exactTargets || [])].map((item) => String(item ?? '')).filter(Boolean));
+  if (String(authority?.resolutionState || authority?.state || '') !== 'qualified') return '';
+  if (!preferredTarget || !exactTargets.has(preferredTarget)) return '';
+  return preferredTarget;
+}
+
+export function qualifySchemaReferenceValue(value = '', authority = {}, options = {}) {
   const observed = parseSchemaReferenceValue(value);
   const expectedSchemaId = String(authority?.schemaId || '').trim();
   const exactTargets = new Set([...(authority?.exactTargets || [])].map((item) => String(item ?? '')).filter(Boolean));
+  const qualifiedExactTarget = qualifiedExactSchemaReferenceTarget(authority);
+  const requireExactTargetWhenQualified = options?.requireExactTargetWhenQualified === true;
   const findings = [];
   if (!expectedSchemaId) findings.push('Expected schema identifier authority is unavailable.');
   if (observed.schemaId !== expectedSchemaId) findings.push(`Schema identifier must be exactly ${expectedSchemaId}; observed ${observed.schemaId || '(empty)'}.`);
@@ -120,12 +142,16 @@ export function qualifySchemaReferenceValue(value = '', authority = {}) {
   if (observed.form === 'markdown-link') {
     targetState = exactTargets.has(observed.target) ? 'qualified' : 'unqualified';
     if (targetState !== 'qualified') findings.push(`Schema reference target is not qualified for ${expectedSchemaId}: ${observed.target || '(empty)'}.`);
+  } else if (observed.form === 'plain-schema-id' && requireExactTargetWhenQualified && qualifiedExactTarget) {
+    targetState = 'qualified-exact-target-omitted';
+    findings.push(`Qualified exact schema-reference authority requires Markdown Link form targeting ${qualifiedExactTarget}; a plain schema id is not sufficient for this new candidate.`);
   }
   if (observed.form === 'empty') findings.push('Schema reference value is empty.');
   return Object.freeze({
     state: findings.length ? 'unavailable' : 'qualified',
     schemaIdState: observed.schemaId === expectedSchemaId && expectedSchemaId ? 'qualified' : 'unavailable',
     targetState,
+    qualifiedExactTarget,
     observed,
     authority,
     findings: Object.freeze(findings)

package/src/schemas/tiinex.root.v1.schema.json

@@ -20,5 +20,6 @@
   "bindingVersion": "tiinex.web.schema-binding.v1",
   "originId": "tiinex-docs-39889512-accepted-local",
   "originTrustRole": "canonical-core",
-  "publicationState": "accepted-local-unpublished"
+  "publicationState": "accepted-local-unpublished",
+  "schemaReferencePublicationState": "published-immutable-canonical"
 }

package/src/tooling/portable/adapters/cli/cli.command-input.js

@@ -11,6 +11,7 @@ import { reductionPreflightCliInput } from './cli.reduction-input.js';
 import {land} from './cli.land.js';
 import { OPERATIONS_WITHOUT_EXPLICIT_MATERIAL } from './cli.material-policy.js';
 import { prepareSourceFrontierComparisonCliInput } from './cli.source-frontier-comparison.js';
+import { prepareSourceFrontierReconciliationCliInput } from './cli.source-frontier-reconciliation.js';
 
 export async function commandInput(parsed, runtime = {}) {
   const flags = parsed.flags;
@@ -140,6 +141,10 @@ export async function commandInput(parsed, runtime = {}) {
   }
 
   if (parsed.command === 'compare-source-frontiers') return prepareSourceFrontierComparisonCliInput(parsed, flags);
+  if (parsed.command === 'prove-source-reconciliation') {
+    const dispositions = await readOptionalJson(flags.dispositions || flags['disposition-file']);
+    return prepareSourceFrontierReconciliationCliInput(flags, dispositions);
+  }
 
   if (parsed.command === 'manufacture-handoff-package') {
     return prepareHandoffManufactureCliCommand(parsed, runtime);

package/src/tooling/portable/adapters/cli/cli.common-output.js

@@ -1,4 +1,5 @@
 import { projectPortableSourceFrontierComparisonSummary } from '../../comparison/sourceFrontierComparison.js';
+import { projectPortableSourceReconciliationProofSummary } from '../../comparison/sourceFrontierReconciliationProof.js';
 
 const COMMON_DEFAULT_PROJECTION = 'common-default';
 
@@ -8,9 +9,31 @@ export function projectCommonCliDefaultOutput(result = {}, parsed = {}) {
   if (parsed?.command === 'project-grounding-readiness') return projectGroundDefault(result, parsed);
   if (parsed?.command === 'manufacture-handoff-package' && parsed?.surfaceCommand === 'handoff') return projectHandoffDefault(result, parsed);
   if (parsed?.command === 'compare-source-frontiers') return projectCompareDefault(result, parsed);
+  if (parsed?.command === 'prove-source-reconciliation') return projectReconciliationProofDefault(result, parsed);
   return result;
 }
 
+function projectReconciliationProofDefault(result = {}, parsed = {}) {
+  const summary = projectPortableSourceReconciliationProofSummary({ ...result, schema: result.resultSchema || result.schema || '' }, { maxPaths: parsed?.flags?.['max-paths'] || 20 });
+  return Object.freeze({
+    schema: result.schema,
+    operation: result.operation || 'prove-source-reconciliation',
+    resultSchema: result.resultSchema,
+    projection: COMMON_DEFAULT_PROJECTION,
+    status: summary.status,
+    state: summary.state,
+    counts: summary.counts,
+    preservation: summary.preservation,
+    workspaces: summary.workspaces,
+    proofFingerprint: summary.proofFingerprint,
+    manufactureBinding: summary.manufactureBinding,
+    findingSummary: summary.findingSummary,
+    actionableFindings: summary.actionableFindings,
+    detail: Object.freeze({ fullReceipt: Object.freeze({ command: String(parsed.surfaceCommand || 'reconcile'), flag: '--full', requiredForManufacture: true }) }),
+    boundary: summary.boundary
+  });
+}
+
 function projectCompareDefault(result = {}, parsed = {}) {
   const summary = projectPortableSourceFrontierComparisonSummary({ ...result, schema: result.resultSchema || result.schema || '' }, { maxPaths: parsed?.flags?.['max-paths'] || 20 });
   return Object.freeze({

package/src/tooling/portable/adapters/cli/cli.handoff-manufacture.js

@@ -2,6 +2,7 @@ import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { prepareNodeHandoffManufacturingInput } from '../node/handoff.manufacture.js';
 import { prepareNodeWorkspaceCarrierManufacturingInput } from '../node/workspaceCarrier.manufacture.js';
+import { prepareNodeBootstrapCarrierManufacturingInput } from '../node/bootstrapCarrier.manufacture.js';
 import { projectHandoffHumanOutput } from '../../handoff/carrierProjection.js';
 import { writePortableRuntimePackageZip } from '../../output/node.zip.js';
 import { writeRecipientFacingV2PackageZip } from '../../output/recipientV2.zip.js';
@@ -16,8 +17,9 @@ export async function prepareHandoffManufactureCliCommand(parsed = {}, runtime =
   const flags = parsed.flags || {};
   const workspaceRoot = flags.workspace || parsed.positionals?.[0] || '.';
   const carrierMode = String(flags['carrier-mode'] || 'handoff').trim().toLowerCase();
-  if (!['handoff', 'workspace'].includes(carrierMode)) throw new Error(`portable.cli.handoff-carrier.carrier-mode.invalid:${carrierMode}`);
+  if (!['handoff', 'workspace', 'bootstrap'].includes(carrierMode)) throw new Error(`portable.cli.handoff-carrier.carrier-mode.invalid:${carrierMode}`);
   if (carrierMode === 'workspace') return prepareWorkspaceCarrierCliCommand(flags, workspaceRoot, runtime);
+  if (carrierMode === 'bootstrap') return prepareBootstrapCarrierCliCommand(flags, runtime);
   const continuationState = parsed.surfaceCommand === 'handoff'
     ? await readGroundContinuationState(workspaceRoot)
     : {};
@@ -28,6 +30,8 @@ export async function prepareHandoffManufactureCliCommand(parsed = {}, runtime =
   if (!flags.route && handoffPath) flags.route = handoffPath;
   if (!flags.output && !flags['output-dir'] && parsed.surfaceCommand === 'handoff' && continuationState.returnOutputDir) flags['output-dir'] = continuationState.returnOutputDir;
   const materialBindings = await readOptionalJson(flags['material-bindings'] || flags.materials);
+  const reconciliationProof = await readOptionalJson(flags['reconciliation-proof']);
+  const requireReconciliationProof = Boolean(flags['require-reconciliation-proof']);
   const packageParentWorkspaceIds = splitFlag(flags['package-parent-workspaces']);
   const packageParentWorkspaceAliases = await readOptionalJson(flags['package-parent-workspace-aliases']);
   const operatorCarrierProfile = await readOptionalJson(flags['carrier-profile']);
@@ -129,7 +133,9 @@ export async function prepareHandoffManufactureCliCommand(parsed = {}, runtime =
     packageParentPath: parentPackagePath ? path.resolve(parentPackagePath) : '',
     packageParentSha256,
     packageParentWorkspaceIds,
-    packageParentWorkspaceAliases
+    packageParentWorkspaceAliases,
+    reconciliationProof,
+    requireReconciliationProof
   }, runtime);
   return {
     input,
@@ -142,13 +148,15 @@ export async function prepareHandoffManufactureCliCommand(parsed = {}, runtime =
 }
 
 export async function materializeHandoffManufactureCliOutput(result = {}, flags = {}) {
-  const workspaceMode = String(result.carrierProjection?.mode || '') === 'workspace';
-  let humanOutput = workspaceMode ? projectWorkspaceCarrierHumanOutput(result, flags) : projectHandoffHumanOutput({
+  const carrierMode = String(result.carrierProjection?.mode || '');
+  const workspaceMode = carrierMode === 'workspace';
+  const bootstrapMode = carrierMode === 'bootstrap';
+  let humanOutput = workspaceMode ? projectWorkspaceCarrierHumanOutput(result, flags) : bootstrapMode ? projectBootstrapCarrierHumanOutput(result, flags) : projectHandoffHumanOutput({
     projection: result.carrierProjection || {},
     route: flags.route || '',
     collisionInstance: flags['collision-instance'] || 1
   });
-  if (!workspaceMode && result.bundle?.transportFormat) humanOutput = projectRecipientV2HumanOutput(humanOutput, result.inspection || {});
+  if (result.bundle?.transportFormat) humanOutput = projectRecipientV2HumanOutput(humanOutput, result.inspection || {});
   const wantsWrite = Boolean(flags.output || flags['output-dir']);
   const blocked = result.status === 'blocked' || result.transportExecutable === false || Number(result.findingSummary?.counts?.error || 0) > 0;
   if (!wantsWrite || blocked) return summarizeHandoffManufactureCliOutput(result, {}, humanOutput, null);
@@ -159,7 +167,6 @@ export async function materializeHandoffManufactureCliOutput(result = {}, flags
   const writeReceipt = writeBundle?.transportFormat
     ? await writeRecipientFacingV2PackageZip(writeBundle, target, writeBundle === result.bundle ? { inspection: result.inspection } : {})
     : await writePortableRuntimePackageZip(writeBundle, target);
-  if (workspaceMode && flags['transport-text']) throw new Error('portable.cli.workspace-carrier.transport-text.unavailable');
   const transportTextReceipt = flags['transport-text'] ? await writeTransportTextSidecar(humanOutput, target, flags['transport-text']) : null;
   return summarizeHandoffManufactureCliOutput(result, writeReceipt, humanOutput, transportTextReceipt);
 }
@@ -170,6 +177,7 @@ async function prepareWorkspaceCarrierCliCommand(flags = {}, workspaceRoot = '.'
   const expectedToolingBootstrap = await readOptionalJson(flags['tooling-bootstrap-manifest']);
   const workspaceDescriptorValue = await readOptionalJson(flags['workspace-roots'] || flags['workspace-descriptors']);
   const workspaceTargetValue = await readOptionalJson(flags['workspace-targets']);
+  const workspaceScopeValue = await readOptionalJson(flags['workspace-scopes']);
   const additionalWorkspaces = [...splitFlag(flags['additional-workspaces']), ...descriptorArray(workspaceDescriptorValue, 'workspaces')];
   const verifyRoundtrip = !flags['no-roundtrip'];
   const carrierProfile = selectCarrierProfile({ operator: operatorCarrierProfile, runtime: runtime.defaultCarrierProfile || null });
@@ -181,6 +189,8 @@ async function prepareWorkspaceCarrierCliCommand(flags = {}, workspaceRoot = '.'
     workspaceTitle: flags['workspace-title'] || flags.title || '',
     workspaceTargetPath: flags['workspace-target'] || flags['workspace-artifact'] || '',
     workspaceTargets: workspaceTargetValue,
+    workspaceScopes: descriptorArray(workspaceScopeValue, 'scopes').length ? descriptorArray(workspaceScopeValue, 'scopes') : workspaceScopeValue,
+    materialRepresentationWorkspaceIds: splitFlag(flags['material-representation-workspaces'] || flags['generic-material-workspaces']),
     toolingBootstrap: flags['tooling-bootstrap'] || 'embedded',
     expectedToolingBootstrap,
     maxFiles: flags['max-files'],
@@ -194,6 +204,37 @@ async function prepareWorkspaceCarrierCliCommand(flags = {}, workspaceRoot = '.'
   return { input, options: { verifyRoundtrip, packageInput: { builtAt: flags['built-at'] || undefined } } };
 }
 
+async function prepareBootstrapCarrierCliCommand(flags = {}, runtime = {}) {
+  if (flags.handoff || flags.route || flags.routes || flags['handoff-routes'] || flags['workspace-routes'] || flags.workspace || flags['workspace-target'] || flags['workspace-targets'] || flags['workspace-roots'] || flags['workspace-descriptors']) throw new Error('portable.cli.bootstrap-carrier.source-material-or-route.forbidden');
+  const operatorCarrierProfile = await readOptionalJson(flags['carrier-profile']);
+  const expectedToolingBootstrap = await readOptionalJson(flags['tooling-bootstrap-manifest']);
+  const verifyRoundtrip = !flags['no-roundtrip'];
+  const carrierProfile = selectCarrierProfile({ operator: operatorCarrierProfile, runtime: runtime.defaultCarrierProfile || null });
+  const input = await prepareNodeBootstrapCarrierManufacturingInput({
+    toolingBootstrap: flags['tooling-bootstrap'] || 'embedded', expectedToolingBootstrap, bootstrapMaxFiles: flags['bootstrap-max-files'], verifyRoundtrip, createdAt: flags['built-at'] || undefined,
+    carrierLineage: Object.freeze({ ...initialHandoffCarrierLineage(), checkpointKind: 'progression', majorReason: '' }), carrierProfile
+  }, runtime);
+  return { input, options: { verifyRoundtrip, packageInput: { builtAt: flags['built-at'] || undefined } } };
+}
+
+function projectBootstrapCarrierHumanOutput(result = {}, flags = {}) {
+  const projection = result.carrierProjection || {};
+  const ready = result.status === 'ready' && projection.status === 'ready' && projection.mode === 'bootstrap' && (projection.routes || []).length === 0 && (projection.workspaces || []).length === 0;
+  const dimension = String(projection.lineage?.dimension || '001');
+  const projectedFilename = String(flags['projected-filename'] || flags.projectedFilename || '').trim();
+  const filename = projectedFilename || `tiinex-${dimension}.handoff-package.zip`;
+  if (filename !== filename.trim() || !filename.endsWith('.handoff-package.zip') || /[<>:"/\\|?*\x00-\x1f\x7f]/.test(filename) || /[. ]$/.test(filename) || /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(filename) || new TextEncoder().encode(filename).byteLength > 255) throw new Error('portable.cli.bootstrap-carrier.filename.invalid');
+  return Object.freeze({
+    schema: 'tiinex.portable.handoff-human-output.v1', status: ready ? 'ready' : 'blocked',
+    primary: ready ? Object.freeze({ kind: 'bootstrap-package', filename, dimension, parentDimension: String(projection.lineage?.parentDimension || ''), checkpointKind: String(projection.lineage?.checkpointKind || ''), routeId: '', workspaceId: '', workspaceRelativeHandoffPath: '', collisionInstance: 1, singleHumanTransportChoice: true }) : null,
+    normalInlineRouting: ready ? Object.freeze({ kind: 'transport-text', content: '', normalEmission: true, requiredForHumanCompletion: true, placement: 'adjacent-to-primary', authority: 'none' }) : null, sharedRouting: null,
+    presentation: Object.freeze({ kind: 'bootstrap-only-carrier', label: 'Bootstrap carrier', authority: 'none', recipientLabel: '' }),
+    normalEmissionBoundary: Object.freeze({ allowed: Object.freeze(['package-file', 'generic-start-transport-text']), forbidden: Object.freeze(['workspace-label', 'route-specific-continue-from', 'recipient-label', 'holder-label', 'current-work-label']) }),
+    fallbackTransportText: ready ? Object.freeze({ supported: true, filename: filename.replace(/\.handoff-package\.zip$/i, '.transport.txt'), content: '', normalEmission: false, requiredForHumanCompletion: false, authority: 'none' }) : null, selectedRoute: null, findings: Object.freeze([]),
+    boundary: 'Bootstrap-only carrier output projection. Generic Start transport text only; no Workspace, Handoff route, recipient, holder, Role, or work projection exists.'
+  });
+}
+
 function projectWorkspaceCarrierHumanOutput(result = {}, flags = {}) {
   const projection = result.carrierProjection || {};
   const ready = result.status === 'ready' && projection.status === 'ready' && projection.mode === 'workspace' && (projection.routes || []).length === 0;
@@ -209,11 +250,11 @@ function projectWorkspaceCarrierHumanOutput(result = {}, flags = {}) {
     schema: 'tiinex.portable.handoff-human-output.v1',
     status: ready ? 'ready' : 'blocked',
     primary: ready ? Object.freeze({ kind: 'workspace-package', filename, dimension, parentDimension: String(projection.lineage?.parentDimension || ''), checkpointKind: String(projection.lineage?.checkpointKind || ''), routeId: '', workspaceId: '', workspaceRelativeHandoffPath: '', collisionInstance: 1, singleHumanTransportChoice: true }) : null,
-    normalInlineRouting: null, sharedRouting: null,
-    presentation: Object.freeze({ kind: 'pointerless-workspace-carrier', label: 'Workspace carrier', authority: 'none' }),
-    normalEmissionBoundary: Object.freeze({ allowed: Object.freeze(['package-file']), forbidden: Object.freeze(['handoff-routing-text', 'continue-from-pointer']) }),
-    fallbackTransportText: null, selectedRoute: null, findings: Object.freeze([]),
-    boundary: 'Pointerless Workspace-carrier output projection only. No Handoff routing text exists because the package role declares no Handoff route.'
+    normalInlineRouting: ready ? Object.freeze({ kind: 'transport-text', content: '', normalEmission: true, requiredForHumanCompletion: true, placement: 'adjacent-to-primary', authority: 'none' }) : null, sharedRouting: null,
+    presentation: Object.freeze({ kind: 'pointerless-workspace-carrier', label: 'Workspace carrier', authority: 'none', recipientLabel: '' }),
+    normalEmissionBoundary: Object.freeze({ allowed: Object.freeze(['package-file', 'generic-start-transport-text']), forbidden: Object.freeze(['route-specific-continue-from', 'recipient-label-from-material']) }),
+    fallbackTransportText: ready ? Object.freeze({ supported: true, filename: filename.replace(/\.handoff-package\.zip$/i, '.transport.txt'), content: '', normalEmission: false, requiredForHumanCompletion: false, authority: 'none' }) : null, selectedRoute: null, findings: Object.freeze([]),
+    boundary: 'Pointerless Workspace-carrier output projection. Generic Start transport text is permitted; Handoff Continue-from and recipient projection remain absent.'
   });
 }
 

package/src/tooling/portable/adapters/cli/cli.help.js

@@ -13,6 +13,7 @@ export function portableCliHelpText(commandPrefix = '', surfaceCommand = '') {
     `${command} author <workspace-dir> --schema <schema-id> (--path <workspace-relative-artifact> | --directory <workspace-relative-directory>) --body <body.md> [--parent <workspace-relative-or-qualified-parent>] [--parent-source <local-parent-file>] [--title <title>] [--summary <summary>] [--why <why>]`,
     `${command} handoff <workspace-dir>`,
     `${command} compare --left-kind <kind> --left <path> --right-kind <kind> --right <path> [side selectors]`,
+    `${command} reconcile --base-kind <kind> --base <path> --incoming-kind <kind> --incoming <path> --current-kind <kind> --current <path> --reconciled-kind <kind> --reconciled <path> [--dispositions <json-file>]`,
     '',
     `Handoff aliases: ${command} orient <carrier.zip>; ${command} validate <carrier.zip>`,
     `Advanced/internal catalog: ${command} operations`,
@@ -21,7 +22,7 @@ export function portableCliHelpText(commandPrefix = '', surfaceCommand = '') {
     '- `orient`, `ground`, and public `handoff` use compact decision-first default projections; add `--full` on the same command for the complete qualified receipt.',
     '- `ground` is read-only; append `--continue <workspace-dir>` only after `grounded-to-act` to materialize the selected carried Workspace and runtime-only `.tiinex/continuation.json`.',
     '- `author` uses continuation state to infer ordinary Parent continuity, seal c14n-v2 integrity, audit, and stage; invalid artifacts are not retained.',
-    '- `handoff` uses continuation state plus the latest qualified authored Handoff to manufacture the canonical return carrier and excludes runtime-only `.tiinex` state. A received `--package-parent` continues carrier lineage only; it never selects parent Workspace source by itself. Advanced manufacture may opt into exact parent snapshots with `--package-parent-workspaces <id,...|all>` and may bind an explicitly selected renamed predecessor with `--package-parent-workspace-aliases`; aliases never infer source identity. Normal operator completion is one Handoff package plus the exact routing text; markdown-capable hosts render that routing in a fenced code block, and do not emit loose Evidence/Handoff markdown as extra transport payloads.',
+    '- `handoff` uses continuation state plus the latest qualified authored Handoff to manufacture the canonical return carrier and excludes runtime-only `.tiinex` state. A received `--package-parent` continues carrier lineage only; it never selects parent Workspace source by itself. Advanced manufacture may opt into exact parent snapshots with `--package-parent-workspaces <id,...|all>` and may bind an explicitly selected renamed predecessor with `--package-parent-workspace-aliases`; aliases never infer source identity. Recovery/integration manufacture may require a full `reconcile --full` receipt with `--require-reconciliation-proof --reconciliation-proof <receipt.json>`; manufacture re-enumerates source and fails closed on missing/stale proof. Normal operator completion is one Handoff package plus the exact routing text; markdown-capable hosts render that routing in a fenced code block, and do not emit loose Evidence/Handoff markdown as extra transport payloads.',
     '- Remote reads/writes remain explicit host concerns. Tooling operation safety does not create or revoke semantic Task/Handoff authority.',
     '',
     'Use `<common-command> --help` for focused common-path usage. Use `operations` deliberately for the advanced/internal operation catalog.'
@@ -29,6 +30,18 @@ export function portableCliHelpText(commandPrefix = '', surfaceCommand = '') {
 }
 
 function commonCommandHelp(command, surfaceCommand) {
+  if (surfaceCommand === 'reconcile' || surfaceCommand === 'prove-source-reconciliation') return [
+    'Tiinex portable tooling — prove source reconciliation for manufacture',
+    '',
+    `${command} reconcile --base-kind <local-workspace|local-frontier|handoff-package> --base <path> --incoming-kind <kind> --incoming <path> --current-kind <kind> --current <path> --reconciled-kind <kind> --reconciled <path> [side ids/selectors/roots] [--dispositions <json-file>]`,
+    '',
+    'The gate deterministically classifies exact, incoming-only, current-only, same-result-concurrent, deletion-candidate, and conflicting-overlap paths. Deletion/conflict candidates remain blocked until an explicit disposition selects `incoming`, `current`, `base`, `reconciled`, or `delete`. `reconciled` explicitly accepts the candidate bytes at that path and therefore supports a separately decided manual semantic resolution without Tooling deciding that resolution.',
+    'The candidate reconciled frontier must preserve every automatically accepted incoming-only/current-only source identity and match every explicit disposition. Extra ungrounded candidate paths fail closed. Local source uses the same enumeration/exclusion contract as Handoff manufacture.',
+    'Default output is compact. Use `--full` when saving a proof for `handoff --require-reconciliation-proof --reconciliation-proof <receipt.json>`; manufacture re-enumerates the Workspace and rejects stale or mismatched candidate bytes.',
+    'This is mechanical byte/path proof only: no semantic merge correctness, intentional deletion, authority, acceptance, remote acquisition, or source mutation is inferred.',
+    '',
+    `Advanced/internal catalog: ${command} operations`
+  ];
   if (surfaceCommand === 'compare' || surfaceCommand === 'compare-source-frontiers') return [
     'Tiinex portable tooling — compare source frontiers',
     '',
@@ -70,7 +83,7 @@ function commonCommandHelp(command, surfaceCommand) {
     '',
     `${command} handoff <workspace-dir>`,
     '',
-    'Infers the latest qualified authored Handoff, selected Workspace identity/target, received package parent as carrier-lineage evidence, canonical projected filename, and return output directory. A non-major continuation that writes a carrier must supply an explicitly coordinated `--package-sibling-index <1..9999>`; Tooling will not silently discover the next sibling because isolated runtimes cannot prove a globally unique reservation. Distinct explicit sibling indexes preserve same-Major parallelism, while byte-identical duplicate transport at one exact output path is idempotent and divergent bytes fail closed. It does not implicitly carry sibling Workspaces from the received package; advanced manufacture must select exact reusable parent snapshots with `--package-parent-workspaces <id,...|all>`. The default receipt keeps output identity, routing text, closure/workspace qualification, verification, and actionable findings compact; add `--full` for the complete manufacture receipt. Normal operator completion is exactly one Handoff package plus the adjacent exact routing text. In markdown-capable hosts render that routing in a fenced code block; do not emit canonical Workspace Evidence/Handoff markdown as additional loose transport files. Runtime-only `.tiinex` state is excluded from canonical manufacture.',
+    'Infers the latest qualified authored Handoff, selected Workspace identity/target, received package parent as carrier-lineage evidence, canonical projected filename, and return output directory. A non-major continuation that writes a carrier must supply an explicitly coordinated `--package-sibling-index <1..9999>`; Tooling will not silently discover the next sibling because isolated runtimes cannot prove a globally unique reservation. Distinct explicit sibling indexes preserve same-Major parallelism, while byte-identical duplicate transport at one exact output path is idempotent and divergent bytes fail closed. It does not implicitly carry sibling Workspaces from the received package; advanced manufacture must select exact reusable parent snapshots with `--package-parent-workspaces <id,...|all>`. Recovery/integration manufacture can bind the reconciled byte proof with `--require-reconciliation-proof --reconciliation-proof <full-reconcile-receipt.json>`; missing, non-ready, edited, or source-stale proof blocks package output. The default receipt keeps output identity, routing text, closure/workspace qualification, verification, and actionable findings compact; add `--full` for the complete manufacture receipt. Normal operator completion is exactly one Handoff package plus the adjacent exact routing text. In markdown-capable hosts render that routing in a fenced code block; do not emit canonical Workspace Evidence/Handoff markdown as additional loose transport files. Runtime-only `.tiinex` state is excluded from canonical manufacture.',
     '',
     `Advanced/internal catalog: ${command} operations`
   ];

package/src/tooling/portable/adapters/cli/cli.run.js

@@ -425,7 +425,7 @@ function withCliPhaseTiming(result = {}, timing = {}) {
 function parseArgs(argv=[]) {
   const args=[...argv],first=args.shift()||'';
   if(first==='--help'||first==='-h') return {command:'help',flags:{help:true},positionals:[]};
-  const command=({orient:'orient-handoff-package',ground:'project-grounding-readiness',receive:'qualify-cold-start',validate:'audit-handoff-package-context',handoff:'manufacture-handoff-package',author:'author',compare:'compare-source-frontiers'})[first]||first;
+  const command=({orient:'orient-handoff-package',ground:'project-grounding-readiness',receive:'qualify-cold-start',validate:'audit-handoff-package-context',handoff:'manufacture-handoff-package',author:'author',compare:'compare-source-frontiers',reconcile:'prove-source-reconciliation'})[first]||first;
   const flags={},positionals=[];
   while(args.length){const token=args.shift();if(!token.startsWith('--')){positionals.push(token);continue;}const key=token.slice(2);flags[key]=!args.length||args[0].startsWith('--')?true:args.shift();}
   return {command,flags,positionals,surfaceCommand:first};

package/src/tooling/portable/adapters/cli/cli.source-frontier-comparison.js

@@ -9,20 +9,20 @@ export async function prepareSourceFrontierComparisonCliInput(parsed = {}, flags
   };
   if (threeWay) {
     const request = {
-      base: descriptorFromFlags('base', flags),
-      incoming: descriptorFromFlags('incoming', flags),
-      current: descriptorFromFlags('current', flags)
+      base: sourceFrontierDescriptorFromFlags('base', flags),
+      incoming: sourceFrontierDescriptorFromFlags('incoming', flags),
+      current: sourceFrontierDescriptorFromFlags('current', flags)
     };
     return { input: await prepareNodeSourceFrontierComparisonInput(request, descriptorOptions), options: {} };
   }
   const request = {
-    left: descriptorFromFlags('left', flags),
-    right: descriptorFromFlags('right', flags)
+    left: sourceFrontierDescriptorFromFlags('left', flags),
+    right: sourceFrontierDescriptorFromFlags('right', flags)
   };
   return { input: await prepareNodeSourceFrontierComparisonInput(request, descriptorOptions), options: {} };
 }
 
-function descriptorFromFlags(prefix, flags) {
+export function sourceFrontierDescriptorFromFlags(prefix, flags) {
   const kind = String(flags[`${prefix}-kind`] || '').trim();
   const root = String(flags[prefix] || '').trim();
   const workspaceId = String(flags[`${prefix}-id`] || flags[`${prefix}-workspace-id`] || '').trim();

package/src/tooling/portable/adapters/cli/cli.source-frontier-reconciliation.js

@@ -0,0 +1,18 @@
+import { prepareNodeSourceReconciliationProofInput } from '../node/sourceFrontierReconciliationProof.js';
+import { sourceFrontierDescriptorFromFlags } from './cli.source-frontier-comparison.js';
+
+export async function prepareSourceFrontierReconciliationCliInput(flags = {}, dispositions = []) {
+  const descriptorOptions = {
+    maxFiles: flags['max-files'],
+    maxCarrierFiles: flags['max-carrier-files'],
+    maxTextBytes: flags['max-text-bytes']
+  };
+  const request = {
+    base: sourceFrontierDescriptorFromFlags('base', flags),
+    incoming: sourceFrontierDescriptorFromFlags('incoming', flags),
+    current: sourceFrontierDescriptorFromFlags('current', flags),
+    reconciled: sourceFrontierDescriptorFromFlags('reconciled', flags),
+    dispositions: Array.isArray(dispositions) ? dispositions : dispositions?.dispositions || []
+  };
+  return { input: await prepareNodeSourceReconciliationProofInput(request, descriptorOptions), options: {} };
+}

package/src/tooling/portable/adapters/node/bootstrapCarrier.manufacture.js

@@ -0,0 +1,18 @@
+import { buildToolingBootstrapTransportFiles } from './handoff.manufacture.bootstrap.js';
+import { normalizeHandoffCarrierLineage } from '../../handoff/carrierLineage.js';
+import { normalizeHandoffCarrierProfile } from '../../handoff/carrierProfile.js';
+
+export async function prepareNodeBootstrapCarrierManufacturingInput(input = {}, options = {}) {
+  const toolingBootstrap = await buildToolingBootstrapTransportFiles({
+    delivery: input.toolingBootstrap || input.bootstrapDelivery || 'embedded',
+    runtimeRoot: input.runtimeRoot || options.runtimeRoot,
+    expected: input.expectedToolingBootstrap || null,
+    maxFiles: input.bootstrapMaxFiles || options.bootstrapMaxFiles
+  });
+  return Object.freeze({
+    carrierMode: 'bootstrap', createdAt: String(input.createdAt || ''), workspaceMaterializations: Object.freeze([]), workspaceTargets: Object.freeze([]),
+    additionalTransportFiles: toolingBootstrap.files,
+    carrierLineage: normalizeHandoffCarrierLineage(input.carrierLineage || null), carrierProfile: normalizeHandoffCarrierProfile(input.carrierProfile || null),
+    toolingBootstrap: toolingBootstrap.summary, manufacturingEvidence: Object.freeze({ toolingBootstrap: toolingBootstrap.summary }), verifyRoundtrip: input.verifyRoundtrip !== false
+  });
+}