@pellux/goodvibes-tui 0.19.53 → 0.19.55

package/src/panels/builtin/shared.ts

@@ -20,6 +20,7 @@ import type { UserAuthManager } from '@pellux/goodvibes-sdk/platform/security/us
 import type { SessionMemoryStore } from '@pellux/goodvibes-sdk/platform/core/session-memory';
 import type { ExecutionPlanManager } from '@pellux/goodvibes-sdk/platform/core/execution-plan';
 import type { AdaptivePlanner } from '@pellux/goodvibes-sdk/platform/core/adaptive-planner';
+import type { ProjectPlanningService } from '@pellux/goodvibes-sdk/platform/knowledge/index';
 import type { ApiTokenAuditor } from '@pellux/goodvibes-sdk/platform/security/token-audit';
 import type { ComponentHealthMonitor } from '../../runtime/perf/panel-health-monitor.ts';
 import type { WorktreeRegistry } from '@pellux/goodvibes-sdk/platform/runtime/worktree/registry';
@@ -89,6 +90,10 @@ export interface BuiltinPanelDeps {
   planManager?: ExecutionPlanManager;
   /** Adaptive planner for ops strategy panels. */
   adaptivePlanner?: AdaptivePlanner;
+  /** Passive SDK-backed project planning artifact service. */
+  projectPlanningService?: ProjectPlanningService;
+  /** Stable workspace project id for project:<projectId> planning spaces. */
+  projectPlanningProjectId?: string;
   /** Shared system-messages panel instance attached from boot so low-priority chatter stays out of conversation. */
   systemMessagesPanel?: import('../system-messages-panel.ts').SystemMessagesPanel;
   /** Explicit UI-facing runtime services for agent/process/WRFC/remote panels and modals. */
@@ -115,6 +120,8 @@ export type ResolvedBuiltinPanelDeps = Omit<
   | 'sessionMemoryStore'
   | 'planManager'
   | 'adaptivePlanner'
+  | 'projectPlanningService'
+  | 'projectPlanningProjectId'
   | 'policyRuntimeState'
   | 'systemMessagesPanel'
 > & {
@@ -126,6 +133,8 @@ export type ResolvedBuiltinPanelDeps = Omit<
   readonly sessionMemoryStore: SessionMemoryStore;
   readonly planManager: ExecutionPlanManager;
   readonly adaptivePlanner: AdaptivePlanner;
+  readonly projectPlanningService: ProjectPlanningService;
+  readonly projectPlanningProjectId: string;
   readonly policyRuntimeState: PolicyRuntimeState;
   readonly systemMessagesPanel: import('../system-messages-panel.ts').SystemMessagesPanel;
 };
@@ -179,6 +188,14 @@ export function resolveBuiltinPanelDeps(deps: BuiltinPanelDeps): ResolvedBuiltin
       uiServices.planning.adaptivePlanner,
       'Adaptive planner must be wired at bootstrap for builtin panels.',
     ),
