@pellux/goodvibes-agent 0.1.116 → 1.0.0

package/src/cli/package-verification.ts

@@ -1,274 +0,0 @@
-import { execSync } from 'node:child_process';
-import { existsSync, readFileSync, statSync } from 'node:fs';
-import { join } from 'node:path';
-import { CommandRegistry } from '../input/command-registry.ts';
-import { registerBuiltinCommands } from '../input/commands.ts';
-
-export interface PackageCliBinVerification {
-  readonly command: 'goodvibes-agent';
-  readonly target: string;
-  readonly exists: boolean;
-  readonly executable: boolean;
-  readonly usesBunShebang: boolean;
-  readonly hasSourceEntrypoint: boolean;
-}
-
-export interface PackageCliVerificationReport {
-  readonly packageName: string;
-  readonly version: string;
-  readonly bins: readonly PackageCliBinVerification[];
-  readonly tarball: {
-    readonly entryCount: number;
-    readonly unpackedSize: number;
-    readonly requiredPathsPresent: readonly string[];
-    readonly forbiddenPaths: readonly string[];
-  };
-  readonly packageFacingText: {
-    readonly checkedPaths: readonly string[];
-    readonly failures: readonly string[];
-  };
-  readonly issues: readonly string[];
-}
-
-const REQUIRED_BIN_COMMANDS = ['goodvibes-agent'] as const;
-const REQUIRED_TARBALL_PATHS = [
-  'README.md',
-  'CHANGELOG.md',
-  'LICENSE',
-  'package.json',
-  'src/main.ts',
-  'dist/package/main.js',
-  'bin/goodvibes-agent.ts',
-  'tsconfig.json',
-  'docs/README.md',
-  'docs/getting-started.md',
-  'docs/connected-services.md',
-  'docs/release-and-publishing.md',
-] as const;
-const FORBIDDEN_TARBALL_PREFIXES = ['.github/', 'src/test/', 'src/.test/', '.goodvibes/', 'vendor/'] as const;
-const FORBIDDEN_TARBALL_DOCS = [
-  ['docs/cloud', 'flare-batch.md'].join(''),
-  ['docs/home', 'assistant-surface.md'].join(''),
-  'docs/wrfc/',
-] as const;
-const FORBIDDEN_TARBALL_FILES = new Set([
-  'src/panels/agent-inspector-panel.ts',
-  'src/panels/agent-inspector-shared.ts',
-  'src/panels/agent-logs-panel.ts',
-  'src/panels/agent-logs-shared.ts',
-  'src/tools/wrfc-agent-guard.ts',
-  'src/renderer/agent-detail-modal.ts',
-  'src/renderer/process-summary.ts',
-]);
-const PACKAGE_FACING_TEXT_PATHS = [
-  'README.md',
-  'CHANGELOG.md',
-  'docs/README.md',
-  'docs/getting-started.md',
-  'docs/connected-services.md',
-  'docs/release-and-publishing.md',
-] as const;
-const PACKAGE_FACING_FORBIDDEN_TEXT = [
-  ['/api/', 'knowledge'].join(''),
-  ['/api/home', 'assistant'].join(''),
-  ['home', 'assistant.home', 'Graph'].join(''),
-  ['include', 'AllSpaces'].join(''),
-  ['knowledge', 'SpaceId'].join(''),
-  ['@pellux/goodvibes-', 'tui'].join(''),
-  ['@pellux/goodvibes-', 'daemon'].join(''),
-  ['goodvibes-', 'daemon'].join(''),
-  ['~/.goodvibes/', 'tui'].join(''),
-  ['Home', ' Assistant'].join(''),
-  ['Home', 'Graph'].join(''),
-  ['Cloud', 'flare'].join(''),
-  ['Open', 'Claw'].join(''),
-  ['Her', 'mes'].join(''),
-  ['cap', 'abilities audit'].join(''),
-  ['cap', 'abilities command'].join(''),
-  ['near', '-fork'].join(''),
-  ['Optional ', 'Browser Access'].join(''),
-  ['Optional ', 'Other-Device Access'].join(''),
-  ['Optional ', 'Incoming Events'].join(''),
-  ['Service ', '& Network'].join(''),
-  ['Surfaces ', '& Integrations'].join(''),
-  ['runtime', '-isolation'].join(''),
-  ['goodvibes-agent', 'serve'].join(' '),
-  ['goodvibes-agent', 'service'].join(' '),
-  ['goodvibes-agent', 'services'].join(' '),
-  ['goodvibes-agent', 'surfaces'].join(' '),
-  ['goodvibes-agent', 'surface'].join(' '),
-  ['goodvibes-agent', 'listener'].join(' '),
-  ['goodvibes-agent', 'control-plane'].join(' '),
-  ['goodvibes-agent', 'remote'].join(' '),
-  ['goodvibes-agent', 'bridge'].join(' '),
-  ['goodvibes-agent', 'web'].join(' '),
-  ['goodvibes-agent', 'launch'].join(' '),
-  ['goodvibes-agent', 'start'].join(' '),
-  ['tui ', '[path]'].join(''),
-  ['tui', '|launch'].join(''),
-  ['tui', '|launch|start'].join(''),
-  'Every plan must have a multi-agent execution strategy',
-  'NEVER skip WRFC',
-  'ALWAYS work in parallel when implementing a plan',
-  'PRIMARY GOAL: Fully complete and functional code',
-  'You are a code reviewer for the WRFC',
-  'ReviewerReport',
-  '"wrfcId"',
-] as const;
-const PACKAGE_FACING_REQUIRED_TEXT: readonly {
-  readonly path: typeof PACKAGE_FACING_TEXT_PATHS[number];
-  readonly required: readonly string[];
-}[] = [
-  { path: 'README.md', required: ['/api/goodvibes-agent/knowledge', 'bun add -g @pellux/goodvibes-agent'] },
-  { path: 'docs/README.md', required: ['/api/goodvibes-agent/knowledge'] },
-  { path: 'docs/getting-started.md', required: ['/api/goodvibes-agent/knowledge', 'bun add -g @pellux/goodvibes-agent'] },
-  { path: 'docs/connected-services.md', required: ['/api/goodvibes-agent/knowledge'] },
-  { path: 'docs/release-and-publishing.md', required: ['/api/goodvibes-agent/knowledge', 'bun add -g @pellux/goodvibes-agent'] },
-];
-const NON_COMMAND_ROUTE_ROOTS = new Set(['api', 'status']);
-
-function readPackageJson(root: string): Record<string, unknown> {
-  return JSON.parse(readFileSync(join(root, 'package.json'), 'utf-8')) as Record<string, unknown>;
-}
-
-function buildRegisteredSlashCommandNames(): ReadonlySet<string> {
-  const registry = new CommandRegistry();
-  registerBuiltinCommands(registry);
-  const names = new Set<string>();
-  for (const command of registry.list()) {
-    names.add(command.name);
-    for (const alias of command.aliases ?? []) names.add(alias);
-  }
-  return names;
-}
-
-function verifyPackageFacingSlashCommands(path: string, content: string, registeredCommands: ReadonlySet<string>): readonly string[] {
-  const failures: string[] = [];
-  const commandPattern = /(^|[\s`([])\/([a-z][a-z0-9_-]*)(?=$|[\s`.,;:)\]])/g;
-  const lines = content.split(/\r?\n/);
-  for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
-    const line = lines[lineIndex] ?? '';
-    commandPattern.lastIndex = 0;
-    for (let match = commandPattern.exec(line); match !== null; match = commandPattern.exec(line)) {
-      const root = match[2] ?? '';
-      if (NON_COMMAND_ROUTE_ROOTS.has(root)) continue;
-      if (registeredCommands.has(root)) continue;
-      failures.push(`package-facing text ${path}:${lineIndex + 1} references unknown Agent slash command: /${root}`);
-    }
-  }
-  return failures;
-}
-
-function hasExecutableBit(path: string): boolean {
-  return existsSync(path) && (statSync(path).mode & 0o111) !== 0;
-}
-
-function verifyBin(root: string, command: typeof REQUIRED_BIN_COMMANDS[number], target: string | undefined): PackageCliBinVerification {
-  const binPath = target ? join(root, target) : '';
-  const source = target && existsSync(binPath) ? readFileSync(binPath, 'utf-8') : '';
-  return {
-    command,
-    target: target ?? '',
-    exists: Boolean(target) && existsSync(binPath),
-    executable: Boolean(target) && hasExecutableBit(binPath),
-    usesBunShebang: source.startsWith('#!/usr/bin/env bun'),
-    hasSourceEntrypoint: source.includes('dist') && source.includes('package') && source.includes('main.js'),
-  };
-}
-
-function registryPackDryRun(root: string): { readonly files: readonly string[]; readonly entryCount: number; readonly unpackedSize: number } {
-  execSync('bun run build:package-runtime', {
-    cwd: root,
-    stdio: 'inherit',
-  });
-  const raw = execSync('npm pack --json --dry-run', {
-    cwd: root,
-    encoding: 'utf-8',
-    stdio: ['ignore', 'pipe', 'inherit'],
-  });
-  const [packResult] = JSON.parse(raw) as Array<{ files?: Array<{ path?: string }>; entryCount?: number; unpackedSize?: number }>;
-  return {
-    files: Array.isArray(packResult?.files) ? packResult.files.map((entry) => String(entry.path ?? '')) : [],
-    entryCount: Number(packResult?.entryCount ?? 0),
-    unpackedSize: Number(packResult?.unpackedSize ?? 0),
-  };
-}
-
-export function verifyPackageFacingText(root: string): { readonly checkedPaths: readonly string[]; readonly failures: readonly string[] } {
-  const failures: string[] = [];
-  const registeredCommands = buildRegisteredSlashCommandNames();
-  for (const path of PACKAGE_FACING_TEXT_PATHS) {
-    const absolutePath = join(root, path);
-    if (!existsSync(absolutePath)) {
-      failures.push(`package-facing text is missing: ${path}`);
-      continue;
-    }
-    const content = readFileSync(absolutePath, 'utf-8');
-    if (path !== 'CHANGELOG.md') {
-      failures.push(...verifyPackageFacingSlashCommands(path, content, registeredCommands));
-    }
-    for (const forbidden of PACKAGE_FACING_FORBIDDEN_TEXT) {
-      if (content.includes(forbidden)) {
-        failures.push(`package-facing text ${path} contains forbidden default/TUI route or policy: ${forbidden}`);
-      }
-    }
-    const requirement = PACKAGE_FACING_REQUIRED_TEXT.find((entry) => entry.path === path);
-    if (requirement) {
-      for (const required of requirement.required) {
-        if (!content.includes(required)) {
-          failures.push(`package-facing text ${path} is missing required Agent route/policy text: ${required}`);
-        }
-      }
-    }
-  }
-  return {
-    checkedPaths: PACKAGE_FACING_TEXT_PATHS,
-    failures,
-  };
-}
-
-export function verifyPackageCliInstall(root: string): PackageCliVerificationReport {
-  const pkg = readPackageJson(root);
-  const bin = pkg.bin && typeof pkg.bin === 'object' ? pkg.bin as Record<string, string | undefined> : {};
-  const bins = REQUIRED_BIN_COMMANDS.map((command) => verifyBin(root, command, bin[command]));
-  const pack = registryPackDryRun(root);
-  const requiredPathsPresent = REQUIRED_TARBALL_PATHS.filter((path) => pack.files.includes(path));
-  const forbiddenPaths = pack.files.filter((path) => {
-    if (FORBIDDEN_TARBALL_PREFIXES.some((prefix) => path.startsWith(prefix))) return true;
-    if (FORBIDDEN_TARBALL_FILES.has(path)) return true;
-    return FORBIDDEN_TARBALL_DOCS.some((docPath) => path === docPath || path.startsWith(docPath));
-  });
-  const issues: string[] = [];
-  const packageFacingText = verifyPackageFacingText(root);
-
-  for (const item of bins) {
-    if (!item.target) issues.push(`package.json bin is missing ${item.command}.`);
-    if (!item.exists) issues.push(`bin target does not exist: ${item.command} -> ${item.target}`);
-    if (!item.executable) issues.push(`bin target is not executable: ${item.command} -> ${item.target}`);
-    if (!item.usesBunShebang) issues.push(`bin target does not use Bun shebang: ${item.command} -> ${item.target}`);
-    if (!item.hasSourceEntrypoint) issues.push(`bin target does not load the packaged Agent runtime: ${item.command}`);
-  }
-  for (const path of REQUIRED_TARBALL_PATHS) {
-    if (!pack.files.includes(path)) issues.push(`registry tarball missing required path: ${path}`);
-  }
-  for (const path of forbiddenPaths) {
-    issues.push(`registry tarball includes forbidden path: ${path}`);
-  }
-  for (const failure of packageFacingText.failures) {
-    issues.push(failure);
-  }
-
-  return {
-    packageName: String(pkg.name ?? ''),
-    version: String(pkg.version ?? ''),
-    bins,
-    tarball: {
-      entryCount: pack.entryCount,
-      unpackedSize: pack.unpackedSize,
-      requiredPathsPresent,
-      forbiddenPaths,
-    },
-    packageFacingText,
-    issues,
-  };
-}

