@phnx-labs/agents-cli 1.21.2 → 1.21.3

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # Changelog
 
+## 1.21.3
+
+- **`agents projects import --from-factory` stops printing raw git errors.** Reading each
+  checkout's real remote is done per registry row, and a checkout with no `origin` makes git
+  write `error: No such remote 'origin'` straight to the terminal — its own stderr, which the
+  surrounding try/catch never sees. Importing 12 rows printed two of them between the progress
+  lines. The probe now discards git's stderr; an absent remote is an expected answer, not
+  something to report. Source: `apps/cli/src/commands/projects.ts`.
+
+- **Sessions now track browser/computer tool use and skill/plugin/slash-command
+  usage, queryable with `agents sessions --skill <name>` / `--plugin <name>`.**
+  `browser.navigate`, `browser.screenshot`, and a new `computer.action` event
+  fire on every `agents browser`/`agents computer` action, carrying session
+  identity for free. The sessions index persists `usedBrowser`/`usedComputer`
+  (from a scoped events-log read, not a transcript re-scan) and a new
+  `session_resource_usage` table records every skill and slash-command
+  invocation with its owning plugin, source repo, and git commit — resolved
+  against `resolveResource()`/`discoverPlugins()` at scan time. The sessions
+  picker preview surfaces both as `browser`/`computer` and `Skills:` tags.
+  Source: `apps/cli/src/lib/browser/service.ts`, `apps/cli/src/commands/computer-actions.ts`,
+  `apps/cli/src/lib/session/db.ts`, `apps/cli/src/lib/session/highlights.ts`,
+  `apps/cli/src/lib/session/discover.ts`, `apps/cli/src/commands/sessions.ts`.
+- **`ResolvedResource` and `DiscoveredPlugin` carry provenance: `repoRoot` and a
+  lazily-resolved `snapshotSha`.** Every resource/plugin resolution can now
+  answer "which DotAgents repo, which commit" without an extra lookup; the git
+  shell-out is memoized per repo root and only runs when a caller actually
+  reads `snapshotSha`. Source: `apps/cli/src/lib/resources.ts`,
+  `apps/cli/src/lib/plugins.ts`, `apps/cli/src/lib/git.ts`.
+- **`SessionEvent.slashCommand` captures a typed or model-invoked slash command**
+  (both the `<command-name>` wrapper and the `SlashCommand` tool call), and
+  `agents sessions`'s perf sample for `command.end` now carries the session id
+  and agent instead of being anonymous. Source: `apps/cli/src/lib/session/prompt.ts`,
+  `apps/cli/src/lib/session/parse.ts`, `apps/cli/src/index.ts`.
+
 ## 1.21.2
 
 - **`agents trends` — resource and session analytics dashboard.** Baked recipes

package/dist/commands/computer-actions.d.ts

@@ -82,4 +82,8 @@ export declare function shouldRaise(opts: {
 }): boolean;
 export declare function appPathIsElectron(appPath: string | null, exists?: (p: string) => boolean): boolean;
 export declare function electronWebviewTip(appLabel: string): string;
+export declare function emitComputerAction(verb: string, targetPid: number | undefined, opts: {
+    bundle?: string;
+    host?: string;
+}, extra?: Record<string, unknown>): void;
 export declare function registerActionCommands(program: Command): void;

package/dist/commands/computer-actions.js

@@ -11,6 +11,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { openComputerClient, describeTransport, resolvePolicyPath, } from '../lib/computer-rpc.js';
 import { COMPUTER_INPUT_GATED_VERBS, formatComputerPermissionGrantHint, } from '../lib/permissions.js';
+import { emit as emitEvent } from '../lib/events.js';
 function isComputerInputVerb(verb) {
     return typeof verb === 'string' && COMPUTER_INPUT_GATED_VERBS.includes(verb);
 }
@@ -350,6 +351,22 @@ function emit(result, json, human) {
         console.log(human());
     }
 }
+// Record one `computer.action` per verb invocation, one call site per command
+// below. Session/agent/machine identity is stamped for free by emitEvent's
+// provenance floor (events.ts resolveProvenance) — this only carries the
+// action-specific facts: which verb, against which target pid/bundle/host.
+// NOTE: the field is `targetPid`, never `pid` — `pid` is a reserved envelope
+// key (the emitting process's OWN pid, events.ts RESERVED_META_KEYS) that
+// sanitizePayload() silently strips from the payload before it can collide.
+export function emitComputerAction(verb, targetPid, opts, extra = {}) {
+    emitEvent('computer.action', {
+        command: verb,
+        targetPid,
+        bundle: opts.bundle,
+        host: opts.host,
+        ...extra,
+    });
+}
 // Add the shared --pid/--bundle/--host target options to a verb. `--host` routes
 // the verb at a remote Windows device: the `computer` preAction hook hydrates
 // COMPUTER_HELPER_TCP from the tunnel `start --host` recorded, so withClient's
