@buildaharness/aielia 0.3.2 → 0.3.4

package/dist/harness-bridge.d.ts

@@ -9,6 +9,23 @@ import { TurnIntentClassification } from './turn-intent-classifier.js';
 import { AssistantSource } from './assistant-source.js';
 import { AssistantProgress } from './assistant-types.js';
 import { TraceEvent } from './trace-events.js';
+/**
+ * `AUDIT_VERIFICATION` gate — feature-value audit (Phase C5 of the internal plan). EVAL-ONLY:
+ * default **ON** (an unset / empty / truthy value keeps today's always-on verification). Only the
+ * benchmark's `verificationOff` arm sets a falsy value (`0` / `false` / `off` / `no` / `disabled`),
+ * which makes `HarnessBridge.run` pass `skipVerification: true` to HarnessRuntime. Read at exactly
+ * one call site (below); no product path sets it. Same shape as `semanticContradictionEnabled()`.
+ */
+export declare function verificationEnabled(env?: Record<string, string | undefined>): boolean;
+/**
+ * `AUDIT_REVIEWER_PASS` gate — feature-value audit (Phase C6 of the internal plan). EVAL-ONLY:
+ * default **ON** (an unset / empty / truthy value keeps today's always-on 3-lens reviewer pass).
+ * Only the benchmark's `reviewerPassOff` arm sets a falsy value (`0` / `false` / `off` / `no` /
+ * `disabled`), which makes `HarnessBridge.run` pass `skipReviewerPass: true` to HarnessRuntime.
+ * Read at exactly one call site (below); no product path sets it. Same shape as
+ * `verificationEnabled()`.
+ */
+export declare function reviewerPassEnabled(env?: Record<string, string | undefined>): boolean;
 export type HarnessOutcome = {
     status: 'paused';
     checkpoint: HarnessCheckpoint;

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export { PersonalAssistant } from './assistant.js';
 export type { AssistantTurnResult, ProposerKind, PersonalAssistantOptions, AssistantProgress, AssistantTrace, AssistantSource, MemorySummary, TranscriptSearchHit, DebugLogEntry } from './assistant.js';
+export type { GoalGraphState, GoalThreadView, GoalThreadVisibility, GoalTaskSummary } from './goal-graph-service.js';
 export type { AnswerClaim, AnswerClaimSourceType, AnswerClaimVerificationStatus } from './answer-claim.js';
 export { classifyRisk } from './risk-classifier.js';
 export type { RiskClassification } from './risk-classifier.js';
@@ -47,12 +48,21 @@ export { resolveAskMode, normalizeAskMode, DEFAULT_ASK_MODE } from './ask-mode-f
 export type { AskMode } from './ask-mode-flag.js';
 export { resolvePlanMode, normalizePlanMode, DEFAULT_PLAN_MODE } from './plan-mode-flag.js';
 export type { PlanRolloutMode } from './plan-mode-flag.js';
+export { resolveGoalGraphMode, normalizeGoalGraphMode, isGoalGraphEnabled, DEFAULT_GOAL_GRAPH_MODE } from './goal-graph-flag.js';
+export type { GoalGraphMode } from './goal-graph-flag.js';
+export type { NextStepSuggestion } from './next-step-proposer.js';
+export { resolveGoalGraphSuggestMode, normalizeGoalGraphSuggestMode, isGoalGraphSuggestEnabled, DEFAULT_GOAL_GRAPH_SUGGEST_MODE } from './goal-graph-suggest-flag.js';
+export type { GoalGraphSuggestMode } from './goal-graph-suggest-flag.js';
+export { LiveSteeringChannel } from './live-steering-channel.js';
+export type { SteeringEvent } from './live-steering-channel.js';
 export { AskClarificationService } from './ask-clarification-service.js';
 export type { AskClarificationPendingState } from './ask-clarification-service.js';
 export { validateAskResponse, MAX_QUESTIONS_PER_BATCH, MIN_OPTIONS_PER_QUESTION, MAX_OPTIONS_PER_QUESTION } from '@buildaharness/harness';
 export type { AskQuestion, AskQuestionOption, AskAnswer, AskResponse } from '@buildaharness/harness';
 export { createScriptedLLMClient } from './scripted-llm-client.js';
 export type { ScriptedLLMClientScript } from './scripted-llm-client.js';
-export { formatMemorySummary, formatSearchResults, formatCostSummary, formatDoctorReport, formatTranscriptMarkdown, defaultExportFilename } from './cli-session.js';
+export { formatMemorySummary, formatSearchResults, formatGoalGraphState, formatCostSummary, formatDoctorReport, formatTranscriptMarkdown, defaultExportFilename } from './cli-session.js';
 export type { CostSummaryInfo, DoctorCheck } from './cli-session.js';
 export { estimateCostUsd } from './model-pricing.js';
+export { PROVIDER_SETUP, getProviderSetup, cleanApiKey, checkApiKeyFormat, testApiKey } from './provider-setup.js';
+export type { KeyedBackend, ProviderSetupInfo, KeyTestResult } from './provider-setup.js';

package/dist/index.js

@@ -1,8 +1,8 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { B as classifyRisk } from "./cli-session-BiX2DOni.js";
-import { A, a, b, C, c, D, e, f, g, i, F, j, I, L, k, l, m, P, n, o, R, p, S, q, W, r, s, t, u, v, w, x, y, z, G, H, J, K, M, N, O, T, U, X, Y, Z, _, $, a1, a2, a3, a7, a8, a9, ac, af, ag, ah, ai, aj, ak, al, am, an, ao, ap, aq, ar, at, au, av, aw, ax, ay, az, aA, aC, aD, aF, aG, aH, aI } from "./cli-session-BiX2DOni.js";
+import { M as classifyRisk } from "./provider-setup-CPbB5y_V.js";
+import { A, a, b, C, c, D, e, f, g, h, i, k, F, l, I, L, m, n, o, p, P, q, r, s, R, t, S, u, W, v, w, x, y, z, B, G, H, J, K, N, O, Q, T, U, V, X, Y, _, $, a1, a2, a3, a4, a5, a7, a8, a9, aa, ae, ag, ah, ak, am, ao, ap, aq, ar, as, at, au, av, aw, ax, ay, az, aA, aB, aC, aD, aE, aG, aH, aI, aJ, aK, aL, aM, aN, aO, aP, aR, aS, aU, aV, aW, aX, aY } from "./provider-setup-CPbB5y_V.js";
 import { MAX_OPTIONS_PER_QUESTION, MAX_QUESTIONS_PER_BATCH, MIN_OPTIONS_PER_QUESTION, validateAskResponse } from "@buildaharness/harness";
 const PLAN_SCHEMA = {
   type: "object",
@@ -126,87 +126,102 @@ export {
   c as ConfigValidationError,
   D as DEFAULT_ASK_MODE,
   e as DEFAULT_CONFIG,
-  f as DEFAULT_ONE_LOOP_MODE,
-  g as DEFAULT_PLAN_MODE,
-  i as EmailDeliveryError,
+  f as DEFAULT_GOAL_GRAPH_MODE,
+  g as DEFAULT_GOAL_GRAPH_SUGGEST_MODE,
+  h as DEFAULT_ONE_LOOP_MODE,
+  i as DEFAULT_PLAN_MODE,
+  k as EmailDeliveryError,
   F as FETCH_URL_TOOL,
-  j as FILE_TOOLS,
+  l as FILE_TOOLS,
   I as InvalidEmailArgsError,
   L as LAYER_DISPLAY_NAME,
-  k as LAYER_ORDER,
-  l as LAYER_SHORT_CODE,
-  m as LIST_DIRECTORY_TOOL,
+  m as LAYER_ORDER,
+  n as LAYER_SHORT_CODE,
+  o as LIST_DIRECTORY_TOOL,
+  p as LiveSteeringChannel,
   MAX_OPTIONS_PER_QUESTION,
   MAX_QUESTIONS_PER_BATCH,
   MIN_OPTIONS_PER_QUESTION,
-  P as PathOutsideWorkspaceError,
-  n as PersonalAssistant,
-  o as PrivateNetworkTargetError,
+  P as PROVIDER_SETUP,
+  q as PathOutsideWorkspaceError,
+  r as PersonalAssistant,
+  s as PrivateNetworkTargetError,
   R as READ_FILE_TOOL,
-  p as RUN_SHELL_COMMAND_TOOL,
+  t as RUN_SHELL_COMMAND_TOOL,
   S as SEND_EMAIL_TOOL,
-  q as SHELL_TOOLS,
+  u as SHELL_TOOLS,
   W as WEB_SEARCH_TOOL,
-  r as WEB_TOOLS,
-  s as WRITE_FILE_TOOL,
-  t as abandonPlan,
-  u as applyPendingAction,
-  v as assertPublicHttpUrl,
-  w as braveSearch,
-  x as buildClaudePrompt,
+  v as WEB_TOOLS,
+  w as WRITE_FILE_TOOL,
+  x as abandonPlan,
+  y as applyPendingAction,
+  z as assertPublicHttpUrl,
+  B as braveSearch,
+  G as buildClaudePrompt,
   buildPlanFromTemplate,
-  y as buildWhyChain,
-  z as classifyError,
+  H as buildWhyChain,
+  J as checkApiKeyFormat,
+  K as classifyError,
   classifyRisk,
-  G as classifyToolYield,
-  H as classifyTurnIntent,
-  J as computePlanPosition,
-  K as createPlanRecord,
-  M as createResendSender,
+  N as classifyToolYield,
+  O as classifyTurnIntent,
+  Q as cleanApiKey,
+  T as computePlanPosition,
+  U as createPlanRecord,
+  V as createResendSender,
   createScriptedLLMClient,
-  N as createSmtpSender,
-  O as defaultExportFilename,
-  T as detectHomogeneousBatchList,
-  U as discardPendingAction,
-  X as estimateCostUsd,
-  Y as executeActionTool,
-  Z as executeFileTool,
-  _ as executeShellTool,
-  $ as executeWebTool,
-  a1 as formatCostSummary,
-  a2 as formatDoctorReport,
-  a3 as formatEmailApprovalReason,
-  a7 as formatMemorySummary,
-  a8 as formatPlanProgress,
-  a9 as formatSearchResults,
-  ac as formatTranscriptMarkdown,
-  af as isLikelyEmailAddress,
-  ag as listTemplateNames,
-  ah as loadActivePlan,
-  ai as loadPendingAction,
-  aj as loadTemplate,
-  ak as matchTemplateIfConfident,
-  al as nextPendingTask,
-  am as nodeDisplayName,
-  an as nodeToLayer,
-  ao as normalizeAskMode,
-  ap as normalizeOneLoopMode,
-  aq as normalizePlanMode,
-  ar as parseClaudeCliOutput,
-  at as pickTemplateForTask,
-  au as planCompletionPct,
-  av as resolveAskMode,
-  aw as resolveConfig,
-  ax as resolveInWorkspace,
-  ay as resolveOneLoopMode,
-  az as resolvePlanMode,
-  aA as savePlan,
-  aC as stagePendingAction,
-  aD as stagedActionInput,
-  aF as stripMcpToolPrefix,
-  aG as summarizeToolStep,
-  aH as updatePlanFromRun,
+  X as createSmtpSender,
+  Y as defaultExportFilename,
+  _ as detectHomogeneousBatchList,
+  $ as discardPendingAction,
+  a1 as estimateCostUsd,
+  a2 as executeActionTool,
+  a3 as executeFileTool,
+  a4 as executeShellTool,
+  a5 as executeWebTool,
+  a7 as formatCostSummary,
+  a8 as formatDoctorReport,
+  a9 as formatEmailApprovalReason,
+  aa as formatGoalGraphState,
+  ae as formatMemorySummary,
+  ag as formatPlanProgress,
+  ah as formatSearchResults,
+  ak as formatTranscriptMarkdown,
+  am as getProviderSetup,
+  ao as isGoalGraphEnabled,
+  ap as isGoalGraphSuggestEnabled,
+  aq as isLikelyEmailAddress,
+  ar as listTemplateNames,
+  as as loadActivePlan,
+  at as loadPendingAction,
+  au as loadTemplate,
+  av as matchTemplateIfConfident,
+  aw as nextPendingTask,
+  ax as nodeDisplayName,
+  ay as nodeToLayer,
+  az as normalizeAskMode,
+  aA as normalizeGoalGraphMode,
+  aB as normalizeGoalGraphSuggestMode,
+  aC as normalizeOneLoopMode,
+  aD as normalizePlanMode,
+  aE as parseClaudeCliOutput,
+  aG as pickTemplateForTask,
+  aH as planCompletionPct,
+  aI as resolveAskMode,
+  aJ as resolveConfig,
+  aK as resolveGoalGraphMode,
+  aL as resolveGoalGraphSuggestMode,
+  aM as resolveInWorkspace,
+  aN as resolveOneLoopMode,
+  aO as resolvePlanMode,
+  aP as savePlan,
+  aR as stagePendingAction,
+  aS as stagedActionInput,
+  aU as stripMcpToolPrefix,
+  aV as summarizeToolStep,
+  aW as testApiKey,
+  aX as updatePlanFromRun,
   validateAskResponse,
-  aI as validateConfig
+  aY as validateConfig
 };
 //# sourceMappingURL=index.js.map

package/dist/live-steering-channel.d.ts

@@ -0,0 +1,31 @@
+/**
+ * R1 (mid-task steering) of plans/hierarchical_goal_tree_and_steering_plan.html — a message sent
+ * while a turn is already running is absorbed here instead of waiting for the CLI's
+ * `dispatchQueue` or chat-ui's disabled composer to free up (see Figure 1 of that plan). One
+ * instance per session, mirroring `OneShotAnswerChannel`'s per-session lifetime
+ * (ask-clarification-service.ts) but with a different shape: that channel resumes a *paused* run
+ * with exactly one answer, this one accumulates zero or more raw steering messages while a turn
+ * keeps running and hands them all back at once.
+ *
+ * Phase 3 only builds the queue and the producer-side routing (cli.ts's line-handler split,
+ * chat-ui's composer un-disabling) — `poll()` has no consumer yet. Phase 4 wires it into
+ * `checkCallerUpdates` via the Scope×Urgency classifier at the harness's own iteration boundary
+ * (`UpdateChannel.poll()` in check-caller-updates.ts), turning each drained message into a real
+ * `CallerUpdate`. This class is deliberately unaware of `GoalGraphRecord`/`GoalThread` — same
+ * "standalone, unused until the wiring phase" discipline `goal-identity-matcher.ts` (Phase 2)
+ * already used.
+ */
+export interface SteeringEvent {
+    message: string;
+    enqueuedAt: number;
+}
+export declare class LiveSteeringChannel {
+    private queue;
+    enqueue(message: string): void;
+    /**
+     * Drains every event queued since the last poll, oldest first (FIFO) — never partial, never
+     * re-delivered: a second call with nothing newly enqueued returns an empty array.
+     */
+    poll(): SteeringEvent[];
+    get pendingCount(): number;
+}

package/dist/memory-service.d.ts

@@ -75,6 +75,16 @@ export interface RecordFactsResult {
     contradictions: ExternalContradictionInput[];
     corroborations: Corroboration[];
 }
+/**
+ * `AUDIT_MODEL_INFERRED_FACTS` gate — feature-value audit (Phase C3 of the internal plan).
+ * Default **ON**: `classifyTurnIntent`'s `statesDurableFacts` (source `model_inferred`) reach
+ * memory today, so an unset / empty / truthy value keeps that behaviour. Set to a falsy value
+ * (`0` / `false` / `off` / `no` / `disabled`) to drop them, leaving only the lexical
+ * `user_asserted` pass. Gates the *consumption* of the classifier's facts, not the classifier call
+ * (which also produces the intent/risk fields every arm needs). Read at exactly one call site —
+ * `buildTurnFacts()` below. Same shape as `semanticContradictionEnabled()` (contradiction-checker.ts).
+ */
+export declare function modelInferredFactsEnabled(env?: Record<string, string | undefined>): boolean;
 /**
  * The exact lexical+LLM merge `recordFacts()` uses to decide what to write to the fact stores,
  * exposed (Phase 4 of the internal plan) so a

package/dist/next-step-proposer.d.ts

@@ -0,0 +1,52 @@
+import { ILLMClient, TokenUsage } from '@buildaharness/runtime';
+import { GoalThread } from './goal-graph-store.js';
+import { GoalGraphSuggestMode } from './goal-graph-suggest-flag.js';
+export type SuggestionConfidence = 'high' | 'medium' | 'low';
+/** Mirrors `shouldAutoPromote()`'s three-way policy *shape* (memory-service.ts) — not its bands, since Q10 found no numeric threshold to reuse: `high` auto-promotes, `medium` queues for explicit confirmation, `low` stays advisory-only and is never persisted past the turn that produced it. */
+export type SuggestionPromotion = 'auto' | 'pending_confirm' | 'session_only';
+export interface NextStepSuggestion {
+    /** A concrete, actionable next step description — third person, e.g. "add tests for the login page". */
+    description: string;
+    confidence: SuggestionConfidence;
+    /** Why this follows from the completed goal — surfaced to the user alongside the suggestion, same spirit as StatedFact's rationale-free text but here always populated since a suggestion needs justification a stated fact doesn't. */
+    rationale: string;
+}
+/**
+ * A persistent advisory node (R7) — `proposeNextSteps()`'s per-suggestion output, carrying the
+ * promotion decision alongside the LLM's own judgment. Self-contained rather than a
+ * `GoalTaskRecord`: a suggestion isn't yet a task on any thread (it may never be promoted at all,
+ * see `session_only`), so it deliberately doesn't reuse that shape.
+ */
+export interface SuggestedNextStepNode {
+    id: string;
+    goalThreadId: string;
+    description: string;
+    rationale: string;
+    confidence: SuggestionConfidence;
+    promotion: SuggestionPromotion;
+    createdAt: string;
+}
+/** Q10's three-way policy shape, applied to this mechanism's own confidence rubric — see this module's doc comment on why the bands aren't reused from `shouldAutoPromote()`. */
+export declare function classifySuggestionPromotion(confidence: SuggestionConfidence): SuggestionPromotion;
+/**
+ * Tier 1.5's entry point (R7): proposes next-step nodes for `thread`, gated by
+ * `goalGraphSuggestMode` independently of `goalGraphMode` (Q8) — returns `[]` without any LLM call
+ * both when the flag is off (INV-43: a flag-off session sees zero behavior change) and when
+ * `thread` hasn't actually reached `DONE` yet, since a suggestion only makes sense once the goal
+ * it follows from is finished.
+ */
+export declare function proposeNextSteps(thread: GoalThread, llmClient: ILLMClient, suggestMode: GoalGraphSuggestMode, model?: string, onUsage?: (usage: TokenUsage) => void): Promise<SuggestedNextStepNode[]>;
+/**
+ * The turn-end entry point: after a full (non-trivial) turn completes, propose up to three
+ * concrete next steps for the user to pick from — shown under the reply, like Claude Code's prompt
+ * suggestions. Same bounded call and confidence rubric as `proposeNextSteps` (the turn's request
+ * stands in for the thread's success criteria, the reply for its rationale), gated by
+ * `goalGraphSuggestMode`. Returns `[]` without any LLM call when the mode isn't 'enabled' or there
+ * is nothing to follow up on. Ordered most-confident first and capped at three; unlike thread
+ * suggestions nothing here is persisted — a turn-end option is advisory for the turn that produced
+ * it, so every confidence tier (including `low`, `session_only` in the thread policy) is shown.
+ */
+export declare function proposeTurnNextSteps(turn: {
+    userMessage: string;
+    reply: string;
+}, llmClient: ILLMClient, suggestMode: GoalGraphSuggestMode, model?: string, onUsage?: (usage: TokenUsage) => void): Promise<NextStepSuggestion[]>;

package/dist/plan-approval-service.d.ts

@@ -58,5 +58,5 @@ export declare class PlanApprovalService {
      * or a throwing edit/activation step, leaves `mode: 'awaiting_approval'` untouched and returns a
      * new `needs_plan_approval` result rather than silently advancing or discarding the plan.
      */
-    resolvePendingPlanApproval(sessionId: string, planApprovalId: string, decision: PlanDecision | undefined, edits: PlanApprovalEdits | undefined): Promise<PlanApprovalOutcome>;
+    resolvePendingPlanApproval(sessionId: string, planApprovalId: string, decision: PlanDecision | undefined, edits: PlanApprovalEdits | undefined, threadId?: string): Promise<PlanApprovalOutcome>;
 }

package/dist/plan-drafting-service.d.ts

@@ -79,7 +79,7 @@ export declare class PlanDraftingService {
      * rather than silently proceeding or discarding the batch.
      */
     resolvePendingAsk(sessionId: string, transcriptKey: string, pendingAskId: string, response: AskResponse | undefined, onUsage: (usage: TokenUsage) => void): Promise<AssistantTurnResult>;
-    draftTurn(sessionId: string, transcriptKey: string, userMessage: string, onUsage: (usage: TokenUsage) => void, seed?: PlanDraftSeed): Promise<PlanDraftOutcome>;
+    draftTurn(sessionId: string, transcriptKey: string, userMessage: string, onUsage: (usage: TokenUsage) => void, seed?: PlanDraftSeed, threadId?: string): Promise<PlanDraftOutcome>;
     private stillAwaitingApproval;
     /** Stages a single nested question (P8) and returns the `needs_clarification` result — mirrors AskClarificationService.stageAndRespond's "append the user's message, return no reply yet" shape, but into `plan-ask-pending:` instead of `ask-pending:`, and resolved by `resolvePendingAsk` above instead of a harness resume. */
     private stageNestedAsk;