@tiinex/app 0.1.1

package/src/styles/responsive.css

@@ -0,0 +1,10 @@
+@media (max-width: 760px) {
+  .tx-shell { padding: 12px; }
+  .tx-grid { grid-template-columns: 1fr; }
+  .tx-toolbar { overflow-x: auto; justify-content: flex-start; }
+}
+@media (max-width: 900px) {
+  .tx-artifact-head { flex-direction:column; }
+  .tx-card-badges { max-width:none; justify-content:flex-start; }
+  .tx-artifact-meta { grid-template-columns:1fr; }
+}

package/src/styles/theme.css

@@ -0,0 +1,4 @@
+html, body { margin: 0; height: 100%; min-height: 100%; overflow: hidden; background: radial-gradient(circle at 50% 0%, rgba(138,72,205,.2), transparent 28rem), var(--tx-bg); color: var(--tx-text); font: 14px/1.45 system-ui, -apple-system, Segoe UI, sans-serif; }
+#root { height: 100%; min-height: 0; }
+a { color: inherit; }
+button, select { font: inherit; }

package/src/styles/tokens.css

@@ -0,0 +1,30 @@
+:root {
+  --tx-bg: #07050d;
+  --tx-panel: rgba(25, 20, 38, 0.92);
+  --tx-panel-soft: rgba(40, 31, 58, 0.72);
+  --tx-border: rgba(176, 112, 255, 0.35);
+  --tx-text: #eee8f7;
+  --tx-muted: #b9a9ca;
+  --tx-accent: #bd73ff;
+  --tx-accent-2: #6ee7d8;
+  --tx-danger: #ff6b8a;
+  --tx-radius: 18px;
+  --tx-shadow: 0 24px 80px rgba(0,0,0,.45);
+}
+
+/* v116 React Tiinex design tokens */
+:root {
+  --tx-bg-deep: #05070d;
+  --tx-bg-grid: rgba(255, 255, 255, 0.035);
+  --tx-panel-strong: rgba(9, 12, 20, 0.88);
+  --tx-panel-glass: rgba(10, 14, 24, 0.72);
+  --tx-panel-line: rgba(118, 242, 224, 0.22);
+  --tx-brand-cyan: #65f2e7;
+  --tx-brand-purple: #bd73ff;
+  --tx-brand-orange: #ffad33;
+  --tx-brand-white: #f7f8fb;
+  --tx-brand-muted: #abb1c4;
+  --tx-gap-icon: 0.55rem;
+  --tx-control-min: 2.45rem;
+  --tx-focus-ring: 0 0 0 3px rgba(101, 242, 231, 0.18);
+}

package/src/surfaces/audit/AuditSurface.js

@@ -0,0 +1 @@
+export function AuditSurface() { return { surface: 'audit', status: 'scaffold' }; }

package/src/surfaces/audit/audit.model.js

@@ -0,0 +1 @@
+export const auditModel = Object.freeze({ id: 'audit', kind: 'audit-report' });

package/src/surfaces/audit/audit.render.js

@@ -0,0 +1 @@
+export function renderAuditSurface(model) { return model; }

package/src/surfaces/contracts.js

@@ -0,0 +1,45 @@
+export const SurfaceImplementationStatus = Object.freeze({
+  parity: 'parity',
+  partial: 'partial',
+  scaffold: 'scaffold',
+  unavailable: 'unavailable'
+});
+
+export const SurfaceTruthBoundary = Object.freeze({
+  projectionOnly: 'projection-only',
+  noTruthMutation: 'no-truth-mutation',
+  commandRequired: 'command-required'
+});
+
+export function defineSurface(surface = {}) {
+  const id = String(surface.id || '').trim();
+  if (!id) throw new Error('surface.id.required');
+  return Object.freeze({
+    id,
+    kind: String(surface.kind || 'surface'),
+    label: String(surface.label || id),
+    purpose: String(surface.purpose || ''),
+    status: normalizeSurfaceStatus(surface.status),
+    boundary: normalizeBoundary(surface.boundary),
+    owner: String(surface.owner || 'surface-registry'),
+    notes: Array.isArray(surface.notes) ? surface.notes.map((note) => String(note || '').trim()).filter(Boolean) : []
+  });
+}
+
+export function isSurfaceReady(surface = {}) {
+  return surface.status === SurfaceImplementationStatus.parity || surface.status === SurfaceImplementationStatus.partial;
+}
+
+export function isSurfaceScaffold(surface = {}) {
+  return surface.status === SurfaceImplementationStatus.scaffold || surface.status === SurfaceImplementationStatus.unavailable;
+}
+
+function normalizeSurfaceStatus(status) {
+  const value = String(status || SurfaceImplementationStatus.scaffold).trim();
+  return Object.values(SurfaceImplementationStatus).includes(value) ? value : SurfaceImplementationStatus.scaffold;
+}
+
+function normalizeBoundary(boundary) {
+  const values = Array.isArray(boundary) ? boundary : [boundary || SurfaceTruthBoundary.projectionOnly, SurfaceTruthBoundary.noTruthMutation];
+  return Object.freeze(values.map((item) => String(item || '').trim()).filter(Boolean));
+}

