@technomoron/agent-run 0.99.31 → 0.99.33

package/CHANGES

@@ -1,6 +1,54 @@
 CHANGES
 =======
 
+Version 0.99.33 (2026-09-06)
+----------------------------
+* Run the agent-brain MCP server as `agent-brain` from `PATH` and choose its
+  socket when the bridge starts, so generated agent configuration no longer
+  contains the path of whichever install rendered it. Re-render existing
+  profiles with `agent-run update`.
+* Let the git guard through for throwaway test repositories: `commit`, `tag`
+  and `push` run normally below a directory holding an `.agent-run-test-repo`
+  marker, so a project's own test suite works inside an agent session.
+* Match the git guard on the subcommand instead of any argument, so
+  `git log --grep push` or a branch named `commit` is no longer blocked.
+* Fix the Windows guard shims: strip a leading PATH entry only when it is the
+  guard directory, resolve the real command explicitly, and refuse recursive
+  resolution.
+* Archive closed review findings to a compact history file and add
+  `review_history` for recalling them without them appearing in normal
+  knowledge retrieval.
+* Keep brain retrieval working when a single knowledge or task file is
+  malformed, reporting the broken file instead of failing every read.
+* Rebuild the search index only when the underlying files change, so read-only
+  retrieval no longer writes on every call.
+* Run brain Git operations against the real git binary rather than the guard
+  shim, and stage `templates/` with `sync save`.
+* Render skills through a loader restricted to the skills directories, so a
+  skill template cannot include files elsewhere in the configuration root.
+* Omit disabled MCP servers from Codex and Grok configuration, as Claude and
+  Gemini already do.
+* Remove `AGENT_WRAPPER_FORCE_PERMISSIVE`, the undocumented environment
+  variable that disabled Claude's permission prompts.
+* Stop overwriting systemd units and helper scripts in the configuration root
+  on every run.
+* Remove `scripts/release-check.sh`. `pnpm release` now only creates and pushes
+  the tag, and `pnpm run release:preflight` is a clean build plus the tests.
+
+Version 0.99.32 (2026-09-06)
+----------------------------
+* Add severity, an assigned C1/H1/M1/L1 label, and an open/fixed/wontfix state
+  to review knowledge, with `review_list` and `resolve_review` for working
+  through findings in priority order.
+* Add `amend_knowledge` to revise an active item in place, keeping its id, file
+  name, and history.
+* Let `remember` choose a file name instead of the item id, with the id appended
+  when that name is taken.
+* Read the package version from `package.json` in one place instead of a second
+  copy in the source, so the version agent-brain reports cannot drift.
+* Fix task updates resetting every field the caller did not mention, which made
+  completing a task discard its description, priority, labels, and notes.
+
 Version 0.99.31 (2026-09-06)
 ----------------------------
 * Add agent-brain for shared project knowledge, skills, review context and

package/README.md

@@ -206,6 +206,23 @@ Codex and Grok and are omitted from Claude and Gemini.
 `local.md.njk` and `overrides/` are not created unless they contain actual
 profile-specific configuration.
 
+## Guard Shims
+
+`blockGitWrite`, `blockPublish`, and `blockGithubRelease` put small `git`, `npm`,
+`pnpm`, and `gh` shims on the launched agent's `PATH`. They refuse
+`git commit`, `git tag`, `git push`, `npm publish`, `pnpm publish`, and
+`gh release create` with exit code 42 and pass everything else through to the
+real command. Set `AGENT_RUN_ALLOW_GIT_WRITE=1`, `AGENT_RUN_ALLOW_PUBLISH=1`, or
+`AGENT_RUN_ALLOW_GITHUB_RELEASE=1` for a single invocation you have reviewed.
+
+Throwaway repositories that a test suite creates and deletes are exempt from the
+`git` shim. Create an empty `.agent-run-test-repo` file in the repository, or in
+any directory above it, and `git commit`, `git tag`, and `git push` run normally
+for anything below that marker. The shim reads the marker from the directory
+`git` would work in, following any leading `-C` options. This is what lets
+`pnpm test` run inside an agent session; nothing outside a marked directory is
+affected.
+
 ## Profile Resolution
 
 The mapped path is:
@@ -597,11 +614,25 @@ and restore the previous unconfigured-project behavior.
 reports omitted items. Use `get_knowledge` to read complete items when necessary.
 Always-recalled knowledge is considered first, then matching file patterns,
 then lexical results. Search uses FTS ranking with extra weight for titles and tags.
