@buildaharness/aielia 0.3.2 → 0.3.4

package/README.md

@@ -99,7 +99,7 @@ silently starting over.
 
 Net effect: one real LLM call per ordinary turn, zero for a blocked one, and
 every layer of the harness touched on the ones that do run — matching what
-[buildaharness.com/harness-comparison](https://buildaharness.com/harness-comparison)
+[myaielia.com/harness-comparison](https://myaielia.com/harness-comparison)
 calls out as missing from Hermes Agent, Kilo Code, and OpenClaw: none of them
 ships a formal Control State resolver *and* a Reviewer/output gate together.
 <!--

package/dist/agent-loop.d.ts

@@ -196,6 +196,14 @@ export declare class AgentLoop {
         onToolStep?: (step: AssistantToolStep) => void;
         onUsage?: (usage: TokenUsage) => void;
         riskHint?: TurnIntentClassification['riskLevel'];
+        /**
+         * Mid-turn steering (goalGraphMode): messages the user sent while this turn runs that the
+         * scope×urgency classifier judged apply to the answer being produced right now. Called once
+         * per iteration, immediately before the LLM call; anything returned is spliced in as a user
+         * turn so the model itself applies it — no lexical matching, unlike the harness's
+         * caller-constraint output contract.
+         */
+        takeSteeringNotes?: () => string[];
     }): (toolCtx: ToolExecutorContext) => Promise<unknown>;
     /**
      * R3 of the internal plan: the wiring-level counterpart to
@@ -208,7 +216,7 @@ export declare class AgentLoop {
      * back whatever got pushed to it once the harness run using this proposer has finished (mirrors
      * `ToolLoopResult`'s `sources` field on the flag-OFF path).
      */
-    createOneLoopProposer(sessionId: string, transcript: ChatMessage[], userMessage: string, systemPrompt: string, onToken?: (token: string) => void, onToolStep?: (step: AssistantToolStep) => void, onUsage?: (usage: TokenUsage) => void, riskHint?: TurnIntentClassification['riskLevel']): {
+    createOneLoopProposer(sessionId: string, transcript: ChatMessage[], userMessage: string, systemPrompt: string, onToken?: (token: string) => void, onToolStep?: (step: AssistantToolStep) => void, onUsage?: (usage: TokenUsage) => void, riskHint?: TurnIntentClassification['riskLevel'], takeSteeringNotes?: () => string[]): {
         proposer: (toolCtx: ToolExecutorContext) => Promise<unknown>;
         sources: AssistantSource[];
     };

package/dist/assistant-session.d.ts

@@ -99,8 +99,8 @@ export declare class AssistantSession {
      * isn't set.
      */
     recordSpend(sessionId: string, usage: TokenUsage | undefined): Promise<void>;
-    /** Read-only — null means plan mode has never been entered (or was already exited/cancelled) for this session. */
-    getPlanModeState(sessionId: string): Promise<PlanModeState | null>;
+    /** Read-only — null means plan mode has never been entered (or was already exited/cancelled) for this session (or this `threadId`, once Phase 5's per-thread rescoping applies — see `planModeKey`). */
+    getPlanModeState(sessionId: string, threadId?: string): Promise<PlanModeState | null>;
     /**
      * The one place `planMode.active` ever flips true — a fresh `draftId` per entry, even if a
      * prior drafting session was cancelled without ever reaching approval, so a stale draftId can
@@ -108,9 +108,9 @@ export declare class AssistantSession {
      * a new state, same as a fresh entry) — callers that only ever call this once per drafting
      * session (P3's future auto-trigger) never observe that.
      */
-    enterPlanMode(sessionId: string): Promise<PlanModeState>;
+    enterPlanMode(sessionId: string, threadId?: string): Promise<PlanModeState>;
     /** Clears `planMode.active` — the only two designed callers are an explicit cancel phrase (PlanDraftingService) and P2's future approval resolution. */
-    exitPlanMode(sessionId: string): Promise<void>;
+    exitPlanMode(sessionId: string, threadId?: string): Promise<void>;
     /** The session's conversation transcript, oldest first — same array `turn()` reads/appends to. Used by `/export`. */
     getTranscript(sessionId: string): Promise<ChatMessage[]>;
     /**

package/dist/assistant-types.d.ts

@@ -1,3 +1,4 @@
+import { NextStepSuggestion } from './next-step-proposer.js';
 import { RiskState, LayerActivityEvent, AskQuestion } from '@buildaharness/harness';
 import { TokenUsage } from '@buildaharness/runtime';
 import { AnswerClaim } from './answer-claim.js';
@@ -63,6 +64,13 @@ export interface AssistantTurnResult {
      */
     status: 'ok' | 'needs_approval' | 'escalated' | 'needs_clarification' | 'needs_plan_approval';
     reply: string | null;
+    /**
+     * Up to three concrete next steps proposed after a full (non-trivial, `ok`) turn, most confident
+     * first — for the front end to show under the reply. Advisory only: never executed, never
+     * persisted from here. Present only when the caller enabled `goalGraphSuggestMode`
+     * (PersonalAssistantOptions) and the proposer returned at least one; absent otherwise.
+     */
+    nextSteps?: NextStepSuggestion[];
     reason?: string;
     /** See ProposerKind. Always set (defaults to 'posthoc'), on every status. */
     proposerKind?: ProposerKind;

package/dist/assistant.d.ts

@@ -16,11 +16,15 @@ import { PlanRecord } from './plan-store.js';
 import { OneLoopMode } from './one-loop-flag.js';
 import { AskMode } from './ask-mode-flag.js';
 import { PlanRolloutMode } from './plan-mode-flag.js';
+import { GoalGraphSuggestMode } from './goal-graph-suggest-flag.js';
+import { GoalGraphState } from './goal-graph-service.js';
+import { LiveSteeringChannel } from './live-steering-channel.js';
 import { DebugLogEntry } from './debug-log.js';
 import { AssistantTurnResult, AssistantProgress } from './assistant-types.js';
 export type { MemorySummary, MemoryExport, PendingFact } from './memory-service.js';
 export type { FactCategory } from './turn-intent-classifier.js';
 export type { IndexedMessage, TranscriptSearchHit } from './assistant-session.js';
+export type { GoalGraphState, GoalThreadView, GoalThreadVisibility, GoalTaskSummary } from './goal-graph-service.js';
 export type { BatchBudgetState } from './agent-loop.js';
 export { trimmedAverage, nextItemBudget } from './agent-loop.js';
 export type { AssistantSource } from './assistant-source.js';
@@ -105,6 +109,21 @@ export interface TurnOptions {
         seedFailures: number;
         onInjected?: () => void;
     };
+    /**
+     * Phase 4 of plans/hierarchical_goal_tree_and_steering_plan.html (R1/R4) — the session-scoped
+     * LiveSteeringChannel a caller (cli.ts/App.tsx, Phase 3) built for mid-task steering. When
+     * present, `turn()` wraps it in a scope×urgency-classifying UpdateChannel
+     * (goal-graph-reconcile.ts) and threads it into harnessBridge.run() so queued messages are
+     * absorbed at the harness's own checkCallerUpdates iteration boundary instead of waiting for
+     * the turn to finish. PersonalAssistant never reads goalGraphMode itself (same convention as
+     * oneLoopMode/askMode/planMode) — the caller decides whether to pass this at all; when absent,
+     * behavior is exactly today's (INV-43). Whatever this turn's harness run doesn't get around to
+     * classifying (it ends before the queue drains, or never calls harnessBridge.run() at all — a
+     * trivial turn) is pushed back onto this same channel in a `finally`, so the caller's own
+     * post-turn fallback drain (built in Phase 3) still picks it up — R4's "never silently drop"
+     * holds either way.
+     */
+    steeringChannel?: LiveSteeringChannel;
 }
 export interface PersonalAssistantOptions {
     llmClient: ILLMClient;
@@ -207,6 +226,16 @@ export interface PersonalAssistantOptions {
      * call resolveOneLoopMode(process.env) and pass the result here.
      */
     oneLoopMode?: OneLoopMode;
+    /**
+     * R7 (Tier 1.5) — next-step suggestions, one bounded LLM call each: after every full
+     * (non-trivial, `ok`) turn, up to three options are attached to the result as `nextSteps` for
+     * the front end to show under the reply; and when a GoalThread finishes its last task, its own
+     * suggestions are persisted on the thread for `/goals`. Defaults to 'disabled' — like
+     * oneLoopMode/askMode/planMode, the front end resolves the flag (cli.ts / App.tsx pass
+     * `config.goalGraphSuggestMode`, which defaults to enabled), so a library or benchmark caller
+     * that never asks for suggestions makes no extra call and sees no new field (INV-43).
+     */
+    goalGraphSuggestMode?: GoalGraphSuggestMode;
     /**
      * Q2 of the internal plan — global-flag control point (tier 1 of
      * INV-29) for the ask-question mechanism. Undefined (the default) falls back to
@@ -269,6 +298,8 @@ export declare class PersonalAssistant {
      * the internal plan phase B1.
      */
     private lastProposerKind;
+    /** See PersonalAssistantOptions.goalGraphSuggestMode. */
+    private readonly goalGraphSuggestMode;
     private readonly memoryService;
     private readonly session;
     private readonly agentLoop;
@@ -330,6 +361,14 @@ export declare class PersonalAssistant {
      * all). Returns `null` when no plan record exists for this session yet.
      */
     getPlanState(sessionId: string): Promise<PlanRecord | null>;
+    /**
+     * Phase 7 of plans/hierarchical_goal_tree_and_steering_plan.html (R5, "Visibility") — the shared
+     * read surface behind the CLI's `/goals` and chat-ui's GoalsPanel, analogous to `searchTranscript`
+     * above. A pure query over whatever Phases 4-5 already populate in this session's
+     * `GoalGraphRecord`; never mints or mutates one. Returns the empty state for a session with no
+     * goal graph yet, same "nothing to show" convention `getGoalGraphState` itself documents.
+     */
+    getGoalGraphState(sessionId: string): Promise<GoalGraphState>;
     /**
      * P9 of the internal plan — the lightweight plan-sketch delegate: a
      * cheaper "just go research and draft an approach" path than plan mode's durable task-graph

package/dist/{bin-CqkqT6KK.js → bin-CdVTAe7j.js}

@@ -8,7 +8,7 @@ import { homedir, tmpdir } from "node:os";
 import { join, dirname, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { OPENROUTER_DEFAULT_MODEL, OPENAI_DEFAULT_MODEL, ANTHROPIC_DEFAULT_MODEL, InMemoryReminderStore, FileSystemAdapter, FileSystemExperienceStore, LLMClient, OpenAICompatibleLLMClient, OPENROUTER_EXTRA_HEADERS, OPENROUTER_BASE_URL, OPENAI_BASE_URL, AnthropicLLMClient } from "@buildaharness/runtime";
-import { x as buildClaudePrompt, aE as stripJsonCodeFence, a as ALREADY_STAGED_ACTION_TOOL, aD as stagedActionInput, ar as parseClaudeCliOutput, aF as stripMcpToolPrefix, V as envOverridesFromProcessEnv, aw as resolveConfig, aB as shouldLaunchTuiApp, aI as validateConfig, c as ConfigValidationError, aa as formatSpendCapStatus, n as PersonalAssistant, w as braveSearch, N as createSmtpSender, M as createResendSender, z as classifyError, an as nodeToLayer, L as LAYER_DISPLAY_NAME, am as nodeDisplayName, X as estimateCostUsd, a0 as formatConfigListing, ae as isConfigKey, C as CONFIG_KEYS, E as ENV_VAR_FOR_CONFIG_KEY, as as parseConfigValue, d as ConfigValueParseError, a2 as formatDoctorReport, a1 as formatCostSummary, a9 as formatSearchResults, ad as formatUndoLogListing, O as defaultExportFilename, ac as formatTranscriptMarkdown, ab as formatStatus, a4 as formatHelp, k as LAYER_ORDER, y as buildWhyChain, l as LAYER_SHORT_CODE, Q as defaultMemoryExportFilename, a5 as formatMemoryExport, a6 as formatMemoryPendingOutcome, a7 as formatMemorySummary } from "./cli-session-BiX2DOni.js";
+import { G as buildClaudePrompt, aT as stripJsonCodeFence, a as ALREADY_STAGED_ACTION_TOOL, aS as stagedActionInput, aE as parseClaudeCliOutput, aU as stripMcpToolPrefix, P as PROVIDER_SETUP, Q as cleanApiKey, J as checkApiKeyFormat, a0 as envOverridesFromProcessEnv, aJ as resolveConfig, aQ as shouldLaunchTuiApp, aW as testApiKey, aY as validateConfig, c as ConfigValidationError, ai as formatSpendCapStatus, r as PersonalAssistant, ap as isGoalGraphSuggestEnabled, ao as isGoalGraphEnabled, B as braveSearch, X as createSmtpSender, V as createResendSender, p as LiveSteeringChannel, af as formatNextSteps, K as classifyError, ay as nodeToLayer, L as LAYER_DISPLAY_NAME, ax as nodeDisplayName, a1 as estimateCostUsd, a6 as formatConfigListing, an as isConfigKey, C as CONFIG_KEYS, E as ENV_VAR_FOR_CONFIG_KEY, aF as parseConfigValue, d as ConfigValueParseError, a8 as formatDoctorReport, a7 as formatCostSummary, aa as formatGoalGraphState, ah as formatSearchResults, al as formatUndoLogListing, Y as defaultExportFilename, ak as formatTranscriptMarkdown, aj as formatStatus, ab as formatHelp, m as LAYER_ORDER, H as buildWhyChain, n as LAYER_SHORT_CODE, Z as defaultMemoryExportFilename, ac as formatMemoryExport, ad as formatMemoryPendingOutcome, ae as formatMemorySummary } from "./provider-setup-CPbB5y_V.js";
 import { spawn } from "node:child_process";
 import { createServer, connect } from "node:net";
 import { createRequire } from "node:module";
@@ -66,7 +66,7 @@ function createNodeFsBackend() {
     }
   };
 }
-const CLI_VERSION = "0.3.2";
+const CLI_VERSION = "0.3.4";
 function seaCacheDir(version, home = homedir()) {
   return join(home, ".buildaharness", "personal-assistant", "sea-cache", version);
 }
@@ -650,6 +650,7 @@ function resolveNonInteractiveApprovalMode(env) {
   console.error(`[warning] ASSISTANT_NON_INTERACTIVE_APPROVAL="${raw}" is not "decline" or "require-tty" — ignoring.`);
   return void 0;
 }
+const MAX_KEY_ATTEMPTS = 3;
 function alreadyConfigured(deps) {
   const { persisted, overriddenKeys } = deps;
   if (persisted.llmBackend !== void 0) return true;
@@ -659,50 +660,94 @@ function alreadyConfigured(deps) {
   }
   return false;
 }
-const PROVIDER_CHOICES = {
-  "1": { backend: "anthropic", label: "Anthropic (Claude) — needs an sk-ant-… key" },
-  "2": { backend: "openai", label: "OpenAI — needs an sk-… key" },
-  "3": { backend: "openrouter", label: "OpenRouter — needs an sk-or-… key" }
-};
 async function maybeRunFirstRunSetup(deps) {
-  const { configStore, persisted, isInteractive, ask, detectClaudeCli, log } = deps;
+  const { configStore, persisted, isInteractive, ask, detectClaudeCli, log, testKey } = deps;
   if (alreadyConfigured(deps)) return persisted;
   if (!isInteractive) return persisted;
   log("");
-  log("Welcome to Aielia — this looks like your first run. Let's pick how to reach a model.");
-  log("(You can change any of this later with /config, or skip with Ctrl+C.)");
+  log("Welcome to Aielia! 👋  Let’s get you set up — it takes about a minute.");
+  log("");
+  log("Aielia needs an AI model to think with. Pick where that comes from below.");
+  log("(You can change this any time with /config, or press Ctrl+C to skip.)");
   log("");
   const patch = {};
   if (await detectClaudeCli()) {
-    const useClaude = await ask(
-      "Found an authenticated `claude` CLI on your PATH. Use it? No API key needed. (Y/n) "
-    );
+    log("✓ Claude is already running on this computer (Claude Code is installed and signed in).");
+    log("  That means you can start right now — no API key, no extra account, nothing to paste.");
+    log("");
+    const useClaude = await ask("Use your Claude login? (Y/n — Enter means yes) ");
     if (useClaude === "" || useClaude.toLowerCase().startsWith("y")) {
       patch.llmBackend = "claude-cli";
       await configStore.save(patch);
       log("");
-      log('✓ Using the claude-cli backend. Try "what time zone is Tokyo in?", then');
+      log('✓ All set — using your Claude login. Try "what time zone is Tokyo in?", then');
       log('  "send an email to my boss saying I quit" to see the approval gate.');
       log("");
       return { ...persisted, ...patch };
     }
+    log("");
+  } else {
+    log("Tip: if you already use Claude Code, install it and sign in (run `claude` once), then");
+    log("start Aielia again — you can use it with no API key. Otherwise, pick a provider below.");
+    log("");
   }
-  log("Pick a provider to use with your own API key:");
-  for (const [key2, { label }] of Object.entries(PROVIDER_CHOICES)) log(`  ${key2}) ${label}`);
-  const choice = (await ask("Provider [1-3, or Enter to skip]: ")).trim();
-  const picked = PROVIDER_CHOICES[choice];
+  log("Which AI provider do you have (or want to use)?");
+  log("");
+  PROVIDER_SETUP.forEach((p, i) => {
+    log(`  ${i + 1}) ${p.name}`);
+    log(`     ${p.blurb}`);
+  });
+  log("");
+  const choice = (await ask(`Type 1-${PROVIDER_SETUP.length} and press Enter (or just Enter to skip): `)).trim();
+  const picked = PROVIDER_SETUP[Number(choice) - 1];
   if (!picked) {
     log("");
-    log('Skipped. The assistant will start on the "proxy" backend (needs @buildaharness/proxy');
-    log("on :8787). Run /config set llmBackend <anthropic|openai|openrouter> and");
-    log("/config set apiKey <key> when you are ready, or set ASSISTANT_LLM_BACKEND + ASSISTANT_API_KEY.");
+    log('Skipped. Until you set a provider, Aielia will try the "proxy" backend (needs');
+    log("@buildaharness/proxy running on :8787). To set one up later, run:");
+    log("  /config set llmBackend <anthropic|openai|openrouter>");
+    log("  /config set apiKey <your key>");
     log("");
     return persisted;
   }
-  const key = (await ask(`Paste your ${picked.backend} API key: `)).trim();
+  log("");
+  log(`To connect ${picked.name}, you need an “API key” — a password-like code that lets Aielia use your account.`);
+  log("Here’s how to get one:");
+  log("");
+  picked.steps.forEach((step, i) => log(`  ${i + 1}. ${step}`));
+  if (picked.safety) {
+    log("");
+    log(`  ${picked.safety.title}:`);
+    picked.safety.steps.forEach((step, i) => log(`     ${i + 1}. ${step}`));
+    log(`     (${picked.safety.urlLabel})`);
+  }
+  log("");
+  log(`The key starts with "${picked.keyPrefix}". Paste it below when you have it.`);
+  log("");
+  let key = "";
+  for (let attempt = 1; attempt <= MAX_KEY_ATTEMPTS; attempt++) {
+    const candidate = cleanApiKey(await ask("Paste your API key (or just Enter to skip): "));
+    if (candidate === "") break;
+    const formatProblem = checkApiKeyFormat(picked.backend, candidate);
+    if (formatProblem) {
+      log(`  ✗ ${formatProblem}`);
+      continue;
+    }
+    if (testKey) {
+      log("  Checking your key…");
+      const result = await testKey(picked.backend, candidate);
+      if (result.status === "invalid") {
+        log(`  ✗ ${result.message}`);
+        continue;
+      }
+      if (result.status === "unverified") log(`  ! ${result.message}`);
+    }
+    key = candidate;
+    break;
+  }
   if (!key) {
     log("");
-    log("No key entered — skipping. Set it later with /config set apiKey <key>.");
+    log("No working key entered, so nothing was saved. Run Aielia again to retry, or use");
+    log("/config set llmBackend " + picked.backend + "  then  /config set apiKey <key>");
     log("");
     return persisted;
   }
@@ -710,8 +755,9 @@ async function maybeRunFirstRunSetup(deps) {
   patch.apiKey = key;
   await configStore.save(patch);
   log("");
-  log(`✓ Saved. Using ${picked.backend}. The key is stored in plain text in your config file`);
-  log("  (~/.buildaharness/personal-assistant/config.json) — the same trust boundary as a .env.");
+  log(`✓ You’re all set — using ${picked.name}. Say hello!`);
+  log("  Your key is saved on this computer in ~/.buildaharness/personal-assistant/config.json");
+  log("  (plain text, like a .env file) — don’t share that file.");
   log("");
   return { ...persisted, ...patch };
 }
@@ -1088,6 +1134,10 @@ async function buildAssistant(config, { backend, dataDir, remindersFile }) {
     // chat-ui, and the Tauri desktop build all decide this the same way. Undefined here means
     // PersonalAssistant falls back to DEFAULT_ONE_LOOP_MODE.
     oneLoopMode: config.oneLoopMode,
+    // R7: turn-end next-step options and DONE-thread suggestions. Undefined config means the
+    // package default (enabled); PersonalAssistant itself defaults to disabled, so this is where
+    // the front end opts in.
+    goalGraphSuggestMode: isGoalGraphSuggestEnabled(config.goalGraphSuggestMode) ? "enabled" : "disabled",
     // P11 of the internal plan — resolved through the same shared config
     // seam as oneLoopMode above (ASSISTANT_PLAN_MODE / `/config set planMode`). Undefined here
     // means PersonalAssistant falls back to DEFAULT_PLAN_MODE ('legacy').
@@ -1095,6 +1145,7 @@ async function buildAssistant(config, { backend, dataDir, remindersFile }) {
   });
 }
 async function runCli(options = {}) {
+  console.log("Aielia is alpha software — expect rough edges and breaking changes. It uses AI models and can make mistakes; verify anything important.\n");
   const dataDir = options.dataDir ?? defaultDataDir;
   const configStore = options.configStore ?? defaultConfigStore;
   const backend = options.backend ?? defaultBackend;
@@ -1123,7 +1174,8 @@ async function runCli(options = {}) {
         ask: firstRunAsk,
         detectClaudeCli: options.detectClaudeCli ?? (async () => (await checkClaudeCli(process.env.CLAUDE_PATH ?? "claude")).ok),
         log: (line) => outputStream.write(`${line}
-`)
+`),
+        testKey: options.firstRunTestKey ?? ((backend2, key) => testApiKey(backend2, key))
       });
     } finally {
       setupRl == null ? void 0 : setupRl.close();
@@ -1495,6 +1547,12 @@ ${formatMemoryPendingOutcome("forgotten", outcome)}
     const hits = await assistant.searchTranscript(query);
     console.log(`
 ${formatSearchResults(hits, query)}
+`);
+  }
+  async function handleGoals() {
+    const state = await assistant.getGoalGraphState("cli");
+    console.log(`
+${formatGoalGraphState(state)}
 `);
   }
   async function printCost() {
@@ -1733,7 +1791,15 @@ Unrecognized input "${token}".
           if (!streamedAnyTokens) writeProgress(progress);
         },
         onToken: writeToken,
-        onToolStep: writeToolStep
+        onToolStep: writeToolStep,
+        // Phase 4 — real intra-turn absorption via checkCallerUpdates, replacing Phase 3's
+        // drain-as-follow-up-turns fallback in dispatchOne's `finally` below (kept there, but
+        // only as a backstop: turn() re-enqueues anything it didn't get around to classifying
+        // this turn — e.g. a trivial turn that never calls harnessBridge.run() at all — back onto
+        // this same channel, see TurnOptions.steeringChannel's doc comment). Passed unconditionally:
+        // with goalGraphMode off, routeMessage (below) never enqueues into steeringChannel, so it's
+        // always empty and this resolves to exactly today's behavior (INV-43).
+        steeringChannel
       });
       if (!streamedAnyTokens) clearProgress();
       if (result.status === "needs_approval" && result.pendingActionId) {
@@ -1803,16 +1869,20 @@ Unrecognized input "${token}".
       const contradictionNotice = result.contradictionNotice ? `
 
 ${result.contradictionNotice}` : "";
+      lastNextSteps = result.nextSteps && result.nextSteps.length > 0 ? result.nextSteps : void 0;
+      const nextStepsBlock = lastNextSteps ? `
+
+${formatNextSteps(lastNextSteps)}` : "";
       if (streamedAnyTokens) {
         const pausedNoteText = result.pausedNote ? `
 
 ${result.pausedNote}` : "";
-        process.stdout.write(`${pausedNoteText}${riskSuffix}${sourcesHint}${planHint}${contradictionNotice}
+        process.stdout.write(`${pausedNoteText}${riskSuffix}${sourcesHint}${planHint}${contradictionNotice}${nextStepsBlock}
 
 `);
       } else {
         console.log(`
-Aielia>${riskSuffix} ${result.reply}${sourcesHint}${planHint}${contradictionNotice}
+Aielia>${riskSuffix} ${result.reply}${sourcesHint}${planHint}${contradictionNotice}${nextStepsBlock}
 `);
       }
     } catch (err) {
@@ -1986,6 +2056,9 @@ ${assistant.getActiveProject() || "(none)"}
     }
     await handleConfigCommand(["set", "activeProject", args.join(" ")]);
   }
+  let turnInProgress = false;
+  let lastNextSteps;
+  const steeringChannel = new LiveSteeringChannel();
   const commands = {
     "/why": () => printWhy(),
     "/layers": () => printLayers(),
@@ -2000,6 +2073,7 @@ ${assistant.getActiveProject() || "(none)"}
     "/undo-action": (args) => handleUndoAction(args),
     "/memory": (args) => handleMemory(args),
     "/search": (args) => handleSearch(args),
+    "/goals": () => handleGoals(),
     "/model": (args) => handleModel(args),
     "/project": (args) => handleProject(args),
     "/cost": () => printCost(),
@@ -2008,13 +2082,29 @@ ${assistant.getActiveProject() || "(none)"}
     "/checkpoint": (args) => handleCheckpoint(args)
   };
   async function dispatchOne(message) {
+    const pick = /^[1-3]$/.test(message) && lastNextSteps ? lastNextSteps[Number(message) - 1] : void 0;
+    lastNextSteps = void 0;
+    if (pick) {
+      console.log(`  → ${pick.description}`);
+      message = pick.description;
+    }
     const [token, ...args] = message.split(/\s+/);
     const handler = commands[token];
     if (handler) {
       await handler(args);
       return;
     }
-    await handleTurn(message);
+    turnInProgress = true;
+    try {
+      await handleTurn(message);
+    } finally {
+      turnInProgress = false;
+      if (isGoalGraphEnabled(config.goalGraphMode)) {
+        for (const event of steeringChannel.poll()) {
+          void enqueue(event.message);
+        }
+      }
+    }
   }
   let dispatchQueue = Promise.resolve();
   function enqueue(message) {
@@ -2024,20 +2114,32 @@ ${assistant.getActiveProject() || "(none)"}
     dispatchQueue = result;
     return result;
   }
+  function isKnownCommand(message) {
+    const [token] = message.split(/\s+/);
+    return token in commands;
+  }
+  function routeMessage(message) {
+    if (isGoalGraphEnabled(config.goalGraphMode) && turnInProgress && !isKnownCommand(message)) {
+      steeringChannel.enqueue(message);
+      console.log("\n[queued — the current turn is still running; this will be taken into account once it finishes]\n");
+      return Promise.resolve();
+    }
+    return enqueue(message);
+  }
   rl.on("line", (line) => {
     const message = line.trim();
     if (!message) {
       rl.prompt();
       return;
     }
-    void enqueue(message).finally(() => rl.prompt());
+    void routeMessage(message).finally(() => rl.prompt());
   });
   rl.resume();
   return {
     dispatchLine: async (line) => {
       const message = line.trim();
       if (!message) return;
-      await enqueue(message);
+      await routeMessage(message);
     },
     close: () => rl.close(),
     getStatusIndicators: async () => {
@@ -2080,7 +2182,7 @@ async function main(argv = process.argv.slice(2)) {
     });
   }
   if (shouldLaunchTuiApp(config.tuiMode ?? "disabled", Boolean(process.stdout.isTTY), Boolean(process.stdin.isTTY))) {
-    const { runTuiApp } = await import("./tui-app-4_TrzESz.js");
+    const { runTuiApp } = await import("./tui-app-DeyZ4Pr9.js");
     await runTuiApp();
     return;
   }
@@ -2104,4 +2206,4 @@ export {
   PLAN_LINE_PREFIX as P,
   runCli as r
 };
-//# sourceMappingURL=bin-CqkqT6KK.js.map
+//# sourceMappingURL=bin-CdVTAe7j.js.map