@rex_koh/subagent-budget-guard 0.1.7 → 0.2.0

package/.claude-plugin/plugin.json

@@ -1,8 +1,8 @@
 {
-  "name": "subagent-budget-guard",
-  "displayName": "Subagent Budget Guard",
+  "name": "agent-guard",
+  "displayName": "Agent Guard",
   "description": "Hard-deny subagent launches, record verified subagent usage, and enforce a session budget against Claude Code's 5-hour rate-limit percentage.",
-  "version": "0.1.7",
+  "version": "0.2.0",
   "author": {
     "name": "ClaudeSubAgentSuppressor"
   },

package/README.md

@@ -1,6 +1,6 @@
-# Subagent Budget Guard
+# Agent Guard
 
-Claude Code plugin that blocks subagents before setup, records verified subagent usage, and enforces a session budget against Claude Code's 5-hour usage percentage.
+Claude Code plugin that guards subagent usage, records verified subagent tokens, and enforces a session budget against Claude Code's 5-hour usage percentage.
 
 ## Install
 
@@ -8,17 +8,17 @@ Recommended Claude Code install:
 
 ```text
 /plugin marketplace add rexkoh425/ClaudeSubAgentSuppressor
-/plugin install subagent-budget-guard@subagent-budget-tools
-/subagent-budget-guard:setup
-/subagent-budget-guard:verify
+/plugin install agent-guard@subagent-budget-tools
+/agent-guard:init
+/agent-guard:doctor
 ```
 
-After `/subagent-budget-guard:setup`, fully exit and reopen Claude Code before verification so the statusLine bridge from `settings.json` is active. Some Claude Code builds do not provide an in-session plugin reload command.
+After `/agent-guard:init`, fully exit and reopen Claude Code before verification so the statusLine bridge from `settings.json` is active. Some Claude Code builds do not provide an in-session plugin reload command.
 
 Useful after install:
 
 ```text
-/subagent-budget-guard:report
+/agent-guard:status
 ```
 
 ## NPM Package
@@ -29,7 +29,7 @@ Claude Code plugin discovery is marketplace-based, so npm is mainly useful as a
 
 ```bash
 npm install -g @rex_koh/subagent-budget-guard
-subagent-budget-guard-verify --offline
+agent-guard doctor --offline
 ```
 
 Maintainer publish command:
@@ -44,7 +44,7 @@ Offline verification:
 node bin/verify.js --offline
 ```
 
-The plugin is strict before setup: `max_concurrent_subagents` defaults to `0`, so normal subagent launches are blocked unless raised. Run `/subagent-budget-guard:setup` to replace the long `--config ...` install command with the recommended config:
+The plugin is strict before setup: `max_concurrent_subagents` defaults to `0`, so normal subagent launches are blocked unless raised. Run `/agent-guard:init` to choose defaults or custom values:
 
 ```text
 max_concurrent_subagents=1
@@ -57,4 +57,22 @@ enforcement_enabled=true
 
 For existing installs, setup also removes obsolete `max_subagents_per_session` and `max_agent_team_tasks_per_session` options from this plugin's Claude settings.
 
+The setup skill can also ask for custom values. For direct terminal setup, use:
+
+```bash
+agent-guard init
+```
+
+Or pass explicit values:
+
+```bash
+agent-guard init \
+  --config max_concurrent_subagents=2 \
+  --config max_subagent_tokens_per_session=250000 \
+  --config subagent_token_warning_threshold_percent=90 \
+  --config session_five_hour_budget_percent=15 \
+  --config absolute_five_hour_ceiling_percent=95 \
+  --config enforcement_enabled=true
+```
+
 `max_subagent_tokens_per_session` is enforced from verified `Agent.totalTokens` values after each completed subagent. `subagent_token_warning_threshold_percent` defaults to `95`; once verified subagent usage reaches that percentage, the plugin tells Claude to stop using subagents and blocks future subagent launches. Claude Code does not expose mid-run per-token subagent streaming to hooks, so a single running subagent can only be evaluated when it reports its final token total.

package/bin/agent-guard.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const BIN_DIR = path.dirname(fileURLToPath(import.meta.url));
+
+const COMMANDS = Object.freeze({
+  init: {
+    script: 'setup.js',
+    help: 'initialize settings and the statusLine bridge'
+  },
+  status: {
+    script: 'report.js',
+    help: 'show the current guard report'
+  },
+  doctor: {
+    script: 'verify.js',
+    help: 'verify the install without spending Claude quota'
+  }
+});
+
+function usage() {
+  return [
+    'Usage: agent-guard <command> [options]',
+    '',
+    'Commands:',
+    ...Object.entries(COMMANDS).map(([name, info]) => `  ${name.padEnd(8)} ${info.help}`),
+    '',
+    'Examples:',
+    '  agent-guard init',
+    '  agent-guard init --defaults',
+    '  agent-guard status',
+    '  agent-guard doctor --offline'
+  ].join('\n');
+}
+
+function main() {
+  const [command, ...args] = process.argv.slice(2);
+
+  if (!command || command === '--help' || command === '-h') {
+    process.stdout.write(`${usage()}\n`);
+    return;
+  }
+
+  const target = COMMANDS[command];
+  if (!target) {
+    process.stderr.write(`Unknown command "${command}".\n\n${usage()}\n`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const child = spawnSync(process.execPath, [path.join(BIN_DIR, target.script), ...args], {
+    stdio: 'inherit',
+    env: process.env,
+    cwd: process.cwd(),
+    windowsHide: true
+  });
+
+  if (child.error) {
+    process.stderr.write(`${child.error.message}\n`);
+    process.exitCode = 1;
+    return;
+  }
+
+  process.exitCode = child.status ?? 1;
+}
+
+main();

package/bin/setup.js

@@ -1,17 +1,128 @@
 #!/usr/bin/env node
-import { getDataDir, getHomeDir, getPluginRoot, installStatusLineBridge } from '../lib/guard.js';
+import { createInterface } from 'node:readline/promises';
+
+import {
+  CONFIG_KEYS,
+  SETUP_CONFIG,
+  buildSetupConfig,
+  getDataDir,
+  getHomeDir,
+  getPluginRoot,
+  installStatusLineBridge
+} from '../lib/guard.js';
+
+const CONFIG_KEY_SET = new Set(CONFIG_KEYS);
+
+function usage() {
+  return [
+    'Usage: agent-guard init [--defaults] [--interactive] [--config key=value ...]',
+    '',
+    'Config keys:',
+    ...CONFIG_KEYS.map((key) => `  ${key} (default ${SETUP_CONFIG[key]})`)
+  ].join('\n');
+}
+
+function parseConfigPair(pair) {
+  const index = pair.indexOf('=');
+  if (index <= 0) {
+    throw new Error(`Invalid --config value "${pair}". Expected key=value.`);
+  }
+
+  const key = pair.slice(0, index);
+  const value = pair.slice(index + 1);
+  if (!CONFIG_KEY_SET.has(key)) {
+    throw new Error(`Unknown config key "${key}". Valid keys: ${CONFIG_KEYS.join(', ')}`);
+  }
+  return [key, value];
+}
+
+function parseArgs(args) {
+  const options = {
+    interactive: false,
+    defaults: false,
+    overrides: {}
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === '--help' || arg === '-h') {
+      process.stdout.write(`${usage()}\n`);
+      process.exit(0);
+    }
+    if (arg === '--interactive') {
+      options.interactive = true;
+      continue;
+    }
+    if (arg === '--defaults' || arg === '--yes' || arg === '-y') {
+      options.defaults = true;
+      continue;
+    }
+    if (arg === '--config') {
+      const pair = args[index + 1];
+      if (!pair) throw new Error('--config requires key=value');
+      const [key, value] = parseConfigPair(pair);
+      options.overrides[key] = value;
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith('--config=')) {
+      const [key, value] = parseConfigPair(arg.slice('--config='.length));
+      options.overrides[key] = value;
+      continue;
+    }
+    throw new Error(`Unknown argument "${arg}".\n${usage()}`);
+  }
+
+  return options;
+}
+
+async function promptForConfig(defaults, { askMode = true } = {}) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stderr
+  });
+  const answers = {};
+
+  try {
+    if (askMode) {
+      const useDefaults = await rl.question('Use recommended defaults? [Y/n]: ');
+      if (!useDefaults.trim() || /^y(es)?$/i.test(useDefaults.trim())) {
+        return buildSetupConfig(defaults);
+      }
+    }
+
+    for (const key of CONFIG_KEYS) {
+      const answer = await rl.question(`${key} [${defaults[key]}]: `);
+      if (answer.trim()) {
+        answers[key] = answer.trim();
+      }
+    }
+  } finally {
+    rl.close();
+  }
+
+  return buildSetupConfig({ ...defaults, ...answers });
+}
 
 async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  const defaults = buildSetupConfig(options.overrides);
