@tiinex/app 0.1.1

package/src/tooling/portable/grounding/grounding.semanticIntegration.case.mjs

@@ -0,0 +1,131 @@
+import assert from 'node:assert/strict';
+import { projectGroundingCapsule } from '@tiinex/core/tooling/portable/grounding/grounding.capsule.js';
+import { projectParticipantAuthority } from '@tiinex/core/tooling/portable/grounding/grounding.participantAuthority.js';
+import { projectWorkProvenance } from '@tiinex/core/tooling/portable/grounding/grounding.workProvenance.js';
+
+const sourcePath = 'orchard/.work/current.task.trace.md';
+const childPath = 'orchard/.work/current-child.task.trace.md';
+const targetA = 'charter/.plans/outcome-a.task.trace.md';
+const targetB = 'charter/.plans/outcome-b.task.trace.md';
+const projectA = 'charter/.plans/project-a.trace.md';
+const projectB = 'charter/.plans/project-b.trace.md';
+const records = [
+  record(sourcePath, 'neutral.task.v1', 'Current execution work', '# Current execution work'),
+  contextChild(targetA, 'Outcome A', './project-a.trace.md'),
+  contextChild(targetB, 'Outcome B', './project-b.trace.md'),
+  contextOwner(projectA, 'Project A', 'Organization Alpha'),
+  contextOwner(projectB, 'Project B', 'Organization Beta'),
+  relation('orchard/.work/edge-a.relation.trace.md', 'advances', './current.task.trace.md', 'charter::.plans/outcome-a.task.trace.md'),
+  relation('orchard/.work/edge-b.relation.trace.md', 'commissioned by', './current.task.trace.md', 'charter::.plans/outcome-b.task.trace.md'),
+  record('orchard/.work/prose-only.trace.md', 'neutral.note.v1', 'Prose only', '# Note\n\n- Parent: charter::.plans/outcome-a.task.trace.md\n- Summary: work-provenance maybe\n')
+];
+
+const projection = projectWorkProvenance({ records, topology: { currentFrontier: [{ path: sourcePath }], relevantPaths: [sourcePath] } });
+assert.equal(projection.state, 'qualified');
+assert.equal(projection.current.edges.length, 2, 'multiple qualified upstream edges must be preserved without electing one controller');
+assert.deepEqual(projection.current.edges.map((edge) => edge.relationType).sort(), ['advances', 'commissioned by']);
+assert.equal(projection.current.edges[0].relationFamily, 'work-provenance');
+assert.equal(projection.current.edges[0].source.resolvedPath, sourcePath);
+assert.equal(projection.current.edges[0].target.state, 'qualified-carried');
+assert.equal(projection.current.edges[0].context.project.state, 'qualified-carried');
+assert.equal(projection.current.edges[0].context.organization.state, 'qualified-carried');
+assert.equal(projection.current.edges[0].context.project.membershipClaim, false);
+assert.equal(projection.reverseDiscovery.length, 2, 'reverse discovery must project the same edges without inverse artifacts');
+assert.equal(projection.edges.length, 2, 'prose/Parent adjacency must not synthesize work provenance');
+assert.equal(projection.unresolved.length, 0);
+
+const lineageRelevant = projectWorkProvenance({
+  records: [...records, record(childPath, 'neutral.task.v1', 'Current descendant', '# Current descendant')],
+  topology: { currentFrontier: [{ path: childPath }], relevantPaths: [sourcePath, childPath] }
+});
+assert.equal(lineageRelevant.state, 'qualified-relevant');
+assert.equal(lineageRelevant.current.state, 'qualified-via-selected-lineage');
+assert.equal(lineageRelevant.current.edges.length, 2);
+assert.equal(lineageRelevant.current.edges[0].source.resolvedPath, sourcePath, 'selected Parent lineage may make an existing relation relevant but must never rewrite its declared source to the descendant frontier');
+assert.equal(lineageRelevant.reverseDiscovery.length, 2, 'lineage relevance must still use the same reverse-projected edges');
+
+const unresolvedTarget = projectWorkProvenance({
+  records: [record(sourcePath, 'neutral.task.v1', 'Current execution work', '# Current execution work'), relation('orchard/.work/edge-missing.relation.trace.md', 'implements', './current.task.trace.md', 'charter::.plans/not-carried.task.trace.md')],
+  topology: { currentFrontier: [{ path: sourcePath }], relevantPaths: [sourcePath] }
+});
+assert.equal(unresolvedTarget.state, 'unresolved');
+assert.equal(unresolvedTarget.edges[0].state, 'unresolved');
+assert.equal(unresolvedTarget.edges[0].target.state, 'not-carried');
+assert.equal(unresolvedTarget.unresolved[0].slot, 'organizational-work-provenance');
+
+
+const contextUnresolvedTargetPath = 'charter/.plans/context-unresolved.task.trace.md';
+const contextUnresolved = projectWorkProvenance({
+  records: [
+    record(sourcePath, 'neutral.task.v1', 'Current execution work', '# Current execution work'),
+    record(contextUnresolvedTargetPath, 'neutral.outcome.v1', 'Context-unresolved outcome', '# Context-unresolved outcome'),
+    relation('orchard/.work/edge-context-unresolved.relation.trace.md', 'advances', './current.task.trace.md', 'charter::.plans/context-unresolved.task.trace.md')
+  ],
+  topology: { currentFrontier: [{ path: sourcePath }], relevantPaths: [sourcePath] }
+});
+assert.equal(contextUnresolved.state, 'qualified', 'qualified typed provenance must remain qualified even when project/organization context is explicitly unresolved');
+assert.equal(contextUnresolved.context.state, 'unresolved');
+assert.equal(contextUnresolved.unresolved.some((item) => item.slot === 'project-context'), true);
+assert.equal(contextUnresolved.unresolved.some((item) => item.slot === 'organization-context'), true);
+
+const authority = projectParticipantAuthority({
+  handoff: { to: 'Courier' },
+  role: {
+    state: 'qualified', endpoint: { label: 'Courier', kind: 'role' },
+    material: { artifact: { path: 'charter/.roles/courier.role.trace.md', schemaId: 'tiinex.party.role.v1', roleLabel: 'Courier' } },
+    authorityBoundaryLoaded: { mayDo: 'Carry and review bounded work.', doesNotAuthorize: 'Does not approve release by identity alone.', reviewBoundary: 'Explicit project instrument required for acceptance.' },
+    interpretationLimitsLoaded: { doesNotProve: 'Holder identity or consent.', mustNotBeTreatedAs: 'Automatic acceptance.' }
+  },
+  holderBinding: { state: 'qualified', roleLabel: 'Courier', source: 'explicit-input', explicit: true, inferredFromTransport: false }
+});
+assert.equal(authority.state, 'qualified-declared-basis');
+assert.match(authority.authorityBoundary.mayDo, /Carry and review/);
+assert.equal(authority.participantIdentityCreatesAuthority, false);
+assert.equal(authority.conversationPositionCreatesAuthority, false);
+assert.equal(authority.universalHumanFeedbackRule, false, 'generic Tooling must not impose a universal human-input-as-feedback rule');
+assert.equal(projectParticipantAuthority({ role: { state: 'qualified', endpoint: { label: 'Courier' } } }).state, 'unresolved');
+for (const label of ['Coordinator', 'Specialist', 'Human Carrier']) {
+  const blank = projectParticipantAuthority({ handoff: { to: label }, role: { state: 'qualified', endpoint: { label } } });
+  assert.equal(blank.state, 'unresolved', `${label} label/identity must not create generic authority without explicit qualified Role material`);
+  assert.equal(blank.universalHumanFeedbackRule, false);
+}
+
+const capsule = projectGroundingCapsule({
+  authority: {
+    selectedRoute: { workspaceId: 'orchard', workspaceRelativeHandoffPath: '.work/handoff.trace.md' },
+    handoff: { to: 'Courier' }, role: {
+      state: 'qualified', endpoint: { label: 'Courier', kind: 'role' },
+      material: { artifact: { path: 'charter/.roles/courier.role.trace.md', schemaId: 'tiinex.party.role.v1', roleLabel: 'Courier' } },
+      authorityBoundaryLoaded: { mayDo: 'Carry and review bounded work.', doesNotAuthorize: 'Does not approve release by identity alone.', reviewBoundary: 'Explicit project instrument required.' }
+    },
+    holderBinding: { state: 'qualified', roleLabel: 'Courier', recipientCompatibility: 'matched', source: 'explicit-input', explicit: true }
+  },
+  records: [...records, { id: 'orchard/.work/handoff.trace.md', path: 'orchard/.work/handoff.trace.md', schemaId: 'neutral.handoff.v1', markdown: '# Handoff' }],
+  topology: { currentFrontier: [{ path: sourcePath, declaredStatus: 'ready/local', objective: 'Advance both declared outcomes.' }], relevantPaths: [sourcePath] }
+});
+assert.equal(capsule.workProvenance.state, 'qualified');
+assert.equal(capsule.workProvenance.current.edges.length, 2);
+assert.equal(capsule.workProvenance.context.state, 'qualified');
+assert.equal(capsule.participantAuthority.state, 'qualified-declared-basis');
+assert.equal(capsule.unresolved.some((item) => item.slot === 'organizational-work-provenance'), false, 'qualified current provenance must replace the old unconditional unresolved slot');
+
+console.log('✓ grounding semantic integration: typed work provenance, selected-lineage relevance, explicit target context, reverse discovery, unresolved targets, and declared participant authority remain generic and fail-visible');
+
+function contextChild(path, title, parentTrace) {
+  const markdown = `# Continuity Context\n\n- Envelope Schema: neutral.root.v1\n- Parent\n  - Parent Schema: neutral.project.v1\n  - Created At: 2026-09-05 00:00:00\n  - Trace: [Parent](${parentTrace})\n- Current\n  - Current Schema: neutral.outcome.v1\n  - Created At: 2026-09-05 00:01:00\n  - Summary: ${title}\n\n---\n\n# ${title}\n\n## Objective\n\nRemain a neutral relation target.\n\n---\n\n# Continuity Integrity\n\n- fixture\n`;
+  return record(path, 'neutral.outcome.v1', title, markdown);
+}
+
+function contextOwner(path, project, organization) {
+  const markdown = `# Continuity Context\n\n- Envelope Schema: neutral.root.v1\n- Current\n  - Current Schema: neutral.project.v1\n  - Created At: 2026-09-05 00:00:00\n  - Summary: ${project}\n\n---\n\n# ${project}\n\n## Project Identity\n\n- Name: ${project}\n- Description: Explicit project context for neutral fixture work.\n- Boundary: Does not imply organization membership by Parent alone.\n\n## Organization Context\n\n- Name: ${organization}\n- Description: Explicit organization context carried by the qualified target context.\n- Boundary: This declaration, not naming or folder placement, is the qualification basis.\n\n---\n\n# Continuity Integrity\n\n- fixture\n`;
+  return record(path, 'neutral.project.v1', project, markdown);
+}
+
+function relation(path, type, source, target) {
+  const markdown = `# Continuity Context\n\n- Envelope Schema: tiinex.root.v1\n- Current\n  - Current Schema: tiinex.relation.v1\n  - Created At: 2026-09-05 00:00:00\n  - Summary: Neutral typed relation.\n\n---\n\n# Neutral Work Relation\n\n## Relation Declaration\n\n- Relation Type: ${type}\n- Relation Direction: execution work -> controlling work\n- Relation Scope: work-level provenance\n- Relation Family: work-provenance\n\n## Relation Source\n\n- Source: [Execution work](${source})\n\n## Relation Target\n\n- Target: [Controlling work](${target})\n\n## Relation Boundary\n\n- The relation target is not Parent.\n\n---\n\n# Continuity Integrity\n\n- sha256-base64url-c14n-v2\n  - Towards: self\n  - Value: fixture\n`;
+  return record(path, 'tiinex.relation.v1', 'Neutral Work Relation', markdown);
+}
+
+function record(path, schemaId, title, markdown) {
+  return { id: path, path, schemaId, title, summary: `${title} summary`, markdown, hasContinuityContext: true, hasIntegrity: true };
+}

