@phnx-labs/agents-cli 1.22.32 → 1.22.34

package/dist/lib/teams/worktree.js

@@ -9,6 +9,7 @@ import { promisify } from 'util';
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import { safeJoin } from '../paths.js';
+import { getMainRepoRoot } from '../git.js';
 const execFileAsync = promisify(execFile);
 const WORKTREE_NAME_RE = /^[A-Za-z0-9_-]+$/;
 /**
@@ -106,7 +107,16 @@ export async function localDefaultBranch(gitRoot) {
  * code. Matches `createRemoteWorktree` — local and remote isolation share one
  * base policy.
  *
- * @param repoDir - Directory inside the git repository
+ * Resolves the placement root with {@link getMainRepoRoot}, NOT the local
+ * `getGitRoot`/`--show-toplevel`, on purpose: when `repoDir` (the caller's
+ * ambient cwd) is itself inside another teammate's linked worktree,
+ * `--show-toplevel` returns THAT worktree's own root, so the new worktree
+ * lands nested inside it (observed: `.../worktrees/A/.agents/worktrees/B`,
+ * destroyed along with A's cleanup). `getMainRepoRoot` follows
+ * `--git-common-dir`, which always points at the primary checkout's `.git`
+ * regardless of which worktree the caller is standing in.
+ *
+ * @param repoDir - Directory inside the git repository (main checkout or any linked worktree)
  * @param worktreeName - Name for the worktree (used in path and branch)
  * @returns The absolute path to the created worktree
  */