package/src/surfaces/create/CreateSurface.js

@@ -0,0 +1 @@
+export function CreateSurface() { return { surface: 'create', status: 'scaffold' }; }

package/src/surfaces/create/create.model.js

@@ -0,0 +1 @@
+export const createModel = Object.freeze({ id: 'create', kind: 'form' });

package/src/surfaces/create/create.render.js

@@ -0,0 +1 @@
+export function renderCreateSurface(model) { return model; }

package/src/surfaces/detail/DetailSurface.js

@@ -0,0 +1 @@
+export function DetailSurface() { return { surface: 'detail', status: 'scaffold' }; }

package/src/surfaces/detail/detail.model.js

@@ -0,0 +1 @@
+export const detailModel = Object.freeze({ id: 'detail', kind: 'detail' });

package/src/surfaces/detail/detail.render.js

@@ -0,0 +1 @@
+export function renderDetailSurface(model) { return model; }

package/src/surfaces/display-options/DisplayOptionsSurface.js

@@ -0,0 +1 @@
+export function DisplayOptionsSurface() { return { surface: 'display-options', status: 'scaffold' }; }

package/src/surfaces/display-options/displayOptions.model.js

@@ -0,0 +1 @@
+export const displayOptionsModel = Object.freeze({ id: 'display-options', kind: 'checklist' });

package/src/surfaces/display-options/displayOptions.render.js

@@ -0,0 +1 @@
+export function renderDisplayOptionsSurface(model) { return model; }

package/src/surfaces/edit/EditSurface.js

@@ -0,0 +1 @@
+export function EditSurface() { return { surface: 'edit', status: 'scaffold' }; }

package/src/surfaces/edit/edit.model.js

@@ -0,0 +1 @@
+export const editModel = Object.freeze({ id: 'edit', kind: 'form' });

package/src/surfaces/edit/edit.render.js

@@ -0,0 +1 @@
+export function renderEditSurface(model) { return model; }

package/src/surfaces/feed/FeedSurface.js

@@ -0,0 +1 @@
+export function FeedSurface() { return { surface: 'feed', verse: 'feed', status: 'verse-parity-scaffold' }; }

package/src/surfaces/feed/feed.model.js

@@ -0,0 +1 @@
+export const feedModel = Object.freeze({ id: 'feed', kind: 'card', verse: 'feed', arrangement: 'scan-order' });

package/src/surfaces/feed/feed.render.js

@@ -0,0 +1 @@
+export function renderFeedSurface(model) { return { ...model, projection: 'feed-verse', truthMutation: false }; }

package/src/surfaces/lineage/LineageSurface.js

@@ -0,0 +1 @@
+export function LineageSurface() { return { surface: 'lineage', status: 'scaffold' }; }

package/src/surfaces/lineage/lineage.model.js

@@ -0,0 +1 @@
+export const lineageModel = Object.freeze({ id: 'lineage', kind: 'graph' });

package/src/surfaces/lineage/lineage.render.js

@@ -0,0 +1 @@
+export function renderLineageSurface(model) { return model; }

package/src/surfaces/preview/PreviewSurface.js

@@ -0,0 +1 @@
+export function PreviewSurface() { return { surface: 'preview', status: 'scaffold' }; }

package/src/surfaces/preview/preview.model.js

@@ -0,0 +1 @@
+export const previewModel = Object.freeze({ id: 'preview', kind: 'detail' });

package/src/surfaces/preview/preview.render.js

@@ -0,0 +1 @@
+export function renderPreviewSurface(model) { return model; }

package/src/surfaces/registry.js