@@ -376,6 +393,7 @@ export function registerActionCommands(program) {
         await withClient(async (client) => {
             const res = unwrap(await client.call('list_apps'));
             const list = res.apps || [];
+            emitComputerAction('apps', undefined, opts);
             emit(res, Boolean(opts.json), () => list.length === 0
                 ? '(no allow-listed apps running)'
                 : list
@@ -422,6 +440,7 @@ export function registerActionCommands(program) {
             if (opts.background)
                 params.background = true;
             const res = unwrap(await client.call('click', params));
+            emitComputerAction('click', pid, opts, { id: opts.id, count: opts.count });
             emit(res, Boolean(opts.json), () => `clicked (${res.action ?? 'ok'})`);
         });
     });
@@ -440,6 +459,7 @@ export function registerActionCommands(program) {
             }
             await applyFocusPolicy(client, pid, opts);
             const res = unwrap(await client.call('right_click', { pid, ...spec.params }));
+            emitComputerAction('right-click', pid, opts, { id: opts.id });
             emit(res, Boolean(opts.json), () => `right-clicked (${res.method ?? 'ok'})`);
         });
     });
@@ -466,6 +486,8 @@ export function registerActionCommands(program) {
             if (opts.allowSecureField)
                 params.allow_secure_field = true;
             const res = unwrap(await client.call('type', params));
+            // textLength, never the text itself — users type passwords/secrets into fields.
+            emitComputerAction('type', pid, opts, { id: opts.id, textLength: opts.text.length, committed: Boolean(res.committed) });
             emit(res, Boolean(opts.json), () => `typed ${opts.text.length} char(s)${res.committed ? ' (committed)' : ''}`);
         });
     });
@@ -493,6 +515,7 @@ export function registerActionCommands(program) {
                 params.char_delay_ms = charDelay;
             const res = unwrap(await client.call('type_text', params));
             warnIfNotFrontmost(res);
+            emitComputerAction('type-text', pid, opts, { textLength: opts.text.length, committed: Boolean(opts.commit) });
             emit(res, Boolean(opts.json), () => `typed ${res.chars ?? opts.text.length} char(s)`);
         });
     });
@@ -513,6 +536,7 @@ export function registerActionCommands(program) {
                 params.require_frontmost = true;
             const res = unwrap(await client.call('key', params));
             warnIfNotFrontmost(res);
+            emitComputerAction('key', pid, opts, { keys: opts.keys });
             emit(res, Boolean(opts.json), () => `sent ${opts.keys}`);
         });
     });
@@ -548,6 +572,7 @@ export function registerActionCommands(program) {
             if (opts.background)
                 params.background = true;
             const res = unwrap(await client.call('drag', params));
+            emitComputerAction('drag', pid, opts, { from: opts.from, to: opts.to });
             emit(res, Boolean(opts.json), () => `dragged ${opts.from} -> ${opts.to} (${res.method ?? 'ok'})`);
         });
     });
@@ -574,6 +599,7 @@ export function registerActionCommands(program) {
             if (opts.dx != null)
                 params.dx = opts.dx;
             const res = unwrap(await client.call('scroll', params));
+            emitComputerAction('scroll', pid, opts, { id: opts.id, dx: opts.dx, dy: opts.dy });
             emit(res, Boolean(opts.json), () => `scrolled (${res.method ?? 'ok'})`);
         });
     });
@@ -587,6 +613,7 @@ export function registerActionCommands(program) {
         await withClient(async (client) => {
             const pid = await resolveTargetPid(client, opts, { verb: 'ax-action' });
             const res = unwrap(await client.call('ax_action', { pid, element_id: opts.id, action: opts.action }));
+            emitComputerAction('ax-action', pid, opts, { id: opts.id, action: opts.action });
             emit(res, Boolean(opts.json), () => `performed ${opts.action}`);
         });
     });
@@ -599,6 +626,7 @@ export function registerActionCommands(program) {
         await withClient(async (client) => {
             const pid = await resolveTargetPid(client, opts, { verb: 'focus' });
             const res = unwrap(await client.call('set_focus', { pid, element_id: opts.id }));
+            emitComputerAction('focus', pid, opts, { id: opts.id });
             emit(res, Boolean(opts.json), () => `focused ${opts.id}`);
         });
     });
