ostacky 0.5.8 → 0.5.10

package/assets/tests/agent-contract.test.js

@@ -0,0 +1,227 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const ASSETS_DIR = join(__dirname, '..');
+const AGENT_FILE = join(ASSETS_DIR, 'agents', 'ostacky.md');
+const CONTROLLER_FILE = join(ASSETS_DIR, 'mcp', 'ostacky-controller', 'index.js');
+
+const agentContent = readFileSync(AGENT_FILE, 'utf8');
+const controllerContent = readFileSync(CONTROLLER_FILE, 'utf8');
+
+// Tools registered in the MCP controller
+const MCP_TOOLS = [
+    'start_request', 'request_clarification', 'record_clarification',
+    'record_discovery', 'consume_route_decision', 'spec_complete',
+    'record_execution_analysis', 'consume_execution_decision',
+    'implementation_complete', 'sync_complete', 'block', 'replan',
+    'get_state', 'get_tasks', 'validate_edit', 'complete_task',
+];
+
+// CodeGraph tools referenced in agent instructions
+const CODEGRAPH_TOOLS = [
+    'codegraph_explore', 'codegraph_node', 'codegraph_search',
+    'codegraph_callers', 'codegraph_callees', 'codegraph_impact',
+    'codegraph_files', 'codegraph_status',
+];
+
+// Native OpenCode tools
+const NATIVE_TOOLS = ['question', 'Read', 'Edit', 'Bash', 'Grep', 'Glob'];
+
+const ALL_VALID_TOOLS = [...MCP_TOOLS, ...CODEGRAPH_TOOLS, ...NATIVE_TOOLS];
+
+describe('Agent contract — ostacky.md', () => {
+    describe('Core Instructions section', () => {
+        it('has "Core Instructions" heading', () => {
+            assert.ok(agentContent.includes('## Core Instructions'),
+                'Missing "## Core Instructions" section');
+        });
+
+        it('has SINGLE SOURCE OF VERDAD marker', () => {
+            assert.ok(agentContent.includes('SINGLE SOURCE OF VERDAD'),
+                'Missing "SINGLE SOURCE OF VERDAD" marker');
+        });
+    });
+
+    describe('CodeGraph section', () => {
+        it('has CodeGraph — búsqueda de código subsection', () => {
+            assert.ok(agentContent.includes('### CodeGraph — búsqueda de código'),
+                'Missing "### CodeGraph — búsqueda de código" section');
+        });
+
+        it('has tool table with codegraph_explore', () => {
+            assert.ok(agentContent.includes('codegraph_explore'),
+                'Missing codegraph_explore in tool table');
+        });
+    });
+
+    describe('Engram section', () => {
+        it('has Engram — memoria persistente subsection', () => {
+            assert.ok(agentContent.includes('### Engram — memoria persistente'),
+                'Missing "### Engram — memoria persistente" section');
+        });
+
+        it('has engram_mem_context in Discovery flow', () => {
+            assert.ok(agentContent.includes('engram_mem_context'),
+                'Missing engram_mem_context — agent should consult memory at start of request');
+        });
+
+        it('has engram_mem_search reference', () => {
+            assert.ok(agentContent.includes('engram_mem_search'),
+                'Missing engram_mem_search — agent should search before deciding');
+        });
+
+        it('has engram_mem_save reference', () => {
+            assert.ok(agentContent.includes('engram_mem_save'),
+                'Missing engram_mem_save — agent should save after significant work');
+        });
+    });
+
+    describe('HARD-STOP rules', () => {
+        it('has at least 2 HARD-STOP blocks (HTML tags or inline markers)', () => {
+            const htmlBlocks = (agentContent.match(/<HARD-STOP>/g) || []).length;
+            const inlineMarkers = (agentContent.match(/\*\*HARD-STOP\*\*/g) || []).length;
+            const total = htmlBlocks + inlineMarkers;
+            assert.ok(total >= 2,
+                `Expected at least 2 HARD-STOP blocks (HTML or inline), found ${total} (${htmlBlocks} HTML, ${inlineMarkers} inline)`);
+        });
+
+        it('has closing HARD-STOP tags matching opening tags', () => {
+            const opens = (agentContent.match(/<HARD-STOP>/g) || []).length;
+            const closes = (agentContent.match(/<\/HARD-STOP>/g) || []).length;
+            assert.equal(opens, closes,
+                `Mismatched HARD-STOP tags: ${opens} opens, ${closes} closes`);
+        });
+
+        it('has HARD-STOP in Regla de oro (global question stop)', () => {
+            const reglaDeOro = agentContent.substring(
+                agentContent.indexOf('## Regla de oro'),
+                agentContent.indexOf('## Flujo')
+            );
+            assert.ok(reglaDeOro.includes('<HARD-STOP>'),
+                'Missing HARD-STOP in Regla de Oro section — agent can continue after questions');
+        });
+    });
+
+    describe('Tool name references — no stale names', () => {
+        it('does NOT reference "ask_user" (non-existent tool)', () => {
+            const refs = agentContent.match(/ask_user/g);
+            const count = refs ? refs.length : 0;
+            assert.equal(count, 0,
+                `Found ${count} reference(s) to "ask_user" — this tool does not exist. Use "question" instead.`);
+        });
+
+        it('does NOT reference "codegraph_context" (stale name)', () => {
+            // Allow it in comments or descriptions, but not as an active tool call
+            const lines = agentContent.split('\n');
+            const offenders = lines.filter(line =>
+                line.includes('codegraph_context') &&
+                !line.startsWith('|') &&
+                !line.includes('NUNCA') &&
+                !line.includes('Prohibido')
+            );
+            assert.equal(offenders.length, 0,
+                `Found stale "codegraph_context" references (use codegraph_explore): ${offenders.join('; ')}`);
+        });
+
+        it('references valid MCP tools in flow instructions', () => {
+            // Extract tool names used in flow steps (lines with backtick-quoted tool names)
+            const toolRefs = agentContent.match(/`([a-z_]+)`/g) || [];
+            const uniqueTools = [...new Set(toolRefs.map(t => t.replace(/`/g, '')))];
+
+            const flowTools = uniqueTools.filter(t =>
+                t.includes('request') || t.includes('record') || t.includes('consume') ||
+                t.includes('spec_') || t.includes('implementation') || t.includes('sync') ||
+                t.includes('validate') || t.includes('complete') || t.includes('block') ||
+                t.includes('replan') || t.includes('start_') || t.includes('get_')
+            );
+
+            const invalidTools = flowTools.filter(t => !MCP_TOOLS.includes(t));
+            assert.equal(invalidTools.length, 0,
+                `References non-existent MCP tools: ${invalidTools.join(', ')}`);
+        });
+    });
+
+    describe('validate_edit instructions', () => {
+        it('mentions content as required parameter', () => {
+            assert.ok(
+                agentContent.includes('content') &&
+                (agentContent.includes('content es OBLIGATORIO') ||
+                 agentContent.includes('`content` es OBLIGATORIO')),
+                'Missing explicit instruction that content is required for validate_edit'
+            );
+        });
+
+        it('instructs to Read file before validate_edit', () => {
+            const executionSection = agentContent.substring(
+                agentContent.indexOf('### 4. Execution'),
+                agentContent.indexOf('### 5. Sync')
+            );
+            assert.ok(executionSection.includes('Read'),
+                'Execution section should instruct to Read file before validate_edit');
+        });
+    });
+
+    describe('Classification rules', () => {
+        it('has Nivel 0, 0+1, and 1+', () => {
+            assert.ok(agentContent.includes('Nivel 0'), 'Missing Nivel 0');
+            assert.ok(agentContent.includes('Nivel 0+1'), 'Missing Nivel 0+1');
+            assert.ok(agentContent.includes('Nivel 1+'), 'Missing Nivel 1+');
+        });
+
+        it('has defaultChoice mapping', () => {
+            assert.ok(agentContent.includes('defaultChoice'), 'Missing defaultChoice mapping');
+            assert.ok(agentContent.includes('"DIRECT"'), 'Missing DIRECT default');
+            assert.ok(agentContent.includes('"SPEC"'), 'Missing SPEC default');
+        });
+    });
+
+    describe('Guardrails', () => {
+        it('has Eficiencia de tokens section', () => {
+            assert.ok(agentContent.includes('### Eficiencia de tokens'),
+                'Missing "### Eficiencia de tokens" guardrail section');
+        });
+
+        it('has Decisiones y estado section', () => {
+            assert.ok(agentContent.includes('### Decisiones y estado'),
+                'Missing "### Decisiones y estado" guardrail section');
+        });
+    });
+});
+
+describe('Controller contract — index.js', () => {
+    it('exports OstackyController', () => {
+        assert.ok(controllerContent.includes('export { OstackyController }'),
+            'Missing OstackyController export');
+    });
+
+    it('has validate_edit tool registered', () => {
+        assert.ok(controllerContent.includes("server.registerTool(\n    'validate_edit'") ||
+                  controllerContent.includes("server.registerTool('validate_edit'"),
+            'validate_edit not registered as MCP tool');
+    });
+
+    it('validate_edit schema has content as required (z.string())', () => {
+        // Find the validate_edit schema section
+        const validateSection = controllerContent.substring(
+            controllerContent.indexOf("'validate_edit'"),
+            controllerContent.indexOf("'complete_task'")
+        );
+        assert.ok(validateSection.includes('content: z.string()') &&
+                  !validateSection.includes('content: z.string().optional()'),
+            'validate_edit content param should be z.string() required — prevents silent state corruption');
+    });
+
+    it('validate_edit handler validates content type', () => {
+        const validateSection = controllerContent.substring(
+            controllerContent.indexOf("'validate_edit'"),
+            controllerContent.indexOf("'complete_task'")
+        );
+        assert.ok(validateSection.includes("typeof content !== 'string'"),
+            'validate_edit handler should check typeof content');
+    });
+});

package/assets/tests/controller.test.js

@@ -0,0 +1,187 @@
+import { describe, it, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { OstackyController } from '../mcp/ostacky-controller/index.js';
+
+function createController(initialState = {}) {
+    return new OstackyController({
+        statePath: null,
+        initialState: {
+            state: 'INTERPRETATION_PENDING',
+            revision: 0,
+            requestId: 'test',
+            changeId: null,
+            routeDecisionId: null,
+            routeChoice: null,
+            executionDecisionId: null,
+            executionMode: null,
+            snapshots: { codegraph: null, execution: null },
+            tasks: {},
+            fileFingerprints: {},
+            error: null,
+            ...initialState,
+        },
+    });
+}
+
+describe('OstackyController', () => {
+    describe('startRequest', () => {
+        it('transitions to INTERPRETATION_PENDING', async () => {
+            const ctrl = createController({ state: 'DONE' });
+            const result = await ctrl.startRequest({ requestId: 'req-1' });
+            assert.equal(result.state, 'INTERPRETATION_PENDING');
+            assert.equal(result.requestId, 'req-1');
+        });
+
+        it('generates requestId when not provided', async () => {
+            const ctrl = createController({ state: 'DONE' });
+            const result = await ctrl.startRequest();
+            assert.ok(result.requestId.startsWith('req-'));
+        });
+    });
+
+    describe('validateEdit', () => {
+        it('returns CONFLICT when content is undefined (the bug we fixed)', async () => {
+            const ctrl = createController({ state: 'EXECUTING_INLINE' });
+            const result = await ctrl.validateEdit({
+                oldString: 'foo',
+                newString: 'bar',
+                content: undefined,
+            });
+            assert.equal(result.outcome, 'CONFLICT');
+            assert.ok(result.reason.includes('Missing required fields'));
+        });
+
+        it('returns CONFLICT when content is not a string', async () => {
+            const ctrl = createController({ state: 'EXECUTING_INLINE' });
+            const result = await ctrl.validateEdit({
+                oldString: 'foo',
+                newString: 'bar',
+                content: 123,
+            });
+            assert.equal(result.outcome, 'CONFLICT');
+            assert.ok(result.reason.includes('Missing required fields'));
+        });
+
+        it('returns EDITABLE when oldString found exactly once', async () => {
+            const ctrl = createController({ state: 'EXECUTING_INLINE' });
+            const result = await ctrl.validateEdit({
+                oldString: 'hello world',
+                newString: 'hello universe',
+                content: 'say hello world to everyone',
+            });
+            assert.equal(result.outcome, 'EDITABLE');
+        });
+
+        it('returns ALREADY_APPLIED when oldString equals newString', async () => {
+            const ctrl = createController({ state: 'EXECUTING_INLINE' });
+            const result = await ctrl.validateEdit({
+                oldString: 'hello',
+                newString: 'hello',
+                content: 'hello world',
+            });
+            assert.equal(result.outcome, 'ALREADY_APPLIED');
+        });
+
+        it('returns ALREADY_APPLIED when newString already present and oldString not found', async () => {
+            const ctrl = createController({ state: 'EXECUTING_INLINE' });
+            const result = await ctrl.validateEdit({
+                oldString: 'old text',
+                newString: 'new text',
+                content: 'already has new text here',
+            });
+            assert.equal(result.outcome, 'ALREADY_APPLIED');
+        });
+
+        it('returns CONFLICT when oldString not found and newString not present', async () => {
+            const ctrl = createController({ state: 'EXECUTING_INLINE' });
+            const result = await ctrl.validateEdit({
+                oldString: 'nonexistent',
+                newString: 'replacement',
+                content: 'some content without the old string',
+            });
+            assert.equal(result.outcome, 'CONFLICT');
+            assert.ok(result.reason.includes('not found'));
+        });
+
+        it('returns CONFLICT when oldString found multiple times', async () => {
+            const ctrl = createController({ state: 'EXECUTING_INLINE' });
+            const result = await ctrl.validateEdit({
+                oldString: 'dup',
+                newString: 'replaced',
+                content: 'dup and dup again',
+            });
+            assert.equal(result.outcome, 'CONFLICT');
+            assert.ok(result.reason.includes('2 times'));
+        });
+
+        it('returns CONFLICT when not in executing state', async () => {
+            const ctrl = createController();
+            const result = await ctrl.validateEdit({
+                oldString: 'foo',
+                newString: 'bar',
+                content: 'foo bar baz',
+            });
+            assert.equal(result.outcome, 'CONFLICT');
+            assert.ok(result.reason.includes('Cannot validate edit from state'));
+        });
+    });
+
+    describe('state transitions', () => {
+        it('full flow: start → discovery → route → execution → sync → done', async () => {
+            const ctrl = createController({ state: 'DONE' });
+            let r = await ctrl.startRequest({ requestId: 'test' });
+            assert.equal(r.state, 'INTERPRETATION_PENDING');
+
+            r = await ctrl.recordDiscovery({ level: '0', routeDecisionId: 'rd-1' });
+            assert.equal(r.state, 'ROUTE_DECISION_PENDING');
+            assert.equal(r.defaultChoice, 'DIRECT');
+
+            r = await ctrl.consumeRouteDecision({ decisionId: 'rd-1', choice: 'DIRECT' });
+            assert.equal(r.state, 'EXECUTION_ANALYSIS');
+
+            r = await ctrl.recordExecutionAnalysis({ executionDecisionId: 'ed-1' });
+            assert.equal(r.state, 'EXECUTION_DECISION_PENDING');
+
+            r = await ctrl.consumeExecutionDecision({ decisionId: 'ed-1', mode: 'INLINE' });
+            assert.equal(r.state, 'EXECUTING_INLINE');
+
+            r = await ctrl.implementationComplete();
+            assert.equal(r.state, 'SYNC');
+
+            r = await ctrl.syncComplete();
+            assert.equal(r.state, 'DONE');
+        });
+
+        it('rejects invalid transition: start from EXECUTING_INLINE', async () => {
+            const ctrl = createController({ state: 'EXECUTING_INLINE', requestId: 'original' });
+            const r = await ctrl.startRequest({ requestId: 'nope' });
+            assert.equal(r.state, 'EXECUTING_INLINE');
+            assert.equal(r.requestId, 'original');
+        });
+
+        it('level 1+ defaults to SPEC', async () => {
+            const ctrl = createController();
+            const r = await ctrl.recordDiscovery({ level: '1+', routeDecisionId: 'rd-2' });
+            assert.equal(r.defaultChoice, 'SPEC');
+        });
+    });
+
+    describe('completeTask', () => {
+        it('marks task as completed', async () => {
+            const ctrl = createController({ state: 'EXECUTING_INLINE' });
+            const r = await ctrl.completeTask({
+                taskId: 'task-1',
+                filePath: 'src/foo.ts',
+                fileHash: 'abc123',
+            });
+            assert.equal(r.status, 'COMPLETED');
+            assert.equal(r.totalCompleted, 1);
+        });
+
+        it('rejects completeTask from wrong state', async () => {
+            const ctrl = createController();
+            const r = await ctrl.completeTask({ taskId: 'task-1' });
+            assert.ok(r.error.includes('Cannot complete task from state'));
+        });
+    });
+});

package/assets/tests/validate-config.sh

@@ -236,6 +236,24 @@ else
 fi
 echo ""
 
+# ─── 14. Runtime tests (node:test) ──────────────────────────────────────────
+echo "14. Runtime tests"
+if command -v node &>/dev/null; then
+    TEST_OUTPUT=$(cd "$ASSETS_DIR" && node --test tests/controller.test.js tests/agent-contract.test.js 2>&1)
+    TEST_EXIT=$?
+    TEST_PASS=$(echo "$TEST_OUTPUT" | grep "^# pass" | awk '{print $3}')
+    TEST_FAIL=$(echo "$TEST_OUTPUT" | grep "^# fail" | awk '{print $3}')
+    if [ "$TEST_EXIT" -eq 0 ]; then
+        pass "runtime tests: ${TEST_PASS}/${TEST_PASS} passed"
+    else
+        fail "runtime tests: ${TEST_FAIL} failed out of $((TEST_PASS + TEST_FAIL))"
+        echo "$TEST_OUTPUT" | grep "not ok" | head -5
+    fi
+else
+    warn "node not found — skipping runtime tests"
+fi
+echo ""
+
 # ─── Summary ──────────────────────────────────────────────────────────────────
 echo "═══════════════════════════════════════════════════════════"
 echo "  Summary"

package/dist/cli.js

@@ -161,7 +161,7 @@ var require_picocolors = __commonJS((exports, module) => {
 // package.json
 var package_default = {
   name: "ostacky",
-  version: "0.5.8",
+  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.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: [
@@ -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.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"
     }
   ],
@@ -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.8",
-      sha256: "d78ceb0d761c40212a0fe39db8872f58c78de235e1b0833be4accb8adcc45462"
+      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.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"
     }
   ]
@@ -1204,7 +1204,7 @@ function clearLockfile(opencodeRoot) {
   const lockfile = readLockfile(opencodeRoot);
   if (!lockfile) {
     writeLockfile(opencodeRoot, {
-      version: "0.5.8",
+      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);