aienvmp 0.1.0

package/src/cli.js

@@ -0,0 +1,81 @@
+import { initWorkspace } from "./commands/init.js";
+import { scanWorkspace } from "./commands/scan.js";
+import { compileWorkspace } from "./commands/compile.js";
+import { diffWorkspace } from "./commands/diff.js";
+import { doctorWorkspace } from "./commands/doctor.js";
+import { dashWorkspace } from "./commands/dash.js";
+import { contextWorkspace } from "./commands/context.js";
+import { recordWorkspace } from "./commands/record.js";
+import { intentWorkspace } from "./commands/intent.js";
+import { resolveWorkspace } from "./commands/resolve.js";
+
+const commands = new Map([
+  ["init", initWorkspace],
+  ["scan", scanWorkspace],
+  ["compile", compileWorkspace],
+  ["diff", diffWorkspace],
+  ["doctor", doctorWorkspace],
+  ["dash", dashWorkspace],
+  ["context", contextWorkspace],
+  ["record", recordWorkspace],
+  ["intent", intentWorkspace],
+  ["resolve", resolveWorkspace]
+]);
+
+const version = "0.1.0";
+
+export async function main(argv) {
+  const [command, ...rest] = argv;
+  if (command === "-v" || command === "--version" || command === "version") {
+    console.log(version);
+    return;
+  }
+  if (!command || command === "-h" || command === "--help") {
+    printUsage();
+    return;
+  }
+  const run = commands.get(command);
+  if (!run) {
+    printUsage();
+    throw new Error(`unknown command "${command}"`);
+  }
+  await run(parseArgs(rest));
+}
+
+export function parseArgs(argv) {
+  const out = { _: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (!arg.startsWith("--")) {
+      out._.push(arg);
+      continue;
+    }
+    const [rawKey, inline] = arg.slice(2).split("=", 2);
+    const key = rawKey.replaceAll("-", "_");
+    if (inline !== undefined) {
+      out[key] = inline;
+    } else if (argv[i + 1] && !argv[i + 1].startsWith("--")) {
+      out[key] = argv[++i];
+    } else {
+      out[key] = true;
+    }
+  }
+  return out;
+}
+
+function printUsage() {
+  console.log(`aienvmp - AI-first env map + lightweight runtime SBOM
+
+Usage:
+  aienvmp init [--dir .]
+  aienvmp scan [--dir .]
+  aienvmp context [--dir .] [--json]
+  aienvmp intent [--dir .] --actor agent:codex --action "install pnpm"
+  aienvmp resolve [--dir .] --actor human:you --id <intent-id> [--status resolved|cancelled]
+  aienvmp record [--dir .] --actor agent:codex --summary "updated .nvmrc" [--target node] [--before 20] [--after 24]
+  aienvmp compile [--dir .] [--agents all|codex,claude,gemini]
+  aienvmp diff [--dir .]
+  aienvmp doctor [--dir .] [--json] [--ci]
+  aienvmp dash [--dir .] [--open]
+`);
+}

package/src/commands/compile.js

@@ -0,0 +1,41 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { diagnose } from "../doctor.js";
+import { readJson, replaceMarkerBlock } from "../fsutil.js";
+import { openIntents, readJsonl, readTimeline } from "../timeline.js";
+import { aiEnvPath, intentsPath, manifestPath, timelinePath, workspaceDir } from "../paths.js";
+import { markerBegin, markerEnd, renderAgentBlock, renderAIEnv } from "../render.js";
+import { loadPolicy, policyWarnings } from "../policy.js";
+
+const agentFiles = {
+  codex: "AGENTS.md",
+  claude: "CLAUDE.md",
+  gemini: "GEMINI.md"
+};
+
+export async function compileWorkspace(args) {
+  const dir = workspaceDir(args);
+  const manifest = await readJson(manifestPath(dir));
+  if (!manifest) throw new Error("missing manifest; run `aienvmp scan` first");
+  const timeline = await readTimeline(timelinePath(dir));
+  const intents = openIntents(await readJsonl(intentsPath(dir)));
+  const policy = await loadPolicy(dir);
+  const warnings = [...diagnose(manifest), ...policyWarnings(manifest, policy)];
+  const rendered = renderAIEnv(manifest, timeline, warnings, intents, policy);
+  await fs.writeFile(aiEnvPath(dir), rendered, "utf8");
+  const agents = parseAgents(args.agents);
+  const block = renderAgentBlock(manifest);
+  for (const agent of agents) {
+    const rel = agentFiles[agent];
+    if (!rel) continue;
+    await replaceMarkerBlock(path.join(dir, rel), markerBegin, markerEnd, block);
+  }
+  console.log(`compiled ${aiEnvPath(dir)}`);
+  if (agents.length) console.log(`injected: ${agents.join(", ")}`);
+}
+
+function parseAgents(value) {
+  if (!value) return [];
+  if (value === true || value === "all") return Object.keys(agentFiles);
+  return String(value).split(",").map((v) => v.trim()).filter(Boolean);
+}

