@tiinex/core 0.20.0 → 0.22.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiinex/core",
-  "version": "0.20.0",
+  "version": "0.22.0",
   "description": "Shared host-neutral Tiinex implementation core for artifacts, schemas, validation, lineage, grounding, Handoffs, provenance and deterministic workflows.",
   "type": "module",
   "sideEffects": true,
@@ -172,12 +172,12 @@
     "type": "git",
     "url": "git+https://github.com/Tiinex/core.git"
   },
-  "gitHead": "75e2e1e324fbe2e652a5c94f877ce6bf68e4a521",
+  "gitHead": "8a8e2e2e1b04eae1e5038116c69a449ad8f01349",
   "tiinexRelease": {
     "policy": "tiinex.master-npm-release.v1",
-    "sourceCommit": "75e2e1e324fbe2e652a5c94f877ce6bf68e4a521",
-    "sourceTree": "3138e1fdb8c064ec3417a55a731310aa8efd66b8",
+    "sourceCommit": "8a8e2e2e1b04eae1e5038116c69a449ad8f01349",
+    "sourceTree": "4596c4e041fb7c7067854f60c7daf68fd631e1f2",
     "repository": "Tiinex/core",
-    "previousVersion": "0.19.0"
+    "previousVersion": "0.21.0"
   }
 }

package/src/tooling/portable/editor/editor.assistance.js

@@ -4,6 +4,7 @@ import { sha256Hex } from '../../../export/package.bytes.js';
 import { integrityMethodReferenceAuthorityForCreation } from '../../../integrity/integrity.methodReference.js';
 import { inspectPortableLineageIntegrity } from '../lineage/lineage.integrity.plan.js';
 import { portableFinding } from '../findings.js';
+import { qualifyTiinexRouteArtifact } from '../handoff/routeArtifactConformance.js';
 
 export const PORTABLE_EDITOR_ASSISTANCE_SCHEMA_ID = 'tiinex.portable.editor-assistance.v1';
 
