@moreih29/nexus-core 0.16.2 → 0.18.2

package/dist/mcp/definitions/task.d.ts

@@ -0,0 +1,138 @@
+import * as z from "zod/v3";
+export declare const taskAddTool: {
+    group: string;
+    name: string;
+    description: string;
+    inputSchema: {
+        title: z.ZodString;
+        context: z.ZodString;
+        acceptance: z.ZodString;
+        approach: z.ZodOptional<z.ZodString>;
+        risk: z.ZodOptional<z.ZodString>;
+        plan_issue: z.ZodOptional<z.ZodNumber>;
+        deps: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+        owner: z.ZodObject<{
+            role: z.ZodString;
+            agent_id: z.ZodOptional<z.ZodString>;
+            resume_tier: z.ZodOptional<z.ZodEnum<["persistent", "bounded", "ephemeral"]>>;
+        }, "strip", z.ZodTypeAny, {
+            role: string;
+            agent_id?: string | undefined;
+            resume_tier?: "persistent" | "bounded" | "ephemeral" | undefined;
+        }, {
+            role: string;
+            agent_id?: string | undefined;
+            resume_tier?: "persistent" | "bounded" | "ephemeral" | undefined;
+        }>;
+        goal: z.ZodOptional<z.ZodString>;
+        decisions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    };
+};
+export declare const taskListTool: {
+    group: string;
+    name: string;
+    description: string;
+    inputSchema: {
+        include_completed: z.ZodOptional<z.ZodBoolean>;
+    };
+};
+export declare const taskUpdateTool: {
+    group: string;
+    name: string;
+    description: string;
+    inputSchema: {
+        id: z.ZodNumber;
+        status: z.ZodOptional<z.ZodEnum<["pending", "in_progress", "completed"]>>;
+        owner: z.ZodOptional<z.ZodObject<{
+            agent_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            resume_tier: z.ZodOptional<z.ZodNullable<z.ZodEnum<["persistent", "bounded", "ephemeral"]>>>;
+        }, "strip", z.ZodTypeAny, {
+            agent_id?: string | null | undefined;
+            resume_tier?: "persistent" | "bounded" | "ephemeral" | null | undefined;
+        }, {
+            agent_id?: string | null | undefined;
+            resume_tier?: "persistent" | "bounded" | "ephemeral" | null | undefined;
+        }>>;
+    };
+};
+export declare const taskCloseTool: {
+    group: string;
+    name: string;
+    description: string;
+    inputSchema: {};
+};
+export declare const taskResumeTool: {
+    group: string;
+    name: string;
+    description: string;
+    inputSchema: {
+        id: z.ZodNumber;
+    };
+};
+export declare const taskToolDefinitions: readonly [{
+    group: string;
+    name: string;
+    description: string;
+    inputSchema: {
+        title: z.ZodString;
+        context: z.ZodString;
+        acceptance: z.ZodString;
+        approach: z.ZodOptional<z.ZodString>;
+        risk: z.ZodOptional<z.ZodString>;
+        plan_issue: z.ZodOptional<z.ZodNumber>;
+        deps: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+        owner: z.ZodObject<{
+            role: z.ZodString;
+            agent_id: z.ZodOptional<z.ZodString>;
+            resume_tier: z.ZodOptional<z.ZodEnum<["persistent", "bounded", "ephemeral"]>>;
+        }, "strip", z.ZodTypeAny, {
+            role: string;
+            agent_id?: string | undefined;
+            resume_tier?: "persistent" | "bounded" | "ephemeral" | undefined;
+        }, {
+            role: string;
+            agent_id?: string | undefined;
+            resume_tier?: "persistent" | "bounded" | "ephemeral" | undefined;
+        }>;
+        goal: z.ZodOptional<z.ZodString>;
+        decisions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    };
+}, {
+    group: string;
+    name: string;
+    description: string;
+    inputSchema: {
+        include_completed: z.ZodOptional<z.ZodBoolean>;
+    };
+}, {
+    group: string;
+    name: string;
+    description: string;
+    inputSchema: {
+        id: z.ZodNumber;
+        status: z.ZodOptional<z.ZodEnum<["pending", "in_progress", "completed"]>>;
+        owner: z.ZodOptional<z.ZodObject<{
+            agent_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            resume_tier: z.ZodOptional<z.ZodNullable<z.ZodEnum<["persistent", "bounded", "ephemeral"]>>>;
+        }, "strip", z.ZodTypeAny, {
+            agent_id?: string | null | undefined;
+            resume_tier?: "persistent" | "bounded" | "ephemeral" | null | undefined;
+        }, {
+            agent_id?: string | null | undefined;
+            resume_tier?: "persistent" | "bounded" | "ephemeral" | null | undefined;
+        }>>;
+    };
+}, {
+    group: string;
+    name: string;
+    description: string;
+    inputSchema: {};
+}, {
+    group: string;
+    name: string;
+    description: string;
+    inputSchema: {
+        id: z.ZodNumber;
+    };
+}];
+//# sourceMappingURL=task.d.ts.map