package/src/input/commands/policy-dispatch.ts

@@ -1,339 +0,0 @@
-import type { CommandContext } from '../command-registry.ts';
-import {
-  buildPolicyPreflightReview,
-  createPermissionSimulator,
-  lintPolicyConfig,
-  runPolicySimulationScenarios,
-} from '@/runtime/index.ts';
-import { DivergenceDashboard } from '@/runtime/index.ts';
-import type { PolicyRuntimeState } from '@/runtime/index.ts';
-import { createUnsignedBundle } from '@/runtime/index.ts';
-import type { PolicyBundlePayload } from '@/runtime/index.ts';
-import type { PolicyRule, PermissionsConfig, DivergenceStats } from '@/runtime/index.ts';
-import { requireShellPaths } from './runtime-services.ts';
-
-function getPolicyState(ctx?: CommandContext): PolicyRuntimeState {
-  const policyRuntimeState = ctx?.extensions.policyRuntimeState;
-  if (!policyRuntimeState) {
-    throw new Error('Policy state is not available in this Agent session.');
-  }
-  return policyRuntimeState;
-}
-
-function getRegistry(ctx?: CommandContext) {
-  return ctx?.extensions.policyRegistry ?? getPolicyState(ctx).getRegistry();
-}
-
-function fmtRate(rate: number): string {
-  return `${(rate * 100).toFixed(1)}%`;
-}
-
-function bundleSummary(
-  label: string,
-  version: { bundle: { bundleId: string; issuedAt: string; issuer?: string }; state: string; rules: PolicyRule[] },
-): string {
-  const issuer = version.bundle.issuer ? ` issuer=${version.bundle.issuer}` : '';
-  const ts = version.bundle.issuedAt.replace('T', ' ').slice(0, 19);
-  return `${label}: ${version.bundle.bundleId} (${ts}${issuer}) [${version.rules.length} rules, ${version.state}]`;
-}
-
-async function handleLoad(args: string[], context: CommandContext): Promise<void> {
-  const registry = getRegistry(context);
-  const policyState = getPolicyState(context);
-  const bundleId = args[0] ?? `policy-candidate-${Date.now()}`;
-  const ruleCount = Math.max(0, parseInt(args[1] ?? '0', 10));
-  const rules: PolicyRule[] = [];
-  for (let i = 0; i < ruleCount; i++) {
-    rules.push({
-      type: 'prefix',
-      id: `${bundleId}-rule-${i}`,
-      description: `Demo rule ${i}`,
-      origin: 'user',
-      effect: 'allow',
-      toolPattern: '*',
-      commandPrefixes: [],
-    });
-  }
-  const payload: PolicyBundlePayload = {
-    version: 1,
-    rules,
-    description: `Loaded via /policy load at ${new Date().toISOString()}`,
-  };
-  const bundle = createUnsignedBundle(bundleId, payload);
-  const result = registry.loadCandidate(bundle);
-  if (!result.ok) {
-    context.print(`[policy] Load failed: ${result.error ?? 'unknown error'}`);
-    return;
-  }
-  const candidate = registry.getCandidate();
-  if (candidate) {
-    policyState.notify();
-    context.print(bundleSummary('[policy] Candidate loaded', candidate));
-    context.print('[policy] Next: run `/policy simulate` to collect divergence evidence before promoting.');
-  }
-}
-
-async function handleSimulate(args: string[], context: CommandContext): Promise<void> {
-  const registry = getRegistry(context);
-  const policyState = getPolicyState(context);
-  const projectRoot = requireShellPaths(context).workingDirectory;
-  const candidate = registry.getCandidate();
-  const current = registry.getCurrent();
-  if (!candidate) {
-    context.print('[policy] No candidate bundle loaded. Run `/policy load <bundle-id>` first.');
-    return;
-  }
-  if (!registry.markSimulating()) {
-    context.print(`[policy] Cannot start simulation: candidate is in "${candidate.state}" state. Only a freshly loaded ("loaded") candidate can be simulated.`);
-    return;
-  }
-  const currentConfig: PermissionsConfig = {
-    mode: 'default',
-    projectRoot,
-    rules: current?.rules ?? [],
-    defaultEffect: 'allow',
-  };
-  const candidateForSim = registry.getCandidate();
-  if (!candidateForSim) {
-    throw new Error('Invariant: candidate disappeared after markSimulating()');
-  }
-  const candidateConfig: PermissionsConfig = {
-    mode: 'default',
-    projectRoot,
-    rules: candidateForSim.rules,
-    defaultEffect: 'allow',
-  };
-  const modeArg = args[0];
-  const simulationMode = modeArg === 'enforce' ? 'enforce' : modeArg === 'silent' ? 'simulation-only' : 'warn-on-divergence';
-  const simulator = createPermissionSimulator(currentConfig, candidateConfig, simulationMode, {});
-  const dashboard = new DivergenceDashboard(simulator, simulationMode, { threshold: 0.05 });
-  policyState.setDashboard(dashboard);
-  context.print(`[policy] Simulation started in "${simulationMode}" mode. Evaluations will be tracked against candidate bundle "${candidate.bundle.bundleId}".`);
-  context.print('[policy] Use `/policy diff` to compare rules. When ready, run `/policy promote` to enforce (requires gate passing).');
-  const report = simulator.getDivergenceReport();
-  const gateResult = dashboard.checkEnforceGate();
-  const scenarioSummary = runPolicySimulationScenarios(simulator);
-  registry.attachSimulationReport(report, gateResult);
-  policyState.recordSimulationSummary(scenarioSummary);
-  const candidate2 = registry.getCandidate();
-  policyState.notify();
-  context.print(`[policy] Baseline divergence: ${fmtRate(report.overall.divergenceRate)} (${report.overall.total} divergences / ${report.overall.totalEvaluations} evaluations). Gate: ${gateResult.status}.`);
-  context.print(`[policy] Scenario run: ${scenarioSummary.totalScenarios} samples, ${scenarioSummary.divergentScenarios} diverged, ${scenarioSummary.allowedByActual}/${scenarioSummary.allowedBySimulated} allowed (actual/candidate).`);
-  if (candidate2) context.print(bundleSummary('[policy] Candidate state', candidate2));
-}
-
-async function handleDiff(_args: string[], context: CommandContext): Promise<void> {
-  const registry = getRegistry(context);
-  const diff = registry.diff();
-  if (!diff) {
-    const current = registry.getCurrent();
-    const candidate = registry.getCandidate();
-    if (!current) context.print('[policy] No active bundle. Load a bundle with `/policy load`.');
-    else if (!candidate) context.print('[policy] No candidate bundle. Load a candidate with `/policy load`.');
-    else context.print('[policy] Diff unavailable.');
-    return;
-  }
-  context.print(`[policy] Diff: ${diff.fromBundleId} → ${diff.toBundleId} (${diff.totalChanges} change${diff.totalChanges !== 1 ? 's' : ''})`);
-  context.print(`  Added:    ${diff.added.length} rule${diff.added.length !== 1 ? 's' : ''}`);
-  context.print(`  Removed:  ${diff.removed.length} rule${diff.removed.length !== 1 ? 's' : ''}`);
-  context.print(`  Changed:  ${diff.changed.length} rule${diff.changed.length !== 1 ? 's' : ''}`);
-  context.print(`  Unchanged: ${diff.unchanged.length} rule${diff.unchanged.length !== 1 ? 's' : ''}`);
-  if (diff.added.length > 0) {
-    context.print('  [+] Added rules:');
-    for (const r of diff.added) context.print(`      + ${r.id} (${r.type}, effect=${r.effect})`);
-  }
-  if (diff.removed.length > 0) {
-    context.print('  [-] Removed rules:');
-    for (const r of diff.removed) context.print(`      - ${r.id} (${r.type}, effect=${r.effect})`);
-  }
-  if (diff.changed.length > 0) {
-    context.print('  [~] Changed rules:');
-    for (const c of diff.changed) context.print(`      ~ ${c.ruleId}`);
-  }
-  const dashboard = getPolicyState(context).getDashboard();
-  if (dashboard) {
-    const snap = dashboard.getSnapshot();
-    const report = snap.report;
-    const prefixEntries = Object.entries(report.byCommandPrefix);
-    if (prefixEntries.length > 0) {
-      context.print('  [divergence by command prefix]');
-      for (const [prefix, stats] of prefixEntries) {
-        context.print(`      ${prefix}: ${fmtRate(stats.divergenceRate)} (${stats.total}/${stats.totalEvaluations})`);
-      }
-    }
-    const classEntries = Object.entries(report.byToolClass) as Array<[string, DivergenceStats]>;
-    if (classEntries.length > 0) {
-      context.print('  [divergence by tool class]');
-      for (const [cls, stats] of classEntries) {
-        if (!stats) continue;
-        context.print(`      ${cls}: ${fmtRate(stats.divergenceRate)} (${stats.total}/${stats.totalEvaluations})`);
-      }
-    }
-  }
-}
-
-async function handleLint(_args: string[], context: CommandContext): Promise<void> {
-  const registry = getRegistry(context);
-  const current = registry.getCurrent();
-  const candidate = registry.getCandidate();
-  if (!current && !candidate) {
-    context.print('[policy] No policy bundles loaded. Use `/policy load` to begin.');
-    return;
-  }
-  const findings = [
-    ...(current ? lintPolicyConfig({ mode: 'custom', rules: current.rules }).map((finding) => ({ scope: 'current', ...finding })) : []),
-    ...(candidate ? lintPolicyConfig({ mode: 'custom', rules: candidate.rules }).map((finding) => ({ scope: 'candidate', ...finding })) : []),
-  ];
-  if (findings.length === 0) {
-    context.print('[policy] No lint findings for the active or candidate bundles.');
-    return;
-  }
-  context.print(`[policy] Lint findings (${findings.length}):`);
-  for (const finding of findings) {
-    context.print(`  [${finding.scope}] ${finding.severity.toUpperCase()} ${finding.ruleId ? `${finding.ruleId}: ` : ''}${finding.message}`);
-  }
-}
-
-async function handlePreflight(_args: string[], context: CommandContext): Promise<void> {
-  const registry = getRegistry(context);
-  const policyState = getPolicyState(context);
-  const current = registry.getCurrent();
-  const candidate = registry.getCandidate();
-  const lintFindings = [
-    ...(current ? lintPolicyConfig({ mode: 'custom', rules: current.rules }) : []),
-    ...(candidate ? lintPolicyConfig({ mode: 'custom', rules: candidate.rules }) : []),
-  ];
-  const review = buildPolicyPreflightReview({
-    config: context.platform.config,
-    lintFindings,
-    mcpServers: context.extensions.mcpRegistry.listServerSecurity().map((server) => ({
-      serverName: server.name,
-      trustMode: server.trustMode,
-      role: server.role,
-      allowedPaths: server.allowedPaths,
-      allowedHosts: server.allowedHosts,
-    })),
-  });
-  policyState.recordPreflightReview(review);
-  context.print(`[policy] Preflight review: ${review.status.toUpperCase()} (${review.issueCount} issue${review.issueCount === 1 ? '' : 's'})`);
-  context.print(`[policy] ${review.summary}`);
-  for (const issue of review.issues.slice(0, 8)) {
-    const subject = issue.serverName ? ` ${issue.serverName}` : '';
-    const detail = issue.detail ? ` — ${issue.detail}` : '';
-    context.print(`  [${issue.severity.toUpperCase()}] ${issue.source}${subject}: ${issue.message}${detail}`);
-  }
-}
-
-async function handlePromote(args: string[], context: CommandContext): Promise<void> {
-  const registry = getRegistry(context);
-  const policyState = getPolicyState(context);
-  const force = args.includes('--force');
-  if (force) {
-    context.print('[policy] WARNING: --force bypasses the divergence gate. This is not safe for production use.');
-  }
-  const result = registry.promote(force);
-  if (!result.ok) {
-    context.print(`[policy] Promotion blocked: ${result.error}`);
-    if (result.gate) {
-      context.print(`[policy] Gate: ${result.gate.status} — divergence rate ${result.gate.divergenceRate !== undefined ? fmtRate(result.gate.divergenceRate) : 'unknown'} (threshold ${fmtRate(result.gate.threshold)}, ${result.gate.totalEvaluations} evaluations).`);
-    }
-    return;
-  }
-  const current = registry.getCurrent();
-  context.print(`[policy] Promoted: "${result.bundleId}" is now the active enforcement policy.`);
-  if (result.gate) {
-    context.print(`[policy] Gate at promotion: ${result.gate.status} — divergence rate ${result.gate.divergenceRate !== undefined ? fmtRate(result.gate.divergenceRate) : 'unknown'} (threshold ${fmtRate(result.gate.threshold)}).`);
-  }
-  if (current) context.print(bundleSummary('[policy] Active bundle', current));
-  policyState.notify();
-}
-
-async function handleRollback(_args: string[], context: CommandContext): Promise<void> {
-  const registry = getRegistry(context);
-  const policyState = getPolicyState(context);
-  const result = registry.rollback();
-  if (!result.ok) {
-    context.print(`[policy] Rollback failed: ${result.error}`);
-    return;
-  }
-  const current = registry.getCurrent();
-  context.print(`[policy] Rolled back to bundle "${result.restoredBundleId}".`);
-  if (current) context.print(bundleSummary('[policy] Active bundle', current));
-  policyState.setDashboard(null);
-  policyState.notify();
-  context.print('[policy] Simulation dashboard cleared. Run `/policy simulate` for the restored bundle.');
-}
-
-async function handleStatus(_args: string[], context: CommandContext): Promise<void> {
-  const registry = getRegistry(context);
-  const policyState = getPolicyState(context);
-  const current = registry.getCurrent();
-  const candidate = registry.getCandidate();
-  const history = registry.getHistory();
-  if (!current && !candidate) {
-    context.print('[policy] No policy bundles loaded. Use `/policy load` to begin.');
-    return;
-  }
-  if (current) context.print(bundleSummary('[policy] Current (enforced)', current));
-  if (candidate) context.print(bundleSummary('[policy] Candidate', candidate));
-  context.print(`[policy] History: ${history.length} previous bundle(s).`);
-  const dashboard = policyState.getDashboard();
-  if (dashboard) {
-    const snap = dashboard.getSnapshot();
-    context.print(`[policy] Divergence gate: ${snap.gate.status} — ${snap.gate.divergenceRate !== undefined ? fmtRate(snap.gate.divergenceRate) : fmtRate(snap.report.overall.divergenceRate)} (${snap.report.overall.totalEvaluations} evaluations).`);
-  } else {
-    context.print('[policy] No active simulation dashboard.');
-  }
-}
-
-export function renderPolicyUsage(): string {
-  return [
-    'Usage: /policy <subcommand>',
-    '  /policy                        — open the policy/governance panel',
-    '  load <bundle-id> [rule-count]  — Load a candidate bundle',
-    '  simulate [mode]               — Run simulation (silent|warn|enforce)',
-    '  diff                          — Show rule diff (current vs candidate)',
-    '  lint                          — Lint active and candidate bundles',
-    '  preflight                     — Review proactive policy and MCP risk state',
-    '  promote [--force]             — Promote candidate to enforcement',
-    '  rollback                      — Restore the previous active bundle',
-    '  status                        — Show current policy state',
-  ].join('\n');
-}
-
-export async function dispatchPolicyCommand(args: string[], context: CommandContext): Promise<void> {
-  const [sub, ...rest] = args;
-  switch (sub) {
-    case 'load':
-      await handleLoad(rest, context);
-      break;
-    case 'simulate':
-    case 'sim':
-      await handleSimulate(rest, context);
-      break;
-    case 'diff':
-      await handleDiff(rest, context);
-      break;
-    case 'lint':
-      await handleLint(rest, context);
-      break;
-    case 'preflight':
-    case 'pf':
-      await handlePreflight(rest, context);
-      break;
-    case 'promote':
-      await handlePromote(rest, context);
-      break;
-    case 'rollback':
-    case 'rb':
-      await handleRollback(rest, context);
-      break;
-    case 'status':
-    case 'st':
-      await handleStatus(rest, context);
-      break;
-    default:
-      context.print(renderPolicyUsage());
-      break;
-  }
-}

package/src/input/commands/policy.ts

@@ -1,17 +0,0 @@
-import type { SlashCommand, CommandContext } from '../command-registry.ts';
-import { dispatchPolicyCommand } from './policy-dispatch.ts';
-
-export const policyCommand: SlashCommand = {
-  name: 'policy',
-  aliases: ['pol'],
-  description: 'Open the policy panel or manage versioned policy bundles (load, simulate, diff, promote, rollback).',
-  usage: '<subcommand> [args]',
-  argsHint: 'load|simulate|diff|lint|preflight|promote|rollback|status',
-  handler: async (args: string[], context: CommandContext): Promise<void> => {
-    if (args.length === 0 && context.openPolicyPanel) {
-      context.openPolicyPanel();
-      return;
-    }
-    await dispatchPolicyCommand(args, context);
-  },
-};