package/src/commands/context.js

@@ -0,0 +1,33 @@
+import { diagnose } from "../doctor.js";
+import { readJson } from "../fsutil.js";
+import { openIntents, readJsonl, readTimeline } from "../timeline.js";
+import { intentsPath, manifestPath, timelinePath, workspaceDir } from "../paths.js";
+import { renderContext } from "../render.js";
+import { loadPolicy, policyWarnings } from "../policy.js";
+
+export async function contextWorkspace(args) {
+  const dir = workspaceDir(args);
+  const manifest = await readJson(manifestPath(dir));
+  if (!manifest) throw new Error("missing manifest; run `aienvmp scan` first");
+  const timeline = await readTimeline(timelinePath(dir));
+  const intents = openIntents(await readJsonl(intentsPath(dir)));
+  const policy = await loadPolicy(dir);
+  const warnings = [...diagnose(manifest), ...policyWarnings(manifest, policy)];
+  if (args.json) {
+    console.log(JSON.stringify({
+      status: warnings.length ? "review-required" : "clear",
+      workspace: manifest.workspace,
+      runtimes: manifest.runtimes,
+      packageManagers: manifest.packageManagers,
+      containers: manifest.containers,
+      projectHints: manifest.projectHints,
+      warnings,
+      policy,
+      intents: intents.slice(-5),
+      recentLedger: timeline.slice(-5),
+      protocol: manifest.agentProtocol
+    }, null, 2));
+    return;
+  }
+  console.log(renderContext(manifest, timeline, warnings, intents, policy));
+}

package/src/commands/dash.js

@@ -0,0 +1,35 @@
+import fs from "node:fs/promises";
+import { execFile } from "node:child_process";
+import path from "node:path";
+import { diagnose } from "../doctor.js";
+import { readJson } from "../fsutil.js";
+import { openIntents, readJsonl, readTimeline } from "../timeline.js";
+import { dashboardPath, intentsPath, manifestPath, timelinePath, workspaceDir } from "../paths.js";
+import { renderDashboard } from "../render.js";
+import { loadPolicy, policyWarnings } from "../policy.js";
+
+export async function dashWorkspace(args) {
+  const dir = workspaceDir(args);
+  const manifest = await readJson(manifestPath(dir));
+  if (!manifest) throw new Error("missing manifest; run `aienvmp scan` first");
+  const timeline = await readTimeline(timelinePath(dir));
+  const intents = openIntents(await readJsonl(intentsPath(dir)));
+  const policy = await loadPolicy(dir);
+  const warnings = [...diagnose(manifest), ...policyWarnings(manifest, policy)];
+  const html = renderDashboard(manifest, timeline, warnings, intents, policy);
+  const out = dashboardPath(dir);
+  await fs.mkdir(path.dirname(out), { recursive: true });
+  await fs.writeFile(out, html, "utf8");
+  console.log(`dashboard: ${out}`);
+  if (args.open) openFile(out);
+}
+
+function openFile(file) {
+  if (process.platform === "win32") {
+    execFile("cmd", ["/c", "start", "", file], { windowsHide: true });
+  } else if (process.platform === "darwin") {
+    execFile("open", [file]);
+  } else {
+    execFile("xdg-open", [file]);
+  }
+}

package/src/commands/diff.js

