@topogram/cli 0.3.78 → 0.3.80

package/src/extractor-policy.js

@@ -0,0 +1,249 @@
+// @ts-check
+
+import fs from "node:fs";
+import path from "node:path";
+
+import { stableStringify } from "./format.js";
+import {
+  optionalStringArray,
+  optionalStringRecord,
+  packageAllowedByPolicy,
+  packageScopeFromName as sharedPackageScopeFromName
+} from "./package-adapters/index.js";
+
+export const EXTRACTOR_POLICY_FILE = "topogram.extractor-policy.json";
+
+/**
+ * @typedef {Object} ExtractorPolicy
+ * @property {string} version
+ * @property {string[]} allowedPackageScopes
+ * @property {string[]} allowedPackages
+ * @property {Record<string, string>} pinnedVersions
+ * @property {string[]} enabledPackages
+ */
+
+/**
+ * @typedef {Object} PackageExtractorBinding
+ * @property {string} packageName
+ * @property {string} version
+ */
+
+/**
+ * @typedef {Object} ExtractorPolicyInfo
+ * @property {string} path
+ * @property {ExtractorPolicy|null} policy
+ * @property {boolean} exists
+ * @property {ExtractorPolicyDiagnostic[]} diagnostics
+ */
+
+/**
+ * @typedef {Object} ExtractorPolicyDiagnostic
+ * @property {string} code
+ * @property {"error"|"warning"} severity
+ * @property {string} message
+ * @property {string|null} path
+ * @property {string|null} suggestedFix
+ * @property {string|null} step
+ * @property {string|null} [packageName]
+ * @property {string|null} [version]
+ */
+
+/**
+ * @param {Record<string, any>} input
+ * @returns {ExtractorPolicyDiagnostic}
+ */
+function extractorPolicyDiagnostic(input) {
+  return {
+    code: String(input.code || "extractor_policy_failed"),
+    severity: input.severity === "warning" ? "warning" : "error",
+    message: String(input.message || "Extractor policy check failed."),
+    path: typeof input.path === "string" ? input.path : null,
+    suggestedFix: typeof input.suggestedFix === "string" ? input.suggestedFix : null,
+    step: typeof input.step === "string" ? input.step : null,
+    packageName: typeof input.packageName === "string" ? input.packageName : null,
+    version: typeof input.version === "string" ? input.version : null
+  };
+}
+
+/**
+ * @returns {ExtractorPolicy}
+ */
+export function defaultExtractorPolicy() {
+  return {
+    version: "0.1",
+    allowedPackageScopes: [],
+    allowedPackages: [],
+    pinnedVersions: {},
+    enabledPackages: []
+  };
+}
+
+/**
+ * @param {unknown} value
+ * @param {string} policyPath
+ * @returns {ExtractorPolicy}
+ */
+export function validateExtractorPolicy(value, policyPath) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${EXTRACTOR_POLICY_FILE} must contain a JSON object.`);
+  }
+  const raw = /** @type {Record<string, unknown>} */ (value);
+  const defaults = defaultExtractorPolicy();
+  return {
+    version: typeof raw.version === "string" && raw.version ? raw.version : defaults.version,
+    allowedPackageScopes: raw.allowedPackageScopes == null
+      ? defaults.allowedPackageScopes
+      : optionalStringArray(raw.allowedPackageScopes, "allowedPackageScopes", policyPath),
+    allowedPackages: optionalStringArray(raw.allowedPackages, "allowedPackages", policyPath),
+    pinnedVersions: optionalStringRecord(raw.pinnedVersions, policyPath, "package-or-extractor ids"),
+    enabledPackages: optionalStringArray(raw.enabledPackages, "enabledPackages", policyPath)
+  };
+}
+
+/**
+ * @param {string} packageName
+ * @returns {string|null}
+ */
+export function packageScopeFromName(packageName) {
+  return sharedPackageScopeFromName(packageName);
+}
+
+/**
+ * @param {ExtractorPolicy} policy
+ * @param {string} packageName
+ * @returns {boolean}
+ */
+export function extractorPackageAllowed(policy, packageName) {
+  return packageName.startsWith("@topogram/extractor-") || packageAllowedByPolicy(policy, packageName);
+}
+
+/**
+ * @param {string} projectRoot
+ * @param {string|null|undefined} policyPath
+ * @returns {string}
+ */
+function resolvePolicyPath(projectRoot, policyPath) {
+  if (policyPath) {
+    const resolved = path.resolve(projectRoot, policyPath);
+    if (fs.existsSync(resolved) && fs.statSync(resolved).isDirectory()) {
+      return path.join(resolved, EXTRACTOR_POLICY_FILE);
+    }
+    return resolved;
+  }
+  return path.join(projectRoot, EXTRACTOR_POLICY_FILE);
+}
+
+/**
+ * @param {string} projectRoot
+ * @param {string|null|undefined} [policyPath]
+ * @returns {ExtractorPolicyInfo}
+ */
+export function loadExtractorPolicy(projectRoot, policyPath = null) {
+  const resolvedPolicyPath = resolvePolicyPath(projectRoot, policyPath);
+  if (!fs.existsSync(resolvedPolicyPath)) {
+    return {
+      path: resolvedPolicyPath,
+      policy: null,
+      exists: false,
+      diagnostics: []
+    };
+  }
+  try {
+    return {
+      path: resolvedPolicyPath,
+      policy: validateExtractorPolicy(JSON.parse(fs.readFileSync(resolvedPolicyPath, "utf8")), resolvedPolicyPath),
+      exists: true,
+      diagnostics: []
+    };
+  } catch (error) {
+    return {
+      path: resolvedPolicyPath,
+      policy: null,
+      exists: true,
+      diagnostics: [extractorPolicyDiagnostic({
+        code: "extractor_policy_invalid",
+        message: error instanceof Error ? error.message : String(error),
+        path: resolvedPolicyPath,
+        suggestedFix: `Fix ${EXTRACTOR_POLICY_FILE} or regenerate it with \`topogram extractor policy init\`.`,
+        step: "extractor-policy"
+      })]
+    };
+  }
+}
+
+/**
+ * @param {ExtractorPolicyInfo} policyInfo
+ * @returns {ExtractorPolicy}
+ */
+export function effectiveExtractorPolicy(policyInfo) {
+  return policyInfo.policy || defaultExtractorPolicy();
+}
+
+/**
+ * @param {string} projectRoot
+ * @param {ExtractorPolicy} policy
+ * @param {string|null|undefined} [policyPath]
+ * @returns {ExtractorPolicy}
+ */
+export function writeExtractorPolicy(projectRoot, policy, policyPath = null) {
+  const resolvedPolicyPath = resolvePolicyPath(projectRoot, policyPath);
+  fs.writeFileSync(resolvedPolicyPath, `${stableStringify(policy)}\n`, "utf8");
+  return policy;
+}
+
+/**
+ * @param {ExtractorPolicyInfo} policyInfo
+ * @param {PackageExtractorBinding[]} bindings
+ * @param {string} [step]
+ * @returns {ExtractorPolicyDiagnostic[]}
+ */
+export function extractorPolicyDiagnosticsForPackages(policyInfo, bindings, step = "extractor-policy") {
+  if (policyInfo.diagnostics.length > 0) {
+    return policyInfo.diagnostics;
+  }
+  const policy = effectiveExtractorPolicy(policyInfo);
+  /** @type {ExtractorPolicyDiagnostic[]} */
+  const diagnostics = [];
+  for (const binding of bindings) {
+    if (!extractorPackageAllowed(policy, binding.packageName)) {
+      const scope = packageScopeFromName(binding.packageName);
+      diagnostics.push(extractorPolicyDiagnostic({
+        code: "extractor_package_denied",
+        message: `Extractor package '${binding.packageName}' is not allowed by ${EXTRACTOR_POLICY_FILE}.`,
+        path: policyInfo.path,
+        suggestedFix: `Review '${binding.packageName}', then run \`topogram extractor policy pin ${binding.packageName}@${binding.version}\` or add '${scope || binding.packageName}' to ${EXTRACTOR_POLICY_FILE}.`,
+        step,
+        packageName: binding.packageName,
+        version: binding.version
+      }));
+    }
+    const pinnedVersion = policy.pinnedVersions[binding.packageName] || null;
+    if (pinnedVersion && pinnedVersion !== binding.version) {
+      diagnostics.push(extractorPolicyDiagnostic({
+        code: "extractor_version_mismatch",
+        message: `Extractor package '${binding.packageName}' uses version '${binding.version}', but ${EXTRACTOR_POLICY_FILE} pins it to '${pinnedVersion}'.`,
+        path: policyInfo.path,
+        suggestedFix: `Use extractor version '${pinnedVersion}', or run \`topogram extractor policy pin ${binding.packageName}@${binding.version}\` after review.`,
+        step,
+        packageName: binding.packageName,
+        version: binding.version
+      }));
+    }
+  }
+  return diagnostics;
+}
+
+/**
+ * @param {string} spec
+ * @returns {{ packageName: string, version: string }}
+ */
+export function parseExtractorPolicyPin(spec) {
+  const separator = spec.lastIndexOf("@");
+  if (separator <= 0 || separator === spec.length - 1) {
+    throw new Error("Extractor policy pin requires a package name and extractor version, for example @topogram/extractor-node-cli@1.");
+  }
+  return {
+    packageName: spec.slice(0, separator),
+    version: spec.slice(separator + 1)
+  };
+}