@@ -615,6 +643,7 @@ export function registerActionCommands(program) {
         await withClient(async (client) => {
             const pid = await resolveTargetPid(client, opts, { verb: 'raise' });
             const res = unwrap(await client.call('focus_window', { pid, ...buildRaiseParams(opts) }));
+            emitComputerAction('raise', pid, opts, { windowId: opts.windowId, title: opts.title });
             emit(res, Boolean(opts.json), () => {
                 const scope = res.raised_window ? `window ${res.title ?? res.window_id ?? ''}`.trim() : 'app';
                 return `raised ${scope} (${res.focus_elapsed_ms ?? 0}ms)`;
@@ -644,6 +673,9 @@ export function registerActionCommands(program) {
             if (params.duration_ms == null)
                 params.pid = await resolveTargetPid(client, opts, { verb: 'wait' });
             const res = unwrap(await client.call('wait', params));
+            emitComputerAction('wait', params.pid, opts, {
+                until: opts.until, durationMs: opts.duration, satisfied: Boolean(res.satisfied),
+            });
             emit(res, Boolean(opts.json), () => res.satisfied ? `satisfied (${res.waited_ms}ms)` : `timed out (${res.waited_ms}ms)`);
         });
     });
@@ -662,6 +694,7 @@ export function registerActionCommands(program) {
             if (opts.maxChars != null)
                 params.max_chars = opts.maxChars;
             const res = unwrap(await client.call('get_text', params));
+            emitComputerAction('get-text', pid, opts, { id: opts.id });
             emit(res, Boolean(opts.json), () => String(res.text ?? ''));
         });
     });
@@ -688,6 +721,7 @@ export function registerActionCommands(program) {
             if (opts.name)
                 params.name = opts.name;
             const res = unwrap(await client.call('launch_app', params));
+            emitComputerAction('launch', res.pid, opts, { path: opts.path, name: opts.name });
             emit(res, Boolean(opts.json), () => `launched ${res.name} (pid ${res.pid})`);
         });
     });

package/dist/commands/computer.js

