@phnx-labs/agents-cli 1.22.113 → 1.22.115

package/dist/lib/commands.d.ts

@@ -8,9 +8,9 @@
  */
 import type { AgentId, CommandInstallation } from './types.js';
 /** Scope of a command: user-global or project-local. */
-export type CommandScope = 'user' | 'project';
+type CommandScope = 'user' | 'project';
 /** Parsed metadata from a command file's YAML frontmatter. */
-export interface CommandMetadata {
+interface CommandMetadata {
     name: string;
     description: string;
     /** When set, sync only to these agents (aliases resolved at parse time). */
@@ -22,8 +22,8 @@ export interface CommandMetadata {
     /** Alternate names this command also resolves under (frontmatter `aliases:`). */
     aliases?: string[];
 }
-export type CommandApplyFailReason = 'unsupported' | 'agent_excluded' | 'too_old' | 'too_new';
-export type CommandApplyResult = {
+type CommandApplyFailReason = 'unsupported' | 'agent_excluded' | 'too_old' | 'too_new';
+type CommandApplyResult = {
     ok: true;
 } | {
     ok: false;
@@ -36,7 +36,6 @@ export type CommandApplyResult = {
  * (or commands-as-skills) capability gate.
  */
 export declare function commandAppliesTo(agent: AgentId, version: string, metadata: Pick<CommandMetadata, 'agents' | 'since' | 'until'> | null | undefined): CommandApplyResult;
-export declare function explainCommandSkip(agent: AgentId, version: string, commandName: string, result: CommandApplyResult): string;
 /** Result of validating command metadata. */
 export interface ValidationResult {
     valid: boolean;
@@ -44,7 +43,7 @@ export interface ValidationResult {
     warnings: string[];
 }
 /** A command discovered in a repository's commands/ directory. */
-export interface DiscoveredCommand {
+interface DiscoveredCommand {
     name: string;
     description: string;
     sourcePath: string;
@@ -52,7 +51,7 @@ export interface DiscoveredCommand {
     validation: ValidationResult;
 }
 /** A command installed in an agent's config directory. */
-export interface InstalledCommand {
+interface InstalledCommand {
     name: string;
     scope: CommandScope;
     path: string;
@@ -164,3 +163,4 @@ export declare function getCommandInfo(name: string): {
     path: string;
     content: string;
 } | null;
+export {};

package/dist/lib/commands.js

@@ -58,7 +58,7 @@ export function commandAppliesTo(agent, version, metadata) {
     }
     return { ok: true };
 }
-export function explainCommandSkip(agent, version, commandName, result) {
+function explainCommandSkip(agent, version, commandName, result) {
     if (result.ok)
         return '';
     const tag = `${agent}@${version}`;

package/dist/lib/comms-render.d.ts

@@ -10,7 +10,7 @@ export declare const GLYPH: {
     readonly stream: "─→";
     readonly thread: "⇄";
 };
-export type Accent = 'cyan' | 'amber';
+type Accent = 'cyan' | 'amber';
 /** Render the shared one-line comms header, with `right` aligned to the terminal edge. */
 export declare function masthead(o: {
     title: string;

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

@@ -48,12 +48,12 @@ export interface ComputerTargetContext {
     sshArgs: string[];
 }
 /** Who is acting, so the engine can stamp the action it reports back. */
-export interface ComputerSessionContext {
+interface ComputerSessionContext {
     sessionId?: string;
     launchId?: string;
     actor: string;
 }
-export interface ComputerContext {
+interface ComputerContext {
     version: 1;
     permissions?: {
         allow: string[];
@@ -64,13 +64,20 @@ export interface ComputerContext {
     target?: ComputerTargetContext;
     session: ComputerSessionContext;
 }
-export interface BuildContextOptions {
+interface BuildContextOptions {
     /** `--device <name>`, if given. */
     device?: string;
     /** Direct host targeting, which bypasses fleet resolution. */
     host?: string;
     /** Resolved path of the standalone executable, for the peer allow list. */
     computerBin?: string;
+    /**
+     * A precomputed target (PHNX-4090: `resolveDeviceHost` in `commands/computer.ts`
+     * already resolved the device's `computer.host` config, or the ssh fallback).
+     * When present, `device` is used only to gate the local-permissions branch
+     * below — this skips a second, possibly Windows-gated, fleet resolution.
+     */
+    target?: ComputerTargetContext;
 }
 /**
  * Build the context handed to the engine on fd 3.
@@ -81,3 +88,4 @@ export interface BuildContextOptions {
  * layer that can actually see the device's platform.
  */
 export declare function buildComputerContext(opts?: BuildContextOptions): Promise<ComputerContext>;
+export {};

package/dist/lib/computer/context.js

@@ -59,8 +59,8 @@ function agentSessionId(env = process.env) {
  * layer that can actually see the device's platform.
  */
 export async function buildComputerContext(opts = {}) {
-    let target;
-    if (opts.device) {
+    let target = opts.target;
+    if (!target && opts.device) {
         const resolved = await resolveRemoteDevice(opts.device, {
             expectPlatform: 'windows',
             forWhat: '`agents computer --device` drives the Windows computer-helper daemon, so it',

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

@@ -22,18 +22,6 @@ export declare function loadComputerAllowList(): string[];
 export declare function loadDefaultPeers(opts?: {
     computerBin?: string;
 }): string[];
-/**
- * Parse a `host:port` VNC endpoint, defaulting the port to 5901. Pure.
- *
- * Kept on the consumer side because the `--vnc` FLAG is parsed here — the
- * platform gate has to know whether a remote desktop was named before the
- * engine is ever spawned (see `shouldBlockOffPlatform`). The RFB protocol
- * implementation itself went to the engine.
- */
-export declare function parseVncEndpoint(raw: string | undefined): {
-    host: string;
-    port: number;
-} | null;
 export declare function resolveTcpEndpoint(): {
     host: string;
     port: number;

package/dist/lib/computer/policy.js

@@ -120,7 +120,7 @@ export function loadDefaultPeers(opts = {}) {
  * engine is ever spawned (see `shouldBlockOffPlatform`). The RFB protocol
  * implementation itself went to the engine.
  */
-export function parseVncEndpoint(raw) {
+function parseVncEndpoint(raw) {
     if (!raw || raw.length === 0)
         return null;
     const idx = raw.lastIndexOf(':');

package/dist/lib/computer/sessions-list.d.ts

@@ -26,7 +26,61 @@ export interface ComputerAction {
     agent?: string;
     machineId?: string;
     hostname?: string;
+    /**
+     * The file a successful `screenshot` action actually wrote.
+     *
+     * Recorded by the standalone engine only AFTER the write succeeded, so its
+     * presence is proof the file existed — which is why nothing here ever derives
+     * a path from the verb. An action from before the producer carried this field
+     * has no capture, and that is reported honestly as none rather than guessed at
+     * from an output flag that may never have been written.
+     */
+    capture?: {
+        path: string;
+        kind: 'screenshot';
+        name: string;
+        bytes?: number;
+    };
 }
+/**
+ * The standalone engine's OWN action ledger.
+ *
+ * `agents computer` is a thin consumer of the standalone `computer` engine
+ * (PHNX-4075), and that engine ALWAYS appends every action it performs to
+ * `<cache>/computer/actions/<day>.jsonl` — independently of whether agents-cli
+ * was in the call at all. So a `computer` command the operator ran directly
+ * appears ONLY here: it never reached `recordComputerAction`, so it is in
+ * neither the feed event ledger nor `computer_sessions`. Reading only those two
+ * meant the actions an operator actually performed were invisible to every
+ * agents-cli surface.
+ */
+export declare function standaloneComputerActionsDir(): string;
+/**
+ * Read the standalone ledger, newest day first, bounded by `limit` actions.
+ *
+ * Bounded by construction: days are read newest-first and reading stops as soon
+ * as the budget is met, so a box with months of history costs the same as one
+ * with a day of it.
+ */
+export declare function listStandaloneComputerActions(opts?: {
+    limit?: number;
+    dir?: string;
+    observer?: string;
+}): ComputerAction[];
+/**
+ * Union the two ledgers, preferring the standalone record for any run present in
+ * both.
+ *
+ * Dedupe keys on `invocationId`, NOT on a timestamp or pid. When a command is
+ * forwarded through `agents computer`, BOTH stores receive it — and the
+ * forwarding rewrites `ts` and `pid` on the way through, so the two copies of one
+ * action do not agree on either. `invocationId` is minted by the engine and
+ * echoed unchanged, which makes it the only field that identifies the same run in
+ * both files. A legacy feed record with no invocationId cannot be matched to
+ * anything, so it is kept: dropping it would lose history the standalone ledger
+ * never had.
+ */
+export declare function mergeComputerActionSources(standalone: ComputerAction[], legacy: ComputerAction[]): ComputerAction[];
 /** Read `computer.action` events straight from the durable event ledger,
  *  newest first, bounded by `limit`. Malformed/legacy records (missing
  *  `command` or `pid`, or an unparseable `ts`) are skipped, never thrown —
@@ -94,6 +148,7 @@ export declare function groupIntoComputerRuns(actions: ComputerAction[], resolve
 export declare function buildComputerSessionRows(opts?: {
     limit?: number;
     machine?: string;
+    observer?: string;
 }): ComputerRunRow[];
 /**
  * Search predicate for the interactive picker: task text, machine/remote

package/dist/lib/computer/sessions-list.js

@@ -58,6 +58,10 @@
  * `sessionId` doesn't resolve (a rotated/unindexed session) but `launchId`
  * still does via the more authoritative pid registry.
  */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { getCacheDir } from '../state.js';
+import { machineId } from '../machine-id.js';
 import { query, truncate } from '../feed/events.js';
 import { formatRelativeTime } from '../session/relative-time.js';
 import { getSessionById, listComputerSessionRecords, pruneToolSessions } from '../session/db.js';
@@ -70,6 +74,21 @@ export const TASK_PREVIEW_MAX_CHARS = 200;
  *  already reads newest-first and stops at this cutoff mid-scan, so raising
  *  it only ever costs as much as the history actually holds. */
 const DEFAULT_ACTION_LIMIT = 5000;
+/** A capture record, accepted only when the producer gave a real path + name. */
+function parseActionCapture(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const record = value;
+    if (typeof record.path !== 'string' || !record.path)
+        return undefined;
+    const name = typeof record.name === 'string' && record.name ? record.name : path.basename(record.path);
+    return {
+        path: record.path,
+        kind: 'screenshot',
+        name,
+        ...(typeof record.bytes === 'number' ? { bytes: record.bytes } : {}),
+    };
+}
 function recordToAction(r) {
     if (typeof r.command !== 'string' || typeof r.pid !== 'number')
         return null;
@@ -91,8 +110,153 @@ function recordToAction(r) {
         agent: typeof r.agent === 'string' ? r.agent : undefined,
         machineId: typeof r.machineId === 'string' ? r.machineId : undefined,
         hostname: typeof r.hostname === 'string' ? r.hostname : undefined,
+        capture: parseActionCapture(r.capture),
     };
 }
+/**
+ * The standalone engine's OWN action ledger.
+ *
+ * `agents computer` is a thin consumer of the standalone `computer` engine
+ * (PHNX-4075), and that engine ALWAYS appends every action it performs to
+ * `<cache>/computer/actions/<day>.jsonl` — independently of whether agents-cli
+ * was in the call at all. So a `computer` command the operator ran directly
+ * appears ONLY here: it never reached `recordComputerAction`, so it is in
+ * neither the feed event ledger nor `computer_sessions`. Reading only those two
+ * meant the actions an operator actually performed were invisible to every
+ * agents-cli surface.
+ */
+export function standaloneComputerActionsDir() {
+    return path.join(getCacheDir(), 'computer', 'actions');
+}
+/**
+ * One line of the standalone ledger as a {@link ComputerAction}.
+ *
+ * The on-disk record is the same `computer.action` event the engine reports on
+ * fd 4 — the contract `computer-client.ts` `ComputerActionEvent` already
+ * describes and `recordComputerAction` already consumes — so this maps the same
+ * fields rather than inventing a second vocabulary. A record missing the two
+ * fields that make it an action at all (`command`, a parseable timestamp) is
+ * skipped, never defaulted: the file is plain JSONL another process may be
+ * mid-append to.
+ */
+function standaloneLineToAction(line, observer) {
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== 'object')
+        return null;
+    const record = parsed;
+    const verb = typeof record.command === 'string' ? record.command : undefined;
+    const ts = typeof record.ts === 'string' ? record.ts : undefined;
+    if (!verb || !ts)
+        return null;
+    const tsMs = Date.parse(ts);
+    if (Number.isNaN(tsMs))
+        return null;
+    const text = (key) => (typeof record[key] === 'string' ? record[key] : undefined);
+    const num = (key) => (typeof record[key] === 'number' ? record[key] : undefined);
+    // The producer identifies the DRIVEN host only for a remote run, and emits no
+    // `hostname`/`machineId` of its own at all. Defaulting those to the observing
+    // machine HERE, at the source, is what keeps a direct local action attributable:
+    // without it `groupIntoComputerRuns` fell back to `machine: 'unknown'`, the row's
+    // device read `unknown`, and every locally-run `computer` action vanished the
+    // moment a consumer filtered by device. The observer IS the machine that ran it
+    // — this ledger is per-machine by construction, written by the engine on the box
+    // it ran on — so the fallback is a fact, not a guess. An explicit `host` still
+    // wins, because that names a genuinely different driven machine.
+    return {
+        verb, ts, tsMs,
+        // The engine's pid is its own; a record without one still groups by
+        // invocationId, which is the identity that actually matters here.
+        pid: num('pid') ?? 0,
+        invocationId: text('invocationId'),
+        targetPid: num('targetPid'),
+        bundle: text('bundle'),
+        host: text('host'),
+        task: text('task'),
+        sessionId: text('sessionId'),
+        launchId: text('launchId'),
+        agent: text('agent'),
+        machineId: text('machineId'),
+        hostname: text('hostname') ?? observer,
+        capture: parseActionCapture(record.capture),
+    };
+}
+/**
+ * Read the standalone ledger, newest day first, bounded by `limit` actions.
+ *
+ * Bounded by construction: days are read newest-first and reading stops as soon
+ * as the budget is met, so a box with months of history costs the same as one
+ * with a day of it.
+ */
+export function listStandaloneComputerActions(opts = {}) {
+    const dir = opts.dir ?? standaloneComputerActionsDir();
+    const limit = opts.limit ?? DEFAULT_ACTION_LIMIT;
+    // This ledger is per-machine by construction, so "who ran it" is this machine
+    // unless the record names a driven remote host.
+    const observer = opts.observer ?? machineId();
+    let days;
+    try {
+        days = fs.readdirSync(dir).filter((name) => name.endsWith('.jsonl')).sort().reverse();
+    }
+    catch {
+        return []; // The engine has never run here, or is not installed.
+    }
+    const out = [];
+    for (const day of days) {
+        if (out.length >= limit)
+            break;
+        let lines;
+        try {
+            lines = fs.readFileSync(path.join(dir, day), 'utf8').split('\n');
+        }
+        catch {
+            continue; /* rotated or removed mid-read */
+        }
+        // Newest last within a day, and the budget favours the newest actions.
+        for (let index = lines.length - 1; index >= 0 && out.length < limit; index--) {
+            const line = lines[index];
+            if (!line)
+                continue;
+            const action = standaloneLineToAction(line, observer);
+            if (action)
+                out.push(action);
+        }
+    }
+    out.sort((a, b) => b.tsMs - a.tsMs);
+    return out;
+}
+/**
+ * Union the two ledgers, preferring the standalone record for any run present in
+ * both.
+ *
+ * Dedupe keys on `invocationId`, NOT on a timestamp or pid. When a command is
+ * forwarded through `agents computer`, BOTH stores receive it — and the
+ * forwarding rewrites `ts` and `pid` on the way through, so the two copies of one
+ * action do not agree on either. `invocationId` is minted by the engine and
+ * echoed unchanged, which makes it the only field that identifies the same run in
+ * both files. A legacy feed record with no invocationId cannot be matched to
+ * anything, so it is kept: dropping it would lose history the standalone ledger
+ * never had.
+ */
+export function mergeComputerActionSources(standalone, legacy) {
+    const standaloneRuns = new Set();
+    for (const action of standalone)
+        if (action.invocationId)
+            standaloneRuns.add(action.invocationId);
+    const merged = [...standalone];
+    for (const action of legacy) {
+        if (action.invocationId && standaloneRuns.has(action.invocationId))
+            continue;
+        merged.push(action);
+    }
+    merged.sort((a, b) => b.tsMs - a.tsMs);
+    return merged;
+}
 /** Read `computer.action` events straight from the durable event ledger,
  *  newest first, bounded by `limit`. Malformed/legacy records (missing
  *  `command` or `pid`, or an unparseable `ts`) are skipped, never thrown —
@@ -240,7 +404,10 @@ function appendPrunedRunsFromDb(rows, limit) {
  *  flat/`--json` printer's) data source. `machine` narrows to rows whose
  *  invoking hostname, machineId, or `--device` target contains the substring. */
 export function buildComputerSessionRows(opts = {}) {
-    const actions = listComputerActions({ limit: opts.limit });
+    const actions = mergeComputerActionSources(
+    // `observer` is threaded from the caller's scope so a row's device and the
+    // scope that reported it can never name the same box differently.
+    listStandaloneComputerActions({ limit: opts.limit, ...(opts.observer ? { observer: opts.observer } : {}) }), listComputerActions({ limit: opts.limit }));
     const index = buildLaunchSessionIndex();
     const rows = groupIntoComputerRuns(actions, (sessionId) => getSessionById(sessionId), (launchId) => resolveLaunchSession(index, launchId));
     // Retention runs here, on the listing path, never on the action hot path:

package/dist/lib/computer-client.d.ts

@@ -114,7 +114,7 @@ export declare function parseEventLines(buffer: string): {
     events: ComputerActionEvent[];
     rest: string;
 };
-export interface RunComputerOptions {
+interface RunComputerOptions {
     /** argv handed to the standalone, after the program name. */
     argv: string[];
     /** The consumer context serialized onto fd 3. */
@@ -131,7 +131,7 @@ export interface RunComputerOptions {
      */
     capture?: boolean;
 }
-export interface RunComputerResult {
+interface RunComputerResult {
     exitCode: number;
     /** Engine stdout, only when `capture` was set. */
     stdout: string;
@@ -147,4 +147,4 @@ export interface RunComputerResult {
 export declare function runComputer(opts: RunComputerOptions): Promise<RunComputerResult>;
 /** Test seam: drop the memoized bin so PATH fixtures can re-resolve. */
 export declare function _resetComputerClientForTest(): void;
-export declare const COMPUTER_INSTALL_HINT = "npm i -g @phnx-labs/computer-cli";
+export {};

package/dist/lib/computer-client.js

@@ -219,4 +219,3 @@ function osSignalNumber(signal) {
 export function _resetComputerClientForTest() {
     cachedBin = undefined;
 }
-export const COMPUTER_INSTALL_HINT = INSTALL_HINT;

package/dist/lib/concurrency.d.ts

@@ -10,10 +10,11 @@
  * `lsof`, multi-dotfile scans) reads to behavioral EDR as recon/enumeration. A
  * bounded, spread-out spawn rate produces the same data without the burst signature.
  */
-export interface BoundedMapOptions {
+interface BoundedMapOptions {
     /** Maximum number of `fn` calls running at once. Coerced to >= 1. */
     concurrency: number;
     /** Minimum spacing (ms) between successive task starts. 0 (default) = no spacing. */
     staggerMs?: number;
 }
 export declare function mapBounded<T, R>(items: readonly T[], fn: (item: T, index: number) => Promise<R>, opts: BoundedMapOptions): Promise<R[]>;
+export {};

package/dist/lib/config-keys.d.ts

@@ -9,7 +9,14 @@
 import type { AgentId } from './types.js';
 import { type ModelTier } from './model-tiers.js';
 /** The top-level scope of a unified config key. */
-export type ConfigScope = 'run' | 'interactive' | 'auto' | 'browser' | 'project' | 'device' | 'summarizer' | 'updates';
+export type ConfigScope = 'run' | 'interactive' | 'auto' | 'browser' | 'project' | 'device' | 'summarizer' | 'updates' | 'menubar';
+/**
+ * The AGI Menu preference leaf names under `menubar.menu.*` (PHNX-3999). The
+ * types, defaults, and enum validation for each live in `device-config.ts`'s
+ * CONFIG_KEYS (user scope); this list is only the parser's allow-set so an
+ * unknown `menubar.menu.<x>` fails loud here instead of at the store.
+ */
+export declare const MENUBAR_MENU_PROPERTIES: readonly ["defaultProject", "workingRowsShown", "showPreviews", "projectPriorityFilter", "hideCompletedMilestones", "bannerWhenNeedsYou", "includeOtherDeviceRequests", "groupBy", "thenBy", "projectScope", "projectSort", "ticketSort", "showPullRequests"];
 /** A run-time default key: model, mode, effort, or tier override. */
 export interface ParsedRunConfigKey {
     scope: 'run';
@@ -60,8 +67,14 @@ export interface ParsedUpdatesConfigKey {
     property: 'auto';
     agent?: AgentId;
 }
-export type ParsedConfigKey = ParsedRunConfigKey | ParsedInteractiveConfigKey | ParsedAutoConfigKey | ParsedBrowserConfigKey | ParsedProjectConfigKey | ParsedDeviceConfigKey | ParsedSummarizerConfigKey | ParsedUpdatesConfigKey;
-export type DeviceConfigProperty = 'role' | 'max-agents' | 'scheduler' | 'daemon' | 'watchdog' | 'tmux' | 'browser.remote-control' | 'browser.task-idle-minutes' | 'notes' | 'browser.profile' | 'browser.viewer';
+/** An AGI Menu preference key: `menubar.menu.<property>` (user-scope, PHNX-3999). */
+export interface ParsedMenubarConfigKey {
+    scope: 'menubar';
+    /** Leaf name under `menubar.menu.` — one of {@link MENUBAR_MENU_PROPERTIES}. */
+    property: string;
+}
+export type ParsedConfigKey = ParsedRunConfigKey | ParsedInteractiveConfigKey | ParsedAutoConfigKey | ParsedBrowserConfigKey | ParsedProjectConfigKey | ParsedDeviceConfigKey | ParsedSummarizerConfigKey | ParsedUpdatesConfigKey | ParsedMenubarConfigKey;
+export type DeviceConfigProperty = 'role' | 'max-agents' | 'scheduler' | 'daemon' | 'watchdog' | 'tmux' | 'browser.remote-control' | 'browser.task-idle-minutes' | 'notes' | 'browser.profile' | 'browser.viewer' | 'computer.host' | 'formFactor';
 /** Normalize agent@version to use `@` consistently. */
 export declare function formatAgentVersion(agent: AgentId, version: string): string;
 /**

package/dist/lib/config-keys.js

@@ -9,6 +9,27 @@
 import { AGENTS } from './agents.js';
 import { MODEL_TIERS } from './model-tiers.js';
 import { VERSION_RE } from './run-defaults.js';
+/**
+ * The AGI Menu preference leaf names under `menubar.menu.*` (PHNX-3999). The
+ * types, defaults, and enum validation for each live in `device-config.ts`'s
+ * CONFIG_KEYS (user scope); this list is only the parser's allow-set so an
+ * unknown `menubar.menu.<x>` fails loud here instead of at the store.
+ */
+export const MENUBAR_MENU_PROPERTIES = [
+    'defaultProject',
+    'workingRowsShown',
+    'showPreviews',
+    'projectPriorityFilter',
+    'hideCompletedMilestones',
+    'bannerWhenNeedsYou',
+    'includeOtherDeviceRequests',
+    'groupBy',
+    'thenBy',
+    'projectScope',
+    'projectSort',
+    'ticketSort',
+    'showPullRequests',
+];
 const DEVICE_CONFIG_PROPERTIES = [
     'browser.viewer',
     'role',
@@ -21,6 +42,8 @@ const DEVICE_CONFIG_PROPERTIES = [
     'browser.task-idle-minutes',
     'notes',
     'browser.profile',
+    'computer.host',
+    'formFactor',
 ];
 /** Split an agent@version token into its parts. Accepts both `@` and `:`. */
 function parseAgentVersion(token) {
@@ -98,6 +121,14 @@ export function parseConfigKey(key) {
     if (summarizerMatch) {
         return { scope: 'summarizer', property: summarizerMatch[1] };
     }
+    const menubarMatch = raw.match(/^menubar\.menu\.(.+)$/);
+    if (menubarMatch) {
+        const property = menubarMatch[1];
+        if (!MENUBAR_MENU_PROPERTIES.includes(property)) {
+            throw new Error(`Unknown AGI Menu preference '${key}'. Known keys: ${MENUBAR_MENU_PROPERTIES.map((p) => `menubar.menu.${p}`).join(', ')}.`);
+        }
+        return { scope: 'menubar', property };
+    }
     if (raw === 'updates.auto') {
         return { scope: 'updates', property: 'auto' };
     }
@@ -109,7 +140,7 @@ export function parseConfigKey(key) {
         }
         return { scope: 'updates', agent: agentPart, property: 'auto' };
     }
-    const deviceMatch = raw.match(/^devices\.(.+)\.(role|max-agents|scheduler|daemon|watchdog|tmux|notes|browser\.remote-control|browser\.task-idle-minutes|browser\.profile|browser\.viewer)$/);
+    const deviceMatch = raw.match(/^devices\.(.+)\.(role|max-agents|scheduler|daemon|watchdog|tmux|notes|formFactor|browser\.remote-control|browser\.task-idle-minutes|browser\.profile|browser\.viewer|computer\.host)$/);
     if (deviceMatch) {
         return {
             scope: 'device',
@@ -139,10 +170,13 @@ export function parseConfigKey(key) {
     if (raw.startsWith('updates.')) {
         throw new Error(`Invalid updates config key '${key}'. Use updates.auto or updates.<agent>.auto.`);
     }
+    if (raw.startsWith('menubar.')) {
+        throw new Error(`Invalid AGI Menu config key '${key}'. Use ${MENUBAR_MENU_PROPERTIES.map((p) => `menubar.menu.${p}`).join(', ')}.`);
+    }
     if (raw.startsWith('devices.')) {
         throw new Error(`Invalid device config key '${key}'. Expected devices.<name>.<${DEVICE_CONFIG_PROPERTIES.join('|')}>.`);
     }
-    throw new Error(`Unknown config scope in '${key}'. Use one of: run, interactive, auto, browser, project, devices, summarizer.`);
+    throw new Error(`Unknown config scope in '${key}'. Use one of: run, interactive, auto, browser, project, devices, summarizer, updates, menubar.`);
 }
 /** Render a parsed key back to its canonical dotted string. */
 export function formatConfigKey(parsed) {
@@ -168,6 +202,8 @@ export function formatConfigKey(parsed) {
             return `summarizer.${parsed.property}`;
         case 'updates':
             return parsed.agent ? `updates.${parsed.agent}.auto` : 'updates.auto';
+        case 'menubar':
+            return `menubar.menu.${parsed.property}`;
     }
 }
 /** List every canonical key the command documents, with wildcards expanded to a concrete example. */
@@ -178,6 +214,9 @@ export function listKnownConfigKeys() {
         keys.push(`run.<agent@version>.tier.${tier}`);
     }
     keys.push('interactive.host', 'auto.pool', 'browser.profile', 'browser.viewer', 'browser.device', 'project.root', 'summarizer.enabled', 'summarizer.baseUrl', 'summarizer.model', 'updates.auto', 'updates.<agent>.auto');
+    for (const prop of MENUBAR_MENU_PROPERTIES) {
+        keys.push(`menubar.menu.${prop}`);
+    }
     for (const prop of DEVICE_CONFIG_PROPERTIES) {
         keys.push(`devices.<name>.${prop}`);
     }
@@ -212,6 +251,10 @@ export function devicePropertyToConfigName(property) {
             return 'browser.profile';
         case 'browser.viewer':
             return 'browser.viewer';
+        case 'computer.host':
+            return 'computer.host';
+        case 'formFactor':
+            return 'formFactor';
     }
 }
 /**
@@ -253,5 +296,7 @@ export function configKeyStorageHint(parsed) {
             return parsed.agent
                 ? `config.updatesAgentAuto.${parsed.agent} (central agents.yaml; syncs fleet-wide)`
                 : 'config.updatesAuto (central agents.yaml; syncs fleet-wide)';
+        case 'menubar':
+            return `config.menubarMenu${parsed.property.charAt(0).toUpperCase()}${parsed.property.slice(1)} (central agents.yaml; syncs fleet-wide)`;
     }
 }

package/dist/lib/convert.d.ts

@@ -4,16 +4,6 @@
  * Handles frontmatter parsing and bidirectional translation so that slash commands
  * authored in one format can be synced to agents that expect the other.
  */
-/** Parsed YAML frontmatter from a Markdown command file. */
-export interface MarkdownFrontmatter {
-    description?: string;
-    [key: string]: unknown;
-}
-/** Extract YAML frontmatter and body from a Markdown string. Returns empty frontmatter if none found. */
-export declare function parseMarkdownFrontmatter(content: string): {
-    frontmatter: MarkdownFrontmatter;
-    body: string;
-};
 /** Convert a Markdown command file to Gemini's TOML format, translating $ARGUMENTS to {{args}}. */
 export declare function markdownToToml(skillName: string, markdown: string): string;
 /**
@@ -27,5 +17,3 @@ export declare function markdownToToml(skillName: string, markdown: string): str
  * Returns a plain object so the caller can `yaml.stringify` it.
  */
 export declare function markdownToGooseRecipe(commandName: string, markdown: string): Record<string, unknown>;
-/** Convert a Gemini TOML command file back to Markdown format, translating {{args}} to $ARGUMENTS. */
-export declare function tomlToMarkdown(toml: string): string;

package/dist/lib/convert.js

@@ -5,7 +5,7 @@
  * authored in one format can be synced to agents that expect the other.
  */
 /** Extract YAML frontmatter and body from a Markdown string. Returns empty frontmatter if none found. */
-export function parseMarkdownFrontmatter(content) {
+function parseMarkdownFrontmatter(content) {
     const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
     if (!match) {
         return { frontmatter: {}, body: content };
@@ -62,14 +62,3 @@ export function markdownToGooseRecipe(commandName, markdown) {
         prompt,
     };
 }
-/** Convert a Gemini TOML command file back to Markdown format, translating {{args}} to $ARGUMENTS. */
-export function tomlToMarkdown(toml) {
-    const nameMatch = toml.match(/name\s*=\s*"([^"]+)"/);
-    const descMatch = toml.match(/description\s*=\s*"([^"]+)"/);
-    const promptMatch = toml.match(/prompt\s*=\s*(?:'''|""")([\s\S]*?)(?:'''|""")/);
-    const description = descMatch?.[1] || '';
-    let prompt = promptMatch?.[1]?.trim() || '';
-    prompt = prompt.replace(/\{\{args\}\}/g, '$ARGUMENTS');
-    const lines = ['---', `description: ${description}`, '---', '', prompt, ''];
-    return lines.join('\n');
-}