ostacky 0.5.9 → 0.5.10

package/dist/cli.js

@@ -161,7 +161,7 @@ var require_picocolors = __commonJS((exports, module) => {
 // package.json
 var package_default = {
   name: "ostacky",
-  version: "0.5.9",
+  version: "0.5.10",
   description: "Instalador interactivo de agentes y comandos para OpenCode",
   type: "module",
   bin: {
@@ -879,16 +879,16 @@ import { join as join5 } from "path";
 import { existsSync as existsSync4 } from "fs";
 // manifest.json
 var manifest_default = {
-  version: "0.5.9",
+  version: "0.5.10",
   repo: "JaimeHoracio/Ostacky",
-  tag: "v0.5.9",
+  tag: "v0.5.10",
   agents: [
     {
       name: "ostacky",
       file: "assets/agents/ostacky.md",
       description: "Orquestador principal con ruteo por nivel de impacto, máquina de estados persistida (controller MCP), edición segura con 3 outcomes, y delegación en OpenSpec + Superpowers",
-      version: "0.5.9",
-      sha256: "ede9800f644d890fa81c4827592ca62ce00756a25fbdb594cb8a7b40cd7ca2fc"
+      version: "0.5.10",
+      sha256: "c624b9163a97fe0aa17a4688f59e2bcfa958c64fbde71c05c0c071911f62b7ad"
     }
   ],
   commands: [
@@ -896,14 +896,14 @@ var manifest_default = {
       name: "install-stack",
       file: "assets/commands/install-stack.md",
       description: "Instala el stack tecnológico del proyecto (CodeGraph, skills, OpenSpec, Engram, Context7, controller MCP)",
-      version: "0.5.9",
-      sha256: "598b54bed669586f832193226ebeddbda325325f8f237ba5104ab3ee58f2ac29"
+      version: "0.5.10",
+      sha256: "61f18cb616bffe4a982d874ee9426011c203ab9c17efb88d44592e202c699330"
     },
     {
       name: "opsx-sync",
       file: "assets/commands/opsx-sync.md",
       description: "Sincroniza delta specs del change activo sin inicializar CodeGraph si ya existe índice",
-      version: "0.5.9",
+      version: "0.5.10",
       sha256: "ed9948f1910743b672e1dfad496bc96972a224a98b063232be39290d43068c50"
     }
   ],
@@ -912,8 +912,8 @@ var manifest_default = {
       name: "ostacky-controller",
       file: "assets/mcp/ostacky-controller/",
       description: "Máquina de estados persistida para Ostacky: 13 tools MCP para ciclo completo de request (start_request → discovery → route → execution → sync → done), edición segura con validación de transiciones y persistencia atómica",
-      version: "0.5.9",
-      sha256: "68b42dfb65938e423a7c81d9e9b179c0d82533047d5c0205cf459f5aa2fc6fa2"
+      version: "0.5.10",
+      sha256: "4469b9e26910a5ba016a0fe7a2d77507d40715d95ce4cbb31c498bf7001b4d0d"
     }
   ],
   skills: [
@@ -921,98 +921,98 @@ var manifest_default = {
       name: "thinking",
       file: "assets/skills/thinking/SKILL.md",
       description: "Skill unificado de pensamiento con dos modos: creative-design (producción de diseño → transición a writing-plans o openspec-propose) y open-exploration (exploración libre)",
-      version: "0.5.9",
+      version: "0.5.10",
       sha256: "6a1fdac86357f89e132013e56cb84c1920880c1c035a8dcf53f69e01824724bb"
     },
     {
       name: "execution-mode-evaluation",
       file: "assets/skills/execution-mode-evaluation/SKILL.md",
       description: "Skill de análisis de modo de ejecución — output reconciliado con controller snapshot contract (recommendation field)",
-      version: "0.5.9",
+      version: "0.5.10",
       sha256: "048925aec576dff014eed0b44e2a553c635ae405f5a245773f480be9b84d18a7"
     },
     {
       name: "writing-plans",
       file: "assets/skills/writing-plans/SKILL.md",
       description: "Skill de planificación de implementación (Superpowers) — execution handoff removido, Ostacky decide modo de ejecución",
-      version: "0.5.9",
+      version: "0.5.10",
       sha256: "13f6e43522567505da90793934d414d290d56f4ea587ac696f66416af9e7633f"
     },
     {
       name: "tdd",
       file: "assets/skills/tdd/SKILL.md",
       description: "Skill de test-driven development (Superpowers)",
-      version: "0.5.9",
+      version: "0.5.10",
       sha256: "7eacd8ee81dc5c0b85065c0392e37ee10314661f7edb59dd8e70a9e0dae8f371"
     },
     {
       name: "subagent-driven-development",
       file: "assets/skills/subagent-driven-development/SKILL.md",
       description: "Skill de ejecución con subagentes (Superpowers) — ejecuta solo después de confirmación del coordinador Ostacky",
-      version: "0.5.9",
+      version: "0.5.10",
       sha256: "cdacae2e5b86f6a642ad0316172cee7dc8d19e909ef4f9ab7fcf7e84a248dda3"
     },
     {
       name: "dispatching-parallel-agents",
       file: "assets/skills/dispatching-parallel-agents/SKILL.md",
       description: "Skill de dispatch paralelo de agentes (Superpowers)",
-      version: "0.5.9",
+      version: "0.5.10",
       sha256: "281edf0c38f358497c7e2066fa8217a2ba3e2a39b4205c4af0c41d328fc035a1"
     },
     {
       name: "review",
       file: "assets/skills/review/SKILL.md",
       description: "Skill de revisión de código (Superpowers)",
-      version: "0.5.9",
+      version: "0.5.10",
       sha256: "14831d9ef3746ef6e2e6047c868fe7aa296d01f0644227ce776fe99436357b1a"
     },
     {
       name: "receiving-code-review",
       file: "assets/skills/receiving-code-review/SKILL.md",
       description: "Skill de recibir y procesar feedback de code review",
-      version: "0.5.9",
+      version: "0.5.10",
       sha256: "0a5780e8a41539d15428114b7c46f36670acc16aba0db3348d36be1175433872"
     },
     {
       name: "openspec-propose",
       file: "assets/skills/openspec-propose/SKILL.md",
       description: "Skill de generación de proposal (OpenSpec)",
-      version: "0.5.9",
+      version: "0.5.10",
       sha256: "3306b21ba9cb8c1611e8ba335126982f3767f7d317b5ed506c57a14c5f88b263"
     },
     {
       name: "openspec-apply-change",
       file: "assets/skills/openspec-apply-change/SKILL.md",
       description: "Skill de aplicación de change (OpenSpec)",
-      version: "0.5.9",
+      version: "0.5.10",
       sha256: "31c1313c3de4616a07efd89306c4c058175d018f42d4381cc7da7030fd03ba30"
     },
     {
       name: "openspec-archive-change",
       file: "assets/skills/openspec-archive-change/SKILL.md",
       description: "Skill de archivo de change (OpenSpec)",
-      version: "0.5.9",
+      version: "0.5.10",
       sha256: "5bf65d1848457bd57be1d21707e55fe6746cdee33bce2f32f12d87661b6aa3a4"
     },
     {
       name: "using-git-worktrees",
       file: "assets/skills/using-git-worktrees/SKILL.md",
       description: "Skill de uso de git worktrees para aislamiento de trabajo",
-      version: "0.5.9",
+      version: "0.5.10",
       sha256: "33433c24f753d566cde16c0931f70d746b6b0cb4d1f3daaa619e928b009e4fc9"
     },
     {
       name: "using-superpowers",
       file: "assets/skills/using-superpowers/SKILL.md",
       description: "Skill de orquestación de Superpowers skills",
-      version: "0.5.9",
+      version: "0.5.10",
       sha256: "fba542003aa788b5edb4ae2d1135773a1dde8111d1dd60378e2f61b6695d46fc"
     },
     {
       name: "writing-skills",
       file: "assets/skills/writing-skills/SKILL.md",
       description: "Skill de creación y edición de skills",
-      version: "0.5.9",
+      version: "0.5.10",
       sha256: "7f74ffe049283803640d78f8c9ac1ea5f5e626dedb885ecff29a87c5b5d41598"
     }
   ]
@@ -1204,7 +1204,7 @@ function clearLockfile(opencodeRoot) {
   const lockfile = readLockfile(opencodeRoot);
   if (!lockfile) {
     writeLockfile(opencodeRoot, {
-      version: "0.5.9",
+      version: "0.5.10",
       lockedAt: new Date().toISOString(),
       repo: "",
       tag: "",
@@ -1514,9 +1514,8 @@ async function installMcpServer(item, manifest, paths) {
       if (output)
         console.error(output);
     } catch (e2) {
-      throw new Error(`MCP server "${item.name}" copiado pero ${installCmd} falló: ${e2.message}.
-` + `Resolvé las dependencias manualmente:
-` + `  cd .opencode/mcp/${item.name} && bun install`);
+      console.error(`[WARN] MCP server "${item.name}" copiado pero ${installCmd} falló: ${e2.message}.
+` + `  Resolvé las dependencias manualmente: cd .opencode/mcp/${item.name} && bun install`);
     }
   }
   upsertLockfile(paths, "mcpServers", item, manifest, treeHash);

package/dist/mcp/ostacky-controller/index.js

@@ -12263,21 +12263,21 @@ var require_errors = /* @__PURE__ */ __commonJSMin((exports) => {
   function extendErrors({ gen, keyword, schemaValue, data, errsCount, it }) {
     if (errsCount === undefined)
       throw new Error("ajv implementation error");
-    const err = gen.name("err");
+    const err2 = gen.name("err");
     gen.forRange("i", errsCount, names_1.default.errors, (i) => {
-      gen.const(err, (0, codegen_1._)`${names_1.default.vErrors}[${i}]`);
-      gen.if((0, codegen_1._)`${err}.instancePath === undefined`, () => gen.assign((0, codegen_1._)`${err}.instancePath`, (0, codegen_1.strConcat)(names_1.default.instancePath, it.errorPath)));
-      gen.assign((0, codegen_1._)`${err}.schemaPath`, (0, codegen_1.str)`${it.errSchemaPath}/${keyword}`);
+      gen.const(err2, (0, codegen_1._)`${names_1.default.vErrors}[${i}]`);
+      gen.if((0, codegen_1._)`${err2}.instancePath === undefined`, () => gen.assign((0, codegen_1._)`${err2}.instancePath`, (0, codegen_1.strConcat)(names_1.default.instancePath, it.errorPath)));
+      gen.assign((0, codegen_1._)`${err2}.schemaPath`, (0, codegen_1.str)`${it.errSchemaPath}/${keyword}`);
       if (it.opts.verbose) {
-        gen.assign((0, codegen_1._)`${err}.schema`, schemaValue);
-        gen.assign((0, codegen_1._)`${err}.data`, data);
+        gen.assign((0, codegen_1._)`${err2}.schema`, schemaValue);
+        gen.assign((0, codegen_1._)`${err2}.data`, data);
       }
     });
   }
   exports.extendErrors = extendErrors;
   function addError(gen, errObj) {
-    const err = gen.const("err", errObj);
-    gen.if((0, codegen_1._)`${names_1.default.vErrors} === null`, () => gen.assign(names_1.default.vErrors, (0, codegen_1._)`[${err}]`), (0, codegen_1._)`${names_1.default.vErrors}.push(${err})`);
+    const err2 = gen.const("err", errObj);
+    gen.if((0, codegen_1._)`${names_1.default.vErrors} === null`, () => gen.assign(names_1.default.vErrors, (0, codegen_1._)`[${err2}]`), (0, codegen_1._)`${names_1.default.vErrors}.push(${err2})`);
     gen.code((0, codegen_1._)`${names_1.default.errors}++`);
   }
   function returnErrors(it, errs) {
@@ -19496,13 +19496,46 @@ var StdioServerTransport = class {
 };
 
 // assets/mcp/ostacky-controller/index.js
-import { readFileSync, writeFileSync, renameSync, mkdirSync } from "node:fs";
-import { dirname } from "node:path";
+import { readFileSync, writeFileSync, renameSync, mkdirSync, readdirSync, unlinkSync } from "node:fs";
+import { dirname, basename } from "node:path";
+var MAX_TASKS = 50;
+var MAX_SNAPSHOT_JSON_LENGTH = 100 * 1024;
+var MAX_STATE_FILE_SIZE = 1024 * 1024;
+function safeJsonStringify(obj, pretty = false) {
+  const seen = new WeakSet;
+  try {
+    return JSON.stringify(obj, (key, value) => {
+      if (typeof value === "object" && value !== null) {
+        if (seen.has(value))
+          return "[Circular]";
+        seen.add(value);
+      }
+      return value;
+    }, pretty ? 2 : undefined);
+  } catch (e) {
+    return `[Unstringifiable: ${e.message}]`;
+  }
+}
 function log(event, data) {
   const ts = new Date().toISOString();
-  const payload = data ? ` ${JSON.stringify(data)}` : "";
+  const payload = data ? ` ${safeJsonStringify(data)}` : "";
   console.error(`[${ts}] ${event}${payload}`);
 }
+function cleanupTmpFiles(statePath) {
+  if (!statePath)
+    return;
+  const dir = dirname(statePath);
+  const name = basename(statePath);
+  try {
+    for (const entry of readdirSync(dir)) {
+      if (entry.startsWith(name + ".tmp.")) {
+        try {
+          unlinkSync(dir + "/" + entry);
+        } catch {}
+      }
+    }
+  } catch {}
+}
 var STATES = Object.freeze({
   INTERPRETATION_PENDING: "INTERPRETATION_PENDING",
   CLARIFICATION_PENDING: "CLARIFICATION_PENDING",
@@ -19557,9 +19590,29 @@ class OstackyController {
     }
     try {
       const raw = readFileSync(this.#statePath, "utf8");
+      if (raw.length > MAX_STATE_FILE_SIZE)
+        throw new Error(`State file too large: ${raw.length} bytes`);
       this.#state = { ...DEFAULT_STATE, ...JSON.parse(raw) };
+      this.#loaded = true;
+      return;
+    } catch (err2) {
+      log("warn:load_primary_failed", { error: err2.message });
+    }
+    const backupPath = this.#statePath + ".backup";
+    try {
+      const raw = readFileSync(backupPath, "utf8");
+      if (raw.length > MAX_STATE_FILE_SIZE)
+        throw new Error(`Backup too large: ${raw.length} bytes`);
+      this.#state = { ...DEFAULT_STATE, ...JSON.parse(raw), error: "State restored from backup" };
+      log("warn:state_restored_from_backup");
+      this.#loaded = true;
+      return;
     } catch {
-      this.#state = { ...DEFAULT_STATE };
+      this.#state = {
+        ...DEFAULT_STATE,
+        error: `State file corrupt: ${err.message}. No backup available. State reset to default.`
+      };
+      log("warn:state_reset", { error: err.message });
     }
     this.#loaded = true;
   }
@@ -19568,14 +19621,48 @@ class OstackyController {
       return;
     const dir = dirname(this.#statePath);
     mkdirSync(dir, { recursive: true });
+    const serialized = safeJsonStringify(this.#state, true);
+    if (serialized.length > MAX_STATE_FILE_SIZE) {
+      log("warn:state_oversized", { size: serialized.length });
+      this.#state.snapshots = { codegraph: null, execution: null };
+      const trimmed = safeJsonStringify(this.#state, true);
+      if (trimmed.length > MAX_STATE_FILE_SIZE) {
+        log("error:state_too_large_even_after_trim");
+        return;
+      }
+      const tmp2 = this.#statePath + ".tmp." + process.pid;
+      writeFileSync(tmp2, trimmed, "utf8");
+      renameSync(tmp2, this.#statePath);
+      return;
+    }
     const tmp = this.#statePath + ".tmp." + process.pid;
-    writeFileSync(tmp, JSON.stringify(this.#state, null, 2), "utf8");
+    writeFileSync(tmp, serialized, "utf8");
     renameSync(tmp, this.#statePath);
+    try {
+      const backupPath = this.#statePath + ".backup";
+      writeFileSync(backupPath, serialized, "utf8");
+    } catch {}
+  }
+  #trimTasks() {
+    if (!this.#state.tasks)
+      return;
+    const entries = Object.entries(this.#state.tasks);
+    if (entries.length <= MAX_TASKS)
+      return;
+    entries.sort((a, b) => {
+      const da = a[1].completedAt || "";
+      const db = b[1].completedAt || "";
+      return db.localeCompare(da);
+    });
+    const trimmed = Object.fromEntries(entries.slice(0, MAX_TASKS));
+    this.#state.tasks = trimmed;
+    log("warn:tasks_trimmed", { before: entries.length, after: MAX_TASKS });
   }
   #transition(to, changes = {}) {
     this.#state.revision++;
     this.#state.state = to;
     Object.assign(this.#state, changes);
+    this.#trimTasks();
     this.#persist();
   }
   #isAllowedTransition(from, via, choiceOrMode) {
@@ -19692,7 +19779,7 @@ class OstackyController {
       return { error: `Cannot record discovery from state ${this.#state.state}` };
     if (!["0", "0+1", "1+"].includes(level))
       return { error: `Invalid level: ${level}` };
-    this.#transition("ROUTE_DECISION_PENDING", {
+    this.#transition(to, {
       routeDecisionId: routeDecisionId || "route-" + Date.now(),
       routeChoice: null,
       snapshots: { ...this.#state.snapshots, codegraph: snapshot || this.#state.snapshots.codegraph }
@@ -19877,6 +19964,7 @@ class OstackyController {
         this.#state.fileFingerprints = {};
       this.#state.fileFingerprints[filePath] = fileHash;
     }
+    this.#trimTasks();
     this.#persist();
     return {
       taskId,
@@ -19884,12 +19972,29 @@ class OstackyController {
       totalCompleted: Object.keys(this.#state.tasks).filter((k) => this.#state.tasks[k].status === "COMPLETED").length
     };
   }
+  flush() {
+    this.#persist();
+  }
 }
 var statePath = process.env.OSTACKY_STATE_PATH || ".opencode/ostacky-state.json";
 var controller = new OstackyController({ statePath });
+function safeHandler(fn) {
+  return async (params) => {
+    try {
+      const result = await fn(params);
+      return { content: [{ type: "text", text: safeJsonStringify(result) }] };
+    } catch (error2) {
+      log("tool:error", { name: fn.name || "anonymous", error: error2.message });
+      return {
+        content: [{ type: "text", text: safeJsonStringify({ error: error2.message }) }],
+        isError: true
+      };
+    }
+  };
+}
 var server = new McpServer({
   name: "ostacky-controller",
-  version: "0.5.9"
+  version: "0.5.10"
 });
 server.registerTool("start_request", {
   description: "Start or resume a new request in the state machine. Call this first.",
@@ -19897,29 +20002,26 @@ server.registerTool("start_request", {
     requestId: string2().optional().describe("Unique request ID"),
     changeId: string2().optional().describe("Optional change ID for OpenSpec tracking")
   })
-}, async ({ requestId, changeId }) => {
+}, safeHandler(async ({ requestId, changeId }) => {
   log("tool:start_request");
-  const result = await controller.startRequest({ requestId, changeId });
-  return { content: [{ type: "text", text: JSON.stringify(result) }] };
-});
+  return await controller.startRequest({ requestId, changeId });
+}));
 server.registerTool("request_clarification", {
   description: "Record that clarification was requested. Transitions to CLARIFICATION_PENDING.",
   inputSchema: object({
     question: string2().optional().describe("The clarification question")
   })
-}, async ({ question }) => {
+}, safeHandler(async ({ question }) => {
   log("tool:request_clarification");
-  const result = await controller.requestClarification({ question });
-  return { content: [{ type: "text", text: JSON.stringify(result) }] };
-});
+  return await controller.requestClarification({ question });
+}));
 server.registerTool("record_clarification", {
   description: "Record that clarification was answered. Transitions to DISCOVERY.",
   inputSchema: object({})
-}, async () => {
+}, safeHandler(async () => {
   log("tool:record_clarification");
-  const result = await controller.recordClarification();
-  return { content: [{ type: "text", text: JSON.stringify(result) }] };
-});
+  return await controller.recordClarification();
+}));
 server.registerTool("record_discovery", {
   description: "Record discovery complete with level classification. Transitions to ROUTE_DECISION_PENDING.",
   inputSchema: object({
@@ -19927,111 +20029,100 @@ server.registerTool("record_discovery", {
     routeDecisionId: string2().optional().describe("Unique route decision ID"),
     snapshot: any().optional().describe("Optional CodeGraph snapshot")
   })
-}, async ({ level, routeDecisionId, snapshot }) => {
+}, safeHandler(async ({ level, routeDecisionId, snapshot }) => {
   log("tool:record_discovery", { level });
-  const result = await controller.recordDiscovery({ level, routeDecisionId, snapshot });
-  return { content: [{ type: "text", text: JSON.stringify(result) }] };
-});
+  return await controller.recordDiscovery({ level, routeDecisionId, snapshot });
+}));
 server.registerTool("consume_route_decision", {
   description: "Consume the route decision (SPEC or DIRECT). Valid only in ROUTE_DECISION_PENDING.",
   inputSchema: object({
     decisionId: string2().describe("Route decision ID from record_discovery"),
     choice: _enum(["SPEC", "DIRECT"]).describe("Route choice")
   })
-}, async ({ decisionId, choice }) => {
+}, safeHandler(async ({ decisionId, choice }) => {
   log("tool:consume_route_decision", { choice });
-  const result = await controller.consumeRouteDecision({ decisionId, choice });
-  return { content: [{ type: "text", text: JSON.stringify(result) }] };
-});
+  return await controller.consumeRouteDecision({ decisionId, choice });
+}));
 server.registerTool("spec_complete", {
   description: "Mark specification phase as complete. Transitions to EXECUTION_ANALYSIS.",
   inputSchema: object({})
-}, async () => {
+}, safeHandler(async () => {
   log("tool:spec_complete");
-  const result = await controller.specComplete();
-  return { content: [{ type: "text", text: JSON.stringify(result) }] };
-});
+  return await controller.specComplete();
+}));
 server.registerTool("record_execution_analysis", {
   description: "Record execution analysis with snapshot. Transitions to EXECUTION_DECISION_PENDING.",
   inputSchema: object({
     executionDecisionId: string2().optional().describe("Unique execution decision ID"),
     snapshot: any().optional().describe("Execution analysis snapshot")
   })
-}, async ({ executionDecisionId, snapshot }) => {
+}, safeHandler(async ({ executionDecisionId, snapshot }) => {
   log("tool:record_execution_analysis");
-  const result = await controller.recordExecutionAnalysis({ executionDecisionId, snapshot });
-  return { content: [{ type: "text", text: JSON.stringify(result) }] };
-});
+  return await controller.recordExecutionAnalysis({ executionDecisionId, snapshot });
+}));
 server.registerTool("consume_execution_decision", {
   description: "Consume the execution mode decision (INLINE or SUBAGENT_DRIVEN).",
   inputSchema: object({
     decisionId: string2().describe("Execution decision ID from record_execution_analysis"),
     mode: _enum(["INLINE", "SUBAGENT_DRIVEN"]).describe("Execution mode")
   })
-}, async ({ decisionId, mode }) => {
+}, safeHandler(async ({ decisionId, mode }) => {
   log("tool:consume_execution_decision", { mode });
-  const result = await controller.consumeExecutionDecision({ decisionId, mode });
-  return { content: [{ type: "text", text: JSON.stringify(result) }] };
-});
+  return await controller.consumeExecutionDecision({ decisionId, mode });
+}));
 server.registerTool("implementation_complete", {
   description: "Mark implementation as complete. Transitions to SYNC.",
   inputSchema: object({})
-}, async () => {
+}, safeHandler(async () => {
   log("tool:implementation_complete");
-  const result = await controller.implementationComplete();
-  return { content: [{ type: "text", text: JSON.stringify(result) }] };
-});
+  return await controller.implementationComplete();
+}));
 server.registerTool("sync_complete", {
   description: "Mark sync as complete. Transitions to DONE.",
   inputSchema: object({})
-}, async () => {
+}, safeHandler(async () => {
   log("tool:sync_complete");
-  const result = await controller.syncComplete();
-  return { content: [{ type: "text", text: JSON.stringify(result) }] };
-});
+  return await controller.syncComplete();
+}));
 server.registerTool("block", {
   description: "Transition to BLOCKED state with an optional reason.",
   inputSchema: object({
     reason: string2().optional().describe("Reason for blocking")
   })
-}, async ({ reason }) => {
+}, safeHandler(async ({ reason }) => {
   log("tool:block");
-  const result = await controller.block({ reason });
-  return { content: [{ type: "text", text: JSON.stringify(result) }] };
-});
+  return await controller.block({ reason });
+}));
 server.registerTool("replan", {
   description: "Replan from BLOCKED state back to INTERPRETATION_PENDING.",
   inputSchema: object({
     reason: string2().optional().describe("Reason for replanning")
   })
-}, async ({ reason }) => {
+}, safeHandler(async ({ reason }) => {
   log("tool:replan");
-  const result = await controller.replan({ reason });
-  return { content: [{ type: "text", text: JSON.stringify(result) }] };
-});
+  return await controller.replan({ reason });
+}));
 server.registerTool("get_state", {
   description: "Get the current controller state (reads persistent store).",
   inputSchema: object({})
-}, async () => {
-  const result = await controller.getState();
-  return { content: [{ type: "text", text: JSON.stringify(result) }] };
-});
+}, safeHandler(async () => {
+  return await controller.getState();
+}));
 server.registerTool("get_tasks", {
   description: "Get current task states.",
   inputSchema: object({})
-}, async () => {
-  const result = await controller.getTasks();
-  return { content: [{ type: "text", text: JSON.stringify(result) }] };
-});
+}, safeHandler(async () => {
+  return await controller.getTasks();
+}));
 server.registerTool("validate_edit", {
   description: "Validate an edit against current file content. Returns EDITABLE, ALREADY_APPLIED, or CONFLICT. " + "Call BEFORE executing an edit tool. Only valid in EXECUTING_INLINE or EXECUTING_SUBAGENTS states. " + "IMPORTANT: content parameter is REQUIRED. Read the file first, then pass the full content.",
   inputSchema: object({
     oldString: string2().describe("The exact string to find in content (must be unique)."),
     newString: string2().describe("The replacement string."),
-    content: string2().optional().describe("The current file content. REQUIRED — read the file first with Read tool."),
+    content: string2().describe("REQUIRED — The current file content. Read the file first with Read tool, then pass the full content here."),
     taskId: string2().optional().describe("Optional task ID for tracking.")
   })
-}, async ({ oldString, newString, content, taskId }) => {
+}, safeHandler(async ({ oldString, newString, content, taskId }) => {
   log("tool:validate_edit", {
     taskId,
     oldLen: oldString?.length,
@@ -20040,20 +20131,12 @@ server.registerTool("validate_edit", {
   });
   if (typeof content !== "string" || typeof oldString !== "string" || typeof newString !== "string") {
     return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({
-            outcome: "CONFLICT",
-            reason: "Missing required fields: content, oldString, and newString are all required. Read the file first, then pass content to validate_edit."
-          })
-        }
-      ]
+      outcome: "CONFLICT",
+      reason: "Missing required fields: content, oldString, and newString are all required. Read the file first, then pass content to validate_edit."
     };
   }
-  const result = await controller.validateEdit({ oldString, newString, content, taskId });
-  return { content: [{ type: "text", text: JSON.stringify(result) }] };
-});
+  return await controller.validateEdit({ oldString, newString, content, taskId });
+}));
 server.registerTool("complete_task", {
   description: "Mark a task as completed and optionally record a file fingerprint. " + "Only valid in EXECUTING_INLINE or EXECUTING_SUBAGENTS states.",
   inputSchema: object({
@@ -20061,14 +20144,33 @@ server.registerTool("complete_task", {
     filePath: string2().optional().describe("Optional file path that was modified."),
     fileHash: string2().optional().describe("Optional SHA-256 hash of the file after modification.")
   })
-}, async ({ taskId, filePath, fileHash }) => {
+}, safeHandler(async ({ taskId, filePath, fileHash }) => {
   log("tool:complete_task", { taskId, filePath });
-  const result = await controller.completeTask({ taskId, filePath, fileHash });
-  return { content: [{ type: "text", text: JSON.stringify(result) }] };
-});
+  return await controller.completeTask({ taskId, filePath, fileHash });
+}));
+function setupGracefulShutdown(ctrl) {
+  const shutdown = (signal) => {
+    log("shutdown", { signal });
+    try {
+      if (ctrl)
+        ctrl.flush();
+    } catch {}
+    try {
+      cleanupTmpFiles(statePath);
+    } catch {}
+    process.exit(signal === "SIGINT" ? 130 : 0);
+  };
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("unhandledRejection", (reason) => {
+    log("unhandled_rejection", { reason: String(reason) });
+  });
+}
 async function main() {
   log("Starting ostacky-controller MCP...");
   log("State path:", { path: statePath });
+  cleanupTmpFiles(statePath);
+  setupGracefulShutdown(controller);
   const transport = new StdioServerTransport;
   await server.connect(transport);
   log("ostacky-controller connected and ready");