@pellux/goodvibes-agent 1.3.0 → 1.4.2

package/src/tools/agent-harness-setup-posture.ts

@@ -30,7 +30,7 @@ export async function setupPostureCatalogStatus(context: CommandContext): Promis
     autonomyBlockers: plan.filter((item) => item.blocksAutonomy && item.status !== 'ready').length,
     nextSetupHandoffs: nextSetupHandoffSummaries(plan, 5),
     setupWizard,
-    setupCloseout: setupWizard.closeout,
+    setupCloseout: setupWizard._diagnostic.closeout,
     collectionIssues: snapshot.collectionIssues.length,
     setupMarkerExists: setupCompletionMarkerExists(context),
     setupSmokeEvidence,
@@ -81,7 +81,7 @@ export async function setupRepairSummary(context: CommandContext, args: AgentHar
       status: setupWizard.status,
       currentStepId: setupWizard.currentStepId,
       currentStepLabel: setupWizard.currentStepLabel,
-      closeout: setupWizard.closeout,
+      closeout: setupWizard._diagnostic.closeout,
     },
     routes: {
       inspectSetup: DEFAULT_AGENT_SETUP_WIZARD_REVIEW_ROUTE,
@@ -149,14 +149,14 @@ export async function setupPostureSummary(context: CommandContext, args: AgentHa
         progressLabel: setupWizard.progressLabel,
         currentStepId: setupWizard.currentStepId,
         currentStepLabel: setupWizard.currentStepLabel,
-        repeatedBlocker: setupWizard.repeatedBlocker,
+        repeatedBlocker: setupWizard._diagnostic.repeatedBlocker,
       },
-      setupCloseout: setupWizard.closeout,
+      setupCloseout: setupWizard._diagnostic.closeout,
     },
     setupSmokeEvidence,
     setupSmokeHistory,
     setupWizard,
-    setupCloseout: setupWizard.closeout,
+    setupCloseout: setupWizard._diagnostic.closeout,
     currentRoute: snapshot.providerRouting,
     issues: snapshot.collectionIssues,
     readinessPlan: filteredPlan.map((item) => describePlanItem(item, includeParameters)),