package/dist/mcp/definitions/task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task.d.ts","sourceRoot":"","sources":["../../../src/mcp/definitions/task.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAS5B,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBI,CAAC;AAE7B,eAAO,MAAM,YAAY;;;;;;;CAUG,CAAC;AAE7B,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;CAcC,CAAC;AAE7B,eAAO,MAAM,aAAa;;;;;CAME,CAAC;AAE7B,eAAO,MAAM,cAAc;;;;;;;CAOC,CAAC;AAE7B,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMtB,CAAC"}

package/dist/mcp/definitions/task.js

@@ -0,0 +1,78 @@
+import * as z from "zod/v3";
+import { ResumeTierSchema, TaskOwnerSchema } from "../../types/state.js";
+const TaskOwnerUpdateSchema = z.object({
+    agent_id: z.string().nullable().optional(),
+    resume_tier: ResumeTierSchema.nullable().optional(),
+});
+export const taskAddTool = {
+    group: "task",
+    name: "nx_task_add",
+    description: "Add a new task to tasks.json",
+    inputSchema: {
+        title: z.string().describe("Task title"),
+        context: z.string().describe("Task context"),
+        acceptance: z.string().describe("Definition of done. Required"),
+        approach: z.string().optional().describe("Implementation approach"),
+        risk: z.string().optional().describe("Known risk"),
+        plan_issue: z.number().optional().describe("Related plan issue ID"),
+        deps: z
+            .array(z.number())
+            .optional()
+            .describe("List of dependency task IDs"),
+        owner: TaskOwnerSchema.describe("Owner metadata. role is required"),
+        goal: z
+            .string()
+            .optional()
+            .describe("Replace the top-level goal in tasks.json"),
+        decisions: z
+            .array(z.string())
+            .optional()
+            .describe("Append entries to the top-level decisions list in tasks.json"),
+    },
+};
+export const taskListTool = {
+    group: "task",
+    name: "nx_task_list",
+    description: "Read tasks.json and return the task list with a summary",
+    inputSchema: {
+        include_completed: z
+            .boolean()
+            .optional()
+            .describe("Whether to include completed tasks. Defaults to true"),
+    },
+};
+export const taskUpdateTool = {
+    group: "task",
+    name: "nx_task_update",
+    description: "Partially update task status or owner metadata",
+    inputSchema: {
+        id: z.number().describe("Task ID to update"),
+        status: z
+            .enum(["pending", "in_progress", "completed"])
+            .optional()
+            .describe("New status"),
+        owner: TaskOwnerUpdateSchema.optional().describe("Partial owner update. Only agent_id and resume_tier are allowed; role cannot be changed"),
+    },
+};
+export const taskCloseTool = {
+    group: "task",
+    name: "nx_task_close",
+    description: "Close the current cycle, archive it to history.json, and remove plan.json and tasks.json",
+    inputSchema: {},
+};
+export const taskResumeTool = {
+    group: "task",
+    name: "nx_task_resume",
+    description: "Get task resume routing information based on owner.resume_tier",
+    inputSchema: {
+        id: z.number().describe("Task ID to look up"),
+    },
+};
+export const taskToolDefinitions = [
+    taskAddTool,
+    taskListTool,
+    taskUpdateTool,
+    taskCloseTool,
+    taskResumeTool,
+];
+//# sourceMappingURL=task.js.map

package/dist/mcp/definitions/task.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"task.js","sourceRoot":"","sources":["../../../src/mcp/definitions/task.ts"],"names":[],"mappings":"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"}

package/dist/mcp/handlers/artifact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifact.d.ts","sourceRoot":"","sources":["../../../src/mcp/handlers/artifact.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAczE,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CASlD;AA2BD,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAE7D"}

package/dist/mcp/handlers/artifact.js

