@phnx-labs/agents-cli 1.20.91 → 1.20.93

package/dist/commands/sessions-picker.js

@@ -146,7 +146,7 @@ function displayAgent(agent) {
 const DOT = chalk.gray(' · ');
 function formatHeader(session, events) {
     const model = extractModel(events) || session.model;
-    const { startedAgo, duration } = extractTiming(events);
+    const { createdAgo, lastActiveAgo, duration } = extractTiming(session, events);
     const totalMessages = session.messageCount ?? countMessages(events);
     const totalTokens = session.tokenCount;
     // Line 1: Agent v version · shortId · model · account
@@ -158,7 +158,7 @@ function formatHeader(session, events) {
         line1.push(chalk.bold.white(shortenModel(model)));
     if (session.account)
         line1.push(chalk.gray(session.account));
-    // Line 2: cwd · project · branch · started X ago · lasted Y
+    // Line 2: cwd · project · branch · created X ago · last active Y ago · lasted Z
     // Project is clickable: Linear issue URL is for tickets (line 4); for the
     // project name prefer a GitHub repo URL derived from the checkout path.
     const line2 = [];
@@ -172,8 +172,10 @@ function formatHeader(session, events) {
     }
     if (session.gitBranch)
         line2.push(chalk.cyan(session.gitBranch));
-    if (startedAgo)
-        line2.push(chalk.gray('started ') + chalk.white(startedAgo + ' ago'));
+    if (createdAgo)
+        line2.push(chalk.gray('created ') + chalk.white(createdAgo + ' ago'));
+    if (lastActiveAgo)
+        line2.push(chalk.gray('last active ') + chalk.white(lastActiveAgo + ' ago'));
     if (duration)
         line2.push(chalk.gray('lasted ') + chalk.white(duration));
     // Line 3: N msgs · T tokens · [label ·] uuid
@@ -292,16 +294,39 @@ function extractModel(events) {
     }
     return undefined;
 }
-function extractTiming(events) {
-    if (events.length === 0)
-        return {};
-    const firstMs = Date.parse(events[0].timestamp);
-    const lastMs = Date.parse(events[events.length - 1].timestamp);
+/** Shortest span worth reporting as a separate last-activity field — matches the
+ * listing's rule, so the pane and the row agree on what counts as a one-shot. */
+const TIMING_SPAN_MIN_MS = 60_000;
+/**
+ * The three timing facts the header reports: when the session was created, when
+ * it was last active, and how long it ran. Reads the parsed transcript when
+ * there is one and otherwise the indexed `SessionMeta`, so a remote or
+ * unindexed session — which has no local transcript to parse — still reports
+ * them instead of silently dropping the whole line.
+ *
+ * `lastActive` and `lasted` are omitted for a session whose whole life was under
+ * a minute: there they just restate `created`.
+ */
+export function extractTiming(session, events) {
+    const firstMs = Date.parse(events[0]?.timestamp ?? session.timestamp);
     if (Number.isNaN(firstMs))
         return {};
-    const ago = humanDuration(Math.max(0, Date.now() - firstMs));
-    const dur = Number.isNaN(lastMs) ? undefined : humanDuration(Math.max(0, lastMs - firstMs));
-    return { startedAgo: ago, duration: dur };
+    const createdAgo = humanDuration(Math.max(0, Date.now() - firstMs));
+    const lastMs = Date.parse(events[events.length - 1]?.timestamp ?? session.lastActivity ?? session.timestamp);
+    if (Number.isNaN(lastMs))
+        return { createdAgo };
+    // A scan-persisted duration beats the timestamp subtraction when there are no
+    // events to read, because `lastActivity` may have fallen back to file mtime.
+    const spanMs = events.length === 0 && session.durationMs !== undefined
+        ? session.durationMs
+        : Math.max(0, lastMs - firstMs);
+    if (spanMs < TIMING_SPAN_MIN_MS)
+        return { createdAgo };
+    return {
+        createdAgo,
+        lastActiveAgo: humanDuration(Math.max(0, Date.now() - lastMs)),
+        duration: humanDuration(spanMs),
+    };
 }
 function countMessages(events) {
     return events.filter(e => e.type === 'message').length;

package/dist/commands/sessions-resume.d.ts

@@ -11,6 +11,8 @@ interface ResumeOptions {
     ghostty?: boolean;
     tmux?: boolean;
     vscodium?: boolean;
+    /** --terminal-app: force macOS Terminal.app. Named to avoid reading as `run --terminal`. */
+    terminalApp?: boolean;
     splits?: boolean;
 }
 export declare function registerSessionsResumeCommand(sessionsCmd: Command): void;

package/dist/commands/sessions-resume.js

@@ -36,6 +36,7 @@ export function registerSessionsResumeCommand(sessionsCmd) {
         .option('--ghostty', 'Force the Ghostty backend')
         .option('--tmux', 'Force the tmux backend')
         .option('--vscodium', 'Force the VSCodium agent-terminal backend (swarm-ext)')
+        .option('--terminal-app', 'Force macOS Terminal.app (no split support — panes become tabs)')
         .option('--splits', 'Pack two sessions side by side per tab (default: one tab per session)');
     setHelpSections(cmd, {
         examples: `
@@ -156,6 +157,12 @@ async function sessionsResumeAction(query, options) {
     // recovery; callers can explicitly opt into pairs of side-by-side panes.
     const packing = resolveResumePacking(options);
     const where = options.host ? `${backend} on ${options.host}` : backend;
+    // Terminal.app has no scriptable split, so its buildSplit opens a tab. Say so
+    // when the user actually asked for panes — the layout silently not happening
+    // is worse than one line of warning.
+    if (backend === 'terminal' && packing === 'two-per-tab') {
+        console.log(chalk.yellow('Terminal.app cannot split panes — opening one tab per session instead.'));
+    }
     console.log(chalk.gray(`Opening ${items.length} session${items.length === 1 ? '' : 's'} in ${where} (${packing})…`));
     const results = await openSurfaces(items.map((it) => ({ cwd: it.cwd, command: it.command })), { backend, host: options.host, packing });
     let opened = 0;
@@ -185,7 +192,8 @@ async function resolveBackend(options, ctx, count) {
         : options.ghostty ? 'ghostty'
             : options.tmux ? 'tmux'
                 : options.vscodium ? 'vscodium-agent'
-                    : undefined;
+                    : options.terminalApp ? 'terminal'
+                        : undefined;
     if (forced)
         return forced;
     // Remote defaults to tmux (headless, no GUI session assumptions); override with a backend flag.

package/dist/commands/sessions.d.ts

@@ -1,4 +1,5 @@
 import { type Command } from 'commander';
+import { type ProjectDef } from '../lib/projects.js';
 import type { SessionAgentId, SessionMeta, ViewMode } from '../lib/session/types.js';
 import { type ActiveSession } from '../lib/session/active.js';
 import { gatherRemoteList, runOnPeer } from '../lib/session/remote-list.js';
@@ -351,11 +352,15 @@ export declare function teamBadge(session: SessionMeta): {
  * dashes and needlessly truncate the topic. Worktree stays a trailing badge. */
 export declare function flatSessionRow(session: SessionMeta, live?: ActiveSession, showTicket?: boolean, cols?: PickerColumns, favorite?: boolean): string;
 /**
- * Group key for the overview: prefer the indexed project name; else fold the cwd
- * to its repo — a worktree (`.../<repo>/.agents/worktrees/<slug>`) folds to the
- * repo, and a monorepo subdir falls back to its leaf dir basename. Pure.
+ * Group key for the overview: resolve the cwd through the same canonical
+ * resolver the `agents activity` timeline groups by — a defined project's name
+ * when `defs` contains the cwd (multi-repo projects read as one group), else
+ * the repo-level key, so a monorepo subdir (`<repo>/apps/cli`) reads as
+ * `<repo>` in both views. Falls back to the indexed project name (stamped at
+ * scan time) when the cwd carries nothing usable, e.g. a remote path this
+ * machine cannot see still folds by basename through the same resolver.
  */
-export declare function overviewProjectKey(s: Pick<SessionMeta, 'project' | 'cwd'>): string;
+export declare function overviewProjectKey(s: Pick<SessionMeta, 'project' | 'cwd'>, defs?: ProjectDef[]): string;
 export interface OverviewGroup {
     key: string;
     total: number;
@@ -369,7 +374,7 @@ export interface OverviewGroup {
  * are ordered by their most-recent session so the newest-active project leads.
  * `perProjectCap = Infinity` expands every group. Pure — unit-tested.
  */
-export declare function buildOverviewGroups(pool: SessionMeta[], perProjectCap: number): {
+export declare function buildOverviewGroups(pool: SessionMeta[], perProjectCap: number, defs?: ProjectDef[]): {
     groups: OverviewGroup[];
     projectCount: number;
 };

package/dist/commands/sessions.js

@@ -14,6 +14,8 @@ import { spawn } from 'child_process';
 import { Option } from 'commander';
 import chalk from 'chalk';
 import { truncate, padRight } from '../lib/format.js';
+import { resolveProjectKey } from '../lib/project-key.js';
+import { listProjectDefs, resolveProjectNameForCwd } from '../lib/projects.js';
 import ora from 'ora';
 import { SESSION_AGENTS } from '../lib/session/types.js';
 import { discoverArtifacts, readArtifact, resolveArtifact } from '../lib/session/artifacts.js';
@@ -32,7 +34,7 @@ import { findSessionsById, querySessions } from '../lib/session/db.js';
 import { filterTeamSessions, safeTeamText } from '../lib/session/team-filter.js';
 import { parseSession } from '../lib/session/parse.js';
 import { runRemoteSessions, buildForwardedArgs, ensureWholeIndex } from '../lib/session/remote.js';
-import { formatRelativeTime } from '../lib/session/relative-time.js';
+import { formatRelativeTime, sessionAgeParts } from '../lib/session/relative-time.js';
 import { renderConversationMarkdown, renderSummary, renderSummaryHeader, computeSummaryStats, renderJson, filterEvents, parseRoleList, linkPath, linkUrl, shortenModel } from '../lib/session/render.js';
 import { linearIssueUrl } from '../lib/session/linear.js';
 import { renderMarkdown } from '../lib/markdown.js';
@@ -1768,6 +1770,33 @@ function metaSignals(s) {
         ticket: s.ticketId ? { id: s.ticketId } : undefined,
     };
 }
+/**
+ * Narrowest topic a row is willing to render. The time cell drops its creation
+ * field rather than squeeze the topic past this — a row that wraps is worse than
+ * a row missing one field.
+ */
+const MIN_TOPIC_W = 16;
+/**
+ * The trailing time cell, as two fields: `3d → 2 hours ago` — when the session
+ * was created, then when it was last active. One label answers neither "is this
+ * the old session I'm looking for" nor "how long did it run", since a session
+ * touched an hour ago may have started last week.
+ *
+ * Collapses to last-activity alone when the session ran under a minute (both
+ * halves would name the same moment) or when `topicSlack` — the columns the row
+ * has left for its topic — cannot spare the extra width. `extraW` is what the
+ * creation field cost, for the caller to take off the topic budget.
+ */
+function timeCell(age, topicSlack) {
+    const lastOnly = { plain: age.last, text: chalk.gray(age.last), extraW: 0 };
+    if (!age.created)
+        return lastOnly;
+    const prefix = `${age.created} → `;
+    const extraW = stringWidth(prefix);
+    if (topicSlack - extraW < MIN_TOPIC_W)
+        return lastOnly;
+    return { plain: prefix + age.last, text: chalk.dim(prefix) + chalk.gray(age.last), extraW };
+}
 /** One flat table row:
  *   shortId · agent · version · model · project · [glyph] label·doing · [ticket] · [wt] · time
  * `doing` is the live preview when running, else the topic. The `ticket` column
@@ -1776,7 +1805,7 @@ function metaSignals(s) {
  * dashes and needlessly truncate the topic. Worktree stays a trailing badge. */
 export function flatSessionRow(session, live, showTicket = false, cols = {}, favorite = false) {
     const agentColor = colorAgent(session.agent);
-    const when = formatRelativeTime(session.lastActivity ?? session.timestamp);
+    const age = sessionAgeParts(session.timestamp, session.lastActivity);
     const project = session.project || '-';
     const tag = originTag(session) || teamTag(session);
     const label = session.label;
@@ -1813,12 +1842,15 @@ export function flatSessionRow(session, live, showTicket = false, cols = {}, fav
     // Same conditional 2 cells as the picker's marker, for the same reason.
     const favW = cols.showFavorite ? 2 : 0;
     const favCell = cols.showFavorite ? (favorite ? chalk.yellow('★ ') : '  ') : '';
-    const fixedW = favW + (10 + 9 + 8 + 16) + glyphW + statusW + machineW + ticketW + wtW + team.width + stringWidth(when) + 1;
-    const modelSlack = width - fixedW - 16;
+    // Sized against the last-activity label alone, so the creation field is an
+    // additive decision the row makes only once it knows what space is left.
+    const fixedW = favW + (10 + 9 + 8 + 16) + glyphW + statusW + machineW + ticketW + wtW + team.width + stringWidth(age.last) + 1;
+    const modelSlack = width - fixedW - MIN_TOPIC_W;
     const modelW = requestedModelW <= modelSlack
         ? requestedModelW
         : modelSlack >= PICKER_MODEL_MIN ? modelSlack : 0;
-    const topicW = Math.max(16, width - fixedW - modelW);
+    const when = timeCell(age, width - fixedW - modelW);
+    const topicW = Math.max(MIN_TOPIC_W, width - fixedW - modelW - when.extraW);
     return (favCell +
         chalk.white(padToWidth(truncateToWidth(session.shortId, 9), 10)) +
         agentColor(padToWidth(truncateToWidth(session.agent, 8), 9)) +
@@ -1832,12 +1864,12 @@ export function flatSessionRow(session, live, showTicket = false, cols = {}, fav
         renderTopicCell(label, doing, '', topicW, topicW) +
         ticketCell +
         (wt ? wt + ' ' : '') +
-        chalk.gray(when));
+        when.text);
 }
 /** One tree-mode row (grouped under a dir header): id · agent · badges · topic · time. No version/project column. */
 function treeSessionRow(session, live) {
     const agentColor = colorAgent(session.agent);
-    const when = formatRelativeTime(session.lastActivity ?? session.timestamp);
+    const age = sessionAgeParts(session.timestamp, session.lastActivity);
     const tag = originTag(session) || teamTag(session);
     const label = session.label;
     const { glyph, preview } = liveGlyphAndPreview(live);
@@ -1853,7 +1885,9 @@ function treeSessionRow(session, live) {
     const head = label ? `${label} · ${topic}` : topic;
     const { cell: statusCell, width: statusW } = liveStatusCell(live);
     const glyphW = glyph ? 2 : 0;
-    const topicW = Math.max(12, terminalWidth() - (2 + 9 + 8) - glyphW - statusW - badgeW - team.width - stringWidth(when) - 1);
+    const baseTopicW = terminalWidth() - (2 + 9 + 8) - glyphW - statusW - badgeW - team.width - stringWidth(age.last) - 1;
+    const when = timeCell(age, baseTopicW);
+    const topicW = Math.max(12, baseTopicW - when.extraW);
     return ('  ' +
         chalk.dim(padToWidth(session.shortId, 9)) +
         agentColor(padToWidth(truncateToWidth(session.agent, 7), 8)) +
@@ -1862,7 +1896,7 @@ function treeSessionRow(session, live) {
         statusCell +
         teamSeg +
         padToWidth(chalk.white(truncateToWidth(head, topicW)), topicW) +
-        ' ' + chalk.gray(when));
+        ' ' + when.text);
 }
 /**
  * Live-session index for enriching the default listing, or undefined when
@@ -1884,21 +1918,21 @@ async function maybeLiveIndex(options) {
     }
 }
 /**
- * Group key for the overview: prefer the indexed project name; else fold the cwd
- * to its repo — a worktree (`.../<repo>/.agents/worktrees/<slug>`) folds to the
- * repo, and a monorepo subdir falls back to its leaf dir basename. Pure.
+ * Group key for the overview: resolve the cwd through the same canonical
+ * resolver the `agents activity` timeline groups by — a defined project's name
+ * when `defs` contains the cwd (multi-repo projects read as one group), else
+ * the repo-level key, so a monorepo subdir (`<repo>/apps/cli`) reads as
+ * `<repo>` in both views. Falls back to the indexed project name (stamped at
+ * scan time) when the cwd carries nothing usable, e.g. a remote path this
+ * machine cannot see still folds by basename through the same resolver.
  */
-export function overviewProjectKey(s) {
+export function overviewProjectKey(s, defs) {
+    const resolved = defs?.length ? resolveProjectNameForCwd(s.cwd, defs) : resolveProjectKey(s.cwd);
+    if (resolved)
+        return resolved;
     if (s.project && s.project.trim())
         return s.project.trim();
-    const cwd = (s.cwd ?? '').replace(/\/+$/, '');
-    if (!cwd)
-        return '(no project)';
-    const wt = cwd.match(/\/([^/]+)\/\.agents\/worktrees\//);
-    if (wt)
-        return wt[1];
-    const parts = cwd.split('/');
-    return parts[parts.length - 1] || cwd;
+    return '(no project)';
 }
 /**
  * Turn a recency-descending pool into project groups: each group shows its
@@ -1906,10 +1940,10 @@ export function overviewProjectKey(s) {
  * are ordered by their most-recent session so the newest-active project leads.
  * `perProjectCap = Infinity` expands every group. Pure — unit-tested.
  */
-export function buildOverviewGroups(pool, perProjectCap) {
+export function buildOverviewGroups(pool, perProjectCap, defs) {
     const byKey = new Map();
     for (const s of pool) {
-        const k = overviewProjectKey(s);
+        const k = overviewProjectKey(s, defs);
         (byKey.get(k) ?? byKey.set(k, []).get(k)).push(s);
     }
     const cap = Math.max(1, perProjectCap);
@@ -1927,7 +1961,7 @@ export function buildOverviewGroups(pool, perProjectCap) {
  * `· N more` per project and a `+N more projects` when the list is capped.
  */
 function printSessionOverview(pool, hiddenCount, liveIndex, opts) {
-    const { groups } = buildOverviewGroups(pool, opts.expand ? Infinity : opts.perProjectCap);
+    const { groups } = buildOverviewGroups(pool, opts.expand ? Infinity : opts.perProjectCap, listProjectDefs());
     const shownGroups = opts.expand ? groups : groups.slice(0, OVERVIEW_MAX_PROJECTS);
     const hiddenProjects = groups.length - shownGroups.length;
     const total = pool.length;
@@ -2252,7 +2286,7 @@ export function liveHostLabel(a) {
 }
 export function formatPickerLabel(s, query, cols = {}, ssh, host = '', favorite = false, live) {
     const agentColor = colorAgent(s.agent);
-    const when = formatRelativeTime(s.lastActivity ?? s.timestamp);
+    const age = sessionAgeParts(s.timestamp, s.lastActivity);
     const project = s.project || '-';
     // SSH-launch origin (live rows only): mirrors the flat listing's `ssh←<device>`
     // badge. Rendered as its OWN red segment before the topic cell — folding it into
@@ -2306,7 +2340,11 @@ export function formatPickerLabel(s, query, cols = {}, ssh, host = '', favorite
     const status = cols.showStatus ? liveStatusCell(live) : { cell: '', width: 0 };
     const statusW = cols.showStatus ? LIVE_STATUS_W : 0;
     const statusCell = cols.showStatus ? (status.cell || ' '.repeat(LIVE_STATUS_W)) : '';
-    const topicW = Math.max(16, terminalWidth() - gutter - favW - statusW - (10 + 9 + 8 + 16) - machineColW - hostW - ticketW - wtW - sshW - team.width - stringWidth(when) - 1);
+    // Sized against the last-activity label alone; the creation field is then an
+    // additive decision made against whatever width is left (see the flat listing).
+    const baseTopicW = terminalWidth() - gutter - favW - statusW - (10 + 9 + 8 + 16) - machineColW - hostW - ticketW - wtW - sshW - team.width - stringWidth(age.last) - 1;
+    const when = timeCell(age, baseTopicW);
+    const topicW = Math.max(MIN_TOPIC_W, baseTopicW - when.extraW);
     return (favCell +
         // Truncated, not just padded: an indexed shortId is always 8 chars, but a
         // live row with no session id is named by its pid or cloud task, which can
@@ -2323,7 +2361,7 @@ export function formatPickerLabel(s, query, cols = {}, ssh, host = '', favorite
         renderTopicCell(label, topic, query, topicW, topicW) +
         ticketCell +
         (wt ? wt + ' ' : '') +
-        chalk.gray(when));
+        when.text);
 }
 /** Hints rotated above the picker so the flags/features stay discoverable. */
 const PICKER_TIPS = [

package/dist/commands/sync.js

@@ -37,6 +37,7 @@ import { capableAgents } from '../lib/capabilities.js';
 import { parseHookManifest, registerHooksToSettings } from '../lib/hooks.js';
 import { compileRulesForProject } from '../lib/rules/compile.js';
 import { runLaunchSync } from '../lib/project-launch.js';
+import { formatKeptProjectResources } from '../lib/project-resources.js';
 import { isInteractiveTerminal, isPromptCancelled } from './utils.js';
 import { runUmbrellaSync } from '../lib/sync-umbrella.js';
 import { addHostOption } from '../lib/hosts/option.js';
@@ -516,8 +517,11 @@ function printSyncDetail(result, agent, version, cwd) {
         lines.push({ kind: 'plugins', items: result.plugins });
     if (result.workflows.length > 0)
         lines.push({ kind: 'workflows', items: result.workflows });
+    const kept = formatKeptProjectResources(result.projectSkipped);
     if (lines.length === 0) {
         console.log(chalk.gray(`Already in sync — ${agentLabel(agent)}@${version}`));
+        if (kept)
+            console.log(chalk.gray(kept));
         return;
     }
     console.log(chalk.green(`Synced to ${agentLabel(agent)}@${version}:`));
@@ -531,6 +535,8 @@ function printSyncDetail(result, agent, version, cwd) {
         const count = chalk.cyan(`(${sorted.length})`.padStart(5));
         console.log(`  ${chalk.bold(padded)}  ${count}  ${chalk.gray(preview)}${more}`);
     }
+    if (kept)
+        console.log(chalk.gray(kept));
 }
 function runLaunchMode(agent, version, cwd, quiet) {
     let result;
@@ -561,7 +567,7 @@ function runLaunchMode(agent, version, cwd, quiet) {
     else {
         console.log(chalk.green(`Launch sync: ${bits.join(', ')}`));
     }
-    if (result.workspaceSkipped.length > 0) {
-        console.log(chalk.yellow(`Skipped (user-owned, not overwritten): ${result.workspaceSkipped.join(', ')}`));
-    }
+    const kept = formatKeptProjectResources(result.workspaceSkipped);
+    if (kept)
+        console.log(chalk.gray(kept));
 }

package/dist/commands/view.js

@@ -11,6 +11,7 @@ import { authCacheKey, formatCheckedAge, readAuthHealthCache } from '../lib/auth
 import { agentReportsUsage, deriveUsageStatusFromSnapshot, formatUsageSection, formatUsageSummary, formatUsageStatusBadge, getUsageInfoForIdentity, getUsageInfoByIdentity, getUsageLookupKey, } from '../lib/usage.js';
 import { readManifest } from '../lib/manifest.js';
 import { listInstalledVersions, listInstalledVersionDirs, getGlobalDefault, getVersionHomePath, getVersionDir, getAvailableResources, getActuallySyncedResources, getNewResources, getProjectOnlyResources, hasNewResources, promptNewResourceSelection, syncResourcesToVersion, removeVersion, printTrashFooter, reconcileStaleLatestForAgent, isGlobalBinaryAgent, getLiveVersion, isVersionIsolated, getIsolatedDefault, } from '../lib/versions.js';
+import { formatKeptProjectResources } from '../lib/project-resources.js';
 import { ensureVersionedAliasCurrent, removeShim, } from '../lib/shims.js';
 import { getAgentResources } from '../lib/resources.js';
 import { renderMergedResources } from '../lib/merged-resources.js';
@@ -722,6 +723,9 @@ async function showInstalledVersions(filterAgentId, viewOpts) {
                         if (synced.length > 0) {
                             console.log(chalk.green(`\nSynced to ${agentLabel(filterAgentId)}@${defaultVersion}: ${synced.join(', ')}`));
                         }
+                        const kept = formatKeptProjectResources(result.projectSkipped);
+                        if (kept)
+                            console.log(chalk.gray(kept));
                     }
                 }
                 catch (err) {

package/dist/index.js

@@ -94,7 +94,7 @@ if (IS_DEV_BUILD) {
 // module on each invocation (which loaded the whole ~50-module tree before the
 // first byte of output), the registry maps a command name to a thunk that
 // imports only what that command needs. See src/lib/startup/command-registry.ts.
-import { COMMAND_LOADERS, LAZY_COMMAND_NAMES, loadView, loadInspect, loadFeedback, loadCommands, loadHooks, loadSkills, loadRules, loadMemory, loadPermissions, loadMcp, loadCli, loadSubagents, loadPlugins, loadWorkflows, loadWorktree, loadVersions, loadImport, loadExport, loadPackages, loadRoutines, loadMonitors, loadRun, loadFork, loadDefaults, loadSet, loadModels, loadPrune, loadTrash, loadRestore, loadDoctor, loadApply, loadStatus, loadProfiles, loadHarness, loadSecrets, loadLogin, loadWallet, loadHelper, loadMenubar, loadBeta, loadSync, loadLock, loadRefreshRules, loadDrive, loadFactory, loadUsage, loadCost, loadPerf, loadOutput, loadBudget, loadAlias, loadMine, loadPty, loadTmux, loadWatchdog, loadBrowser, loadComputer, loadHosts, loadLogs, loadEvents, loadAudit, loadWebhook, loadFunnel, loadSsh, loadPull, loadPush, loadRepo, loadSetup, loadUninstall, loadShare, loadSend, loadHq, loadFeed, loadActivity, loadMailboxes, } from './lib/startup/command-registry.js';
+import { COMMAND_LOADERS, LAZY_COMMAND_NAMES, loadView, loadInspect, loadFeedback, loadCommands, loadHooks, loadSkills, loadRules, loadMemory, loadPermissions, loadMcp, loadCli, loadSubagents, loadPlugins, loadWorkflows, loadWorktree, loadVersions, loadImport, loadExport, loadPackages, loadRoutines, loadMonitors, loadProjects, loadRun, loadFork, loadDefaults, loadSet, loadModels, loadPrune, loadTrash, loadRestore, loadDoctor, loadApply, loadStatus, loadProfiles, loadHarness, loadSecrets, loadLogin, loadWallet, loadHelper, loadMenubar, loadBeta, loadSync, loadLock, loadRefreshRules, loadDrive, loadFactory, loadUsage, loadCost, loadPerf, loadOutput, loadBudget, loadAlias, loadMine, loadPty, loadTmux, loadWatchdog, loadBrowser, loadComputer, loadHosts, loadLogs, loadEvents, loadAudit, loadWebhook, loadFunnel, loadSsh, loadPull, loadPush, loadRepo, loadSetup, loadUninstall, loadShare, loadSend, loadHq, loadFeed, loadActivity, loadMailboxes, } from './lib/startup/command-registry.js';
 import { applyGlobalHelpConventions } from './lib/help.js';
 import { renderWhatsNew } from './lib/whats-new.js';
 import { getCliLaunch } from './lib/cli-entry.js';
@@ -147,11 +147,25 @@ function auditCommandPath(cmd) {
     return parts;
 }
 const auditStarts = new WeakMap();
+/**
+ * Commands that WRITE the event stream, so recording their own invocation would
+ * add records to the log they are writing into. `events emit` is batched — one
+ * flush every few seconds per open editor window — so auditing it would bury the
+ * real events under two `command.*` records per flush. `_internal friction`
+ * exists for the same reason (shell guards fire before any `agents` process
+ * exists, so they cannot emit in-process) and had the same self-logging bug.
+ */
+const AUDIT_EXEMPT_COMMANDS = new Set([
+    'events emit',
+    '_internal friction',
+]);
 program.hook('preAction', (_thisCommand, actionCommand) => {
     try {
         const parts = auditCommandPath(actionCommand);
         if (parts.length === 0)
             return;
+        if (AUDIT_EXEMPT_COMMANDS.has(parts.join(' ')))
+            return;
         auditStarts.set(actionCommand, Date.now());
         emit('command.start', {
             module: parts[0],
@@ -172,6 +186,8 @@ program.hook('postAction', (_thisCommand, actionCommand) => {
         const parts = auditCommandPath(actionCommand);
         if (parts.length === 0)
             return;
+        if (AUDIT_EXEMPT_COMMANDS.has(parts.join(' ')))
+            return;
         const started = auditStarts.get(actionCommand);
         const durationMs = started !== undefined ? Date.now() - started : undefined;
         const command = parts.join(' ');
@@ -871,6 +887,7 @@ async function registerAllEagerCommands() {
     await reg(loadPackages);
     await reg(loadRoutines);
     await reg(loadMonitors);
+    await reg(loadProjects);
     await reg(loadRun);
     await reg(loadFork);
     await reg(loadDefaults);