ultimate-brain 0.0.0-stage → 0.2.0

package/dist/commands/link.js

@@ -0,0 +1,285 @@
+import { lstat, readdir, readFile, realpath, stat, unlink } from "node:fs/promises";
+import { basename, join, resolve } from "node:path";
+import { isProductRepository } from "../lib/brain-path.js";
+import { BrainError } from "../lib/errors.js";
+import { atomicWriteFile, ensureDirectory } from "../lib/fs-safe.js";
+import { scanNotes } from "../lib/notes.js";
+import { assertPlainPath, listShippedSkillFiles } from "../lib/skills.js";
+const START = "<!-- ultimate-brain:start -->";
+const END = "<!-- ultimate-brain:end -->";
+const STACK = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+/** `brain link <repo-path>` (spec/cli.md §5.12). */
+export const linkCommand = {
+    name: "link",
+    usage: "brain link <repo-path> [--project <id>] [--area <id>] [--stack <name>]… [--repo-name <name>] [--json]",
+    summary: "Link a consuming repository to this brain and install its consult instruction.",
+    options: { project: "string", area: "string", stack: "list", "repo-name": "string" },
+    maxPositionals: 1,
+    needsBrain: true,
+    async run({ args, brain }) {
+        const [requested] = args.positionals;
+        if (requested === undefined)
+            throw new BrainError("USAGE", "brain link needs a repository path");
+        const root = await openRepo(requested);
+        if (root === brain.root || await isProductRepository(root)) {
+            throw new BrainError("OUTSIDE_ROOT", "Refusing to write a brain or product repository as a consuming repository");
+        }
+        const { notes } = await scanNotes(brain.root);
+        const existingMarker = await readMarker(root);
+        const marker = buildMarker(existingMarker, root, args.options, notes);
+        const project = marker.project === undefined ? undefined : noteOf(notes, marker.project, "project");
+        const area = marker.area === undefined ? undefined : noteOf(notes, marker.area, "area");
+        const block = instructionBlock(project, area);
+        const agents = await readOptional(root, "AGENTS.md");
+        const claude = await readOptional(root, "CLAUDE.md");
+        const agentText = replaceOrAppend(agents, block, "AGENTS.md");
+        const claudeText = claude === null
+            ? "@AGENTS.md\n"
+            : hasAgentImport(claude) ? claude : replaceOrAppend(claude, block, "CLAUDE.md");
+        const planned = [
+            { path: ".brain", before: existingMarker.raw, after: `${JSON.stringify(marker, null, 2)}\n` },
+            { path: "AGENTS.md", before: agents, after: agentText },
+            { path: "CLAUDE.md", before: claude, after: claudeText },
+            ...await planSkill(root),
+        ];
+        await writePlan(root, planned);
+        const action = (file) => file.before === null ? "created" : file.after === null ? "removed" : file.before === file.after ? "unchanged" : "updated";
+        return {
+            data: {
+                repo_abs: root,
+                marker: { path: ".brain", written: planned[0].before !== planned[0].after, value: marker },
+                files: planned.slice(1).map((file) => ({ path: file.path, action: action(file) })),
+            },
+            human: `Linked ${root} to the brain.\n`,
+        };
+    },
+};
+async function openRepo(requested) {
+    const path = resolve(requested);
+    try {
+        if (!(await stat(path)).isDirectory())
+            throw new BrainError("USAGE", `Repository path is not a directory: ${path}`);
+        return await realpath(path);
+    }
+    catch (error) {
+        if (error instanceof BrainError)
+            throw error;
+        throw new BrainError("USAGE", `Repository path does not exist or cannot be read: ${path}`);
+    }
+}
+async function readMarker(root) {
+    const raw = await readOptional(root, ".brain");
+    if (raw === null)
+        return { raw, value: {} };
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new BrainError("INPUT_INVALID", `.brain is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!isMarker(parsed))
+        throw new BrainError("INPUT_INVALID", ".brain must be an object with only repo, project, area and stacks");
+    return { raw, value: parsed };
+}
+function buildMarker(previous, root, options, notes) {
+    const marker = { ...previous.value };
+    marker.repo = options["repo-name"] ?? basename(root);
+    const requestedProject = options.project;
+    const requestedArea = options.area;
+    if (requestedProject !== undefined) {
+        const project = noteOf(notes, requestedProject, "project");
+        marker.project = project.id;
+        marker.area = requestedArea === undefined ? areaOf(project) : noteOf(notes, requestedArea, "area").id;
+    }
+    else if (requestedArea !== undefined) {
+        marker.area = noteOf(notes, requestedArea, "area").id;
+    }
+    if (options.stack !== undefined) {
+        const rawStacks = options.stack;
+        for (const stack of rawStacks) {
+            if (!STACK.test(stack))
+                throw new BrainError("USAGE", `--stack must be lowercase kebab-case: ${stack}`);
+        }
+        marker.stacks = [...new Set(rawStacks)].sort();
+    }
+    if (marker.project !== undefined)
+        noteOf(notes, marker.project, "project");
+    if (marker.area !== undefined)
+        noteOf(notes, marker.area, "area");
+    if (marker.stacks !== undefined)
+        marker.stacks = canonicalStacks(marker.stacks);
+    return orderedMarker(marker);
+}
+function areaOf(project) {
+    if (typeof project.attributes.area !== "string") {
+        throw new BrainError("UNKNOWN_ID", `Project ${project.id} has no area`);
+    }
+    return project.attributes.area;
+}
+function noteOf(notes, id, type) {
+    const note = notes.find((candidate) => candidate.id === id && candidate.type === type);
+    if (note === undefined)
+        throw new BrainError("UNKNOWN_ID", `No ${type} with id ${id}`);
+    return note;
+}
+function canonicalStacks(stacks) {
+    if (!stacks.every((stack) => typeof stack === "string" && STACK.test(stack))) {
+        throw new BrainError("INPUT_INVALID", ".brain stacks must be lowercase kebab-case strings");
+    }
+    return [...new Set(stacks)].sort();
+}
+function orderedMarker(marker) {
+    const ordered = {};
+    if (marker.repo !== undefined)
+        ordered.repo = marker.repo;
+    if (marker.project !== undefined)
+        ordered.project = marker.project;
+    if (marker.area !== undefined)
+        ordered.area = marker.area;
+    if (marker.stacks !== undefined)
+        ordered.stacks = marker.stacks;
+    return ordered;
+}
+function instructionBlock(project, area) {
+    const lines = [
+        START,
+        "## Ultimate Brain",
+        "",
+        "Managed by `brain link`; edits inside this block are overwritten.",
+        "",
+        `This repo is linked to the user's second brain${project === undefined && area === undefined ? "." : ":"}`,
+    ];
+    if (project !== undefined)
+        lines.push(`- Project: ${String(project.attributes.title)} (\`${project.id}\`)`);
+    if (area !== undefined)
+        lines.push(`- Area: ${String(area.attributes.title)} (\`${area.id}\`)`);
+    lines.push("", "The brain holds decisions, key facts, people and meeting history that this repo does not.", "", "Consult it before you:", "- make or revisit a decision about scope, architecture, vendors or the client;", "- answer why something was decided, who someone is, or a date, budget or owner;", "- rely on a fact about the client or project that this repo does not state.", "", "How: use the `brain-query` skill, or run `brain query --candidates \"<question>\" --json` and read the notes it returns. Cite the note paths. Say when a fact is `contested` or `superseded`.", "", "The brain is read-only from this repo. Never edit its files from here.", END);
+    return lines.join("\n");
+}
+function replaceOrAppend(existing, block, file) {
+    if (existing === null || existing === "")
+        return `${block}\n`;
+    const range = blockRange(existing);
+    if (range !== undefined)
+        return `${existing.slice(0, range.start)}${block}${existing.slice(range.end)}`;
+    if (existing.includes(START) || existing.includes(END)) {
+        throw new BrainError("INPUT_INVALID", `${file} has malformed Ultimate Brain markers`);
+    }
+    return `${existing}${existing.endsWith("\n\n") ? "" : existing.endsWith("\n") ? "\n" : "\n\n"}${block}\n`;
+}
+function blockRange(content) {
+    const start = markerPositions(content, START);
+    const end = markerPositions(content, END);
+    if (start.length === 0 && end.length === 0)
+        return undefined;
+    if (start.length !== 1 || end.length !== 1 || start[0] >= end[0]) {
+        throw new BrainError("INPUT_INVALID", "Ultimate Brain markers must appear exactly once and in order");
+    }
+    return { start: start[0], end: end[0] + END.length };
+}
+function markerPositions(content, marker) {
+    const expression = new RegExp(`(?:^|\\n)${escapeRegExp(marker)}(?=\\n|$)`, "g");
+    return [...content.matchAll(expression)].map((match) => match.index + (match[0].startsWith("\n") ? 1 : 0));
+}
+function hasAgentImport(content) {
+    return content.split(/\r?\n/).some((line) => line === "@AGENTS.md");
+}
+async function readOptional(root, path) {
+    try {
+        const target = `${root}/${path}`;
+        if ((await lstat(target)).isSymbolicLink())
+            throw new BrainError("OUTSIDE_ROOT", `Refusing to replace a symbolic link: ${target}`);
+        return await readFile(target, "utf8");
+    }
+    catch (error) {
+        if (error instanceof BrainError)
+            throw error;
+        if (isNodeError(error) && error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+/** Product-owned `.agents/skills/brain-query/` (decision 0029): replace changed files, remove stale ones. */
+async function planSkill(root) {
+    const shipped = await listShippedSkillFiles("brain-query");
+    const planned = [];
+    const keep = new Set();
+    await assertPlainPath(root, ".agents/skills/brain-query", "folder");
+    for (const file of shipped) {
+        const path = `.agents/skills/${file.relative}`;
+        await assertPlainPath(root, path);
+        keep.add(path);
+        planned.push({ path, before: await readOptional(root, path), after: file.content.toString("utf8") });
+    }
+    const folder = ".agents/skills/brain-query";
+    for (const path of await listFiles(root, folder)) {
+        await assertPlainPath(root, path);
+        if (!keep.has(path))
+            planned.push({ path, before: await readOptional(root, path), after: null });
+    }
+    return planned.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+}
+async function listFiles(root, folder) {
+    let entries;
+    try {
+        entries = await readdir(join(root, folder), { withFileTypes: true });
+    }
+    catch (error) {
+        if (isNodeError(error) && (error.code === "ENOENT" || error.code === "ENOTDIR"))
+            return [];
+        throw error;
+    }
+    const paths = [];
+    for (const entry of entries) {
+        const path = `${folder}/${entry.name}`;
+        if (entry.isDirectory())
+            paths.push(...await listFiles(root, path));
+        else
+            paths.push(path);
+    }
+    return paths;
+}
+async function writePlan(root, files) {
+    const changed = files.filter((file) => file.before !== file.after);
+    const done = [];
+    try {
+        for (const file of changed) {
+            if (file.after === null)
+                await unlink(`${root}/${file.path}`);
+            else {
+                await ensureDirectory(root, file.path.split("/").slice(0, -1).join("/") || ".");
+                await atomicWriteFile(root, file.path, file.after);
+            }
+            done.push(file);
+        }
+    }
+    catch (error) {
+        for (const file of done.reverse()) {
+            if (file.before === null)
+                await unlink(`${root}/${file.path}`).catch(() => undefined);
+            else
+                await atomicWriteFile(root, file.path, file.before).catch(() => undefined);
+        }
+        throw error;
+    }
+}
+function isMarker(value) {
+    if (!isRecord(value))
+        return false;
+    if (!Object.keys(value).every((key) => ["repo", "project", "area", "stacks"].includes(key)))
+        return false;
+    return (value.repo === undefined || typeof value.repo === "string")
+        && (value.project === undefined || typeof value.project === "string")
+        && (value.area === undefined || typeof value.area === "string")
+        && (value.stacks === undefined || Array.isArray(value.stacks));
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function isNodeError(error) {
+    return error instanceof Error && "code" in error;
+}

package/dist/commands/lint.js

@@ -0,0 +1,47 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { posix } from "node:path";
+import { BrainError } from "../lib/errors.js";
+import { lintBrain } from "../lib/lint.js";
+import { scanNotes } from "../lib/notes.js";
+/** `brain lint [<path>…] [--strict]` (spec/cli.md §5.10). */
+export const lintCommand = {
+    name: "lint",
+    usage: "brain lint [<path>…] [--strict] [--json]",
+    summary: "Validate notes, links and brain.json against the schema. Exits 1 on errors (or warnings with --strict).",
+    options: { strict: "boolean" },
+    needsBrain: true,
+    async run({ args, brain }) {
+        const root = brain.root;
+        const { notes, problems } = await scanNotes(root);
+        let indexMarkdown;
+        try {
+            indexMarkdown = await readFile(join(root, "index.md"), "utf8");
+        }
+        catch {
+            indexMarkdown = null;
+        }
+        const all = lintBrain({ root, notes, problems, brainConfig: brain.config, indexMarkdown });
+        // Path filters: note files, brain-relative folders (prefix match), brain.json, index.md. brain.json is always checked.
+        const known = new Set([...notes.map((note) => note.path), ...problems.map((problem) => problem.path), "brain.json", "index.md"]);
+        const filters = args.positionals.map((path) => posix.normalize(path).replace(/^\.\//, "").replace(/\/$/, ""));
+        for (const filter of filters) {
+            if (!known.has(filter) && ![...known].some((path) => path.startsWith(`${filter}/`))) {
+                throw new BrainError("USAGE", `No note file or folder "${filter}" in the brain`);
+            }
+        }
+        const matches = (path) => path === "brain.json" || filters.some((filter) => path === filter || path.startsWith(`${filter}/`));
+        const issues = filters.length === 0 ? all : all.filter((issue) => matches(issue.path));
+        const errors = issues.filter((issue) => issue.severity === "error").length;
+        const warnings = issues.length - errors;
+        const failed = errors > 0 || (args.options.strict === true && warnings > 0);
+        const human = issues.length === 0
+            ? "No issues.\n"
+            : `${issues.map((issue) => `${issue.path}:${issue.line} ${issue.severity} ${issue.rule}: ${issue.message}`).join("\n")}\n${errors} errors, ${warnings} warnings\n`;
+        return {
+            data: { errors, warnings, files: notes.length + problems.length, issues },
+            exitCode: failed ? 1 : 0,
+            human,
+        };
+    },
+};

package/dist/commands/log.js

@@ -0,0 +1,48 @@
+import { BrainError } from "../lib/errors.js";
+import { appendLog, formatLogLine } from "../lib/log.js";
+import { scanNotes } from "../lib/notes.js";
+const OP = /^[a-z][a-z0-9-]*$/;
+const KEY = /^[a-z][a-z0-9_]*$/;
+/** `brain log <op> [<id>] [--title <title>] [<key>=<value>…]` (spec/cli.md §5.11). */
+export const logCommand = {
+    name: "log",
+    usage: "brain log <op> [<id>|-] [--title <title>] [<key>=<value>…] [--json]",
+    summary: "Append one operation line to log/<YYYY-MM>.md.",
+    options: { title: "string" },
+    needsBrain: true,
+    async run({ args, brain, now }) {
+        const [op, ...rest] = args.positionals;
+        if (op === undefined || !OP.test(op)) {
+            throw new BrainError("USAGE", "brain log needs an <op> matching [a-z][a-z0-9-]*");
+        }
+        let id = "-";
+        const pairs = [];
+        for (const [index, value] of rest.entries()) {
+            const equals = value.indexOf("=");
+            if (equals !== -1) {
+                const key = value.slice(0, equals);
+                if (!KEY.test(key))
+                    throw new BrainError("USAGE", `Invalid key "${key}": keys match [a-z][a-z0-9_]*`);
+                pairs.push([key, value.slice(equals + 1)]);
+            }
+            else if (index === 0) {
+                id = value;
+            }
+            else {
+                throw new BrainError("USAGE", `Expected <key>=<value>, got "${value}"`);
+            }
+        }
+        let title = args.options.title;
+        if (id !== "-") {
+            const { notes } = await scanNotes(brain.root);
+            const note = notes.find((candidate) => candidate.id === id);
+            if (note === undefined)
+                throw new BrainError("UNKNOWN_ID", `No note with id ${id}`);
+            title ??= typeof note.attributes.title === "string" ? note.attributes.title : "";
+        }
+        const entry = { op, id, title: title ?? "", pairs };
+        const path = await appendLog(brain.root, now, [entry]);
+        const line = formatLogLine(now, entry);
+        return { data: { path, line }, human: `${line}\n` };
+    },
+};

package/dist/commands/note.js

@@ -0,0 +1,36 @@
+import { assertNoProblems, isRecord, readJsonInput, unknownKeys } from "../lib/input.js";
+import { assertStagedValid, checkNoteInput, stageNotes } from "../lib/note-new.js";
+import { Workspace } from "../lib/workspace.js";
+import { lintWarnings } from "../lib/warnings.js";
+/** `brain note new --input <file|-> [--dry-run]` (spec/cli.md §5.5). */
+export const noteNewCommand = {
+    name: "note new",
+    usage: "brain note new --input <file|-> [--dry-run] [--json]",
+    summary: "Write new draft notes from JSON input. All or nothing; never changes an existing note.",
+    options: { input: "string", "dry-run": "boolean" },
+    maxPositionals: 0,
+    needsBrain: true,
+    async run({ args, brain, now }) {
+        const input = await readJsonInput(args.options.input, "note new");
+        if (!isRecord(input))
+            assertNoProblems([{ pointer: "", message: "must be an object with a notes list" }]);
+        const record = input;
+        const problems = unknownKeys(record, ["notes"], "");
+        if (!Array.isArray(record.notes))
+            problems.push({ pointer: "/notes", message: "must be a list" });
+        else
+            record.notes.forEach((item, index) => problems.push(...checkNoteInput(item, `/notes/${index}`)));
+        assertNoProblems(problems);
+        const dryRun = args.options["dry-run"] === true;
+        const workspace = await Workspace.open(brain);
+        const staged = stageNotes(workspace, record.notes, (index) => `/notes/${index}`, { now });
+        assertStagedValid(workspace, staged.pointers, "/notes");
+        const warnings = lintWarnings(workspace.warnings());
+        if (!dryRun) {
+            await workspace.commit(staged.created.map((note) => ({ op: "note-new", id: note.id, title: note.title })), now);
+        }
+        const human = staged.created.map((note) => `${dryRun ? "would create" : "created"} ${note.path}\n`).join("")
+            + staged.skipped.map((skip) => `skipped notes[${skip.input_index}]: same content as ${skip.existing}\n`).join("");
+        return { data: { created: staged.created, skipped: staged.skipped, dry_run: dryRun }, warnings, human: human || "Nothing to write.\n" };
+    },
+};

package/dist/commands/proposal.js

@@ -0,0 +1,57 @@
+import { BrainError } from "../lib/errors.js";
+import { assertNoProblems, isRecord, readJsonInput, unknownKeys } from "../lib/input.js";
+import { listProposals, PROPOSAL_STATUSES, stageProposals } from "../lib/proposals.js";
+import { Workspace } from "../lib/workspace.js";
+import { lintWarnings } from "../lib/warnings.js";
+/** `brain proposal new --input <file|-> [--dry-run]` (spec/cli.md §5.6). */
+export const proposalNewCommand = {
+    name: "proposal new",
+    usage: "brain proposal new --input <file|-> [--dry-run] [--json]",
+    summary: "Write pending proposals for changes to existing knowledge. All or nothing; skips duplicates of pending proposals.",
+    options: { input: "string", "dry-run": "boolean" },
+    maxPositionals: 0,
+    needsBrain: true,
+    async run({ args, brain, now }) {
+        const input = await readJsonInput(args.options.input, "proposal new");
+        if (!isRecord(input))
+            assertNoProblems([{ pointer: "", message: "must be an object with a proposals list" }]);
+        const record = input;
+        assertNoProblems(unknownKeys(record, ["proposals"], ""));
+        const dryRun = args.options["dry-run"] === true;
+        const workspace = await Workspace.open(brain);
+        const { created, skipped } = stageProposals(workspace, record.proposals, now);
+        const warnings = lintWarnings(workspace.warnings());
+        if (!dryRun) {
+            await workspace.commit(created.map((proposal) => ({
+                op: "proposal-new",
+                id: proposal.id,
+                title: proposal.title,
+                pairs: proposal.target === undefined ? [["kind", proposal.kind]] : [["kind", proposal.kind], ["target", proposal.target]],
+            })), now);
+        }
+        const human = created.map((proposal) => `${dryRun ? "would create" : "created"} ${proposal.path}\n`).join("")
+            + skipped.map((skip) => `skipped proposals[${skip.input_index}]: same as pending ${skip.existing}\n`).join("");
+        return { data: { created, skipped, dry_run: dryRun }, warnings, human: human || "Nothing to write.\n" };
+    },
+};
+/** `brain proposal list [--status <s>[,<s>…]] [--target <id>]` (spec/cli.md §5.6). */
+export const proposalListCommand = {
+    name: "proposal list",
+    usage: "brain proposal list [--status <s>[,<s>…]] [--target <id>] [--json]",
+    summary: "List proposals, filtered by status and target, sorted by created then id.",
+    options: { status: "string", target: "string" },
+    maxPositionals: 0,
+    needsBrain: true,
+    async run({ args, brain }) {
+        const statuses = typeof args.options.status === "string" ? args.options.status.split(",").map((status) => status.trim()).filter((status) => status !== "") : [];
+        const unknown = statuses.filter((status) => !PROPOSAL_STATUSES.includes(status));
+        if (unknown.length > 0)
+            throw new BrainError("USAGE", `Unknown status ${unknown.join(", ")}; use ${PROPOSAL_STATUSES.join(", ")}`);
+        const workspace = await Workspace.open(brain);
+        const proposals = listProposals(workspace, statuses, args.options.target);
+        const human = proposals.length === 0
+            ? "No proposals.\n"
+            : proposals.map((proposal) => `${String(proposal.id)} ${String(proposal.status)} ${String(proposal.kind)} ${String(proposal.title)}\n`).join("");
+        return { data: { proposals }, human };
+    },
+};

package/dist/commands/query.js

@@ -0,0 +1,38 @@
+import { BrainError } from "../lib/errors.js";
+import { scanNotes } from "../lib/notes.js";
+import { queryContext, queryTypes, queryWords, rankCandidates } from "../lib/query.js";
+/** `brain query --candidates <question>` (spec/cli.md §5.13). */
+export const queryCommand = {
+    name: "query",
+    usage: "brain query --candidates <question> [--limit <n>] [--types <t>[,<t>…]] [--repo <path>] [--json]",
+    summary: "Return ranked note candidates for the brain-query skill.",
+    options: { candidates: "string", limit: "string", types: "string", repo: "string" },
+    maxPositionals: 0,
+    needsBrain: true,
+    async run({ args, brain }) {
+        const question = args.options.candidates;
+        if (question === undefined) {
+            throw new BrainError("USAGE", "brain query requires --candidates; use the brain-query skill to answer questions");
+        }
+        const limit = parseLimit(args.options.limit);
+        const tokens = queryWords(question);
+        const [context, scanned] = await Promise.all([
+            queryContext(args.options.repo),
+            scanNotes(brain.root),
+        ]);
+        const candidates = rankCandidates(scanned.notes, tokens, queryTypes(args.options.types), context).slice(0, limit);
+        return {
+            data: { query: question, tokens, context, candidates },
+            warnings: scanned.problems.map((problem) => ({ code: problem.code, message: `${problem.path}: ${problem.message}`, path: problem.path })),
+            human: `${candidates.length} candidate${candidates.length === 1 ? "" : "s"}.\n`,
+        };
+    },
+};
+function parseLimit(value) {
+    if (value === undefined)
+        return 10;
+    if (!/^[1-9]\d*$/.test(value) || Number(value) > 50) {
+        throw new BrainError("USAGE", "--limit must be an integer from 1 to 50");
+    }
+    return Number(value);
+}

package/dist/commands/status.js

@@ -0,0 +1,98 @@
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { BrainError } from "../lib/errors.js";
+import { buildIndex } from "../lib/index-builder.js";
+import { lintBrain } from "../lib/lint.js";
+import { scanNotes } from "../lib/notes.js";
+import { describeErrors, loadSchemas } from "../lib/schemas.js";
+const NOTE_TYPES = ["area", "project", "person", "org", "meeting", "decision", "question", "concept", "source", "view", "goal", "memory"];
+const PROPOSAL_STATUSES = ["pending", "approved", "edited", "rejected", "applied", "closed"];
+/** `brain status` (spec/cli.md §5.2). */
+export const statusCommand = {
+    name: "status",
+    usage: "brain status [--json]",
+    summary: "Show a read-only health summary for this brain.",
+    options: {},
+    maxPositionals: 0,
+    needsBrain: true,
+    async run({ brain }) {
+        const schemas = loadSchemas();
+        if (!schemas.brain(brain.config)) {
+            throw new BrainError("BRAIN_CONFIG_INVALID", `brain.json fails schema: ${describeErrors(schemas.brain.errors).join("; ")}`);
+        }
+        const { notes, problems } = await scanNotes(brain.root);
+        const noteCounts = Object.fromEntries(NOTE_TYPES.map((type) => [type, 0]));
+        const proposalCounts = Object.fromEntries(PROPOSAL_STATUSES.map((status) => [status, 0]));
+        for (const note of notes) {
+            if (note.type === "proposal") {
+                const status = note.attributes.status;
+                if (typeof status === "string" && status in proposalCounts)
+                    proposalCounts[status] += 1;
+            }
+            else if (note.type in noteCounts) {
+                noteCounts[note.type] += 1;
+            }
+        }
+        const index = buildIndex(notes).markdown;
+        let currentIndex = null;
+        try {
+            currentIndex = await readFile(join(brain.root, "index.md"), "utf8");
+        }
+        catch {
+            // A missing index is stale, as it would be regenerated by `brain index`.
+        }
+        const issues = lintBrain({
+            root: brain.root,
+            notes,
+            problems,
+            brainConfig: brain.config,
+            indexMarkdown: currentIndex,
+        });
+        const viewStale = issues.filter((issue) => issue.rule === "view-stale").map((issue) => issue.path);
+        const notion = readNotion(brain.config);
+        const lastLog = await findLastLogLine(brain.root);
+        const data = {
+            schema_version: brain.config.schema_version,
+            owner: brain.config.owner.name,
+            notes: noteCounts,
+            proposals: proposalCounts,
+            notion,
+            index_stale: currentIndex !== index,
+            views_stale: viewStale,
+            last_log: lastLog,
+        };
+        return { data, human: `Owner: ${data.owner}\nNotes: ${notes.length}\n` };
+    },
+};
+function readNotion(config) {
+    const notion = config.notion;
+    const databases = notion.databases;
+    const configured = [];
+    const missing = [];
+    for (const [key, value] of Object.entries(databases)) {
+        (typeof value === "string" && value !== "" ? configured : missing).push(key);
+    }
+    const tasks = notion.tasks;
+    return { configured, missing, tasks_database: typeof tasks.database === "string" && tasks.database !== "" };
+}
+async function findLastLogLine(root) {
+    let entries;
+    try {
+        entries = (await readdir(join(root, "log"))).filter((entry) => /^\d{4}-\d{2}\.md$/.test(entry)).sort();
+    }
+    catch {
+        return null;
+    }
+    for (const entry of entries.reverse()) {
+        try {
+            const lines = (await readFile(join(root, "log", entry), "utf8")).trimEnd().split("\n");
+            for (const line of lines.reverse())
+                if (line.startsWith("- "))
+                    return line;
+        }
+        catch {
+            // Status is diagnostic; an unreadable old log does not make the brain unusable.
+        }
+    }
+    return null;
+}