@@ -0,0 +1,42 @@
+import { mkdir, realpath, writeFile } from "node:fs/promises";
+import { dirname, join, relative } from "node:path";
+import { textResult } from "../../shared/mcp-utils.js";
+import { findProjectRoot, getStateRoot } from "../../shared/paths.js";
+import { registerNxTools, } from "../../shared/register-tool.js";
+import { artifactWriteTool } from "../definitions/artifact.js";
+export function sanitizeName(input) {
+    const normalized = input.replace(/\\/g, "/");
+    const segments = normalized
+        .split("/")
+        .filter((s) => s && s !== "." && s !== "..");
+    if (segments.length === 0) {
+        throw new Error("Invalid filename: empty after sanitize");
+    }
+    return segments.join("/");
+}
+const artifactToolBindings = [
+    {
+        definition: artifactWriteTool,
+        handler: async ({ filename, content }) => {
+            const safeName = sanitizeName(filename);
+            const artifactsDir = join(getStateRoot(), "artifacts");
+            const outputPath = join(artifactsDir, safeName);
+            const outputDir = dirname(outputPath);
+            await mkdir(outputDir, { recursive: true });
+            const realOutputDir = await realpath(outputDir);
+            const realArtifactsDir = await realpath(artifactsDir);
+            if (!realOutputDir.startsWith(`${realArtifactsDir}/`) &&
+                realOutputDir !== realArtifactsDir) {
+                throw new Error("Security: resolved path escapes artifactsDir");
+            }
+            await writeFile(outputPath, content, "utf-8");
+            const projectRoot = findProjectRoot();
+            const relPath = relative(projectRoot, outputPath);
+            return textResult({ success: true, path: relPath });
+        },
+    },
+];
+export function registerArtifactTools(server) {
+    registerNxTools(server, artifactToolBindings);
+}
+//# sourceMappingURL=artifact.js.map

package/dist/mcp/handlers/artifact.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifact.js","sourceRoot":"","sources":["../../../src/mcp/handlers/artifact.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC9D,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAEpD,OAAO,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,EAEL,eAAe,GAChB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAO/D,MAAM,UAAU,YAAY,CAAC,KAAa;IACxC,MAAM,UAAU,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;IAC7C,MAAM,QAAQ,GAAG,UAAU;SACxB,KAAK,CAAC,GAAG,CAAC;SACV,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,IAAI,CAAC,CAAC;IAC/C,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC1B,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;IAC5D,CAAC;IACD,OAAO,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAC5B,CAAC;AAED,MAAM,oBAAoB,GAAiC;IACzD;QACE,UAAU,EAAE,iBAAiB;QAC7B,OAAO,EAAE,KAAK,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAqB,EAAE,EAAE;YAC1D,MAAM,QAAQ,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAC;YACxC,MAAM,YAAY,GAAG,IAAI,CAAC,YAAY,EAAE,EAAE,WAAW,CAAC,CAAC;YACvD,MAAM,UAAU,GAAG,IAAI,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC;YAChD,MAAM,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;YACtC,MAAM,KAAK,CAAC,SAAS,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;YAC5C,MAAM,aAAa,GAAG,MAAM,QAAQ,CAAC,SAAS,CAAC,CAAC;YAChD,MAAM,gBAAgB,GAAG,MAAM,QAAQ,CAAC,YAAY,CAAC,CAAC;YACtD,IACE,CAAC,aAAa,CAAC,UAAU,CAAC,GAAG,gBAAgB,GAAG,CAAC;gBACjD,aAAa,KAAK,gBAAgB,EAClC,CAAC;gBACD,MAAM,IAAI,KAAK,CAAC,8CAA8C,CAAC,CAAC;YAClE,CAAC;YACD,MAAM,SAAS,CAAC,UAAU,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;YAC9C,MAAM,WAAW,GAAG,eAAe,EAAE,CAAC;YACtC,MAAM,OAAO,GAAG,QAAQ,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC;YAClD,OAAO,UAAU,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;QACtD,CAAC;KACF;CACF,CAAC;AAEF,MAAM,UAAU,qBAAqB,CAAC,MAAiB;IACrD,eAAe,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;AAChD,CAAC"}

package/dist/mcp/handlers/history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"history.d.ts","sourceRoot":"","sources":["../../../src/mcp/handlers/history.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AA+CzE,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAE5D"}

package/dist/mcp/handlers/history.js