package/src/tooling/portable/handoff/boundedWorkspaceRepresentation.case.mjs

@@ -0,0 +1,103 @@
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { prepareNodeHandoffManufacturingInput } from '@tiinex/core/tooling/portable/adapters/node/handoff.manufacture.js';
+import { manufactureRecipientRelativeHandoffPackage } from '@tiinex/core/tooling/portable/handoff/manufacture.js';
+import { qualifiedHandoffFixture } from '@tiinex/core/tooling/portable/handoff/qualifiedHandoffFixture.js';
+import { sealC14nV2Self, validatedC14nV2PrimarySelfDigest } from '@tiinex/core/integrity/integrity.c14nV2.js';
+import { C14N_V2_VALIDATOR_TARGET } from '@tiinex/core/integrity/integrity.methodReference.js';
+import { inspectRecipientFacingV2Topology } from '@tiinex/core/tooling/portable/handoff/recipientV2.inspect.js';
+import { inspectStoredWorkspaceArchive } from '@tiinex/core/tooling/portable/handoff/workspaceByteProvider.js';
+import { packageFileBytes } from '@tiinex/core/export/package.bytes.js';
+import { parseRecipientV2Relation } from '@tiinex/core/tooling/portable/handoff/recipientV2.artifacts.js';
+
+const root = await mkdtemp(path.join(os.tmpdir(), 'tiinex-bounded-workspace-'));
+try {
+  const workspaceRoot = path.join(root, 'site');
+  const runtimeRoot = path.join(root, 'runtime');
+  await mkdir(path.join(workspaceRoot, '.topics'), { recursive: true });
+  await writeFile(path.join(workspaceRoot, 'workspace.workspace.md'), workspaceMarkdown(), 'utf8');
+  const parentMarkdown = await readFile(new URL('../fixtures/legacy-artifacts/tooling/dogfood/001-site-tooling-v471-portable-lineage-authoring-closure.trace.fixture.txt', import.meta.url), 'utf8');
+  const parentDigest = validatedC14nV2PrimarySelfDigest(parentMarkdown);
+  assert.equal(parentDigest.state, 'verified');
+  await writeFile(path.join(workspaceRoot, '.topics', 'parent.trace.md'), parentMarkdown, 'utf8');
+  await writeFile(path.join(workspaceRoot, '.topics', 'handoff.trace.md'), qualifiedHandoffFixture({
+    title: 'Bounded Workspace Representation fixture',
+    to: 'Loom',
+    purpose: 'prove bounded entry-set carriage plus detached Parent recovery',
+    createdAt: '2026-08-31 03:00:00',
+    parent: { trace: 'parent.trace.md', relative: 'parent.trace.md', towards: 'parent.trace.md', targetValue: parentDigest.value, includeBrowseGit: false }
+  }), 'utf8');
+  await writeFile(path.join(workspaceRoot, 'omitted.txt'), 'outside bounded representation\n', 'utf8');
+  await makeRuntime(runtimeRoot);
+
+  const input = await prepareNodeHandoffManufacturingInput({
+    workspaceRoot,
+    workspaceId: 'site-bounded',
+    workspaceTitle: 'Site bounded fixture',
+    workspaceTargetPath: 'workspace.workspace.md',
+    handoffPath: '.topics/handoff.trace.md',
+    workspaceScopes: [{ workspaceId: 'site-bounded', coverage: 'bounded', include: ['.topics/handoff.trace.md'] }],
+    toolingBootstrap: 'embedded',
+    runtimeRoot,
+    verifyRoundtrip: true,
+    carrierLineage: { mode: 'continue', dimension: '001-1', parentDimension: '001', checkpointKind: 'progression' }
+  });
+  assert.equal(input.workspaceMaterializations[0].state, 'bounded');
+  assert.equal(input.workspaceMaterializations[0].scopeEvidence.state, 'qualified');
+  assert.deepEqual(input.workspaceMaterializations[0].includedEntries.map((entry) => entry.path), ['.topics/handoff.trace.md', 'workspace.workspace.md']);
+  assert(input.requirements.dependencies.some((item) => item.classification === 'parent-boundary' && item.targetPath === '.topics/parent.trace.md'));
+
+  const built = manufactureRecipientRelativeHandoffPackage(input, { verifyRoundtrip: true, packageInput: { builtAt: '2026-08-31T01:00:00.000Z' } });
+  assert.equal(built.status, 'ready', JSON.stringify(built.findings, null, 2));
+  const binding = built.descriptor.workspaceArchiveBindings[0];
+  assert.equal(binding.coverage, 'bounded');
+  assert.equal(binding.representation.kind, 'bounded-workspace-snapshot');
+  assert.equal(binding.scope.state, 'qualified');
+  assert.equal(binding.selection.rule, 'explicit-binding-per-bounded-scope');
+  assert.equal(binding.entryMap.count, 2);
+  assert.equal(binding.entryMap.entries.some((entry) => entry.path === '.topics/parent.trace.md'), false, 'detached Parent must not enter bounded representation scope');
+  assert.equal(binding.entryMap.entries.some((entry) => entry.path === 'omitted.txt'), false, 'ordinary omitted source bytes must remain outside bounded representation');
+
+  const archiveFile = built.bundle.files.find((file) => String(file.path || '') === '001-2-workspace.zip');
+  const archive = inspectStoredWorkspaceArchive(packageFileBytes(archiveFile));
+  assert.equal(archive.state, 'qualified');
+  assert.deepEqual(archive.entries.map((entry) => entry.path), ['.topics/handoff.trace.md', 'workspace.workspace.md']);
+
+  const payloadFile = built.bundle.files.find((file) => String(file.path || '') === '001-2-workspace-payload.trace.md');
+  assert.match(new TextDecoder().decode(packageFileBytes(payloadFile)), /Payload Role: bounded Workspace archive representation payload/);
+  const relationFile = built.bundle.files.find((file) => String(file.path || '') === '001-3-workspace-representation-relation.trace.md');
+  const parsedRelation = parseRecipientV2Relation(new TextDecoder().decode(packageFileBytes(relationFile)));
+  assert.equal(parsedRelation.scope, 'bounded recipient-relative workspace materialization');
+
+  const inspection = inspectRecipientFacingV2Topology(built.bundle);
+  assert.equal(inspection.status, 'valid', JSON.stringify(inspection.findings, null, 2));
+  assert.equal(inspection.phase1?.coverage, 'bounded');
+  assert.equal(inspection.phase1?.workspaceTargetQualification?.state, 'qualified');
+  assert.equal(inspection.phase1?.carrierProjection?.routes?.[0]?.state, 'qualified');
+  assert.equal(inspection.phase1?.caches?.length, 1, 'detached Parent recovery should reuse the Workspace-scoped cache channel');
+
+  console.log('✓ bounded Workspace Representation keeps exact scope distinct from detached Parent recovery and preserves recipient qualification');
+} finally {
+  await rm(root, { recursive: true, force: true });
+}
+
+function workspaceMarkdown() {
+  const unsigned = `# Continuity Context\n\n- Envelope Schema: tiinex.root.v1\n- Current\n  - Current Schema: tiinex.workspace.v1\n  - Created At: 2026-08-31 02:59:00\n  - Authors: Fixture\n  - Why: Qualify the bounded Workspace Representation fixture.\n  - Summary: Bounded Workspace Representation fixture Workspace.\n  - Status: active/local\n\n---\n\n# Bounded Workspace\n\nExact bounded representation fixture.\n\n# Continuity Integrity\n\n- [sha256-base64url-c14n-v2](${C14N_V2_VALIDATOR_TARGET})\n  - Towards: self\n  - Value: `;
+  const sealed = sealC14nV2Self(unsigned);
+  assert.equal(sealed.state, 'sealed');
+  return `${sealed.markdown}\n`;
+}
+
+async function makeRuntime(rootPath) {
+  await mkdir(path.join(rootPath, 'tools'), { recursive: true });
+  await mkdir(path.join(rootPath, 'src', 'tooling', 'portable', 'bootstrap'), { recursive: true });
+  await mkdir(path.join(rootPath, 'src', 'tooling', 'portable', 'schema', 'bootstrap', 'tiinex.root.v1'), { recursive: true });
+  await writeFile(path.join(rootPath, 'tools', 'tiinex-portable.mjs'), "import '../src/runtime.js';\n", 'utf8');
+  await writeFile(path.join(rootPath, 'src', 'runtime.js'), "export const runtime = 'fixture';\n", 'utf8');
+  await writeFile(path.join(rootPath, 'package.json'), '{"type":"module"}\n', 'utf8');
+  await writeFile(path.join(rootPath, 'src', 'tooling', 'portable', 'bootstrap', 'tiinex.llm.bootstrap.md'), '# Portable bootstrap fixture\n', 'utf8');
+  await writeFile(path.join(rootPath, 'src', 'tooling', 'portable', 'bootstrap', 'tiinex.llm.bootstrap.pointer.json'), '{"schema":"fixture"}\n', 'utf8');
+  await writeFile(path.join(rootPath, 'src', 'tooling', 'portable', 'schema', 'bootstrap', 'tiinex.root.v1', 'schema.md'), '# Canonical schema material fixture\n', 'utf8');
+}