@@ -114,7 +124,7 @@ export async function createWorktree(repoDir, worktreeName) {
     if (!WORKTREE_NAME_RE.test(worktreeName)) {
         throw new Error(`Invalid worktree name: ${worktreeName}`);
     }
-    const gitRoot = await getGitRoot(repoDir);
+    const gitRoot = await getMainRepoRoot(repoDir);
     const worktreePath = safeJoin(path.join(gitRoot, '.agents', 'worktrees'), worktreeName);
     const branchName = `agents/${worktreeName}`;
     const base = await localDefaultBranch(gitRoot);
@@ -137,7 +147,12 @@ export async function createWorktree(repoDir, worktreeName) {
 /**
  * Remove a git worktree and optionally its branch.
  *
- * @param repoDir - Directory inside the main git repository (not the worktree)
+ * Resolves via {@link getMainRepoRoot}, same as {@link createWorktree} — a
+ * caller standing inside a DIFFERENT linked worktree (e.g. a `teams stop`
+ * run from within another teammate's checkout) must still target the main
+ * repo's `.agents/worktrees/<name>`, not `--show-toplevel`'s local answer.
+ *
+ * @param repoDir - Directory inside the git repository (main checkout or any linked worktree)
  * @param worktreeName - Name of the worktree to remove
  * @param deleteBranch - Whether to delete the associated branch
  */
@@ -145,7 +160,7 @@ export async function removeWorktree(repoDir, worktreeName, deleteBranch = true)
     if (!WORKTREE_NAME_RE.test(worktreeName)) {
         throw new Error(`Invalid worktree name: ${worktreeName}`);
     }
-    const gitRoot = await getGitRoot(repoDir);
+    const gitRoot = await getMainRepoRoot(repoDir);
     const worktreePath = safeJoin(path.join(gitRoot, '.agents', 'worktrees'), worktreeName);
     const branchName = `agents/${worktreeName}`;
     try {
@@ -183,3 +198,44 @@ export function getWorktreePath(gitRoot, worktreeName) {
 export function getWorktreeBranch(worktreeName) {
     return `agents/${worktreeName}`;
 }
+/**
+ * Does the CHECKOUT DIRECTORY for this worktree name exist?
+ *
+ * Narrower than {@link worktreeExists}, and the difference is load-bearing:
+ * `teams add` only ever cleans up after a failed create when there is NO
+ * checkout — i.e. when all that can be left is a dangling `agents/<name>`
+ * branch ref. That keeps the cleanup incapable of deleting anybody's files,
+ * including a concurrent add's freshly-created worktree, whatever the
+ * pre-flight probe saw a `git fetch` ago. (RUSH-2356)
+ */
+export async function worktreeCheckoutExists(repoDir, worktreeName) {
+    if (!WORKTREE_NAME_RE.test(worktreeName)) {
+        throw new Error(`Invalid worktree name: ${worktreeName}`);
+    }
+    const gitRoot = await getMainRepoRoot(repoDir);
+    const dir = safeJoin(path.join(gitRoot, '.agents', 'worktrees'), worktreeName);
+    return fs.stat(dir).then(() => true).catch(() => false);
+}
+/**
+ * Does anything already exist under this worktree name — the checkout directory
+ * or its `agents/<name>` branch?
+ *
+ * Answered from git and the filesystem, never from teammate records: it is asked
+ * by `teams add` immediately BEFORE {@link createWorktree}, so that if the create
+ * fails the command can tell "the branch ref I half-created" (safe to remove)
+ * from "something that was already here" (never remove — `teams stop` deliberately
+ * KEEPS a worktree holding uncommitted changes, and its teammate record is
+ * terminal by then, so no record-based check can protect it). (RUSH-2356)
+ */
+export async function worktreeExists(repoDir, worktreeName) {
+    if (await worktreeCheckoutExists(repoDir, worktreeName))
+        return true;
+    const gitRoot = await getMainRepoRoot(repoDir);
+    try {
+        await execFileAsync('git', ['rev-parse', '--verify', '--quiet', `refs/heads/${getWorktreeBranch(worktreeName)}`], { cwd: gitRoot });
+        return true;
+    }
+    catch {
+        return false; // `--verify` exits non-zero when the ref doesn't exist
+    }
+}

package/dist/lib/types.d.ts

@@ -587,6 +587,17 @@ export interface PluginManifest {
     description: string;
     version: string;
     agents?: AgentId[];
+    /**
+     * Who published the plugin, per the official plugin format. Every plugin.json
+     * in this repo already carries one; it was missing from this interface, so
+     * `loadPluginManifest`'s cast passed it through un-typed and no surface read it.
+     * Accepts the shorthand string form as well as the object form.
+     */
+    author?: string | {
+        name: string;
+        email?: string;
+        url?: string;
+    };
     /** Interactive config fields prompted at install time. Values stored in .user-config.json. */
     userConfig?: PluginUserConfigField[];
     /** Other plugin names this plugin depends on. Missing deps produce a warning. */

package/dist/lib/versions.js

@@ -31,7 +31,7 @@ import { activeRulesPreset, filterNamesForActiveResourceProfile } from './resour
 import { VERSION_RE, compareVersions } from './agent-spec/primitives.js';
 import { AGENTS, agentConfigDirName, getAccountEmail, resolveAgentName, formatAgentError, findInPath, isSelfUpdatingAgent, isAgentHardDeprecated, hardDeprecationError } from './agents.js';
 import { discoverPermissionGroups, getActivePermissionPresetName, readPermissionPresetRecipe, PERMISSION_PRESET_ENV_VAR } from './permissions.js';
-import { parseMcpServerConfig, isProjectMcpTrusted } from './mcp.js';
+import { parseMcpConfigForScan, isProjectMcpTrusted } from './mcp.js';
 import { createVersionedAlias, removeVersionedAlias, getConfigSymlinkVersion, ensureClaudeInsideSymlink, assertIsolationBoundary, } from './shims.js';
 import { importInstallScriptBinary } from './import.js';
 import { createInstallation } from './installations/store.js';
@@ -84,7 +84,7 @@ function getScopedMcpResources(cwd) {
         const files = fs.readdirSync(mcpDir)
             .filter(f => f.endsWith('.yaml') || f.endsWith('.yml'));
         for (const file of files) {
-            const config = parseMcpServerConfig(path.join(mcpDir, file));
+            const config = parseMcpConfigForScan(path.join(mcpDir, file));
             if (config?.name && !resources.has(config.name)) {
                 resources.set(config.name, { name: config.name, scope });
             }

package/dist/lib/watchdog/history.d.ts

@@ -0,0 +1,20 @@
+import type { WatchdogEvent, WatchdogEventKind } from './log.js';
+export interface WatchdogHistoryEntry {
+    ts: number;
+    kind: WatchdogEventKind | 'inspection';
+    sessionId?: string;
+    agent?: string;
+    message: string;
+    reason?: string;
+    stalledForMs?: number;
+    nudgeText?: string;
+}
+export interface WatchdogHistoryOptions {
+    limit?: number;
+    sinceMs?: number;
+    sessionId?: string;
+    includeTicks?: boolean;
+    nowMs?: number;
+}
+/** Select newest history and deliberately remove raw transcript tailLines. */
+export declare function selectWatchdogHistory(events: WatchdogEvent[], options?: WatchdogHistoryOptions): WatchdogHistoryEntry[];

package/dist/lib/watchdog/history.js

@@ -0,0 +1,46 @@
+/** Select newest history and deliberately remove raw transcript tailLines. */
+export function selectWatchdogHistory(events, options = {}) {
+    const limit = options.limit ?? 50;
+    const cutoff = options.sinceMs === undefined
+        ? Number.NEGATIVE_INFINITY
+        : (options.nowMs ?? Date.now()) - options.sinceMs;
+    const session = options.sessionId?.toLowerCase();
+    const expanded = events.flatMap((event) => {
+        const inspections = event.inspections?.map((inspection) => ({
+            ts: event.ts,
+            kind: 'inspection',
+            sessionId: inspection.terminalId,
+            agent: inspection.agentType,
+            message: inspection.message,
+            reason: inspection.reason,
+            stalledForMs: inspection.stalledForMs,
+        })) ?? [];
+        if (event.kind === 'tick' && !options.includeTicks)
+            return inspections;
+        return [...inspections, {
+                ts: event.ts,
+                kind: event.kind,
+                sessionId: event.terminalId,
+                agent: event.agentType,
+                message: event.message,
+                reason: event.reason,
+                stalledForMs: event.stalledForMs,
+                nudgeText: event.nudgeText,
+            }];
+    });
+    const matching = expanded
+        .filter((entry) => entry.ts >= cutoff)
+        .filter((entry) => !session || entry.sessionId?.toLowerCase().startsWith(session))
+        .sort((a, b) => b.ts - a.ts);
+    if (matching.length <= limit)
+        return matching;
+    // A busy tick can contain more inspections than the display limit. Keep the
+    // newest timeline, but reserve one row for the newest real action.
+    const newest = matching.slice(0, limit);
+    if (newest.some((entry) => entry.kind !== 'inspection'))
+        return newest;
+    const newestAction = matching.find((entry) => entry.kind !== 'inspection');
+    if (!newestAction)
+        return newest;
+    return [...newest.slice(0, limit - 1), newestAction].sort((a, b) => b.ts - a.ts);
+}

package/dist/lib/watchdog/log.d.ts

@@ -19,7 +19,19 @@ export interface WatchdogEvent {
     lastAssistantMessage?: string;
     /** For a 'decision'/'nudge' that injects: the exact text delivered. */
     nudgeText?: string;
+    /** Compact per-session evaluations carried by heartbeat ticks. */
+    inspections?: WatchdogInspection[];
 }
+export interface WatchdogInspection {
+    terminalId?: string;
+    agentType: string;
+    message: string;
+    reason: string;
+    stalledForMs?: number;
+}
+/** Parse the audit log without letting a partial final append hide valid rows. */
+export declare function parseWatchdogEvents(text: string): WatchdogEvent[];
+export declare function readWatchdogEvents(logPath?: string): WatchdogEvent[];
 /** Serialize one event to a JSONL line (no trailing newline). */
 export declare function formatEvent(ev: WatchdogEvent): string;
 /**
@@ -27,7 +39,10 @@ export declare function formatEvent(ev: WatchdogEvent): string;
  * writer trims (watchdogLog.ts trimToLast). Large enough to keep a useful
  * history, small enough to bound the file the UI polls.
  */
-export declare const WATCHDOG_LOG_MAX_LINES = 2000;
+export declare const WATCHDOG_LOG_MAX_LINES = 5000;
+export declare const WATCHDOG_TAIL_MAX_CHARS = 4096;
+/** Keep the newest transcript context without letting it consume the audit window. */
+export declare function boundTailLines(lines: string[], maxChars?: number): string[];
 /** Trim a JSONL body to the last `maxLines` events (same logic as the reader). */
 export declare function trimToLast(text: string, maxLines: number): string;
 /**

package/dist/lib/watchdog/log.js

@@ -18,6 +18,65 @@ import * as path from 'path';
 import { withFileLock, atomicWriteFileSync, ensureLockTarget } from '../fs-atomic.js';
 /** Same path the Factory reader pulls (apps/factory/src/core/watchdogLog.ts). */
 export const WATCHDOG_LOG_PATH = path.join(os.homedir(), '.agents', '.cache', 'logs', 'watchdog.log');
+const WATCHDOG_EVENT_KINDS = new Set(['tick', 'decision', 'nudge', 'rotate', 'error']);
+/** Parse the audit log without letting a partial final append hide valid rows. */
+export function parseWatchdogEvents(text) {
+    const events = [];
+    for (const line of text.split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            const value = JSON.parse(line);
+            if (typeof value.ts !== 'number' ||
+                !Number.isFinite(value.ts) ||
+                typeof value.kind !== 'string' ||
+                !WATCHDOG_EVENT_KINDS.has(value.kind) ||
+                typeof value.message !== 'string')
+                continue;
+            const inspections = Array.isArray(value.inspections)
+                ? value.inspections.flatMap((item) => {
+                    if (item === null || typeof item !== 'object')
+                        return [];
+                    const row = item;
+                    if (typeof row.agentType !== 'string' || typeof row.message !== 'string' || typeof row.reason !== 'string')
+                        return [];
+                    return [{
+                            terminalId: typeof row.terminalId === 'string' ? row.terminalId : undefined,
+                            agentType: row.agentType,
+                            message: row.message,
+                            reason: row.reason,
+                            stalledForMs: typeof row.stalledForMs === 'number' ? row.stalledForMs : undefined,
+                        }];
+                })
+                : undefined;
+            events.push({
+                ts: value.ts,
+                kind: value.kind,
+                message: value.message,
+                terminalId: typeof value.terminalId === 'string' ? value.terminalId : undefined,
+                agentType: typeof value.agentType === 'string' ? value.agentType : undefined,
+                reason: typeof value.reason === 'string' ? value.reason : undefined,
+                tailLines: Array.isArray(value.tailLines)
+                    ? value.tailLines.filter((item) => typeof item === 'string')
+                    : undefined,
+                stalledForMs: typeof value.stalledForMs === 'number' ? value.stalledForMs : undefined,
+                lastUserMessage: typeof value.lastUserMessage === 'string' ? value.lastUserMessage : undefined,
+                lastAssistantMessage: typeof value.lastAssistantMessage === 'string' ? value.lastAssistantMessage : undefined,
+                nudgeText: typeof value.nudgeText === 'string' ? value.nudgeText : undefined,
+                inspections,
+            });
+        }
+        catch {
+            // Interrupted writers can leave one partial row; earlier rows remain useful.
+        }
+    }
+    return events;
+}
+export function readWatchdogEvents(logPath = WATCHDOG_LOG_PATH) {
+    if (!fs.existsSync(logPath))
+        return [];
+    return parseWatchdogEvents(fs.readFileSync(logPath, 'utf8'));
+}
 /** Serialize one event to a JSONL line (no trailing newline). */
 export function formatEvent(ev) {
     return JSON.stringify(ev);
@@ -27,7 +86,25 @@ export function formatEvent(ev) {
  * writer trims (watchdogLog.ts trimToLast). Large enough to keep a useful
  * history, small enough to bound the file the UI polls.
  */
-export const WATCHDOG_LOG_MAX_LINES = 2000;
+export const WATCHDOG_LOG_MAX_LINES = 5000;
+export const WATCHDOG_TAIL_MAX_CHARS = 4096;
+/** Keep the newest transcript context without letting it consume the audit window. */
+export function boundTailLines(lines, maxChars = WATCHDOG_TAIL_MAX_CHARS) {
+    const kept = [];
+    let remaining = maxChars;
+    for (let i = lines.length - 1; i >= 0 && remaining > 0; i--) {
+        const line = lines[i];
+        if (line.length <= remaining) {
+            kept.unshift(line);
+            remaining -= line.length;
+        }
+        else {
+            kept.unshift(line.slice(-remaining));
+            remaining = 0;
+        }
+    }
+    return kept;
+}
 /** Trim a JSONL body to the last `maxLines` events (same logic as the reader). */
 export function trimToLast(text, maxLines) {
     const lines = text.split('\n').filter((l) => l.trim().length > 0);
@@ -58,7 +135,10 @@ export function appendWatchdogEvents(events, opts = {}) {
             catch {
                 /* first write — no file yet */
             }
-            const appended = events.map(formatEvent).join('\n') + '\n';
+            const boundedEvents = events.map((event) => event.tailLines === undefined
+                ? event
+                : { ...event, tailLines: boundTailLines(event.tailLines) });
+            const appended = boundedEvents.map(formatEvent).join('\n') + '\n';
             const body = trimToLast(existing + appended, maxLines);
             atomicWriteFileSync(logPath, body);
         });

package/dist/lib/watchdog/runner.d.ts

@@ -137,7 +137,19 @@ export interface SessionOutcome {
     kind: string;
     host?: string;
     cwd?: string;
+    project?: string | null;
     label?: string;
+    name?: string;
+    topic?: string;
+    preview?: string;
+    activity?: ActiveSession['activity'];
+    status?: ActiveSession['status'];
+    startedAtMs?: number;
+    lastActivityMs?: number;
+    origin?: ActiveSession['origin'];
+    routineName?: string;
+    machine?: string;
+    owner?: string;
     /** classifyTerminal's verdict for this session. */
     stall: StallStatus['kind'];
     /** stalled duration (ms), when stalled. */

package/dist/lib/watchdog/runner.js

@@ -409,7 +409,19 @@ export async function runWatchdogTick(opts = {}) {
             kind: session.kind,
             host: session.host,
             cwd: session.cwd,
+            project: session.project,
             label: session.label,
+            name: session.name,
+            topic: session.topic,
+            preview: session.preview,
+            activity: session.activity,
+            status: session.status,
+            startedAtMs: session.startedAtMs,
+            lastActivityMs: session.lastActivityMs,
+            origin: session.origin,
+            routineName: session.routineName,
+            machine: session.machine ?? session.provenance?.host,
+            owner: session.owner,
             policy,
             stall: 'active',
             decision: 'skip',
@@ -429,6 +441,7 @@ export async function runWatchdogTick(opts = {}) {
             continue;
         }
         const lastActivityMs = lastActivityFor(session);
+        base.lastActivityMs = session.lastActivityMs ?? lastActivityMs;
         if (lastActivityMs === undefined) {
             outcomes.push({ ...base, reason: 'no activity timestamp (no transcript / start time)' });
             continue;
@@ -878,6 +891,13 @@ export async function runWatchdogTick(opts = {}) {
         ts: nowMs,
         kind: 'tick',
         message: `${counts.total} live · ${counts.stalled} stalled · ${counts.nudged} nudged · ${counts.unaddressable} un-addressable`,
+        inspections: outcomes.map((outcome) => ({
+            terminalId: outcome.sessionId,
+            agentType: outcome.kind,
+            message: outcome.decision,
+            reason: outcome.reason,
+            stalledForMs: outcome.stalledForMs,
+        })),
     });
     appendWatchdogEvents(logEvents, { logPath: opts.logPath });
     return result;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.22.32",
+  "version": "1.22.34",
   "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",