@tiinex/app 0.1.1

package/src/acceptance/postV437M0ETimePortalProductParityClosure.case.mjs

@@ -0,0 +1,51 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import '../workspaces/workspace.route.js';
+import { resolveTimePortalSnapshot } from '../app/timePortalSnapshotResolution.js';
+import { historicalWorkspaceForReadModel, loadTimePortalHistoricalReadModel } from '../app/timePortalHistoricalRead.js';
+import { normalizeTimePortalView, timePortalWithIntent, timePortalWithResolvedSnapshot } from '../workspaces/workspace.timePortal.js';
+
+const liveCommit='a'.repeat(40), historicalCommit='b'.repeat(40);
+const liveSource={ id:'github:docs', adapterId:'github', sourceKind:'github.repo', kind:'github-tree', label:'Docs', repo:'owner/repo', ref:'main', materializedCommit:liveCommit, rootPath:'.topics', repoDiscovery:true, explicitFileRefs:[], config:{repo:'owner/repo',ref:'main',rootPath:'.topics'} };
+const liveRecord={id:'live:A',title:'Live A',path:'.topics/live-a.trace.md',markdown:'# Live A',source:{...liveSource},sourceTarget:{inputTarget:'.topics/live-a.trace.md',materializedCommit:liveCommit}};
+const localDraft={id:'local:draft',title:'Local draft',path:'draft.trace.md',markdown:'# Draft',source:{id:'local',adapterId:'local'}};
+const workspace={id:'w1',title:'Docs',sources:[{id:'local',adapterId:'local'},liveSource],records:[liveRecord,localDraft],assets:[]};
+const original=JSON.stringify(workspace);
+const intent=timePortalWithIntent({workspaceVerse:'feed'},{begin:'2026-05-01T10:00',end:'2026-05-31T22:40',sourceId:'github:docs',snapshotInput:historicalCommit});
+assert.equal(normalizeTimePortalView(intent.timePortal).mode,'intent');
+const resolution=await resolveTimePortalSnapshot({workspace,view:intent,snapshotInput:historicalCommit,fetchImpl:async()=>{throw new Error('exact commit must not resolve over network');}});
+assert.equal(resolution.ok,true);
+assert.equal(resolution.snapshot.materializedCommit,historicalCommit);
+const historicalView=timePortalWithResolvedSnapshot(intent,resolution.snapshot);
+assert.equal(historicalView.timePortal.snapshot.materializedCommit,historicalCommit);
+assert.equal(liveSource.materializedCommit,liveCommit,'historical selection must not rewrite live source receipt');
+const treeUrl=`https://api.github.com/repos/owner/repo/git/trees/${historicalCommit}?recursive=1`;
+const rawUrl=`https://raw.githubusercontent.com/owner/repo/${historicalCommit}/.topics/history.trace.md`;
+const read=await loadTimePortalHistoricalReadModel({workspace,snapshot:resolution.snapshot,fetchImpl:async(url)=>{
+ if(url===treeUrl)return{ok:true,json:async()=>({truncated:false,tree:[{type:'blob',path:'.topics/history.trace.md'}]})};
+ if(url===rawUrl)return{ok:true,text:async()=> '# Historical B\n\nExact old source.'};
+ return{ok:false,status:404,statusText:'Not Found',json:async()=>({message:'missing'}),text:async()=>''};
+},options:{allowCache:false}});
+assert.equal(read.state,'loaded');
+assert.equal(JSON.stringify(workspace),original,'historical B cannot redefine live/latest A or local drafts');
+const shell=historicalWorkspaceForReadModel(workspace,read);
+assert.equal(shell.records.length,1);
+assert.equal(shell.records[0].sourceTarget.materializedCommit,historicalCommit);
+assert.equal(shell.records.some((record)=>record.id==='live:A'),false,'historical shell cannot silently show live A as historical');
+assert.equal(shell.records.some((record)=>record.id==='local:draft'),false,'local draft is not projected into historical source review');
+assert.equal(workspace.records.some((record)=>record.id==='local:draft'),true,'local draft remains intact in live workspace');
+assert.equal(shell.sources[0].closeable,false);
+assert.equal(shell.sources[0].loadable,false);
+assert.equal(shell.records[0].sourceMode,'source-backed-historical');
+
+const appSource=fs.readFileSync(new URL('../app/TiinexApp.jsx',import.meta.url),'utf8');
+assert.match(appSource,/loadHistoricalSnapshot\(workspace\.id\)/,'historical fetch remains explicit behind product action');
+const routeHandler=appSource.slice(appSource.indexOf('const onRoute ='),appSource.indexOf("window.addEventListener('popstate'"));
+assert.doesNotMatch(routeHandler,/loadHistoricalSnapshot|resolveTimePortalSnapshot|materializeGithubSource/,'semantic route restore must stay network-silent for Time Portal');
+const surfaceSource=fs.readFileSync(new URL('../schemas/workspace/workspace.views.jsx',import.meta.url),'utf8');
+assert.match(surfaceSource,/!readOnlyHistorical && \(verse === 'feed' \|\| verse === 'lineage'\)/,'historical presentation must not prepare canonical mutation actions');
+assert.match(surfaceSource,/readOnly=\{readOnlyHistorical\}/,'historical cards/tree are explicitly read-only');
+const displaySource=fs.readFileSync(new URL('../schemas/workspace/workspace.displayOptions.views.jsx',import.meta.url),'utf8');
+assert.match(displaySource,/Time Portal/);
+assert.match(displaySource,/no date is converted into a commit/);
+console.log('post-v437 M0-E Time Portal product parity closure: PASS');

package/src/acceptance/postV447M0FGithubSocialPublicationProductIntegration.case.mjs

