ostacky 0.5.10 → 0.6.0

package/assets/mcp/openspec/node_modules/zod/v4/package.json

@@ -0,0 +1,7 @@
+{ 
+  "type": "module",
+  "main": "./index.cjs",
+  "module": "./index.js",
+  "types": "./index.d.cts",
+  "sideEffects": false
+}

package/assets/mcp/openspec/node_modules/zod/v4-mini/index.cjs

@@ -0,0 +1,32 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.z = void 0;
+const z = __importStar(require("../v4/mini/external.cjs"));
+exports.z = z;
+__exportStar(require("../v4/mini/external.cjs"), exports);

package/assets/mcp/openspec/node_modules/zod/v4-mini/index.d.cts

@@ -0,0 +1,3 @@
+import * as z from "../v4/mini/external.cjs";
+export * from "../v4/mini/external.cjs";
+export { z };

package/assets/mcp/openspec/node_modules/zod/v4-mini/index.d.ts

@@ -0,0 +1,3 @@
+import * as z from "../v4/mini/external.js";
+export * from "../v4/mini/external.js";
+export { z };

package/assets/mcp/openspec/node_modules/zod/v4-mini/index.js

@@ -0,0 +1,3 @@
+import * as z from "../v4/mini/external.js";
+export * from "../v4/mini/external.js";
+export { z };

package/assets/mcp/openspec/node_modules/zod/v4-mini/package.json

@@ -0,0 +1,7 @@
+{ 
+  "type": "module",
+  "main": "./index.cjs",
+  "module": "./index.js",
+  "types": "./index.d.cts",
+  "sideEffects": false
+}

package/assets/mcp/openspec/package.json

@@ -0,0 +1,10 @@
+{
+    "name": "openspec-mcp",
+    "version": "0.6.0",
+    "private": true,
+    "type": "module",
+    "dependencies": {
+        "@modelcontextprotocol/server": "^2.0.0-beta.5",
+        "zod": "^4.0.0"
+    }
+}

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

