@tiinex/core 0.11.0 → 0.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiinex/core",
-  "version": "0.11.0",
+  "version": "0.13.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": "d9fce40b1ec63fb0e4dc0a673161650d1661a25c",
+  "gitHead": "7e705cbd611919cc46659f9bcee0cf363a09c41c",
   "tiinexRelease": {
     "policy": "tiinex.master-npm-release.v1",
-    "sourceCommit": "d9fce40b1ec63fb0e4dc0a673161650d1661a25c",
-    "sourceTree": "1827ddd3975215d019cb809f2d477de6ebc4b300",
+    "sourceCommit": "7e705cbd611919cc46659f9bcee0cf363a09c41c",
+    "sourceTree": "f6b7df8dfa2757bd05cd4d9f764cd0696cc23797",
     "repository": "Tiinex/core",
-    "previousVersion": "0.10.0"
+    "previousVersion": "0.12.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

@@ -28,6 +28,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 +131,9 @@ export async function prepareHandoffManufactureCliCommand(parsed = {}, runtime =
     packageParentPath: parentPackagePath ? path.resolve(parentPackagePath) : '',
     packageParentSha256,
     packageParentWorkspaceIds,
-    packageParentWorkspaceAliases
+    packageParentWorkspaceAliases,
+    reconciliationProof,
+    requireReconciliationProof
   }, runtime);
   return {
     input,

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/handoff.manufacture.bootstrap.js

@@ -14,6 +14,7 @@ export async function buildToolingBootstrapTransportFiles(input = {}) {
   const delivery = normalizeDelivery(input.delivery);
   const runtimeRoot = path.resolve(String(input.runtimeRoot || DEFAULT_RUNTIME_ROOT));
   const runtime = await enumerateRuntimeDependencyGraph(runtimeRoot, { maxFiles: input.maxFiles });
+  const runtimeIdentity = runtimeIdentityFromEnumeration(runtime);
   const manifest = Object.freeze({
     schema: PORTABLE_TOOLING_BOOTSTRAP_MANIFEST_SCHEMA_ID,
     version: 1,
@@ -30,7 +31,42 @@ export async function buildToolingBootstrapTransportFiles(input = {}) {
   const summary = Object.freeze({ schema: 'tiinex.portable.tooling-bootstrap.summary.v1', delivery, manifestSha256, representationSha256: runtime.representationSha256, runtimeFiles: runtime.entries.length, runtimeBytes: runtime.totalBytes, status: delivery === 'embedded' ? 'embedded-qualified' : 'persistent-identity-verified', persistentVerification });
   const files = [transportFile('tiinex.bootstrap/manifest.json', manifestBytes, 'tooling-bootstrap-manifest', 'portable-tooling-bootstrap-control')];
   if (delivery === 'embedded') for (const entry of runtime.entries) files.push(transportFile(`tiinex.bootstrap/runtime/${entry.path}`, entry.data, 'tooling-bootstrap-runtime', 'portable-tooling-bootstrap-runtime'));
-  return Object.freeze({ manifest, summary, files: Object.freeze(files) });
+  return Object.freeze({ manifest, summary, files: Object.freeze(files), runtimeIdentity });
+}
+
+export async function buildToolingBootstrapRuntimeIdentity(input = {}) {
+  const runtimeRoot = path.resolve(String(input.runtimeRoot || DEFAULT_RUNTIME_ROOT));
+  const runtime = await enumerateRuntimeDependencyGraph(runtimeRoot, { maxFiles: input.maxFiles });
+  return runtimeIdentityFromEnumeration(runtime);
+}
+
+
+function runtimeIdentityFromEnumeration(runtime = {}) {
+  const runtimeEntries = runtime.entries || [];
+  const packageEntry = runtimeEntries.find((entry) => String(entry?.path || '') === 'package.json');
+  let packageName = '';
+  let packageVersion = '';
+  if (packageEntry?.data) {
+    try {
+      const parsed = JSON.parse(new TextDecoder().decode(packageEntry.data));
+      packageName = String(parsed?.name || '').trim();
+      packageVersion = String(parsed?.version || '').trim();
+    } catch {}
+  }
+  const shaFor = (entryPath) => String(runtimeEntries.find((entry) => String(entry?.path || '') === entryPath)?.sha256 || '');
+  const sourceEntries = runtimeEntries.filter((entry) => String(entry?.path || '') !== 'package.json');
+  const sourceRepresentationSha256 = sha256Text(stableJson(sourceEntries.map(({ path: entryPath, bytes, sha256 }) => ({ path: `runtime/${entryPath}`, bytes, sha256 }))));
+  return Object.freeze({
+    schema: 'tiinex.portable.tooling-runtime-identity.v1',
+    packageName,
+    packageVersion,
+    representationSha256: String(runtime.representationSha256 || ''),
+    sourceRepresentationSha256,
+    runtimeFiles: Number(runtimeEntries.length),
+    runtimeBytes: Number(runtime.totalBytes || 0),
+    entrypointSha256: shaFor('tools/tiinex-portable.mjs'),
+    enumerationPolicySha256: shaFor('src/tooling/portable/adapters/node/handoff.manufacture.enumeration.js')
+  });
 }
 
 function verifyExpectedPersistentBootstrap(expected, manifest, manifestSha256) {

package/src/tooling/portable/adapters/node/handoff.manufacture.enumeration.js

@@ -2,17 +2,25 @@ import { readdir, readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { sha256Hex } from '../../../../export/package.bytes.js';
 import { safeWorkspaceToken, serializableMetadata } from './handoff.manufacture.multiRoot.js';
+import {
+  DEFAULT_PORTABLE_SOURCE_EXCLUDED_DIRECTORIES,
+  DEFAULT_PORTABLE_SOURCE_EXCLUDED_RELATIVE_PATHS,
+  portableSourceEligibilityPolicy,
+  qualifyPortableSourcePath
+} from '../../source/sourceEligibility.js';
 
 export const PORTABLE_NODE_WORKSPACE_ENUMERATION_SCHEMA_ID = 'tiinex.portable.node-workspace-enumeration.v1';
-export const DEFAULT_HANDOFF_MANUFACTURE_EXCLUDED_DIRECTORIES = Object.freeze(['.git', '.tiinex', 'node_modules', '.site-publish', '.release', '.outgoing-handoff-packages']);
-export const DEFAULT_HANDOFF_MANUFACTURE_EXCLUDED_RELATIVE_PATHS = Object.freeze(['.vscode/link']);
+export const DEFAULT_HANDOFF_MANUFACTURE_EXCLUDED_DIRECTORIES = DEFAULT_PORTABLE_SOURCE_EXCLUDED_DIRECTORIES;
+export const DEFAULT_HANDOFF_MANUFACTURE_EXCLUDED_RELATIVE_PATHS = DEFAULT_PORTABLE_SOURCE_EXCLUDED_RELATIVE_PATHS;
 const DEFAULT_MAX_FILES = 10000;
 
 export async function enumerateNodeWorkspace(rootInput = '.', options = {}) {
   const root = path.resolve(String(rootInput || '.'));
   const maxFiles = positiveInteger(options.maxFiles, DEFAULT_MAX_FILES);
-  const excluded = new Set([...(options.excludeDirectories || DEFAULT_HANDOFF_MANUFACTURE_EXCLUDED_DIRECTORIES)].map(String));
-  const excludedPaths = new Set(options.excludeRelativePaths || DEFAULT_HANDOFF_MANUFACTURE_EXCLUDED_RELATIVE_PATHS);
+  const sourceEligibility = portableSourceEligibilityPolicy({
+    excludeDirectories: options.excludeDirectories == null ? DEFAULT_HANDOFF_MANUFACTURE_EXCLUDED_DIRECTORIES : options.excludeDirectories,
+    excludeRelativePaths: options.excludeRelativePaths == null ? DEFAULT_HANDOFF_MANUFACTURE_EXCLUDED_RELATIVE_PATHS : options.excludeRelativePaths
+  });
   const queue = [root];
   const absoluteFiles = [];
   const skippedSymlinks = [];
@@ -21,10 +29,15 @@ export async function enumerateNodeWorkspace(rootInput = '.', options = {}) {
     const entries = await readdir(current, { withFileTypes: true });
     entries.sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
-      if (entry.isDirectory() && excluded.has(entry.name)) continue;
       const absolute = path.join(current, entry.name);
-      if (excludedPaths.has(normalizeRelativePath(path.relative(root, absolute)))) continue;
-      if (entry.isSymbolicLink()) { skippedSymlinks.push(normalizeRelativePath(path.relative(root, absolute))); continue; }
+      const relative = normalizeRelativePath(path.relative(root, absolute));
+      const eligibility = qualifyPortableSourcePath(relative, {
+        excludeDirectories: sourceEligibility.excludedDirectories,
+        excludeRelativePaths: sourceEligibility.excludedRelativePaths,
+        entryKind: entry.isDirectory() ? 'directory' : 'file'
+      });
+      if (!eligibility.eligible) continue;
+      if (entry.isSymbolicLink()) { skippedSymlinks.push(relative); continue; }
       if (entry.isDirectory()) queue.push(absolute);
       else if (entry.isFile()) absoluteFiles.push(absolute);
       if (absoluteFiles.length > maxFiles) {
@@ -62,7 +75,13 @@ export async function enumerateNodeWorkspace(rootInput = '.', options = {}) {
     workspaceId,
     entryCount: includedEntries.length,
     totalBytes,
-    exclusions: Object.freeze({ directories: Object.freeze([...excluded].sort()), relativePaths: Object.freeze([...excludedPaths].sort()), symbolicLinks: 'excluded-and-reported' }),
+    exclusions: Object.freeze({
+      directories: sourceEligibility.excludedDirectories,
+      relativePaths: sourceEligibility.excludedRelativePaths,
+      fileSuffixes: sourceEligibility.excludedFileSuffixes,
+      symbolicLinks: 'excluded-and-reported',
+      sourceEligibilitySchema: sourceEligibility.schema
+    }),
     skippedSymlinks: Object.freeze(skippedSymlinks.sort()),
     entriesFingerprint: sha256Text(stableJson(includedEntries))
   });