@tiinex/core 0.19.0 → 0.21.0

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

@@ -0,0 +1,314 @@
+import { posix } from 'node:path';
+import { sha256Hex } from '../../../export/package.bytes.js';
+
+export function projectGroundingDelegationArtifactAuthority({ authority = null, records = [], topology = {}, sourceEvidence = null } = {}) {
+  const unresolved = [];
+  const handoff = authority?.handoff || null;
+  const recipientRole = authority?.role || null;
+  const senderRole = authority?.senderRole || null;
+  if (!handoff || String(handoff.schemaId || '') !== 'tiinex.handoff.v1') return empty('selected-qualified-handoff-not-established');
+
+  const transferSelection = selectControllingTransfer(handoff, records, topology);
+  if (!transferSelection) unresolved.push('forward-controlling-transfer-not-established');
+  const recipient = qualifiedRole(recipientRole, handoff.toReference || '');
+  if (!recipient) unresolved.push('exact-recipient-role-authority-not-established');
+  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 = 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;
+  if (!processApplicability) unresolved.push('delegation-applicability-artifact-projection-not-established');
+
+  const delegationTargetAuthority = taskRecord && workspaceSource && transferSelection
+    ? targetProjection(taskRecord, workspaceSource, handoff, transferSelection)
+    : null;
+  if (!delegationTargetAuthority) unresolved.push('delegation-target-artifact-projection-not-established');
+
+  const implementationSourceAuthority = taskRecord && recipient && transferSelection
+    ? sourceProjection(taskRecord, recipient, handoff, transferSelection)
+    : null;
+  if (!implementationSourceAuthority) unresolved.push('implementation-source-artifact-projection-not-established');
+
+  const delegationReturnReconciliationExpectation = transferSelection
+    ? returnProjection(handoff, transferSelection)
+    : null;
+  if (!delegationReturnReconciliationExpectation) unresolved.push('return-reconciliation-artifact-projection-not-established');
+
+  const ready = Boolean(delegateCapabilityAuthority && processApplicability && delegationTargetAuthority && implementationSourceAuthority && delegationReturnReconciliationExpectation);
+  return Object.freeze({
+    state: ready ? 'qualified-forward-artifact-closure' : 'not-established',
+    delegateCapabilityAuthority,
+    processApplicability,
+    delegationTargetAuthority,
+    implementationSourceAuthority,
+    delegationReturnReconciliationExpectation,
+    unresolved: Object.freeze([...new Set(unresolved)].map((code) => Object.freeze({ code }))),
+    provenance: Object.freeze({
+      basis: 'exact-qualified-forward-selected-artifact-chain',
+      selectedHandoff: sourceArtifactFromHandoff(handoff),
+      controllingTask: taskRecord ? sourceArtifactFromRecord(taskRecord) : null,
+      senderRole: sender ? sender.sourceArtifact : null,
+      recipientRole: recipient ? recipient.sourceArtifact : null,
+      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. 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.'
+  });
+}
+
+function selectControllingTransfer(handoff, records, topology) {
+  const handoffPath = qualifiedHandoffPath(handoff);
+  const frontierPaths = new Set((topology?.currentFrontier || []).flatMap((item) => [String(item.path || ''), String(item.resolvedPath || '')]).filter(Boolean));
+  const candidates = [];
+  for (const transfer of handoff.transfers || []) {
+    const target = String(transfer.controllingArtifactTarget || '').trim();
+    if (!target) continue;
+    const resolved = resolveReference(target, handoffPath);
+    if (!resolved) continue;
+    const matches = (records || []).filter((record) => String(record.path || '') === resolved && String(record.schemaId || '') === 'tiinex.task.v1' && record.hasContinuityContext && record.hasIntegrity);
+    if (matches.length !== 1) continue;
+    if (frontierPaths.size && !frontierPaths.has(resolved) && !frontierPaths.has(String(matches[0].id || ''))) continue;
+    candidates.push(Object.freeze({ transfer, record: matches[0], resolvedPath: resolved }));
+  }
+  return candidates.length === 1 ? candidates[0] : null;
+}
+
+function qualifiedRole(role, declaredReference = '') {
+  const artifact = role?.material?.artifact || null;
+  if (String(role?.state || '') !== 'qualified' || String(role?.material?.state || '') !== 'qualified' || !artifact) return null;
+  const sha256 = String(artifact.sha256 || '').trim().toLowerCase();
+  if (!/^[0-9a-f]{64}$/i.test(sha256)) return null;
+  const reference = String(artifact.reference || declaredReference || '').trim();
+  if (!reference) return null;
+  return Object.freeze({
+    label: String(role?.endpoint?.label || artifact.roleLabel || ''),
+    kind: String(role?.endpoint?.kind || 'role'),
+    roleKind: String(artifact.roleKind || ''),
+    boundary: Object.freeze({ ...(role.exactBoundaryLoaded || {}) }),
+    authority: Object.freeze({ ...(role.authorityBoundaryLoaded || {}) }),
+    sourceArtifact: sourceArtifactFromReference(reference, sha256, String(artifact.schemaId || 'tiinex.party.role.v1'))
+  });
+}
+
+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,
+    role.authority.mayDo ? Object.freeze({ kind: 'role-may-do', value: role.authority.mayDo }) : null
+  ].filter(Boolean);
+  if (!role.label || !capabilities.length) return null;
+  return Object.freeze({
+    explicit: true,
+    qualification: 'qualified',
+    delegate: Object.freeze({ label: role.label, kind: role.kind || 'role' }),
+    capabilities: Object.freeze(capabilities),
+    selection: Object.freeze({ state: 'explicit-forward-selected', forwardSelected: true }),
+    sourceArtifact: role.sourceArtifact,
+    facts: Object.freeze([
+      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: '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 })
+    })
+  });
+}
+
+function processProjection(role, handoff, selected) {
+  const facts = [
+    role.authority.delegation ? Object.freeze({ kind: 'sender-role-delegation', value: role.authority.delegation }) : null,
+    role.authority.requiredInstrument ? Object.freeze({ kind: 'sender-role-required-instrument', value: role.authority.requiredInstrument }) : null,
+    role.authority.mayDo ? Object.freeze({ kind: 'sender-role-may-do', value: role.authority.mayDo }) : null,
+    Object.freeze({ kind: 'selected-handoff-work-transfer', transferId: String(selected.transfer.id || ''), transferKind: String(selected.transfer.transferKind || ''), controllingArtifact: selected.resolvedPath })
+  ].filter(Boolean);
+  if (facts.length < 2) return null;
+  return Object.freeze({
+    explicit: true,
+    qualification: 'qualified',
+    facts: Object.freeze(facts),
+    source: role.sourceArtifact.path,
+    provenance: Object.freeze({ source: role.sourceArtifact.path, sourceArtifact: role.sourceArtifact, basis: 'exact-sender-role-authority-plus-selected-handoff-work-transfer', forwardSelector: Object.freeze({ handoff: qualifiedHandoffPath(handoff), transferId: String(selected.transfer.id || '') }) })
+  });
+}
+
+function targetProjection(taskRecord, workspaceSource, handoff, selected) {
+  const workspaceId = String(taskRecord.path || '').split('/')[0];
+  const relativeTask = String(taskRecord.path || '').slice(workspaceId.length + 1);
+  const relativeHandoff = String(handoff.workspaceRelativePath || '').replace(/^\/+/, '');
+  return Object.freeze({
+    explicit: true,
+    qualification: 'qualified',
+    target: Object.freeze({
+      workspaceId,
+      repository: String(workspaceSource.repository || ''),
+      rootPath: String(workspaceSource.rootPath || ''),
+      taskDirectory: posix.dirname(relativeTask),
+      handoffDirectory: posix.dirname(relativeHandoff)
+    }),
+    sourceArtifact: sourceArtifactFromRecord(taskRecord),
+    facts: Object.freeze([
+      Object.freeze({ kind: 'controlling-task-placement', path: String(taskRecord.path || '') }),
+      Object.freeze({ kind: 'workspace-source-identity', workspaceId, repository: String(workspaceSource.repository || ''), rootPath: String(workspaceSource.rootPath || '') })
+    ]),
+    provenance: Object.freeze({ source: String(taskRecord.path || ''), basis: 'exact-controlling-task-plus-qualified-workspace-source-identity', forwardSelector: Object.freeze({ handoff: qualifiedHandoffPath(handoff), transferId: String(selected.transfer.id || '') }) })
+  });
+}
+
+function sourceProjection(taskRecord, role, handoff, selected) {
+  const scope = section(taskRecord.markdown || '', 'Scope');
+  const facts = [
+    scope ? Object.freeze({ kind: 'controlling-task-scope', value: scope }) : null,
+    role.authority.mayDo ? Object.freeze({ kind: 'recipient-role-may-do', value: role.authority.mayDo }) : null,
+    role.authority.requiredInstrument ? Object.freeze({ kind: 'recipient-role-required-instrument', value: role.authority.requiredInstrument }) : null,
+    Object.freeze({ kind: 'selected-handoff-work-transfer', transferId: String(selected.transfer.id || ''), transferKind: String(selected.transfer.transferKind || ''), controllingArtifact: selected.resolvedPath })
+  ].filter(Boolean);
+  if (!scope || !role.authority.mayDo) return null;
+  return Object.freeze({
+    explicit: true,
+    qualification: 'qualified',
+    sourceArtifact: sourceArtifactFromRecord(taskRecord),
+    facts: Object.freeze(facts),
+    provenance: Object.freeze({ source: String(taskRecord.path || ''), basis: 'exact-controlling-task-scope-plus-recipient-role-authority-plus-selected-transfer', forwardSelector: Object.freeze({ handoff: qualifiedHandoffPath(handoff), transferId: String(selected.transfer.id || '') }), recipientRoleSourceArtifact: role.sourceArtifact })
+  });
+}
+
+function returnProjection(handoff, selected) {
+  const completion = handoff.completionExpectation || {};
+  const returnTo = String(completion.returnTo || '').trim();
+  const retained = (handoff.retainedResponsibilities || []).filter((item) => normalize(item.retainedBy) === normalize(returnTo));
+  if (!completion.signalKind || !completion.signalMeaning || !returnTo || retained.length !== 1) return null;
+  return Object.freeze({
+    explicit: true,
+    qualification: 'qualified',
+    completionExpectation: Object.freeze({ signalKind: String(completion.signalKind), signalMeaning: String(completion.signalMeaning), returnTo }),
+    reconciliation: Object.freeze({ state: 'retained-by-return-target', expectation: String(retained[0].responsibility || '') }),
+    sourceArtifact: sourceArtifactFromHandoff(handoff),
+    facts: Object.freeze([
+      Object.freeze({ kind: 'selected-handoff-completion-expectation', signalKind: String(completion.signalKind), returnTo }),
+      Object.freeze({ kind: 'return-target-retained-responsibility', id: String(retained[0].id || ''), retainedBy: returnTo, responsibility: String(retained[0].responsibility || '') })
+    ]),
+    provenance: Object.freeze({ source: qualifiedHandoffPath(handoff), basis: 'exact-selected-handoff-completion-plus-return-target-retained-responsibility', forwardSelector: Object.freeze({ transferId: String(selected.transfer.id || ''), controllingArtifact: selected.resolvedPath }) })
+  });
+}
+
+function sourceArtifactFromRecord(record) {
+  return Object.freeze({ workspaceId: String(record.path || '').split('/')[0] || '', path: String(record.path || ''), sha256: sha256(record.markdown || ''), schemaId: String(record.schemaId || '') });
+}
+function sourceArtifactFromHandoff(handoff) {
+  return Object.freeze({ workspaceId: String(handoff.workspaceId || ''), path: qualifiedHandoffPath(handoff), sha256: String(handoff.sha256 || '').trim().toLowerCase(), schemaId: String(handoff.schemaId || 'tiinex.handoff.v1') });
+}
+function sourceArtifactFromReference(reference, sha, schemaId) {
+  const raw = String(reference || '').trim();
+  const cross = raw.match(/^([^:/\\]+)::(.+)$/);
+  return Object.freeze({ workspaceId: cross ? cross[1] : '', path: raw, sha256: String(sha || '').toLowerCase(), schemaId: String(schemaId || '') });
+}
+function qualifiedHandoffPath(handoff) { return [String(handoff.workspaceId || ''), String(handoff.workspaceRelativePath || '').replace(/^\/+/, '')].filter(Boolean).join('/'); }
+function resolveReference(reference, ownerPath) {
+  const raw = String(reference || '').split('#')[0].trim().replace(/\\/g, '/');
+  const cross = raw.match(/^([^:/\\]+)::(.+)$/);
+  const candidate = cross ? `${cross[1]}/${cross[2].replace(/^\/+/, '')}` : raw.startsWith('/') ? raw.slice(1) : posix.join(posix.dirname(ownerPath), raw);
+  const normalized = posix.normalize(candidate).replace(/^\.\//, '');
+  return !normalized || normalized === '..' || normalized.startsWith('../') ? '' : normalized;
+}
+function section(markdown = '', heading = '') { const escaped = String(heading || '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); return String(markdown || '').match(new RegExp(`(?:^|\\n)##\\s+${escaped}\\s*\\r?\\n([\\s\\S]*?)(?=\\n##\\s+|\\n#\\s+Continuity Integrity|$)`, 'i'))?.[1]?.trim() || ''; }
+function sha256(markdown) { return sha256Hex(new TextEncoder().encode(String(markdown || ''))); }
+function normalize(value) { return String(value || '').trim().toLowerCase(); }
+function empty(code) { return Object.freeze({ state: 'not-established', delegateCapabilityAuthority: null, processApplicability: null, delegationTargetAuthority: null, implementationSourceAuthority: null, delegationReturnReconciliationExpectation: null, unresolved: Object.freeze([Object.freeze({ code })]), provenance: null, boundary: 'No exact selected qualified Handoff authority was available for artifact-derived delegation projection.' }); }

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

@@ -0,0 +1,241 @@
+const MAX_CAPABILITIES = 12;
+const MAX_FACTS = 12;
+
+export function projectGroundingDelegationReadiness({ authority = null, processApplicability = null, implementationSourceAuthority = null } = {}) {
+  const delegateCapabilityAuthority = projectDelegateCapabilityAuthority(authority?.delegateCapabilityAuthority || authority?.delegationContext?.delegateCapabilityAuthority || null);
+  const targetAuthority = projectDelegationTargetAuthority(authority?.delegationTargetAuthority || authority?.delegationContext?.targetAuthority || authority?.delegationContext?.delegationTargetAuthority || null);
+  const returnReconciliationExpectation = projectDelegationReturnReconciliationExpectation(authority?.delegationReturnReconciliationExpectation || authority?.delegationContext?.returnReconciliationExpectation || authority?.delegationContext?.delegationReturnReconciliationExpectation || null);
+  const process = processApplicability || Object.freeze({ state: 'not-established', unresolved: Object.freeze([]) });
+  const source = implementationSourceAuthority || Object.freeze({ state: 'unresolved', unresolved: Object.freeze([]) });
+  const blockers = [];
+
+  if (delegateCapabilityAuthority.state !== 'explicit-qualified-forward-selection') blockers.push(blocker(
+    'delegate-capability-authority-not-established',
+    delegateCapabilityAuthority.unresolved?.[0]?.detail || 'No explicit upstream-qualified forward-selected delegate/capability authority is established.',
+    'Provide an explicit upstream-qualified forward-selected delegate/capability projection with exact source-artifact identity. Cached Role presence, participant inventory, Handoff endpoint labels, filenames and chat position are not delegate selection authority.'
+  ));
+  const processReady = String(process.state || '') === 'explicit-qualified-authority' && Array.isArray(process.facts) && process.facts.length > 0 && Boolean(String(process.provenance?.source || process.provenance?.upstreamProvenance?.source || '').trim());
+  if (!processReady) blockers.push(blocker(
+    'delegation-process-applicability-not-established',
+    process.unresolved?.[0]?.detail || 'Delegation/process applicability is not explicitly established by upstream semantic authority.',
+    'Provide the explicit upstream-qualified process/delegation applicability projection. Do not infer applicability from Role/cache inventory or repository adjacency.'
+  ));
+  if (targetAuthority.state !== 'explicit-qualified-target-authority') blockers.push(blocker(
+    'delegation-target-authority-not-established',
+    targetAuthority.unresolved?.[0]?.detail || 'Target repository/workspace authority and repo-local Task/Handoff placement are not explicitly established.',
+    'Provide an explicit upstream-qualified delegation target projection naming repository, workspaceId, taskDirectory and handoffDirectory with exact source-artifact identity.'
+  ));
+  const sourceReady = String(source.state || '') === 'explicit-qualified-upstream-projection' && Array.isArray(source.facts) && source.facts.length > 0;
+  if (!sourceReady) blockers.push(blocker(
+    'delegation-source-authority-not-established',
+    source.unresolved?.[0]?.detail || 'Implementation/source authority is not explicitly established by upstream semantic authority.',
+    'Provide the exact upstream-qualified implementation-source authority projection. Workspace carriage, writability text, repository identity and executable Task presence remain descriptive only.'
+  ));
+  if (returnReconciliationExpectation.state !== 'explicit-qualified-return-reconciliation') blockers.push(blocker(
+    'delegation-return-reconciliation-expectation-not-established',
+    returnReconciliationExpectation.unresolved?.[0]?.detail || 'Return/reconciliation responsibility is not explicitly established.',
+    'Provide an explicit upstream-qualified return/reconciliation projection with Completion Expectation and an explicit reconciliation state/expectation.'
+  ));
+
+  const ready = blockers.length === 0;
+  return Object.freeze({
+    state: ready ? 'qualified-for-delegation-authoring' : 'not-established',
+    delegateCapabilityAuthority,
+    processApplicability: process,
+    targetAuthority,
+    sourceAuthority: source,
+    returnReconciliationExpectation,
+    blockers: Object.freeze(blockers),
+    plainChatFallbackPermitted: false,
+    repositoryScanningFallbackPermitted: false,
+    nextOperations: ready ? projectNextOperations({ delegateCapabilityAuthority, targetAuthority, returnReconciliationExpectation }) : Object.freeze([]),
+    boundary: 'Mechanical delegation qualification only. Core consumes already-explicit, already-qualified semantic projections and exposes the normal Task -> Handoff -> carrier Tooling path; it never selects a delegate, invents process applicability, generates a work plan, grants source authority, or treats cached Role presence as delegation authority.'
+  });
+}
+
+export function projectDelegateCapabilityAuthority(value = null) {
+  const base = qualifyExplicitProjection(value);
+  if (!base.qualified) return unresolvedProjection('delegate-capability-authority-not-established', 'No exact upstream-qualified explicit delegate/capability projection is present.');
+  const delegate = value?.delegate || value?.selectedDelegate || {};
+  const label = String(delegate.label || delegate.roleLabel || value?.delegateLabel || '').trim();
+  const kind = String(delegate.kind || value?.delegateKind || 'role').trim();
+  const capabilities = Array.isArray(value?.capabilities) ? value.capabilities : Array.isArray(delegate.capabilities) ? delegate.capabilities : [];
+  const selectionState = String(value?.selection?.state || value?.selectionState || '').trim().toLowerCase();
+  const forwardSelected = value?.selection?.forwardSelected === true || value?.forwardSelected === true || ['forward-selected', 'explicit-forward-selected'].includes(selectionState);
+  if (!label || !capabilities.length || !forwardSelected) return unresolvedProjection(
+    'delegate-capability-authority-incomplete',
+    'The upstream delegate/capability projection is marked qualified but does not expose one explicit forward-selected delegate label plus at least one capability.'
+  );
+  return Object.freeze({
+    state: 'explicit-qualified-forward-selection',
+    delegate: Object.freeze({ label, kind }),
+    capabilities: Object.freeze(capabilities.slice(0, MAX_CAPABILITIES).map((item) => freezeValue(item))),
+    sourceArtifact: Object.freeze(base.sourceArtifact),
+    facts: Object.freeze(projectFacts(value)),
+    provenance: Object.freeze({
+      basis: 'exact-upstream-qualified-forward-selected-delegate-capability-projection',
+      sourceArtifact: Object.freeze(base.sourceArtifact),
+      upstreamProvenance: value?.provenance ? Object.freeze({ ...(value.provenance || {}) }) : null,
+      boundary: 'Delegate relevance/capability is passed through from explicit upstream authority. Core does not select a Role from cache or participant inventory.'
+    }),
+    unresolved: Object.freeze([]),
+    boundary: 'Forward selection is semantic input, not a Role-discovery result.'
+  });
+}
+
+export function projectDelegationTargetAuthority(value = null) {
+  const base = qualifyExplicitProjection(value);
+  if (!base.qualified) return unresolvedProjection('delegation-target-authority-not-established', 'No exact upstream-qualified delegation target projection is present.');
+  const target = value?.target || value?.placement || {};
+  const workspaceId = String(target.workspaceId || value?.workspaceId || '').trim();
+  const repository = String(target.repository || value?.repository || '').trim();
+  const taskDirectory = normalizeDirectory(target.taskDirectory || value?.taskDirectory || '');
+  const handoffDirectory = normalizeDirectory(target.handoffDirectory || value?.handoffDirectory || '');
+  if (!workspaceId || !repository || !taskDirectory || !handoffDirectory) return unresolvedProjection(
+    'delegation-target-authority-incomplete',
+    'The upstream delegation target projection is marked qualified but does not expose repository, workspaceId, taskDirectory and handoffDirectory.'
+  );
+  return Object.freeze({
+    state: 'explicit-qualified-target-authority',
+    target: Object.freeze({ workspaceId, repository, taskDirectory, handoffDirectory, rootPath: String(target.rootPath || value?.rootPath || '').trim() }),
+    sourceArtifact: Object.freeze(base.sourceArtifact),
+    facts: Object.freeze(projectFacts(value)),
+    provenance: Object.freeze({
+      basis: 'exact-upstream-qualified-delegation-target-projection',
+      sourceArtifact: Object.freeze(base.sourceArtifact),
+      upstreamProvenance: value?.provenance ? Object.freeze({ ...(value.provenance || {}) }) : null,
+      boundary: 'Repository/Workspace identity and repo-local Task/Handoff placement are passed through from upstream authority; Core does not discover or choose a repository.'
+    }),
+    unresolved: Object.freeze([]),
+    boundary: 'Target placement is explicit authority input only; source mutation permission is separate.'
+  });
+}
+
+export function projectDelegationReturnReconciliationExpectation(value = null) {
+  const base = qualifyExplicitProjection(value);
+  if (!base.qualified) return unresolvedProjection('delegation-return-reconciliation-expectation-not-established', 'No exact upstream-qualified return/reconciliation projection is present.');
+  const completion = value?.completionExpectation || value?.returnExpectation || {};
+  const signalKind = String(completion.signalKind || '').trim();
+  const signalMeaning = String(completion.signalMeaning || '').trim();
+  const returnTo = String(completion.returnTo || '').trim();
+  const reconciliation = normalizeReconciliation(value?.reconciliation || value?.reconciliationExpectation || null);
+  if (!signalKind || !signalMeaning || !returnTo || !reconciliation.state) return unresolvedProjection(
+    'delegation-return-reconciliation-expectation-incomplete',
+    'The upstream return/reconciliation projection is marked qualified but does not expose a complete Completion Expectation and an explicit reconciliation state/expectation.'
+  );
+  return Object.freeze({
+    state: 'explicit-qualified-return-reconciliation',
+    completionExpectation: Object.freeze({ signalKind, signalMeaning, returnTo }),
+    reconciliation,
+    sourceArtifact: Object.freeze(base.sourceArtifact),
+    facts: Object.freeze(projectFacts(value)),
+    provenance: Object.freeze({
+      basis: 'exact-upstream-qualified-return-reconciliation-projection',
+      sourceArtifact: Object.freeze(base.sourceArtifact),
+      upstreamProvenance: value?.provenance ? Object.freeze({ ...(value.provenance || {}) }) : null,
+      boundary: 'Return and reconciliation responsibility are passed through exactly; Core does not invent acceptance, completion or merge semantics.'
+    }),
+    unresolved: Object.freeze([]),
+    boundary: 'Completion and reconciliation expectations are semantic-owner inputs; carrier manufacture remains a separate mechanical operation.'
+  });
+}
+
+function projectNextOperations({ delegateCapabilityAuthority, targetAuthority, returnReconciliationExpectation }) {
+  const target = targetAuthority.target;
+  const delegate = delegateCapabilityAuthority.delegate;
+  return Object.freeze([
+    Object.freeze({
+      kind: 'author-delegation-task',
+      command: 'author',
+      schemaId: 'tiinex.task.v1',
+      workspaceId: target.workspaceId,
+      repository: target.repository,
+      directory: target.taskDirectory,
+      bodyAuthority: 'caller/upstream-authored-work-semantics-required',
+      boundary: 'Mechanical authoring coordinate only. Core does not generate the Task objective, Done Criteria, scope or work plan.'
+    }),
+    Object.freeze({
+      kind: 'author-delegation-handoff',
+      command: 'author',
+      schemaId: 'tiinex.handoff.v1',
+      workspaceId: target.workspaceId,
+      repository: target.repository,
+      directory: target.handoffDirectory,
+      parent: 'newly-authored-qualified-task',
+      recipient: Object.freeze({ ...delegate }),
+      completionExpectation: Object.freeze({ ...(returnReconciliationExpectation.completionExpectation || {}) }),
+      boundary: 'Author the Handoff through normal Tooling with the qualified Task as Parent and the upstream-selected delegate/return semantics; Core does not synthesize transfer semantics.'
+    }),
+    Object.freeze({
+      kind: 'manufacture-delegation-carrier',
+      command: 'handoff',
+      workspaceId: target.workspaceId,
+      recipient: Object.freeze({ ...delegate }),
+      carrierAllocation: 'machine-derived-from-qualified-parent-pointer-topology',
+      reconciliation: returnReconciliationExpectation.reconciliation,
+      boundary: 'Manufacture only after the Task and Handoff qualify. Carrier topology is transport-only and does not create semantic delegation authority.'
+    })
+  ]);
+}
+
+function qualifyExplicitProjection(value = null) {
+  if (!value || typeof value !== 'object' || value.explicit !== true) return { qualified: false, sourceArtifact: emptySourceArtifact() };
+  if (String(value.qualification || value.state || '').trim().toLowerCase() !== 'qualified') return { qualified: false, sourceArtifact: emptySourceArtifact() };
+  const sourceArtifact = projectSourceArtifact(value);
+  if (!sourceArtifact.path || !/^[0-9a-f]{64}$/i.test(sourceArtifact.sha256)) return { qualified: false, sourceArtifact };
+  return { qualified: true, sourceArtifact };
+}
+
+function projectSourceArtifact(value = {}) {
+  const source = value.sourceArtifact || value.provenance?.sourceArtifact || {};
+  return Object.freeze({
+    workspaceId: String(source.workspaceId || source.workspace || '').trim(),
+    path: String(source.path || source.workspaceRelativePath || value.provenance?.sourceArtifactPath || '').trim(),
+    sha256: String(source.sha256 || value.provenance?.sourceArtifactSha256 || '').trim().toLowerCase(),
+    schemaId: String(source.schemaId || '').trim()
+  });
+}
+
+function unresolvedProjection(code, detail) {
+  return Object.freeze({
+    state: 'not-established',
+    facts: Object.freeze([]),
+    sourceArtifact: Object.freeze(emptySourceArtifact()),
+    unresolved: Object.freeze([Object.freeze({ code, detail })]),
+    boundary: 'No semantic meaning is inferred from Role/cache inventory, Handoff endpoints, filenames, repository adjacency or transport placement.'
+  });
+}
+
+function blocker(code, detail, request) {
+  return Object.freeze({
+    code,
+    detail: String(detail || ''),
+    request: `${String(request || '')} Do not fall back to plain-chat delegation, repository scanning, network discovery, or selecting a Role merely because it is carried.`
+  });
+}
+
+function projectFacts(value = {}) {
+  const facts = Array.isArray(value.facts) ? value.facts : Array.isArray(value.items) ? value.items : [];
+  return facts.slice(0, MAX_FACTS).map((item) => freezeValue(item));
+}
+
+function freezeValue(value) {
+  if (value && typeof value === 'object' && !Array.isArray(value)) return Object.freeze({ ...value });
+  if (Array.isArray(value)) return Object.freeze([...value]);
+  return value;
+}
+
+function normalizeDirectory(value = '') {
+  return String(value || '').replace(/\\/g, '/').replace(/^\/+/, '').replace(/\/+$/, '').trim();
+}
+
+function normalizeReconciliation(value = null) {
+  if (typeof value === 'string') return Object.freeze({ state: String(value || '').trim(), expectation: '' });
+  if (!value || typeof value !== 'object') return Object.freeze({ state: '', expectation: '' });
+  return Object.freeze({
+    state: String(value.state || value.disposition || '').trim(),
+    expectation: String(value.expectation || value.description || '').trim()
+  });
+}
+
+function emptySourceArtifact() { return { workspaceId: '', path: '', sha256: '', schemaId: '' }; }