@pellux/goodvibes-agent 0.1.53 → 0.1.55

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 All notable changes to GoodVibes Agent will be recorded here.
 
+## 0.1.55 - 2026-05-31
+
+- d8f4eee Remove copied developer audit surfaces
+
+## 0.1.54 - 2026-05-31
+
+- dc1a290 Keep release docs version-neutral
+- 07eb275 Stabilize Bun package install smoke
+- d5da8fb Fix Bun global TUI launch smoke
+- 883a11c Add exact-confirm local library delete flow
+
 ## 0.1.53 - 2026-05-31
 
 - 77ad0cf Add local library edit workspace flow

package/docs/deployment-and-services.md

@@ -27,6 +27,7 @@ The executable is backed by TypeScript-authored source with a Bun shebang. Packa
 - `goodvibes-agent --help`
 - `goodvibes-agent --version`
 - `goodvibes-agent status --json`
+- `goodvibes-agent` launches the TUI in a real PTY
 - `goodvibes-agent smoke --json` when that command is available in the baseline being tested
 
 ## External Daemon Connection

package/docs/release-and-publishing.md

@@ -1,6 +1,6 @@
 # Release And Publishing
 
-GoodVibes Agent `0.1.9` is the current installable public alpha release.
+GoodVibes Agent's current installable public alpha version is recorded in `package.json` and `CHANGELOG.md`.
 
 ## Package Identity
 
@@ -21,7 +21,7 @@ bun run typecheck
 bun run build
 bun run package:install-check
 bun run publish:check
