@phuetz/code-buddy 1.6.1 → 2.0.0

package/dist/context/transcript-repair.js

@@ -10,68 +10,105 @@
 import { hasToolCalls } from '../codebuddy/client.js';
 import { logger } from '../utils/logger.js';
 /**
- * Repair tool call/result pairing in a message transcript.
+ * Repair tool call/result pairing in a message transcript by CANONICAL
+ * REBUILD: every tool result is re-emitted directly after the assistant
+ * message that called it — the layout providers actually require.
  *
- * 1. Removes orphaned tool results (tool_call_id has no matching tool_call).
- * 2. Injects synthetic results for tool_calls that lost their results.
+ * Handles, in one pass over corrupted transcripts (all observed after
+ * compaction or provider hiccups):
+ *  1. Orphaned tool results (tool_call_id with no surviving call) — removed.
+ *  2. tool_calls that lost their result — a synthetic result is injected.
+ *  3. Id-less tool_calls — stripped (they can never be paired; a provider
+ *     rejects them); an assistant left with zero calls loses the property.
+ *  4. Duplicate tool_call ids across assistants — first occurrence wins,
+ *     later duplicates are stripped (an id shared by two calls is protocol
+ *     corruption with no unambiguous repair).
+ *  5. Duplicate results for one id — first wins.
+ *  6. Results ordered BEFORE their call — relocated to the canonical slot.
+ *
+ * Idempotent: repairing a repaired transcript is a no-op.
  *
  * @returns Repaired message array (new array, original not mutated).
  */
 export function repairToolCallPairs(messages) {
-    // Collect all tool_call IDs from assistant messages
-    const toolCallIds = new Set();
+    // Pass A — decide the valid call ids (dedupe: first assistant occurrence
+    // wins) and index each id's FIRST result.
+    const validCallIds = new Set();
+    let strippedCalls = 0;
     for (const msg of messages) {
         if (hasToolCalls(msg)) {
             for (const tc of msg.tool_calls) {
-                if (tc.id)
-                    toolCallIds.add(tc.id);
+                if (!tc.id || validCallIds.has(tc.id)) {
+                    strippedCalls++;
+                    continue;
+                }
+                validCallIds.add(tc.id);
             }
         }
     }
-    // Collect all tool_call_ids from tool result messages
-    const toolResultIds = new Set();
+    const resultsById = new Map();
+    let removedOrphans = 0;
+    let duplicateResults = 0;
     for (const msg of messages) {
-        if (msg.role === 'tool') {
-            const callId = msg.tool_call_id;
-            if (callId)
-                toolResultIds.add(callId);
+        if (msg.role !== 'tool')
+            continue;
+        const callId = msg.tool_call_id;
+        if (!callId || !validCallIds.has(callId)) {
+            removedOrphans++;
+        }
+        else if (resultsById.has(callId)) {
+            duplicateResults++;
+        }
+        else {
+            resultsById.set(callId, msg);
         }
     }
-    let removedOrphans = 0;
+    // Pass B — rebuild: non-tool messages keep their order; each assistant's
+    // valid calls are followed immediately by their (real or synthetic) results.
+    const seenCallIds = new Set();
+    const result = [];
     let injectedSynthetics = 0;
-    // Step 1: Remove orphaned tool results (no matching tool_call)
-    const filtered = messages.filter(msg => {
-        if (msg.role === 'tool') {
-            const callId = msg.tool_call_id;
-            if (callId && !toolCallIds.has(callId)) {
-                removedOrphans++;
-                return false;
+    for (const msg of messages) {
+        if (msg.role === 'tool')
+            continue; // re-emitted in their canonical slot
+        if (hasToolCalls(msg)) {
+            const validCalls = msg.tool_calls.filter(tc => {
+                if (!tc.id || seenCallIds.has(tc.id))
+                    return false;
+                seenCallIds.add(tc.id);
+                return true;
+            });
+            if (validCalls.length === 0) {
+                // No pairable calls left — emit as a plain assistant message.
+                const { tool_calls: _stripped, ...rest } = msg;
+                result.push(rest);
+                continue;
             }
-        }
-        return true;
-    });
-    // Step 2: Inject synthetic results for tool_calls without results
-    const result = [];
-    for (const msg of filtered) {
-        result.push(msg);
-        if (hasToolCalls(msg) && msg.tool_calls.length > 0) {
-            const calls = msg.tool_calls;
-            for (const tc of calls) {
-                if (tc.id && !toolResultIds.has(tc.id)) {
-                    // Inject a synthetic result so the provider doesn't reject the transcript
+            result.push(validCalls.length === msg.tool_calls.length ? msg : { ...msg, tool_calls: validCalls });
+            for (const tc of validCalls) {
+                const existing = resultsById.get(tc.id);
+                if (existing) {
+                    result.push(existing);
+                }
+                else {
                     result.push({
                         role: 'tool',
                         tool_call_id: tc.id,
+                        name: tc.function.name,
                         content: '[result lost during compaction]',
                     });
                     injectedSynthetics++;
                 }
             }
+            continue;
         }
+        result.push(msg);
     }
-    if (removedOrphans > 0 || injectedSynthetics > 0) {
+    if (removedOrphans > 0 || injectedSynthetics > 0 || strippedCalls > 0 || duplicateResults > 0) {
         logger.info(`Transcript repair: removed ${removedOrphans} orphaned tool results, ` +
-            `injected ${injectedSynthetics} synthetic results`);
+            `injected ${injectedSynthetics} synthetic results, ` +
+            `stripped ${strippedCalls} unpairable tool calls, ` +
+            `dropped ${duplicateResults} duplicate results`);
     }
     return result;
 }

package/dist/context/types.d.ts

@@ -278,4 +278,6 @@ export interface ContextArchive {
     sessionId?: string;
     /** Reason for archival. */
     reason: 'compression' | 'manual' | 'checkpoint';
+    /** SHA-256 prefix of the archived messages; recoverContext refuses a mismatch. */
+    contentHash: string;
 }

package/dist/conversation/argument-obligations.d.ts

@@ -0,0 +1,65 @@
+import type { ConversationPlan } from './types.js';
+/** A response can have at most one obligation of each semantic kind. */
+export declare const MAX_ARGUMENT_OBLIGATIONS = 6;
+export declare const MAX_ARGUMENT_OBLIGATION_TARGET_CHARS = 320;
+export type ArgumentObligationTargetSource = 'current_turn' | 'deliberation_open_question' | 'deliberation_objection' | 'deliberation_correction' | 'deliberation_assistant_position';
+/**
+ * Bounded evidence identifying what an obligation is about. The excerpt is
+ * data, not an instruction or a completion criterion.
+ */
+export interface ArgumentObligationTarget {
+    source: ArgumentObligationTargetSource;
+    excerpt: string;
+}
+/**
+ * Semantic commitments for a response. `kind` is the stable obligation ID;
+ * each kind occurs at most once in a derived list.
+ *
+ * These types intentionally describe what must be achieved without defining
+ * lexical proxies for whether it was achieved. A semantic reviewer can assess
+ * the obligations later without rewarding connective words or sentence count.
+ */
+export type ArgumentObligation = {
+    kind: 'answer_question';
+    mode: 'required';
+    question?: ArgumentObligationTarget;
+} | {
+    kind: 'support_position';
+    mode: 'required';
+    position?: ArgumentObligationTarget;
+} | {
+    kind: 'address_objection';
+    mode: 'required';
+    objection: ArgumentObligationTarget;
+} | {
+    kind: 'revise_or_defend_position';
+    mode: 'required';
+    priorPosition: ArgumentObligationTarget;
+    challenge: ArgumentObligationTarget;
+} | {
+    kind: 'source_fresh_facts';
+    mode: 'required';
+    topic?: ArgumentObligationTarget;
+} | {
+    kind: 'express_uncertainty';
+    mode: 'conditional';
+    when: 'evidence_incomplete_or_conflicting' | 'conclusion_remains_contestable';
+    topic?: ArgumentObligationTarget;
+};
+/**
+ * Detect a question whose answer claims direct knowledge of a runtime event.
+ * These short confirmations need evidence just as much as a longer factual
+ * answer, even though the dialogue planner otherwise treats them as ordinary
+ * conversation.
+ */
+export declare function isRuntimeEvidenceVerificationRequest(value: string): boolean;
+/**
+ * Derive a deterministic, bounded set of semantic obligations from the plan
+ * that already drives the response. The optional current turn supplies a more
+ * precise target for normal questions and fresh-information requests.
+ *
+ * This function does not inspect a candidate response and deliberately makes
+ * no claim that surface words, length or rhetorical markers satisfy an
+ * obligation.
+ */
+export declare function deriveArgumentObligations(plan: ConversationPlan, currentTurn?: string): ArgumentObligation[];

package/dist/conversation/argument-obligations.js

@@ -0,0 +1,157 @@
+/** A response can have at most one obligation of each semantic kind. */
+export const MAX_ARGUMENT_OBLIGATIONS = 6;
+export const MAX_ARGUMENT_OBLIGATION_TARGET_CHARS = 320;
+function boundedExcerpt(value) {
+    const excerpt = value
+        ?.replace(/\p{Cc}+/gu, ' ')
+        .replace(/[<>&]/g, (character) => {
+        if (character === '<')
+            return '‹';
+        if (character === '>')
+            return '›';
+        return '＆';
+    })
+        .replace(/\s+/g, ' ')
+        .trim()
+        .slice(0, MAX_ARGUMENT_OBLIGATION_TARGET_CHARS);
+    return excerpt || undefined;
+}
+function target(source, value) {
+    const excerpt = boundedExcerpt(value);
+    return excerpt ? { source, excerpt } : undefined;
+}
+function currentTurnTarget(currentTurn) {
+    return target('current_turn', currentTurn);
+}
+function questionTarget(plan, currentTurn) {
+    return (currentTurnTarget(currentTurn) ??
+        target('deliberation_open_question', plan.deliberation.openQuestion));
+}
+function currentChallenge(plan) {
+    return plan.deliberation.correction
+        ? target('deliberation_correction', plan.deliberation.correction)
+        : target('deliberation_objection', plan.deliberation.objection);
+}
+function requiresDirectAnswer(plan, currentTurn) {
+    if (plan.act === 'question' ||
+        plan.act === 'clarification' ||
+        plan.act === 'fresh_information') {
+        return true;
+    }
+    // Opinion questions are classified as `opinion` before the generic question
+    // act. The punctuation/open-question state is used only to derive the target;
+    // it is never used to validate a model response.
+    if (plan.act === 'action' ||
+        plan.act === 'closing' ||
+        plan.act === 'phatic' ||
+        plan.act === 'backchannel' ||
+        plan.act === 'continuation') {
+        return false;
+    }
+    if (currentTurn !== undefined)
+        return currentTurn.includes('?');
+    return plan.deliberation.phase === 'opening' && Boolean(plan.deliberation.openQuestion);
+}
+function normalizeEvidenceQuestion(value) {
+    return value
+        .toLowerCase()
+        .normalize('NFD')
+        .replace(/\p{M}+/gu, '')
+        .replace(/[^\p{L}\p{N}]+/gu, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+/**
+ * Detect a question whose answer claims direct knowledge of a runtime event.
+ * These short confirmations need evidence just as much as a longer factual
+ * answer, even though the dialogue planner otherwise treats them as ordinary
+ * conversation.
+ */
+export function isRuntimeEvidenceVerificationRequest(value) {
+    const normalized = normalizeEvidenceQuestion(value);
+    if (!normalized)
+        return false;
+    const asksQuestion = value.includes('?') ||
+        /^(?:est ce que|as tu|avez vous|did you|have you|can you confirm|peux tu confirmer)\b/u.test(normalized);
+    if (!asksQuestion)
+        return false;
+    const refersToReceiver = /\b(?:tu|te|t|toi|vous|you|lisa|robot|systeme|code buddy)\b/u.test(normalized);
+    const asksAboutObservedEvent = /\b(?:transmis|transmise|transmettre|recu|recue|recevoir|entendu|entendue|entends|capt(?:e|ee|ure|uree)|arriv(?:e|ee)|received|receive|sent|transmitted|heard|captured)\b/u.test(normalized);
+    return refersToReceiver && asksAboutObservedEvent;
+}
+function requiresFreshSources(plan, currentTurn) {
+    return (plan.analysis.needsFreshContext ||
+        plan.act === 'fresh_information' ||
+        (plan.moves.includes('freshness') && plan.moves.includes('source')) ||
+        (currentTurn !== undefined && isRuntimeEvidenceVerificationRequest(currentTurn)));
+}
+/**
+ * Derive a deterministic, bounded set of semantic obligations from the plan
+ * that already drives the response. The optional current turn supplies a more
+ * precise target for normal questions and fresh-information requests.
+ *
+ * This function does not inspect a candidate response and deliberately makes
+ * no claim that surface words, length or rhetorical markers satisfy an
+ * obligation.
+ */
+export function deriveArgumentObligations(plan, currentTurn) {
+    const obligations = [];
+    const topic = currentTurnTarget(currentTurn);
+    const freshSources = requiresFreshSources(plan, currentTurn);
+    if (requiresDirectAnswer(plan, currentTurn)) {
+        const question = questionTarget(plan, currentTurn);
+        obligations.push({
+            kind: 'answer_question',
+            mode: 'required',
+            ...(question ? { question } : {}),
+        });
+    }
+    if (plan.moves.includes('position')) {
+        obligations.push({
+            kind: 'support_position',
+            mode: 'required',
+        });
+    }
+    const challenge = plan.deliberation.phase === 'challenging' ? currentChallenge(plan) : undefined;
+    if (challenge) {
+        obligations.push({
+            kind: 'address_objection',
+            mode: 'required',
+            objection: challenge,
+        });
+        const priorPosition = target('deliberation_assistant_position', plan.deliberation.assistantPosition);
+        if (priorPosition) {
+            obligations.push({
+                kind: 'revise_or_defend_position',
+                mode: 'required',
+                priorPosition,
+                challenge,
+            });
+        }
+    }
+    if (freshSources) {
+        obligations.push({
+            kind: 'source_fresh_facts',
+            mode: 'required',
+            ...(topic ? { topic } : {}),
+        });
+    }
+    if (freshSources) {
+        obligations.push({
+            kind: 'express_uncertainty',
+            mode: 'conditional',
+            when: 'evidence_incomplete_or_conflicting',
+            ...(topic ? { topic } : {}),
+        });
+    }
+    else if (plan.depth === 'deliberative') {
+        obligations.push({
+            kind: 'express_uncertainty',
+            mode: 'conditional',
+            when: 'conclusion_remains_contestable',
+            ...(topic ? { topic } : {}),
+        });
+    }
+    return obligations.slice(0, MAX_ARGUMENT_OBLIGATIONS);
+}
+//# sourceMappingURL=argument-obligations.js.map

package/dist/conversation/companion-model-routing.d.ts

@@ -0,0 +1,121 @@
+import type { ConversationTurn } from './types.js';
+import { type ModelEgress } from '../providers/model-egress.js';
+export type CompanionRoutingSurface = 'voice' | 'telegram' | 'cowork';
+export type CompanionRoutingLane = 'fast' | 'factual' | 'deep' | 'emotional' | 'action';
+export interface CompanionRoutingProfile {
+    version: 1;
+    enabled: boolean;
+    profileId: string;
+    createdAt: string;
+    expiresAt: string;
+    source: {
+        comparisonId: string;
+        evidenceFingerprint: string;
+        candidateId: string;
+        judgedTrials: number;
+        totalTrials: number;
+        reviewCoverage: number;
+        minimumCoverage: number;
+        coverageOverride: boolean;
+        automatedRelationshipSafetyTrials: number;
+        automatedHighRiskTrials: number;
+        automatedHighRiskRelationshipSafetyTrials: number;
+        reviewedRelationshipSafetyTrials: number;
+        reviewedHighRiskTrials: number;
+        reviewedHighRiskRelationshipSafetyTrials: number;
+    };
+    winner: {
+        model: string;
+        provider: string;
+        averageBorda: number;
+        winRate: number;
+        automatedScore: number;
+        errors: number;
+        passRate: number;
+        safetyPassRate: number;
+        averageLatencyMs: number;
+    };
+    policy: {
+        surfaces: CompanionRoutingSurface[];
+        lanes: CompanionRoutingLane[];
+    };
+}
+export interface CompanionRoutingDecision {
+    profileId: string;
+    surface: CompanionRoutingSurface;
+    lane: CompanionRoutingLane;
+    model: string;
+    provider: string;
+}
+export interface CompanionRuntimeRoute extends CompanionRoutingDecision {
+    apiKey: string;
+    baseURL: string;
+    /** Actual inference destination; subscription CLIs remain cloud egress. */
+    egress: ModelEgress;
+    reason: string;
+}
+export interface CompanionRoutingEvent {
+    version: 1;
+    timestamp: string;
+    profileId: string;
+    surface: CompanionRoutingSurface;
+    lane: CompanionRoutingLane;
+    preferredModel: string;
+    selectedModel?: string;
+    outcome: 'route_selected' | 'fallback_unavailable' | 'fallback_local_only';
+}
+export interface RuntimeCandidate {
+    provider: string;
+    model: string;
+    apiKey?: string;
+    baseURL?: string;
+    egress?: ModelEgress;
+}
+export interface ResolveCompanionModelRouteOptions {
+    surface: CompanionRoutingSurface;
+    text: string;
+    /** Recent transport-independent turns, oldest first. */
+    history?: ConversationTurn[];
+    requireLocal?: boolean;
+    env?: NodeJS.ProcessEnv;
+    now?: () => Date;
+    profile?: CompanionRoutingProfile | null;
+    listCandidates?: () => Promise<RuntimeCandidate[]>;
+    resolveExplicit?: (model: string, provider: string) => Promise<RuntimeCandidate | null>;
+    recordEvent?: (event: CompanionRoutingEvent) => void;
+}
+export interface ActivateCompanionRoutingOptions {
+    forceCoverage?: boolean;
+    minimumCoverage?: number;
+    ttlDays?: number;
+    now?: Date;
+    profilePath?: string;
+    previousPath?: string;
+}
+export declare function defaultCompanionRoutingPaths(home?: string): {
+    profile: string;
+    previous: string;
+    events: string;
+};
+/** Effective private paths, including test/deployment overrides. */
+export declare function configuredCompanionRoutingPaths(env?: NodeJS.ProcessEnv): ReturnType<typeof defaultCompanionRoutingPaths>;
+export declare function validateCompanionRoutingProfile(value: unknown): CompanionRoutingProfile;
+export declare function readCompanionRoutingProfile(path?: string): CompanionRoutingProfile | null;
+export declare function activateCompanionRoutingFromFiles(preferencesPath: string, aggregatePath: string, options?: ActivateCompanionRoutingOptions): CompanionRoutingProfile;
+export declare function rollbackCompanionRoutingProfile(profilePath?: string, previousPath?: string): CompanionRoutingProfile | null;
+/** Emergency stop that never restores or mutates the previous profile. */
+export declare function disableCompanionRoutingProfile(profilePath?: string): CompanionRoutingProfile | null;
+/**
+ * Classify a turn in its real discussion. Elliptical follow-ups inherit the
+ * active deliberation, so "Continue" and "Et la réciprocité ?" remain deep
+ * after a philosophical exchange. The planner explicitly cancels inheritance
+ * for a brief request, action, closing, phatic or ordinary backchannel turn.
+ * Explicit current-turn action, emotion, factual and deep signals still win.
+ */
+export declare function classifyCompanionRoutingLane(text: string, history?: ConversationTurn[]): CompanionRoutingLane;
+export declare function decideCompanionRouting(profile: CompanionRoutingProfile | null, surface: CompanionRoutingSurface, text: string, now?: Date, history?: ConversationTurn[]): CompanionRoutingDecision | null;
+export declare function recordCompanionRoutingEvent(event: CompanionRoutingEvent, path?: string): void;
+export declare function resolveCompanionModelRoute(options: ResolveCompanionModelRouteOptions): Promise<CompanionRuntimeRoute | null>;
+export declare function readRecentCompanionRoutingEvents(limit?: number, path?: string, profileId?: string): CompanionRoutingEvent[];
+/** Test seam for credential/model-pool changes. */
+export declare function resetCompanionModelRoutingCache(): void;