@pellux/goodvibes-agent 1.4.1 → 1.4.3

package/src/input/agent-workspace-host-category.ts

@@ -7,51 +7,27 @@ export const AGENT_WORKSPACE_HOST_CATEGORY: AgentWorkspaceCategory = {
   summary: 'Connected-host health, tasks, sessions, channels, and automation.',
   detail: 'Use this workspace to inspect the GoodVibes host surfaces that Agent can see: system health, remote routes, host tasks, sessions, channels, schedules, knowledge, media, MCP, provider auth, support bundles, and telemetry/config posture.',
   actions: [
-    { id: 'host-overview', label: 'Host overview', detail: 'Review connected-host, provider, settings, continuity, and Agent health without starting or mutating host work.', command: '/health review', kind: 'command', safety: 'read-only' },
-    { id: 'host-services', label: 'Host services', detail: 'Inspect connected-host service readiness, credentials, and integration issues without changing them.', command: '/health host', kind: 'command', safety: 'read-only' },
-    { id: 'host-setup', label: 'Setup review', detail: 'Inspect setup issues that affect connected-host and Agent runtime readiness.', command: '/health setup', kind: 'command', safety: 'read-only' },
-    { id: 'host-remote', label: 'Remote routes', detail: 'Inspect remote build-host route health and recovery signals without starting build work.', command: '/health remote', kind: 'command', safety: 'read-only' },
-    { id: 'host-maintenance', label: 'Session maintenance', detail: 'Review continuity, compaction, and current-session maintenance posture.', command: '/health maintenance', kind: 'command', safety: 'read-only' },
-    { id: 'host-continuity', label: 'Continuity', detail: 'Inspect last-session pointer, recovery-file posture, and return-context state.', command: '/health continuity', kind: 'command', safety: 'read-only' },
-    { id: '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: 'host-task-filter', label: 'Filter host tasks', detail: 'Open a status/type form for read-only connected-host task filtering.', editorKind: 'task-list-filter', kind: 'editor', safety: 'read-only' },
     { id: 'host-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' },
     { id: 'host-task-output', label: 'Show task output', detail: 'Open a task-id form for read-only connected-host task output.', editorKind: 'task-output', kind: 'editor', safety: 'read-only' },
-    { id: 'host-sessions', label: 'Host session routes', detail: 'Browse saved Agent sessions and return-context posture exposed through the runtime session surface.', command: '/session list', kind: 'command', safety: 'read-only' },
     { id: 'host-session-graph', label: 'Session graph', detail: 'Open a read-only form for cross-session graph inspection; graph mutation remains blocked in Agent.', editorKind: 'session-graph', kind: 'editor', safety: 'read-only' },
-    { id: 'host-channels-status', label: 'Channel status', detail: 'Inspect connected channel runtime status from the host without mutating delivery state.', command: '/channels status', kind: 'command', safety: 'read-only' },
-    { id: 'host-channel-accounts', label: 'Channel accounts', detail: 'Inspect connected channel accounts without printing secret values or sending messages.', command: '/channels accounts', kind: 'command', safety: 'read-only' },
-    { id: 'host-channel-policies', label: 'Channel policies', detail: 'Inspect channel delivery policy posture without changing routing.', command: '/channels policies', kind: 'command', safety: 'read-only' },
     { id: 'host-channels', label: 'Open Channels', detail: 'Jump to the channel setup and delivery workspace.', targetCategoryId: 'channels', kind: 'workspace', safety: 'safe' },
     { id: 'host-automation', label: 'Open Automation', detail: 'Jump to connected schedules, reminders, receipts, and explicit run controls.', targetCategoryId: 'automation', kind: 'workspace', safety: 'safe' },
-    { id: 'host-schedules', label: 'Schedule status', detail: 'Inspect schedules and run history without running or mutating them.', command: '/schedule list', kind: 'command', safety: 'read-only' },
-    { id: 'host-schedule-reconcile', label: 'Reconcile schedules', detail: 'Compare local promotion receipts with live connected schedules.', command: '/schedule reconcile', kind: 'command', safety: 'read-only' },
-    { id: 'host-knowledge', label: 'Knowledge route', detail: 'Inspect isolated Agent Knowledge route readiness and source counts.', command: '/knowledge status', kind: 'command', safety: 'read-only' },
     { id: 'host-knowledge-open', label: 'Open Knowledge', detail: 'Jump to Agent Knowledge source, graph, review, and ingest controls.', targetCategoryId: 'knowledge', kind: 'workspace', safety: 'safe' },
-    { id: 'host-media', label: 'Media providers', detail: 'Inspect configured media providers before generating media with confirmation.', command: '/media providers', kind: 'command', safety: 'read-only' },
     { id: 'host-media-open', label: 'Open Voice and Media', detail: 'Jump to voice, TTS, image input, media provider, and browser-tool setup actions.', targetCategoryId: 'voice-media', kind: 'workspace', safety: 'safe' },
-    { id: 'host-mcp-health', label: 'MCP health', detail: 'Inspect MCP lifecycle issues without changing trust posture or approving tool-definition review.', command: '/health mcp', kind: 'command', safety: 'read-only' },
-    { id: 'host-mcp-review', label: 'MCP review', detail: 'Inspect MCP server connection, trust, role, and review posture.', command: '/mcp review', kind: 'command', safety: 'read-only' },
     { id: 'host-tools-open', label: 'Open Tools and MCP', detail: 'Jump to MCP server setup, tool inventory, secrets, and security review.', targetCategoryId: 'tools', kind: 'workspace', safety: 'safe' },
-    { id: 'host-provider-accounts', label: 'Provider accounts', detail: 'Review provider account routes, subscription windows, and billing-path safety.', command: '/accounts review', kind: 'command', safety: 'read-only' },
     { id: 'host-provider-detail', label: 'Provider detail', detail: 'Open a provider-id form for account and provider configuration review.', editorKind: 'provider-inspect', kind: 'editor', safety: 'read-only' },
     { id: 'host-provider-routes', label: 'Provider routes', detail: 'Open a provider-id form for account, subscription, and route inspection.', editorKind: 'provider-routes', kind: 'editor', safety: 'read-only' },
     { id: 'host-provider-repair', label: 'Provider repair guidance', detail: 'Open a provider-id form for read-only provider repair guidance.', editorKind: 'provider-account-repair', kind: 'editor', safety: 'read-only' },
-    { id: 'host-auth-owner', label: 'Connected-host auth owner', detail: 'Show connected-host auth ownership, local companion-token posture, and the confirmed Agent setup route that can create or repair its own operator token without printing it.', command: '/auth local', kind: 'command', safety: 'read-only' },
-    { id: 'host-auth-review', label: 'Provider auth review', detail: 'Review provider auth posture without printing token values.', command: '/auth review', kind: 'command', safety: 'read-only' },
     { id: 'host-auth-detail', label: 'Provider auth detail', detail: 'Open a provider-id form for read-only provider auth inspection.', editorKind: 'auth-show', kind: 'editor', safety: 'read-only' },
     { id: 'host-auth-repair', label: 'Provider auth repair', detail: 'Open a provider-id form for provider auth repair guidance.', editorKind: 'auth-repair', kind: 'editor', safety: 'read-only' },
     { id: 'host-auth-bundle-export', label: 'Export auth bundle', detail: 'Open a confirmed form that exports a redacted provider auth review bundle.', editorKind: 'auth-bundle-export', kind: 'editor', safety: 'safe' },
     { id: 'host-auth-bundle-inspect', label: 'Inspect auth bundle', detail: 'Open a form that inspects a provider auth review bundle before sharing or import.', editorKind: 'auth-bundle-inspect', kind: 'editor', safety: 'read-only' },
     { id: 'host-subscription-bundle-export', label: 'Export subscription bundle', detail: 'Open a confirmed form that exports redacted provider subscription state for review.', editorKind: 'subscription-bundle-export', kind: 'editor', safety: 'safe' },
     { id: 'host-subscription-bundle-inspect', label: 'Inspect subscription bundle', detail: 'Open a form that inspects provider subscription state before sharing.', editorKind: 'subscription-bundle-inspect', kind: 'editor', safety: 'read-only' },
-    { id: 'host-security', label: 'Security review', detail: 'Inspect token posture, MCP attack paths, policy lint, plugin risk, and incident pressure.', command: '/security review', kind: 'command', safety: 'read-only' },
-    { id: 'host-trust', label: 'Trust review', detail: 'Review permission, secret, plugin, and MCP trust posture without exporting bundles or changing trust.', command: '/trust review', kind: 'command', safety: 'read-only' },
     { id: 'host-support-bundle-export', label: 'Export support bundle', detail: 'Export a redacted Agent support bundle from the Host page.', editorKind: 'support-bundle-export', kind: 'editor', safety: 'safe' },
     { id: 'host-support-bundle-inspect', label: 'Inspect support bundle', detail: 'Inspect a support bundle before import or sharing.', editorKind: 'support-bundle-inspect', kind: 'editor', safety: 'read-only' },
     { id: 'host-support-bundle-import', label: 'Import support bundle', detail: 'Import reviewed, non-redacted config values from a support bundle.', editorKind: 'support-bundle-import', kind: 'editor', safety: 'safe' },
-    { id: 'host-telemetry', label: 'Telemetry settings', detail: 'Open telemetry payload policy settings for connected-host and Agent observability review.', command: '/config telemetry', kind: 'command', safety: 'safe' },
-    { id: 'host-config', label: 'Control-plane settings', detail: 'Open configuration controls for service, channels, tools, automation, provider, and storage posture.', command: '/config', kind: 'command', safety: 'safe' },
     { id: 'host-safety', label: 'Host mutation policy', detail: 'Agent may inspect connected-host surfaces and run explicit confirmed actions, but does not silently create tasks, send channel messages, mutate auth, or start automation.', kind: 'guidance', safety: 'blocked' },
   ],
 };

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,35 +392,36 @@ 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: '—',
   };
 }
 
 function actionChange(workspace: AgentWorkspace, category: AgentWorkspaceCategory, action: AgentWorkspaceAction): string {
-  return isOnboardingCategory(category) ? onboardingActionColumns(workspace, action).setting : actionCommand(action);
+  // Always show the action label via onboardingActionColumns for consistency across categories.
+  return onboardingActionColumns(workspace, action).setting;
 }
 
 function actionMetaLine(workspace: AgentWorkspace, category: AgentWorkspaceCategory, action: AgentWorkspaceAction): ContextLine {
-  const onboarding = isOnboardingCategory(category);
-  if (onboarding) {
-    return {
-      text: `About: ${compactText(action.detail, 100)}`,
-      fg: action.safety === 'blocked' ? PALETTE.warn : PALETTE.muted,
-    };
-  }
+  // Same About-style detail line on every category.
   return {
-    text: `Does: ${actionChange(workspace, category, action)}`,
-    fg: action.safety === 'blocked' ? PALETTE.warn : action.kind === 'command' ? PALETTE.info : PALETTE.muted,
+    text: `About: ${compactText(action.detail, 100)}`,
+    fg: action.safety === 'blocked' ? PALETTE.warn : PALETTE.muted,
   };
 }
 
 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[] {
@@ -569,8 +570,9 @@ function buildActionRows(workspace: AgentWorkspace, width: number, height: numbe
   if (workspace.localEditor) return buildEditorRows(workspace.localEditor, width, height);
   const category = workspace.selectedActionCategory;
   const onboarding = isOnboardingCategory(category);
-  const settingTable = onboarding
-    && !workspace.actionSearchActive
+  // Apply the consistent Setting/Default/Current 3-column layout to EVERY category, not
+  // just the ONBOARDING group. Different layouts across pages were confusing.
+  const settingTable = !workspace.actionSearchActive
     && shouldRenderOnboardingSettingsTable(workspace.actions);
   const rows: WorkspaceRow[] = [];
   const valueWidth = settingTable

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.3';
 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),
-      );
-    },
-  });
-}