package/src/generator/check.js

@@ -2,12 +2,18 @@
 
 import fs from "node:fs";
 import path from "node:path";
-import { createRequire } from "node:module";
 
 import {
   loadPackageGeneratorManifest,
   validateGeneratorManifest
 } from "./registry.js";
+import {
+  isPathSpec,
+  loadInstalledPackageAdapter,
+  loadLocalPackageAdapter,
+  packageNameFromSpec,
+  validateRelativeStringFileMap
+} from "../package-adapters/index.js";
 
 /**
  * @typedef {import("./registry.js").GeneratorManifest} GeneratorManifest
@@ -28,82 +34,6 @@ import {
  * @property {boolean} executesPackageCode
  */
 
-/**
- * @param {string} spec
- * @param {string} cwd
- * @returns {boolean}
- */
-function isPathSpec(spec, cwd) {
-  return spec.startsWith(".") || spec.startsWith("/") || fs.existsSync(path.resolve(cwd, spec));
-}
-
-/**
- * @param {string} spec
- * @returns {string}
- */
-function packageNameFromSpec(spec) {
-  if (spec.startsWith("@")) {
-    const versionIndex = spec.indexOf("@", 1);
-    return versionIndex > 0 ? spec.slice(0, versionIndex) : spec;
-  }
-  const versionIndex = spec.indexOf("@");
-  return versionIndex > 0 ? spec.slice(0, versionIndex) : spec;
-}
-
-/**
- * @param {any} moduleValue
- * @param {string|null|undefined} exportName
- * @returns {any}
- */
-function selectPackageExport(moduleValue, exportName) {
-  if (exportName) {
-    return moduleValue?.[exportName] || moduleValue?.default?.[exportName] || null;
-  }
-  return moduleValue?.default || moduleValue;
-}
-
-/**
- * @param {string} root
- * @param {GeneratorManifest} manifest
- * @returns {{ adapter: any|null, error: string|null }}
- */
-function loadLocalAdapter(root, manifest) {
-  try {
-    const packageJsonPath = path.join(root, "package.json");
-    const requireFromPackage = createRequire(packageJsonPath);
-    return {
-      adapter: selectPackageExport(requireFromPackage(root), manifest.export),
-      error: null
-    };
-  } catch (error) {
-    return {
-      adapter: null,
-      error: `Generator package export could not be loaded from '${root}': ${error instanceof Error ? error.message : String(error)}`
-    };
-  }
-}
-
-/**
- * @param {string} packageName
- * @param {string} rootDir
- * @param {GeneratorManifest} manifest
- * @returns {{ adapter: any|null, error: string|null }}
- */
-function loadInstalledAdapter(packageName, rootDir, manifest) {
-  try {
-    const requireFromRoot = createRequire(path.join(rootDir, "package.json"));
-    return {
-      adapter: selectPackageExport(requireFromRoot(packageName), manifest.export),
-      error: null
-    };
-  } catch (error) {
-    return {
-      adapter: null,
-      error: `Generator package '${packageName}' export could not be loaded from '${rootDir}': ${error instanceof Error ? error.message : String(error)}`
-    };
-  }
-}
-
 /**
  * @param {GeneratorManifest} manifest
  * @returns {Record<string, any>}
@@ -208,14 +138,12 @@ function validateSmokeResult(result) {
   if (!result.files || typeof result.files !== "object" || Array.isArray(result.files)) {
     return { ok: false, message: "generate(context) result must include a files object", smoke: null };
   }
-  for (const [filePath, content] of Object.entries(result.files)) {
-    const normalizedPath = typeof filePath === "string" ? path.normalize(filePath) : "";
-    if (typeof filePath !== "string" || filePath.length === 0 || path.isAbsolute(filePath) || normalizedPath === ".." || normalizedPath.startsWith(`..${path.sep}`)) {
-      return { ok: false, message: "generated file paths must be non-empty relative paths", smoke: null };
-    }
-    if (typeof content !== "string") {
-      return { ok: false, message: `generated file '${filePath}' content must be a string`, smoke: null };
-    }
+  const fileMapValidation = validateRelativeStringFileMap(result.files, {
+    filePathMessage: "generated file paths must be non-empty relative paths",
+    contentMessage: (filePath) => `generated file '${filePath}' content must be a string`
+  });
+  if (!fileMapValidation.ok) {
+    return { ok: false, message: fileMapValidation.message, smoke: null };
   }
   return {
     ok: true,
@@ -304,7 +232,11 @@ export function checkGeneratorPack(sourceSpec, options = {}) {
   }
 
   if (payload.source === "path") {
-    const loaded = loadLocalAdapter(payload.packageRoot || cwd, payload.manifest);
+    const loaded = loadLocalPackageAdapter({
+      packageRoot: payload.packageRoot || cwd,
+      exportName: payload.manifest.export,
+      packageLabel: "Generator package"
+    });
     adapter = loaded.adapter;
     if (loaded.error) {
       payload.errors.push(loaded.error);
@@ -312,7 +244,12 @@ export function checkGeneratorPack(sourceSpec, options = {}) {
       return payload;
     }
   } else if (payload.packageName) {
-    const loaded = loadInstalledAdapter(payload.packageName, cwd, payload.manifest);
+    const loaded = loadInstalledPackageAdapter({
+      packageName: payload.packageName,
+      rootDir: cwd,
+      exportName: payload.manifest.export,
+      packageLabel: "Generator package"
+    });
     adapter = loaded.adapter;
     if (loaded.error) {
       payload.errors.push(loaded.error);

package/src/generator/context/bundle.js

@@ -12,6 +12,7 @@ import {
   stableSortedStrings,
   summarizeById,
   summarizeDocsByIds,
+  summarizeJourneyLikeByIds,
   summarizeStatementsByIds,
   verificationIdsForTarget
 } from "./shared.js";
@@ -89,9 +90,12 @@ function uiBundle(graph) {
       .map((doc) => doc.id)
   );
   const journeys = stableSortedStrings(
-    (graph.docs || [])
-      .filter((doc) => doc.kind === "journey" && (doc.relatedProjections || []).some((id) => projections.includes(id)))
-      .map((doc) => doc.id)
+    [
+      ...(graph.byKind.journey || []),
+      ...(graph.docs || []).filter((doc) => doc.kind === "journey")
+    ]
+      .filter((journey) => (journey.relatedProjections || []).some((id) => projections.includes(id)))
+      .map((journey) => journey.id)
   );
   const rules = stableSortedStrings(capabilities.flatMap((capabilityId) => {
     return (graph.byKind.rule || [])
@@ -112,7 +116,7 @@ function uiBundle(graph) {
       projections: summarizeStatementsByIds(graph, projections),
       capabilities: summarizeStatementsByIds(graph, capabilities),
       workflows: summarizeDocsByIds(graph, workflows),
-      journeys: summarizeDocsByIds(graph, journeys),
+      journeys: summarizeJourneyLikeByIds(graph, journeys),
       rules: summarizeStatementsByIds(graph, rules)
     },
     dependencies: {
@@ -131,7 +135,7 @@ function uiBundle(graph) {
     review_boundaries: {
       projections: projections.map((id) => ({ id, review_boundary: summarizeById(graph, id)?.reviewBoundary || null })),
       workflows: workflows.map((id) => ({ id, review_boundary: reviewBoundaryForWorkflowDoc((graph.docs || []).find((doc) => doc.id === id)) })),
-      journeys: journeys.map((id) => ({ id, review_boundary: reviewBoundaryForJourneyDoc((graph.docs || []).find((doc) => doc.id === id)) }))
+      journeys: journeys.map((id) => ({ id, review_boundary: reviewBoundaryForJourneyDoc(summarizeById(graph, id) || null) }))
     }
   };
 }
@@ -186,7 +190,10 @@ function dbBundle(graph) {
 function maintainedAppBundle(graph) {
   const proofStories = maintainedProofMetadata(graph);
   const projections = stableSortedStrings((graph.byKind.projection || []).map((item) => item.id));
-  const journeys = stableSortedStrings((graph.docs || []).filter((doc) => doc.kind === "journey").map((doc) => doc.id));
+  const journeys = stableSortedStrings([
+    ...(graph.byKind.journey || []).map((item) => item.id),
+    ...(graph.docs || []).filter((doc) => doc.kind === "journey").map((doc) => doc.id)
+  ]);
   const verifications = stableSortedStrings((graph.byKind.verification || []).map((item) => item.id));
   const maintainedFiles = stableSortedStrings(proofStories.flatMap((item) => item.maintainedFiles || []));
   const emittedDependencies = stableSortedStrings(proofStories.flatMap((item) => item.emittedDependencies || []));
@@ -215,7 +222,7 @@ function maintainedAppBundle(graph) {
     },
     included_surfaces: {
       projections: summarizeStatementsByIds(graph, projections),
-      journeys: summarizeDocsByIds(graph, journeys),
+      journeys: summarizeJourneyLikeByIds(graph, journeys),
       maintained_files_in_scope: maintainedFiles,
       emitted_artifact_dependencies: emittedDependencies,
       human_owned_seams: humanOwnedSeams,

package/src/generator/context/diff.js

@@ -16,10 +16,17 @@ import {
 import { defaultOwnershipBoundary } from "../../policy/review-boundaries.js";
 
 function normalizeTargetMap(graph, kind) {
-  if (kind === "workflow" || kind === "journey") {
+  if (kind === "workflow") {
     const docs = (graph.docs || []).filter((doc) => doc.kind === kind);
     return new Map(docs.map((doc) => [doc.id, summarizeDoc(doc)]));
   }
+  if (kind === "journey") {
+    const journeys = [
+      ...(graph.byKind?.journey || []).map((statement) => summarizeStatement(statement)),
+      ...(graph.docs || []).filter((doc) => doc.kind === kind).map((doc) => summarizeDoc(doc))
+    ];
+    return new Map(journeys.map((journey) => [journey.id, journey]));
+  }
 
   return new Map(((graph.byKind[kind] || []).map((statement) => [statement.id, summarizeStatement(statement)])));
 }

package/src/generator/context/digest.js

@@ -138,6 +138,11 @@ function journeyDigest(graph, journey) {
       id: journey.id
     },
     summary: summarizeById(graph, journey.id),
+    steps: (journey.steps || []).map((step) => ({
+      id: step.id,
+      intent: step.intent || null,
+      after: [...(step.after || [])]
+    })),
     verifications: verificationIdsForTarget(graph, [journey.id, ...(journey.relatedCapabilities || [])]),
     review_boundary: reviewBoundaryForJourneyDoc(journey),
     ownership_boundary: defaultOwnershipBoundary()
@@ -174,7 +179,11 @@ export function generateContextDigest(graph) {
     files[`projections/${projection.id}.context-digest.json`] = projectionDigest(graph, projection);
   }
 
-  for (const journey of (graph.docs || []).filter((doc) => doc.kind === "journey").sort((a, b) => a.id.localeCompare(b.id))) {
+  const journeys = [
+    ...(graph.byKind.journey || []),
+    ...(graph.docs || []).filter((doc) => doc.kind === "journey")
+  ].sort((a, b) => a.id.localeCompare(b.id));
+  for (const journey of journeys) {
     files[`journeys/${journey.id}.context-digest.json`] = journeyDigest(graph, journey);
   }
 

package/src/generator/context/shared/domain-sdlc.js

@@ -287,9 +287,13 @@ export function getWorkflowDoc(graph, workflowId) {
  * @returns {any}
  */
 export function getJourneyDoc(graph, journeyId) {
+  const journey = (graph.byKind?.journey || []).find(/** @param {any} item */ (item) => item.id === journeyId);
+  if (journey) {
+    return journey;
+  }
   const doc = (graph.docs || []).find(/** @param {any} item */ (item) => item.kind === "journey" && item.id === journeyId);
   if (!doc) {
-    throw new Error(`No journey doc found with id '${journeyId}'`);
+    throw new Error(`No journey found with id '${journeyId}'`);
   }
   return doc;
 }

