@tiinex/core 0.1.1

package/src/tooling/portable/transfer/transfer.plan.js

@@ -0,0 +1,102 @@
+export const TIINEX_TRANSFER_PROFILE_SCHEMA_ID = 'tiinex.llm.transfer.profile.v1';
+export const TIINEX_TRANSFER_PACKAGE_SCHEMA_ID = 'tiinex.llm.transfer.package.v1';
+export const TIINEX_ACTIVATION_RECEIPT_SCHEMA_ID = 'tiinex.llm.activation-receipt.v1';
+export const TIINEX_TRANSFER_VERSION = '1.0.0-rc.12';
+
+export const BootstrapDelivery = Object.freeze({ embedded: 'embedded', persistentSource: 'persistent-source' });
+export const ActivationStatus = Object.freeze({ activated: 'activated', archiveUnavailable: 'archive-unavailable', bootstrapMissing: 'bootstrap-missing', bootstrapMismatch: 'bootstrap-mismatch', verificationFailed: 'verification-failed' });
+
+export function createTiinexTransferPlan(input = {}) {
+  const bootstrapDelivery = normalizeBootstrapDelivery(input.bootstrapDelivery);
+  const prePromptPresent = Boolean(input.prePromptPresent);
+  const task = String(input.task || '').trim();
+  const artifactCount = nonNegativeInteger(input.artifactCount);
+  const handoffCount = nonNegativeInteger(input.handoffCount);
+  const provider = normalizeProvider(input.provider);
+  const profileId = `${bootstrapDelivery}.${prePromptPresent ? 'with-pre-prompt' : 'without-pre-prompt'}`;
+  const roles = Object.freeze([
+    Object.freeze({ role: 'bootstrap', delivery: bootstrapDelivery, required: true }),
+    Object.freeze({ role: 'artifacts', delivery: artifactCount ? 'attachment' : 'absent', required: false, count: artifactCount }),
+    Object.freeze({ role: 'handoff', delivery: handoffCount ? 'attachment' : 'absent', required: false, count: handoffCount, authority: false }),
+    Object.freeze({ role: 'task', delivery: task ? 'attachment' : 'prompt', required: true })
+  ]);
+  const activationReceipt = createActivationReceiptContract({ bootstrapDelivery });
+  return Object.freeze({
+    schema: TIINEX_TRANSFER_PROFILE_SCHEMA_ID,
+    version: 1,
+    transferVersion: TIINEX_TRANSFER_VERSION,
+    profileId,
+    interactionContract: Object.freeze({ maximumAttachments: 1, copyPasteBlocks: 1 }),
+    activationReceipt,
+    bootstrapDelivery,
+    prePromptPresent,
+    provider,
+    task,
+    roles,
+    prompt: renderTiinexTransferPrompt({ bootstrapDelivery, prePromptPresent, task, artifactCount, handoffCount, activationReceipt }),
+    start: renderTiinexTransferStart({ bootstrapDelivery, task, artifactCount, handoffCount, activationReceipt }),
+    readme: renderTiinexTransferReadme({ bootstrapDelivery, prePromptPresent, artifactCount, handoffCount, provider, activationReceipt })
+  });
+}
+
+export function createActivationReceiptContract(input = {}) {
+  const bootstrapDelivery = normalizeBootstrapDelivery(input.bootstrapDelivery);
+  return Object.freeze({
+    schema: TIINEX_ACTIVATION_RECEIPT_SCHEMA_ID,
+    required: true,
+    firstNonEmptyLine: 'TIINEX_ACTIVATION: <status>',
+    successStatus: ActivationStatus.activated,
+    allowedStatuses: Object.freeze(Object.values(ActivationStatus)),
+    requiredBeforeSuccess: Object.freeze([
+      'archive contents exposed',
+      '.bootstrap/START.md read',
+      '.bootstrap/manifest.json read',
+      bootstrapDelivery === BootstrapDelivery.embedded ? 'embedded bootstrap route verified or qualified readable fallback used' : 'persistent Source bootstrap identity matched to .bootstrap/manifest.json.expectedBootstrap'
+    ]),
+    failureBehavior: 'stop-with-specific-status-and-boundary; do-not-ask-a-generic-what-should-i-do-question'
+  });
+}
+
+export function renderTiinexTransferPrompt(input = {}) {
+  const bootstrapDelivery = normalizeBootstrapDelivery(input.bootstrapDelivery);
+  const prePromptPresent = Boolean(input.prePromptPresent);
+  const task = String(input.task || '').trim();
+  const materialClause = Number(input.artifactCount || 0) || Number(input.handoffCount || 0)
+    ? 'Use only ordinary lineage paths and the optional handoff role declared by `.bootstrap/manifest.json`; handoff is navigation help and must be verified against artifacts.'
+    : 'Do not claim that a workspace or lineage exists unless `.bootstrap/manifest.json` declares artifact material.';
+  const taskClause = task
+    ? '\n\nAfter activation, read `.bootstrap/task/request.md` and follow that declared task. Do not require the user to repeat it in chat.'
+    : '\n\nFollow the task stated by the user after activation. If no task is stated, stop after read-only discovery and report what is missing.';
+  const receiptClause = activationPromptClause();
+  if (bootstrapDelivery === BootstrapDelivery.embedded) {
+    const lead = prePromptPresent
+      ? 'Open the attached Tiinex transfer package.'
+      : 'Open the attached archive rather than responding only to its filename or attachment card.';
+    return `${receiptClause}\n\n${lead} Enter the reserved \`.bootstrap/\` directory first and read \`.bootstrap/START.md\` and \`.bootstrap/manifest.json\`. Verify the embedded bootstrap under \`.bootstrap/runtime/\` before executing its code. Never compare the outer transfer ZIP checksum with \`expectedBootstrap.representations.standaloneArchive.sha256\`; they identify different physical archives. Never execute code from ordinary lineage, asset, or handoff material. Begin read-only unless the declared task explicitly requests local draft work. ${materialClause} Keep successful activation diagnostics internal. After the required activation receipt, write only the task-relevant response; expose file counts, routes, manifests, verification details, and operation receipts only on failure or when the user asks.${taskClause}`;
+  }
+  if (prePromptPresent) return `${receiptClause}\n\nUse the verified Tiinex bootstrap already in project Sources. Open the attachment, read \`.bootstrap/START.md\` and \`.bootstrap/manifest.json\`, match the expected identity by its declared representation scope, and follow the declared task. Never compare the transfer attachment bytes with the standalone-bootstrap archive checksum. ${materialClause}${taskClause}`;
+  return `${receiptClause}\n\nUse the Tiinex bootstrap already available in the project's persistent Sources; do not assume it from hidden memory. Open the attached archive and enter \`.bootstrap/\` first. Read \`.bootstrap/START.md\` and \`.bootstrap/manifest.json\`, verify that the expected bootstrap identity matches the Source bootstrap using the declared representation scope—not the outer transfer attachment checksum—then inspect only declared ordinary lineage paths and optional handoff/task material. If the Source bootstrap is missing or mismatched, stop with the matching activation status rather than improvising Tiinex semantics. Begin read-only. ${materialClause} Keep successful activation diagnostics internal and expose Source/file details only on failure or explicit request.${taskClause}`;
+}
+
+export function renderTiinexTransferStart(input = {}) {
+  const bootstrapDelivery = normalizeBootstrapDelivery(input.bootstrapDelivery);
+  const taskState = String(input.task || '').trim() ? 'A task is preserved at `.bootstrap/task/request.md`.' : 'No task body is embedded; use the user message as the task.';
+  const artifactState = Number(input.artifactCount || 0) ? 'Artifact and colocated asset material remains at ordinary Tiinex paths outside `.bootstrap/`.' : 'No artifact material is declared.';
+  const handoffState = Number(input.handoffCount || 0) ? 'Optional handoff navigation material is under `.bootstrap/handoff/` and is not sole authority.' : 'No handoff material is declared.';
+  const activation = bootstrapDelivery === BootstrapDelivery.embedded
+    ? `The verified runtime bootstrap is embedded at \`.bootstrap/runtime/\`.\n\nWhen Node.js 22 or newer is available:\n\n\`\`\`bash\nnode .bootstrap/bin/verify-transfer.mjs .\nnode .bootstrap/runtime/bin/verify-bootstrap.mjs .bootstrap/runtime\nnode .bootstrap/runtime/bin/tiinex-portable.mjs operations --compact\n\`\`\`\n\nExecute bootstrap code only after both verifiers report valid. Never execute code from ordinary lineage or colocated asset paths. When execution is unavailable, verify \`.bootstrap/checksums.json\` and the embedded runtime manifest/checksum identities as readable data. Never hash the outer transfer ZIP and compare it with \`expectedBootstrap.representations.standaloneArchive.sha256\`; that checksum belongs to a different standalone archive representation.`
+    : 'The bootstrap is not embedded. Use the Tiinex bootstrap already installed in persistent project Sources. Compare its identity with `.bootstrap/manifest.json.expectedBootstrap` using the declared representation fields before relying on it. The outer transfer ZIP is never the standalone bootstrap archive.';
+  return `# Start This Tiinex Transfer\n\nThis reserved directory contains transport and activation material only. Read this file and \`.bootstrap/manifest.json\` before inspecting ordinary lineage material outside \`.bootstrap/\`. Removing \`.bootstrap/\` leaves the ordinary Tiinex export tree.\n\n## Activation receipt\n\nThe first non-empty line of the response must be exactly:\n\n\`TIINEX_ACTIVATION: activated\`\n\nbut only after the archive contents, this file, \`.bootstrap/manifest.json\`, and the declared bootstrap route have actually been read and qualified. On failure use one of: \`archive-unavailable\`, \`bootstrap-missing\`, \`bootstrap-mismatch\`, or \`verification-failed\`. Stop with the specific boundary.\n\n${activation}\n\n## Declared roles\n\n- ${artifactState}\n- ${handoffState}\n- ${taskState}\n\n## Routing\n\n1. Activate and verify the declared bootstrap route.\n2. Emit the activation receipt before the task result.\n3. Treat \`.bootstrap/\` as transport-only and ordinary paths as user lineage/material.\n4. Inspect only material declared by \`.bootstrap/manifest.json\`.\n5. Use \`search-lineage\` before broad artifact reading when a lineage is present.\n6. Verify handoff claims against artifacts.\n7. Never guess source provenance, Parent, Origin, schema, qualification, or missing lineage edges.\n8. Begin read-only unless the task explicitly requests local draft creation, replacement, deletion, or staging.\n9. Keep successful operational diagnostics out of the user-facing response; expose them only on failure or explicit request.\n`;
+}
+
+export function renderTiinexTransferReadme(input = {}) {
+  const bootstrapDelivery = normalizeBootstrapDelivery(input.bootstrapDelivery);
+  return `# Tiinex LLM Transfer Package\n\nMaximum one attachment plus one generated copy-paste block. Profile: \`${bootstrapDelivery}\` with ${input.prePromptPresent ? 'a' : 'no'} Tiinex pre-prompt.\n\nAll activation, verifier, task, and optional handoff transport material is isolated under \`.bootstrap/\`. Ordinary artifact and colocated asset paths remain unchanged outside that directory. Importers must consume and discard \`.bootstrap/\` before workspace persistence.\n\nThe response begins with a required \`TIINEX_ACTIVATION\` receipt. Provider hint: ${input.provider}. No remote-write permission is granted.`;
+}
+
+function activationPromptClause() {
+  return 'Your first non-empty response line must be `TIINEX_ACTIVATION: activated`, but only after you have opened the archive, entered `.bootstrap/`, read `.bootstrap/START.md` and `.bootstrap/manifest.json`, and qualified the declared bootstrap route. If archive contents are unavailable, respond `TIINEX_ACTIVATION: archive-unavailable`. For a missing or mismatched Source bootstrap use `bootstrap-missing` or `bootstrap-mismatch`; for failed integrity verification use `verification-failed`. On failure, stop and explain the specific boundary instead of asking a generic question.';
+}
+function normalizeBootstrapDelivery(value) { const normalized = String(value || BootstrapDelivery.embedded).trim().toLowerCase(); if (Object.values(BootstrapDelivery).includes(normalized)) return normalized; throw new Error(`tiinex.transfer.bootstrap-delivery.unsupported:${normalized}`); }
+function normalizeProvider(value) { return String(value || 'provider-neutral').trim() || 'provider-neutral'; }
+function nonNegativeInteger(value) { const number = Number(value || 0); return Number.isFinite(number) && number > 0 ? Math.floor(number) : 0; }