+Queries compare the current files with the index and write only added, changed,
+or removed entries. Unchanged queries do not take a database write lock. Context
+retrieval scans the files once. Search and context MCP tools declare that they
+may write because they can refresh this derived index.
 Symbols contribute search terms. Manual Markdown changes are read on every query;
 the index can be deleted while the service is stopped and rebuilt on the next query.
 
 ### Knowledge and skills
 
+Malformed knowledge and task files do not block other entries. When a scan finds
+problems, MCP and CLI list/search responses contain `items` and `brokenFiles`;
+object responses, including context, gain a `brokenFiles` field. Each error lists
+the source path, `status: "broken"`, a reason, and an ID when it can be parsed.
+Responses without errors keep their existing format. Broken entries are excluded
+from search and context, and reads or updates of those entries are refused.
+Correct the file on disk; the next scan picks up the repair automatically.
+Duplicate IDs flag all matching files. External task imports and new review
+numbering stop when broken files would make deduplication or numbering unreliable.
+
 Knowledge is one Markdown file per item, with YAML metadata:
 
 ```markdown
@@ -641,7 +672,8 @@ install either. Global skills remain available without copying them into each
 project. The brain-memory skill explains these choices to native agents.
 
 Available MCP tools include `get_context`, `search_knowledge`, `get_knowledge`,
-`remember`, `promote`, `deprecate_knowledge`, and `review_context`.
+`remember`, `amend_knowledge`, `promote`, `deprecate_knowledge`, `review_context`,
+`review_list`, `resolve_review`, `review_history`, and `review_archive`.
 Writes use atomic file replacement and a shared lock; concurrent writes either
 complete or report that the caller should retry. After a crashed writer, stop
 the service, verify the PID in `runtime/brain-write.lock` is no longer running,
@@ -651,10 +683,71 @@ and remove that lock before restarting.
 agent-brain remember --json '{"scope":"project","type":"observation","title":"Refresh handling","content":"Investigate concurrent refresh requests."}'
 agent-brain search "refresh"
 agent-brain get ITEM_ID
+agent-brain amend ITEM_ID --revision REVISION --json '{"content":"Corrected text."}'
 agent-brain deprecate ITEM_ID --revision REVISION "No longer applies"
 agent-brain promote ITEM_ID --scope global --revision REVISION --confirmed
 ```
 
+`amend_knowledge` revises an active item in place, keeping its id, file name, scope,
+type, authority, and history, and updating only the fields you pass. Use it to correct
+or extend knowledge instead of writing a near-duplicate. Scope, type, authority, and
+review severity are not amendable; if one of those is wrong, deprecate the item and
+write a corrected one.
+
+#### File names
+
+`remember` names each file after the item id. Pass `filename` to choose the name
+instead, as lower-case words separated by single dashes and no extension:
+
+```sh
+agent-brain remember --json '{"scope":"project","type":"observation","title":"Build flow","content":"...","filename":"build-flow"}'
+```
+
+If that name is taken, the item id is appended rather than overwriting anything. The
+name is storage only and is never written into the metadata: the `id` in the front
+matter is the identity, so files stay safe to rename by hand and the item is still found
+by id afterwards.
+
+#### Review findings
+
+Review knowledge is a numbered, prioritized list. `remember` requires a
+`severity` of `critical`, `high`, `medium`, or `low` when the type is `review`,
+and rejects `severity` for every other type. The store assigns the finding
+label itself: `C1`, `H1`, `M1`, `L1`, counting up per severity within the scope.
+Resolved numbers are never handed out again, so a label always refers to the
+same finding.
+
+Each finding also carries a `state` of `open`, `fixed`, or `wontfix`, separate
+from the `active` and `deprecated` status that controls recall. New findings
+start `open`.
+
+```sh
+agent-brain review list
+agent-brain review list --severity high --state open
+agent-brain review resolve ITEM_ID --revision REVISION --state fixed "Fixed by using a stable command name"
+```
+
+`review_list` returns findings in severity then number order, open ones only
+unless states are given, each with the revision needed to resolve it.
+`resolve_review` records the state and reason and takes the finding out of active
+recall. It writes a short record (label, title, outcome, date, reason, and original
+file/revision) to the scope's `review-history.jsonl`, then deletes the full finding
+file. `review-counters.json` preserves numbering. These files participate in brain
+Git sync but are excluded from normal knowledge retrieval.
+
+Use MCP `review_history` to recall old fixes, with optional `query`, `scope`, `state`,
+`offset`, and `limit` (default 100). The CLI equivalent is
+`agent-brain review history [query]`. Git retains full details only when the original
+files were committed before cleanup; the MCP history is sufficient for the short fix list.
+Use `review_archive` with a scope, or `agent-brain review archive --scope project`,
+to compact existing files already marked `fixed` or `wontfix`. Deferred findings
+remain open. Mark a finding `wontfix` only when the user explicitly drops it or
+confirms it is intentional. A request to postpone an issue does not close it.
+
+Finding labels are indexed, so `search_knowledge` for `H2` finds that finding.
+Review files written before these fields existed keep parsing; they simply carry
+no label and stay out of the finding list.
+
 Remembered deductions default to inferred authority and must remain observations,
 memories, or review records. Global writes require explicit user authority.
 Promotion copies an item, records its origin, preserves the original, and requires
