@pellux/goodvibes-agent 0.1.58 → 0.1.59

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 All notable changes to GoodVibes Agent will be recorded here.
 
+## 0.1.59 - 2026-05-31
+
+- f03ee5f Remove unused coding panel sources
+- 5950687 Remove blocked teamwork command surface
+- e60bf10 Remove noisy Bun preinstall lifecycle
+
 ## 0.1.58 - 2026-05-31
 
 - e137f90 Fail cleanly for non-TTY TUI launch

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "0.1.58",
+  "version": "0.1.59",
   "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",
@@ -19,14 +19,10 @@
     "!src/**/*.test.ts",
     "!src/**/__tests__",
     "!src/panels/diff-panel.ts",
-    "!src/panels/file-explorer-panel.ts",
-    "!src/panels/file-preview-panel.ts",
     "!src/panels/git-panel.ts",
     "!src/panels/sandbox-panel.ts",
-    "!src/panels/symbol-outline-panel.ts",
     "!src/panels/worktree-panel.ts",
     "!src/panels/wrfc-panel.ts",
-    "scripts/check-bun.sh",
     "tsconfig.json",
     "README.md",
     "CHANGELOG.md",
@@ -51,7 +47,6 @@
     "build:all-shell": "bun run build:linux-x64 && bun run build:linux-arm64 && bun run build:macos-x64 && bun run build:macos-arm64 && bun run build:windows",
     "test": "bun run scripts/run-tests.ts",
     "version": "bun run scripts/prebuild.ts",
-    "preinstall": "sh scripts/check-bun.sh",
     "release": "bun run scripts/release.ts",
     "release:dry": "bun run scripts/release.ts --dry-run",
     "publish:package": "bun run scripts/publish-package.ts",

package/src/cli/package-verification.ts