package/src/tooling/portable/handoff/carrierLineage.fixedWidth.case.mjs

@@ -0,0 +1,97 @@
+import assert from 'node:assert/strict';
+import { finalizeFile } from '@tiinex/core/export/package.fileMap.js';
+import { prepareHandoffManufactureCliCommand } from '@tiinex/core/tooling/portable/adapters/cli/cli.handoff-manufacture.js';
+import { advanceHandoffCarrierMajor, continueHandoffCarrierLineage, initialHandoffCarrierLineage, parentHandoffCarrierLineageFromBundle, qualifyMajorCarrierReadiness } from '@tiinex/core/tooling/portable/handoff/carrierLineage.js';
+import { renderHandoffPackageV1 } from '@tiinex/core/tooling/portable/handoff/recipientV2.packageV1.contract.js';
+import { buildRecipientV2TransportManifestFile, recipientV2TransportFacts } from '@tiinex/core/tooling/portable/handoff/recipientV2.transportManifest.js';
+
+const initial = initialHandoffCarrierLineage();
+assert.equal(initial.dimension, '001');
+assert.equal(initial.major, '001');
+
+const child = continueHandoffCarrierLineage({ ...initial, packageSha256: 'a'.repeat(64), packageFilename: '001-parent.zip' });
+assert.equal(child.dimension, '001-1');
+assert.equal(child.major, '001');
+assert.equal(child.parentDimension, '001');
+
+const grandchild = continueHandoffCarrierLineage({ ...child, packageSha256: 'b'.repeat(64), packageFilename: '001-1-parent.zip' });
+assert.equal(grandchild.dimension, '001-1-1');
+assert.equal(grandchild.major, '001');
+
+assert.throws(() => continueHandoffCarrierLineage({ dimension: '004-x' }), /portable\.handoff-carrier-lineage\.parent\.unresolved/, 'explicit malformed parent dimensions must fail closed rather than collapse to a fresh root');
+assert.throws(() => advanceHandoffCarrierMajor({ dimension: '004--1' }, 'checkpoint'), /portable\.handoff-carrier-lineage\.parent\.unresolved/, 'malformed major parent dimensions must fail closed');
+assert.throws(() => advanceHandoffCarrierMajor(grandchild, ''), /portable\.handoff-carrier-lineage\.major-reason\.required/, 'major advancement requires an explicit closure reason');
+assert.throws(() => advanceHandoffCarrierMajor({ dimension: '999' }, 'overflow checkpoint'), /portable\.handoff-carrier-lineage\.major\.invalid/, 'major progression must remain inside the fixed-width major domain');
+await assert.rejects(
+  () => prepareHandoffManufactureCliCommand({ positionals: ['.'], flags: { 'package-major': true } }),
+  /portable\.cli\.handoff-carrier\.package-major\.parent-required/,
+  'manufacture must reject major advancement without an exact package parent'
+);
+
+const major = advanceHandoffCarrierMajor({ ...grandchild, packageSha256: 'c'.repeat(64), packageFilename: '001-1-1-parent.zip' }, 'stabilization checkpoint');
+assert.equal(major.dimension, '002');
+assert.equal(major.major, '002');
+assert.equal(major.parentDimension, '001-1-1');
+
+const neutralProfile = { id: 'neutral-foundation', requiredMajorWorkspaceIds: ['alpha', 'beta', 'gamma'] };
+const progressionReadiness = qualifyMajorCarrierReadiness({ carrierProfile: neutralProfile, workspaceMaterializations: [] }, grandchild);
+assert.equal(progressionReadiness.state, 'not-applicable');
+assert.deepEqual(progressionReadiness.requiredWorkspaceIds, ['alpha', 'beta', 'gamma']);
+const unresolvedMajor = qualifyMajorCarrierReadiness({ workspaceMaterializations: [
+  { id: 'alpha', state: 'complete', completenessEvidence: { state: 'qualified' } }
+] }, major);
+assert.equal(unresolvedMajor.state, 'qualified');
+assert.equal(unresolvedMajor.reason, 'major-carrier-has-complete-carried-workspaces-without-named-profile-requirements');
+const incompleteMajor = qualifyMajorCarrierReadiness({ carrierProfile: neutralProfile, workspaceMaterializations: [
+  { id: 'alpha', state: 'complete', completenessEvidence: { state: 'qualified' } },
+  { id: 'beta', state: 'complete', completenessEvidence: { state: 'qualified' } }
+] }, major);
+assert.equal(incompleteMajor.state, 'blocked');
+assert.deepEqual(incompleteMajor.missingWorkspaceIds, ['gamma']);
+const completeMajor = qualifyMajorCarrierReadiness({ carrierProfile: neutralProfile, workspaceMaterializations: [
+  { id: 'alpha', state: 'complete', completenessEvidence: { state: 'qualified' } },
+  { id: 'beta', state: 'complete', completenessEvidence: { state: 'qualified' } },
+  { id: 'gamma', state: 'complete', completenessEvidence: { state: 'qualified' } }
+] }, major);
+assert.equal(completeMajor.state, 'qualified');
+assert.equal(completeMajor.profile.id, 'neutral-foundation');
+
+const rootPath = '001-package.trace.md';
+const root = finalizeFile({
+  path: rootPath,
+  kind: 'handoff-package-lineage-root',
+  mediaType: 'text/markdown',
+  content: '# placeholder\n',
+  transportFacts: recipientV2TransportFacts('package-root', { carrierLineage: grandchild, packageRootPath: rootPath, entryArtifactPath: '001-1-READ-BEFORE-PROCEEDING.trace.md', format: 'tiinex-recipient-facing-handoff-v2-flat' })
+});
+const manifest = buildRecipientV2TransportManifestFile([root], { format: 'tiinex-recipient-facing-handoff-v2-flat', packageRootPath: rootPath, entryArtifactPath: '001-1-READ-BEFORE-PROCEEDING.trace.md' });
+const recovered = parentHandoffCarrierLineageFromBundle({ files: [root, manifest] }, { packageSha256: 'd'.repeat(64), packageFilename: '001-1-1-carrier.zip' });
+assert.equal(recovered.dimension, '001-1-1');
+assert.equal(recovered.major, '001');
+assert.equal(continueHandoffCarrierLineage(recovered).dimension, '001-1-1-1');
+assert.equal(advanceHandoffCarrierMajor(recovered, 'next fixed-width checkpoint').dimension, '002');
+
+const packageV1Root = finalizeFile({
+  path: '001-tiinex-handoff-package.trace.md',
+  kind: 'handoff-package-v1-root',
+  mediaType: 'text/markdown',
+  content: renderHandoffPackageV1({
+    createdAt: '2026-09-01 15:51:48',
+    carrierLineage: { mode: 'continue', dimension: '002-1', parentDimension: '002', checkpointKind: 'progression' },
+    workspaces: [{
+      workspaceId: 'site',
+      workspacePath: '001-5-site.workspace.md',
+      archivePath: '001-5-site.workspace.zip',
+      sourceWorkspaceTargetInnerPath: '.topics/.workspaces/tiinex-site.workspace.md',
+      archiveSha256: 'e'.repeat(64),
+      archiveBytes: 123
+    }]
+  })
+});
+const recoveredPackageV1 = parentHandoffCarrierLineageFromBundle({ files: [packageV1Root] });
+assert.equal(recoveredPackageV1.dimension, '002-1');
+assert.equal(recoveredPackageV1.parentDimension, '002');
+assert.equal(recoveredPackageV1.checkpointKind, 'progression');
+assert.equal(continueHandoffCarrierLineage(recoveredPackageV1).dimension, '002-1-1');
+
+console.log('✓ carrier lineage fixed-width regression: 001 is preserved through continuation and explicit major advancement');