@@ -7,7 +7,7 @@ import { openComputerClient, resolveHelperApp, resolveHelperExec, resolveSocketP
 import { setupRemoteHelper, startRemoteTunnel, stopRemoteHelper, hydrateRemoteEnvFromState, readRemoteState, resolveRemoteDevice, REMOTE_TASK_NAME, WIN_HELPER_EXE, } from '../lib/ssh-tunnel.js';
 import { sshExec } from '../lib/ssh-exec.js';
 import { encodePowershell } from '../lib/hosts/remote-cmd.js';
-import { registerActionCommands, withClient, unwrap, pickTarget } from './computer-actions.js';
+import { registerActionCommands, withClient, unwrap, pickTarget, emitComputerAction } from './computer-actions.js';
 import { runComputerLoop } from '../lib/computer/loop.js';
 import { makeVerbDispatcher } from '../lib/computer/dispatch.js';
 import { makeClaudeResponder, resolveApiKey, DEFAULT_CLAUDE_MODEL, DEFAULT_CLAUDE_BASE_URL } from '../lib/computer/model.js';
@@ -301,7 +301,7 @@ function registerRunCommand(program) {
             maxTokens: opts.maxTokens,
         });
         await withClient(async (client) => {
-            const dispatch = makeVerbDispatcher(client);
+            const dispatch = makeVerbDispatcher(client, { host: opts.host });
             const targetInput = opts.bundle ? { bundle: opts.bundle } : {};
             const result = await runComputerLoop({
                 task: opts.task,
@@ -375,6 +375,7 @@ function registerScreenshotCommand(program) {
             // --list: enumerate windows, no image.
             if (opts.list) {
                 const res = unwrap(await client.call('screenshot', { pid, list: true }));
+                emitComputerAction('screenshot', pid, opts, { list: true });
                 const windows = res.windows || [];
                 if (opts.json) {
                     console.log(JSON.stringify(res, null, 2));
@@ -402,6 +403,7 @@ function registerScreenshotCommand(program) {
                 console.error('helper returned no image_data');
                 process.exit(1);
             }
+            emitComputerAction('screenshot', pid, opts, { display: opts.display, windowId: opts.windowId });
             const buf = Buffer.from(b64, 'base64');
             // Sniff the real format and correct the extension so the filename never
             // lies about its bytes (macOS -> JPEG, Windows helper -> PNG).

package/dist/commands/perf.d.ts

@@ -14,6 +14,13 @@
 import type { Command } from 'commander';
 import { type PerfAggregateRow } from '../lib/perf/db.js';
 import { type HookProfileRow } from '../lib/hooks/profile.js';
+interface PerfGlobalOpts {
+    days?: string;
+    warnMs?: string;
+    json?: boolean;
+    limit?: string;
+    project?: string;
+}
 /** Map warehouse rows shaped like hook.fire into the existing HookProfileRow UI. */
 export declare function asHookRows(rows: PerfAggregateRow[]): HookProfileRow[];
 export declare function renderHookTable(rows: HookProfileRow[], warnMs: number): void;
@@ -24,4 +31,13 @@ export declare function renderHookTable(rows: HookProfileRow[], warnMs: number):
  * hit ignores it (a caller filtering by project has no legacy rows to miss).
  */
 export declare function loadHookProfile(days: number, project?: string): HookProfileRow[];
+/**
+ * Sessions stuck repeatedly hitting the SAME guard block (git-guard,
+ * rm-guard, git-require-clean-tree, …) instead of adapting after the first
+ * denial. Reads the `friction` event sink (emitFriction in events.ts) that
+ * guard hooks self-report into via `agents _internal friction` before they
+ * exit 2 — see lib/friction-heuristics.ts for the grouping.
+ */
+export declare function frictionAction(opts: PerfGlobalOpts): void;
 export declare function registerPerfCommand(program: Command): void;
+export {};

package/dist/commands/perf.js

@@ -175,7 +175,17 @@ function runAction(opts) {
  * guard hooks self-report into via `agents _internal friction` before they
  * exit 2 — see lib/friction-heuristics.ts for the grouping.
  */
-function frictionAction(opts) {
+export function frictionAction(opts) {
+    // --project is declared on the shared `perf` parent for hooks/commands/run,
+    // where every sample carries a cwd. friction events (emitFriction in
+    // events.ts) don't carry one today — agents _internal friction has no
+    // --cwd flag — so silently accepting the flag here would look like it
+    // filtered when it did nothing. Fail loud instead of no-op.
+    if (opts.project) {
+        console.error(chalk.red("agents perf friction does not support --project yet — friction events carry no cwd to filter on."));
+        process.exitCode = 1;
+        return;
+    }
     const days = parseDays(opts.days);
     const startDate = new Date(Date.now() - days * 86_400_000);
     const events = query({ eventTypes: ['friction'], startDate });

package/dist/commands/projects.d.ts

@@ -20,7 +20,17 @@ export declare const PROJECTS_NO_FANOUT_ENV = "AGENTS_PROJECTS_LOCAL";
  * string when everything answered.
  */
 export declare function formatFleetSkippedNote(skipped: string[]): string;
-/** Best-effort `owner/repo` from a repo's origin remote. */
+/**
+ * Best-effort `owner/repo` from a repo's origin remote.
+ *
+ * `stderr: 'ignore'` is load-bearing, not tidiness. A checkout with no origin
+ * makes git print `error: No such remote 'origin'` on ITS stderr, which is the
+ * terminal's — the catch below never sees it. That was invisible while this was
+ * called once from `add` inside a real repo, and became noise the moment
+ * `import --from-factory` started calling it per row: importing 12 registry
+ * rows printed two raw git errors between the progress lines. Absence of a
+ * remote is an expected answer here (`undefined`), not something to report.
+ */
 export declare function originSlug(cwd: string): string | undefined;
 /** One `projects list` row, pre-render. */
 export interface ProjectListRow {

package/dist/commands/projects.js

@@ -57,10 +57,24 @@ function parseContextFlag(raw) {
         return { path: raw.trim(), purpose: '' };
     return { path: raw.slice(0, i).trim(), purpose: raw.slice(i + 1).trim() };
 }
-/** Best-effort `owner/repo` from a repo's origin remote. */
+/**
+ * Best-effort `owner/repo` from a repo's origin remote.
+ *
+ * `stderr: 'ignore'` is load-bearing, not tidiness. A checkout with no origin
+ * makes git print `error: No such remote 'origin'` on ITS stderr, which is the
+ * terminal's — the catch below never sees it. That was invisible while this was
+ * called once from `add` inside a real repo, and became noise the moment
+ * `import --from-factory` started calling it per row: importing 12 registry
+ * rows printed two raw git errors between the progress lines. Absence of a
+ * remote is an expected answer here (`undefined`), not something to report.
+ */
 export function originSlug(cwd) {
     try {
-        const url = execFileSync('git', ['remote', 'get-url', 'origin'], { cwd, encoding: 'utf8' }).trim();
+        const url = execFileSync('git', ['remote', 'get-url', 'origin'], {
+            cwd,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
         return parseOwnerRepoFromRemote(url) ?? undefined;
     }
     catch {

package/dist/commands/sessions-picker.js

@@ -374,6 +374,13 @@ function formatCompactPreview(events, session) {
     let latestTodos;
     let subAgentCount = 0;
     const toolTags = new Set();
+    // usedBrowser/usedComputer are computed at scan time from a sessionId-scoped
+    // events-log read (session/db.ts detectToolUsage), NOT a transcript regex —
+    // undefined means a legacy row this scanner hasn't computed the field for
+    // yet, so only THEN does classifySessionTool's transcript-derived guess run
+    // below (mirrors directoriesTouched's prefer-persisted/fall-back-to-derived
+    // pattern for recentDirectoriesTouched).
+    const knownToolUsage = session.usedBrowser !== undefined;
     for (const event of events) {
         if (event.type === 'message') {
             if (event.role === 'user' && !firstUser && event.content) {
@@ -388,8 +395,10 @@ function formatCompactPreview(events, session) {
         else if (event.type === 'tool_use' && !event._local) {
             const tool = event.tool || '';
             const command = event.command || '';
-            for (const tag of classifySessionTool(tool, command))
-                toolTags.add(tag);
+            if (!knownToolUsage) {
+                for (const tag of classifySessionTool(tool, command))
+                    toolTags.add(tag);
+            }
             if (isSubAgentTool(tool, command))
                 subAgentCount++;
             const p = event.path || event.args?.file_path || event.args?.path || '';
@@ -412,6 +421,12 @@ function formatCompactPreview(events, session) {
             toolCalls++;
         }
     }
+    // Persisted field wins when computed — it comes from real browser.navigate/
+    // browser.screenshot/computer.action events, not a fuzzy tool-name regex.
+    if (session.usedBrowser)
+        toolTags.add('browser');
+    if (session.usedComputer)
+        toolTags.add('computer');
     // Prefer the transcript-derived list when we just re-parsed the file (freshest
     // checklist write); fall back to SessionMeta.todos for rows where the scan/
     // fan-out attached progress but the event stream has no TodoWrite yet.

package/dist/commands/sessions.d.ts

@@ -70,6 +70,11 @@ interface SessionsOptions extends SessionFilterOptions {
     printCmd?: boolean;
     /** Print a compact preview of the matched session and exit (no pager). */
     preview?: boolean;
+    /** Only sessions that invoked this skill (#12) — matches a bare name or a
+     * namespaced plugin skill's short name (`--skill design` finds `rush:design`). */
+    skill?: string;
+    /** Only sessions that used a skill/command owned by this plugin (#12). */
+    plugin?: string;
 }
 /**
  * Strip terminal/harness noise from a preview so the column stays a single line

package/dist/commands/sessions.js

@@ -1172,6 +1172,12 @@ export function hasNoBrowserDisqualifyingFlags(options, query) {
         !options.markdown &&
         !options.until &&
         !options.project &&
+        // The interactive browser picker is a fuzzy-search TUI over the discovered
+        // pool, not a SQL-filtered listing — it cannot represent a skill/plugin
+        // scope. Falling through to it here would silently drop the filter and
+        // show the unfiltered pool instead (same reasoning as --project/--sort).
+        !options.skill &&
+        !options.plugin &&
         !options.sort &&
         !options.artifacts &&
         options.artifact === undefined &&
@@ -1202,6 +1208,10 @@ function canonicalSessionsCommand(query, options) {
         a.push('--device', h);
     if (options.project)
         a.push('--project', options.project);
+    if (options.skill)
+        a.push('--skill', options.skill);
+    if (options.plugin)
+        a.push('--plugin', options.plugin);
     if (options.all)
         a.push('--all');
     if (options.since)
@@ -1557,6 +1567,8 @@ limitSource) {
             until: options.until,
             sortBy,
             origin: options.routine ? 'routine' : undefined,
+            skill: options.skill,
+            plugin: options.plugin,
         };
         let hiddenUnmanaged = 0;
         let sessions = await discoverSessions({
@@ -3306,6 +3318,8 @@ export function registerSessionsCommands(program) {
         .option('--in-team <name>', "Only this team: the session that spawned it plus (with --teams) its teammates. Spans every directory and all time, since a team's worktrees and history sit outside the default window.")
         .option('--routine', 'Show only sessions archived from routine runs')
         .option('-p, --project <name>', 'Filter by project name (searches across all directories)')
+        .option('--skill <name>', 'Only sessions that invoked this skill (matches a bare name or a namespaced plugin skill\'s short name, e.g. --skill design finds rush:design)')
+        .option('--plugin <name>', 'Only sessions that used a skill/command owned by this plugin')
         .option('--since <time>', 'Only sessions newer than this (e.g., 2h, 7d, 4w, or ISO date)')
         .option('--until <time>', 'Only sessions older than this (ISO timestamp)')
         .option('-n, --limit <n>', 'Maximum number of sessions to return', DEFAULT_LIMIT)

package/dist/index.js

@@ -99,6 +99,7 @@ import { applyGlobalHelpConventions } from './lib/help.js';
 import { renderWhatsNew } from './lib/whats-new.js';
 import { getCliLaunch } from './lib/cli-entry.js';
 import { emit, emitFriction, redactArgs } from './lib/events.js';
+import { stampProvenance } from './lib/event-provenance.js';
 import { die } from './lib/format.js';
 // Transparent shim delegate: the generated Windows `.cmd` shims invoke
 // `agents __shim <agent>[@version] <raw args>`. Intercept here, before commander
@@ -211,12 +212,19 @@ program.hook('postAction', (_thisCommand, actionCommand) => {
         }
         // Disposable perf warehouse — fail-soft spool append (no SQLite on this path).
         if (durationMs !== undefined && parts[0] !== 'perf') {
+            // sessionId/agent are resolvable here the same way emit() resolves them
+            // for command.start/command.end above (the shared provenance floor,
+            // event-provenance.ts) — without this, every command.end perf sample
+            // was anonymous, unlike the audit log record right next to it.
+            const { sessionId, agent } = stampProvenance();
             void import('./lib/perf/spool.js').then(({ recordSample }) => {
                 recordSample({
                     kind: 'command.end',
                     label: command,
                     durationMs,
                     cwd: process.cwd(),
+                    sessionId,
+                    agent,
                 });
             }).catch(() => { });
         }

package/dist/lib/browser/service.js

@@ -486,6 +486,7 @@ export class BrowserService {
             const sessionId = await this.getSessionId(conn, cdpTargetId);
             await conn.cdp.send('Page.navigate', { url }, sessionId);
             await this.saveTaskState(task.profile, conn.tasks);
+            emit('browser.navigate', { profile: task.profile, task: task.name, url, tabId: currentShortId, created: false });
             return { tabId: currentShortId, url, created: false };
         }
         // No current tab - create one
@@ -500,6 +501,7 @@ export class BrowserService {
             task.tabs[shortId] = cdpTargetId;
             task.currentTabId = shortId;
             await this.saveTaskState(task.profile, conn.tasks);
+            emit('browser.navigate', { profile: task.profile, task: task.name, url, tabId: shortId, created: true });
             return { tabId: shortId, url, created: true };
         }
         // Chrome: create new tab
@@ -511,6 +513,7 @@ export class BrowserService {
         task.currentTabId = shortId;
         this.invalidateTargetCache(conn);
         await this.saveTaskState(task.profile, conn.tasks);
+        emit('browser.navigate', { profile: task.profile, task: task.name, url, tabId: shortId, created: true });
         return { tabId: shortId, url, created: true };
     }
     async tabAdd(taskId, url, profileName) {
@@ -705,6 +708,16 @@ export class BrowserService {
         await fs.promises.writeFile(finalPath, buffer);
         const dims = (extension === 'png' ? readPngDimensions(buffer) : readJpegDimensions(buffer)) ??
             { width: 0, height: 0 };
+        emit('browser.screenshot', {
+            profile: profileName,
+            task: task.name,
+            tabId: shortId,
+            path: finalPath,
+            bytes: buffer.length,
+            width: dims.width,
+            height: dims.height,
+            quality,
+        });
         return { path: finalPath, bytes: buffer.length, width: dims.width, height: dims.height };
     }
     /**

package/dist/lib/computer/dispatch.d.ts

@@ -3,6 +3,8 @@ import { type AppInfo } from '../../commands/computer-actions.js';
 import type { VerbDispatcher } from './loop.js';
 declare function rpcMethodFor(verb: string): string;
 declare function toRpcParams(verb: string, input: Record<string, unknown>, pid?: number): Record<string, unknown>;
-export declare function makeVerbDispatcher(client: ComputerClient): VerbDispatcher;
+export declare function makeVerbDispatcher(client: ComputerClient, context?: {
+    host?: string;
+}): VerbDispatcher;
 export { rpcMethodFor, toRpcParams };
 export type { AppInfo };

package/dist/lib/computer/dispatch.js

@@ -5,7 +5,7 @@
 // it names the same RPC methods the explicit `agents computer <verb>` commands
 // call, so the external-agent verb surface is untouched. The daemon stays the
 // single authority on permissions and targeting.
-import { resolveTargetPidDecision } from '../../commands/computer-actions.js';
+import { resolveTargetPidDecision, emitComputerAction } from '../../commands/computer-actions.js';
 // CLI verb -> daemon RPC method. Only the rename cases need listing; the rest
 // pass through by name.
 const RPC_METHOD = {
@@ -102,7 +102,14 @@ function toRpcParams(verb, input, pid) {
 // Build a dispatcher bound to a live client. Every call is a single daemon
 // round-trip; errors are returned (never thrown) so the loop can feed them
 // back to the model as a tool_result.
-export function makeVerbDispatcher(client) {
+//
+// `computer run`'s embedded model loop drives every verb (click, type,
+// screenshot, ...) through THIS single seam rather than the explicit
+// `agents computer <verb>` commands in computer-actions.ts, so it must emit
+// the same `computer.action` event those commands emit — otherwise a session
+// that only used the loop reads back usedComputer=false even though it drove
+// real actions (reviewer-flagged regression on #1864).
+export function makeVerbDispatcher(client, context = {}) {
     return async (call) => {
         const verb = call.name;
         const input = call.input ?? {};
@@ -118,6 +125,7 @@ export function makeVerbDispatcher(client) {
         const res = await client.call(method, params);
         if (res.error)
             return { ok: false, error: `${res.error.code}: ${res.error.message}` };
+        emitComputerAction(verb, pid, { bundle: input.bundle, host: context.host });
         return { ok: true, result: res.result ?? {} };
     };
 }

package/dist/lib/event-stream.d.ts

@@ -18,6 +18,8 @@ export interface UnifiedQuery {
     eventTypes?: EventType[];
     level?: EventLevel;
     agent?: string;
+    /** Only events stamped with this session id (payload `sessionId`, the provenance floor). */
+    sessionId?: string;
     caller?: string;
     command?: string;
     module?: string;

package/dist/lib/event-stream.js

@@ -29,6 +29,8 @@ function matches(r, q) {
         return false;
     if (q.agent && r.agent !== q.agent)
         return false;
+    if (q.sessionId && r.sessionId !== q.sessionId)
+        return false;
     if (q.caller && r.caller !== q.caller)
         return false;
     if (q.command && r.command !== q.command &&
@@ -51,6 +53,7 @@ export function readUnifiedEvents(q = {}) {
         eventTypes: q.eventTypes,
         level: q.level,
         agent: q.agent,
+        sessionId: q.sessionId,
         caller: q.caller,
         command: q.command,
         module: q.module,

package/dist/lib/events.d.ts

@@ -13,7 +13,7 @@
  */
 import type { ActorKind } from './actor.js';
 export type EventLevel = 'audit' | 'warn' | 'info' | 'debug';
-export type EventType = 'agent.run.start' | 'agent.run.end' | 'agent.spawn.start' | 'agent.spawn.end' | 'version.install' | 'version.switch' | 'version.remove' | 'skill.install' | 'skill.remove' | 'browser.launch' | 'browser.close' | 'browser.navigate' | 'browser.screenshot' | 'secrets.get' | 'secrets.unlocked' | 'secrets.create' | 'secrets.import' | 'secrets.export' | 'secrets.view' | 'secrets.set' | 'secrets.delete' | 'secrets.rename' | 'cloud.dispatch' | 'cloud.complete' | 'cloud.cancel' | 'cloud.message' | 'teams.create' | 'teams.add' | 'teams.start' | 'teams.complete' | 'teams.disband' | 'hook.fire' | 'hook.complete' | 'hook.error' | 'mcp.add' | 'mcp.remove' | 'mcp.register' | 'resource.sync' | 'rotation.resolved' | 'command.start' | 'command.end' | 'perf.timing' | 'session.start' | 'session.end' | 'webhook.received' | 'webhook.authorized' | 'webhook.rejected' | 'webhook.matched' | 'webhook.fired' | 'webhook.handler.start' | 'webhook.handler.end' | 'plan.created' | 'pr.opened' | 'pr.merged' | 'worktree.created' | 'worktree.removed' | 'commit.created' | 'pushed' | 'subagent.spawned' | 'artifact.created' | 'task.completed' | 'checklist.created' | 'status.posted' | 'file.edited' | 'factory.command' | 'factory.action' | 'factory.uri' | 'factory.launch' | 'friction' | 'error' | 'warn' | 'info' | 'debug';
+export type EventType = 'agent.run.start' | 'agent.run.end' | 'agent.spawn.start' | 'agent.spawn.end' | 'version.install' | 'version.switch' | 'version.remove' | 'skill.install' | 'skill.remove' | 'browser.launch' | 'browser.close' | 'browser.navigate' | 'browser.screenshot' | 'computer.action' | 'secrets.get' | 'secrets.unlocked' | 'secrets.create' | 'secrets.import' | 'secrets.export' | 'secrets.view' | 'secrets.set' | 'secrets.delete' | 'secrets.rename' | 'cloud.dispatch' | 'cloud.complete' | 'cloud.cancel' | 'cloud.message' | 'teams.create' | 'teams.add' | 'teams.start' | 'teams.complete' | 'teams.disband' | 'hook.fire' | 'hook.complete' | 'hook.error' | 'mcp.add' | 'mcp.remove' | 'mcp.register' | 'resource.sync' | 'rotation.resolved' | 'command.start' | 'command.end' | 'perf.timing' | 'session.start' | 'session.end' | 'webhook.received' | 'webhook.authorized' | 'webhook.rejected' | 'webhook.matched' | 'webhook.fired' | 'webhook.handler.start' | 'webhook.handler.end' | 'plan.created' | 'pr.opened' | 'pr.merged' | 'worktree.created' | 'worktree.removed' | 'commit.created' | 'pushed' | 'subagent.spawned' | 'artifact.created' | 'task.completed' | 'checklist.created' | 'status.posted' | 'file.edited' | 'factory.command' | 'factory.action' | 'factory.uri' | 'factory.launch' | 'friction' | 'error' | 'warn' | 'info' | 'debug';
 /** Every known event kind. Derived from {@link EVENT_TYPE_TABLE}, never hand-listed. */
 export declare const EVENT_TYPES: readonly EventType[];
 /** Runtime guard for an event kind arriving from outside this process. */
@@ -208,6 +208,8 @@ export declare function query(options: {
     eventTypes?: EventType[];
     level?: EventLevel;
     agent?: string;
+    /** Only events stamped with this session id (payload `sessionId`, the provenance floor). */
+    sessionId?: string;
     caller?: string;
     command?: string;
     module?: string;

package/dist/lib/events.js

@@ -84,6 +84,7 @@ const EVENT_TYPE_TABLE = {
     'version.install': true, 'version.switch': true, 'version.remove': true,
     'skill.install': true, 'skill.remove': true,
     'browser.launch': true, 'browser.close': true, 'browser.navigate': true, 'browser.screenshot': true,
+    'computer.action': true,
     'secrets.get': true, 'secrets.unlocked': true, 'secrets.create': true, 'secrets.import': true, 'secrets.export': true, 'secrets.view': true, 'secrets.set': true, 'secrets.delete': true, 'secrets.rename': true,
     'cloud.dispatch': true, 'cloud.complete': true, 'cloud.cancel': true, 'cloud.message': true,
     'teams.create': true, 'teams.add': true, 'teams.start': true, 'teams.complete': true, 'teams.disband': true,
@@ -327,7 +328,6 @@ export function detectCaller(env = process.env, stdoutIsTTY = Boolean(process.st
     }
     return { kind: stdoutIsTTY ? 'terminal' : 'script' };
 }
-// ─── Audit attribution ────────────────────────────────────────────────────────
 // ─── Core API ─────────────────────────────────────────────────────────────────
 /**
  * Emit a structured event to the append-only audit log.
@@ -729,7 +729,7 @@ export function maybeRotate() {
  * @returns Array of event records
  */
 export function query(options) {
-    const { startDate, endDate = new Date(), eventTypes, level, agent, caller, command, module, limit } = options;
+    const { startDate, endDate = new Date(), eventTypes, level, agent, sessionId, caller, command, module, limit } = options;
     const results = [];
     if (!fs.existsSync(eventsDir()))
         return results;
@@ -774,6 +774,8 @@ export function query(options) {
                     continue;
                 if (agent && record.agent !== agent)
                     continue;
+                if (sessionId && record.sessionId !== sessionId)
+                    continue;
                 if (caller && record.caller !== caller)
                     continue;
                 if (command && record.command !== command &&

package/dist/lib/git.d.ts

@@ -103,6 +103,20 @@ export interface RepoStateSnapshot {
  *  result is stable across git versions and never mutates the tree. Returns null
  *  when the path is not a git worktree. */
 export declare function readRepoState(repoPath: string): RepoStateSnapshot | null;
+/**
+ * The short HEAD sha of the git repo at `repoRoot` (`git -C <repoRoot>
+ * rev-parse --short HEAD`), for provenance — "which commit of this DotAgents
+ * repo was this resource/plugin resolved from". `undefined` when `repoRoot`
+ * isn't a git repo (or has no commits yet), never a throw.
+ *
+ * Deliberately synchronous + resolved once and cached: callers (resources.ts,
+ * plugins.ts) attach this as a lazy getter on the resolved object, so a
+ * consumer that never inspects provenance never pays for the git shell-out —
+ * see {@link ResolvedResource.snapshotSha} / {@link DiscoveredPlugin.snapshotSha}.
+ */
+export declare function resolveSnapshotSha(repoRoot: string): string | undefined;
+/** Test seam: clear the memoized snapshot-sha cache between test cases. */
+export declare function _resetSnapshotShaCacheForTest(): void;
 /**
  * Get the current GitHub username using gh CLI.
  * Returns null if gh is not installed or user is not authenticated.