@@ -668,6 +761,13 @@ A project/default skill overrides a global skill with the same name. Add
 `extends: global:NAME` to include the global skill's instructions before the local
 instructions. The existing native skill-template system continues to work.
 
+Skill templates and their includes must stay under `global/skills/` or the active
+project/default profile's `skills/` directory. Use config-root-relative paths such
+as `{% include "global/skills/shared/checks.md" %}`, or `./` paths relative to the
+including template. Nunjucks variables remain available. Symlinks are rejected,
+and each file is limited to 1 MiB. Move snippets and skill overrides stored
+elsewhere into these directories before rendering or loading those skills.
+
 The installed `brain-memory`, `brain-review`, and `todo-manager` skills describe
 retrieval, persistence, review learning, and task workflows. Review records use
 the knowledge tools and remain inferred unless confirmed by the user.
@@ -739,9 +839,14 @@ agent-brain sync push --confirmed
 
 The command without an action previews Git status and eligible files. Saving
 includes Markdown knowledge, skills, tasks, project metadata, and `.gitignore`.
+It also includes all regular files under each scope's `templates/` directory,
+including nested Nunjucks templates and supporting files. Template additions,
+edits, and deletions are synced; symlinks are rejected.
 It excludes indexes, runtime state, secrets, `brain.jsonc`, and native agent
 configuration. Existing staged changes block a save. Configure the remote and
 upstream with normal Git commands using your existing credentials.
+Brain Git operations use `AGENT_RUN_REAL_PATH` when available, so agent-session
+Git guards do not intercept configuration sync.
 After cloning onto another machine, run `agent-brain init` to restore generated
 profile markers and shared templates, then update source roots in `config.yaml`
 to match that machine.
@@ -765,7 +870,13 @@ It listens on `$XDG_RUNTIME_DIR/agent-brain.sock`, or
 directory must belong to the current user and have mode `0700`; the socket has
 mode `0600`. No TCP listener or application user database is created.
 
-`agent-run mcp` bridges native-agent stdio to this socket. Use `--socket PATH`
+Generated native-agent configurations run `agent-brain mcp` through `PATH`, so
+`agent-brain` must be installed and available there. The bridge selects the socket
+when it starts; generated files do not depend on the installation or runtime
+directory used to render them. Re-render existing profiles with `agent-run update`
+to replace older commands that contain absolute installation paths.
+
+`agent-run mcp` also bridges native-agent stdio to this socket. Use `--socket PATH`
 for a particular service. The bridge verifies the socket's ownership and private
 permissions. A missing or unreachable socket is an error; start the service
 before connecting. There is no standalone stdio server or TCP fallback. Apicore
@@ -812,6 +923,9 @@ Transport and connector implementations follow the
 ## Systemd Jobs
 
 The repo includes optional systemd units for keeping global AI tooling current.
+Run the installer from the agent-run checkout. Setup, generation, and updates do
+not copy systemd units or helper scripts into `.agent-run`. Remove legacy copies
+there once any custom changes have been moved to your maintained scripts.
 
 Install the global AI tools updater:
 
