@phnx-labs/agents-cli 1.21.2 → 1.21.3

package/dist/lib/session/parse.js

@@ -9,7 +9,7 @@ import * as fs from 'fs';
 import { truncate } from '../format.js';
 import * as path from 'path';
 import Database from '../sqlite.js';
-import { isSyntheticUserMessage } from './prompt.js';
+import { isSyntheticUserMessage, extractSlashCommandName, extractSlashCommandFromToolInput } from './prompt.js';
 /**
  * Largest session file we will load into memory. Above this we throw a clean
  * error instead of OOMing or hitting V8's ERR_STRING_TOO_LONG. Aligns with
@@ -379,6 +379,14 @@ export function parseClaudeContent(content) {
                     };
                     if (isLocal)
                         event._local = true;
+                    // SlashCommand: the MODEL invoking a slash command programmatically
+                    // (distinct from the <command-name> wrapper below, which is the
+                    // USER typing one) — see prompt.ts's extractSlashCommandFromToolInput.
+                    if (toolName === 'SlashCommand') {
+                        const slashCommand = extractSlashCommandFromToolInput(toolInput);
+                        if (slashCommand)
+                            event.slashCommand = slashCommand;
+                    }
                     events.push(event);
                 }
             }
@@ -403,13 +411,21 @@ export function parseClaudeContent(content) {
                 // Simple user text
                 const text = contentBlocks.trim();
                 if (text) {
-                    events.push({
+                    const event = {
                         type: 'message',
                         agent: 'claude',
                         timestamp,
                         role: 'user',
                         content: text,
-                    });
+                    };
+                    // The USER typing a slash command — Claude injects a <command-name>
+                    // wrapper as the message content (see prompt.ts's
+                    // extractSlashCommandName; distinct from the SlashCommand tool-use
+                    // above, which is the model invoking one programmatically).
+                    const slashCommand = extractSlashCommandName(text);
+                    if (slashCommand)
+                        event.slashCommand = slashCommand;
+                    events.push(event);
                 }
             }
             else if (Array.isArray(contentBlocks)) {

package/dist/lib/session/prompt.d.ts

@@ -12,6 +12,25 @@
  * own scaffolding at parse time simply never reach here.
  */
 export declare function isSyntheticUserMessage(raw: string | undefined): boolean;
+/**
+ * Extract the invoked slash-command name from a raw `role=user` message, or
+ * undefined when the message carries no `<command-name>` wrapper. Used by
+ * `parseClaudeContent` to populate `SessionEvent.slashCommand`.
+ *
+ * Normalizes a leading `/` onto the result: current Claude Code wraps the
+ * name WITH the slash already (`/recap`), but the wrapper predates that and
+ * older transcripts carry the bare name (`recap`) — normalizing here means
+ * every consumer sees one consistent `/name` shape regardless of vintage.
+ */
+export declare function extractSlashCommandName(raw: string | undefined): string | undefined;
+/**
+ * Extract the invoked slash-command name from the `SlashCommand` tool's input
+ * — the MODEL invoking a command programmatically, not the user typing it.
+ * The tool's `command` field carries the full invocation text (name plus any
+ * args, e.g. `/code:commit fix the bug`); only the leading command token is
+ * the name, matching {@link extractSlashCommandName}'s shape.
+ */
+export declare function extractSlashCommandFromToolInput(toolInput: Record<string, any> | undefined): string | undefined;
 export declare const HEADLESS_PLAN_MODE_PREFIX = "You are running in HEADLESS PLAN MODE.";
 /** Strip framework noise from a raw session prompt, returning only meaningful user text. */
 export declare function cleanSessionPrompt(raw: string): string;

package/dist/lib/session/prompt.js

@@ -63,6 +63,49 @@ export function isSyntheticUserMessage(raw) {
         return false;
     return SYNTHETIC_USER_MESSAGE_PATTERNS.some(pattern => pattern.test(raw));
 }
+/**
+ * The `<command-name>` wrapper Claude injects into a `role=user` message when
+ * a typed slash command is invoked, e.g.:
+ *   <command-message>recap</command-message>
+ *   <command-name>/recap</command-name>
+ * Captures the name INCLUDING its leading slash (`/recap`), matching how the
+ * `SlashCommand` tool's own `command` input is formatted (see
+ * `extractSlashCommandFromToolInput`) so both sources land on the same shape.
+ */
+const COMMAND_NAME_WRAPPER_RE = /<command-name>\s*([^<]*?)\s*<\/command-name>/i;
+/**
+ * Extract the invoked slash-command name from a raw `role=user` message, or
+ * undefined when the message carries no `<command-name>` wrapper. Used by
+ * `parseClaudeContent` to populate `SessionEvent.slashCommand`.
+ *
+ * Normalizes a leading `/` onto the result: current Claude Code wraps the
+ * name WITH the slash already (`/recap`), but the wrapper predates that and
+ * older transcripts carry the bare name (`recap`) — normalizing here means
+ * every consumer sees one consistent `/name` shape regardless of vintage.
+ */
+export function extractSlashCommandName(raw) {
+    if (!raw)
+        return undefined;
+    const m = raw.match(COMMAND_NAME_WRAPPER_RE);
+    const name = m?.[1]?.trim();
+    if (!name)
+        return undefined;
+    return name.startsWith('/') ? name : `/${name}`;
+}
+/**
+ * Extract the invoked slash-command name from the `SlashCommand` tool's input
+ * — the MODEL invoking a command programmatically, not the user typing it.
+ * The tool's `command` field carries the full invocation text (name plus any
+ * args, e.g. `/code:commit fix the bug`); only the leading command token is
+ * the name, matching {@link extractSlashCommandName}'s shape.
+ */
+export function extractSlashCommandFromToolInput(toolInput) {
+    const command = toolInput?.command;
+    if (typeof command !== 'string')
+        return undefined;
+    const name = command.trim().split(/\s+/)[0];
+    return name || undefined;
+}
 // Prefix prepended to every Claude-in-plan-mode team spawn prompt.
 // Ends at a blank line before the real user task.
 export const HEADLESS_PLAN_MODE_PREFIX = 'You are running in HEADLESS PLAN MODE.';

