ostacky 0.5.8 → 0.5.10

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",
@@ -19539,8 +19572,13 @@ class OstackyController {
   #loaded;
   constructor(opts = {}) {
     this.#statePath = opts.statePath;
-    this.#state = opts.initialState ? { ...DEFAULT_STATE, ...opts.initialState } : null;
-    this.#loaded = false;
+    if (opts.initialState) {
+      this.#state = { ...DEFAULT_STATE, ...opts.initialState };
+      this.#loaded = true;
+    } else {
+      this.#state = null;
+      this.#loaded = false;
+    }
   }
   #load() {
     if (this.#loaded)
@@ -19552,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;
   }
@@ -19563,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) {
@@ -19687,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 }
@@ -19872,6 +19964,7 @@ class OstackyController {
         this.#state.fileFingerprints = {};
       this.#state.fileFingerprints[filePath] = fileHash;
     }
+    this.#trimTasks();
     this.#persist();
     return {
       taskId,
@@ -19879,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.8"
+  version: "0.5.10"
 });
 server.registerTool("start_request", {
   description: "Start or resume a new request in the state machine. Call this first.",
@@ -19892,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({
@@ -19922,115 +20029,114 @@ 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.",
+  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().describe("The current file content (read fresh 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 }) => {
-  log("tool:validate_edit", { taskId, oldLen: oldString.length, newLen: newString.length });
-  const result = await controller.validateEdit({ oldString, newString, content, taskId });
-  return { content: [{ type: "text", text: JSON.stringify(result) }] };
-});
+}, safeHandler(async ({ oldString, newString, content, taskId }) => {
+  log("tool:validate_edit", {
+    taskId,
+    oldLen: oldString?.length,
+    newLen: newString?.length,
+    hasContent: !!content
+  });
+  if (typeof content !== "string" || typeof oldString !== "string" || typeof newString !== "string") {
+    return {
+      outcome: "CONFLICT",
+      reason: "Missing required fields: content, oldString, and newString are all required. Read the file first, then pass content to validate_edit."
+    };
+  }
+  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({
@@ -20038,19 +20144,44 @@ 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");
 }
-main().catch((error2) => {
-  console.error("Fatal error:", error2);
-  process.exit(1);
-});
+var isDirectRun = process.argv[1] && (process.argv[1].endsWith("/index.js") || process.argv[1].endsWith("\\index.js"));
+if (isDirectRun) {
+  main().catch((error2) => {
+    console.error("Fatal error:", error2);
+    process.exit(1);
+  });
+}
+export {
+  OstackyController
+};

package/manifest.json

@@ -1,14 +1,14 @@
 {
-    "version": "0.5.8",
+    "version": "0.5.10",
     "repo": "JaimeHoracio/Ostacky",
-    "tag": "v0.5.8",
+    "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.8",
-            "sha256": "eb3ab4cfcdedee63dd4aae05d748d34d9cfc3323bdc5f53f06848cfe3efd439f"
+            "version": "0.5.10",
+            "sha256": "c624b9163a97fe0aa17a4688f59e2bcfa958c64fbde71c05c0c071911f62b7ad"
         }
     ],
     "commands": [
@@ -16,14 +16,14 @@
             "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.8",
-            "sha256": "16538e1ec81887738716dc8f97a3de4f26fc8d218489a6cd20029a8981bdbd95"
+            "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.8",
+            "version": "0.5.10",
             "sha256": "ed9948f1910743b672e1dfad496bc96972a224a98b063232be39290d43068c50"
         }
     ],
@@ -32,8 +32,8 @@
             "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.8",
-            "sha256": "d78ceb0d761c40212a0fe39db8872f58c78de235e1b0833be4accb8adcc45462"
+            "version": "0.5.10",
+            "sha256": "4469b9e26910a5ba016a0fe7a2d77507d40715d95ce4cbb31c498bf7001b4d0d"
         }
     ],
     "skills": [
@@ -41,98 +41,98 @@
             "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.8",
+            "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.8",
+            "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.8",
+            "version": "0.5.10",
             "sha256": "13f6e43522567505da90793934d414d290d56f4ea587ac696f66416af9e7633f"
         },
         {
             "name": "tdd",
             "file": "assets/skills/tdd/SKILL.md",
             "description": "Skill de test-driven development (Superpowers)",
-            "version": "0.5.8",
+            "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.8",
+            "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.8",
+            "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.8",
+            "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.8",
+            "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.8",
+            "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.8",
+            "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.8",
+            "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.8",
+            "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.8",
+            "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.8",
+            "version": "0.5.10",
             "sha256": "7f74ffe049283803640d78f8c9ac1ea5f5e626dedb885ecff29a87c5b5d41598"
         }
     ]

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "ostacky",
-    "version": "0.5.8",
+    "version": "0.5.10",
     "description": "Instalador interactivo de agentes y comandos para OpenCode",
     "type": "module",
     "bin": {