@@ -0,0 +1,33 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+const read = (path) => fs.readFileSync(new URL(`../${path}`, import.meta.url), 'utf8');
+const plan = read('export/export.plan.js');
+const controller = read('schemas/workspace/workspace.exportDialog.controller.jsx');
+const view = read('schemas/workspace/workspace.exportDialog.views.jsx');
+const product = read('app/workspaceGithubPublication.js');
+const command = read('app/workspaceExportExecutionCommand.js');
+const snapshot = read('adapters/github/github.issueSnapshot.js');
+const publicationRead = read('adapters/github/github.publicationRead.js');
+const readTransport = read('adapters/github/github.readTransport.js');
+const persistence = read('workspaces/workspace.persistence.js');
+assert.ok(plan.includes("status: 'available'") && plan.includes('Exact issue / issue-comment'), 'GitHub social publication must no longer be stale future/Case C UI');
+assert.ok(plan.includes("action: 'guided-github-publication'"), 'export plan exposes guided routine, not hidden write');
+assert.ok(command.includes('github-publication.guided-routine-required'), 'generic export command must not simulate a provider write');
+assert.ok(product.includes('buildPublicationPlan') && product.includes('buildPublicationResult'), 'Site consumes shared plan/result authority directly');
+assert.ok(product.includes('parseExactGithubIssueTarget'), 'final target uses accepted exact shared parser');
+assert.equal(product.includes('parseGithubIssueSnapshotTarget'), false, 'permissive issue snapshot parser must not qualify publication targets');
+assert.ok(publicationRead.includes('readExactGithubIssuePublicationRepresentation'), 'bounded GitHub read sibling exposes exact post-write body observation');
+assert.equal(publicationRead.includes('parseGithubIssueSnapshotTarget'), false, 'verification read owner receives already-qualified target and does not use permissive snapshot parsing');
+assert.ok(publicationRead.includes('fetchGithubJson') && snapshot.includes('fetchGithubJson') && readTransport.includes('export async function fetchGithubJson'), 'publication verification and issue snapshots share one read-only GitHub JSON transport owner');
+assert.ok(controller.includes('copiedPlanSha256') && controller.includes('verificationPlanSha256'), 'transient completion is bound to exact plan identity');
+assert.ok(controller.includes('buildWorkspaceGithubPublicationPreflight') && controller.includes('publicationPreflight'), 'shared publication preflight is memoized per workspace/GitHub selection rather than rebuilt on each form input');
+assert.ok(view.includes('Copy exact payload') && view.includes('Open GitHub') && view.includes('Verify exact publication'), 'guided routine remains visible and ordered');
+assert.ok(view.includes('Final exact GitHub URL'), 'create-new/comment completion requires exact result target');
+assert.ok(persistence.includes('publicationReceipts'), 'qualified local receipt has durable local-delta owner');
+assert.equal(product.includes('fetch('), false, 'Site product owner must not add a second GitHub fetch implementation');
+assert.equal(product.includes('api.github.com'), false, 'Site product owner must not construct GitHub API URLs');
+assert.equal(controller.includes('api.github.com'), false);
+assert.equal(view.includes('api.github.com'), false);
+assert.equal(controller.includes('Issue #3'), false);
+assert.equal(product.includes('Tiinusen'), false);
+console.log('postV447M0FGithubSocialPublicationProductIntegration: PASS');

package/src/acceptance/postV450M0ProductAcceptanceHardening.case.mjs

