@pellux/goodvibes-agent 0.1.52 → 0.1.54

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 All notable changes to GoodVibes Agent will be recorded here.
 
+## 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
+
 ## 0.1.52 - 2026-05-31
 
 - e543fa5 Add selected local library actions

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.52",
+  "version": "0.1.54",
   "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",

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';
@@ -25,16 +26,22 @@ export type AgentWorkspaceActionKind = 'command' | 'guidance' | 'workspace' | 'e
 export type AgentWorkspaceLocalEditorKind = 'persona' | 'skill' | 'routine';
 
 export type AgentWorkspaceLocalOperation =
+  | 'persona-edit'
   | '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;
@@ -47,6 +54,8 @@ export interface AgentWorkspaceEditorField {
 
 export interface AgentWorkspaceLocalEditor {
   readonly kind: AgentWorkspaceLocalEditorKind;
+  readonly mode: 'create' | 'update' | 'delete';
+  readonly recordId?: string;
   readonly title: string;
   readonly fields: readonly AgentWorkspaceEditorField[];
   readonly selectedFieldIndex: number;
@@ -533,9 +542,11 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
       { id: 'personas-prev', label: 'Previous persona', detail: 'Move the local persona selection up without changing active state.', localKind: 'persona', selectionDelta: -1, kind: 'local-selection', safety: 'safe' },
       { id: 'personas-next', label: 'Next persona', detail: 'Move the local persona selection down without changing active state.', localKind: 'persona', selectionDelta: 1, kind: 'local-selection', safety: 'safe' },
       { id: 'personas-create', label: 'Create persona', detail: 'Open an in-workspace form for a local persona. No placeholder command is dispatched.', editorKind: 'persona', kind: 'editor', safety: 'safe' },
+      { id: 'personas-edit', label: 'Edit selected', detail: 'Open the selected local persona in an in-workspace editor.', localKind: 'persona', localOperation: 'persona-edit', kind: 'local-operation', safety: 'safe' },
       { 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' },
     ],
   },
   {
@@ -550,9 +561,11 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
       { id: 'skills-prev', label: 'Previous skill', detail: 'Move the local skill selection up without changing enabled state.', localKind: 'skill', selectionDelta: -1, kind: 'local-selection', safety: 'safe' },
       { id: 'skills-next', label: 'Next skill', detail: 'Move the local skill selection down without changing enabled state.', localKind: 'skill', selectionDelta: 1, kind: 'local-selection', safety: 'safe' },
       { id: 'skills-create', label: 'Create skill', detail: 'Open an in-workspace form for a reusable local procedure. No placeholder command is dispatched.', editorKind: 'skill', kind: 'editor', safety: 'safe' },
+      { id: 'skills-edit', label: 'Edit selected', detail: 'Open the selected local Agent skill in an in-workspace editor.', localKind: 'skill', localOperation: 'skill-edit', kind: 'local-operation', safety: 'safe' },
       { 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' },
     ],
   },
   {
@@ -567,10 +580,12 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
       { id: 'routines-prev', label: 'Previous routine', detail: 'Move the local routine selection up without changing enabled state.', localKind: 'routine', selectionDelta: -1, kind: 'local-selection', safety: 'safe' },
       { id: 'routines-next', label: 'Next routine', detail: 'Move the local routine selection down without changing enabled state.', localKind: 'routine', selectionDelta: 1, kind: 'local-selection', safety: 'safe' },
       { id: 'routines-create', label: 'Create routine', detail: 'Open an in-workspace form for a repeatable local workflow. No placeholder command is dispatched.', editorKind: 'routine', kind: 'editor', safety: 'safe' },
+      { id: 'routines-edit', label: 'Edit selected', detail: 'Open the selected local Agent routine in an in-workspace editor.', localKind: 'routine', localOperation: 'routine-edit', kind: 'local-operation', safety: 'safe' },
       { id: 'routines-start', label: 'Start selected', detail: 'Mark the selected routine started and show it as a main-conversation workflow. This creates no hidden job.', localKind: 'routine', localOperation: 'routine-start', kind: 'local-operation', safety: 'safe' },
       { 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' },
     ],
@@ -627,6 +642,7 @@ function createLocalEditor(kind: AgentWorkspaceLocalEditorKind): AgentWorkspaceL
   if (kind === 'persona') {
     return {
       kind,
+      mode: 'create',
       title: 'Create Persona',
       selectedFieldIndex: 0,
       message: 'Enter a local behavior profile for the serial main-conversation assistant.',
@@ -643,6 +659,7 @@ function createLocalEditor(kind: AgentWorkspaceLocalEditorKind): AgentWorkspaceL
   if (kind === 'skill') {
     return {
       kind,
+      mode: 'create',
       title: 'Create Skill',
       selectedFieldIndex: 0,
       message: 'Enter a reusable local procedure the assistant can apply from the main conversation.',
@@ -658,6 +675,7 @@ function createLocalEditor(kind: AgentWorkspaceLocalEditorKind): AgentWorkspaceL
   }
   return {
     kind,
+    mode: 'create',
     title: 'Create Routine',
     selectedFieldIndex: 0,
     message: 'Enter a repeatable workflow. It runs in the main conversation unless explicitly promoted to a daemon schedule.',
@@ -672,6 +690,78 @@ function createLocalEditor(kind: AgentWorkspaceLocalEditorKind): AgentWorkspaceL
   };
 }
 
+function createPersonaUpdateEditor(record: AgentPersonaRecord, active: boolean): AgentWorkspaceLocalEditor {
+  return {
+    kind: 'persona',
+    mode: 'update',
+    recordId: record.id,
+    title: 'Edit Persona',
+    selectedFieldIndex: 0,
+    message: `Editing ${record.name}. Saving marks it fresh for review.`,
+    fields: [
+      { id: 'name', label: 'Name', value: record.name, required: true, multiline: false, hint: 'Short persona name.' },
+      { id: 'description', label: 'Description', value: record.description, required: true, multiline: false, hint: 'One-line summary of when to use it.' },
+      { id: 'body', label: 'Instructions', value: record.body, required: true, multiline: true, hint: 'Operating guidance. Ctrl-J inserts a new line.' },
+      { id: 'tags', label: 'Tags', value: record.tags.join(', '), required: false, multiline: false, hint: 'Comma-separated optional tags.' },
+      { id: 'triggers', label: 'Triggers', value: record.triggers.join(', '), required: false, multiline: false, hint: 'Comma-separated words that suggest this persona.' },
+      { id: 'activate', label: 'Active', value: active ? 'yes' : 'no', required: false, multiline: false, hint: 'yes/no. Setting no clears this persona only if it is currently active.' },
+    ],
+  };
+}
+
+function createSkillUpdateEditor(record: AgentSkillRecord): AgentWorkspaceLocalEditor {
+  return {
+    kind: 'skill',
+    mode: 'update',
+    recordId: record.id,
+    title: 'Edit Skill',
+    selectedFieldIndex: 0,
+    message: `Editing ${record.name}. Saving marks it fresh for review.`,
+    fields: [
+      { id: 'name', label: 'Name', value: record.name, required: true, multiline: false, hint: 'Short skill name.' },
+      { id: 'description', label: 'Description', value: record.description, required: true, multiline: false, hint: 'One-line summary of the procedure.' },
+      { id: 'procedure', label: 'Procedure', value: record.procedure, required: true, multiline: true, hint: 'Reusable steps. Ctrl-J inserts a new line.' },
+      { id: 'triggers', label: 'Triggers', value: record.triggers.join(', '), required: false, multiline: false, hint: 'Comma-separated words that suggest this skill.' },
+      { id: 'tags', label: 'Tags', value: record.tags.join(', '), required: false, multiline: false, hint: 'Comma-separated optional tags.' },
+      { id: 'enabled', label: 'Enabled', value: record.enabled ? 'yes' : 'no', required: false, multiline: false, hint: 'yes/no.' },
+    ],
+  };
+}
+
+function createRoutineUpdateEditor(record: AgentRoutineRecord): AgentWorkspaceLocalEditor {
+  return {
+    kind: 'routine',
+    mode: 'update',
+    recordId: record.id,
+    title: 'Edit Routine',
+    selectedFieldIndex: 0,
+    message: `Editing ${record.name}. Saving marks it fresh for review.`,
+    fields: [
+      { id: 'name', label: 'Name', value: record.name, required: true, multiline: false, hint: 'Short routine name.' },
+      { id: 'description', label: 'Description', value: record.description, required: true, multiline: false, hint: 'One-line summary of the workflow.' },
+      { id: 'steps', label: 'Steps', value: record.steps, required: true, multiline: true, hint: 'Workflow steps. Ctrl-J inserts a new line.' },
+      { id: 'triggers', label: 'Triggers', value: record.triggers.join(', '), required: false, multiline: false, hint: 'Comma-separated words that suggest this routine.' },
+      { id: 'tags', label: 'Tags', value: record.tags.join(', '), required: false, multiline: false, hint: 'Comma-separated optional tags.' },
+      { id: 'enabled', label: 'Enabled', value: record.enabled ? 'yes' : 'no', required: false, multiline: false, hint: 'yes/no.' },
+    ],
+  };
+}
+
+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);
 }
@@ -1062,12 +1152,37 @@ export class AgentWorkspace {
         };
         return;
       }
-      if (operation === 'persona-use') {
+      if (operation === 'persona-edit') {
+        const registry = AgentPersonaRegistry.fromShellPaths(shellPaths);
+        const persona = registry.get(selected.id);
+        if (!persona) throw new Error(`Unknown persona: ${selected.id}`);
+        this.localEditor = createPersonaUpdateEditor(persona, registry.snapshot().activePersonaId === persona.id);
+        this.status = `Editing persona: ${persona.name}.`;
+        this.lastActionResult = {
+          kind: 'guidance',
+          title: this.localEditor.title,
+          detail: this.localEditor.message,
+          safety: 'safe',
+        };
+      } else if (operation === 'persona-use') {
         AgentPersonaRegistry.fromShellPaths(shellPaths).setActive(selected.id);
         this.finishLocalOperation('persona', `Using persona ${selected.name}`, `${selected.name} will shape future main-conversation turns.`);
       } 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}`);
+        this.localEditor = createSkillUpdateEditor(skill);
+        this.status = `Editing skill: ${skill.name}.`;
+        this.lastActionResult = {
+          kind: 'guidance',
+          title: this.localEditor.title,
+          detail: this.localEditor.message,
+          safety: 'safe',
+        };
       } else if (operation === 'skill-enable') {
         AgentSkillRegistry.fromShellPaths(shellPaths).setEnabled(selected.id, true);
         this.finishLocalOperation('skill', `Enabled skill ${selected.name}`, `${selected.name} can now inform main-conversation turns.`);
@@ -1077,6 +1192,19 @@ 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}`);
+        this.localEditor = createRoutineUpdateEditor(routine);
+        this.status = `Editing routine: ${routine.name}.`;
+        this.lastActionResult = {
+          kind: 'guidance',
+          title: this.localEditor.title,
+          detail: this.localEditor.message,
+          safety: 'safe',
+        };
       } else if (operation === 'routine-start') {
         AgentRoutineRegistry.fromShellPaths(shellPaths).markStarted(selected.id);
         this.finishLocalOperation('routine', `Started routine ${selected.name}`, `${selected.name} was marked started for this main-conversation workflow. No hidden job was created.`);
@@ -1086,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);
@@ -1119,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;
@@ -1163,8 +1304,27 @@ 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) {
+          const wasActive = registry.snapshot().activePersonaId === editor.recordId;
+          const updated = registry.update(editor.recordId, {
+            name: this.editorField('name'),
+            description: this.editorField('description'),
+            body: this.editorField('body'),
+            tags: splitList(this.editorField('tags')),
+            triggers: splitList(this.editorField('triggers')),
+            provenance: 'agent-workspace',
+          });
+          if (isAffirmative(this.editorField('activate'))) registry.setActive(updated.id);
+          else if (wasActive) registry.clearActive();
+          this.finishLocalEditor(editor.kind, updated.id, updated.name, 'Updated');
+          return;
+        }
         const created = registry.create({
           name: this.editorField('name'),
           description: this.editorField('description'),
@@ -1175,9 +1335,22 @@ export class AgentWorkspace {
           provenance: 'agent-workspace',
         });
         if (isAffirmative(this.editorField('activate'))) registry.setActive(created.id);
-        this.finishLocalEditor(editor.kind, created.id, created.name);
+        this.finishLocalEditor(editor.kind, created.id, created.name, 'Created');
       } else if (editor.kind === 'skill') {
         const registry = AgentSkillRegistry.fromShellPaths(shellPaths);
+        if (editor.mode === 'update' && editor.recordId) {
+          const updated = registry.update(editor.recordId, {
+            name: this.editorField('name'),
+            description: this.editorField('description'),
+            procedure: this.editorField('procedure'),
+            triggers: splitList(this.editorField('triggers')),
+            tags: splitList(this.editorField('tags')),
+            provenance: 'agent-workspace',
+          });
+          registry.setEnabled(updated.id, isAffirmative(this.editorField('enabled')));
+          this.finishLocalEditor(editor.kind, updated.id, updated.name, 'Updated');
+          return;
+        }
         const created = registry.create({
           name: this.editorField('name'),
           description: this.editorField('description'),
@@ -1188,9 +1361,22 @@ export class AgentWorkspace {
           source: 'user',
           provenance: 'agent-workspace',
         });
-        this.finishLocalEditor(editor.kind, created.id, created.name);
+        this.finishLocalEditor(editor.kind, created.id, created.name, 'Created');
       } else {
         const registry = AgentRoutineRegistry.fromShellPaths(shellPaths);
+        if (editor.mode === 'update' && editor.recordId) {
+          const updated = registry.update(editor.recordId, {
+            name: this.editorField('name'),
+            description: this.editorField('description'),
+            steps: this.editorField('steps'),
+            triggers: splitList(this.editorField('triggers')),
+            tags: splitList(this.editorField('tags')),
+            provenance: 'agent-workspace',
+          });
+          registry.setEnabled(updated.id, isAffirmative(this.editorField('enabled')));
+          this.finishLocalEditor(editor.kind, updated.id, updated.name, 'Updated');
+          return;
+        }
         const created = registry.create({
           name: this.editorField('name'),
           description: this.editorField('description'),
@@ -1201,7 +1387,7 @@ export class AgentWorkspace {
           source: 'user',
           provenance: 'agent-workspace',
         });
-        this.finishLocalEditor(editor.kind, created.id, created.name);
+        this.finishLocalEditor(editor.kind, created.id, created.name, 'Created');
       }
     } catch (error) {
       const detail = error instanceof Error ? error.message : String(error);
@@ -1215,7 +1401,30 @@ export class AgentWorkspace {
     }
   }
 
-  private finishLocalEditor(kind: AgentWorkspaceLocalEditorKind, id: string, name: string): void {
+  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);
     const categoryIndex = this.categories.findIndex((category) => category.id === categoryId);
@@ -1224,15 +1433,34 @@ export class AgentWorkspace {
       this.selectedActionIndex = 0;
     }
     this.runtimeSnapshot = this.context ? buildAgentWorkspaceRuntimeSnapshot(this.context) : this.runtimeSnapshot;
-    this.status = `Created ${kind}: ${name}.`;
+    this.status = `${verb} ${kind}: ${name}.`;
     this.lastActionResult = {
       kind: 'refreshed',
-      title: `Created ${kind}`,
+      title: `${verb} ${kind}`,
       detail: `${name} (${id}) was saved to the Agent-local ${categoryId} registry.`,
       safety: 'safe',
     };
     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/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/runtime/services.ts

@@ -136,6 +136,114 @@ function ensureConfiguredModelIsRoutable(providerRegistry: ProviderRegistry, con
   });
 }
 