@@ -0,0 +1,58 @@
+import { SurfaceImplementationStatus, SurfaceTruthBoundary, defineSurface, isSurfaceReady, isSurfaceScaffold } from './contracts.js';
+
+const surfaces = [
+  defineSurface({ id: 'feed', kind: 'card', label: 'Feed', purpose: 'Scan current artifact set', status: SurfaceImplementationStatus.partial, owner: 'workspace.discoveryView + workspace.discovery.views', boundary: [SurfaceTruthBoundary.projectionOnly, SurfaceTruthBoundary.noTruthMutation], notes: ['Uses normalized workspace material; not yet full legacy Feed parity.'] }),
+  defineSurface({ id: 'tree', kind: 'tree', label: 'Tree', purpose: 'Navigate declared path and continuity structure', status: SurfaceImplementationStatus.partial, owner: 'workspace.discoveryView + workspace.pathTree', boundary: [SurfaceTruthBoundary.projectionOnly, SurfaceTruthBoundary.noTruthMutation], notes: ['Path-tree parity is partial; declared lineage graph parity remains separate.'] }),
+  defineSurface({ id: 'lineage', kind: 'graph', label: 'Lineage', purpose: 'Trace loaded-only lineage edges', status: SurfaceImplementationStatus.partial, owner: 'workspace.lineageView', boundary: [SurfaceTruthBoundary.projectionOnly, SurfaceTruthBoundary.noTruthMutation], notes: ['Loaded-only traversal is implemented; no remote traversal.'] }),
+  defineSurface({ id: 'audit', kind: 'audit-report', label: 'Audit', purpose: 'Display loaded-only audit and recoverability report', status: SurfaceImplementationStatus.partial, owner: 'workspace.auditView', boundary: [SurfaceTruthBoundary.projectionOnly, SurfaceTruthBoundary.noTruthMutation], notes: ['Loaded-only audit is implemented; full legacy traversal remains partial.'] }),
+  defineSurface({ id: 'detail', kind: 'detail', label: 'Detail', purpose: 'Read one artifact deeply', status: SurfaceImplementationStatus.partial, owner: 'workspace.recordDialogs.views + workspace.read.views', boundary: [SurfaceTruthBoundary.projectionOnly, SurfaceTruthBoundary.noTruthMutation], notes: ['Record detail/read sheet is implemented; final PoC/mobile readability remains a Q product gate.'] }),
+  defineSurface({ id: 'preview', kind: 'detail', label: 'Preview', purpose: 'Preview material or assets', status: SurfaceImplementationStatus.partial, owner: 'workspace.cards.views + storage.policy + source.assetReferences', boundary: [SurfaceTruthBoundary.projectionOnly, SurfaceTruthBoundary.noTruthMutation], notes: ['Local text/image asset preview is implemented; source-backed references preserve availability/source truth without inventing remote preview fetches.'] }),
+  defineSurface({ id: 'share', kind: 'card', label: 'Share', purpose: 'Project reconstructive share targets without mutating source material', status: SurfaceImplementationStatus.partial, owner: 'm3 share projection + TiinexApp share actions', boundary: [SurfaceTruthBoundary.projectionOnly, SurfaceTruthBoundary.commandRequired, SurfaceTruthBoundary.noTruthMutation], notes: ['Record/workspace share actions are implemented; final receiver/browser parity remains deferred.'] }),
+  defineSurface({ id: 'create', kind: 'form', label: 'Create', purpose: 'Create artifacts through qualified canonical Transition/schema authoring authority', status: SurfaceImplementationStatus.partial, owner: 'transition product preparation + workspace.canonicalTaskDialog.views', boundary: [SurfaceTruthBoundary.commandRequired, SurfaceTruthBoundary.noTruthMutation], notes: ['Contextual and bounded standalone canonical Create paths are implemented; broad PoC creation breadth is not a parity claim.'] }),
+  defineSurface({ id: 'edit', kind: 'form', label: 'Edit', purpose: 'Edit qualified browser-local draft artifacts', status: SurfaceImplementationStatus.partial, owner: 'localDraftMutationCommand + canonical Task authoring projection', boundary: [SurfaceTruthBoundary.commandRequired, SurfaceTruthBoundary.noTruthMutation], notes: ['Canonical local Task Edit is implemented through the existing lossless mutation owner; source-backed artifacts remain read-only.'] }),
+  defineSurface({ id: 'display-options', kind: 'checklist', label: 'Display Options', purpose: 'Control filters and reader density', status: SurfaceImplementationStatus.partial, owner: 'workspace.displayOptions + workspace.displayOptions.views', boundary: [SurfaceTruthBoundary.projectionOnly, SurfaceTruthBoundary.noTruthMutation], notes: ['Current loaded-workspace display/filter controls are implemented; bounded Time Portal preserves explicit temporal intent, exact GitHub snapshot identity, and read-only historical review without replacing live source truth.'] }),
+  defineSurface({ id: 'source-settings', kind: 'checklist', label: 'Source Settings', purpose: 'Plan, continue, and materialize bounded source configuration', status: SurfaceImplementationStatus.partial, owner: 'workspace.add.views + github source operation/materialization commands', boundary: [SurfaceTruthBoundary.commandRequired, SurfaceTruthBoundary.noTruthMutation], notes: ['GitHub source planning/continuation and boundary controls are implemented; broader PoC source-management parity remains deferred.'] })
+];
+
+export const surfaceRegistry = Object.freeze({
+  schema: 'tiinex.surface.registry.v1',
+  surfaces: Object.freeze(surfaces),
+  counts: Object.freeze({
+    total: surfaces.length,
+    parity: surfaces.filter((surface) => surface.status === SurfaceImplementationStatus.parity).length,
+    partial: surfaces.filter((surface) => surface.status === SurfaceImplementationStatus.partial).length,
+    scaffold: surfaces.filter((surface) => surface.status === SurfaceImplementationStatus.scaffold).length,
+    unavailable: surfaces.filter((surface) => surface.status === SurfaceImplementationStatus.unavailable).length,
+    ready: surfaces.filter(isSurfaceReady).length,
+    notReady: surfaces.filter(isSurfaceScaffold).length
+  })
+});
+
+export function surfaceLabels(options = {}) {
+  const includeScaffold = options.includeScaffold !== false;
+  return includeScaffold ? surfaceRegistry.surfaces : surfaceRegistry.surfaces.filter(isSurfaceReady);
+}
+
+export function resolveSurfaceDescriptor(surfaceId) {
+  const id = String(surfaceId || '').trim();
+  return surfaceRegistry.surfaces.find((surface) => surface.id === id) || null;
+}
+
+export function listSurfaceFindings() {
+  const findings = [];
+  for (const surface of surfaceRegistry.surfaces) {
+    if (isSurfaceScaffold(surface)) {
+      findings.push({
+        severity: 'info',
+        code: 'surface.status.scaffold',
+        surfaceId: surface.id,
+        message: `${surface.label} is registered as ${surface.status}; do not treat it as parity-ready.`,
+        source: 'tiinex.surface.registry.v1'
+      });
+    }
+    if (!surface.boundary.includes(SurfaceTruthBoundary.noTruthMutation)) {
+      findings.push({ severity: 'error', code: 'surface.boundary.truthMutation.missing', surfaceId: surface.id, message: `${surface.label} must declare no-truth-mutation unless backed by an explicit command.`, source: 'tiinex.surface.registry.v1' });
+    }
+  }
+  return findings;
+}