@@ -36,7 +36,6 @@ const REQUIRED_TARBALL_PATHS = [
   'package.json',
   'src/main.ts',
   'bin/goodvibes-agent.ts',
-  'scripts/check-bun.sh',
   'tsconfig.json',
   '.goodvibes/GOODVIBES.md',
   'docs/README.md',

package/src/input/commands.ts

@@ -22,7 +22,6 @@ import { registerProfileSyncRuntimeCommands } from './commands/profile-sync-runt
 import { registerManagedRuntimeCommands } from './commands/managed-runtime.ts';
 import { registerPlatformAccessRuntimeCommands } from './commands/platform-access-runtime.ts';
 import { registerPlatformServicesRuntimeCommands } from './commands/platform-services-runtime.ts';
-import { registerTeamworkRuntimeCommands } from './commands/teamwork-runtime.ts';
 import { registerMarketplaceRuntimeCommands } from './commands/marketplace-runtime.ts';
 import { registerGuidanceRuntimeCommands } from './commands/guidance-runtime.ts';
 import { registerRemoteRuntimeCommands } from './commands/remote-runtime.ts';
@@ -81,7 +80,6 @@ export function registerBuiltinCommands(registry: CommandRegistry): void {
   registerManagedRuntimeCommands(registry);
   registerPlatformAccessRuntimeCommands(registry);
   registerPlatformServicesRuntimeCommands(registry);
-  registerTeamworkRuntimeCommands(registry);
   registerMarketplaceRuntimeCommands(registry);
   registerGuidanceRuntimeCommands(registry);
   registerRemoteRuntimeCommands(registry);

package/src/input/submission-router.ts

@@ -8,7 +8,7 @@ export interface SubmissionRouterInput {
 }
 
 const PLAN_COMMANDS = new Set(['plan']);
-const DELEGATION_COMMANDS = new Set(['delegate', 'build', 'review', 'wrfc', 'teamwork', 'agents', 'remote']);
+const DELEGATION_COMMANDS = new Set(['delegate', 'build', 'review', 'wrfc', 'agents', 'remote']);
 const PANEL_COMMANDS = new Set(['panel']);
 const ORCHESTRATION_COMMANDS = new Set([
   'orchestration',

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.58';
+let _version = '0.1.59';
 let _sdkVersion = '0.33.35';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8')) as {

package/scripts/check-bun.sh

@@ -1,22 +0,0 @@
-#!/bin/sh
-set -eu
-
-if ! command -v bun >/dev/null 2>&1; then
-  cat >&2 <<'EOF'
-goodvibes-agent requires Bun.
-
-Install Bun first, then install GoodVibes Agent with:
-
-  bun add -g @pellux/goodvibes-agent
-
-If the installed command is not found, add Bun's global bin directory to PATH:
-
-  export PATH="$(bun pm bin -g):$PATH"
-EOF
-  exit 1
-fi
-
-if ! bun --version >/dev/null 2>&1; then
-  echo "goodvibes-agent requires a working Bun executable on PATH." >&2
-  exit 1
-fi

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

@@ -1,339 +0,0 @@
-import type { CommandRegistry, CommandContext } from '../command-registry.ts';
-import { join } from 'node:path';
-import { AGENT_TEMPLATES } from '@pellux/goodvibes-sdk/platform/tools';
-import { ArchetypeLoader, type AgentArchetype } from '@pellux/goodvibes-sdk/platform/agents';
-import { requireReadModels, requireShellPaths } from './runtime-services.ts';
-
-type TeamworkModeId =
-  | 'local-engineer'
-  | 'local-shell'
-  | 'remote-engineer'
-  | 'teammate'
-  | 'research'
-  | 'dream'
-  | 'review'
-  | 'verifier'
-  | 'integration';
-
-interface TeamworkMode {
-  readonly id: TeamworkModeId;
-  readonly label: string;
-  readonly taskKind: 'agent' | 'exec' | 'acp' | 'integration';
-  readonly owner: string;
-  readonly template?: keyof typeof AGENT_TEMPLATES;
-  readonly reviewMode: 'none' | 'wrfc';
-  readonly executionProtocol: 'direct' | 'gather-plan-apply';
-}
-
-interface TeamworkRecipe {
-  readonly id: string;
-  readonly summary: string;
-  readonly steps: readonly string[];
-}
-
-interface ResolvedArchetypeMode {
-  readonly id: string;
-  readonly label: string;
-  readonly owner: string;
-  readonly taskKind: 'agent' | 'exec' | 'acp' | 'integration';
-  readonly template?: string;
-  readonly reviewMode: 'none' | 'wrfc';
-  readonly executionProtocol: 'direct' | 'gather-plan-apply';
-  readonly source: 'builtin' | 'custom';
-  readonly family: 'implement' | 'review' | 'test' | 'research' | 'general';
-  readonly sourcePath?: string;
-  readonly validationIssues: readonly string[];
-  readonly tools: readonly string[];
-}
-
-interface TeamworkReviewSnapshot {
-  readonly builtinArchetypes: number;
-  readonly customArchetypes: number;
-  readonly archetypesWithIssues: number;
-  readonly implementArchetypes: number;
-  readonly reviewArchetypes: number;
-  readonly researchArchetypes: number;
-  readonly activeTaskCount: number;
-  readonly blockedTaskCount: number;
-  readonly reviewTaskCount: number;
-}
-
-const TEAMWORK_MODES: readonly TeamworkMode[] = [
-  { id: 'local-engineer', label: 'Local engineer task', taskKind: 'agent', owner: 'local-engineer', template: 'engineer', reviewMode: 'wrfc', executionProtocol: 'gather-plan-apply' },
-  { id: 'local-shell', label: 'Local shell task', taskKind: 'exec', owner: 'local-shell', reviewMode: 'none', executionProtocol: 'direct' },
-  { id: 'remote-engineer', label: 'Remote engineer task', taskKind: 'acp', owner: 'remote-engineer', template: 'engineer', reviewMode: 'wrfc', executionProtocol: 'gather-plan-apply' },
-  { id: 'teammate', label: 'In-process teammate task', taskKind: 'agent', owner: 'teammate', template: 'general', reviewMode: 'wrfc', executionProtocol: 'gather-plan-apply' },
-  { id: 'research', label: 'Research task', taskKind: 'agent', owner: 'research', template: 'researcher', reviewMode: 'none', executionProtocol: 'gather-plan-apply' },
-  { id: 'dream', label: 'Speculative dream task', taskKind: 'agent', owner: 'dream', template: 'researcher', reviewMode: 'none', executionProtocol: 'gather-plan-apply' },
-  { id: 'review', label: 'Review-only task', taskKind: 'agent', owner: 'review', template: 'reviewer', reviewMode: 'wrfc', executionProtocol: 'gather-plan-apply' },
-  { id: 'verifier', label: 'Verifier task', taskKind: 'agent', owner: 'verifier', template: 'reviewer', reviewMode: 'wrfc', executionProtocol: 'gather-plan-apply' },
-  { id: 'integration', label: 'Integration task', taskKind: 'integration', owner: 'integration', template: 'engineer', reviewMode: 'wrfc', executionProtocol: 'gather-plan-apply' },
-];
-
-const TEAMWORK_RECIPES: readonly TeamworkRecipe[] = [
-  {
-    id: 'research-implement-review',
-    summary: 'Research first, implement second, certify with WRFC review.',
-    steps: ['research', 'local-engineer', 'review', 'verifier'],
-  },
-  {
-    id: 'remote-certification',
-    summary: 'Remote engineer execution with local review and integration.',
-    steps: ['remote-engineer', 'review', 'integration'],
-  },
-  {
-    id: 'triage-delegate-integrate',
-    summary: 'Triage locally, delegate focused teammate work, then integrate.',
-    steps: ['teammate', 'review', 'integration'],
-  },
-  {
-    id: 'dream-then-certify',
-    summary: 'Run a speculative research pass, then ground it through engineer, review, and verifier steps.',
-    steps: ['dream', 'local-engineer', 'review', 'verifier'],
-  },
-];
-
-function formatMode(mode: TeamworkMode): string {
-  return `  ${mode.id.padEnd(18)} ${mode.taskKind.padEnd(11)} ${mode.owner.padEnd(16)} ${mode.reviewMode.padEnd(4)} ${mode.executionProtocol}${mode.template ? `  template=${mode.template}` : ''}`;
-}
-
-function classifyArchetype(archetype: AgentArchetype): ResolvedArchetypeMode['family'] {
-  const haystack = `${archetype.name} ${archetype.description}`.toLowerCase();
-  const tools = new Set(archetype.tools.map((tool) => tool.toLowerCase()));
-  if (haystack.includes('review') || haystack.includes('audit')) return 'review';
-  if (haystack.includes('test') || tools.has('exec') && tools.has('write') && !tools.has('edit')) return 'test';
-  if (haystack.includes('research') || haystack.includes('analysis') || (tools.has('find') && tools.has('analyze') && !tools.has('write') && !tools.has('edit'))) return 'research';
-  if (tools.has('write') || tools.has('edit')) return 'implement';
-  return 'general';
-}
-
-function buildArchetypeMode(archetype: AgentArchetype): ResolvedArchetypeMode {
-  const family = classifyArchetype(archetype);
-  const source = archetype.isCustom ? 'custom' : 'builtin';
-  return {
-    id: archetype.name,
-    label: archetype.description || `${archetype.name} archetype`,
-    owner: source === 'custom' ? `custom:${archetype.name}` : archetype.name,
-    taskKind: 'agent',
-    template: archetype.name,
-    reviewMode: family === 'review' ? 'wrfc' : 'none',
-    executionProtocol: family === 'research' ? 'gather-plan-apply' : family === 'implement' ? 'gather-plan-apply' : 'direct',
-    source,
-    family,
-    sourcePath: archetype.sourcePath,
-    validationIssues: archetype.validationIssues ?? [],
-    tools: archetype.tools,
-  };
-}
-
-function listArchetypeModes(projectRoot: string): ResolvedArchetypeMode[] {
-  const loader = new ArchetypeLoader(join(projectRoot, '.goodvibes', 'agents'));
-  return loader.listArchetypes()
-    .map(buildArchetypeMode)
-    .sort((a, b) => a.id.localeCompare(b.id));
-}
-
-function buildTeamworkReviewSnapshot(ctx: CommandContext): TeamworkReviewSnapshot {
-  const projectRoot = requireShellPaths(ctx).workingDirectory;
-  const archetypes = listArchetypeModes(projectRoot);
-  const tasks = [...requireReadModels(ctx).tasks.getSnapshot().tasks];
-  return {
-    builtinArchetypes: archetypes.filter((entry) => entry.source === 'builtin').length,
-    customArchetypes: archetypes.filter((entry) => entry.source === 'custom').length,
-    archetypesWithIssues: archetypes.filter((entry) => entry.validationIssues.length > 0).length,
-    implementArchetypes: archetypes.filter((entry) => entry.family === 'implement').length,
-    reviewArchetypes: archetypes.filter((entry) => entry.family === 'review').length,
-    researchArchetypes: archetypes.filter((entry) => entry.family === 'research').length,
-    activeTaskCount: tasks.filter((task) => task.status === 'running' || task.status === 'queued').length,
-    blockedTaskCount: tasks.filter((task) => task.status === 'blocked').length,
-    reviewTaskCount: tasks.filter((task) => task.owner === 'review' || task.owner === 'verifier').length,
-  };
-}
-
-function printAgentDelegationBoundary(ctx: CommandContext, requestedAction: string): void {
-  ctx.print([
-    'GoodVibes Agent does not create local teamwork, Engineer, Reviewer, Tester, Verifier, or WRFC-owned tasks.',
-    `  requested: ${requestedAction}`,
-    '  policy: keep ordinary work serial in the main assistant conversation',
-    '  build/fix/review: delegate one request to GoodVibes TUI through the public shared-session/build-delegation contract',
-    '  preserve: full original user ask and executionIntent; let TUI own WRFC when explicitly requested',
-  ].join('\n'));
-}
-
-export function registerTeamworkRuntimeCommands(registry: CommandRegistry): void {
-  registry.register({
-    name: 'teamwork',
-    aliases: ['teammates'],
-    description: 'Packaged task modes, teammate templates, and orchestration recipes',
-    usage: '[review|modes|mode <id>|create-mode <id> <title...>|recipes|recipe <id>|templates|archetypes|validate|archetype <name>|create-archetype <name> <title...>]',
-    handler(args, ctx) {
-      const sub = args[0]?.toLowerCase() ?? 'review';
-
-      if (sub === 'review') {
-        const snapshot = buildTeamworkReviewSnapshot(ctx);
-        ctx.print([
-          'Teamwork Review',
-          `  modes: ${TEAMWORK_MODES.length}`,
-          `  recipes: ${TEAMWORK_RECIPES.length}`,
-          `  builtin archetypes: ${snapshot.builtinArchetypes}`,
-          `  custom archetypes: ${snapshot.customArchetypes}`,
-          `  archetypes with issues: ${snapshot.archetypesWithIssues}`,
-          `  implement/review/research: ${snapshot.implementArchetypes}/${snapshot.reviewArchetypes}/${snapshot.researchArchetypes}`,
-          `  active tasks: ${snapshot.activeTaskCount}`,
-          `  blocked tasks: ${snapshot.blockedTaskCount}`,
-          `  review tasks: ${snapshot.reviewTaskCount}`,
-          '  next: /teamwork archetypes',
-          '  next: /teamwork validate',
-          '  next: /tasks',
-        ].join('\n'));
-        return;
-      }
-
-      if (sub === 'modes') {
-        ctx.print([
-          'Teamwork Modes',
-          ...TEAMWORK_MODES.map(formatMode),
-        ].join('\n'));
-        return;
-      }
-
-      if (sub === 'mode') {
-        const modeId = args[1] as TeamworkModeId | undefined;
-        const mode = TEAMWORK_MODES.find((entry) => entry.id === modeId);
-        if (!mode) {
-          ctx.print('Usage: /teamwork mode <local-engineer|local-shell|remote-engineer|teammate|research|dream|review|verifier|integration>');
-          return;
-        }
-        ctx.print([
-          `Teamwork Mode ${mode.id}`,
-          `  label: ${mode.label}`,
-          `  taskKind: ${mode.taskKind}`,
-          `  owner: ${mode.owner}`,
-          `  template: ${mode.template ?? '(none)'}`,
-          `  reviewMode: ${mode.reviewMode}`,
-          `  executionProtocol: ${mode.executionProtocol}`,
-        ].join('\n'));
-        return;
-      }
-
-      if (sub === 'create-mode') {
-        const modeId = args[1] as TeamworkModeId | undefined;
-        const title = args.slice(2).join(' ').trim();
-        const mode = TEAMWORK_MODES.find((entry) => entry.id === modeId);
-        if (!mode || !title) {
-          ctx.print('Usage: /teamwork create-mode <local-engineer|local-shell|remote-engineer|teammate|research|dream|review|verifier|integration> <title...>');
-          return;
-        }
-        printAgentDelegationBoundary(ctx, `/teamwork create-mode ${mode.id} ${title}`);
-        return;
-      }
-
-      if (sub === 'recipes') {
-        ctx.print([
-          'Teamwork Recipes',
-          ...TEAMWORK_RECIPES.map((recipe) => `  ${recipe.id.padEnd(26)} ${recipe.summary}`),
-        ].join('\n'));
-        return;
-      }
-
-      if (sub === 'recipe') {
-        const recipeId = args[1];
-        const recipe = TEAMWORK_RECIPES.find((entry) => entry.id === recipeId);
-        if (!recipe) {
-          ctx.print('Usage: /teamwork recipe <id>');
-          return;
-        }
-        ctx.print([
-          `Teamwork Recipe ${recipe.id}`,
-          `  summary: ${recipe.summary}`,
-          `  steps: ${recipe.steps.join(' -> ')}`,
-        ].join('\n'));
-        return;
-      }
-
-      if (sub === 'templates') {
-        const archetypes = listArchetypeModes(requireShellPaths(ctx).workingDirectory);
-        ctx.print([
-          'Teamwork Templates',
-          ...Object.entries(AGENT_TEMPLATES).map(([name, template]) => (
-            `  ${name.padEnd(12)} ${template.description}`
-          )),
-          '',
-          'Discovered Archetypes',
-          ...archetypes.map((entry) => `  ${entry.id.padEnd(12)} ${entry.family.padEnd(10)} ${entry.source.padEnd(7)} ${entry.label}`),
-        ].join('\n'));
-        return;
-      }
-
-      if (sub === 'archetypes') {
-        const archetypes = listArchetypeModes(requireShellPaths(ctx).workingDirectory);
-        ctx.print([
-          'Teamwork Archetypes',
-          ...archetypes.map((entry) => `  ${entry.id.padEnd(18)} ${entry.family.padEnd(10)} ${entry.source.padEnd(7)} ${entry.reviewMode.padEnd(4)} ${entry.executionProtocol}${entry.validationIssues.length > 0 ? '  issues' : ''}`),
-        ].join('\n'));
-        return;
-      }
-
-      if (sub === 'validate') {
-        const archetypes = listArchetypeModes(requireShellPaths(ctx).workingDirectory);
-        const invalid = archetypes.filter((entry) => entry.validationIssues.length > 0);
-        ctx.print(invalid.length > 0
-          ? [
-              'Teamwork Archetype Validation',
-              ...invalid.flatMap((entry) => [
-                `  ${entry.id} (${entry.source})`,
-                ...entry.validationIssues.map((issue) => `    issue: ${issue}`),
-              ]),
-            ].join('\n')
-          : 'Teamwork Archetype Validation\n  All discovered archetypes are currently valid.');
-        return;
-      }
-
-      if (sub === 'archetype') {
-        const archetypeName = args[1];
-        if (!archetypeName) {
-          ctx.print('Usage: /teamwork archetype <name>');
-          return;
-        }
-        const mode = listArchetypeModes(requireShellPaths(ctx).workingDirectory).find((entry) => entry.id === archetypeName);
-        if (!mode) {
-          ctx.print(`Unknown archetype: ${archetypeName}`);
-          return;
-        }
-        ctx.print([
-          `Teamwork Archetype ${mode.id}`,
-          `  label: ${mode.label}`,
-          `  family: ${mode.family}`,
-          `  source: ${mode.source}`,
-          `  owner: ${mode.owner}`,
-          `  reviewMode: ${mode.reviewMode}`,
-          `  executionProtocol: ${mode.executionProtocol}`,
-          `  tools: ${mode.tools.join(', ') || '(none)'}`,
-          `  sourcePath: ${mode.sourcePath ?? '(builtin)'}`,
-          ...(mode.validationIssues.length > 0
-            ? mode.validationIssues.map((issue) => `  issue: ${issue}`)
-            : ['  validation: clean']),
-        ].join('\n'));
-        return;
-      }
-
-      if (sub === 'create-archetype') {
-        const archetypeName = args[1];
-        const title = args.slice(2).join(' ').trim();
-        if (!archetypeName || !title) {
-          ctx.print('Usage: /teamwork create-archetype <name> <title...>');
-          return;
-        }
-        const mode = listArchetypeModes(requireShellPaths(ctx).workingDirectory).find((entry) => entry.id === archetypeName);
-        if (!mode) {
-          ctx.print(`Unknown archetype: ${archetypeName}`);
-          return;
-        }
-        printAgentDelegationBoundary(ctx, `/teamwork create-archetype ${mode.id} ${title}`);
-        return;
-      }
-
-      ctx.print('Usage: /teamwork [review|modes|mode <id>|create-mode <id> <title...>|recipes|recipe <id>|templates|archetypes|validate|archetype <name>|create-archetype <name> <title...>]');
-    },
-  });
-}