package/src/tooling/portable/handoff/coldStartQualification.case.mjs

@@ -0,0 +1,293 @@
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { buildRecipientRelativeHandoffTransportPackage } from '@tiinex/core/tooling/portable/handoff/materialClosure.package.js';
+import { qualifiedHandoffFixture } from '@tiinex/core/tooling/portable/handoff/qualifiedHandoffFixture.js';
+import {
+  COLD_START_INGRESS_KINDS,
+  describePortableColdStartIngress,
+  groundPortableColdConsumer,
+  projectPortableColdStartHostGuidance,
+  qualifyPortableColdStart
+} from '@tiinex/core/tooling/portable/handoff/coldStartQualification.js';
+import { runPortableOperation } from '@tiinex/core/tooling/portable/operation.catalog.js';
+
+const fixturePath = fileURLToPath(new URL('./fixtures/cold-start-qualification.v1.examples.json', import.meta.url));
+const fixtures = JSON.parse(await readFile(fixturePath, 'utf8'));
+assert.equal(fixtures.schema, 'tiinex.portable.cold-start-qualification.examples.v1');
+assert.equal(fixtures.examples.length, 4);
+
+for (const example of fixtures.examples) {
+  const result = qualifyPortableColdStart(example);
+  assert.equal(result.status, example.expect.status, example.id);
+  assert.equal(result.qualification.preferredPathPassed, example.expect.preferredPathPassed, example.id);
+  for (const [key, expected] of Object.entries(example.expect)) {
+    if (key === 'status' || key === 'preferredPathPassed') continue;
+    if (Object.prototype.hasOwnProperty.call(result.metrics, key)) assert.equal(result.metrics[key], expected, `${example.id}:${key}`);
+    else if (Object.prototype.hasOwnProperty.call(result.qualification, key)) assert.equal(result.qualification[key], expected, `${example.id}:${key}`);
+  }
+}
+
+const archaeology = qualifyPortableColdStart(fixtures.examples.find((entry) => entry.id === 'axiom-style-native-archaeology-recovery'));
+assert.equal(archaeology.qualification.recoveryState, 'recovered');
+assert.equal(archaeology.qualification.recoveryIsPreferredPathEvidence, false);
+assert(archaeology.findings.some((finding) => finding.code === 'portable.cold-start.native-archaeology.pre-takeover'));
+assert(archaeology.findings.some((finding) => finding.code === 'portable.cold-start.arbitrary-read.pre-orientation'));
+
+const degradedQualification = qualifyPortableColdStart(fixtures.examples.find((entry) => entry.id === 'voice-stt-degraded-capture'));
+assert.equal(degradedQualification.status, 'degraded-fallback');
+assert.equal(degradedQualification.findingSummary.counts.error, 0);
+assert.equal(degradedQualification.metrics.unexpectedNativeActionsBeforeTiinexTakeover, 0);
+assert.equal(degradedQualification.metrics.arbitraryFilesReadBeforeOrientation, 0);
+
+const mislabeledBootstrapRead = qualifyPortableColdStart({
+  ingressKind: 'routed-handoff-package',
+  toolingAvailable: true,
+  events: [
+    { mechanism: 'native-host', action: 'list-zip-entries', semanticClass: 'minimal-bootstrap', path: 'package.zip', candidateArtifacts: 6 },
+    { mechanism: 'tiinex', operation: 'orient-handoff-package', status: 'ready' },
+    { mechanism: 'tiinex', operation: 'ground-cold-consumer', status: 'ready' },
+    { mechanism: 'native-host', action: 'substantive-reasoning', semanticClass: 'substantive-work' }
+  ],
+  outcome: { correct: true }
+});
+assert.equal(mislabeledBootstrapRead.status, 'recovered-not-preferred');
+assert.equal(mislabeledBootstrapRead.qualification.preferredPathPassed, false);
+assert.equal(mislabeledBootstrapRead.metrics.arbitraryFilesReadBeforeOrientation, 1);
+assert(mislabeledBootstrapRead.findings.some((finding) => finding.code === 'portable.cold-start.arbitrary-read.pre-orientation'));
+
+const handoffMarkdown = qualifiedHandoffFixture({
+  title: 'Cold consumer fixture',
+  from: 'Anchor',
+  to: 'Loom',
+  purpose: 'continue a design discussion about preferred-path qualification',
+  createdAt: '2026-08-24 13:41:00'
+});
+
+const roleMarkdown = `# Continuity Context
+
+- Envelope Schema: tiinex.root.v1
+- Parent
+  - Parent Schema: tiinex.party.role.v1
+  - Created At: 2026-08-23 10:00:00
+  - Trace: predecessor-loom-role.trace.md
+- Current
+  - Current Schema: tiinex.party.role.v1
+  - Created At: 2026-08-24 10:00:00
+
+---
+
+# Loom
+
+## Role Identity
+
+- Role Label: Loom
+- Role Kind: implementation role
+
+## Role Boundary
+
+- In Scope: portable implementation and deterministic qualification fixtures
+- Out Of Scope: independent acceptance and remote publication
+- Context: Tooling 026
+
+## Authority And Responsibility Boundary
+
+- May Do: implement local portable source and tests
+- Does Not Authorize: remote writes, credentials, self-acceptance
+- Review Boundary: return implementation for independent acceptance
+
+## Holder Relationship
+
+- Holder State: unproven
+
+## Interpretation Limits
+
+- Does Not Prove: that one chat account equals the Role holder
+- Must Not Be Treated As: remote repository authority
+
+# Continuity Integrity
+`;
+
+const packageBuilt = buildRecipientRelativeHandoffTransportPackage({
+  workspace: { id: 'tiinex-site', title: 'tiinex-site', name: 'tiinex-site', records: [], assets: [] },
+  handoff: { id: '.topics/development/handoff/loom/026-cold-start-qualification.trace.md', path: '.topics/development/handoff/loom/026-cold-start-qualification.trace.md', semanticStatus: 'unknown', markdown: handoffMarkdown },
+  workspaceMaterializations: [{
+    id: 'tiinex-site',
+    title: 'tiinex-site',
+    state: 'complete',
+    source: { kind: 'fixture', workspaceId: 'tiinex-site' },
+    completenessEvidence: { state: 'qualified', proof: 'cold-start-grounding-fixture', boundary: '.' },
+    entries: [
+      { path: '.topics/development/handoff/loom/026-cold-start-qualification.trace.md', data: new TextEncoder().encode(handoffMarkdown), mediaType: 'text/markdown' },
+      { path: '.topics/roles/loom-role.trace.md', data: new TextEncoder().encode(roleMarkdown), mediaType: 'text/markdown' }
+    ]
+  }],
+  materials: [],
+  recipient: { referenceTargets: [] },
+  transportRoutes: [{ workspaceId: 'tiinex-site', path: '.topics/development/handoff/loom/026-cold-start-qualification.trace.md' }],
+  verifyRoundtrip: false
+}, { packageInput: { builtAt: '2026-08-24T19:15:00.000Z' } });
+assert.equal(packageBuilt.status, 'ready');
+
+const oneShotPreferred = qualifyPortableColdStart({ bundle: packageBuilt.bundle, preTakeover: 'minimal-bootstrap-only' });
+assert.equal(oneShotPreferred.status, 'preferred-pass');
+assert.equal(oneShotPreferred.qualification.preferredPathPassed, true);
+assert.equal(oneShotPreferred.oneShot.toolingEvidence, 'generated-by-qualify-cold-start-run');
+assert.equal(oneShotPreferred.oneShot.hostEvidence.independentlyObservedByTooling, false);
+assert.equal(oneShotPreferred.oneShot.evidenceAttribution.tooling.independentlyObserved, true);
+assert.deepEqual(oneShotPreferred.oneShot.evidenceAttribution.tooling.covers, ['orientation', 'route-resolution', 'recipient-grounding']);
+assert.equal(oneShotPreferred.oneShot.evidenceAttribution.preTakeoverHost.independentlyObservedByTooling, false);
+assert.equal(oneShotPreferred.grounding.handoff.to, 'Loom');
+assert.equal(oneShotPreferred.qualification.hostEvidence.source, 'caller-declared');
+assert.equal(oneShotPreferred.qualification.hostEvidence.independentlyObservedByTooling, false);
+assert.equal(oneShotPreferred.grounding.next.qualification.mode, 'one-shot-package');
+assert.equal(oneShotPreferred.grounding.next.qualification.externalQualificationSchemaRequired, false);
+assert.equal(oneShotPreferred.grounding.next.qualification.separateGroundingCallRequired, false);
+assert.equal(oneShotPreferred.grounding.next.qualification.eligible, true);
+assert.equal(oneShotPreferred.grounding.next.qualification.degradedGroundingBlocksPreferredPath, false);
+assert.equal(oneShotPreferred.continuation.state, 'ready');
+assert.equal(oneShotPreferred.continuation.substantiveWorkMayBegin, true);
+assert.equal(oneShotPreferred.continuation.transfer[0].id, 'fixture-transfer');
+assert.equal(oneShotPreferred.continuation.transfer[0].description, 'bounded fixture work');
+assert.equal(oneShotPreferred.continuation.requiredContext.length, 0);
+assert.equal(oneShotPreferred.continuation.completionExpectation.returnTo, 'Anchor');
+assert.match(oneShotPreferred.continuation.next, /No Tooling API discovery is required/);
+
+const oneShotUnverified = qualifyPortableColdStart({ bundle: packageBuilt.bundle });
+assert.equal(oneShotUnverified.status, 'incomplete');
+assert.equal(oneShotUnverified.qualification.preferredPathPassed, false);
+assert(oneShotUnverified.findings.some((finding) => finding.code === 'portable.cold-start.host-evidence.unverified'));
+
+const oneShotArchaeology = qualifyPortableColdStart({ bundle: packageBuilt.bundle, preTakeover: 'native-archaeology' });
+assert.equal(oneShotArchaeology.status, 'recovered-not-preferred');
+assert.equal(oneShotArchaeology.qualification.preferredPathPassed, false);
+assert(oneShotArchaeology.findings.some((finding) => finding.code === 'portable.cold-start.native-archaeology.pre-takeover'));
+
+const tools = [
+  { id: 'local.runtime', name: 'local.runtime', description: 'Read files and zip archives and execute JavaScript processes.', capabilities: ['filesystemRead', 'archiveRead', 'javascript'] },
+  { id: 'host.presentation', name: 'host.presentation', description: 'Return artifacts, request human confirmation, request authentication, and present copyable text.', capabilities: ['artifactReturn', 'humanConfirmation', 'authenticationRequest', 'copyableTextPresentation'] }
+];
+const grounding = groundPortableColdConsumer({
+  bundle: packageBuilt.bundle,
+  ingressKind: COLD_START_INGRESS_KINDS.HANDOFF,
+  tools,
+  provider: { id: 'provider-a', name: 'Provider A' },
+  hostIdentity: { id: 'host-a', name: 'Host A' },
+  session: { id: 'session-a', name: 'Current Session' },
+  holderBinding: { holderId: 'session-a', roleLabel: 'Loom' },
+  participants: [
+    { id: 'p1', label: 'Operator contribution stream', identities: ['operator-declared'], roles: ['operator', 'reviewer'], verification: 'declared', transportChannel: 'chat-thread' },
+    { id: 'p2', label: 'Implementation consumer', identities: ['consumer-session'], roles: ['Loom'], verification: 'unverified', transportChannel: 'chat-thread' }
+  ],
+  contributions: [
+    { id: 'c1', participantId: 'p1', speaker: 'Operator contribution stream', attribution: 'declared', kind: 'message' },
+    { id: 'c2', participantId: 'p2', speaker: 'Implementation consumer', attribution: 'unverified', kind: 'message' }
+  ],
+  currentContributionId: 'c1',
+  interaction: { mode: 'design-discussion', purpose: 'review and refine preferred-path qualification', continuingDialogue: true }
+});
+assert.equal(grounding.status, 'ready');
+assert.equal(grounding.handoff.to, 'Loom');
+assert.equal(grounding.role.state, 'qualified');
+assert.equal(grounding.role.material.artifact.roleLabel, 'Loom');
+assert.equal(grounding.role.exactBoundaryLoaded.inScope, 'portable implementation and deterministic qualification fixtures');
+assert.equal(grounding.role.predecessor.state, 'declared');
+assert.equal(grounding.holderBinding.state, 'qualified');
+assert.equal(grounding.holderBinding.roleLabel, 'Loom');
+assert.equal(grounding.holderBinding.holderId, 'session-a');
+assert.equal(grounding.holderBinding.inferredFromTransport, false);
+assert.equal(grounding.interaction.nonExecutionMode, true);
+assert.equal(grounding.interaction.executionExpected, false);
+assert.equal(grounding.interaction.oneShotAssumed, false);
+assert.equal(grounding.participation.cardinality.participants, 2);
+assert.equal(grounding.participation.transportIdentityAssumption, false);
+assert.equal(grounding.capabilities.instance.provider.id, 'provider-a');
+assert.equal(grounding.capabilities.instance.host.id, 'host-a');
+assert.equal(grounding.capabilities.instance.session.id, 'session-a');
+assert.equal(grounding.capabilities.instance.authority.providerNameGrantsCapability, false);
+assert.equal(grounding.capabilities.discovery.profile.capabilities.interaction.artifactReturn, true);
+assert.equal(grounding.capabilities.discovery.profile.capabilities.interaction.humanConfirmation, true);
+assert.equal(grounding.capabilities.discovery.profile.capabilities.interaction.authenticationRequest, true);
+assert.equal(grounding.capabilities.discovery.profile.capabilities.interaction.copyableTextPresentation, true);
+
+const unresolvedHolderGrounding = groundPortableColdConsumer({
+  bundle: packageBuilt.bundle,
+  participants: [{ id: 'p', roles: ['Loom'] }],
+  interaction: { mode: 'execution' }
+});
+assert.equal(unresolvedHolderGrounding.role.state, 'qualified');
+assert.equal(unresolvedHolderGrounding.holderBinding.state, 'unresolved');
+assert.equal(unresolvedHolderGrounding.holderBinding.inferredFromTransport, false);
+assert.equal(unresolvedHolderGrounding.status, 'degraded');
+
+const mismatchedHolderGrounding = groundPortableColdConsumer({
+  bundle: packageBuilt.bundle,
+  holderBinding: { holderId: 'session-b', roleLabel: 'Axiom' },
+  participants: [{ id: 'p', roles: ['Loom'] }],
+  interaction: { mode: 'execution' }
+});
+assert.equal(mismatchedHolderGrounding.holderBinding.state, 'blocked');
+assert.equal(mismatchedHolderGrounding.status, 'blocked');
+assert(mismatchedHolderGrounding.findings.some((finding) => finding.code === 'portable.cold-start.holder-binding.role-mismatch'));
+
+const roleMissingPackage = buildRecipientRelativeHandoffTransportPackage({
+  workspace: { id: 'tiinex-site', title: 'tiinex-site', name: 'tiinex-site', records: [], assets: [] },
+  handoff: { id: '.topics/development/handoff/loom/026-cold-start-qualification.trace.md', path: '.topics/development/handoff/loom/026-cold-start-qualification.trace.md', semanticStatus: 'unknown', markdown: handoffMarkdown },
+  workspaceMaterializations: [{ id: 'tiinex-site', title: 'tiinex-site', state: 'complete', source: { kind: 'fixture' }, completenessEvidence: { state: 'qualified', proof: 'missing-role-fixture', boundary: '.' }, entries: [{ path: '.topics/development/handoff/loom/026-cold-start-qualification.trace.md', data: new TextEncoder().encode(handoffMarkdown), mediaType: 'text/markdown' }] }],
+  materials: [], recipient: { referenceTargets: [] }, transportRoutes: [{ workspaceId: 'tiinex-site', path: '.topics/development/handoff/loom/026-cold-start-qualification.trace.md' }], verifyRoundtrip: false
+}, { packageInput: { builtAt: '2026-08-24T19:16:00.000Z' } });
+const missingRole = groundPortableColdConsumer({ bundle: roleMissingPackage.bundle, participants: [{ id: 'p', roles: ['Loom'] }], interaction: { mode: 'execution' } });
+assert.equal(missingRole.status, 'degraded');
+assert.equal(missingRole.role.state, 'degraded');
+assert.equal(missingRole.role.compatibility, 'degraded-missing-material');
+assert(missingRole.findings.some((finding) => finding.code === 'portable.cold-start.role.material.missing'));
+
+const degradedCapture = groundPortableColdConsumer({
+  ingressKind: 'degraded-capture',
+  toolingAvailable: false,
+  capture: { toolingState: 'unavailable', reason: 'voice host has no Tooling surface' },
+  participants: [{ id: 'speaker-a', label: 'Speaker A', verification: 'unverified' }],
+  contributions: [{ id: 'voice-1', speakerId: 'speaker-a', attribution: 'unverified', kind: 'voice-transcript' }],
+  currentContributionId: 'voice-1',
+  interaction: { mode: 'collaborative-dialogue', purpose: 'capture provisional design discussion' }
+});
+assert.equal(degradedCapture.status, 'degraded');
+assert.equal(degradedCapture.degradedCapture.active, true);
+assert.equal(degradedCapture.degradedCapture.toolingDependentMutationAllowed, false);
+assert.equal(degradedCapture.degradedCapture.laterToolingCapableCondensationRequired, true);
+assert.equal(degradedCapture.participation.currentContribution.state, 'declared-unverified');
+
+const hostProjection = projectPortableColdStartHostGuidance({ ingressKind: 'routed-handoff-package', tools, provider: { id: 'provider-a' }, hostIdentity: { id: 'host-a' }, session: { id: 'session-a' } });
+assert.equal(hostProjection.status, 'ready');
+assert.deepEqual(hostProjection.steps.map((step) => step.operation), ['orient-handoff-package', 'ground-cold-consumer']);
+assert.equal(hostProjection.authority.semanticAuthority, 'none');
+assert.equal(hostProjection.authority.providerSpecificSemanticAuthority, false);
+
+const nestedHostProjection = projectPortableColdStartHostGuidance({
+  ingressKind: 'routed-handoff-package',
+  host: {
+    id: 'nested-host',
+    name: 'Nested Host',
+    tools,
+    provider: { id: 'nested-provider' },
+    session: { id: 'nested-session' }
+  }
+});
+assert.equal(nestedHostProjection.capabilityInstance.provider.id, 'nested-provider');
+assert.equal(nestedHostProjection.capabilityInstance.host.id, 'nested-host');
+assert.equal(nestedHostProjection.capabilityInstance.host.name, 'Nested Host');
+assert.equal(nestedHostProjection.capabilityInstance.session.id, 'nested-session');
+
+const contract = describePortableColdStartIngress({ ingressKind: 'workspace-bootstrap' });
+assert.equal(contract.profile.firstSemanticOperation, 'discover-tooling');
+assert.equal(contract.profile.orientationOperation, 'search-lineage');
+assert.equal(contract.qualification.recoveryIsNotPreferredPath, true);
+assert.equal(contract.semanticSeparations.lineageLeafIsWorkflowFrontier, false);
+assert.equal(contract.semanticSeparations.workflowFrontierIsTaskState, false);
+
+const catalogResult = await runPortableOperation('qualify-cold-start', fixtures.examples[0]);
+assert.equal(catalogResult.operation, 'qualify-cold-start');
+assert.equal(catalogResult.resultSchema, 'tiinex.portable.cold-start-qualification.v1');
+assert.equal(catalogResult.status, 'preferred-pass');
+
+console.log('✓ Tooling 026 cold-start ingress, grounding, provider/session capability projection, degraded capture, and recovery-vs-preferred qualification passed');