package/src/surfaces/share/ShareSurface.js

@@ -0,0 +1 @@
+export function ShareSurface() { return { surface: 'share', status: 'scaffold' }; }

package/src/surfaces/share/share.model.js

@@ -0,0 +1 @@
+export const shareModel = Object.freeze({ id: 'share', kind: 'card' });

package/src/surfaces/share/share.render.js

@@ -0,0 +1 @@
+export function renderShareSurface(model) { return model; }

package/src/surfaces/source-settings/SourceSettingsSurface.js

@@ -0,0 +1 @@
+export function SourceSettingsSurface() { return { surface: 'source-settings', status: 'scaffold' }; }

package/src/surfaces/source-settings/sourceSettings.model.js

@@ -0,0 +1 @@
+export const sourceSettingsModel = Object.freeze({ id: 'source-settings', kind: 'checklist' });

package/src/surfaces/source-settings/sourceSettings.render.js

@@ -0,0 +1 @@
+export function renderSourceSettingsSurface(model) { return model; }

package/src/surfaces/surfaceContext.js

@@ -0,0 +1 @@
+export function createSurfaceContext(surfaceId, readerMode = 'scan') { return { surfaceId, readerMode }; }

package/src/surfaces/tree/TreeSurface.js

@@ -0,0 +1 @@
+export function TreeSurface() { return { surface: 'tree', verse: 'tree', status: 'verse-parity-scaffold' }; }

package/src/surfaces/tree/tree.model.js

@@ -0,0 +1 @@
+export const treeModel = Object.freeze({ id: 'tree', kind: 'tree', verse: 'tree', arrangement: 'declared-continuity' });

package/src/surfaces/tree/tree.render.js

@@ -0,0 +1 @@
+export function renderTreeSurface(model) { return { ...model, projection: 'tree-verse', declaredEdgesOnly: true, truthMutation: false }; }