@@ -28,11 +29,26 @@ function projectDocument(record = {}, records = [], lineageInspection = null) {
   const markdown = String(record.markdown || '');
   const recordPath = norm(record.path || record.id || '');
   const lineageFindings = findingsForPath(lineageInspection?.findings || [], recordPath);
-  const sharedFindings = [...(audit.findings || []), ...lineageFindings];
+  const workspaceConformance = String(audit.schemaId || '') === 'tiinex.workspace.v1'
+    ? qualifyTiinexRouteArtifact({ markdown, expectedSchemaId: 'tiinex.workspace.v1', requireExactContract: true })
+    : null;
+  const packageQualifiedWorkspace = workspaceConformance?.status === 'qualified';
+  const sharedFindings = [...(audit.findings || []), ...lineageFindings].filter((finding) => !(packageQualifiedWorkspace && String(finding?.code || '') === 'audit.schema-authority.unqualified'));
   const diagnostics = sharedFindings
     .filter((item) => item.severity === 'error' || item.severity === 'warning')
     .map((finding) => projectDiagnostic(finding, markdown));
   const actions = [];
+  const workspacePackagingRepair = deterministicWorkspacePackagingRepair(record, audit, markdown);
+  if (workspacePackagingRepair.state === 'ready' && workspacePackagingRepair.markdown !== markdown) actions.push(freeze({
+    id: 'normalize-workspace-schema-and-self-integrity',
+    title: workspacePackagingRepair.schemaReferenceChanged ? 'Repair Workspace schema reference and self integrity' : 'Repair Workspace self integrity',
+    kind: 'replace-document',
+    qualification: 'deterministic-shared-core',
+    sourceSha256: sha256Hex(new TextEncoder().encode(markdown)),
+    replacementMarkdown: workspacePackagingRepair.markdown,
+    diagnosticCodes: workspacePackagingRepair.diagnosticCodes,
+    boundary: 'Repairs only a tiinex.workspace.v1 artifact whose replacement independently qualifies through the same exact registered Workspace contract and c14n-v2 self-integrity requirements used by Handoff package manufacture. A linked Current Schema target is normalized to the registered schema identifier only when the linked target itself is not qualified; no repository, Workspace, Handoff, Role, or authority meaning is invented.'
+  }));
   const integrityRepair = deterministicIntegrityHygieneRepair(markdown, audit.findings || []);
   const repairQualification = integrityRepair.state === 'ready'
     ? qualifyReplacementAgainstSharedGuardrails(record, records, integrityRepair.markdown)
@@ -54,13 +70,13 @@ function projectDocument(record = {}, records = [], lineageInspection = null) {
     path: String(record.path || record.id || ''),
     schemaId: String(audit.schemaId || ''),
     validator: {
-      state: audit.qualification?.exact && validationAuthority?.state === 'qualified' ? 'qualified-exact' : 'degraded',
+      state: packageQualifiedWorkspace || (audit.qualification?.exact && validationAuthority?.state === 'qualified') ? 'qualified-exact' : 'degraded',
       requestedSchema: String(audit.qualification?.requestedSchema || audit.schemaId || ''),
       resolvedThrough: String(audit.qualification?.resolvedThrough || ''),
       fallbackUsed: Boolean(audit.qualification?.fallback?.used),
-      authorityState: String(validationAuthority?.state || 'unavailable'),
-      authorityBasis: String(validationAuthority?.currentReference?.basis || ''),
-      authorityFindings: [...(validationAuthority?.findings || [])]
+      authorityState: packageQualifiedWorkspace ? 'qualified-package-conformance' : String(validationAuthority?.state || 'unavailable'),
+      authorityBasis: packageQualifiedWorkspace ? 'registered-workspace-contract+self-integrity' : String(validationAuthority?.currentReference?.basis || ''),
+      authorityFindings: packageQualifiedWorkspace ? [] : [...(validationAuthority?.findings || [])]
     },
     diagnostics,
     actions
@@ -72,6 +88,37 @@ function findingsForPath(findings = [], path = '') {
   return (findings || []).filter((finding) => norm(finding?.evidencePath || finding?.ref || '') === wanted);
 }
 
+function deterministicWorkspacePackagingRepair(record = {}, audit = {}, markdown = '') {
+  if (String(audit.schemaId || '') !== 'tiinex.workspace.v1') return freeze({ state: 'unavailable' });
+  const source = String(markdown || '');
+  if (!source) return freeze({ state: 'unavailable' });
+  const currentMatches = [...source.matchAll(/^(\s*-\s+Current Schema:\s*)(.*)$/gm)];
+  if (currentMatches.length !== 1) return freeze({ state: 'unavailable' });
+  const currentRaw = String(currentMatches[0][2] || '').trim();
+  const linked = currentRaw.match(/^\[tiinex\.workspace\.v1\]\(([^)]+)\)$/);
+  const bare = currentRaw === 'tiinex.workspace.v1';
+  if (!linked && !bare) return freeze({ state: 'unavailable' });
+
+  let candidate = source;
+  let schemaReferenceChanged = false;
+  const schemaAuthorityUnqualified = (audit.findings || []).some((item) => String(item.code || '') === 'audit.schema-authority.unqualified');
+  if (linked && schemaAuthorityUnqualified) {
+    candidate = candidate.replace(currentMatches[0][0], `${currentMatches[0][1]}tiinex.workspace.v1`);
+    schemaReferenceChanged = true;
+  }
+
+  const sealed = sealC14nV2Self(candidate);
+  if (sealed.state !== 'sealed' && sealed.state !== 'unchanged') return freeze({ state: 'unavailable' });
+  candidate = String(sealed.markdown || candidate);
+  const conformance = qualifyTiinexRouteArtifact({ markdown: candidate, expectedSchemaId: 'tiinex.workspace.v1', requireExactContract: true });
+  if (conformance.status !== 'qualified') return freeze({ state: 'blocked', reasons: (conformance.findings || []).map((item) => String(item.code || '')) });
+  const diagnosticCodes = [...new Set([
+    ...(audit.findings || []).filter((item) => /schema-authority|integrity/i.test(String(item.code || ''))).map((item) => String(item.code || '')),
+    'portable.lineage-integrity.child-self-mismatch'
+  ].filter(Boolean))];
+  return freeze({ state: 'ready', markdown: candidate, schemaReferenceChanged, diagnosticCodes });
+}
+
 function qualifyReplacementAgainstSharedGuardrails(record = {}, records = [], replacementMarkdown = '') {
   const focusPath = norm(record.path || record.id || '');
   if (!focusPath || !replacementMarkdown) return freeze({ state: 'unavailable', reason: 'replacement-or-focus-unavailable' });
@@ -99,11 +146,23 @@ function projectDiagnostic(finding = {}, markdown = '') {
     message: String(finding.message || 'Tiinex validation finding.'),
     fixability: String(finding.fixability || 'unknown'),
     line: located.line,
+    sourceRange: located.sourceRange,
     locationState: located.state,
     locationBasis: located.basis
   });
 }
 