+  const setupConfig = options.interactive
+    ? await promptForConfig(defaults, { askMode: false })
+    : !options.defaults && Object.keys(options.overrides).length === 0 && process.stdin.isTTY
+      ? await promptForConfig(defaults)
+      : defaults;
   const result = await installStatusLineBridge({
     homeDir: getHomeDir(process.env),
     pluginRoot: getPluginRoot(process.env),
-    pluginData: getDataDir(process.env)
+    pluginData: getDataDir(process.env),
+    setupConfig
   });
 
   process.stdout.write(
     [
-      'Subagent Budget Guard statusLine bridge installed.',
-      'Recommended plugin config applied:',
+      'Agent Guard statusLine bridge installed.',
+      'Plugin config applied:',
       `  max_concurrent_subagents=${result.pluginConfigOptions.max_concurrent_subagents}`,
       `  max_subagent_tokens_per_session=${result.pluginConfigOptions.max_subagent_tokens_per_session}`,
       `  subagent_token_warning_threshold_percent=${result.pluginConfigOptions.subagent_token_warning_threshold_percent}`,

package/lib/guard.js

@@ -17,8 +17,9 @@ import { fileURLToPath } from 'node:url';
 
 const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 
-export const PLUGIN_NAME = 'subagent-budget-guard';
-export const PLUGIN_ID = 'subagent-budget-guard@subagent-budget-tools';
+export const PLUGIN_NAME = 'agent-guard';
+export const PLUGIN_ID = 'agent-guard@subagent-budget-tools';
+export const LEGACY_PLUGIN_ID = 'subagent-budget-guard@subagent-budget-tools';
 
 export const DEFAULT_CONFIG = Object.freeze({
   max_concurrent_subagents: 0,
@@ -87,7 +88,9 @@ function readSettingsOptions(env) {
   try {
     const text = readFileSync(settingsPath, 'utf8');
     const settings = JSON.parse(text.replace(/^\uFEFF/, ''));
-    const options = settings?.pluginConfigs?.[PLUGIN_ID]?.options;
+    const options =
+      settings?.pluginConfigs?.[PLUGIN_ID]?.options ||
+      settings?.pluginConfigs?.[LEGACY_PLUGIN_ID]?.options;
     return isPlainObject(options) ? options : {};
   } catch (error) {
     if (error.code === 'ENOENT') return {};
@@ -134,6 +137,12 @@ export function loadConfig(env = process.env) {
   return normalizeConfig(config);
 }
 
+export function buildSetupConfig(overrides = {}) {
+  const config = { ...SETUP_CONFIG };
+  applyConfigValues(config, (key) => overrides[key]);
+  return normalizeConfig(config);
+}
+
 export function getHomeDir(env = process.env) {
   return env.USERPROFILE || env.HOME || os.homedir();
 }
@@ -754,7 +763,7 @@ export function formatReport(report) {
   const { state, config, summary } = report;
   const fiveHour = state.rateLimits.fiveHour;
   const lines = [
-    `Subagent Budget Guard report for ${report.sessionId}`,
+    `Agent Guard report for ${report.sessionId}`,
     `Enforcement: ${config.enforcement_enabled ? 'enabled' : 'disabled'}`,
     `Subagents: allowed ${state.subagents.allowed}, denied ${state.subagents.denied}, active ${state.subagents.active}, lifecycle starts ${state.subagents.lifecycleStarted}, lifecycle stops ${state.subagents.lifecycleStopped}`,
     `Verified usage: ${summary.verifiedTokenLabel}, ${state.subagents.totalToolUseCount} subagent tool calls, ${state.subagents.totalDurationMs} ms`,
@@ -770,7 +779,7 @@ export function formatReport(report) {
     );
   } else {
     lines.push(
-      '5-hour latest: unavailable. Run /subagent-budget-guard:setup so the statusLine bridge can capture rate_limits.five_hour.used_percentage.'
+      '5-hour latest: unavailable. Run /agent-guard:init so the statusLine bridge can capture rate_limits.five_hour.used_percentage.'
     );
   }
 
@@ -816,26 +825,33 @@ function applySetupPluginConfig(
     settings.pluginConfigs = {};
   }
 
+  const legacyEntry = isPlainObject(settings.pluginConfigs[LEGACY_PLUGIN_ID])
+    ? settings.pluginConfigs[LEGACY_PLUGIN_ID]
+    : {};
   const currentEntry = isPlainObject(settings.pluginConfigs[pluginId])
     ? settings.pluginConfigs[pluginId]
-    : {};
+    : legacyEntry;
   const currentOptions = isPlainObject(currentEntry.options)
     ? currentEntry.options
     : {};
   const nextOptions = { ...currentOptions };
+  const normalizedSetupConfig = buildSetupConfig(setupConfig);
 
   for (const key of REMOVED_CONFIG_KEYS) {
     delete nextOptions[key];
   }
 
   for (const key of CONFIG_KEYS) {
-    nextOptions[key] = setupConfig[key];
+    nextOptions[key] = normalizedSetupConfig[key];
   }
 
   settings.pluginConfigs[pluginId] = {
     ...currentEntry,
     options: nextOptions
   };
+  if (pluginId !== LEGACY_PLUGIN_ID) {
+    delete settings.pluginConfigs[LEGACY_PLUGIN_ID];
+  }
 
   return nextOptions;
 }
@@ -843,7 +859,8 @@ function applySetupPluginConfig(
 export async function installStatusLineBridge({
   homeDir = getHomeDir(),
   pluginRoot = getPluginRoot(),
-  pluginData = getDataDir()
+  pluginData = getDataDir(),
+  setupConfig = SETUP_CONFIG
 } = {}) {
   await mkdir(pluginData, { recursive: true });
   const { settingsPath, settings } = await ensureSettings(homeDir);
@@ -861,7 +878,7 @@ export async function installStatusLineBridge({
     padding: existing?.padding ?? previousStatusLine?.padding ?? 0,
     refreshInterval: existing?.refreshInterval ?? 5
   };
-  const pluginConfigOptions = applySetupPluginConfig(settings);
+  const pluginConfigOptions = applySetupPluginConfig(settings, { setupConfig });
 
   settings.statusLine = nextStatusLine;
   await writeJsonAtomic(settingsPath, settings);

package/lib/verifier.js

@@ -64,6 +64,27 @@ function assert(condition, message) {
   if (!condition) throw new Error(message);
 }
 
+async function withIsolatedPluginEnv(env, root, fn) {
+  const dataDir = await mkdtemp(path.join(os.tmpdir(), 'sbg-verify-data-'));
+  const homeDir = await mkdtemp(path.join(os.tmpdir(), 'sbg-verify-home-'));
+  const checkEnv = {
+    PATH: env.PATH,
+    Path: env.Path,
+    SystemRoot: env.SystemRoot,
+    USERPROFILE: homeDir,
+    HOME: homeDir,
+    CLAUDE_PLUGIN_DATA: dataDir,
+    CLAUDE_PLUGIN_ROOT: root
+  };
+
+  try {
+    return await fn(checkEnv, { dataDir, homeDir });
+  } finally {
+    await rm(dataDir, { recursive: true, force: true });
+    await rm(homeDir, { recursive: true, force: true });
+  }
+}
+
 export async function runOfflineVerification({
   repoRoot = process.cwd(),
   env = process.env
@@ -83,14 +104,14 @@ export async function runOfflineVerification({
       const marketplace = await readJson(marketplacePath);
       assert(marketplace.name === 'subagent-budget-tools', 'marketplace name mismatch');
       assert(Array.isArray(marketplace.plugins), 'marketplace.plugins must be an array');
-      const entry = marketplace.plugins.find((plugin) => plugin.name === 'subagent-budget-guard');
-      assert(entry, 'subagent-budget-guard entry missing');
+      const entry = marketplace.plugins.find((plugin) => plugin.name === 'agent-guard');
+      assert(entry, 'agent-guard entry missing');
       assert(entry.source?.source === 'npm', 'marketplace source must use npm');
       assert(
         entry.source?.package === '@rex_koh/subagent-budget-guard',
         'marketplace npm package mismatch'
       );
-      assert(entry.source?.version === '0.1.7', 'marketplace npm version mismatch');
+      assert(entry.source?.version === '0.2.0', 'marketplace npm version mismatch');
       return marketplacePath;
     });
   } else {
@@ -108,7 +129,7 @@ export async function runOfflineVerification({
   await withCheck(result, 'plugin-manifest-no-install-config', async () => {
     const manifestPath = path.join(root, '.claude-plugin', 'plugin.json');
     const manifest = await readJson(manifestPath);
-    assert(manifest.name === 'subagent-budget-guard', 'plugin name mismatch');
+    assert(manifest.name === 'agent-guard', 'plugin name mismatch');
     assert(
       manifest.hooks === undefined,
       'manifest.hooks must be omitted for default hooks/hooks.json to avoid duplicate loading'
@@ -147,12 +168,16 @@ export async function runOfflineVerification({
   await withCheck(result, 'script-paths', async () => {
     const scripts = [
       'bin/hook.js',
+      'bin/agent-guard.js',
       'bin/statusline.js',
       'bin/setup.js',
       'bin/report.js',
       'bin/verify.js',
       'lib/guard.js',
       'lib/verifier.js',
+      'skills/init/SKILL.md',
+      'skills/status/SKILL.md',
+      'skills/doctor/SKILL.md',
       'skills/setup/SKILL.md',
       'skills/report/SKILL.md',
       'skills/verify/SKILL.md'
@@ -164,13 +189,7 @@ export async function runOfflineVerification({
   });
 
   await withCheck(result, 'pretool-agent-denies-default', async () => {
-    const dataDir = await mkdtemp(path.join(os.tmpdir(), 'sbg-verify-'));
-    try {
-      const checkEnv = {
-        ...env,
-        CLAUDE_PLUGIN_DATA: dataDir,
-        CLAUDE_PLUGIN_ROOT: root
-      };
+    return withIsolatedPluginEnv(env, root, async (checkEnv) => {
       const output = await handlePreToolUseAgent(
         {
           session_id: 'offline-pretool',
@@ -185,19 +204,11 @@ export async function runOfflineVerification({
         'Agent launch was not denied by default'
       );
       return output.stdout.hookSpecificOutput.permissionDecisionReason;
-    } finally {
-      await rm(dataDir, { recursive: true, force: true });
-    }
+    });
   });
 
   await withCheck(result, 'posttool-agent-records-verified-tokens', async () => {
-    const dataDir = await mkdtemp(path.join(os.tmpdir(), 'sbg-verify-'));
-    try {
-      const checkEnv = {
-        ...env,
-        CLAUDE_PLUGIN_DATA: dataDir,
-        CLAUDE_PLUGIN_ROOT: root
-      };
+    return withIsolatedPluginEnv(env, root, async (checkEnv) => {
       await handlePostToolUseAgent(
         {
           session_id: 'offline-posttool',
@@ -217,18 +228,13 @@ export async function runOfflineVerification({
       const report = await buildReport('offline-posttool', checkEnv);
       assert(report.state.subagents.verifiedTokens === 101, 'verified token count mismatch');
       return report.summary.verifiedTokenLabel;
-    } finally {
-      await rm(dataDir, { recursive: true, force: true });
-    }
+    });
   });
 
   await withCheck(result, 'statusline-budget-blocks', async () => {
-    const dataDir = await mkdtemp(path.join(os.tmpdir(), 'sbg-verify-'));
-    try {
+    return withIsolatedPluginEnv(env, root, async (baseEnv) => {
       const checkEnv = {
-        ...env,
-        CLAUDE_PLUGIN_DATA: dataDir,
-        CLAUDE_PLUGIN_ROOT: root,
+        ...baseEnv,
         CLAUDE_PLUGIN_OPTION_session_five_hour_budget_percent: '3'
       };
       await updateRateLimitFromStatusLine(
@@ -255,9 +261,7 @@ export async function runOfflineVerification({
       );
       assert(output.stdout?.decision === 'block', 'prompt was not blocked');
       return output.stdout.reason;
-    } finally {
-      await rm(dataDir, { recursive: true, force: true });
-    }
+    });
   });
 
   await withCheck(result, 'statusline-setup-wraps-existing-command', async () => {
@@ -408,12 +412,12 @@ export async function runLiveVerification({
       const list = await runCommand('claude', ['plugin', 'list'], { cwd: repoRoot });
       assert(list.code === 0, list.stderr || list.stdout || 'claude plugin list failed');
       assert(
-        list.stdout.includes('subagent-budget-guard'),
-        'subagent-budget-guard is not installed'
+        list.stdout.includes('agent-guard'),
+        'agent-guard is not installed'
       );
       assert(
-        !/subagent-budget-guard@subagent-budget-tools[\s\S]*failed to load/i.test(list.stdout),
-        'subagent-budget-guard is installed but failed to load'
+        !/agent-guard@subagent-budget-tools[\s\S]*failed to load/i.test(list.stdout),
+        'agent-guard is installed but failed to load'
       );
       return 'claude plugin list returned output';
     });
@@ -427,7 +431,7 @@ export async function runLiveVerification({
       typeof settings.statusLine?.command === 'string' &&
         settings.statusLine.command.includes('statusline.js') &&
         settings.statusLine.command.includes('--data'),
-      'statusLine bridge is not installed; run /subagent-budget-guard:setup'
+      'statusLine bridge is not installed; run /agent-guard:init'
     );
     return settings.statusLine.command;
   });
@@ -438,7 +442,7 @@ export async function runLiveVerification({
 
 export function formatVerificationResult(result) {
   const lines = [
-    `Subagent Budget Guard ${result.mode} verification`,
+    `Agent Guard ${result.mode} verification`,
     result.ok ? 'PASS' : 'FAIL'
   ];
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rex_koh/subagent-budget-guard",
-  "version": "0.1.7",
+  "version": "0.2.0",
   "description": "Claude Code plugin that blocks subagents by default, records verified subagent usage, and enforces 5-hour usage budgets.",
   "license": "MIT",
   "author": "ClaudeSubAgentSuppressor",
@@ -32,6 +32,8 @@
     "LICENSE"
   ],
   "bin": {
+    "agent-guard": "bin/agent-guard.js",
+    "ag": "bin/agent-guard.js",
     "subagent-budget-guard-report": "bin/report.js",
     "subagent-budget-guard-setup": "bin/setup.js",
     "subagent-budget-guard-verify": "bin/verify.js"
@@ -43,7 +45,7 @@
     "test": "node --test test/*.test.js",
     "verify:offline": "node bin/verify.js --offline",
     "verify:live": "node bin/verify.js --live",
-    "prepack": "node --check bin/hook.js && node --check bin/statusline.js && node --check bin/setup.js && node --check bin/report.js && node --check bin/verify.js && node --check lib/guard.js && node --check lib/verifier.js"
+    "prepack": "node --check bin/hook.js && node --check bin/statusline.js && node --check bin/setup.js && node --check bin/report.js && node --check bin/verify.js && node --check bin/agent-guard.js && node --check lib/guard.js && node --check lib/verifier.js"
   },
   "engines": {
     "node": ">=20"

package/skills/doctor/SKILL.md

@@ -0,0 +1,20 @@
+---
+description: Verify Agent Guard installation and offline behavior.
+disable-model-invocation: true
+---
+
+# Doctor Agent Guard
+
+For default offline verification, run:
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/bin/agent-guard.js" doctor --offline
+```
+
+For live local installation checks, run:
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/bin/agent-guard.js" doctor --live
+```
+
+The live verifier does not submit Claude prompts. It checks local plugin shape, `claude plugin validate` when available, plugin listing shape, and statusLine bridge setup.

package/skills/init/SKILL.md

@@ -0,0 +1,42 @@
+---
+description: Initialize Agent Guard settings and the statusLine bridge.
+---
+
+# Init Agent Guard
+
+Ask the user whether to use recommended defaults or custom values.
+
+Recommended defaults:
+
+```text
+max_concurrent_subagents=1
+max_subagent_tokens_per_session=100000
+subagent_token_warning_threshold_percent=95
+session_five_hour_budget_percent=25
+absolute_five_hour_ceiling_percent=95
+enforcement_enabled=true
+```
+
+If they choose defaults, run:
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/bin/agent-guard.js" init --defaults
+```
+
+If they choose custom values, ask for each value. Accept a blank answer as the default, then run:
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/bin/agent-guard.js" init \
+  --config max_concurrent_subagents=<value> \
+  --config max_subagent_tokens_per_session=<value> \
+  --config subagent_token_warning_threshold_percent=<value> \
+  --config session_five_hour_budget_percent=<value> \
+  --config absolute_five_hour_ceiling_percent=<value> \
+  --config enforcement_enabled=<true-or-false>
+```
+
+Then tell the user to fully exit and reopen Claude Code, interact once so the statusLine bridge receives fresh session JSON, and run:
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/bin/agent-guard.js" doctor --live
+```

package/skills/report/SKILL.md

@@ -1,18 +1,20 @@
 ---
-description: Show the current Subagent Budget Guard session report with subagent counts, verified token totals, and 5-hour budget state.
+description: Compatibility alias for /agent-guard:status.
 disable-model-invocation: true
 ---
 
-# Report Subagent Budget Guard Usage
+# Report Agent Guard Usage
+
+Prefer `/agent-guard:status`.
 
 Run this command:
 
 ```bash
-node "${CLAUDE_PLUGIN_ROOT}/bin/report.js"
+node "${CLAUDE_PLUGIN_ROOT}/bin/agent-guard.js" status
 ```
 
 If the user asks for machine-readable output, run:
 
 ```bash
-node "${CLAUDE_PLUGIN_ROOT}/bin/report.js" --json
+node "${CLAUDE_PLUGIN_ROOT}/bin/agent-guard.js" status --json
 ```

package/skills/setup/SKILL.md

@@ -1,17 +1,18 @@
 ---
-description: Install or refresh the Subagent Budget Guard statusLine bridge and apply the recommended plugin config.
-disable-model-invocation: true
+description: Compatibility alias for /agent-guard:init.
 ---
 
-# Setup Subagent Budget Guard
+# Setup Agent Guard
 
-Run this command:
+Prefer `/agent-guard:init`.
+
+Ask the user whether to use the recommended defaults or customize the values. If they choose defaults, run:
 
 ```bash
-node "${CLAUDE_PLUGIN_ROOT}/bin/setup.js"
+node "${CLAUDE_PLUGIN_ROOT}/bin/agent-guard.js" init --defaults
 ```
 
-This applies the recommended config in Claude settings:
+If they choose custom values, ask for each value below. The value in parentheses is the default; accept a blank answer as the default.
 
 ```text
 max_concurrent_subagents=1
@@ -22,10 +23,22 @@ absolute_five_hour_ceiling_percent=95
 enforcement_enabled=true
 ```
 
+Then run setup with the chosen values:
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/bin/agent-guard.js" init \
+  --config max_concurrent_subagents=<value> \
+  --config max_subagent_tokens_per_session=<value> \
+  --config subagent_token_warning_threshold_percent=<value> \
+  --config session_five_hour_budget_percent=<value> \
+  --config absolute_five_hour_ceiling_percent=<value> \
+  --config enforcement_enabled=<true-or-false>
+```
+
 Then tell the user to fully exit and reopen Claude Code, interact once so the statusLine bridge receives fresh session JSON, and run:
 
 ```bash
-node "${CLAUDE_PLUGIN_ROOT}/bin/verify.js" --live
+node "${CLAUDE_PLUGIN_ROOT}/bin/agent-guard.js" doctor --live
 ```
 
 The live verifier does not submit Claude prompts. It checks local plugin shape, Claude plugin validation when `claude` is on `PATH`, and whether the statusLine bridge is configured.

package/skills/status/SKILL.md

@@ -0,0 +1,18 @@
+---
+description: Show the current Agent Guard report.
+disable-model-invocation: true
+---
+
+# Status Agent Guard
+
+Run:
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/bin/agent-guard.js" status
+```
+
+If the user asks for machine-readable output, run:
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/bin/agent-guard.js" status --json
+```

package/skills/verify/SKILL.md

@@ -1,20 +1,22 @@
 ---
-description: Verify the Subagent Budget Guard plugin without spending Claude quota, or run live local installation checks.
+description: Compatibility alias for /agent-guard:doctor.
 disable-model-invocation: true
 ---
 
-# Verify Subagent Budget Guard
+# Verify Agent Guard
+
+Prefer `/agent-guard:doctor`.
 
 For default offline verification, run:
 
 ```bash
-node "${CLAUDE_PLUGIN_ROOT}/bin/verify.js" --offline
+node "${CLAUDE_PLUGIN_ROOT}/bin/agent-guard.js" doctor --offline
 ```
 
 For live local installation checks, run:
 
 ```bash
-node "${CLAUDE_PLUGIN_ROOT}/bin/verify.js" --live
+node "${CLAUDE_PLUGIN_ROOT}/bin/agent-guard.js" doctor --live
 ```
 
 The live verifier does not submit Claude prompts. It checks local plugin shape, `claude plugin validate` when available, plugin listing shape, and statusLine bridge setup.