@@ -0,0 +1,82 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import { createPersistenceOwnershipPolicy, PersistenceRouteOwner } from '../app/persistenceOwnership.js';
+import { executeCanonicalTransitionLocalCreate } from '../app/canonicalTransitionLocalCreateCommand.js';
+import { canonicalC14nV2SelfState } from '@tiinex/core/integrity/integrity.c14nV2.js';
+import { CANONICAL_TRANSITION_SCHEMA_CACHE_MANIFEST } from '../transitions/canonicalTransition.schemaCache.js';
+import { prepareCanonicalTransitionProductActions, prepareCanonicalTransitionWorkspaceActions } from '../transitions/transition.productPreparation.js';
+import '../workspaces/workspace.persistenceRecovery.js';
+import '../workspaces/workspace.persistenceRouteCache.js';
+import '../workspaces/workspace.persistencePresentation.js';
+import '../workspaces/workspace.persistenceClear.js';
+import '../workspaces/workspace.persistence.js';
+import '../workspaces/workspace.lifecycle.js';
+
+const lifecycle=globalThis.TiinexWorkspaceLifecycle, persistence=globalThis.TiinexWorkspacePersistence;
+const ownership=createPersistenceOwnershipPolicy(PersistenceRouteOwner.semanticState);
+const cachePaths={
+ 'tiinex.root.v1':'src/transitions/canonical-schema-cache/d69b8ff55a56b8cb9282b8684db6a938a4435b94/tiinex.root.v1.schema.md',
+ 'tiinex.transition.definition.v1':'src/transitions/canonical-schema-cache/d69b8ff55a56b8cb9282b8684db6a938a4435b94/tiinex.transition.definition.v1.schema.md',
+ 'tiinex.task.v1':'src/schemas/core/task/tiinex.task.v1.schema.md',
+ 'tiinex.topic.v1':'src/transitions/canonical-schema-cache/52ecdea0a75893882ce282214d155f70e1309c2a/tiinex.topic.v1.schema.md',
+ 'tiinex.interpretation.v1':'src/schemas/core/interpretation/tiinex.interpretation.v1.schema.md',
+ 'tiinex.relation.v1':'src/transitions/canonical-schema-cache/053d46ce082d4ec261b82abc44ecca403d61e240/tiinex.relation.v1.schema.md',
+ 'tiinex.schema.contract.v1':'src/transitions/canonical-schema-cache/053d46ce082d4ec261b82abc44ecca403d61e240/tiinex.schema.contract.v1.schema.md',
+ 'tiinex.schema.generation.v1':'src/transitions/canonical-schema-cache/053d46ce082d4ec261b82abc44ecca403d61e240/tiinex.schema.generation.v1.schema.md'
+};
+const schemaCache=CANONICAL_TRANSITION_SCHEMA_CACHE_MANIFEST.map((item)=>({...item,markdown:fs.readFileSync(cachePaths[item.schemaId],'utf8'),sourceQualification:'source-qualified-cache'}));
+function bundled(path,title,sourceQualification='site-local-definition-source-qualified'){return Object.freeze({path,title,markdown:fs.readFileSync(path,'utf8'),sourceQualification,sourceMode:'bundled-canonical-transition-definition',source:Object.freeze({id:`site:${path}`,adapterId:'static',sourceKind:'bundled-canonical',sourceMode:'bundled-canonical-transition-definition',sourceArtifactPath:path})});}
+const definitions=Object.freeze([
+ bundled('src/schemas/core/task/.transitions/topic-to-task-transition-definition.trace.md','Topic to Task','compiled-semantic-package-qualified'),
+ bundled('src/schemas/core/interpretation/.transitions/evidence-to-interpretation-transition-definition.trace.md','Evidence to Interpretation'),
+ bundled('src/schemas/core/relation/.transitions/topic-references-task-transition-definition.trace.md','Topic references Task'),
+ bundled('src/schemas/core/topic/.transitions/create-topic-transition-definition.trace.md','Create standalone Topic'),
+ bundled('src/schemas/core/task/.transitions/create-task-transition-definition.trace.md','Create standalone Task')
+]);
+const state={version:1,activeWorkspaceId:'w',view:{universe:'column',workspaceVerse:'feed',reader:'scan',query:''},workspaces:[{id:'w',name:'Workspace',title:'Workspace',createdAt:'2026-08-20T00:00:00.000Z',kind:'workspace',source:{id:'local',adapterId:'local',kind:'local-session'},sources:[],sourceOrder:[],records:[],assets:[],importLog:[],mode:'feed'}],audit:null};
+const workspaceActions=prepareCanonicalTransitionWorkspaceActions({workspaceId:'w',schemaCache,bundledDefinitions:definitions});
+const createTopic=workspaceActions.actions.find((a)=>a.canonicalIdentifier==='tiinex.site.create-topic.v1');
+const createTask=workspaceActions.actions.find((a)=>a.canonicalIdentifier==='tiinex.site.create-task.v1');
+assert.equal(createTopic.icon,'create'); assert.equal(createTask.icon,'create');
+
+// Q-reported valid-looking Topic failure: canonical Topic materialization owns representation-local whitespace normalization; generic authoring values remain untouched.
+const topic=executeCanonicalTransitionLocalCreate({lifecycle,state,workspaceId:'w',currentRecordId:'',definitionKey:createTopic.definitionKey,values:{Summary:'  Standalone Topic  ','Current Read':'  Current state\n','Design Direction':' Move here  ','Next Artifacts':' One task   '},placementFolder:'.topics/research',schemaCache,bundledDefinitions:definitions,persistenceOwnership:ownership,clock:()=> '2026-08-20T10:00:00.000Z'});
+assert.equal(topic.ok,true,topic.notice);
+assert.equal(topic.record.title,'Standalone Topic');
+assert.match(topic.record.path,/^\.topics\/research\/standalone-topic--topic(?:-\d+)?\.trace\.md$/);
+assert.equal(topic.placement.mode,'explicit-same-workspace-folder');
+assert.equal(topic.placement.folder,'.topics/research');
+assert.equal(canonicalC14nV2SelfState(topic.record.markdown).state,'verified');
+
+// Parent semantics remain canonical while only the storage coordinate changes.
+const prep=prepareCanonicalTransitionProductActions({currentRecord:topic.record,workspaceRecords:topic.workspace.records,workspaceId:'w',schemaCache,bundledDefinitions:definitions});
+const cont=prep.actions.find((a)=>a.canonicalIdentifier==='tiinex.site.topic-to-task.v1');
+const reference=prep.actions.find((a)=>a.canonicalIdentifier==='tiinex.site.topic-references-task.v1');
+assert.equal(cont.icon,'continue'); assert.equal(reference.icon,'reference');
+const task=executeCanonicalTransitionLocalCreate({lifecycle,state:topic.state,workspaceId:'w',currentRecordId:topic.record.id,definitionKey:cont.definitionKey,values:{Summary:'Placed Task',Objective:'Do it','Done Criteria':'Done',Scope:'Local',Dependencies:'None'},placementFolder:'.topics/research/tasks',schemaCache,bundledDefinitions:definitions,persistenceOwnership:ownership,clock:()=> '2026-08-20T10:01:00.000Z'});
+assert.equal(task.ok,true,task.notice);
+assert.match(task.record.path,/^\.topics\/research\/tasks\//);
+assert.equal(task.record.parentSchemaId,'tiinex.topic.v1');
+assert.ok(task.record.trace || task.record.origin, 'canonical Parent representation remains present');
+assert.equal(task.record.sourceTarget,undefined);
+
+// Exact placement survives durable workspace persistence/reopen as ordinary path truth.
+const env=memoryEnv(); persistence.writeState(task.state,{storage:env.storage,location:env.location,history:env.history,mode:'replace'}); const reopened=persistence.readRecoverableLocalState(env.storage);
+assert.equal(reopened.workspaces[0].records.find((r)=>r.id===task.record.id).path,task.record.path);
+
+// Product shape: one generic selection session drives Reference / fixed Parent review / storage placement; dialogs yield while selection is active.
+const authoring=fs.readFileSync('src/schemas/workspace/workspace.canonicalTaskDialog.views.jsx','utf8');
+const referenceDialog=fs.readFileSync('src/schemas/workspace/workspace.canonicalReferenceDialog.views.jsx','utf8');
+const surface=fs.readFileSync('src/schemas/workspace/workspace.selection.views.jsx','utf8');
+assert(authoring.includes("CANONICAL_STORAGE_PLACEMENT_SELECTION_ROLE = 'storage-placement'"));
+assert(authoring.includes("CANONICAL_CONTINUITY_PARENT_SELECTION_ROLE = 'continuity-parent'"));
+assert(referenceDialog.includes("CANONICAL_REFERENCE_SELECTION_ROLE = 'reference-target'"));
+assert(authoring.includes('return null'));
+assert(referenceDialog.includes('return null'));
+assert(surface.includes('Existing workspace context remains visible while selection is active'));
+assert.equal(surface.includes('session?.candidates'),false,'selection banner no longer owns a parallel generic candidate list');
+assert.equal(authoring.includes("schemaId === 'tiinex.task.v1'"),false);
+assert.equal(referenceDialog.includes("canonicalIdentifier ==="),false);
+
+console.log('post-v450 M0 product acceptance hardening: PASS');
+function memoryEnv(){const map=new Map();const location={pathname:'/index.html',search:'',hash:''};const history={replaceState:(_a,_b,url)=>{location.hash=url.includes('#')?`#${url.split('#').pop()}`:'';},pushState:(_a,_b,url)=>{location.hash=url.includes('#')?`#${url.split('#').pop()}`:'';}};const storage={getItem:(k)=>map.get(k)||null,setItem:(k,v)=>map.set(k,String(v)),removeItem:(k)=>map.delete(k)};return{map,location,history,storage};}

package/src/acceptance/postV470SchemaReadingContractMaterializationIdentitySourceCoalescingAuthorityCorrection.case.mjs

@@ -0,0 +1,236 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { createRecordFromMarkdown } from '@tiinex/core/artifacts/artifact.record.js';
+import { openSchemaForRecordCommand } from '../app/schemaNavigationCommand.js';
+import '../workspaces/workspace.lifecycle.js';
+
+const lifecycle = globalThis.TiinexWorkspaceLifecycle;
+const schemaId = 'tiinex.topic.v1';
+const taskId = 'tiinex.task.v1';
+const B = 'https://schemas.example.invalid/b/topic.schema.md';
+const topicMarkdown = readFileSync(new URL('../schemas/core/topic/tiinex.topic.v1.schema.md', import.meta.url), 'utf8');
+const topicPath = 'src/schemas/core/topic/tiinex.topic.v1.schema.md';
+
+// 1. Invalid same-representation record never receives recovered semantic authority.
+{
+  const declaration = declaring('rep-invalid', B);
+  const invalid = httpRepresentationRecord('invalid-b', B, '# README\n\nBAD\n');
+  const { state, workspace } = workspaceWith('rep-invalid', declaration, invalid);
+  const opened = await openSchemaForRecordCommand({ state, workspace, record: declaration, catalog: {}, fetchImpl: async () => response(topicMarkdown, B) });
+  assert.equal(opened.ok, true, opened.error);
+  assert.notEqual(opened.record.id, invalid.id);
+  assert.equal(opened.record.markdown, topicMarkdown);
+  assert.equal(opened.workspace.records.find((record) => record.id === invalid.id)?.schemaNavigation, undefined);
+}
+
+// 2. Invalid first + exact valid second on one representation reuses only the concrete valid record.
+{
+  const declaration = declaring('rep-mixed', B);
+  const invalid = httpRepresentationRecord('first-invalid', B, '# README\nBAD\n');
+  const valid = httpRepresentationRecord('second-valid', B, topicMarkdown);
+  const { state, workspace } = workspaceWith('rep-mixed', declaration, invalid, valid);
+  const opened = await openSchemaForRecordCommand({ state, workspace, record: declaration, catalog: {}, fetchImpl: async () => response(topicMarkdown, B) });
+  assert.equal(opened.ok, true, opened.error);
+  assert.equal(opened.record.id, valid.id);
+  assert.equal(opened.workspace.records.find((record) => record.id === invalid.id)?.schemaNavigation, undefined);
+  assert.equal(opened.workspace.records.find((record) => record.id === valid.id)?.schemaNavigation?.reason, 'reading-contract-badge');
+}
+
+// 3. One exact semantically-qualified representation collision may be reused truthfully.
+{
+  const declaration = declaring('rep-valid', B);
+  const valid = httpRepresentationRecord('only-valid', B, topicMarkdown);
+  const { state, workspace } = workspaceWith('rep-valid', declaration, valid);
+  const opened = await openSchemaForRecordCommand({ state, workspace, record: declaration, catalog: {}, fetchImpl: async () => response(topicMarkdown, B) });
+  assert.equal(opened.ok, true, opened.error);
+  assert.equal(opened.record.id, valid.id);
+  assert.equal(opened.record.markdown, topicMarkdown);
+}
+
+// 4. Two reusable exact collisions do not become first-hit authority.
+{
+  const declaration = declaring('rep-two-valid', B);
+  const first = httpRepresentationRecord('valid-1', B, topicMarkdown);
+  const second = httpRepresentationRecord('valid-2', B, topicMarkdown);
+  const { state, workspace } = workspaceWith('rep-two-valid', declaration, first, second);
+  const opened = await openSchemaForRecordCommand({ state, workspace, record: declaration, catalog: {}, fetchImpl: async () => response(topicMarkdown, B) });
+  assert.equal(opened.ok, false);
+  assert.equal(opened.error, 'schema.materialization.ambiguous');
+  assert.equal(workspace.records[1].schemaNavigation, undefined);
+  assert.equal(workspace.records[2].schemaNavigation, undefined);
+}
+
+// 5. Bundled schema + invalid generated-id collision fails closed; invalid bytes are untouched.
+{
+  const declaration = declaring('bundled-id', '');
+  const workspaceId = 'ws-v470-bundled-id';
+  const invalid = { id: `schema:${workspaceId}:${schemaId}`, schemaId, currentSchemaId: schemaId, path: 'ordinary/not-schema.md', markdown: '# README\nBAD\n' };
+  const { state, workspace } = workspaceWithId(workspaceId, declaration, invalid);
+  const opened = await openSchemaForRecordCommand({ state, workspace, record: declaration, schemaEntry: { markdown: topicMarkdown, path: topicPath } });
+  assert.equal(opened.ok, false);
+  assert.equal(opened.error, 'schema.materialization.identity-conflict');
+  assert.equal(invalid.schemaNavigation, undefined);
+}
+
+// 6. Bundled schema + invalid exact-path collision fails closed; path is not semantic authority.
+{
+  const declaration = declaring('bundled-path', '');
+  const invalid = { id: 'invalid-path', schemaId, currentSchemaId: schemaId, path: topicPath, markdown: '# README\nBAD\n' };
+  const { state, workspace } = workspaceWith('bundled-path', declaration, invalid);
+  const opened = await openSchemaForRecordCommand({ state, workspace, record: declaration, schemaEntry: { markdown: topicMarkdown, path: topicPath } });
+  assert.equal(opened.ok, false);
+  assert.equal(opened.error, 'schema.materialization.identity-conflict');
+  assert.equal(invalid.schemaNavigation, undefined);
+}
+
+// 7. Unrelated throwing-markdown record with no collision remains unread.
+{
+  let reads = 0;
+  const declaration = declaring('bounded-unrelated', '');
+  const unrelated = throwingRecord('unrelated', taskId, 'ordinary/unrelated.trace.md', () => { reads += 1; });
+  const { state, workspace } = workspaceWith('bounded-unrelated', declaration, unrelated);
+  const opened = await openSchemaForRecordCommand({ state, workspace, record: declaration, schemaEntry: { markdown: topicMarkdown, path: topicPath } });
+  assert.equal(opened.ok, true, opened.error);
+  assert.equal(reads, 0);
+  assert.equal(opened.workspace.records.find((record) => record.id === unrelated.id), unrelated);
+}
+
+// 8. Throwing same-representation collision is bounded/read once and never upgraded; exact recovery may materialize separately.
+{
+  let reads = 0;
+  const declaration = declaring('bounded-collision', B);
+  const collision = httpRepresentationRecord('throwing-b', B, '');
+  Object.defineProperty(collision, 'markdown', { configurable: true, enumerable: true, get() { reads += 1; throw new Error('collision markdown unreadable'); } });
+  const { state, workspace } = workspaceWith('bounded-collision', declaration, collision);
+  const opened = await openSchemaForRecordCommand({ state, workspace, record: declaration, catalog: {}, fetchImpl: async () => response(topicMarkdown, B) });
+  assert.equal(opened.ok, true, opened.error);
+  assert.equal(reads, 1);
+  assert.notEqual(opened.record.id, collision.id);
+  assert.equal(opened.workspace.records.find((record) => record.id === collision.id)?.schemaNavigation, undefined);
+}
+
+// 9. One coherent exact GitHub source boundary may coalesce as before.
+{
+  const tuple = githubTuple();
+  const declaration = declaring('source-exact', tuple.blob);
+  const existing = coherentGithubSource('source-exact-existing', tuple);
+  const { state, workspace } = workspaceWith('source-exact', declaration);
+  workspace.sources = [existing]; workspace.sourceOrder = [existing.id];
+  const opened = await openSchemaForRecordCommand({ state, workspace, record: declaration, catalog: {}, fetchImpl: async () => response(topicMarkdown, tuple.raw) });
+  assert.equal(opened.ok, true, opened.error);
+  assert.equal(opened.workspace.sources.length, 1);
+  assert.equal(opened.record.source.id, existing.id);
+}
+
+// 10. Contradictory repo aliases are not exact coalescing authority and are never repaired.
+{
+  const tuple = githubTuple();
+  const declaration = declaring('source-repo-conflict', tuple.blob);
+  const ambiguous = coherentGithubSource('source-repo-conflict-existing', tuple);
+  ambiguous.repository = 'Evil/other';
+  ambiguous.config = { ...ambiguous.config, repo: 'Evil/other' };
+  const before = JSON.stringify(ambiguous);
+  const { state, workspace } = workspaceWith('source-repo-conflict', declaration);
+  workspace.sources = [ambiguous]; workspace.sourceOrder = [ambiguous.id];
+  const opened = await openSchemaForRecordCommand({ state, workspace, record: declaration, catalog: {}, fetchImpl: async () => response(topicMarkdown, tuple.raw) });
+  assert.equal(opened.ok, true, opened.error);
+  assert.equal(opened.workspace.sources.length, 2);
+  assert.equal(JSON.stringify(opened.workspace.sources.find((source) => source.id === ambiguous.id)), before);
+  assert.notEqual(opened.record.source.id, ambiguous.id);
+}
+
+// 11. Contradictory ref aliases are independently non-coalescing and remain untouched.
+{
+  const tuple = githubTuple();
+  const declaration = declaring('source-ref-conflict', tuple.blob);
+  const ambiguous = coherentGithubSource('source-ref-conflict-existing', tuple);
+  ambiguous.config = { ...ambiguous.config, ref: 'other' };
+  const before = JSON.stringify(ambiguous);
+  const { state, workspace } = workspaceWith('source-ref-conflict', declaration);
+  workspace.sources = [ambiguous]; workspace.sourceOrder = [ambiguous.id];
+  const opened = await openSchemaForRecordCommand({ state, workspace, record: declaration, catalog: {}, fetchImpl: async () => response(topicMarkdown, tuple.raw) });
+  assert.equal(opened.ok, true, opened.error);
+  assert.equal(opened.workspace.sources.length, 2);
+  assert.equal(JSON.stringify(opened.workspace.sources.find((source) => source.id === ambiguous.id)), before);
+  assert.notEqual(opened.record.source.id, ambiguous.id);
+}
+
+// 12. Root/boundary aliases follow the same exact 0/1/>1 rule.
+{
+  const tuple = githubTuple();
+  const declaration = declaring('source-root-conflict', tuple.blob);
+  const ambiguous = coherentGithubSource('source-root-conflict-existing', tuple);
+  ambiguous.config = { ...ambiguous.config, rootPath: 'other-root' };
+  const before = JSON.stringify(ambiguous);
+  const { state, workspace } = workspaceWith('source-root-conflict', declaration);
+  workspace.sources = [ambiguous]; workspace.sourceOrder = [ambiguous.id];
+  const opened = await openSchemaForRecordCommand({ state, workspace, record: declaration, catalog: {}, fetchImpl: async () => response(topicMarkdown, tuple.raw) });
+  assert.equal(opened.ok, true, opened.error);
+  assert.equal(opened.workspace.sources.length, 2);
+  assert.equal(JSON.stringify(opened.workspace.sources.find((source) => source.id === ambiguous.id)), before);
+}
+
+// 13. Multiple coherent exact source candidates are not first-hit authority.
+{
+  const tuple = githubTuple();
+  const declaration = declaring('source-two-exact', tuple.blob);
+  const first = coherentGithubSource('source-exact-1', tuple);
+  const second = coherentGithubSource('source-exact-2', tuple);
+  const { state, workspace } = workspaceWith('source-two-exact', declaration);
+  workspace.sources = [first, second]; workspace.sourceOrder = [first.id, second.id];
+  const opened = await openSchemaForRecordCommand({ state, workspace, record: declaration, catalog: {}, fetchImpl: async () => response(topicMarkdown, tuple.raw) });
+  assert.equal(opened.ok, false);
+  assert.equal(opened.error, 'schema.source.ambiguous');
+  assert.equal(workspace.sources[0], first);
+  assert.equal(workspace.sources[1], second);
+}
+
+// 14. Generic owner/security boundaries remain intact.
+{
+  const commandSource = readFileSync(new URL('../app/schemaNavigationCommand.js', import.meta.url), 'utf8');
+  const materializationSource = readFileSync(new URL('../app/schemaNavigationMaterialization.js', import.meta.url), 'utf8');
+  for (const source of [commandSource, materializationSource]) {
+    assert.equal(/tiinex\.topic\.v1|tiinex\.task\.v1|Tiinex\/docs/u.test(source), false);
+    assert.equal(/\beval\s*\(|\bnew\s+Function\s*\(|import\s*\(\s*['"`]https?:/u.test(source), false);
+  }
+  assert.equal(/\.findIndex\(\(item\) => sameRecordIdentity/u.test(commandSource + materializationSource), false, 'first-hit materialization authority must stay removed');
+  assert.equal(/source\.repo \|\| source\.repository \|\| source\.config\?\.repo/u.test(materializationSource), false, 'first-value source repo authority must stay removed');
+  assert.equal(/source\.ref \|\| source\.config\?\.ref/u.test(materializationSource), false, 'first-value source ref authority must stay removed');
+}
+
+console.log('post-v470 schema reading-contract materialization identity + source coalescing authority correction: PASS');
+
+function declaring(id, target) {
+  const current = target ? `[${schemaId}](${target})` : schemaId;
+  const markdown = `# Continuity Context\n\n- Envelope Schema: tiinex.root.v1\n- Current\n  - Current Schema: ${current}\n  - Created At: 2026-08-21 10:00:00\n  - Summary: ${id}\n\n---\n\n# ${id}\n`;
+  return Object.assign(createRecordFromMarkdown(markdown, { path: `work/${id}.trace.md`, sourceMode: 'archive-local' }), { id, schemaId, currentSchemaId: schemaId });
+}
+
+function httpRepresentationRecord(id, target, markdown) {
+  return { id, schemaId, currentSchemaId: schemaId, path: `ordinary/${id}.txt`, sourceMode: 'source-backed', lifecycleStatus: '', markdown,
+    source: { id: `src-${id}`, adapterId: 'http', sourceKind: 'http.file', sourceBacked: true, permalink: target },
+    sourceTarget: { sourceArtifactPath: target, inputTarget: target, browseUrl: target, rawUrl: target } };
+}
+
+function throwingRecord(id, governedSchemaId, path, onRead) {
+  return { id, schemaId: governedSchemaId, currentSchemaId: governedSchemaId, path, get markdown() { onRead(); throw new Error('unrelated markdown read'); } };
+}
+
+function githubTuple() {
+  const repo = 'Acme/repo'; const ref = 'main'; const path = 'schemas/topic.schema.md';
+  return { repo, ref, path, rootPath: 'schemas', blob: `https://github.com/${repo}/blob/${ref}/${path}`, raw: `https://raw.githubusercontent.com/${repo}/${ref}/${path}` };
+}
+
+function coherentGithubSource(id, tuple) {
+  return { id, label: tuple.repo, kind: 'github-tree', adapterId: 'github', sourceKind: 'github.repo', repo: tuple.repo, repository: tuple.repo, ref: tuple.ref, rootPath: tuple.rootPath,
+    sourceBacked: true, originReferenceSource: false, recoveryOnly: false, loadable: true, explicitFileRefs: [], config: { repo: tuple.repo, ref: tuple.ref, rootPath: tuple.rootPath, explicitFileRefs: [] } };
+}
+
+function workspaceWith(label, ...records) { return workspaceWithId(`ws-v470-${label}`, ...records); }
+function workspaceWithId(id, ...records) {
+  const state = lifecycle.createWorkspace(lifecycle.makeEmptyAppState(), { id, name: 'v470' }).state;
+  const workspace = lifecycle.activeWorkspace(state);
+  workspace.records = records;
+  return { state, workspace };
+}
+function response(body, url) { return { ok: true, status: 200, url, redirected: false, text: async () => body }; }

package/src/acceptance/recoveryAcceptance.case.mjs

@@ -0,0 +1,196 @@
+import assert from 'node:assert/strict';
+import { createRecordFromMarkdown } from '@tiinex/core/artifacts/artifact.record.js';
+import { runLocalMaterialImportCommand } from '../app/localMaterialCommand.js';
+import { applyGithubSourceMaterializationCommand } from '../app/githubSourceMaterializationCommand.js';
+import { loadFullLineageCommand } from '../app/lineageCommand.js';
+import { buildWorkspaceTreeExportBundle } from '@tiinex/core/export/tree.bundle.js';
+import { exportTreeZipUint8Array } from '@tiinex/core/export/package.zip.js';
+import { buildWorkspaceMaterialLedger } from '../workspaces/workspace.materialLedger.js';
+import { stateWithSourceMaterialCleared } from '../workspaces/workspace.sourceMaterial.js';
+import '../sources/source.identity.js';
+import '../workspaces/workspace.lifecycle.js';
+
+const lifecycle = globalThis.TiinexWorkspaceLifecycle;
+const clock = () => '2026-08-09T00:00:00.000Z';
+
+const issuePath = '.topics/.github/tiinusen/socials/.issues/3/000-fs25-markaryd.workspace.md';
+const localChildPath = '.topics/.github/tiinusen/socials/.issues/3/004-fler-bondg-rdar.trace.md';
+
+const localBundle = {
+  schema: 'tiinex.export.tree.bundle.v1',
+  packageEnvelope: false,
+  files: [
+    { path: '.topics/gaming/root.workspace.md', kind: 'workspace-markdown', content: workspaceMarkdown('Gaming Import Shell') },
+    { path: localChildPath, kind: 'artifact-markdown', content: artifactMarkdown('Fler bondgårdar', 'tiinex.discovery.finding.v1', 'Gräns i spelet är nådd.', { integrity: 'fler-bondgardar' }) },
+    { path: issuePath, kind: 'workspace-markdown', content: workspaceMarkdown('FS25 Markaryd', { integrity: 'fs25-markaryd' }) },
+    { path: 'assets/evidence/local-note.txt', kind: 'asset-content', content: 'local evidence' }
+  ]
+};
+
+const imported = await runLocalMaterialImportCommand({
+  lifecycle,
+  state: lifecycle.makeEmptyAppState(),
+  fileList: [fileFromZip('tiinex-tree-gaming.zip', exportTreeZipUint8Array(localBundle))],
+  options: { clock, sourceMode: 'drop' }
+});
+assert.equal(imported.ok, true, imported.error);
+let state = imported.state;
+const importWorkspace = lifecycle.activeWorkspace(state);
+assert.equal(importWorkspace.records.length, 2, 'local tree import rehydrates leaf + workspace artifacts on one canonical record spine');
+assert.equal(importWorkspace.assets.length, 1, 'local tree import rehydrates assets');
+assert.equal(Object.prototype.hasOwnProperty.call(importWorkspace, 'workspaceMergeCandidates'), false, 'new local import does not create the legacy candidate runtime shape');
+assert.equal(importWorkspace.records.filter((record) => record.source?.adapterId === 'local').length, 2, 'imported artifacts stay browser-local/session');
+assert(importWorkspace.records.some((record) => record.path === issuePath && record.workspaceArtifactRole?.openEligible), 'workspace artifact carries Open/Merge capability as a record role');
+
+const registered = lifecycle.addWorkspaceSource(state, importWorkspace.id, {
+  label: 'Tiinusen/socials',
+  repository: 'Tiinusen/socials',
+  rootPath: '.topics',
+  issueDiscovery: true,
+  issueUrls: 'https://github.com/Tiinusen/socials/issues/3',
+  requestedSurfaces: { issueSnapshots: { requested: true }, repoFiles: { requested: false }, explicitFiles: { requested: false } }
+});
+assert.equal(registered.ok, true, registered.error);
+state = registered.state;
+const source = registered.source;
+const sourceRecords = [
+  sourceRecord('FS25 Markaryd', 'tiinex.workspace.v1', issuePath, workspaceMarkdown('FS25 Markaryd', { integrity: 'fs25-markaryd' })),
+  sourceRecord('Lagar och regler', 'tiinex.topic.v1', '.topics/.github/tiinusen/socials/.issues/3/comment-000-lagar-och-regler.trace.md', artifactMarkdown('Lagar och regler', 'tiinex.topic.v1', 'Nu ska vi få ordning på torpet.', { integrity: 'lagar' })),
+  sourceRecord('§1 Ångkvistlagen', 'tiinex.decision.v1', '.topics/.github/tiinusen/socials/.issues/3/comment-001-1-ngkvistlagen.trace.md', artifactMarkdown('§1 Ångkvistlagen', 'tiinex.decision.v1', 'Regelutkast för Ångkvistlagen.', { integrity: 'angkvistlagen' })),
+  sourceRecord('Klagomuren', 'tiinex.topic.v1', '.topics/.github/tiinusen/socials/.issues/3/comment-002-klagomuren.trace.md', artifactMarkdown('Klagomuren', 'tiinex.topic.v1', 'Klagomuren är parent till fler bondgårdar.', { integrity: 'klagomuren' })),
+  sourceRecord('Fler bondgårdar', 'tiinex.discovery.finding.v1', localChildPath, artifactMarkdown('Fler bondgårdar', 'tiinex.discovery.finding.v1', 'Gräns i spelet är nådd.', { trace: 'comment-002-klagomuren.trace.md', integrity: 'fler-bondgardar' }))
+];
+const materialized = applyGithubSourceMaterializationCommand({
+  lifecycle,
+  state,
+  workspaceId: importWorkspace.id,
+  source,
+  sourceId: source.id,
+  sourceLabel: source.label,
+  adapterResult: { okCount: sourceRecords.length, records: sourceRecords, diagnostics: { surfaces: { issueSnapshots: { loaded: sourceRecords.length } } } },
+  repository: 'Tiinusen/socials',
+  rootPath: '.topics',
+  issueDiscovery: true,
+  issueUrls: 'https://github.com/Tiinusen/socials/issues/3',
+  requestedSurfaces: source.requestedSurfaces,
+  selectedTransportSurfaces: ['issueSnapshots'],
+  transportLabel: 'proxy',
+  transportRefreshTier: 'proxy'
+});
+assert.equal(materialized.ok, true, materialized.error);
+state = materialized.state;
+const sourceWorkspace = state.workspaces.find((workspace) => workspace.id === importWorkspace.id);
+const sourceAfter = sourceWorkspace.sources.find((item) => item.id === source.id);
+assert.equal(sourceAfter.discoveryState, 'loaded', 'materialized source is marked loaded');
+assert.equal(sourceAfter.count, 5, 'source count tracks inserted source-backed records');
+assert.equal(sourceAfter.surfaces.issueSnapshots.loaded, 5, 'issue surface count survives source command');
+assert.equal(sourceWorkspace.records.filter((record) => record.source?.id === source.id).length, 5, 'source command inserts all source issue artifacts');
+assert.equal(sourceWorkspace.records.filter((record) => record.source?.adapterId === 'local').length, 0, 'verified equivalent local artifacts are pruned once source becomes canonical');
+assert.equal(Object.prototype.hasOwnProperty.call(sourceWorkspace, 'workspaceMergeCandidates'), false, 'workspace artifacts stay canonical records without a legacy candidate runtime shape');
+const ledger = buildWorkspaceMaterialLedger(sourceWorkspace, { displayOptions: sourceWorkspace.displayOptions || {} });
+assert.equal(ledger.recordsBySource[source.id], 5, 'ledger source count matches inserted issue artifacts');
+assert.equal(Number(ledger.groupedRecordsBySource.local || 0), 0, 'exact local duplicates are not hidden as shadow payloads');
+assert.equal(ledger.workspaceArtifactsBySource[source.id], 1, 'ledger counts source-backed workspace artifact records');
+assert.equal(materialized.materialLedgerReceipt.rawAdapterRecords, 5, 'source receipt keeps raw adapter count');
+assert.equal(materialized.materialLedgerReceipt.sourceRecords, 5, 'source receipt keeps inserted source count');
+assert.equal(materialized.materialLedgerReceipt.sourceWorkspaceArtifacts, 1, 'source receipt exposes workspace artifact role without candidate duplication');
+
+const cleared = stateWithSourceMaterialCleared(state, importWorkspace.id, source.id, { discoveryState: 'deferred' });
+assert.equal(cleared.ok, true, cleared.error);
+assert.equal(cleared.workspace.records.some((record) => record.source?.id === source.id), false, 'source refresh clear removes source-backed records');
+assert.equal(cleared.workspace.records.filter((record) => record.source?.adapterId === 'local').length, 0, 'source clear does not resurrect deduplicated local copies');
+assert.equal(cleared.workspace.assets.length, 1, 'independent local asset remains after source clear');
+
+const exportBundle = buildWorkspaceTreeExportBundle(sourceWorkspace, { clock });
+assert.equal(exportBundle.packageEnvelope, false, 'ordinary tree export remains envelope-free');
+assert.equal(exportBundle.counts.records, 4, 'tree export counts non-workspace artifact Markdown separately');
+assert.equal(exportBundle.counts.workspaceEntries, 2, 'tree export includes current workspace entry and canonical workspace artifact record');
+assert(exportBundle.files.some((file) => file.path === issuePath), 'tree export preserves source-canonical workspace entry path');
+assert(!exportBundle.files.some((file) => file.path.startsWith('tiinex.package/')), 'ordinary tree export does not include package envelope paths');
+
+const reimported = await runLocalMaterialImportCommand({
+  lifecycle,
+  state: lifecycle.makeEmptyAppState(),
+  fileList: [fileFromZip('roundtrip.zip', exportTreeZipUint8Array(exportBundle))],
+  options: { clock, sourceMode: 'acceptance-roundtrip' }
+});
+assert.equal(reimported.ok, true, reimported.error);
+const roundtripWorkspace = lifecycle.activeWorkspace(reimported.state);
+assert(roundtripWorkspace.records.length >= 5, 'roundtrip rehydrates exported artifact records');
+assert.equal(roundtripWorkspace.records.filter((record) => record.source?.adapterId === 'github').length, 0, 'roundtrip import remains local/session and does not infer GitHub source-backed authority');
+assert.equal(Object.prototype.hasOwnProperty.call(roundtripWorkspace, 'workspaceMergeCandidates'), false, 'roundtrip preserves workspace capability on records without legacy candidate runtime shape');
+assert(roundtripWorkspace.records.some((record) => record.path === issuePath && record.workspaceArtifactRole?.openEligible), 'roundtrip preserves workspace artifact capability');
+
+const lineageChildMarkdown = `# Continuity Context\n\n- Envelope Schema: [tiinex.root.v1](tiinex.root.v1.schema.md)\n- Parent\n  - Parent Schema: [tiinex.topic.v1](tiinex.topic.v1.schema.md)\n  - Trace: [Recovered parent](recovered-parent.trace.md)\n  - Origin: [Recovered parent](https://github.com/Tiinex/docs/blob/abc123/.topics/recovered-parent.trace.md)\n- Current\n  - Current Schema: [tiinex.topic.v1](tiinex.topic.v1.schema.md)\n  - Summary: Local child with explicit source boundary\n\n---\n\n# Local Child With Explicit Origin`;
+const lineageChild = Object.assign(createRecordFromMarkdown(lineageChildMarkdown, { path: 'local/child.trace.md', sourceMode: 'archive-local' }), {
+  id: 'local:acceptance-origin-child',
+  source: { id: 'local', kind: 'local', adapterId: 'local', sourceKind: 'local.session' }
+});
+const lineageCreated = lifecycle.createWorkspace(lifecycle.makeEmptyAppState(), { name: 'Acceptance Lineage' }, { clock });
+const lineageWorkspace = lifecycle.activeWorkspace(lineageCreated.state);
+lineageWorkspace.records = [lineageChild];
+lineageWorkspace.sources = [{ id: 'local', kind: 'local', adapterId: 'local', sourceKind: 'local.session', sourceBacked: false }];
+const fetched = [];
+const lineageLoaded = await loadFullLineageCommand({
+  lifecycle,
+  state: lineageCreated.state,
+  workspace: lineageWorkspace,
+  selectedRecordId: lineageChild.id,
+  fetchImpl: async (url) => {
+    fetched.push(String(url || ''));
+    return { ok: true, status: 200, statusText: 'OK', transportTier: 'direct', text: async () => artifactMarkdown('Recovered Parent', 'tiinex.topic.v1', 'Recovered parent', { integrity: 'recovered-parent' }) };
+  },
+  clock
+});
+assert.equal(lineageLoaded.ok, true, lineageLoaded.error);
+assert.equal(lineageLoaded.recoveredParents, 1, 'explicit origin recovers missing parent without a pre-added discovery source');
+assert.equal(lineageLoaded.lineageLoadReport.state, 'complete');
+assert(fetched.includes('https://raw.githubusercontent.com/tiinex/docs/abc123/.topics/recovered-parent.trace.md'), 'lineage recovery uses exact GitHub blob ref from Origin');
+const lineageAfter = lifecycle.activeWorkspace(lineageLoaded.state);
+assert.equal(lineageAfter.records.find((record) => record.id === lineageChild.id).source.id, 'local', 'declaring imported/local child remains local after recovery');
+const recoverySource = lineageAfter.sources.find((item) => item.id === 'origin:github:tiinex:docs');
+assert(recoverySource && recoverySource.originReferenceSource, 'recovery-only source boundary is registered');
+assert.equal(recoverySource.sourceBacked, false, 'recovery-only boundary does not claim imported material is source-backed');
+
+console.log('✓ recovery acceptance scenarios passed');
+
+function fileFromZip(name, zip) {
+  return { name, size: zip.byteLength, type: 'application/zip', arrayBuffer: async () => zip.buffer.slice(zip.byteOffset, zip.byteOffset + zip.byteLength) };
+}
+
+function sourceRecord(title, schemaId, path, markdown) {
+  return {
+    title,
+    path,
+    kind: schemaId,
+    schemaId,
+    markdown,
+    sourceMode: 'github-issue-embedded-artifact',
+    sourceTarget: {
+      surface: 'issueSnapshots',
+      targetKind: 'github-issue-embedded-artifact',
+      inputTarget: 'https://github.com/Tiinusen/socials/issues/3',
+      sourceArtifactPath: path
+    },
+    integrity: { entries: [{ towards: 'self', value: integrityFromMarkdown(markdown) }] }
+  };
+}
+
+function workspaceMarkdown(title, options = {}) {
+  const integrity = options.integrity || slug(title);
+  return `# Continuity Context\n\n- Envelope Schema: [tiinex.root.v1](tiinex.root.v1.schema.md)\n- Current\n  - Current Schema: [tiinex.workspace.v1](tiinex.workspace.v1.schema.md)\n  - Created At: 2026-08-09\n  - Summary: ${title} workspace.\n\n---\n\n# ${title}\n\n- Browser Title: ${title}\n\n---\n\n# Continuity Integrity\n\n- sha256-base64url-c14n-v2\n  - Towards: self\n  - Value: ${integrity}\n`;
+}
+
+function artifactMarkdown(title, schemaId, summary, options = {}) {
+  const parent = options.trace ? `- Parent\n  - Parent Schema: [tiinex.topic.v1](tiinex.topic.v1.schema.md)\n  - Trace: [Parent](${options.trace})\n` : '';
+  const integrity = options.integrity || slug(title);
+  return `# Continuity Context\n\n- Envelope Schema: [tiinex.root.v1](tiinex.root.v1.schema.md)\n${parent}- Current\n  - Current Schema: [${schemaId}](${schemaId}.schema.md)\n  - Created At: 2026-08-09\n  - Summary: ${summary}\n\n---\n\n# ${title}\n\n${summary}\n\n---\n\n# Continuity Integrity\n\n- sha256-base64url-c14n-v2\n  - Towards: self\n  - Value: ${integrity}\n`;
+}
+
+function integrityFromMarkdown(markdown = '') {
+  return String(markdown).match(/-\s*Value:\s*(.+)$/mi)?.[1]?.trim() || '';
+}
+
+function slug(value = '') {
+  return String(value || '').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '') || 'fixture';
+}