@phnx-labs/agents-cli 1.22.112 → 1.22.114

package/dist/lib/menubar/download-menubar.js

@@ -20,7 +20,7 @@
  * before the bundle is ever installed. This matches the release-time gate in
  * `scripts/verify-menubar-helper.sh`.
  */
-import { EXPECTED_TEAM_ID, downloadHelperApp, helperAssetUrls, helperCacheDir, verifyHelperApp, } from '../helper-download.js';
+import { EXPECTED_TEAM_ID, downloadHelperApp, helperAssetUrls, helperCacheDir } from '../helper-download.js';
 /** The zipped `.app` release asset name. */
 export const MENUBAR_HELPER_ASSET = 'MenubarHelper.app.zip';
 /** The bundle directory name once extracted. */
@@ -50,10 +50,6 @@ export function menubarHelperAssetUrls(version) {
 export function menubarHelperCacheDir(version) {
     return helperCacheDir(MENUBAR_HELPER_SPEC, version);
 }
-/** Verify a menu-bar helper `.app`: codesign + Team + DR pin + notarization. */
-export function verifyMenubarHelper(appPath) {
-    verifyHelperApp(appPath, MENUBAR_HELPER_SPEC);
-}
 /**
  * Download the menu-bar helper release asset for `version`, verify sha256 +
  * signature + DR pin, and return the path to the extracted `MenubarHelper.app`

package/dist/lib/menubar/install-menubar.d.ts

@@ -45,7 +45,7 @@ export declare function serviceLabel(): string;
  */
 /** Version label for a bundle that has none of its own (a local dev build). */
 export declare const LOCAL_BUILD_LABEL = "local";
-export type MenubarStamp = {
+type MenubarStamp = {
     source: 'release';
     helperVersion: string;
 } | {
@@ -64,10 +64,6 @@ export type MenubarStamp = {
  * package, or a dev checkout without a built bundle).
  */
 export declare function resolveInstalledMenubarExecutable(): string | null;
-/** True if the user explicitly disabled the menu bar (don't auto-enable on upgrade). */
-export declare function menubarDisabledByUser(): boolean;
-/** True if the launchd plist for the menu-bar service is installed. */
-export declare function menubarServiceInstalled(): boolean;
 /** Where a downloaded copy of the floor release sits once fetched and verified. */
 export declare function cachedFloorBundlePath(): string;
 /**
@@ -76,14 +72,6 @@ export declare function cachedFloorBundlePath(): string;
  * The startup self-heal installs from here, network-free.
  */
 export declare function cachedReleaseBundlePath(): string;
-/**
- * The release version an explicit install should fetch: the newest published
- * build, but never below what this Mac already runs — a release deleted after
- * it was installed must not roll the helper back through `setup`/`enable`.
- */
-export declare function menubarVersionToInstall(opts?: {
-    force?: boolean;
-}): Promise<string>;
 /** True when the bundle carries a signature the kernel will accept at launch. */
 export declare function codesignVerifies(appPath: string): boolean;
 /**
@@ -526,7 +514,7 @@ export declare function isMenubarProcessStaleAgainstBundle(pidStartedAtMs: numbe
  */
 export declare function buildMenubarDoctorReport(): MenubarDoctorReport;
 /** Outcome of one auto-update pass (`updateMenubarHelperIfNewer`). */
-export interface MenubarUpdateResult {
+interface MenubarUpdateResult {
     outcome: 'updated' | 'current' | 'skipped' | 'failed';
     installed: string | null;
     available: string;
@@ -567,3 +555,4 @@ export declare function updateMenubarHelperIfNewer(opts?: {
     dryRun?: boolean;
     force?: boolean;
 }): Promise<MenubarUpdateResult>;
+export {};

package/dist/lib/menubar/install-menubar.js

@@ -155,11 +155,11 @@ function disabledSentinelPath() {
     return path.join(getRuntimeStateDir(), 'menubar.disabled');
 }
 /** True if the user explicitly disabled the menu bar (don't auto-enable on upgrade). */
-export function menubarDisabledByUser() {
+function menubarDisabledByUser() {
     return fs.existsSync(disabledSentinelPath());
 }
 /** True if the launchd plist for the menu-bar service is installed. */
-export function menubarServiceInstalled() {
+function menubarServiceInstalled() {
     return onDarwin() && fs.existsSync(servicePlistPath());
 }
 /**
@@ -238,7 +238,7 @@ export function cachedReleaseBundlePath() {
  * build, but never below what this Mac already runs — a release deleted after
  * it was installed must not roll the helper back through `setup`/`enable`.
  */
-export async function menubarVersionToInstall(opts = {}) {
+async function menubarVersionToInstall(opts = {}) {
     const resolved = await resolveMenubarVersion({ force: opts.force });
     const installed = readInstalledMenubarStamp();
     if (installed?.source === 'release' && compareVersions(installed.helperVersion, resolved) > 0)

package/dist/lib/menubar/migrate-prefs.d.ts

@@ -0,0 +1,53 @@
+/**
+ * One-time, CLI-owned migration of AGI Menu preferences from the macOS
+ * UserDefaults domain `com.phnx-labs.agents-menubar` into the registered
+ * `menubar.menu.*` config keys (PHNX-3999).
+ *
+ * Why here: before the preferences became `agents config` keys, the stable menu
+ * bar stored them in its own UserDefaults. A user upgrading must keep those
+ * settings, but the CLI is now the single source of truth and syncs fleet-wide,
+ * so the values are lifted into config ONCE and then owned there.
+ *
+ * The rules (from the integration contract) are all fail-safe:
+ *   - macOS only. On any other platform this is a no-op (Linux derives canonical
+ *     config only).
+ *   - The PRODUCTION domain only — never the dev bundle
+ *     `com.phnx-labs.agents-menubar.dev` (we simply never read it).
+ *   - Import only KNOWN keys ({@link MENUBAR_MENU_PROPERTIES}) that are still
+ *     UNSET in config — an already-set (synced) value is never overridden.
+ *   - One-shot, gated by a sentinel, so a later `agents config unset` cannot
+ *     resurrect the legacy value on the next run.
+ *
+ * The stable app stores each preference under its FULL `menubar.menu.*` key name
+ * (the Swift MenuPreferences local-cache key), so the migration matches on the
+ * full name. If a key is stored under a different name, it simply is not matched
+ * and the migration stays a safe no-op for it. The read uses `defaults export
+ * <domain> -` piped through `plutil` (NOT `defaults read <domain> -json`, which
+ * treats `-json` as a key and errors).
+ */
+/**
+ * Pure plan step: which UserDefaults entries should be imported. The stable app
+ * stores each preference under its FULL `menubar.menu.*` key name (the Swift
+ * MenuPreferences local-cache key), so we match on the full name — only known
+ * keys that are present in `userDefaults` AND currently unset in config
+ * (`isUnset`) are imported, so an already-set value is preserved. Values are
+ * returned raw; the caller coerces + validates them against each key's spec.
+ */
+export declare function planMenubarPrefMigration(userDefaults: Record<string, unknown>, isUnset: (fullName: string) => boolean): Array<{
+    name: string;
+    value: unknown;
+}>;
+/**
+ * Coerce a raw UserDefaults value to the type its config key expects. The
+ * `plutil` scalar output is text, but a bool can arrive as
+ * 0/1 or "true"/"false" and an int as a numeric string, so normalize before
+ * validation. Returns undefined for a value that cannot be coerced (skipped,
+ * never forced).
+ */
+export declare function coerceMenubarPrefValue(name: string, raw: unknown): unknown;
+/**
+ * Run the one-shot migration. macOS only, gated by the sentinel, best-effort:
+ * any failure is swallowed (a migration must never break the snapshot read that
+ * calls it) and a failed read remains eligible for a later retry.
+ */
+export declare function migrateMenubarPreferencesFromUserDefaults(): void;

package/dist/lib/menubar/migrate-prefs.js

@@ -0,0 +1,168 @@
+/**
+ * One-time, CLI-owned migration of AGI Menu preferences from the macOS
+ * UserDefaults domain `com.phnx-labs.agents-menubar` into the registered
+ * `menubar.menu.*` config keys (PHNX-3999).
+ *
+ * Why here: before the preferences became `agents config` keys, the stable menu
+ * bar stored them in its own UserDefaults. A user upgrading must keep those
+ * settings, but the CLI is now the single source of truth and syncs fleet-wide,
+ * so the values are lifted into config ONCE and then owned there.
+ *
+ * The rules (from the integration contract) are all fail-safe:
+ *   - macOS only. On any other platform this is a no-op (Linux derives canonical
+ *     config only).
+ *   - The PRODUCTION domain only — never the dev bundle
+ *     `com.phnx-labs.agents-menubar.dev` (we simply never read it).
+ *   - Import only KNOWN keys ({@link MENUBAR_MENU_PROPERTIES}) that are still
+ *     UNSET in config — an already-set (synced) value is never overridden.
+ *   - One-shot, gated by a sentinel, so a later `agents config unset` cannot
+ *     resurrect the legacy value on the next run.
+ *
+ * The stable app stores each preference under its FULL `menubar.menu.*` key name
+ * (the Swift MenuPreferences local-cache key), so the migration matches on the
+ * full name. If a key is stored under a different name, it simply is not matched
+ * and the migration stays a safe no-op for it. The read uses `defaults export
+ * <domain> -` piped through `plutil` (NOT `defaults read <domain> -json`, which
+ * treats `-json` as a key and errors).
+ */
+import { execFileSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import { assertValidValue, configKeySpec, getConfigValue, setConfigValue } from '../device-config.js';
+import { getRuntimeStateDir } from '../state.js';
+import { MENUBAR_MENU_PROPERTIES } from '../config-keys.js';
+/** The production menu-bar UserDefaults domain (NOT the `.dev` bundle). */
+const USER_DEFAULTS_DOMAIN = 'com.phnx-labs.agents-menubar';
+/** Sentinel marking the one-shot done; its presence blocks every later run. */
+function sentinelPath() {
+    return path.join(getRuntimeStateDir(), 'menubar-prefs-migrated');
+}
+/**
+ * Pure plan step: which UserDefaults entries should be imported. The stable app
+ * stores each preference under its FULL `menubar.menu.*` key name (the Swift
+ * MenuPreferences local-cache key), so we match on the full name — only known
+ * keys that are present in `userDefaults` AND currently unset in config
+ * (`isUnset`) are imported, so an already-set value is preserved. Values are
+ * returned raw; the caller coerces + validates them against each key's spec.
+ */
+export function planMenubarPrefMigration(userDefaults, isUnset) {
+    const plan = [];
+    for (const prop of MENUBAR_MENU_PROPERTIES) {
+        const name = `menubar.menu.${prop}`;
+        if (!(name in userDefaults))
+            continue;
+        if (!isUnset(name))
+            continue;
+        plan.push({ name, value: userDefaults[name] });
+    }
+    return plan;
+}
+/**
+ * Coerce a raw UserDefaults value to the type its config key expects. The
+ * `plutil` scalar output is text, but a bool can arrive as
+ * 0/1 or "true"/"false" and an int as a numeric string, so normalize before
+ * validation. Returns undefined for a value that cannot be coerced (skipped,
+ * never forced).
+ */
+export function coerceMenubarPrefValue(name, raw) {
+    const type = configKeySpec(name).type;
+    if (type === 'bool') {
+        if (typeof raw === 'boolean')
+            return raw;
+        if (raw === 1 || raw === '1' || raw === 'true' || raw === 'YES')
+            return true;
+        if (raw === 0 || raw === '0' || raw === 'false' || raw === 'NO')
+            return false;
+        return undefined;
+    }
+    if (type === 'int') {
+        if (typeof raw === 'number' && Number.isInteger(raw))
+            return raw;
+        if (typeof raw === 'string' && /^\d+$/.test(raw.trim()))
+            return Number.parseInt(raw.trim(), 10);
+        return undefined;
+    }
+    return typeof raw === 'string' ? raw : undefined;
+}
+/**
+ * Read known scalar preferences from the production domain.
+ *
+ * `defaults read <domain> -json` does NOT exist — `defaults read` treats `-json`
+ * as a KEY name and errors. The correct read is `defaults export <domain> -`,
+ * which writes the domain's plist to stdout (an EMPTY plist, exit 0, when the
+ * domain is absent — a legitimate "nothing to migrate"), read one known scalar key at a time with `plutil -extract … raw`. Other
+ * defaults may contain dates or data that cannot be represented as JSON.
+ *
+ * Returns `{ ok }` so the caller can tell a genuine read/convert FAILURE (do not
+ * write the sentinel — retry next run) from an ABSENT domain (ok, empty values —
+ * mark done). A failure never fabricates an empty map.
+ */
+function readUserDefaultsDomain() {
+    try {
+        const plist = execFileSync('defaults', ['export', USER_DEFAULTS_DOMAIN, '-'], {
+            encoding: 'utf8', timeout: 5_000,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        const values = {};
+        for (const property of MENUBAR_MENU_PROPERTIES) {
+            const key = `menubar.menu.${property}`;
+            try {
+                values[key] = execFileSync('plutil', ['-extract', key.replaceAll('.', '\\.'), 'raw', '-o', '-', '-'], {
+                    input: plist, encoding: 'utf8', timeout: 5_000, stdio: ['pipe', 'pipe', 'ignore'],
+                }).trimEnd();
+            }
+            catch {
+                // Missing or non-scalar legacy keys are outside the preference contract.
+            }
+        }
+        return { ok: true, values };
+    }
+    catch {
+        // `defaults`/`plutil` missing, a non-zero exit, or malformed output — a real
+        // failure. Do NOT claim an empty domain; the caller must retry.
+        return { ok: false, values: {} };
+    }
+}
+/**
+ * Run the one-shot migration. macOS only, gated by the sentinel, best-effort:
+ * any failure is swallowed (a migration must never break the snapshot read that
+ * calls it) and a failed read remains eligible for a later retry.
+ */
+export function migrateMenubarPreferencesFromUserDefaults() {
+    if (process.platform !== 'darwin')
+        return;
+    const sentinel = sentinelPath();
+    if (fs.existsSync(sentinel))
+        return;
+    const { ok, values } = readUserDefaultsDomain();
+    // A genuine read/convert failure must NOT mark the migration done — retry on a
+    // later run rather than silently skipping the user's real settings forever. An
+    // ABSENT domain reads ok with empty values and legitimately marks done.
+    if (!ok)
+        return;
+    try {
+        const plan = planMenubarPrefMigration(values, (name) => getConfigValue(name).value === undefined);
+        for (const { name, value } of plan) {
+            const coerced = coerceMenubarPrefValue(name, value);
+            if (coerced === undefined)
+                continue; // unrepresentable — skip, never force
+            try {
+                assertValidValue(configKeySpec(name), coerced);
+            }
+            catch {
+                continue;
+            }
+            setConfigValue(name, coerced);
+        }
+    }
+    catch {
+        return;
+    }
+    try {
+        fs.mkdirSync(path.dirname(sentinel), { recursive: true });
+        fs.writeFileSync(sentinel, new Date().toISOString() + '\n');
+    }
+    catch {
+        /* if we cannot mark it, a later run retries — still safe (idempotent) */
+    }
+}

package/dist/lib/menubar/resolve-version.d.ts

@@ -18,10 +18,6 @@
  * (`downloadMenubarHelperApp`: sha256, codesign, Team, designated-requirement
  * pin, notarization) is unchanged — resolution only chooses the version.
  */
-/** The repo whose releases carry `menubar/v*` tags (same as the download URL). */
-export declare const MENUBAR_RELEASES_API = "https://api.github.com/repos/phnx-labs/agi-cli/releases?per_page=100";
-/** How long a resolved answer is trusted before the release list is re-read. */
-export declare const MENUBAR_RESOLVE_TTL_MS: number;
 /** One release as the resolver sees it — the subset of the GitHub shape it reads. */
 export interface ReleaseCandidate {
     tagName: string;
@@ -29,7 +25,7 @@ export interface ReleaseCandidate {
     draft?: boolean;
     prerelease?: boolean;
 }
-export interface MenubarResolveCache {
+interface MenubarResolveCache {
     /** Epoch ms of the release-list read this answer came from. */
     checkedAt: number;
     /** The newest published helper version at that time (never below the floor then). */
@@ -41,8 +37,6 @@ export interface MenubarResolveCache {
  * pre-release, and carry both the zip and its `.sha256`.
  */
 export declare function pickNewestMenubarVersion(candidates: ReleaseCandidate[], floor: string): string;
-/** Where the resolved answer lives: beside the helper's own download cache. */
-export declare function menubarResolveCachePath(): string;
 export declare function readMenubarResolveCache(file: string): MenubarResolveCache | null;
 /**
  * The cached answer when it is usable offline: at or above the floor, of any
@@ -61,8 +55,6 @@ type FetchLike = (input: string, init?: {
     status: number;
     json(): Promise<unknown>;
 }>;
-/** Read the release list. Unauthenticated: release metadata is public and this runs at most once a day per machine. */
-export declare function fetchMenubarReleaseCandidates(fetchImpl?: FetchLike): Promise<ReleaseCandidate[]>;
 /**
  * The helper version to install now: the newest published build >= floor.
  *

package/dist/lib/menubar/resolve-version.js

@@ -26,9 +26,9 @@ import { helperFloor } from '../helper-versions.js';
 import { getCliVersion } from '../version.js';
 import { MENUBAR_HELPER_ASSET } from './download-menubar.js';
 /** The repo whose releases carry `menubar/v*` tags (same as the download URL). */
-export const MENUBAR_RELEASES_API = 'https://api.github.com/repos/phnx-labs/agi-cli/releases?per_page=100';
+const MENUBAR_RELEASES_API = 'https://api.github.com/repos/phnx-labs/agi-cli/releases?per_page=100';
 /** How long a resolved answer is trusted before the release list is re-read. */
-export const MENUBAR_RESOLVE_TTL_MS = 24 * 60 * 60 * 1000;
+const MENUBAR_RESOLVE_TTL_MS = 24 * 60 * 60 * 1000;
 const TAG = /^menubar\/v(\d+\.\d+\.\d+)$/;
 /**
  * Pure: the newest candidate at or above `floor`, else the floor. A tag must be
@@ -51,7 +51,7 @@ export function pickNewestMenubarVersion(candidates, floor) {
     return best;
 }
 /** Where the resolved answer lives: beside the helper's own download cache. */
-export function menubarResolveCachePath() {
+function menubarResolveCachePath() {
     return path.join(getCacheDir(), 'menubar', 'latest.json');
 }
 export function readMenubarResolveCache(file) {
@@ -84,7 +84,7 @@ export function cachedMenubarVersion(opts = {}) {
     return cache && compareVersions(cache.version, floor) >= 0 ? cache.version : floor;
 }
 /** Read the release list. Unauthenticated: release metadata is public and this runs at most once a day per machine. */
-export async function fetchMenubarReleaseCandidates(fetchImpl = fetch) {
+async function fetchMenubarReleaseCandidates(fetchImpl = fetch) {
     const res = await fetchImpl(MENUBAR_RELEASES_API, {
         headers: {
             Accept: 'application/vnd.github+json',

package/dist/lib/menubar/snapshot.d.ts

@@ -8,14 +8,20 @@ import type { WatchdogTickResult } from '../watchdog/runner.js';
  * is deliberately NOT claimed here (the registry's cached tailscale flag is
  * documented as stale in both directions — registry.ts isLikelyOnline).
  */
-export interface MenubarDevice {
+interface MenubarDevice {
     name: string;
     platform: string;
+    /**
+     * Physical form factor for a factual hardware icon: `laptop` | `desktop` |
+     * `server` | `unknown` (PHNX-3999). A shared device-scope config fact set
+     * explicitly per device — never inferred from `platform`. `unknown` when unset.
+     */
+    formFactor: string;
     interactive: boolean;
     isLocal: boolean;
     preferred: boolean;
 }
-export interface MenubarSnapshot {
+interface MenubarSnapshot {
     version: 1;
     capturedAt: string;
     /**
@@ -29,11 +35,27 @@ export interface MenubarSnapshot {
     recentSessions: Record<string, unknown>[];
     activeSessions: Record<string, unknown>[];
     devices: MenubarDevice[];
+    /**
+     * AGI Menu preferences (PHNX-3999), keyed by the full `menubar.menu.*` config
+     * name, carrying the EFFECTIVE value — the stored value, else the registered
+     * default. The native menu consumes this from the snapshot it already polls
+     * rather than a second preference-read mechanism. `menubar.menu.defaultProject`
+     * is omitted when unset (it has no default); every other key is always present.
+     * Writes stay one `agents config set/unset <key>` per setting.
+     */
+    menuPreferences: Record<string, unknown>;
     watchdog: {
         enabled: boolean;
         lastTick: Pick<WatchdogTickResult, 'didNudge' | 'counts'> | null;
     };
 }
+/**
+ * The effective AGI Menu preferences map for the snapshot: each `menubar.menu.*`
+ * key's stored value, or its registered default when unset. A key with neither
+ * (only `defaultProject`) is omitted so the native app keeps its own default.
+ */
+export declare function buildMenuPreferences(): Record<string, unknown>;
 export declare function readLastWatchdogTick(stateDir?: string): WatchdogTickResult | null;
 /** One-process read model for AGI Menu's repeating three-minute refresh. */
 export declare function computeMenubarSnapshot(): Promise<MenubarSnapshot>;
+export {};

package/dist/lib/menubar/snapshot.js

@@ -3,12 +3,31 @@ import * as path from 'path';
 import { buildRoutineListJson } from '../scheduling/routines.js';
 import { backfillActiveRowsFromIndex, isRunningLiveSession, serializeActiveSessionsForJson, serializeSessionsJson } from '../session/active.js';
 import { getConfigValue, loadAutoLaunchPreferences } from '../device-config.js';
+import { MENUBAR_MENU_PROPERTIES } from '../config-keys.js';
+import { migrateMenubarPreferencesFromUserDefaults } from './migrate-prefs.js';
 import { loadDevices } from '../devices/registry.js';
 import { machineId } from '../machine-id.js';
 import { querySessions } from '../session/db.js';
 import { readActiveSessionsCache } from '../session/session-cache.js';
 import { getRuntimeStateDir } from '../state.js';
 import { getCliVersion } from '../version.js';
+/**
+ * The effective AGI Menu preferences map for the snapshot: each `menubar.menu.*`
+ * key's stored value, or its registered default when unset. A key with neither
+ * (only `defaultProject`) is omitted so the native app keeps its own default.
+ */
+export function buildMenuPreferences() {
+    const out = {};
+    for (const prop of MENUBAR_MENU_PROPERTIES) {
+        const name = `menubar.menu.${prop}`;
+        const entry = getConfigValue(name);
+        const value = entry.value !== undefined ? entry.value : entry.spec.defaultValue;
+        if (value === undefined)
+            continue; // unset defaultProject — no default to emit
+        out[name] = value;
+    }
+    return out;
+}
 /**
  * The full registered-device roster for the menu bar, from the local registry
  * file only (no ssh, no stats probe) — as cheap as `buildRoutineListJson()`, so
@@ -26,6 +45,8 @@ async function buildMenubarDevices() {
         .map((name) => ({
         name,
         platform: reg[name].platform,
+        // Shared device-scope fact (readable for any device); `unknown` when unset.
+        formFactor: getConfigValue('formFactor', { device: name }).value ?? 'unknown',
         interactive: name === interactiveHost,
         isLocal: name === self,
         preferred: prefs[name]?.preferred === true,
@@ -41,6 +62,10 @@ export function readLastWatchdogTick(stateDir = path.join(getRuntimeStateDir(),
 }
 /** One-process read model for AGI Menu's repeating three-minute refresh. */
 export async function computeMenubarSnapshot() {
+    // One-shot, sentinel-gated, macOS-only lift of legacy UserDefaults prefs into
+    // config before we read them. After the first run it is a cheap existsSync
+    // no-op; it never throws into the snapshot.
+    migrateMenubarPreferencesFromUserDefaults();
     const [routines, recent, devices] = await Promise.all([
         Promise.resolve(buildRoutineListJson()),
         Promise.resolve(querySessions({ limit: 40, skipExistenceCheck: true })),
@@ -69,6 +94,7 @@ export async function computeMenubarSnapshot() {
         recentSessions: JSON.parse(serializeSessionsJson(recent)),
         activeSessions: serializeActiveSessionsForJson(activeSessions),
         devices,
+        menuPreferences: buildMenuPreferences(),
         watchdog: {
             enabled: getConfigValue('watchdog.enabled').value === true,
             lastTick: (() => {

package/dist/lib/model-tier-overrides.d.ts

@@ -22,8 +22,8 @@
  */
 import type { AgentId } from './types.js';
 import { type ModelTier } from './model-tiers.js';
-export type TierOverrideMap = Partial<Record<ModelTier, string>>;
-export interface TierOverrideEntry {
+type TierOverrideMap = Partial<Record<ModelTier, string>>;
+interface TierOverrideEntry {
     selector: string;
     tiers: TierOverrideMap;
 }
@@ -41,3 +41,4 @@ export declare function listTierOverrides(): TierOverrideEntry[];
 export declare function setTierOverride(selectorInput: string, tierInput: string | ModelTier, model: string): TierOverrideEntry;
 /** Clear one tier (or all tiers when `tierInput` is omitted) for a selector. Returns true if anything changed. */
 export declare function clearTierOverride(selectorInput: string, tierInput?: string): boolean;
+export {};

package/dist/lib/monitors/config.d.ts

@@ -262,5 +262,3 @@ export declare function writeMonitor(config: MonitorConfig): void;
 export declare function deleteMonitor(name: string): boolean;
 /** Enable or disable a monitor by name. */
 export declare function setMonitorEnabled(name: string, enabled: boolean): void;
-/** Check whether a monitor with the given name exists on disk. */
-export declare function monitorExists(name: string): boolean;

package/dist/lib/monitors/config.js

@@ -500,7 +500,3 @@ export function setMonitorEnabled(name, enabled) {
     monitor.enabled = enabled;
     writeMonitor(monitor);
 }
-/** Check whether a monitor with the given name exists on disk. */
-export function monitorExists(name) {
-    return readMonitor(name) !== null;
-}

package/dist/lib/monitors/engine.d.ts

@@ -29,7 +29,7 @@ interface MonitorLivenessLike {
     droughtNotifiedAt?: string;
 }
 /** The fire/no-fire decision for one observation, plus what to persist. */
-export interface FireDecision {
+interface FireDecision {
     fire: boolean;
     /** The value whose de-dupe signature is stored on persist. */
     value: string;

package/dist/lib/monitors/remote.d.ts

@@ -49,7 +49,7 @@ export interface RemoteMonitor {
  * must never blank the guard for the rest of the fleet.
  */
 export declare function parseRemoteMonitors(stdout: string, machine: string): RemoteMonitor[];
-export interface FleetMonitorsResult {
+interface FleetMonitorsResult {
     monitors: RemoteMonitor[];
     /** Target discovery failed before any peer was dialed — the fleet was not
      *  consulted at all, which must not read as "no duplicate anywhere". */
@@ -58,7 +58,7 @@ export interface FleetMonitorsResult {
      *  silently treating "we could not ask" as "there is no duplicate". */
     skipped: string[];
 }
-export interface GatherFleetMonitorsOptions {
+interface GatherFleetMonitorsOptions {
     /** When supplied, the fan-out aborts as soon as any peer returns a monitor with
      *  this behavioral fingerprint. The miss path still waits for every peer so the
      *  guard can prove absence fleet-wide. */
@@ -80,3 +80,4 @@ export interface GatherFleetMonitorsOptions {
  * knowable once every peer has answered.
  */
 export declare function gatherFleetMonitors(options?: GatherFleetMonitorsOptions): Promise<FleetMonitorsResult>;
+export {};

package/dist/lib/monitors/sources/webhook.d.ts

@@ -2,22 +2,9 @@
  * Webhook source evaluator.
  *
  * Webhooks are push-based (an inbound signed HTTP delivery), so the poll-model
- * `evaluate` returns null. When a delivery arrives, the receiver matches it
- * against monitors with `matchWebhook`, which reuses the github/linear matchers
- * from lib/triggers/webhook.ts by projecting the monitor's webhook filters onto a
- * synthesized JobConfig-shaped trigger.
+ * `evaluate` returns null.
  */
-import { type IncomingWebhook } from '../../triggers/webhook.js';
-import type { JobTrigger } from '../../scheduling/routines.js';
-import type { MonitorSource, MonitorConfig } from '../config.js';
+import type { MonitorSource } from '../config.js';
 import type { Observation } from './types.js';
 /** Push-only: nothing to snapshot on a poll tick. */
 export declare function evaluate(_source: MonitorSource): Promise<Observation | null>;
-/** Project a monitor's webhook source onto a JobTrigger for the shared matcher. */
-export declare function monitorTrigger(source: MonitorSource): JobTrigger | null;
-/**
- * True when an incoming webhook matches this monitor's webhook source — reuses
- * the routines matcher (lib/triggers/webhook.ts) so github/linear filter
- * semantics stay in one place.
- */
-export declare function matchWebhook(monitor: MonitorConfig, webhook: IncomingWebhook): boolean;

package/dist/lib/monitors/sources/webhook.js

@@ -2,46 +2,9 @@
  * Webhook source evaluator.
  *
  * Webhooks are push-based (an inbound signed HTTP delivery), so the poll-model
- * `evaluate` returns null. When a delivery arrives, the receiver matches it
- * against monitors with `matchWebhook`, which reuses the github/linear matchers
- * from lib/triggers/webhook.ts by projecting the monitor's webhook filters onto a
- * synthesized JobConfig-shaped trigger.
+ * `evaluate` returns null.
  */
-import { jobMatchesWebhook } from '../../triggers/webhook.js';
 /** Push-only: nothing to snapshot on a poll tick. */
 export function evaluate(_source) {
     return Promise.resolve(null);
 }
-/** Project a monitor's webhook source onto a JobTrigger for the shared matcher. */
-export function monitorTrigger(source) {
-    const w = source.webhook;
-    if (!w)
-        return null;
-    if (w.source === 'github') {
-        return {
-            type: 'github_event',
-            event: w.event,
-            ...(w.repo ? { repo: w.repo } : {}),
-            ...(w.branch ? { branch: w.branch } : {}),
-        };
-    }
-    return {
-        type: 'linear_event',
-        event: w.event,
-        ...(w.action ? { action: w.action } : {}),
-        ...(w.teamKey ? { teamKey: w.teamKey } : {}),
-        ...(w.label ? { label: w.label } : {}),
-    };
-}
-/**
- * True when an incoming webhook matches this monitor's webhook source — reuses
- * the routines matcher (lib/triggers/webhook.ts) so github/linear filter
- * semantics stay in one place.
- */
-export function matchWebhook(monitor, webhook) {
-    const trigger = monitorTrigger(monitor.source);
-    if (!trigger)
-        return false;
-    const shim = { name: monitor.name, trigger };
-    return jobMatchesWebhook(shim, webhook);
-}