package/src/tooling/portable/adapters/cli/cli.common-output.case.mjs

@@ -0,0 +1,153 @@
+import assert from 'node:assert/strict';
+import { projectCommonCliDefaultOutput } from '@tiinex/core/tooling/portable/adapters/cli/cli.common-output.js';
+import { groundContinuationOperationInput } from '@tiinex/core/tooling/portable/adapters/cli/cli.ground-materialize.js';
+
+{
+  const full = {
+    schema: 'tiinex.portable.operation.result.v1',
+    operation: 'orient-handoff-package',
+    resultSchema: 'tiinex.portable.handoff-cold-consumer-orientation.v1',
+    status: 'ready',
+    workspaces: [{ id: 'site', title: 'site', qualification: 'qualified' }],
+    routes: [{ id: 'route:site', state: 'qualified', workspaceId: 'site', workspaceRelativeHandoffPath: '.topics/handoff.trace.md', from: 'Anchor', to: 'Loom', pointerPath: '001-pointer.trace.md', requiredClosure: { requirements: [{ body: 'large' }] } }],
+    selection: { qualifiedRouteCount: 1, implicitRouteId: 'route:site' },
+    carrierLineage: { mode: 'continue', dimension: '007-1', parentDimension: '007', checkpointKind: 'progression', authority: 'human-progress-projection-only', boundary: 'large' },
+    endpointRoles: [{ body: 'large endpoint receipt' }],
+    entrypoint: { projection: { authority: { semanticAuthority: 'none', packageTruthRequired: true } } },
+    findings: [],
+    findingSummary: { counts: { error: 0, warning: 0, total: 0 } }
+  };
+  const parsed = { command: 'orient-handoff-package', surfaceCommand: 'orient', positionals: ['/tmp/carrier.zip'], flags: {} };
+  const compact = projectCommonCliDefaultOutput(full, parsed);
+  assert.equal(compact.projection, 'common-default');
+  assert.equal(compact.routes[0].pointerPath, '001-pointer.trace.md');
+  assert.deepEqual(compact.nextAction, { command: 'ground', package: '/tmp/carrier.zip', route: '001-pointer.trace.md' });
+  assert.equal('endpointRoles' in compact, false);
+  assert.equal('requiredClosure' in compact.routes[0], false);
+  assert.equal(compact.authority.semanticAuthority, 'none');
+  assert.equal(projectCommonCliDefaultOutput(full, { ...parsed, flags: { full: true } }), full, '--full must preserve the complete qualified receipt');
+}
+
+{
+  const full = {
+    schema: 'tiinex.portable.operation.result.v1',
+    operation: 'project-grounding-readiness',
+    resultSchema: 'tiinex.portable.grounding-readiness.v1',
+    status: 'ready',
+    readiness: { state: 'grounded-to-act', reasons: [{ code: 'bounded-act-ready', message: 'Ready.' }], missingEvidence: [], nextAction: { kind: 'continue-bounded-handoff-work', target: 'site/.topics/task.trace.md' } },
+    authority: {
+      state: 'degraded',
+      route: { id: 'route:site', pointerPath: '001-pointer.trace.md', workspaceId: 'site' },
+      handoff: { purpose: 'Do bounded work.', from: 'Anchor', to: 'Loom', completionExpectation: { returnTo: 'Anchor' } },
+      role: { state: 'qualified', label: 'Loom', kind: 'role' },
+      operationBoundary: { sourceMutation: false, remoteWrite: false, semanticAuthority: 'Handoff/Task/Role govern.', boundary: 'Grounding only.' }
+    },
+    coverage: { requiredContext: { declared: 2, matchedInWorkspaceSnapshots: 2, missingFromWorkspaceSnapshots: 0, items: [
+      { requirementId: 'required:a', name: 'a', state: 'qualified', workspaceId: 'site', innerPath: '.topics/a.md', contentProjected: false },
+      { requirementId: 'required:b', name: 'b', state: 'qualified', workspaceId: 'site', innerPath: '.topics/b.md', contentProjected: true, content: '# Exact requested body' }
+    ], bodiesProjected: 1, bodiesAvailable: 2 } },
+    capsule: { schema: 'tiinex.portable.grounding-capsule.v1', semanticReductions: [{ id: 'required:a', title: 'Context A', signals: [] }], frontier: { state: 'resolved' }, exclusions: [], sourceEvidence: { carrier: { state: 'qualified' }, workspaces: [] }, roleState: { recipient: 'Loom', holder: 'Loom' }, unresolved: [{ slot: 'organizational-work-provenance', state: 'unresolved' }], boundary: 'bounded' },
+    currentWork: { state: 'current-frontier-resolved', frontier: [{ id: 'site/.topics/task.trace.md', path: 'site/.topics/task.trace.md', title: 'Task', declaredStatus: 'ready/local', contentProjected: true, content: '# Current task body' }], blockers: [] },
+    continuity: { state: 'qualified', proof: { roots: [{ id: 'root', path: 'site/.topics/root.md', title: 'Root', schemaId: 'tiinex.decision.v1', declaresParent: false, hasContinuityContext: true, hasIntegrity: true }] }, blockingIssues: [], recovery: { state: 'not-required' }, losses: { state: 'none', blocking: false, items: [] } },
+    lineage: { large: 'receipt' },
+    evidence: { large: 'receipt' },
+    findings: [],
+    actionableFindings: [],
+    findingSummary: { counts: { error: 0, warning: 0, total: 0 } },
+    continuationMaterialization: { state: 'materialized', workspaceId: 'site', outputDir: '/tmp/site', fileCount: 10 }
+  };
+  const compact = projectCommonCliDefaultOutput(full, { command: 'project-grounding-readiness', surfaceCommand: 'ground', positionals: ['/tmp/carrier.zip'], flags: { route: '001-pointer.trace.md', continue: '/tmp/site' } });
+  assert.equal(compact.readiness.state, 'grounded-to-act');
+  assert.equal(compact.authority.role.label, 'Loom');
+  assert.equal(compact.requiredContext.missingFromWorkspaceSnapshots, 0);
+  assert.equal(compact.requiredContext.items.length, 0, 'ordinary continuation must not repeat qualified Required Context item paths by default');
+  assert.equal(compact.requiredContext.itemsOmitted, 2);
+  assert.equal(compact.capsule.semanticReductions[0].title, 'Context A');
+  assert.equal(compact.capsule.unresolved[0].slot, 'organizational-work-provenance');
+  assert.equal(compact.currentWork.frontier[0].content, '# Current task body');
+  assert.equal(compact.continuity.state, 'qualified');
+  assert.equal(compact.continuity.roots.length, 0, 'ordinary continuation must not repeat already-qualified root-detail receipts');
+  assert.equal(compact.continuity.rootsOmitted, 1);
+  assert.equal(compact.continuationMaterialization.state, 'materialized');
+  assert.equal('lineage' in compact, false);
+  assert.equal('evidence' in compact, false);
+
+  const explicit = projectCommonCliDefaultOutput(full, { command: 'project-grounding-readiness', surfaceCommand: 'ground', positionals: ['/tmp/carrier.zip'], flags: { route: '001-pointer.trace.md', continue: '/tmp/site', 'include-required-context': 'required:b' } });
+  assert.equal(explicit.requiredContext.items.length, 2, 'explicit Required Context projection must retain item metadata/body in continuation output');
+  assert.equal(explicit.requiredContext.items[1].content, '# Exact requested body');
+}
+
+{
+  const ordinary = groundContinuationOperationInput({ includeRequiredContext: '' }, { continue: '/tmp/site' });
+  assert.equal(ordinary.includeRequiredContext, '', 'ordinary ground --continue must not auto-project every Required Context body');
+  assert.equal(ordinary.includeCurrentWork, true, 'ordinary ground --continue must still project bounded current work');
+  const full = groundContinuationOperationInput({ includeRequiredContext: '' }, { continue: '/tmp/site', full: true });
+  assert.equal(full.includeRequiredContext, 'all', '--full ground --continue must retain the legacy full body-scale receipt path');
+  const selected = groundContinuationOperationInput({ includeRequiredContext: '' }, { continue: '/tmp/site', 'include-required-context': 'required:a' });
+  assert.equal(selected.includeRequiredContext, 'required:a', 'explicit Required Context selection must override compact default behavior');
+}
+
+{
+  const full = {
+    schema: 'tiinex.portable.operation.result.v1',
+    operation: 'manufacture-handoff-package',
+    resultSchema: 'tiinex.portable.handoff-manufacturing.v2',
+    status: 'ready',
+    verification: { roundtrip: 'passed', toolingBootstrap: 'valid' },
+    planSummary: { status: 'ready', requiredClosureReady: true, semanticHandoffStatus: 'unknown', required: [{ id: 'a' }], reference: [], workspaces: [{ id: 'site', materialization: 'complete', qualification: 'qualified', entryCount: 10, completenessState: 'qualified', noisy: 'large' }] },
+    carrierProjection: { status: 'ready', mode: 'single', lineage: { mode: 'continue', dimension: '007-2', parentDimension: '007-1', checkpointKind: 'progression', authority: 'human-progress-projection-only' }, routes: [{ id: 'route:return', state: 'qualified', workspaceId: 'site', workspaceRelativePath: '.topics/return.trace.md', from: 'Loom', to: 'Anchor', projectedFilename: 'return.handoff-package.zip', large: 'receipt' }] },
+    primaryOutput: { status: 'written', path: '/tmp/return.handoff-package.zip', bytes: 1000, projectedFilename: 'return.handoff-package.zip', selectedRoute: '.topics/return.trace.md' },
+    humanOutput: {
+      normalInlineRouting: { kind: 'transport-text', content: 'Handoff package attached.\n', normalEmission: true, authority: 'none' },
+      sharedRouting: { mode: 'one-shared-package-many-exact-route-texts', primary: { filename: 'return.handoff-package.zip' }, routes: [{ routeId: 'route:return', transportText: 'route text', authority: 'none' }], selectionAuthority: 'exact-qualified-route-only', siblingInference: false, readOnly: true },
+      presentation: { copyableSurfaceRequired: true, exactContentRequired: true, fencedCodeBlockWhenSupported: 'required', markdownCapableHostRendering: 'fenced-code-block', wrapperAuthority: 'none' },
+      normalEmissionBoundary: { allowed: ['primary', 'normalInlineRouting'], canonicalFilePayloadCount: 1, workspaceArtifactsAsLooseTransportFiles: false, semanticWorkSummaryProse: false, helperArtifacts: false, manuallyReconstructedRouting: false, duplicateNormalFileChoices: false },
+      internal: { large: 'receipt' }
+    },
+    roundtripSummary: { status: 'passed' },
+    toolingBootstrapInspection: { status: 'valid', delivery: 'embedded', counts: { errors: 0 }, qualification: { large: 'receipt' } },
+    operationBoundary: { sourceMutation: false, remoteMutation: false },
+    manufacturingEvidence: { huge: 'receipt' },
+    findingSummary: { counts: { error: 0, warning: 0, total: 0 } },
+    findings: []
+  };
+  const parsed = { command: 'manufacture-handoff-package', surfaceCommand: 'handoff', positionals: ['/tmp/site'], flags: {} };
+  const compact = projectCommonCliDefaultOutput(full, parsed);
+  assert.equal(compact.projection, 'common-default');
+  assert.equal(compact.transport.primary.path, '/tmp/return.handoff-package.zip');
+  assert.equal(compact.transport.routing.content, 'Handoff package attached.\n');
+  assert.equal(compact.transport.sharedRouting.selectionAuthority, 'exact-qualified-route-only');
+  assert.equal(compact.transport.sharedRouting.siblingInference, false);
+  assert.equal(compact.transport.presentation.markdownCapableHostRendering, 'fenced-code-block');
+  assert.equal(compact.transport.normalEmission.canonicalFilePayloadCount, 1);
+  assert.equal(compact.transport.normalEmission.workspaceArtifactsAsLooseTransportFiles, false);
+  assert.equal(compact.closure.requiredClosureReady, true);
+  assert.equal(compact.carrier.route.to, 'Anchor');
+  assert.equal('manufacturingEvidence' in compact, false);
+  assert.equal(compact.detail.fullReceipt.workspace, '/tmp/site');
+  assert.equal(projectCommonCliDefaultOutput(full, { ...parsed, flags: { full: true } }), full, 'public handoff --full must preserve the complete manufacture receipt');
+  assert.equal(projectCommonCliDefaultOutput(full, { ...parsed, surfaceCommand: 'manufacture-handoff-package' }), full, 'advanced manufacture operation must retain its existing default receipt contract');
+}
+
+{
+  const blocked = projectCommonCliDefaultOutput({
+    schema: 'tiinex.portable.operation.result.v1',
+    operation: 'project-grounding-readiness',
+    resultSchema: 'tiinex.portable.grounding-readiness.v1',
+    status: 'blocked',
+    readiness: { state: 'grounded-to-discuss', reasons: [{ code: 'required-context-missing', message: 'Required material is missing.' }], missingEvidence: ['required:missing'], nextAction: { kind: 'recover-required-context', target: 'required:missing' } },
+    authority: { route: {}, handoff: {}, role: {}, operationBoundary: {} },
+    coverage: { requiredContext: { declared: 1, matchedInWorkspaceSnapshots: 0, missingFromWorkspaceSnapshots: 1, items: [{ requirementId: 'required:missing', name: 'missing', state: 'missing' }] } },
+    currentWork: { state: 'blocked', frontier: [], blockers: [{ kind: 'required-context', text: 'Recover missing material.' }] },
+    continuity: { state: 'blocked', proof: { roots: [] }, blockingIssues: [{ code: 'parent-unresolved' }], recovery: { state: 'host-action-available', hostAction: { action: 'repository-read', request: { path: '.topics/missing.trace.md' } } }, losses: { state: 'none', blocking: false, items: [] } },
+    findings: [{ severity: 'error', code: 'required-context.missing', message: 'Recover the exact required context before acting.' }],
+    findingSummary: { status: 'invalid', counts: { error: 1, warning: 0, total: 1 } }
+  }, { command: 'project-grounding-readiness', surfaceCommand: 'ground', positionals: ['/tmp/carrier.zip'], flags: { route: '001-pointer.trace.md' } });
+  assert.equal(blocked.readiness.state, 'grounded-to-discuss');
+  assert.equal(blocked.requiredContext.missingFromWorkspaceSnapshots, 1);
+  assert.equal(blocked.continuity.recovery.state, 'host-action-available');
+  assert.equal(blocked.actionableFindings[0].code, 'required-context.missing');
+  assert.equal(blocked.actionableFindings[0].message, 'Recover the exact required context before acting.');
+}
+
+console.log('✓ common CLI decision-first default projection and explicit --full detail path passed');

