@buildaharness/aielia 0.3.3 → 0.3.4

package/dist/cli-session.d.ts

@@ -1,6 +1,8 @@
+import { NextStepSuggestion } from './next-step-proposer.js';
 import { ChatMessage, TokenUsage } from '@buildaharness/runtime';
 import { AssistantConfig } from './config.js';
 import { MemorySummary, MemoryExport, TranscriptSearchHit, MemoryPendingOutcome } from './assistant.js';
+import { GoalGraphState } from './goal-graph-service.js';
 import { UndoLogEntry } from './action-snapshot.js';
 /**
  * Pure formatting/logic backing cli.ts's session-level commands (/help, /status, /export,
@@ -34,6 +36,16 @@ export declare function formatMemorySummary(summary: MemorySummary): string;
 export declare function formatMemoryExport(data: MemoryExport): string;
 /** Renders `/search <query>`'s results — each hit is one message (session id short form, timestamp, role, snippet), ranked by relevance, never the whole session it came from. An empty list is an explicit "no results" line, never a silent blank output. */
 export declare function formatSearchResults(hits: TranscriptSearchHit[], query: string): string;
+/** Renders the turn-end next-step options shown under a full turn's reply — numbered so the CLI can accept a bare `1`/`2`/`3` as "run that one" (see cli.ts's dispatchOne). Only the description is shown; the rationale and confidence stay in the structured result for richer front ends. */
+export declare function formatNextSteps(steps: NextStepSuggestion[]): string;
+/**
+ * Renders `/goals`' review surface (R5, "Visibility") — every known GoalThread this session, each
+ * tagged with which of R5's four visibility buckets it falls in
+ * (freshly-computed/carried-over/done/suggested-but-not-committed), so a user can tell live state
+ * apart from stale carryover without re-deriving it from raw JSON. An empty graph is an explicit
+ * line, same convention `formatSearchResults` follows for zero hits.
+ */
+export declare function formatGoalGraphState(state: GoalGraphState): string;
 /** Renders /undo-action's no-argument listing — newest first (see action-snapshot.ts's listUndoLogEntries), with each entry's undoable status so the user doesn't have to stage a revert just to find out it's unavailable. */
 export declare function formatUndoLogListing(entries: UndoLogEntry[]): string;
 /** Renders a transcript as markdown for /export — "You:"/"Assistant:" turns, oldest first. */

package/dist/cli.d.ts

@@ -2,6 +2,7 @@ import { FsBackend } from '@buildaharness/runtime';
 import { PersonalAssistant } from './assistant.js';
 import { AssistantConfig, ConfigStore } from './config.js';
 import { NonInteractiveApprovalMode } from './non-interactive-mode.js';
+import { KeyedBackend, KeyTestResult } from './provider-setup.js';
 /**
  * One choice in a structured multi-option prompt (Phase 7 of the internal plan
  * — the numbered/arrow-key approval selector). `key` is both the single-character shortcut shown
@@ -42,6 +43,8 @@ export interface RunCliOptions {
     detectClaudeCli?: () => Promise<boolean>;
     /** Test seam: script the first-run setup's line reads. */
     firstRunAsk?: (question: string) => Promise<string>;
