@structured-vibe-coding/core 0.17.2 → 0.19.0

package/dist/{chunk-KYWETNFU.js → chunk-4BRO7BOJ.js}

@@ -1,12 +1,10 @@
-import {
-  sddRoot
-} from "./chunk-7MJYPJMR.js";
 import {
   ensureDir,
   pathExists,
   readYaml,
+  sddRoot,
   writeYaml
-} from "./chunk-EPFURATC.js";
+} from "./chunk-O5SP6X5R.js";
 
 // src/mcp/sources.ts
 import { join } from "pathe";

package/dist/{chunk-74OGSVJZ.js → chunk-H55RFAEI.js}

@@ -2,7 +2,7 @@ import {
   interpolate,
   interpolateArgs,
   loadMcpConfig
-} from "./chunk-KYWETNFU.js";
+} from "./chunk-4BRO7BOJ.js";
 import {
   SddError
 } from "./chunk-MHODNFIL.js";
@@ -26,7 +26,7 @@ function toProcessEnv(base, extra) {
 }
 
 // src/version.ts
-var SDD_CORE_VERSION = "0.17.2" ? "0.17.2" : "0.0.0-dev";
+var SDD_CORE_VERSION = "0.19.0" ? "0.19.0" : "0.0.0-dev";
 
 // src/mcp/client.ts
 function mcpTimeoutMs() {

package/dist/chunk-HG7TPW5V.js

@@ -0,0 +1,567 @@
+import {
+  activePointerPath,
+  changeMetaPath,
+  changePath,
+  changesDir,
+  displayChangePath,
+  ensureDir,
+  listDirs,
+  listFiles,
+  pathExists,
+  readText,
+  readYaml,
+  workflowsDir,
+  writeText,
+  writeYaml
+} from "./chunk-O5SP6X5R.js";
+
+// src/schemas.ts
+import { z } from "zod";
+var GateSchema = z.object({
+  type: z.enum(["none", "soft", "hard"]).default("soft"),
+  mode: z.enum(["none", "human_approval", "checklist"]).default("checklist"),
+  checklist: z.array(z.string()).default([]),
+  /** Role names, or human for a person listed on the team. */
+  approvers: z.array(z.string().trim().min(1)).optional(),
+  overridable: z.boolean().default(true)
+});
+var ArtifactDefSchema = z.object({
+  id: z.string(),
+  path: z.string(),
+  template: z.string().optional(),
+  required: z.boolean().default(true)
+});
+var VerifyCommandSchema = z.object({
+  name: z.string(),
+  run: z.string(),
+  required: z.boolean().default(false)
+});
+var StageSchema = z.object({
+  id: z.string(),
+  title: z.string().optional(),
+  summary: z.string().optional(),
+  /**
+   * standard — normal work stage
+   * brainstorm — optional multi-approach exploration (before design)
+   * clarify — optional Q&A before leaving a major stage
+   */
+  kind: z.enum(["standard", "brainstorm", "clarify"]).default("standard"),
+  /** When true, stage is optional (skippable); agents may skip if not needed */
+  optional: z.boolean().default(false),
+  /** Role that produces this stage. */
+  owner: z.string().trim().min(1).optional(),
+  /** Roles who work with the owner on this stage. */
+  collaborates: z.array(z.string().trim().min(1)).optional(),
+  /**
+   * One item per matching file when the stage starts.
+   * A directory, a slash, and one star in the file name: tasks/T-*.md
+   */
+  items_from: z.string().regex(/^(?!.*\.\.)[A-Za-z0-9._-]+\/[A-Za-z0-9._-]*\*[A-Za-z0-9._-]*$/).optional(),
+  artifacts: z.array(ArtifactDefSchema).default([]),
+  gate: GateSchema.default({}),
+  skippable: z.boolean().default(true),
+  skip_when: z.object({
+    flags: z.array(z.string()).optional()
+  }).optional(),
+  verify: z.object({
+    commands: z.array(VerifyCommandSchema).default([]),
+    evidence_dir: z.string().optional()
+  }).optional(),
+  agent_context: z.object({
+    include: z.array(z.string()).default([]),
+    instructions: z.string().optional()
+  }).optional()
+});
+var WorkflowSchema = z.object({
+  name: z.string(),
+  description: z.string().optional(),
+  version: z.number().default(1),
+  stages: z.array(StageSchema).min(1),
+  recommendation: z.object({
+    when: z.object({
+      labels: z.array(z.string()).optional(),
+      keywords: z.array(z.string()).optional(),
+      max_complexity: z.enum(["low", "medium", "high"]).optional(),
+      min_complexity: z.enum(["low", "medium", "high"]).optional()
+    }).optional(),
+    priority: z.number().default(0)
+  }).optional(),
+  on_complete: z.object({
+    archive: z.boolean().default(false),
+    domain_sync: z.enum(["never", "recommend", "require"]).default("never")
+  }).optional()
+});
+var ConfigSchema = z.object({
+  version: z.number().default(1),
+  metrics: z.object({
+    enabled: z.boolean().default(true),
+    exclude: z.array(z.string().min(1)).default([])
+  }).default({}),
+  memory_path: z.string().default("memory"),
+  changes_path: z.string().default("changes"),
+  archive_path: z.string().default("archive"),
+  domains_path: z.string().default("domains"),
+  default_workflow: z.string().default("recommend"),
+  allowed_workflows: z.array(z.string()).optional(),
+  per_change: z.object({
+    allow_skip: z.boolean().default(true),
+    allow_gate_override: z.enum(["true", "false", "soft_only"]).default("soft_only"),
+    allow_custom_stages: z.boolean().default(true),
+    require_reason_on_skip: z.boolean().default(true)
+  }).default({}),
+  persistence: z.object({
+    default: z.enum(["change_only", "domain_sync"]).default("change_only"),
+    archive_on_complete: z.boolean().default(false),
+    domain_sync: z.object({
+      mode: z.enum(["never", "recommend", "require"]).default("never"),
+      anchored_domains: z.array(z.string()).default([])
+    }).default({})
+  }).default({}),
+  policy: z.object({
+    gates: z.enum(["soft", "hard"]).default("soft")
+  }).default({})
+});
+var ChangeMetaSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  workflow: z.string(),
+  created: z.string(),
+  updated: z.string().optional(),
+  status: z.enum(["in_progress", "blocked", "completed", "abandoned"]).default("in_progress"),
+  stage: z.string(),
+  branch: z.string().optional(),
+  /** Epic key such as issue-37. Stories in one epic share a dependency graph. */
+  epic: z.string().optional(),
+  /** Story id such as S-001. */
+  story: z.string().optional(),
+  depends: z.array(z.string()).optional(),
+  domain: z.string().optional(),
+  flags: z.record(z.union([z.boolean(), z.string(), z.number()])).default({}),
+  overrides: z.object({
+    skip_stages: z.array(z.string()).default([]),
+    gates: z.record(z.enum(["none", "soft", "hard"])).default({}),
+    extra_stages: z.array(StageSchema).default([])
+  }).default({}),
+  skipped: z.array(
+    z.object({
+      stage: z.string(),
+      reason: z.string(),
+      at: z.string()
+    })
+  ).default([]),
+  gates: z.record(
+    z.object({
+      status: z.enum(["pending", "approved", "failed", "waived"]),
+      note: z.string().optional(),
+      at: z.string().optional()
+    })
+  ).default({}),
+  /** Results from `sdd verify` keyed by stage id */
+  verify_results: z.record(
+    z.object({
+      ok: z.boolean(),
+      /** pass | fail | not_run (absent in metas written before 0.17.3) */
+      status: z.enum(["pass", "fail", "not_run"]).optional(),
+      head_sha: z.string().regex(/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/i).optional(),
+      at: z.string(),
+      results: z.array(
+        z.object({
+          name: z.string(),
+          exitCode: z.number().nullable()
+        })
+      ).default([])
+    })
+  ).default({}),
+  pr: z.object({
+    number: z.number().optional(),
+    url: z.string().optional()
+  }).optional(),
+  completed_at: z.string().optional()
+});
+
+// src/slug.ts
+var SLUG_MAX = 60;
+function trailingIssueRef(input) {
+  return input.match(/#\s*(\d+)\s*\)?\s*$/)?.[1];
+}
+function slugify(input) {
+  const normalized = input.toLowerCase().trim().replace(/['"]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  if (normalized.length <= SLUG_MAX) return normalized;
+  const issue = trailingIssueRef(input);
+  const tokens = normalized.split("-").filter(Boolean);
+  const body = issue && tokens.at(-1) === issue ? tokens.slice(0, -1) : tokens;
+  const reserve = issue && issue.length <= SLUG_MAX ? issue.length + 1 : 0;
+  const kept = [];
+  let length = 0;
+  for (const token of body) {
+    const next = length === 0 ? token.length : length + 1 + token.length;
+    if (next + reserve > SLUG_MAX) break;
+    kept.push(token);
+    length = next;
+  }
+  if (reserve && issue) {
+    if (kept.length === 0) return issue;
+    return `${kept.join("-")}-${issue}`;
+  }
+  return kept.join("-");
+}
+function todayIsoDate(d = /* @__PURE__ */ new Date()) {
+  return d.toISOString().slice(0, 10);
+}
+function nowIso(d = /* @__PURE__ */ new Date()) {
+  return d.toISOString();
+}
+function changeDirName(title, d = /* @__PURE__ */ new Date()) {
+  const slug = slugify(title) || "change";
+  return `${todayIsoDate(d)}-${slug}`;
+}
+function uniqueChangeDirName(base, taken) {
+  if (!taken.has(base)) return base;
+  let n = 2;
+  while (taken.has(`${base}-${n}`)) n += 1;
+  return `${base}-${n}`;
+}
+
+// src/workflow.ts
+import { join as join2 } from "pathe";
+
+// src/defaults.ts
+import { existsSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join } from "pathe";
+function defaultsRoot() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    join(here, "..", "defaults"),
+    // npm package: dist/../defaults
+    join(here, "defaults"),
+    // same-dir defaults if present
+    join(here, "..", "..", "defaults")
+    // src/ during some test runners
+  ];
+  for (const c of candidates) {
+    if (existsSync(c)) return c;
+  }
+  return candidates[0];
+}
+function defaultWorkflowsDir() {
+  return join(defaultsRoot(), "workflows");
+}
+function defaultTeamsDir() {
+  return join(defaultsRoot(), "teams");
+}
+function defaultTemplatesDir() {
+  return join(defaultsRoot(), "templates");
+}
+function defaultMemoryDir() {
+  return join(defaultsRoot(), "memory");
+}
+function defaultMcpYamlPath() {
+  return join(defaultsRoot(), "mcp.yaml");
+}
+function defaultPricesYamlPath() {
+  return join(defaultsRoot(), "prices.yaml");
+}
+function defaultSearchYamlPath() {
+  return join(defaultsRoot(), "search.yaml");
+}
+
+// src/workflow.ts
+function workflowNamesIn(files) {
+  return files.filter((f) => f.endsWith(".yaml") || f.endsWith(".yml")).map((f) => f.replace(/\.ya?ml$/, "")).sort();
+}
+async function listWorkflowNames(projectRoot) {
+  const dir = workflowsDir(projectRoot);
+  return workflowNamesIn(await listFiles(dir));
+}
+async function listBundledWorkflowNames() {
+  return workflowNamesIn(await listFiles(defaultWorkflowsDir()));
+}
+async function missingBundledWorkflows(projectRoot) {
+  const present = new Set(await listWorkflowNames(projectRoot));
+  return (await listBundledWorkflowNames()).filter((name) => !present.has(name));
+}
+function workflowUnavailableMessage(name, available, bundled) {
+  const listed = available.join(", ") || "(none)";
+  const base = `Workflow "${name}" is not available. Available: ${listed}`;
+  if (!bundled.includes(name)) return base;
+  return `${base}. This CLI ships ${name}. Run \`sdd init --here --force\` to copy new defaults.`;
+}
+async function loadWorkflow(projectRoot, name) {
+  const dir = workflowsDir(projectRoot);
+  const candidates = [`${name}.yaml`, `${name}.yml`];
+  for (const file of candidates) {
+    const path = join2(dir, file);
+    if (await pathExists(path)) {
+      const raw = await readYaml(path);
+      const workflow = WorkflowSchema.parse(raw);
+      if (workflow.name !== name) {
+      }
+      return workflow;
+    }
+  }
+  const available = await listWorkflowNames(projectRoot);
+  const bundled = await listBundledWorkflowNames();
+  const listed = available.join(", ") || "(none)";
+  let message = `Workflow "${name}" not found in ${dir}. Available: ${listed}`;
+  if (bundled.includes(name)) {
+    message += `. This CLI ships ${name}. Run \`sdd init --here --force\` to copy new defaults.`;
+  }
+  throw new Error(message);
+}
+function resolveStages(workflow, meta) {
+  const base = [...workflow.stages];
+  const extra = meta.overrides?.extra_stages ?? [];
+  const stages = [...base, ...extra];
+  return stages.map((stage) => {
+    const gateOverride = meta.overrides?.gates?.[stage.id];
+    if (!gateOverride) return stage;
+    return {
+      ...stage,
+      gate: {
+        ...stage.gate,
+        type: gateOverride
+      }
+    };
+  });
+}
+function isStageSkipped(meta, stageId) {
+  if (meta.overrides?.skip_stages?.includes(stageId)) return true;
+  if (meta.skipped?.some((s) => s.stage === stageId)) return true;
+  return false;
+}
+function shouldAutoSkip(stage, meta) {
+  const flags = stage.skip_when?.flags ?? [];
+  for (const flag of flags) {
+    if (meta.flags?.[flag] === true || meta.flags?.[flag] === "true") {
+      return true;
+    }
+  }
+  return false;
+}
+function activeStages(workflow, meta) {
+  return resolveStages(workflow, meta).filter((s) => {
+    if (isStageSkipped(meta, s.id)) return false;
+    if (shouldAutoSkip(s, meta)) return false;
+    return true;
+  });
+}
+function getStage(workflow, meta, stageId) {
+  return resolveStages(workflow, meta).find((s) => s.id === stageId);
+}
+function nextStageId(workflow, meta) {
+  const all = resolveStages(workflow, meta);
+  const activeIds = new Set(activeStages(workflow, meta).map((s) => s.id));
+  let start = all.findIndex((s) => s.id === meta.stage);
+  if (start === -1) start = -1;
+  for (let i = start + 1; i < all.length; i++) {
+    const id = all[i].id;
+    if (activeIds.has(id)) return id;
+  }
+  return null;
+}
+function firstActiveStageId(workflow, meta) {
+  return activeStages(workflow, meta)[0]?.id ?? null;
+}
+function inferComplexity(title, hints) {
+  const text = `${title} ${(hints?.keywords ?? []).join(" ")}`.toLowerCase();
+  const hotfixHints = ["typo", "hotfix", "nit", "rename", "bump", "chore", "readme", "docs"];
+  const highHints = [
+    "architecture",
+    "migration",
+    "auth",
+    "payment",
+    "billing",
+    "redesign",
+    "platform",
+    "arb",
+    "epic"
+  ];
+  if (hotfixHints.some((h) => text.includes(h))) return "low";
+  if (highHints.some((h) => text.includes(h))) return "high";
+  if (text.length > 80) return "medium";
+  return "medium";
+}
+async function recommendWorkflow(projectRoot, title, config, opts) {
+  const available = await listWorkflowNames(projectRoot);
+  const allowed = config.allowed_workflows?.length ? available.filter((n) => config.allowed_workflows.includes(n)) : available;
+  if (opts?.preferred) {
+    if (!available.includes(opts.preferred)) {
+      throw new Error(
+        workflowUnavailableMessage(opts.preferred, available, await listBundledWorkflowNames())
+      );
+    }
+    if (config.allowed_workflows?.length && !config.allowed_workflows.includes(opts.preferred)) {
+      throw new Error(
+        `Workflow "${opts.preferred}" is not in allowed_workflows: ${config.allowed_workflows.join(", ")}`
+      );
+    }
+    return {
+      name: opts.preferred,
+      reason: "Explicitly selected",
+      alternatives: allowed.filter((n) => n !== opts.preferred)
+    };
+  }
+  if (config.default_workflow !== "recommend" && allowed.includes(config.default_workflow)) {
+    return {
+      name: config.default_workflow,
+      reason: `Repo default_workflow=${config.default_workflow}`,
+      alternatives: allowed.filter((n) => n !== config.default_workflow)
+    };
+  }
+  const complexity = opts?.complexity ?? inferComplexity(title);
+  const scored = [];
+  for (const name of allowed) {
+    try {
+      const wf = await loadWorkflow(projectRoot, name);
+      let score = wf.recommendation?.priority ?? 0;
+      let reason = `workflow priority ${score}`;
+      const when = wf.recommendation?.when;
+      if (complexity === "low" && name === "hotfix") {
+        score += 50;
+        reason = "Low complexity \u2192 hotfix";
+      } else if (complexity === "low" && name === "patch") {
+        score += 40;
+        reason = "Low complexity \u2192 patch";
+      } else if (complexity === "medium" && name === "feature") {
+        score += 45;
+        reason = "Medium complexity \u2192 feature";
+      } else if (complexity === "medium" && name === "patch") {
+        score += 30;
+        reason = "Medium complexity \u2192 patch";
+      } else if (complexity === "high" && name === "enterprise-feature") {
+        score += 50;
+        reason = "High complexity \u2192 enterprise-feature";
+      } else if (complexity === "high" && name === "feature") {
+        score += 35;
+        reason = "High complexity \u2192 feature";
+      }
+      const keywords = when?.keywords ?? [];
+      const titleLower = title.toLowerCase();
+      if (keywords.some((k) => titleLower.includes(k.toLowerCase()))) {
+        score += 20;
+        reason = `Keyword match for ${name}`;
+      }
+      scored.push({ name, score, reason });
+    } catch {
+    }
+  }
+  scored.sort((a, b) => b.score - a.score);
+  const best = scored[0];
+  if (!best) {
+    throw new Error("No workflows available. Run `sdd init` or add files under .sdd/workflows/");
+  }
+  return {
+    name: best.name,
+    reason: best.reason,
+    alternatives: scored.slice(1).map((s) => s.name)
+  };
+}
+
+// src/change-context.ts
+async function loadChangeMeta(projectRoot, config, changeId) {
+  const path = changeMetaPath(projectRoot, config, changeId);
+  if (!await pathExists(path)) {
+    throw new Error(`Change not found: ${changeId}`);
+  }
+  return ChangeMetaSchema.parse(await readYaml(path));
+}
+async function saveChangeMeta(projectRoot, config, meta) {
+  meta.updated = nowIso();
+  await writeYaml(changeMetaPath(projectRoot, config, meta.id), ChangeMetaSchema.parse(meta));
+}
+async function buildContext(projectRoot, config, changeId) {
+  const meta = await loadChangeMeta(projectRoot, config, changeId);
+  const workflow = await loadWorkflow(projectRoot, meta.workflow);
+  return {
+    id: changeId,
+    path: changePath(projectRoot, config, changeId),
+    displayPath: displayChangePath(config, changeId),
+    meta,
+    workflow,
+    stages: resolveStages(workflow, meta),
+    active: activeStages(workflow, meta)
+  };
+}
+async function listChanges(projectRoot, config) {
+  return listDirs(changesDir(projectRoot, config));
+}
+async function getActiveChangeId(projectRoot, config) {
+  const pointer = activePointerPath(projectRoot, config);
+  if (await pathExists(pointer)) {
+    const id = (await readText(pointer)).trim();
+    if (id && await pathExists(changePath(projectRoot, config, id))) {
+      return id;
+    }
+    if (id) {
+      await writeText(pointer, "");
+    }
+  }
+  return null;
+}
+async function clearActiveIf(projectRoot, config, changeId) {
+  const pointer = activePointerPath(projectRoot, config);
+  if (!await pathExists(pointer)) return;
+  const id = (await readText(pointer)).trim();
+  if (id === changeId) {
+    await writeText(pointer, "");
+  }
+}
+async function setActiveChange(projectRoot, config, changeId) {
+  await ensureDir(changesDir(projectRoot, config));
+  await writeText(activePointerPath(projectRoot, config), `${changeId}
+`);
+}
+async function resolveChangeId(projectRoot, config, changeId) {
+  if (changeId) return changeId;
+  const active = await getActiveChangeId(projectRoot, config);
+  if (!active) {
+    throw new Error("No active change. Pass --change <id> or run `sdd new`.");
+  }
+  return active;
+}
+
+export {
+  GateSchema,
+  ArtifactDefSchema,
+  VerifyCommandSchema,
+  StageSchema,
+  WorkflowSchema,
+  ConfigSchema,
+  ChangeMetaSchema,
+  slugify,
+  todayIsoDate,
+  nowIso,
+  changeDirName,
+  uniqueChangeDirName,
+  defaultsRoot,
+  defaultWorkflowsDir,
+  defaultTeamsDir,
+  defaultTemplatesDir,
+  defaultMemoryDir,
+  defaultMcpYamlPath,
+  defaultPricesYamlPath,
+  defaultSearchYamlPath,
+  listWorkflowNames,
+  listBundledWorkflowNames,
+  missingBundledWorkflows,
+  workflowUnavailableMessage,
+  loadWorkflow,
+  resolveStages,
+  isStageSkipped,
+  shouldAutoSkip,
+  activeStages,
+  getStage,
+  nextStageId,
+  firstActiveStageId,
+  inferComplexity,
+  recommendWorkflow,
+  loadChangeMeta,
+  saveChangeMeta,
+  buildContext,
+  listChanges,
+  getActiveChangeId,
+  clearActiveIf,
+  setActiveChange,
+  resolveChangeId
+};

package/dist/{chunk-EPFURATC.js → chunk-O5SP6X5R.js}

@@ -1,3 +1,73 @@
+// src/paths.ts
+import { join } from "pathe";
+var SDD_DIR = ".sdd";
+function sddRoot(projectRoot) {
+  return join(projectRoot, SDD_DIR);
+}
+function configPath(projectRoot) {
+  return join(sddRoot(projectRoot), "config.yaml");
+}
+function workflowsDir(projectRoot) {
+  return join(sddRoot(projectRoot), "workflows");
+}
+function templatesDir(projectRoot) {
+  return join(sddRoot(projectRoot), "templates");
+}
+function memoryDir(projectRoot, config) {
+  return join(projectRoot, config.memory_path);
+}
+function stripTrailingSlashes(value) {
+  let end = value.length;
+  while (end > 0 && value.charCodeAt(end - 1) === 47) end -= 1;
+  return value.slice(0, end);
+}
+function memoryPathRel(config) {
+  return stripTrailingSlashes(config.memory_path) || "memory";
+}
+function changesPathRel(config) {
+  return stripTrailingSlashes(config.changes_path) || "changes";
+}
+function displayArchivePath(config, changeId) {
+  return `${stripTrailingSlashes(config.archive_path) || "archive"}/${changeId}`;
+}
+function displayChangePath(config, changeId) {
+  return `${changesPathRel(config)}/${changeId}`;
+}
+function guidancePaths(config) {
+  const memory = memoryPathRel(config);
+  const changes = changesPathRel(config);
+  return {
+    memory,
+    changes,
+    constitution: `${memory}/constitution.md`,
+    memoryIndex: `${memory}/index.md`
+  };
+}
+function changesDir(projectRoot, config) {
+  return join(projectRoot, config.changes_path);
+}
+function archiveDir(projectRoot, config) {
+  return join(projectRoot, config.archive_path);
+}
+function domainsDir(projectRoot, config) {
+  return join(projectRoot, config.domains_path);
+}
+function changePath(projectRoot, config, changeId) {
+  return join(changesDir(projectRoot, config), changeId);
+}
+function changeMetaPath(projectRoot, config, changeId) {
+  return join(changePath(projectRoot, config, changeId), "meta.yaml");
+}
+function activePointerPath(projectRoot, config) {
+  return join(changesDir(projectRoot, config), ".active");
+}
+function searchConfigPath(projectRoot) {
+  return join(sddRoot(projectRoot), "search.yaml");
+}
+function indexDbPath(projectRoot) {
+  return join(sddRoot(projectRoot), "index.db");
+}
+
 // src/fs.ts
 import { promises as fs } from "fs";
 import { dirname } from "pathe";
@@ -81,6 +151,25 @@ async function removePath(path) {
 }
 
 export {
+  SDD_DIR,
+  sddRoot,
+  configPath,
+  workflowsDir,
+  templatesDir,
+  memoryDir,
+  memoryPathRel,
+  changesPathRel,
+  displayArchivePath,
+  displayChangePath,
+  guidancePaths,
+  changesDir,
+  archiveDir,
+  domainsDir,
+  changePath,
+  changeMetaPath,
+  activePointerPath,
+  searchConfigPath,
+  indexDbPath,
   pathExists,
   ensureDir,
   readText,