+    projectPlanningService: requireBuiltinPanelDep(
+      uiServices.planning.projectPlanningService,
+      'Project planning service must be wired at bootstrap for builtin panels.',
+    ),
+    projectPlanningProjectId: requireBuiltinPanelDep(
+      uiServices.planning.projectPlanningProjectId,
+      'Project planning project id must be wired at bootstrap for builtin panels.',
+    ),
     policyRuntimeState: requireBuiltinPanelDep(
       uiServices.platform.policyRuntimeState,
       'Policy runtime state must be wired at bootstrap for builtin panels.',

package/src/panels/project-planning-panel.ts

@@ -0,0 +1,370 @@
+import type {
+  ProjectPlanningDecision,
+  ProjectPlanningEvaluation,
+  ProjectPlanningLanguageArtifact,
+  ProjectPlanningService,
+  ProjectPlanningState,
+  ProjectPlanningStatus,
+} from '@pellux/goodvibes-sdk/platform/knowledge/index';
+import type { Line } from '../types/grid.ts';
+import { BasePanel } from './base-panel.ts';
+import {
+  buildBodyText,
+  buildEmptyState,
+  buildKeyValueLine,
+  buildPanelLine,
+  buildPanelWorkspace,
+  DEFAULT_PANEL_PALETTE,
+  extendPalette,
+  resolveScrollablePanelSection,
+  type PanelWorkspaceSection,
+} from './polish.ts';
+
+const C = extendPalette(DEFAULT_PANEL_PALETTE, {
+  planning: '#38bdf8',
+  blocked: '#f97316',
+  approved: '#22c55e',
+  rejected: '#ef4444',
+});
+
+interface ProjectPlanningPanelSnapshot {
+  readonly status: ProjectPlanningStatus | null;
+  readonly state: ProjectPlanningState | null;
+  readonly evaluation: ProjectPlanningEvaluation | null;
+  readonly decisions: readonly ProjectPlanningDecision[];
+  readonly language: ProjectPlanningLanguageArtifact | null;
+}
+
+export interface ProjectPlanningPanelOptions {
+  readonly service: ProjectPlanningService;
+  readonly projectId: string;
+  readonly requestRender?: () => void;
+}
+
+export class ProjectPlanningPanel extends BasePanel {
+  private readonly service: ProjectPlanningService;
+  private readonly projectId: string;
+  private readonly requestRender: () => void;
+  private snapshot: ProjectPlanningPanelSnapshot | null = null;
+  private loading = false;
+  private scrollOffset = 0;
+
+  public constructor(options: ProjectPlanningPanelOptions) {
+    super('project-planning', 'Planning', 'P', 'agent');
+    this.service = options.service;
+    this.projectId = options.projectId;
+    this.requestRender = options.requestRender ?? (() => {});
+  }
+
+  public override onActivate(): void {
+    super.onActivate();
+    this.refresh();
+  }
+
+  public handleInput(key: string): boolean {
+    if (key === 'r' || key === 'R') {
+      this.refresh(true);
+      return true;
+    }
+    if (key === 'a' || key === 'A') {
+      this.approveExecution();
+      return true;
+    }
+    if (key === 'up' || key === 'k') {
+      this.scrollOffset = Math.max(0, this.scrollOffset - 1);
+      this.markDirty();
+      return true;
+    }
+    if (key === 'down' || key === 'j') {
+      this.scrollOffset += 1;
+      this.markDirty();
+      return true;
+    }
+    return false;
+  }
+
+  public render(width: number, height: number): Line[] {
+    return this.trackedRender(() => {
+      if (!this.snapshot && !this.loading) this.refresh();
+
+      const sections: PanelWorkspaceSection[] = [];
+      const status = this.snapshot?.status;
+      const state = this.snapshot?.state;
+      const evaluation = this.snapshot?.evaluation ?? null;
+      const language = this.snapshot?.language ?? null;
+      const decisions = this.snapshot?.decisions ?? [];
+
+      sections.push({
+        title: 'Workspace',
+        lines: [
+          buildKeyValueLine(width, [
+            { label: 'project', value: this.projectId, valueColor: C.planning },
+            { label: 'space', value: status?.knowledgeSpaceId ?? `project:${this.projectId}`, valueColor: C.value },
+            { label: 'mode', value: 'TUI-owned passive backing store', valueColor: C.info },
+          ], C),
+          buildPanelLine(width, [
+            [' Planning never starts from daemon, webhooks, ntfy, Home Assistant, or companion surfaces.', C.dim],
+          ]),
+        ],
+      });
+
+      if (!state) {
+        sections.push({
+          title: 'No Active Planning State',
+          lines: buildEmptyState(
+            width,
+            'No project planning state has been saved for this workspace.',
+            'Describe the intended change in normal chat to let the TUI start the planning interview. The SDK only stores and evaluates artifacts.',
+            [],
+            C,
+          ),
+        });
+      } else {
+        sections.push(this.buildStateSection(width, state, evaluation));
+        sections.push(this.buildGapsSection(width, evaluation));
+        sections.push(this.buildTasksSection(width, state));
+        sections.push(this.buildDecisionsSection(width, state, decisions));
+        sections.push(this.buildLanguageSection(width, language));
+      }
+
+      if (this.lastError) {
+        const line = this.renderErrorLine(width);
+        if (line) sections.push({ title: 'Error', lines: [line] });
+      }
+
+      const flattened = sections.flatMap((section) => [
+        ...(section.title ? [buildPanelLine(width, [[` ${section.title}`, C.label]])] : []),
+        ...section.lines,
+      ]);
+      const scroll = resolveScrollablePanelSection(width, height, {
+        intro: 'Project planning state, readiness gaps, decisions, language, task graph, verification gates, and agent handoff metadata.',
+        footerLines: this.footerLines(width),
+        palette: C,
+        section: {
+          title: 'Project Planning',
+          scrollableLines: flattened,
+          selectedIndex: 0,
+          scrollOffset: this.scrollOffset,
+          minRows: 8,
+        },
+      });
+      this.scrollOffset = scroll.scrollOffset;
+
+      return buildPanelWorkspace(width, height, {
+        title: this.loading ? 'Project Planning - loading' : 'Project Planning',
+        intro: 'Passive SDK-backed planning artifacts for the current workspace. Conversation control stays inside this TUI.',
+        sections: [scroll.section],
+        footerLines: this.footerLines(width),
+        palette: C,
+      });
+    });
+  }
+
+  private footerLines(width: number): Line[] {
+    return [
+      buildPanelLine(width, [
+        [' Up/Down', C.info],
+        [' scroll  ', C.dim],
+        ['r', C.info],
+        [' refresh  ', C.dim],
+        ['a', C.info],
+        [' approve execution-ready plan  Esc close panel focus', C.dim],
+      ]),
+    ];
+  }
+
+  private buildStateSection(
+    width: number,
+    state: ProjectPlanningState,
+    evaluation: ProjectPlanningEvaluation | null,
+  ): PanelWorkspaceSection {
+    const readiness = evaluation?.readiness ?? state.readiness;
+    const readinessColor = readiness === 'executable'
+      ? C.approved
+      : readiness === 'needs-user-input'
+      ? C.blocked
+      : C.dim;
+    const lines: Line[] = [
+      buildKeyValueLine(width, [
+        { label: 'readiness', value: readiness, valueColor: readinessColor },
+        { label: 'approved', value: state.executionApproved ? 'yes' : 'no', valueColor: state.executionApproved ? C.approved : C.blocked },
+        { label: 'questions', value: `${state.openQuestions.length} open / ${state.answeredQuestions.length} answered`, valueColor: C.value },
+      ], C),
+      ...buildBodyText(width, `Goal: ${state.goal || '(not set)'}`, C, state.goal ? C.value : C.blocked),
+    ];
+    if (state.scope) lines.push(...buildBodyText(width, `Scope: ${state.scope}`, C, C.value));
+    if (state.knownContext.length) {
+      lines.push(...buildBodyText(width, `Known context: ${state.knownContext.join(' | ')}`, C, C.dim));
+    }
+    if (evaluation?.nextQuestion) {
+      lines.push(...buildBodyText(width, `Next question: ${evaluation.nextQuestion.prompt}`, C, C.planning));
+      if (evaluation.nextQuestion.whyItMatters) {
+        lines.push(...buildBodyText(width, `Why it matters: ${evaluation.nextQuestion.whyItMatters}`, C, C.dim));
+      }
+      if (evaluation.nextQuestion.recommendedAnswer) {
+        lines.push(...buildBodyText(width, `Recommended answer: ${evaluation.nextQuestion.recommendedAnswer}`, C, C.good));
+      }
+    }
+    return { title: 'State', lines };
+  }
+
+  private buildGapsSection(width: number, evaluation: ProjectPlanningEvaluation | null): PanelWorkspaceSection {
+    const gaps = evaluation?.gaps ?? [];
+    if (gaps.length === 0) {
+      return {
+        title: 'Readiness Gaps',
+        lines: [buildPanelLine(width, [[' No readiness gaps.', C.good]])],
+      };
+    }
+    return {
+      title: 'Readiness Gaps',
+      lines: gaps.slice(0, 12).flatMap((gap) => buildBodyText(
+        width,
+        `${gap.severity.toUpperCase()} ${gap.kind}: ${gap.message}`,
+        C,
+        gap.severity === 'blocking' ? C.blocked : C.warn,
+      )),
+    };
+  }
+
+  private buildTasksSection(width: number, state: ProjectPlanningState): PanelWorkspaceSection {
+    const lines: Line[] = [];
+    if (state.tasks.length === 0) {
+      lines.push(buildPanelLine(width, [[' No decomposed tasks recorded yet.', C.dim]]));
+    } else {
+      for (const task of state.tasks) {
+        lines.push(...buildBodyText(
+          width,
+          `${task.id}: ${task.title} [${task.status ?? 'pending'}]${task.canRunConcurrently ? ' - concurrent' : ''}`,
+          C,
+          task.blockedOnUserInput ? C.blocked : C.value,
+        ));
+        if (task.dependencies?.length) lines.push(...buildBodyText(width, `Dependencies: ${task.dependencies.join(', ')}`, C, C.dim));
+        if (task.verification?.length) lines.push(...buildBodyText(width, `Verification: ${task.verification.join(' | ')}`, C, C.good));
+      }
+    }
+
+    if (state.verificationGates.length) {
+      lines.push(buildPanelLine(width, [[' Verification gates:', C.label]]));
+      for (const gate of state.verificationGates) {
+        lines.push(...buildBodyText(width, `${gate.id}: ${gate.description} [${gate.status ?? 'pending'}]`, C, gate.required === false ? C.dim : C.good));
+      }
+    }
+    if (state.agentAssignments.length) {
+      lines.push(buildPanelLine(width, [[' Agent handoff candidates:', C.label]]));
+      for (const assignment of state.agentAssignments) {
+        lines.push(...buildBodyText(
+          width,
+          `${assignment.taskId}: ${assignment.agentType ?? 'none'}${assignment.canRunConcurrently ? ' - can run concurrently' : ''}`,
+          C,
+          C.info,
+        ));
+      }
+    }
+    return { title: 'Task Graph', lines };
+  }
+
+  private buildDecisionsSection(
+    width: number,
+    state: ProjectPlanningState,
+    storedDecisions: readonly ProjectPlanningDecision[],
+  ): PanelWorkspaceSection {
+    const byId = new Map<string, ProjectPlanningDecision>();
+    for (const decision of [...storedDecisions, ...state.decisions]) byId.set(decision.id, decision);
+    const decisions = [...byId.values()];
+    if (decisions.length === 0) {
+      return {
+        title: 'Decisions',
+        lines: [buildPanelLine(width, [[' No durable planning decisions recorded yet.', C.dim]])],
+      };
+    }
+    return {
+      title: 'Decisions',
+      lines: decisions.slice(0, 12).flatMap((decision) => buildBodyText(
+        width,
+        `${decision.title}: ${decision.decision} [${decision.status ?? 'accepted'}]`,
+        C,
+        decision.status === 'rejected' ? C.rejected : C.value,
+      )),
+    };
+  }
+
+  private buildLanguageSection(width: number, language: ProjectPlanningLanguageArtifact | null): PanelWorkspaceSection {
+    if (!language || (language.terms.length === 0 && language.ambiguities.length === 0)) {
+      return {
+        title: 'Project Language',
+        lines: [buildPanelLine(width, [[' No project language terms or ambiguity resolutions recorded yet.', C.dim]])],
+      };
+    }
+    const lines: Line[] = [];
+    for (const term of language.terms.slice(0, 8)) {
+      lines.push(...buildBodyText(width, `${term.term}: ${term.definition}`, C, C.value));
+      if (term.avoid?.length) lines.push(...buildBodyText(width, `Avoid: ${term.avoid.join(', ')}`, C, C.blocked));
+    }
+    for (const ambiguity of language.ambiguities.slice(0, 8)) {
+      lines.push(...buildBodyText(width, `Resolved ambiguity - ${ambiguity.phrase}: ${ambiguity.resolution}`, C, C.info));
+    }
+    return { title: 'Project Language', lines };
+  }
+
+  private refresh(force = false): void {
+    if (this.loading && !force) return;
+    this.loading = true;
+    this.markDirty();
+    this.requestRender();
+    void (async () => {
+      try {
+        const [status, stateResult, decisionsResult, languageResult] = await Promise.all([
+          this.service.status({ projectId: this.projectId }),
+          this.service.getState({ projectId: this.projectId }),
+          this.service.listDecisions({ projectId: this.projectId }),
+          this.service.getLanguage({ projectId: this.projectId }),
+        ]);
+        const evaluation = await this.service.evaluate({ projectId: this.projectId });
+        this.snapshot = {
+          status,
+          state: stateResult.state,
+          evaluation,
+          decisions: decisionsResult.decisions,
+          language: languageResult.language,
+        };
+        this.clearError();
+      } catch (err) {
+        this.setError(err instanceof Error ? err.message : String(err));
+      } finally {
+        this.loading = false;
+        this.markDirty();
+        this.requestRender();
+      }
+    })();
+  }
+
+  private approveExecution(): void {
+    const state = this.snapshot?.state;
+    if (!state) {
+      this.setError('No planning state exists to approve.');
+      this.requestRender();
+      return;
+    }
+    void (async () => {
+      try {
+        await this.service.upsertState({
+          projectId: this.projectId,
+          state: {
+            ...state,
+            executionApproved: true,
+            metadata: {
+              ...(state.metadata ?? {}),
+              approvedFrom: 'project-planning-panel',
+              approvedAt: Date.now(),
+            },
+          },
+        });
+        this.refresh(true);
+      } catch (err) {
+        this.setError(err instanceof Error ? err.message : String(err));
+        this.requestRender();
+      }
+    })();
+  }
+}

package/src/planning/project-planning-coordinator.ts

@@ -0,0 +1,249 @@
+import type {
+  ProjectPlanningEvaluation,
+  ProjectPlanningQuestion,
+  ProjectPlanningService,
+  ProjectPlanningState,
+} from '@pellux/goodvibes-sdk/platform/knowledge/index';
+
+export interface ProjectPlanningCoordinatorOptions {
+  readonly service: ProjectPlanningService;
+  readonly projectId: string;
+  readonly workingDirectory: string;
+  readonly openPanel?: () => void;
+  readonly notify?: (message: string) => void;
+  readonly now?: () => number;
+}
+
+export interface ProjectPlanningTurnPreparation {
+  readonly systemMessage: string;
+  readonly state: ProjectPlanningState;
+  readonly evaluation: ProjectPlanningEvaluation;
+}
+
+const PLANNING_INTENT_PATTERNS: readonly RegExp[] = [
+  /\b(plan|planning)\b/i,
+  /\bimplementation (plan|strategy)\b/i,
+  /\bexecution (plan|strategy)\b/i,
+  /\bdependency graph\b/i,
+  /\bbreak (this|it|that|the work) down\b/i,
+  /\bbefore (coding|implementing|we start|execution)\b/i,
+  /\bagent (handoff|assignment|assignments)\b/i,
+  /\bverification gates?\b/i,
+  /\binterview (me|loop)\b/i,
+];
+
+const CANCEL_PATTERNS: readonly RegExp[] = [
+  /\b(stop|cancel|pause|exit) (the )?planning\b/i,
+  /\bplanning (is )?(done|cancelled|canceled|paused)\b/i,
+];
+
+const APPROVAL_PATTERNS: readonly RegExp[] = [
+  /\b(approve|approved|approval granted)\b/i,
+  /\b(go ahead|execute this plan|start execution|ready to execute)\b/i,
+];
+
+export function hasProjectPlanningIntent(text: string): boolean {
+  const trimmed = text.trim();
+  if (!trimmed || trimmed.startsWith('/')) return false;
+  return PLANNING_INTENT_PATTERNS.some((pattern) => pattern.test(trimmed));
+}
+
+export class ProjectPlanningCoordinator {
+  private readonly service: ProjectPlanningService;
+  private readonly projectId: string;
+  private readonly workingDirectory: string;
+  private readonly openPanel: () => void;
+  private readonly notify: (message: string) => void;
+  private readonly now: () => number;
+
+  public constructor(options: ProjectPlanningCoordinatorOptions) {
+    this.service = options.service;
+    this.projectId = options.projectId;
+    this.workingDirectory = options.workingDirectory;
+    this.openPanel = options.openPanel ?? (() => {});
+    this.notify = options.notify ?? (() => {});
+    this.now = options.now ?? (() => Date.now());
+  }
+
+  public async prepareTurn(text: string): Promise<ProjectPlanningTurnPreparation | null> {
+    const prompt = text.trim();
+    if (!prompt || prompt.startsWith('!') || prompt.startsWith('/')) return null;
+
+    const stateResult = await this.service.getState({ projectId: this.projectId });
+    const existing = stateResult.state;
+    const active = this.isActive(existing);
+    const startsPlanning = hasProjectPlanningIntent(prompt);
+
+    if (this.isCancel(prompt)) {
+      if (existing) {
+        await this.service.upsertState({
+          projectId: this.projectId,
+          state: {
+            ...existing,
+            metadata: {
+              ...(existing.metadata ?? {}),
+              active: false,
+              pausedAt: this.now(),
+            },
+          },
+        });
+        this.notify('[Planning] Paused project planning for this workspace.');
+      }
+      return null;
+    }
+
+    if (!active && !startsPlanning) return null;
+
+    const answeredQuestion = active ? this.firstOpenQuestion(existing) : null;
+    const stateDraft = this.buildStateDraft(existing, prompt, {
+      startsPlanning,
+      answeredQuestion,
+      approved: this.isApproval(prompt),
+    });
+
+    const firstEvaluation = await this.service.evaluate({
+      projectId: this.projectId,
+      state: stateDraft,
+    });
+    const withNextQuestion = this.recordNextQuestion(stateDraft, firstEvaluation.nextQuestion);
+    const normalized = await this.service.evaluate({
+      projectId: this.projectId,
+      state: withNextQuestion,
+    });
+    const saved = await this.service.upsertState({
+      projectId: this.projectId,
+      state: normalized.state,
+    });
+    const state = saved.state ?? normalized.state;
+    const evaluation = await this.service.evaluate({
+      projectId: this.projectId,
+      state,
+    });
+
+    this.openPanel();
+    return {
+      systemMessage: this.buildSystemMessage(state, evaluation),
+      state,
+      evaluation,
+    };
+  }
+
+  private buildStateDraft(
+    existing: ProjectPlanningState | null,
+    prompt: string,
+    options: {
+      readonly startsPlanning: boolean;
+      readonly answeredQuestion: ProjectPlanningQuestion | null;
+      readonly approved: boolean;
+    },
+  ): Partial<ProjectPlanningState> {
+    const now = this.now();
+    const openQuestions = [...(existing?.openQuestions ?? [])];
+    const answeredQuestions = [...(existing?.answeredQuestions ?? [])];
+    if (options.answeredQuestion) {
+      const idx = openQuestions.findIndex((question) => question.id === options.answeredQuestion?.id);
+      if (idx >= 0) openQuestions.splice(idx, 1);
+      answeredQuestions.push({
+        ...options.answeredQuestion,
+        status: 'answered',
+        answer: prompt,
+        answeredAt: now,
+      });
+    }
+
+    const knownContext = new Set(existing?.knownContext ?? []);
+    knownContext.add(`Workspace: ${this.workingDirectory}`);
+    if (options.startsPlanning && existing?.goal && prompt !== existing.goal) {
+      knownContext.add(`Latest planning request: ${prompt}`);
+    }
+
+    return {
+      ...(existing ?? {}),
+      projectId: this.projectId,
+      goal: existing?.goal?.trim() ? existing.goal : prompt,
+      knownContext: [...knownContext],
+      openQuestions,
+      answeredQuestions,
+      executionApproved: existing?.executionApproved === true || options.approved,
+      metadata: {
+        ...(existing?.metadata ?? {}),
+        active: true,
+        owner: 'tui',
+        source: 'conversation',
+        lastPromptAt: now,
+      },
+    };
+  }
+
+  private 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,
+    };
+  }
+
+  private buildSystemMessage(
+    state: ProjectPlanningState,
+    evaluation: ProjectPlanningEvaluation,
+  ): string {
+    const nextQuestion = evaluation.nextQuestion;
+    const gaps = evaluation.gaps
+      .slice(0, 8)
+      .map((gap) => `- ${gap.severity}: ${gap.kind} - ${gap.message}`)
+      .join('\n') || '- none';
+    const tasks = state.tasks
+      .map((task) => `- ${task.id}: ${task.title}`)
+      .join('\n') || '- none recorded yet';
+
+    return [
+      'TUI-owned project planning loop is active for this turn.',
+      'Do not execute code changes, spawn agents, or claim implementation is complete unless the user explicitly approves execution after the plan is structurally ready.',
+      'Be relentless and thorough: challenge vague wording, inspect relevant context before proposing execution, and ask exactly one focused question when information is missing.',
+      'Prefer concrete examples and recommended answers so the user can answer quickly.',
+      '',
+      `Project id: ${this.projectId}`,
+      `Knowledge space: ${state.knowledgeSpaceId}`,
+      `Readiness: ${evaluation.readiness}`,
+      `Execution approved: ${state.executionApproved ? 'yes' : 'no'}`,
+      `Goal: ${state.goal || '(missing)'}`,
+      state.scope ? `Scope: ${state.scope}` : 'Scope: (missing)',
+      '',
+      'Readiness gaps:',
+      gaps,
+      '',
+      'Recorded tasks:',
+      tasks,
+      '',
+      nextQuestion
+        ? `Ask this exact next planning question unless the user already answered it: ${nextQuestion.prompt}`
+        : 'If the plan is structurally ready, summarize the plan and ask for explicit execution approval. Do not start execution yourself.',
+    ].join('\n');
+  }
+
+  private isActive(state: ProjectPlanningState | null): boolean {
+    return state?.metadata?.['active'] === true && state.executionApproved !== true;
+  }
+
+  private firstOpenQuestion(state: ProjectPlanningState | null): ProjectPlanningQuestion | null {
+    return state?.openQuestions.find((question) => (question.status ?? 'open') === 'open') ?? null;
+  }
+
+  private isCancel(text: string): boolean {
+    return CANCEL_PATTERNS.some((pattern) => pattern.test(text));
+  }
+
+  private isApproval(text: string): boolean {
+    return APPROVAL_PATTERNS.some((pattern) => pattern.test(text));
+  }
+}

package/src/renderer/compositor.ts

@@ -3,6 +3,7 @@ import { DiffEngine } from './diff.ts';
 import { type Line, createEmptyCell, createStyledCell } from '../types/grid.ts';
 import { getDisplayWidth } from '../utils/terminal-width.ts';
 import type { SearchManager } from '../input/search.ts';
+import { allowTerminalWrite } from '../runtime/terminal-output-guard.ts';
 
 export interface SelectionInfo {
   isCellSelected: (col: number, absoluteRow: number) => boolean;
@@ -270,7 +271,7 @@ export class Compositor {
     // R3: Diff against front-buffer (last-rendered), then swap front/back — no clone() needed
     const diff = this.diffEngine.diff(this.frontBuffer, newBuffer);
     if (diff) {
-      this.stdout.write(diff);
+      allowTerminalWrite(() => this.stdout.write(diff));
     }
 
     // Swap: back (just written) becomes the new front reference; old front becomes the next back