@tiinex/app 0.1.1

package/src/workspaces/workspace.localSourceLifecycle.js

@@ -0,0 +1,91 @@
+import { isOriginReferenceSource } from '@tiinex/core/sources/origin.references.js';
+import { countReconciledLocalSnapshots, stripLocalSnapshotFromReconciledRecord } from './workspace.materialReconciliation.js';
+const LOCAL_SESSION_KIND = 'local-session';
+const LOCAL_SOURCE_ID = 'local';
+
+export function isLocalSessionSource(source = {}) {
+  const id = String(source?.id || '').trim();
+  const kind = String(source?.kind || '').trim();
+  const adapter = String(source?.adapterId || '').trim();
+  const sourceKind = String(source?.sourceKind || '').trim();
+  return id === LOCAL_SOURCE_ID || kind === LOCAL_SESSION_KIND || kind === 'local' || adapter === 'local' || sourceKind === 'local.session';
+}
+
+export function isLocalSessionMaterial(item = {}) {
+  const source = item?.source || {};
+  const mode = String(item?.sourceMode || '').trim().toLowerCase();
+  return isLocalSessionSource(source) || mode.startsWith('local') || mode === 'archive-local' || mode === 'zip' || mode === 'manual-file' || mode === 'manual-folder' || mode.startsWith('package-import');
+}
+
+export function countLocalRecords(workspace = {}) {
+  return (Array.isArray(workspace.records) ? workspace.records : []).filter((record) => isLocalSessionMaterial(record)).length;
+}
+
+export function summarizeLocalSourceMaterial(workspace = {}) {
+  const workspaceRecords = Array.isArray(workspace.records) ? workspace.records : [];
+  const directRecords = workspaceRecords.filter((record) => isLocalSessionMaterial(record)).length;
+  const reconciledLocalRecords = countReconciledLocalSnapshots(workspaceRecords);
+  const records = directRecords + reconciledLocalRecords;
+  const assets = (Array.isArray(workspace.assets) ? workspace.assets : []).filter((asset) => isLocalSessionMaterial(asset)).length;
+  const total = records + assets;
+  return Object.freeze({ records, directRecords, reconciledLocalRecords, assets, total });
+}
+
+export function countLocalSourceItems(workspace = {}) {
+  return summarizeLocalSourceMaterial(workspace).total;
+}
+
+export function makeLocalSource(input = {}) {
+  const counts = input.counts && typeof input.counts === 'object'
+    ? Object.assign({ records: 0, assets: 0, total: 0 }, input.counts)
+    : null;
+  const count = Number(input.count ?? counts?.total ?? 0);
+  const materialCounts = counts || Object.freeze({ records: count, assets: 0, total: count });
+  return {
+    id: LOCAL_SOURCE_ID,
+    kind: 'local',
+    adapterId: 'local',
+    sourceKind: 'local.session',
+    label: 'Local',
+    count,
+    materialCounts,
+    config: { persistence: 'browser-local' },
+    boundary: 'browser-local session material: local drafts, archive imports, assets, and workspace artifacts; no source provenance is inferred',
+    closeLabel: 'Clear local/session material',
+    closeAction: 'clear-local-session',
+    closeable: input.closeable === true || count > 0
+  };
+}
+
+export function makeLocalSourceForWorkspace(workspace = {}) {
+  const counts = summarizeLocalSourceMaterial(workspace);
+  return makeLocalSource({ count: counts.total, counts });
+}
+
+export function clearLocalSessionMaterial(workspace = {}) {
+  const beforeRecords = Array.isArray(workspace.records) ? workspace.records : [];
+  const beforeAssets = Array.isArray(workspace.assets) ? workspace.assets : [];
+  let strippedReconciledLocalRecords = 0;
+  workspace.records = beforeRecords.flatMap((record) => {
+    if (isLocalSessionMaterial(record)) return [];
+    const stripped = stripLocalSnapshotFromReconciledRecord(record);
+    if (stripped.stripped) strippedReconciledLocalRecords += 1;
+    return [stripped.record];
+  });
+  workspace.assets = beforeAssets.filter((asset) => !isLocalSessionMaterial(asset));
+  return {
+    records: (beforeRecords.length - workspace.records.length) + strippedReconciledLocalRecords,
+    reconciledLocalRecords: strippedReconciledLocalRecords,
+    assets: beforeAssets.length - workspace.assets.length
+  };
+}
+
+export function clearLocalSourceBoundary(workspace = {}, nextState = {}) {
+  const counts = clearLocalSessionMaterial(workspace);
+  workspace.sources = [makeLocalSourceForWorkspace(workspace)].concat((Array.isArray(workspace.sources) ? workspace.sources : []).filter((source) => source.id !== LOCAL_SOURCE_ID && !isOriginReferenceSource(source)));
+  workspace.sourceOrder = workspace.sources.map((source) => source.id);
+  if (workspace.discoveryProgress?.sourceId === LOCAL_SOURCE_ID) workspace.discoveryProgress = null;
+  const selected = String(nextState.view?.selectedRecordId || '').trim();
+  if (selected && !workspace.records.some((record) => String(record?.id || '') === selected)) nextState.view = Object.assign(nextState.view || {}, { selectedRecordId: '', lineageAuditReport: null, lineageLoadReport: null });
+  return counts;
+}

