@tiinex/core 0.1.1

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

@@ -0,0 +1,128 @@
+import { projectParticipantAuthority } from './grounding.participantAuthority.js';
+import { projectWorkProvenance } from './grounding.workProvenance.js';
+import { projectGroundingSourceEvidence } from './grounding.sourceEvidence.js';
+import { projectGroundingPlanningContext } from './grounding.planningContext.js';
+
+export const PORTABLE_GROUNDING_CAPSULE_SCHEMA_ID = 'tiinex.portable.grounding-capsule.v1';
+
+const MAX_CONTEXT = 8;
+const MAX_EXCLUSIONS = 6;
+
+export function projectGroundingCapsule({ authority = null, continuation = null, contextAudit = null, requiredContext = [], records = [], topology = {}, blockers = [] } = {}) {
+  const routeRecords = selectedRouteRecords(authority, records);
+  const workProvenance = projectWorkProvenance({ records, topology });
+  const participantAuthority = projectParticipantAuthority(authority);
+  return Object.freeze({
+    schema: PORTABLE_GROUNDING_CAPSULE_SCHEMA_ID,
+    semanticReductions: Object.freeze(requiredContext.slice(0, MAX_CONTEXT).map(reduceRequiredContext)),
+    frontier: projectFrontier(topology, blockers),
+    exclusions: Object.freeze(routeRecords.flatMap((record) => parseExclusions(record.markdown || '')).slice(0, MAX_EXCLUSIONS)),
+    sourceEvidence: projectGroundingSourceEvidence({ records, contextAudit, continuation }),
+    planningContext: projectGroundingPlanningContext(requiredContext),
+    roleState: Object.freeze({
+      recipient: String(authority?.role?.endpoint?.label || authority?.handoff?.to || ''),
+      recipientState: String(authority?.role?.state || 'unresolved'),
+      holder: String(authority?.holderBinding?.roleLabel || ''),
+      holderState: String(authority?.holderBinding?.state || 'unresolved'),
+      compatibility: String(authority?.holderBinding?.recipientCompatibility || 'unresolved')
+    }),
+    participantAuthority,
+    workProvenance,
+    unresolved: Object.freeze([...workProvenance.unresolved]),
+    boundary: 'Full Required Context bodies remain selector-gated.'
+  });
+}
+
+function reduceRequiredContext(entry = {}) {
+  const qualified = String(entry.state || '') === 'qualified';
+  const markdown = qualified && typeof entry.content === 'string' ? entry.content : '';
+  const signals = markdown ? semanticSignals(markdown) : [];
+  return Object.freeze({
+    id: String(entry.requirementId || entry.name || ''),
+    state: String(entry.state || 'unresolved'),
+    workspace: String(entry.workspaceId || ''),
+    path: String(entry.innerPath || entry.workspaceRelativePath || ''),
+    title: markdown ? firstHeading(markdown) : String(entry.name || ''),
+    signals: Object.freeze(signals),
+    basis: markdown ? 'exact-qualified-body-reduction' : 'qualified-locator-without-body'
+  });
+}
+
+function semanticSignals(markdown = '') {
+  const preferred = ['Objective', 'Purpose', 'Decision', 'Scope', 'Done Criteria', 'Completion Expectation', 'Dependencies'];
+  const out = [];
+  for (const heading of preferred) {
+    const text = section(markdown, heading);
+    if (!text) continue;
+    out.push(Object.freeze({ heading, text: compact(sectionMeaning(text), 220) }));
+    if (out.length === 2) break;
+  }
+  if (!out.length) {
+    const summary = field(markdown, 'Summary');
+    if (summary) out.push(Object.freeze({ heading: 'Summary', text: compact(summary, 220) }));
+  }
+  return out;
+}
+
+function projectFrontier(topology = {}, blockers = []) {
+  const frontier = (topology.currentFrontier || []).slice(0, 4).map((item) => Object.freeze({
+    path: String(item.path || ''),
+    status: String(item.declaredStatus || ''),
+    objective: compact(item.objective || '', 180)
+  }));
+  return Object.freeze({
+    state: frontier.length ? 'resolved' : 'unresolved',
+    rationale: frontier.length ? 'nearest nonterminal Task ancestor(s) to the exact selected Handoff route by declared Parent distance' : 'no exact-qualified nonterminal Task ancestor resolved on the selected route Parent lineage',
+    items: Object.freeze(frontier),
+    blockers: Object.freeze((blockers || []).slice(0, 4).map((item) => Object.freeze({ code: String(item.code || item.id || ''), detail: compact(item.detail || item.message || item.label || '', 180) })))
+  });
+}
+
+function parseExclusions(markdown = '') {
+  const body = section(markdown, 'Exclusions And Dependencies');
+  if (!body) return [];
+  const blocks = body.split(/\n(?=-\s+[^\s])/g).map((item) => item.trim()).filter(Boolean);
+  return blocks.map((block) => {
+    const id = (block.match(/^-\s+([^\n]+)/) || [])[1] || '';
+    return Object.freeze({
+      id: id.trim(),
+      kind: field(block, 'Kind'),
+      description: compact(field(block, 'Description'), 220)
+    });
+  }).filter((item) => item.id);
+}
+
+function selectedRouteRecords(authority = {}, records = []) {
+  const workspace = String(authority?.selectedRoute?.workspaceId || '');
+  const inner = String(authority?.selectedRoute?.workspaceRelativeHandoffPath || '').replace(/^\/+/, '');
+  const expected = workspace && inner ? `${workspace}/${inner}` : '';
+  return expected ? records.filter((record) => String(record.path || '') === expected) : [];
+}
+
+function section(markdown = '', heading = '') {
+  const escaped = heading.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const match = String(markdown || '').match(new RegExp(`(?:^|\\n)##\\s+${escaped}\\s*\\r?\\n([\\s\\S]*?)(?=\\n##\\s+|$)`, 'i'));
+  return match ? match[1].trim() : '';
+}
+
+function field(markdown = '', label = '') {
+  const escaped = label.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const match = String(markdown || '').match(new RegExp(`^\\s*-\\s+${escaped}:\\s*(.+)$`, 'mi'));
+  return match ? stripMarkdown(match[1]) : '';
+}
+
+function firstHeading(markdown = '') {
+  const match = String(markdown || '').match(/^#\s+(.+)$/m);
+  return match ? stripMarkdown(match[1]) : '';
+}
+
+function sectionMeaning(text = '') {
+  const description = field(text, 'Description');
+  if (description) return description;
+  const purpose = field(text, 'Purpose');
+  if (purpose) return purpose;
+  return String(text || '').replace(/^\s*-\s+/gm, '').replace(/^\s{2,}-\s+/gm, ' ').replace(/\s+/g, ' ').trim();
+}
+
+function stripMarkdown(value = '') { return String(value || '').replace(/\[([^\]]+)\]\([^)]*\)/g, '$1').replace(/[`*_]/g, '').trim(); }
+function compact(value = '', limit = 220) { const text = stripMarkdown(String(value || '').replace(/\s+/g, ' ')); return text.length > limit ? `${text.slice(0, limit - 1).trimEnd()}…` : text; }

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

@@ -0,0 +1,283 @@
+import { relevantLineageIssues } from './grounding.readiness.support.js';
+
+const MAX_ITEMS = 12;
+
+export function projectColdStartContinuity({ mode = '', lineage = {}, routeRecordIds = new Set(), authority = {}, material = {} } = {}) {
+  if (mode !== 'routed-handoff-package') return Object.freeze({
+    state: 'not-applicable',
+    proof: emptyProof(),
+    blockingIssues: Object.freeze([]),
+    recovery: Object.freeze({ state: 'not-applicable' }),
+    boundary: continuityBoundary()
+  });
+
+  const ancestorIds = ancestorLineageCone(lineage, routeRecordIds);
+  const nodeById = new Map((lineage.nodes || []).map((node) => [node.id, node]));
+  const parentEdges = (lineage.edges || []).filter((edge) => edge.kind === 'parent' && ancestorIds.has(edge.to));
+  const issues = relevantLineageIssues(lineage, ancestorIds);
+  const rootNodes = [...ancestorIds]
+    .map((id) => nodeById.get(id))
+    .filter(Boolean)
+    .filter((node) => !hasResolvedParent(parentEdges, node.id));
+  const qualifiedRoots = rootNodes.filter(isQualifiedSemanticRoot);
+  const apparentRoots = rootNodes.filter((node) => !isQualifiedSemanticRoot(node));
+  const rootIssues = apparentRoots.map((node) => Object.freeze({
+    code: 'continuity.root.unqualified',
+    severity: 'warning',
+    nodeId: node.id || '',
+    target: String(node.trace || ''),
+    message: node.trace
+      ? 'A loaded apparent root still declares a Parent that is not qualified in the current continuity proof.'
+      : 'A loaded root lacks the continuity/integrity evidence required for compact cold-start root qualification.'
+  }));
+  const blockingIssues = dedupe([...issues, ...rootIssues]);
+  const qualified = ancestorIds.size > 0 && blockingIssues.length === 0 && qualifiedRoots.length > 0;
+  const firstIssue = blockingIssues.find((item) => String(item.target || '').trim()) || null;
+  const recovery = qualified ? Object.freeze({ state: 'not-required' }) : projectExactRecovery(firstIssue || {}, authority, nodeById);
+  const losses = projectNonCriticalLosses(material);
+
+  return Object.freeze({
+    state: qualified ? 'qualified' : 'unproven',
+    proof: Object.freeze({
+      schema: 'tiinex.portable.cold-start-continuity-proof.v1',
+      state: qualified ? 'qualified' : 'unproven',
+      basis: 'declared-parent-only + loaded edge qualification + qualified semantic root',
+      routeRecordIds: Object.freeze([...routeRecordIds].slice(0, MAX_ITEMS)),
+      ancestorRecordsChecked: ancestorIds.size,
+      parentEdgesChecked: parentEdges.length,
+      roots: Object.freeze(rootNodes.slice(0, MAX_ITEMS).map(rootSummary)),
+      qualifiedRoots: Object.freeze(qualifiedRoots.slice(0, MAX_ITEMS).map(rootSummary)),
+      bodiesProjected: 0,
+      compactReceiptOnly: true,
+      filenameDimensionsUsed: false,
+      carrierDimensionsUsed: false
+    }),
+    blockingIssues: Object.freeze(blockingIssues.slice(0, MAX_ITEMS)),
+    blockingIssuesOmitted: Math.max(0, blockingIssues.length - MAX_ITEMS),
+    recovery,
+    losses,
+    boundary: continuityBoundary()
+  });
+}
+
+export function acceptedRecoveryMaterial(value = {}) {
+  const acceptance = value?.result || value || {};
+  if (!acceptance || String(acceptance.status || '') !== 'accepted') return Object.freeze({
+    files: Object.freeze([]),
+    findings: Object.freeze(acceptance && Object.keys(acceptance).length ? [Object.freeze({
+      severity: 'warning',
+      code: 'portable.grounding.recovery.unaccepted',
+      message: 'Recovery input was supplied but is not an accepted host-action receipt result, so it was not used as lineage material.',
+      source: 'tiinex.portable.grounding-readiness.v1'
+    })] : [])
+  });
+  const files = [];
+  for (const response of Array.isArray(acceptance.providerResponses) ? acceptance.providerResponses : []) {
+    for (const file of Array.isArray(response?.files) ? response.files : []) files.push(file);
+  }
+  for (const file of Array.isArray(acceptance.material?.files) ? acceptance.material.files : []) files.push(file);
+  return Object.freeze({ files: Object.freeze(files), findings: Object.freeze([]) });
+}
+
+export function projectNonCriticalLosses(material = {}) {
+  const assets = Array.isArray(material.assets) ? material.assets : [];
+  const unavailable = assets.filter((asset) => asset?.previewState === 'metadata-only' || asset?.contentAvailable === false);
+  return Object.freeze({
+    state: unavailable.length ? 'degraded' : 'none',
+    blocking: false,
+    items: Object.freeze(unavailable.slice(0, MAX_ITEMS).map((asset) => Object.freeze({
+      path: String(asset.path || ''),
+      kind: String(asset.kind || 'asset'),
+      state: 'unavailable',
+      necessity: 'non-critical'
+    }))),
+    itemsOmitted: Math.max(0, unavailable.length - MAX_ITEMS),
+    boundary: 'Unavailable non-lineage assets remain visible degradation only. They do not block cold-start act-readiness unless another authoritative relation makes them required grounding material.'
+  });
+}
+
+function ancestorLineageCone(lineage = {}, startIds = new Set()) {
+  const all = new Set((lineage.nodes || []).map((node) => node.id));
+  const parents = new Map();
+  for (const edge of lineage.edges || []) {
+    if (edge.kind !== 'parent' || !edge.from || !edge.to) continue;
+    if (['missing', 'mismatch'].includes(String(edge.status || ''))) continue;
+    if (!parents.has(edge.to)) parents.set(edge.to, []);
+    parents.get(edge.to).push(edge.from);
+  }
+  const starts = [...startIds].filter((id) => all.has(id));
+  const out = new Set(starts);
+  const queue = [...starts];
+  while (queue.length) {
+    const id = queue.shift();
+    for (const parentId of parents.get(id) || []) {
+      if (out.has(parentId)) continue;
+      out.add(parentId);
+      queue.push(parentId);
+    }
+  }
+  return out;
+}
+
+function hasResolvedParent(edges = [], nodeId = '') {
+  return edges.some((edge) => edge.to === nodeId && edge.from && !['missing', 'mismatch'].includes(String(edge.status || '')));
+}
+
+function isQualifiedSemanticRoot(node = {}) {
+  return Boolean(node && !String(node.trace || '').trim() && node.hasContinuityContext && node.hasIntegrity);
+}
+
+function rootSummary(node = {}) {
+  return Object.freeze({
+    id: String(node.id || ''),
+    path: String(node.path || ''),
+    title: String(node.title || ''),
+    schemaId: String(node.schemaId || ''),
+    declaresParent: Boolean(String(node.trace || '').trim()),
+    hasContinuityContext: Boolean(node.hasContinuityContext),
+    hasIntegrity: Boolean(node.hasIntegrity)
+  });
+}
+
+function projectExactRecovery(issue = {}, authority = {}, nodeById = new Map()) {
+  const exactTarget = String(issue?.target || '').trim();
+  if (!exactTarget) return Object.freeze({
+    state: 'operator-required',
+    target: '',
+    whyRequired: 'Cold-start Parent continuity is unproven and no exact machine-recoverable target was available from the blocking lineage evidence.',
+    allowedScope: 'Resolve only the declared blocking Parent/continuity evidence; do not search for semantically similar substitutes.',
+    operatorRequest: operatorRequest('', authority)
+  });
+
+  const sourceNode = nodeById.get(String(issue?.nodeId || '')) || null;
+  const github = parseGithubBlob(exactTarget) || acceptedPinnedRelativeRepositoryTarget(exactTarget, sourceNode);
+  const repositoryBinding = authority?.capabilities?.discovery?.profile?.toolBindings?.repositoryRead?.selected || null;
+  if (github && repositoryBinding) {
+    return Object.freeze({
+      state: 'host-action-available',
+      target: exactTarget,
+      whyRequired: 'This exact declared Parent is required to prove cold-start continuity to a qualified root.',
+      allowedScope: 'Read only the exact declared or deterministically resolved repository path/ref. Do not broaden search or substitute similar material.',
+      ...(github.basis ? { resolutionBasis: github.basis } : {}),
+      hostAction: Object.freeze({
+        operation: 'plan-host-action',
+        action: 'repository-read',
+        request: Object.freeze({
+          repository: github.repository,
+          ref: github.ref,
+          path: github.path,
+          purpose: 'recover exact declared Parent for cold-start continuity proof',
+          nextOperation: 'ground'
+        }),
+        selectedTool: Object.freeze({
+          id: String(repositoryBinding.tool?.id || ''),
+          name: String(repositoryBinding.tool?.name || '')
+        })
+      }),
+      resume: resumeGround(authority)
+    });
+  }
+
+  return Object.freeze({
+    state: 'operator-required',
+    target: exactTarget,
+    whyRequired: 'This exact declared Parent is required to prove cold-start continuity to a qualified root, and no currently bound exact repository-read capability can supply it.',
+    allowedScope: 'Provide the exact declared target bytes or an accepted exact-read receipt. Do not substitute semantically similar material or widen origin scope.',
+    operatorRequest: operatorRequest(exactTarget, authority),
+    resume: resumeGround(authority)
+  });
+}
+
+function parseGithubBlob(value = '') {
+  const match = String(value || '').match(/^https:\/\/github\.com\/([^/]+\/[^/]+)\/blob\/([^/]+)\/(.+)$/i);
+  if (!match) return null;
+  return Object.freeze({ repository: match[1], ref: match[2], path: match[3], basis: 'declared-github-blob-target' });
+}
+
+function acceptedPinnedRelativeRepositoryTarget(target = '', node = {}) {
+  const raw = String(target || '').trim();
+  if (!raw || /^[a-z][a-z0-9+.-]*:/i.test(raw) || raw.startsWith('/')) return null;
+  const source = node?.record?.source || {};
+  if (source.receiptQualification !== 'accepted-host-repository-read') return null;
+  if (source.provenanceQualification !== 'accepted-host-repository-pinned') return null;
+  const repository = String(source.repository || '').trim();
+  const ref = String(source.commit || source.ref || '').trim();
+  const sourcePath = String(source.path || '').trim();
+  const path = resolveRelativeRepositoryPath(sourcePath, raw);
+  if (!repository || !ref || !path) return null;
+  return Object.freeze({
+    repository,
+    ref,
+    path,
+    basis: 'accepted-pinned-parent-source-relative-resolution'
+  });
+}
+
+function resolveRelativeRepositoryPath(sourcePath = '', target = '') {
+  const base = String(sourcePath || '').replace(/\\/g, '/').replace(/^\/+/, '');
+  const raw = String(target || '').replace(/\\/g, '/').trim();
+  if (!base || !raw || raw.startsWith('/') || /^[a-z][a-z0-9+.-]*:/i.test(raw)) return '';
+  const parts = base.split('/').filter(Boolean);
+  parts.pop();
+  for (const segment of raw.split('/')) {
+    if (!segment || segment === '.') continue;
+    if (segment === '..') {
+      if (!parts.length) return '';
+      parts.pop();
+      continue;
+    }
+    parts.push(segment);
+  }
+  return parts.join('/');
+}
+
+function operatorRequest(target = '', authority = {}) {
+  return Object.freeze({
+    role: 'Transport Operator',
+    target: String(target || ''),
+    request: target
+      ? 'Provide exactly the declared Parent material (or an accepted host exact-read receipt for it) so Tooling can resume the same ground operation.'
+      : 'Provide the exact missing Parent/continuity material identified by Tooling so the same ground operation can resume.',
+    semanticJudgmentRequired: false,
+    resume: resumeGround(authority)
+  });
+}
+
+function resumeGround(authority = {}) {
+  return Object.freeze({
+    operation: 'ground',
+    route: String(authority?.selectedRoute?.pointerPath || ''),
+    recoveryOption: '--recovery <accepted-host-receipt.json>',
+    note: 'Resume the same ground command after accept-host-receipt; recovered material remains candidate input until lineage identity/integrity qualification succeeds.'
+  });
+}
+
+function emptyProof() {
+  return Object.freeze({
+    schema: 'tiinex.portable.cold-start-continuity-proof.v1',
+    state: 'not-applicable',
+    basis: 'not-applicable',
+    routeRecordIds: Object.freeze([]),
+    ancestorRecordsChecked: 0,
+    parentEdgesChecked: 0,
+    roots: Object.freeze([]),
+    qualifiedRoots: Object.freeze([]),
+    bodiesProjected: 0,
+    compactReceiptOnly: true,
+    filenameDimensionsUsed: false,
+    carrierDimensionsUsed: false
+  });
+}
+
+function continuityBoundary() {
+  return 'Cold-start continuity is proven only through declared Parent topology and qualified loaded evidence. Apparent roots with an unavailable declared Parent are not closure; full ancestor bodies are not projected by this proof; fetched/recovered representations remain candidate material until independently qualified.';
+}
+
+function dedupe(items = []) {
+  const map = new Map();
+  for (const item of items) {
+    const key = `${item.code || ''}:${item.nodeId || ''}:${item.target || ''}`;
+    if (!map.has(key)) map.set(key, item);
+  }
+  return [...map.values()];
+}

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

@@ -0,0 +1,20 @@
+export function projectParticipantAuthority(authority = null) {
+  const role = authority?.role || {};
+  const material = role.material?.artifact || null;
+  const declared = role.authorityBoundaryLoaded || {};
+  const holder = authority?.holderBinding || {};
+  const hasBasis = String(role.state || '') === 'qualified' && Boolean(material) && Boolean(declared.mayDo || declared.doesNotAuthorize || declared.reviewBoundary);
+  if (!hasBasis) return Object.freeze({ state: 'unresolved', participantIdentityCreatesAuthority: false, conversationPositionCreatesAuthority: false, universalHumanFeedbackRule: false });
+  return Object.freeze({
+    state: 'qualified-declared-basis',
+    recipientRole: String(role.endpoint?.label || authority?.handoff?.to || ''),
+    roleMaterial: Object.freeze({ path: String(material.path || ''), schemaId: String(material.schemaId || ''), roleLabel: String(material.roleLabel || '') }),
+    authorityBoundary: Object.freeze({ mayDo: compact(declared.mayDo), doesNotAuthorize: compact(declared.doesNotAuthorize), reviewBoundary: compact(declared.reviewBoundary) }),
+    holderBinding: Object.freeze({ state: String(holder.state || 'unresolved'), roleLabel: String(holder.roleLabel || ''), source: String(holder.source || 'none'), explicit: Boolean(holder.explicit), inferredFromTransport: Boolean(holder.inferredFromTransport) }),
+    participantIdentityCreatesAuthority: false,
+    conversationPositionCreatesAuthority: false,
+    universalHumanFeedbackRule: false,
+    boundary: 'Qualified Role material plus explicit holder binding is the basis. Identity/chat position alone create no authority; no universal human-input-as-feedback rule is imposed.'
+  });
+}
+function compact(value = '', limit = 180) { const text = String(value || '').replace(/\s+/g, ' ').trim(); return text.length > limit ? `${text.slice(0, limit - 1).trimEnd()}…` : text; }

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

@@ -0,0 +1,34 @@
+const MAX_ITEMS = 6;
+
+export function projectGroundingPlanningContext(requiredContext = []) {
+  const items = [];
+  for (const entry of requiredContext || []) {
+    if (String(entry?.state || '') !== 'qualified' || typeof entry?.content !== 'string') continue;
+    const planning = section(entry.content, 'Planning Context');
+    if (!planning) continue;
+    items.push(Object.freeze({
+      requirementId: String(entry.requirementId || entry.name || ''),
+      workspace: String(entry.workspaceId || ''),
+      path: String(entry.innerPath || entry.workspaceRelativePath || ''),
+      segment: field(planning, 'Segment'),
+      purpose: field(planning, 'Purpose'),
+      endCondition: field(planning, 'End Condition'),
+      forecast: field(planning, 'Expected Remaining Turns Or Handoffs'),
+      confidence: field(planning, 'Confidence'),
+      afterBoundary: field(planning, 'After This Segment'),
+      basis: 'exact-qualified-required-context-planning-section'
+    }));
+    if (items.length >= MAX_ITEMS) break;
+  }
+  if (!items.length) return Object.freeze({ state: 'unresolved', items: Object.freeze([]) });
+  return Object.freeze({
+    state: 'qualified',
+    items: Object.freeze(items),
+    boundary: 'Only qualified carried Planning Context fields create plan semantics.'
+  });
+}
+
+function section(markdown = '', heading = '') { const escaped = escape(heading); return String(markdown || '').match(new RegExp(`(?:^|\\n)##\\s+${escaped}\\s*\\r?\\n([\\s\\S]*?)(?=\\n##\\s+|\\n#\\s+Continuity Integrity|$)`, 'i'))?.[1]?.trim() || ''; }
+function field(markdown = '', label = '') { const escaped = escape(label); return strip(String(markdown || '').match(new RegExp(`^\\s*-\\s+${escaped}:\\s*(.+)$`, 'mi'))?.[1] || ''); }
+function strip(value = '') { return String(value || '').replace(/^\[([^\]]+)\]\([^)]+\)$/, '$1').replace(/[`*_]/g, '').trim(); }
+function escape(value = '') { return String(value || '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }

package/src/tooling/portable/grounding/grounding.readiness.authority.js

@@ -0,0 +1,17 @@
+export function projectGroundingAuthority(authority, mode) {
+  if (!authority || mode !== 'routed-handoff-package') return Object.freeze({ state: 'not-supplied', route: null, handoff: null, role: null, holderBinding: null, operationBoundary: null });
+  const mutationBoundary = authority.mutationBoundary || null;
+  return Object.freeze({
+    state: String(authority.status || ''),
+    route: authority.selectedRoute ? Object.freeze({ id: authority.selectedRoute.id || '', pointerPath: authority.selectedRoute.pointerPath || '', workspaceId: authority.selectedRoute.workspaceId || '' }) : null,
+    handoff: authority.handoff ? Object.freeze({ purpose: authority.handoff.purpose || '', from: authority.handoff.from || '', to: authority.handoff.to || '', completionExpectation: authority.handoff.completionExpectation || null }) : null,
+    role: authority.role ? Object.freeze({ state: authority.role.state || '', label: authority.role.endpoint?.label || '', kind: authority.role.endpoint?.kind || '' }) : null,
+    holderBinding: authority.holderBinding ? Object.freeze({ state: authority.holderBinding.state || '', holderId: authority.holderBinding.holderId || '', roleLabel: authority.holderBinding.roleLabel || '', recipientRoleLabel: authority.holderBinding.recipientRoleLabel || '', recipientCompatibility: authority.holderBinding.recipientCompatibility || '', source: authority.holderBinding.source || '', explicit: Boolean(authority.holderBinding.explicit), inferredFromTransport: Boolean(authority.holderBinding.inferredFromTransport), boundary: authority.holderBinding.boundary || '' }) : null,
+    operationBoundary: mutationBoundary ? Object.freeze({
+      ...mutationBoundary,
+      scope: 'current-grounding-operation-only',
+      semanticAuthority: 'Handoff/Task/Role artifacts govern downstream work authority; this operation boundary neither grants nor revokes source-edit authority.',
+      boundary: 'Describes the non-mutating behavior and host-safety limits of the current Tooling grounding operation only. It must not be interpreted as a prohibition on separately authorized downstream Workspace work.'
+    }) : null
+  });
+}