@@ -7,8 +7,73 @@ import { readFileSync, writeFileSync, renameSync, mkdirSync, readdirSync, unlink
 import { dirname, basename } from 'node:path';
 
 const MAX_TASKS = 50;
-const MAX_SNAPSHOT_JSON_LENGTH = 100 * 1024; // 100KB per snapshot serialized
-const MAX_STATE_FILE_SIZE = 1024 * 1024; // 1MB hard cap for the entire state file
+const MAX_SNAPSHOT_JSON_LENGTH = 100 * 1024;
+const MAX_STATE_FILE_SIZE = 1024 * 1024;
+const WATCHDOG_TIMEOUT_MS = 30_000;
+const WATCHDOG_CHECK_INTERVAL_MS = 10_000;
+let lastToolActivity = Date.now();
+
+const TRANSITIONS = {
+    INTERPRETATION_PENDING: [
+        { via: 'request_clarification', to: 'CLARIFICATION_PENDING' },
+        { via: 'proceed_to_discovery', to: 'DISCOVERY' },
+        { via: 'record_discovery', to: 'ROUTE_DECISION_PENDING' },
+        { via: 'block', to: 'BLOCKED' },
+    ],
+    CLARIFICATION_PENDING: [
+        { via: 'record_clarification', to: 'DISCOVERY' },
+        { via: 'block', to: 'BLOCKED' },
+        { via: 'abandon', to: 'BLOCKED' },
+    ],
+    DISCOVERY: [
+        { via: 'record_discovery', to: 'LEVEL_RESOLVED' },
+        { via: 'block', to: 'BLOCKED' },
+        { via: 'abandon', to: 'BLOCKED' },
+    ],
+    LEVEL_RESOLVED: [
+        { via: 'proceed_to_route', to: 'ROUTE_DECISION_PENDING' },
+        { via: 'block', to: 'BLOCKED' },
+    ],
+    ROUTE_DECISION_PENDING: [
+        { via: 'consume_route_decision', to: 'SPECIFICATION', choice: 'SPEC' },
+        { via: 'consume_route_decision', to: 'EXECUTION_ANALYSIS', choice: 'DIRECT' },
+        { via: 'block', to: 'BLOCKED' },
+        { via: 'abandon', to: 'BLOCKED' },
+    ],
+    SPECIFICATION: [
+        { via: 'spec_complete', to: 'EXECUTION_ANALYSIS' },
+        { via: 'block', to: 'BLOCKED' },
+        { via: 'abandon', to: 'BLOCKED' },
+    ],
+    EXECUTION_ANALYSIS: [
+        { via: 'analysis_complete', to: 'EXECUTION_DECISION_PENDING' },
+        { via: 'block', to: 'BLOCKED' },
+        { via: 'abandon', to: 'BLOCKED' },
+    ],
+    EXECUTION_DECISION_PENDING: [
+        { via: 'consume_execution_decision', to: 'EXECUTING_INLINE', mode: 'INLINE' },
+        { via: 'consume_execution_decision', to: 'EXECUTING_SUBAGENTS', mode: 'SUBAGENT_DRIVEN' },
+        { via: 'block', to: 'BLOCKED' },
+        { via: 'abandon', to: 'BLOCKED' },
+    ],
+    EXECUTING_INLINE: [
+        { via: 'implementation_complete', to: 'SYNC' },
+        { via: 'block', to: 'BLOCKED' },
+    ],
+    EXECUTING_SUBAGENTS: [
+        { via: 'implementation_complete', to: 'SYNC' },
+        { via: 'block', to: 'BLOCKED' },
+    ],
+    BLOCKED: [
+        { via: 'replan', to: 'INTERPRETATION_PENDING' },
+        { via: 'abandon', to: 'DONE' },
+    ],
+    SYNC: [
+        { via: 'sync_complete', to: 'DONE' },
+        { via: 'block', to: 'BLOCKED' },
+    ],
+    DONE: [],
+};
 
 /**
  * Safe JSON.stringify that won't throw on circular references.
@@ -107,6 +172,19 @@ class OstackyController {
         }
     }
 
+    /**
+     * Validates that a parsed state object has the required fields and valid values.
+     * Returns null if valid, or an error message if invalid.
+     */
+    #validateState(parsed) {
+        if (typeof parsed !== 'object' || parsed === null) return 'State is not an object';
+        if (typeof parsed.state !== 'string') return 'Missing or invalid "state" field';
+        if (!STATES[parsed.state]) return `Unknown state: "${parsed.state}"`;
+        if (typeof parsed.revision !== 'number') return 'Missing or invalid "revision" field';
+        if (parsed.revision < 0) return `Invalid revision: ${parsed.revision}`;
+        return null; // valid
+    }
+
     #load() {
         if (this.#loaded) return;
         if (!this.#statePath) {
@@ -118,7 +196,10 @@ 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) };
+            const parsed = JSON.parse(raw);
+            const validationError = this.#validateState(parsed);
+            if (validationError) throw new Error(`State validation failed: ${validationError}`);
+            this.#state = { ...DEFAULT_STATE, ...parsed };
             this.#loaded = true;
             return;
         } catch (err) {
@@ -129,17 +210,20 @@ class OstackyController {
         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' };
+            const parsed = JSON.parse(raw);
+            const validationError = this.#validateState(parsed);
+            if (validationError) throw new Error(`Backup validation failed: ${validationError}`);
+            this.#state = { ...DEFAULT_STATE, ...parsed, error: 'State restored from backup' };
             log('warn:state_restored_from_backup');
             this.#loaded = true;
             return;
-        } catch {
+        } catch (backupErr) {
             // No backup either — set error state instead of silent reset
             this.#state = {
                 ...DEFAULT_STATE,
-                error: `State file corrupt: ${err.message}. No backup available. State reset to default.`,
+                error: `State file corrupt: ${backupErr.message}. No backup available. State reset to default.`,
             };
-            log('warn:state_reset', { error: err.message });
+            log('warn:state_reset', { error: backupErr.message });
         }
         this.#loaded = true;
     }
