@pellux/goodvibes-agent 1.4.1 → 1.4.2

package/docs/README.md

@@ -12,7 +12,6 @@ These are the package-facing docs for the GoodVibes Agent `1.0.x` release line.
 - [Channels, Remote Access, and API](channels-remote-and-api.md)
 - [Providers and Routing](providers-and-routing.md)
 - [Voice and Live TTS](voice-and-live-tts.md)
-- [Project Planning](project-planning.md)
 - [Release And Publishing](release-and-publishing.md)
 
 ## Baseline

package/docs/tools-and-commands.md

@@ -24,7 +24,6 @@ High-signal TUI routes:
 | `/model`, `/provider`, `/effort` | Inspect or change provider/model/reasoning routes. |
 | `/knowledge` | Use isolated Agent Knowledge. |
 | `/vibe`, `/memory`, `/notes`, `/personas`, `/skills`, `/routines` | Manage VIBE.md personality and Agent-local behavior libraries. |
-| `/plan`, `/workplan` | Planning and durable visible work tracking. |
 | `/approval`, `/automation`, `/schedule` | Read posture and run exact confirmed operator actions. |
 | `/channels`, `/notify`, `/qrcode` | Pair companions, inspect channel readiness, review delivery receipts, and send confirmed messages. |
 | `/media`, `/voice`, `/tts` | Inspect media/voice readiness, generate media, and run spoken turns. |
@@ -297,7 +296,6 @@ Routine promotion is an explicit scheduling route. Local routines stay local unt
 | `/paste` | Insert clipboard text or image into the prompt. |
 | `/personas` | Manage Agent-local personas. |
 | `/pin` | Pin a model to the favorites list. |
-| `/plan` | Inspect or seed Agent workspace planning state. |
 | `/prev-error` | Jump to the previous error message in the conversation. |
 | `/provider` | Switch provider or manage custom providers. |
 | `/qrcode` | Print companion pairing details and a QR code. |
@@ -327,7 +325,6 @@ Routine promotion is an explicit scheduling route. Local routines stay local unt
 | `/vibe` | Inspect, create, show, or import VIBE.md personality files. |
 | `/voice` | Review voice posture and portable voice metadata. |
 | `/welcome` | Open or print the Agent setup guide. |
-| `/workplan` | Track a persistent workspace-scoped work plan. |
 
 ## Related Docs
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "1.4.1",
+  "version": "1.4.2",
   "private": false,
   "description": "GoodVibes personal operator assistant TUI with a proactive Agent product brain, isolated Agent Knowledge, local profiles, routines, skills, personas, and explicit build delegation.",
   "type": "module",

package/release/release-notes.md