+function locatedLine(lines = [], index = -1, state = 'deterministic', basis = '') {
+  if (!Number.isInteger(index) || index < 0 || index >= lines.length) return freeze({ state: 'unresolved', line: null, sourceRange: null, basis: basis || 'line-unavailable' });
+  const text = String(lines[index] || '');
+  return freeze({
+    state,
+    line: index + 1,
+    sourceRange: { startLine: index + 1, startColumn: 1, endLine: index + 1, endColumn: text.length + 1 },
+    basis
+  });
+}
+
 export function locateFindingLine(finding = {}, markdown = '') {
   const lines = String(markdown || '').replace(/\r\n?/g, '\n').split('\n');
   const params = finding.params || finding;
@@ -113,43 +172,43 @@ export function locateFindingLine(finding = {}, markdown = '') {
   const group = String(params.group || '').trim();
   if (field) {
     const index = lines.findIndex((line) => new RegExp(`^\\s*-\\s+${escapeRegExp(field)}\\s*:`).test(line));
-    if (index >= 0) return freeze({ state: 'deterministic', line: index + 1, basis: `field:${field}` });
+    if (index >= 0) return locatedLine(lines, index, 'deterministic', `field:${field}`);
   }
   for (const owner of [section, heading, group].filter(Boolean)) {
     const sectionIndex = lines.findIndex((line) => new RegExp(`^#{2,6}\\s+${escapeRegExp(owner)}\\s*$`, 'i').test(line));
-    if (sectionIndex >= 0) return freeze({ state: section || heading ? 'deterministic' : 'deterministic-anchor', line: sectionIndex + 1, basis: `${section || heading ? 'section' : 'owning-section'}:${owner}` });
+    if (sectionIndex >= 0) return locatedLine(lines, sectionIndex, section || heading ? 'deterministic' : 'deterministic-anchor', `${section || heading ? 'section' : 'owning-section'}:${owner}`);
     const envelopeIndex = lines.findIndex((line) => new RegExp(`^\\s*-\\s+${escapeRegExp(owner)}(?:\\s*:.*)?\\s*$`, 'i').test(line));
-    if (envelopeIndex >= 0) return freeze({ state: 'deterministic-anchor', line: envelopeIndex + 1, basis: `envelope-owner:${owner}` });
+    if (envelopeIndex >= 0) return locatedLine(lines, envelopeIndex, 'deterministic-anchor', `envelope-owner:${owner}`);
   }
   const code = String(finding.code || '');
   if (code.includes('schema.') || code.endsWith('.schema.mismatch') || code === 'audit.schema-authority.unqualified') {
     const index = lines.findIndex((line) => /^\s*-\s+Current Schema\s*:/.test(line));
-    if (index >= 0) return freeze({ state: 'deterministic', line: index + 1, basis: 'current-schema-field' });
+    if (index >= 0) return locatedLine(lines, index, 'deterministic', 'current-schema-field');
   }
   if (code === 'integrity.method-reference.unqualified') {
     const headingIndex = lines.findIndex((line) => line.trim() === '# Continuity Integrity');
     const methodIndex = lines.findIndex((line, index) => index > headingIndex && /^\s*-\s+\[sha256-base64url-c14n-v2\]\([^)]+\)\s*$/.test(line));
-    if (methodIndex >= 0) return freeze({ state: 'deterministic', line: methodIndex + 1, basis: 'continuity-integrity-method-reference' });
+    if (methodIndex >= 0) return locatedLine(lines, methodIndex, 'deterministic', 'continuity-integrity-method-reference');
   }
   if (code.includes('integrity') || /integrity|checksum|digest/i.test(String(finding.message || ''))) {
     const headingIndex = lines.findIndex((line) => line.trim() === '# Continuity Integrity');
     if (headingIndex >= 0) {
       const index = lines.findIndex((line, i) => i > headingIndex && /^\s+-\s+Value\s*:/.test(line));
-      if (index >= 0) return freeze({ state: 'deterministic', line: index + 1, basis: 'continuity-integrity-value' });
-      return freeze({ state: 'deterministic-anchor', line: headingIndex + 1, basis: 'continuity-integrity-heading' });
+      if (index >= 0) return locatedLine(lines, index, 'deterministic', 'continuity-integrity-value');
+      return locatedLine(lines, headingIndex, 'deterministic-anchor', 'continuity-integrity-heading');
     }
   }
   if (/^(portable\.contract\.|root\.|integrity\.)/i.test(code) && (/missing|required|incomplete/i.test(code) || /\bmissing\b|\brequired\b/i.test(String(finding.message || '')))) {
     const bodyHeading = lines.findIndex((line) => /^#\s+\S/.test(line) && !/^#\s+Continuity (?:Context|Integrity)\s*$/.test(line));
-    if (bodyHeading >= 0) return freeze({ state: 'deterministic-anchor', line: bodyHeading + 1, basis: section ? `body-heading-for-missing-section:${section}` : field ? `body-heading-for-missing-field:${field}` : 'body-heading-for-missing-required-content' });
+    if (bodyHeading >= 0) return locatedLine(lines, bodyHeading, 'deterministic-anchor', section ? `body-heading-for-missing-section:${section}` : field ? `body-heading-for-missing-field:${field}` : 'body-heading-for-missing-required-content');
     const contextHeading = lines.findIndex((line) => line.trim() === '# Continuity Context');
-    if (contextHeading >= 0) return freeze({ state: 'deterministic-anchor', line: contextHeading + 1, basis: 'continuity-context-for-missing-required-content' });
+    if (contextHeading >= 0) return locatedLine(lines, contextHeading, 'deterministic-anchor', 'continuity-context-for-missing-required-content');
   }
   if (/\.body\.|body/i.test(code) || /\bbody\b/i.test(String(finding.message || ''))) {
     const bodyHeading = lines.findIndex((line) => /^#\s+\S/.test(line) && !/^#\s+Continuity (?:Context|Integrity)\s*$/.test(line));
-    if (bodyHeading >= 0) return freeze({ state: 'deterministic-anchor', line: bodyHeading + 1, basis: 'body-heading-for-body-finding' });
+    if (bodyHeading >= 0) return locatedLine(lines, bodyHeading, 'deterministic-anchor', 'body-heading-for-body-finding');
   }
-  return freeze({ state: 'unresolved', line: null, basis: 'shared-finding-has-no-deterministic-line-evidence' });
+  return freeze({ state: 'unresolved', line: null, sourceRange: null, basis: 'shared-finding-has-no-deterministic-line-evidence' });
 }
 
 function deterministicIntegrityHygieneRepair(markdown = '', findings = []) {

package/src/tooling/portable/grounding/grounding.delegationArtifactAuthority.js

@@ -15,12 +15,18 @@ export function projectGroundingDelegationArtifactAuthority({ authority = null,
   const sender = qualifiedRole(senderRole, handoff.fromReference || '');
   if (!sender) unresolved.push('exact-sender-role-authority-not-established');
 
+  const delegateSelection = transferSelection ? selectForwardDelegate(transferSelection.record, authority) : null;
+  if (transferSelection && !delegateSelection?.selector) unresolved.push('forward-delegate-selector-not-established');
+  if (delegateSelection?.selector && !delegateSelection?.role) unresolved.push('exact-forward-selected-delegate-role-authority-not-established');
+
   const taskRecord = transferSelection?.record || null;
   const targetWorkspaceId = String(taskRecord?.path || '').split('/')[0] || '';
   const workspaceSource = (sourceEvidence?.workspaces || []).find((item) => String(item.workspace || '') === targetWorkspaceId && ['qualified', 'explicit-profile'].includes(String(item.state || ''))) || null;
   if (!workspaceSource?.repository) unresolved.push('exact-target-repository-authority-not-established');
 
-  const delegateCapabilityAuthority = recipient && transferSelection ? delegateProjection(recipient, handoff, transferSelection) : null;
+  const delegateCapabilityAuthority = delegateSelection?.role && delegateSelection?.selector && transferSelection
+    ? delegateProjection(delegateSelection.role, handoff, transferSelection, delegateSelection.selector)
+    : null;
   if (!delegateCapabilityAuthority) unresolved.push('delegate-capability-artifact-projection-not-established');
 
   const processApplicability = sender && transferSelection ? processProjection(sender, handoff, transferSelection) : null;
@@ -56,9 +62,11 @@ export function projectGroundingDelegationArtifactAuthority({ authority = null,
       controllingTask: taskRecord ? sourceArtifactFromRecord(taskRecord) : null,
       senderRole: sender ? sender.sourceArtifact : null,
       recipientRole: recipient ? recipient.sourceArtifact : null,
-      boundary: 'Projection only. Exact Handoff transfer, exact endpoint Role authority, exact controlling Task and exact Workspace source identity are composed mechanically; Role/cache inventory, filenames, adjacency and arbitrary prose are never searched for delegation meaning.'
+      delegateSelector: delegateSelection?.selector || null,
+      delegateRole: delegateSelection?.role?.sourceArtifact || null,
+      boundary: 'Projection only. The inbound Handoff recipient/current holder and downstream specialist are independent claims. The downstream Role is resolved only after one exact explicit selector declaration on the controlling current Task; route-bounded Role material then qualifies that already-selected Role. Role/cache inventory, endpoint identity, filenames, adjacency and arbitrary prose are never used to choose a delegate.'
     }),
-    boundary: 'Artifact-derived delegation closure is available only from the exact selected forward chain. It does not select a delegate, invent a process, create source permission, or treat an endpoint alone as delegation authority.'
+    boundary: 'Artifact-derived delegation closure is available only from the exact selected forward chain. The current-work declaration selects the downstream Role; exact Role material qualifies capability. Inbound recipient/holder identity, Role-cache carriage, process applicability, source permission and return authority remain separate.'
   });
 }
 
@@ -96,7 +104,85 @@ function qualifiedRole(role, declaredReference = '') {
   });
 }
 