@@ -882,6 +996,11 @@ After updating `package.json` and `CHANGES`, run:
 pnpm release
 ```
 
-This validates the repo, creates the annotated tag matching the package version,
-and pushes that tag to `origin`. The tag push triggers the release workflow,
-which verifies, packs, publishes to npm, and creates the GitHub release.
+This creates the annotated tag matching the package version and pushes that tag
+to `origin`. It stops if the tag already exists, and removes the local tag again
+if the push fails. The tag push triggers the release workflow, which runs the
+tests and build, packs, publishes to npm, and creates the GitHub release.
+
+`pnpm run release:preflight` is the local gate to run first: a clean build and
+the full test suite. Update `package.json` and `CHANGES` yourself; nothing
+checks them for you.

package/dist/agent-run.js

@@ -1,14 +1,13 @@
 #!/usr/bin/env node
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseEditorCommand = exports.resolveProfile = exports.resolveAgentDir = exports.findProjectRoot = exports.defaultConfigRootSearchCandidates = exports.defaultConfigRoot = exports.parseInvocation = void 0;
+exports.parseEditorCommand = exports.resolveProfile = exports.resolveAgentDir = exports.findProjectRoot = exports.defaultConfigRoot = exports.parseInvocation = void 0;
 const path = require("path");
 const commands_1 = require("./commands");
 var cli_1 = require("./cli");
 Object.defineProperty(exports, "parseInvocation", { enumerable: true, get: function () { return cli_1.parseInvocation; } });
 var project_1 = require("./project");
 Object.defineProperty(exports, "defaultConfigRoot", { enumerable: true, get: function () { return project_1.defaultConfigRoot; } });
-Object.defineProperty(exports, "defaultConfigRootSearchCandidates", { enumerable: true, get: function () { return project_1.defaultConfigRootSearchCandidates; } });
 Object.defineProperty(exports, "findProjectRoot", { enumerable: true, get: function () { return project_1.findProjectRoot; } });
 Object.defineProperty(exports, "resolveAgentDir", { enumerable: true, get: function () { return project_1.resolveAgentDir; } });
 Object.defineProperty(exports, "resolveProfile", { enumerable: true, get: function () { return project_1.resolveProfile; } });

package/dist/agents/claude.js

@@ -51,13 +51,9 @@ exports.claudeAdapter = {
     generate,
     spawn(runtime, options) {
         (0, shared_1.assertRuntimeFile)('claude', runtime.instructionFile, runtime.context.profileDir);
-        const forcedPermissionArgs = process.env.AGENT_WRAPPER_FORCE_PERMISSIVE === '1' &&
-            typeof process.getuid === 'function' && process.getuid() !== 0
-            ? ['--permission-mode', 'bypassPermissions']
-            : [];
         const runtimeArgs = options.wrapperArgs.sandboxMode === 'danger'
             ? ['--dangerously-skip-permissions']
-            : forcedPermissionArgs;
+            : [];
         return {
             command: options.binary,
             args: [

package/dist/brain/cli.js

@@ -8,6 +8,7 @@ const constants_1 = require("../constants");
 const project_1 = require("../project");
 const config_1 = require("./config");
 const projects_1 = require("./projects");
+const zod_1 = require("zod");
 const store_1 = require("./store");
 const skills_1 = require("./skills");
 const todos_1 = require("./todos");
@@ -18,7 +19,7 @@ async function brainMain(argv, wrapperCommand) {
             configdir: { type: 'string' }, cwd: { type: 'string' }, socket: { type: 'string' },
             quick: { type: 'boolean' }, guided: { type: 'boolean' },
             pull: { type: 'boolean' },
-            json: { type: 'string' }, scope: { type: 'string' }, revision: { type: 'string' },
+            json: { type: 'string' }, scope: { type: 'string' }, revision: { type: 'string' }, state: { type: 'string' }, severity: { type: 'string' },
             confirmed: { type: 'boolean' }, message: { type: 'string' }, help: { type: 'boolean', short: 'h' }
         } });
     if (values.configdir)
@@ -33,9 +34,14 @@ async function brainMain(argv, wrapperCommand) {
         process.stdout.write([
             'agent-brain init | status | search <query> | context <task> | get <id>',
             'agent-brain remember --json <knowledge-object>',
+            'agent-brain amend <id> --revision <hash> --json <changes>',
             'agent-brain promote <id> --scope <scope> --revision <hash> --confirmed',
             'agent-brain deprecate <id> --revision <hash> [reason]',
             'agent-brain skills [name]',
+            'agent-brain review list [--severity <level>] [--state <state>]',
+            'agent-brain review history [query] [--scope <scope>] [--state fixed|wontfix]',
+            'agent-brain review archive --scope <scope>',
+            'agent-brain review resolve <id> --revision <hash> --state fixed|wontfix [reason]',
             'agent-brain todo list | get <id> | add --json <task-object>',
             'agent-brain todo update <id> --revision <hash> --json <changes>',
             'agent-brain todo complete <id> --revision <hash>',
@@ -96,61 +102,87 @@ async function brainMain(argv, wrapperCommand) {
         throw new Error('--revision is required; read the item first'); return values.revision; };
     const json = () => { if (!values.json)
         throw new Error('--json is required'); return JSON.parse(values.json); };
+    const report = (value) => print(store.withDiagnostics(value));
     try {
         switch (command) {
             case 'status':
-                print({ configRoot: root, enabled: (0, config_1.readBrainConfig)(root)?.enabled ?? false, profile: store.profile, scopes: store.scopes, knowledge: store.allKnowledge().length, todos: (0, todos_1.listTodos)(store).length });
+                report({ configRoot: root, enabled: (0, config_1.readBrainConfig)(root)?.enabled ?? false, profile: store.profile, scopes: store.scopes, knowledge: store.allKnowledge().length, todos: (0, todos_1.listTodos)(store).length });
                 break;
             case 'search':
-                print(store.search(positionals.join(' ')));
+                report(store.search(positionals.join(' ')));
                 break;
             case 'context':
-                print(store.context(positionals.join(' ')));
+                report(store.context(positionals.join(' ')));
                 break;
             case 'get':
-                print(store.get(requireId()));
+                report(store.get(requireId()));
                 break;
             case 'remember':
-                print(store.remember(store_1.knowledgeInput.parse(json())));
+                report(store.remember(store_1.knowledgeInput.parse(json())));
                 break;
             case 'promote':
                 if (!values.confirmed)
                     throw new Error('Promotion requires --confirmed after explicit user approval');
-                print(store.promote(requireId(), store_1.scopeSchema.parse(values.scope), requireRevision()));
+                report(store.promote(requireId(), store_1.scopeSchema.parse(values.scope), requireRevision()));
+                break;
+            case 'amend':
+                report(store.amend(requireId(), requireRevision(), store_1.knowledgeChanges.parse(json())));
                 break;
             case 'deprecate':
-                print(store.deprecate(requireId(), requireRevision(), positionals.slice(1).join(' ')));
+                report(store.deprecate(requireId(), requireRevision(), positionals.slice(1).join(' ')));
                 break;
             case 'skills':
-                print(positionals[0] ? (0, skills_1.getSkill)(store, positionals[0]) : (0, skills_1.listSkills)(store));
+                report(positionals[0] ? (0, skills_1.getSkill)(store, positionals[0]) : (0, skills_1.listSkills)(store));
+                break;
+            case 'review': {
+                const operation = positionals.shift() ?? 'list';
+                if (operation === 'list') {
+                    report(store.reviews({
+                        ...(values.severity ? { severity: [store_1.severitySchema.parse(values.severity)] } : {}),
+                        ...(values.state ? { state: [store_1.reviewStateSchema.parse(values.state)] } : {})
+                    }).map((item) => ({ finding: item.finding, severity: item.severity, state: item.state ?? 'open', title: item.title, id: item.id, revision: item.revision })));
+                }
+                else if (operation === 'history') {
+                    report(store.reviewHistory({ query: positionals.join(' '), ...(values.scope ? { scope: store_1.scopeSchema.parse(values.scope) } : {}), ...(values.state ? { state: zod_1.z.enum(['fixed', 'wontfix']).parse(values.state) } : {}), limit: Number.MAX_SAFE_INTEGER }));
+                }
+                else if (operation === 'archive') {
+                    report(store.archiveReviews(store_1.scopeSchema.parse(values.scope)));
+                }
+                else if (operation === 'resolve') {
+                    const state = zod_1.z.enum(['fixed', 'wontfix']).parse(values.state);
+                    report(store.resolveReview(requireId(), requireRevision(), state, positionals.slice(1).join(' ') || undefined));
+                }
+                else
+                    throw new Error('Usage: agent-brain review list | resolve <id> --revision <hash> --state fixed|wontfix');
                 break;
+            }
             case 'sync': {
                 const action = positionals[0];
                 if (!action) {
-                    print((0, git_1.gitPreview)(store));
+                    report((0, git_1.gitPreview)(store));
                     break;
                 }
                 if (!['init', 'save', 'pull', 'push'].includes(action))
                     throw new Error('Unknown sync action');
                 if (!values.confirmed)
                     throw new Error('Review agent-brain sync output and obtain authorization before using --confirmed');
-                print((0, git_1.syncGit)(store, action, values.message));
+                report((0, git_1.syncGit)(store, action, values.message));
                 break;
             }
             case 'todo': {
                 const operation = positionals.shift();
                 if (operation === 'list')
-                    print((0, todos_1.listTodos)(store));
+                    report((0, todos_1.listTodos)(store));
                 else if (operation === 'get')
-                    print((0, todos_1.getTodo)(store, requireId()));
+                    report((0, todos_1.getTodo)(store, requireId()));
                 else if (operation === 'add')
-                    print((0, todos_1.addTodo)(store, todos_1.todoInput.parse(json())));
+                    report((0, todos_1.addTodo)(store, todos_1.todoInput.parse(json())));
                 else if (operation === 'update')
-                    print((0, todos_1.updateTodo)(store, requireId(), requireRevision(), todos_1.todoChanges.parse(json())));
+                    report((0, todos_1.updateTodo)(store, requireId(), requireRevision(), todos_1.todoChanges.parse(json())));
                 else if (operation === 'complete')
-                    print((0, todos_1.updateTodo)(store, requireId(), requireRevision(), { status: 'done' }));
+                    report((0, todos_1.updateTodo)(store, requireId(), requireRevision(), { status: 'done' }));
                 else if (operation === 'import' || operation === 'sync')
-                    print(await (0, connectors_1.syncConnector)(store, requireId(), store_1.scopeSchema.parse(values.scope)));
+                    report(await (0, connectors_1.syncConnector)(store, requireId(), store_1.scopeSchema.parse(values.scope)));
                 else
                     throw new Error('Unknown todo command; use agent-brain --help');
                 break;
@@ -158,11 +190,11 @@ async function brainMain(argv, wrapperCommand) {
             case 'project': {
                 const operation = positionals[0];
                 if (operation === 'list')
-                    print((0, config_1.listBrainProjects)(root));
+                    report((0, config_1.listBrainProjects)(root));
                 else if (operation === 'info')
-                    print({ profile: store.profile, ...(0, projects_1.inspectProject)(cwd) });
+                    report({ profile: store.profile, ...(0, projects_1.inspectProject)(cwd) });
                 else if (operation === 'bootstrap')
-                    print({ status: 'proposal', message: 'Inspect the listed documents to propose architecture, constraints, conventions, and specs. Confirm proposals before saving authoritative knowledge.', ...(0, projects_1.inspectProject)(cwd) });
+                    report({ status: 'proposal', message: 'Inspect the listed documents to propose architecture, constraints, conventions, and specs. Confirm proposals before saving authoritative knowledge.', ...(0, projects_1.inspectProject)(cwd) });
                 else
                     throw new Error('Usage: agent-run project list | info | bootstrap');
                 break;

package/dist/brain/git.js

@@ -11,7 +11,7 @@ const store_1 = require("./store");
 const config_1 = require("./config");
 function git(root, args) {
     const result = (0, node_child_process_1.spawnSync)('git', ['-C', root, ...args], { encoding: 'utf8', shell: false, timeout: 60000,
-        env: { ...process.env, GIT_TERMINAL_PROMPT: '0' }, maxBuffer: 16 * 1024 * 1024 });
+        env: { ...process.env, PATH: process.env.AGENT_RUN_REAL_PATH ?? process.env.PATH, GIT_TERMINAL_PROMPT: '0' }, maxBuffer: 16 * 1024 * 1024 });
     if (result.error || result.status !== 0)
         throw new Error(`git ${args[0]} failed: ${result.error?.message ?? result.stderr.trim()}`);
     return result.stdout.trimEnd();
@@ -40,12 +40,18 @@ function syncableFiles(store) {
     for (const root of roots) {
         for (const folder of folders)
             files.push(...store.files(path.join(root, folder)));
-        for (const name of ['config.yaml', 'project.md']) {
+        files.push(...store.files(path.join(root, 'templates'), { includeAllFiles: true }));
+        for (const name of ['config.yaml', 'project.md', 'review-history.jsonl', 'review-counters.json']) {
             const file = store.safePath(root, name);
             if (fs.existsSync(file))
                 files.push(file);
         }
     }
+    if (fs.existsSync(path.join(store.configRoot, '.git'))) {
+        const removable = roots.flatMap((root) => ['templates', 'reviews'].map((folder) => path.relative(store.configRoot, path.join(root, folder))));
+        const deleted = git(store.configRoot, ['ls-files', '--deleted', '-z', '--', ...removable]).split('\0').filter(Boolean);
+        files.push(...deleted.map((file) => store.safePath(file)));
+    }
     const ignore = store.safePath('.gitignore');
     if (fs.existsSync(ignore))
         files.push(ignore);

package/dist/brain/projects.js

@@ -21,7 +21,7 @@ const builtInSkills = {
     },
     'brain-review': {
         description: 'Review changes against project constraints and previous findings, and save confirmed review knowledge.',
-        content: 'Call review_context with the task and changed paths. Check correctness, security, architecture, and meaningful test coverage against relevant constraints. Report concrete, actionable findings with severity and file references. If authorized to save the review, call remember with type=review. Keep suspected hazards marked inferred. Never convert a finding into an authoritative constraint without user confirmation.'
+        content: 'Call review_context with the task and changed paths. Check correctness, security, architecture, and meaningful test coverage against relevant constraints. Report concrete, actionable findings with severity and file references. If authorized to save the review, call remember with type=review. Keep suspected hazards marked inferred. Never convert a finding into an authoritative constraint without user confirmation. Use review_list for open findings. After completing an authorized fix and relevant checks, resolve_review as fixed with a short explanation and verification result; use wontfix only for an explicit user decision to drop the finding. Postponed findings stay open. Closing saves compact history and removes the full finding file. Recall old fixes through review_history, not normal knowledge search. Use review_archive to compact already closed files when cleanup is requested. Do not create separate done lists or full archived review copies.'
     },
     'todo-manager': {
         description: 'Manage local tasks and import externally tracked tasks without duplicates.',

package/dist/brain/server.js

@@ -13,7 +13,7 @@ const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamable
 const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 const apicore_server_1 = require("@technomoron/apicore-server");
 const zod_1 = require("zod");
-const constants_1 = require("../constants");
+const version_1 = require("../version");
 const store_1 = require("./store");
 const skills_1 = require("./skills");
 const todos_1 = require("./todos");
@@ -22,13 +22,15 @@ const git_1 = require("./git");
 var config_1 = require("./config");
 Object.defineProperty(exports, "defaultSocketPath", { enumerable: true, get: function () { return config_1.defaultSocketPath; } });
 function createBrainServer(store) {
-    const server = new mcp_js_1.McpServer({ name: 'agent-brain', version: constants_1.PACKAGE_VERSION });
+    const server = new mcp_js_1.McpServer({ name: 'agent-brain', version: (0, version_1.packageVersion)() });
     function tool(name, description, shape, readOnly, handler) {
         const schema = zod_1.z.object(shape).strict();
         server.registerTool(name, { description, inputSchema: schema, annotations: { readOnlyHint: readOnly, destructiveHint: false, openWorldHint: false } }, async (input) => {
+            store.knowledgeErrors.length = 0;
+            store.todoErrors.length = 0;
             try {
                 const result = await handler(zod_1.z.object(shape).strict().parse(input));
-                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+                return { content: [{ type: 'text', text: JSON.stringify(store.withDiagnostics(result)) }] };
             }
             catch (error) {
                 return { isError: true, content: [{ type: 'text', text: error instanceof Error ? error.message : String(error) }] };
@@ -52,13 +54,16 @@ function createBrainServer(store) {
     });
     tool('get_context', 'Retrieve relevant constraints and knowledge before substantial work. Check omitted; explicitly fetch required knowledge if the budget excluded it.', {
         task: zod_1.z.string().max(10000), files: zod_1.z.array(zod_1.z.string()).max(100).optional(), symbols: zod_1.z.array(zod_1.z.string()).max(100).optional()
-    }, true, ({ task, files, symbols }) => store.context(task, files, symbols));
+    }, false, ({ task, files, symbols }) => store.context(task, files, symbols));
     tool('search_knowledge', 'Search Markdown knowledge in the active scopes using SQLite FTS.', {
         query: zod_1.z.string().max(10000), scopes: zod_1.z.array(store_1.scopeSchema).optional(), types: zod_1.z.array(store_1.typeSchema).optional(),
         includeDeprecated: zod_1.z.boolean().optional(), limit: zod_1.z.number().int().min(1).max(100).optional()
-    }, true, ({ query, ...options }) => store.search(query, options));
+    }, false, ({ query, ...options }) => store.search(query, options));
     tool('get_knowledge', 'Read a complete knowledge item and its current revision.', { id }, true, ({ id }) => store.get(id));
     tool('remember', 'Persist durable knowledge when authorized by the user. Choose scope and a singular type; the server stores it in the matching directory (for example constraint in constraints/, preference in preferences/). Explicit user instructions have authority=user; deductions remain inferred observations. Global writes require explicit global intent. Use todo tools for tasks; skills and templates are separate files.', store_1.knowledgeInput.shape, false, (input) => store.remember(input));
+    tool('amend_knowledge', 'Revise an active item in place using its last-read revision, keeping its id, file name, scope, type, authority, and history. Use this to correct or extend existing knowledge instead of writing a near-duplicate. Scope, type, authority, and review severity cannot be changed this way.', {
+        id, revision, changes: store_1.knowledgeChanges
+    }, false, ({ id, revision, changes }) => store.amend(id, revision, changes));
     tool('promote', 'Copy active knowledge to another available scope with user authority. Requires explicit user approval; the original is preserved.', {
         id, scope: store_1.scopeSchema, revision, confirmed: zod_1.z.literal(true)
     }, false, ({ id, scope, revision }) => store.promote(id, scope, revision));
@@ -67,7 +72,23 @@ function createBrainServer(store) {
     tool('get_skill', 'Load a full skill only when it applies to the current task.', { name: zod_1.z.string().max(100) }, true, ({ name }) => (0, skills_1.getSkill)(store, name));
     tool('review_context', 'Retrieve constraints, decisions, prior review findings, and path-specific knowledge for a code review.', {
         task: zod_1.z.string().max(10000), files: zod_1.z.array(zod_1.z.string()).max(100).optional()
-    }, true, ({ task, files }) => store.context(`review constraint decision ${task}`, files));
+    }, false, ({ task, files }) => store.context(`review constraint decision ${task}`, files));
+    tool('review_list', 'List review findings in severity then number order. Open findings only unless states are given; archived findings are in review_history. Each finding carries its label, severity, state, and the revision needed to resolve it.', {
+        severity: zod_1.z.array(store_1.severitySchema).optional(), state: zod_1.z.array(store_1.reviewStateSchema).optional()
+    }, true, ({ severity, state }) => store.reviews({ severity, state }).map((item) => ({
+        finding: item.finding, severity: item.severity, state: item.state ?? 'open', title: item.title,
+        applies_to: item.applies_to, id: item.id, revision: item.revision
+    })));
+    tool('review_history', 'Recall compact closed review records by label, ID, title, or reason. Excluded from normal knowledge retrieval; newest first, with pagination.', {
+        scope: store_1.scopeSchema.optional(), query: zod_1.z.string().max(1000).optional(), state: zod_1.z.enum(['fixed', 'wontfix']).optional(),
+        offset: zod_1.z.number().int().min(0).optional(), limit: zod_1.z.number().int().min(1).max(1000).optional()
+    }, true, (options) => store.reviewHistory(options));
+    tool('review_archive', 'Compact already finished review files in one scope into closure history and remove their full files. Leaves unresolved and deferred findings alone.', {
+        scope: store_1.scopeSchema
+    }, false, ({ scope }) => store.archiveReviews(scope));
+    tool('resolve_review', 'Close a review finding as fixed or wontfix, preserving a compact closure record and deleting the full finding file. Supply the revision you last read. Use wontfix only when the user has said the finding is intentional.', {
+        id, revision, state: zod_1.z.enum(['fixed', 'wontfix']), reason: zod_1.z.string().max(2000).optional()
+    }, false, ({ id, revision, state, reason }) => store.resolveReview(id, revision, state, reason));
     tool('todo_list', 'List structured tasks in the active scopes.', { status: todos_1.todoInput.shape.status.optional() }, true, ({ status }) => (0, todos_1.listTodos)(store).filter((item) => !status || item.status === status));
     tool('todo_get', 'Read a task and its revision.', { id }, true, ({ id }) => (0, todos_1.getTodo)(store, id));
     tool('todo_add', 'Create a local task. Reimporting the same external task returns the existing task.', todos_1.todoInput.shape, false, (input) => (0, todos_1.addTodo)(store, input));

package/dist/brain/skills.js

@@ -19,11 +19,12 @@ function getSkills(store) {
     const directory = store.scopeDirectory(store.profile ? 'project' : 'default');
     const env = (0, templates_1.createNunjucksEnv)(store.configRoot);
     const context = (0, templates_1.buildRenderContext)(store.projectRoot, directory, store.configRoot, (0, manifest_1.normalizeManifest)((0, manifest_1.loadManifest)(store.configRoot, directory, profile), profile), env);
+    const skillEnv = (0, templates_1.createSkillNunjucksEnv)(store.configRoot, directory);
     const skills = new Map();
     const globalSkills = new Map();
     for (const { scope, directory } of store.scopes) {
         for (const file of store.files(path.join(directory, 'skills')).filter((file) => path.basename(file) === 'SKILL.md')) {
-            const text = env.renderString(store.read(file), context);
+            const text = skillEnv.render(path.relative(store.configRoot, file), context);
             const document = (0, store_1.readMarkdown)(text);
             const parsed = metadata.parse(document.metadata);
             if (path.basename(path.dirname(file)) !== parsed.name)