@ctxr/skill-llm-wiki 1.0.1 → 1.0.2

package/scripts/testkit/make-wiki-fixture.mjs

@@ -0,0 +1,301 @@
+// make-wiki-fixture.mjs — testkit helper: build a minimal hosted-
+// mode wiki at a caller-supplied path using the skill's shipped
+// starter templates. Useful for consumer tests that need a
+// plausible wiki shape to read against without running the full
+// build pipeline.
+//
+// What this does NOT do: invoke the full orchestrator. It seeds the
+// layout contract and optionally writes seed leaves the consumer
+// asks for. That is enough for consumers whose tests read/write
+// frontmatter; for tests that exercise validate/fix/rebuild,
+// consumers should `spawn` the CLI via cli-run.mjs.
+//
+// Zero runtime deps; pure Node built-ins.
+
+import {
+  copyFile,
+  lstat,
+  mkdir,
+  writeFile,
+} from "node:fs/promises";
+import { existsSync } from "node:fs";
+import {
+  basename,
+  dirname,
+  isAbsolute,
+  join,
+  relative,
+  resolve,
+} from "node:path";
+import { defaultTemplateForKind, templatesDir } from "../lib/templates.mjs";
+
+const VALID_KINDS = new Set(["dated", "subject"]);
+
+// Reject any seed-leaf path that would escape the fixture root via
+// an absolute path or `..` traversal. This is a LEXICAL check; it
+// does not detect symlink-based escapes inside the fixture tree.
+// For those, see `refuseSymlink` below, which walks every path
+// segment from the root down to the leaf and rejects if any is a
+// symbolic link. Together the two functions defend against:
+//   - absolute seed paths
+//   - `..` segments that resolve outside the root
+//   - symlinks anywhere in the resolved path's intermediate
+//     directories (e.g. `<root>/sub -> /etc/`)
+function assertInsideRoot(rootAbs, entryRel) {
+  if (typeof entryRel !== "string" || entryRel.length === 0) {
+    throw new Error("makeWikiFixture: seedLeaves entries must have a non-empty path");
+  }
+  if (isAbsolute(entryRel)) {
+    throw new Error(
+      `makeWikiFixture: seed-leaf path "${entryRel}" must be relative to the fixture root`,
+    );
+  }
+  const resolved = resolve(rootAbs, entryRel);
+  const rel = relative(rootAbs, resolved);
+  if (rel.startsWith("..") || isAbsolute(rel)) {
+    throw new Error(
+      `makeWikiFixture: seed-leaf path "${entryRel}" resolves outside the fixture root`,
+    );
+  }
+  return resolved;
+}
+
+// Walk UP from `absPath` to the first existing ancestor and
+// lstat it. Refuse if that ancestor is a symbolic link. Catches
+// the attack where a pre-existing symlink on the path TO the
+// fixture root would let `mkdir(rootAbs, {recursive:true})`
+// follow it and create the fixture outside the caller's
+// intended tree. Non-existent segments are safe — mkdir creates
+// them fresh. We stop at the first existing ancestor, so OS-
+// level symlinks above the caller-supplied tmp dir (macOS's
+// /var → /private/var) don't false-positive.
+async function refuseSymlinkOnExistingAncestor(absPath) {
+  let cursor = absPath;
+  while (true) {
+    try {
+      const st = await lstat(cursor);
+      if (st.isSymbolicLink()) {
+        throw new Error(
+          `makeWikiFixture: ${cursor} is a symbolic link on the path to ${absPath}; refusing to write through it`,
+        );
+      }
+      return; // found first existing, and it's not a symlink
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+      const parent = dirname(cursor);
+      if (parent === cursor) return; // filesystem root, no anchor
+      cursor = parent;
+    }
+  }
+}
+
+// Refuse to write through a pre-existing symlink.
+//
+// When called with a single `absPath` (no `rootAbs`), only that
+// path is checked — useful for the one-time fixture-root probe,
+// where climbing further up the chain would trip macOS's
+// /var → /private/var (or similar OS-level symlinks that are NOT
+// a fixture concern).
+//
+// When called with `rootAbs`, every segment from rootAbs down to
+// absPath is checked. A lexical `assertInsideRoot` check can be
+// bypassed by planting a symlinked sub-directory inside the
+// fixture (e.g. `<root>/sub -> /etc/`) and then passing a
+// seedLeaves entry like `sub/passwd`; walking every segment
+// closes that.
+//
+// Non-existent segments are accepted (mkdir/writeFile will create
+// them).
+async function refuseSymlink(absPath, rootAbs = null) {
+  const segments = [];
+  if (rootAbs) {
+    // Build segment list from rootAbs DOWN to absPath so we only
+    // inspect paths inside the fixture. Never climb past rootAbs.
+    segments.push(rootAbs);
+    if (absPath !== rootAbs) {
+      const rel = relative(rootAbs, absPath);
+      if (rel && !rel.startsWith("..") && !isAbsolute(rel)) {
+        const parts = rel.split(/[\\/]/).filter(Boolean);
+        let cursor = rootAbs;
+        for (const part of parts) {
+          cursor = join(cursor, part);
+          segments.push(cursor);
+        }
+      }
+    }
+  } else {
+    segments.push(absPath);
+  }
+  for (const seg of segments) {
+    try {
+      const st = await lstat(seg);
+      if (st.isSymbolicLink()) {
+        throw new Error(
+          `makeWikiFixture: ${seg} is a symbolic link; refusing to write through it`,
+        );
+      }
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+      // Segment doesn't exist yet — that's fine for mkdir's path.
+    }
+  }
+}
+
+export const CONTRACT_FILENAME = ".llmwiki.layout.yaml";
+
+export async function makeWikiFixture({
+  path,
+  kind = "dated",
+  template = null,
+  seedLeaves = [],
+} = {}) {
+  if (!path || typeof path !== "string") {
+    throw new Error("makeWikiFixture: { path } is required");
+  }
+  // Validate `kind` up front and throw on unknown values rather
+  // than silently falling back to the dated template and then
+  // returning the caller's (invalid) `kind` in the result. This
+  // matches runInit's behaviour (INIT-03).
+  if (!VALID_KINDS.has(kind)) {
+    throw new Error(
+      `makeWikiFixture: unknown kind "${kind}". Accepted: ${[...VALID_KINDS].join(", ")}`,
+    );
+  }
+  const rootAbs = resolve(path);
+  // Root-level check: walk UP from rootAbs to the first existing
+  // ancestor, lstat it, and refuse if it's a symlink. This catches
+  // an attacker-planted intermediate segment (e.g. `/tmp/foo -> /etc`
+  // before init runs `makeWikiFixture({ path: "/tmp/foo/wiki" })`,
+  // where mkdir(recursive:true) would otherwise follow the symlink
+  // and create the fixture outside the caller's intended tree.
+  // The walker stops at the first existing ancestor so OS-level
+  // symlinks above the caller's path (macOS's /var → /private/var)
+  // don't false-positive.
+  await refuseSymlinkOnExistingAncestor(rootAbs);
+  await mkdir(rootAbs, { recursive: true });
+
+  // Pick a template. `templatesDir()` returns the absolute path;
+  // filenames follow `<name>.llmwiki.layout.yaml`.
+  // Pick the default template from the shared table so
+  // makeWikiFixture and runInit stay in lockstep: both route
+  // dated → "reports", subject → "runbooks". Explicit --template
+  // still overrides.
+  const tmplName = template ?? defaultTemplateForKind(kind);
+  const tmplPath = join(templatesDir(), `${tmplName}.llmwiki.layout.yaml`);
+  if (!existsSync(tmplPath)) {
+    throw new Error(
+      `makeWikiFixture: template "${tmplName}" not found at ${tmplPath}`,
+    );
+  }
+  const contractPath = join(rootAbs, CONTRACT_FILENAME);
+  await refuseSymlink(contractPath, rootAbs);
+  await copyFile(tmplPath, contractPath);
+
+  // Seed a root index.md so `skill-llm-wiki validate/heal` against
+  // the fixture doesn't trip WIKI-01 ("not a valid wiki root").
+  // validateWiki requires index.md with the `generator` marker, a
+  // matching `id`, `type: index`, `depth_role: category` for the
+  // root, and a non-empty `focus`.
+  const indexPath = join(rootAbs, "index.md");
+  await refuseSymlink(indexPath, rootAbs);
+  const rootId = basename(rootAbs);
+  await writeFile(indexPath, defaultRootIndexBody(rootId, tmplName), "utf8");
+
+  // Seed any requested leaves. Each entry is either:
+  //   { path: "reports/2026/04/18/example.md", body: "..." }
+  // or just a plain string `"reports/2026/04/18/example.md"` which
+  // seeds a minimal leaf with default frontmatter.
+  const createdLeaves = [];
+  for (const raw of seedLeaves) {
+    const entry =
+      typeof raw === "string" ? { path: raw, body: null } : raw;
+    // Refuse any seed path that escapes the fixture root. Caller
+    // bugs (typos, absolute paths) are caught loudly before any
+    // write happens.
+    const abs = assertInsideRoot(rootAbs, entry.path);
+    const dirAbs = dirname(abs);
+    // IMPORTANT: segment-walk BEFORE mkdir. Once mkdir(recursive)
+    // runs, it follows any pre-existing symlinked sub-dir and can
+    // create directories OUTSIDE rootAbs — the attack this helper
+    // is explicitly defending against. Check every segment of
+    // dirAbs, then mkdir, then re-check the leaf path for a
+    // symlinked file.
+    await refuseSymlink(dirAbs, rootAbs);
+    await mkdir(dirAbs, { recursive: true });
+    await refuseSymlink(abs, rootAbs);
+    const body = entry.body ?? defaultLeafBody(entry.path);
+    await writeFile(abs, body, "utf8");
+    createdLeaves.push(abs);
+  }
+
+  return {
+    path,
+    template: tmplName,
+    kind,
+    contract_path: contractPath,
+    seeded_leaves: createdLeaves,
+  };
+}
+
+function defaultLeafBody(relativePath) {
+  const segments = relativePath.split(/[\\/]/).filter(Boolean);
+  const leafName = segments[segments.length - 1] ?? "leaf.md";
+  const id = leafName.replace(/\.md$/, "");
+  // Compute parents[] relative to the single root index.md that
+  // makeWikiFixture seeds. Depth is (segments - 1) because the
+  // last segment is the leaf file itself. A root-level leaf gets
+  // `index.md`, a 1-level-deep leaf gets `../index.md`, a 3-level
+  // date-partitioned leaf (yyyy/mm/dd/x.md) gets `../../../index.md`.
+  const depth = Math.max(0, segments.length - 1);
+  const parents = depth === 0 ? "index.md" : `${"../".repeat(depth)}index.md`;
+  // source.path is a POSIX-relative path per the contract
+  // (scripts/lib/contract.mjs frontmatter_schema.leaf.source.path).
+  // Windows callers may pass "a\\b\\c"; normalise.
+  const sourcePathPosix = relativePath.split(/[\\/]/).filter(Boolean).join("/");
+  return [
+    "---",
+    `id: ${id}`,
+    "type: primary",
+    "depth_role: leaf",
+    `focus: "${id}"`,
+    "covers: []",
+    `parents: [${parents}]`,
+    "tags: []",
+    `source:`,
+    `  origin: file`,
+    `  path: ${sourcePathPosix}`,
+    "---",
+    "",
+    `# ${id}`,
+    "",
+    "Fixture leaf body.",
+    "",
+  ].join("\n");
+}
+
+// Minimal root index.md for a fresh fixture. Carries the fields
+// validateWiki + isWikiRoot require: generator marker, id matching
+// basename, type: index, depth_role: category, focus, empty
+// parents. Without this, `skill-llm-wiki validate/heal` against
+// the fixture returns verdict "broken" with WIKI-01.
+function defaultRootIndexBody(rootId, templateName) {
+  return [
+    "---",
+    `id: ${rootId}`,
+    "type: index",
+    "depth_role: category",
+    "depth: 0",
+    `focus: "test fixture: ${templateName}"`,
+    "parents: []",
+    "children: []",
+    "entries: []",
+    "shared_covers: []",
+    `generator: "skill-llm-wiki/v1"`,
+    "---",
+    "",
+    `# ${rootId}`,
+    "",
+    "Fixture root index seeded by makeWikiFixture. Not a production wiki.",
+    "",
+  ].join("\n");
+}

