@phnx-labs/agents-cli 1.22.120 → 1.22.121

package/dist/lib/rules/compose.d.ts

@@ -1,35 +1,12 @@
-/**
- * Rules composition — assemble a fully-inlined rules document from layered
- * `subrules/` fragments and `rules.yaml` preset definitions.
- *
- * The model:
- *   - Every DotAgents repo holds `<repo>/rules/subrules/*.md` (rule fragments)
- *     and `<repo>/rules/rules.yaml` (preset definitions).
- *   - Layers are read in precedence order (highest first):
- *       project > user > extra > system.
- *   - The active preset's `subrules:` list is resolved against the layer set
- *     using per-name shadowing — a project subrule shadows a user/system one
- *     of the same name.
- *   - Subrules in the user / extra / project layers that the preset did NOT
- *     name are auto-appended in precedence order. (System auto-append is
- *     opt-in only: system never auto-appends to avoid noise.)
- *   - Output is a single concatenated string with no `@-import` syntax.
- *
- * No filesystem writes happen here — callers (`syncResourcesToVersion`,
- * project-rules compile) decide where to land the composed output.
- */
 import type { ManifestHook } from '../types.js';
 export type LayerScope = 'project' | 'user' | 'extra' | 'system';
 export interface RulesLayer {
     scope: LayerScope;
     rulesDir: string;
-    /** Set when scope is 'extra'; undefined otherwise. */
     alias?: string;
 }
 interface ComposeOptions {
-    /** Defaults to `"default"`. */
     preset?: string;
-    /** Layers in precedence order, highest first. */
     layers: RulesLayer[];
 }
 export interface ComposedSubrule {
@@ -37,56 +14,23 @@ export interface ComposedSubrule {
     sourcePath: string;
     layerScope: LayerScope;
     layerAlias?: string;
-    /** Set when the subrule is dir-form (`subrules/<name>/`); the dir itself. */
     subruleDir?: string;
 }
 interface ComposeResult {
-    /** Fully concatenated, no @-imports. */
     content: string;
-    /** The preset name that was applied. */
     preset: string;
-    /** The layer that defined the preset. */
     presetLayer: LayerScope;
-    /** Subrules included, in concatenation order. */
     subrules: ComposedSubrule[];
 }
-/**
- * Compose a rules document from the given layers.
- *
- * Throws when the requested preset isn't defined in any layer's rules.yaml —
- * means the caller passed a typo or no layer ships the named preset.
- */
 export declare function composeRules(opts: ComposeOptions): ComposeResult;
-/**
- * Discover layers for use at sync time (no cwd) or runtime (with cwd).
- *
- * Project layer is included only when cwd is given AND `<cwd>/.agents/rules/`
- * exists. Without cwd, only user / extras / system are surfaced — matching
- * the home-file write at sync time.
- */
 export declare function discoverRulesLayers(opts?: {
     cwd?: string;
 }): RulesLayer[];
-/** Convenience wrapper — discovers layers from state, then composes. */
 export declare function composeRulesFromState(opts?: {
     preset?: string;
     cwd?: string;
 }): ComposeResult;
-/**
- * Collect hooks declared inside the active subrule directories.
- *
- * Resolves the same composed subrule set as {@link composeRules} (preset-named
- * plus auto-append, highest-layer-wins per name). For each dir-form subrule
- * that ships a `hooks.yaml`, parses it, rewrites each hook's `script` to an
- * ABSOLUTE path under the subrule dir, and namespaces the key as
- * `<subruleName>__<hookName>` to avoid collisions across subrules.
- *
- * Returns an empty map for flat subrules and dir-form subrules without a
- * `hooks.yaml`. A malformed hooks.yaml is skipped (try/catch) so a bad file
- * never breaks rule composition or hook registration.
- */
 export declare function collectSubruleHooks(layers: RulesLayer[], presetName?: string): Record<string, ManifestHook>;
-/** Convenience wrapper — discovers layers from state, then collects hooks. */
 export declare function collectSubruleHooksFromState(opts?: {
     preset?: string;
     cwd?: string;

package/dist/lib/rules/compose.js

@@ -1,23 +1,3 @@
-/**
- * Rules composition — assemble a fully-inlined rules document from layered
- * `subrules/` fragments and `rules.yaml` preset definitions.
- *
- * The model:
- *   - Every DotAgents repo holds `<repo>/rules/subrules/*.md` (rule fragments)
- *     and `<repo>/rules/rules.yaml` (preset definitions).
- *   - Layers are read in precedence order (highest first):
- *       project > user > extra > system.
- *   - The active preset's `subrules:` list is resolved against the layer set
- *     using per-name shadowing — a project subrule shadows a user/system one
- *     of the same name.
- *   - Subrules in the user / extra / project layers that the preset did NOT
- *     name are auto-appended in precedence order. (System auto-append is
- *     opt-in only: system never auto-appends to avoid noise.)
- *   - Output is a single concatenated string with no `@-import` syntax.
- *
- * No filesystem writes happen here — callers (`syncResourcesToVersion`,
- * project-rules compile) decide where to land the composed output.
- */
 import * as fs from 'fs';
 import * as path from 'path';
 import * as yaml from 'yaml';
@@ -26,18 +6,8 @@ const SUBRULES_DIR_NAME = 'subrules';
 const RULES_YAML_NAME = 'rules.yaml';
 const DEFAULT_PRESET = 'default';
 const SUBRULES_README = 'README.md';
-/** Inside a dir-form subrule, the prose file. */
 const SUBRULE_RULE_FILE = 'rule.md';
-/** Inside a dir-form subrule, the optional hook manifest. */
 const SUBRULE_HOOKS_FILE = 'hooks.yaml';
-/**
- * Resolve the prose file for a subrule named `name` under `<rulesDir>/subrules/`.
- *
- * A subrule resolves to the DIRECTORY form `subrules/<name>/rule.md` when that
- * file exists, otherwise the flat form `subrules/<name>.md`. Returns the
- * markdown path plus the dir-form subrule directory when applicable (callers
- * that fold hooks need the dir to resolve `hooks.yaml` and relative scripts).
- */
 function resolveSubrulePath(rulesDir, name) {
     const dirForm = path.join(rulesDir, SUBRULES_DIR_NAME, name, SUBRULE_RULE_FILE);
     if (fs.existsSync(dirForm)) {
@@ -79,11 +49,6 @@ function findSubrule(layers, name) {
     }
     return null;
 }
-/**
- * List subrule names in a layer. A name is contributed by either the flat
- * form `subrules/<name>.md` OR the dir form `subrules/<name>/rule.md`; a
- * directory without `rule.md` is not a subrule and is skipped.
- */
 function listLayerSubruleNames(layer) {
     const dir = path.join(layer.rulesDir, SUBRULES_DIR_NAME);
     if (!fs.existsSync(dir))
@@ -105,12 +70,6 @@ function listLayerSubruleNames(layer) {
         return [];
     }
 }
-/**
- * Compose a rules document from the given layers.
- *
- * Throws when the requested preset isn't defined in any layer's rules.yaml —
- * means the caller passed a typo or no layer ships the named preset.
- */
 export function composeRules(opts) {
     const presetName = opts.preset || DEFAULT_PRESET;
     const presetMatch = resolvePreset(opts.layers, presetName);
@@ -119,13 +78,12 @@ export function composeRules(opts) {
     }
     const composed = [];
     const seen = new Set();
-    // 1. Preset's named subrules, resolved by per-name shadowing.
     for (const name of presetMatch.def.subrules || []) {
         if (seen.has(name))
             continue;
         const found = findSubrule(opts.layers, name);
         if (!found)
-            continue; // missing subrule: skip silently — same as @-import miss
+            continue;
         composed.push({
             name,
             sourcePath: found.sourcePath,
@@ -135,8 +93,6 @@ export function composeRules(opts) {
         });
         seen.add(name);
     }
-    // 2. Auto-append: any subrule in a non-system layer not yet included.
-    //    Honors precedence — project layer's auto-appends come first.
     for (const layer of opts.layers) {
         if (layer.scope === 'system')
             continue;
@@ -156,8 +112,6 @@ export function composeRules(opts) {
             seen.add(name);
         }
     }
-    // 3. Concatenate. Trim trailing whitespace on each fragment so spacing is
-    //    predictable — fragments often end in a newline already.
     const parts = composed.map((c) => fs.readFileSync(c.sourcePath, 'utf-8').replace(/\s+$/, ''));
     const content = parts.length === 0 ? '' : parts.join('\n\n') + '\n';
     return {
@@ -167,13 +121,6 @@ export function composeRules(opts) {
         subrules: composed,
     };
 }
-/**
- * Discover layers for use at sync time (no cwd) or runtime (with cwd).
- *
- * Project layer is included only when cwd is given AND `<cwd>/.agents/rules/`
- * exists. Without cwd, only user / extras / system are surfaced — matching
- * the home-file write at sync time.
- */
 export function discoverRulesLayers(opts = {}) {
     const layers = [];
     if (opts.cwd) {
@@ -201,23 +148,10 @@ export function discoverRulesLayers(opts = {}) {
     }
     return layers;
 }
-/** Convenience wrapper — discovers layers from state, then composes. */
 export function composeRulesFromState(opts = {}) {
     const layers = discoverRulesLayers({ cwd: opts.cwd });
     return composeRules({ preset: opts.preset, layers });
 }
-/**
- * hooks.yaml shape (the bare-map form, chosen for brevity):
- *
- *   <hookName>:
- *     script: enforce.sh        # relative to the subrule dir
- *     events: [PreToolUse]
- *     matcher: "Edit|Write"     # optional
- *     timeout: 30               # optional
- *
- * A wrapped `{ hooks: { <hookName>: {...} } }` form is also accepted so a
- * hooks.yaml can carry sibling keys without confusing the parser.
- */
 function parseSubruleHooksFile(file) {
     const parsed = yaml.parse(fs.readFileSync(file, 'utf-8'));
     if (!parsed || typeof parsed !== 'object')
@@ -225,19 +159,6 @@ function parseSubruleHooksFile(file) {
     const map = parsed.hooks ?? parsed;
     return map || {};
 }
-/**
- * Collect hooks declared inside the active subrule directories.
- *
- * Resolves the same composed subrule set as {@link composeRules} (preset-named
- * plus auto-append, highest-layer-wins per name). For each dir-form subrule
- * that ships a `hooks.yaml`, parses it, rewrites each hook's `script` to an
- * ABSOLUTE path under the subrule dir, and namespaces the key as
- * `<subruleName>__<hookName>` to avoid collisions across subrules.
- *
- * Returns an empty map for flat subrules and dir-form subrules without a
- * `hooks.yaml`. A malformed hooks.yaml is skipped (try/catch) so a bad file
- * never breaks rule composition or hook registration.
- */
 export function collectSubruleHooks(layers, presetName) {
     const result = {};
     let composed;
@@ -249,7 +170,7 @@ export function collectSubruleHooks(layers, presetName) {
     }
     for (const sub of composed.subrules) {
         if (!sub.subruleDir)
-            continue; // flat subrule — no hooks
+            continue;
         const hooksFile = path.join(sub.subruleDir, SUBRULE_HOOKS_FILE);
         if (!fs.existsSync(hooksFile))
             continue;
@@ -263,12 +184,10 @@ export function collectSubruleHooks(layers, presetName) {
             }
         }
         catch {
-            // Malformed hooks.yaml — skip this subrule's hooks, keep the rest.
         }
     }
     return result;
 }
-/** Convenience wrapper — discovers layers from state, then collects hooks. */
 export function collectSubruleHooksFromState(opts = {}) {
     const layers = discoverRulesLayers({ cwd: opts.cwd });
     return collectSubruleHooks(layers, opts.preset);

package/dist/lib/rules/rules.d.ts

@@ -1,11 +1,3 @@
-/**
- * Rules file management -- reading, writing, and syncing agent instructions.
- *
- * The canonical rules file (AGENTS.md) gets synced
- * into each agent's config directory under their native name (CLAUDE.md,
- * GEMINI.md, etc.). This module handles reading, managing includes, and
- * refreshing rules files across version homes.
- */
 import type { AgentId } from '../types.js';
 type InstructionsScope = 'user' | 'project';
 interface InstalledInstructions {
@@ -19,14 +11,6 @@ interface DiscoveredInstructions {
     sourcePath: string;
     filename: string;
 }
-/**
- * Get the canonical central rules filename for an agent's instructionsFile.
- * Central storage uses AGENTS.md, which gets renamed per-agent when syncing:
- *   - Claude: AGENTS.md → CLAUDE.md
- *   - Gemini: AGENTS.md → GEMINI.md
- *   - Cursor: AGENTS.md → .cursorrules
- *   - Codex/OpenCode: AGENTS.md → AGENTS.md (no rename)
- */
 export declare function getCentralRulesFileName(agentId: AgentId): string;
 export declare function getInstructionsPath(agentId: AgentId, scope: InstructionsScope, cwd?: string): string;
 export declare function instructionsExists(agentId: AgentId, scope?: InstructionsScope, cwd?: string): boolean;
@@ -37,16 +21,9 @@ export declare function listInstalledInstructionsWithScope(agentId: AgentId, cwd
     home?: string;
 }): InstalledInstructions[];
 export declare function getInstructionsContent(agentId: AgentId, scope?: InstructionsScope, cwd?: string): string | null;
-/**
- * Install rules files from repo rules/ to central ~/.agents/rules/ directory.
- * Nested presets/ and rules/ fragments are preserved so @imports keep working.
- */
 export declare function installInstructionsCentrally(repoPath: string, filesToInstall?: string[]): {
     installed: string[];
     errors: string[];
 };
-/**
- * List top-level rules files from user and system dirs (user wins on collision).
- */
 export declare function listCentralRules(): string[];
 export {};

package/dist/lib/rules/rules.js

@@ -1,20 +1,8 @@
-/**
- * Rules file management -- reading, writing, and syncing agent instructions.
- *
- * The canonical rules file (AGENTS.md) gets synced
- * into each agent's config directory under their native name (CLAUDE.md,
- * GEMINI.md, etc.). This module handles reading, managing includes, and
- * refreshing rules files across version homes.
- */
 import * as fs from 'fs';
 import * as path from 'path';
 import { AGENTS, ALL_AGENT_IDS, agentConfigDirName } from '../agents.js';
 import { getResolvedRulesDir, getUserRulesDir, getProjectAgentsDir } from '../state.js';
 import { getEffectiveHome } from '../installations/store.js';
-/**
- * Central rules filename constant.
- * All agents map to this file in ~/.agents/rules/, renamed per-agent when synced.
- */
 const CENTRAL_RULES_FILENAME = 'AGENTS.md';
 const RULES_DOC_FILENAME = 'README.md';
 function isSyncableRuleMarkdown(filename) {
@@ -38,28 +26,15 @@ function listRuleMarkdownFiles(rulesDir) {
     }
     return files.sort();
 }
-/**
- * Get the canonical central rules filename for an agent's instructionsFile.
- * Central storage uses AGENTS.md, which gets renamed per-agent when syncing:
- *   - Claude: AGENTS.md → CLAUDE.md
- *   - Gemini: AGENTS.md → GEMINI.md
- *   - Cursor: AGENTS.md → .cursorrules
- *   - Codex/OpenCode: AGENTS.md → AGENTS.md (no rename)
- */
 export function getCentralRulesFileName(agentId) {
     const agent = AGENTS[agentId];
     const instrFile = agent.instructionsFile;
-    // If it contains a path separator, extract just the filename
     const filename = instrFile.includes('/') ? path.basename(instrFile) : instrFile;
-    // If the agent's instructionsFile isn't AGENTS.md, it was renamed FROM AGENTS.md
     if (filename !== CENTRAL_RULES_FILENAME) {
         return CENTRAL_RULES_FILENAME;
     }
     return filename;
 }
-/**
- * Get the user-scope config dir for an agent (version-aware).
- */
 function getUserConfigDir(agentId) {
     const home = getEffectiveHome(agentId);
     return path.join(home, agentConfigDirName(agentId));
@@ -101,8 +76,6 @@ export function discoverInstructionsFromRepo(repoPath) {
     }
     for (const agentId of ALL_AGENT_IDS) {
         const agent = AGENTS[agentId];
-        // AGENTS.md is the canonical central rules file - don't claim it per-agent.
-        // It gets installed centrally to ~/.agents/rules/ and synced per-agent.
         const possibleNames = [
             `${agentId}.md`,
             agent.instructionsFile,
@@ -146,7 +119,6 @@ export function uninstallInstructions(agentId) {
 export function listInstalledInstructionsWithScope(agentId, cwd = process.cwd(), options) {
     const results = [];
     const agent = AGENTS[agentId];
-    // User-scoped instructions (version-aware when home is provided)
     const home = options?.home || getEffectiveHome(agentId);
     const userConfigDir = path.join(home, agentConfigDirName(agentId));
     const userPath = path.join(userConfigDir, agent.instructionsFile);
@@ -177,10 +149,6 @@ export function getInstructionsContent(agentId, scope = 'user', cwd = process.cw
         return null;
     }
 }
-/**
- * Install rules files from repo rules/ to central ~/.agents/rules/ directory.
- * Nested presets/ and rules/ fragments are preserved so @imports keep working.
- */
 export function installInstructionsCentrally(repoPath, filesToInstall) {
     const installed = [];
     const errors = [];
@@ -217,9 +185,6 @@ export function installInstructionsCentrally(repoPath, filesToInstall) {
     }
     return { installed, errors };
 }
-/**
- * List top-level rules files from user and system dirs (user wins on collision).
- */
 export function listCentralRules() {
     const seen = new Set();
     for (const dir of [getUserRulesDir(), getResolvedRulesDir()]) {

package/dist/lib/rules/run-sync.d.ts

@@ -1,18 +1,2 @@
 import type { AgentId } from '../types.js';
-/**
- * Re-apply the active rules preset for (agent, version) into its version
- * home when the composed source set has drifted since the last time this ran.
- * Returns true when the version-home rules file was (re)written.
- *
- * No-cwd fingerprint on purpose: the version-home rules file never includes
- * the project layer (see `staleness/writers/rules.ts` — project rules are
- * resolved separately, at launch, into the workspace `AGENTS.md` by
- * `compileRulesForProject`). Fingerprinting with a cwd would pull the project
- * layer's subrules into the comparison and trigger a pointless version-home
- * rewrite every time a project's own `.agents/rules/` changes.
- *
- * Silent on any failure (no rules.yaml, unknown preset, unsupported agent) —
- * mirrors `syncResourcesToVersion`'s own catch-and-skip for rules: a bad
- * preset must never block a launch, and this now also runs on the hot path.
- */
 export declare function applyActiveRulesPresetAtRun(agent: AgentId, version: string, versionHome: string): boolean;

package/dist/lib/rules/run-sync.js

@@ -1,35 +1,9 @@
-/**
- * Rules preset auto-apply at `agents run` launch time.
- *
- * `agents rules switch <agent>@<version> --preset <name>` persists the active
- * preset (`state.ts:setActiveRulesPreset`) and immediately recompiles it into
- * the version home via `syncResourcesToVersion` → the rules writer
- * (`staleness/writers/rules.ts`). Same for `agents add`/`use`. But nothing
- * re-applies the preset on a LATER `agents run` — if `setActiveRulesPreset`
- * is ever called without a follow-up sync (or a subrule file changes after
- * the last sync), the harness launches against a stale rules file until the
- * next explicit `agents rules switch` / `agents sync`.
- *
- * This closes that gap the same way `runLaunchSync` (project-launch.ts)
- * recompiles PROJECT rules on every launch: idempotent, and skip-fast when
- * nothing changed. The skip-fast reuses the staleness checkers' mtime+size
- * fingerprint comparison (`staleness/checkers/rules.ts`,
- * `staleness/fingerprint.ts`) against a small per-(agent,version) sentinel —
- * the same "hash the cheap inputs, compare, skip the write on a match" shape
- * `installScope` (project-launch.ts) uses for plugin marketplaces. The common
- * case (no preset or subrule change since the last run) costs one JSON read
- * plus a handful of `stat()` calls — no recompose, no write.
- *
- * Version-level scope only — the active preset is keyed by (agent, version),
- * matching `getActiveRulesPreset`. Per-model preset scoping is a follow-up.
- */
 import * as fs from 'fs';
 import * as path from 'path';
 import { AGENTS } from '../agents.js';
 import { getActiveRulesPreset, getCacheDir } from '../state.js';
 import { getWriter } from '../staleness/registry.js';
 import { buildRules, isRulesStale } from '../staleness/checkers/rules.js';
-/** ~/.agents/.cache/rules-run-sync/ — regenerable; a lost sentinel just costs one extra compose+write. */
 function sentinelPath(agent, version) {
     const key = `${agent}@${version}`.replace(/[^a-zA-Z0-9@._-]/g, '_');
     return path.join(getCacheDir(), 'rules-run-sync', `${key}.json`);
@@ -49,25 +23,8 @@ function saveSentinel(agent, version, sentinel) {
         fs.writeFileSync(p, JSON.stringify(sentinel));
     }
     catch {
-        // Best-effort — a failed write just means the next run redoes the compose+write.
     }
 }
-/**
- * Re-apply the active rules preset for (agent, version) into its version
- * home when the composed source set has drifted since the last time this ran.
- * Returns true when the version-home rules file was (re)written.
- *
- * No-cwd fingerprint on purpose: the version-home rules file never includes
- * the project layer (see `staleness/writers/rules.ts` — project rules are
- * resolved separately, at launch, into the workspace `AGENTS.md` by
- * `compileRulesForProject`). Fingerprinting with a cwd would pull the project
- * layer's subrules into the comparison and trigger a pointless version-home
- * rewrite every time a project's own `.agents/rules/` changes.
- *
- * Silent on any failure (no rules.yaml, unknown preset, unsupported agent) —
- * mirrors `syncResourcesToVersion`'s own catch-and-skip for rules: a bad
- * preset must never block a launch, and this now also runs on the hot path.
- */
 export function applyActiveRulesPresetAtRun(agent, version, versionHome) {
     const cap = AGENTS[agent].capabilities.rules;
     if (cap === false)
@@ -79,7 +36,7 @@ export function applyActiveRulesPresetAtRun(agent, version, versionHome) {
     const current = buildRules(agent, version, '');
     const stored = loadSentinel(agent, version);
     if (stored && stored.preset === preset && !isRulesStale(stored.entry, agent, version, '')) {
-        return false; // skip-fast: preset unchanged AND composed source set unchanged
+        return false;
     }
     try {
         rulesWriter.write({ version, versionHome, selection: { preset }, cwd: '' });

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

@@ -1,9 +1,2 @@
-/**
- * Project-local `run:` config discovery.
- *
- * The user/system `agents.yaml` is read through state.ts. Project-local
- * agents.yaml files are discovered from the current working directory upward.
- */
 import type { RunConfig } from './types.js';
-/** Return project-local run configs from nearest directory upward. */
 export declare function getProjectRunConfigs(startPath?: string): RunConfig[];

package/dist/lib/run-config.js

@@ -1,9 +1,3 @@
-/**
- * Project-local `run:` config discovery.
- *
- * The user/system `agents.yaml` is read through state.ts. Project-local
- * agents.yaml files are discovered from the current working directory upward.
- */
 import * as fs from 'fs';
 import * as path from 'path';
 import * as yaml from 'yaml';
@@ -11,7 +5,6 @@ import { getUserAgentsDir } from './state.js';
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
-/** Return project-local run configs from nearest directory upward. */
 export function getProjectRunConfigs(startPath = process.cwd()) {
     const configs = [];
     let dir = path.resolve(startPath);
@@ -26,7 +19,6 @@ export function getProjectRunConfigs(startPath = process.cwd()) {
                 }
             }
             catch {
-                // Ignore malformed project config and keep walking.
             }
         }
         dir = path.dirname(dir);

package/dist/lib/run-defaults.d.ts

@@ -1,16 +1,3 @@
-/**
- * Selector-based defaults for `agents run`.
- *
- * Stored under agents.yaml:
- *
- *   run:
- *     defaults:
- *       "claude:*":
- *         mode: auto
- *         model: opus
- *       "claude:2.1.45":
- *         mode: plan
- */
 import type { AgentId, Mode, RunConfig, RunDefaults } from './types.js';
 export declare const VERSION_RE: RegExp;
 interface ParsedRunDefaultSelector {
@@ -43,7 +30,6 @@ export declare function formatRunDefaultEntry(entry: RunDefaultEntry): string;
 export declare function listRunDefaults(): RunDefaultEntry[];
 export declare function setRunDefault(selectorInput: string, defaultsInput: RunDefaultsInput): RunDefaultEntry;
 export declare function unsetRunDefault(selectorInput: string): boolean;
-/** Convenience setters used by `agents config` for single-field updates. */
 export declare function setRunDefaultModel(selectorInput: string, model: string): RunDefaultEntry;
 export declare function setRunDefaultMode(selectorInput: string, mode: string): RunDefaultEntry;
 export declare function setRunDefaultEffort(selectorInput: string, effort: string): RunDefaultEntry;

package/dist/lib/run-defaults.js

@@ -1,16 +1,3 @@
-/**
- * Selector-based defaults for `agents run`.
- *
- * Stored under agents.yaml:
- *
- *   run:
- *     defaults:
- *       "claude:*":
- *         mode: auto
- *         model: opus
- *       "claude:2.1.45":
- *         mode: plan
- */
 import { ALL_MODES } from './types.js';
 import { AGENTS } from './agents.js';
 import { readMeta, updateMeta } from './state.js';
@@ -208,7 +195,6 @@ export function unsetRunDefault(selectorInput) {
     });
     return removed;
 }
-/** Convenience setters used by `agents config` for single-field updates. */
 export function setRunDefaultModel(selectorInput, model) {
     return setRunDefault(selectorInput, { model });
 }

package/dist/lib/run-notify.d.ts

@@ -1,32 +1,14 @@
 import { type DesktopNotification } from './menubar/notify-desktop.js';
 interface RunNotifyContext {
-    /** Agent that ran, e.g. `claude`. */
     agent: string;
-    /** `--name` slug when the caller named the run; falls back to the agent. */
     name?: string;
-    /** The prompt, used for a one-line reminder of what the run was about. */
     prompt?: string;
-    /** Working directory the run was scoped to; its basename names the project. */
     cwd?: string;
-    /** Machine the run executed on, when it was dispatched off-box. */
     host?: string;
-    /** Clickable target — a PR/ticket URL the caller already knows. */
     url?: string;
-    /** Session id the run coined, so the banner can open/focus it. */
     sessionId?: string;
-    /** Report/log path the run produced — becomes the `open-report` choice + `open:` action. */
     reportPath?: string;
 }
-/**
- * The finish notification for one run. Pure — the exit handler and the tests
- * both build through here, so what ships is what is asserted.
- */
 export declare function buildRunFinishNotification(ctx: RunNotifyContext, exitCode: number): DesktopNotification;
-/**
- * Post the finish notification when this process exits. Best-effort by
- * construction: `notifyDesktop` swallows its own failures, and a run killed
- * outright (SIGKILL) never reaches an exit handler — that is the documented
- * limit, not a case to paper over.
- */
 export declare function armRunFinishNotification(ctx: RunNotifyContext): void;
 export {};