@tiinex/app 0.1.1

package/src/workspaces/workspace.lifecycle.js

@@ -0,0 +1,357 @@
+import{canonicalizeSourceRecordPath}from'./workspace.sourceRecordPath.js';
+import{canDiscardLocalDraft}from'@tiinex/core/artifacts/artifact.localDraft.js';
+import{artifactRegistryIdentityForRecord}from'../artifacts/artifact.identityAggregation.js';
+import{clearLocalSourceBoundary,countLocalRecords,isLocalSessionMaterial,makeLocalSource,makeLocalSourceForWorkspace as localSourceFor}from'./workspace.localSourceLifecycle.js';
+import{reconcileLocalRecordWithSourceBackedWorkspace,restoreLocalShadowForRemovedSource,restoreLocalSnapshotsForRemovedSourceRecord}from'./workspace.materialReconciliation.js';
+import{addWorkspaceSourceRecordsWithReconciliation}from'./workspace.sourceRecords.js';
+import{makeConfiguredSource as configuredSource}from'./workspace.configuredSource.js';
+(function attachWorkspaceLifecycle(global) {
+const WORKSPACE_NAME_MAX_LENGTH=72,RECORD_TITLE_MAX_LENGTH=96,RECORD_SUMMARY_MAX_LENGTH=280,SESSION_SOURCE_KIND='local-session',CONFIGURED_SOURCE_KIND='github-tree',GITHUB_ADAPTER_ID='github',GITHUB_REPO_SOURCE_KIND='github.repo',SOURCE_STATES=new Set(['not-started','deferred','loading','loaded','partial','failed','unavailable']);
+function nowIso(clock){return typeof clock==='function'?clock():new Date().toISOString();}
+function normalizeWorkspaceName(value){return String(value||'').replace(/\s+/g,' ').trim().slice(0,WORKSPACE_NAME_MAX_LENGTH);}
+function normalizeRecordTitle(value){return String(value||'').replace(/\s+/g,' ').trim().slice(0,RECORD_TITLE_MAX_LENGTH);}
+function normalizeRecordSummary(value){return String(value||'').replace(/\s+/g,' ').trim().slice(0,RECORD_SUMMARY_MAX_LENGTH);}
+function makeWorkspaceId(name,createdAt){
+const slug = normalizeWorkspaceName(name)
+.toLowerCase()
+.replace(/[^a-z0-9]+/g, '-')
+.replace(/^-|-$/g, '') || 'workspace';
+const stamp = String(createdAt || nowIso()).replace(/[^0-9]/g, '').slice(0, 14) || 'session';
+return `local-${slug}-${stamp}`;
+}
+function canonicalizeLocalPath(inputPath){
+let p = String(inputPath || '').trim();
+if (!p) return '';
+p = p.replace(/\\/g, '/').replace(/\/{2,}/g, '/');
+const out = [];
+for (const part of p.split('/')) {
+if (!part || part === '.') continue;
+if (part === '..') {
+out.pop();
+continue;
+}
+out.push(part);
+}
+return out.join('/');
+}
+function makeLocalRecordId(workspaceId,path){
+const canonicalPath = canonicalizeLocalPath(path);
+if (!canonicalPath) return '';
+return `local:${workspaceId || 'workspace'}:${canonicalPath}`;
+}
+function targetQualifiedMaterialIdentity(record={},workspaceId=''){
+if(!String(record?.sourceTarget?.inputTarget||'').trim())return null;
+const identity=artifactRegistryIdentityForRecord(record,[workspaceId],()=>'',()=>'', 'tiinex.workspace.material');
+return identity?.global&&String(identity.kind||'').startsWith('input-target')?identity:null;
+}
+function makeRecordId(workspaceId,title,createdAt){
+const slug = normalizeRecordTitle(title)
+.toLowerCase()
+.replace(/[^a-z0-9]+/g, '-')
+.replace(/^-|-$/g, '') || 'artifact';
+const stamp = String(createdAt || nowIso()).replace(/[^0-9]/g, '').slice(0, 17) || 'session';
+return `${workspaceId || 'workspace'}-${slug}-${stamp}`;
+}
+function makeEmptyAppState() {
+return {
+version: 1,
+activeWorkspaceId: '',
+view: { universe: 'column', workspaceVerse: 'feed', reader: 'scan', query: '' },
+workspaces: [],
+audit: null
+};
+}
+function createWorkspace(state,input={},options={}){
+const name = normalizeWorkspaceName(input.name);
+if (!name) return { ok: false, error: 'workspace.name.required', state };
+const createdAt = nowIso(options.clock), id = input.id || makeWorkspaceId(name, createdAt);
+const workspace = { id, name, title: name, createdAt, kind: 'workspace', source: makeSessionSource(), sources: [makeLocalSource()], sourceOrder: ['local'], discoveryProgress: null, records: [], assets: [], importLog: [], mode: 'feed' };
+const next = cloneState(state);
+next.workspaces = next.workspaces.filter((item) => item.id !== workspace.id).concat(workspace);
+next.activeWorkspaceId = workspace.id;
+next.view = Object.assign({ universe: 'column', workspaceVerse: 'feed', reader: 'scan', query: '' }, next.view || {}, { workspaceVerse: 'feed' });
+return { ok: true, workspace, state: next };
+}
+function addWorkspaceRecord(state,workspaceId,input={},options={}){
+const title = normalizeRecordTitle(input.title || input.name);
+if (!title) return { ok: false, error: 'record.title.required', state };
+const next = cloneState(state);
+const targetId = workspaceId || next.activeWorkspaceId;
+const workspace = next.workspaces.find((item) => item.id === targetId);
+if (!workspace) return { ok: false, error: 'workspace.not.found', state };
+const createdAt = nowIso(options.clock);
+const canonicalPath = canonicalizeLocalPath(input.path || '');
+const targetIdentity = targetQualifiedMaterialIdentity(input, workspace.id);
+const deterministicLocalId = input.id || targetIdentity?.id || makeLocalRecordId(workspace.id, canonicalPath);
+const record = Object.assign({}, input, {
+id: deterministicLocalId || makeRecordId(workspace.id, title, createdAt),
+title,
+summary: normalizeRecordSummary(input.summary || input.body || 'Local session material added in Tiinex.'),
+kind: input.kind || 'local.material',
+status: input.status || 'local',
+createdAt: input.createdAt || createdAt.slice(0, 10),
+path: canonicalPath || input.path || '',
+markdown: input.markdown || '',
+sourceMode: input.sourceMode || 'local-manual',
+hasContinuityContext: Boolean(input.hasContinuityContext),
+hasIntegrity: Boolean(input.hasIntegrity),
+source: makeSessionSource()
+});
+const existingIndex = Array.isArray(workspace.records)
+? workspace.records.findIndex((item) => item.id === record.id || (!targetIdentity && canonicalPath && !targetQualifiedMaterialIdentity(item, workspace.id) && item.source?.kind === SESSION_SOURCE_KIND && canonicalizeLocalPath(item.path || '') === canonicalPath))
+: -1;
+if (existingIndex >= 0) {
+workspace.records = workspace.records.slice();
+workspace.records[existingIndex] = record;
+} else {
+const reconciled = reconcileLocalRecordWithSourceBackedWorkspace(workspace, record);
+if (reconciled?.reconciled) {
+workspace.sources=ensureWorkspaceSources(workspace);upsertSource(workspace,localSourceFor(workspace));
+next.activeWorkspaceId = workspace.id;
+next.view = Object.assign({ universe: 'column', workspaceVerse: 'feed', reader: 'scan', query: '' }, next.view || {}, { workspaceVerse: 'feed' });
+return { ok: true, record: reconciled.record, localSnapshotRecord: record, reconciliationAction: reconciled.action, workspace, state: next };
+}
+workspace.records = [record].concat(Array.isArray(workspace.records) ? workspace.records : []);
+}
+workspace.sources=ensureWorkspaceSources(workspace);upsertSource(workspace,localSourceFor(workspace));
+next.activeWorkspaceId = workspace.id;
+next.view = Object.assign({ universe: 'column', workspaceVerse: 'feed', reader: 'scan', query: '' }, next.view || {}, { workspaceVerse: 'feed' });
+return { ok: true, record, workspace, state: next };
+}
+
+function removeWorkspaceRecord(state,workspaceId,recordId){
+const next=cloneState(state);
+const targetId=workspaceId||next.activeWorkspaceId;
+const workspace=next.workspaces.find((item)=>item.id===targetId);
+if(!workspace)return{ok:false,error:'workspace.not.found',state};
+const cleanId=String(recordId||'').trim();
+if(!cleanId)return{ok:false,error:'record.id.required',state};
+const records=Array.isArray(workspace.records)?workspace.records:[];
+const record=records.find((item)=>String(item&&item.id||'')===cleanId)||null;
+if(!record)return{ok:false,error:'record.not.found',state};
+if(!canDiscardLocalDraft(record))return{ok:false,error:'record.remove.refused',state};
+workspace.records=records.filter((item)=>String(item&&item.id||'')!==cleanId);
+workspace.sources=ensureWorkspaceSources(workspace);upsertSource(workspace,localSourceFor(workspace));
+if(String(next.view?.selectedRecordId||'')===cleanId)next.view=Object.assign({},next.view||{},{selectedRecordId:'',lineageAuditReport:null,lineageLoadReport:null});
+next.activeWorkspaceId=workspace.id;
+return{ok:true,record,workspace,state:next};
+}
+function addWorkspaceRecords(state,workspaceId,inputs=[],options={}){
+const records = Array.isArray(inputs) ? inputs : [];
+let next = cloneState(state);
+const added = [];
+for (const input of records) {
+const result = addWorkspaceRecord(next, workspaceId || next.activeWorkspaceId, input, options);
+if (result?.ok) {
+next = result.state;
+added.push(result.record);
+}
+}
+if (!added.length) return { ok: false, error: 'records.empty', state };
+const workspace = activeWorkspace(next);
+return { ok: true, records: added, workspace, state: next };
+}
+function addWorkspaceAssets(state, workspaceId, inputs = [], options = {}) {
+const assets = Array.isArray(inputs) ? inputs : [];
+const next = cloneState(state);
+const targetId = workspaceId || next.activeWorkspaceId;
+const workspace = next.workspaces.find((item) => item.id === targetId);
+if (!workspace) return { ok: false, error: 'workspace.not.found', state };
+const added = [];
+const existing = Array.isArray(workspace.assets) ? workspace.assets.slice() : [];
+for (const input of assets) {
+const canonicalPath = canonicalizeLocalPath(input.path || input.name || 'asset');
+if (!canonicalPath) continue;
+const id = input.id || `asset:${workspace.id}:${canonicalPath}`;
+const asset = Object.assign({}, input, {
+schema: input.schema || 'tiinex.local.asset.v1',
+id,
+path: canonicalPath,
+name: input.name || canonicalPath.split('/').pop() || 'asset',
+type: input.type || 'application/octet-stream',
+size: Number(input.size || 0),
+content: input.content || '',
+dataUrl: input.dataUrl || '',
+sourceMode: input.sourceMode || 'local-asset',
+source: makeSessionSource(),
+createdAt: input.createdAt || nowIso(options.clock).slice(0, 10),
+assetBoundary: 'local-asset-store',
+materialAvailability: input.materialAvailability || (input.content || input.dataUrl ? 'local-available' : 'local-metadata-only'),
+publicAvailability: 'not-public',
+boundary: 'browser-local asset availability; not source or public truth'
+});
+const idx = existing.findIndex((item) => item.id === id || canonicalizeLocalPath(item.path || '') === canonicalPath);
+if (idx >= 0) existing[idx] = asset;
+else existing.unshift(asset);
+added.push(asset);
+}
+workspace.assets = existing;
+workspace.importLog = Array.isArray(workspace.importLog) ? workspace.importLog : [];
+if (added.length) workspace.importLog.unshift({ kind: 'assets', count: added.length, at: nowIso(options.clock) });
+workspace.sources = ensureWorkspaceSources(workspace);
+upsertSource(workspace, localSourceFor(workspace));
+next.activeWorkspaceId = workspace.id;
+return { ok: Boolean(added.length), assets: added, workspace, state: next, error: added.length ? '' : 'assets.empty' };
+}
+function openWorkspaceFromMarkdown(state, markdown = '', input = {}, options = {}) {
+const title = normalizeWorkspaceName(input.title || workspaceTitleFromMarkdown(markdown) || input.name || 'Imported workspace');
+if (!title) return { ok: false, error: 'workspace.title.required', state };
+const createdAt = nowIso(options.clock);
+const workspace = {
+id: input.id || makeWorkspaceId(title, createdAt),
+name: title,
+title,
+createdAt,
+kind: 'workspace',
+source: makeSessionSource(),
+sources: [makeLocalSource()],
+sourceOrder: ['local'],
+discoveryProgress: null,
+records: [],
+assets: [],
+importLog: [{ kind: 'workspace-open', path: input.path || 'workspace.workspace.md', at: createdAt }],
+mode: 'feed',
+workspaceMarkdown: String(markdown || ''),
+workspaceImport: {
+schema: 'tiinex.workspace.import.v1',
+path: input.path || 'workspace.workspace.md',
+sourceMode: input.sourceMode || 'local-workspace-file',
+boundary: 'browser-local workspace file; no GitHub provenance inferred'
+}
+};
+const next = cloneState(state);
+next.workspaces = (next.workspaces || []).filter((item) => item.id !== workspace.id).concat(workspace);
+next.activeWorkspaceId = workspace.id;
+next.view = Object.assign({ universe: 'column', workspaceVerse: 'feed', reader: 'scan', query: '' }, next.view || {}, { workspaceVerse: 'feed' });
+return { ok: true, workspace, state: next };
+}
+function mergeWorkspaceArtifactContext(state, workspaceId, workspaceEntry = {}, options = {}) {
+const next = cloneState(state);
+const workspace = next.workspaces.find((item) => item.id === (workspaceId || next.activeWorkspaceId));
+if (!workspace) return { ok: false, error: 'workspace.not.found', state };
+const path = canonicalizeLocalPath(workspaceEntry.path || 'workspace.workspace.md') || 'workspace.workspace.md';
+const mergedAt = nowIso(options.clock);
+const merged = Object.assign({}, workspaceEntry, { path, mergedAt, mergeMode: 'artifact-context', mergedIntoWorkspaceId: workspace.id || '', mergedIntoWorkspaceTitle: workspace.title || workspace.name || '' });
+workspace.workspaceMergedEntries = Array.isArray(workspace.workspaceMergedEntries) ? workspace.workspaceMergedEntries.slice() : [];
+const idx = workspace.workspaceMergedEntries.findIndex((item) => canonicalizeLocalPath(item.path || '') === path);
+if (idx >= 0) workspace.workspaceMergedEntries[idx] = merged;
+else workspace.workspaceMergedEntries.unshift(merged);
+workspace.importLog = Array.isArray(workspace.importLog) ? workspace.importLog : [];
+workspace.importLog.unshift({ kind: 'workspace-artifact-merge', path, title: merged.title || '', at: mergedAt });
+next.activeWorkspaceId = workspace.id;
+return { ok: true, workspace, state: next, entry: merged, merge: { mode: 'artifact-context', targetWorkspaceId: workspace.id || '', targetWorkspaceTitle: workspace.title || workspace.name || '' } };
+}
+// Compatibility alias for older callers/checkpoints. Canonical runtime material remains record-based.
+function mergeWorkspaceImport(state, workspaceId, workspaceEntry = {}, options = {}) {
+return mergeWorkspaceArtifactContext(state, workspaceId, workspaceEntry, options);
+}
+function workspaceTitleFromMarkdown(markdown = '') {
+const text = String(markdown || '');
+const browserTitle = text.match(/^\s*-\s*Browser Title:\s*(.+)$/mi)?.[1]?.trim();
+if (browserTitle) return stripMarkdown(browserTitle);
+const heading = text.match(/^#\s+(.+)\s*$/m)?.[1]?.trim();
+return stripMarkdown(heading || '');
+}
+function stripMarkdown(value = '') {
+return String(value || '').replace(/^\[([^\]]+)\]\([^)]*\)$/, '$1').trim();
+}
+function addWorkspaceSourceRecords(state, workspaceId, sourceId, inputs = [], options = {}) {
+return addWorkspaceSourceRecordsWithReconciliation(state,workspaceId,sourceId,inputs,options,{cloneState,activeWorkspace,nowIso,normalizeRecordTitle,normalizeRecordSummary,normalizeSourceDiscoveryState,canonicalizeSourceRecordPath,CONFIGURED_SOURCE_KIND,ensureWorkspaceSources,upsertSource});
+}
+function addWorkspaceSource(state, workspaceId, input = {}, options = {}) {
+const next = cloneState(state);
+const targetId = workspaceId || next.activeWorkspaceId;
+const workspace = next.workspaces.find((item) => item.id === targetId);
+if (!workspace) return { ok: false, error: 'workspace.not.found', state };
+workspace.sources = ensureWorkspaceSources(workspace);
+const source = makeConfiguredSource(input, options, workspace.sources);
+upsertSource(workspace, source);
+workspace.discoveryProgress = input.progress ? sourceProgress(input.progress || {}, source) : null;
+next.activeWorkspaceId = workspace.id;
+return { ok: true, source, workspace, state: next };
+}
+function closeWorkspaceSource(state,workspaceId,sourceId){const next=cloneState(state),targetId=workspaceId||next.activeWorkspaceId,workspace=next.workspaces.find((item)=>item.id===targetId);if(!workspace)return{ok:false,error:'workspace.not.found',state};const cleanId=String(sourceId||'').trim();if(!cleanId)return{ok:false,error:'source.close.refused',state};if(cleanId==='local'){const counts=clearLocalSourceBoundary(workspace,next);next.activeWorkspaceId=workspace.id;return{ok:true,workspace,state:next,localSessionCleared:true,counts};}workspace.sources=ensureWorkspaceSources(workspace).filter(source=>source.id!==cleanId);workspace.sourceOrder=workspace.sources.map(source=>source.id);const keep=item=>String(item?.source?.id||'')!==cleanId;workspace.records=Array.isArray(workspace.records)?workspace.records.flatMap((record)=>{if(keep(record))return[restoreLocalShadowForRemovedSource(record,cleanId)];const restored=restoreLocalSnapshotsForRemovedSourceRecord(record);return restored?[restored]:[];}):[];workspace.assets=Array.isArray(workspace.assets)?workspace.assets.filter(keep):[];if(workspace.discoveryProgress?.sourceId===cleanId)workspace.discoveryProgress=null;workspace.sources=ensureWorkspaceSources(workspace);const selected=String(next.view?.selectedRecordId||'').trim();if(selected&&!workspace.records.some((record)=>String(record?.id||'')===selected))next.view=Object.assign(next.view||{},{selectedRecordId:'',lineageAuditReport:null,lineageLoadReport:null});next.activeWorkspaceId=workspace.id;return{ok:true,workspace,state:next};}
+function renameWorkspace(state,workspaceId,name){const next=cloneState(state),workspace=next.workspaces.find((item)=>item.id===(workspaceId||next.activeWorkspaceId));if(!workspace)return{ok:false,error:'workspace.not.found',state};const cleanName=normalizeWorkspaceName(name);if(!cleanName)return{ok:false,error:'workspace.name.required',state};workspace.name=cleanName;workspace.title=cleanName;workspace.renamedAt=nowIso();next.activeWorkspaceId=workspace.id;return{ok:true,workspace,state:next};}
+function closeWorkspace(state, workspaceId) {
+const next = cloneState(state);
+const targetId = workspaceId || next.activeWorkspaceId;
+const closed = next.workspaces.find((item) => item.id === targetId) || null;
+next.workspaces = next.workspaces.filter((item) => item.id !== targetId);
+next.activeWorkspaceId = next.workspaces[0]?.id || '';
+if (!next.activeWorkspaceId) {
+next.view = Object.assign({}, next.view || {}, { workspaceVerse: 'feed', query: '' });
+next.audit = null;
+}
+return { ok: Boolean(closed), closed, state: next };
+}
+function setWorkspaceVerse(state, verse) {
+const next = cloneState(state);
+const requested = String(verse || '').trim();
+const workspaceVerse = ['feed', 'tree', 'lineage', 'audit'].includes(requested) ? requested : 'feed';
+next.view = Object.assign({}, next.view || {}, { workspaceVerse });
+return next;
+}
+function setActiveWorkspace(state, workspaceId) {
+const next = cloneState(state);
+const target = String(workspaceId || '').trim();
+if (!target || !next.workspaces.some((workspace) => workspace.id === target)) return next;
+next.activeWorkspaceId = target;
+return next;
+}
+function activeWorkspace(state){return (state.workspaces || []).find((workspace)=>workspace.id===state.activeWorkspaceId)||null;}
+function cloneState(state){const base=state&&typeof state==='object'?state:makeEmptyAppState();return JSON.parse(JSON.stringify(Object.assign(makeEmptyAppState(),base)));}
+function ensureWorkspaceSources(workspace) {
+const sources = Array.isArray(workspace?.sources) ? workspace.sources.slice() : [];
+if (!sources.some((source) => source.id === 'local')) sources.unshift(localSourceFor(workspace));
+return sources.map((source) => source.id === 'local' ? Object.assign({}, source, localSourceFor(workspace)) : Object.assign({}, source));
+}
+function upsertSource(workspace, source) {
+const sources = ensureWorkspaceSources(workspace).filter((item) => item.id !== source.id);
+sources.push(Object.assign({}, source));
+workspace.sources = sources;
+workspace.sourceOrder = sources.map((item) => item.id);
+return source;
+}
+function normalizeSourceDiscoveryState(value,fallback='deferred'){const candidate=String(value||'').trim();return SOURCE_STATES.has(candidate)?candidate:fallback;}
+function makeConfiguredSource(input={},options={},existingSources=[]){return configuredSource(input,options,{configuredSourceKind:CONFIGURED_SOURCE_KIND,githubAdapterId:GITHUB_ADAPTER_ID,githubRepoSourceKind:GITHUB_REPO_SOURCE_KIND,normalizeSourceDiscoveryState,existingSources});}
+function sourceProgress(progress={},source={}){const percent=Math.max(0,Math.min(100,Number(progress.percent??48)));return{sourceId:source.id||'',phase:progress.phase||'snapshot-processing',label:progress.label||`Preparing repository snapshot from ${source.transportLabel||'repository mirror'}`,percent,active:progress.active!==false};}
+function makeSessionSource(){return{kind:SESSION_SOURCE_KIND,adapterId:'local',sourceKind:'local.session',label:'local session workspace',boundary:'browser-local session state; no source files or GitHub provenance inferred',githubPolicy:'not guessed',sourceBacked:false,writeCapability:'session-local'};}
+global.TiinexWorkspaceLifecycle = {
+RECORD_SUMMARY_MAX_LENGTH,
+RECORD_TITLE_MAX_LENGTH,
+WORKSPACE_NAME_MAX_LENGTH,
+CONFIGURED_SOURCE_KIND,
+GITHUB_ADAPTER_ID,
+GITHUB_REPO_SOURCE_KIND,
+SESSION_SOURCE_KIND,
+activeWorkspace,
+addWorkspaceRecord,
+addWorkspaceRecords,
+removeWorkspaceRecord,
+addWorkspaceAssets,
+openWorkspaceFromMarkdown,
+mergeWorkspaceArtifactContext,
+mergeWorkspaceImport,
+addWorkspaceSourceRecords,
+addWorkspaceSource,
+cloneState,
+countLocalRecords,
+closeWorkspace,
+closeWorkspaceSource,
+createWorkspace,
+renameWorkspace,
+makeEmptyAppState,
+makeConfiguredSource,
+makeLocalSource,
+normalizeSourceDiscoveryState,
+makeLocalRecordId,
+canonicalizeLocalPath,
+makeRecordId,
+makeWorkspaceId,
+normalizeRecordSummary,
+normalizeRecordTitle,
+normalizeWorkspaceName,
+setActiveWorkspace,
+setWorkspaceVerse
+};
+})(typeof window !== 'undefined' ? window : globalThis);

