@sous-io/sous 0.2.32 → 0.2.33

package/src/commands/namespace/show.ts

@@ -85,8 +85,8 @@ export default class NamespaceShow extends BaseCommand {
     });
 
     const detail = flags.installed
-      ? describeInstalled(inputs, args.ref, describeNamespace, "namespace")
-      : describeNamespace(inputs, args.ref);
+      ? await describeInstalled(inputs, args.ref, describeNamespace, "namespace")
+      : await describeNamespace(inputs, args.ref);
 
     heading(`The namespace ${detail.namespace}`);
     blankLine();

package/src/commands/recipe/show.ts

@@ -34,6 +34,7 @@ import {
   type RecipeVersionListing,
 } from "../../lib/repos/catalog.js";
 import { PROJECT_REQUESTER } from "../../lib/repos/resolver.js";
+import { recipeRef } from "../../services/ref-resolver/index.js";
 import { describeDeclaration, describeDependencyKind } from "../../lib/repos/declarations.js";
 import { formatQuestionPlan } from "../../lib/vars/question-plan.js";
 import { describeError } from "../../lib/repos/release/validate.js";
@@ -156,8 +157,8 @@ export default class RecipeShow extends BaseCommand {
     });
 
     const detail = flags.installed
-      ? describeInstalled(inputs, args.ref, describeRecipe, "recipe")
-      : describeRecipe(inputs, args.ref);
+      ? await describeInstalled(inputs, args.ref, describeRecipe, "recipe")
+      : await describeRecipe(inputs, args.ref);
 
     heading(detail.key);
     blankLine();
@@ -236,12 +237,10 @@ export default class RecipeShow extends BaseCommand {
     }
     try {
       return await service.previewSubscription(
-        {
+        recipeRef(detail.namespace, detail.name, {
           repo: detail.repo,
-          namespace: detail.namespace,
-          recipe: detail.name,
           range: detail.describing,
-        },
+        }),
         {
           indexes: new Map(inputs.repos.map((repo) => [repo.name, repo.index])),
           ...(semver.prerelease(detail.describing) === null ? {} : { prerelease: true }),
@@ -409,9 +408,7 @@ export default class RecipeShow extends BaseCommand {
       destination:
         entry.destinations.length > 0
           ? entry.destinations.join(", ")
-          : entry.kind === "config"
-            ? "loaded as a config layer, so nothing is written"
-            : `nowhere: this project sets no 'recipeOutputs.${entry.kind}' directory`,
+          : noDestinationText(entry.kind),
     }));
 
     for (const line of renderTable(CONTENT_COLUMNS, rows, { indent: INDENT })) {
@@ -420,3 +417,23 @@ export default class RecipeShow extends BaseCommand {
   }
 }
 
+/**
+ * What to say where a content kind has no destination directory: each kind
+ * reaches the project in its own way.
+ *
+ * noDestinationText("memories"); // -> "included in an agent's instructions by an include line, so nothing is written"
+ *
+ * @param kind - The content kind.
+ */
+function noDestinationText(kind: string): string {
+  switch (kind) {
+    case "config":
+      return "loaded as a config layer, so nothing is written";
+    case "memories":
+      return "reaches an agent through an include line in its instructions, so nothing is written";
+    case "skills":
+      return "nowhere: this project sets no 'recipes.skills.outputs' directory";
+    default:
+      return `nowhere: this project has no destination for ${kind} yet`;
+  }
+}

package/src/commands/repo/contribute.ts

@@ -3,11 +3,14 @@ import { BaseCommand } from "../../base-command.js";
 import { ConfigError } from "../../lib/errors.js";
 import { nonInteractiveError } from "../../lib/interactive.js";
 import {
-  SousScope,
-  findReference,
-  pickReference,
-  type ReferenceRepo,
-} from "../../lib/refs/index.js";
+  CatalogLookup,
+  RefPickArguments,
+  RefResolveArguments,
+  repoOf,
+  sharedRefPicker,
+  sharedRefResolver,
+  type CatalogRepo,
+} from "../../services/ref-resolver/index.js";
 import {
   assessPendingWork,
   assessProposal,
@@ -373,27 +376,33 @@ export default class RepoContribute extends BaseCommand {
       shellEnv: this.shellEnv,
     });
 