@@ -148,28 +232,24 @@ class OstackyController {
         if (!this.#statePath) return;
         const dir = dirname(this.#statePath);
         mkdirSync(dir, { recursive: true });
-        const serialized = safeJsonStringify(this.#state, true);
-        // Hard cap — if state exceeds 1MB, trim snapshots and retry
+        let 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) {
+            const trimmed = { ...this.#state, snapshots: { codegraph: null, execution: null } };
+            serialized = safeJsonStringify(trimmed, true);
+            if (serialized.length > MAX_STATE_FILE_SIZE) {
                 log('error:state_too_large_even_after_trim');
-                return; // Don't persist — better to keep old state than write garbage
+                return;
             }
-            const tmp = this.#statePath + '.tmp.' + process.pid;
-            writeFileSync(tmp, trimmed, 'utf8');
-            renameSync(tmp, this.#statePath);
-            return;
+            this.#state.snapshots = { codegraph: null, execution: null };
         }
         const tmp = this.#statePath + '.tmp.' + process.pid;
         writeFileSync(tmp, serialized, 'utf8');
         renameSync(tmp, this.#statePath);
-        // Best-effort backup
         try {
-            const backupPath = this.#statePath + '.backup';
-            writeFileSync(backupPath, serialized, 'utf8');
+            const backupTmp = this.#statePath + '.backup.tmp.' + process.pid;
+            writeFileSync(backupTmp, serialized, 'utf8');
+            renameSync(backupTmp, this.#statePath + '.backup');
         } catch {
             /* backup is best-effort */
         }
@@ -198,71 +278,11 @@ class OstackyController {
         this.#state.revision++;
         this.#state.state = to;
         Object.assign(this.#state, changes);
-        this.#trimTasks();
         this.#persist();
     }
 
     #isAllowedTransition(from, via, choiceOrMode) {
-        const table = {
-            INTERPRETATION_PENDING: [
-                { to: 'CLARIFICATION_PENDING', via: 'request_clarification' },
-                { to: 'DISCOVERY', via: 'proceed_to_discovery' },
-                { to: 'ROUTE_DECISION_PENDING', via: 'record_discovery' },
-                { to: 'BLOCKED', via: 'block' },
-            ],
-            CLARIFICATION_PENDING: [
-                { to: 'DISCOVERY', via: 'record_clarification' },
-                { to: 'BLOCKED', via: 'block' },
-                { to: 'BLOCKED', via: 'abandon' },
-            ],
-            DISCOVERY: [
-                { to: 'LEVEL_RESOLVED', via: 'record_discovery' },
-                { to: 'BLOCKED', via: 'block' },
-                { to: 'BLOCKED', via: 'abandon' },
-            ],
-            LEVEL_RESOLVED: [
-                { to: 'ROUTE_DECISION_PENDING', via: 'route_decision_pending' },
-                { to: 'BLOCKED', via: 'block' },
-            ],
-            ROUTE_DECISION_PENDING: [
-                { to: 'SPECIFICATION', via: 'consume_route_decision', choice: 'SPEC' },
-                { to: 'EXECUTION_ANALYSIS', via: 'consume_route_decision', choice: 'DIRECT' },
-                { to: 'BLOCKED', via: 'block' },
-            ],
-            SPECIFICATION: [
-                { to: 'EXECUTION_ANALYSIS', via: 'spec_complete' },
-                { to: 'BLOCKED', via: 'block' },
-                { to: 'BLOCKED', via: 'abandon' },
-            ],
-            EXECUTION_ANALYSIS: [
-                { to: 'EXECUTION_DECISION_PENDING', via: 'analysis_complete' },
-                { to: 'BLOCKED', via: 'block' },
-                { to: 'BLOCKED', via: 'abandon' },
-            ],
-            EXECUTION_DECISION_PENDING: [
-                { to: 'EXECUTING_INLINE', via: 'consume_execution_decision', mode: 'INLINE' },
-                { to: 'EXECUTING_SUBAGENTS', via: 'consume_execution_decision', mode: 'SUBAGENT_DRIVEN' },
-                { to: 'BLOCKED', via: 'block' },
-            ],
-            EXECUTING_INLINE: [
-                { to: 'SYNC', via: 'implementation_complete' },
-                { to: 'BLOCKED', via: 'block' },
-            ],
-            EXECUTING_SUBAGENTS: [
-                { to: 'SYNC', via: 'implementation_complete' },
-                { to: 'BLOCKED', via: 'block' },
-            ],
-            BLOCKED: [
-                { to: 'INTERPRETATION_PENDING', via: 'replan' },
-                { to: 'DONE', via: 'abandon' },
-            ],
-            SYNC: [
-                { to: 'DONE', via: 'sync_complete' },
-                { to: 'BLOCKED', via: 'block' },
-            ],
-            DONE: [],
-        };
-        const transitions = table[from] || [];
+        const transitions = TRANSITIONS[from] || [];
         for (const t of transitions) {
             if (t.via !== via) continue;
             if (t.choice !== undefined && t.choice !== choiceOrMode) continue;
@@ -274,11 +294,7 @@ class OstackyController {
 
     async startRequest({ requestId, changeId } = {}) {
         this.#load();
-        if (
-            this.#state.state !== 'INTERPRETATION_PENDING' &&
-            this.#state.state !== 'BLOCKED' &&
-            this.#state.state !== 'DONE'
-        ) {
+        if (this.#state.state === 'INTERPRETATION_PENDING' && !requestId) {
             return { state: this.#state.state, revision: this.#state.revision, requestId: this.#state.requestId };
         }
         this.#transition('INTERPRETATION_PENDING', {
@@ -316,7 +332,9 @@ class OstackyController {
         this.#load();
         const to = this.#isAllowedTransition(this.#state.state, 'record_discovery');
         if (!to) return { error: `Cannot record discovery from state ${this.#state.state}` };
-        if (!['0', '0+1', '1+'].includes(level)) return { error: `Invalid level: ${level}` };
+        if (snapshot && safeJsonStringify(snapshot).length > MAX_SNAPSHOT_JSON_LENGTH) {
+            return { error: `Snapshot exceeds maximum size of ${MAX_SNAPSHOT_JSON_LENGTH} bytes` };
+        }
         this.#transition(to, {
             routeDecisionId: routeDecisionId || 'route-' + Date.now(),
             routeChoice: null,
@@ -332,17 +350,28 @@ class OstackyController {
         };
     }
 
+    async proceedToRoute() {
+        this.#load();
+        const to = this.#isAllowedTransition(this.#state.state, 'proceed_to_route');
+        if (!to) return { error: `Cannot proceed to route from state ${this.#state.state}` };
+        this.#transition(to);
+        return { state: this.#state.state, revision: this.#state.revision };
+    }
+
+    async abandon({ reason } = {}) {
+        this.#load();
+        const to = this.#isAllowedTransition(this.#state.state, 'abandon');
+        if (!to) return { error: `Cannot abandon from state ${this.#state.state}` };
+        this.#transition(to, { error: reason || 'Abandoned' });
+        return { state: this.#state.state, revision: this.#state.revision };
+    }
+
     async consumeRouteDecision({ decisionId, choice } = {}) {
         this.#load();
         if (this.#state.state !== 'ROUTE_DECISION_PENDING') {
-            if (this.#state.routeDecisionId === decisionId && this.#state.routeChoice) {
-                return { error: `Route decision ${decisionId} already consumed as ${this.#state.routeChoice}` };
-            }
             return { error: `Cannot consume route decision from state ${this.#state.state}` };
         }
         if (this.#state.routeDecisionId !== decisionId) return { error: `Decision ID mismatch` };
-        if (choice !== 'SPEC' && choice !== 'DIRECT') return { error: `Invalid choice: ${choice}` };
-        if (this.#state.routeChoice) return { error: `Decision already consumed as ${this.#state.routeChoice}` };
         const to = this.#isAllowedTransition(this.#state.state, 'consume_route_decision', choice);
         if (!to) return { error: `Route ${choice} not allowed from ${this.#state.state}` };
         this.#transition(to, { routeChoice: choice });
@@ -361,7 +390,10 @@ class OstackyController {
         this.#load();
         const to = this.#isAllowedTransition(this.#state.state, 'analysis_complete');
         if (!to) return { error: `Cannot record execution analysis from state ${this.#state.state}` };
-        this.#transition('EXECUTION_DECISION_PENDING', {
+        if (snapshot && safeJsonStringify(snapshot).length > MAX_SNAPSHOT_JSON_LENGTH) {
+            return { error: `Snapshot exceeds maximum size of ${MAX_SNAPSHOT_JSON_LENGTH} bytes` };
+        }
+        this.#transition(to, {
             executionDecisionId: executionDecisionId || 'exec-' + Date.now(),
             executionMode: null,
             snapshots: { ...this.#state.snapshots, execution: snapshot || null },
@@ -376,14 +408,9 @@ class OstackyController {
     async consumeExecutionDecision({ decisionId, mode } = {}) {
         this.#load();
         if (this.#state.state !== 'EXECUTION_DECISION_PENDING') {
-            if (this.#state.executionDecisionId === decisionId && this.#state.executionMode) {
-                return { error: `Execution decision ${decisionId} already consumed as ${this.#state.executionMode}` };
-            }
             return { error: `Cannot consume execution decision from state ${this.#state.state}` };
         }
         if (this.#state.executionDecisionId !== decisionId) return { error: `Decision ID mismatch` };
-        if (mode !== 'INLINE' && mode !== 'SUBAGENT_DRIVEN') return { error: `Invalid mode: ${mode}` };
-        if (this.#state.executionMode) return { error: `Decision already consumed as ${this.#state.executionMode}` };
         const to = this.#isAllowedTransition(this.#state.state, 'consume_execution_decision', mode);
         if (!to) return { error: `Mode ${mode} not allowed from ${this.#state.state}` };
         this.#transition(to, { executionMode: mode });
@@ -433,7 +460,7 @@ class OstackyController {
 
     async getState() {
         this.#load();
-        return { ...this.#state };
+        return structuredClone(this.#state);
     }
 
     async getTasks() {
@@ -441,6 +468,14 @@ class OstackyController {
         return { ...this.#state.tasks };
     }
 
+    async getAvailableTransitions() {
+        this.#load();
+        return {
+            currentState: this.#state.state,
+            transitions: TRANSITIONS[this.#state.state] || [],
+        };
+    }
+
     /**
      * Validates an edit against the current file content.
      * Returns one of: EDITABLE, ALREADY_APPLIED, CONFLICT.
@@ -541,11 +576,16 @@ const controller = new OstackyController({ statePath });
  */
 function safeHandler(fn) {
     return async (params) => {
+        lastToolActivity = Date.now();
         try {
             const result = await fn(params);
             return { content: [{ type: 'text', text: safeJsonStringify(result) }] };
         } catch (error) {
-            log('tool:error', { name: fn.name || 'anonymous', error: error.message });
+            log('tool:error', {
+                name: fn.name || 'anonymous',
+                error: error.message,
+                stack: error.stack,
+            });
             return {
                 content: [{ type: 'text', text: safeJsonStringify({ error: error.message }) }],
                 isError: true,
@@ -556,13 +596,13 @@ function safeHandler(fn) {
 
 const server = new McpServer({
     name: 'ostacky-controller',
-    version: '0.5.10',
+    version: '0.6.0',
 });
 
 server.registerTool(
     'start_request',
     {
-        description: 'Start or resume a new request in the state machine. Call this first.',
+        description: 'Start or reset a new request. Can be called from ANY state — resets state machine. Call this first.',
         inputSchema: z.object({
             requestId: z.string().optional().describe('Unique request ID'),
             changeId: z.string().optional().describe('Optional change ID for OpenSpec tracking'),
@@ -603,7 +643,7 @@ server.registerTool(
 server.registerTool(
     'record_discovery',
     {
-        description: 'Record discovery complete with level classification. Transitions to ROUTE_DECISION_PENDING.',
+        description: 'Record discovery complete with level classification. From INTERPRETATION_PENDING goes to ROUTE_DECISION_PENDING. From DISCOVERY goes to LEVEL_RESOLVED.',
         inputSchema: z.object({
             level: z.enum(['0', '0+1', '1+']).describe('Impact level'),
             routeDecisionId: z.string().optional().describe('Unique route decision ID'),
@@ -725,6 +765,50 @@ server.registerTool(
     })
 );
 
+server.registerTool(
+    'proceed_to_route',
+    {
+        description: 'Proceed from LEVEL_RESOLVED to ROUTE_DECISION_PENDING after discovery is confirmed.',
+        inputSchema: z.object({}),
+    },
+    safeHandler(async () => {
+        log('tool:proceed_to_route');
+        return await controller.proceedToRoute();
+    })
+);
+
+server.registerTool(
+    'abandon',
+    {
+        description: 'Abandon the current request. Transitions to BLOCKED from most states, or to DONE from BLOCKED.',
+        inputSchema: z.object({
+            reason: z.string().optional().describe('Reason for abandoning'),
+        }),
+    },
+    safeHandler(async ({ reason }) => {
+        log('tool:abandon');
+        return await controller.abandon({ reason });
+    })
+);
+
+server.registerTool(
+    'ping',
+    {
+        description: 'Health check — returns pong if controller is alive. Use this to verify controller availability before making other calls.',
+        inputSchema: z.object({}),
+    },
+    safeHandler(async () => {
+        return {
+            pong: true,
+            state: await controller.getState().then(s => ({
+                state: s.state,
+                revision: s.revision,
+                requestId: s.requestId,
+            })),
+        };
+    })
+);
+
 server.registerTool(
     'get_state',
     {
@@ -747,6 +831,47 @@ server.registerTool(
     })
 );
 
+server.registerTool(
+    'get_available_transitions',
+    {
+        description: 'Get valid transitions from current state. Useful for debugging state machine issues.',
+        inputSchema: z.object({}),
+    },
+    safeHandler(async () => {
+        return await controller.getAvailableTransitions();
+    })
+);
+
+server.registerTool(
+    'check_pending_state',
+    {
+        description:
+            'Check if agent is in a pending state waiting for user input. ' +
+            'MUST be called before ANY tool call when controller is available. ' +
+            'Returns ALLOW or BLOCKED with reason. ' +
+            'EXCEPTION: controller tools (consume_route_decision, consume_execution_decision, ' +
+            'record_clarification, abandon) are ALWAYS allowed — they unlock the state.',
+        inputSchema: z.object({}),
+    },
+    safeHandler(async () => {
+        const state = await controller.getState();
+        const pendingStates = [
+            'CLARIFICATION_PENDING',
+            'ROUTE_DECISION_PENDING',
+            'EXECUTION_DECISION_PENDING',
+        ];
+        if (pendingStates.includes(state.state)) {
+            return {
+                status: 'BLOCKED',
+                state: state.state,
+                revision: state.revision,
+                reason: `Cannot execute tools while in ${state.state}. Wait for user response first.`,
+            };
+        }
+        return { status: 'ALLOW', state: state.state, revision: state.revision };
+    })
+);
+
 server.registerTool(
     'validate_edit',
     {
@@ -822,18 +947,35 @@ function setupGracefulShutdown(ctrl) {
     };
     process.on('SIGTERM', () => shutdown('SIGTERM'));
     process.on('SIGINT', () => shutdown('SIGINT'));
+    process.on('SIGHUP', () => shutdown('SIGHUP'));
+    process.on('SIGPIPE', () => shutdown('SIGPIPE'));
     // Prevent unhandled rejections from silently killing the server
     process.on('unhandledRejection', (reason) => {
         log('unhandled_rejection', { reason: String(reason) });
     });
 }
 
+/**
+ * Watchdog that forces process restart if controller stops responding.
+ * This prevents the agent from hanging when the MCP server is stuck.
+ */
+function setupWatchdog() {
+    setInterval(() => {
+        const idleMs = Date.now() - lastToolActivity;
+        if (idleMs > WATCHDOG_TIMEOUT_MS) {
+            log('watchdog:timeout', { idleMs, threshold: WATCHDOG_TIMEOUT_MS });
+            process.exit(1);
+        }
+    }, WATCHDOG_CHECK_INTERVAL_MS);
+}
+
 async function main() {
     log('Starting ostacky-controller MCP...');
     log('State path:', { path: statePath });
     // Clean up stale tmp files from previous runs
     cleanupTmpFiles(statePath);
     setupGracefulShutdown(controller);
+    setupWatchdog();
     const transport = new StdioServerTransport();
     await server.connect(transport);
     log('ostacky-controller connected and ready');

package/assets/mcp/ostacky-controller/node_modules/.package-lock.json

@@ -1,13 +1,13 @@
 {
     "name": "ostacky-controller",
-    "version": "0.5.6",
+    "version": "0.6.0",
     "lockfileVersion": 3,
     "requires": true,
     "packages": {
         "node_modules/@modelcontextprotocol/core": {
-            "version": "2.0.0-beta.4",
-            "resolved": "https://registry.npmjs.org/@modelcontextprotocol/core/-/core-2.0.0-beta.4.tgz",
-            "integrity": "sha512-nsMXd4wQBKzmph6r+WOhum+mXjDYljTAqwY/XUg3hLtvNOQ8+JVqBSJOVCMJvx9lXhTpTOPrGZ3BuNiaNPjSvg==",
+            "version": "2.0.0-beta.5",
+            "resolved": "https://registry.npmjs.org/@modelcontextprotocol/core/-/core-2.0.0-beta.5.tgz",
+            "integrity": "sha512-HKbY9XTbsDy1Y6r2I55TGE3JEapM0vg96e1MUmBIF9LGjos5gjhcIrTz1yvBPLg2aFKHjwhUAQfRdrCEnPxNew==",
             "license": "MIT",
             "dependencies": {
                 "zod": "^4.2.0"
@@ -17,12 +17,12 @@
             }
         },
         "node_modules/@modelcontextprotocol/server": {
-            "version": "2.0.0-beta.4",
-            "resolved": "https://registry.npmjs.org/@modelcontextprotocol/server/-/server-2.0.0-beta.4.tgz",
-            "integrity": "sha512-pjMZcNEt1dOq0aJCcY3b7w1Ayh+qmQN2xlfTELcGV9yiAjEGIczBPBLWWW0k0zzo5T8kiv15jtKPsWeHGxLvLg==",
+            "version": "2.0.0-beta.5",
+            "resolved": "https://registry.npmjs.org/@modelcontextprotocol/server/-/server-2.0.0-beta.5.tgz",
+            "integrity": "sha512-i1E5l75rQKsgY/AKAIspgMBH1vEL7dqiK7tHr0L+raYcb0SWOziqNGJXGIG6NY4AlXDWIKGJQGB7Nqfs3oUi5g==",
             "license": "MIT",
             "dependencies": {
-                "@modelcontextprotocol/core": "2.0.0-beta.4",
+                "@modelcontextprotocol/core": "2.0.0-beta.5",
                 "zod": "^4.2.0"
             },
             "engines": {