@vybestack/llxprt-code-core 0.10.0 → 0.11.0-nightly.260728.ffaa8d5d7

package/src/recording/types.ts

@@ -25,12 +25,14 @@
 
 import { type IContent } from '../services/history/IContent.js';
 
+export const SESSION_TITLE_MAX_LENGTH = 120;
+
 // ---------------------------------------------------------------------------
 // Event type discriminator
 // ---------------------------------------------------------------------------
 
 /**
- * The seven event types that can appear in a session JSONL file.
+ * The event types that can appear in a session JSONL file.
  */
 export type SessionEventType =
   | 'session_start'
@@ -39,6 +41,7 @@ export type SessionEventType =
   | 'rewind'
   | 'provider_switch'
   | 'session_event'
+  | 'session_metadata'
   | 'directories_changed';
 
 // ---------------------------------------------------------------------------
@@ -74,6 +77,8 @@ export interface SessionStartPayload {
   sessionId: string;
   projectHash: string;
   workspaceDirs: string[];
+  /** Effective absolute working directory, when recorded by newer clients. */
+  cwd?: string;
   provider: string;
   model: string;
   /** ISO-8601 timestamp of when the session started. */
@@ -122,6 +127,19 @@ export interface SessionEventPayload {
   message: string;
 }
 
+/**
+ * Payload for the `session_metadata` event — session-level metadata updates
+ * (currently only the human-readable title). The title is tri-state:
+ * - `undefined` (field absent): legacy event, no title assertion.
+ * - `null`: explicit untitled (the caller asserts there is no meaningful title).
+ * - `string`: a concrete title.
+ *
+ * This is a typed first-class recording event, NOT a `session_event` sentinel.
+ */
+export interface SessionMetadataPayload {
+  readonly title?: string | null;
+}
+
 /**
  * Payload for the `directories_changed` event.
  */
@@ -141,6 +159,8 @@ export interface SessionRecordingServiceConfig {
   projectHash: string;
   chatsDir: string;
   workspaceDirs: string[];
+  /** Effective absolute working directory for lifecycle discovery. */
+  cwd?: string;
   provider: string;
   model: string;
 }
@@ -151,7 +171,14 @@ export interface SessionRecordingServiceConfig {
 
 /**
  * Metadata extracted from a session's `session_start` event and updated
- * by subsequent `provider_switch` / `directories_changed` events.
+ * by subsequent `provider_switch` / `directories_changed` / `session_metadata`
+ * events.
+ *
+ * The title is tri-state:
+ * - `undefined`: no `session_metadata` event seen (legacy file). Callers fall
+ *   back to first-human-text heuristics.
+ * - `null`: explicit untitled (`session_metadata` asserted no title).
+ * - `string`: a concrete title.
  */
 export interface SessionMetadata {
   sessionId: string;
@@ -159,7 +186,9 @@ export interface SessionMetadata {
   provider: string;
   model: string;
   workspaceDirs: string[];
+  cwd?: string;
   startTime: string;
+  title?: string | null;
 }
 
 /**
@@ -199,4 +228,17 @@ export interface SessionSummary {
   fileSize: number;
   provider: string;
   model: string;
+  cwd?: string;
+  /**
+   * Tri-state title from a persisted `session_metadata` event:
+   * - `undefined`: no `session_metadata` event seen (legacy fallback).
+   * - `null`: explicit untitled.
+   * - `string`: a concrete title.
+   */
+  title?: string | null;
+  /**
+   * Immutable creation timestamp extracted from `session_start.startTime`.
+   * Used for stable ordering independent of file `lastModified` mutations.
+   */
+  createdAt?: string;
 }

package/src/runtime/AgentRuntimeLoader.ts

@@ -109,6 +109,7 @@ function hydrateContentGeneratorConfig(
 
 type ToolGovernance = {
   allowed: Set<string>;
+  allowedExplicit: boolean;
   disabled: Set<string>;
   excluded: Set<string>;
 };
@@ -128,6 +129,7 @@ function buildToolGovernance(
     allowed: new Set(
       (allowedRaw ?? []).map((tool) => normalizeToolName(tool) ?? tool),
     ),
+    allowedExplicit: allowedRaw !== undefined,
     disabled: new Set(
       (disabledRaw ?? []).map((tool) => normalizeToolName(tool) ?? tool),
     ),
@@ -148,7 +150,7 @@ function isToolPermitted(
   if (governance.disabled.has(canonical)) {
     return false;
   }
-  if (governance.allowed.size > 0 && !governance.allowed.has(canonical)) {
+  if (governance.allowedExplicit && !governance.allowed.has(canonical)) {
     return false;
   }
   return true;

package/src/scheduler/liveOutput.ts

@@ -4,36 +4,39 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import type { AnsiOutput } from '../utils/terminalSerializer.js';
+import type {
+  AnsiOutput,
+  LiveOutputUpdate,
+} from '../utils/terminalSerializer.js';
 
 /**
- * Accumulates a live-output chunk onto an existing value.
+ * Accumulates a live-output update onto an existing accumulated value using
+ * the explicit tagged {@link LiveOutputUpdate} protocol.
  *
- * Tools that stream via `canUpdateOutput` deliver chunks in one of two
- * semantics:
- *
- * - **`AnsiOutput`** (e.g. the shell tool) — a full terminal-buffer snapshot.
- *   Each chunk supersedes the previous one, so the latest snapshot replaces
- *   the old value.
- * - **`string`** (e.g. the task tool streaming subagent text) — an incremental
- *   delta.  Each chunk must be appended to the existing text so the display
- *   grows rather than showing only the latest token.
+ * - **`append`** (text deltas) — concatenated onto the existing value when it
+ *   is a string; otherwise the prior non-string value is dropped and the
+ *   delta starts a fresh string.
+ * - **`replace`** (terminal-buffer snapshots) — supersedes any prior value.
  *
  * The `existing` parameter is typed `unknown` because callers may pass values
  * drawn from a broader display union (e.g. `ToolResultDisplay`, which also
- * includes `FileDiff` / `FileRead`).  The function only ever appends when both
- * values are strings; any other combination replaces with the incoming chunk.
- *
- * Note: the append-vs-replace distinction is currently inferred from the
- * payload type.  Migrating to an explicit tagged update protocol (e.g.
- * `{ mode: 'append'; data: string } | { mode: 'replace'; data: AnsiOutput }`)
- * is tracked in follow-up #2586.
+ * includes `FileDiff` / `FileRead`). The returned type is the narrow
+ * `string | AnsiOutput` union the live-output channel actually produces.
  */
 export function accumulateLiveOutput(
   existing: unknown,
-  chunk: string | AnsiOutput,
+  update: LiveOutputUpdate,
 ): string | AnsiOutput {
-  return typeof chunk === 'string' && typeof existing === 'string'
-    ? existing + chunk
-    : chunk;
+  switch (update.mode) {
+    case 'append':
+      return typeof existing === 'string'
+        ? existing + update.data
+        : update.data;
+    case 'replace':
+      return update.data;
+    default: {
+      const _exhaustive: never = update;
+      return _exhaustive;
+    }
+  }
 }

package/src/scheduler/types.ts

@@ -22,7 +22,10 @@ import type {
   ToolCallResponseInfo,
 } from '../core/turn.js';
 import type { ToolConfirmationOutcome } from '@vybestack/llxprt-code-tools';
-import type { AnsiOutput } from '../utils/terminalSerializer.js';
+import type {
+  AnsiOutput,
+  LiveOutputUpdate,
+} from '../utils/terminalSerializer.js';
 import type { SerializableConfirmationDetails } from '../confirmation-bus/types.js';
 
 /**
@@ -142,7 +145,7 @@ export type ConfirmHandler = (
 
 export type OutputUpdateHandler = (
   toolCallId: string,
-  outputChunk: string | AnsiOutput,
+  update: LiveOutputUpdate,
 ) => void;
 
 export type AllToolCallsCompleteHandler = (

package/src/services/history/ContentConverters.ts

@@ -73,77 +73,92 @@ export class ContentConverters {
     return 'model';
   }
 
+  private static toolCallBlockToPart(
+    toolCall: Extract<ContentBlock, { type: 'tool_call' }>,
+  ): GeminiContentPart {
+    this.logger.debug('Converting tool_call block to functionCall:', {
+      id: toolCall.id,
+      name: toolCall.name,
+      hasParameters: ContentConverters.hasLegacyTruthyValue(
+        toolCall.parameters,
+      ),
+    });
+    return {
+      functionCall: {
+        name: toolCall.name,
+        args: toolCall.parameters as Record<string, unknown>,
+        id: toolCall.id,
+      },
+    };
+  }
+
+  private static toolResponseBlockToPart(
+    toolResponse: Extract<ContentBlock, { type: 'tool_response' }>,
+  ): GeminiContentPart {
+    this.logger.debug('Converting tool_response block to functionResponse:', {
+      callId: toolResponse.callId,
+      toolName: toolResponse.toolName,
+      hasResult: ContentConverters.hasLegacyTruthyValue(toolResponse.result),
+      hasError: ContentConverters.hasLegacyTruthyValue(toolResponse.error),
+    });
+    return {
+      functionResponse: {
+        name: toolResponse.toolName,
+        response: toolResponse.result as Record<string, unknown>,
+        id: toolResponse.callId,
+      },
+    };
+  }
+
+  private static thinkingBlockToPart(
+    thinkingBlock: Extract<ContentBlock, { type: 'thinking' }>,
+  ): GeminiContentPart {
+    const thinkingPart: GeminiContentPart = {
+      thought: true,
+      text: thinkingBlock.thought,
+    };
+    if (ContentConverters.hasLegacyTruthyValue(thinkingBlock.signature)) {
+      thinkingPart.thoughtSignature = thinkingBlock.signature;
+    }
+    if (ContentConverters.hasLegacyTruthyValue(thinkingBlock.sourceField)) {
+      thinkingPart.llxprtSourceField = thinkingBlock.sourceField;
+    }
+    if (ContentConverters.hasLegacyTruthyValue(thinkingBlock.streamId)) {
+      thinkingPart.llxprtThoughtBlockId = thinkingBlock.streamId;
+    }
+    if (ContentConverters.hasLegacyTruthyValue(thinkingBlock.streamStatus)) {
+      thinkingPart.llxprtThoughtBlockStatus = thinkingBlock.streamStatus;
+    }
+    if (thinkingBlock.isHidden !== undefined) {
+      thinkingPart.llxprtThoughtIsHidden = thinkingBlock.isHidden;
+    }
+    return thinkingPart;
+  }
+
+  private static codeBlockToPart(
+    codeBlock: Extract<ContentBlock, { type: 'code' }>,
+  ): GeminiContentPart {
+    const codeText = codeBlock.language
+      ? `\`\`\`${codeBlock.language}\n${codeBlock.code}\n\`\`\``
+      : codeBlock.code;
+    return { text: codeText };
+  }
+
   /** Convert a single IContent block to a Gemini Part. */
   private static blockToPart(block: ContentBlock): GeminiContentPart | null {
     switch (block.type) {
-      case 'text': {
-        const textBlock = block;
-        return { text: textBlock.text };
-      }
-      case 'tool_call': {
-        const toolCall = block;
-        this.logger.debug('Converting tool_call block to functionCall:', {
-          id: toolCall.id,
-          name: toolCall.name,
-          hasParameters: ContentConverters.hasLegacyTruthyValue(
-            toolCall.parameters,
-          ),
-        });
-        return {
-          functionCall: {
-            name: toolCall.name,
-            args: toolCall.parameters as Record<string, unknown>,
-            id: toolCall.id,
-          },
-        };
-      }
-      case 'tool_response': {
-        const toolResponse = block;
-        this.logger.debug(
-          'Converting tool_response block to functionResponse:',
-          {
-            callId: toolResponse.callId,
-            toolName: toolResponse.toolName,
-            hasResult: ContentConverters.hasLegacyTruthyValue(
-              toolResponse.result,
-            ),
-            hasError: ContentConverters.hasLegacyTruthyValue(
-              toolResponse.error,
-            ),
-          },
-        );
-        return {
-          functionResponse: {
-            name: toolResponse.toolName,
-            response: toolResponse.result as Record<string, unknown>,
-            id: toolResponse.callId,
-          },
-        };
-      }
-      case 'thinking': {
-        const thinkingBlock = block;
-        const thinkingPart: GeminiContentPart = {
-          thought: true,
-          text: thinkingBlock.thought,
-        };
-        if (ContentConverters.hasLegacyTruthyValue(thinkingBlock.signature)) {
-          thinkingPart.thoughtSignature = thinkingBlock.signature;
-        }
-        if (ContentConverters.hasLegacyTruthyValue(thinkingBlock.sourceField)) {
-          thinkingPart.llxprtSourceField = thinkingBlock.sourceField;
-        }
-        return thinkingPart;
-      }
-      case 'media': {
+      case 'text':
+        return { text: block.text };
+      case 'tool_call':
+        return this.toolCallBlockToPart(block);
+      case 'tool_response':
+        return this.toolResponseBlockToPart(block);
+      case 'thinking':
+        return this.thinkingBlockToPart(block);
+      case 'media':
         return null;
-      }
-      case 'code': {
-        const codeBlock = block;
-        const codeText = codeBlock.language
-          ? `\`\`\`${codeBlock.language}\n${codeBlock.code}\n\`\`\``
-          : codeBlock.code;
-        return { text: codeText };
-      }
+      case 'code':
+        return this.codeBlockToPart(block);
       default:
         return null;
     }
@@ -201,12 +216,20 @@ export class ContentConverters {
     const thinkingBlock: ThinkingBlock = {
       type: 'thinking',
       thought: part.text ?? '',
-      isHidden: true,
       sourceField,
     };
+    if (part.llxprtThoughtIsHidden !== undefined) {
+      thinkingBlock.isHidden = part.llxprtThoughtIsHidden;
+    }
     if (part.thoughtSignature) {
       thinkingBlock.signature = part.thoughtSignature;
     }
+    if (part.llxprtThoughtBlockId) {
+      thinkingBlock.streamId = part.llxprtThoughtBlockId;
+    }
+    if (part.llxprtThoughtBlockStatus) {
+      thinkingBlock.streamStatus = part.llxprtThoughtBlockStatus;
+    }
     return thinkingBlock;
   }
 

package/src/services/history/HistoryService.ts

@@ -14,7 +14,11 @@
  * limitations under the License.
  */
 
-import { type IContent, type ToolCallBlock } from './IContent.js';
+import {
+  type IContent,
+  type ToolCallBlock,
+  type ToolResponseBlock,
+} from './IContent.js';
 import { EventEmitter } from 'events';
 // @plan:PLAN-20260603-ISSUE1584.P05 RuntimeTokenizerFactory used for injection path
 import type { RuntimeTokenizerFactory } from '../../runtime/contracts/RuntimeTokenizerFactory.js';
@@ -437,6 +441,93 @@ export class HistoryService
     await this.recalculateTotalTokens();
   }
 
+  /**
+   * Immutably replace a single tool_response block with a replacement
+   * tool_response block, preserving callId/toolName invariants.
+   *
+   * Unlike a generic block-replacement API, this method enforces structural
+   * invariants that compression/truncation callers rely on:
+   *   - The target block at (entryIndex, blockIndex) MUST be a tool_response.
+   *   - The replacement MUST be a tool_response.
+   *   - The replacement MUST carry the same callId and toolName as the target.
+   * This prevents accidental corruption of tool-call/response pairing.
+   */
+  async replaceToolResponseBlock(
+    entryIndex: number,
+    blockIndex: number,
+    replacement: ToolResponseBlock,
+    modelName?: string,
+  ): Promise<boolean> {
+    if (
+      !Number.isInteger(entryIndex) ||
+      entryIndex < 0 ||
+      entryIndex >= this.history.length
+    ) {
+      return false;
+    }
+    const entry = this.history[entryIndex];
+    if (
+      !Number.isInteger(blockIndex) ||
+      blockIndex < 0 ||
+      blockIndex >= entry.blocks.length
+    ) {
+      return false;
+    }
+
+    const target = entry.blocks[blockIndex];
+    if (target.type !== 'tool_response') {
+      return false;
+    }
+    // Runtime invariant: the replacement MUST be a tool_response at runtime,
+    // even though the TypeScript type already constrains it. A malformed
+    // object with matching callId/toolName but wrong type (or missing type)
+    // could slip through at runtime and corrupt tool-call/response pairing.
+    const replacementType = (replacement as { type?: unknown }).type;
+    if (replacementType !== 'tool_response') {
+      return false;
+    }
+    if (
+      target.callId !== replacement.callId ||
+      target.toolName !== replacement.toolName
+    ) {
+      return false;
+    }
+
+    const newBlocks = [...entry.blocks];
+    newBlocks[blockIndex] = replacement;
+    const previousEntry = this.history[entryIndex];
+    const previousTotalTokens = this.totalTokens;
+    this.history[entryIndex] = { ...entry, blocks: newBlocks };
+
+    try {
+      await this.recalculateTotalTokens(modelName);
+    } catch (error) {
+      // Restore BOTH invariants: the history array AND the token accounting.
+      // recalculateTotalTokens may have already mutated this.totalTokens to
+      // reflect the replacement content before a listener/event error aborted
+      // the emit. Leaving totalTokens stale would corrupt the token budget.
+      this.history[entryIndex] = previousEntry;
+      this.totalTokens = previousTotalTokens;
+      // Best-effort notification so healthy listeners observe the rollback.
+      // A broken listener that originally caused the failure must not mask
+      // the original error.
+      try {
+        this.emit('tokensUpdated', {
+          totalTokens: this.getTotalTokens(),
+          addedTokens: 0,
+          contentId: null,
+        });
+      } catch (emitError) {
+        this.logger.debug(
+          'tokensUpdated emit during rollback failed; original error preserved',
+          emitError,
+        );
+      }
+      throw error;
+    }
+    return true;
+  }
+
   /**
    * Return a read-only typed view of the backing history array.
    *

package/src/services/history/IContent.ts

@@ -55,6 +55,13 @@ export interface ContentMetadata {
   /** Unique identifier for this content */
   id?: string;
 
+  /**
+   * Whether this AI turn was persisted server-side (e.g. OpenAI Responses
+   * API store=true). When true the id is safe to reference via
+   * previous_response_id for stateful conversations (#207).
+   */
+  responsesStored?: boolean;
+
   /** Provider that generated this content */
   provider?: string;
 
@@ -244,6 +251,12 @@ export interface ThinkingBlock {
   /** Signature for Anthropic extended thinking */
   signature?: string;
 
+  /** Provider-scoped stream identity for replacing incremental thinking updates */
+  streamId?: string;
+
+  /** Whether this block is an incremental update or the completed thinking block */
+  streamStatus?: 'delta' | 'complete';
+
   /** Base64-encoded reasoning content (for OpenAI Codex/Responses API) */
   encryptedContent?: string;
 

package/src/skills/skillManager.ts

@@ -108,7 +108,17 @@ export class SkillManager {
 
   /**
    * Discovers skills from built-in, extension, user and workspace locations.
-   * Precedence: Built-in (lowest) -> Extensions -> User -> Workspace (highest).
+   *
+   * Load order (later loads win for same-named skills):
+   * 1. Built-in
+   * 2. Extensions
+   * 3. User `<OS-standard-config-dir>/skills/`
+   * 4. User `~/.agents/skills/` (cross-tool standard, https://agentskills.io)
+   * 5. Workspace `.llxprt/skills/`
+   * 6. Workspace `.agents/skills/` (highest precedence)
+   *
+   * The overall Workspace > User > Extension > Built-in precedence is
+   * preserved, while `.agents/skills/` wins within each user or workspace tier.
    */
   async discoverSkills(
     storage: Storage,
@@ -143,6 +153,16 @@ export class SkillManager {
       'user',
     );
     this.addSkillsWithPrecedence(userSkills);
+    try {
+      const userAgentSkills = await loadSkillsFromDir(
+        Storage.getUserAgentSkillsDir(),
+        'user',
+      );
+      this.addSkillsWithPrecedence(userAgentSkills);
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      debugLogger.warn(`Skipping user .agents/skills discovery: ${reason}`);
+    }
 
     // 4. Workspace skills (highest precedence)
     const projectSkills = await loadSkillsFromDir(
@@ -150,6 +170,11 @@ export class SkillManager {
       'project',
     );
     this.addSkillsWithPrecedence(projectSkills);
+    const projectAgentSkills = await loadSkillsFromDir(
+      storage.getProjectAgentSkillsDir(),
+      'project',
+    );
+    this.addSkillsWithPrecedence(projectAgentSkills);
   }
 
   /**

package/src/test-utils/mock-tool.ts

@@ -9,6 +9,7 @@ import type {
   ToolCallConfirmationDetails,
   ToolInvocation,
   ToolResult,
+  LiveOutputUpdate,
 } from '@vybestack/llxprt-code-tools';
 import {
   BaseDeclarativeTool,
@@ -33,7 +34,7 @@ interface MockToolOptions {
   execute?: (
     params: { [key: string]: unknown },
     signal: AbortSignal,
-    updateOutput?: (output: string) => void,
+    updateOutput?: (update: LiveOutputUpdate) => void,
   ) => Promise<ToolResult>;
   params?: object;
   messageBus?: IToolMessageBus;
@@ -64,7 +65,7 @@ class MockToolInvocation extends BaseToolInvocation<
 
   execute(
     signal: AbortSignal,
-    updateOutput?: (output: string) => void,
+    updateOutput?: (update: LiveOutputUpdate) => void,
   ): Promise<ToolResult> {
     return this.tool.executeFn(this.params, signal, updateOutput);
   }
@@ -86,7 +87,7 @@ class MockToolInvocation extends BaseToolInvocation<
 type ExecuteFn = (
   params: { [key: string]: unknown },
   signal: AbortSignal,
-  updateOutput?: (output: string) => void,
+  updateOutput?: (update: LiveOutputUpdate) => void,
 ) => Promise<ToolResult>;
 
 type ExecuteMock = ReturnType<typeof vi.fn<ExecuteFn>>;

package/src/test-utils/tools.ts

@@ -12,6 +12,7 @@ import {
   type ToolCallConfirmationDetails,
   type ToolInvocation,
   type ToolResult,
+  type LiveOutputUpdate,
   Kind,
 } from '@vybestack/llxprt-code-tools';
 import { MessageBus } from '../confirmation-bus/message-bus.js';
@@ -61,7 +62,7 @@ async function executeMockTool(
   tool: { name: string; executeFn: ToolSpy },
   params: Record<string, unknown>,
   abortSignal: AbortSignal,
-  updateOutput?: (output: string) => void,
+  updateOutput?: (update: LiveOutputUpdate) => void,
 ): Promise<ToolResult> {
   const result = await tool.executeFn(params, abortSignal, updateOutput);
   if (isToolResultLike(result)) {
@@ -87,7 +88,7 @@ class MockToolInvocation extends BaseToolInvocation<
 
   async execute(
     abortSignal: AbortSignal,
-    updateOutput?: (output: string) => void,
+    updateOutput?: (update: LiveOutputUpdate) => void,
   ): Promise<ToolResult> {
     return executeMockTool(this.tool, this.params, abortSignal, updateOutput);
   }
@@ -168,7 +169,7 @@ export class MockModifiableToolInvocation extends BaseToolInvocation<
 
   async execute(
     abortSignal: AbortSignal,
-    updateOutput?: (output: string) => void,
+    updateOutput?: (update: LiveOutputUpdate) => void,
   ): Promise<ToolResult> {
     return executeMockTool(this.tool, this.params, abortSignal, updateOutput);
   }

package/src/tools-adapters/CoreShellToolHostAdapter.ts

@@ -224,13 +224,7 @@ export class CoreShellToolHostAdapter implements IShellToolHost {
   private mapOutputEvent(event: ShellOutputEvent): ToolsShellOutputEvent {
     switch (event.type) {
       case 'data':
-        return {
-          type: 'data',
-          chunk:
-            typeof event.chunk === 'string'
-              ? event.chunk
-              : JSON.stringify(event.chunk),
-        };
+        return { type: 'data', chunk: event.chunk };
       case 'binary_detected':
         return { type: 'binary_detected' };
       case 'binary_progress':