@@ -0,0 +1,23 @@
+import { diffManifests } from "../diff.js";
+import { readJson } from "../fsutil.js";
+import { manifestPath, previousManifestPath, workspaceDir } from "../paths.js";
+
+export async function diffWorkspace(args) {
+  const dir = workspaceDir(args);
+  const previous = await readJson(previousManifestPath(dir));
+  const current = await readJson(manifestPath(dir));
+  if (!current) throw new Error("missing manifest; run `aienvmp scan` first");
+  const changes = diffManifests(previous, current);
+  if (!changes.length) {
+    console.log("no environment changes detected");
+    return;
+  }
+  for (const change of changes) {
+    console.log(format(change));
+  }
+}
+
+function format(change) {
+  if (change.type === "changed") return `${change.scope} ${change.key}: ${change.before} -> ${change.after}`;
+  return `${change.scope} ${change.key}: ${change.type} ${change.after ?? change.before}`;
+}

package/src/commands/doctor.js

@@ -0,0 +1,34 @@
+import { diagnose } from "../doctor.js";
+import { readJson } from "../fsutil.js";
+import { manifestPath, workspaceDir } from "../paths.js";
+import { loadPolicy, policyWarnings } from "../policy.js";
+
+export async function doctorWorkspace(args) {
+  const dir = workspaceDir(args);
+  const manifest = await readJson(manifestPath(dir));
+  if (!manifest) throw new Error("missing manifest; run `aienvmp scan` first");
+  const policy = await loadPolicy(dir);
+  const warnings = [...diagnose(manifest), ...policyWarnings(manifest, policy)];
+  if (args.json) {
+    console.log(JSON.stringify({
+      status: warnings.length ? "warning" : "ok",
+      policy,
+      warnings
+    }, null, 2));
+    if (args.ci && warnings.length) {
+      process.exitCode = 1;
+    }
+    return;
+  }
+  if (!warnings.length) {
+    console.log("doctor: no blocking environment warnings detected");
+    return;
+  }
+  for (const warning of warnings) {
+    console.log(`[${warning.code}] ${warning.message}`);
+  }
+  console.log("doctor: warnings are non-blocking by default; pass --ci to fail automation.");
+  if (args.ci) {
+    process.exitCode = 1;
+  }
+}

package/src/commands/init.js

@@ -0,0 +1,19 @@
+import fs from "node:fs/promises";
+import { stateDir, workspaceDir } from "../paths.js";
+
+export async function initWorkspace(args) {
+  const dir = workspaceDir(args);
+  await fs.mkdir(stateDir(dir), { recursive: true });
+  await fs.writeFile(`${stateDir(dir)}/policy.yml`, [
+    "# aienvmp policy",
+    "# Keep this small and explicit so AI agents can avoid version drift.",
+    "# Default behavior is non-blocking: warn, ask, and record instead of locking.",
+    "# node: 24",
+    "# python: 3.11",
+    "# packageManager: npm",
+    "globalInstalls: ask-first",
+    "runtimeChanges: ask-first",
+    ""
+  ].join("\n"), { flag: "wx" }).catch(() => {});
+  console.log(`initialized ${stateDir(dir)}`);
+}

package/src/commands/intent.js

@@ -0,0 +1,26 @@
+import { appendJsonLine } from "../fsutil.js";
+import { intentsPath, workspaceDir } from "../paths.js";
+import { newIntentID } from "../timeline.js";
+
+export async function intentWorkspace(args) {
+  const dir = workspaceDir(args);
+  const actor = required(args.actor, "actor");
+  const action = required(args.action, "action");
+  const entry = {
+    at: new Date().toISOString(),
+    type: "intent",
+    actor,
+    action,
+    target: args.target || "",
+    reason: args.reason || "",
+    status: "open"
+  };
+  entry.id = newIntentID();
+  await appendJsonLine(intentsPath(dir), entry);
+  console.log(`intent recorded: ${entry.id}`);
+}
+
+function required(value, name) {
+  if (!value) throw new Error(`intent: --${name} is required`);
+  return String(value);
+}

package/src/commands/record.js

@@ -0,0 +1,26 @@
+import { appendJsonLine } from "../fsutil.js";
+import { timelinePath, workspaceDir } from "../paths.js";
+
+export async function recordWorkspace(args) {
+  const dir = workspaceDir(args);
+  const actor = required(args.actor, "actor");
+  const summary = required(args.summary || args.change, "summary");
+  const entry = {
+    at: new Date().toISOString(),
+    actor,
+    type: args.type || "agent-record",
+    summary,
+    target: args.target || "",
+    before: args.before || "",
+    after: args.after || "",
+    evidence: args.evidence || "",
+    requiresReview: args.review === true || args.review === "true"
+  };
+  await appendJsonLine(timelinePath(dir), entry);
+  console.log(`recorded ${entry.type} by ${actor}`);
+}
+
+function required(value, name) {
+  if (!value) throw new Error(`record: --${name} is required`);
+  return String(value);
+}