@@ -0,0 +1,35 @@
+import { join } from "node:path";
+import { readJsonFile } from "../../shared/json-store.js";
+import { textResult } from "../../shared/mcp-utils.js";
+import { getNexusRoot } from "../../shared/paths.js";
+import { registerNxTools, } from "../../shared/register-tool.js";
+import { historySearchTool } from "../definitions/history.js";
+const historyToolBindings = [
+    {
+        definition: historySearchTool,
+        handler: async ({ query, last_n }) => {
+            const historyPath = join(getNexusRoot(), "history.json");
+            const history = await readJsonFile(historyPath, {
+                cycles: [],
+            });
+            let cycles = Array.isArray(history.cycles) ? history.cycles : [];
+            if (query && query.length > 0) {
+                const q = query.toLowerCase();
+                cycles = cycles.filter((c) => JSON.stringify(c).toLowerCase().includes(q));
+            }
+            const total = cycles.length;
+            const reversed = [...cycles].reverse();
+            const limit = last_n ?? 10;
+            const showing = reversed.slice(0, limit);
+            return textResult({
+                total,
+                showing: showing.length,
+                cycles: showing,
+            });
+        },
+    },
+];
+export function registerHistoryTools(server) {
+    registerNxTools(server, historyToolBindings);
+}
+//# sourceMappingURL=history.js.map

package/dist/mcp/handlers/history.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"history.js","sourceRoot":"","sources":["../../../src/mcp/handlers/history.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAEL,eAAe,GAChB,MAAM,+BAA+B,CAAC;AAEvC,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAO9D,MAAM,mBAAmB,GAAiC;IACxD;QACE,UAAU,EAAE,iBAAiB;QAC7B,OAAO,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,MAAM,EAAqB,EAAE,EAAE;YACtD,MAAM,WAAW,GAAG,IAAI,CAAC,YAAY,EAAE,EAAE,cAAc,CAAC,CAAC;YACzD,MAAM,OAAO,GAAG,MAAM,YAAY,CAAc,WAAW,EAAE;gBAC3D,MAAM,EAAE,EAAE;aACX,CAAC,CAAC;YACH,IAAI,MAAM,GAAG,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;YAEjE,IAAI,KAAK,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAC9B,MAAM,CAAC,GAAG,KAAK,CAAC,WAAW,EAAE,CAAC;gBAC9B,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAC3B,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,CAC5C,CAAC;YACJ,CAAC;YAED,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC;YAC5B,MAAM,QAAQ,GAAG,CAAC,GAAG,MAAM,CAAC,CAAC,OAAO,EAAE,CAAC;YACvC,MAAM,KAAK,GAAG,MAAM,IAAI,EAAE,CAAC;YAC3B,MAAM,OAAO,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;YAEzC,OAAO,UAAU,CAAC;gBAChB,KAAK;gBACL,OAAO,EAAE,OAAO,CAAC,MAAM;gBACvB,MAAM,EAAE,OAAO;aAChB,CAAC,CAAC;QACL,CAAC;KACF;CACF,CAAC;AAEF,MAAM,UAAU,oBAAoB,CAAC,MAAiB;IACpD,eAAe,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;AAC/C,CAAC"}

package/dist/mcp/handlers/plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../../src/mcp/handlers/plan.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AA2bzE,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAEzD"}

package/dist/mcp/handlers/plan.js

