@hecer/yoke 1.14.0 → 1.15.1

package/dist/cli.js

@@ -22,6 +22,7 @@ import { runUpgrade } from './update/upgrade.js';
 import { AGENT_LIST, isSupportedAgent, SUPPORTED_AGENTS } from './agents/catalog.js';
 import { printAudit, runAudit } from './audit/command.js';
 import { runSetup } from './setup/command.js';
+import { runCodeIntelligenceServer } from './code-intelligence/mcp-server.js';
 import { pendingChanges, queueChange } from './change/inbox.js';
 import { answerPendingDecision, answeredDecisionResumeIsValid, clearDecisionResume, decisionProcessingExists, decisionResumeMatchesCurrent, finalizeCommittedDecisionResume, formatPendingDecision, readDecisionResume, readPendingDecision, writeDecisionResume, } from './loop/decision.js';
 export { runRetrofit } from './retrofit/command.js';
@@ -104,6 +105,8 @@ export function parseQualityFlags(args) {
 export function main(argv) {
     const [cmd, ...rest] = argv;
     switch (cmd) {
+        case 'code-intelligence-server':
+            return runCodeIntelligenceServer(rest).then(() => 0).catch(error => { console.error(`Code intelligence server: ${error.message}`); return 2; });
         case 'setup': {
             const targetDir = rest.find(a => !a.startsWith('-')) ?? '.';
             const valid = [...SUPPORTED_AGENTS];
@@ -130,6 +133,11 @@ export function main(argv) {
                 console.error(`Invalid --code-graph value: ${graphArg}`);
                 return 1;
             }
+            const intelligenceArg = rest.find(a => a.startsWith('--code-intelligence='))?.slice('--code-intelligence='.length);
+            if (intelligenceArg && !['off', 'shadow', 'active'].includes(intelligenceArg)) {
+                console.error(`Invalid --code-intelligence value: ${intelligenceArg}`);
+                return 1;
+            }
             const policyArg = rest.find(a => a.startsWith('--decision-policy='))?.slice('--decision-policy='.length);
             if (policyArg && policyArg !== 'auto' && policyArg !== 'critical') {
                 console.error(`Invalid --decision-policy value: ${policyArg}`);
@@ -152,6 +160,7 @@ export function main(argv) {
                 modelProviders: modelProviders,
                 host: hostArg, agents, runner: runnerArg,
                 codeGraph: graphArg,
+                codeIntelligence: intelligenceArg,
                 loop, routing, decisionPolicy: policyArg,
                 routingStrategy: routingStrategy,
                 routingPreset: rest.includes('--routing-preset'),
@@ -291,7 +300,12 @@ export function main(argv) {
                 console.error(`Invalid --code-graph value: ${cgArg} (expected graphify|serena)`);
                 return 1;
             }
-            return runRetrofit(targetDir, { loop, agents, codeGraph });
+            const ciArg = rest.find(a => a.startsWith('--code-intelligence='))?.slice('--code-intelligence='.length);
+            if (ciArg && !['off', 'shadow', 'active'].includes(ciArg)) {
+                console.error(`Invalid --code-intelligence value: ${ciArg} (expected off|shadow|active)`);
+                return 1;
+            }
+            return runRetrofit(targetDir, { loop, agents, codeGraph, codeIntelligence: ciArg });
         }
         case 'change': {
             const sub = rest[0];
@@ -657,7 +671,7 @@ export function main(argv) {
             return runUpgrade();
         default:
             console.log('Project workflows: yoke check [dir] [--json|--protect] | goal set|run|resume|pause|status|handoff|budget [dir] | projects add|list|remove | dashboard [dir] [--port=N]');
-            console.log(`usage: yoke <setup [dir] | new <dir> [--idea="..."] | validate [canonDir] | retrofit [targetDir] [--agent=${AGENT_LIST}|all] [--code-graph=graphify|serena] [--loop] | change <add|status> [dir] | prd <draft|check|assess> [dir] | loop <on|off|status|decision|answer|resume|run|cleanup> | context <init|status> | review [dir] [--reviewer=<${AGENT_LIST}>] [--base=<ref>] [--focus="..."] | design-scan [dir] [--max=N] [--report] | flow-smoke [dir] [--url=<baseUrl>] [--label=<name>] | upgrade>`);
+            console.log(`usage: yoke <setup [dir] | new <dir> [--idea="..."] | validate [canonDir] | retrofit [targetDir] [--agent=${AGENT_LIST}|all] [--code-graph=graphify|serena] [--code-intelligence=off|shadow|active] [--loop] | change <add|status> [dir] | code-intelligence-server --workspace=<dir> --mode=<mode> | prd <draft|check|assess> [dir] | loop <on|off|status|decision|answer|resume|run|cleanup> | context <init|status> | review [dir] | design-scan [dir] | flow-smoke [dir] | upgrade>`);
             return cmd ? 1 : 0;
     }
 }

package/dist/code-intelligence/adapters/graft.js

@@ -0,0 +1,11 @@
+import { McpBackendAdapter } from './mcp.js';
+export const GRAFT_VERSION = '0.17.0';
+export function createGraftAdapter(cwd, override) {
+    return new McpBackendAdapter({
+        name: 'graft', version: GRAFT_VERSION, cwd, command: override?.command ?? 'graft', args: override?.args ?? ['mcp'], framing: 'line', semantic: false, documents: false,
+        aliases: { context: 'graft_find_code', trace: 'graft_trace_calls', file: 'graft_file_api', freshness: 'graft_check_freshness', repo_map: 'graft_repo_map' },
+    });
+}
+export function graftCall(kind, args) {
+    return { tool: kind, arguments: args };
+}

package/dist/code-intelligence/adapters/graphify.js

@@ -0,0 +1,8 @@
+import { McpBackendAdapter } from './mcp.js';
+export const GRAPHIFY_VERSION = '0.9.56';
+export function createGraphifyAdapter(cwd, override) {
+    return new McpBackendAdapter({
+        name: 'graphify', version: GRAPHIFY_VERSION, cwd, command: override?.command ?? 'python', args: override?.args ?? ['-m', 'graphify.serve'], framing: 'content-length', semantic: false, documents: true,
+        aliases: { context: 'query_graph', symbol: 'get_node', neighbors: 'get_neighbors', trace: 'shortest_path', impact: 'get_pr_impact' },
+    });
+}

package/dist/code-intelligence/adapters/index.js

@@ -0,0 +1,5 @@
+export * from './types.js';
+export * from './mcp.js';
+export * from './graft.js';
+export * from './graphify.js';
+export * from './serena.js';

package/dist/code-intelligence/adapters/mcp.js

@@ -0,0 +1,37 @@
+import { McpStdioClient } from '../mcp-client.js';
+function valueFromResult(value) {
+    if (!value || typeof value !== 'object')
+        return value;
+    if (value.structuredContent !== undefined)
+        return value.structuredContent;
+    const text = Array.isArray(value.content) ? value.content.find((item) => item?.type === 'text')?.text : undefined;
+    if (typeof text !== 'string')
+        return value;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return { text };
+    }
+}
+export class McpBackendAdapter {
+    name;
+    version;
+    semantic;
+    documents;
+    client;
+    aliases;
+    constructor(options) {
+        this.name = options.name;
+        this.version = options.version;
+        this.semantic = options.semantic;
+        this.documents = options.documents;
+        this.aliases = options.aliases;
+        this.client = new McpStdioClient(options.command, options.args, options.cwd, options.framing);
+    }
+    async call(request, timeoutMs) {
+        const tool = this.aliases[request.tool] ?? request.tool;
+        return valueFromResult(await this.client.call(tool, request.arguments, timeoutMs));
+    }
+    close() { return this.client.close(); }
+}

package/dist/code-intelligence/adapters/serena.js

@@ -0,0 +1,11 @@
+import { McpBackendAdapter } from './mcp.js';
+export const SERENA_VERSION = '1.7.1-dev';
+export function createSerenaAdapter(cwd, override) {
+    return new McpBackendAdapter({
+        name: 'serena-lsp', version: SERENA_VERSION, cwd, command: override?.command ?? 'serena', args: override?.args ?? ['start-mcp-server', '--project-from-cwd', '--context', 'codex'], framing: 'content-length', semantic: true, documents: false,
+        aliases: {
+            symbol: 'find_symbol', references: 'find_referencing_symbols', implementations: 'find_implementations', overview: 'get_symbols_overview', diagnostics: 'get_diagnostics_for_file',
+            rename: 'rename_symbol', replace_symbol_body: 'replace_symbol_body', insert_before_symbol: 'insert_before_symbol', insert_after_symbol: 'insert_after_symbol', safe_delete: 'safe_delete_symbol',
+        },
+    });
+}

package/dist/code-intelligence/adapters/types.js

@@ -0,0 +1 @@
+export {};

package/dist/code-intelligence/contracts.js

@@ -0,0 +1,137 @@
+import { z } from 'zod';
+export const CodeIntelligenceModeSchema = z.enum(['off', 'shadow', 'active']);
+export const BackendNameSchema = z.enum(['graft', 'graphify', 'serena-lsp', 'serena-jetbrains', 'yoke']);
+export const StatusSchema = z.enum(['success', 'partial', 'blocked', 'error']);
+export const ResolutionSchema = z.enum(['resolved', 'unresolved', 'ambiguous', 'not_applicable']);
+export const FreshnessSchema = z.enum(['current', 'stale', 'unknown']);
+export const ProvenanceSchema = z.object({
+    backend: BackendNameSchema,
+    version: z.string().min(1),
+    source_path: z.string().nullable(),
+    content_hash: z.string().nullable(),
+    byte_range: z.object({ start: z.number().int().nonnegative(), end: z.number().int().nonnegative() }).nullable(),
+    origin: z.enum(['parser', 'resolver', 'lsp', 'ide', 'llm', 'manual']),
+    resolution: ResolutionSchema,
+    freshness: FreshnessSchema,
+});
+export const CoverageSchema = z.object({
+    backends_requested: z.array(BackendNameSchema),
+    backends_used: z.array(BackendNameSchema),
+    backends_missing: z.array(BackendNameSchema),
+    structural: z.enum(['complete', 'partial', 'unavailable']),
+    semantic: z.enum(['complete', 'partial', 'unavailable']),
+    documents: z.enum(['complete', 'partial', 'unavailable']),
+});
+export const MetricsSchema = z.object({
+    latency_ms: z.number().nonnegative(),
+    result_tokens: z.number().int().nonnegative(),
+    token_count_kind: z.enum(['exact', 'estimated']),
+    returned_bytes: z.number().int().nonnegative(),
+});
+export const ErrorSchema = z.object({
+    code: z.enum([
+        'INVALID_ARGUMENT', 'WORKSPACE_DENIED', 'CAPABILITY_UNAVAILABLE', 'SNAPSHOT_STALE',
+        'AMBIGUOUS_SYMBOL', 'BACKEND_TIMEOUT', 'BACKEND_UNAVAILABLE', 'BUDGET_EXCEEDED',
+        'APPROVAL_REQUIRED', 'PLAN_EXPIRED', 'SCOPE_VIOLATION', 'VALIDATION_FAILED',
+        'WRITE_CONFLICT', 'IDEMPOTENCY_CONFLICT', 'INTERNAL_ERROR',
+    ]),
+    message: z.string().min(1),
+    backend: BackendNameSchema.optional(),
+});
+export const ItemSchema = z.object({
+    item_id: z.string().min(1),
+    kind: z.enum(['symbol', 'code', 'document', 'memory', 'summary']),
+    path: z.string().nullable(),
+    excerpt: z.string().max(12000),
+    evidence_ids: z.array(z.string().min(1)),
+    rank: z.number().nonnegative(),
+});
+export const SymbolSchema = z.object({
+    symbol_id: z.string().min(1),
+    name: z.string().min(1),
+    path: z.string().nullable(),
+    kind: z.string().min(1),
+    signature: z.string().nullable(),
+    evidence_ids: z.array(z.string().min(1)),
+});
+export const ReferenceSchema = z.object({
+    symbol_id: z.string().min(1),
+    path: z.string().nullable(),
+    line: z.number().int().positive().nullable(),
+    excerpt: z.string().max(4000),
+    evidence_ids: z.array(z.string().min(1)),
+});
+export const DiagnosticSchema = z.object({
+    path: z.string().nullable(),
+    line: z.number().int().positive().nullable(),
+    severity: z.enum(['error', 'warning', 'info', 'unknown']),
+    message: z.string().max(4000),
+    evidence_ids: z.array(z.string().min(1)),
+});
+export const EdgeSchema = z.object({
+    from: z.string().min(1),
+    to: z.string().min(1),
+    relation: z.enum(['calls', 'references', 'imports', 'implements', 'extends', 'docs', 'rationale_for', 'related_to']),
+    evidence_ids: z.array(z.string().min(1)),
+});
+export const ResponseBaseSchema = z.object({
+    schema_version: z.literal('0.1.0'),
+    request_id: z.string().min(1),
+    workspace_id: z.string().min(1),
+    snapshot_id: z.string().min(1),
+    status: StatusSchema,
+    coverage: CoverageSchema,
+    provenance: z.array(ProvenanceSchema),
+    warnings: z.array(z.string()),
+    metrics: MetricsSchema,
+    artifact_uri: z.string().nullable(),
+    error: ErrorSchema.nullable(),
+});
+const BudgetSchema = z.object({
+    token_budget: z.number().int().min(128).max(16000).default(2400),
+    timeout_ms: z.number().int().min(100).max(60000).default(5000),
+});
+export const ContextInputSchema = z.object({
+    workspace_id: z.string().min(1), query: z.string().min(1).max(20000), snapshot_id: z.string().min(1).optional(),
+    mode: z.enum(['orient', 'locate', 'explain']).default('orient'), paths: z.array(z.string().min(1)).max(32).default([]),
+    include_docs: z.boolean().default(false), ...BudgetSchema.shape,
+});
+export const SymbolInputSchema = z.object({
+    workspace_id: z.string().min(1), snapshot_id: z.string().min(1), symbol_id: z.string().min(1).optional(),
+    query: z.string().min(1).optional(), path: z.string().min(1).optional(),
+    include: z.array(z.enum(['definition', 'references', 'implementations', 'diagnostics'])).default(['definition']), ...BudgetSchema.shape,
+}).refine(v => Boolean(v.symbol_id) !== Boolean(v.query), 'exactly one of symbol_id or query is required');
+export const TraceInputSchema = z.object({
+    workspace_id: z.string().min(1), snapshot_id: z.string().min(1), symbol_id: z.string().min(1),
+    direction: z.enum(['in', 'out']), relations: z.array(z.enum(['calls', 'references', 'imports', 'implements', 'extends'])).min(1),
+    max_depth: z.number().int().min(1).max(6).default(2), max_nodes: z.number().int().min(1).max(2000).default(200),
+    require_resolved: z.boolean().default(false), timeout_ms: z.number().int().min(100).max(60000).default(5000),
+});
+const TargetSchema = z.union([z.object({ path: z.string().min(1) }), z.object({ symbol_id: z.string().min(1) })]);
+export const ImpactInputSchema = z.object({
+    workspace_id: z.string().min(1), snapshot_id: z.string().min(1), targets: z.array(TargetSchema).max(50).optional(),
+    plan_id: z.string().min(1).optional(), include_docs: z.boolean().default(true), require_semantic: z.boolean().default(true),
+    max_depth: z.number().int().min(1).max(6).default(3), timeout_ms: z.number().int().min(100).max(60000).default(10000),
+}).refine(v => Boolean(v.targets) !== Boolean(v.plan_id), 'exactly one of targets or plan_id is required');
+const OperationSchema = z.discriminatedUnion('kind', [
+    z.object({ kind: z.literal('rename'), symbol_id: z.string().min(1), new_name: z.string().regex(/^[A-Za-z_$][\w$]*$/) }),
+    z.object({ kind: z.literal('replace_symbol_body'), symbol_id: z.string().min(1), content: z.string().max(500000) }),
+    z.object({ kind: z.literal('insert_before_symbol'), symbol_id: z.string().min(1), content: z.string().max(500000) }),
+    z.object({ kind: z.literal('insert_after_symbol'), symbol_id: z.string().min(1), content: z.string().max(500000) }),
+    z.object({ kind: z.literal('safe_delete'), symbol_id: z.string().min(1) }),
+]);
+export const EditPreviewInputSchema = z.object({
+    workspace_id: z.string().min(1), snapshot_id: z.string().min(1), operations: z.array(OperationSchema).min(1).max(20),
+    validation_profile: z.enum(['default', 'extended']), timeout_ms: z.number().int().min(100).max(600000).default(120000),
+});
+export const EditApplyInputSchema = z.object({
+    workspace_id: z.string().min(1), plan_id: z.string().min(1), expected_snapshot_id: z.string().min(1),
+    idempotency_key: z.string().min(8).max(128),
+});
+export const TOOL_NAMES = ['code_context', 'code_symbol', 'code_trace', 'code_impact', 'code_edit_preview', 'code_edit_apply'];
+export const TOOL_DEFINITIONS = TOOL_NAMES.map(name => ({
+    name,
+    description: `Yoke-controlled ${name.replace('code_', '').replace('_', ' ')} with snapshot-bound evidence.`,
+    inputSchema: { type: 'object', additionalProperties: false },
+    annotations: { openWorldHint: false, destructiveHint: name === 'code_edit_apply', readOnlyHint: name !== 'code_edit_preview' && name !== 'code_edit_apply', idempotentHint: name !== 'code_edit_apply' },
+}));

package/dist/code-intelligence/coordinator.js

@@ -0,0 +1,370 @@
+import { randomUUID } from 'node:crypto';
+import { copyFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { ContextInputSchema, EditApplyInputSchema, EditPreviewInputSchema, ImpactInputSchema, SymbolInputSchema, TraceInputSchema, } from './contracts.js';
+import { createGraftAdapter, createGraphifyAdapter, createSerenaAdapter } from './adapters/index.js';
+import { normalizeEdges, normalizeItems, normalizeSymbols } from './evidence.js';
+import { assertSnapshotCurrent, createSnapshot, loadSnapshot, workspaceId } from './snapshots.js';
+import { applyEditPlan } from './transactions.js';
+import { createEditPlan, loadEditPlan } from './edit-plans.js';
+function nowMs() { return Date.now(); }
+function compact(value, maxBytes) {
+    const encoded = JSON.stringify(value) ?? '';
+    if (Buffer.byteLength(encoded) <= maxBytes)
+        return value;
+    return { truncated: true, excerpt: encoded.slice(0, Math.max(0, maxBytes - 64)) };
+}
+function statusFor(missing, hard = false) { return hard ? 'error' : missing.length ? 'partial' : 'success'; }
+function errorCode(message) {
+    if (/outside|workspace|symbolic/u.test(message))
+        return 'WORKSPACE_DENIED';
+    if (/stale/u.test(message))
+        return 'SNAPSHOT_STALE';
+    if (/approval/u.test(message))
+        return 'APPROVAL_REQUIRED';
+    if (/expired/u.test(message))
+        return 'PLAN_EXPIRED';
+    if (/idempotency/u.test(message))
+        return 'IDEMPOTENCY_CONFLICT';
+    if (/transaction|lock|conflict/u.test(message))
+        return 'WRITE_CONFLICT';
+    if (/active|unavailable|MCP/u.test(message))
+        return 'CAPABILITY_UNAVAILABLE';
+    if (/scope|does not match/u.test(message))
+        return 'SCOPE_VIOLATION';
+    return 'INVALID_ARGUMENT';
+}
+function symbolArgs(symbol, fallbackPath = '') {
+    if (symbol.startsWith('serena:')) {
+        try {
+            const value = JSON.parse(decodeURIComponent(symbol.slice('serena:'.length)));
+            if (value.name_path)
+                return { name_path: value.name_path, relative_path: value.relative_path ?? fallbackPath };
+        }
+        catch { /* accept user-provided names below */ }
+    }
+    return { name_path: symbol, relative_path: fallbackPath };
+}
+export class CodeIntelligenceCoordinator {
+    root;
+    workspace_id;
+    options;
+    adapters;
+    constructor(root, options = {}) {
+        this.root = root;
+        this.workspace_id = workspaceId(root);
+        this.options = options;
+        this.adapters = {
+            graft: options.adapters?.graft ?? createGraftAdapter(root, options.graft),
+            graphify: options.adapters?.graphify ?? createGraphifyAdapter(root, options.graphify),
+            'serena-lsp': options.adapters?.['serena-lsp'] ?? createSerenaAdapter(root, options.serena),
+        };
+    }
+    async close() { await Promise.all(Object.values(this.adapters).map(adapter => adapter.close())); }
+    async dispatch(name, input) {
+        const requestId = randomUUID();
+        const started = nowMs();
+        const suppliedWorkspace = typeof input === 'object' && input !== null && typeof input.workspace_id === 'string' ? input.workspace_id : this.workspace_id;
+        let snapshot;
+        try {
+            snapshot = this.snapshotFor(input);
+        }
+        catch (error) {
+            return this.errorResponse(requestId, suppliedWorkspace, this.safeSnapshotId(), started, error);
+        }
+        try {
+            let result;
+            switch (name) {
+                case 'code_context':
+                    result = await this.context(ContextInputSchema.parse(input), snapshot);
+                    break;
+                case 'code_symbol':
+                    result = await this.symbol(SymbolInputSchema.parse(input), snapshot);
+                    break;
+                case 'code_trace':
+                    result = await this.trace(TraceInputSchema.parse(input), snapshot);
+                    break;
+                case 'code_impact':
+                    result = await this.impact(ImpactInputSchema.parse(input), snapshot);
+                    break;
+                case 'code_edit_preview':
+                    result = await this.preview(EditPreviewInputSchema.parse(input), snapshot);
+                    break;
+                case 'code_edit_apply':
+                    result = await this.apply(EditApplyInputSchema.parse(input), snapshot);
+                    break;
+                default: throw new Error(`unknown code-intelligence tool: ${name}`);
+            }
+            const bytes = Buffer.byteLength(JSON.stringify(result.data) ?? '');
+            const maxBytes = this.options.limits?.maxBytes ?? 2_000_000;
+            return {
+                schema_version: '0.1.0', request_id: requestId, workspace_id: this.workspace_id, snapshot_id: snapshot.snapshot_id,
+                status: statusFor(result.missing, result.hard), data: compact(result.data, maxBytes), coverage: this.coverage(result.used, result.missing), provenance: result.provenance,
+                warnings: result.warnings, metrics: { latency_ms: nowMs() - started, result_tokens: Math.ceil(bytes / 4), token_count_kind: 'estimated', returned_bytes: Math.min(bytes, maxBytes) }, artifact_uri: null, error: null,
+            };
+        }
+        catch (error) {
+            return this.errorResponse(requestId, this.workspace_id, snapshot.snapshot_id, started, error);
+        }
+    }
+    snapshotFor(input) {
+        const candidate = input && typeof input === 'object' ? input : {};
+        if (candidate.workspace_id && candidate.workspace_id !== this.workspace_id)
+            throw new Error('workspace is not permitted');
+        const snapshot = candidate.snapshot_id ? loadSnapshot(this.root, candidate.snapshot_id) : createSnapshot(this.root, this.options.policy, this.workspace_id);
+        if (candidate.snapshot_id)
+            assertSnapshotCurrent(this.root, snapshot, this.options.policy);
+        return snapshot;
+    }
+    safeSnapshotId() {
+        try {
+            return createSnapshot(this.root, this.options.policy, this.workspace_id).snapshot_id;
+        }
+        catch {
+            return '0'.repeat(64);
+        }
+    }
+    coverage(used, missing) {
+        return {
+            backends_requested: [...new Set([...used, ...missing])], backends_used: [...new Set(used)], backends_missing: [...new Set(missing)],
+            structural: used.includes('graft') ? 'complete' : 'unavailable',
+            semantic: used.includes('serena-lsp') ? 'complete' : 'unavailable',
+            documents: used.includes('graphify') ? 'complete' : 'unavailable',
+        };
+    }
+    async call(backend, tool, args, timeout, state) {
+        const seen = new Set([...state.used, ...state.missing]);
+        const maxBackends = this.options.limits?.maxBackends ?? 3;
+        if (!seen.has(backend) && seen.size >= maxBackends) {
+            state.missing.push(backend);
+            state.warnings.push(`${backend}: backend budget exceeded`);
+            return null;
+        }
+        try {
+            const value = await this.adapters[backend].call({ tool, arguments: args }, Math.min(timeout, this.options.limits?.timeoutMs ?? timeout));
+            if (!state.used.includes(backend))
+                state.used.push(backend);
+            return value;
+        }
+        catch (error) {
+            if (!state.missing.includes(backend))
+                state.missing.push(backend);
+            state.warnings.push(`${backend}: ${error.message}`);
+            return null;
+        }
+    }
+    evidenceOptions(snapshot, backend, maxChars = 12000) {
+        return { root: this.root, snapshot, adapter: this.adapters[backend], maxChars };
+    }
+    async context(input, snapshot) {
+        const state = { used: [], missing: [], warnings: [] };
+        const provenance = [];
+        let items = [];
+        const raw = await this.call('graft', 'context', { query: input.query, limit: Math.max(1, Math.floor(input.token_budget / 300)), ...(input.paths[0] ? { in: input.paths[0] } : {}) }, input.timeout_ms, state);
+        if (raw !== null) {
+            const normalized = normalizeItems(raw, this.evidenceOptions(snapshot, 'graft'), 'code', 100);
+            items.push(...normalized.items);
+            provenance.push(...normalized.provenance);
+        }
+        if (input.include_docs) {
+            const docs = await this.call('graphify', 'context', { question: input.query, depth: 3, token_budget: input.token_budget }, input.timeout_ms, state);
+            if (docs !== null) {
+                const normalized = normalizeItems(docs, this.evidenceOptions(snapshot, 'graphify'), 'document', 50);
+                items.push(...normalized.items);
+                provenance.push(...normalized.provenance);
+            }
+        }
+        return { data: { items, next_cursor: null }, provenance, ...state, warnings: state.warnings };
+    }
+    async symbol(input, snapshot) {
+        const state = { used: [], missing: [], warnings: [] };
+        const provenance = [];
+        let symbols = [];
+        let references = [];
+        let diagnostics = [];
+        const name = input.symbol_id ?? input.query;
+        const reference = symbolArgs(name, input.path ?? '');
+        const graft = await this.call('graft', 'context', { query: name, limit: 10, ...(input.path ? { in: input.path } : {}) }, input.timeout_ms, state);
+        if (graft !== null) {
+            const normalized = normalizeItems(graft, this.evidenceOptions(snapshot, 'graft'), 'symbol', 20);
+            symbols.push(...normalized.items.map(item => ({ symbol_id: `graft:${item.item_id}`, name: item.excerpt.split(/\s|\(|\{/u)[0] ?? name, path: item.path, kind: 'unknown', signature: item.excerpt.slice(0, 500), evidence_ids: item.evidence_ids })));
+            provenance.push(...normalized.provenance);
+        }
+        const symbol = await this.call('serena-lsp', 'symbol', { name_path_pattern: reference.name_path, depth: 0, relative_path: reference.relative_path, include_body: false, max_matches: 20 }, input.timeout_ms, state);
+        if (symbol !== null) {
+            const normalized = normalizeSymbols(symbol, this.evidenceOptions(snapshot, 'serena-lsp'));
+            symbols.push(...normalized.symbols);
+            provenance.push(...normalized.provenance);
+        }
+        if (input.include.includes('references')) {
+            const raw = await this.call('serena-lsp', 'references', reference, input.timeout_ms, state);
+            if (raw !== null) {
+                const normalized = normalizeItems(raw, this.evidenceOptions(snapshot, 'serena-lsp'), 'code', 100);
+                references = normalized.items.map(item => ({ symbol_id: input.symbol_id ?? `symbol-${item.item_id.slice(5)}`, path: item.path, line: null, excerpt: item.excerpt, evidence_ids: item.evidence_ids }));
+                provenance.push(...normalized.provenance);
+            }
+        }
+        if (input.include.includes('implementations')) {
+            const raw = await this.call('serena-lsp', 'implementations', reference, input.timeout_ms, state);
+            if (raw !== null) {
+                const normalized = normalizeSymbols(raw, this.evidenceOptions(snapshot, 'serena-lsp'));
+                symbols.push(...normalized.symbols);
+                provenance.push(...normalized.provenance);
+            }
+        }
+        if (input.include.includes('diagnostics')) {
+            const raw = await this.call('serena-lsp', 'diagnostics', { relative_path: reference.relative_path }, input.timeout_ms, state);
+            if (raw !== null) {
+                const normalized = normalizeItems(raw, this.evidenceOptions(snapshot, 'serena-lsp'), 'code', 100);
+                diagnostics = normalized.items.map(item => ({ path: item.path, line: null, severity: 'unknown', message: item.excerpt, evidence_ids: item.evidence_ids }));
+                provenance.push(...normalized.provenance);
+            }
+        }
+        return { data: { symbols, references, diagnostics }, provenance, ...state, warnings: state.warnings };
+    }
+    async trace(input, snapshot) {
+        const state = { used: [], missing: [], warnings: [] };
+        const provenance = [];
+        let nodes = [];
+        let edges = [];
+        const raw = await this.call('graft', 'trace', { symbol: input.symbol_id, direction: input.direction, depth: input.max_depth }, input.timeout_ms, state);
+        if (raw !== null) {
+            const normalized = normalizeEdges(raw, this.evidenceOptions(snapshot, 'graft'), input.relations[0] ?? 'references');
+            nodes.push(...normalized.nodes);
+            edges.push(...normalized.edges);
+            provenance.push(...normalized.provenance);
+        }
+        if (input.require_resolved || input.relations.some(relation => relation === 'implements' || relation === 'extends')) {
+            const rawSemantic = await this.call('serena-lsp', 'references', symbolArgs(input.symbol_id), input.timeout_ms, state);
+            if (rawSemantic !== null) {
+                const normalized = normalizeEdges(rawSemantic, this.evidenceOptions(snapshot, 'serena-lsp'), 'references');
+                nodes.push(...normalized.nodes);
+                edges.push(...normalized.edges);
+                provenance.push(...normalized.provenance);
+            }
+        }
+        nodes = [...new Map(nodes.map(node => [node.id, node])).values()].slice(0, input.max_nodes);
+        edges = edges.filter(edge => nodes.some(node => node.id === edge.from) && nodes.some(node => node.id === edge.to));
+        return { data: { nodes, edges, frontier_remaining: Math.max(0, edges.length - nodes.length) }, provenance, ...state, warnings: state.warnings };
+    }
+    async impact(input, snapshot) {
+        const state = { used: [], missing: [], warnings: [] };
+        const provenance = [];
+        const structural = [];
+        const semantic = [];
+        const documents = [];
+        const unresolved = [];
+        let targets = input.targets;
+        if (!targets && input.plan_id) {
+            const plan = loadEditPlan(this.root, input.plan_id);
+            if (plan.workspace_id !== this.workspace_id)
+                throw new Error('impact plan belongs to another workspace');
+            targets = plan.changed_paths.map(path => ({ path }));
+        }
+        targets ??= [];
+        for (const target of targets) {
+            const value = 'path' in target ? target.path : target.symbol_id;
+            const raw = await this.call('graft', 'context', { query: `impact of ${value}`, limit: 20, ...('path' in target ? { in: target.path } : {}) }, input.timeout_ms, state);
+            if (raw !== null) {
+                const normalized = normalizeItems(raw, this.evidenceOptions(snapshot, 'graft'), 'code', 50);
+                structural.push(...normalized.items);
+                provenance.push(...normalized.provenance);
+            }
+            else
+                unresolved.push(value);
+            if (input.require_semantic) {
+                const rawSemantic = 'symbol_id' in target
+                    ? await this.call('serena-lsp', 'references', symbolArgs(target.symbol_id), input.timeout_ms, state)
+                    : await this.call('serena-lsp', 'overview', { relative_path: target.path, depth: 2 }, input.timeout_ms, state);
+                if (rawSemantic !== null) {
+                    const normalized = normalizeItems(rawSemantic, this.evidenceOptions(snapshot, 'serena-lsp'), 'symbol', 50);
+                    semantic.push(...normalized.items);
+                    provenance.push(...normalized.provenance);
+                }
+                else
+                    unresolved.push('symbol_id' in target ? target.symbol_id : target.path);
+            }
+        }
+        if (input.include_docs) {
+            const docs = await this.call('graphify', 'context', { question: `architecture impact ${JSON.stringify(targets)}`, depth: input.max_depth, token_budget: 2000 }, input.timeout_ms, state);
+            if (docs !== null) {
+                const normalized = normalizeItems(docs, this.evidenceOptions(snapshot, 'graphify'), 'document', 50);
+                documents.push(...normalized.items);
+                provenance.push(...normalized.provenance);
+            }
+        }
+        const suggested = [...new Set(snapshot.files.map(file => file.path).filter(path => /(^|\/)(test|tests|__tests__|spec)(\/|\.)/u.test(path)))].slice(0, 20);
+        return { data: { semantic_findings: semantic, structural_candidates: structural, documents, suggested_test_paths: suggested, unresolved }, provenance, ...state, warnings: state.warnings };
+    }
+    async preview(input, snapshot) {
+        if (this.options.mode !== 'active')
+            throw new Error('code edits require code-intelligence mode=active');
+        const state = { used: [], missing: [], warnings: [] };
+        const provenance = [];
+        const sandbox = join(this.root, '.yoke', 'code-intelligence', 'worktrees', `preview-${randomUUID()}`);
+        mkdirSync(sandbox, { recursive: true });
+        for (const file of snapshot.files) {
+            const source = join(this.root, file.path);
+            const target = join(sandbox, file.path);
+            mkdirSync(dirname(target), { recursive: true });
+            copyFileSync(source, target);
+        }
+        const adapter = createSerenaAdapter(sandbox, this.options.serena);
+        const changed = new Set();
+        try {
+            for (const operation of input.operations) {
+                const reference = symbolArgs(operation.symbol_id);
+                const args = 'new_name' in operation ? { ...reference, new_name: operation.new_name } : operation.kind === 'safe_delete' ? { name_path_pattern: reference.name_path, relative_path: reference.relative_path } : { ...reference, body: 'content' in operation ? operation.content : '' };
+                const tool = operation.kind === 'safe_delete' ? 'safe_delete' : operation.kind;
+                try {
+                    await adapter.call({ tool, arguments: args }, input.timeout_ms);
+                    state.used.push('serena-lsp');
+                }
+                catch (error) {
+                    state.missing.push('serena-lsp');
+                    state.warnings.push(`serena-lsp: ${error.message}`);
+                    break;
+                }
+            }
+        }
+        finally {
+            await adapter.close();
+        }
+        const diffs = [];
+        for (const file of snapshot.files) {
+            const before = readFileSync(join(this.root, file.path));
+            const afterPath = join(sandbox, file.path);
+            if (!existsSync(afterPath)) {
+                changed.add(file.path);
+                diffs.push(`--- a/${file.path}\n+++ /dev/null\n`);
+                continue;
+            }
+            const after = readFileSync(afterPath);
+            if (!before.equals(after)) {
+                changed.add(file.path);
+                diffs.push(`--- a/${file.path}\n+++ b/${file.path}\n@@\n-${before.toString('utf8')}\n+${after.toString('utf8')}\n`);
+            }
+        }
+        const diff = diffs.join('\n').slice(0, this.options.limits?.maxBytes ?? 2_000_000);
+        const plan = createEditPlan(this.root, snapshot, sandbox, input.operations, state.missing.length ? 'incomplete' : 'passed', input.validation_profile, [...changed], diff);
+        return { data: plan, provenance, ...state, warnings: state.warnings };
+    }
+    async apply(input, snapshot) {
+        if (this.options.mode !== 'active')
+            throw new Error('code edits require code-intelligence mode=active');
+        const state = { used: [], missing: [], warnings: [] };
+        const plan = loadEditPlan(this.root, input.plan_id);
+        if (plan.workspace_id !== this.workspace_id || plan.snapshot_id !== input.expected_snapshot_id)
+            throw new Error('edit plan scope does not match workspace or expected snapshot');
+        const expected = loadSnapshot(this.root, input.expected_snapshot_id);
+        assertSnapshotCurrent(this.root, expected, this.options.policy);
+        const result = applyEditPlan(this.root, plan, expected, input.idempotency_key);
+        return { data: { plan_id: result.plan_id, transaction_id: result.transaction_id, changed_paths: result.changed_paths, new_snapshot_id: result.new_snapshot_id, validation: result.validation, committed: false, merged: false }, provenance: [], ...state, warnings: state.warnings };
+    }
+    errorResponse(requestId, workspace, snapshotId, started, error) {
+        const code = errorCode(error.message);
+        const blocked = ['WORKSPACE_DENIED', 'SNAPSHOT_STALE', 'APPROVAL_REQUIRED', 'PLAN_EXPIRED', 'CAPABILITY_UNAVAILABLE', 'SCOPE_VIOLATION', 'WRITE_CONFLICT'].includes(code);
+        return { schema_version: '0.1.0', request_id: requestId, workspace_id: workspace, snapshot_id: snapshotId, status: blocked ? 'blocked' : 'error', data: null, coverage: { backends_requested: [], backends_used: [], backends_missing: [], structural: 'unavailable', semantic: 'unavailable', documents: 'unavailable' }, provenance: [], warnings: [], metrics: { latency_ms: nowMs() - started, result_tokens: 0, token_count_kind: 'exact', returned_bytes: 0 }, artifact_uri: null, error: { code, message: error.message } };
+    }
+}
+export function createCodeIntelligenceCoordinator(root, options) { return new CodeIntelligenceCoordinator(root, options); }