@topogram/cli 0.3.77 → 0.3.79

package/src/init-project.js

@@ -0,0 +1,215 @@
+// @ts-check
+
+import fs from "node:fs";
+import path from "node:path";
+
+import { defaultSdlcPolicy, SDLC_POLICY_FILE } from "./sdlc/policy.js";
+import { DEFAULT_TOPO_FOLDER_NAME, DEFAULT_WORKSPACE_PATH, PROJECT_CONFIG_FILE } from "./workspace-paths.js";
+
+/**
+ * @typedef {Object} InitProjectOptions
+ * @property {string} [targetPath]
+ * @property {boolean} [withSdlc]
+ */
+
+/**
+ * @typedef {Object} InitProjectResult
+ * @property {boolean} ok
+ * @property {string} projectRoot
+ * @property {string} workspaceRoot
+ * @property {string} projectConfigPath
+ * @property {string[]} created
+ * @property {string[]} skipped
+ * @property {Record<string, any>} projectConfig
+ * @property {{ enabled: boolean, path: string|null }} sdlc
+ */
+
+/**
+ * @param {string} projectRoot
+ * @param {string} targetPath
+ * @returns {string}
+ */
+function relativeProjectPath(projectRoot, targetPath) {
+  const relative = path.relative(projectRoot, targetPath);
+  return relative ? relative.split(path.sep).join("/") : ".";
+}
+
+/**
+ * @param {string} projectRoot
+ * @param {string} filePath
+ * @param {string} content
+ * @param {string[]} created
+ * @param {string[]} skipped
+ * @returns {void}
+ */
+function writeIfMissing(projectRoot, filePath, content, created, skipped) {
+  if (fs.existsSync(filePath)) {
+    skipped.push(relativeProjectPath(projectRoot, filePath));
+    return;
+  }
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, content, "utf8");
+  created.push(relativeProjectPath(projectRoot, filePath));
+}
+
+/**
+ * @returns {Record<string, any>}
+ */
+function defaultMaintainedProjectConfig() {
+  return {
+    version: "0.1",
+    workspace: DEFAULT_WORKSPACE_PATH,
+    outputs: {
+      app: {
+        path: ".",
+        ownership: "maintained"
+      }
+    },
+    topology: {
+      runtimes: []
+    }
+  };
+}
+
+/**
+ * @returns {string}
+ */
+function initializedReadme() {
+  return `# Topogram Project
+
+Initialized with \`topogram init\`.
+
+This repository is treated as a maintained app or workspace: Topogram will not
+overwrite source code under \`./\`. Use \`topogram emit\` for contracts, reports,
+snapshots, and proposals, and edit maintained app code directly after reading
+focused query packets.
+
+## First Commands
+
+\`\`\`bash
+topogram agent brief --json
+topogram check --json
+topogram query list --json
+\`\`\`
+
+To adopt enforced SDLC after initialization, run:
+
+\`\`\`bash
+topogram sdlc policy init .
+\`\`\`
+
+## Source
+
+- \`topo/\` is the project-owned Topogram workspace.
+- \`topogram.project.json\` declares workspace, output ownership, and runtime topology.
+- Output \`app\` points at \`.\` with \`maintained\` ownership.
+`;
+}
+
+/**
+ * @returns {string}
+ */
+function initializedAgentsGuide() {
+  return `# Agent Guide
+
+This repository was initialized with \`topogram init\`.
+
+Start with:
+
+\`\`\`bash
+topogram agent brief --json
+topogram check --json
+topogram query list --json
+\`\`\`
+
+Edit \`topo/**\` and \`topogram.project.json\` for Topogram source. The project
+output is maintained, so app/source files under \`./\` are human-owned and may be
+edited directly after reading focused packets.
+
+Use \`topogram emit <target>\` for contracts, reports, snapshots, migration
+plans, and agent context. Do not expect \`topogram generate\` to overwrite this
+maintained app unless output ownership is deliberately changed.
+
+If \`topogram.sdlc-policy.json\` exists, use SDLC commands for task and status
+work before protected edits:
+
+\`\`\`bash
+topogram sdlc policy explain --json
+topogram sdlc prep commit . --json
+\`\`\`
+`;
+}
+
+/**
+ * @param {string} projectRoot
+ * @returns {void}
+ */
+function assertInitTarget(projectRoot) {
+  if (fs.existsSync(projectRoot) && !fs.statSync(projectRoot).isDirectory()) {
+    throw new Error(`Cannot initialize Topogram at '${projectRoot}' because it is not a directory.`);
+  }
+  const configPath = path.join(projectRoot, PROJECT_CONFIG_FILE);
+  if (fs.existsSync(configPath)) {
+    throw new Error(`Refusing to initialize Topogram because ${PROJECT_CONFIG_FILE} already exists.`);
+  }
+  const workspaceRoot = path.join(projectRoot, DEFAULT_TOPO_FOLDER_NAME);
+  if (fs.existsSync(workspaceRoot)) {
+    if (!fs.statSync(workspaceRoot).isDirectory()) {
+      throw new Error(`Refusing to initialize Topogram because ${DEFAULT_TOPO_FOLDER_NAME}/ exists and is not a directory.`);
+    }
+    const entries = fs.readdirSync(workspaceRoot).filter(/** @param {string} entry */ (entry) => entry !== ".DS_Store");
+    if (entries.length > 0) {
+      throw new Error(`Refusing to initialize Topogram because ${DEFAULT_TOPO_FOLDER_NAME}/ already exists and is not empty.`);
+    }
+  }
+}
+
+/**
+ * @param {InitProjectOptions} [options]
+ * @returns {InitProjectResult}
+ */
+export function initTopogramProject(options = {}) {
+  const projectRoot = path.resolve(options.targetPath || ".");
+  assertInitTarget(projectRoot);
+  fs.mkdirSync(projectRoot, { recursive: true });
+
+  /** @type {string[]} */
+  const created = [];
+  /** @type {string[]} */
+  const skipped = [];
+  const workspaceRoot = path.join(projectRoot, DEFAULT_TOPO_FOLDER_NAME);
+  fs.mkdirSync(workspaceRoot, { recursive: true });
+  created.push(DEFAULT_TOPO_FOLDER_NAME);
+
+  writeIfMissing(projectRoot, path.join(workspaceRoot, ".gitkeep"), "", created, skipped);
+  const projectConfig = defaultMaintainedProjectConfig();
+  const projectConfigPath = path.join(projectRoot, PROJECT_CONFIG_FILE);
+  fs.writeFileSync(projectConfigPath, `${JSON.stringify(projectConfig, null, 2)}\n`, "utf8");
+  created.push(PROJECT_CONFIG_FILE);
+  writeIfMissing(projectRoot, path.join(projectRoot, "README.md"), initializedReadme(), created, skipped);
+  writeIfMissing(projectRoot, path.join(projectRoot, "AGENTS.md"), initializedAgentsGuide(), created, skipped);
+  const sdlcPolicyPath = path.join(projectRoot, SDLC_POLICY_FILE);
+  if (options.withSdlc) {
+    writeIfMissing(
+      projectRoot,
+      sdlcPolicyPath,
+      `${JSON.stringify(defaultSdlcPolicy(), null, 2)}\n`,
+      created,
+      skipped
+    );
+  }
+
+  return {
+    ok: true,
+    projectRoot,
+    workspaceRoot,
+    projectConfigPath,
+    created,
+    skipped,
+    projectConfig,
+    sdlc: {
+      enabled: options.withSdlc ? fs.existsSync(sdlcPolicyPath) : false,
+      path: options.withSdlc ? sdlcPolicyPath : null
+    }
+  };
+}