@@ -0,0 +1,324 @@
+import fs from "node:fs";
+import { join } from "node:path";
+import { readJsonFile, updateJsonFileLocked, writeJsonFile, } from "../../shared/json-store.js";
+import { textResult } from "../../shared/mcp-utils.js";
+import { ensureDir, getCurrentBranch, getNexusRoot, getStateRoot, } from "../../shared/paths.js";
+import { registerNxTools, } from "../../shared/register-tool.js";
+import { planAnalysisAddTool, planDecideTool, planResumeTool, planStartTool, planStatusTool, planUpdateTool, } from "../definitions/plan.js";
+function planPath() {
+    return join(getStateRoot(), "plan.json");
+}
+function historyPath() {
+    return join(getNexusRoot(), "history.json");
+}
+async function nextPlanId() {
+    const history = await readJsonFile(historyPath(), {
+        cycles: [],
+    });
+    let maxId = 0;
+    for (const cycle of history.cycles) {
+        if (cycle.plan && typeof cycle.plan.id === "number") {
+            maxId = Math.max(maxId, cycle.plan.id);
+        }
+    }
+    return maxId + 1;
+}
+const planToolBindings = [
+    {
+        definition: planStartTool,
+        handler: async ({ topic, issues, research_summary }) => {
+            if (!research_summary || research_summary.trim() === "") {
+                throw new Error("research_summary is required — complete research before starting a plan");
+            }
+            const hPath = historyPath();
+            const pPath = planPath();
+            const existingRaw = await readJsonFile(pPath, null);
+            let previousArchived = false;
+            if (existingRaw) {
+                try {
+                    ensureDir(getNexusRoot());
+                    await updateJsonFileLocked(hPath, { cycles: [] }, (history) => ({
+                        ...history,
+                        cycles: [
+                            ...(Array.isArray(history.cycles) ? history.cycles : []),
+                            {
+                                completed_at: new Date().toISOString(),
+                                branch: getCurrentBranch(),
+                                plan: existingRaw,
+                                tasks: [],
+                            },
+                        ],
+                    }));
+                }
+                catch { }
+                try {
+                    fs.unlinkSync(pPath);
+                }
+                catch { }
+                previousArchived = true;
+            }
+            const planId = await nextPlanId();
+            const now = new Date().toISOString();
+            const newPlan = {
+                id: planId,
+                topic,
+                issues: issues.map((title, index) => ({
+                    id: index + 1,
+                    title,
+                    status: "pending",
+                })),
+                research_summary,
+                created_at: now,
+            };
+            ensureDir(getStateRoot());
+            await writeJsonFile(pPath, newPlan);
+            return textResult({
+                created: true,
+                plan_id: planId,
+                topic,
+                issueCount: issues.length,
+                previousArchived,
+            });
+        },
+    },
+    {
+        definition: planStatusTool,
+        handler: async () => {
+            const plan = await readJsonFile(planPath(), null);
+            if (!plan) {
+                return textResult({ exists: false });
+            }
+            const total = plan.issues.length;
+            const pending = plan.issues.filter((issue) => issue.status === "pending").length;
+            const decided = plan.issues.filter((issue) => issue.status === "decided").length;
+            return textResult({
+                exists: true,
+                id: plan.id,
+                topic: plan.topic,
+                summary: { total, pending, decided },
+                issues: plan.issues.map((issue) => ({
+                    id: issue.id,
+                    title: issue.title,
+                    status: issue.status,
+                    ...(issue.decision !== undefined ? { decision: issue.decision } : {}),
+                })),
+            });
+        },
+    },
+    {
+        definition: planUpdateTool,
+        handler: async ({ action, issue_id, title }) => {
+            const pPath = planPath();
+            let result = {};
+            await updateJsonFileLocked(pPath, null, (raw) => {
+                if (!raw) {
+                    throw new Error("No active plan");
+                }
+                if (action === "add") {
+                    if (!title) {
+                        throw new Error("title is required for add");
+                    }
+                    const maxId = raw.issues.reduce((m, issue) => Math.max(m, issue.id), 0);
+                    const newIssue = {
+                        id: maxId + 1,
+                        title,
+                        status: "pending",
+                    };
+                    raw.issues.push(newIssue);
+                    result = {
+                        updated: true,
+                        action,
+                        issue_id: newIssue.id,
+                        issue: newIssue,
+                    };
+                    return raw;
+                }
+                if (action === "remove") {
+                    if (issue_id === undefined) {
+                        throw new Error("issue_id is required for remove");
+                    }
+                    const index = raw.issues.findIndex((issue) => issue.id === issue_id);
+                    if (index === -1) {
+                        throw new Error(`Issue ${issue_id} not found`);
+                    }
+                    const [removed] = raw.issues.splice(index, 1);
+                    result = { updated: true, action, issue_id: removed.id };
+                    return raw;
+                }
+                if (action === "modify") {
+                    if (issue_id === undefined || !title) {
+                        throw new Error("issue_id and title are required for modify");
+                    }
+                    const issue = raw.issues.find((candidate) => candidate.id === issue_id);
+                    if (!issue) {
+                        throw new Error(`Issue ${issue_id} not found`);
+                    }
+                    issue.title = title;
+                    result = {
+                        updated: true,
+                        action,
+                        issue_id: issue.id,
+                        title: issue.title,
+                    };
+                    return raw;
+                }
+                if (issue_id === undefined) {
+                    throw new Error("issue_id is required for reopen");
+                }
+                const issue = raw.issues.find((candidate) => candidate.id === issue_id);
+                if (!issue) {
+                    throw new Error(`Issue ${issue_id} not found`);
+                }
+                issue.status = "pending";
+                delete issue.decision;
+                result = {
+                    updated: true,
+                    action,
+                    issue_id: issue.id,
+                    status: issue.status,
+                };
+                return raw;
+            });
+            return textResult(result);
+        },
+    },
+    {
+        definition: planDecideTool,
+        handler: async ({ issue_id, decision, how_agents, how_summary, how_agent_ids, }) => {
+            const pPath = planPath();
+            let responsePayload = {};
+            await updateJsonFileLocked(pPath, null, (raw) => {
+                if (!raw) {
+                    throw new Error("No active plan");
+                }
+                const issue = raw.issues.find((candidate) => candidate.id === issue_id);
+                if (!issue) {
+                    throw new Error(`Issue ${issue_id} not found`);
+                }
+                if (issue.status === "decided") {
+                    throw new Error("이미 결정된 issue입니다. 재결정은 reopen 후 진행하세요.");
+                }
+                issue.status = "decided";
+                issue.decision = decision;
+                if (how_agents && how_agents.length > 0) {
+                    const now = new Date().toISOString();
+                    if (!issue.analysis) {
+                        issue.analysis = [];
+                    }
+                    for (const agentName of how_agents) {
+                        const entry = {
+                            role: agentName,
+                            summary: how_summary?.[agentName] ?? "",
+                            recorded_at: now,
+                        };
+                        if (how_agent_ids?.[agentName]) {
+                            entry.agent_id = how_agent_ids[agentName];
+                        }
+                        issue.analysis.push(entry);
+                    }
+                }
+                const allComplete = raw.issues.every((candidate) => candidate.status === "decided");
+                const remaining = raw.issues.filter((candidate) => candidate.status !== "decided");
+                responsePayload = {
+                    decided: true,
+                    issue: {
+                        id: issue.id,
+                        title: issue.title,
+                        status: issue.status,
+                        decision: issue.decision,
+                    },
+                    allComplete,
+                    remaining: remaining.map((candidate) => ({
+                        id: candidate.id,
+                        title: candidate.title,
+                        status: candidate.status,
+                    })),
+                    ...(allComplete
+                        ? {
+                            message: "모든 안건이 결정되었습니다. tasks.json으로 태스크를 생성하세요.",
+                        }
+                        : {}),
+                };
+                return raw;
+            });
+            return textResult(responsePayload);
+        },
+    },
+    {
+        definition: planResumeTool,
+        handler: async ({ role }) => {
+            const plan = await readJsonFile(planPath(), null);
+            if (!plan) {
+                return textResult({
+                    role,
+                    resumable: false,
+                    agent_id: null,
+                    resume_tier: null,
+                    issue_id: null,
+                });
+            }
+            let latestEntry = null;
+            let latestIssueId = null;
+            let latestTime = "";
+            for (const issue of plan.issues) {
+                if (!issue.analysis) {
+                    continue;
+                }
+                for (const entry of issue.analysis) {
+                    if (entry.role === role && entry.recorded_at > latestTime) {
+                        latestTime = entry.recorded_at;
+                        latestEntry = entry;
+                        latestIssueId = issue.id;
+                    }
+                }
+            }
+            return textResult({
+                role,
+                resumable: latestEntry !== null,
+                agent_id: latestEntry?.agent_id ?? null,
+                resume_tier: null,
+                issue_id: latestIssueId,
+            });
+        },
+    },
+    {
+        definition: planAnalysisAddTool,
+        handler: async ({ issue_id, role, agent_id, summary, }) => {
+            const pPath = planPath();
+            let responsePayload = {};
+            await updateJsonFileLocked(pPath, null, (raw) => {
+                if (!raw) {
+                    throw new Error("No active plan");
+                }
+                const issue = raw.issues.find((candidate) => candidate.id === issue_id);
+                if (!issue) {
+                    throw new Error(`Issue ${issue_id} not found`);
+                }
+                if (!issue.analysis) {
+                    issue.analysis = [];
+                }
+                const recorded_at = new Date().toISOString();
+                const entry = {
+                    role,
+                    summary,
+                    recorded_at,
+                    ...(agent_id !== undefined ? { agent_id } : {}),
+                };
+                issue.analysis.push(entry);
+                responsePayload = {
+                    added: true,
+                    issue_id,
+                    role,
+                    recorded_at,
+                    total_entries: issue.analysis.length,
+                };
+                return raw;
+            });
+            return textResult(responsePayload);
+        },
+    },
+];
+export function registerPlanTools(server) {
+    registerNxTools(server, planToolBindings);
+}
+//# sourceMappingURL=plan.js.map