@tiinex/app 0.1.1

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

@@ -0,0 +1,205 @@
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, readFile, readdir, rm, writeFile } from 'node:fs/promises';
+import { spawnSync } from 'node:child_process';
+import os from 'node:os';
+import path from 'node:path';
+import { parseArtifactMarkdown } from '@tiinex/core/artifacts/artifact.parse.js';
+import { validatedC14nV2PrimarySelfDigest } from '@tiinex/core/integrity/integrity.c14nV2.js';
+import { C14N_V2_VALIDATOR_TARGET } from '@tiinex/core/integrity/integrity.methodReference.js';
+import { projectPortableEditorAssistance, locateFindingLine } from '@tiinex/core/tooling/portable/editor/editor.assistance.js';
+import { portableRuntimeValidationAuthorityForRecord } from '@tiinex/core/tooling/portable/schema/qualifiedLocalRoot.runtime.js';
+import { projectQualifiedHandoffLeaves } from '@tiinex/core/tooling/portable/handoff/handoffLeafProjection.js';
+import { qualifiedHandoffFixture } from '@tiinex/core/tooling/portable/handoff/qualifiedHandoffFixture.js';
+import { runPortableOperation } from '@tiinex/core/tooling/portable/operation.catalog.js';
+import { renderHandoffPackageV1, parseHandoffPackageV1, validatePackageFields, WORKSPACE_PACKAGE_ROLE } from '@tiinex/core/tooling/portable/handoff/recipientV2.packageV1.contract.js';
+import { manufactureRecipientRelativeHandoffPackage } from '@tiinex/core/tooling/portable/handoff/manufacture.js';
+import { projectQualifiedWorkspacePackageSources } from '@tiinex/core/tooling/portable/handoff/workspacePackageSources.js';
+import { projectPortableHandoffAuthoringPlan } from '@tiinex/core/tooling/portable/handoff/handoffAuthoringPlan.js';
+import { projectQualifiedHandoffEndpoints } from '@tiinex/core/tooling/portable/handoff/handoffEndpointProjection.js';
+
+function record(path, markdown) {
+  const parsed = parseArtifactMarkdown(markdown);
+  return { id: path, path, title: parsed.title, schemaId: parsed.envelope.current.schema.id, currentSchemaId: parsed.envelope.current.schema.id, markdown, parent: parsed.envelope.parent };
+}
+
+const baseMarkdown = qualifiedHandoffFixture({ title: 'Base Handoff', from: 'Anchor', to: 'Loom' });
+const baseDigest = validatedC14nV2PrimarySelfDigest(baseMarkdown);
+assert.equal(baseDigest.state, 'verified');
+const childMarkdown = qualifiedHandoffFixture({
+  title: 'Child Handoff', from: 'Loom', to: 'Anchor',
+  parent: { schemaId: 'tiinex.handoff.v1', trace: 'base.trace.md', relative: 'base.trace.md', includeBrowseGit: false, towards: 'base.trace.md', targetValue: baseDigest.value }
+});
+const leaves = projectQualifiedHandoffLeaves({ records: [record('base.trace.md', baseMarkdown), record('child.trace.md', childMarkdown)] });
+assert.equal(leaves.status, 'ready');
+assert.deepEqual(leaves.leaves.map((item) => item.path), ['child.trace.md']);
+assert.equal(leaves.leaves[0].from, 'Loom');
+assert.equal(leaves.leaves[0].to, 'Anchor');
+assert.equal(leaves.pointerless.manufactureState, 'ready');
+assert.equal(leaves.pointerless.packageRole, 'recipient-facing-workspace-carrier');
+
+const altered = baseMarkdown.replace('- Purpose: qualified Handoff regression fixture', '- Purpose: changed after sealing');
+const assistance = projectPortableEditorAssistance({ records: [record('broken.trace.md', altered)] });
+assert.equal(assistance.documents.length, 1);
+assert.equal(assistance.documents[0].validator.state, 'qualified-exact');
+assert.equal(assistance.documents[0].actions[0].id, 'refresh-primary-self-integrity');
+assert.equal(assistance.documents[0].actions[0].kind, 'replace-document');
+assert.notEqual(assistance.documents[0].actions[0].replacementMarkdown, altered);
+assert.deepEqual(assistance.documents[0].actions[0].diagnosticCodes, ['integrity.c14n-v2.mismatch', 'integrity.c14n-v2.ambiguous']);
+
+const legacyIntegrityTarget = 'https://github.com/Tiinex/docs/blob/4cb7046454f1cf75333097fc1a3d4562838afc26/.topics/.validators/sha256-base64url-c14n-v2.validator.md';
+const staleMethodMarkdown = baseMarkdown.replaceAll(C14N_V2_VALIDATOR_TARGET, legacyIntegrityTarget);
+const staleMethodAssistance = projectPortableEditorAssistance({ records: [record('stale-method.trace.md', staleMethodMarkdown)] });
+const staleMethodAction = staleMethodAssistance.documents[0].actions.find((item) => item.id === 'refresh-primary-self-integrity');
+assert.ok(staleMethodAction, 'unqualified maintained c14n-v2 footer references must project one deterministic shared-core hygiene action');
+assert.equal(staleMethodAction.diagnosticCodes.includes('integrity.method-reference.unqualified'), true);
+assert.equal(staleMethodAction.replacementMarkdown.includes(legacyIntegrityTarget), false);
+assert.equal(staleMethodAction.replacementMarkdown.includes(C14N_V2_VALIDATOR_TARGET), true);
+const repairedMethodAssistance = projectPortableEditorAssistance({ records: [record('stale-method.trace.md', staleMethodAction.replacementMarkdown)] });
+assert.equal(repairedMethodAssistance.documents[0].diagnostics.some((item) => item.code === 'integrity.method-reference.unqualified' || item.code === 'integrity.c14n-v2.mismatch'), false);
+
+const mixedSchemaReferenceMarkdown = baseMarkdown.replace(/- Envelope Schema: \[tiinex\.root\.v1\]\([^)]+\)/, '- Envelope Schema: tiinex.root.v1');
+const mixedSchemaAssistance = projectPortableEditorAssistance({ records: [record('mixed-schema.trace.md', mixedSchemaReferenceMarkdown)], focusPath: 'mixed-schema.trace.md' });
+const mixedSchemaDiagnostic = mixedSchemaAssistance.documents[0].diagnostics.find((item) => item.code === 'portable.editor.schema-reference.canonical-target-available');
+assert.ok(mixedSchemaDiagnostic, 'mixed exact/plain schema-reference conventions must be visible to shared editor assistance');
+assert.equal(mixedSchemaDiagnostic.locationState, 'deterministic');
+assert.match(mixedSchemaReferenceMarkdown.split(/\r?\n/)[mixedSchemaDiagnostic.line - 1], /^- Envelope Schema:/);
+assert.equal(mixedSchemaAssistance.documents[0].actions.length, 0, 'self reseal must be withheld while another known shared guardrail remains open');
+
+const parentSchemaMismatchMarkdown = qualifiedHandoffFixture({
+  title: 'Parent Schema Mismatch', from: 'Loom', to: 'Anchor',
+  parent: { schemaId: 'tiinex.task.v1', trace: 'base.trace.md', relative: 'base.trace.md', includeBrowseGit: false, towards: 'base.trace.md', targetValue: baseDigest.value }
+});
+const parentSchemaAssistance = projectPortableEditorAssistance({ records: [record('base.trace.md', baseMarkdown), record('parent-schema-mismatch.trace.md', parentSchemaMismatchMarkdown)], focusPath: 'parent-schema-mismatch.trace.md' });
+const parentSchemaDiagnostic = parentSchemaAssistance.documents[0].diagnostics.find((item) => item.code === 'portable.lineage-integrity.parent-schema-mismatch');
+assert.ok(parentSchemaDiagnostic, 'declared Parent Schema must be compared with the resolved Parent Current Schema');
+assert.equal(parentSchemaDiagnostic.locationState, 'deterministic');
+assert.match(parentSchemaMismatchMarkdown.split(/\r?\n/)[parentSchemaDiagnostic.line - 1], /Parent Schema:/);
+
+const descendantBoundAssistance = projectPortableEditorAssistance({ records: [record('base.trace.md', altered), record('child.trace.md', childMarkdown)], focusPath: 'base.trace.md' });
+assert.equal(descendantBoundAssistance.documents[0].diagnostics.some((item) => item.code === 'integrity.c14n-v2.mismatch'), true);
+assert.equal(descendantBoundAssistance.documents[0].actions.length, 0, 'repair must be withheld when resealing the focused Parent would leave a loaded digest-bound descendant invalid');
+
+const editorCliRoot = await mkdtemp(path.join(os.tmpdir(), 'tiinex-editor-cli-'));
+const editorOverlayPath = path.join(editorCliRoot, 'overlay.md');
+try {
+  await mkdir(path.join(editorCliRoot, '.topics'), { recursive: true });
+  await writeFile(path.join(editorCliRoot, '.topics/base.trace.md'), baseMarkdown, 'utf8');
+  await writeFile(editorOverlayPath, altered, 'utf8');
+  const editorCli = spawnSync(process.execPath, ['tools/tiinex-portable.mjs', 'project-editor-assistance', editorCliRoot, '--focus', '.topics/base.trace.md', '--overlay', editorOverlayPath, '--compact'], { encoding: 'utf8' });
+  assert.equal(editorCli.status, 0, editorCli.stderr);
+  const editorCliReceipt = JSON.parse(editorCli.stdout);
+  assert.equal(editorCliReceipt.documents.length, 1, 'CLI overlay must preserve file-backed material instead of shadowing it with an empty records array');
+  assert.equal(editorCliReceipt.documents[0].path, '.topics/base.trace.md');
+  assert.equal(editorCliReceipt.documents[0].diagnostics.some((item) => item.code === 'integrity.c14n-v2.mismatch'), true);
+} finally { await rm(editorCliRoot, { recursive: true, force: true }); }
+
+const sectionLine = locateFindingLine({ params: { section: 'Required Context' } }, baseMarkdown);
+assert.equal(sectionLine.state, 'deterministic');
+assert.equal(baseMarkdown.split(/\r?\n/)[sectionLine.line - 1], '## Required Context');
+const fieldLine = locateFindingLine({ params: { field: 'From' } }, baseMarkdown);
+assert.equal(fieldLine.state, 'deterministic');
+assert.match(baseMarkdown.split(/\r?\n/)[fieldLine.line - 1], /^- From:/);
+const unresolved = locateFindingLine({ code: 'task.title.missing', message: 'Title missing.' }, baseMarkdown);
+assert.equal(unresolved.state, 'unresolved');
+assert.equal(unresolved.line, null);
+const missingSectionAnchor = locateFindingLine({ code: 'portable.contract.section.required.missing', message: 'Required section is missing: Missing Section.', params: { section: 'Missing Section' } }, baseMarkdown);
+assert.equal(missingSectionAnchor.state, 'deterministic-anchor');
+assert.equal(baseMarkdown.split(/\r?\n/)[missingSectionAnchor.line - 1], '# Base Handoff');
+
+const organizationAuthority = portableRuntimeValidationAuthorityForRecord({ markdown: `# Continuity Context\n\n- Envelope Schema: [tiinex.root.v1](https://github.com/Tiinex/docs/blob/911d4cf990e35ce25a56e8f376d296e327c48260/.topics/.schemas/tiinex.root.v1.schema.md)\n- Current\n  - Current Schema: [tiinex.party.organization.v1](https://github.com/Tiinex/docs/blob/911d4cf990e35ce25a56e8f376d296e327c48260/.topics/.schemas/party/organization/tiinex.party.organization.v1.schema.md)\n\n---\n\n# Organization\n` });
+assert.equal(organizationAuthority.state, 'unavailable');
+assert.equal(organizationAuthority.currentReference.state, 'qualified');
+assert.equal(organizationAuthority.findings.some((item) => item.includes('Compiled lineage substitutes source authority')), true);
+const roleAuthority = portableRuntimeValidationAuthorityForRecord({ markdown: `# Continuity Context\n\n- Envelope Schema: [tiinex.root.v1](https://github.com/Tiinex/docs/blob/3988951208eb9a8926e84ab42625d4b42fa00c2d/.topics/.schemas/tiinex.root.v1.schema.md)\n- Current\n  - Current Schema: [tiinex.party.role.v1](https://github.com/Tiinex/docs/blob/3988951208eb9a8926e84ab42625d4b42fa00c2d/.topics/.schemas/party/role/tiinex.party.role.v1.schema.md)\n\n---\n\n# Role\n` });
+assert.equal(roleAuthority.state, 'qualified');
+assert.equal(roleAuthority.currentReference.basis, 'qualified-workspace-local-authority');
+
+const op = await runPortableOperation('project-handoff-leaves', { records: [record('base.trace.md', baseMarkdown), record('child.trace.md', childMarkdown)] });
+assert.equal(op.operation, 'project-handoff-leaves');
+assert.equal(op.resultSchema, 'tiinex.portable.handoff-leaf-projection.v1');
+assert.deepEqual(op.leaves.map((item) => item.path), ['child.trace.md']);
+
+const sourceWorkspaceMarkdown = await readFile('.topics/.workspaces/tiinex-site.workspace.md', 'utf8');
+const sourceProjection = projectQualifiedWorkspacePackageSources({ files: [{ path: '.topics/.workspaces/tiinex-site.workspace.md', content: sourceWorkspaceMarkdown }] });
+assert.equal(sourceProjection.status, 'ready');
+assert.equal(sourceProjection.candidates.length, 1);
+assert.equal(sourceProjection.candidates[0].workspaceId, 'site');
+assert.equal(sourceProjection.candidates[0].repositoryIdentity, 'tiinex/site');
+assert.equal(sourceProjection.candidates[0].ref, 'refactor');
+const collidedSourceProjection = projectQualifiedWorkspacePackageSources({ files: [
+  { path: '.topics/.workspaces/tiinex-site.workspace.md', content: sourceWorkspaceMarkdown },
+  { path: 'alternate/tiinex-site.workspace.md', content: sourceWorkspaceMarkdown }
+] });
+assert.equal(collidedSourceProjection.candidates.length, 2);
+assert.equal(new Set(collidedSourceProjection.candidates.map((item) => item.repositoryIdentity)).size, 1, 'physical repository snapshot identity remains shared');
+assert.equal(new Set(collidedSourceProjection.candidates.map((item) => item.workspaceId)).size, 2, 'semantic Workspace artifact choices must remain distinct despite the same repository basename');
+assert.equal(collidedSourceProjection.candidates.every((item) => item.workspaceId.startsWith('site--')), true);
+
+const loomRoleMarkdown = await readFile('src/tooling/portable/fixtures/legacy-artifacts/loom/role/001-loom-role.trace.fixture.txt', 'utf8');
+const endpointProjection = projectQualifiedHandoffEndpoints({ workspaceId: 'business', files: [{ path: '.topics/roles/001-3-loom-role.trace.md', content: loomRoleMarkdown }] });
+assert.equal(endpointProjection.status, 'ready');
+assert.equal(endpointProjection.candidates.length, 1);
+assert.equal(endpointProjection.candidates[0].kind, 'role');
+assert.equal(endpointProjection.candidates[0].target, 'business::.topics/roles/001-3-loom-role.trace.md');
+assert.equal(endpointProjection.candidates[0].reference, endpointProjection.candidates[0].target);
+const matchedSourceProjection = projectQualifiedWorkspacePackageSources({ files: [{ path: '.topics/.workspaces/tiinex-site.workspace.md', content: sourceWorkspaceMarkdown }], repositories: [{ id: '/repo/site', root: '/repo/site', repository: 'git@github.com:Tiinex/site.git', branch: 'refactor', clean: true }] });
+assert.equal(matchedSourceProjection.candidates.length, 1);
+assert.equal(matchedSourceProjection.candidates[0].localRepository.id, '/repo/site');
+const unmatchedSourceProjection = projectQualifiedWorkspacePackageSources({ files: [{ path: '.topics/.workspaces/tiinex-site.workspace.md', content: sourceWorkspaceMarkdown }], repositories: [{ id: '/repo/docs', root: '/repo/docs', repository: 'https://github.com/Tiinex/docs.git', branch: 'master', clean: true }] });
+assert.equal(unmatchedSourceProjection.candidates.length, 0);
+assert.equal(unmatchedSourceProjection.findings.some((item) => item.code === 'portable.workspace-package-source.local-repository-unmatched'), true);
+
+const rootAuthoring = projectPortableHandoffAuthoringPlan({ records: [record('.topics/base.trace.md', baseMarkdown)], title: 'Operator Native Handoff' });
+assert.equal(rootAuthoring.status, 'ready');
+assert.equal(rootAuthoring.mode, 'root');
+assert.equal(rootAuthoring.path.endsWith('--handoff.trace.md'), true);
+const continuationAuthoring = projectPortableHandoffAuthoringPlan({ records: [record('.topics/base.trace.md', baseMarkdown)], title: 'Child Return', parentPath: '.topics/base.trace.md' });
+assert.equal(continuationAuthoring.status, 'ready');
+assert.equal(continuationAuthoring.mode, 'continuation');
+assert.equal(continuationAuthoring.parentPath, '.topics/base.trace.md');
+assert.equal(continuationAuthoring.path, '.topics/child-return--handoff.trace.md');
+
+const workspaceCarrierMarkdown = renderHandoffPackageV1({
+  createdAt: '2026-09-06T12:00:00.000Z',
+  packageRole: WORKSPACE_PACKAGE_ROLE,
+  workspaces: [{ workspaceId: 'site', workspacePath: '001-3-site.workspace.md', archivePath: '001-3-site.workspace.zip', sourceWorkspaceTargetInnerPath: '.topics/.workspaces/tiinex-site.workspace.md', archiveSha256: 'a'.repeat(64), archiveBytes: 123 }],
+  carrierLineage: { dimension: '009', checkpointKind: 'progression' }
+});
+const workspaceCarrier = parseHandoffPackageV1(workspaceCarrierMarkdown);
+assert.equal(workspaceCarrier.packageRole, WORKSPACE_PACKAGE_ROLE);
+assert.equal(workspaceCarrier.routePlacementRule, 'none');
+assert.equal(workspaceCarrier.continueFromRule, 'none');
+assert.equal(workspaceCarrier.preHandoffClosureRule, 'none');
+const workspaceFindings = [];
+validatePackageFields(workspaceCarrier, workspaceFindings);
+assert.equal(workspaceFindings.some((item) => item.severity === 'error'), false);
+const mixed = { ...workspaceCarrier, routePlacementRule: 'authoritative-workspace-descended' };
+const mixedFindings = [];
+validatePackageFields(mixed, mixedFindings);
+assert.equal(mixedFindings.some((item) => item.code === 'portable.handoff-package-v1.field.routePlacementRule.invalid'), true);
+const pointerlessMissingInputs = manufactureRecipientRelativeHandoffPackage({ carrierMode: 'workspace' });
+assert.equal(pointerlessMissingInputs.status, 'blocked');
+assert.equal(pointerlessMissingInputs.transportExecutable, false);
+
+const cliOut = await mkdtemp(path.join(os.tmpdir(), 'tiinex-pointerless-'));
+const cliWorkspace = await mkdtemp(path.join(os.tmpdir(), 'tiinex-pointerless-workspace-'));
+try {
+  const targetPath = '.topics/.workspaces/tiinex-site.workspace.md';
+  await mkdir(path.join(cliWorkspace, '.topics/.workspaces'), { recursive: true });
+  await writeFile(path.join(cliWorkspace, targetPath), sourceWorkspaceMarkdown, 'utf8');
+  const cli = spawnSync(process.execPath, ['tools/tiinex-portable.mjs', 'manufacture-handoff-package', cliWorkspace, '--carrier-mode', 'workspace', '--workspace-id', 'site', '--workspace-target', targetPath, '--output-dir', cliOut, '--compact'], { encoding: 'utf8' });
+  assert.equal(cli.status, 0, cli.stderr);
+  const receipt = JSON.parse(cli.stdout);
+  assert.equal(receipt.status, 'ready');
+  assert.equal(receipt.transportExecutable, true);
+  assert.equal(receipt.carrierProjection.mode, 'workspace');
+  assert.equal(receipt.carrierProjection.routes.length, 0);
+  assert.equal(receipt.carrierProjection.selection.policy, 'none');
+  assert.equal(receipt.humanOutput.normalInlineRouting, null);
+  assert.deepEqual(await readdir(cliOut), ['tiinex-workspace-001.handoff-package.zip']);
+  const forbiddenRoute = spawnSync(process.execPath, ['tools/tiinex-portable.mjs', 'manufacture-handoff-package', cliWorkspace, '--carrier-mode', 'workspace', '--workspace-id', 'site', '--workspace-target', targetPath, '--route', 'incidental.trace.md', '--compact'], { encoding: 'utf8' });
+  assert.equal(forbiddenRoute.status, 1);
+  assert.match(forbiddenRoute.stderr, /workspace-carrier\.handoff-route\.forbidden/);
+} finally { await rm(cliOut, { recursive: true, force: true }); await rm(cliWorkspace, { recursive: true, force: true }); }
+
+console.log('✓ Major 012 shared editor-assistance, Handoff-leaf, and qualified fail-closed two-mode carrier mechanics passed');

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