package/src/generator/context/shared/relationships.js

@@ -45,10 +45,13 @@ export function verificationsFor(graph, predicate) {
  * @returns {any}
  */
 export function relatedJourneysForCapability(graph, capabilityId) {
-  return relatedDocs(
-    graph,
-    /** @param {import("./types.d.ts").ContextDoc} doc */ (doc) => doc.kind === "journey" && (doc.relatedCapabilities || []).includes(capabilityId)
-  );
+  return [
+    ...(graph.byKind?.journey || []).filter(/** @param {any} journey */ (journey) => (journey.relatedCapabilities || []).includes(capabilityId)),
+    ...relatedDocs(
+      graph,
+      /** @param {import("./types.d.ts").ContextDoc} doc */ (doc) => doc.kind === "journey" && (doc.relatedCapabilities || []).includes(capabilityId)
+    )
+  ];
 }
 
 /**
@@ -395,6 +398,15 @@ export function summarizeDocsByIds(graph, ids) {
     .map(summarizeDoc);
 }
 
+/**
+ * @param {import("./types.d.ts").ContextGraph} graph
+ * @param {Iterable<string>} ids
+ * @returns {any}
+ */
+export function summarizeJourneyLikeByIds(graph, ids) {
+  return stableSortedStrings(ids).map(/** @param {string} id */ (id) => summarizeById(graph, id)).filter(Boolean);
+}
+
 /**
  * @param {import("./types.d.ts").ContextGraph} graph
  * @returns {any}
@@ -403,7 +415,10 @@ export function workspaceInventory(graph) {
   return {
     capabilities: stableSortedStrings((graph.byKind.capability || []).map(/** @param {any} item */ (item) => item.id)),
     workflows: stableSortedStrings((graph.docs || []).filter(/** @param {import("./types.d.ts").ContextDoc} doc */ (doc) => doc.kind === "workflow").map(/** @param {import("./types.d.ts").ContextDoc} doc */ (doc) => doc.id)),