@@ -1,15 +1,7 @@
-- v1.4.0 was cut but its publish step never ran; v1.4.1 ships the same onboarding rebuild as the first publicly published version of the 1.4.x line. The fullscreen Agent workspace, Agent-local behavior, isolated Agent Knowledge, connected-host operator integration, explicit side-effect boundaries, and release hardening from 1.3.x all stay in force.
-- Fixed a release-evidence test that hardcoded a 1.3.0-specific phrase (`compact model-visible harness pass`) and prevented the v1.4.0 publish workflow from completing. The assertion now targets the stable required-theme `fullscreen Agent workspace`, so future release-notes rotations no longer break release CI.
-- Rebuilt the Agent Workspace onboarding modal so first-time users land in a focused ONBOARDING-only category list, no longer see HOME and post-onboarding categories competing for attention, and never get kicked out of the modal when activating a slash-command row.
-- Added typed `commandBehavior` (inline | compose | exit) on workspace actions so safe read-only commands can run inside the onboarding modal with their captured output rendered into the result pane, instead of forcing the modal closed to dispatch through the composer.
-- Guarded the new inline dispatch path so a missing `executeCommand` no longer clobbers `context.print`; the modal surfaces a clear "command unavailable" result and stays open.
-- Replaced release-engineering vocabulary (smoke history, receipt gaps, durable receipt, closeout policy, schema status, event cursor, publication guarantee, step history, repeated blocker, setup checkpoint summary) with a tight progress + single next-action summary in the onboarding right pane.
-- Closed a leak where channel-guide context lines could expose internal `userRoute` strings containing model-tool-call syntax; the channels guide now shows only human-readable labels.
-- Trimmed the user-facing setup checklist from fifteen items to thirteen by removing the `install-smoke` and `browser-pwa` release-engineering items; both remain available to model-facing routes but no longer appear in the onboarding flow.
-- Renamed the misleading `command` field on `AgentWorkspaceSetupChecklistItem` to `breadcrumb` so the field's purpose (UI navigation hint) no longer collides with the `kind: 'command'` action type.
-- Added clear verb-led row labels in the onboarding modal so users can see exactly what activating a row does: "Choose provider and model", "Edit MCP server", "Switch to <category>", "Run: <command>", "Open: <command>", "Finish setup", and so on, replacing generic labels like "Open option" and "Open guided form".
-- Added a sticky "Finish setup" footer row visible on every ONBOARDING category, colored green when prerequisites (provider/model, connected-host auth, runtime) are ready and warn-colored with the unmet items listed otherwise; the row is wired through the real activation path so pressing Enter triggers `completeOnboarding()`.
-- Added per-category readiness glyphs in the onboarding left pane: a green checkmark for categories whose mapped checklist items are all ready, a warn glyph for categories with blockers or recommended items, and no glyph for optional-only categories.
-- Relocated the diagnostic fields on `AgentSetupWizard` (smokeHistory, stepHistory, receiptGaps, closeout, checkpoint, repeatedBlocker) under a `_diagnostic` subkey so model-facing wizard mechanics are cleanly separated from user-facing wizard state, while preserving the existing model-tool surface.
-- Tightened `AgentWorkspaceCategory.group` and the workspace `_onlyGroup` filter to a literal union `AgentWorkspaceCategoryGroup`, so category-group typos fail at compile time instead of producing silent navigation bugs.
-- Added end-to-end acceptance tests for the new behavior: inline command dispatch keeps the workspace active and populates `lastActionResult` with captured output, first-run filter restricts the modal to ONBOARDING categories only, and the jargon allowlist guarantees no banned vocabulary leaks back into user-facing copy.
+- v1.4.2 continues the stable 1.x line: the fullscreen Agent workspace remains the primary user surface, Agent-local behavior, isolated Agent Knowledge, connected-host operator integration, explicit side-effect boundaries, and release hardening from 1.3.x and 1.4.x all stay in force; 1.4.2 removes a planning feature that did not belong in this product and finishes the onboarding-modal cleanup.
+- Removed the project planning subsystem entirely. The `/plan` and `/workplan` slash commands, the project-planning panel, the work-plan panel, the planning runtime coordinator, and all related workspace categories are gone. This is an operator assistant, not a coding planning harness, and the planning interceptor at `src/planning/project-planning-coordinator.ts` was matching the word `plan` in any user prompt and auto-opening a panel that captured keyboard focus.
+- Stopped the onboarding modal from exiting the user mid-flow. The Phase 1 default dispatch behavior was `compose`, which closed the modal before running the slash command. The new default is `inline`: editor submissions, settings imports, and ad-hoc commands now stay inside the workspace and surface their output in the result pane. Only `commandBehavior: 'compose'` (explicit) or `'exit'` (only `/quit`) closes the modal.
+- Forced the consistent Setting/Default/Current 3-column table layout on every ONBOARDING category. Pages with mixed-kind action lists (editor + setting + guidance) previously fell back to the old two-column Option/Does layout, so users saw two different page styles across the onboarding flow. Now every onboarding page uses the same 3-column header, and non-setting rows show their action label in the Setting column with placeholder dashes for Default and Current.
+- Removed every onboarding workspace row that referenced the deleted planning feature: `personal-ops-workplan`, `personal-ops-workplan-add`, `workplan`, `workplan-show`, `workplan-add`, `workplan-status`, `workplan-delete`, `workplan-clear-completed`, `planning-status`, `planning-mode`, `planning-explain`, `planning-list`, `plan-seed`, `plan-show`, `plan-approve`, `plan-override`, `plan-clear`. Help overlay and docs cleaned of `/plan` and `/workplan` mentions.
+- Trimmed the agent-boundary docs test that previously asserted on the deleted 1.2.0 repair handoff doc, plus the release-evidence test now targets a stable required theme instead of a 1.3.0-specific phrase.
+- Test suite: 7601 pass / 0 fail / 19 skip across 548 files.

package/src/input/agent-workspace-categories.ts

@@ -174,8 +174,6 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
       { id: 'personal-ops-calendar', label: 'Calendar workflows', detail: 'Calendar agenda and conflict checks use workflow cards with reviewed connector routes; reminders stay on confirmed schedules.', kind: 'guidance', safety: 'safe' },
       { id: 'personal-ops-notes', label: 'Scratchpad notes', detail: 'Open Agent-local notes for source triage, decisions, and handoff context.', targetCategoryId: 'notes', kind: 'workspace', safety: 'safe' },
       { id: 'personal-ops-note-create', label: 'Create note', detail: 'Capture temporary context as an Agent-local scratchpad note.', editorKind: 'note', kind: 'editor', safety: 'safe' },
-      { id: 'personal-ops-workplan', label: 'Review work plan', detail: 'Open the visible work-plan route for user-facing task tracking.', targetCategoryId: 'work', kind: 'workspace', safety: 'safe' },
-      { id: 'personal-ops-workplan-add', label: 'Add work item', detail: 'Create one visible work-plan item instead of hiding the task in background state.', editorKind: 'workplan-add', kind: 'editor', safety: 'safe' },
       { id: 'personal-ops-host-tasks', label: 'Host tasks', detail: 'Inspect connected-host task state without creating, retrying, or mutating tasks.', command: '/tasks list', kind: 'command', safety: 'read-only' },
       { id: 'personal-ops-reminder', label: 'Create reminder', detail: 'Create one connected reminder schedule with real timing, optional delivery target, and explicit confirmation.', editorKind: 'reminder-schedule', kind: 'editor', safety: 'safe' },
       { id: 'personal-ops-routines', label: 'Routine library', detail: 'Open repeatable workflows and schedule-promotion readiness.', targetCategoryId: 'routines', kind: 'workspace', safety: 'safe' },