+const PROVIDER_STARTUP_PLACEHOLDER_API_KEY = 'goodvibes-agent-startup-placeholder';
+
+type ProviderRegistryConstructionOptions = ConstructorParameters<typeof ProviderRegistry>[0];
+
+type ProviderStartupEnv = {
+  readonly providerId: string;
+  readonly envVars: readonly string[];
+};
+
+type MutableApiKeyProvider = {
+  apiKey: string;
+};
+
+type MutableConfiguredProvider = {
+  configured: boolean;
+};
+
+const PROVIDER_STARTUP_PLACEHOLDER_ENVS: readonly ProviderStartupEnv[] = [
+  { providerId: 'openai', envVars: ['OPENAI_API_KEY', 'OPENAI_KEY'] },
+  { providerId: 'inceptionlabs', envVars: ['INCEPTION_API_KEY'] },
+  { providerId: 'openrouter', envVars: ['OPENROUTER_API_KEY'] },
+  { providerId: 'aihubmix', envVars: ['AIHUBMIX_API_KEY'] },
+  { providerId: 'groq', envVars: ['GROQ_API_KEY'] },
+  { providerId: 'cerebras', envVars: ['CEREBRAS_API_KEY'] },
+  { providerId: 'mistral', envVars: ['MISTRAL_API_KEY'] },
+  { providerId: 'ollama-cloud', envVars: ['OLLAMA_CLOUD_API_KEY', 'OLLAMA_API_KEY'] },
+  { providerId: 'huggingface', envVars: ['HF_API_KEY', 'HUGGINGFACE_API_KEY', 'HF_TOKEN'] },
+  { providerId: 'nvidia', envVars: ['NVIDIA_API_KEY'] },
+  { providerId: 'llm7', envVars: ['LLM7_API_KEY'] },
+  { providerId: 'deepseek', envVars: ['DEEPSEEK_API_KEY'] },
+  { providerId: 'fireworks', envVars: ['FIREWORKS_API_KEY'] },
+  { providerId: 'microsoft-foundry', envVars: ['AZURE_OPENAI_API_KEY'] },
+  { providerId: 'moonshot', envVars: ['MOONSHOT_API_KEY'] },
+  { providerId: 'qianfan', envVars: ['QIANFAN_API_KEY'] },
+  { providerId: 'qwen', envVars: ['QWEN_API_KEY', 'DASHSCOPE_API_KEY', 'MODELSTUDIO_API_KEY'] },
+  { providerId: 'sglang', envVars: ['SGLANG_API_KEY'] },
+  { providerId: 'stepfun', envVars: ['STEPFUN_API_KEY'] },
+  { providerId: 'together', envVars: ['TOGETHER_API_KEY'] },
+  { providerId: 'venice', envVars: ['VENICE_API_KEY'] },
+  { providerId: 'volcengine', envVars: ['VOLCANO_ENGINE_API_KEY'] },
+  { providerId: 'xai', envVars: ['XAI_API_KEY'] },
+  { providerId: 'xiaomi', envVars: ['XIAOMI_API_KEY'] },
+  { providerId: 'zai', envVars: ['ZAI_API_KEY', 'Z_AI_API_KEY'] },
+  { providerId: 'cloudflare-ai-gateway', envVars: ['CLOUDFLARE_AI_GATEWAY_API_KEY'] },
+  { providerId: 'vercel-ai-gateway', envVars: ['AI_GATEWAY_API_KEY'] },
+  { providerId: 'litellm', envVars: ['LITELLM_API_KEY'] },
+  { providerId: 'copilot-proxy', envVars: ['COPILOT_PROXY_API_KEY'] },
+];
+
+function hasMutableApiKeyProvider(value: unknown): value is MutableApiKeyProvider {
+  if (typeof value !== 'object' || value === null) return false;
+  const candidate = value as { readonly apiKey?: unknown };
+  return typeof candidate.apiKey === 'string';
+}
+
+function hasMutableConfiguredProvider(value: unknown): value is MutableConfiguredProvider {
+  if (typeof value !== 'object' || value === null) return false;
+  const candidate = value as { readonly configured?: unknown };
+  return typeof candidate.configured === 'boolean';
+}
+
+function hasAnyConfiguredEnv(envVars: readonly string[]): boolean {
+  return envVars.some((envVar) => {
+    const value = process.env[envVar];
+    return typeof value === 'string' && value.trim().length > 0;
+  });
+}
+
+export function createLaunchTolerantProviderRegistry(options: ProviderRegistryConstructionOptions): ProviderRegistry {
+  const placeholders = PROVIDER_STARTUP_PLACEHOLDER_ENVS
+    .filter((entry) => !hasAnyConfiguredEnv(entry.envVars))
+    .map((entry) => ({ providerId: entry.providerId, envVar: entry.envVars[0] }))
+    .filter((entry): entry is { readonly providerId: string; readonly envVar: string } => typeof entry.envVar === 'string');
+
+  if (placeholders.length === 0) {
+    return new ProviderRegistry(options);
+  }
+
+  const previousValues = new Map<string, string | undefined>();
+  for (const placeholder of placeholders) {
+    previousValues.set(placeholder.envVar, process.env[placeholder.envVar]);
+    process.env[placeholder.envVar] = PROVIDER_STARTUP_PLACEHOLDER_API_KEY;
+  }
+  let providerRegistry: ProviderRegistry;
+  try {
+    providerRegistry = new ProviderRegistry(options);
+  } finally {
+    for (const [envVar, previousValue] of previousValues) {
+      if (previousValue === undefined) {
+        delete process.env[envVar];
+      } else {
+        process.env[envVar] = previousValue;
+      }
+    }
+  }
+
+  for (const placeholder of placeholders) {
+    const provider = providerRegistry.get(placeholder.providerId);
+    if (hasMutableApiKeyProvider(provider) && provider.apiKey === PROVIDER_STARTUP_PLACEHOLDER_API_KEY) {
+      provider.apiKey = '';
+    }
+    if (hasMutableConfiguredProvider(provider)) {
+      provider.configured = false;
+    }
+  }
+  return providerRegistry;
+}
+
 export interface RuntimeServicesOptions {
   readonly runtimeBus: RuntimeEventBus;
   readonly runtimeStore: RuntimeStore;
@@ -285,7 +393,7 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
   const modelLimitsService = new ModelLimitsService({
     cachePath: shellPaths.resolveUserPath(GOODVIBES_AGENT_SURFACE_ROOT, 'model-limits.json'),
   });
-  const providerRegistry = new ProviderRegistry({
+  const providerRegistry = createLaunchTolerantProviderRegistry({
     configManager,
     subscriptionManager,
     secretsManager,

package/src/version.ts

@@ -6,7 +6,7 @@ import { join } from 'node:path';
 // The prebuild script updates the fallback value before compilation.
 // Uses import.meta.dir (Bun) to locate package.json relative to this file,
 // which is correct regardless of the process working directory.
-let _version = '0.1.52';
+let _version = '0.1.54';
 let _sdkVersion = '0.33.35';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8')) as {