package/src/workspaces/workspace.lineageView.js

@@ -0,0 +1,244 @@
+import { resolveLineage } from '@tiinex/core/lineage/lineage.resolve.js';
+import { traverseLoadedLineage } from '@tiinex/core/lineage/lineage.traverse.js';
+import { schemaIdForRecord } from '@tiinex/core/schemas/schema.identity.js';
+
+export const WORKSPACE_LINEAGE_VIEW_SCHEMA_ID = 'tiinex.workspace.loadedLineageView.v1';
+
+export function buildWorkspaceLineageView(workspace = {}, input = {}) {
+  const records = Array.isArray(input.records) ? input.records : (Array.isArray(workspace.records) ? workspace.records : []);
+  const query = String(input.query || '').trim().toLowerCase();
+  const resolved = resolveLineage(records, { depth: 'loaded-workspace' });
+  const nodesById = new Map(resolved.nodes.map((node) => [node.id, node]));
+  const selectedRecordId = String(input.selectedRecordId || '').trim();
+  const selectedTraversal = selectedRecordId ? traverseLoadedLineage(records, { resolvedLineage: resolved, startId: selectedRecordId, direction: 'ancestors', maxDepth: 32 }) : null;
+  const matchedNodeIds = new Set();
+
+  if (query) {
+    for (const node of resolved.nodes) {
+      if (nodeMatchesQuery(node, query)) matchedNodeIds.add(node.id);
+    }
+    // Keep immediate lineage context visible when a match is selected. This avoids
+    // turning a filtered Lineage projection into fake missing-parent diagnostics.
+    for (const edge of resolved.edges) {
+      if (matchedNodeIds.has(edge.from) || matchedNodeIds.has(edge.to)) {
+        if (edge.from) matchedNodeIds.add(edge.from);
+        if (edge.to) matchedNodeIds.add(edge.to);
+      }
+    }
+  }
+
+  const visibleNodes = query
+    ? resolved.nodes.filter((node) => matchedNodeIds.has(node.id))
+    : resolved.nodes;
+  const visibleNodeIds = new Set(visibleNodes.map((node) => node.id));
+  const visibleEdges = resolved.edges.filter((edge) => {
+    const fromVisible = !edge.from || visibleNodeIds.has(edge.from);
+    const toVisible = !edge.to || visibleNodeIds.has(edge.to);
+    return fromVisible && toVisible;
+  });
+  const visibleFindings = resolved.findings.filter((finding) => !query || !finding.nodeId || visibleNodeIds.has(finding.nodeId));
+
+  return {
+    schema: WORKSPACE_LINEAGE_VIEW_SCHEMA_ID,
+    workspaceId: workspace.id || '',
+    title: `Lineage · ${workspace.title || workspace.name || 'workspace'}`,
+    query,
+    nodes: visibleNodes.map((node) => presentNode(node)),
+    edges: visibleEdges.map((edge) => presentEdge(edge, nodesById)),
+    findings: visibleFindings,
+    selectedTraversal: selectedTraversal ? presentSelectedTraversal(selectedTraversal, nodesById, resolved.findings) : null,
+    stats: Object.assign({}, resolved.stats, {
+      visibleNodes: visibleNodes.length,
+      visibleEdges: visibleEdges.length,
+      visibleFindings: visibleFindings.length
+    }),
+    empty: !visibleNodes.length
+  };
+}
+
+
+
+function presentSelectedTraversal(traversal = {}, nodesById = new Map(), resolvedFindings = []) {
+  const traversalNodeIds = new Set((traversal.nodes || []).map((node) => node.id));
+  const findingsByNodeId = groupFindingsByNodeId(resolvedFindings);
+  const resolvedTraversalFindings = (Array.isArray(resolvedFindings) ? resolvedFindings : []).filter((finding) => finding.nodeId && traversalNodeIds.has(finding.nodeId));
+  const terminalNodes = terminalTraversalNodes(traversal);
+  const rootNodeIds = new Set(resolvedTraversalFindings.filter((finding) => finding.code === 'lineage.root').map((finding) => finding.nodeId));
+  const ambiguous = Boolean(resolvedTraversalFindings.some((finding) => finding.code === 'lineage.target.ambiguous') || (traversal.findings || []).some((finding) => finding.code === 'lineage.target.ambiguous'));
+  const hasMissing = Boolean((traversal.missingEdges || []).length || (traversal.findings || []).some((finding) => finding.code === 'lineage.traversal.missingTarget'));
+  const hasMismatch = Boolean((traversal.edges || []).some((edge) => edge.status === 'mismatch') || resolvedTraversalFindings.some((finding) => finding.code === 'lineage.parent.integrityMismatch'));
+  const depthLimited = Boolean(traversal.stats?.stoppedAtDepth);
+  const terminalRootReached = terminalNodes.some((node) => rootNodeIds.has(node.id) || isRootLikeLineageNode(node, nodesById));
+  const rootReached = Boolean(!hasMissing && !ambiguous && !depthLimited && terminalRootReached);
+  const noParentDeclared = Boolean(!hasMissing && !ambiguous && !depthLimited && (traversal.nodes || []).length === 1 && terminalNodes.some((node) => rootNodeIds.has(node.id)));
+  const scopeTransitions = buildScopeTransitions(traversal.nodes || [], nodesById);
+  const status = traversalStatus({ rootReached, noParentDeclared, ambiguous, hasMissing, hasMismatch, depthLimited, scopeTransitions, traversal });
+  const secondaryFindings = resolvedTraversalFindings.filter((finding) => finding.code !== 'lineage.root' && finding.code !== 'lineage.parent.missing' && finding.code !== 'lineage.target.ambiguous');
+  return {
+    schema: traversal.schema,
+    boundary: traversal.boundary,
+    direction: traversal.direction,
+    maxDepth: traversal.maxDepth,
+    startIds: Array.isArray(traversal.startIds) ? traversal.startIds.slice() : [],
+    nodes: (traversal.nodes || []).map((node) => {
+      const resolvedNode = nodesById.get(node.id) || {};
+      const source = resolvedNode.record?.source || {};
+      return Object.assign({}, node, {
+        path: node.path || resolvedNode.path || '',
+        sourceId: resolvedNode.sourceId || source.id || '',
+        sourceLabel: source.label || '',
+        sourceBoundary: resolvedNode.boundary || source.boundary || '',
+        sourceRef: source.ref || '',
+        sourceBacked: Boolean(source.adapterId && source.adapterId !== 'local'),
+        record: resolvedNode.record || null,
+        findings: findingsByNodeId.get(node.id) || [],
+        terminal: terminalNodes.some((terminal) => terminal.id === node.id),
+        root: rootNodeIds.has(node.id)
+      });
+    }),
+    edges: (traversal.edges || []).map((edge) => presentEdge(edge, nodesById)),
+    missingEdges: (traversal.missingEdges || []).map((edge) => presentEdge(edge, nodesById)),
+    findings: (traversal.findings || []).slice(),
+    selectedFindings: (traversal.findings || []).filter((finding) => !finding.nodeId || traversalNodeIds.has(finding.nodeId)),
+    resolvedFindings: resolvedTraversalFindings,
+    secondaryFindings,
+    rootReached,
+    noParentDeclared,
+    ambiguous,
+    hasMissing,
+    hasMismatch,
+    depthLimited,
+    complete: status.complete,
+    completeness: status.complete ? 'complete' : 'partial',
+    terminalState: status.terminalState,
+    scopeTransitions,
+    terminalNodeIds: terminalNodes.map((node) => node.id),
+    status,
+    stats: Object.assign({}, traversal.stats || {}, { rootReached, noParentDeclared, ambiguous, hasMissing, hasMismatch, depthLimited, complete: status.complete, scopeTransitions: scopeTransitions.length })
+  };
+}
+
+function presentNode(node = {}) {
+  const record = node.record || {};
+  return {
+    id: node.id,
+    title: node.title || 'Untitled artifact',
+    path: node.path || record.path || '',
+    schemaId: node.schemaId || schemaIdForRecord(record),
+    trace: node.trace || '',
+    origin: node.origin || '',
+    boundary: node.boundary || '',
+    sourceLabel: record.source?.label || '',
+    sourceBacked: Boolean(record.source?.adapterId && record.source.adapterId !== 'local'),
+    hasContinuityContext: Boolean(node.hasContinuityContext),
+    hasIntegrity: Boolean(node.hasIntegrity),
+    record
+  };
+}
+
+function presentEdge(edge = {}, nodesById = new Map()) {
+  const fromNode = edge.from ? nodesById.get(edge.from) : null;
+  const toNode = edge.to ? nodesById.get(edge.to) : null;
+  return {
+    id: edge.id,
+    kind: edge.kind,
+    status: edge.status,
+    target: edge.target,
+    method: edge.method,
+    label: edge.label,
+    from: edge.from,
+    to: edge.to,
+    fromTitle: fromNode?.title || (edge.from ? edge.from : 'Missing target'),
+    toTitle: toNode?.title || edge.to || 'Unknown artifact',
+    fromPath: fromNode?.path || '',
+    toPath: toNode?.path || ''
+  };
+}
+
+function nodeMatchesQuery(node = {}, query = '') {
+  const record = node.record || {};
+  return [
+    node.title,
+    node.path,
+    node.schemaId,
+    node.trace,
+    node.origin,
+    node.boundary,
+    record.summary,
+    record.schemaId,
+    record.currentSchemaId,
+    record.markdown,
+    record.source?.label
+  ].some((value) => String(value || '').toLowerCase().includes(query));
+}
+
+
+function groupFindingsByNodeId(findings = []) {
+  const map = new Map();
+  for (const finding of Array.isArray(findings) ? findings : []) {
+    const id = String(finding?.nodeId || '').trim();
+    if (!id) continue;
+    if (!map.has(id)) map.set(id, []);
+    map.get(id).push(finding);
+  }
+  return map;
+}
+
+function terminalTraversalNodes(traversal = {}) {
+  const nodes = Array.isArray(traversal.nodes) ? traversal.nodes : [];
+  if (!nodes.length) return [];
+  const maxDepth = Math.max(...nodes.map((node) => Number(node.depth || 0)));
+  return nodes.filter((node) => Number(node.depth || 0) === maxDepth);
+}
+
+function isRootLikeLineageNode(node = {}, nodesById = new Map()) {
+  const resolvedNode = nodesById.get(node.id) || {};
+  const record = resolvedNode.record || {};
+  const schema = String(node.schemaId || resolvedNode.schemaId || schemaIdForRecord(record)).toLowerCase();
+  const title = String(node.title || resolvedNode.title || record.title || '').trim().toLowerCase();
+  const path = String(node.path || resolvedNode.path || record.path || '').toLowerCase();
+  return schema === 'tiinex.root.v1' || schema === 'root' || title === 'root' || /tiinex\.root\.v1\.schema\.md$/.test(path);
+}
+
+function buildScopeTransitions(nodes = [], nodesById = new Map()) {
+  const transitions = [];
+  const lineageNodes = Array.isArray(nodes) ? nodes : [];
+  for (let index = 1; index < lineageNodes.length; index += 1) {
+    const from = sourceSignature(nodesById.get(lineageNodes[index - 1]?.id));
+    const to = sourceSignature(nodesById.get(lineageNodes[index]?.id));
+    if (!from.key || !to.key || from.key === to.key) continue;
+    transitions.push(Object.freeze({
+      from: from.label,
+      to: to.label,
+      fromId: from.id,
+      toId: to.id,
+      index
+    }));
+  }
+  return Object.freeze(transitions);
+}
+
+function sourceSignature(node = {}) {
+  const record = node?.record || {};
+  const source = record.source || {};
+  const id = String(node?.sourceId || source.id || '').trim();
+  const ref = String(source.ref || '').trim();
+  const boundary = String(node?.boundary || source.boundary || '').trim();
+  const label = String(source.label || id || boundary || 'unknown source').trim();
+  const key = [id, ref, boundary].filter(Boolean).join('@');
+  return { id, ref, boundary, label: ref ? `${label}@${ref}` : label, key };
+}
+
+function traversalStatus({ rootReached = false, noParentDeclared = false, ambiguous = false, hasMissing = false, hasMismatch = false, depthLimited = false, scopeTransitions = [], traversal = {} } = {}) {
+  if (ambiguous) return { label: 'ambiguous parent', tone: 'mismatch', terminalState: 'ambiguous-parent', complete: false, message: 'Selected lineage has an ambiguous declared target; no guessed edge was created.' };
+  if (hasMissing) return { label: 'target unavailable', tone: 'mismatch', terminalState: 'target-unavailable', complete: false, message: 'Selected lineage stops because a declared parent target is not loaded.' };
+  if (hasMismatch) return { label: 'integrity mismatch', tone: 'mismatch', terminalState: 'integrity-mismatch', complete: false, message: 'Selected lineage remains navigable, but at least one parent edge has changed or does not match the child integrity declaration.' };
+  if (depthLimited) return { label: 'partial lineage', tone: 'open', terminalState: 'depth-limited', complete: false, message: 'Selected lineage reached the current traversal limit before a terminal root was proven.' };
+  if (noParentDeclared) return { label: 'no parent declared', tone: 'ok', terminalState: 'no-parent-declared', complete: true, message: 'Selected artifact declares no Parent Trace and is terminal in the loaded workspace graph.' };
+  if (rootReached && scopeTransitions.length) return { label: 'root reached · scope transition', tone: 'ok', terminalState: 'root-reached-scope-transition', complete: true, message: 'Selected Parent Trace chain reaches a loaded root and crosses explicit source scope.' };
+  if (rootReached) return { label: 'root reached', tone: 'ok', terminalState: 'root-reached', complete: true, message: 'Selected Parent Trace chain reaches a loaded root.' };
+  const nodes = Array.isArray(traversal.nodes) ? traversal.nodes : [];
+  if (nodes.length > 1) return { label: 'partial lineage', tone: 'open', terminalState: 'not-exhausted', complete: false, message: 'Selected Parent Trace chain is loaded so far, but no terminal root/no-parent state was proven.' };
+  if (nodes.length === 1) return { label: 'partial lineage', tone: 'open', terminalState: 'not-exhausted', complete: false, message: 'Selected artifact has no proven terminal lineage state in the loaded workspace.' };
+  return { label: 'selected open', tone: 'open', terminalState: 'not-loaded', complete: false, message: 'No selected lineage traversal is loaded.' };
+}