package/scripts/testkit/stub-skill.mjs

@@ -0,0 +1,107 @@
+// stub-skill.mjs — testkit helper: seed a presence-only
+// @ctxr/skill-llm-wiki install at a kit-canonical path under the
+// caller-supplied base directory.
+//
+// Consumers use this in their test suites to satisfy the "is the
+// skill installed?" preflight without needing a real skill
+// checkout. The stub is NOT a working skill — it only carries the
+// SKILL.md frontmatter consumers typically grep for. For richer
+// test fixtures (a real hosted wiki), see make-wiki-fixture.mjs.
+//
+// Zero runtime deps; pure Node built-ins.
+
+import { lstat, mkdir, writeFile } from "node:fs/promises";
+import { isAbsolute, join, relative, resolve } from "node:path";
+import { FORMAT_VERSION } from "../lib/contract.mjs";
+
+// The kit's ARTIFACT_TYPES.skill enumerates these install layouts.
+// Consumers pick the one their test environment emulates.
+const LAYOUTS = {
+  "claude-skills": [".claude", "skills"],
+  "agents-skills": [".agents", "skills"],
+};
+
+export const STUB_SKILL_NAME = "ctxr-skill-llm-wiki";
+
+// Walk every segment from `base` (inclusive) down to `target`
+// (inclusive), lstat-ing each. Refuse if any segment is a
+// symbolic link. Non-existent segments are accepted (they'll be
+// created by mkdir). `base` itself is NOT walked further upward:
+// we never inspect OS-level directories above the caller-supplied
+// home (macOS's /var → /private/var, for example, would false-
+// positive otherwise).
+//
+// Containment is validated with path.resolve + path.relative
+// rather than a string-prefix check, so `/tmp/home2/x` is NOT
+// misclassified as "under /tmp/home" and path separators /
+// trailing slashes don't matter.
+async function refuseSymlinkChain(base, target) {
+  const baseAbs = resolve(base);
+  const targetAbs = resolve(target);
+  const segments = [baseAbs];
+  if (targetAbs !== baseAbs) {
+    const rel = relative(baseAbs, targetAbs);
+    if (rel === "" || rel.startsWith("..") || isAbsolute(rel)) {
+      throw new Error(
+        `stubSkill: internal error, target ${target} is not under base ${base}`,
+      );
+    }
+    const parts = rel.split(/[\\/]/).filter(Boolean);
+    let cursor = baseAbs;
+    for (const part of parts) {
+      cursor = join(cursor, part);
+      segments.push(cursor);
+    }
+  }
+  for (const seg of segments) {
+    try {
+      const st = await lstat(seg);
+      if (st.isSymbolicLink()) {
+        throw new Error(
+          `stubSkill: ${seg} is a symbolic link; refusing to write through it`,
+        );
+      }
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+  }
+}
+
+export async function stubSkill({ home, layout = "claude-skills" } = {}) {
+  if (!home || typeof home !== "string") {
+    throw new Error(
+      "stubSkill: { home } is required (the base directory under which the stub install tree is seeded)",
+    );
+  }
+  const parts = LAYOUTS[layout];
+  if (!parts) {
+    const known = Object.keys(LAYOUTS).join(", ");
+    throw new Error(
+      `stubSkill: unknown layout "${layout}". Known: ${known}`,
+    );
+  }
+  const dir = join(home, ...parts, STUB_SKILL_NAME);
+  const skillMd = join(dir, "SKILL.md");
+  // Walk every intermediate segment (home → .claude → skills →
+  // ctxr-skill-llm-wiki) BEFORE mkdir. mkdir({recursive: true})
+  // follows symlinks, so a hostile fixture that planted
+  // `${home}/.claude -> /etc` would otherwise cause stubSkill to
+  // create `.claude/skills/ctxr-skill-llm-wiki` under `/etc/`.
+  await refuseSymlinkChain(home, dir);
+  await mkdir(dir, { recursive: true });
+  // Re-check the leaf file path before writing, so a pre-existing
+  // symlink at `<dir>/SKILL.md` is also rejected.
+  await refuseSymlinkChain(home, skillMd);
+  const body = [
+    "---",
+    "name: skill-llm-wiki",
+    "description: test stub of @ctxr/skill-llm-wiki — presence-only, not a working skill",
+    `format_version: ${FORMAT_VERSION}`,
+    "---",
+    "",
+    "This is a test stub. Do not invoke wiki operations against it.",
+    "",
+  ].join("\n");
+  await writeFile(skillMd, body, "utf8");
+  return { dir, skillMd, layout };
+}

package/templates/adrs.llmwiki.layout.yaml

@@ -0,0 +1,33 @@
+# Layout contract for an architecture-decision-records (ADRs) topic.
+#
+# Copy this file to <topic>/.llmwiki.layout.yaml (or let `skill-llm-wiki init`
+# seed it for you) before building in hosted mode:
+#
+#   skill-llm-wiki init <topic> --kind subject --template adrs
+#
+# ADRs are subject-grouped with a zero-padded sequential prefix per file
+# (e.g. 0001-use-postgres.md). Subfolders emerge once a domain accumulates
+# three or more decisions.
+
+mode: hosted
+
+versioning:
+  style: in-place
+  backup_before_mutate: true
+  backup_dir: .llmwiki.backups
+
+purpose: "Architecture decision records, numbered and grouped by subject."
+
+global_invariants:
+  - "filenames carry a zero-padded sequential prefix (NNNN-slug.md)"
+  - "superseded ADRs stay in place with status: superseded in frontmatter; never rename or delete"
+  - "category subfolders appear when three or more ADRs share a domain (storage/, auth/, transport/, ...)"
+
+layout:
+  - path: .
+    purpose: "ADRs, numbered and grouped by subject"
+    allow_entry_types: [primary, index]
+    content_rules:
+      - "one decision per leaf; link to related decisions via parents[]"
+      - "frontmatter declares status: proposed | accepted | superseded | deprecated"
+      - "root-level leaves are reserved for broad, cross-cutting decisions; domain-specific nest under a subject subfolder"

package/templates/plans.llmwiki.layout.yaml

@@ -0,0 +1,34 @@
+# Layout contract for a plans topic.
+#
+# Copy this file to <topic>/.llmwiki.layout.yaml (or let `skill-llm-wiki init`
+# seed it for you) before building in hosted mode:
+#
+#   skill-llm-wiki init <topic> --kind dated --template plans
+#
+# Plans are hybrid: most live in dated subfolders alongside when they were
+# drafted, but long-running plan families live under a subject subfolder
+# instead. Both shapes are valid under this contract.
+
+mode: hosted
+
+versioning:
+  style: in-place
+  backup_before_mutate: true
+  backup_dir: .llmwiki.backups
+
+purpose: "Implementation plans: dated drafts under {yyyy}/{mm}/{dd}/, long-running families under a subject subfolder."
+
+global_invariants:
+  - "no flat date-prefixed leaves at the topic root"
+  - "plan families (3+ related plans under one umbrella) live in a subject subfolder, not a date subfolder"
+
+layout:
+  - path: .
+    purpose: "plans filed by date, with subject subfolders for long-running families"
+    dynamic_subdirs:
+      template: "{yyyy}/{mm}/{dd}"
+      purpose: "one-off plans drafted on a given day"
+      allow_entry_types: [primary]
+      content_rules:
+        - "slug encodes the subject, not the date"
+        - "promote a plan to a named subject subfolder once a third related plan appears"

package/templates/regressions.llmwiki.layout.yaml

@@ -0,0 +1,34 @@
+# Layout contract for a dated regressions topic.
+#
+# Copy this file to <topic>/.llmwiki.layout.yaml (or let `skill-llm-wiki init`
+# seed it for you) before building in hosted mode:
+#
+#   skill-llm-wiki init <topic> --kind dated --template regressions
+#
+# Regressions are lower-volume than reports or sessions, so the default
+# template is {yyyy}/{mm}. If your regression volume grows past a few
+# dozen per month, bump the template to {yyyy}/{mm}/{dd} and rebuild.
+
+mode: hosted
+
+versioning:
+  style: in-place
+  backup_before_mutate: true
+  backup_dir: .llmwiki.backups
+
+purpose: "Regression notes (bug-triage writeups, post-mortems, failing-build captures), filed by month."
+
+global_invariants:
+  - "no flat date-prefixed leaves at the topic root; regressions live under {yyyy}/{mm}/"
+  - "one leaf per distinct regression; update the leaf in place when the investigation continues"
+
+layout:
+  - path: .
+    purpose: "regressions filed by month"
+    dynamic_subdirs:
+      template: "{yyyy}/{mm}"
+      purpose: "all regressions captured in a given month"
+      allow_entry_types: [primary]
+      content_rules:
+        - "slug encodes the symptom or ticket id, not the date"
+        - "include the commit or release that introduced the regression in frontmatter.source"

package/templates/reports.llmwiki.layout.yaml

@@ -0,0 +1,33 @@
+# Layout contract for a dated reports topic.
+#
+# Copy this file to <topic>/.llmwiki.layout.yaml (or let `skill-llm-wiki init`
+# seed it for you) before building in hosted mode:
+#
+#   skill-llm-wiki init <topic> --kind dated --template reports
+#
+# Reports accrete over time and must land under {yyyy}/{mm}/{dd}/ to keep
+# the topic root scannable. Flat date-prefixed siblings are refused.
+
+mode: hosted
+
+versioning:
+  style: in-place
+  backup_before_mutate: true
+  backup_dir: .llmwiki.backups
+
+purpose: "Generated reports (code review, investigation, regression triage), filed by date."
+
+global_invariants:
+  - "no flat date-prefixed leaves at the topic root; reports live under {yyyy}/{mm}/{dd}/"
+  - "no user-visible versioned filenames (.v1.md, -v2.md, etc.); history lives in the private git"
+
+layout:
+  - path: .
+    purpose: "reports filed by date"
+    dynamic_subdirs:
+      template: "{yyyy}/{mm}/{dd}"
+      purpose: "all reports written on a given day"
+      allow_entry_types: [primary]
+      content_rules:
+        - "one leaf per reviewed PR or standalone investigation"
+        - "slug encodes subject, not date (date is the path)"

package/templates/runbooks.llmwiki.layout.yaml

@@ -0,0 +1,33 @@
+# Layout contract for a subject-categorised runbooks topic.
+#
+# Copy this file to <topic>/.llmwiki.layout.yaml (or let `skill-llm-wiki init`
+# seed it for you) before building in hosted mode:
+#
+#   skill-llm-wiki init <topic> --kind subject --template runbooks
+#
+# Runbooks group by subject, not date. The hierarchy grows as you add
+# subjects; pick a category subfolder on the first leaf, and create a new
+# subfolder whenever two or more leaves share a defensible grouping.
+
+mode: hosted
+
+versioning:
+  style: in-place
+  backup_before_mutate: true
+  backup_dir: .llmwiki.backups
+
+purpose: "Operational runbooks and playbooks, grouped by subject (e.g. deploy/, incident/, database/, onboarding/)."
+
+global_invariants:
+  - "no flat list of runbook leaves at the topic root once more than three exist"
+  - "category subfolders are created on the first write; never 'later when there are enough files'"
+  - "no date prefixes or timestamp suffixes in filenames; history lives in the private git"
+
+layout:
+  - path: .
+    purpose: "runbooks grouped by subject"
+    allow_entry_types: [primary, index]
+    content_rules:
+      - "root-level leaves are reserved for the 3-5 most general runbooks; everything else nests"
+      - "subject subfolders name the domain, not a ticket or date"
+      - "nested subcategories are preferred over long filenames"

package/templates/sessions.llmwiki.layout.yaml

@@ -0,0 +1,34 @@
+# Layout contract for a dated sessions topic.
+#
+# Copy this file to <topic>/.llmwiki.layout.yaml (or let `skill-llm-wiki init`
+# seed it for you) before building in hosted mode:
+#
+#   skill-llm-wiki init <topic> --kind dated --template sessions
+#
+# Sessions are per-day log-style entries (pair-programming sessions, daily
+# working logs, standup notes). The day is the path; the slug is the
+# topic or ticket, never the date.
+
+mode: hosted
+
+versioning:
+  style: in-place
+  backup_before_mutate: true
+  backup_dir: .llmwiki.backups
+
+purpose: "Daily session logs (working sessions, pair-programming notes, standup records), filed by date."
+
+global_invariants:
+  - "no flat date-prefixed leaves at the topic root; sessions live under {yyyy}/{mm}/{dd}/"
+  - "slug encodes the subject or ticket, not the date"
+
+layout:
+  - path: .
+    purpose: "sessions filed by date"
+    dynamic_subdirs:
+      template: "{yyyy}/{mm}/{dd}"
+      purpose: "all sessions started on a given day"
+      allow_entry_types: [primary]
+      content_rules:
+        - "one leaf per discrete session; append to the leaf if the same session resumes same day"
+        - "link to related plans/reports via parents[] rather than inlining them"