@hecer/yoke 1.21.1 → 1.22.0

package/dist/code-intelligence/evidence.js

@@ -1,5 +1,10 @@
 import { createHash } from 'node:crypto';
 import { assertSafePath } from './snapshots.js';
+/** Truncate only between Unicode code points, including at normalizer limits. */
+export function shorten(value, maxChars) {
+    const clipped = value.slice(0, Math.max(0, maxChars));
+    return /[\uD800-\uDBFF]$/u.test(clipped) ? clipped.slice(0, -1) : clipped;
+}
 function hash(value) { return createHash('sha256').update(value).digest('hex'); }
 function textOf(raw) {
     if (typeof raw === 'string')
@@ -22,32 +27,46 @@ function locate(text, root) {
         return { path: null, line: null };
     }
 }
-export function makeProvenance(options, text, resolution = 'resolved') {
+export function makeProvenance(options, text, resolution = 'unresolved') {
     const location = locate(text, options.root);
-    const file = location.path ? options.snapshot.files.find(item => item.path === location.path) : undefined;
     return {
-        backend: options.adapter.name, version: options.adapter.version, source_path: location.path, content_hash: file?.hash ?? null,
-        byte_range: null, origin: options.origin ?? (options.adapter.semantic ? 'lsp' : 'parser'), resolution, freshness: 'current',
+        backend: options.adapter.name, version: options.adapter.version, source_path: location.path, content_hash: null,
+        // A current workspace snapshot does not prove that a backend index read it.
+        // None of the supported backend wire contracts supplies a validated index
+        // snapshot binding. Do not trust raw `freshness` or attach a newer file hash.
+        byte_range: null, origin: options.origin ?? (options.adapter.semantic ? 'lsp' : 'parser'), resolution, freshness: 'unknown',
     };
 }
 export function evidenceId(provenance, excerpt) {
-    return `evidence-${hash(JSON.stringify({ provenance, excerpt })).slice(0, 24)}`;
+    const { evidence_id: _id, ...fields } = provenance;
+    return `evidence-${hash(JSON.stringify({ provenance: fields, excerpt })).slice(0, 24)}`;
+}
+function candidates(raw) {
+    if (Array.isArray(raw))
+        return raw;
+    if (raw && typeof raw === 'object' && Array.isArray(raw.results))
+        return raw.results;
+    return null;
 }
 export function normalizeItems(raw, options, kind = 'code', limit = 100) {
-    const full = textOf(raw);
-    const chunks = Array.isArray(raw) ? raw : (raw && typeof raw === 'object' && Array.isArray(raw.results) ? raw.results : [raw]);
+    const chunks = candidates(raw) ?? (raw === null || raw === undefined || raw === '' ? [] : [raw]);
     const provenance = [];
     const items = [];
-    const maxChars = options.maxChars ?? 12000;
+    const warnings = [];
+    const maxChars = Math.min(12000, options.maxChars ?? 12000);
+    if (chunks.length > limit)
+        warnings.push('backend result list truncated');
     for (const candidate of chunks.slice(0, limit)) {
-        const excerpt = textOf(candidate).slice(0, maxChars);
+        const text = textOf(candidate);
+        const excerpt = shorten(text, maxChars);
+        if (excerpt !== text)
+            warnings.push('backend result excerpt truncated');
         if (!excerpt)
             continue;
-        const p = makeProvenance(options, excerpt, excerpt.toLowerCase().includes('ambiguous') ? 'ambiguous' : 'resolved');
-        if (candidate && typeof candidate === 'object' && typeof candidate.relative_path === 'string') {
+        const p = makeProvenance(options, excerpt);
+        if (candidate && typeof candidate === 'object' && 'relative_path' in candidate && typeof candidate.relative_path === 'string') {
             try {
                 p.source_path = assertSafePath(options.root, candidate.relative_path);
-                p.content_hash = options.snapshot.files.find(file => file.path === p.source_path)?.hash ?? null;
             }
             catch {
                 p.source_path = null;
@@ -56,33 +75,67 @@ export function normalizeItems(raw, options, kind = 'code', limit = 100) {
             }
         }
         const id = evidenceId(p, excerpt);
+        p.evidence_id = id;
         provenance.push(p);
         items.push({ item_id: `item-${hash(excerpt).slice(0, 24)}`, kind, path: p.source_path, excerpt, evidence_ids: [id], rank: items.length });
     }
-    if (items.length === 0 && full) {
-        const excerpt = full.slice(0, maxChars);
-        const p = makeProvenance(options, excerpt, 'unresolved');
-        const id = evidenceId(p, excerpt);
-        provenance.push(p);
-        items.push({ item_id: `item-${hash(excerpt).slice(0, 24)}`, kind, path: p.source_path, excerpt, evidence_ids: [id], rank: 0 });
-    }
-    return { items, provenance };
+    return { items, provenance, warnings: [...new Set(warnings)] };
+}
+export function serenaSymbolId(namePath, relativePath) {
+    return `serena:${encodeURIComponent(JSON.stringify({ name_path: namePath, relative_path: relativePath }))}`;
 }
 export function normalizeSymbols(raw, options) {
-    const normalized = normalizeItems(raw, options, 'symbol');
-    const candidates = Array.isArray(raw) ? raw : (raw && typeof raw === 'object' && Array.isArray(raw.results) ? raw.results : []);
-    const symbols = normalized.items.map((item, index) => {
-        const candidate = candidates[index] && typeof candidates[index] === 'object' ? candidates[index] : {};
-        const namePath = String(candidate.name_path ?? candidate.namePath ?? candidate.name ?? item.excerpt.split(/\s|\(|\{/u)[0] ?? 'unknown');
-        const path = typeof candidate.relative_path === 'string' ? candidate.relative_path : item.path;
-        const stableId = `serena:${encodeURIComponent(JSON.stringify({ name_path: namePath, relative_path: path ?? '' }))}`;
-        return { symbol_id: stableId, name: String(candidate.name ?? namePath.split('/').at(-1) ?? namePath), path, kind: String(candidate.kind ?? 'unknown'), signature: item.excerpt.slice(0, 500), evidence_ids: item.evidence_ids };
-    });
-    return { symbols, references: [], diagnostics: [], provenance: normalized.provenance };
+    const list = candidates(raw);
+    const symbols = [];
+    const provenance = [];
+    const warnings = [];
+    if (!list) {
+        const normalized = normalizeItems(raw, options, 'symbol');
+        return { symbols, references: [], diagnostics: [], provenance: normalized.provenance, warnings: [...normalized.warnings, 'unrecognized semantic symbol response'] };
+    }
+    if (list.length > 100)
+        warnings.push('semantic symbol result list truncated');
+    for (const value of list.slice(0, 100)) {
+        const normalized = normalizeItems([value], options, 'symbol', 1);
+        warnings.push(...normalized.warnings);
+        const item = normalized.items[0];
+        const p = normalized.provenance[0];
+        if (!item || !p)
+            continue;
+        const candidate = value && typeof value === 'object' ? value : {};
+        const namePath = typeof candidate.name_path === 'string' ? candidate.name_path.trim() : '';
+        if (!options.adapter.semantic || !namePath || !item.path || !options.snapshot.files.some(file => file.path === item.path)) {
+            provenance.push(p);
+            warnings.push('unresolved semantic symbol record');
+            continue;
+        }
+        p.resolution = 'resolved';
+        p.evidence_id = evidenceId(p, item.excerpt);
+        provenance.push(p);
+        symbols.push({ symbol_id: serenaSymbolId(namePath, item.path), name: typeof candidate.name === 'string' && candidate.name ? candidate.name : namePath.split('/').at(-1) || namePath,
+            path: item.path, kind: typeof candidate.kind === 'string' ? candidate.kind : 'unknown', signature: shorten(item.excerpt, 500), evidence_ids: [p.evidence_id] });
+    }
+    return { symbols, references: [], diagnostics: [], provenance, warnings: [...new Set(warnings)] };
 }
-export function normalizeEdges(raw, options, relation) {
+/** Graft prose/search hits are candidates, not an ordered graph path. */
+export function normalizeEdges(raw, options, _relation) {
     const normalized = normalizeItems(raw, options, 'code');
-    const nodes = normalized.items.map(item => ({ id: item.item_id, label: item.excerpt.slice(0, 160), path: item.path, evidence_ids: item.evidence_ids }));
-    const edges = nodes.slice(1).map((node, index) => ({ from: nodes[index].id, to: node.id, relation, evidence_ids: node.evidence_ids }));
-    return { nodes, edges, provenance: normalized.provenance };
+    const nodes = normalized.items.map(item => ({ id: item.item_id, label: shorten(item.excerpt, 160), path: item.path, evidence_ids: item.evidence_ids }));
+    return { nodes, edges: [], provenance: normalized.provenance, warnings: [...normalized.warnings, 'structural trace response has no validated edge contract'] };
+}
+export function normalizeReferenceEdges(raw, options, target, relation = 'references') {
+    const normalized = normalizeSymbols(raw, options);
+    const nodes = normalized.symbols.map(symbol => ({ id: symbol.symbol_id, label: symbol.name, path: symbol.path, evidence_ids: symbol.evidence_ids }));
+    let targetPath;
+    try {
+        targetPath = assertSafePath(options.root, target.relative_path);
+        if (!options.snapshot.files.some(file => file.path === targetPath))
+            throw new Error('target is absent from snapshot');
+    }
+    catch {
+        return { nodes, edges: [], provenance: normalized.provenance, warnings: [...normalized.warnings, 'reference target is unresolved'] };
+    }
+    const targetNode = { id: target.symbol_id, label: target.name_path, path: targetPath, evidence_ids: [] };
+    const edges = nodes.map(node => ({ from: node.id, to: targetNode.id, relation, evidence_ids: node.evidence_ids }));
+    return { nodes: [targetNode, ...nodes], edges, provenance: normalized.provenance, warnings: normalized.warnings };
 }

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

@@ -20,8 +20,14 @@ export class McpStdioClient {
         this.maxBytes = maxBytes;
     }
     async call(tool, arguments_, timeoutMs) {
+        const deadline = Date.now() + timeoutMs;
         await this.start(timeoutMs);
-        return this.request('tools/call', { name: tool, arguments: arguments_ }, timeoutMs);
+        const remaining = deadline - Date.now();
+        if (remaining <= 0) {
+            void this.close();
+            throw new Error('MCP call deadline exceeded during initialization');
+        }
+        return this.request('tools/call', { name: tool, arguments: arguments_ }, remaining);
     }
     async close() {
         if (!this.child)
@@ -35,7 +41,7 @@ export class McpStdioClient {
         this.pending.clear();
         child.kill('SIGTERM');
         await new Promise(resolve => {
-            const timer = setTimeout(() => { if (!child.killed)
+            const timer = setTimeout(() => { if (child.exitCode === null && child.signalCode === null)
                 child.kill('SIGKILL'); resolve(); }, 500);
             child.once('close', () => { clearTimeout(timer); resolve(); });
         });
@@ -60,6 +66,8 @@ export class McpStdioClient {
         return Promise.resolve();
     }
     request(method, params, timeoutMs) {
+        if (timeoutMs <= 0)
+            return Promise.reject(new Error(`MCP request deadline exceeded: ${method}`));
         if (!this.child)
             return Promise.reject(new Error('MCP process is not running'));
         const id = this.nextId++;

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

@@ -4,22 +4,22 @@ import { TOOL_DEFINITIONS } from './contracts.js';
 import { loadConfig } from '../retrofit/config.js';
 const INPUT_SCHEMAS = {
     code_context: { type: 'object', required: ['workspace_id', 'query'], properties: { workspace_id: { type: 'string' }, query: { type: 'string' }, snapshot_id: { type: 'string' }, mode: { type: 'string', enum: ['orient', 'locate', 'explain'] }, paths: { type: 'array', items: { type: 'string' } }, include_docs: { type: 'boolean' }, token_budget: { type: 'integer' }, timeout_ms: { type: 'integer' } } },
-    code_symbol: { type: 'object', required: ['workspace_id', 'snapshot_id'], properties: { workspace_id: { type: 'string' }, snapshot_id: { type: 'string' }, symbol_id: { type: 'string' }, query: { type: 'string' }, path: { type: 'string' }, include: { type: 'array' } } },
-    code_trace: { type: 'object', required: ['workspace_id', 'snapshot_id', 'symbol_id', 'direction', 'relations'], properties: { workspace_id: { type: 'string' }, snapshot_id: { type: 'string' }, symbol_id: { type: 'string' }, direction: { type: 'string', enum: ['in', 'out'] }, relations: { type: 'array' }, max_depth: { type: 'integer' }, max_nodes: { type: 'integer' } } },
-    code_impact: { type: 'object', required: ['workspace_id', 'snapshot_id'], properties: { workspace_id: { type: 'string' }, snapshot_id: { type: 'string' }, targets: { type: 'array' }, plan_id: { type: 'string' }, include_docs: { type: 'boolean' }, require_semantic: { type: 'boolean' } } },
-    code_edit_preview: { type: 'object', required: ['workspace_id', 'snapshot_id', 'operations', 'validation_profile'], properties: { workspace_id: { type: 'string' }, snapshot_id: { type: 'string' }, operations: { type: 'array' }, validation_profile: { type: 'string', enum: ['default', 'extended'] } } },
+    code_symbol: { type: 'object', required: ['workspace_id', 'snapshot_id'], properties: { workspace_id: { type: 'string' }, snapshot_id: { type: 'string' }, symbol_id: { type: 'string' }, query: { type: 'string' }, path: { type: 'string' }, include: { type: 'array' }, token_budget: { type: 'integer', minimum: 128, maximum: 16000 }, timeout_ms: { type: 'integer', minimum: 100, maximum: 60000 } } },
+    code_trace: { type: 'object', required: ['workspace_id', 'snapshot_id', 'symbol_id', 'direction', 'relations'], properties: { workspace_id: { type: 'string' }, snapshot_id: { type: 'string' }, symbol_id: { type: 'string' }, direction: { type: 'string', enum: ['in', 'out'] }, relations: { type: 'array' }, max_depth: { type: 'integer' }, max_nodes: { type: 'integer' }, require_resolved: { type: 'boolean' }, timeout_ms: { type: 'integer', minimum: 100, maximum: 60000 } } },
+    code_impact: { type: 'object', required: ['workspace_id', 'snapshot_id'], properties: { workspace_id: { type: 'string' }, snapshot_id: { type: 'string' }, targets: { type: 'array' }, plan_id: { type: 'string' }, include_docs: { type: 'boolean' }, require_semantic: { type: 'boolean' }, max_depth: { type: 'integer' }, timeout_ms: { type: 'integer', minimum: 100, maximum: 60000 } } },
+    code_edit_preview: { type: 'object', required: ['workspace_id', 'snapshot_id', 'operations', 'validation_profile'], properties: { workspace_id: { type: 'string' }, snapshot_id: { type: 'string' }, operations: { type: 'array' }, validation_profile: { type: 'string', enum: ['default', 'extended'] }, timeout_ms: { type: 'integer', minimum: 100, maximum: 600000 } } },
     code_edit_apply: { type: 'object', required: ['workspace_id', 'plan_id', 'expected_snapshot_id', 'idempotency_key'], properties: { workspace_id: { type: 'string' }, plan_id: { type: 'string' }, expected_snapshot_id: { type: 'string' }, idempotency_key: { type: 'string' } } },
 };
 function arg(name, args) { return args.find(value => value.startsWith(`--${name}=`))?.slice(name.length + 3); }
 function summary(response) { return `status=${response.status} snapshot=${response.snapshot_id} warnings=${response.warnings.length} (full result in structuredContent)`; }
-export async function runCodeIntelligenceServer(argv = process.argv.slice(2)) {
+export async function runCodeIntelligenceServer(argv = process.argv.slice(2), io = process) {
     const workspace = arg('workspace', argv) ?? process.cwd();
     const configured = loadConfig(workspace)?.codeIntelligence;
     const mode = arg('mode', argv) ?? configured?.mode ?? 'active';
     const coordinator = new CodeIntelligenceCoordinator(workspace, {
         mode,
         policy: { excludePatterns: configured?.policy?.excludePatterns, maxFileBytes: configured?.policy?.maxFileBytes },
-        limits: { maxBytes: configured?.limits?.maxBytes, maxBackends: configured?.limits?.maxBackends },
+        limits: configured?.limits,
         graft: configured?.graft, graphify: configured?.graphify, serena: configured?.serena,
     });
     let framing = 'line';
@@ -27,9 +27,9 @@ export async function runCodeIntelligenceServer(argv = process.argv.slice(2)) {
     const send = (message) => {
         const payload = JSON.stringify(message);
         if (framing === 'line')
-            process.stdout.write(`${payload}\n`);
+            io.stdout.write(`${payload}\n`);
         else
-            process.stdout.write(`Content-Length: ${Buffer.byteLength(payload, 'utf8')}\r\n\r\n${payload}`);
+            io.stdout.write(`Content-Length: ${Buffer.byteLength(payload, 'utf8')}\r\n\r\n${payload}`);
     };
     const handle = async (message) => {
         if (message.method === 'notifications/initialized' || message.method?.startsWith('notifications/'))
@@ -51,7 +51,7 @@ export async function runCodeIntelligenceServer(argv = process.argv.slice(2)) {
         if (message.id !== undefined)
             send({ jsonrpc: '2.0', id: message.id, error: { code: -32601, message: `method not found: ${message.method}` } });
     };
-    process.stdin.on('data', chunk => {
+    io.stdin.on('data', chunk => {
         buffer = Buffer.concat([buffer, Buffer.from(chunk)]);
         while (buffer.length) {
             let raw;
@@ -87,7 +87,7 @@ export async function runCodeIntelligenceServer(argv = process.argv.slice(2)) {
             catch { /* malformed protocol input is ignored */ }
         }
     });
-    await new Promise(resolve => { const stop = () => { process.off('SIGTERM', stop); process.off('SIGINT', stop); void coordinator.close().finally(resolve); }; process.once('SIGTERM', stop); process.once('SIGINT', stop); process.stdin.once('end', stop); });
+    await new Promise(resolve => { const stop = () => { process.off('SIGTERM', stop); process.off('SIGINT', stop); io.stdin.off('end', stop); void coordinator.close().finally(resolve); }; process.once('SIGTERM', stop); process.once('SIGINT', stop); io.stdin.once('end', stop); });
 }
 if (process.argv[1]?.endsWith('code-intelligence-server.js'))
     void runCodeIntelligenceServer();

package/dist/dashboard/analytics.js

@@ -50,7 +50,8 @@ export function aggregateMeasurements(events, period) {
         for (const target of targets)
             target.activity++;
         if (event.type === 'tokens') {
-            const calls = Array.isArray(data.calls) && data.calls.length ? data.calls : [{ ...data, actualModel: data.model, durationMs: event.durationMs }];
+            const hasCallBreakdown = Array.isArray(data.calls) && data.calls.length > 0;
+            const calls = hasCallBreakdown ? data.calls : [{ ...data, actualModel: data.model, durationMs: event.durationMs }];
             for (const item of calls) {
                 if (!item || typeof item !== 'object')
                     continue;
@@ -70,7 +71,8 @@ export function aggregateMeasurements(events, period) {
                     dimensionTargets.push(dimension);
                 }
                 for (const target of [...targets, get(models, key), get(modelBuckets, JSON.stringify([bucketOf(event.timestamp, period.bucket), provider, model, role])), ...dimensionTargets]) {
-                    const usageAvailable = call.usageAvailable !== false && data.usageAvailable !== false && call.measurementComplete !== false && data.measurementComplete !== false;
+                    const usageAvailable = call.usageAvailable !== false && call.measurementComplete !== false
+                        && (hasCallBreakdown || (data.usageAvailable !== false && data.measurementComplete !== false));
                     if (usageAvailable) {
                         addMetric(target, 'inputTokens', call.inputTokens);
                         addMetric(target, 'outputTokens', call.outputTokens);
@@ -87,7 +89,7 @@ export function aggregateMeasurements(events, period) {
                         target.unknownCalls++;
                     if (finite(call.totalCostUsd))
                         target.costReportedCalls++;
-                    if (call.costMeasurementComplete === false || data.costMeasurementComplete === false)
+                    if (call.costMeasurementComplete === false || (!hasCallBreakdown && data.costMeasurementComplete === false))
                         target.incompleteCosts++;
                 }
             }