@vibecodetown/mcp-server 1.3.1 → 1.4.0

package/build/mcp/chunking/artifacts.js

@@ -1,41 +1,140 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { ensureDirSync, getPmRunDir } from "../paths.js";
-import { emitEvent } from "../events/emitter.js";
-export function writeChunkArtifacts(params) {
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { ensureDirSync, getPmRunDir } from '../../kernel/paths.js';
+import { emitEvent } from '../events/emitter.js';
+import { chunksToBlockInputs } from './chunking.js';
+import { computeBlockId } from '../../kernel/blocks/hasher.js';
+import { resolveChainManager } from '../../kernel/resolve_deps.js';
+/**
+ * Write chunk artifacts with optional Block Store dual-write.
+ *
+ * By default, writes to both legacy chunks AND Block Store for backward compatibility.
+ * Set options to control write behavior:
+ * - writeToBlockStore: false - Skip Block Store (legacy-only mode)
+ * - writeLegacyChunks: false - Skip legacy chunks (Block Store-only mode)
+ *
+ * @example
+ * ```typescript
+ * // Default: dual-write (both legacy and Block Store)
+ * writeChunkArtifacts({ workspaceRoot, runId, chunks, manifest });
+ *
+ * // Legacy-only mode
+ * writeChunkArtifacts({ workspaceRoot, runId, chunks, manifest }, { writeToBlockStore: false });
+ *
+ * // Block Store-only mode (no legacy files)
+ * writeChunkArtifacts({ workspaceRoot, runId, chunks, manifest }, { writeLegacyChunks: false });
+ * ```
+ */
+export function writeChunkArtifacts(params, options = {}, deps) {
+    const { writeToBlockStore = true, writeLegacyChunks = true } = options;
     const runDir = getPmRunDir(params.workspaceRoot, params.runId);
-    const chunkDir = path.join(runDir, "chunks");
+    const chunkDir = path.join(runDir, 'chunks');
+    // Legacy chunk write
+    if (writeLegacyChunks) {
+        writeLegacyChunkFiles(params, chunkDir);
+    }
+    // Block Store write
+    let chainResult;
+    if (writeToBlockStore && params.chunks.length > 0) {
+        chainResult = writeToBlockStoreChain(params, deps);
+    }
+    return { chunkDir, chainResult };
+}
+/**
+ * Write legacy chunk files (backward compatibility).
+ */
+function writeLegacyChunkFiles(params, chunkDir) {
     ensureDirSync(chunkDir);
     for (const chunk of params.chunks) {
         const filePath = path.join(chunkDir, `${chunk.chunk_id}.json`);
         fs.writeFileSync(filePath, JSON.stringify(chunk, null, 2));
     }
-    const manifestPath = path.join(chunkDir, "chunk_manifest.v1.json");
+    const manifestPath = path.join(chunkDir, 'chunk_manifest.v1.json');
     fs.writeFileSync(manifestPath, JSON.stringify(params.manifest, null, 2));
-    const summaryPath = path.join(chunkDir, "chunk_summary.md");
+    const summaryPath = path.join(chunkDir, 'chunk_summary.md');
     const summaryLines = [
-        "# Chunk Summary",
-        "",
-        ...params.chunks.map((c) => `- ${c.chunk_id} (${c.profile}) ${c.source.path}:${c.source.line_start}-${c.source.line_end} (${c.token_estimate} tokens)`),
+        '# Chunk Summary',
+        '',
+        ...params.chunks.map(c => `- ${c.chunk_id} (${c.profile}) ${c.source.path}:${c.source.line_start}-${c.source.line_end} (${c.token_estimate} tokens)`),
     ];
-    fs.writeFileSync(summaryPath, summaryLines.join("\n"));
+    fs.writeFileSync(summaryPath, summaryLines.join('\n'));
     emitEvent({
         runId: params.manifest.run_id,
-        type: "artifact.chunk_manifest_written",
-        reason: "chunk_manifest_written",
+        type: 'artifact.chunk_manifest_written',
+        reason: 'chunk_manifest_written',
         paths: [manifestPath],
-        component: "chunking",
-        actor: "engine",
+        component: 'chunking',
+        actor: 'engine',
         workspaceRoot: params.workspaceRoot,
     });
     emitEvent({
         runId: params.manifest.run_id,
-        type: "artifact.chunk_summary_written",
-        reason: "chunk_summary_written",
+        type: 'artifact.chunk_summary_written',
+        reason: 'chunk_summary_written',
         paths: [summaryPath],
-        component: "chunking",
-        actor: "engine",
+        component: 'chunking',
+        actor: 'engine',
+        workspaceRoot: params.workspaceRoot,
+    });
+}
+/**
+ * Write chunks to Block Store as a chain.
+ */
+function writeToBlockStoreChain(params, deps) {
+    const { blockStore: store, chainManager } = resolveChainManager(params.workspaceRoot, deps);
+    // Use source path from first chunk if not provided
+    const sourcePath = params.sourcePath ?? params.chunks[0]?.source.path ?? `run/${params.runId}`;
+    // Check for existing chain from same source path
+    const oldRootHash = store.getRootHashBySourcePath(sourcePath);
+    // Convert chunks to block inputs
+    const blockInputs = chunksToBlockInputs(params.chunks);
+    // Skip if content unchanged (compare first+last block IDs)
+    if (oldRootHash && blockInputs.length > 0) {
+        const oldChain = store.getChain(oldRootHash);
+        if (oldChain && oldChain.blocks.length === blockInputs.length) {
+            const newFirstId = computeBlockId({
+                content: blockInputs[0].content,
+                sourceRef: blockInputs[0].sourceRef,
+            });
+            const newLastId = computeBlockId({
+                content: blockInputs[blockInputs.length - 1].content,
+                sourceRef: blockInputs[blockInputs.length - 1].sourceRef,
+            });
+            if (oldChain.blocks[0]?.block_id === newFirstId &&
+                oldChain.blocks[oldChain.blocks.length - 1]?.block_id === newLastId) {
+                return {
+                    chain: oldChain,
+                    blocks: [],
+                    storedCount: 0,
+                    skippedCount: blockInputs.length,
+                };
+            }
+        }
+    }
+    // Create chain
+    const result = chainManager.createChain({
+        sourcePath,
+        blocks: blockInputs,
+    });
+    // Clean up old chain if root_hash changed (source file content changed)
+    if (oldRootHash && oldRootHash !== result.chain.root_hash) {
+        store.deleteChain(oldRootHash);
+    }
+    // Emit Block Store events
+    emitEvent({
+        runId: params.runId,
+        type: 'artifact.chain_created',
+        reason: 'block_chain_created',
+        paths: [],
+        component: 'blocks',
+        actor: 'engine',
         workspaceRoot: params.workspaceRoot,
+        metadata: {
+            root_hash: result.chain.root_hash,
+            block_count: result.blocks.length,
+            stored_count: result.storedCount,
+            skipped_count: result.skippedCount,
+        },
     });
-    return { chunkDir };
+    return result;
 }

package/build/mcp/chunking/chunking.d.ts

@@ -1,4 +1,5 @@
-import { ChunkData, ChunkInput, ChunkManifest, ChunkPolicy } from "./types.js";
+import { ChunkData, ChunkInput, ChunkManifest, ChunkProfile, ChunkPolicy } from './types.js';
+import { SemanticBlock, BlockType, BlockInput } from '../../kernel/blocks/types.js';
 export declare function buildChunks(input: ChunkInput, overridePolicy?: ChunkPolicy): {
     chunks: ChunkData[];
     manifest: ChunkManifest;
@@ -8,3 +9,38 @@ export declare function buildAndWriteChunks(input: ChunkInput, overridePolicy?:
     manifest: ChunkManifest;
     chunkDir: string;
 };
+/**
+ * Map ChunkProfile to BlockType.
+ *
+ * Profile mappings:
+ * - extraction → extraction (logs, data extraction)
+ * - reasoning → reasoning (code analysis, thought process)
+ * - reference → reference (documentation, specs)
+ */
+export declare function chunkProfileToBlockType(profile: ChunkProfile): BlockType;
+/**
+ * Convert a ChunkData to a SemanticBlock.
+ *
+ * This adapter enables migration from run-scoped chunks to repo-wide Block Store.
+ *
+ * @param chunk - Legacy chunk data
+ * @param rootHash - Root hash for the block chain
+ * @param parentHash - Parent block's hash (null for first block)
+ * @returns SemanticBlock ready for Block Store
+ *
+ * @example
+ * ```typescript
+ * const block = chunkToSemanticBlock(chunk, rootHash, parentHash);
+ * store.put(block);
+ * ```
+ */
+export declare function chunkToSemanticBlock(chunk: ChunkData, rootHash: string, parentHash: string | null): SemanticBlock;
+/**
+ * Convert multiple chunks to BlockInputs for ChainManager.
+ *
+ * Useful for creating a new chain from existing chunks.
+ *
+ * @param chunks - Array of legacy chunks
+ * @returns Array of BlockInput ready for ChainManager.createChain()
+ */
+export declare function chunksToBlockInputs(chunks: ChunkData[]): BlockInput[];

package/build/mcp/chunking/chunking.js

@@ -1,7 +1,9 @@
-import * as crypto from "node:crypto";
-import * as path from "node:path";
-import { loadChunkPolicy } from "./policy.js";
-import { writeChunkArtifacts } from "./artifacts.js";
+import * as crypto from 'node:crypto';
+import * as path from 'node:path';
+import { loadChunkPolicy } from './policy.js';
+import { writeChunkArtifacts } from './artifacts.js';
+import { BLOCK_SCHEMA_VERSION, } from '../../kernel/blocks/types.js';
+import { computeBlockId } from '../../kernel/blocks/hasher.js';
 function estimateTokens(text) {
     const trimmed = text.trim();
     if (!trimmed)
@@ -9,7 +11,7 @@ function estimateTokens(text) {
     return trimmed.split(/\s+/).length;
 }
 function hashText(text) {
-    return crypto.createHash("sha256").update(text).digest("hex");
+    return crypto.createHash('sha256').update(text).digest('hex');
 }
 function getFileExt(filePath) {
     if (!filePath)
@@ -21,22 +23,22 @@ function selectProfile(input, policy) {
         return input.profile;
     const ext = getFileExt(input.filePath);
     if (ext && policy.routing?.extensions?.extraction?.includes(ext))
-        return "extraction";
+        return 'extraction';
     if (ext && policy.routing?.extensions?.reasoning?.includes(ext))
-        return "reasoning";
+        return 'reasoning';
     if (input.filePath) {
-        const normalized = input.filePath.replace(/\\/g, "/");
+        const normalized = input.filePath.replace(/\\/g, '/');
         const referencePaths = policy.routing?.extensions?.reference ?? [];
-        if (referencePaths.some((p) => normalized.includes(p)))
-            return "reference";
+        if (referencePaths.some(p => normalized.includes(p)))
+            return 'reference';
     }
-    return "reasoning";
+    return 'reasoning';
 }
 function findBoundaryLines(lines, profile, ext) {
     const boundaries = [0];
-    const rust = /\.(rs)$/i.test(ext ?? "");
-    const ts = /\.(ts|tsx|js|jsx)$/i.test(ext ?? "");
-    const md = /\.(md|markdown)$/i.test(ext ?? "");
+    const rust = /\.(rs)$/i.test(ext ?? '');
+    const ts = /\.(ts|tsx|js|jsx)$/i.test(ext ?? '');
+    const md = /\.(md|markdown)$/i.test(ext ?? '');
     const headerRe = /^#{1,6}\s+/;
     const tsFunc = /^\s*(export\s+)?(async\s+)?function\s+\w+/;
     const tsClass = /^\s*(export\s+)?class\s+\w+/;
@@ -48,12 +50,12 @@ function findBoundaryLines(lines, profile, ext) {
     const logStamp = /^\s*\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}/;
     for (let i = 0; i < lines.length; i += 1) {
         const line = lines[i];
-        if (profile === "extraction") {
+        if (profile === 'extraction') {
             if (logStamp.test(line) || headerRe.test(line))
                 boundaries.push(i);
             continue;
         }
-        if (profile === "reference") {
+        if (profile === 'reference') {
             if (headerRe.test(line))
                 boundaries.push(i);
             continue;
@@ -67,7 +69,8 @@ function findBoundaryLines(lines, profile, ext) {
             boundaries.push(i);
             continue;
         }
-        if (rust && (rsFn.test(line) || rsStruct.test(line) || rsImpl.test(line) || rsEnum.test(line))) {
+        if (rust &&
+            (rsFn.test(line) || rsStruct.test(line) || rsImpl.test(line) || rsEnum.test(line))) {
             boundaries.push(i);
             continue;
         }
@@ -118,13 +121,13 @@ function mergeSmall(chunks, lines, minTokens, maxTokens) {
     const merged = [];
     for (let i = 0; i < chunks.length; i += 1) {
         const cur = chunks[i];
-        const curTokens = estimateTokens(lines.slice(cur.start, cur.end).join("\n"));
+        const curTokens = estimateTokens(lines.slice(cur.start, cur.end).join('\n'));
         if (curTokens >= minTokens || merged.length === 0) {
             merged.push(cur);
             continue;
         }
         const prev = merged[merged.length - 1];
-        const combinedTokens = estimateTokens(lines.slice(prev.start, cur.end).join("\n"));
+        const combinedTokens = estimateTokens(lines.slice(prev.start, cur.end).join('\n'));
         if (combinedTokens <= maxTokens) {
             merged[merged.length - 1] = { start: prev.start, end: cur.end };
         }
@@ -144,7 +147,7 @@ export function buildChunks(input, overridePolicy) {
     const segments = splitSegments(lines, boundaries);
     let ranges = [];
     for (const seg of segments) {
-        const segText = lines.slice(seg.start, seg.end).join("\n");
+        const segText = lines.slice(seg.start, seg.end).join('\n');
         const segTokens = estimateTokens(segText);
         if (segTokens <= profileRule.max) {
             ranges.push(seg);
@@ -155,7 +158,7 @@ export function buildChunks(input, overridePolicy) {
     }
     ranges = mergeSmall(ranges, lines, profileRule.min, profileRule.max);
     const chunks = ranges.map((range, index) => {
-        const payload = lines.slice(range.start, range.end).join("\n");
+        const payload = lines.slice(range.start, range.end).join('\n');
         const tokenEstimate = estimateTokens(payload);
         const hash = hashText(payload);
         const chunkId = `chk_${hash.slice(0, 12)}_${index}`;
@@ -163,7 +166,7 @@ export function buildChunks(input, overridePolicy) {
             chunk_id: chunkId,
             profile,
             source: {
-                path: input.filePath ?? "<inline>",
+                path: input.filePath ?? '<inline>',
                 line_start: range.start + 1,
                 line_end: range.end,
             },
@@ -174,10 +177,14 @@ export function buildChunks(input, overridePolicy) {
         };
     });
     const manifest = {
-        schema_version: "chunk_manifest.v1",
+        schema_version: 'chunk_manifest.v1',
         run_id: input.runId,
         created_at: new Date().toISOString(),
-        chunks: chunks.map((c) => ({ chunk_id: c.chunk_id, profile: c.profile, token_estimate: c.token_estimate })),
+        chunks: chunks.map(c => ({
+            chunk_id: c.chunk_id,
+            profile: c.profile,
+            token_estimate: c.token_estimate,
+        })),
     };
     return { chunks, manifest };
 }
@@ -188,6 +195,83 @@ export function buildAndWriteChunks(input, overridePolicy) {
         runId: input.runId,
         chunks,
         manifest,
+        sourcePath: input.filePath,
     });
     return { chunks, manifest, chunkDir };
 }
+/**
+ * Map ChunkProfile to BlockType.
+ *
+ * Profile mappings:
+ * - extraction → extraction (logs, data extraction)
+ * - reasoning → reasoning (code analysis, thought process)
+ * - reference → reference (documentation, specs)
+ */
+export function chunkProfileToBlockType(profile) {
+    const mapping = {
+        extraction: 'extraction',
+        reasoning: 'reasoning',
+        reference: 'reference',
+    };
+    return mapping[profile];
+}
+/**
+ * Convert a ChunkData to a SemanticBlock.
+ *
+ * This adapter enables migration from run-scoped chunks to repo-wide Block Store.
+ *
+ * @param chunk - Legacy chunk data
+ * @param rootHash - Root hash for the block chain
+ * @param parentHash - Parent block's hash (null for first block)
+ * @returns SemanticBlock ready for Block Store
+ *
+ * @example
+ * ```typescript
+ * const block = chunkToSemanticBlock(chunk, rootHash, parentHash);
+ * store.put(block);
+ * ```
+ */
+export function chunkToSemanticBlock(chunk, rootHash, parentHash) {
+    // Build source_ref from chunk source
+    const sourceRef = `${chunk.source.path}:${chunk.source.line_start}-${chunk.source.line_end}`;
+    // Compute content-addressable block ID
+    const blockId = computeBlockId({
+        content: chunk.payload,
+        sourceRef,
+    });
+    return {
+        schema_version: BLOCK_SCHEMA_VERSION,
+        block_id: blockId,
+        parent_hash: parentHash,
+        root_hash: rootHash,
+        content: chunk.payload,
+        block_type: chunkProfileToBlockType(chunk.profile),
+        source_ref: sourceRef,
+        token_estimate: chunk.token_estimate,
+        created_at: Date.now(),
+        metadata: {
+            legacy_chunk_id: chunk.chunk_id,
+            legacy_hash: chunk.hash,
+        },
+    };
+}
+/**
+ * Convert multiple chunks to BlockInputs for ChainManager.
+ *
+ * Useful for creating a new chain from existing chunks.
+ *
+ * @param chunks - Array of legacy chunks
+ * @returns Array of BlockInput ready for ChainManager.createChain()
+ */
+export function chunksToBlockInputs(chunks) {
+    return chunks.map(chunk => ({
+        content: chunk.payload,
+        sourceRef: `${chunk.source.path}:${chunk.source.line_start}-${chunk.source.line_end}`,
+        blockType: chunkProfileToBlockType(chunk.profile),
+        tokenEstimate: chunk.token_estimate,
+        metadata: {
+            legacy_chunk_id: chunk.chunk_id,
+            legacy_hash: chunk.hash,
+        },
+    }));
+}

package/build/mcp/chunking/policy.d.ts

@@ -1,11 +1,11 @@
-import { ChunkPolicy, PackPolicy } from "./types.js";
+import { ChunkPolicy, PackPolicy } from './types.js';
 export declare function getChunkPolicyPath(workspaceRoot: string): string;
 export declare function getPackPolicyPath(workspaceRoot: string): string;
 export declare function loadChunkPolicy(workspaceRoot: string): {
     policy: ChunkPolicy;
     sha256: string;
     absPath: string;
-    source: "file" | "default";
+    source: 'file' | 'default';
     validation: {
         ok: true;
     } | {
@@ -17,7 +17,7 @@ export declare function loadPackPolicy(workspaceRoot: string): {
     policy: PackPolicy;
     sha256: string;
     absPath: string;
-    source: "file" | "default";
+    source: 'file' | 'default';
     validation: {
         ok: true;
     } | {

package/build/mcp/chunking/policy.js

@@ -1,23 +1,23 @@
-import * as path from "node:path";
-import { getVibeConfigDir } from "../paths.js";
-import { ChunkPolicySchema, PackPolicySchema } from "../policy/schema.js";
-import { loadJsonPolicy } from "../policy/loader.js";
+import * as path from 'node:path';
+import { getVibeConfigDir } from '../../kernel/paths.js';
+import { ChunkPolicySchema, PackPolicySchema } from '../policy/schema.js';
+import { loadJsonPolicy } from '../policy/loader.js';
 export function getChunkPolicyPath(workspaceRoot) {
     const override = process.env.CHUNK_POLICY_PATH?.trim();
     if (override) {
         return path.isAbsolute(override) ? override : path.join(workspaceRoot, override);
     }
-    return path.join(getVibeConfigDir(workspaceRoot), "chunk_policy.v1.json");
+    return path.join(getVibeConfigDir(workspaceRoot), 'chunk_policy.v1.json');
 }
 export function getPackPolicyPath(workspaceRoot) {
     const override = process.env.PACK_POLICY_PATH?.trim();
     if (override) {
         return path.isAbsolute(override) ? override : path.join(workspaceRoot, override);
     }
-    return path.join(getVibeConfigDir(workspaceRoot), "pack_policy.v1.json");
+    return path.join(getVibeConfigDir(workspaceRoot), 'pack_policy.v1.json');
 }
 const DEFAULT_CHUNK_POLICY = {
-    schema_version: "chunk_policy.v1",
+    schema_version: 'chunk_policy.v1',
     profiles: {
         extraction: { target: [450, 750], max: 900, min: 250, overlap: 0.07 },
         reasoning: { target: [800, 1200], max: 1500, min: 400, overlap: 0.12 },
@@ -25,14 +25,14 @@ const DEFAULT_CHUNK_POLICY = {
     },
     routing: {
         extensions: {
-            extraction: [".log", ".jsonl", ".trace"],
-            reasoning: [".rs", ".ts", ".tsx", ".js", ".py"],
-            reference: [".vibe/", "docs/specs/"],
+            extraction: ['.log', '.jsonl', '.trace'],
+            reasoning: ['.rs', '.ts', '.tsx', '.js', '.py'],
+            reference: ['.vibe/', 'docs/specs/'],
         },
     },
 };
 const DEFAULT_PACK_POLICY = {
-    schema_version: "pack_policy.v1",
+    schema_version: 'pack_policy.v1',
     main_input: { min: 1600, max: 2200, recommended: 1800 },
     conclusion_lines: 3,
     evidence_max: 5,

package/build/mcp/cli.js

@@ -1,4 +1,6 @@
 import { spawn, spawnSync } from "node:child_process";
+import { getPolicyContext } from "./policy/context.js";
+import { runInSandbox, DEFAULT_SANDBOX_CONFIG } from "./security/sandbox.js";
 /**
  * Environment variable whitelist for subprocess execution
  * Only these variables are passed through to child processes
@@ -64,6 +66,18 @@ export function sanitizeEnv(additionalEnv) {
 }
 export async function runCmd(cmd, args, opts) {
     const timeoutMs = opts?.timeoutMs ?? 120_000;
+    // P3: optional sandboxing (policy-driven, default "none").
+    const policy = getPolicyContext();
+    const sandbox = policy?.sandbox ?? DEFAULT_SANDBOX_CONFIG;
+    if (sandbox.mode !== "none") {
+        const result = await runInSandbox(cmd, args, sandbox, {
+            cwd: opts?.cwd,
+            env: sanitizeEnv(opts?.env),
+            stdin: opts?.stdin,
+            timeoutMs,
+        });
+        return result;
+    }
     return await new Promise((resolve) => {
         let resolved = false;
         const p = spawn(cmd, args, {
@@ -89,7 +103,9 @@ export async function runCmd(cmd, args, opts) {
             try {
                 p.kill("SIGKILL");
             }
-            catch { }
+            catch {
+                // ignore: process may already be dead or unkillable
+            }
             finish(124, stdout, stderr + "\n[TIMEOUT]");
         }, timeoutMs);
         // stdout/stderr can be null in Node typings; guard for strict TS builds.

package/build/mcp/cockpit-bridge/client.d.ts

@@ -2,6 +2,11 @@
  * Cockpitd HTTP Client
  * Connects to the Rust cockpitd daemon
  */
+/**
+ * Validate cockpit auth configuration.
+ * Throws in production (NODE_ENV=production) if COCKPITD_SHARED_SECRET is empty.
+ */
+export declare function validateCockpitConfig(): void;
 /**
  * Status response from cockpitd
  */
@@ -25,6 +30,11 @@ export interface CockpitCommandResponse {
     state: string;
     message: string;
     run_id: string | null;
+    status?: string | null;
+    reason?: string | null;
+    required_inputs?: string[] | null;
+    next_action?: string | null;
+    details?: Record<string, unknown> | null;
 }
 /**
  * Prompt response from cockpitd
@@ -66,10 +76,83 @@ export declare function isCockpitdAvailable(): Promise<boolean>;
  * Get cockpit status
  */
 export declare function cockpitStatus(): Promise<CockpitStatus>;
+/**
+ * Extended run options for cockpit.run
+ */
+export interface CockpitRunOptions {
+    run_id?: string;
+    target_paths?: string[];
+    spec_path?: string;
+    review_stage?: "full" | "spec_compliance" | "code_quality";
+    max_attempts?: number;
+    intent_scope?: {
+        include: string[];
+        exclude: string[];
+        do_not_touch: string[];
+        impact_area?: string;
+    };
+}
+/**
+ * Gate result response from cockpitd
+ */
+export interface CockpitGateResult {
+    has_result: boolean;
+    run_id: string | null;
+    signal: string | null;
+    violation_count: number;
+    violations: Array<{
+        violation_type: string;
+        message: string;
+        path: string | null;
+        evidence: string[];
+    }>;
+    path_zones: Array<{
+        path: string;
+        zone: string;
+    }>;
+    checked_at: string | null;
+    attempt_count: number;
+    max_attempts: number;
+}
 /**
  * Execute a cockpit command
  */
-export declare function cockpitCommand(cmd: string, runId?: string): Promise<CockpitCommandResponse>;
+export declare function cockpitCommand(cmd: string, runId?: string, idempotencyKey?: string): Promise<CockpitCommandResponse>;
+/**
+ * Execute a cockpit run with extended options (gate targets, review stage, etc.)
+ */
+export declare function cockpitRunWithOptions(options: CockpitRunOptions): Promise<CockpitCommandResponse>;
+/**
+ * Get the last gate check result
+ */
+export declare function cockpitGateResult(): Promise<CockpitGateResult>;
+/**
+ * SSE event from cockpitd /v1/events
+ */
+export interface CockpitSSEEvent {
+    event_type: string;
+    run_id: string | null;
+    state: string;
+    phase: string | null;
+    verdict: string | null;
+    attempt_count: number;
+    max_attempts: number;
+}
+/**
+ * Subscribe to cockpitd SSE event stream.
+ * Yields parsed events as they arrive. Caller should break to stop.
+ */
+export declare function cockpitEventStream(signal?: AbortSignal): AsyncGenerator<{
+    type: string;
+    data: CockpitSSEEvent;
+}>;
+/**
+ * Wait for cockpitd to reach a terminal state.
+ * Tries SSE first, falls back to polling on failure.
+ *
+ * @returns Final status, or null if timed out
+ */
+export declare function waitForCompletion(pollIntervalMs?: number, timeoutMs?: number): Promise<CockpitStatus | null>;
 /**
  * Get current prompt (if any)
  */
@@ -77,7 +160,7 @@ export declare function cockpitPrompt(): Promise<CockpitPrompt>;
 /**
  * Submit a decision
  */
-export declare function cockpitDecide(choice: "LOOP" | "DIAGNOSE"): Promise<CockpitDecideResponse>;
+export declare function cockpitDecide(choice: "LOOP" | "DIAGNOSE", idempotencyKey?: string): Promise<CockpitDecideResponse>;
 /**
  * Get manual content
  */