-npm pack --dry-run
+bun pm pack --dry-run
 git diff --check
 ```
 
@@ -34,6 +34,7 @@ Also run the package install smoke from a packed artifact. It must prove:
 - the Bun shebang survives pack/install
 - `goodvibes-agent --help` works
 - `goodvibes-agent --version` reports the package version
+- the installed TUI launches in a PTY and does not exit immediately
 - daemon-backed commands fail clearly when the external daemon is unavailable or unauthenticated
 - no token value is printed
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "0.1.53",
+  "version": "0.1.55",
   "private": false,
   "description": "Near-fork GoodVibes operator assistant with the GoodVibes TUI shell, renderer, input, fullscreen workspace, and daemon-connected Agent product brain.",
   "type": "module",
@@ -65,10 +65,7 @@
     "architecture:check": "bun run scripts/check-architecture.ts",
     "foundation:artifacts": "bun run scripts/export-foundation-artifacts.ts",
     "verification:ledger": "bun run scripts/verification-ledger.ts",
-    "verification:live": "bun run scripts/verify-live.ts",
-    "eval:gate": "bun run scripts/eval-gate.ts",
-    "eval:gate:verbose": "bun run scripts/eval-gate.ts --verbose",
-    "eval:baseline": "bun run scripts/eval-gate.ts --save-baseline"
+    "verification:live": "bun run scripts/verify-live.ts"
   },
   "license": "MIT",
   "repository": {

package/scripts/check-bun.sh

@@ -8,8 +8,6 @@ goodvibes-agent requires Bun.
 Install Bun first, then install GoodVibes Agent from the npm registry with:
 
   bun add -g @pellux/goodvibes-agent
-
-npm install -g @pellux/goodvibes-agent also works, but Bun must already be installed and available on PATH.
 EOF
   exit 1
 fi

package/src/input/agent-workspace.ts

@@ -1,4 +1,5 @@
 import type { InputToken } from '@pellux/goodvibes-sdk/platform/core';
+import type { ShellPathService } from '@/runtime/index.ts';
 import { basename, sep } from 'node:path';
 import type { CommandContext } from './command-registry.ts';
 import { AgentPersonaRegistry, type AgentPersonaRecord } from '../agent/persona-registry.ts';
@@ -29,15 +30,18 @@ export type AgentWorkspaceLocalOperation =
   | 'persona-use'
   | 'persona-review'
   | 'persona-clear'
+  | 'persona-delete'
   | 'skill-edit'
   | 'skill-enable'
   | 'skill-disable'
   | 'skill-review'
+  | 'skill-delete'
   | 'routine-edit'
   | 'routine-start'
   | 'routine-enable'
   | 'routine-disable'
-  | 'routine-review';
+  | 'routine-review'
+  | 'routine-delete';
 
 export interface AgentWorkspaceEditorField {
   readonly id: string;
@@ -50,7 +54,7 @@ export interface AgentWorkspaceEditorField {
 
 export interface AgentWorkspaceLocalEditor {
   readonly kind: AgentWorkspaceLocalEditorKind;
-  readonly mode: 'create' | 'update';
+  readonly mode: 'create' | 'update' | 'delete';
   readonly recordId?: string;
   readonly title: string;
   readonly fields: readonly AgentWorkspaceEditorField[];
@@ -542,6 +546,7 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
       { id: 'personas-use', label: 'Use selected', detail: 'Activate the selected local persona for future main-conversation turns.', localKind: 'persona', localOperation: 'persona-use', kind: 'local-operation', safety: 'safe' },
       { id: 'personas-review', label: 'Review selected', detail: 'Mark the selected local persona reviewed after inspecting it.', localKind: 'persona', localOperation: 'persona-review', kind: 'local-operation', safety: 'safe' },
       { id: 'personas-clear', label: 'Clear active persona', detail: 'Return to the default Agent policy without deleting any persona.', localKind: 'persona', localOperation: 'persona-clear', kind: 'local-operation', safety: 'safe' },
+      { id: 'personas-delete', label: 'Delete selected', detail: 'Open a confirmation form before deleting the selected local persona.', localKind: 'persona', localOperation: 'persona-delete', kind: 'local-operation', safety: 'safe' },
     ],
   },
   {
@@ -560,6 +565,7 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
       { id: 'skills-enable', label: 'Enable selected', detail: 'Enable the selected local Agent skill for future main-conversation guidance.', localKind: 'skill', localOperation: 'skill-enable', kind: 'local-operation', safety: 'safe' },
       { id: 'skills-disable', label: 'Disable selected', detail: 'Disable the selected local Agent skill without deleting it.', localKind: 'skill', localOperation: 'skill-disable', kind: 'local-operation', safety: 'safe' },
       { id: 'skills-review', label: 'Review selected', detail: 'Mark the selected local skill reviewed after inspecting it.', localKind: 'skill', localOperation: 'skill-review', kind: 'local-operation', safety: 'safe' },
+      { id: 'skills-delete', label: 'Delete selected', detail: 'Open a confirmation form before deleting the selected local Agent skill.', localKind: 'skill', localOperation: 'skill-delete', kind: 'local-operation', safety: 'safe' },
     ],
   },
   {
@@ -579,6 +585,7 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
       { id: 'routines-enable', label: 'Enable selected', detail: 'Enable the selected routine for future main-conversation guidance.', localKind: 'routine', localOperation: 'routine-enable', kind: 'local-operation', safety: 'safe' },
       { id: 'routines-disable', label: 'Disable selected', detail: 'Disable the selected routine without deleting it.', localKind: 'routine', localOperation: 'routine-disable', kind: 'local-operation', safety: 'safe' },
       { id: 'routines-review', label: 'Review selected', detail: 'Mark the selected local routine reviewed after inspecting it.', localKind: 'routine', localOperation: 'routine-review', kind: 'local-operation', safety: 'safe' },
+      { id: 'routines-delete', label: 'Delete selected', detail: 'Open a confirmation form before deleting the selected local Agent routine.', localKind: 'routine', localOperation: 'routine-delete', kind: 'local-operation', safety: 'safe' },
       { id: 'routines-promote', label: 'Promote to schedule', detail: 'Create an external daemon schedule from a reviewed routine only with real timing and --yes.', command: '/routines promote <id> --cron <expr> --yes', kind: 'command', safety: 'safe' },
       { id: 'routines-receipts', label: 'Promotion receipts', detail: 'Inspect local redacted routine schedule promotion receipts.', command: '/routines receipts', kind: 'command', safety: 'read-only' },
     ],
@@ -740,6 +747,21 @@ function createRoutineUpdateEditor(record: AgentRoutineRecord): AgentWorkspaceLo
   };
 }
 
+function createDeleteEditor(kind: AgentWorkspaceLocalEditorKind, item: AgentWorkspaceLocalLibraryItem): AgentWorkspaceLocalEditor {
+  const label = kind[0]!.toUpperCase() + kind.slice(1);
+  return {
+    kind,
+    mode: 'delete',
+    recordId: item.id,
+    title: `Delete ${label}`,
+    selectedFieldIndex: 0,
+    message: `Type ${item.id} exactly to delete ${item.name}. This only changes the Agent-local registry.`,
+    fields: [
+      { id: 'confirm', label: 'Confirm id', value: '', required: true, multiline: false, hint: `Type ${item.id} exactly.` },
+    ],
+  };
+}
+
 function splitList(value: string): string[] {
   return value.split(',').map((part) => part.trim()).filter(Boolean);
 }
@@ -1148,6 +1170,8 @@ export class AgentWorkspace {
       } else if (operation === 'persona-review') {
         AgentPersonaRegistry.fromShellPaths(shellPaths).markReviewed(selected.id);
         this.finishLocalOperation('persona', `Reviewed persona ${selected.name}`, `${selected.name} is marked reviewed.`);
+      } else if (operation === 'persona-delete') {
+        this.openDeleteEditor('persona', selected);
       } else if (operation === 'skill-edit') {
         const skill = AgentSkillRegistry.fromShellPaths(shellPaths).get(selected.id);
         if (!skill) throw new Error(`Unknown skill: ${selected.id}`);
@@ -1168,6 +1192,8 @@ export class AgentWorkspace {
       } else if (operation === 'skill-review') {
         AgentSkillRegistry.fromShellPaths(shellPaths).markReviewed(selected.id);
         this.finishLocalOperation('skill', `Reviewed skill ${selected.name}`, `${selected.name} is marked reviewed.`);
+      } else if (operation === 'skill-delete') {
+        this.openDeleteEditor('skill', selected);
       } else if (operation === 'routine-edit') {
         const routine = AgentRoutineRegistry.fromShellPaths(shellPaths).get(selected.id);
         if (!routine) throw new Error(`Unknown routine: ${selected.id}`);
@@ -1188,9 +1214,11 @@ export class AgentWorkspace {
       } else if (operation === 'routine-disable') {
         AgentRoutineRegistry.fromShellPaths(shellPaths).setEnabled(selected.id, false);
         this.finishLocalOperation('routine', `Disabled routine ${selected.name}`, `${selected.name} remains saved but is no longer injected into guidance.`);
-      } else {
+      } else if (operation === 'routine-review') {
         AgentRoutineRegistry.fromShellPaths(shellPaths).markReviewed(selected.id);
         this.finishLocalOperation('routine', `Reviewed routine ${selected.name}`, `${selected.name} is marked reviewed.`);
+      } else {
+        this.openDeleteEditor('routine', selected);
       }
     } catch (error) {
       const detail = error instanceof Error ? error.message : String(error);
@@ -1221,6 +1249,17 @@ export class AgentWorkspace {
     };
   }
 
+  private openDeleteEditor(kind: AgentWorkspaceLocalEditorKind, selected: AgentWorkspaceLocalLibraryItem): void {
+    this.localEditor = createDeleteEditor(kind, selected);
+    this.status = `Confirm deletion for ${selected.name}.`;
+    this.lastActionResult = {
+      kind: 'guidance',
+      title: this.localEditor.title,
+      detail: this.localEditor.message,
+      safety: 'safe',
+    };
+  }
+
   private replaceEditorField(index: number, value: string, message: string): void {
     const editor = this.localEditor;
     if (!editor) return;
@@ -1265,6 +1304,10 @@ export class AgentWorkspace {
       return;
     }
     try {
+      if (editor.mode === 'delete') {
+        this.submitLocalDeleteEditor(shellPaths, editor);
+        return;
+      }
       if (editor.kind === 'persona') {
         const registry = AgentPersonaRegistry.fromShellPaths(shellPaths);
         if (editor.mode === 'update' && editor.recordId) {
@@ -1358,6 +1401,29 @@ export class AgentWorkspace {
     }
   }
 
+  private submitLocalDeleteEditor(shellPaths: ShellPathService, editor: AgentWorkspaceLocalEditor): void {
+    const expectedId = editor.recordId ?? '';
+    const confirmedId = this.editorField('confirm');
+    if (!expectedId || confirmedId !== expectedId) {
+      this.localEditor = {
+        ...editor,
+        message: `Deletion not confirmed. Type ${expectedId} exactly, then press Enter.`,
+      };
+      this.status = 'Deletion not confirmed.';
+      return;
+    }
+    if (editor.kind === 'persona') {
+      const removed = AgentPersonaRegistry.fromShellPaths(shellPaths).deletePersona(expectedId);
+      this.finishLocalDelete(editor.kind, removed.id, removed.name);
+    } else if (editor.kind === 'skill') {
+      const removed = AgentSkillRegistry.fromShellPaths(shellPaths).deleteSkill(expectedId);
+      this.finishLocalDelete(editor.kind, removed.id, removed.name);
+    } else {
+      const removed = AgentRoutineRegistry.fromShellPaths(shellPaths).deleteRoutine(expectedId);
+      this.finishLocalDelete(editor.kind, removed.id, removed.name);
+    }
+  }
+
   private finishLocalEditor(kind: AgentWorkspaceLocalEditorKind, id: string, name: string, verb: 'Created' | 'Updated'): void {
     this.localEditor = null;
     const categoryId = editorCategoryId(kind);
@@ -1376,6 +1442,25 @@ export class AgentWorkspace {
     };
     this.clampSelection();
   }
+
+  private finishLocalDelete(kind: AgentWorkspaceLocalEditorKind, id: string, name: string): void {
+    this.localEditor = null;
+    const categoryId = editorCategoryId(kind);
+    const categoryIndex = this.categories.findIndex((category) => category.id === categoryId);
+    if (categoryIndex >= 0) {
+      this.selectedCategoryIndex = categoryIndex;
+      this.selectedActionIndex = 0;
+    }
+    this.runtimeSnapshot = this.context ? buildAgentWorkspaceRuntimeSnapshot(this.context) : this.runtimeSnapshot;
+    this.status = `Deleted ${kind}: ${name}.`;
+    this.lastActionResult = {
+      kind: 'refreshed',
+      title: `Deleted ${kind}`,
+      detail: `${name} (${id}) was removed from the Agent-local ${categoryId} registry.`,
+      safety: 'safe',
+    };
+    this.clampSelection();
+  }
 }
 
 export function handleAgentWorkspaceToken(

package/src/input/command-registry.ts

@@ -177,7 +177,6 @@ export interface CommandOpsServices
 export interface CommandExtensionRegistryServices {
   readonly toolRegistry: ToolRegistry;
   readonly mcpRegistry: McpRegistry;
-  readonly evalRegistry?: import('../panels/eval-panel.ts').EvalRegistry;
 }
 
 export interface CommandExtensionServices

package/src/input/commands/local-runtime.ts

@@ -67,7 +67,7 @@ export function registerLocalRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'tools',
     aliases: ['t'],
-    description: 'List available tools and review compact native tool capability surfaces',
+    description: 'List available tools and review tool safety/status',
     usage: '[review|panel]',
     handler(args, ctx) {
       const sub = (args[0] ?? '').toLowerCase();
@@ -79,12 +79,11 @@ export function registerLocalRuntimeCommands(registry: CommandRegistry): void {
         }
         if (sub === 'review') {
           ctx.print([
-            'Tool Surface Review',
-            '  Native file tools stay compact by default.',
-            '  Read/write/edit/notebook capabilities are available through the native tool stack, with detail routed to the tools panel and approval surfaces instead of transcript bloat.',
-            '  Shell and native tool approvals classify work into read, mutation, destructive, dependency, config, notebook, network, remote, and lifecycle risk families.',
-            '  Use /tools panel to inspect risk class, output-policy actions, spill posture, compact summaries, and approval posture for recent calls.',
-            '  Use /approval review shell or /approval review file when you need the action-specific why-prompted posture.',
+            'Tool Status',
+            '  Tools are available for the main Agent conversation.',
+            '  Read-only actions can run directly; writes, destructive changes, network effects, service changes, and external side effects require explicit user intent or approval.',
+            '  Recent tool activity and approval posture are available in the tools and approvals views.',
+            '  Build/fix/review work should be delegated explicitly with /delegate.',
           ].join('\n'));
         }
         return;

package/src/input/commands/operator-runtime.ts

@@ -1,6 +1,5 @@
 import type { CommandRegistry } from '../command-registry.ts';
 import type { ProfileData } from '@pellux/goodvibes-sdk/platform/profiles';
-import { ToolContractVerifier } from '@/runtime/index.ts';
 import type { ReplaySnapshotInput } from '@/runtime/index.ts';
 import { logger } from '@pellux/goodvibes-sdk/platform/utils';
 import { registerOperatorPanelCommand } from './operator-panel-runtime.ts';
@@ -283,55 +282,6 @@ export function registerOperatorRuntimeCommands(registry: CommandRegistry): void
     },
   });
 
-  registry.register({
-    name: 'tool',
-    description: 'Tool contract verification — verify registered tool contracts',
-    usage: 'verify <name> | verify-all | contract show <name>',
-    argsHint: 'verify <name> | verify-all | contract show <name>',
-    handler(args, ctx) {
-      const sub = args[0];
-      if (sub === 'verify' && args[1]) {
-        const result = ctx.extensions.toolRegistry.verifyContract(args[1]);
-        if (!result) {
-          ctx.print(`[tool verify] Tool '${args[1]}' is not registered.`);
-          return;
-        }
-        ctx.print(ToolContractVerifier.formatResult(result));
-        return;
-      }
-      if (sub === 'verify-all') {
-        ctx.print(ToolContractVerifier.formatAllResults(ctx.extensions.toolRegistry.verifyAllContracts()));
-        return;
-      }
-      if (sub === 'contract' && args[1] === 'show' && args[2]) {
-        const toolName = args[2];
-        const result = ctx.extensions.toolRegistry.verifyContract(toolName);
-        if (!result) {
-          ctx.print(`[tool contract show] Tool '${toolName}' is not registered.`);
-          return;
-        }
-        const lines: string[] = [ToolContractVerifier.formatResult(result)];
-        const tool = ctx.extensions.toolRegistry.list().find((t) => t.definition.name === toolName);
-        if (tool) {
-          lines.push('');
-          lines.push('Tool Definition:');
-          lines.push(`  Name:        ${tool.definition.name}`);
-          lines.push(`  Description: ${tool.definition.description}`);
-          lines.push(`  Parameters:  ${JSON.stringify(tool.definition.parameters, null, 2).replace(/\n/g, '\n               ')}`);
-        }
-        ctx.print(lines.join('\n'));
-        return;
-      }
-
-      ctx.print(
-        'Usage: /tool <subcommand>\n'
-        + '  /tool verify <name>             — verify contract for a specific registered tool\n'
-        + '  /tool verify-all                — verify contracts for all registered tools\n'
-        + '  /tool contract show <name>      — show full contract details for a tool'
-      );
-    },
-  });
-
   registry.register({
     name: 'forensics',
     aliases: ['foren'],

package/src/input/commands/product-runtime.ts

@@ -1,9 +1,7 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
 import type { CommandContext, CommandRegistry } from '../command-registry.ts';
-import { listInstalledEcosystemEntries, loadEcosystemCatalog } from '@/runtime/index.ts';
-import { BUILTIN_SUITES } from '@/runtime/index.ts';
-import { requireEcosystemCatalogPaths, requireReadModels, requireSecretsManager, requireServiceRegistry, requireShellPaths } from './runtime-services.ts';
+import { requireReadModels, requireSecretsManager, requireServiceRegistry, requireShellPaths } from './runtime-services.ts';
 import { requireYesFlag, stripYesFlag } from './confirmation.ts';
 
 interface TrustReviewBundle {
@@ -29,29 +27,6 @@ interface TrustReviewBundle {
   };
 }
 
-interface ReleaseBundle {
-  readonly version: 1;
-  readonly capturedAt: number;
-  readonly runtime: {
-    readonly provider: string;
-    readonly model: string;
-    readonly sessionId: string;
-  };
-  readonly evalSuites: readonly string[];
-  readonly incidentCount: number;
-  readonly remote: {
-    readonly pools: number;
-    readonly contracts: number;
-    readonly artifacts: number;
-  };
-  readonly ecosystem: {
-    readonly pluginCatalog: number;
-    readonly skillCatalog: number;
-    readonly installedPlugins: number;
-    readonly installedSkills: number;
-  };
-}
-
 function countByMode<T extends string>(values: readonly T[], mode: T): number {
   return values.filter((value) => value === mode).length;
 }
@@ -112,46 +87,6 @@ function inspectTrustBundle(path: string): string {
   ].join('\n');
 }
 
-function buildReleaseBundle(ctx: Parameters<NonNullable<CommandRegistry['register']>>[0]['handler'] extends (args: string[], context: infer C) => unknown ? C : never): ReleaseBundle {
-  const remoteRuntime = ctx.ops.remoteRuntime;
-  const incidents = ctx.extensions.forensicsRegistry?.getAll() ?? [];
-  const ecosystemPaths = requireEcosystemCatalogPaths(ctx);
-  return {
-    version: 1,
-    capturedAt: Date.now(),
-    runtime: {
-      provider: ctx.session.runtime.provider,
-      model: ctx.session.runtime.model,
-      sessionId: ctx.session.runtime.sessionId,
-    },
-    evalSuites: Object.keys(BUILTIN_SUITES),
-    incidentCount: incidents.length,
-    remote: {
-      pools: remoteRuntime?.listPools().length ?? 0,
-      contracts: remoteRuntime?.listContracts().length ?? 0,
-      artifacts: remoteRuntime?.listArtifacts().length ?? 0,
-    },
-    ecosystem: {
-      pluginCatalog: loadEcosystemCatalog('plugin', ecosystemPaths).length,
-      skillCatalog: loadEcosystemCatalog('skill', ecosystemPaths).length,
-      installedPlugins: listInstalledEcosystemEntries('plugin', ecosystemPaths).length,
-      installedSkills: listInstalledEcosystemEntries('skill', ecosystemPaths).length,
-    },
-  };
-}
-
-function inspectReleaseBundle(path: string): string {
-  const parsed = JSON.parse(readFileSync(path, 'utf-8')) as ReleaseBundle;
-  return [
-    'Release Bundle Review',
-    `  provider/model: ${parsed.runtime.provider || '(unset)'}/${parsed.runtime.model || '(unset)'}`,
-    `  eval suites: ${parsed.evalSuites.length}`,
-    `  incidents: ${parsed.incidentCount}`,
-    `  remote pools/contracts/artifacts: ${parsed.remote.pools}/${parsed.remote.contracts}/${parsed.remote.artifacts}`,
-    `  ecosystem catalog plugins/skills: ${parsed.ecosystem.pluginCatalog}/${parsed.ecosystem.skillCatalog}`,
-  ].join('\n');
-}
-
 export function registerProductRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'trust',
@@ -314,65 +249,4 @@ export function registerProductRuntimeCommands(registry: CommandRegistry): void
     },
   });
 
-  registry.register({
-    name: 'release',
-    description: 'Package certification and release-readiness operations',
-    usage: '[review|checklist|bundle export <path> --yes|bundle inspect <path>]',
-    handler(args, ctx) {
-      const parsed = stripYesFlag(args);
-      const commandArgs = [...parsed.rest];
-      const shellPaths = requireShellPaths(ctx);
-      const sub = commandArgs[0] ?? 'review';
-      if (sub === 'review') {
-        const bundle = buildReleaseBundle(ctx);
-        ctx.print([
-          'Release Review',
-          `  provider/model: ${bundle.runtime.provider || '(unset)'}/${bundle.runtime.model || '(unset)'}`,
-          `  eval suites: ${bundle.evalSuites.length}`,
-          `  incidents: ${bundle.incidentCount}`,
-          `  remote pools/contracts/artifacts: ${bundle.remote.pools}/${bundle.remote.contracts}/${bundle.remote.artifacts}`,
-          `  ecosystem catalog plugins/skills: ${bundle.ecosystem.pluginCatalog}/${bundle.ecosystem.skillCatalog}`,
-          `  installed plugins/skills: ${bundle.ecosystem.installedPlugins}/${bundle.ecosystem.installedSkills}`,
-        ].join('\n'));
-        return;
-      }
-      if (sub === 'checklist') {
-        ctx.print([
-          'Release Checklist',
-          '  1. Run /setup review and /setup doctor',
-          '  2. Run /security review and /trust review',
-          '  3. Run /policy preflight and /policy simulate',
-          '  4. Run /eval gate <suite> --yes for required certification suites',
-          '  5. Review /incident latest and /bridge status',
-          '  6. Export /release bundle export <path> --yes for release evidence',
-        ].join('\n'));
-        return;
-      }
-      if (sub === 'bundle') {
-        const mode = commandArgs[1];
-        const pathArg = commandArgs[2];
-        if ((mode === 'export' || mode === 'inspect') && !pathArg) {
-          ctx.print(`Usage: /release bundle ${mode} <path>${mode === 'export' ? ' --yes' : ''}`);
-          return;
-        }
-        if (mode === 'export') {
-          if (!parsed.yes) {
-            requireYesFlag(ctx, `export release bundle to ${pathArg}`, '/release bundle export <path> --yes');
-            return;
-          }
-          const bundle = buildReleaseBundle(ctx);
-          const targetPath = shellPaths.resolveWorkspacePath(pathArg!);
-          mkdirSync(dirname(targetPath), { recursive: true });
-          writeFileSync(targetPath, JSON.stringify(bundle, null, 2) + '\n', 'utf-8');
-          ctx.print(`Release bundle exported to ${targetPath}`);
-          return;
-        }
-        if (mode === 'inspect') {
-          ctx.print(inspectReleaseBundle(shellPaths.resolveWorkspacePath(pathArg!)));
-          return;
-        }
-      }
-      ctx.print('Usage: /release [review|checklist|bundle export <path> --yes|bundle inspect <path>]');
-    },
-  });
 }

package/src/input/commands.ts

@@ -1,7 +1,6 @@
 import type { CommandRegistry } from './command-registry.ts';
 import { policyCommand } from './commands/policy.ts';
 import { providerCommand } from './commands/provider.ts';
-import { evalCommand } from './commands/eval.ts';
 import { sessionCommand } from './commands/session.ts';
 import { recallCommand } from './commands/memory.ts';
 import { knowledgeCommand } from './commands/knowledge.ts';
@@ -126,9 +125,6 @@ export function registerBuiltinCommands(registry: CommandRegistry): void {
   // ── /provider ─────────────────────────────────────────────────────────────
   registry.register(providerCommand);
 
-  // ── /eval ─────────────────────────────────────────────────────────────────
-  registry.register(evalCommand);
-
   // ── /session ─────────────────────────────────────────────────────────────
   registry.register(sessionCommand);
 

package/src/main.ts

@@ -767,4 +767,31 @@ async function main() {
 
 }
 
-main().catch(err => logger.error('Fatal error', { error: err }));
+function formatFatalStartupError(error: unknown): string {
+  if (error instanceof Error) {
+    return error.stack ?? error.message;
+  }
+  if (typeof error === 'string') {
+    return error;
+  }
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return String(error);
+  }
+}
+
+main().catch((err: unknown) => {
+  const detail = formatFatalStartupError(err);
+  try {
+    logger.error('Fatal error', { error: detail });
+  } catch {
+    // Startup diagnostics must never hide the original launch failure.
+  }
+  try {
+    process.stderr.write(`goodvibes-agent failed to launch:\n${detail}\n`);
+  } catch {
+    // Ignore secondary stderr failures during process teardown.
+  }
+  process.exit(1);
+});

package/src/panels/builtin/operations.ts

@@ -27,7 +27,6 @@ import { DebugPanel } from '../debug-panel.ts';
 import { IncidentReviewPanel } from '../incident-review-panel.ts';
 import { ForensicsPanel } from '../forensics-panel.ts';
 import { PolicyPanel } from '../policy-panel.ts';
-import { EvalPanel } from '../eval-panel.ts';
 import { createProviderAccountSnapshotQuery } from '../provider-account-snapshot.ts';
 import {
   createEnvironmentVariableQuery,
@@ -335,15 +334,4 @@ export function registerOperationsPanels(manager: PanelManager, deps: ResolvedBu
     factory: () => new PolicyPanel(deps.policyRuntimeState),
   });
 
-  if (deps.evalRegistry) {
-    const { evalRegistry } = deps;
-    manager.registerType({
-      id: 'eval',
-      name: 'Eval',
-      icon: 'Y',
-      category: 'monitoring',
-      description: 'Evaluation harness: benchmark suite results, scorecards, and regression gates',
-      factory: () => new EvalPanel(evalRegistry),
-    });
-  }
 }

package/src/panels/builtin/shared.ts

@@ -62,8 +62,6 @@ export interface BuiltinPanelDeps {
   dismissPlanning?: () => void;
   /** ForensicsRegistry for the Forensics panel. */
   forensicsRegistry?: import('@/runtime/index.ts').ForensicsRegistry;
-  /** EvalRegistry for the Eval panel. */
-  evalRegistry?: import('../eval-panel.ts').EvalRegistry;
   /** MemoryRegistry for the Memory panel. */
   memoryRegistry?: MemoryRegistry;
   /** Isolated Agent Knowledge service for the Agent Knowledge panel. */