package/src/transitions/record.transitions.js

@@ -0,0 +1,484 @@
+import { externalWebArtifactUrl } from '../sources/source.explicitTargets.js';
+import { validateTransitionDraft } from './transition.validate.js';
+import { parseArtifactMarkdown } from '../artifacts/artifact.parse.js';
+import { buildArtifactCreationContract, createArtifactDraftMarkdown, validateArtifactCreationResult } from '../schemas/creation.contracts.js';
+
+export const RECORD_TRANSITION_CONTRACT_ID = 'tiinex.record.transitions.v1';
+export const RECORD_TRANSITION_RESULT_SCHEMA_ID = 'tiinex.record.transition.result.v1';
+export const ROOT_SCHEMA_ID = 'tiinex.root.v1';
+
+export function listContinuationTargets(schemaRegistry = {}) {
+  const modules = Array.isArray(schemaRegistry.modules) ? schemaRegistry.modules : [];
+  return modules
+    .filter((module) => module && module.kind === 'concrete' && module.role === 'core-artifact' && module.id === 'tiinex.task.v1')
+    .map((module) => ({
+      id: module.id,
+      label: module.label || labelFromSchemaId(module.id),
+      summary: module.summary || 'Schema-backed Tiinex leaf.',
+      parentSchemaId: module.parentSchemaId || '',
+      contract: RECORD_TRANSITION_CONTRACT_ID,
+      creationContract: `creation:continue-from-record:${module.id}`,
+      creationStatus: 'implemented',
+      boundary: 'Only schema-honest Topic continuation is exposed until additional schema create renderers are implemented.'
+    }));
+}
+
+export function createContinuationDraft(parentRecord = {}, target = {}, input = {}, options = {}) {
+  const targetId = String(target.id || input.targetSchemaId || 'tiinex.task.v1').trim();
+  const targetLabel = String(target.label || labelFromSchemaId(targetId)).trim();
+  const parentTitle = String(parentRecord.title || 'artifact').trim();
+  const title = normalizeTitle(input.title || `Continue · ${parentTitle}`, parentTitle);
+  const summary = normalizeSummary(input.summary || `Continuation leaf drafted from ${parentTitle}.`);
+  const pathTitle = input.title ? title : parentTitle;
+  const allocation = allocateContinuationPath({ parentRecord, targetId, targetLabel, title: pathTitle }, options);
+  const path = allocation.path;
+  const createdAt = nowIso(options);
+  const creationContract = buildArtifactCreationContract({ schemaId: targetId, transitionType: 'continue-from-record' });
+  const markdown = createContinuationMarkdown({ parentRecord, targetId, targetLabel, title, summary, createdAt, creationContract, childPath: path });
+  const envelopeMetadata = draftEnvelopeMetadata(markdown, targetId);
+  const draft = {
+    schema: RECORD_TRANSITION_RESULT_SCHEMA_ID,
+    schemaId: targetId,
+    title,
+    summary,
+    kind: targetId,
+    status: 'local',
+    path,
+    markdown,
+    sourceMode: 'local-transition',
+    hasContinuityContext: true,
+    hasIntegrity: true,
+    creationContract,
+    ...envelopeMetadata,
+    transition: {
+      schema: RECORD_TRANSITION_RESULT_SCHEMA_ID,
+      contract: RECORD_TRANSITION_CONTRACT_ID,
+      type: 'continue-from-record',
+      intent: String(input.intent || target.intent || 'continue'),
+      definitionId: String(input.transitionDefinitionId || target.transitionDefinitionId || target.contract || ''),
+      parentRecordId: parentRecord.id || '',
+      parentPath: parentRecord.path || '',
+      parentBoundary: boundaryForRecord(parentRecord),
+      targetSchemaId: targetId,
+      createdAt,
+      creationContractId: creationContract.id,
+      pathPolicy: allocation.policy
+    }
+  };
+  draft.creationValidation = validateArtifactCreationResult(draft, parentRecord, { contract: creationContract });
+  draft.validation = validateTransitionDraft(draft, parentRecord);
+  return draft;
+}
+
+
+export function ensureUniqueTransitionPath(draft = {}, existingRecords = []) {
+  const currentPath = String(draft.path || '').trim();
+  if (!currentPath) return Object.assign({}, draft);
+  const occupied = existingTransitionPaths({ existingRecords });
+  let nextPath = currentPath;
+  const policy = draft.transition?.pathPolicy || null;
+  if (occupied.has(canonicalLocalPath(currentPath)) && policy?.kind === 'same-parent-directory') nextPath = pathFromPolicy(policy, occupied);
+  else nextPath = uniqueTransitionPath(currentPath, occupied);
+  if (nextPath === currentPath) return Object.assign({}, draft);
+  const nextTransition = draft.transition ? Object.assign({}, draft.transition) : draft.transition;
+  return Object.assign({}, draft, { path: nextPath, id: '', transition: nextTransition });
+}
+
+export function createReferenceDraft(parentRecord = {}, input = {}, options = {}) {
+  const parentTitle = String(parentRecord.title || 'artifact').trim();
+  const title = normalizeTitle(input.title || `Reference · ${parentTitle}`, parentTitle);
+  const summary = normalizeSummary(input.summary || `Reference leaf preserving ${parentTitle}.`);
+  const path = `references/${slugify(parentTitle)}.md`;
+  const createdAt = nowIso(options);
+  const creationContract = buildArtifactCreationContract({ schemaId: 'tiinex.evidence.v1', transitionType: 'reference-record' });
+  const referenceBody = createEvidenceReferenceBody({ parentRecord, title, summary });
+  const exactMarkdown = exactCreationParentEligible(parentRecord) ? createArtifactDraftMarkdown(creationContract, {
+    parentRecord,
+    childPath: path,
+    title,
+    summary,
+    createdAt,
+    status: 'draft/local',
+    why: 'Created as a browser-local reference draft from an existing Tiinex record.',
+    bodyMarkdown: referenceBody
+  }) : '';
+  const markdown = exactMarkdown || [
+    createRootEnvelope({ parentRecord, currentSchemaId: 'tiinex.evidence.v1', createdAt, summary, status: 'draft/local', why: 'Created as a browser-local reference draft from an existing Tiinex record.' }),
+    '', '---', '', referenceBody, '', createDraftIntegrity()
+  ].join('\n');
+  const envelopeMetadata = draftEnvelopeMetadata(markdown, 'tiinex.evidence.v1');
+  const draft = {
+    schema: RECORD_TRANSITION_RESULT_SCHEMA_ID,
+    schemaId: 'tiinex.evidence.v1',
+    title,
+    summary,
+    kind: 'tiinex.evidence.v1',
+    status: 'local',
+    path,
+    markdown,
+    sourceMode: 'local-reference',
+    hasContinuityContext: true,
+    hasIntegrity: true,
+    creationContract,
+    ...envelopeMetadata,
+    transition: {
+      schema: RECORD_TRANSITION_RESULT_SCHEMA_ID,
+      contract: RECORD_TRANSITION_CONTRACT_ID,
+      type: 'reference-record',
+      parentRecordId: parentRecord.id || '',
+      parentPath: parentRecord.path || '',
+      parentBoundary: boundaryForRecord(parentRecord),
+      targetSchemaId: 'tiinex.evidence.v1',
+      createdAt,
+      creationContractId: creationContract.id
+    }
+  };
+  draft.creationValidation = validateArtifactCreationResult(draft, parentRecord, { contract: creationContract });
+  draft.validation = validateTransitionDraft(draft, parentRecord);
+  return draft;
+}
+
+
+
+
+export function allocateRootArtifactPath({ targetId = '', targetLabel = '', title = '' } = {}, options = {}) {
+  const occupied = existingTransitionPaths(options);
+  const explicitPath = canonicalLocalPath(options.path || options.draftPath || '');
+  if (explicitPath) return { path: uniqueTransitionPath(explicitPath, occupied), policy: pathPolicyForExplicit(explicitPath) };
+  const labelSlug = slugify(title || targetLabel || labelFromSchemaId(targetId) || 'artifact');
+  const targetSlug = slugify(targetLabel || labelFromSchemaId(targetId) || 'artifact');
+  const basePath = `.topics/${labelSlug}--${targetSlug}.trace.md`;
+  return {
+    path: uniqueTransitionPath(basePath, occupied),
+    policy: {
+      schema: 'tiinex.transition.path-policy.v1',
+      kind: 'standalone-root',
+      parentDirectory: '.topics',
+      labelSlug,
+      targetSlug,
+      extension: '.trace.md'
+    }
+  };
+}
+
+export function allocateContinuationPath({ parentRecord = {}, targetId = '', targetLabel = '', title = '' } = {}, options = {}) {
+  const occupied = existingTransitionPaths(options);
+  const explicitPath = canonicalLocalPath(options.path || options.draftPath || '');
+  if (explicitPath) return { path: uniqueTransitionPath(explicitPath, occupied), policy: pathPolicyForExplicit(explicitPath) };
+  const parentPath = externalWebArtifactUrl(parentRecord) ? '' : canonicalLocalPath(parentRecord.path || parentRecord.sourcePath || parentRecord.sourceTarget?.sourceArtifactPath || '');
+  const parentDir = parentDirectory(parentPath) || '.topics';
+  const parentPrefix = lineagePrefixFromPath(parentPath);
+  const labelSlug = slugify(title || parentRecord.title || targetLabel || 'continuation');
+  const targetSlug = slugify(targetLabel || labelFromSchemaId(targetId) || 'leaf');
+  const extension = '.trace.md';
+  const policy = {
+    schema: 'tiinex.transition.path-policy.v1',
+    kind: 'same-parent-directory',
+    parentDirectory: parentDir,
+    parentPath,
+    parentLineagePrefix: parentPrefix,
+    labelSlug,
+    targetSlug,
+    extension
+  };
+  return { path: pathFromPolicy(policy, occupied), policy };
+}
+
+function pathFromPolicy(policy = {}, occupied = new Set()) {
+  const dir = canonicalLocalPath(policy.parentDirectory || '.topics') || '.topics';
+  const extension = String(policy.extension || '.trace.md').startsWith('.') ? String(policy.extension || '.trace.md') : `.${policy.extension}`;
+  const labelSlug = slugify(policy.labelSlug || 'continuation');
+  const targetSlug = slugify(policy.targetSlug || 'leaf');
+  const parentPrefix = String(policy.parentLineagePrefix || '').trim();
+  if (parentPrefix) {
+    const childPrefix = nextChildLineagePrefix(parentPrefix, dir, occupied);
+    return `${dir}/${childPrefix}-${labelSlug}.${extension.replace(/^\./, '')}`;
+  }
+  return uniqueTransitionPath(`${dir}/${labelSlug}--${targetSlug}${extension}`, occupied);
+}
+
+function pathPolicyForExplicit(path = '') {
+  const canonical = canonicalLocalPath(path);
+  return {
+    schema: 'tiinex.transition.path-policy.v1',
+    kind: 'explicit-path',
+    parentDirectory: parentDirectory(canonical) || '',
+    explicitPath: canonical
+  };
+}
+
+function parentDirectory(path = '') {
+  const raw = String(path || '').trim();
+  if (/^https?:\/\//i.test(raw)) return '';
+  const canonical = canonicalLocalPath(raw);
+  if (!canonical) return '';
+  const index = canonical.lastIndexOf('/');
+  return index > -1 ? canonical.slice(0, index) || '.' : '';
+}
+
+function lineagePrefixFromPath(path = '') {
+  const name = basenameWithoutKnownMarkdownExtension(path);
+  if (!name) return '';
+  const recoveredComment = name.match(/^comment-(\d{3})(?:-|$)/i);
+  if (recoveredComment) return recoveredComment[1];
+  const numeric = name.match(/^(\d+(?:-\d+)*)(?:-|$)/);
+  if (numeric && !/^20\d{2}$/.test(numeric[1])) return numeric[1];
+  return '';
+}
+
+function nextChildLineagePrefix(parentPrefix = '', dir = '', occupied = new Set()) {
+  const prefix = String(parentPrefix || '').trim();
+  const width = childOrdinalWidth(prefix);
+  const numbers = [];
+  for (const path of occupied || []) {
+    const canonical = canonicalLocalPath(path);
+    if (parentDirectory(canonical) !== dir) continue;
+    const name = basenameWithoutKnownMarkdownExtension(canonical);
+    const escaped = prefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const match = name.match(new RegExp(`^${escaped}-(\\d+)(?:-|$)`));
+    if (!match || !isChildOrdinalSegment(prefix, match[1])) continue;
+    numbers.push(Number(match[1]));
+  }
+  const next = numbers.length ? Math.max(...numbers) + 1 : 1;
+  return `${prefix}-${String(next).padStart(width, '0')}`;
+}
+
+function isChildOrdinalSegment(prefix = '', value = '') {
+  const raw = String(value || '').trim();
+  if (!/^\d+$/.test(raw)) return false;
+  return true;
+}
+
+function childOrdinalWidth(prefix = '') {
+  const parts = String(prefix || '').split('-').filter(Boolean);
+  if (parts.length >= 2 && parts.every((part) => /^\d{2}$/.test(part))) return 2;
+  return 1;
+}
+
+function basenameWithoutKnownMarkdownExtension(path = '') {
+  const canonical = canonicalLocalPath(path);
+  const base = canonical.split('/').filter(Boolean).pop() || '';
+  return base.replace(/\.trace\.md$/i, '').replace(/\.workspace\.md$/i, '').replace(/\.md$/i, '');
+}
+
+function draftEnvelopeMetadata(markdown = '', fallbackSchemaId = '') {
+  const parsed = parseArtifactMarkdown(markdown);
+  const parent = parsed.envelope?.parent || {};
+  const current = parsed.envelope?.current || {};
+  return {
+    schemaId: current.schema?.id || fallbackSchemaId || '',
+    parentSchemaId: parent.schema?.id || '',
+    trace: parent.trace || '',
+    traceLabel: parent.traceLabel || '',
+    origin: parent.origin || '',
+    boundary: parent.boundary || '',
+    createdAt: current.createdAt || '',
+    currentCreatedAt: current.createdAt || '',
+    currentStatus: current.status || '',
+    currentWhy: current.why || ''
+  };
+}
+
+function createEvidenceReferenceBody({ parentRecord = {}, title = 'Reference', summary = '' }) {
+  const boundary = boundaryForRecord(parentRecord);
+  const sourceLabel = parentRecord.source?.label || parentRecord.source?.repo || parentRecord.source?.id || '';
+  const excerpt = truncate(String(parentRecord.markdown || parentRecord.summary || '').trim(), 1800) || '_No embedded source material was available._';
+  return [
+    `# ${title}`,
+    '',
+    '## Reference',
+    '',
+    'This browser-local Evidence draft preserves the selected record as bounded reference material.',
+    '',
+    '## Supported Claim Or Question',
+    '',
+    summary || `Preserves ${parentRecord.title || 'the selected artifact'} as supporting material for later review or continuation.`,
+    '',
+    '## Provenance',
+    '',
+    `- Parent Trace: ${parentRecord.id ? `record:${parentRecord.id}` : 'record:unassigned'}`,
+    parentRecord.path ? `- Parent path: ${parentRecord.path}` : '',
+    sourceLabel ? `- Parent source: ${sourceLabel}` : '',
+    `- Boundary: ${boundary}`,
+    '',
+    '## Evidence Material',
+    '',
+    '```markdown',
+    excerpt,
+    '```',
+    '',
+    '## Preservation And Fidelity',
+    '',
+    '- Method: browser-local reference draft from loaded material.',
+    '- Fidelity: excerpted material is bounded to the currently loaded record; remote parents are not fetched or completed silently.',
+    '- Mutation: no source mutation; no publication occurred.',
+    '',
+    '## Interpretation Limits',
+    '',
+    '- This Evidence draft preserves material for review; it does not validate, endorse, attest, or make the supported claim true.',
+    '- Missing parent, source, or remote material must remain explicit until loaded or resolved through a separate audit/lineage traversal.'
+  ].filter(Boolean).join('\n');
+}
+
+
+function exactCreationParentEligible(record = {}) {
+  const published = record.publishedReference || record.browseGitReference || record.browseGit || null;
+  const publishedTarget = typeof published === 'string' ? published : String(published?.target || published?.url || '');
+  const publishedState = typeof published === 'string' ? 'unresolved' : String(published?.state || published?.resolutionState || 'unresolved');
+  const schemaReference = record.schemaReferenceAuthority || record.parentSchemaReferenceAuthority || null;
+  const schemaTarget = typeof schemaReference === 'string' ? schemaReference : String(schemaReference?.preferredTarget || schemaReference?.target || '');
+  const schemaState = typeof schemaReference === 'string' ? 'unresolved' : String(schemaReference?.resolutionState || schemaReference?.state || 'unresolved');
+  return Boolean(publishedTarget && publishedState === 'qualified' && schemaTarget && schemaState === 'qualified');
+}
+
+function createContinuationMarkdown({ parentRecord, targetId, targetLabel, title, summary, createdAt, creationContract, childPath = '' }) {
+  const bodyMarkdown = [
+    `# ${title}`,
+    '',
+    `## ${targetLabel} Draft`,
+    '',
+    summary,
+    '',
+    '## Source Boundary',
+    '',
+    `- ${boundaryForRecord(parentRecord)}`,
+    parentRecord.path ? `- Parent path: ${parentRecord.path}` : '',
+    parentRecord.source?.label ? `- Parent source: ${parentRecord.source.label}` : '',
+    '',
+    '## Next Step',
+    '',
+    '- Review and refine this task draft before export/publication.',
+    '',
+    '## Source Excerpt',
+    '',
+    truncate(String(parentRecord.markdown || parentRecord.summary || '').trim(), 1800) || '_No embedded source material was available._'
+  ].filter(Boolean).join('\n');
+  const exact = exactCreationParentEligible(parentRecord) ? createArtifactDraftMarkdown(creationContract, {
+    parentRecord,
+    childPath,
+    currentSchemaId: targetId,
+    title,
+    summary,
+    createdAt,
+    status: 'draft/local',
+    why: 'Created as a browser-local continuation draft. No source provenance is inferred.',
+    bodyMarkdown
+  }) : '';
+  if (exact) return exact;
+  // Preserve the pre-existing Site transition draft as explicitly non-exact
+  // local material when no qualified published Parent representation exists.
+  // v475 exact creation validation rejects this legacy envelope/footer; this
+  // compatibility path never upgrades it to canonical authority.
+  return [
+    createRootEnvelope({ parentRecord, currentSchemaId: targetId, createdAt, summary, status: 'draft/local', why: 'Created as a browser-local continuation draft. No source provenance is inferred.' }),
+    '', '---', '', bodyMarkdown, '', createDraftIntegrity()
+  ].join('\n');
+}
+
+function createRootEnvelope({ parentRecord, currentSchemaId, createdAt, summary, status, why }) {
+  const parentSchemaId = parentSchemaForRecord(parentRecord);
+  return [
+    '# Continuity Context',
+    '',
+    `- Envelope Schema: [${ROOT_SCHEMA_ID}](${ROOT_SCHEMA_ID}.schema.md)`,
+    '- Parent',
+    `  - Parent Schema: [${parentSchemaId}](${parentSchemaId}.schema.md)`,
+    `  - Created At: ${parentRecord.createdAt || 'unknown'}`,
+    `  - Trace: ${parentRecord.id ? `record:${parentRecord.id}` : 'record:unassigned'}`,
+    parentRecord.path ? `  - Origin: ${parentRecord.path}` : '',
+    `  - Boundary: ${boundaryForRecord(parentRecord)}`,
+    '- Current',
+    `  - Current Schema: [${currentSchemaId}](${currentSchemaId}.schema.md)`,
+    `  - Created At: ${createdAt}`,
+    `  - Summary: ${summary}`,
+    `  - Status: ${status}`,
+    `  - Why: ${why}`
+  ].filter(Boolean).join('\n');
+}
+
+function createDraftIntegrity() {
+  return [
+    '# Continuity Integrity',
+    '',
+    '- Draft Local Integrity',
+    '  - Method: browser-local-draft',
+    '  - Value: pending-publication-or-export'
+  ].join('\n');
+}
+
+function parentSchemaForRecord(record = {}) {
+  const schemaId = String(record.schemaId || record.currentSchemaId || '').trim();
+  return schemaId || ROOT_SCHEMA_ID;
+}
+
+function boundaryForRecord(record = {}) {
+  const source = record.source || {};
+  if (source.adapterId === 'github') return 'source-backed github material';
+  if (source.adapterId === 'local' || source.kind === 'local-session' || record.sourceMode?.startsWith?.('local')) return 'browser-local session material; no GitHub provenance inferred';
+  return 'explicit record boundary';
+}
+
+function normalizeTitle(value, fallback = 'artifact') {
+  const text = String(value || '').replace(/\s+/g, ' ').trim();
+  return text.slice(0, 96) || `Continue · ${fallback}`.slice(0, 96);
+}
+
+function normalizeSummary(value) {
+  return String(value || '').replace(/\s+/g, ' ').trim().slice(0, 280) || 'Continuation drafted in Tiinex.';
+}
+
+function labelFromSchemaId(id = '') {
+  const tail = String(id || '').split('.').filter(Boolean).slice(-2, -1)[0] || String(id || 'leaf');
+  return tail.charAt(0).toUpperCase() + tail.slice(1);
+}
+
+function existingTransitionPaths(options = {}) {
+  const inputs = [];
+  if (Array.isArray(options.existingRecords)) inputs.push(...options.existingRecords);
+  if (Array.isArray(options.workspaceRecords)) inputs.push(...options.workspaceRecords);
+  if (Array.isArray(options.existingPaths)) inputs.push(...options.existingPaths.map((path) => ({ path })));
+  return new Set(inputs.map((item) => canonicalLocalPath(typeof item === 'string' ? item : item?.path || '')).filter(Boolean));
+}
+
+function uniqueTransitionPath(basePath = '', occupied = new Set()) {
+  const canonical = canonicalLocalPath(basePath || 'continuations/continuation.md') || 'continuations/continuation.md';
+  if (!occupied.has(canonical)) return canonical;
+  const compound = canonical.match(/^(.*?)(\.trace\.md|\.workspace\.md|\.schema\.md|\.md)$/i);
+  const stem = compound ? compound[1] : (canonical.lastIndexOf('.') > -1 ? canonical.slice(0, canonical.lastIndexOf('.')) : canonical);
+  const ext = compound ? compound[2] : (canonical.lastIndexOf('.') > -1 ? canonical.slice(canonical.lastIndexOf('.')) : '');
+  for (let index = 2; index < 10000; index += 1) {
+    const candidate = `${stem}-${index}${ext}`;
+    if (!occupied.has(candidate)) return candidate;
+  }
+  return `${stem}-${Date.now().toString(36)}${ext}`;
+}
+
+function canonicalLocalPath(value = '') {
+  const raw = String(value || '').trim().replace(/\\/g, '/').replace(/\/+/g, '/');
+  if (!raw) return '';
+  const parts = [];
+  for (const part of raw.split('/')) {
+    if (!part || part === '.') continue;
+    if (part === '..') {
+      parts.pop();
+      continue;
+    }
+    parts.push(part);
+  }
+  return parts.join('/');
+}
+
+
+function slugify(value = '') {
+  return String(value || 'artifact').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 64) || 'artifact';
+}
+
+function truncate(value = '', limit = 1800) {
+  const text = String(value || '').trim();
+  return text.length > limit ? `${text.slice(0, limit)}\n…` : text;
+}
+
+function nowIso(options = {}) {
+  if (typeof options.clock === 'function') return options.clock();
+  return new Date().toISOString();
+}