@gregiteen/ssss-cli 0.8.0 → 0.9.1

package/scripts/phase9-cross-host-corpus.mjs

@@ -0,0 +1,223 @@
+#!/usr/bin/env node
+/**
+ * Phase 9 — shared cross-host command corpus.
+ *
+ * Runs a normalized set of Operation Contract envelopes through the package
+ * kernel (MemoryVfs + memory durable stores) and prints a machine-readable
+ * report. Hosts can re-run the same envelopes via their bridges and compare
+ * success/valid/type verdicts against this reference.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+import { createKernel, canonicalRequestHash } from '../src/kernel.mjs';
+import { FileSystemVfs } from '../src/vfs.mjs';
+import { MemoryEventStore } from '../src/events.mjs';
+import { MemoryIdempotencyStore } from '../src/idempotency.mjs';
+import { MemoryLeaseStore } from '../src/leases.mjs';
+import { createValidator } from '../src/validator.mjs';
+import { loadRegistries } from '../src/registry.mjs';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+function ruleContent(name) {
+  return [
+    '---',
+    'type: rule',
+    `title: ${name}`,
+    `description: Phase 9 corpus rule ${name}`,
+    'timestamp: 2026-07-10T00:00:00Z',
+    `name: ${name}`,
+    '---',
+    '',
+    `Body for ${name}.`,
+    '',
+  ].join('\n');
+}
+
+function spanishRuleContent() {
+  return [
+    '---',
+    'type: rule',
+    'title: Bienvenida',
+    'description: Regla estructural de corpus multilingüe',
+    'timestamp: 2026-07-10T00:00:00Z',
+    'name: bienvenida',
+    '---',
+    '',
+    'Cuerpo en español.',
+    '',
+  ].join('\n');
+}
+
+const CORPUS = [
+  {
+    id: 'corpus-rule-create',
+    envelope: {
+      type: 'operation',
+      workspace_id: 'ws-corpus',
+      idempotency_key: 'corpus-rule-1',
+      path: 'rules/welcome.md',
+      content: ruleContent('welcome'),
+    },
+    expect: { success: true, valid: true },
+  },
+  {
+    id: 'corpus-rule-idempotent-replay',
+    envelope: {
+      type: 'operation',
+      workspace_id: 'ws-corpus',
+      idempotency_key: 'corpus-rule-1',
+      path: 'rules/welcome.md',
+      content: ruleContent('welcome'),
+    },
+    expect: { success: true, valid: true, replay: true },
+  },
+  {
+    id: 'corpus-rule-idempotent-conflict',
+    envelope: {
+      type: 'operation',
+      workspace_id: 'ws-corpus',
+      idempotency_key: 'corpus-rule-1',
+      path: 'rules/welcome.md',
+      content: ruleContent('welcome-changed'),
+    },
+    expect: { success: false },
+  },
+  {
+    id: 'corpus-dry-run',
+    envelope: {
+      type: 'operation',
+      workspace_id: 'ws-corpus',
+      idempotency_key: 'corpus-dry-1',
+      path: 'rules/dry.md',
+      content: ruleContent('dry'),
+      dry_run: true,
+    },
+    expect: { success: true, valid: true, dry_run: true },
+  },
+  {
+    id: 'corpus-multilingual-rule',
+    envelope: {
+      type: 'operation',
+      workspace_id: 'ws-corpus',
+      idempotency_key: 'corpus-es-1',
+      path: 'rules/bienvenida.md',
+      content: spanishRuleContent(),
+    },
+    expect: { success: true, valid: true },
+  },
+  {
+    id: 'corpus-missing-actor-denied',
+    envelope: {
+      type: 'operation',
+      workspace_id: 'ws-corpus',
+      idempotency_key: 'corpus-no-actor',
+      path: 'rules/no-actor.md',
+      content: ruleContent('no-actor'),
+    },
+    principal: null,
+    expect: { success: false },
+  },
+];
+
+function principal() {
+  return {
+    id: 'phase9:corpus',
+    kind: 'system',
+    workspaceIds: ['ws-corpus'],
+    capabilities: ['*:*'],
+    authentication: { provider: 'phase9-corpus', assurance: 'system' },
+  };
+}
+
+async function main() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ssss-phase9-corpus-'));
+  const registrySet = loadRegistries();
+  const validator = createValidator({ registrySet });
+  const kernel = createKernel({
+    vfs: new FileSystemVfs(root),
+    eventStore: new MemoryEventStore(),
+    leaseStore: new MemoryLeaseStore(),
+    idempotencyStore: new MemoryIdempotencyStore(),
+    validator,
+  });
+
+  const results = [];
+  for (const caseDef of CORPUS) {
+    const p =
+      caseDef.principal === null
+        ? null
+        : caseDef.principal || principal();
+    let result;
+    try {
+      if (!p) {
+        // Simulate host fail-closed before kernel when identity missing
+        result = {
+          success: false,
+          validation: { valid: false, errors: ['Missing actor'] },
+        };
+      } else {
+        result = await kernel.execute(caseDef.envelope, { principal: p });
+      }
+    } catch (error) {
+      result = {
+        success: false,
+        validation: { valid: false, errors: [error.message] },
+        error: error.message,
+      };
+    }
+
+    const verdict = {
+      id: caseDef.id,
+      success: !!result.success,
+      valid: !!result.validation?.valid,
+      replay: !!result.replay,
+      dry_run: !!result.dry_run || !!caseDef.envelope.dry_run,
+      type: result.validation?.type || null,
+      errors: result.validation?.errors || [],
+      request_hash: canonicalRequestHash(caseDef.envelope),
+    };
+
+    const ok =
+      (caseDef.expect.success === undefined ||
+        verdict.success === caseDef.expect.success) &&
+      (caseDef.expect.valid === undefined ||
+        verdict.valid === caseDef.expect.valid) &&
+      (caseDef.expect.replay === undefined ||
+        verdict.replay === caseDef.expect.replay) &&
+      (caseDef.expect.dry_run === undefined ||
+        verdict.dry_run === caseDef.expect.dry_run);
+
+    results.push({ ...verdict, passed: ok });
+    console.log(`${ok ? '✅' : '❌'} ${caseDef.id} success=${verdict.success} valid=${verdict.valid}`);
+  }
+
+  const report = {
+    suite: 'phase9-cross-host-corpus',
+    package: '@gregiteen/ssss-cli',
+    version: JSON.parse(
+      fs.readFileSync(path.join(__dirname, '../package.json'), 'utf8'),
+    ).version,
+    generated_at: new Date().toISOString(),
+    passed: results.every((r) => r.passed),
+    results,
+  };
+
+  const outDir = path.join(__dirname, '../artifacts');
+  fs.mkdirSync(outDir, { recursive: true });
+  const outFile = path.join(outDir, 'phase9-cross-host-corpus.json');
+  fs.writeFileSync(outFile, `${JSON.stringify(report, null, 2)}\n`);
+  console.log(`\nReport: ${outFile}`);
+  console.log(`Overall: ${report.passed ? 'PASS' : 'FAIL'} (${results.filter((r) => r.passed).length}/${results.length})`);
+
+  fs.rmSync(root, { recursive: true, force: true });
+  process.exit(report.passed ? 0 : 1);
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/scripts/ssss.mjs

@@ -36,9 +36,12 @@ Vault → bundle → tenant lifecycle:
   import <bundle>       Replay a bundle/plan into a target vault (idempotent).
 
 Authoring & conformance:
+  primitive <verb>      Create, validate, inspect, migrate, or emit types.
+  registry <verb>       Compose, lock, or verify an effective registry.
+  adapter conformance   Run machine-readable adapter contract suites.
+  migrate 0.8-to-0.9    Diagnose and plan a non-destructive 0.9 migration.
   autolink [dir]        Generate OKF wiki links across a vault.
   semantic <vault>      Build/query a deterministic semantic projection (§11.9).
-  localize <vault>      Materialize approved locale overlays outside the vault.
   conformance           Run the canonical conformance suite (spec §12).
                         --engine | --endpoint <url> [--token <pat>]
 
@@ -63,7 +66,10 @@ const MODULES = {
   provision: './cmd-provision.mjs',
   import: './cmd-import.mjs',
   semantic: './cmd-semantic.mjs',
-  localize: './cmd-localize.mjs',
+  primitive: './cmd-primitive.mjs',
+  registry: './cmd-registry.mjs',
+  adapter: './cmd-adapter.mjs',
+  migrate: './cmd-migrate.mjs',
   help: './cmd-help.mjs',
 };
 

package/skills/ssss/SKILL.md

@@ -1,225 +1,49 @@
 ---
 type: skill
-title: SSSS System Manager
+title: SSSS Protocol Reference
 name: ssss
-description: "Inspect, validate, implement, or change SSSS primitives, extension registries, operation envelopes, workflow runtimes, semantic search, translation/localization overlays, bundles, projections, and host adapters. Use for SSSS schema changes, registry collisions, conformance failures, portability/privacy questions, or translatable semantic vault work. MANDATORY: Read this file before editing SSSS files or code."
-timestamp: 2026-07-10T00:00:00Z
+description: "Use this skill when reading, writing, parsing, validating, or extending SSSS -- the Structured Semantic Syntax System: the SSSS Core Contract API, VFS-native primitives, operation/patch/event envelopes, leases, and projections. MANDATORY: You MUST read the full SKILL.md file before executing."
+timestamp: 2026-07-15T00:00:00Z
 ---
 
-# SSSS — Structured Semantic Syntax System Manager
+# SSSS — Structured Semantic Syntax System Reference
 
-SSSS is a vendor-neutral, Markdown-first state and mutation contract. Canonical
-state is typed Markdown plus append-only events. Databases, indexes, queues,
-dashboards, and search stores are host projections unless explicitly documented
-as external resources.
+You are operating in a repository that implements, extends, or relies on the **Structured Semantic Syntax System (SSSS)**. SSSS is a database-free, Markdown-first schema and mutation contract for AI-agent state.
 
-## Establish Ground Truth First
+This skill provides the normative rules for interacting with an SSSS-compliant vault or host engine (like Total Recall). 
 
-Do not infer the contract from an installed skill snapshot.
+## ⚠️ The VFS-First Mandate (Absolute Rule)
 
-1. Find the repository root and inspect `package.json`, `VERSION`,
-   `registry/core.json`, and `docs/ssss-spec.md` when they exist.
-2. Treat `registry/core.json` as the machine-readable primitive contract and
-   `docs/ssss-spec.md` as the normative explanation.
-3. Treat `src/engine.mjs`, `src/runtime.mjs`, `src/semantic.mjs`,
-   `src/bundle.mjs`, `src/registry.mjs`, and `src/frontmatter.mjs` as the
-   reference behavior.
-4. Treat host schemas and services as adapters or extension registries. Never
-   promote host-only fields into the core standard without an explicit spec and
-   registry change.
-5. Read the current package name and version instead of hard-coding an alias.
-   In this checkout the published package is `@gregiteen/ssss-cli`; the CLI is
-   `ssss`.
+**NEVER use raw database inserts, updates, or deletes to mutate application state in an SSSS environment!**
 
-If those files are absent, inspect the installed
-`@gregiteen/ssss-cli/registry/core.json` export. Use the bundled reference only
-as a fallback and report that the result is snapshot-based.
+All persistent state (memories, agents, workflows, tasks) lives in the Virtual File System (VFS) as Markdown files with YAML frontmatter. The VFS is the absolute source of truth. 
+- If you are interacting via CLI: Use `npx total-recall remember` or `npx total-recall recall`.
+- If you are building host code: You must route mutations through the SSSS **Operation Contract** engine (which handles idempotency, leasing, and semantic indexing), or use the provided API wrappers. Do not bypass the engine to write files directly.
 
-## Authority Order
+## SSSS Core Concepts
 
-When sources disagree, resolve drift in this order:
+### 1. Primitives (The Data Model)
+Data in SSSS is defined by standard primitives (e.g. `workflow`, `assistant`, `skill`, `memory`). Each primitive has a defined schema (in `registry/core.json` or extension registries) and belongs to a specific Portability Class:
+- `structural`: Logic and system prompts (e.g. rules, workflows). Included in export templates.
+- `tenant_private`: User data (e.g. chats, tasks). NEVER included in templates.
+- `resource_bound`: Requires external setup (e.g. Twilio numbers). Exported only as a requirement.
 
-1. Conformance fixtures and tests for observed executable behavior.
-2. `registry/core.json` for required fields, enums, append behavior, and
-   portability.
-3. `docs/ssss-spec.md` for normative semantics.
-4. Reference engine/runtime/bundle code.
-5. Host extension registry and host adapter documentation.
-6. Skills, examples, README prose, and copied mirrors.
+### 2. The Operation Contract (Envelopes)
+When an SSSS engine processes a write, it receives an **Envelope**:
+- `operation`: Creates or completely replaces a document.
+- `patch`: Merges partial data into a document (e.g. updating task status).
+- `event`: Appends an immutable log entry to a document.
+- `delete`: Tombstones a replace-type document.
 
-Do not silently pick one side. Identify the mismatch, decide whether code or
-canon is wrong, update every affected source, and add a regression check.
+### 3. Idempotency and Leases
+- **Idempotency**: All mutations must provide an `idempotency_key`. The engine ensures duplicate submissions do not result in duplicate state.
+- **Leases**: Background tasks and workflows use the Lease store to acquire temporary locks on documents to prevent race conditions during execution.
 
-## Document Contract
+### 4. Bundles (.ucw)
+An SSSS vault can be packaged into a `.ucw` (Universal Containerized Workspace) bundle. A bundle is a portable snapshot containing a manifest, deterministic file paths, and content hashes for cryptographic integrity.
 
-Every SSSS document has YAML frontmatter and a Markdown body. SSSS-managed
-documents require the universal fields:
+## Validation 
 
-- `type`
-- `title`
-- `description`
-- `timestamp`
-
-Primitive-specific required fields are additive. An SSSS-managed skill also
-requires `name`; a schema-v2 memory has knowledge-graph fields; a workflow
-requires `name`.
-
-Unknown frontmatter fields must be preserved for forward compatibility. Never
-drop a nested map, array, or unknown field during parse/serialize or patch.
-
-Registry declarations are executable contract. Enforce `required_fields`,
-`required_when`, `enums`, `patterns`, `immutable_fields`, `references`,
-`append_only`, and `portability`. Reject malformed extension definitions,
-symlinked registry files, and core or sibling type collisions during load.
-
-## Mutation Contract
-
-Agent-generated mutations flow through the Operation Contract:
-
-```text
-validate envelope
-  -> verify safe workspace/idempotency/actor identifiers
-  -> resolve and contain the target path
-  -> replay or reject the idempotency key + request hash
-  -> authorize with verified actor identity (fail closed)
-  -> validate any active lease (fail closed)
-  -> validate universal + primitive-specific content
-  -> commit atomically
-  -> append the audit event
-```
-
-The mutation envelopes are:
-
-- `operation` — create or fully replace a replace-type document.
-- `patch` — merge an existing replace-type document without changing `type`.
-- `event` — append an immutable event record.
-- `delete` — remove a replace-type document and emit an audit event; reject
-  append-type targets.
-
-Use `dry_run: true` for model-generated preflight. Idempotency is scoped by the
-effective request, not the key alone: the same request replays, while the same
-workspace/key with a different request hash is a conflict.
-
-## Append, Lease, and Path Safety
-
-- `conversation` and `run` are append-only. Preserve prior bytes and append new
-  records; never rewrite or delete them.
-- Events are immutable.
-- Paths must be relative, contained vault paths. Reject absolute paths,
-  backslashes, null bytes, empty segments, `.`/`..`, directory targets, and
-  symlink escapes.
-- Leases are actor-owned, operation-linked, expiring locks. Missing, mismatched,
-  malformed, or unreadable lease state fails closed.
-- Hosts must overwrite caller-supplied actor data with verified session identity
-  before authorization.
-
-## Workflow Runtime
-
-Workflow frontmatter owns the schedule. Cron, daemon, webhook, file watcher, and
-event-loop processes are wake-up mechanisms, not a second scheduling database.
-
-Use `@gregiteen/ssss-cli/runtime` to deterministically derive the trigger event,
-task, and run envelopes. Duplicate ticks must replay idempotently. Queues and
-task dashboards are disposable projections over workflow state and events.
-
-## Bundles and Portability
-
-Every document primitive resolves to one portability class:
-
-- `structural` — reusable model shipped in templates and sale bundles.
-- `tenant_private` — operator/customer runtime data; excluded from template and
-  sale exports.
-- `resource_bound` — exported only as a requirement declaration; never leak the
-  seller's bound resource value.
-
-Bundle paths must be unique, safe, and symlink-free. Validate content hashes,
-required extensions, primitive inventory, core version, parameters, and link
-integrity before import. Preflight the complete plan before the first commit so a
-late invalid envelope cannot leave a partial install. Provisioning produces
-deterministic Operation Contract envelopes; re-import must be a no-op.
-
-## Semantic Search and Localization
-
-Treat semantic indexes and localized trees as disposable projections. Use
-`@gregiteen/ssss-cli/semantic`, `ssss semantic`, and `ssss localize` for the
-dependency-free reference behavior.
-
-- Index only `structural` documents by default. Include `tenant_private` and
-  `resource_bound` sources only after an explicit authorized opt-in.
-- Derive stable identity from `semantic_id`, then `resource`, then source path.
-- Build edges from explicit `relations`, wiki links, and Markdown links.
-- Keep projection output outside the source vault; reject symlinks and unsafe paths,
-  and stage the complete tree before publishing it.
-- Model localization as a `translation` document pointing to an existing
-  structural source and its exact SHA-256 content hash.
-- Translate only `title`, `description`, and body. Preserve types, ids, enums,
-  permissions, status, portability, relations, and paths from the source.
-- Apply approved overlays by default. Reject stale hashes, duplicate locale/source
-  overlays, recursive translations, private sources, and immutable identity edits.
-
-## Scope and Host Adapters
-
-The core standard does not collapse host ownership layers. A host may implement
-global/project or system/account/workspace overlays, but must document precedence
-and preserve isolation. Shared system skills should be inherited through an
-overlay rather than copied into every workspace.
-
-When working in Total Recall, use its validated-write and memory-validator
-adapter if those modules exist. In another host, locate its extension registry
-and conformance bridge. Do not quote Total Recall paths as universal SSSS
-architecture.
-
-## Procedure for Changes
-
-1. Classify the change: core primitive, contract behavior, runtime behavior,
-   semantic/localization behavior, bundle/provisioning behavior, projection, or
-   host extension.
-2. Inspect the registry, spec section, implementation, fixtures, and host bridge
-   for that surface.
-3. Make the smallest coherent change across code and canon.
-4. Add positive, negative, replay, and invalid-path cases where applicable.
-5. Run focused validation, then the full conformance gate.
-6. Update skill/reference mirrors only after the executable contract is green.
-
-## Validation
-
-Validate a Markdown document with the dependency-free skill helper:
-
-```bash
-node skills/ssss/scripts/validate-schema.mjs path/to/document.md
-```
-
-In the SSSS reference repository, the required gate is:
-
-```bash
-npm test
-```
-
-It covers registry/engine parity, shipped-skill conformance, Operation Contract
-fixtures, workflow runtime behavior, lease/frontmatter regressions,
-extension-registry hardening, semantic/localization behavior,
-bundle/provisioning round trips, and CLI smoke tests.
-
-For host adapters, run the host's named SSSS conformance command as well. Do not
-substitute a loose YAML parse or a generic typecheck for the SSSS gate.
-
-## Do Not
-
-- Do not treat an installed skill, copied spec, or README as newer than the live
-  registry and conformance suite.
-- Do not use raw file writes for agent-generated vault mutations.
-- Do not make a derived database/index/queue the canonical record.
-- Do not add a primitive in prose without registry and fixture coverage.
-- Do not translate symbolic control fields or index private content by default.
-- Do not materialize a projection inside its source vault.
-- Do not mix document primitives with contract envelopes.
-- Do not claim conformance from HTTP success or file creation alone.
-- Do not publish package names, versions, or exporter identities without reading
-  them from current package metadata.
-
-## References
-
-Read `references/contract-reference.md` for the compact topology, primitive
-families, package entry points, and drift checklist. For normative detail, read
-the exact linked section of `docs/ssss-spec.md` rather than loading a stale
-vendored copy.
+If you are writing tests or schemas in a host repository, ensure that:
+1. `MemoryNodeSchema` validations provide all required SSSS v2 properties (`status`, `created`, `updated`, `last_accessed`, `source`, `decay`).
+2. Schema changes maintain strict compatibility with the Open Knowledge Format (OKF) standard if applicable.

package/skills/ssss/evals/evals.json

@@ -26,12 +26,12 @@
   },
   {
     "name": "ssss-semantic-default-is-private",
-    "assertion": "The skill requires structural-only semantic and localization projections by default, with explicit authorization before private or resource-bound indexing.",
+    "assertion": "The skill requires structural-only semantic projections by default, with explicit authorization before private or resource-bound indexing.",
     "severity": "error"
   },
   {
-    "name": "ssss-translations-preserve-controls",
-    "assertion": "The skill limits translations to title, description, and body; requires an exact structural source hash; and preserves symbolic control fields.",
+    "name": "ssss-runtime-rendering-preserves-controls",
+    "assertion": "The skill requires runtime multilingual rendering and preserves all symbolic control fields.",
     "severity": "error"
   }
 ]

package/skills/ssss/references/contract-reference.md

@@ -11,7 +11,7 @@ This is an operational map. The normative source is the current
 | `registry/extensions/*.json` | Host/application types that cannot redefine core primitives. |
 | `src/engine.mjs` | Operation Contract, validation, authorization, leases, idempotency, atomic commit, audit. |
 | `src/runtime.mjs` | Workflow trigger planning and deterministic event/task/run envelopes. |
-| `src/semantic.mjs` | Deterministic semantic records/edges, localized search, and safe materialization. |
+| `src/semantic.mjs` | Deterministic records/edges, multilingual embeddings, hybrid retrieval, and invariant rendering. |
 | `src/bundle.mjs` | Export, validate, provision, import, portability filtering, link/hash integrity. |
 | `src/registry.mjs` | Registry loading and type/portability resolution. |
 | `src/frontmatter.mjs` | Dependency-free parse/serialize with unknown-field preservation. |
@@ -35,8 +35,7 @@ document types.
 Current core document families include knowledge (`memory`), capability
 (`skill`, `page`), governance (`rule`, `security_role`), work (`task`,
 `workflow`), actors/catalog (`assistant`, `model`), transcripts (`conversation`,
-`run`), localization (`translation`), and lifecycle/meta (`conflict`, `migration`,
-`release`).
+`run`), and lifecycle/meta (`conflict`, `migration`, `release`, `primitive`).
 
 The contract primitives are `operation`, `patch`, `event`, `delete`, and
 `lease`.
@@ -77,15 +76,15 @@ For a bundle:
 7. Internal links resolve after remapping.
 8. Re-import replays without new commits.
 
-For a semantic/localization projection:
+For a multilingual semantic projection:
 
 1. Records and index hashes are deterministic for identical inputs.
 2. Stable identity, tokens, content hashes, portability, and graph edges are retained.
 3. Private and resource-bound documents are excluded unless explicitly authorized.
-4. A translation targets one structural, non-translation source by safe relative path.
-5. The source hash is exact and only natural-language surface fields change.
-6. Duplicate, stale, traversing, symlinked, or recursive overlays fail closed.
-7. Materialization occurs outside the source vault and remains rebuildable.
+4. Embedding records retain model identity and vector dimensions.
+5. Lexical and semantic evidence remain separately inspectable.
+6. Runtime rendering preserves all symbolic control fields.
+7. Language selection never widens authorization or portability scope.
 
 ## Drift checklist
 

package/skills/ssss/scripts/validate-schema.mjs

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 import fs from 'node:fs';
 import path from 'node:path';
-import crypto from 'node:crypto';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
 const FALLBACK_UNIVERSAL = ['type', 'title', 'description', 'timestamp'];
@@ -20,7 +19,7 @@ const FALLBACK_REQUIRED = {
   page: ['slug', 'name', 'sandbox_entry'],
   migration: ['migration_id', 'from_version', 'to_version', 'status'],
   release: ['release_id', 'version', 'schema_version', 'summary', 'released_at'],
-  translation: ['translation_id', 'source_path', 'source_hash', 'locale', 'status', 'translated_fields'],
+  primitive: ['primitive_id', 'namespace', 'version', 'name', 'mutation', 'portability', 'scopes', 'fields'],
 };
 const CONTRACT_TYPES = new Set(['operation', 'patch', 'event', 'delete', 'lease']);
 const APPEND_TYPES = new Set(['conversation', 'run']);
@@ -120,46 +119,6 @@ function isSafeReferencePath(value) {
     value.split('/').every((segment) => segment && segment !== '.' && segment !== '..');
 }
 
-function inferVaultRoot(target) {
-  let cursor = path.dirname(target);
-  while (path.dirname(cursor) !== cursor) {
-    if (path.basename(cursor) === 'translations') return path.dirname(cursor);
-    cursor = path.dirname(cursor);
-  }
-  return null;
-}
-
-async function validateTranslationReference(target, data, registry, kernelRoot, errors, warnings) {
-  if (data.type !== 'translation' || isEmpty(data.source_path)) return;
-  if (!isSafeReferencePath(data.source_path)) {
-    errors.push(`Field 'source_path' must be a safe vault-relative Markdown path.`);
-    return;
-  }
-  const vaultRoot = inferVaultRoot(target);
-  if (!vaultRoot) {
-    warnings.push("Cannot resolve translation source outside the canonical translations/<locale>/ layout.");
-    return;
-  }
-  const source = path.resolve(vaultRoot, data.source_path);
-  const relative = path.relative(vaultRoot, source);
-  if (relative.startsWith('..') || path.isAbsolute(relative)) {
-    errors.push("Translation source_path escapes the vault.");
-    return;
-  }
-  if (!fs.existsSync(source) || !fs.statSync(source).isFile() || fs.lstatSync(source).isSymbolicLink()) {
-    errors.push(`Translation source does not exist as a regular non-symlinked file: ${data.source_path}.`);
-    return;
-  }
-  const raw = fs.readFileSync(source, 'utf8');
-  const parsed = await parseDocument(raw, kernelRoot);
-  if (parsed.data.type === 'translation') errors.push('Translations may not target another translation.');
-  const sourceDefinition = registry?.document_primitives?.[parsed.data.type];
-  const portability = parsed.data.x_portability || sourceDefinition?.portability;
-  if (portability !== 'structural') errors.push('Translations may target structural documents only.');
-  const hash = `sha256:${crypto.createHash('sha256').update(raw).digest('hex')}`;
-  if (data.source_hash !== hash) errors.push(`Translation source_hash is stale; expected '${hash}'.`);
-}
-
 export async function validateNode(filePath) {
   const target = path.resolve(filePath);
   const kernelRoot = findKernelRoot(path.dirname(target)) || findKernelRoot(process.cwd());
@@ -210,8 +169,6 @@ export async function validateNode(filePath) {
     }
   }
 
-  await validateTranslationReference(target, data, registry, kernelRoot, errors, warnings);
-
   if (APPEND_TYPES.has(data.type) && body.trim() === '') {
     warnings.push(`Append-only primitive '${data.type}' has an empty body.`);
   }