@tiinex/core 0.13.0 → 0.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiinex/core",
-  "version": "0.13.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,
@@ -168,12 +168,12 @@
     "type": "git",
     "url": "git+https://github.com/Tiinex/core.git"
   },
-  "gitHead": "7e705cbd611919cc46659f9bcee0cf363a09c41c",
+  "gitHead": "030669b6596196da946edb049d15af044bcd96c6",
   "tiinexRelease": {
     "policy": "tiinex.master-npm-release.v1",
-    "sourceCommit": "7e705cbd611919cc46659f9bcee0cf363a09c41c",
-    "sourceTree": "f6b7df8dfa2757bd05cd4d9f764cd0696cc23797",
+    "sourceCommit": "030669b6596196da946edb049d15af044bcd96c6",
+    "sourceTree": "090aaead28df51b2aeb6679018526f54260a1ca8",
     "repository": "Tiinex/core",
-    "previousVersion": "0.12.0"
+    "previousVersion": "0.13.0"
   }
 }

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)
     : {};
@@ -146,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);
@@ -163,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);
 }
@@ -174,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 });
@@ -185,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'],
@@ -198,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;
@@ -213,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/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
+  });
+}

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

@@ -3,7 +3,7 @@ import { enumerateNodeWorkspace } from './handoff.manufacture.enumeration.js';
 import { buildToolingBootstrapTransportFiles } from './handoff.manufacture.bootstrap.js';
 import { qualifyToolingRuntimeSourceAlignment } from './handoff.manufacture.runtimeSource.js';
 import { inferWorkspaceTitle, normalizeAdditionalWorkspaceDescriptors, safeWorkspaceToken } from './handoff.manufacture.multiRoot.js';
-import { normalizeWorkspaceTargetBindings } from './handoff.manufacture.scope.js';
+import { normalizeWorkspaceScopes, normalizeWorkspaceTargetBindings, projectBoundedWorkspaceMaterialization } from './handoff.manufacture.scope.js';
 import { normalizeHandoffCarrierLineage } from '../../handoff/carrierLineage.js';
 import { normalizeHandoffCarrierProfile } from '../../handoff/carrierProfile.js';
 
@@ -43,6 +43,15 @@ export async function prepareNodeWorkspaceCarrierManufacturingInput(input = {},
     explicitBindings: input.workspaceTargets || input.workspaceTargetBindings || [],
     additionalWorkspaceDescriptors
   });
