@agent-plan/mcp 0.2.10 → 0.2.16

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAgyBA,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CAItD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AA21BA,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CAItD"}

package/dist/index.js

@@ -7,7 +7,7 @@ import { existsSync } from "node:fs";
 import { pathToFileURL } from "node:url";
 import { PlanStore, ExportService, withFeatureLock, needsMotivation } from "@agent-plan/core";
 import { serve } from "@agent-plan/server";
-import { createChecklistItemId, createFeatureId, createPhaseId, createTaskId, normalizeSlug } from "@agent-plan/core/naming";
+import { createChecklistItemId, createFeatureId, createPhaseId, createTaskId, clampSlug, normalizeSlug } from "@agent-plan/core/naming";
 const STATUS_VALUES = ["planned", "in-progress", "done", "blocked", "canceled", "rejected", "deferred", "waiting"];
 const PHASE_STATUS_VALUES = ["draft", "discovery", ...STATUS_VALUES];
 function text(textValue, structuredContent) {
@@ -30,9 +30,67 @@ async function requireStore() {
         throw new Error(`No .planner/ found at ${st.root}. Use planner-init first.`);
     return st;
 }
-// In-process web server handle, managed by the planner-web tool. Lives as long
-// as this MCP stdio process (i.e. the host session). Null when not running.
+// In-process web server handle, managed by the planner-web tool and planner-load.
+// Lives as long as this MCP stdio process (i.e. the host session). Null when not running.
 let webHandle = null;
+/** Start the web dashboard on LAN (0.0.0.0:0, OS-assigned port) if not already
+ *  running. Returns the local/LAN URLs. No-op (empty url) when no .planner/ exists. */
+async function ensureWebStarted() {
+    if (webHandle)
+        return { localUrl: webHandle.localUrl, lanUrl: webHandle.lanUrl, mode: webHandle.mode };
+    const root = planRoot();
+    const st = new PlanStore(root);
+    if (!(await st.exists()))
+        return { localUrl: "" };
+    try {
+        webHandle = await serve({ planRoot: root, host: "0.0.0.0", port: 0, quiet: true });
+        return { localUrl: webHandle.localUrl, lanUrl: webHandle.lanUrl, mode: webHandle.mode };
+    }
+    catch {
+        return { localUrl: "" };
+    }
+}
+/** Build a consolidated planner recap (project state + active work + pending
+ *  handoff + web URL). Harness-agnostic equivalent of Pi's buildStartupResumeSummary. */
+async function buildRecapText(st, web) {
+    const [plan, resume, handoff] = await Promise.all([st.loadAll(), st.loadResume(), st.loadHandoff()]);
+    const allTasks = plan.phases.flatMap((p) => p.tasks.map((t) => ({ phase: p, task: t })));
+    const totalF = plan.features.features.length;
+    const doneF = plan.features.features.filter((f) => f.status === "done").length;
+    const activeF = plan.features.features.filter((f) => f.status === "in-progress").length;
+    const totalP = plan.phases.length;
+    const doneP = plan.phases.filter((p) => p.status === "done").length;
+    const activeP = plan.phases.filter((p) => p.status === "in-progress" || p.status === "discovery").length;
+    const totalT = allTasks.length;
+    const doneT = allTasks.filter(({ task }) => task.status === "done").length;
+    const activeT = allTasks.filter(({ task }) => task.status === "in-progress").length;
+    const inProgress = allTasks.filter(({ task }) => task.status === "in-progress");
+    const focus = inProgress[0];
+    const focusFeature = focus ? plan.features.features.find((f) => f.id === focus.phase.featureId) : undefined;
+    const lines = [];
+    lines.push("## Planner recap");
+    const name = plan.project.name || "(unnamed project)";
+    lines.push(`Project: ${name}${plan.project.goal ? " — " + plan.project.goal : ""}`);
+    lines.push(`Progress: Features ${doneF}/${totalF} done (${activeF} active) · Phases ${doneP}/${totalP} done (${activeP} active) · Tasks ${doneT}/${totalT} done (${activeT} active)`);
+    if (focus) {
+        lines.push(`Current focus: ${focusFeature?.name ?? "?"} / ${focus.phase.title} / ${focus.task.title} (in-progress)`);
+    }
+    else {
+        lines.push("Current focus: no active task — review the plan and pick the next concrete task");
+    }
+    if (resume?.nextSteps?.length)
+        lines.push(`Next step: ${resume.nextSteps[0]}`);
+    if (handoff) {
+        lines.push("", "## Pending handoff (read me first)", handoff.content || "(empty handoff)", "", "→ After processing the handoff above, call planner-handoff-clear to remove it.");
+    }
+    else if (activeT === 0) {
+        lines.push("", "No handoff pending and no task in-progress. Use planner-task-add / planner-task-start to begin work.");
+    }
+    if (web.localUrl) {
+        lines.push("", "## Web UI", `🌐 ${web.localUrl}${web.lanUrl ? " (LAN: " + web.lanUrl + ")" : ""}`);
+    }
+    return lines.join("\n");
+}
 function findFeatureByRef(features, ref) {
     const normalized = ref.trim().toLowerCase();
     return features.find((feature) => feature.id.toLowerCase() === normalized)
@@ -508,7 +566,7 @@ server.registerTool("planner-task-add", {
         id: taskId,
         phaseId: found.id,
         number: found.tasks.length + 1,
-        shortName: normalizeSlug(title).slice(0, 30),
+        shortName: clampSlug(title, 30, `task-${Date.now().toString(36)}`),
         title: title.trim(),
         status: "planned",
         description: description?.trim() ?? "",
@@ -644,12 +702,13 @@ server.registerTool("planner-task-start", {
     inputSchema: { task: z.string().min(1) },
 }, async ({ task: ref }) => {
     const st = await requireStore();
-    // Hygiene Gate: block starting work if a pending handoff exists.
-    if (existsSync(join(st.root, "HANDOFF.md"))) {
-        return text(`🚨 HYGIENE VIOLATION: A pending handoff file exists at .planner/HANDOFF.md. ` +
-            `You MUST read and delete it before you can officially start a task. ` +
-            `This is a non-negotiable rule in AGENTS.md.`);
-    }
+    // Hygiene notice (non-blocking): surface an existing handoff but never block
+    // task_start — the handoff is a captured-context artifact, not a lock (e.g. a
+    // small modification after writing a handoff should start without forcing
+    // deletion, which would lose context).
+    const handoffNotice = existsSync(join(st.root, "HANDOFF.md"))
+        ? "ℹ️  A handoff exists at .planner/HANDOFF.md — read it for context, then delete it with planner-handoff-delete when no longer needed. Proceeding with task start.\n"
+        : "";
     const found = findTaskByRef(await st.loadAllPhases(), ref);
     if (!found)
         return text(`Task not found: ${ref}`);
@@ -677,7 +736,7 @@ server.registerTool("planner-task-start", {
         return phase;
     });
     await st.syncTaskStatusRollup(found.phase.id);
-    return writeAndSummarize(st, `✅ Task started: ${found.task.id}`, { task: updatedTask ?? found.task });
+    return writeAndSummarize(st, `${handoffNotice}✅ Task started: ${found.task.id}`, { task: updatedTask ?? found.task });
 });
 server.registerTool("planner-task-complete", {
     description: "Set a task to done. Fails if checklist is incomplete unless force=true.",
@@ -798,8 +857,15 @@ server.registerTool("planner-web", {
     return text("planner-web not running. Use planner-web with action=start to start the dashboard.");
 });
 server.registerTool("planner-load", {
-    description: "MCP no-op equivalent of Pi /planner load. MCP server is already loaded when tools are available.",
-}, async () => text("Planner MCP server is loaded."));
+    description: "Load/refresh the planner on explicit user request (NOT automatic): starts the web dashboard on LAN and returns a consolidated recap (project state, active task, pending handoff, web URL). This is the MCP equivalent of Pi /planner load. Call it ONLY when the user runs /planner load or /planner recap (or asks to load the planner). Present the recap to the user in that reply, including the web URL on a final prominent line. If a pending handoff is included, read it, summarize it to the user, then call planner-handoff-clear. Do NOT start the planner/web or show the web URL unless the user explicitly asks (load/recap/web status).",
+}, async () => {
+    const st = store();
+    if (!(await st.exists()))
+        return text("No .planner/ found at " + planRoot() + ". Run planner-init first.");
+    const web = await ensureWebStarted();
+    const recap = await buildRecapText(st, web);
+    return text(recap);
+});
 server.registerTool("planner-disable", {
     description: "MCP no-op equivalent of Pi /planner disable. Stop the MCP process from the host to disable it.",
 }, async () => text("To disable planner MCP, remove/disable this MCP server from the host config or stop the process."));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-plan/mcp",
-  "version": "0.2.10",
+  "version": "0.2.16",
   "private": false,
   "description": "MCP server for Agent Plan, exposing planner-* tools over stdio.",
   "license": "MIT",
@@ -41,8 +41,8 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.17.0",
     "zod": "^3.24.0",
-    "@agent-plan/core": "0.2.10",
-    "@agent-plan/server": "0.2.10"
+    "@agent-plan/core": "0.2.16",
+    "@agent-plan/server": "0.2.16"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",