@tiinex/core 0.19.0 → 0.20.0

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

@@ -0,0 +1,220 @@
+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 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;
+  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,
+      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.'
+    }),
+    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.'
+  });
+}
+
+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 delegateProjection(role, handoff, selected) {
+  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: '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 })
+    ]),
+    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 }) })
+  });
+}
+
+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: '' }; }

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

@@ -0,0 +1,125 @@
+import { deepFreeze, normalizeToken } from '../handoff/coldStartQualification.shared.js';
+
+export const HOLDER_ASSIGNMENT_MODE = deepFreeze({
+  EXPLICIT_SESSION: 'explicit-session',
+  EXPLICIT_USER_SESSION: 'explicit-user-session',
+  EXPLICIT_ROLE_INVOCATION: 'explicit-role-invocation',
+  HANDOFF: 'handoff',
+  EXPLICIT_PARTICIPATION: 'explicit-participation'
+});
+
+const KNOWN_MODES = new Set(Object.values(HOLDER_ASSIGNMENT_MODE));
+
+export function projectHolderAssignmentModeAuthority(role = {}) {
+  const endpointKind = normalizeToken(role?.endpoint?.kind || '');
+  if (endpointKind !== 'role') return deepFreeze({
+    state: 'not-applicable',
+    modes: deepFreeze([]),
+    holderState: '',
+    source: 'none',
+    reasonCode: 'recipient-not-role',
+    unknownModes: deepFreeze([]),
+    provenance: baseProvenance(role, { basis: 'recipient-not-role', field: 'Assignment Modes' }),
+    boundary: 'Holder assignment-mode authority applies only to a selected Role recipient.'
+  });
+
+  const material = role?.material?.artifact || null;
+  const relationship = role?.holderRelationshipLoaded || {};
+  const holderState = String(relationship.holderState || '').trim();
+  const qualifiedMaterial = String(role?.state || '') === 'qualified'
+    && String(role?.material?.state || '') === 'qualified'
+    && Boolean(material?.path)
+    && /^[0-9a-f]{64}$/i.test(String(material?.sha256 || ''));
+  if (!qualifiedMaterial) return unresolved(role, holderState, 'qualified-role-holder-authority-not-established', 'none', {
+    basis: 'exact-qualified-role-assignment-mode-authority-not-established', field: 'Assignment Modes'
+  });
+
+  const structured = parseStructuredModes(relationship.assignmentModes);
+  if (!structured.present) return unresolved(role, holderState, 'holder-assignment-mode-authority-missing', 'qualified-recipient-role-material', {
+    basis: 'canonical-assignment-modes-missing', field: 'Assignment Modes'
+  });
+  if (structured.unknown.length) return unresolved(role, holderState, 'holder-assignment-mode-authority-unknown-token', 'qualified-recipient-role-structured-modes', {
+    basis: 'exact-qualified-role-assignment-modes', field: 'Assignment Modes', exactValue: structured.raw, unknownModes: structured.unknown
+  });
+  if (!structured.modes.length) return unresolved(role, holderState, 'holder-assignment-mode-authority-empty', 'qualified-recipient-role-structured-modes', {
+    basis: 'exact-qualified-role-assignment-modes', field: 'Assignment Modes', exactValue: structured.raw
+  });
+  return deepFreeze({
+    state: 'qualified',
+    modes: deepFreeze(structured.modes),
+    holderState,
+    source: 'qualified-recipient-role-structured-modes',
+    reasonCode: 'holder-assignment-mode-authority-qualified',
+    unknownModes: deepFreeze([]),
+    provenance: baseProvenance(role, {
+      basis: 'exact-qualified-role-assignment-modes',
+      field: 'Assignment Modes',
+      exactValue: structured.raw,
+      boundary: 'Positive mode authority comes only from the exact structured Assignment Modes field on the qualified current Role. Holder State is diagnostic-only; historical compatibility material does not authorize current holder binding.'
+    }),
+    boundary: 'Exact structured canonical assignment modes authorize only their named bounded mechanisms; they do not establish a holder, durable identity, participation, delegation, process, source, or acceptance authority.'
+  });
+}
+
+export function isCanonicalHolderAssignmentMode(value = '') {
+  return KNOWN_MODES.has(String(value || '').trim());
+}
+
+function parseStructuredModes(value) {
+  if (Array.isArray(value)) {
+    const raw = value.map((item) => String(item || '').trim()).filter(Boolean);
+    const tokens = raw.map(stripCode).filter(Boolean);
+    return classifyStructured(tokens, raw.join(', '), true);
+  }
+  const raw = String(value || '').trim();
+  if (!raw) return { present: false, raw: '', modes: [], unknown: [] };
+  const tokens = raw.split(',').map((item) => stripCode(item.trim())).filter(Boolean);
+  return classifyStructured(tokens, raw, true);
+}
+
+function classifyStructured(tokens, raw, present) {
+  const modes = [];
+  const unknown = [];
+  for (const token of tokens) {
+    if (KNOWN_MODES.has(token)) {
+      if (!modes.includes(token)) modes.push(token);
+    } else if (!unknown.includes(token)) unknown.push(token);
+  }
+  return { present, raw, modes, unknown };
+}
+
+function stripCode(value) {
+  const text = String(value || '').trim();
+  return /^`[^`]+`$/.test(text) ? text.slice(1, -1).trim() : text;
+}
+
+function unresolved(role, holderState, reasonCode, source, details = {}) {
+  return deepFreeze({
+    state: 'unresolved',
+    modes: deepFreeze([]),
+    holderState,
+    source,
+    reasonCode,
+    unknownModes: deepFreeze([...(details.unknownModes || [])]),
+    provenance: baseProvenance(role, details),
+    boundary: 'Positive holder assignment-mode authorization is unresolved. Core does not infer canonical modes from Holder State prose, historical Role compatibility, endpoint labels, package placement, session assertions, filenames, or lexical similarity.'
+  });
+}
+
+function baseProvenance(role = {}, details = {}) {
+  const material = role?.material?.artifact || {};
+  return deepFreeze({
+    basis: String(details.basis || ''),
+    roleArtifactPath: String(material.path || ''),
+    roleArtifactSha256: String(material.sha256 || ''),
+    roleSchemaId: String(material.schemaId || ''),
+    roleLabel: String(material.roleLabel || role?.endpoint?.label || ''),
+    section: 'Holder Relationship',
+    field: String(details.field || 'Assignment Modes'),
+    exactValue: String(details.exactValue || ''),
+    exactRoleSourcePath: '',
+    exactRoleSha256: '',
+    decisionArtifact: null,
+    boundary: String(details.boundary || 'Only exact structured Assignment Modes on exact qualified current Role material may establish canonical assignment modes. Holder State and historical compatibility material remain non-authoritative for positive authorization.')
+  });
+}