-    journeys: stableSortedStrings((graph.docs || []).filter(/** @param {import("./types.d.ts").ContextDoc} doc */ (doc) => doc.kind === "journey").map(/** @param {import("./types.d.ts").ContextDoc} doc */ (doc) => doc.id)),
+    journeys: stableSortedStrings([
+      ...(graph.byKind.journey || []).map(/** @param {any} item */ (item) => item.id),
+      ...(graph.docs || []).filter(/** @param {import("./types.d.ts").ContextDoc} doc */ (doc) => doc.kind === "journey").map(/** @param {import("./types.d.ts").ContextDoc} doc */ (doc) => doc.id)
+    ]),
     entities: stableSortedStrings((graph.byKind.entity || []).map(/** @param {any} item */ (item) => item.id)),
     projections: stableSortedStrings((graph.byKind.projection || []).map(/** @param {any} item */ (item) => item.id)),
     widgets: stableSortedStrings((graph.byKind.widget || []).map(/** @param {any} item */ (item) => item.id)),

package/src/generator/context/shared/summaries.js

@@ -97,6 +97,30 @@ export function summarizeJourneyDoc(doc) {
   };
 }
 
+/**
+ * @param {import("./types.d.ts").ContextStatement} journey
+ * @returns {any}
+ */
+export function summarizeJourney(journey) {
+  return {
+    id: journey.id,
+    kind: journey.kind,
+    name: journey.name || journey.id,
+    description: journey.description || null,
+    status: journey.status || null,
+    goal: journey.goal || null,
+    actors: stableSortedStrings(journey.actors || []),
+    relatedCapabilities: stableSortedStrings(journey.relatedCapabilities || []),
+    relatedWorkflows: stableSortedStrings(journey.relatedWorkflows || []),
+    relatedProjections: stableSortedStrings(journey.relatedProjections || []),
+    relatedWidgets: stableSortedStrings(journey.relatedWidgets || []),
+    stepCount: (journey.steps || []).length,
+    alternateCount: (journey.alternates || []).length,
+    reviewBoundary: reviewBoundaryForJourneyDocPolicy(journey),
+    ownership_boundary: defaultOwnershipBoundary()
+  };
+}
+
 /**
  * @param {import("./types.d.ts").ContextStatement} statement
  * @returns {any}
@@ -163,6 +187,8 @@ export function summarizeStatement(statement) {
       };
     case "widget":
       return summarizeComponent(statement);
+    case "journey":
+      return summarizeJourney(statement);
     case "shape":
       return {
         id: statement.id,

package/src/generator/context/shared.d.ts

@@ -34,6 +34,7 @@ export function summarizeById(...args: any[]): any;
 export function summarizeDocsByIds(...args: any[]): any;
 export function summarizeDocument(...args: any[]): any;
 export function summarizeDomain(...args: any[]): any;
+export function summarizeJourneyLikeByIds(...args: any[]): any;
 export function summarizePitch(...args: any[]): any;
 export function summarizePlan(...args: any[]): any;
 export function summarizeProjection(...args: any[]): any;

package/src/generator/context/shared.js

@@ -20,6 +20,7 @@ export {
   summarizeById,
   summarizeStatementsByIds,
   summarizeDocsByIds,
+  summarizeJourneyLikeByIds,
   workspaceInventory
 } from "./shared/relationships.js";
 export {

package/src/generator/context/slice/core.js

@@ -20,6 +20,7 @@ import {
   relatedWorkflowDocsForCapability,
   summarizeById,
   summarizeDocsByIds,
+  summarizeJourneyLikeByIds,
   summarizeProjection,
   summarizeStatementsByIds,
   verificationIdsForTarget,
@@ -87,7 +88,7 @@ function capabilitySlice(graph, capabilityId) {
       entities: summarizeStatementsByIds(graph, entities),
       rules: summarizeStatementsByIds(graph, rules),
       workflows: summarizeDocsByIds(graph, workflows),
-      journeys: summarizeDocsByIds(graph, journeys),
+      journeys: summarizeJourneyLikeByIds(graph, journeys),
       projections: summarizeStatementsByIds(graph, projections)
     },
     verification: summarizeStatementsByIds(graph, verifications),
@@ -118,9 +119,12 @@ function workflowSlice(graph, workflowId) {
     ];
   }))].sort();
   const rules = [...new Set(capabilities.flatMap(/** @param {string} capabilityId */ (capabilityId) => relatedRulesForTarget(graph, capabilityId)))].sort();
