@ikarmic/forge-core 5.1.0 → 5.1.1

package/dist/specs/generate.js

@@ -9,6 +9,7 @@
  * order) into the three separate document bodies `SpecStore.approve`
  * writes to disk.
  */
+import { convertToCheckboxes, parseTasks } from './tasks-parser.js';
 /** Read-only tools exposed to the model during spec-mode generation. */
 export const SPEC_READONLY_TOOLS = [
     'read_file',
@@ -23,37 +24,87 @@ const SECTION_MATCHES = [
     { key: 'design', header: 'design.md' },
     { key: 'tasks', header: 'tasks.md' },
 ];
+/** Where a section body ends: the next `## ` heading. */
+const STRICT_STOP = /^##\s+\S/m;
+/** Stage replies: a level-1 or level-2 heading, or any named section heading at level 1 to 3. */
+const LENIENT_STOP = /^(?:#{1,2}[ \t]+\S|#{1,3}[ \t]*`?(?:requirements|design|tasks)\.md`?[ \t]*$)/im;
+/** A line that is nothing but a code fence. */
+const FENCE_ONLY_LINE = /\n[ \t]*(?:```|~~~)[ \t]*$/;
+const FENCE_LINE_ANYWHERE = /^[ \t]*(?:```|~~~)/gm;
 /**
- * Split a spec-mode run's final text into its three sections. Each
- * section is introduced by a `## <file>.md` markdown heading (case-
- * insensitive, arbitrary surrounding whitespace); the body runs until
- * the next matching heading or end of text. Section order in `raw`
- * does not matter.
+ * Drop the closing fence a model leaves behind when it wrapped the whole reply
+ * in a code block: the opening fence sits before the first heading, so the last
+ * section ends with an unmatched closing one.
  *
- * Throws when any of the three expected headings is missing: callers
- * should surface this as a generation failure rather than write partial
- * or malformed files.
+ * Only when the count is odd. A `tasks.md` that legitimately *ends* with a
+ * fenced code block has a balanced pair, and stripping that would eat the real
+ * document — which is what the existing one-shot test caught on the first run.
  */
-export function splitSpecSections(raw) {
+function dropUnmatchedTrailingFence(body) {
+    const fences = body.match(FENCE_LINE_ANYWHERE)?.length ?? 0;
+    if (fences % 2 === 0)
+        return body;
+    // `$` without /m anchors at the very end of the string, not before a trailing
+    // newline, so the trailing whitespace has to go before the fence can match.
+    return body.trimEnd().replace(FENCE_ONLY_LINE, '');
+}
+/**
+ * Find every section the text contains, validating nothing. Callers decide
+ * which they require, so the one-shot path can keep demanding all three while
+ * the journey's Spec stage asks for two and its ImplPlan stage for one.
+ *
+ * A section's body runs to the next `## ` heading or the end of the text, so an
+ * unrelated heading the model wrote between two sections ends only its own
+ * section. Text before the first heading is never part of a body, which is what
+ * makes a preamble harmless.
+ *
+ * `lenient` is for the journey's stage replies and is opt-in; the one-shot
+ * `splitSpecSections` passes false and reads exactly as it always has. Lenient
+ * does two things:
+ *
+ * - It strips the closing fence a wrapped reply leaves behind. This once ran for
+ *   both paths, which quietly changed what `/spec` persists (a wrapped reply
+ *   lost its closing fence, and a tilde block holding a bare backtick line lost
+ *   its own) and contradicted the plan's "nothing existing changes behaviour".
+ * - It accepts a section heading at level 1 to 3, optionally in backticks. A live
+ *   MiniMax-M3 run answered with `# tasks.md` and the strict parser threw "got:
+ *   none" although the model had done the work. Once a section may be headed
+ *   `###`, a body cannot end at "any `##` line" or the first section would
+ *   swallow the second, so it ends at a level-1/2 heading *or* at any named
+ *   section heading; a level-3 subsection inside a document stays inside it.
+ *
+ * The one-shot flaws are real and recorded in RB-31; they are not fixed here.
+ */
+function splitSections(raw, lenient) {
     const found = {};
     const foundHeaders = [];
     for (const { key, header } of SECTION_MATCHES) {
-        const re = new RegExp(`^##\\s*${escapeRegExp(header)}\\s*$`, 'im');
+        const re = lenient
+            ? new RegExp(`^#{1,3}[ \\t]*\`?${escapeRegExp(header)}\`?[ \\t]*$`, 'im')
+            : new RegExp(`^##\\s*${escapeRegExp(header)}\\s*$`, 'im');
         const match = re.exec(raw);
         if (!match)
             continue;
         const start = match.index + match[0].length;
         const rest = raw.slice(start);
         // Body runs until the next `## ...` heading line, or end of text.
-        const nextHeadingRe = /^##\s+\S/m;
-        const nextMatch = nextHeadingRe.exec(rest);
-        const body = nextMatch ? rest.slice(0, nextMatch.index) : rest;
+        const nextMatch = (lenient ? LENIENT_STOP : STRICT_STOP).exec(rest);
+        const slice = nextMatch ? rest.slice(0, nextMatch.index) : rest;
+        const body = lenient ? dropUnmatchedTrailingFence(slice) : slice;
         found[key] = key === 'tasks' ? splitInlineSubtasks(body.trim()) : body.trim();
         foundHeaders.push(header);
     }
+    return { found, foundHeaders };
+}
+function describeFound(foundHeaders) {
+    return foundHeaders.length > 0 ? foundHeaders.join(', ') : 'none';
+}
+export function splitSpecSections(raw) {
+    const { found, foundHeaders } = splitSections(raw, false);
+    // Strict on purpose: see `splitSections`. The one-shot path reads exactly as it always has.
     const missing = SECTION_MATCHES.filter((s) => found[s.key] === undefined);
     if (missing.length > 0) {
-        throw new Error(`Spec generation did not include all three sections (requirements.md/design.md/tasks.md): got: ${foundHeaders.length > 0 ? foundHeaders.join(', ') : 'none'}`);
+        throw new Error(`Spec generation did not include all three sections (requirements.md/design.md/tasks.md): got: ${describeFound(foundHeaders)}`);
     }
     return {
         requirements: found.requirements,
@@ -61,6 +112,115 @@ export function splitSpecSections(raw) {
         tasks: found.tasks,
     };
 }
+/**
+ * The Spec stage's two documents. Returns **only** those two keys: a model that
+ * volunteers a `## tasks.md` section despite being told not to must not be able
+ * to smuggle it into a draft, because the person has not reached the
+ * implementation-plan gate yet.
+ */
+export function splitRequirementsDesign(raw) {
+    const { found, foundHeaders } = splitSections(raw, true);
+    const missing = ['requirements', 'design'].filter((k) => found[k] === undefined);
+    if (missing.length > 0) {
+        throw new Error(`Spec generation did not include ${missing.map((k) => `${k}.md`).join(' and ')}: got: ${describeFound(foundHeaders)}`);
+    }
+    return { requirements: found.requirements, design: found.design };
+}
+const CHECKBOX_LINE = /^\s*[-*+]\s+\[[ xX]\]\s+\S/;
+const FENCE_START = /^\s*(?:```|~~~)/;
+/** `_Requirements: 2_`, `*Requirements: 2*`, `**Requirements:** 1.1`: the footer under a task, however the model dressed it. */
+const REQUIREMENTS_FOOTER = /^\s*[_*]{1,2}Requirements\b.*$/i;
+/** A line that belongs to the task above it: indented, or its requirements footer. */
+function continuesTask(line) {
+    return /^\s+\S/.test(line) || REQUIREMENTS_FOOTER.test(line);
+}
+/**
+ * Cut a closing summary off the end of a task list.
+ *
+ * Nothing ends the *last* section of a reply, so a model that finishes with
+ * "Notes on two judgment calls… Plan is complete, next step would be executing
+ * task 1" has that text written into the persisted `tasks.md`. A live
+ * MiniMax-M3 run did exactly that. The checklist is the anchor: the document
+ * ends where the last checkbox's own block ends.
+ *
+ * That block is the task's indented lines and its requirements footer, and it
+ * may contain blank lines, so a blank run is looked *through* and kept when what
+ * follows still belongs to the task. A fenced block under the last task is part
+ * of it and is kept whole; an *unclosed* fence is trailer, because keeping it
+ * would persist a document that ends inside a code block. The anchor itself is
+ * the last checkbox `parseTasks` would see, so one inside a fenced example does
+ * not count.
+ *
+ * With no checkbox at all (a prose or numbered list) there is nothing to anchor
+ * on, so the text is returned as it is and approval converts it to checkboxes
+ * the way the one-shot path always has.
+ */
+function dropClosingSummary(tasks) {
+    const lines = tasks.split('\n');
+    let last = -1;
+    let inFence = false;
+    lines.forEach((line, i) => {
+        if (FENCE_START.test(line)) {
+            inFence = !inFence;
+            return;
+        }
+        if (!inFence && CHECKBOX_LINE.test(line))
+            last = i;
+    });
+    if (last === -1)
+        return tasks;
+    let end = last;
+    let i = last + 1;
+    while (i < lines.length) {
+        const line = lines[i];
+        if (line.trim() === '') {
+            let next = i + 1;
+            while (next < lines.length && lines[next].trim() === '')
+                next += 1;
+            const rest = lines[next];
+            if (rest !== undefined && (continuesTask(rest) || FENCE_START.test(rest))) {
+                i = next;
+                continue;
+            }
+            break;
+        }
+        if (FENCE_START.test(line)) {
+            let close = i + 1;
+            while (close < lines.length && !FENCE_START.test(lines[close]))
+                close += 1;
+            if (close >= lines.length)
+                break;
+            end = close;
+            i = close + 1;
+            continue;
+        }
+        if (!continuesTask(line))
+            break;
+        end = i;
+        i += 1;
+    }
+    return lines.slice(0, end + 1).join('\n').trimEnd();
+}
+/**
+ * The ImplPlan stage's single document.
+ *
+ * Throws when the reply holds no task at all: an empty body or a prose-only
+ * "Plan is complete." would otherwise be written by `writeDraftTasks` and then
+ * approved, because `approveDraft` only checks that the file exists — leaving a
+ * spec with nothing to run, which is the very outcome that guard exists to
+ * prevent. Failing generation here sends the journey back to "Revise".
+ */
+export function splitTasksSection(raw) {
+    const { found, foundHeaders } = splitSections(raw, true);
+    if (found.tasks === undefined) {
+        throw new Error(`Spec generation did not include tasks.md: got: ${describeFound(foundHeaders)}`);
+    }
+    const tasks = dropClosingSummary(found.tasks);
+    if (parseTasks(convertToCheckboxes(tasks)).length === 0) {
+        throw new Error(`Spec generation produced a tasks.md with no tasks in it: got: ${describeFound(foundHeaders)}`);
+    }
+    return tasks;
+}
 // A task line with a numbered subtask glued on after it: "- [ ] 1. Title - [ ] 1.1 Sub".
 const INLINE_SUBTASK_RE = /^(\s*)([-*+]\s+\[[ xX]\]\s+.+?)\s+[-*+]\s+(\[[ xX]\]\s+\d.*)$/;
 /**

package/dist/specs/index.d.ts

@@ -6,8 +6,8 @@
  * `./generate.js`, added in a later task.
  */
 export { SpecStore, isSafeSpecId, runKey, slugifyTaskForSpecId } from './store.js';
-export type { SpecDraft, SpecRunRecord, SpecRuns, SpecSections, SpecSummary } from './types.js';
-export { SPEC_READONLY_TOOLS, splitSpecSections } from './generate.js';
+export type { SpecDraft, SpecDraftSections, SpecRunRecord, SpecRuns, SpecSections, SpecSummary } from './types.js';
+export { SPEC_READONLY_TOOLS, splitRequirementsDesign, splitSpecSections, splitTasksSection } from './generate.js';
 export { convertToCheckboxes, parseTasks, setTaskDone } from './tasks-parser.js';
 export type { SpecTask } from './tasks-parser.js';
 export { changedSince, changeSize, keepDoneTasks, referencedPaths, specDrift, syncSpecTask } from './sync.js';

package/dist/specs/index.js

@@ -6,6 +6,6 @@
  * `./generate.js`, added in a later task.
  */
 export { SpecStore, isSafeSpecId, runKey, slugifyTaskForSpecId } from './store.js';
-export { SPEC_READONLY_TOOLS, splitSpecSections } from './generate.js';
+export { SPEC_READONLY_TOOLS, splitRequirementsDesign, splitSpecSections, splitTasksSection } from './generate.js';
 export { convertToCheckboxes, parseTasks, setTaskDone } from './tasks-parser.js';
 export { changedSince, changeSize, keepDoneTasks, referencedPaths, specDrift, syncSpecTask } from './sync.js';

package/dist/specs/store.d.ts

@@ -7,7 +7,7 @@
  * generation happens entirely in memory (in the CLI/REPL layer), so a
  * cancelled review leaves no trace here.
  */
-import type { SpecDraft, SpecRunRecord, SpecRuns, SpecSections, SpecSummary } from './types.js';
+import type { SpecDraft, SpecDraftSections, SpecRunRecord, SpecRuns, SpecSections, SpecSummary } from './types.js';
 /** Spec ids become path segments; the leading-alphanumeric rule also rejects `.drafts`, `.` and `..`. */
 export declare function isSafeSpecId(id: string): boolean;
 /** Key for a task's run history: a reordered or renamed task stops matching old runs. */
@@ -33,7 +33,19 @@ export declare class SpecStore {
     /** Delete an approved spec's directory. Returns false when it didn't exist. */
     delete(id: string): Promise<boolean>;
     private draftDir;
-    createDraft(id: string, task: string, sections: SpecSections): Promise<SpecDraft>;
+    /**
+     * A draft may be created before its tasks exist: the journey's Spec stage
+     * writes requirements and design, and `tasks.md` arrives from the ImplPlan
+     * stage behind its own gate (`writeDraftTasks`). The one-shot `/spec` path
+     * passes all three and is unaffected.
+     */
+    createDraft(id: string, task: string, sections: SpecDraftSections): Promise<SpecDraft>;
+    /**
+     * Write (or replace) a draft's `tasks.md`, which is the ImplPlan stage's
+     * artefact. `writeFile` truncates, so running the stage again after the person
+     * chose "Revise them" replaces the list rather than appending to it.
+     */
+    writeDraftTasks(id: string, tasks: string): Promise<void>;
     getDraft(id: string): Promise<SpecDraft | null>;
     listDrafts(): Promise<SpecDraft[]>;
     /** Approve what is on disk now (the user may have edited it), converting tasks.md to checkboxes if needed. */

package/dist/specs/store.js

@@ -134,6 +134,12 @@ export class SpecStore {
     draftDir(id) {
         return path.join(this.root, DRAFTS_DIR, id);
     }
+    /**
+     * A draft may be created before its tasks exist: the journey's Spec stage
+     * writes requirements and design, and `tasks.md` arrives from the ImplPlan
+     * stage behind its own gate (`writeDraftTasks`). The one-shot `/spec` path
+     * passes all three and is unaffected.
+     */
     async createDraft(id, task, sections) {
         assertSafeSpecId(id);
         const dir = this.draftDir(id);
@@ -142,11 +148,24 @@ export class SpecStore {
         await mkdir(dir, { recursive: true });
         await writeFile(path.join(dir, 'requirements.md'), sections.requirements, 'utf8');
         await writeFile(path.join(dir, 'design.md'), sections.design, 'utf8');
-        await writeFile(path.join(dir, 'tasks.md'), sections.tasks, 'utf8');
+        if (sections.tasks !== undefined)
+            await writeFile(path.join(dir, 'tasks.md'), sections.tasks, 'utf8');
         const createdAt = new Date().toISOString();
         await writeFile(path.join(dir, DRAFT_FILENAME), JSON.stringify({ id, task, createdAt }, null, 2), 'utf8');
         return { id, task, createdAt, dir };
     }
+    /**
+     * Write (or replace) a draft's `tasks.md`, which is the ImplPlan stage's
+     * artefact. `writeFile` truncates, so running the stage again after the person
+     * chose "Revise them" replaces the list rather than appending to it.
+     */
+    async writeDraftTasks(id, tasks) {
+        assertSafeSpecId(id);
+        const draft = await this.getDraft(id);
+        if (!draft)
+            throw new Error(`no draft ${id}`);
+        await writeFile(path.join(draft.dir, 'tasks.md'), tasks, 'utf8');
+    }
     async getDraft(id) {
         if (!isSafeSpecId(id))
             return null;
@@ -187,6 +206,12 @@ export class SpecStore {
         // Finish the spec inside the draft folder, then move it into place with one rename,
         // so a spec directory never exists half-written.
         const tasksPath = path.join(draft.dir, 'tasks.md');
+        // A journey draft has no tasks until the ImplPlan stage has run. Approving
+        // then would produce a spec the Specs tree shows with nothing to run, so say
+        // what is missing instead.
+        if (!existsSync(tasksPath)) {
+            throw new Error(`draft ${id} has no tasks.md: the implementation plan stage has not run yet`);
+        }
         await writeFile(tasksPath, convertToCheckboxes(await readFile(tasksPath, 'utf8')), 'utf8');
         const summary = { id, task: draft.task, approvedAt: new Date().toISOString(), dir: specDir };
         await writeFile(path.join(draft.dir, MANIFEST_FILENAME), JSON.stringify(summary, null, 2), 'utf8');

package/dist/specs/types.d.ts

@@ -4,6 +4,17 @@ export interface SpecSections {
     design: string;
     tasks: string;
 }
+/**
+ * A draft mid-journey. The Spec stage writes requirements and design; `tasks`
+ * arrives later, from the ImplPlan stage, behind its own gate. `SpecSections`
+ * deliberately stays all-required: the one-shot `/spec` path produces all three
+ * at once and nothing about it changes.
+ */
+export interface SpecDraftSections {
+    requirements: string;
+    design: string;
+    tasks?: string;
+}
 /** An unapproved spec in `.forge/specs/.drafts/<id>/`. */
 export interface SpecDraft {
     id: string;

package/dist/tools/ask-user.js

@@ -14,6 +14,18 @@ const UNAVAILABLE = {
     unavailable: true,
     note: 'No user is available. Choose the safest reasonable option and say what you assumed.',
 };
+/**
+ * A guided journey asks at most four questions. The budget is enforced here
+ * rather than in prompt text for the same reason stage gates live in the tool
+ * sandbox: a limit the model is merely told about is a limit it will exceed,
+ * and one bad extra question is what makes an interview feel like an
+ * interrogation (spec anti-goal 3).
+ */
+const BUDGET_SPENT = {
+    answer: '',
+    unavailable: true,
+    note: 'The question budget for this journey is spent: no more questions. Proceed with what you have and say what you assumed.',
+};
 export const askUserTool = {
     name: 'ask_user',
     description: 'Ask the user a clarifying question when you cannot proceed safely without their answer. Give a few options when you can. Do not ask for permission to run tools; approvals are handled separately.',
@@ -25,7 +37,23 @@ export const askUserTool = {
         const signal = ctx.abortSignal;
         if (signal?.aborted)
             return UNAVAILABLE;
-        const answered = ctx.askUser(args, signal).then((answer) => ({ answer }));
+        // Counted only once the question is actually put to a surface, so a refused
+        // or impossible question never spends part of the budget.
+        if (ctx.askBudget) {
+            if (ctx.askBudget.used >= ctx.askBudget.max)
+                return BUDGET_SPENT;
+            ctx.askBudget.used += 1;
+        }
+        const budget = ctx.askBudget;
+        const answered = ctx.askUser(args, signal).then((answer) => {
+            // A question the person dismissed resolves to an empty answer and must not
+            // cost part of the budget: four dismissals would otherwise end an interview
+            // without a single question being answered. Refunding keeps the budget a
+            // count of questions actually answered.
+            if (budget && answer.trim() === '')
+                budget.used = Math.max(0, budget.used - 1);
+            return { answer };
+        });
         const aborted = new Promise((resolve) => signal?.addEventListener('abort', () => resolve(UNAVAILABLE), { once: true }));
         return Promise.race([answered, aborted]);
     },

package/dist/tools/read-file.js

@@ -55,6 +55,11 @@ export const readFileTool = {
         }
         const text = decoded.text;
         const lines = text.split(/\r?\n/);
+        // A file that ends with a newline splits into one extra, empty piece. It is not a line. Numbering it told the model a
+        // 37-line file had 38 lines and that the last was empty (a live spec caught it), and made a file of exactly max_lines
+        // lines look truncated. A genuinely blank last line ("a\n\n") still counts: only the piece after the final newline goes.
+        if (lines.length > 1 && lines[lines.length - 1] === '')
+            lines.pop();
         const offset = args.offset ?? 1;
         const maxLines = args.max_lines ?? 2000;
         const slice = lines.slice(offset - 1, offset - 1 + maxLines);

package/dist/tools/sub-agent.d.ts

@@ -145,7 +145,7 @@ export declare function childAgentConfig(setup: {
     model: ModelConfig;
     maxIterations: number;
     systemPrompt?: string;
-}, ctx: Pick<ToolContext, 'autoApproveTools' | 'permissionRules' | 'toolSandbox'>, cwd: string, auto: boolean): AgentConfig;
+}, ctx: Pick<ToolContext, 'autoApproveTools' | 'permissionRules' | 'toolSandbox' | 'askBudget'>, cwd: string, auto: boolean): AgentConfig;
 /** What a child runs without asking: what the parent does, else the read-only tools. Destructive tools still never run unasked. */
 export declare function childAutoApprove(ctx: Pick<ToolContext, 'autoApproveTools'>): string[];
 /** The configured sub-agent model, else the parent's, else a last-resort default. */

package/dist/tools/sub-agent.js

@@ -328,6 +328,9 @@ export function childAgentConfig(setup, ctx, cwd, auto) {
         autoApproveTools: childAutoApprove(ctx),
         ...(ctx.permissionRules ? { permissionRules: ctx.permissionRules } : {}),
         ...(ctx.toolSandbox ? { toolSandbox: ctx.toolSandbox } : {}),
+        // The same budget object, not a copy: a child that started its own four
+        // would be a way around the limit the parent is under (RB-14).
+        ...(ctx.askBudget ? { askBudget: ctx.askBudget } : {}),
         // The child's toolset is the built-in set minus sub_agent, narrowed by the agent file when one is named.
         disableBuiltins: true,
         extraTools: setup.tools,

package/dist/types.d.ts

@@ -2,6 +2,7 @@ import type { ModelMessage, LanguageModel } from 'ai';
 import type { z } from 'zod';
 import type { BackgroundAgents } from './agent/background.js';
 import type { Attachment } from './attachments.js';
+import type { Answer } from './journey/types.js';
 import type { SkillRegistry } from './skills/types.js';
 /**
  * The summarizer takes a chunk of messages and returns a structured
@@ -114,6 +115,15 @@ export interface ToolContext {
     maxOutputChars?: number;
     /** Asks the person a question (`ask_user`); absent when no surface can answer. */
     askUser?: (question: UserQuestion, signal?: AbortSignal) => Promise<string>;
+    /**
+     * How many questions this run may still ask (a guided journey's interview
+     * budget). Mutated in place as questions are asked, and handed to a child
+     * agent so a child cannot start a fresh four (RB-14). Absent means no limit.
+     */
+    askBudget?: {
+        max: number;
+        used: number;
+    };
     /** The run's todo list. `set` also tells the UI (`todo_updated`). Supplied by the Agent. */
     todos?: {
         get(): TodoItem[];
@@ -570,6 +580,13 @@ export interface AgentConfig {
      * this project is checked and built. Added to the system prompt after the project instructions.
      */
     projectCommands?: string;
+    /**
+     * Answers the person gave in a guided journey's interview, rendered into the
+     * system prompt as a `<journey-answers>` block. The interview runs before the
+     * first agent run, because the blocks are assembled only on a session's first
+     * turn (see `buildInitialMessages`), so answers that arrive later cannot enter.
+     */
+    journeyAnswers?: Answer[];
     /**
      * Override the byte budget for memory injected into the system prompt.
      * Default 8 KB. Larger budgets use more context window but surface more
@@ -734,6 +751,14 @@ export interface AgentConfig {
      * Answers `ask_user`. When absent, or when `auto` is on, the model is not offered the tool.
      */
     askUser?: (question: UserQuestion, signal?: AbortSignal) => Promise<string>;
+    /**
+     * How many `ask_user` questions this run may ask. Reaches tools as
+     * `ToolContext.askBudget` and is handed down to sub-agents. Absent means no limit.
+     */
+    askBudget?: {
+        max: number;
+        used: number;
+    };
     /** The model `sub_agent` children run on; the parent's model when unset. */
     subAgentModel?: ModelConfig;
     /** Where background sub-agents are kept between messages. Without it `sub_agent { background: true }` runs the child to completion. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ikarmic/forge-core",
-  "version": "5.1.0",
+  "version": "5.1.1",
   "description": "Agent engine for IKarmic AI Forge. Model loop, tools, MCP, sandbox, memory, compaction, plan mode, skills, hooks.",
   "type": "module",
   "main": "./dist/index.js",