package/dist/lib/session/types.d.ts

@@ -52,6 +52,15 @@ export interface SessionEvent {
     hookName?: string;
     /** Lifecycle event the hook fired on (SessionStart, PreToolUse, …). */
     hookEvent?: string;
+    /**
+     * Slash-command invocation name (e.g. `/recap`, `/code:commit`), captured
+     * two ways in a Claude transcript: a `role=user` message whose content is
+     * the `<command-name>` wrapper Claude injects for a typed slash command
+     * (`parseClaudeContent`, see `prompt.ts`'s `extractSlashCommandName`), or a
+     * `tool_use` event for the `SlashCommand` tool (a command the MODEL invoked
+     * programmatically, not the user). Undefined for every other event.
+     */
+    slashCommand?: string;
 }
 /** A displayable file attachment discovered in a session transcript. */
 export interface SessionAttachment {
@@ -186,6 +195,39 @@ export interface SessionMeta {
     todos?: TodoProgress;
     /** Most-recent unique directories changed or used as a shell working directory. */
     recentDirectoriesTouched?: string[];
+    /**
+     * Skills invoked during the session (structurally identical to
+     * session/highlights.ts's SkillUse — declared inline here rather than
+     * imported, to avoid a circular import: highlights.ts imports SessionEvent
+     * from this file). Populated by discover.ts's incremental Claude
+     * accumulator (ClaudeParseState.skillEvents, run through extractSkills at
+     * finalize) so session/db.ts's upsertSessionsBatch can write
+     * session_resource_usage rows WITHOUT re-parsing the whole transcript —
+     * the same reason meta.todos/recentDirectoriesTouched are pre-computed by
+     * the caller for claude/codex instead of left to db.ts's re-parse path.
+     */
+    skillsUsed?: Array<{
+        name: string;
+        count: number;
+    }>;
+    /** Sibling of {@link skillsUsed} for slash-command invocations (SessionEvent.slashCommand). */
+    slashCommandsUsed?: Array<{
+        name: string;
+        count: number;
+    }>;
+    /**
+     * Whether this session emitted at least one `browser.navigate` /
+     * `browser.screenshot` event, computed at scan time from a sessionId-scoped
+     * read of the events log (events.ts `query({ sessionId })`) rather than a
+     * transcript re-scan — see `detectToolUsage` in session/db.ts. `undefined`
+     * means a legacy row this scanner hasn't computed the field for yet (never
+     * collapsed to `false`, so a consumer — e.g. sessions-picker.ts's
+     * `classifySessionTool` — knows to fall back to a transcript-derived guess
+     * instead of trusting a false negative).
+     */
+    usedBrowser?: boolean;
+    /** Sibling of {@link usedBrowser} for `computer.action` events. */
+    usedComputer?: boolean;
     /** Linear project containing ticketId, resolved lazily and cached in SQLite. */
     linearProject?: string;
     /** Browser URL for linearProject. */

package/dist/lib/types.d.ts

@@ -605,6 +605,20 @@ export interface DiscoveredPlugin {
      * (e.g. workflow-scoped) — those default to the user marketplace on sync.
      */
     marketplace?: string;
+    /**
+     * Absolute path to the DotAgents repo root containing this plugin — the
+     * grandparent of `root` (`<repo>/plugins/<name>` → `<repo>`), true for every
+     * marketplace kind (user/system/extra/project). DotAgents repos are
+     * git-tracked (plugins.ts), so this pairs with {@link snapshotSha}.
+     */
+    repoRoot: string;
+    /**
+     * Short HEAD sha of `repoRoot`'s git checkout, lazily resolved (a getter,
+     * not computed at discovery time) and memoized per repoRoot
+     * (`git.ts` `resolveSnapshotSha`) — see `ResolvedResource.snapshotSha` for
+     * the identical rationale. `undefined` when `repoRoot` isn't a git repo.
+     */
+    readonly snapshotSha: string | undefined;
 }
 /**
  * Identifies one DotAgents repo that contributes a plugin marketplace. Each

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.21.2",
+  "version": "1.21.3",
   "description": "One CLI for all your AI coding agents - versions, config, cloud dispatch, sessions, and teams (now with first-class Grok Build CLI support)",
   "type": "module",
   "main": "dist/index.js",