-  const journeys = (graph.docs || [])
-    .filter(/** @param {any} doc */ (doc) => doc.kind === "journey" && (doc.relatedWorkflows || []).includes(workflowId))
-    .map(/** @param {any} doc */ (doc) => doc.id)
+  const journeys = [
+    ...(graph.byKind?.journey || []),
+    ...(graph.docs || []).filter(/** @param {any} doc */ (doc) => doc.kind === "journey")
+  ]
+    .filter(/** @param {any} journey */ (journey) => (journey.relatedWorkflows || []).includes(workflowId))
+    .map(/** @param {any} journey */ (journey) => journey.id)
     .sort();
   const verifications = verificationIdsForTarget(graph, [...capabilities, ...entities, workflowId]);
 
@@ -143,7 +147,7 @@ function workflowSlice(graph, workflowId) {
       capabilities: summarizeStatementsByIds(graph, capabilities),
       entities: summarizeStatementsByIds(graph, entities),
       rules: summarizeStatementsByIds(graph, rules),
-      journeys: summarizeDocsByIds(graph, journeys)
+      journeys: summarizeJourneyLikeByIds(graph, journeys)
     },
     verification: summarizeStatementsByIds(graph, verifications),
     verification_targets: recommendedVerificationTargets(graph, [...capabilities, ...entities, workflowId], {