@tiinex/core 0.1.1

package/src/tooling/portable/assets/asset.operations.js

@@ -0,0 +1,170 @@
+import { normalizePortableInput, portableInputFiles } from '../input/portable.input.js';
+import { portableFinding, summarizePortableFindings } from '../findings.js';
+import { discoverPortableHostCapabilities } from '../host/host.capabilities.js';
+
+export const PORTABLE_ASSET_INDEX_SCHEMA_ID = 'tiinex.portable.asset-index.v1';
+export const PORTABLE_ASSET_ANALYSIS_REQUEST_SCHEMA_ID = 'tiinex.portable.asset-analysis-request.v1';
+
+export function inspectPortableAssets(input = {}, options = {}) {
+  const material = normalizePortableInput(input);
+  const files = portableInputFiles(input);
+  const references = buildReferenceIndex(material.records || []);
+  const assets = (material.assets || []).map((asset) => {
+    const file = files.find((entry) => normalizePath(entry.path || entry.name) === normalizePath(asset.path)) || {};
+    const mimeType = inferMimeType(asset.path, asset.type || file.type || '');
+    return Object.freeze({
+      path: asset.path,
+      kind: asset.kind || 'asset',
+      mimeType,
+      mediaKind: mediaKind(mimeType, asset.path),
+      size: Number(asset.size || file.size || 0),
+      contentAvailable: Boolean(file.content || file.data || file.bytes || file.buffer),
+      locator: sanitizeLocator(file.locator || asset.locator || null),
+      referencedBy: Object.freeze(references.get(normalizePath(asset.path)) || []),
+      analysis: Object.freeze({
+        portableSemanticAnalysis: false,
+        requiresHostCapability: mediaKind(mimeType, asset.path) === 'image' ? 'multimodal.images' : mediaKind(mimeType, asset.path) === 'pdf' ? 'multimodal.pdf' : 'host-specific'
+      })
+    });
+  });
+  const findings = [...(material.findings || [])];
+  return Object.freeze({
+    schema: PORTABLE_ASSET_INDEX_SCHEMA_ID,
+    boundary: Object.freeze({
+      receivedCodeExecution: false,
+      automaticSemanticAnalysis: false,
+      localAssetIsNotRemoteSource: true
+    }),
+    assets: Object.freeze(assets),
+    counts: Object.freeze({
+      total: assets.length,
+      images: assets.filter((asset) => asset.mediaKind === 'image').length,
+      pdfs: assets.filter((asset) => asset.mediaKind === 'pdf').length,
+      referenced: assets.filter((asset) => asset.referencedBy.length).length,
+      contentAvailable: assets.filter((asset) => asset.contentAvailable).length
+    }),
+    findings: Object.freeze(findings),
+    findingSummary: summarizePortableFindings(findings)
+  });
+}
+
+export function preparePortableAssetAnalysis(input = {}, options = {}) {
+  const index = inspectPortableAssets(input, options);
+  const path = normalizePath(input.assetPath || input.path || options.assetPath || '');
+  const asset = index.assets.find((entry) => normalizePath(entry.path) === path || normalizePath(entry.path).endsWith(path));
+  const discovery = discoverPortableHostCapabilities(input.host || input, options.host || options);
+  const findings = [...(index.findings || []), ...(discovery.findings || [])];
+  if (!asset) findings.push(portableFinding('error', 'portable.asset-analysis.asset.not-found', 'Requested asset was not found in supplied material.', { ref: path }));
+  const capability = asset?.mediaKind === 'image' ? 'images' : asset?.mediaKind === 'pdf' ? 'pdf' : '';
+  const supported = Boolean(asset && capability && discovery.profile.capabilities.multimodal[capability]);
+  if (asset && !capability) findings.push(portableFinding('warning', 'portable.asset-analysis.media.unsupported', 'Portable tooling cannot identify a standard multimodal analysis capability for this asset type.', { ref: asset.path, mimeType: asset.mimeType }));
+  if (asset && capability && !supported) findings.push(portableFinding('warning', 'portable.asset-analysis.host-capability.unavailable', 'The host profile does not expose the required multimodal capability.', { ref: asset.path, capability: `multimodal.${capability}` }));
+
+  const request = asset ? Object.freeze({
+    schema: PORTABLE_ASSET_ANALYSIS_REQUEST_SCHEMA_ID,
+    status: supported ? 'host-action-ready' : 'host-capability-required',
+    asset: Object.freeze({
+      path: asset.path,
+      mimeType: asset.mimeType,
+      mediaKind: asset.mediaKind,
+      size: asset.size,
+      locator: asset.locator,
+      contentAvailable: asset.contentAvailable,
+      referencedBy: asset.referencedBy
+    }),
+    requiredCapability: capability ? `multimodal.${capability}` : 'host-specific',
+    hostAction: Object.freeze({
+      sequence: Object.freeze([
+        ...(asset.contentAvailable ? [] : ['materialize-or-extract-asset-by-path']),
+        capability === 'image' ? 'open-image-with-host-vision' : capability === 'pdf' ? 'open-or-render-pdf-with-host-reader' : 'select-host-specific-reader',
+        'return-analysis-as-explicit-result',
+        'do-not-promote-analysis-to-evidence-without-human-intent'
+      ]),
+      ingestResultAs: Object.freeze({
+        schema: 'tiinex.portable.asset-analysis-response.v1',
+        assetPath: asset.path,
+        description: '<host-generated description>',
+        observations: Object.freeze(['<bounded observation>']),
+        qualification: Object.freeze({ mode: 'host-multimodal', sourceAssetPreserved: true, analysisIsNotSourceMaterial: true })
+      })
+    }),
+    boundary: Object.freeze({
+      assetRemainsLocalUnlessExplicitlyPublished: true,
+      analysisDoesNotAlterAsset: true,
+      analysisIsInterpretationNotEmbeddedProvenance: true
+    })
+  }) : null;
+  return Object.freeze({
+    schema: 'tiinex.portable.asset-analysis-preparation.v1',
+    status: request?.status || 'blocked',
+    request,
+    host: discovery.profile,
+    findings: Object.freeze(findings),
+    findingSummary: summarizePortableFindings(findings)
+  });
+}
+
+function buildReferenceIndex(records = []) {
+  const map = new Map();
+  for (const record of records) {
+    const markdown = String(record.markdown || '');
+    const re = /!?\[[^\]]*\]\(([^)]+)\)/g;
+    for (const match of markdown.matchAll(re)) {
+      const target = normalizeReferenceTarget(match[1]);
+      if (!target || /^https?:\/\//i.test(target)) continue;
+      const resolved = resolveRelative(record.path || '', target);
+      if (!map.has(resolved)) map.set(resolved, []);
+      map.get(resolved).push(Object.freeze({ recordId: record.id, path: record.path, target }));
+    }
+  }
+  return map;
+}
+
+function resolveRelative(recordPath, target) {
+  const base = normalizePath(recordPath).split('/');
+  base.pop();
+  const parts = [...base, ...normalizePath(target).split('/')];
+  const out = [];
+  for (const part of parts) {
+    if (!part || part === '.') continue;
+    if (part === '..') out.pop();
+    else out.push(part);
+  }
+  return out.join('/');
+}
+
+function normalizeReferenceTarget(value = '') {
+  return String(value || '').trim().replace(/^<|>$/g, '').split(/[?#]/)[0];
+}
+
+function inferMimeType(path = '', explicit = '') {
+  if (explicit) return explicit;
+  const lower = String(path || '').toLowerCase();
+  if (lower.endsWith('.png')) return 'image/png';
+  if (/\.jpe?g$/.test(lower)) return 'image/jpeg';
+  if (lower.endsWith('.webp')) return 'image/webp';
+  if (lower.endsWith('.gif')) return 'image/gif';
+  if (lower.endsWith('.svg')) return 'image/svg+xml';
+  if (lower.endsWith('.pdf')) return 'application/pdf';
+  if (lower.endsWith('.mp4')) return 'video/mp4';
+  return 'application/octet-stream';
+}
+
+function mediaKind(mimeType = '', path = '') {
+  if (String(mimeType).startsWith('image/')) return 'image';
+  if (mimeType === 'application/pdf' || String(path).toLowerCase().endsWith('.pdf')) return 'pdf';
+  if (String(mimeType).startsWith('video/')) return 'video';
+  return 'binary';
+}
+
+function sanitizeLocator(locator) {
+  if (!locator || typeof locator !== 'object') return null;
+  return Object.freeze({
+    kind: String(locator.kind || ''),
+    archivePath: String(locator.archivePath || ''),
+    entryPath: normalizePath(locator.entryPath || ''),
+    localPath: String(locator.localPath || '')
+  });
+}
+
+function normalizePath(value = '') { return String(value || '').replace(/\\/g, '/').replace(/^\/+/, '').replace(/\/+/g, '/'); }

package/src/tooling/portable/audit/audit.capability.js

@@ -0,0 +1,119 @@
+import { runAudit } from '../../../audit/audit.run.js';
+import { portableRuntimeValidationAuthorityForRecord, portableRuntimeValidationContractForSchema } from '../schema/qualifiedLocalRoot.runtime.js';
+import { normalizePortableFinding, portableFinding, summarizePortableFindings } from '../findings.js';
+import { qualifyAuditResult } from '../qualification.js';
+
+export const PORTABLE_SHARED_AUDIT_CAPABILITY_SCHEMA_ID = 'tiinex.portable.shared-audit-capability.v1';
+
+export function auditPortableRecord(record = {}, options = {}) {
+  const schemaId = String(record.schemaId || record.currentSchemaId || '');
+  const requireExactSchemaAuthority = options.requireExactSchemaAuthority === true;
+  const runtimeAuthority = requireExactSchemaAuthority ? portableRuntimeValidationAuthorityForRecord(record) : null;
+  const runtimeProjection = requireExactSchemaAuthority ? runtimeAuthority : portableRuntimeValidationContractForSchema(schemaId);
+  let result;
+  try {
+    result = runAudit({
+      record,
+      markdown: record.markdown,
+      validationContractOverride: runtimeProjection?.state === 'qualified' ? runtimeProjection.compiledContract : null,
+      schemaValidationAuthority: requireExactSchemaAuthority ? runtimeAuthority : null
+    });
+  } catch (error) {
+    const finding = portableFinding('error', 'portable.audit.exception', error?.message || 'Audit failed.', {
+      source: PORTABLE_SHARED_AUDIT_CAPABILITY_SCHEMA_ID,
+      ref: record.path || record.id || ''
+    });
+    result = {
+      status: 'invalid-or-incomplete',
+      artifact: { schemaId, moduleId: 'tiinex.root.v1', fallbackUsed: true },
+      summary: { error: 1, warning: 0, info: 0, preserve: 0 },
+      findings: [finding],
+      validation: null,
+      materialAvailability: record.markdown ? { status: 'available' } : { status: 'pending-unavailable' }
+    };
+  }
+  return sanitizeSharedAudit(result, record, options);
+}
+
+export function auditPortableRecords(records = [], options = {}) {
+  const audits = Object.freeze((Array.isArray(records) ? records : []).map((record) => auditPortableRecord(record, options)));
+  const findings = Object.freeze(audits.flatMap((audit) => audit.findings || []));
+  return Object.freeze({
+    schema: PORTABLE_SHARED_AUDIT_CAPABILITY_SCHEMA_ID,
+    status: summarizePortableFindings(findings).status,
+    audits,
+    findings,
+    findingSummary: summarizePortableFindings(findings),
+    boundary: Object.freeze({
+      adapterNeutral: true,
+      sharedConsumers: Object.freeze(['Viewer', 'CLI', 'LLM', 'VS Code']),
+      sourceMutation: false,
+      remoteWrite: false,
+      findingIdentity: 'artifact path/id + stable finding code + evidence path',
+      findingOwnership: 'normalized finding source; presentation adapters do not redefine ownership or severity'
+    })
+  });
+}
+
+function sanitizeSharedAudit(result = {}, record = {}, options = {}) {
+  const parsed = result.parsed || null;
+  const id = String(record.id || record.path || '');
+  const path = String(record.path || '');
+  const resolvedSchemaId = String(parsed?.envelope?.current?.schema?.id || result.artifact?.schemaId || record.schemaId || '');
+  const moduleId = String(result.resolution?.module?.id || result.artifact?.moduleId || '');
+  const findings = Object.freeze((result.findings || []).map((finding) => projectSharedFinding(finding, { id, path, schemaId: resolvedSchemaId, sourceMode: record.sourceMode || '', moduleId })));
+  return Object.freeze({
+    schema: 'tiinex.portable.shared-audit-record.v1',
+    id,
+    path,
+    title: String(record.title || result.artifact?.title || parsed?.title || path || 'Untitled artifact'),
+    status: result.status || '',
+    schemaId: resolvedSchemaId,
+    resolution: Object.freeze({
+      status: result.resolution?.status || '',
+      moduleId,
+      fallbackUsed: Boolean(result.resolution?.fallbackUsed || result.artifact?.fallbackUsed),
+      unresolvedSchemaId: result.resolution?.unresolvedSchemaId || ''
+    }),
+    artifact: result.artifact || null,
+    parsed: parsed ? Object.freeze({
+      title: parsed.title,
+      hasContinuityContext: parsed.hasContinuityContext,
+      hasIntegrity: parsed.hasIntegrity,
+      envelope: parsed.envelope,
+      body: Object.freeze({ title: parsed.body?.title || '', sections: Object.freeze([...(parsed.body?.sections || [])]) })
+    }) : null,
+    findings,
+    summary: result.summary || null,
+    validation: result.validation || null,
+    schemaValidationAuthority: result.schemaValidationAuthority || null,
+    materialAvailability: result.materialAvailability || null,
+    qualification: qualifyAuditResult(result),
+    capabilityBoundary: Object.freeze({
+      sourceMutation: false,
+      remoteWrite: false,
+      adapterNeutral: true,
+      recordIdentity: id || path,
+      recordPath: path,
+      schemaId: resolvedSchemaId
+    }),
+    ...(options.includeMarkdown ? { markdown: record.markdown || '' } : {})
+  });
+}
+
+function projectSharedFinding(finding = {}, artifact = {}) {
+  const normalized = normalizePortableFinding(finding, { ref: artifact.path || artifact.id || '' });
+  const evidencePath = String(normalized.evidencePath || normalized.ref || '');
+  const owner = String(normalized.source || artifact.moduleId || PORTABLE_SHARED_AUDIT_CAPABILITY_SCHEMA_ID);
+  return Object.freeze({
+    ...normalized,
+    findingIdentity: `${artifact.path || artifact.id || '(artifact)'}::${normalized.code || 'portable.finding'}::${evidencePath}`,
+    ownership: Object.freeze({ kind: 'implementation-source', owner }),
+    artifactBoundary: Object.freeze({
+      id: artifact.id || '',
+      path: artifact.path || '',
+      schemaId: artifact.schemaId || '',
+      sourceMode: artifact.sourceMode || ''
+    })
+  });
+}

package/src/tooling/portable/bootstrap/artifact.result.selfverify.mjs

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+import { createHash } from 'node:crypto';
+import { lstat, readFile, readdir } from 'node:fs/promises';
+import path from 'node:path';
+
+const root = path.resolve(process.argv[2] || '.');
+const findings = [];
+try {
+  const manifest = await json('manifest.json');
+  const checksums = await json('checksums.json');
+  const creation = await json('artifact.creation.receipt.json');
+  const input = await json('artifact.input.snapshot.json');
+  const operation = await json('artifact.operation.receipt.json');
+  const writeReceipt = await json('artifact.write.receipt.json');
+  const transferManifest = await json('context/transfer.manifest.json');
+  const bootstrapManifest = await json('context/bootstrap.manifest.json');
+  const taskRequest = await readFile(path.join(root, 'context/task.request.txt'));
+  const transfer = await json('verification/transfer.json');
+  const bootstrap = await json('verification/bootstrap.json');
+  const actual = await walk(root);
+  const expected = new Map((checksums.files || []).map((entry) => [entry.path, entry]));
+
+  check(manifest.schema === 'tiinex.portable.artifact-result-package.v1', 'result.verify.manifest-schema', 'manifest.json');
+  check(checksums.schema === 'tiinex.portable.artifact-result-checksums.v1', 'result.verify.checksum-schema', 'checksums.json');
+  check(creation.schema === 'tiinex.portable.artifact-creation-receipt.v1' && creation.status === 'packaged-local-clean', 'result.verify.creation-receipt', 'artifact.creation.receipt.json');
+  check(input.schema === 'tiinex.portable.artifact-input-snapshot.v1', 'result.verify.input-snapshot', 'artifact.input.snapshot.json');
+  check(operation.schema === 'tiinex.portable.artifact-operation-receipt.v1' && operation.status === 'created-clean', 'result.verify.operation-receipt', 'artifact.operation.receipt.json');
+  check(writeReceipt.schema === 'tiinex.portable.draft-write-receipt.v1' && writeReceipt.status === 'written-local-clean', 'result.verify.write-receipt', 'artifact.write.receipt.json');
+  check(transfer.schema === 'tiinex.llm.transfer.verification.v1' && transfer.status === 'valid', 'result.verify.transfer-verification', 'verification/transfer.json');
+  check(['tiinex.bootstrap.verification.v2', 'tiinex.bootstrap.archive-verification.v2'].includes(bootstrap.schema) && bootstrap.status === 'valid', 'result.verify.bootstrap-verification', 'verification/bootstrap.json');
+
+  for (const [relative, entry] of expected) {
+    try {
+      const bytes = await readFile(path.join(root, relative));
+      check(bytes.length === entry.bytes, 'result.verify.bytes-mismatch', relative, { expected: entry.bytes, actual: bytes.length });
+      check(sha256(bytes) === entry.sha256, 'result.verify.sha256-mismatch', relative, { expected: entry.sha256, actual: sha256(bytes) });
+    } catch (error) {
+      findings.push(finding('error', 'result.verify.file-missing', relative, { detail: String(error?.message || error) }));
+    }
+  }
+  for (const relative of actual) {
+    if (relative === 'checksums.json') continue;
+    check(expected.has(relative), 'result.verify.file-unlisted', relative);
+  }
+  for (const required of ['artifact.trace.md', 'artifact.creation.receipt.json', 'artifact.input.snapshot.json', 'artifact.operation.receipt.json', 'artifact.write.receipt.json', 'context/task.request.txt', 'context/transfer.manifest.json', 'context/bootstrap.manifest.json', 'verification/transfer.json', 'verification/bootstrap.json', 'manifest.json', 'checksums.json', 'bin/verify-result.mjs']) check(actual.includes(required), 'result.verify.required-file-missing', required);
+
+  const artifact = await readFile(path.join(root, 'artifact.trace.md'));
+  const artifactSha = sha256(artifact);
+  const inputSha = sha256(await readFile(path.join(root, 'artifact.input.snapshot.json')));
+  const taskSha = sha256(taskRequest);
+  const transferManifestSha = sha256(await readFile(path.join(root, 'context/transfer.manifest.json')));
+  const bootstrapManifestSha = sha256(await readFile(path.join(root, 'context/bootstrap.manifest.json')));
+  const transferVerificationSha = sha256(await readFile(path.join(root, 'verification/transfer.json')));
+  const bootstrapVerificationSha = sha256(await readFile(path.join(root, 'verification/bootstrap.json')));
+  check(manifest.artifact?.sha256 === artifactSha, 'result.verify.manifest-artifact-binding', 'manifest.json');
+  check(creation.artifact?.sha256 === artifactSha, 'result.verify.creation-artifact-binding', 'artifact.creation.receipt.json');
+  check(operation.artifact?.sha256 === artifactSha, 'result.verify.operation-artifact-binding', 'artifact.operation.receipt.json');
+  check(writeReceipt.sha256 === artifactSha, 'result.verify.write-artifact-binding', 'artifact.write.receipt.json');
+  check(creation.inputSnapshot?.sha256 === inputSha, 'result.verify.creation-input-binding', 'artifact.creation.receipt.json');
+  check(manifest.evidence?.inputSnapshot?.sha256 === inputSha, 'result.verify.manifest-input-binding', 'manifest.json');
+  check(manifest.evidence?.taskRequest?.sha256 === taskSha && creation.context?.task?.sha256 === taskSha, 'result.verify.task-binding', 'context/task.request.txt');
+  check(manifest.evidence?.transferManifest?.sha256 === transferManifestSha && creation.context?.transfer?.manifestSha256 === transferManifestSha, 'result.verify.transfer-manifest-binding', 'context/transfer.manifest.json');
+  check(manifest.evidence?.bootstrapManifest?.sha256 === bootstrapManifestSha && creation.context?.bootstrap?.manifestSha256 === bootstrapManifestSha, 'result.verify.bootstrap-manifest-binding', 'context/bootstrap.manifest.json');
+  check(manifest.evidence?.transferVerification?.sha256 === transferVerificationSha && creation.context?.transfer?.verificationSha256 === transferVerificationSha, 'result.verify.transfer-verification-binding', 'verification/transfer.json');
+  check(manifest.evidence?.bootstrapVerification?.sha256 === bootstrapVerificationSha && creation.context?.bootstrap?.verificationSha256 === bootstrapVerificationSha, 'result.verify.bootstrap-verification-binding', 'verification/bootstrap.json');
+  check(transferManifest.schema === 'tiinex.llm.transfer.package.v1' && bootstrapManifest.schema === 'tiinex.bootstrap.package.v1', 'result.verify.context-manifest-schema', 'context');
+  check(transferManifest.expectedBootstrap?.bootstrapVersion === bootstrapManifest.bootstrapVersion, 'result.verify.context-bootstrap-version', 'context');
+  check(transferManifest.expectedBootstrap?.sourceIdentity?.runtimeFingerprint === bootstrapManifest.sourceIdentity?.runtimeFingerprint, 'result.verify.context-bootstrap-runtime', 'context');
+  check(transferManifest.expectedBootstrap?.canonicalMaterial?.schemaPackFingerprint === bootstrapManifest.canonicalMaterial?.schemaPackFingerprint, 'result.verify.context-bootstrap-canonical', 'context');
+  check(creation.context?.bootstrap?.verificationStatus === 'valid' && creation.context?.transfer?.verificationStatus === 'valid', 'result.verify.context-status', 'artifact.creation.receipt.json');
+  check(creation.boundary?.sourceMutation === false && creation.boundary?.remoteWrite === false && creation.boundary?.sourceBacked === false, 'result.verify.boundary', 'artifact.creation.receipt.json');
+
+  const result = {
+    schema: 'tiinex.portable.artifact-result-verification.v1',
+    status: findings.some((entry) => entry.severity === 'error') ? 'invalid' : 'valid',
+    root,
+    artifact: { schemaId: creation.artifact?.schemaId || '', logicalPath: creation.artifact?.logicalPath || '', sha256: artifactSha },
+    context: creation.context || null,
+    counts: { files: actual.length, checkedFiles: expected.size, findings: findings.length, errors: findings.filter((entry) => entry.severity === 'error').length },
+    findings
+  };
+  console.log(JSON.stringify(result, null, 2));
+  process.exitCode = result.status === 'valid' ? 0 : 1;
+} catch (error) {
+  console.error(JSON.stringify({ schema: 'tiinex.portable.artifact-result-verification.v1', status: 'invalid', root, error: String(error?.message || error) }, null, 2));
+  process.exitCode = 1;
+}
+
+async function json(relative) { return JSON.parse(await readFile(path.join(root, relative), 'utf8')); }
+async function walk(directory) {
+  const output = [];
+  const queue = [directory];
+  while (queue.length) {
+    const current = queue.shift();
+    const entries = await readdir(current, { withFileTypes: true });
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      const absolute = path.join(current, entry.name);
+      const info = await lstat(absolute);
+      if (info.isSymbolicLink()) throw new Error(`result.verify.symlink:${absolute}`);
+      if (info.isDirectory()) queue.push(absolute);
+      else if (info.isFile()) output.push(path.relative(directory, absolute).replace(/\\/g, '/'));
+    }
+  }
+  return output.sort();
+}
+function check(condition, code, file, extra = {}) { if (!condition) findings.push(finding('error', code, file, extra)); }
+function finding(severity, code, file, extra = {}) { return { severity, code, file, ...extra }; }
+function sha256(value) { return createHash('sha256').update(value).digest('hex'); }

package/src/tooling/portable/bootstrap/bootstrap.case.mjs

@@ -0,0 +1,43 @@
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+
+const pointer = JSON.parse(await readFile(new URL('./tiinex.llm.bootstrap.pointer.json', import.meta.url), 'utf8'));
+const bootstrap = await readFile(new URL('./tiinex.llm.bootstrap.md', import.meta.url), 'utf8');
+
+assert.equal(pointer.schema, 'tiinex.portable.bootstrap.pointer.v1');
+assert.equal(pointer.repository, 'Tiinex/site');
+assert.equal(pointer.firstOperations.includes('discover-tooling'), true);
+assert.equal(pointer.firstOperations.includes('plan-host-action'), true);
+assert.equal(pointer.boundary.remoteWrite, false);
+assert.equal(pointer.boundary.sourceMutation, false);
+assert.equal(bootstrap.includes('## Startup Modes'), true);
+assert.equal(bootstrap.includes('Pre-prompt only; no bootstrap source is loaded'), true);
+assert.equal(bootstrap.includes(pointer.bootstrapPath), true);
+assert.equal(bootstrap.includes('do not execute package code'), true);
+assert.equal(bootstrap.includes('## Bind Capabilities To Concrete Host Tools'), true);
+assert.equal(bootstrap.includes('tiinex.portable.host-action-receipt.v1'), true);
+assert.equal(bootstrap.includes('## Manufacture Recipient-Relative Handoff Packages'), true);
+assert.equal(bootstrap.includes('manufacture-handoff-package'), true);
+assert.equal(bootstrap.includes('001-1-READ-BEFORE-PROCEEDING.trace.md'), true);
+assert.equal(bootstrap.includes('001-<package-slug>.trace.md'), true);
+assert.equal(bootstrap.includes('Generated Markdown children declare package-local `Parent` continuity'), true);
+assert.equal(bootstrap.includes('Exact durable source artifacts inside Workspace/cache archives retain their own historical provenance'), true);
+assert.equal(bootstrap.includes('001-0-READ-BEFORE-PROCEEDING.trace.md'), false);
+assert.equal(bootstrap.includes('tiinex.package/START.md'), false);
+assert.equal(bootstrap.includes('orient-handoff-package'), true);
+assert.equal(bootstrap.includes('audit-handoff-package-context'), true);
+assert.equal(bootstrap.includes('inspect ./received --summary --phase-timing'), true);
+assert.equal(bootstrap.includes('audit ./received --summary --phase-timing'), true);
+assert.equal(bootstrap.includes('search-lineage ./received --query \"mobile overflow\" --relation leaf --summary --phase-timing'), true);
+assert.equal(bootstrap.includes('resolve-lineage ./received --depth 3 --direction both --summary --phase-timing'), true);
+assert.equal(bootstrap.includes('npm run tooling:search -- --query'), true);
+assert.equal(bootstrap.includes('--include-legacy-topics'), true);
+assert.equal(bootstrap.includes('--include-legacy-fixtures'), true);
+assert.equal(bootstrap.includes('ground ... --include-required-context all'), true);
+assert.equal(bootstrap.includes('A receipt that omits Required Context bodies is not proof that the model has read those bodies.'), true);
+assert.equal(bootstrap.includes('humanOutput.normalInlineRouting.content'), true);
+assert.equal(bootstrap.includes('sole primary package'), true);
+assert.equal(bootstrap.includes('Filename or co-location under a bootstrap-like path does not grant bootstrap authority.'), true);
+assert.equal(bootstrap.includes('canonical Handoff semantic authoring/validation or a locked canonical package schema'), true);
+
+console.log('✓ portable bootstrap pointer and startup-mode contract passed');