@@ -0,0 +1,143 @@
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, 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 { runPortableCli } from '@tiinex/core/tooling/portable/adapters/cli/cli.run.js';
+import { manufactureRecipientRelativeHandoffPackage } from '@tiinex/core/tooling/portable/handoff/manufacture.js';
+import { qualifiedHandoffFixture } from '@tiinex/core/tooling/portable/handoff/qualifiedHandoffFixture.js';
+import { recipientFacingV2PackageZipBuffer } from '@tiinex/core/tooling/portable/output/recipientV2.zip.js';
+import { projectPortableWorkspaceLandingPlan } from '@tiinex/core/tooling/portable/handoff/workspaceLandingPlan.js';
+import { sealC14nV2Self } from '@tiinex/core/integrity/integrity.c14nV2.js';
+import { C14N_V2_VALIDATOR_TARGET } from '@tiinex/core/integrity/integrity.methodReference.js';
+
+const root = await mkdtemp(path.join(os.tmpdir(), 'tiinex-workspace-landing-'));
+try {
+  const siteRoot = path.join(root, 'site');
+  const vscodeRoot = path.join(root, 'vscode');
+  const runtimeRoot = path.join(root, 'runtime');
+  await makeWorkspace(siteRoot, 'Site', 'Tiinex/site', 'refactor', true);
+  await makeWorkspace(vscodeRoot, 'VS Code', 'Tiinex/vscode', 'master', false);
+  await makeRuntime(runtimeRoot);
+  const input = await prepareNodeHandoffManufacturingInput({
+    workspaceRoot: siteRoot,
+    workspaceId: 'site',
+    workspaceTargetPath: '.topics/.workspaces/tiinex-site.workspace.md',
+    handoffPath: '.topics/001-handoff.trace.md',
+    additionalWorkspaces: [{ id: 'vscode', root: vscodeRoot, workspaceTargetPath: '.topics/.workspaces/tiinex-vscode.workspace.md' }],
+    toolingBootstrap: 'embedded',
+    runtimeRoot,
+    verifyRoundtrip: true
+  });
+  const manufactured = manufactureRecipientRelativeHandoffPackage(input, { legacyRecipientV2Compatibility: true, verifyRoundtrip: true, packageInput: { builtAt: '2026-09-06T12:00:00.000Z' } });
+  assert.equal(manufactured.status, 'ready', JSON.stringify(manufactured.findings, null, 2));
+
+  const repos = [
+    { id: 'local-site', root: '/repos/site', repository: 'git@github.com:Tiinex/site.git', branch: 'refactor', clean: true },
+    { id: 'local-vscode', root: '/repos/vscode', repository: 'https://github.com/Tiinex/vscode.git', branch: 'master', clean: true }
+  ];
+  const ready = projectPortableWorkspaceLandingPlan({ ...manufactured.bundle, repositories: repos });
+  assert.equal(ready.status, 'ready', JSON.stringify(ready.findings, null, 2));
+  assert.deepEqual(ready.affected.map((item) => item.workspaceId).sort(), ['site', 'vscode']);
+  assert.equal(ready.confirmation.required, true);
+  assert.match(ready.confirmation.statement, /preserve \.git and unrelated ignored local material; do not commit or push/i);
+  assert.equal(ready.operationBoundary.sourceMutation, false);
+  assert.equal(ready.operationBoundary.push, false);
+  assert.equal(ready.workspaces.find((item) => item.workspaceId === 'site').archivePackagePath.length > 0, true);
+
+  const dirty = projectPortableWorkspaceLandingPlan({ ...manufactured.bundle, repositories: repos.map((item) => item.id === 'local-vscode' ? { ...item, clean: false } : item) });
+  assert.equal(dirty.status, 'blocked');
+  assert(dirty.findings.some((item) => item.code === 'portable.workspace-landing.local-repository-dirty'));
+
+  const duplicate = projectPortableWorkspaceLandingPlan({ ...manufactured.bundle, repositories: [...repos, { ...repos[0], id: 'second-site', root: '/repos/site-2' }] });
+  assert.equal(duplicate.status, 'blocked');
+  assert(duplicate.findings.some((item) => item.code === 'portable.workspace-landing.local-repository-ambiguous'));
+
+  const selected = projectPortableWorkspaceLandingPlan({ ...manufactured.bundle, repositories: [...repos, { ...repos[0], id: 'second-site', root: '/repos/site-2' }], selections: { site: 'second-site' } });
+  assert.equal(selected.status, 'ready', JSON.stringify(selected.findings, null, 2));
+  assert.equal(selected.affected.find((item) => item.workspaceId === 'site').repository.id, 'second-site');
+
+  const wrongBranch = projectPortableWorkspaceLandingPlan({ ...manufactured.bundle, repositories: repos.map((item) => item.id === 'local-site' ? { ...item, branch: 'master' } : item) });
+  assert.equal(wrongBranch.status, 'blocked');
+  assert(wrongBranch.findings.some((item) => item.code === 'portable.workspace-landing.ref-branch-mismatch'));
+
+  const onlySite = projectPortableWorkspaceLandingPlan({ ...manufactured.bundle, repositories: [repos[0]], workspaceIds: ['site'] });
+  assert.equal(onlySite.status, 'ready');
+  assert.deepEqual(onlySite.affected.map((item) => item.workspaceId), ['site']);
+
+  const explicitMissing = projectPortableWorkspaceLandingPlan({ ...manufactured.bundle, repositories: [repos[0]], workspaceIds: ['vscode'] });
+  assert.equal(explicitMissing.status, 'blocked');
+  assert(explicitMissing.findings.some((item) => item.code === 'portable.workspace-landing.local-repository-unmatched'));
+
+  const packagePath = path.join(root, 'carrier.zip');
+  const repositoriesPath = path.join(root, 'repositories.json');
+  await writeFile(packagePath, recipientFacingV2PackageZipBuffer(manufactured.bundle, { inspection: manufactured.inspection }));
+  await writeFile(repositoriesPath, `${JSON.stringify({ repositories: repos }, null, 2)}\n`, 'utf8');
+  const lines = [];
+  const code = await runPortableCli(['project-workspace-landing', packagePath, '--repositories', repositoriesPath, '--compact'], { log: (value) => lines.push(value), error: (value) => lines.push(value) }, { runtimeRoot });
+  assert.equal(code, 0, lines.join('\n'));
+  const cli = JSON.parse(lines.at(-1));
+  assert.equal(cli.operation, 'project-workspace-landing');
+  assert.equal(cli.status, 'ready');
+  assert.deepEqual(cli.affected.map((item) => item.workspaceId).sort(), ['site', 'vscode']);
+} finally {
+  await rm(root, { recursive: true, force: true });
+}
+
+async function makeWorkspace(rootPath, title, repository, ref, withHandoff) {
+  await mkdir(path.join(rootPath, '.topics', '.workspaces'), { recursive: true });
+  await mkdir(path.join(rootPath, '.topics'), { recursive: true });
+  await writeFile(path.join(rootPath, '.topics', '.workspaces', `tiinex-${title === 'VS Code' ? 'vscode' : 'site'}.workspace.md`), workspaceMarkdown(title, repository, ref), 'utf8');
+  await writeFile(path.join(rootPath, 'README.md'), `# ${title}\n`, 'utf8');
+  if (withHandoff) await writeFile(path.join(rootPath, '.topics', '001-handoff.trace.md'), qualifiedHandoffFixture({ title: 'Landing plan fixture', purpose: 'qualify landing plan fixture', createdAt: '2026-09-06 12:00:00' }), 'utf8');
+}
+
+function workspaceMarkdown(title, repository, ref) {
+  const unsigned = `# Continuity Context
+
+- Envelope Schema: tiinex.root.v1
+- Current
+  - Current Schema: tiinex.workspace.v1
+  - Created At: 2026-09-06 11:59:00
+  - Authors: Fixture
+  - Why: Qualify the ${title} Workspace for landing-plan regression.
+  - Summary: ${title} landing-plan fixture Workspace.
+  - Status: active/local
+
+---
+
+# ${title}
+
+## Workspace Entrypoints
+
+### ${title} source
+
+- Source Kind: github-tree
+- Repository: ${repository}
+- Ref: ${ref}
+- Root Path: .
+- Repo Files Discovery: on
+
+# Continuity Integrity
+
+- [sha256-base64url-c14n-v2](${C14N_V2_VALIDATOR_TARGET})
+  - Towards: self
+  - 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'), '# Bootstrap\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'), '# Root\n', 'utf8');
+}
+
+console.log('✓ Major 012 qualified Workspace landing-plan projection passed');