package/src/tooling/portable/adapters/cli/cli.handoff-sibling-allocation.case.mjs

@@ -0,0 +1,52 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, rm } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { reserveHandoffSiblingIndex } from '@tiinex/core/tooling/portable/adapters/cli/cli.handoff-sibling-allocation.js';
+
+const root = await mkdtemp(path.join(os.tmpdir(), 'tiinex-sibling-allocation-'));
+try {
+  const parentPackagePath = path.join(root, 'parent.handoff-package.zip');
+  const parentPackageSha256 = 'a'.repeat(64);
+  const parentDimension = '009-2';
+  const first = await reserveHandoffSiblingIndex({ parentPackagePath, parentPackageSha256, parentDimension });
+  const retry = await reserveHandoffSiblingIndex({ parentPackagePath, parentPackageSha256, parentDimension });
+  assert.equal(first.siblingIndex, 1);
+  assert.equal(retry.siblingIndex, 2, 'a retry after a claimed slot must not reuse the prior sibling dimension');
+
+  const concurrent = await Promise.all(Array.from({ length: 16 }, () => reserveHandoffSiblingIndex({ parentPackagePath, parentPackageSha256, parentDimension })));
+  const concurrentIndexes = concurrent.map((item) => item.siblingIndex);
+  assert.equal(new Set(concurrentIndexes).size, concurrentIndexes.length, 'atomic reservation must prevent concurrent sibling collisions');
+  assert.deepEqual([...concurrentIndexes].sort((a, b) => a - b), Array.from({ length: 16 }, (_, index) => index + 3));
+
+  const differentParentIdentity = await reserveHandoffSiblingIndex({
+    parentPackagePath,
+    parentPackageSha256: 'b'.repeat(64),
+    parentDimension
+  });
+  assert.equal(differentParentIdentity.siblingIndex, 1, 'allocation authority is scoped to exact parent package identity');
+
+  const differentParentDimension = await reserveHandoffSiblingIndex({
+    parentPackagePath,
+    parentPackageSha256,
+    parentDimension: '009-3'
+  });
+  assert.equal(differentParentDimension.siblingIndex, 1, 'allocation authority is also scoped to the exact parent dimension');
+
+  const routeMetadataIgnored = await reserveHandoffSiblingIndex({
+    parentPackagePath,
+    parentPackageSha256: 'c'.repeat(64),
+    parentDimension,
+    routeOrder: ['route-b', 'route-a'],
+    routeId: 'route-b'
+  });
+  assert.equal(routeMetadataIgnored.siblingIndex, 1, 'route order and route identity are not allocation authority');
+
+  const disabled = await reserveHandoffSiblingIndex({ parentPackagePath, parentPackageSha256, parentDimension, enabled: false });
+  assert.equal(disabled.state, 'not-reserved');
+  assert.equal(disabled.siblingIndex, 1);
+
+  console.log('✓ sibling allocation regression: retry/concurrency/exact-parent safety preserved without route-order authority');
+} finally {
+  await rm(root, { recursive: true, force: true });
+}