@@ -175,7 +175,7 @@ export async function setupCheckpointSummary(context: CommandContext): Promise<R
   const setupWizard = buildSetupWizard(plan, context);
   return {
     mode: 'setup_checkpoint',
-    checkpoint: setupWizard.checkpoint,
+    checkpoint: setupWizard._diagnostic.checkpoint,
     currentStep: setupWizard.currentStepId
       ? setupWizard.steps.find((step) => step.id === setupWizard.currentStepId) ?? null
       : null,
@@ -254,7 +254,7 @@ export async function markSetupCheckpoint(context: CommandContext, args: AgentHa
       progressLabel: updatedWizard.progressLabel,
       currentStepId: updatedWizard.currentStepId,
       currentStepLabel: updatedWizard.currentStepLabel,
-      checkpoint: updatedWizard.checkpoint,
+      checkpoint: updatedWizard._diagnostic.checkpoint,
     },
     routes: {
       inspectCheckpoint: DEFAULT_AGENT_SETUP_WIZARD_INSPECT_CHECKPOINT_ROUTE,

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

package/src/input/commands/work-plan-runtime.ts

@@ -1,191 +0,0 @@
-import type { CommandRegistry } from '../command-registry.ts';
-import type { WorkPlanItemStatus, WorkPlanStore } from '../../work-plans/work-plan-store.ts';
-import { WORK_PLAN_STATUSES } from '../../work-plans/work-plan-store.ts';
-import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
-import { requireYesFlag, stripYesFlag } from './confirmation.ts';
-
-const STATUS_COMMANDS: Record<string, WorkPlanItemStatus> = {
-  pending: 'pending',
-  todo: 'pending',
-  start: 'in_progress',
-  active: 'in_progress',
-  progress: 'in_progress',
-  block: 'blocked',
-  blocked: 'blocked',
-  done: 'done',
-  complete: 'done',
-  fail: 'failed',
-  failed: 'failed',
-  cancel: 'cancelled',
-  cancelled: 'cancelled',
-};
-
-function getStore(ctx: import('../command-registry.ts').CommandContext): WorkPlanStore | null {
-  return ctx.workspace.workPlanStore ?? null;
-}
-
-function formatList(store: WorkPlanStore): string {
-  const items = store.listItems();
-  if (items.length === 0) {
-    return [
-      'Work plan is empty',
-      '  next /workplan add <title>',
-    ].join('\n');
-  }
-  return [
-    `Work Plan (${items.length})`,
-    ...items.map((item) => {
-      const owner = item.owner ? ` @${item.owner}` : '';
-      return `  ${item.id}  ${item.status.padEnd(11)} ${item.title}${owner}`;
-    }),
-  ].join('\n');
-}
-
-function parseAddArgs(args: string[]): { title: string; owner?: string; source?: string; notes?: string } {
-  const titleParts: string[] = [];
-  let owner: string | undefined;
-  let source: string | undefined;
-  let notes: string | undefined;
-  for (let i = 0; i < args.length; i++) {
-    const part = args[i] ?? '';
-    if (part === '--owner' && args[i + 1]) {
-      owner = args[++i];
-      continue;
-    }
-    if (part === '--source' && args[i + 1]) {
-      source = args[++i];
-      continue;
-    }
-    if (part === '--notes' && args[i + 1]) {
-      notes = args.slice(i + 1).join(' ').trim();
-      break;
-    }
-    titleParts.push(part);
-  }
-  return {
-    title: titleParts.join(' ').trim(),
-    ...(owner ? { owner } : {}),
-    ...(source ? { source } : {}),
-    ...(notes ? { notes } : {}),
-  };
-}
-
-export function registerWorkPlanRuntimeCommands(registry: CommandRegistry): void {
-  registry.register({
-    name: 'workplan',
-    aliases: ['wp', 'todo'],
-    description: 'Track a persistent workspace-scoped work plan',
-    usage: '[list|show|add <title> [--owner name] [--source label] [--notes text]|done <id>|start <id>|block <id>|fail <id>|cancel <id>|pending <id>|remove <id> --yes|clear-done --yes]',
-    argsHint: '[list|add|show|done]',
-    handler(args, ctx) {
-      const parsed = stripYesFlag(args);
-      const commandArgs = [...parsed.rest];
-      const store = getStore(ctx);
-      if (!store) {
-        ctx.print('Work plan store is not available in this runtime.');
-        return;
-      }
-      const subcommand = (commandArgs[0] ?? 'list').toLowerCase();
-      try {
-        if (subcommand === 'panel' || subcommand === 'open') {
-          ctx.print('Open Agent Workspace -> Work -> Work plan for the workspace view, or run /workplan list for compact command output.');
-          return;
-        }
-        if (subcommand === 'list') {
-          ctx.print(formatList(store));
-          return;
-        }
-        if (subcommand === 'show' || subcommand === 'markdown') {
-          ctx.print(store.toMarkdown());
-          return;
-        }
-        if (subcommand === 'add') {
-          const addArgs = parseAddArgs(commandArgs.slice(1));
-          if (!addArgs.title) {
-            ctx.print('Usage: /workplan add <title> [--owner name] [--source label] [--notes text]');
-            return;
-          }
-          const addOptions = {
-            ...(addArgs.owner ? { owner: addArgs.owner } : {}),
-            source: addArgs.source ?? 'manual',
-            ...(addArgs.notes ? { notes: addArgs.notes } : {}),
-          };
-          const item = store.addItem(addArgs.title, addOptions);
-          ctx.print([
-            'Added work plan item',
-            `  id ${item.id}`,
-            `  title ${item.title}`,
-            '  next open Agent Workspace -> Work -> Work plan to review',
-          ].join('\n'));
-          return;
-        }
-        if (subcommand === 'remove' || subcommand === 'delete' || subcommand === 'rm') {
-          const id = commandArgs[1];
-          if (!id) {
-            ctx.print(`Usage: /workplan ${subcommand} <id> --yes`);
-            return;
-          }
-          if (!parsed.yes) {
-            requireYesFlag(ctx, `remove work plan item ${id}`, `/workplan ${subcommand} <id> --yes`);
-            return;
-          }
-          const item = store.removeItem(id);
-          ctx.print([
-            'Removed work plan item',
-            `  id ${item.id}`,
-            `  title ${item.title}`,
-          ].join('\n'));
-          return;
-        }
-        if (subcommand === 'clear-done' || subcommand === 'clear-completed') {
-          if (!parsed.yes) {
-            requireYesFlag(ctx, 'clear completed work plan items', `/workplan ${subcommand} --yes`);
-            return;
-          }
-          const count = store.clearCompleted();
-          ctx.print([
-            'Cleared completed/cancelled work plan items',
-            `  count ${count}`,
-          ].join('\n'));
-          return;
-        }
-        if (subcommand === 'cycle' || subcommand === 'toggle') {
-          const id = commandArgs[1];
-          if (!id) {
-            ctx.print(`Usage: /workplan ${subcommand} <id>`);
-            return;
-          }
-          const item = store.cycleItemStatus(id);
-          ctx.print([
-            'Updated work plan item',
-            `  id ${item.id}`,
-            `  status ${item.status}`,
-          ].join('\n'));
-          return;
-        }
-        const status = STATUS_COMMANDS[subcommand];
-        if (status) {
-          const id = commandArgs[1];
-          if (!id) {
-            ctx.print(`Usage: /workplan ${subcommand} <id>`);
-            return;
-          }
-          const item = store.setItemStatus(id, status);
-          ctx.print([
-            'Updated work plan item',
-            `  id ${item.id}`,
-            `  status ${item.status}`,
-          ].join('\n'));
-          return;
-        }
-        if (WORK_PLAN_STATUSES.includes(subcommand as WorkPlanItemStatus)) {
-          ctx.print(`Usage: /workplan ${subcommand} <id>`);
-          return;
-        }
-        ctx.print(`Unknown workplan subcommand ${subcommand}`);
-      } catch (error) {
-        ctx.print(summarizeError(error));
-      }
-    },
-  });
-}