@phuetz/code-buddy 2.0.0 → 2.1.0

package/dist/orchestration/orchestrator.d.ts

@@ -20,6 +20,8 @@ export declare class Orchestrator extends EventEmitter {
     private failedTaskCount;
     private totalTaskDuration;
     private running;
+    private workflowTaskSequence;
+    private workflowTaskIdentity;
     constructor(config?: Partial<OrchestratorConfig>);
     /**
      * Register a new agent
@@ -81,6 +83,25 @@ export declare class Orchestrator extends EventEmitter {
      * Cancel a task
      */
     cancelTask(taskId: string): void;
+    private isTerminal;
+    /**
+     * A report (result, error, answered approval) for a task that is already
+     * terminal — typically abandoned when its workflow timed out — changes
+     * nothing: no status, output, retry, stat or event. The worker its executor
+     * kept busy is released, but only if it is still on that task.
+     */
+    private releaseWorkerAfterLateReport;
+    /**
+     * A failed workflow must stop dispatching: its queued tasks leave the queue and
+     * every unfinished task becomes cancelled. A task whose executor is still busy
+     * keeps its worker until that executor reports back (see
+     * `releaseWorkerAfterLateReport`); an effect it already started is not undone.
+     */
+    private abandonUnfinishedTasks;
+    private assertWorkflowRunning;
+    private createWorkflowTask;
+    private isDependencyComplete;
+    private pruneTerminalTasksForCapacity;
     /**
      * Process the task queue
      */

package/dist/orchestration/orchestrator.js

@@ -37,6 +37,8 @@ export class Orchestrator extends EventEmitter {
     failedTaskCount = 0;
     totalTaskDuration = 0;
     running = false;
+    workflowTaskSequence = 0;
+    workflowTaskIdentity = new WeakMap();
     constructor(config = {}) {
         super();
         this.config = { ...DEFAULT_CONFIG, ...config };
@@ -147,6 +149,7 @@ export class Orchestrator extends EventEmitter {
      * Create a new task
      */
     createTask(definition) {
+        this.pruneTerminalTasksForCapacity();
         if (this.tasks.size >= this.config.maxTasks) {
             throw new Error(`Maximum task limit (${this.config.maxTasks}) reached`);
         }
@@ -237,6 +240,10 @@ export class Orchestrator extends EventEmitter {
         const task = this.tasks.get(taskId);
         if (!task)
             throw new Error(`Task '${taskId}' not found`);
+        if (this.isTerminal(task)) {
+            this.releaseWorkerAfterLateReport(task);
+            return;
+        }
         task.status = 'completed';
         task.output = output;
         task.completedAt = new Date();
@@ -245,10 +252,10 @@ export class Orchestrator extends EventEmitter {
         if (task.startedAt) {
             this.totalTaskDuration += task.completedAt.getTime() - task.startedAt.getTime();
         }
-        // Free up agent
+        // Free up agent — only if it is still on this task
         if (task.assignedAgent) {
             const agent = this.agents.get(task.assignedAgent);
-            if (agent) {
+            if (agent && agent.currentTask === taskId) {
                 agent.status = 'idle';
                 agent.currentTask = undefined;
                 agent.completedTasks++;
@@ -267,16 +274,20 @@ export class Orchestrator extends EventEmitter {
         const task = this.tasks.get(taskId);
         if (!task)
             throw new Error(`Task '${taskId}' not found`);
+        if (this.isTerminal(task)) {
+            this.releaseWorkerAfterLateReport(task);
+            return;
+        }
         // Check for retries
         if (task.retries < (task.definition.maxRetries || 0)) {
             task.retries++;
             task.status = 'queued';
             this.insertIntoQueue(task);
             this.log('warn', `Task ${taskId} failed, retrying (${task.retries}/${task.definition.maxRetries})`);
-            // Free up agent
+            // Free up agent — only if it is still on this task
             if (task.assignedAgent) {
                 const agent = this.agents.get(task.assignedAgent);
-                if (agent) {
+                if (agent && agent.currentTask === taskId) {
                     agent.status = 'idle';
                     agent.currentTask = undefined;
                     agent.lastActivity = new Date();
@@ -290,10 +301,10 @@ export class Orchestrator extends EventEmitter {
         task.error = error;
         task.completedAt = new Date();
         this.failedTaskCount++;
-        // Free up agent
+        // Free up agent — only if it is still on this task
         if (task.assignedAgent) {
             const agent = this.agents.get(task.assignedAgent);
-            if (agent) {
+            if (agent && agent.currentTask === taskId) {
                 agent.status = 'idle';
                 agent.currentTask = undefined;
                 agent.failedTasks++;
@@ -318,6 +329,8 @@ export class Orchestrator extends EventEmitter {
         const task = this.tasks.get(taskId);
         if (!task)
             throw new Error(`Task '${taskId}' not found`);
+        if (this.isTerminal(task))
+            return;
         task.status = 'cancelled';
         task.completedAt = new Date();
         // Remove from queue
@@ -325,10 +338,10 @@ export class Orchestrator extends EventEmitter {
         if (queueIdx !== -1) {
             this.taskQueue.splice(queueIdx, 1);
         }
-        // Free up agent
+        // Free up agent — only if it is still on this task
         if (task.assignedAgent) {
             const agent = this.agents.get(task.assignedAgent);
-            if (agent) {
+            if (agent && agent.currentTask === taskId) {
                 agent.status = 'idle';
                 agent.currentTask = undefined;
                 agent.lastActivity = new Date();
@@ -336,6 +349,95 @@ export class Orchestrator extends EventEmitter {
         }
         this.log('info', `Task cancelled: ${taskId}`);
     }
+    isTerminal(task) {
+        return task.status === 'completed' || task.status === 'failed' || task.status === 'cancelled';
+    }
+    /**
+     * A report (result, error, answered approval) for a task that is already
+     * terminal — typically abandoned when its workflow timed out — changes
+     * nothing: no status, output, retry, stat or event. The worker its executor
+     * kept busy is released, but only if it is still on that task.
+     */
+    releaseWorkerAfterLateReport(task) {
+        const taskId = task.definition.id;
+        const agent = task.assignedAgent ? this.agents.get(task.assignedAgent) : undefined;
+        this.log('debug', `Ignored late report for ${task.status} task ${taskId}`);
+        task.assignedAgent = undefined;
+        if (agent?.currentTask === taskId) {
+            agent.status = 'idle';
+            agent.currentTask = undefined;
+            agent.lastActivity = new Date();
+            this.processQueue();
+        }
+    }
+    /**
+     * A failed workflow must stop dispatching: its queued tasks leave the queue and
+     * every unfinished task becomes cancelled. A task whose executor is still busy
+     * keeps its worker until that executor reports back (see
+     * `releaseWorkerAfterLateReport`); an effect it already started is not undone.
+     */
+    abandonUnfinishedTasks(instance) {
+        for (const task of instance.tasks.values()) {
+            if (this.isTerminal(task))
+                continue;
+            task.status = 'cancelled';
+            task.completedAt = new Date();
+            const queueIdx = this.taskQueue.indexOf(task);
+            if (queueIdx !== -1)
+                this.taskQueue.splice(queueIdx, 1);
+        }
+    }
+    assertWorkflowRunning(instance) {
+        if (instance.status !== 'running') {
+            throw new Error(`Workflow '${instance.instanceId}' is no longer running`);
+        }
+    }
+    createWorkflowTask(instance, definition) {
+        this.assertWorkflowRunning(instance);
+        const logicalTaskId = definition.id;
+        const runtimeTaskId = `${instance.instanceId}:${logicalTaskId}:${++this.workflowTaskSequence}`;
+        const task = this.createTask({ ...definition, id: runtimeTaskId });
+        this.workflowTaskIdentity.set(task, { instanceId: instance.instanceId, logicalTaskId });
+        instance.tasks.set(runtimeTaskId, task);
+        return task;
+    }
+    isDependencyComplete(task, dependencyId) {
+        const identity = this.workflowTaskIdentity.get(task);
+        if (!identity)
+            return this.tasks.get(dependencyId)?.status === 'completed';
+        const workflow = this.workflows.get(identity.instanceId);
+        if (!workflow)
+            return false;
+        let latestDependency;
+        for (const candidate of workflow.tasks.values()) {
+            const candidateIdentity = this.workflowTaskIdentity.get(candidate);
+            if (candidateIdentity?.logicalTaskId === dependencyId)
+                latestDependency = candidate;
+        }
+        return latestDependency?.status === 'completed';
+    }
+    pruneTerminalTasksForCapacity() {
+        if (this.tasks.size < this.config.maxTasks)
+            return;
+        for (const [taskId, task] of this.tasks) {
+            if (!this.isTerminal(task))
+                continue;
+            const identity = this.workflowTaskIdentity.get(task);
+            if (identity && this.workflows.get(identity.instanceId)?.status === 'running')
+                continue;
+            const hasOutstandingExecutor = task.status === 'cancelled' && task.assignedAgent !== undefined;
+            if (hasOutstandingExecutor)
+                continue;
+            const isRequiredByActiveStandaloneTask = Array.from(this.tasks.values()).some((candidate) => !this.isTerminal(candidate) &&
+                !this.workflowTaskIdentity.has(candidate) &&
+                candidate.definition.dependsOn?.includes(taskId));
+            if (isRequiredByActiveStandaloneTask)
+                continue;
+            this.tasks.delete(taskId);
+            if (this.tasks.size < this.config.maxTasks)
+                return;
+        }
+    }
     // ============================================================================
     // Queue Processing
     // ============================================================================
@@ -348,10 +450,7 @@ export class Orchestrator extends EventEmitter {
         for (const task of this.taskQueue) {
             // Check dependencies
             if (task.definition.dependsOn && task.definition.dependsOn.length > 0) {
-                const allDepsComplete = task.definition.dependsOn.every((depId) => {
-                    const dep = this.tasks.get(depId);
-                    return dep?.status === 'completed';
-                });
+                const allDepsComplete = task.definition.dependsOn.every((depId) => this.isDependencyComplete(task, depId));
                 if (!allDepsComplete)
                     continue;
             }
@@ -412,6 +511,7 @@ export class Orchestrator extends EventEmitter {
             instance.status = 'failed';
             instance.error = errorMessage;
             instance.completedAt = new Date();
+            this.abandonUnfinishedTasks(instance);
             this.emit('workflow_failed', { type: 'workflow_failed', instanceId, error: errorMessage });
             this.log('error', `Workflow failed: ${instanceId} - ${errorMessage}`);
         }
@@ -425,6 +525,7 @@ export class Orchestrator extends EventEmitter {
         for (const step of instance.definition.steps) {
             instance.currentStep = step.id;
             await this.executeWorkflowStep(instance, step, context);
+            this.assertWorkflowRunning(instance);
             instance.completedSteps.push(step.id);
             this.emit('workflow_step_completed', {
                 type: 'workflow_step_completed',
@@ -438,6 +539,7 @@ export class Orchestrator extends EventEmitter {
      * Execute a workflow step
      */
     async executeWorkflowStep(instance, step, context) {
+        this.assertWorkflowRunning(instance);
         switch (step.type) {
             case 'task':
                 await this.executeTaskStep(instance, step, context);
@@ -463,20 +565,21 @@ export class Orchestrator extends EventEmitter {
         if (!step.tasks || step.tasks.length === 0)
             return;
         for (const taskDef of step.tasks) {
+            this.assertWorkflowRunning(instance);
             // Substitute variables in task input
             const resolvedInput = this.resolveVariables(taskDef.input, context);
             const resolvedDef = { ...taskDef, input: resolvedInput };
-            const task = this.createTask(resolvedDef);
-            instance.tasks.set(task.definition.id, task);
+            const task = this.createWorkflowTask(instance, resolvedDef);
             this.queueTask(task.definition.id);
             // Wait for completion
             await this.waitForTask(task.definition.id);
+            this.assertWorkflowRunning(instance);
             // Add output to context — both under the task's namespaced key and,
             // optionally, under a user-provided alias for readability in
             // downstream conditions / tool inputs.
             const completedTask = this.tasks.get(task.definition.id);
             if (completedTask?.output) {
-                context[`task_${task.definition.id}`] = completedTask.output;
+                context[`task_${taskDef.id}`] = completedTask.output;
                 if (typeof taskDef.aliasAs === 'string' && taskDef.aliasAs.length > 0) {
                     context[taskDef.aliasAs] = completedTask.output;
                 }
@@ -497,6 +600,7 @@ export class Orchestrator extends EventEmitter {
             return branchContext;
         });
         const results = await Promise.all(branchPromises);
+        this.assertWorkflowRunning(instance);
         // Merge branch results
         for (let i = 0; i < results.length; i++) {
             context[`branch_${i}`] = results[i];
@@ -525,6 +629,7 @@ export class Orchestrator extends EventEmitter {
         const maxIterations = Math.max(1, Math.min(configuredLimit, 100));
         while (this.evaluateCondition(step.loopCondition || 'false', context) &&
             iteration < maxIterations) {
+            this.assertWorkflowRunning(instance);
             context['iteration'] = iteration;
             this.emit('loop_iteration_started', {
                 type: 'loop_iteration_started',
@@ -557,6 +662,7 @@ export class Orchestrator extends EventEmitter {
             return;
         }
         const tasks = items.map((item, index) => async () => {
+            this.assertWorkflowRunning(instance);
             // Create local context fork for this batch item execution
             const localContext = { ...context, [varName]: item, index };
             this.emit('loop_iteration_started', {
@@ -581,6 +687,7 @@ export class Orchestrator extends EventEmitter {
             }
         });
         await Promise.all(workers);
+        this.assertWorkflowRunning(instance);
     }
     evaluateExpression(expression, context) {
         let resolved = expression;

package/dist/persistence/session-content.d.ts

@@ -0,0 +1,8 @@
+import type { SessionMessage } from './session-store.js';
+export declare class SessionDecryptionError extends Error {
+    constructor(cause: unknown);
+}
+export declare function hasEncryptedSessionContent(messages: SessionMessage[]): boolean;
+/** Both async and legacy synchronous store readers use the same authenticated decoder. */
+export declare function decryptSessionContent(messages: SessionMessage[], keyPath?: string): SessionMessage[];
+export declare function encryptSessionContent(messages: SessionMessage[], keyPath?: string): Promise<SessionMessage[]>;

package/dist/persistence/session-content.js

@@ -0,0 +1,76 @@
+import { SessionEncryption } from '../security/session-encryption.js';
+export class SessionDecryptionError extends Error {
+    constructor(cause) {
+        super('Cannot decrypt session: restore the original encryption key before continuing.', { cause });
+        this.name = 'SessionDecryptionError';
+    }
+}
+function envelope(messages) {
+    if (messages.length !== 1 || messages[0]?.type !== 'assistant')
+        return null;
+    let value;
+    try {
+        value = JSON.parse(messages[0].content);
+    }
+    catch {
+        return null;
+    }
+    if (!value || typeof value !== 'object' || !('__encrypted' in value) || value.__encrypted !== true)
+        return null;
+    if (!('data' in value))
+        throw new SessionDecryptionError(new Error('Missing encrypted data'));
+    return value;
+}
+export function hasEncryptedSessionContent(messages) {
+    return envelope(messages) !== null;
+}
+/** Both async and legacy synchronous store readers use the same authenticated decoder. */
+export function decryptSessionContent(messages, keyPath) {
+    const wrapped = envelope(messages);
+    if (!wrapped)
+        return messages;
+    const encryption = new SessionEncryption({ keyPath, requirePersistentKey: true });
+    try {
+        if (!encryption.isEncrypted(wrapped.data) || ![1, 2].includes(wrapped.data.version))
+            throw new Error('Invalid encrypted envelope');
+        encryption.initializeForRead();
+        const decoded = encryption.decryptObject(wrapped.data);
+        if (!Array.isArray(decoded))
+            throw new Error('Invalid encrypted history');
+        const types = new Set(['user', 'assistant', 'tool_call', 'tool_result', 'reasoning', 'plan_progress', 'steer', 'diff_preview']);
+        return decoded.map((entry) => {
+            if (!entry || typeof entry !== 'object')
+                throw new Error('Invalid encrypted message');
+            const message = entry;
+            if (!types.has(message.type) || typeof message.content !== 'string' ||
+                typeof message.timestamp !== 'string' || !Number.isFinite(Date.parse(message.timestamp))) {
+                throw new Error('Invalid encrypted message');
+            }
+            // Legacy envelopes contain ChatEntry JSON; its timestamp is already serialized.
+            return { ...message };
+        });
+    }
+    catch (error) {
+        throw new SessionDecryptionError(error);
+    }
+    finally {
+        encryption.dispose();
+    }
+}
+export async function encryptSessionContent(messages, keyPath) {
+    if (hasEncryptedSessionContent(messages))
+        return messages;
+    const encryption = new SessionEncryption({ keyPath, requirePersistentKey: true });
+    try {
+        await encryption.initialize();
+        const data = encryption.encryptObject(messages);
+        if (!encryption.isEncrypted(data))
+            throw new Error('Session encryption produced plaintext');
+        return [{ type: 'assistant', timestamp: new Date().toISOString(),
+                content: JSON.stringify({ __encrypted: true, format: 'session-messages-v1', data }) }];
+    }
+    finally {
+        encryption.dispose();
+    }
+}
+//# sourceMappingURL=session-content.js.map

package/dist/persistence/session-handoff.d.ts

@@ -0,0 +1,64 @@
+/**
+ * GUI → terminal session handoff (comparatif plan P6).
+ *
+ * Converts a text conversation (e.g. a Cowork session) into the CLI session
+ * store format so `buddy --resume <id>` continues it in the terminal.
+ *
+ * Contract:
+ * - only user/assistant TEXT turns are exported (no tool payloads, attachments
+ *   or system/context blocks);
+ * - every turn goes through the data-redaction engine; secrets become
+ *   placeholders and are counted, never copied;
+ * - the file is written atomically with mode 0600 in the CLI sessions dir
+ *   (CODEBUDDY_SESSIONS_DIR or ~/.codebuddy/sessions); the id is deterministic
+ *   (`cowork-<source id>`) so a later export refreshes the same terminal session;
+ * - the returned command carries no credential.
+ */
+export interface HandoffTurn {
+    role: string;
+    text: string;
+    timestamp?: number | string;
+}
+export interface HandoffInput {
+    source: 'cowork';
+    sourceId: string;
+    name: string;
+    workingDirectory?: string;
+    model?: string;
+    createdAt?: number | string;
+    turns: HandoffTurn[];
+}
+export interface HandoffResult {
+    id: string;
+    path: string;
+    command: string;
+    messageCount: number;
+    redactions: number;
+}
+export declare function handoffSessionId(source: HandoffInput['source'], sourceId: string): string;
+export declare function buildHandoffSession(input: HandoffInput, now?: Date): {
+    session: {
+        id: string;
+        name: string;
+        workingDirectory: string;
+        model: string;
+        messages: {
+            type: "user" | "assistant";
+            content: string;
+            timestamp: string;
+        }[];
+        createdAt: string;
+        lastAccessedAt: string;
+        metadata: {
+            handoffSource: "cowork";
+            handoffSourceId: string;
+            handoffAt: string;
+        };
+    };
+    redactions: number;
+};
+export declare function cliSessionsDir(): string;
+export declare function writeHandoffSession(input: HandoffInput, options?: {
+    dir?: string;
+    now?: Date;
+}): Promise<HandoffResult>;

package/dist/persistence/session-handoff.js

@@ -0,0 +1,80 @@
+/**
+ * GUI → terminal session handoff (comparatif plan P6).
+ *
+ * Converts a text conversation (e.g. a Cowork session) into the CLI session
+ * store format so `buddy --resume <id>` continues it in the terminal.
+ *
+ * Contract:
+ * - only user/assistant TEXT turns are exported (no tool payloads, attachments
+ *   or system/context blocks);
+ * - every turn goes through the data-redaction engine; secrets become
+ *   placeholders and are counted, never copied;
+ * - the file is written atomically with mode 0600 in the CLI sessions dir
+ *   (CODEBUDDY_SESSIONS_DIR or ~/.codebuddy/sessions); the id is deterministic
+ *   (`cowork-<source id>`) so a later export refreshes the same terminal session;
+ * - the returned command carries no credential.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { getDataRedactionEngine } from '../security/data-redaction.js';
+import { writeJsonAtomic } from '../utils/atomic-write.js';
+const MAX_TURN_CHARS = 200_000;
+function isoTime(value, fallback) {
+    const parsed = typeof value === 'number' ? new Date(value) : typeof value === 'string' ? new Date(value) : undefined;
+    return parsed && !Number.isNaN(parsed.getTime()) ? parsed.toISOString() : fallback.toISOString();
+}
+export function handoffSessionId(source, sourceId) {
+    const safe = sourceId.replace(/[^a-zA-Z0-9_-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 80);
+    if (!safe)
+        throw new Error('HANDOFF_INVALID_SOURCE_ID');
+    return `${source}-${safe}`;
+}
+export function buildHandoffSession(input, now = new Date()) {
+    const engine = getDataRedactionEngine();
+    let redactions = 0;
+    const redact = (text) => {
+        const result = engine.redact(text);
+        redactions += result.redactions.length;
+        return result.redacted;
+    };
+    const messages = input.turns
+        .filter((turn) => (turn.role === 'user' || turn.role === 'assistant') && typeof turn.text === 'string' && turn.text.trim())
+        .map((turn) => ({
+        type: turn.role,
+        content: redact(turn.text.slice(0, MAX_TURN_CHARS)),
+        timestamp: isoTime(turn.timestamp, now),
+    }));
+    const createdAt = isoTime(input.createdAt, now);
+    const session = {
+        id: handoffSessionId(input.source, input.sourceId),
+        name: redact(input.name || input.sourceId).slice(0, 200),
+        workingDirectory: input.workingDirectory && path.isAbsolute(input.workingDirectory) ? input.workingDirectory : process.cwd(),
+        model: input.model || 'unknown',
+        messages,
+        createdAt,
+        lastAccessedAt: now.toISOString(),
+        metadata: { handoffSource: input.source, handoffSourceId: input.sourceId, handoffAt: now.toISOString() },
+    };
+    return { session, redactions };
+}
+export function cliSessionsDir() {
+    return path.resolve(process.env.CODEBUDDY_SESSIONS_DIR || path.join(os.homedir(), '.codebuddy', 'sessions'));
+}
+export async function writeHandoffSession(input, options = {}) {
+    const { session, redactions } = buildHandoffSession(input, options.now);
+    if (session.messages.length === 0)
+        throw new Error('HANDOFF_EMPTY_CONVERSATION');
+    const dir = options.dir ?? cliSessionsDir();
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const filePath = path.join(dir, `${session.id}.json`);
+    await writeJsonAtomic(filePath, session, { mode: 0o600 });
+    return {
+        id: session.id,
+        path: filePath,
+        command: `buddy --resume ${session.id}`,
+        messageCount: session.messages.length,
+        redactions,
+    };
+}
+//# sourceMappingURL=session-handoff.js.map

package/dist/persistence/session-history.d.ts

@@ -0,0 +1,4 @@
+import type { ChatEntry } from '../agent/types.js';
+import type { CodeBuddyMessage } from '../codebuddy/client.js';
+/** Restore the provider transcript, not just the visible chat bubbles. */
+export declare function restoreSessionHistory(entries: ChatEntry[]): CodeBuddyMessage[];

package/dist/persistence/session-history.js

@@ -0,0 +1,38 @@
+import { repairToolCallPairs } from '../context/transcript-repair.js';
+import { sanitizeModelOutput } from '../utils/output-sanitizer.js';
+/** Restore the provider transcript, not just the visible chat bubbles. */
+export function restoreSessionHistory(entries) {
+    const messages = [];
+    const knownCalls = new Set();
+    for (const entry of entries) {
+        const calls = (entry.toolCalls ?? (entry.toolCall ? [entry.toolCall] : []))
+            .filter(call => Boolean(call.id && call.function?.name));
+        if (entry.type === 'user' || entry.type === 'steer') {
+            messages.push({ role: 'user', content: entry.content });
+        }
+        else if (entry.type === 'assistant' || entry.type === 'tool_call') {
+            const newCalls = calls.filter(call => !knownCalls.has(call.id));
+            for (const call of newCalls)
+                knownCalls.add(call.id);
+            if (entry.content || newCalls.length) {
+                messages.push({ role: 'assistant', content: sanitizeModelOutput(entry.content),
+                    ...(newCalls.length ? { tool_calls: newCalls } : {}) });
+            }
+        }
+        else if (entry.type === 'tool_result') {
+            const call = calls[0];
+            const result = entry.toolResult;
+            const content = result ? JSON.stringify({ ...result, ...(result.output === undefined && entry.content ? { output: entry.content } : {}) }) : entry.content;
+            if (call && knownCalls.has(call.id)) {
+                messages.push({ role: 'tool', tool_call_id: call.id, content });
+            }
+            else {
+                // Old sessions have no stable pairing. Keep the evidence as historical
+                // data without inventing a tool invocation or dropping a failed result.
+                messages.push({ role: 'assistant', content: `[Historical tool result (untrusted data)${call ? `: ${call.function.name}` : ''}]\n${content}` });
+            }
+        }
+    }
+    return repairToolCallPairs(messages);
+}
+//# sourceMappingURL=session-history.js.map

package/dist/persistence/session-store.d.ts

@@ -35,6 +35,8 @@ export interface SessionUsageSnapshot {
     turns?: SessionTurnUsage[];
 }
 export interface Session {
+    /** Sticky protection: metadata changes and forks must remain encrypted. */
+    encrypted?: boolean;
     id: string;
     name: string;
     workingDirectory: string;
@@ -55,12 +57,17 @@ export interface SessionMessage {
     timestamp: string;
     toolCallName?: string;
     toolCallSuccess?: boolean;
+    toolCall?: ChatEntry['toolCall'];
+    toolCalls?: ChatEntry['toolCalls'];
+    toolResult?: ChatEntry['toolResult'];
+    truncated?: boolean;
     /** Task state for cross-session continuity */
     taskState?: Record<string, unknown>;
 }
 export interface SessionStoreConfig {
     /** Use SQLite database instead of JSON files */
     useSQLite: boolean;
+    encryptionKeyPath?: string;
 }
 /**
  * Session Store for persisting and restoring chat sessions
@@ -102,6 +109,8 @@ export declare class SessionStore {
      * unprotected. Callers MUST hold the session lock before invoking this.
      */
     private writeSessionUnlocked;
+    private shouldEncrypt;
+    private decodeContent;
     /**
      * Load a session from disk.
      *