package/src/commands/resolve.js

@@ -0,0 +1,35 @@
+import { appendJsonLine } from "../fsutil.js";
+import { readJsonl, openIntents } from "../timeline.js";
+import { intentsPath, workspaceDir } from "../paths.js";
+
+export async function resolveWorkspace(args) {
+  const dir = workspaceDir(args);
+  const actor = required(args.actor, "actor");
+  const requested = required(args.id || args.ref, "id");
+  const ref = await resolveIntentRef(dir, requested);
+  const entry = {
+    at: new Date().toISOString(),
+    type: "intent-resolved",
+    actor,
+    ref,
+    status: args.status || "resolved",
+    reason: args.reason || ""
+  };
+  await appendJsonLine(intentsPath(dir), entry);
+  console.log(`intent ${entry.status}: ${ref}`);
+}
+
+function required(value, name) {
+  if (!value) throw new Error(`resolve: --${name} is required`);
+  return String(value);
+}
+
+async function resolveIntentRef(dir, requested) {
+  const open = openIntents(await readJsonl(intentsPath(dir)));
+  const matches = open.filter((intent) => intent.id === requested || intent.id.startsWith(requested));
+  if (matches.length === 1) return matches[0].id;
+  if (matches.length > 1) {
+    throw new Error(`resolve: "${requested}" matches multiple open intents`);
+  }
+  return requested;
+}

package/src/commands/scan.js

@@ -0,0 +1,28 @@
+import fs from "node:fs/promises";
+import { buildManifest } from "../manifest.js";
+import { diffManifests } from "../diff.js";
+import { appendJsonLine, exists, readJson, writeJson } from "../fsutil.js";
+import { manifestPath, previousManifestPath, timelinePath, workspaceDir } from "../paths.js";
+
+export async function scanWorkspace(args) {
+  const dir = workspaceDir(args);
+  const currentPath = manifestPath(dir);
+  const previous = await readJson(currentPath, null);
+  if (previous && await exists(currentPath)) {
+    await fs.copyFile(currentPath, previousManifestPath(dir));
+  }
+  const manifest = await buildManifest(dir);
+  await writeJson(currentPath, manifest);
+  const changes = diffManifests(previous, manifest);
+  for (const change of changes) {
+    await appendJsonLine(timelinePath(dir), {
+      at: manifest.generatedAt,
+      actor: "system:scan",
+      type: "detected-change",
+      change
+    });
+  }
+  console.log(`scanned ${dir}`);
+  console.log(`manifest: ${currentPath}`);
+  console.log(`changes: ${changes.length}`);
+}

package/src/diff.js

@@ -0,0 +1,23 @@
+export function diffManifests(previous, current) {
+  if (!previous) return [];
+  const changes = [];
+  compareFlat("runtime", previous.runtimes || {}, current.runtimes || {}, changes);
+  compareFlat("package-manager", previous.packageManagers || {}, current.packageManagers || {}, changes);
+  compareFlat("container", previous.containers || {}, current.containers || {}, changes);
+  compareFlat("project-hint", previous.projectHints || {}, current.projectHints || {}, changes);
+  compareFlat("agent-file", previous.agentFiles || {}, current.agentFiles || {}, changes);
+  return changes;
+}
+
+function compareFlat(scope, before, after, changes) {
+  const keys = new Set([...Object.keys(before), ...Object.keys(after)]);
+  for (const key of [...keys].sort()) {
+    if (before[key] === undefined && after[key] !== undefined) {
+      changes.push({ scope, key, type: "added", after: after[key] });
+    } else if (before[key] !== undefined && after[key] === undefined) {
+      changes.push({ scope, key, type: "removed", before: before[key] });
+    } else if (JSON.stringify(before[key]) !== JSON.stringify(after[key])) {
+      changes.push({ scope, key, type: "changed", before: before[key], after: after[key] });
+    }
+  }
+}

package/src/doctor.js