-function delegateProjection(role, handoff, selected) {
+function selectForwardDelegate(taskRecord, authority = {}) {
+  const selector = explicitTaskSpecialistSelector(taskRecord);
+  if (!selector) return Object.freeze({ selector: null, role: null, candidates: Object.freeze([]) });
+  const candidates = exactRouteRoleMaterials(authority).filter((role) => normalize(role.label) === normalize(selector.roleLabel));
+  const unique = dedupeRoles(candidates);
+  return Object.freeze({ selector, role: unique.length === 1 ? unique[0] : null, candidates: Object.freeze(unique) });
+}
+
+function explicitTaskSpecialistSelector(taskRecord = {}) {
+  if (String(taskRecord.schemaId || '') !== 'tiinex.task.v1' || !taskRecord.hasContinuityContext || !taskRecord.hasIntegrity) return null;
+  const objective = section(taskRecord.markdown || '', 'Objective');
+  if (!objective) return null;
+  const declarations = objective
+    .split(/\r?\n\s*\r?\n/u)
+    .map((item) => item.trim())
+    .filter(Boolean)
+    .flatMap((paragraph) => {
+      if (/\r|\n/u.test(paragraph)) return [];
+      const match = paragraph.match(/^(.{1,80}?) is the explicitly selected specialist for this (.{1,120}?)\.$/u);
+      if (!match) return [];
+      const roleLabel = match[1].trim();
+      const scope = match[2].trim();
+      if (!roleLabel || !scope || /[\r\n]/u.test(roleLabel)) return [];
+      return [Object.freeze({
+        state: 'explicit-current-work-selector',
+        roleLabel,
+        selectorKind: 'explicit-specialist-declaration-paragraph',
+        section: 'Objective',
+        declaration: paragraph,
+        scope,
+        sourceArtifact: sourceArtifactFromRecord(taskRecord),
+        boundary: 'Closed lexical declaration paragraph only. Core does not interpret surrounding prose: no Role label is searched for, guessed from inventory, inferred from endpoint identity, or recovered from near-match text.'
+      })];
+    });
+  return declarations.length === 1 ? declarations[0] : null;
+}
+
+function exactRouteRoleMaterials(authority = {}) {
+  const roles = [];
+  const recipient = qualifiedRole(authority?.role || null, authority?.handoff?.toReference || '');
+  const sender = qualifiedRole(authority?.senderRole || null, authority?.handoff?.fromReference || '');
+  if (recipient) roles.push(recipient);
+  if (sender) roles.push(sender);
+  for (const item of authority?.participation?.packageRoleGrounding || []) {
+    const role = qualifiedPackageGroundingRole(item);
+    if (role) roles.push(role);
+  }
+  return Object.freeze(dedupeRoles(roles));
+}
+
+function qualifiedPackageGroundingRole(entry = {}) {
+  const artifact = entry?.roleArtifact || null;
+  if (!entry?.groundingOnly || String(entry?.materialQualification || '') !== 'qualified' || !artifact) return null;
+  const sha256 = String(artifact.sha256 || '').trim().toLowerCase();
+  if (!/^[0-9a-f]{64}$/iu.test(sha256)) return null;
+  const reference = String(artifact.reference || artifact.path || '').trim();
+  const label = String(artifact.roleLabel || entry.label || '').trim();
+  if (!reference || !label || String(artifact.schemaId || '') !== 'tiinex.party.role.v1') return null;
+  return Object.freeze({
+    label,
+    kind: 'role',
+    roleKind: String(artifact.roleKind || ''),
+    boundary: Object.freeze({ ...(entry.exactBoundaryLoaded || {}) }),
+    authority: Object.freeze({ ...(entry.authorityBoundaryLoaded || {}) }),
+    sourceArtifact: sourceArtifactFromReference(reference, sha256, String(artifact.schemaId || 'tiinex.party.role.v1')),
+    materialResolution: Object.freeze({ pointerPath: String(entry.pointerPath || ''), groundingOnly: true })
+  });
+}
+
+function dedupeRoles(roles = []) {
+  const map = new Map();
+  for (const role of roles) {
+    const key = `${normalize(role?.label)}\u0000${String(role?.sourceArtifact?.path || '')}\u0000${String(role?.sourceArtifact?.sha256 || '')}`;
+    if (!map.has(key)) map.set(key, role);
+  }
+  return [...map.values()];
+}
+
+function delegateProjection(role, handoff, selected, selector) {
   const capabilities = [
     role.roleKind ? Object.freeze({ kind: 'role-kind', value: role.roleKind }) : null,
     role.boundary.inScope ? Object.freeze({ kind: 'role-in-scope', value: role.boundary.inScope }) : null,
@@ -111,10 +197,18 @@ function delegateProjection(role, handoff, selected) {
     selection: Object.freeze({ state: 'explicit-forward-selected', forwardSelected: true }),
     sourceArtifact: role.sourceArtifact,
     facts: Object.freeze([
-      Object.freeze({ kind: 'selected-handoff-transfer', handoff: qualifiedHandoffPath(handoff), transferId: String(selected.transfer.id || ''), transferKind: String(selected.transfer.transferKind || ''), controllingArtifact: selected.resolvedPath }),
-      Object.freeze({ kind: 'exact-recipient-role-authority', role: role.label, roleKind: role.roleKind })
+      Object.freeze({ kind: 'current-work-forward-delegate-selector', role: selector.roleLabel, section: selector.section, selectorKind: selector.selectorKind, controllingArtifact: selected.resolvedPath }),
+      Object.freeze({ kind: 'exact-forward-selected-role-authority', role: role.label, roleKind: role.roleKind }),
+      Object.freeze({ kind: 'selected-handoff-current-work-transfer', handoff: qualifiedHandoffPath(handoff), transferId: String(selected.transfer.id || ''), transferKind: String(selected.transfer.transferKind || ''), controllingArtifact: selected.resolvedPath })
     ]),
-    provenance: Object.freeze({ source: role.sourceArtifact.path, basis: 'selected-handoff-transfer-to-exact-recipient-role-and-controlling-task', forwardSelector: Object.freeze({ handoff: qualifiedHandoffPath(handoff), transferId: String(selected.transfer.id || ''), controllingArtifact: selected.resolvedPath }) })
+    provenance: Object.freeze({
+      source: role.sourceArtifact.path,
+      basis: 'exact-controlling-task-explicit-specialist-selector-plus-exact-selected-role-material',
+      forwardSelector: selector,
+      roleSourceArtifact: role.sourceArtifact,
+      materialResolution: role.materialResolution || null,
+      currentWorkTransfer: Object.freeze({ handoff: qualifiedHandoffPath(handoff), transferId: String(selected.transfer.id || ''), controllingArtifact: selected.resolvedPath })
+    })
   });
 }
 

package/src/tooling/portable/handoff/coldStartQualification.grounding.js

@@ -422,7 +422,18 @@ function resolvePackageParticipantRoles(bundle = {}, orientation = null, selecte
       packageDeclared: true,
       groundingOnly: true,
       semanticParticipant: false,
-      roleArtifact: Object.freeze({ path: parsed.path, sha256: parsed.sha256, schemaId: parsed.schemaId, roleLabel: parsed.label, roleKind: parsed.roleKind }),
+      materialQualification: 'qualified',
+      roleArtifact: Object.freeze({
+        path: parsed.path,
+        reference: String(facts.referenceTarget || parsed.path || ''),
+        sha256: parsed.sha256,
+        schemaId: parsed.schemaId,
+        roleLabel: parsed.label,
+        roleKind: parsed.roleKind
+      }),
+      exactBoundaryLoaded: parsed.boundary,
+      authorityBoundaryLoaded: parsed.authorityBoundary,
+      interpretationLimitsLoaded: parsed.interpretationLimits,
       pointerPath
     }));
   }