-    const repos: ReferenceRepo[] = service.cachedReferenceRepos();
+    const repos: CatalogRepo[] = service.cachedReferenceRepos();
 
-    const matches = findReference(
-      ref,
-      [SousScope.Repository, SousScope.Namespace, SousScope.Recipe],
-      { repos }
+    const { refs } = await sharedRefResolver().resolve(
+      new RefResolveArguments({
+        input: ref,
+        lookup: new CatalogLookup(repos),
+        kinds: ["repo", "namespace", "recipe"],
+        refusedIsEmpty: true,
+      })
     );
 
-    const chosen = await pickReference(matches, {
-      search: ref,
-      interactive: this.interactive,
-      acceptFirst,
-      prompt: `Which '${ref}' do you want to contribute to?`,
-      details: [
-        "  No trusted repository, namespace or recipe has that name.",
-        repos.length === 0
-          ? "  This project trusts no repositories."
-          : `  This project trusts: ${repos.map((entry) => entry.name).join(", ")}.`,
-      ],
-    });
-    return chosen.repo ?? chosen.key;
+    const chosen = await sharedRefPicker().pick(
+      refs,
+      new RefPickArguments({
+        search: ref,
+        interactive: this.interactive,
+        acceptFirst,
+        prompt: `Which '${ref}' do you want to contribute to?`,
+        details: [
+          "  No trusted repository, namespace or recipe has that name.",
+          repos.length === 0
+            ? "  This project trusts no repositories."
+            : `  This project trusts: ${repos.map((entry) => entry.name).join(", ")}.`,
+        ],
+      })
+    );
+    return chosen.kind === "repo" ? chosen.name! : repoOf(chosen)!.name!;
   }
 
   // --- The link ---------------------------------------------------------------------------------

package/src/commands/repo/gc.ts

@@ -17,7 +17,7 @@ import { subscriptionServiceFor } from "../../lib/repos/subscription-service.js"
 import { resolveStoreSettings } from "../../lib/repos/store/settings.js";
 import type { StoreKey } from "../../lib/repos/store/contract.js";
 import { renderTable, type TableColumn } from "../../utils/table.js";
-import { splitRecipeKey } from "../../lib/refs/parse.js";
+import { splitRecipeKey } from "../../services/ref-resolver/index.js";
 import {
   blankLine,
   dryRunNotice,

package/src/commands/repo/remove.ts

@@ -105,7 +105,7 @@ export default class RepoRemove extends BaseCommand {
       yes: flags.yes,
       dryRun,
       // The output files a removed recipe wrote can only be named once the
-      // `recipeOutputs` destinations have had their variables substituted.
+      // `recipes.skills.outputs` destinations have had their variables substituted.
       scope: resolveRootScope(this.settings, this.configContext),
     });
 

package/src/commands/repo/search.ts

@@ -21,7 +21,7 @@ import {
 } from "../../lib/repos/catalog-display.js";
 import { readEffectiveLinks } from "../../lib/repos/links.js";
 import { renderTable, type TableColumn } from "../../utils/table.js";