+    /** Test seam: stub the live API-key check in the first-run setup (defaults to a real call to the provider). */
+    firstRunTestKey?: (backend: KeyedBackend, key: string) => Promise<KeyTestResult>;
 }
 export interface CliInstance {
     /** Parses and dispatches one line of input exactly as the REPL's 'line' handler does (same dispatchQueue serialization) — the seam cli.test.ts drives command dispatch through without a live TTY. */

package/dist/cli.js

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
-import "./bin-Btzhiyzi.js";
+import "./bin-CdVTAe7j.js";
 //# sourceMappingURL=cli.js.map

package/dist/config.d.ts

@@ -3,6 +3,8 @@ import { AskMode } from './ask-mode-flag.js';
 import { PlanRolloutMode } from './plan-mode-flag.js';
 import { TuiMode } from './tui-mode-flag.js';
 import { UpdateCheckMode } from './update-check-flag.js';
+import { GoalGraphMode } from './goal-graph-flag.js';
+import { GoalGraphSuggestMode } from './goal-graph-suggest-flag.js';
 export interface AssistantConfig {
     llmBackend: 'proxy' | 'claude-cli' | 'anthropic' | 'openai' | 'openrouter';
     proxyUrl: string;
@@ -155,6 +157,26 @@ export interface AssistantConfig {
      * `/config reset activeProject`, mirroring `/model`'s relationship to `/config set model`.
      */
     activeProject?: string;
+    /**
+     * Phase 8 of plans/hierarchical_goal_tree_and_steering_plan.html — the shared config seam for
+     * the hierarchical goal-tree mechanism's Tier 0/1 gate (R1's mid-task steering, R4's scope×
+     * urgency classifier). Undefined (the default, for the whole rollout window) means every
+     * surface falls back to `DEFAULT_GOAL_GRAPH_MODE` ('disabled') — today's behavior, byte-for-byte
+     * (INV-43). Mirrors `oneLoopMode`/`askMode`/`planMode`'s exact chain: env override
+     * (`ASSISTANT_GOAL_GRAPH`, cli-config.ts), build-time override (`VITE_ASSISTANT_GOAL_GRAPH`,
+     * chat-ui's browser-config.ts), and a package-owned default kept out of DEFAULT_CONFIG so an
+     * unset value stays undefined. Before this phase, cli.ts/App.tsx read this straight off
+     * process.env/import.meta.env instead of through this field — see goal-graph-flag.ts's doc
+     * comment for why that was deliberate up to now.
+     */
+    goalGraphMode?: GoalGraphMode;
+    /**
+     * Phase 8 — the same shared config seam as `goalGraphMode` above, for the next-step proposer's
+     * (Tier 1.5) independent gate (Q8: a regression there shouldn't block Tier 0/1). Undefined
+     * falls back to `DEFAULT_GOAL_GRAPH_SUGGEST_MODE` ('disabled'). Same env/build-time/`/config
+     * set` chain, via `ASSISTANT_GOAL_GRAPH_SUGGEST`/`VITE_ASSISTANT_GOAL_GRAPH_SUGGEST`.
+     */
+    goalGraphSuggestMode?: GoalGraphSuggestMode;
 }
 /** Every AssistantConfig key, in the order every surface's settings UI/listing renders them. */
 export declare const CONFIG_KEYS: readonly (keyof AssistantConfig)[];

package/dist/first-run.d.ts

@@ -1,4 +1,5 @@
 import { AssistantConfig, ConfigStore } from './config.js';
+import { KeyTestResult, KeyedBackend } from './provider-setup.js';
 export interface FirstRunDeps {
     configStore: ConfigStore;
     /** Result of `configStore.load()` — the setup is skipped entirely if this already names a backend/key. */
@@ -13,6 +14,8 @@ export interface FirstRunDeps {
     detectClaudeCli: () => Promise<boolean>;
     /** Where to print prompts/status (defaults to process.stdout in cli.ts). */
     log: (line: string) => void;
+    /** Live-checks a key against the provider. Optional so unit tests can skip the network; cli.ts passes the real testApiKey. */
+    testKey?: (backend: KeyedBackend, key: string) => Promise<KeyTestResult>;
 }
 /**
  * Runs the first-run pass if needed. Returns the persisted config to use from

package/dist/goal-graph-flag.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Pure logic backing the hierarchical-goal-tree mechanism's Tier 0/1 gate — the
+ * `LiveSteeringChannel` producer/routing split (Phase 3), the Scope×Urgency classifier and
+ * `GoalGraphRecord` status writes (Phase 4) — see
+ * plans/hierarchical_goal_tree_and_steering_plan.html. Split out so it's unit-testable in
+ * isolation, the same pattern as one-loop-flag.ts/ask-mode-flag.ts/plan-mode-flag.ts.
+ *
+ * As of Phase 8, threaded through `AssistantConfig` exactly like those three: `goalGraphMode` is a
+ * real config field with `/config set` support, a `VITE_ASSISTANT_GOAL_GRAPH` build-time line in
+ * chat-ui's browser-config.ts, and flag-chain resolution tests (cli-config.test.ts,
+ * browser-config.test.ts). Before Phase 8 this mirrored the Trajectory Supervisor's own S0
+ * discipline ("flag defined, default OFF, read nowhere yet except a single guard stub"): cli.ts
+ * read it directly from `process.env.ASSISTANT_GOAL_GRAPH` via a `RunCliOptions.goalGraphMode`
+ * field (not `AssistantConfig`) and chat-ui's App.tsx read it directly from a module-level
+ * `import.meta.env.VITE_ASSISTANT_GOAL_GRAPH` constant — both now resolve through
+ * `config.goalGraphMode` instead, via `cli-config.ts`'s `envOverridesFromProcessEnv` /
+ * `browser-config.ts`'s `envOverridesFromImportMetaEnv`, both still ultimately calling
+ * `normalizeGoalGraphMode` below.
+ *
+ * Default ON ('enabled') as of 2026-09-23 (before that OFF; the 3-seed benchmark vs the queue-behind-the-turn baseline was neutral on success at lower cost). 'disabled' is the escape hatch: the CLI's `dispatchQueue` and chat-ui's busy-disables-composer
+ * behavior stay byte-identical to today (INV-43) — a message sent while a turn is running keeps
+ * waiting on `dispatchQueue` / the disabled composer, exactly as before. 'enabled' routes an
+ * in-flight message into a `LiveSteeringChannel` instead. This flag alone still has no consumer
+ * for it inside the harness's iteration loop (Phase 4 wires that in via the scope×urgency
+ * classifier) — see that phase's own notes for the actual reconciliation behavior.
+ */
+export type GoalGraphMode = 'enabled' | 'disabled';
+export declare const DEFAULT_GOAL_GRAPH_MODE: GoalGraphMode;
+/**
+ * The single place a resolved `config.goalGraphMode` becomes a boolean. `AssistantConfig.goalGraphMode`
+ * stays out of DEFAULT_CONFIG (undefined = "the package owns the default"), so every consumer must
+ * fall back to DEFAULT_GOAL_GRAPH_MODE rather than compare `=== 'enabled'` against a possibly-undefined value.
+ */
+export declare function isGoalGraphEnabled(mode: GoalGraphMode | undefined): boolean;
+/**
+ * Shared by cli.ts (reads `process.env.ASSISTANT_GOAL_GRAPH`) and chat-ui's App.tsx (reads Vite's
+ * `import.meta.env.VITE_ASSISTANT_GOAL_GRAPH`, which has no `process` to hand a
+ * `NodeJS.ProcessEnv` to). An unset or empty value falls back to the default silently; an
+ * unrecognized non-empty value falls back with a startup warning naming `varName`, the same
+ * typo-tolerance-with-a-warning convention normalizeOneLoopMode/normalizeAskMode/normalizePlanMode
+ * use.
+ */
+export declare function normalizeGoalGraphMode(raw: string | undefined, varName?: string): GoalGraphMode;
+export declare function resolveGoalGraphMode(env: NodeJS.ProcessEnv): GoalGraphMode;

package/dist/goal-graph-reconcile.d.ts

@@ -0,0 +1,55 @@
+import { ILLMClient, MemoryAdapter, TokenUsage } from '@buildaharness/runtime';
+import { UpdateChannel } from '@buildaharness/harness';
+import { LiveSteeringChannel, SteeringEvent } from './live-steering-channel.js';
+import { GoalGraphFsPersistence } from './goal-graph-store.js';
+/**
+ * Phase 4 of plans/hierarchical_goal_tree_and_steering_plan.html — the Tier-1 reconcile pass that
+ * turns a drained LiveSteeringChannel (Phase 3) into a handled ask via the scope×urgency
+ * classifier. One message is classified per poll() — checkCallerUpdates polls once per harness
+ * iteration, so a backlog of several queued messages drains one per iteration rather than all at
+ * once.
+ *
+ * Every classified message ends in exactly one of two places — never dropped (R4):
+ *
+ *  - **Applied in place** — a *steering note* the running turn's proposer reads before its next
+ *    LLM call (`takeNotes()`): SAME_TASK always, SAME_GOAL_NEW_TASK when IMMEDIATE. The model
+ *    itself interprets the note. Earlier revisions instead pushed the raw message text into the
+ *    harness's `add_constraint` / `add_success_criteria`, which are enforced *lexically*
+ *    (output-validation.ts's negation-word rule, criterionCovered's token overlap): a correction
+ *    like "use the audited figure, not the draft one" then made the reply's own words a
+ *    "violation" and threw the whole turn, and a criterion no proposer ever read was never acted
+ *    on. Neither field is read by the one-loop proposer's LLM call, so neither can carry a
+ *    natural-language ask.
+ *  - **Deferred to a follow-up turn** — everything else (NEW_GOAL, SAME_GOAL_NEW_TASK×DEFERRED,
+ *    CANCEL_CURRENT's replacement ask) plus any note the proposer never got to read (classified
+ *    after its last LLM call). `drainUnconsumed()` returns these so the caller re-enqueues them on
+ *    the LiveSteeringChannel, where the caller's post-turn drain (cli.ts / App.tsx) runs each as
+ *    an ordinary turn, in arrival order.
+ *
+ * Goal-graph bookkeeping (NEW_GOAL mints a thread, CANCEL_CURRENT abandons the active one and
+ * blocks the task graph via `cancel_current`) is unchanged — INV-39: never writes the ACTIVE
+ * pointer except through the Scheduler's own forceActivateThread.
+ */
+export interface SteeringReconcileChannel {
+    channel: UpdateChannel;
+    /**
+     * Steering notes classified since the last call, for the proposer to fold into its next LLM
+     * call. Each is returned once and counted as applied — call it only when about to make that call.
+     */
+    takeNotes(): string[];
+    /**
+     * Everything that must still be run as a follow-up turn: deferred asks, notes the proposer never
+     * took, and messages never classified at all (the harness run ended before its next poll). The
+     * caller re-enqueues these onto the original LiveSteeringChannel (R4).
+     */
+    drainUnconsumed(): SteeringEvent[];
+}
+export declare function createSteeringReconcileChannel(params: {
+    steeringChannel: LiveSteeringChannel;
+    sessionId: string;
+    memory: MemoryAdapter;
+    llmClient: ILLMClient;
+    model?: string;
+    onUsage?: (usage: TokenUsage) => void;
+    fsPersistence?: GoalGraphFsPersistence;
+}): SteeringReconcileChannel;

package/dist/goal-graph-service.d.ts

@@ -0,0 +1,48 @@
+import { MemoryAdapter } from '@buildaharness/runtime';
+import { GoalGraphFsPersistence, GoalThread, GoalThreadStatus, SiblingRelation } from './goal-graph-store.js';
+/**
+ * R5's four visibility buckets, derived from fields Phases 1/4/5 already persist rather than any
+ * new schema or wiring: `mode: 'drafting'` is a thread proposed but not yet approved/committed to
+ * (Q1's absorbed PlanRecord semantics) — "suggested-but-not-committed"; `status: 'DONE'` is done;
+ * everything else is "freshly (re)computed this turn" when it has never been touched since
+ * creation (`createdAt === updatedAt`), else "carried over" from a prior turn.
+ */
+export type GoalThreadVisibility = 'suggested_not_committed' | 'done' | 'freshly_computed' | 'carried_over';
+export declare function classifyThreadVisibility(thread: GoalThread): GoalThreadVisibility;
+export interface GoalTaskSummary {
+    total: number;
+    complete: number;
+    failed: number;
+    pending: number;
+}
+/** One thread as rendered by a review surface — a read-only projection, never the raw persisted `GoalThread` (callers have no business mutating it). */
+export interface GoalThreadView {
+    id: string;
+    status: GoalThreadStatus;
+    visibility: GoalThreadVisibility;
+    successCriteria: string;
+    tasks: GoalTaskSummary;
+    relationToSiblings?: SiblingRelation;
+    siblingIds?: string[];
+    isActive: boolean;
+    /** Advisory next steps proposed when the thread reached DONE (high/medium confidence only — low is never persisted). Absent when there are none. */
+    suggestions?: {
+        description: string;
+        rationale: string;
+        confidence: 'high' | 'medium' | 'low';
+    }[];
+    createdAt: string;
+    updatedAt: string;
+}
+export interface GoalGraphState {
+    activeThreadId: string | null;
+    threads: GoalThreadView[];
+}
+/**
+ * R5's review-surface entry point: every known GoalThread for `sessionId`, each tagged with its
+ * visibility bucket, plus the current focus pointer. Returns the empty state (never throws, never
+ * mints a record) when no goal graph exists yet for this session — same "nothing to show" shape as
+ * `getPlanState`'s `null`, just pre-shaped into an empty list instead, since a review surface wants
+ * something iterable, not a null check.
+ */
+export declare function getGoalGraphState(memory: MemoryAdapter, sessionId: string, fsPersistence?: GoalGraphFsPersistence): Promise<GoalGraphState>;