package/src/workspaces/workspace.materialLedger.js

@@ -0,0 +1,110 @@
+import { buildWorkspaceDiscoveryView } from './workspace.discoveryView.js';
+import { isWorkspaceRecord } from '@tiinex/core/actions/record.actions.js';
+
+export const WORKSPACE_MATERIAL_LEDGER_SCHEMA = 'tiinex.workspace.material.ledger.v1';
+
+export function buildWorkspaceMaterialLedger(workspace = {}, options = {}) {
+  const records = Array.isArray(workspace.records) ? workspace.records : [];
+  const assets = Array.isArray(workspace.assets) ? workspace.assets : [];
+  const displayOptions = options.displayOptions || workspace.displayOptions || {};
+  const query = options.query || '';
+  const discovery = buildWorkspaceDiscoveryView(workspace, { records, assets, displayOptions, query, auditById: options.auditById });
+  const hiddenReasonsByRecord = discovery.hiddenReasonsByRecordId || new Map();
+  const hiddenRecordsByReason = countReasons(hiddenReasonsByRecord);
+  const recordsBySource = new Map();
+  const visibleRecordsBySource = new Map();
+  const hiddenRecordsBySource = new Map();
+  const groupedRecordsBySource = new Map();
+  const workspaceArtifactsBySource = new Map();
+  const visibleWorkspaceArtifactsBySource = new Map();
+
+  for (const record of records) {
+    const id = sourceIdForRecord(record);
+    recordsBySource.set(id, (recordsBySource.get(id) || 0) + 1);
+    const workspaceArtifact = isWorkspaceRecord(record);
+    if (workspaceArtifact) workspaceArtifactsBySource.set(id, (workspaceArtifactsBySource.get(id) || 0) + 1);
+    const reason = hiddenReasonsByRecord.get(recordKey(record));
+    if (reason) {
+      hiddenRecordsBySource.set(id, (hiddenRecordsBySource.get(id) || 0) + 1);
+      if (reason === 'hidden-local-shadowed-by-source') groupedRecordsBySource.set(id, (groupedRecordsBySource.get(id) || 0) + 1);
+    } else {
+      visibleRecordsBySource.set(id, (visibleRecordsBySource.get(id) || 0) + 1);
+      if (workspaceArtifact) visibleWorkspaceArtifactsBySource.set(id, (visibleWorkspaceArtifactsBySource.get(id) || 0) + 1);
+    }
+  }
+
+  const hiddenRecords = Math.max(0, records.length - discovery.counts.visibleRecords);
+  const groupedRecords = Number(hiddenRecordsByReason['hidden-local-shadowed-by-source'] || 0);
+  return Object.freeze({
+    schema: WORKSPACE_MATERIAL_LEDGER_SCHEMA,
+    workspaceId: workspace.id || '',
+    counts: Object.freeze({
+      rawRecords: records.length,
+      rawAssets: assets.length,
+      rawWorkspaceArtifacts: records.filter(isWorkspaceRecord).length,
+      visibleRecords: discovery.counts.visibleRecords,
+      visibleAssets: discovery.counts.visibleAssets,
+      visibleWorkspaceArtifacts: discovery.counts.visibleWorkspaceArtifacts,
+      hiddenRecords,
+      groupedRecords,
+      hiddenByDisplayRecords: Math.max(0, hiddenRecords - groupedRecords),
+      hiddenWorkspaceArtifacts: Math.max(0, records.filter(isWorkspaceRecord).length - discovery.counts.visibleWorkspaceArtifacts),
+      lineageUsableRecords: records.length
+    }),
+    hiddenRecordsByReason: Object.freeze(hiddenRecordsByReason),
+    recordsBySource: Object.freeze(Object.fromEntries(recordsBySource.entries())),
+    visibleRecordsBySource: Object.freeze(Object.fromEntries(visibleRecordsBySource.entries())),
+    hiddenRecordsBySource: Object.freeze(Object.fromEntries(hiddenRecordsBySource.entries())),
+    groupedRecordsBySource: Object.freeze(Object.fromEntries(groupedRecordsBySource.entries())),
+    workspaceArtifactsBySource: Object.freeze(Object.fromEntries(workspaceArtifactsBySource.entries())),
+    visibleWorkspaceArtifactsBySource: Object.freeze(Object.fromEntries(visibleWorkspaceArtifactsBySource.entries())),
+    discoveryCounts: discovery.counts
+  });
+}
+
+export function materialLedgerSourceReceipt(workspace = {}, sourceId = '', adapterResult = {}, options = {}) {
+  const ledger = buildWorkspaceMaterialLedger(workspace, options);
+  const cleanId = String(sourceId || '').trim();
+  const sourceRecords = Number(ledger.recordsBySource[cleanId] || 0);
+  const visibleSourceRecords = Number(ledger.visibleRecordsBySource[cleanId] || 0);
+  const hiddenSourceRecords = Number(ledger.hiddenRecordsBySource[cleanId] || 0);
+  const groupedSourceRecords = Number(ledger.groupedRecordsBySource[cleanId] || 0);
+  const sourceWorkspaceArtifacts = Number(ledger.workspaceArtifactsBySource[cleanId] || 0);
+  const visibleSourceWorkspaceArtifacts = Number(ledger.visibleWorkspaceArtifactsBySource[cleanId] || 0);
+  const rawAdapterRecords = Number(adapterResult.rawAdapterRecords ?? adapterResult.records ?? adapterResult.okCount ?? 0);
+  return Object.freeze({
+    schema: 'tiinex.workspace.source-material.ledger-receipt.v1',
+    sourceId: cleanId,
+    rawAdapterRecords,
+    sourceRecords,
+    visibleSourceRecords,
+    hiddenSourceRecords,
+    groupedSourceRecords,
+    sourceWorkspaceArtifacts,
+    visibleSourceWorkspaceArtifacts,
+    visibleRecords: ledger.counts.visibleRecords,
+    hiddenRecords: ledger.counts.hiddenRecords,
+    groupedRecords: ledger.counts.groupedRecords,
+    hiddenByDisplayRecords: ledger.counts.hiddenByDisplayRecords,
+    lineageUsableRecords: ledger.counts.lineageUsableRecords,
+    hiddenRecordsByReason: ledger.hiddenRecordsByReason
+  });
+}
+
+function countReasons(reasonMap) {
+  const counts = {};
+  if (!reasonMap || typeof reasonMap.forEach !== 'function') return counts;
+  reasonMap.forEach((reason) => {
+    const key = String(reason || 'hidden').trim() || 'hidden';
+    counts[key] = Number(counts[key] || 0) + 1;
+  });
+  return counts;
+}
+
+function sourceIdForRecord(record = {}) {
+  return String(record?.source?.id || 'local').trim() || 'local';
+}
+
+function recordKey(record = {}) {
+  return String(record?.id || record?.path || '').trim();
+}