-import { namespaceOfKey } from "../../lib/refs/parse.js";
+import { namespaceOfKey } from "../../services/ref-resolver/index.js";
 import { browsingFlags } from "../../utils/flags.js";
 import {
   blankLine,

package/src/commands/vars/ask.ts

@@ -5,7 +5,7 @@
  * answers in `.sous/.env` or `.sous/.env.local`. By default it asks only what
  * is unanswered or no longer fits; `--all` asks everything again.
  *
- * The optional name is a reference, resolved through `src/lib/refs/` exactly as
+ * The optional name is a reference, resolved through `src/services/ref-resolver/` exactly as
  * every other command resolves one. It may name a variable, an environment
  * variable that answers one, a recipe, a namespace or a repository, at any
  * level of qualification; naming anything larger than a variable asks every
@@ -38,18 +38,22 @@ import { Args, Flags } from "@oclif/core";
 import { BaseCommand } from "../../base-command.js";
 import { ConfigError } from "../../lib/errors.js";
 import {
-  ALL_SCOPES,
-  SousScope,
-  findNamespace,
-  findReference,
-  findRepository,
-  findVariable,
-  pickReference,
-  referenceContextFromVariables,
-  variableReferenceKey,
-  type ReferenceMatch,
-  type ReferenceRepo,
-} from "../../lib/refs/index.js";
+  ChainedLookup,
+  RefPickArguments,
+  RefResolveArguments,
+  VariableLookup,
+  namespaceOf,
+  recipeOf,
+  refKey,
+  repoOf,
+  sharedRefPicker,
+  sharedRefResolver,
+  variableRefOf,
+  type CatalogRepo,
+  type RefKind,
+  type SousRef,
+} from "../../services/ref-resolver/index.js";
+import { EnvVarLookup } from "../../services/ref-resolver/lookups/env-var-lookup.js";
 import { subscriptionServiceFor } from "../../lib/repos/subscription-service.js";
 import {
   applyProvidedAnswers,
@@ -269,10 +273,10 @@ export default class VarsAsk extends BaseCommand {
     defined: DefinedVariable[],
     ladder: LadderContext,
     selection: Selection,
-    trusted: ReferenceRepo[] = []
+    trusted: CatalogRepo[] = []
   ): Promise<string[] | undefined> {
-    const contextOf = (pool: DefinedVariable[]) =>
-      referenceContextFromVariables(pool, ladder, trusted);
+    const lookupOf = (pool: DefinedVariable[]) =>
+      new ChainedLookup(new VariableLookup(pool, trusted), new EnvVarLookup(pool, ladder));
     const { name, repo, namespace, vars } = selection;
     if (name === undefined && repo === undefined && namespace === undefined && vars === undefined) {
       return undefined;
@@ -281,36 +285,24 @@ export default class VarsAsk extends BaseCommand {
     let pool = defined;
 
     if (repo !== undefined) {
-      const match = await this.pick(findRepository(repo, contextOf(pool)), repo, selection);
-      pool = pool.filter((entry) => entry.recipe.repo === match.repo);
+      const match = await this.pick(repo, lookupOf(pool), ["repo"], selection);
+      pool = pool.filter((entry) => entry.recipe.repo === repoOf(match)?.name);
     }
 
     if (namespace !== undefined) {
-      const match = await this.pick(
-        findNamespace(namespace, contextOf(pool)),
-        namespace,
-        selection
-      );
+      const match = await this.pick(namespace, lookupOf(pool), ["namespace"], selection);
       pool = narrowTo(pool, match);
     }
 
     if (name !== undefined) {
-      const match = await this.pick(
-        findReference(name, ALL_SCOPES, contextOf(pool)),
-        name,
-        selection
-      );
+      const match = await this.pick(name, lookupOf(pool), undefined, selection);
       pool = narrowTo(pool, match);
     }
 
     if (vars !== undefined) {
       const chosen: DefinedVariable[] = [];
       for (const wanted of vars) {
-        const match = await this.pick(
-          findVariable(wanted, contextOf(pool)),
-          wanted,
-          selection
-        );
+        const match = await this.pick(wanted, lookupOf(pool), ["variable", "envVar"], selection);
         chosen.push(...narrowTo(pool, match));
       }
       pool = chosen;
@@ -323,7 +315,7 @@ export default class VarsAsk extends BaseCommand {
       );
     }
 
-    return [...new Set(pool.map(variableReferenceKey))];
+    return [...new Set(pool.map((entry) => refKey(variableRefOf(entry))))];
   }
 
   /**
@@ -331,7 +323,7 @@ export default class VarsAsk extends BaseCommand {
    * indexes alone. A project whose repositories cannot be read this way still
    * answers every other form of reference, so a failure here is an empty list.
    */
-  private trustedRepos(): ReferenceRepo[] {
+  private trustedRepos(): CatalogRepo[] {
     try {
       return subscriptionServiceFor({
         configContext: this.configContext,
@@ -347,38 +339,67 @@ export default class VarsAsk extends BaseCommand {
    * Settles which of the things a reference could have meant this run proceeds
    * with, through the rule every command shares.
    *
-   * @param matches - What the reference could have meant, in listing order.
    * @param search - The reference exactly as it was written.
+   * @param lookup - What the reference is searched in.
+   * @param kinds - The kinds of ref this step accepts; every kind when left out.
    * @param selection - The selection, read for `--accept-first`.
    */
   private async pick(
-    matches: ReferenceMatch[],
     search: string,
+    lookup: ChainedLookup,
+    kinds: readonly RefKind[] | undefined,
     selection: Selection
-  ): Promise<ReferenceMatch> {
-    return pickReference(matches, {
-      search,
-      interactive: this.interactive,
-      acceptFirst: selection.acceptFirst,
-      announce: false,
-      details: [SEE_ALL],
-    });
+  ): Promise<SousRef> {
+    const { refs } = await sharedRefResolver().resolve(
+      new RefResolveArguments({
+        input: search,
+        lookup,
+        refusedIsEmpty: true,
+        ...(kinds === undefined ? {} : { kinds }),
+      })
+    );
+    // A name that answers several variables is one candidate per variable, so
+    // choosing between them is the same question as choosing between variables.
+    const candidates = refs.flatMap((ref) =>
+      ref.kind === "envVar" && (ref.variables?.length ?? 0) > 1
+        ? ref.variables!.map((variable): SousRef => ({ ...ref, variables: [variable] }))
+        : [ref]
+    );
+    return sharedRefPicker().pick(
+      candidates,
+      new RefPickArguments({
+        search,
+        interactive: this.interactive,
+        acceptFirst: selection.acceptFirst,
+        announce: false,
+        details: [SEE_ALL],
+      })
+    );
   }
 }
 
-/** The variables one match covers: a whole repository, namespace, recipe, or one variable. */
-function narrowTo(pool: DefinedVariable[], match: ReferenceMatch): DefinedVariable[] {
+/**
+ * The variables one ref covers: a whole repository, namespace, recipe, or one
+ * variable, or the variable an environment variable name answers.
+ */
+function narrowTo(pool: DefinedVariable[], match: SousRef): DefinedVariable[] {
+  const target = match.kind === "envVar" ? match.variables?.[0] : match;
+  if (target === undefined) return [];
+  const repo = repoOf(target)?.name;
+  const namespace = namespaceOf(target)?.name;
+  const recipe = recipeOf(target)?.name;
+
   return pool.filter((entry) => {
-    if (match.repo !== undefined && entry.recipe.repo !== match.repo) return false;
-    if (match.scope === SousScope.Repository) return true;
+    if (repo !== undefined && entry.recipe.repo !== repo) return false;
+    if (target.kind === "repo") return true;
 
-    if (match.namespace !== undefined && entry.recipe.namespace !== match.namespace) return false;
-    if (match.scope === SousScope.Namespace) return true;
+    if (namespace !== undefined && entry.recipe.namespace !== namespace) return false;
+    if (target.kind === "namespace") return true;
 
-    if (match.recipe !== undefined && entry.recipe.name !== match.recipe) return false;
-    if (match.scope === SousScope.Recipe) return true;
+    if (recipe !== undefined && entry.recipe.name !== recipe) return false;
+    if (target.kind === "recipe") return true;
 
-    return entry.definition.name === match.variable;
+    return target.kind === "variable" && entry.definition.name === target.name;
   });
 }
 

package/src/lib/build-service.ts

@@ -2,11 +2,11 @@ import path from "node:path";
 import fs from "node:fs";
 import type { ConfigContext, Settings } from "./settings.js";
 import { resolveAliases, resolveCompilation, resolveRootScope } from "./settings.js";
-import { resolveIncludeCandidates } from "./include-resolver.js";
+import { resolveIncludeFiles, type ViewMap } from "./include-resolver.js";
 import type { NamespaceResolver } from "./repos/namespace-resolver.js";
 import { createProjectNamespaceResolver } from "./repos/locked-namespace-resolver.js";
 import { buildRecipeTargets, type RecipeTargets } from "./repos/recipe-targets.js";
-import { CompilationService, resolveOutputPath } from "./markdown-compiler.js";
+import { CompilationService, INCLUDE_LINE_PATTERN, resolveOutputPath } from "./markdown-compiler.js";
 import type { CompilationConfig, CompilationTarget } from "./markdown-compiler.js";
 import { StateService } from "./state.js";
 import { isProtectedPath } from "./state.js";
@@ -19,7 +19,9 @@ import {
   unansweredWarning,
   type RecipeAnswers,
 } from "./vars/answers.js";
-import { footer, heading, log, warning } from "../utils/formatting.js";
+import { BULLET, footer, heading, log, warning } from "../utils/formatting.js";
+import { sharedHashNames } from "../services/ref-resolver/index.js";
+import { listMemories, type MemoryFile } from "./repos/recipe-memories.js";
 
 export type BuildOptions = {
   strict?: boolean;
@@ -146,6 +148,54 @@ export function withRecipeTargets(
   return { ...config, targets: [...config.targets, ...recipes.targets] };
 }
 
+/**
+ * The memories an active recipe publishes that no output of the build included
+ * by any route (an exact path, a glob or the `#memories` view). Recipes under
+ * `recipes.memories.exclude` are never listed.
+ *
+ * @param settings - The merged project config, for `recipes.memories`.
+ * @param sousDir - The project's `.sous/` directory.
+ * @param included - Every file the compile read, as real paths.
+ */
+export function unincludedMemories(
+  settings: Settings,
+  sousDir: string,
+  included: ReadonlySet<string>
+): MemoryFile[] {
+  const memories = settings.recipes?.memories;
+  return listMemories({ sousDir, first: memories?.first, exclude: memories?.exclude }).filter(
+    (memory) => !included.has(realPath(memory.file))
+  );
+}
+
+/** The path with symbolic links resolved, or the path itself when it cannot be read. */
+function realPath(filePath: string): string {
+  try {
+    return fs.realpathSync(filePath);
+  } catch {
+    return filePath;
+  }
+}
+
+/**
+ * The warning for memories no output included, or undefined when there are none.
+ *
+ * @param missing - What {@link unincludedMemories} found.
+ */
+export function unincludedMemoriesWarning(missing: readonly MemoryFile[]): string | undefined {
+  if (missing.length === 0) return undefined;
+  const noun = missing.length === 1 ? "memory" : "memories";
+  return (
+    `${missing.length} ${noun} published by your subscribed recipes ${
+      missing.length === 1 ? "is" : "are"
+    } not included in any output, so no agent will read ${missing.length === 1 ? "it" : "them"}:\n` +
+    missing.map((memory) => `${BULLET} ${memory.recipe}: ${memory.relative}`).join("\n") +
+    `\nTo include every memory, add the line "@#memories/**/*.md" to your project's instruction ` +
+    `source (the file your AGENTS.md or CLAUDE.md is built from). To leave a recipe's memories out on purpose, ` +
+    `list the recipe in "recipes.memories.exclude" in your sous config.`
+  );
+}
+
 /**
  * The directories a build's deletions must never reach into, for the project the
  * options describe. Empty when the caller gave no config context, which is the
@@ -193,6 +243,7 @@ function collectIncludeGraph(
     aliases?: Record<string, string[]>;
     scope?: Record<string, string>;
     namespaceResolver?: NamespaceResolver;
+    views?: ViewMap;
   } = {},
   visited: Set<string> = new Set()
 ): Set<string> {
@@ -208,21 +259,23 @@ function collectIncludeGraph(
     return visited;
   }
 
-  const includePattern = /^@([~a-zA-Z0-9_${}][a-zA-Z0-9_\-/.:${}]*\.md)$/gm;
   const baseDir = path.dirname(filePath);
-  let match: RegExpExecArray | null;
 
-  while ((match = includePattern.exec(content)) !== null) {
-    const includePath = match[1].trim();
-    const candidates = resolveIncludeCandidates(includePath, {
+  for (const line of content.split("\n")) {
+    const match = INCLUDE_LINE_PATTERN.exec(line.trimEnd());
+    if (match === null) continue;
+    const { files, candidates } = resolveIncludeFiles(match[1].trim(), {
       aliases: resolveOpts.aliases,
+      views: resolveOpts.views,
       scope: resolveOpts.scope,
       baseDir,
       namespaceResolver: resolveOpts.namespaceResolver,
       fromFile: filePath,
     });
-    const fullPath = candidates.find((c) => fs.existsSync(c)) ?? candidates[0];
-    collectIncludeGraph(fullPath, resolveOpts, visited);
+    // A file that does not exist yet is still part of the graph, as its first candidate.
+    for (const fullPath of files.length > 0 ? files : candidates.slice(0, 1)) {
+      collectIncludeGraph(fullPath, resolveOpts, visited);
+    }
   }
 
   return visited;
@@ -248,6 +301,7 @@ export function findAffectedTargets(
   return config.targets.filter(target => {
     const graph = collectIncludeGraph(target.rootInputPath, {
       aliases: config.aliases,
+      views: config.views,
       scope: config.includeScope,
       namespaceResolver,
     });
@@ -313,12 +367,23 @@ export class BuildService {
       const recipes = resolveRecipeTargets(settings, rootScope, options.configContext, answers);
       for (const notice of recipes.warnings) warning(notice);
 
-      const config = withRecipeTargets(
+      const withoutViews = withRecipeTargets(
         resolveCompilation(settings, rootScope),
         recipes,
         settings,
         rootScope
       );
+      // The files each view lists (`#memories`), worked out once per build.
+      const config: CompilationConfig | null =
+        withoutViews === null || options.configContext === undefined
+          ? withoutViews
+          : {
+              ...withoutViews,
+              views: sharedHashNames().viewMap({
+                sousDir: options.configContext.sousDir,
+                settings,
+              }),
+            };
 
       if (config) {
         let effectiveConfig: CompilationConfig = config;
@@ -351,6 +416,15 @@ export class BuildService {
           });
           const compileOk = await compiler.compile(effectiveConfig, stateFilePath);
           if (!compileOk) success = false;
+
+          // Only a full build knows every route an include can take, so only a
+          // full build that compiled cleanly checks that every memory got in.
+          if (compileOk && options.configContext !== undefined) {
+            const notice = unincludedMemoriesWarning(
+              unincludedMemories(settings, options.configContext.sousDir, compiler.includedFiles())
+            );
+            if (notice !== undefined) warning(notice);
+          }
         }
       }
     }

package/src/lib/config-schema.ts

@@ -19,6 +19,7 @@
 
 import { z } from "zod";
 import { ConfigError } from "./errors.js";
+import { compileRecipeKeyMatcher } from "./repos/recipe-key-matcher.js";
 import { repoUrlSchema, semverRangeSchema } from "./repos/formats/common.js";
 import { REF_KEY_PATTERN, REPO_NAME_PATTERN } from "./repos/formats/patterns.js";
 import type { Settings } from "./settings.js";
@@ -174,27 +175,66 @@ const storeSchema = z
   .strict();
 
 /**
- * Where the files a subscribed recipe contributes are written, one list of
- * destination directories per content kind. Each destination is `${var}`
- * substituted like any other config path, and a kind may name several so the
- * same recipe feeds more than one agent directory (`.claude/skills` and
- * `.codex/skills`, say).
+ * One list of recipe keys: each entry is a glob over `namespace/recipe` keys, or
+ * a regular expression written between two slashes (`/^tool-usage\//`). A
+ * regular expression that does not compile is an error naming the key and the
+ * value.
+ */
+function recipeKeyListSchema(where: string) {
+  return z.array(z.string()).superRefine((entries, context) => {
+    entries.forEach((entry, index) => {
+      try {
+        compileRecipeKeyMatcher([entry], `${where}[${index}]`);
+      } catch (error) {
+        context.addIssue({
+          code: "custom",
+          path: [index],
+          message: error instanceof Error ? error.message : String(error),
+        });
+      }
+    });
+  });
+}
+
+/**
+ * What a project does with the content kinds the subscribed recipes publish, one
+ * block per kind.
  *
- * Only `skills` has a default: `<project root>/.claude/skills`, the project root
- * being the parent of the discovered `.sous/` directory. A kind with no
- * destination is skipped, with one warning naming this key, because sous cannot
- * guess where a project wants its memories or its prompts. A recipe's `config`
- * contents are not listed here; they are loaded as config layers rather than
- * written anywhere.
+ * `skills.outputs` lists the destination directories recipe skill bundles are
+ * written into. Each is `${var}` substituted like any other config path, and
+ * several may be named so the same recipe feeds more than one agent directory
+ * (`.claude/skills` and `.codex/skills`, say). The default is
+ * `<project root>/.claude/skills`, the project root being the parent of the
+ * discovered `.sous/` directory.
+ *
+ * `memories.first` and `memories.exclude` shape which recipe memories an
+ * `@#memories` include pulls in and in what order: recipes matching `first` lead,
+ * and recipes matching `exclude` are left out. Each entry is a glob over
+ * `namespace/recipe` keys, or a regular expression written between two slashes.
+ *
+ * A recipe's `config` contents are not listed here; they are loaded as config
+ * layers rather than written anywhere.
  */
-const recipeOutputsSchema = z
+const recipesSchema = z
   .object({
     /** Where recipe skill bundles are written. */
-    skills: z.array(z.string()).optional(),
-    /** Where recipe memory files are written. */
-    memories: z.array(z.string()).optional(),
-    /** Where recipe prompt files are written. */
-    prompts: z.array(z.string()).optional(),
+    skills: z
+      .object({
+        /** Destination directories, `${var}` substituted. */
+        outputs: z.array(z.string()).optional(),
+      })
+      .strict()
+      .optional(),
+    /** Which recipe memories an `@#memories` include pulls in, and in what order. */
+    memories: z
+      .object({
+        /** Recipes whose memories come first. */
+        first: recipeKeyListSchema("recipes.memories.first").optional(),
+        /** Recipes whose memories are left out. */
+        exclude: recipeKeyListSchema("recipes.memories.exclude").optional(),
+      })
+      .strict()
+      .optional(),
   })
   .strict();
 
@@ -267,8 +307,8 @@ export const settingsSchema = z
       .optional(),
     /** Knobs for the machine-wide recipe store. */
     store: storeSchema.optional(),
-    /** Where the files subscribed recipes contribute are written, per content kind. */
-    recipeOutputs: recipeOutputsSchema.optional(),
+    /** What the project does with each content kind its subscribed recipes publish. */
+    recipes: recipesSchema.optional(),
     /**
      * Variable mapping records, keyed by environment variable name. Each entry
      * binds that name to one recipe variable, which is how an answer is stored