package/src/new-project/constants.js

@@ -31,7 +31,7 @@ export const SURFACE_ORDER = new Map([
  * @returns {string}
  */
 export function unsupportedTemplateSymlinkMessage(templateId, relativePath) {
-  return `Template '${templateId}' contains unsupported symlink '${relativePath}'. Template packs must copy real files because Topogram records hashes for copied workspace and implementation/ content; symlinks can point outside the trusted template root. Replace the symlink with a real file or directory before running topogram new or topogram template check.`;
+  return `Template '${templateId}' contains unsupported symlink '${relativePath}'. Template packs must copy real files because Topogram records hashes for copied workspace and implementation/ content; symlinks can point outside the trusted template root. Replace the symlink with a real file or directory before running topogram copy or topogram template check.`;
 }
 
 /**

package/src/new-project/create.js

@@ -36,7 +36,7 @@ export function createNewProject({
   templateProvenance = null
 }) {
   if (!targetPath) {
-    throw new Error("topogram new requires <path>.");
+    throw new Error("topogram copy requires <target>.");
   }
   const projectRoot = path.resolve(targetPath);
   assertProjectOutsideEngine(projectRoot, engineRoot);
@@ -68,7 +68,7 @@ export function createNewProject({
     writeTemplateTrustRecord(projectRoot, projectConfig);
     warnings.push(
       `Template '${template.manifest.id}' copied implementation/ code into this project. ` +
-        "topogram new did not execute it, but topogram generate may load it later. " +
+        "topogram copy did not execute it, but topogram generate may load it later. " +
         "Recorded local trust in .topogram-template-trust.json."
     );
   }

package/src/new-project/project-files.js

@@ -247,7 +247,7 @@ export function writeProjectReadme(projectRoot, projectConfig) {
   provenanceLines.push(`- Executable implementation: \`${template.includesExecutableImplementation ? "yes" : "no"}\``);
   const readme = `# ${packageNameFromPath(projectRoot)}
 
-Generated by \`topogram new\`.
+Copied by \`topogram copy\`.
 
 ## Template
 
@@ -263,7 +263,7 @@ Edit the workspace folder \`${DEFAULT_TOPO_FOLDER_NAME}/\` and \`topogram.projec
 Generated app code is written to \`app/\`.
 Use \`topogram emit <target>\` to inspect contracts, reports, snapshots, and other artifacts without regenerating the app.
 Agents should start with \`AGENTS.md\` and \`npm run agent:brief\`. The direct \`topogram agent brief --json\` command is the canonical machine-readable first-run guidance.
-${template.includesExecutableImplementation ? "\nThis template copied `implementation/` code. `topogram new` did not execute it; review `implementation/`, `topogram.template-policy.json`, and `.topogram-template-trust.json` before regenerating after edits.\n" : ""}
+${template.includesExecutableImplementation ? "\nThis template copied `implementation/` code. `topogram copy` did not execute it; review `implementation/`, `topogram.template-policy.json`, and `.topogram-template-trust.json` before regenerating after edits.\n" : ""}
 `;
   fs.writeFileSync(path.join(projectRoot, "README.md"), readme, "utf8");
 }
@@ -339,12 +339,12 @@ npm run query:show -- widget-behavior
 
 - Local edits to template-derived Topogram files are project-owned.
 - Use \`npm run source:status\` and \`npm run template:update:recommend\` before applying template updates.
-${hasImplementation ? "- This project has executable `implementation/` code. `topogram new` did not execute it. Do not refresh trust until the implementation has been reviewed.\n" : "- This template does not declare executable implementation code.\n"}
-## Import And Adoption
+${hasImplementation ? "- This project has executable `implementation/` code. `topogram copy` did not execute it. Do not refresh trust until the implementation has been reviewed.\n" : "- This template does not declare executable implementation code.\n"}
+## Extract And Adopt
 
-- If \`.topogram-import.json\` exists, agents should run \`topogram import check . --json\`, \`topogram import plan . --json\`, \`topogram import adopt --list . --json\`, \`topogram import status . --json\`, and \`topogram import history . --verify --json\`.
-- Import JSON payloads expose \`workspaceRoot\`; prefer it as the canonical project-owned workspace path.
-- Imported Topogram files are project-owned after adoption; source hashes record trusted import evidence at the time of import.
+- If \`.topogram-extract.json\` exists, agents should run \`topogram extract check . --json\`, \`topogram extract plan . --json\`, \`topogram adopt --list . --json\`, \`topogram extract status . --json\`, and \`topogram extract history . --verify --json\`.
+- Extract JSON payloads expose \`workspaceRoot\`; prefer it as the canonical project-owned workspace path.
+- Extracted Topogram files are project-owned after adoption; source hashes record trusted source evidence at the time of extraction.
 
 ## Verification Gates
 

package/src/reconcile/journeys.js

@@ -28,9 +28,11 @@ function primaryEntityIdForBundle(bundle) {
 
 function canonicalJourneyCoverage(graph) {
   const journeyDocs = (graph?.docs || []).filter((doc) => doc.kind === "journey");
+  const journeyStatements = graph?.byKind?.journey || [];
+  const journeys = [...journeyStatements, ...journeyDocs];
   return {
-    byEntityId: new Set(journeyDocs.flatMap((doc) => doc.relatedEntities || [])),
-    byCapabilityId: new Set(journeyDocs.flatMap((doc) => doc.relatedCapabilities || []))
+    byEntityId: new Set(journeys.flatMap((journey) => journey.relatedEntities || [])),
+    byCapabilityId: new Set(journeys.flatMap((journey) => journey.relatedCapabilities || []))
   };
 }
 
@@ -42,7 +44,10 @@ function collectJourneyGenerationContext(graph) {
   const uiSharedScreens = projections
     .filter((projection) => projection.type === "ui_contract")
     .flatMap((projection) => (projection.uiScreens || []).map((screen) => ({ ...screen, projectionId: projection.id })));
-  const canonicalJourneys = (graph.docs || []).filter((doc) => doc.kind === "journey");
+  const canonicalJourneys = [
+    ...(graph.byKind?.journey || []),
+    ...(graph.docs || []).filter((doc) => doc.kind === "journey")
+  ];
   const coveredEntityIds = new Set(canonicalJourneys.flatMap((doc) => doc.relatedEntities || []));
 
   return entities

package/src/record-blocks.js

@@ -0,0 +1,125 @@
+// @ts-check
+
+/**
+ * @typedef {{
+ *   key: string,
+ *   value: import("./parser.js").AstValue | null,
+ *   values: import("./parser.js").AstValue[],
+ *   loc: import("./parser.js").AstLocation
+ * }} TopogramRecordField
+ *
+ * @typedef {{
+ *   fields: Map<string, TopogramRecordField[]>,
+ *   fieldOrder: TopogramRecordField[],
+ *   loc: import("./parser.js").AstLocation
+ * }} TopogramRecordBlock
+ */
+
+/**
+ * @param {import("./parser.js").AstValue[]} values
+ * @param {import("./parser.js").AstLocation} loc
+ * @returns {import("./parser.js").AstValue | null}
+ */
+function valuesToRecordValue(values, loc) {
+  if (values.length === 0) {
+    return null;
+  }
+  if (values.length === 1) {
+    return values[0];
+  }
+  return {
+    type: "sequence",
+    items: values,
+    loc
+  };
+}
+
+/**
+ * @param {import("./parser.js").AstBlock} block
+ * @returns {TopogramRecordBlock}
+ */
+export function parseRecordBlock(block) {
+  /** @type {Map<string, TopogramRecordField[]>} */
+  const fields = new Map();
+  /** @type {TopogramRecordField[]} */
+  const fieldOrder = [];
+
+  for (const entry of block.entries || []) {
+    const [keyToken, ...values] = entry.items || [];
+    const key = keyToken?.type === "symbol" ? keyToken.value : "";
+    const field = {
+      key,
+      value: valuesToRecordValue(values, entry.loc),
+      values,
+      loc: entry.loc
+    };
+    if (!fields.has(key)) {
+      fields.set(key, []);
+    }
+    fields.get(key)?.push(field);
+    fieldOrder.push(field);
+  }
+
+  return {
+    fields,
+    fieldOrder,
+    loc: block.loc
+  };
+}
+
+/**
+ * @param {TopogramRecordBlock} record
+ * @param {string} key
+ * @returns {TopogramRecordField | null}
+ */
+export function recordField(record, key) {
+  return record.fields.get(key)?.[0] || null;
+}
+
+/**
+ * @param {TopogramRecordBlock} record
+ * @param {string} key
+ * @returns {string | null}
+ */
+export function recordSymbol(record, key) {
+  const value = recordField(record, key)?.value;
+  return value?.type === "symbol" ? value.value : null;
+}
+
+/**
+ * @param {TopogramRecordBlock} record
+ * @param {string} key
+ * @returns {string | null}
+ */
+export function recordString(record, key) {
+  const value = recordField(record, key)?.value;
+  return value?.type === "string" ? value.value : null;
+}
+
+/**
+ * @param {TopogramRecordBlock} record
+ * @param {string} key
+ * @returns {string[]}
+ */
+export function recordStringList(record, key) {
+  const value = recordField(record, key)?.value;
+  if (!value) return [];
+  const items = value.type === "list" ? value.items : value.type === "sequence" ? value.items : [value];
+  return items
+    .map((item) => item.type === "string" ? item.value : null)
+    .filter(/** @param {string | null} value */ (value) => value !== null);
+}
+
+/**
+ * @param {TopogramRecordBlock} record
+ * @param {string} key
+ * @returns {string[]}
+ */
+export function recordSymbolList(record, key) {
+  const value = recordField(record, key)?.value;
+  if (!value) return [];
+  const items = value.type === "list" ? value.items : value.type === "sequence" ? value.items : [value];
+  return items
+    .map((item) => item.type === "symbol" ? item.value : null)
+    .filter(/** @param {string | null} value */ (value) => value !== null);
+}

package/src/resolver/index.js

@@ -111,6 +111,7 @@ export function resolveWorkspace(workspaceAst) {
         orchestrations: [],
         operations: [],
         decisions: [],
+        journeys: [],
         pitches: [],
         requirements: [],
         tasks: [],
@@ -128,6 +129,7 @@ export function resolveWorkspace(workspaceAst) {
     orchestration: "orchestrations",
     operation: "operations",
     decision: "decisions",
+    journey: "journeys",
     pitch: "pitches",
     requirement: "requirements",
     task: "tasks",
@@ -321,6 +323,7 @@ export function resolveWorkspace(workspaceAst) {
             orchestrations: [],
             operations: [],
             decisions: [],
+            journeys: [],
             pitches: [],
             requirements: [],
             tasks: [],

package/src/resolver/journeys.js

@@ -0,0 +1,74 @@
+// @ts-check
+
+import {
+  parseRecordBlock,
+  recordString,
+  recordStringList,
+  recordSymbol,
+  recordSymbolList
+} from "../record-blocks.js";
+
+/**
+ * @param {import("../parser.js").AstStatement} statement
+ * @param {string} key
+ * @returns {import("../parser.js").AstField[]}
+ */
+function fieldsByKey(statement, key) {
+  return statement.fields.filter((field) => field.key === key);
+}
+
+/**
+ * @param {import("../parser.js").AstField} field
+ * @returns {any}
+ */
+function parseStepField(field) {
+  if (field.value.type !== "block") {
+    return null;
+  }
+  const record = parseRecordBlock(field.value);
+  return {
+    id: recordSymbol(record, "id"),
+    intent: recordString(record, "intent"),
+    commands: recordStringList(record, "commands"),
+    expects: recordStringList(record, "expects"),
+    after: recordSymbolList(record, "after"),
+    notes: recordString(record, "notes"),
+    loc: field.loc
+  };
+}
+
+/**
+ * @param {import("../parser.js").AstField} field
+ * @returns {any}
+ */
+function parseAlternateField(field) {
+  if (field.value.type !== "block") {
+    return null;
+  }
+  const record = parseRecordBlock(field.value);
+  return {
+    id: recordSymbol(record, "id"),
+    from: recordSymbol(record, "from"),
+    condition: recordString(record, "condition"),
+    commands: recordStringList(record, "commands"),
+    expects: recordStringList(record, "expects"),
+    notes: recordString(record, "notes"),
+    loc: field.loc
+  };
+}
+
+/**
+ * @param {import("../parser.js").AstStatement} statement
+ * @returns {any[]}
+ */
+export function parseJourneySteps(statement) {
+  return fieldsByKey(statement, "step").map(parseStepField).filter(Boolean);
+}
+
+/**
+ * @param {import("../parser.js").AstStatement} statement
+ * @returns {any[]}
+ */
+export function parseJourneyAlternates(statement) {
+  return fieldsByKey(statement, "alternate").map(parseAlternateField).filter(Boolean);
+}

package/src/resolver/normalize.js

@@ -75,6 +75,7 @@ import {
   parseProjectionGeneratorDefaultsBlock
 } from "./projections-db.js";
 import { parsePlanSteps } from "../sdlc/plan-steps.js";
+import { parseJourneyAlternates, parseJourneySteps } from "./journeys.js";
 
 export function normalizeStatement(statement, registry) {
   const fieldMap = collectFieldMap(statement);
@@ -308,6 +309,30 @@ export function normalizeStatement(statement, registry) {
           : null,
         aliases: normalizeDomainScopeList(statement, "aliases")
       };
+    case "journey":
+      return {
+        ...base,
+        actors: symbolValues(getFieldValue(statement, "actors")),
+        roles: symbolValues(getFieldValue(statement, "roles")),
+        goal: stringValue(getFieldValue(statement, "goal")),
+        trigger: stringValue(getFieldValue(statement, "trigger")),
+        steps: parseJourneySteps(statement),
+        alternates: parseJourneyAlternates(statement),
+        successSignals: normalizeDomainScopeList(statement, "success_signals"),
+        failureSignals: normalizeDomainScopeList(statement, "failure_signals"),
+        relatedCapabilities: symbolValues(getFieldValue(statement, "related_capabilities")),
+        relatedEntities: symbolValues(getFieldValue(statement, "related_entities")),
+        relatedRules: symbolValues(getFieldValue(statement, "related_rules")),
+        relatedWorkflows: symbolValues(getFieldValue(statement, "related_workflows")),
+        relatedProjections: symbolValues(getFieldValue(statement, "related_projections")),
+        relatedWidgets: symbolValues(getFieldValue(statement, "related_widgets")),
+        relatedVerifications: symbolValues(getFieldValue(statement, "related_verifications")),
+        relatedDecisions: symbolValues(getFieldValue(statement, "related_decisions")),
+        relatedDocs: symbolValues(getFieldValue(statement, "related_docs")),
+        tags: normalizeDomainScopeList(statement, "tags"),
+        updated: stringValue(getFieldValue(statement, "updated")),
+        resolvedDomain: resolveDomainTag(statement, registry)
+      };
     case "pitch":
       return {
         ...base,

package/src/sdlc/adopt.js

@@ -55,7 +55,7 @@ function scanPressure(root) {
 export function sdlcAdopt(workspaceRoot) {
   const root = path.resolve(workspaceRoot);
   if (!existsSync(resolveTopoRoot(root))) {
-    return { ok: false, error: `No '${DEFAULT_TOPO_FOLDER_NAME}/' workspace folder at ${root}; run 'topogram new' first` };
+    return { ok: false, error: `No '${DEFAULT_TOPO_FOLDER_NAME}/' workspace folder at ${root}; run 'topogram init' or 'topogram copy' first` };
   }
   const folders = SDLC_FOLDERS.map((name) => ensureFolder(root, name));
   const pressure = scanPressure(root);

package/src/validator/common.js

@@ -205,6 +205,8 @@ function validateFieldShapes(errors, statement, fieldMap) {
   ensureSingleValueField(errors, statement, fieldMap, "updated", ["string"]);
   ensureSingleValueField(errors, statement, fieldMap, "notes", ["string"]);
   ensureSingleValueField(errors, statement, fieldMap, "outcome", ["string"]);
+  ensureSingleValueField(errors, statement, fieldMap, "goal", ["string"]);
+  ensureSingleValueField(errors, statement, fieldMap, "trigger", ["string"]);
 
   const listFields = [
     "aliases",
@@ -238,7 +240,19 @@ function validateFieldShapes(errors, statement, fieldMap) {
     "regions",
     "lookups",
     "dependencies",
-    "approvals"
+    "approvals",
+    "success_signals",
+    "failure_signals",
+    "tags",
+    "related_capabilities",
+    "related_entities",
+    "related_rules",
+    "related_workflows",
+    "related_projections",
+    "related_widgets",
+    "related_verifications",
+    "related_decisions",
+    "related_docs"
   ];
   if (statement.kind === "orchestration") {
     listFields.push("steps");
@@ -251,6 +265,16 @@ function validateFieldShapes(errors, statement, fieldMap) {
   if (statement.kind === "plan") {
     blockFields.push("steps");
   }
+  if (statement.kind === "journey") {
+    for (const key of ["step", "alternate"]) {
+      const fields = fieldMap.get(key) || [];
+      for (const field of fields) {
+        if (field.value.type !== "block") {
+          pushError(errors, `Field '${key}' on ${statement.kind} ${statement.id} must be block, found ${field.value.type}`, field.loc);
+        }
+      }
+    }
+  }
   for (const key of blockFields) {
     ensureSingleValueField(errors, statement, fieldMap, key, ["block"]);
   }
@@ -429,6 +453,15 @@ function validateReferenceKinds(errors, statement, fieldMap, registry) {
     requirement: null,
     from_requirement: ["requirement"],
     affects: ["capability", "entity", "rule", "projection", "widget", "orchestration", "operation"],
+    related_capabilities: ["capability"],
+    related_entities: ["entity"],
+    related_rules: ["rule"],
+    related_workflows: null,
+    related_projections: ["projection"],
+    related_widgets: ["widget"],
+    related_verifications: ["verification"],
+    related_decisions: ["decision"],
+    related_docs: null,
     introduces_rules: ["rule"],
     respects_rules: ["rule"],
     decisions: ["decision"],

package/src/validator/index.js

@@ -20,6 +20,7 @@ import { validateAcceptanceCriterion } from "./per-kind/acceptance-criterion.js"
 import { validateTask } from "./per-kind/task.js";
 import { validatePlan } from "./per-kind/plan.js";
 import { validateBug } from "./per-kind/bug.js";
+import { validateJourney } from "./per-kind/journey.js";
 
 export {
   STATEMENT_KINDS,
@@ -32,6 +33,7 @@ export {
   TASK_IDENTIFIER_PATTERN,
   PLAN_IDENTIFIER_PATTERN,
   BUG_IDENTIFIER_PATTERN,
+  JOURNEY_IDENTIFIER_PATTERN,
   DOCUMENT_IDENTIFIER_PATTERN,
   GLOBAL_STATUSES,
   DECISION_STATUSES,
@@ -48,6 +50,7 @@ export {
   PLAN_STATUSES,
   PLAN_STEP_STATUSES,
   BUG_STATUSES,
+  JOURNEY_STATUSES,
   PRIORITY_VALUES,
   WORK_TYPES,
   BUG_SEVERITIES,
@@ -112,6 +115,7 @@ export function validateWorkspace(workspaceAst) {
       validateTask(errors, statement, fieldMap, registry);
       validatePlan(errors, statement, fieldMap, registry);
       validateBug(errors, statement, fieldMap, registry);
+      validateJourney(errors, statement, fieldMap, registry);
       validateExpressions(errors, statement, fieldMap);
     }
   }