@@ -0,0 +1,38 @@
+export function diagnose(manifest) {
+  const warnings = [];
+  const hints = manifest.projectHints || {};
+  const runtimes = manifest.runtimes || {};
+  if (hints.nvmrc && runtimes.node && !String(runtimes.node).startsWith(String(hints.nvmrc).replace(/^v/, ""))) {
+    warnings.push({
+      code: "node-version-mismatch",
+      message: `.nvmrc requests ${hints.nvmrc}, but detected node is ${runtimes.node}.`
+    });
+  }
+  const py = runtimes.python || runtimes.python3;
+  if (hints.pythonVersion && py && !String(py).startsWith(String(hints.pythonVersion))) {
+    warnings.push({
+      code: "python-version-mismatch",
+      message: `.python-version requests ${hints.pythonVersion}, but detected python is ${py}.`
+    });
+  }
+  const locks = ["packageLock", "pnpmLock", "yarnLock"].filter((key) => hints[key]);
+  if (locks.length > 1) {
+    warnings.push({
+      code: "mixed-node-lockfiles",
+      message: `Multiple Node lockfiles detected: ${locks.join(", ")}. Prefer one package manager.`
+    });
+  }
+  if ((hints.pyproject || hints.requirements) && !py) {
+    warnings.push({
+      code: "python-missing",
+      message: "Python project hints detected, but no Python runtime was found."
+    });
+  }
+  if (hints.dockerfile && !manifest.containers?.docker) {
+    warnings.push({
+      code: "docker-missing",
+      message: "Dockerfile detected, but Docker CLI was not found."
+    });
+  }
+  return warnings;
+}

package/src/fsutil.js