+  const workspaceScopes = normalizeWorkspaceScopes(input.workspaceScopes || input.workspaceScopeBindings || []);
+  const materializations = enumerations.map((item) => {
+    const materialization = item.materialization;
+    const scope = workspaceScopes.get(String(materialization.id || '')) || null;
+    if (!scope || scope.coverage !== 'bounded') return materialization;
+    const targets = workspaceTargets.filter((target) => String(target.workspaceId || '') === String(materialization.id || ''));
+    if (targets.length !== 1) throw new Error(`portable.workspace-carrier.workspace-scope.target-${targets.length ? 'ambiguous' : 'required'}:${materialization.id}`);
+    return projectBoundedWorkspaceMaterialization(materialization, scope, targets[0].path);
+  });
   const toolingBootstrap = await buildToolingBootstrapTransportFiles({
     delivery: input.toolingBootstrap || input.bootstrapDelivery || 'embedded',
     runtimeRoot: input.runtimeRoot || options.runtimeRoot,
@@ -51,13 +60,14 @@ export async function prepareNodeWorkspaceCarrierManufacturingInput(input = {},
   });
   const runtimeSourceAlignment = await qualifyToolingRuntimeSourceAlignment({
     runtimeIdentity: toolingBootstrap.runtimeIdentity,
-    localWorkspaces: enumerations.map((item) => Object.freeze({ id: item.materialization.id, root: item.root, materialization: item.materialization })),
+    localWorkspaces: enumerations.map((item, index) => Object.freeze({ id: materializations[index].id, root: item.root, materialization: item.materialization })),
     maxFiles: input.bootstrapMaxFiles || options.bootstrapMaxFiles
   });
   return Object.freeze({
     carrierMode: 'workspace',
     createdAt: String(input.createdAt || ''),
-    workspaceMaterializations: Object.freeze(enumerations.map((item) => item.materialization)),
+    workspaceMaterializations: Object.freeze(materializations),
+    materialRepresentationWorkspaceIds: Object.freeze([...(input.materialRepresentationWorkspaceIds || input.genericMaterialWorkspaceIds || [])].map(String)),
     workspaceTargets,
     additionalTransportFiles: toolingBootstrap.files,
     carrierLineage: normalizeHandoffCarrierLineage(input.carrierLineage || null),

package/src/tooling/portable/bootstrap/tiinex.llm.bootstrap.md

@@ -18,9 +18,9 @@ The same workflow must survive different host arrangements:
 
 When this bootstrap or the portable repository is available as a project source, normalize only the explicitly uploaded Markdown, archive, and project-source material, then start with `discover-tooling` or `prepare-task`.
 
-### Qualified routed Handoff package
+### Qualified Tiinex package
 
-When a received carrier exposes the qualified recipient-facing Tiinex Handoff package surface, start at `001-1-READ-BEFORE-PROCEEDING.trace.md`. Before Tiinex Tooling is available, the host may perform only the bounded bootstrap exception: read the declared bootstrap node, extract `001-2-bootstrap.zip` into a writable runtime location, and make its Tooling entrypoint callable. Prefer a location that survives turns in the current runtime, but never treat that location as project or artifact authority. Do not manually unpack Workspace/cache payloads or perform broad ZIP/filesystem/repository archaeology. The Tooling entrypoint is exactly `runtime/tools/tiinex-portable.mjs` relative to the chosen extraction root; do not search/list the extracted runtime to discover it. Give the untouched original Handoff-package carrier to that entrypoint and use `orient-handoff-package` as the first semantic operation. Keep the outer Continue-from path opaque to native access. After orientation, use `ground <same-package.zip> --route <same-Continue-from>` as the one shared human/LLM decision-grounding path. Its bounded default receipt composes the selected Handoff authority, exact qualified Required Context identities, the selected-route declared-Parent leaf, a compact declared-Parent continuity-to-qualified-root proof, declared current-work frontier, blockers, and explicit unresolved evidence. Continue substantive bounded work only when `readiness.state` is `grounded-to-act`; `grounded-to-discuss` and `insufficient-grounding` must not be upgraded by generic inference. An apparent loaded root that still declares an unavailable Parent is not cold-start closure: follow `readiness.nextAction.recovery` exactly. If a bound exact repository-read host capability is available, use the projected `plan-host-action` request, normalize the host result through `accept-host-receipt`, then resume the same `ground` command with `--recovery <accepted-host-receipt.json>`; otherwise request exactly the named material from the Transport Operator. When an accepted pinned repository Parent declares a deterministic relative Parent, Tooling may derive only that exact sibling path from the accepted repository/commit/base-path context. For repeated recovery, call `accept-host-receipt --prior <previous-accepted.json>` so the newest accepted result explicitly carries all prior accepted recovery material; pass only that newest cumulative result back to the same `ground --recovery` seam. Never broaden search or treat fetched material as verified before lineage identity/integrity qualification. Re-run the same `ground` command with `--include-required-context <requirement-id,name|all>` only when exact qualified Required Context body text is needed. No external qualification schema, Tooling source inspection, `--help`/operation discovery, context-audit detour, or separate `ground-cold-consumer` call is required before this decision grounding. Native host tools remain valid execution mechanics after Tiinex takeover on already-resolved ordinary source, and explicit degraded fallback only when qualification explains why it was required.
+When a received carrier exposes the qualified recipient-facing Tiinex package surface, start at its declared Start artifact (normally `001-1-READ-BEFORE-PROCEEDING.trace.md`). Before Tiinex Tooling is available, the host may perform only the bounded bootstrap exception: read the declared bootstrap node, extract `001-2-bootstrap.zip` into a writable runtime location, and make its Tooling entrypoint callable. Prefer a location that survives turns in the current runtime, but never treat that location as project or artifact authority. Do not manually unpack Workspace/cache payloads or perform broad ZIP/filesystem/repository archaeology. The Tooling entrypoint is exactly `runtime/tools/tiinex-portable.mjs` relative to the chosen extraction root; do not search/list the extracted runtime to discover it. Give the untouched original package carrier to that entrypoint and use `orient-handoff-package` as the first semantic operation. Package role is qualified from the carried package contract rather than inferred from filenames, Workspace/Role presence, or transport labels. A bootstrap-only or pointerless Workspace carrier has no Handoff route and must not be upgraded into recipient, holder, participation, delegation, current-work, or grounded-to-act authority; use the qualified route-less orientation/material projection only. For a routed Handoff carrier, keep the outer Continue-from path opaque to native access and, after orientation, use `ground <same-package.zip> --route <same-Continue-from>` as the one shared human/LLM decision-grounding path. Its bounded default receipt composes the selected Handoff authority, exact qualified Required Context identities, the selected-route declared-Parent leaf, a compact declared-Parent continuity-to-qualified-root proof, declared current-work frontier, blockers, and explicit unresolved evidence. Continue substantive bounded work only when `readiness.state` is `grounded-to-act`; `grounded-to-discuss` and `insufficient-grounding` must not be upgraded by generic inference. An apparent loaded root that still declares an unavailable Parent is not cold-start closure: follow `readiness.nextAction.recovery` exactly. If a bound exact repository-read host capability is available, use the projected `plan-host-action` request, normalize the host result through `accept-host-receipt`, then resume the same `ground` command with `--recovery <accepted-host-receipt.json>`; otherwise request exactly the named material from the Transport Operator. When an accepted pinned repository Parent declares a deterministic relative Parent, Tooling may derive only that exact sibling path from the accepted repository/commit/base-path context. For repeated recovery, call `accept-host-receipt --prior <previous-accepted.json>` so the newest accepted result explicitly carries all prior accepted recovery material; pass only that newest cumulative result back to the same `ground --recovery` seam. Never broaden search or treat fetched material as verified before lineage identity/integrity qualification. Re-run the same `ground` command with `--include-required-context <requirement-id,name|all>` only when exact qualified Required Context body text is needed. No external qualification schema, Tooling source inspection, `--help`/operation discovery, context-audit detour, or separate `ground-cold-consumer` call is required before this decision grounding. Native host tools remain valid execution mechanics after Tiinex takeover on already-resolved ordinary source, and explicit degraded fallback only when qualification explains why it was required.
 
 ### Bootstrap travels inside an archive
 

package/src/tooling/portable/handoff/bootstrapCarrier.manufacture.js

@@ -0,0 +1,56 @@
+import { finalizeFile } from '../../../export/package.fileMap.js';
+import { summarizePortableFindings } from '../findings.js';
+import { inspectPortableToolingBootstrap } from './toolingBootstrap.js';
+import { renderRecipientV2Pointer } from './recipientV2.artifacts.js';
+import { RECIPIENT_V2_READ_PATH, RECIPIENT_V2_FORMAT_ID } from './recipientV2.topology.js';
+import { recipientV2BootstrapEntryCurrentRead } from './recipientV2.entryContract.js';
+import { recipientV2TransportFacts } from './recipientV2.transportManifest.js';
+import { buildRecipientV2BootstrapCarrier, recipientV2ParentAuthority } from './recipientV2.topology.workspaces.js';
+import { RECIPIENT_V2_PACKAGE_V1_ROOT_PATH, RECIPIENT_V2_PACKAGE_V1_SCHEMA_ID, RECIPIENT_V2_PACKAGE_V1_SCHEMA_TARGET } from './recipientV2.packageV1.constants.js';
+import { BOOTSTRAP_PACKAGE_ROLE, renderHandoffPackageV1 } from './recipientV2.packageV1.contract.js';
+import { deepFreeze } from './recipientV2.packageV1.shared.js';
+import { inspectRecipientFacingV2Topology, roundTripRecipientFacingV2Topology } from './recipientV2.inspect.js';
+
+export function manufactureRecipientRelativeBootstrapPackage(input = {}) {
+  const findings = [];
+  const createdAt = String(input.createdAt || '1970-01-01 00:00:00');
+  const bootstrapSource = (input.additionalTransportFiles || []).filter((file) => String(file.path || '').startsWith('tiinex.bootstrap/'));
+  const sourceInspection = inspectPortableToolingBootstrap({ files: bootstrapSource });
+  if (sourceInspection.status !== 'valid') findings.push(...(sourceInspection.findings || []));
+  if (!bootstrapSource.length) findings.push(Object.freeze({ severity: 'error', code: 'portable.bootstrap-carrier.bootstrap-missing', message: 'Bootstrap-only carrier requires one qualified portable Tooling bootstrap source.' }));
+  const packageFile = finalizeFile({
+    path: RECIPIENT_V2_PACKAGE_V1_ROOT_PATH,
+    kind: 'tiinex-handoff-package-artifact', logicalKind: 'recipient-v2-package-v1-root', mediaType: 'text/markdown',
+    content: renderHandoffPackageV1({ createdAt, packageRole: BOOTSTRAP_PACKAGE_ROLE, workspaces: [], materialRepresentations: [], carrierLineage: input.carrierLineage || {}, carrierProfile: input.carrierProfile || null, startPath: RECIPIENT_V2_READ_PATH, bootstrapPath: '001-2-bootstrap.trace.md' })
+  });
+  const packageParent = recipientV2ParentAuthority(packageFile, RECIPIENT_V2_PACKAGE_V1_SCHEMA_ID, RECIPIENT_V2_PACKAGE_V1_SCHEMA_TARGET, createdAt);
+  const files = [packageFile];
+  const bootstrap = bootstrapSource.length ? buildRecipientV2BootstrapCarrier(bootstrapSource, createdAt, findings, packageParent) : null;
+  if (bootstrap) files.push(bootstrap.artifact, bootstrap.payload);
+  const readFacts = recipientV2TransportFacts('recovery-orientation', {
+    format: 'tiinex-recipient-facing-handoff-package-v1', packageRole: BOOTSTRAP_PACKAGE_ROLE,
+    packageRootPath: RECIPIENT_V2_PACKAGE_V1_ROOT_PATH, entryArtifactPath: RECIPIENT_V2_READ_PATH,
+    artifactSurface: 'tiinex.handoff.package.v1-plus-qualified-bootstrap-only', routeAuthority: 'none', routeSelectionAuthority: 'none', siblingRouteInference: false,
+    carrierLineage: input.carrierLineage || null, pathParentProjection: true, pathAuthority: false
+  });
+  const readFile = finalizeFile({
+    path: RECIPIENT_V2_READ_PATH, kind: 'handoff-recovery-pointer', logicalKind: 'recipient-v2-package-v1-bootstrap-recovery-orientation', mediaType: 'text/markdown', transportFacts: readFacts,
+    content: renderRecipientV2Pointer({ createdAt, parent: packageParent, role: 'recovery-orientation', title: 'READ BEFORE PROCEEDING — Tiinex Bootstrap Carrier', summary: 'Qualified recovery/orientation Pointer for a bootstrap-only package-v1 carrier.', prose: 'Read this Start artifact first and qualify the declared Tooling bootstrap. This carrier intentionally contains no project/source Workspace material and no Handoff route. Do not infer recipient, holder, Role, current-work, participation, delegation, or grounded-to-act authority from transport.', currentRead: [...recipientV2BootstrapEntryCurrentRead(), { label: 'Package Artifact', value: `[Bootstrap Package](${RECIPIENT_V2_PACKAGE_V1_ROOT_PATH})` }, { label: 'Carrier Dimension', value: `\`${String(input.carrierLineage?.dimension || '001')}\`` }], destinations: [{ label: 'Bootstrap Package contract', target: RECIPIENT_V2_PACKAGE_V1_ROOT_PATH }, ...(bootstrap ? [{ label: 'Portable Tooling bootstrap', target: bootstrap.projection.artifactPath }] : [])], facts: readFacts })
+  });
+  files.push(readFile);
+  const sortedFiles = Object.freeze([...files].sort((a, b) => String(a.path || '').localeCompare(String(b.path || ''))));
+  const bundle = deepFreeze({ status: 'ready', files: sortedFiles, handoffClosure: null, transportFormat: RECIPIENT_V2_FORMAT_ID, boundary: 'Bootstrap-only recipient carrier. Start/bootstrap qualification creates no Workspace, Role, Handoff, recipient, holder, work, or action authority.' });
+  const inspection = inspectRecipientFacingV2Topology(bundle);
+  const roundtrip = input.verifyRoundtrip === false ? null : roundTripRecipientFacingV2Topology(bundle, inspection);
+  const toolingBootstrapInspection = inspection.bootstrapInspection || sourceInspection;
+  const allFindings = [...findings, ...(inspection.findings || []), ...(roundtrip?.findings || [])];
+  const ready = inspection.status === 'valid' && inspection.carrierProjection?.mode === 'bootstrap' && inspection.carrierProjection?.status === 'ready' && (!roundtrip || roundtrip.status === 'passed') && toolingBootstrapInspection.status === 'valid' && !allFindings.some((item) => item.severity === 'error');
+  return deepFreeze({
+    schema: 'tiinex.portable.handoff-manufacturing.v2', status: ready ? 'ready' : 'blocked', executable: ready, transportExecutable: ready,
+    verification: Object.freeze({ baselineManufacture: 'ready', manufacturePath: 'qualified-bootstrap-to-zero-material-package-v1', packageInspection: inspection.status, closureInspection: 'not-applicable', carrierInspection: inspection.status, selectedHandoffConformance: 'not-applicable', pointerEntrypointInspection: 'not-applicable', coldConsumerEntrypointInspection: inspection.status, companionInspection: 'not-applicable', roundtrip: roundtrip?.status || 'not-requested', toolingBootstrap: toolingBootstrapInspection.status }),
+    plan: Object.freeze({ status: ready ? 'ready' : 'blocked', requiredClosureReady: true, semanticHandoffStatus: 'not-declared', workspaceMaterializations: Object.freeze([]), requirements: Object.freeze({ required: Object.freeze([]), reference: Object.freeze([]) }) }),
+    bundle, inspection, carrierProjection: inspection.carrierProjection, roundtrip, toolingBootstrapInspection, toolingBootstrap: input.toolingBootstrap || null, carrierLineage: input.carrierLineage || inspection.carrierProjection?.lineage || null, manufacturingEvidence: input.manufacturingEvidence || null,
+    findings: Object.freeze(allFindings), findingSummary: summarizePortableFindings(allFindings), operationBoundary: Object.freeze({ sourceMutation: false, remoteWrite: false, handoffSemantics: false, recipientAuthority: false, holderAuthority: false, workAuthority: false }),
+    boundary: 'Canonical bootstrap-only carrier manufacture. Qualified Start/bootstrap mechanics only; no project/source material or Handoff/Role/recipient/holder/work authority is created.'
+  });
+}