package/src/workspaces/workspace.materialReconciliation.case.mjs

@@ -0,0 +1,164 @@
+import assert from 'node:assert/strict';
+import { createRecordFromMarkdown } from '@tiinex/core/artifacts/artifact.record.js';
+import { recordMaterialBadge } from '../schemas/workspace/workspace.viewFormatting.js';
+import { buildWorkspaceDiscoveryView } from './workspace.discoveryView.js';
+
+await import('../sources/source.identity.js');
+await import('./workspace.lifecycle.js');
+const lifecycle = globalThis.TiinexWorkspaceLifecycle;
+
+function markdown(title, checksum, body = '', parent = '') {
+  const bodyText = body || `# ${title}`;
+  const parentLines = parent ? `- Parent Trace\n  - Path: ${parent}\n` : '';
+  return `# Continuity Context\n\n- Current\n  - Current Schema: [tiinex.topic.v1](tiinex.topic.v1.schema.md)\n  - Summary: ${title}\n${parentLines}\n---\n\n${bodyText}\n\n# Continuity Integrity\n\n- [sha256-base64url-c14n-v2](validator.md)\n  - Towards: self\n  - Value: ${checksum}\n`;
+}
+
+function sourceFixture(name = 'Recon') {
+  const created = lifecycle.createWorkspace(lifecycle.makeEmptyAppState(), { name });
+  assert.equal(created.ok, true);
+  const sourceAdded = lifecycle.addWorkspaceSource(created.state, created.workspace.id, { label: 'Repo', repository: 'owner/repo', ref: 'main', rootPath: '.topics' });
+  assert.equal(sourceAdded.ok, true);
+  return { state: sourceAdded.state, workspaceId: created.workspace.id, sourceId: sourceAdded.source.id };
+}
+
+function discoveryTitles(workspace) {
+  return buildWorkspaceDiscoveryView(workspace, { records: workspace.records }).records.map((record) => record.title);
+}
+
+{
+  const { state, workspaceId, sourceId } = sourceFixture('Checksum cluster');
+  const parent = createRecordFromMarkdown(markdown('Parent Leaf', 'parent-hash'), { path: '.topics/parent.trace.md', sourceMode: 'archive-local' });
+  const local = createRecordFromMarkdown(markdown('Same Leaf', 'same-hash', '', '.topics/parent.trace.md'), { path: '.topics/same.trace.md', sourceMode: 'archive-local' });
+  const localAdded = lifecycle.addWorkspaceRecords(state, workspaceId, [parent, local]);
+  assert.equal(localAdded.ok, true);
+  const source = createRecordFromMarkdown(markdown('Same Leaf', 'same-hash', '', '.topics/parent.trace.md'), { path: 'same.trace.md', sourceMode: 'source' });
+  const sourceAdded = lifecycle.addWorkspaceSourceRecords(localAdded.state, workspaceId, sourceId, [source]);
+  assert.equal(sourceAdded.ok, true);
+  const workspace = lifecycle.activeWorkspace(sourceAdded.state);
+  assert.equal(workspace.records.length, 2, 'verified source takeover keeps parent + one canonical source artifact');
+  assert.equal(workspace.records.filter((record) => record.title === 'Same Leaf').length, 1, 'identical local duplicate is pruned when verified source becomes canonical');
+  const canonical = workspace.records.find((record) => record.source?.id === sourceId && record.title === 'Same Leaf');
+  assert(canonical, 'source canonical variant should exist');
+  assert.equal(canonical.materialReconciliation.status, 'source-canonical-pruned-local-duplicate');
+  assert.equal(recordMaterialBadge(canonical), 'source-backed');
+  assert.deepEqual(discoveryTitles(workspace).filter((title) => title === 'Same Leaf'), ['Same Leaf'], 'feed/tree readmodel should show one visible artifact identity');
+  assert.equal(workspace.sources.find((item) => item.id === 'local').count, 1, 'Local count should retain only independent local material after exact duplicate pruning');
+  assert.equal(workspace.sources.find((item) => item.id === sourceId).count, 1, 'Configured source count should include canonical source material');
+
+  const closed = lifecycle.closeWorkspaceSource(sourceAdded.state, workspaceId, sourceId);
+  assert.equal(closed.ok, true);
+  const restoredWorkspace = lifecycle.activeWorkspace(closed.state);
+  assert.equal(restoredWorkspace.records.filter((record) => record.title === 'Same Leaf').length, 0, 'closing source must not resurrect a local copy that was already deduplicated as source-owned');
+}
+
+{
+  const { state, workspaceId, sourceId } = sourceFixture('Stable source path readmodel');
+  const local = createRecordFromMarkdown(markdown('Moved Leaf', 'stable-hash'), { path: '.topics/imported/old-comment-123.trace.md', sourceMode: 'archive-local' });
+  const localAdded = lifecycle.addWorkspaceRecords(state, workspaceId, [local]);
+  const source = createRecordFromMarkdown(markdown('Moved Leaf', 'stable-hash'), { path: '.topics/.github/owner/repo/.issues/1/001-moved-leaf.trace.md', sourceMode: 'source' });
+  const sourceAdded = lifecycle.addWorkspaceSourceRecords(localAdded.state, workspaceId, sourceId, [source]);
+  const workspace = lifecycle.activeWorkspace(sourceAdded.state);
+  assert.equal(workspace.records.length, 1, 'verified equivalent material should collapse to the stable source path');
+  const visible = buildWorkspaceDiscoveryView(workspace, { records: workspace.records }).records;
+  assert.equal(visible.length, 1, 'stable source path wins in the readmodel instead of by deleting the local record');
+  assert.equal(visible[0].path, '.topics/.github/owner/repo/.issues/1/001-moved-leaf.trace.md');
+  assert.equal(visible[0].materialReconciliation.matchedBy, 'checksum:self');
+}
+
+{
+  const { state, workspaceId, sourceId } = sourceFixture('Semantic same body is not enough');
+  const local = createRecordFromMarkdown(markdown('Semantic Leaf', 'old-envelope-hash', '# Semantic Leaf\n\nSame authored body.'), { path: '.topics/local-semantic.trace.md', sourceMode: 'archive-local' });
+  const localAdded = lifecycle.addWorkspaceRecords(state, workspaceId, [local]);
+  const source = createRecordFromMarkdown(markdown('Semantic Leaf', 'new-envelope-hash', '# Semantic Leaf\n\nSame authored body.'), { path: '.topics/source-semantic.trace.md', sourceMode: 'source' });
+  const sourceAdded = lifecycle.addWorkspaceSourceRecords(localAdded.state, workspaceId, sourceId, [source]);
+  const workspace = lifecycle.activeWorkspace(sourceAdded.state);
+  assert.equal(workspace.records.length, 2, 'same title/body without matching checksum or identity must not auto-collapse records');
+  assert.equal(workspace.records.some((record) => record.materialReconciliation?.status === 'semantic-match'), false, 'semantic-match auto merge must remain disabled');
+}
+
+{
+  const { state, workspaceId, sourceId } = sourceFixture('Checksum mismatch');
+  const local = createRecordFromMarkdown(markdown('Diverged Leaf', 'old-hash', '# Diverged Leaf\n\nOld local body.'), { path: '.topics/diverged.trace.md', sourceMode: 'archive-local' });
+  const localAdded = lifecycle.addWorkspaceRecords(state, workspaceId, [local]);
+  assert.equal(localAdded.ok, true);
+  const source = createRecordFromMarkdown(markdown('Diverged Leaf', 'new-hash', '# Diverged Leaf\n\nNew source body.'), { path: 'diverged.trace.md', sourceMode: 'source' });
+  const sourceAdded = lifecycle.addWorkspaceSourceRecords(localAdded.state, workspaceId, sourceId, [source]);
+  assert.equal(sourceAdded.ok, true);
+  const workspace = lifecycle.activeWorkspace(sourceAdded.state);
+  assert.equal(workspace.records.length, 2, 'checksum mismatch should not collapse local/source material');
+  assert.equal(workspace.records.filter((record) => record.materialReconciliation?.status === 'checksum-mismatch').length, 2, 'both sides of mismatch should be marked explicitly');
+  assert(workspace.records.some((record) => record.source.id === sourceId), 'source side should remain visible');
+  assert(workspace.records.some((record) => record.source.kind === lifecycle.SESSION_SOURCE_KIND), 'local side should remain visible');
+}
+
+{
+  const { state, workspaceId, sourceId } = sourceFixture('Local clear strips retained copy');
+  const local = createRecordFromMarkdown(markdown('Clearable Leaf', 'clear-hash'), { path: '.topics/clear.trace.md', sourceMode: 'archive-local' });
+  const localAdded = lifecycle.addWorkspaceRecords(state, workspaceId, [local]);
+  const source = createRecordFromMarkdown(markdown('Clearable Leaf', 'clear-hash'), { path: 'clear.trace.md', sourceMode: 'source' });
+  const sourceAdded = lifecycle.addWorkspaceSourceRecords(localAdded.state, workspaceId, sourceId, [source]);
+  const cleared = lifecycle.closeWorkspaceSource(sourceAdded.state, workspaceId, 'local');
+  assert.equal(cleared.ok, true);
+  const workspace = lifecycle.activeWorkspace(cleared.state);
+  assert.equal(workspace.records.length, 1, 'clearing Local leaves canonical source-backed material');
+  assert.equal(workspace.records[0].materialReconciliation.status, 'source-canonical-pruned-local-duplicate');
+  assert.equal(workspace.sources.find((item) => item.id === 'local').count, 0, 'Local count should drop after retained local copy is cleared');
+}
+
+{
+  const { state, workspaceId, sourceId } = sourceFixture('Issue comment hash identity');
+  const localA = createRecordFromMarkdown(markdown('Comment A', 'hash-a'), { path: 'https://github.com/owner/repo/issues/1#issuecomment-111', sourceMode: 'archive-local' });
+  const localB = createRecordFromMarkdown(markdown('Comment B', 'hash-b'), { path: 'https://github.com/owner/repo/issues/1#issuecomment-222', sourceMode: 'archive-local' });
+  const localAdded = lifecycle.addWorkspaceRecords(state, workspaceId, [localA, localB]);
+  const sourceA = createRecordFromMarkdown(markdown('Comment A', 'hash-a'), { path: 'https://github.com/owner/repo/issues/1#issuecomment-111', sourceMode: 'source' });
+  const sourceAdded = lifecycle.addWorkspaceSourceRecords(localAdded.state, workspaceId, sourceId, [sourceA]);
+  const workspace = lifecycle.activeWorkspace(sourceAdded.state);
+  assert.equal(workspace.records.filter((record) => /Comment/.test(record.title)).length, 2, 'matching one issue comment prunes only its identical local duplicate while preserving sibling comments');
+  assert(workspace.records.some((record) => record.title === 'Comment B' && !record.materialReconciliation), 'sibling issue comment stays independent');
+}
+
+
+{
+  const { state, workspaceId, sourceId } = sourceFixture('Container URL is provenance, not artifact identity');
+  const first = createRecordFromMarkdown(markdown('Same issue artifact one', 'container-one'), { path: '.topics/.github/owner/repo/.issues/1/001-one.trace.md', sourceMode: 'source' });
+  const second = createRecordFromMarkdown(markdown('Same issue artifact two', 'container-two'), { path: '.topics/.github/owner/repo/.issues/1/002-two.trace.md', sourceMode: 'source' });
+  const withContainer = [first, second].map((record, index) => Object.assign({}, record, {
+    recoveredFromUrl: 'https://github.com/owner/repo/issues/1',
+    snapshot: Object.assign({}, record.snapshot || {}, { sourceUrl: 'https://github.com/owner/repo/issues/1' }),
+    sourceTarget: Object.assign({}, record.sourceTarget || {}, { surface: 'issueSnapshots', inputTarget: 'https://github.com/owner/repo/issues/1', sourceArtifactPath: record.path, sourceOrdinal: index })
+  }));
+  const sourceAdded = lifecycle.addWorkspaceSourceRecords(state, workspaceId, sourceId, withContainer);
+  const workspace = lifecycle.activeWorkspace(sourceAdded.state);
+  assert.equal(workspace.records.filter((record) => record.source?.id === sourceId).length, 2, 'different artifact paths from the same issue container must not source-upsert over each other');
+}
+
+
+{
+  const { state, workspaceId, sourceId } = sourceFixture('Parent origin is not child identity');
+  const childMarkdown = `# Continuity Context
+
+- Envelope Schema: [tiinex.root.v1](tiinex.root.v1.schema.md)
+- Parent
+  - Parent Schema: [tiinex.topic.v1](tiinex.topic.v1.schema.md)
+  - Trace: [Parent](parent.trace.md)
+  - Origin: [Parent](https://github.com/owner/repo/blob/main/.topics/parent.trace.md)
+- Current
+  - Current Schema: [tiinex.topic.v1](tiinex.topic.v1.schema.md)
+  - Summary: child
+
+---
+
+# Child`;
+  const localChild = createRecordFromMarkdown(childMarkdown, { path: '.topics/child.trace.md', sourceMode: 'archive-local' });
+  const localAdded = lifecycle.addWorkspaceRecords(state, workspaceId, [localChild]);
+  const sourceParent = createRecordFromMarkdown(markdown('Parent', 'parent-hash'), { path: '.topics/parent.trace.md', sourceMode: 'source' });
+  const sourceAdded = lifecycle.addWorkspaceSourceRecords(localAdded.state, workspaceId, sourceId, [sourceParent]);
+  const workspace = lifecycle.activeWorkspace(sourceAdded.state);
+  assert.equal(workspace.records.length, 2, 'loading a declared parent must not shadow the local child that declared that Parent Origin');
+  const child = workspace.records.find((record) => record.title === 'Child');
+  assert(child, 'declaring child should remain present');
+  assert.equal(child.source.kind, lifecycle.SESSION_SOURCE_KIND, 'declaring child should remain local/imported authority');
+  assert.equal(child.materialReconciliation?.sourceRecordId || '', '', 'Parent Origin must not be used as the declaring artifact identity');
+}
+
+console.log('✓ workspace material reconciliation tests passed');