@@ -0,0 +1,51 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+export async function exists(file) {
+  try {
+    await fs.access(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function readJson(file, fallback = null) {
+  try {
+    return JSON.parse(await fs.readFile(file, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+
+export async function writeJson(file, data) {
+  await fs.mkdir(path.dirname(file), { recursive: true });
+  await fs.writeFile(file, `${JSON.stringify(data, null, 2)}\n`, "utf8");
+}
+
+export async function appendJsonLine(file, data) {
+  await fs.mkdir(path.dirname(file), { recursive: true });
+  await fs.appendFile(file, `${JSON.stringify(data)}\n`, "utf8");
+}
+
+export async function replaceMarkerBlock(file, begin, end, block) {
+  let current = "";
+  try {
+    current = await fs.readFile(file, "utf8");
+  } catch {
+    current = "";
+  }
+  const start = current.indexOf(begin);
+  const finish = current.indexOf(end);
+  const rendered = `${begin}\n${block.trimEnd()}\n${end}`;
+  let next;
+  if (start >= 0 && finish > start) {
+    next = current.slice(0, start) + rendered + current.slice(finish + end.length);
+  } else if (start < 0 && finish < 0) {
+    const sep = current.trim() ? "\n\n" : "";
+    next = `${current.trimEnd()}${sep}${rendered}\n`;
+  } else {
+    throw new Error(`${path.basename(file)} has a broken aienvmp marker block`);
+  }
+  await fs.writeFile(file, next, "utf8");
+}

package/src/manifest.js

@@ -0,0 +1,130 @@
+import os from "node:os";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { commandOutput, commandVersion } from "./shell.js";
+import { exists } from "./fsutil.js";
+
+export async function buildManifest(dir) {
+  const now = new Date().toISOString();
+  const manifest = {
+    schemaVersion: 1,
+    generatedAt: now,
+    workspace: {
+      path: dir,
+      name: path.basename(dir)
+    },
+    os: await scanOS(),
+    runtimes: await scanRuntimes(),
+    packageManagers: await scanPackageManagers(),
+    containers: await scanContainers(),
+    projectHints: await scanProjectHints(dir),
+    agentFiles: await scanAgentFiles(dir),
+    agentProtocol: {
+      sourceOfTruth: "AIENV.md",
+      preflightCommand: "aienvmp context",
+      intentCommand: "aienvmp intent --actor <agent:id> --action <planned-change>",
+      recordCommand: "aienvmp record --actor <agent:id> --summary <what-changed>",
+      afterEnvironmentChange: ["aienvmp scan", "aienvmp compile"],
+      globalRuntimeChangeRequiresUserApproval: true,
+      globalInstallPolicy: "ask-first",
+      projectLocalChanges: "allowed-when-task-requires"
+    }
+  };
+  return manifest;
+}
+
+async function scanOS() {
+  return {
+    platform: os.platform(),
+    release: os.release(),
+    arch: os.arch(),
+    hostname: os.hostname(),
+    shell: process.env.SHELL || process.env.ComSpec || ""
+  };
+}
+
+async function scanRuntimes() {
+  return compact({
+    node: await commandVersion("node"),
+    python: await commandVersion("python"),
+    python3: await commandVersion("python3"),
+    go: await commandVersion("go", ["version"]),
+    java: await commandVersion("java", ["-version"]),
+    rustc: await commandVersion("rustc", ["--version"])
+  });
+}
+
+async function scanPackageManagers() {
+  return compact({
+    npm: await commandVersion(process.platform === "win32" ? "npm.cmd" : "npm"),
+    pnpm: await commandVersion(process.platform === "win32" ? "pnpm.cmd" : "pnpm"),
+    yarn: await commandVersion(process.platform === "win32" ? "yarn.cmd" : "yarn"),
+    uv: await commandVersion("uv"),
+    pip: await commandVersion("pip"),
+    pipx: await commandVersion("pipx"),
+    mise: await commandVersion("mise"),
+    asdf: await commandVersion("asdf"),
+    pyenv: await commandVersion("pyenv"),
+    nvm: await commandVersion("nvm"),
+    fnm: await commandVersion("fnm"),
+    volta: await commandVersion("volta")
+  });
+}
+
+async function scanContainers() {
+  return compact({
+    docker: await commandVersion("docker", ["--version"]),
+    compose: await dockerComposeVersion()
+  });
+}
+
+async function dockerComposeVersion() {
+  const v2 = await commandOutput("docker", ["compose", "version"]);
+  if (v2) return v2.replace(/^Docker Compose version\s+/i, "");
+  return await commandVersion(process.platform === "win32" ? "docker-compose.exe" : "docker-compose");
+}
+
+async function scanProjectHints(dir) {
+  const hints = {};
+  for (const [key, file] of [
+    ["nvmrc", ".nvmrc"],
+    ["pythonVersion", ".python-version"],
+    ["mise", "mise.toml"],
+    ["toolVersions", ".tool-versions"],
+    ["packageJson", "package.json"],
+    ["pyproject", "pyproject.toml"],
+    ["requirements", "requirements.txt"],
+    ["dockerfile", "Dockerfile"],
+    ["packageLock", "package-lock.json"],
+    ["pnpmLock", "pnpm-lock.yaml"],
+    ["yarnLock", "yarn.lock"]
+  ]) {
+    const full = path.join(dir, file);
+    if (!(await exists(full))) continue;
+    if (["nvmrc", "pythonVersion"].includes(key)) {
+      hints[key] = (await fs.readFile(full, "utf8")).trim();
+    } else {
+      hints[key] = true;
+    }
+  }
+  return hints;
+}
+
+async function scanAgentFiles(dir) {
+  const files = {
+    agents: "AGENTS.md",
+    claude: "CLAUDE.md",
+    gemini: "GEMINI.md",
+    cursor: path.join(".cursor", "rules", "environment.md"),
+    copilot: path.join(".github", "copilot-instructions.md")
+  };
+  const out = {};
+  for (const [name, rel] of Object.entries(files)) {
+    out[name] = await exists(path.join(dir, rel));
+  }
+  return out;
+}
+
+function compact(obj) {
+  return Object.fromEntries(Object.entries(obj).filter(([, value]) => value));
+}

package/src/paths.js

@@ -0,0 +1,33 @@
+import path from "node:path";
+
+export function workspaceDir(args) {
+  return path.resolve(String(args.dir || "."));
+}
+
+export function stateDir(dir) {
+  return path.join(dir, ".aienvmp");
+}
+
+export function manifestPath(dir) {
+  return path.join(stateDir(dir), "manifest.json");
+}
+
+export function previousManifestPath(dir) {
+  return path.join(stateDir(dir), "manifest.previous.json");
+}
+
+export function timelinePath(dir) {
+  return path.join(stateDir(dir), "timeline.jsonl");
+}
+
+export function intentsPath(dir) {
+  return path.join(stateDir(dir), "intents.jsonl");
+}
+
+export function dashboardPath(dir) {
+  return path.join(stateDir(dir), "dashboard.html");
+}
+
+export function aiEnvPath(dir) {
+  return path.join(dir, "AIENV.md");
+}