@@ -658,18 +656,12 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
     id: 'work',
     group: 'OPERATIONS',
     label: 'Work & Approvals',
-    summary: 'Visible task state, work plan, and approval posture.',
-    detail: 'Use this workspace to inspect active operator state and update visible work-plan items from confirmed TUI forms.',
+    summary: 'Visible task state and approval posture.',
+    detail: 'Use this workspace to inspect active operator state and approval posture.',
     actions: [
-      { id: 'workplan', label: 'Review work plan', detail: 'Print a concise work plan summary in the main Agent transcript.', command: '/workplan list', kind: 'command', safety: 'read-only' },
-      { id: 'work-autonomy-queue', label: 'Autonomy queue', detail: 'Inspect visible work-plan, host-task, approval, automation, schedule, routine, and delegation queue cards.', kind: 'guidance', safety: 'read-only' },
+      { id: 'work-autonomy-queue', label: 'Autonomy queue', detail: 'Inspect visible host-task, approval, automation, schedule, routine, and delegation queue cards.', kind: 'guidance', safety: 'read-only' },
       { id: 'work-background-processes', label: 'Background processes', detail: 'Inspect tracked local background processes, bounded output tails, visible monitor routes, and lifecycle controls with execution action:"processes".', kind: 'guidance', safety: 'read-only' },
       { id: 'work-process-capabilities', label: 'Process capabilities', detail: 'Inspect process parity for start/list/poll/wait/log/kill/write, PTY, and sudo before choosing a local execution route.', kind: 'guidance', safety: 'read-only' },
-      { id: 'workplan-show', label: 'Show work plan detail', detail: 'Open a read-only form for the detailed work plan view.', editorKind: 'workplan-show', kind: 'editor', safety: 'read-only' },
-      { id: 'workplan-add', label: 'Add work item', detail: 'Open a form that creates one visible work plan item from the Agent workspace.', editorKind: 'workplan-add', kind: 'editor', safety: 'safe' },
-      { id: 'workplan-status', label: 'Update work item status', detail: 'Open a form that updates one work plan item to pending, active, blocked, done, failed, or cancelled.', editorKind: 'workplan-status', kind: 'editor', safety: 'safe' },
-      { id: 'workplan-delete', label: 'Remove work item', detail: 'Open a confirmed form before removing one work plan item.', editorKind: 'workplan-delete', kind: 'editor', safety: 'safe' },
-      { id: 'workplan-clear-completed', label: 'Clear completed work', detail: 'Open a confirmed form before clearing completed and cancelled work plan items.', editorKind: 'workplan-clear-completed', kind: 'editor', safety: 'safe' },
       { id: 'conversation-export', label: 'Export conversation', detail: 'Open a confirmed form that exports the current Agent conversation to a workspace file.', editorKind: 'conversation-export', kind: 'editor', safety: 'safe' },
       { id: 'conversation-review', label: 'Review transcript', detail: 'Inspect current transcript structure without changing the conversation.', command: '/conversation review', kind: 'command', safety: 'read-only' },
       { id: 'conversation-composer', label: 'Composer posture', detail: 'Inspect current composer mode, pending approval posture, and context warning state.', command: '/conversation composer', kind: 'command', safety: 'read-only' },
@@ -690,15 +682,6 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
       { id: 'session-export-saved', label: 'Export saved session', detail: 'Open a form that prints one saved-session transcript as markdown or text.', editorKind: 'session-export-saved', kind: 'editor', safety: 'read-only' },
       { id: 'session-search', label: 'Search saved sessions', detail: 'Open a form that searches saved Agent sessions.', editorKind: 'session-search', kind: 'editor', safety: 'read-only' },
       { id: 'session-delete', label: 'Delete saved session', detail: 'Open a confirmed form before deleting one saved Agent session.', editorKind: 'session-delete', kind: 'editor', safety: 'safe' },
-      { id: 'planning-status', label: 'Planning status', detail: 'Inspect current Agent planning readiness, mode, and next question without seeding or approving planning state.', command: '/plan status', kind: 'command', safety: 'read-only' },
-      { id: 'planning-mode', label: 'Planning mode', detail: 'Inspect current planner mode and runtime strategy without changing it.', command: '/plan mode', kind: 'command', safety: 'read-only' },
-      { id: 'planning-explain', label: 'Explain planner', detail: 'Explain planner state and readiness without approving or changing it.', command: '/plan explain', kind: 'command', safety: 'read-only' },
-      { id: 'planning-list', label: 'Saved plans', detail: 'List saved Agent execution plans without changing current planning state.', command: '/plan list', kind: 'command', safety: 'read-only' },
-      { id: 'plan-seed', label: 'Seed planning goal', detail: 'Open a form that seeds current planning state from a concrete Agent operating goal.', editorKind: 'plan-seed', kind: 'editor', safety: 'safe' },
-      { id: 'plan-show', label: 'Show saved plan', detail: 'Open a plan-id form for read-only saved plan detail.', editorKind: 'plan-show', kind: 'editor', safety: 'read-only' },
-      { id: 'plan-approve', label: 'Approve planning state', detail: 'Open a confirmation form before approving current planning state for execution.', editorKind: 'plan-approve', kind: 'editor', safety: 'safe' },
-      { id: 'plan-override', label: 'Override planning strategy', detail: 'Open a confirmation form before changing planner strategy.', editorKind: 'plan-override', kind: 'editor', safety: 'safe' },
-      { id: 'plan-clear', label: 'Clear planning state', detail: 'Open a confirmation form before clearing planner state.', editorKind: 'plan-clear', kind: 'editor', safety: 'safe' },
       { id: 'tasks-list', label: 'Host tasks', detail: 'Inspect connected-host task state without creating, retrying, or mutating tasks.', command: '/tasks list', kind: 'command', safety: 'read-only' },
       { id: 'tasks-filter', label: 'Filter host tasks', detail: 'Open a status/kind form for read-only connected-host task filtering.', editorKind: 'task-list-filter', kind: 'editor', safety: 'read-only' },
       { id: 'task-show', label: 'Inspect host task', detail: 'Open a task-id form for read-only connected-host task metadata.', editorKind: 'task-show', kind: 'editor', safety: 'read-only' },

package/src/input/commands.ts

@@ -6,7 +6,6 @@ import { knowledgeCommand } from './commands/knowledge.ts';
 import { registerShellCoreCommands } from './commands/shell-core.ts';
 import { registerConfigCommand } from './commands/config.ts';
 import { registerSessionWorkflowCommands } from './commands/session-workflow.ts';
-import { registerPlanningRuntimeCommands } from './commands/planning-runtime.ts';
 import { registerScheduleRuntimeCommands } from './commands/schedule-runtime.ts';
 import { registerOperatorRuntimeCommands } from './commands/operator-runtime.ts';
 import { registerNotifyRuntimeCommands } from './commands/notify-runtime.ts';
@@ -27,7 +26,6 @@ import { registerConversationRuntimeCommands } from './commands/conversation-run
 import { registerQrcodeRuntimeCommands } from './commands/qrcode-runtime.ts';
 import { registerOnboardingRuntimeCommands } from './commands/onboarding-runtime.ts';
 import { registerTtsRuntimeCommands } from './commands/tts-runtime.ts';
-import { registerWorkPlanRuntimeCommands } from './commands/work-plan-runtime.ts';
 import { registerAgentWorkspaceRuntimeCommands } from './commands/agent-workspace-runtime.ts';
 import { registerAgentRuntimeProfileRuntimeCommands } from './commands/agent-runtime-profile-runtime.ts';
 import { registerDelegationRuntimeCommands } from './commands/delegation-runtime.ts';
@@ -90,10 +88,8 @@ export function registerBuiltinCommands(registry: CommandRegistry): void {
   registerQrcodeRuntimeCommands(registry);
   registerOnboardingRuntimeCommands(registry);
   registerTtsRuntimeCommands(registry);
-  registerWorkPlanRuntimeCommands(registry);
   registerLocalRuntimeCommands(registry);
   registerSessionWorkflowCommands(registry);
-  registerPlanningRuntimeCommands(registry);
   registerScheduleRuntimeCommands(registry);
   registerSessionContentCommands(registry);
   registerAgentMemoryCommand(registry);

package/src/input/handler.ts

@@ -397,7 +397,10 @@ export class InputHandler {
   }
 
   public dispatchAgentWorkspaceCommand(command: string, context: CommandContext, behavior?: 'inline' | 'compose' | 'exit'): void {
-    const resolved = behavior ?? 'compose';
+    // Default to 'inline' so editor submissions stay inside the workspace modal.
+    // Closing the modal mid-flow (the old 'compose' default) traps users in the
+    // wrong context and was the primary symptom of the broken onboarding flow.
+    const resolved = behavior ?? 'inline';
     const { name, args } = parseSlashCommand(command);
     if (!name) return;
     if (resolved === 'exit') {

package/src/main.ts

@@ -54,7 +54,6 @@ import { applyInitialTuiCliState, formatFatalStartupErrorForLog, formatFatalStar
 import { wireSpokenTurnRuntime } from './audio/spoken-turn-wiring.ts';
 import { attachSpokenTurnModelRouting, createSpokenTurnInputOptions } from './audio/spoken-turn-model-routing.ts';
 import { allowTerminalWrite, installTuiTerminalOutputGuard } from './runtime/terminal-output-guard.ts';
-import { ProjectPlanningCoordinator } from './planning/project-planning-coordinator.ts';
 import { buildCommandArgsHint } from './input/command-args-hint.ts';
 import { GOODVIBES_AGENT_PAIRING_SURFACE } from './config/surface.ts';
 
@@ -262,18 +261,6 @@ async function main() {
     configManager,
     notify: (message) => { systemMessageRouter.high(message); render(); },
   }));
-  const projectPlanningCoordinator = new ProjectPlanningCoordinator({
-    service: ctx.services.projectPlanningService,
-    projectId: ctx.services.projectPlanningProjectId,
-    workingDirectory: workingDir,
-    notify: (message) => { systemMessageRouter.high(message); render(); },
-    openPanel: () => {
-      panelManager.open('project-planning');
-      panelManager.show();
-      render();
-    },
-  });
-
   const submitInput = (text: string, content?: ContentPart[], options: { readonly spokenOutput?: boolean } = {}) => {
     input.clearModalStack();
     scrollLocked = true; // Re-lock on user input
@@ -308,33 +295,7 @@ async function main() {
     }
     if (processedText || content) {
       void (async () => {
-        let inputOptions = options.spokenOutput ? createSpokenTurnInputOptions() : undefined;
-        if (!options.spokenOutput && processedText) {
-          try {
-            const planning = await projectPlanningCoordinator.prepareTurn(processedText);
-            if (planning) {
-              if (planning.handledLocally) {
-                systemMessageRouter.high(planning.statusMessage);
-                render();
-                return;
-              }
-              conversation.addSystemMessage(planning.systemMessage);
-              inputOptions = {
-                origin: {
-                  source: 'project-planning',
-                  surface: GOODVIBES_AGENT_PAIRING_SURFACE,
-                  metadata: {
-                    projectId: ctx.services.projectPlanningProjectId,
-                    knowledgeSpaceId: planning.state.knowledgeSpaceId,
-                    readiness: planning.evaluation.readiness,
-                  },
-                },
-              };
-            }
-          } catch (err) {
-            systemMessageRouter.high(`[Planning] ${summarizeError(err)}`);
-          }
-        }
+        const inputOptions = options.spokenOutput ? createSpokenTurnInputOptions() : undefined;
         if (options.spokenOutput && processedText) {
           spokenTurns.submitNextTurn(processedText);
         }

package/src/panels/builtin/agent.ts

@@ -3,8 +3,6 @@ import { ContextVisualizerPanel } from '../context-visualizer-panel.ts';
 import { ThinkingPanel } from '../thinking-panel.ts';
 import { ToolInspectorPanel } from '../tool-inspector-panel.ts';
 import { SchedulePanel } from '../schedule-panel.ts';
-import { ProjectPlanningPanel } from '../project-planning-panel.ts';
-import { WorkPlanPanel } from '../work-plan-panel.ts';
 import type { ResolvedBuiltinPanelDeps } from './shared.ts';
 import { requireAutomationManager, requireUiServices } from './shared.ts';
 
@@ -49,32 +47,6 @@ export function registerAgentPanels(manager: PanelManager, deps: ResolvedBuiltin
     ),
   });
 
-  manager.registerType({
-    id: 'work-plan',
-    name: 'Work Plan',
-    icon: 'L',
-    category: 'agent',
-    description: 'Persistent workspace checklist for multi-step work and cross-session task tracking',
-    preload: true,
-    factory: () => new WorkPlanPanel(deps.workPlanStore),
-  });
-
-  manager.registerType({
-    id: 'project-planning',
-    name: 'Planning',
-    icon: 'P',
-    category: 'agent',
-    description: 'Passive project planning artifacts: readiness, questions, decisions, language, task graph, and agent handoff metadata',
-    preload: true,
-    factory: () => new ProjectPlanningPanel({
-      service: deps.projectPlanningService,
-      projectId: deps.projectPlanningProjectId,
-      requestRender: deps.requestRender,
-      submitAnswer: deps.submitPlanningAnswer,
-      dismissPlanning: deps.dismissPlanning,
-    }),
-  });
-
   manager.registerType({
     id: 'schedule',
     name: 'Schedule',

package/src/renderer/agent-workspace.ts

@@ -392,10 +392,13 @@ function onboardingActionColumns(workspace: AgentWorkspace, action: AgentWorkspa
       currentValue: '(unknown)',
     };
   }
+  // Non-setting rows keep the 3-column layout but use placeholders for Default and Current,
+  // since those concepts only make sense for actual settings. The action label carries
+  // the meaning of the row.
   return {
-    setting: onboardingActionLabel(workspace, action),
-    defaultValue: '',
-    currentValue: '',
+    setting: action.label,
+    defaultValue: '—',
+    currentValue: '—',
   };
 }
 
@@ -418,9 +421,12 @@ function actionMetaLine(workspace: AgentWorkspace, category: AgentWorkspaceCateg
 }
 
 function shouldRenderOnboardingSettingsTable(actions: readonly AgentWorkspaceAction[]): boolean {
-  // Exclude the synthetic finish footer row — it is not a setting and must not block table mode.
+  // Always use the Setting/Default/Current 3-column layout on ONBOARDING pages so the
+  // user gets a consistent visual structure across every category, even ones that mix
+  // settings with editors, guidance, or pickers. Non-setting rows fill Default/Current
+  // with placeholders via onboardingActionColumns().
   const nonFinish = actions.filter((a) => a.kind !== 'onboarding-complete');
-  return nonFinish.length > 0 && nonFinish.every((action) => action.kind === 'setting');
+  return nonFinish.length > 0;
 }
 
 function editorContextLines(editor: AgentWorkspaceLocalEditor, snapshot: AgentWorkspaceRuntimeSnapshot | null): ContextLine[] {

package/src/renderer/help-overlay.ts

@@ -22,7 +22,6 @@ const FEATURED_HELP_COMMANDS: Array<[name: string, argHint: string, desc: string
   ['personas',     '',           'Manage serial Agent operating personas'],
   ['skills',       '',           'Manage Agent-local skills and bundles'],
   ['routines',     '',           'Manage reusable main-conversation routines'],
-  ['workplan',     '',           'Inspect shared work-plan state'],
   ['approval',     '',           'Review and explicitly act on approvals'],
   ['automation',   '',           'Run confirmed connected-host automation actions'],
   ['schedule',     'remind',     'Create confirmed reminders or inspect schedules'],
@@ -202,7 +201,6 @@ export function renderHelpOverlay(
       'personas',
       'skills',
       'routines',
-      'workplan',
       'approval',
       'schedule',
       'delegate',

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 = '1.4.1';
+let _version = '1.4.2';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8')) as {
     readonly version?: unknown;

package/docs/project-planning.md

@@ -1,81 +0,0 @@
-# Project Planning
-
-GoodVibes Agent owns the active planning loop for operator work. Planning is part of the Agent main conversation, not a hidden execution flow and not a default knowledge query.
-
-## Boundary
-
-The Agent owns:
-
-- natural-language planning intent detection in the main terminal conversation;
-- one-question-at-a-time clarification;
-- the Agent-owned planning loop;
-- transcript-first planning summaries and the Agent operator workspace planning state;
-- explicit execution approval;
-- delegation metadata when work needs GoodVibes TUI.
-
-The connected-host runtime owns durable storage and route contracts:
-
-- planning namespaces such as `project:<projectId>`;
-- readiness evaluation and next-question hints;
-- decision records;
-- task, dependency, verification, and assignment metadata;
-- read-only public operator methods.
-
-Other surfaces can store or inspect planning artifacts, but conversation control stays in Agent. Agent planning state is not default knowledge, another product segment, or arbitrary knowledge data.
-
-## Agent Behavior
-
-The Agent derives a stable `projectId` from the workspace path and passes it to the connected-host planning service. Planning artifacts are stored under the matching planning namespace so unrelated workspaces do not share state.
-
-Normal conversation can start planning when the user asks for an execution strategy, dependency graph, verification gates, or delegation handoff. The Agent then:
-
-- prints a concise planning summary in the main transcript;
-- persists the current planning state through public connected-host runtime routes;
-- records active open questions and user answers;
-- calls readiness evaluation for gaps and the suggested next question;
-- asks one focused question instead of executing prematurely.
-
-The planning loop can be paused with natural language such as "stop planning" or "pause planning".
-
-## Planning View
-
-The planning view is transcript-first. It shows:
-
-- workspace project id and planning namespace;
-- readiness and approval state;
-- goal, scope, known context, and current next question;
-- blocking or advisory readiness gaps;
-- task graph and verification gates;
-- delegation candidates;
-- durable decisions;
-- project language and ambiguity resolutions.
-
-Keyboard behavior stays in the main Agent TUI: predictable prompt editing, scroll, submit, dismiss, and return-to-chat behavior.
-
-## `/plan`
-
-`/plan` remains a command workspace for inspection and seeding:
-
-- `/plan` prints current planning readiness and the next planning question;
-- `/plan panel` is guidance-only in Agent and points back to `/plan status` or `/plan list`;
-- `/plan approve` records explicit execution approval;
-- `/plan <goal>` seeds Agent workspace planning state;
-- `/plan list` and `/plan show <id>` inspect older execution-plan records.
-
-Use natural language such as "pause planning" or "stop planning" when planning should pause and normal chat should continue.
-
-## Work Plan
-
-The work-plan tracker is for concrete, durable task state after work becomes actionable. It is separate from the planning interview loop.
-
-Use `/workplan` when the work already has tasks and needs status tracking. Use `/delegate` when explicit build/fix/review work should go to GoodVibes TUI; include the original ask, delegation reason, success evidence, workspace/worktree hint, priority, and explicit review intent.
-
-The model can keep the same visible work plan current with `agent_work_plan`. Approved items can be dispatched through confirmed `agent_work_plan action:"dispatch_agents"` into visible `agent` spawn or batch-spawn calls, with linked-agent receipts written back to the plan and post-dispatch next routes for orchestration, work-plan detail, agent inspect/wait/message/cancel, and closeout. Those linked receipts and matching remote-runner artifacts appear in `agent_harness mode:"agent_orchestration"` closeout cards with exact work-plan and artifact review routes. It can also inspect planning/work-plan visibility through `agent_harness` workspace and panel metadata, and inspect explicit build-delegation posture with `delegation action:"status|routes|route"`; destructive work-plan changes, agent dispatch, and delegated submissions still require explicit user request and confirmation.
-
-## Agent Knowledge Boundary
-
-Planning may link to Agent Knowledge evidence, but it must not query or ingest through default knowledge. Source-backed facts for Agent belong under:
-
-```text
-/api/goodvibes-agent/knowledge/*
-```

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

@@ -1,215 +0,0 @@
-import type {
-  ProjectPlanningEvaluation,
-  ProjectPlanningQuestion,
-  ProjectPlanningService,
-  ProjectPlanningState,
-} from '@pellux/goodvibes-sdk/platform/knowledge';
-import type { CommandRegistry } from '../command-registry.ts';
-import { requirePlanManager, requireSessionLineageTracker } from './runtime-services.ts';
-import { requireYesFlag, stripYesFlag } from './confirmation.ts';
-
-function recordNextQuestion(
-  state: Partial<ProjectPlanningState>,
-  question: ProjectPlanningQuestion | undefined,
-): Partial<ProjectPlanningState> {
-  if (!question) return state;
-  const answered = new Set((state.answeredQuestions ?? []).map((entry) => entry.id));
-  if (answered.has(question.id)) return state;
-  const openQuestions = [...(state.openQuestions ?? [])];
-  const existingIndex = openQuestions.findIndex((entry) => entry.id === question.id);
-  const normalized = { ...question, status: question.status ?? 'open' } satisfies ProjectPlanningQuestion;
-  if (existingIndex >= 0) openQuestions[existingIndex] = normalized;
-  else openQuestions.unshift(normalized);
-  return { ...state, openQuestions };
-}
-
-async function persistEvaluatedNextQuestion(
-  service: ProjectPlanningService,
-  projectId: string,
-  state: ProjectPlanningState,
-  evaluation: ProjectPlanningEvaluation,
-): Promise<{ state: ProjectPlanningState; evaluation: ProjectPlanningEvaluation }> {
-  if (!evaluation.nextQuestion) return { state, evaluation };
-  if (state.openQuestions.some((question) => question.id === evaluation.nextQuestion?.id)) {
-    return { state, evaluation };
-  }
-  const withQuestion = recordNextQuestion(evaluation.state ?? state, evaluation.nextQuestion);
-  const saved = await service.upsertState({ projectId, state: withQuestion });
-  const nextState = saved.state ?? state;
-  const nextEvaluation = await service.evaluate({ projectId, state: nextState });
-  return { state: nextState, evaluation: nextEvaluation };
-}
-
-function formatNextQuestion(question: ProjectPlanningQuestion | undefined): string {
-  if (!question) return 'No next question recorded.';
-  const lines = [`Next question: ${question.prompt}`];
-  if (question.recommendedAnswer) lines.push(`Recommended answer: ${question.recommendedAnswer}`);
-  lines.push('Answer in the main prompt or review planning state with /plan status.');
-  return lines.join('\n');
-}
-
-export function registerPlanningRuntimeCommands(registry: CommandRegistry): void {
-  registry.register({
-    name: 'plan',
-    description: 'Inspect or seed Agent workspace planning state',
-    usage: '[approve --yes | list | show <id> | mode | explain | override <strategy> --yes | status | clear --yes | <planning goal>]',
-    argsHint: '[approve|status|list|<goal>]',
-    async handler(args, ctx) {
-      const planManager = requirePlanManager(ctx);
-      const sessionLineageTracker = requireSessionLineageTracker(ctx);
-      const plannerSubs = ['mode', 'explain', 'override', 'status', 'clear'];
-      if (args.length > 0 && plannerSubs.includes(args[0].toLowerCase())) {
-        const parsed = stripYesFlag(args);
-        const subcommand = parsed.rest[0]?.toLowerCase() ?? '';
-        if ((subcommand === 'override' || subcommand === 'clear') && !parsed.yes) {
-          requireYesFlag(ctx, `${subcommand} planner state`, `/plan ${subcommand}${subcommand === 'override' ? ' <strategy>' : ''} --yes`);
-          return;
-        }
-        const result = ctx.ops.planRuntime
-          ? ctx.ops.planRuntime(parsed.rest[0] ?? args[0], parsed.rest.slice(1))
-          : { ok: false, output: 'Plan runtime route is not available in this runtime.' };
-        ctx.print(result.output);
-        return;
-      }
-
-      const projectPlanningService = ctx.workspace.projectPlanningService;
-      const projectId = ctx.workspace.projectPlanningProjectId;
-
-      if (args.length === 0) {
-        if (projectPlanningService && projectId) {
-          const [status, stateResult] = await Promise.all([
-            projectPlanningService.status({ projectId }),
-            projectPlanningService.getState({ projectId }),
-          ]);
-          const initialEvaluation = await projectPlanningService.evaluate({
-            projectId,
-            ...(stateResult.state ? { state: stateResult.state } : {}),
-          });
-          const { evaluation } = stateResult.state
-            ? await persistEvaluatedNextQuestion(projectPlanningService, projectId, stateResult.state, initialEvaluation)
-            : { evaluation: initialEvaluation };
-          const planningNamespace = String(
-            status[['knowledge', 'SpaceId'].join('') as keyof typeof status] ?? `project:${status.projectId}`,
-          );
-          ctx.print(
-            `Project planning: ${evaluation.readiness}\n` +
-            `Project: ${status.projectId}\n` +
-            `Planning namespace: ${planningNamespace}\n` +
-            `Artifacts: ${status.counts.states} state, ${status.counts.decisions} decisions, ${status.counts.languageArtifacts} language\n` +
-            formatNextQuestion(evaluation.nextQuestion),
-          );
-          return;
-        }
-        const active = planManager.getActive(ctx.session.runtime.sessionId);
-        if (!active) {
-          ctx.print('No active execution plan.');
-          return;
-        }
-        const summary = planManager.getSummary(active);
-        ctx.print(`Active plan: "${active.title}" [${active.status.toUpperCase()}]\n${summary}`);
-        return;
-      }
-
-      if (args[0] === 'panel') {
-        ctx.print('Use /plan status or /plan list for compact command output. Open Agent Workspace -> Work -> Planning status or Saved plans for the workspace view.');
-        return;
-      }
-
-      if (args[0] === 'approve') {
-        const parsed = stripYesFlag(args);
-        if (!parsed.yes) {
-          requireYesFlag(ctx, 'approve project planning state for execution', '/plan approve --yes');
-          return;
-        }
-        if (!projectPlanningService || !projectId) {
-          ctx.print('Project planning service is not available in this runtime.');
-          return;
-        }
-        const current = await projectPlanningService.getState({ projectId });
-        if (!current.state) {
-          ctx.print('No project planning state exists to approve.');
-          return;
-        }
-        const result = await projectPlanningService.upsertState({
-          projectId,
-          state: {
-            ...current.state,
-            executionApproved: true,
-            metadata: {
-              ...(current.state.metadata ?? {}),
-              approvedFrom: 'plan-command',
-              approvedAt: Date.now(),
-            },
-          },
-        });
-        const evaluation = await projectPlanningService.evaluate({ projectId });
-        ctx.print(`Project planning approved. Readiness: ${evaluation.readiness}. State: ${result.state?.id ?? 'current'}.`);
-        return;
-      }
-
-      if (args[0] === 'list') {
-        const plans = planManager.list();
-        if (plans.length === 0) {
-          ctx.print('No plans found.');
-          return;
-        }
-        ctx.print(`Plans (${plans.length}):\n${plans.map((plan) => {
-          const marker = plan.status === 'active' ? '▶' : ' ';
-          return `  ${marker} ${plan.id.slice(0, 8)}  [${plan.status.padEnd(8)}]  ${plan.title}`;
-        }).join('\n')}`);
-        return;
-      }
-
-      if (args[0] === 'show') {
-        const id = args[1];
-        if (!id) {
-          ctx.print('Usage: /plan show <plan-id>');
-          return;
-        }
-        const plans = planManager.list();
-        const plan = plans.find((entry) => entry.id === id || entry.id.startsWith(id));
-        if (!plan) {
-          ctx.print(`Plan not found: ${id}`);
-          return;
-        }
-        ctx.print(planManager.toMarkdown(plan));
-        return;
-      }
-
-      const taskDescription = args.join(' ');
-      if (!projectPlanningService || !projectId) {
-        ctx.print('Project planning service is not available in this runtime.');
-        return;
-      }
-      const result = await projectPlanningService.upsertState({
-        projectId,
-        state: {
-          goal: taskDescription,
-          knownContext: [
-            `Workspace planning was seeded from the Agent /plan command.`,
-          ],
-          metadata: {
-            active: true,
-            owner: 'agent',
-            source: 'plan-command',
-            lastPromptAt: Date.now(),
-          },
-        },
-      });
-      const initialEvaluation = await projectPlanningService.evaluate({
-        projectId,
-        ...(result.state ? { state: result.state } : {}),
-      });
-      const { state, evaluation } = result.state
-        ? await persistEvaluatedNextQuestion(projectPlanningService, projectId, result.state, initialEvaluation)
-        : { state: result.state, evaluation: initialEvaluation };
-      sessionLineageTracker.setOriginalTask(taskDescription.slice(0, 200));
-
-      ctx.print(
-        `Project planning seeded: "${state?.goal ?? taskDescription}"\n` +
-        `Readiness: ${evaluation.readiness}\n` +
-        formatNextQuestion(evaluation.nextQuestion),
-      );
-    },
-  });
-}