@technomoron/agent-run 0.99.31 → 0.99.32

package/CHANGES

@@ -1,6 +1,20 @@
 CHANGES
 =======
 
+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

@@ -641,7 +641,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`, and `resolve_review`.
 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 +652,60 @@ 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, keeping its text and history. Mark a finding `wontfix` only when the user
+has said it is intentional.
+
+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

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,12 @@ 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 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>',
@@ -118,12 +122,31 @@ async function brainMain(argv, wrapperCommand) {
                     throw new Error('Promotion requires --confirmed after explicit user approval');
                 print(store.promote(requireId(), store_1.scopeSchema.parse(values.scope), requireRevision()));
                 break;
+            case 'amend':
+                print(store.amend(requireId(), requireRevision(), store_1.knowledgeChanges.parse(json())));
+                break;
             case 'deprecate':
                 print(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));
                 break;
+            case 'review': {
+                const operation = positionals.shift() ?? 'list';
+                if (operation === 'list') {
+                    print(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 === 'resolve') {
+                    const state = zod_1.z.enum(['fixed', 'wontfix']).parse(values.state);
+                    print(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) {

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,7 +22,7 @@ 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) => {
@@ -59,6 +59,9 @@ function createBrainServer(store) {
     }, true, ({ 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));
@@ -68,6 +71,15 @@ function createBrainServer(store) {
     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));
+    tool('review_list', 'List review findings in severity then number order. Open findings only unless states are given. 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('resolve_review', 'Close a review finding as fixed or wontfix, with a reason and 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/store.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BrainStore = exports.knowledgeDirectories = exports.knowledgeMetadata = exports.knowledgeInput = exports.typeSchema = exports.scopeSchema = void 0;
+exports.BrainStore = exports.knowledgeDirectories = exports.knowledgeChanges = exports.knowledgeMetadata = exports.knowledgeInput = exports.reviewStateSchema = exports.severitySchema = exports.typeSchema = exports.scopeSchema = void 0;
 exports.readMarkdown = readMarkdown;
 const fs = require("node:fs");
 const path = require("node:path");
@@ -13,6 +13,10 @@ const utils_1 = require("../utils");
 const config_1 = require("./config");
 exports.scopeSchema = zod_1.z.enum(['global', 'project', 'default']);
 exports.typeSchema = zod_1.z.enum(['rule', 'preference', 'convention', 'constraint', 'decision', 'spec', 'review', 'memory', 'observation']);
+exports.severitySchema = zod_1.z.enum(['critical', 'high', 'medium', 'low']);
+exports.reviewStateSchema = zod_1.z.enum(['open', 'fixed', 'wontfix']);
+const severityPrefix = { critical: 'C', high: 'H', medium: 'M', low: 'L' };
+const severityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
 exports.knowledgeInput = zod_1.z.object({
     scope: exports.scopeSchema,
     type: exports.typeSchema,
@@ -20,17 +24,32 @@ exports.knowledgeInput = zod_1.z.object({
     content: zod_1.z.string().trim().min(1).max(200000),
     authority: zod_1.z.enum(['user', 'inferred']).default('inferred'),
     recall: zod_1.z.enum(['always', 'relevant']).default('relevant'),
+    severity: exports.severitySchema.optional(),
     tags: zod_1.z.array(zod_1.z.string().max(100)).max(50).default([]),
-    applies_to: zod_1.z.array(zod_1.z.string().max(500)).max(50).default([])
+    applies_to: zod_1.z.array(zod_1.z.string().max(500)).max(50).default([]),
+    // Naming only. The id in the front matter stays the identity, so files can be renamed freely.
+    filename: zod_1.z.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, 'Use lower-case words separated by single dashes, with no extension').max(100).optional()
 }).strict();
-exports.knowledgeMetadata = exports.knowledgeInput.omit({ content: true }).extend({
+// finding and state stay optional so review files written before they existed keep parsing.
+exports.knowledgeMetadata = exports.knowledgeInput.omit({ content: true, filename: true }).extend({
     id: zod_1.z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/),
     status: zod_1.z.enum(['active', 'deprecated']).default('active'),
+    finding: zod_1.z.string().regex(/^[CHML][1-9][0-9]*$/).optional(),
+    state: exports.reviewStateSchema.optional(),
     created: zod_1.z.string().default(''),
     updated: zod_1.z.string().default(''),
     reason: zod_1.z.string().optional(),
     promoted_from: zod_1.z.string().optional()
 }).strict();
+// Spelled out rather than derived from knowledgeInput: .partial() keeps .default(), so a
+// derived schema would silently reset every field the caller did not mention.
+exports.knowledgeChanges = zod_1.z.object({
+    title: zod_1.z.string().trim().min(1).max(300).optional(),
+    content: zod_1.z.string().trim().min(1).max(200000).optional(),
+    recall: zod_1.z.enum(['always', 'relevant']).optional(),
+    tags: zod_1.z.array(zod_1.z.string().max(100)).max(50).optional(),
+    applies_to: zod_1.z.array(zod_1.z.string().max(500)).max(50).optional()
+}).strict();
 exports.knowledgeDirectories = {
     rule: 'rules', preference: 'preferences', convention: 'conventions', constraint: 'constraints',
     decision: 'decisions', spec: 'specs', review: 'reviews', memory: 'memory', observation: 'observations'
@@ -180,7 +199,7 @@ class BrainStore {
             this.db.prepare('DELETE FROM knowledge WHERE environment = ?').run(environment);
             const insert = this.db.prepare('INSERT INTO knowledge(source, environment, title, content, tags) VALUES (?, ?, ?, ?, ?)');
             for (const item of items)
-                insert.run(item.source, environment, item.title, item.content, item.tags.join(' '));
+                insert.run(item.source, environment, item.title, item.content, [...item.tags, item.finding ?? ''].join(' ').trim());
             this.db.exec('COMMIT');
         }
         catch (error) {
@@ -219,15 +238,74 @@ class BrainStore {
         }
         if (value.scope === 'global' && value.authority !== 'user')
             throw new Error('Global writes require explicit user authority.');
+        if (value.type === 'review' && !value.severity)
+            throw new Error('Review findings require a severity: critical, high, medium, or low.');
+        if (value.type !== 'review' && value.severity)
+            throw new Error('Severity applies only to review findings.');
         return this.writeLocked(() => {
             const now = new Date().toISOString();
-            const { content, ...metadata } = value;
-            const item = { ...metadata, id: (0, node_crypto_1.randomUUID)(), status: 'active', created: now, updated: now };
-            const file = path.join(this.scopeDirectory(value.scope), exports.knowledgeDirectories[value.type], `${item.id}.md`);
-            this.atomicWrite(file, `---\n${(0, yaml_1.stringify)(item)}---\n\n${content}\n`);
+            const { content, filename, ...metadata } = value;
+            const review = value.severity ? { finding: this.nextFinding(value.scope, value.severity), state: 'open' } : {};
+            const item = { ...metadata, ...review, id: (0, node_crypto_1.randomUUID)(), status: 'active', created: now, updated: now };
+            const directory = path.join(this.scopeDirectory(value.scope), exports.knowledgeDirectories[value.type]);
+            this.atomicWrite(this.availableFile(directory, filename, item.id), `---\n${(0, yaml_1.stringify)(item)}---\n\n${content}\n`);
             return this.allKnowledge().find((entry) => entry.id === item.id);
         });
     }
+    /** Chosen name when one is given and free, otherwise the same name with the id appended. */
+    availableFile(directory, filename, id) {
+        if (!filename)
+            return path.join(directory, `${id}.md`);
+        const preferred = path.join(directory, `${filename}.md`);
+        return fs.existsSync(preferred) ? path.join(directory, `${filename}-${id}.md`) : preferred;
+    }
+    /** Revise an item in place, keeping its id, filename, scope, type, authority, and history. */
+    amend(id, revision, changes) {
+        const parsed = exports.knowledgeChanges.parse(changes);
+        if (Object.keys(parsed).length === 0)
+            throw new Error('Supply at least one field to change.');
+        return this.writeLocked(() => {
+            const item = this.get(id);
+            if (item.revision !== revision)
+                throw new Error('Knowledge changed; read the current revision before amending.');
+            if (item.status !== 'active')
+                throw new Error('Deprecated knowledge cannot be amended.');
+            const { source, revision: _revision, content, ...metadata } = item;
+            const { content: nextContent, ...nextMetadata } = parsed;
+            this.atomicWrite(source, `---\n${(0, yaml_1.stringify)({ ...metadata, ...nextMetadata, updated: new Date().toISOString() })}---\n\n${nextContent ?? content}\n`);
+            return this.get(id);
+        });
+    }
+    /** Next unused finding label for a severity, counting resolved findings so numbers are never reused. */
+    nextFinding(scope, severity) {
+        const prefix = severityPrefix[severity];
+        const used = this.allKnowledge()
+            .filter((item) => item.scope === scope && item.type === 'review' && item.finding?.startsWith(prefix))
+            .map((item) => Number.parseInt(item.finding.slice(prefix.length), 10))
+            .filter((sequence) => Number.isSafeInteger(sequence));
+        return `${prefix}${Math.max(0, ...used) + 1}`;
+    }
+    /** Review findings in severity then sequence order. Open findings only unless states are given. */
+    reviews(options = {}) {
+        const sequence = (item) => Number.parseInt(item.finding.slice(1), 10);
+        return this.allKnowledge()
+            .filter((item) => item.type === 'review' && item.finding && item.severity)
+            .filter((item) => !options.severity || options.severity.includes(item.severity))
+            .filter((item) => (options.state ?? ['open']).includes(item.state ?? 'open'))
+            .sort((left, right) => severityOrder[left.severity] - severityOrder[right.severity] || sequence(left) - sequence(right));
+    }
+    resolveReview(id, revision, state, reason) {
+        return this.writeLocked(() => {
+            const item = this.get(id);
+            if (item.type !== 'review' || !item.finding)
+                throw new Error('Only review findings can be resolved.');
+            if (item.revision !== revision)
+                throw new Error('Knowledge changed; read the current revision before updating.');
+            const { source, revision: _revision, content, ...metadata } = item;
+            this.atomicWrite(source, `---\n${(0, yaml_1.stringify)({ ...metadata, state, status: 'deprecated', updated: new Date().toISOString(), ...(reason ? { reason } : {}) })}---\n\n${content}\n`);
+            return this.get(id);
+        });
+    }
     deprecate(id, revision, reason) {
         return this.writeLocked(() => {
             const item = this.get(id);
@@ -248,8 +326,10 @@ class BrainStore {
             if (item.scope === scope)
                 throw new Error('Knowledge already belongs to this scope.');
             const { source: _source, revision: _revision, content, ...metadata } = item;
-            const promoted = { ...metadata, id: (0, node_crypto_1.randomUUID)(), scope, authority: 'user', promoted_from: id, updated: new Date().toISOString() };
-            this.atomicWrite(path.join(this.scopeDirectory(scope), exports.knowledgeDirectories[item.type], `${promoted.id}.md`), `---\n${(0, yaml_1.stringify)(promoted)}---\n\n${content}\n`);
+            const renumbered = item.severity ? { finding: this.nextFinding(scope, item.severity) } : {};
+            const promoted = { ...metadata, ...renumbered, id: (0, node_crypto_1.randomUUID)(), scope, authority: 'user', promoted_from: id, updated: new Date().toISOString() };
+            const target = path.join(this.scopeDirectory(scope), exports.knowledgeDirectories[item.type]);
+            this.atomicWrite(this.availableFile(target, path.basename(item.source, '.md'), promoted.id), `---\n${(0, yaml_1.stringify)(promoted)}---\n\n${content}\n`);
             return this.get(promoted.id);
         });
     }

package/dist/brain/todos.js

@@ -59,7 +59,18 @@ function addTodo(store, input) {
         return writeTodo(store, { ...value, id: (0, node_crypto_1.randomUUID)(), created: now, updated: now });
     });
 }
-exports.todoChanges = exports.todoInput.omit({ scope: true, source: true }).partial();
+// Spelled out rather than todoInput.omit(...).partial(): .partial() keeps .default(), so
+// updating one field would reset description, priority, labels, and notes to their defaults.
+exports.todoChanges = zod_1.z.object({
+    title: zod_1.z.string().trim().min(1).max(300).optional(),
+    description: zod_1.z.string().trim().max(200000).optional(),
+    status: zod_1.z.enum(['todo', 'doing', 'blocked', 'done', 'cancelled']).optional(),
+    priority: zod_1.z.enum(['low', 'medium', 'high', 'critical']).optional(),
+    owner: zod_1.z.string().optional(),
+    due: zod_1.z.iso.date().optional(),
+    labels: zod_1.z.array(zod_1.z.string()).optional(),
+    notes: zod_1.z.string().optional()
+}).strict();
 function updateTodo(store, id, revision, changes) {
     const parsed = exports.todoChanges.parse(changes);
     return store.writeLocked(() => {

package/dist/cli.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseInvocation = parseInvocation;
-const fs = require("fs");
 const path = require("path");
 const constants_1 = require("./constants");
+const version_1 = require("./version");
 const registry_1 = require("./agents/registry");
 const types_1 = require("./agents/types");
 const project_1 = require("./project");
@@ -299,7 +299,7 @@ function isVersionFlag(value) {
     return value === '-V' || value === '--version';
 }
 function printVersion() {
-    process.stdout.write(`agent-run ${agentRunVersion()}\n`);
+    process.stdout.write(`agent-run ${(0, version_1.packageVersion)()}\n`);
     process.exit(0);
 }
 function printHelp(topic) {
@@ -347,7 +347,7 @@ function renderHelp(topic) {
         return help[topic].join('\n');
     }
     return [
-        `agent-run ${agentRunVersion()}`,
+        `agent-run ${(0, version_1.packageVersion)()}`,
         '',
         'Usage:',
         '  agent-run <codex|claude|gemini|grok|check|status|setup|generate|edit|update> [options]',
@@ -393,15 +393,6 @@ function renderHelp(topic) {
         ''
     ].join('\n');
 }
-function agentRunVersion() {
-    try {
-        const pkg = JSON.parse(fs.readFileSync(path.resolve(__dirname, '..', 'package.json'), 'utf8'));
-        return typeof pkg.version === 'string' && pkg.version ? pkg.version : constants_1.PACKAGE_VERSION;
-    }
-    catch {
-        return constants_1.PACKAGE_VERSION;
-    }
-}
 function normalizeCommandName(value) {
     if (!value) {
         return null;

package/dist/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.REQUIRED_GLOBAL_TEMPLATES = exports.GENERATED_GITIGNORE_ENTRIES = exports.BRAIN_GITIGNORE_ENTRIES = exports.LOCAL_AI_DIRECTORY_NAMES = exports.LOCAL_AI_FILE_NAMES = exports.UNEXPANDED_TEMPLATE_RE = exports.PACKAGE_VERSION = exports.VERBOSE_ENV = exports.CONFIG_DIR_ENV = exports.CONFIG_ROOT_OVERRIDE_ENV = exports.LIVE_DIR_NAME = exports.LOCAL_TEMPLATE_FILE_NAME = exports.MANIFEST_FILE_NAME = exports.CONFIG_ROOT_DEFAULTS_FILE_NAME = exports.IGNORE_FILE_NAME = exports.ENV_FILE_NAME = exports.IS_WINDOWS = void 0;
+exports.REQUIRED_GLOBAL_TEMPLATES = exports.GENERATED_GITIGNORE_ENTRIES = exports.BRAIN_GITIGNORE_ENTRIES = exports.LOCAL_AI_DIRECTORY_NAMES = exports.LOCAL_AI_FILE_NAMES = exports.UNEXPANDED_TEMPLATE_RE = exports.VERBOSE_ENV = exports.CONFIG_DIR_ENV = exports.CONFIG_ROOT_OVERRIDE_ENV = exports.LIVE_DIR_NAME = exports.LOCAL_TEMPLATE_FILE_NAME = exports.MANIFEST_FILE_NAME = exports.CONFIG_ROOT_DEFAULTS_FILE_NAME = exports.IGNORE_FILE_NAME = exports.ENV_FILE_NAME = exports.IS_WINDOWS = void 0;
 exports.IS_WINDOWS = process.platform === 'win32';
 exports.ENV_FILE_NAME = '.agent-run.env';
 exports.IGNORE_FILE_NAME = '.agent-run-ignore';
@@ -11,7 +11,6 @@ exports.LIVE_DIR_NAME = 'live';
 exports.CONFIG_ROOT_OVERRIDE_ENV = 'AGENT_RUN_CONFIG_ROOT_OVERRIDE';
 exports.CONFIG_DIR_ENV = 'AGENT_CONFIG_DIR';
 exports.VERBOSE_ENV = 'AGENT_RUN_VERBOSE';
-exports.PACKAGE_VERSION = '0.99.30';
 exports.UNEXPANDED_TEMPLATE_RE = /\{\{[^}]+\}\}|\{%[^%]+%\}/;
 exports.LOCAL_AI_FILE_NAMES = new Set([
     'AGENTS.md',

package/dist/version.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageVersion = packageVersion;
+const fs = require("fs");
+const path = require("path");
+let cached = null;
+/**
+ * The package version, read from package.json next to the compiled output.
+ * This is the single source; nothing else in the tree hardcodes a version.
+ */
+function packageVersion() {
+    if (cached === null) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(path.resolve(__dirname, '..', 'package.json'), 'utf8'));
+            cached = typeof pkg.version === 'string' && pkg.version ? pkg.version : '0.0.0';
+        }
+        catch {
+            cached = '0.0.0';
+        }
+    }
+    return cached;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@technomoron/agent-run",
-  "version": "0.99.31",
+  "version": "0.99.32",
   "packageManager": "pnpm@10.34.5",
   "bin": {
     "agent-run": "dist/agent-run.js",