@buildaharness/aielia 0.3.3 → 0.3.5

package/dist/grounding-check.d.ts

@@ -0,0 +1,33 @@
+import { ILLMClient, TokenUsage } from '@buildaharness/runtime';
+import { AssistantSource } from './assistant-source.js';
+/**
+ * - 'grounded': every specific claim in the reply that rests on the tool results matches them.
+ * - 'ungrounded': at least one specific claim or figure conflicts with, or isn't supported by,
+ *   what the tools actually returned (`discrepancy` says which).
+ * - 'not_checked': nothing was compared — no raw tool text was visible (claude-cli runs its tool
+ *   loop in a subprocess), or the check errored / returned something unparseable.
+ */
+export type GroundingVerdict = 'grounded' | 'ungrounded' | 'not_checked';
+export interface GroundingResult {
+    verdict: GroundingVerdict;
+    discrepancy?: string;
+}
+/**
+ * `AUDIT_SEMANTIC_GROUNDING` gate. Default **ON**: an unset / empty / truthy value runs the grounding
+ * check, so `answerClaim.verification_status` can only say `verified` for a reply that was compared
+ * against the raw tool results. A falsy value (`0` / `false` / `off` / `no` / `disabled`) skips the
+ * LLM call and restores the previous, mechanical-only derivation of `verified`. Same shape as
+ * `semanticFailureMatchEnabled()`; read at exactly one site, assistant.ts's ResponseService wiring.
+ */
+export declare function semanticGroundingEnabled(env?: Record<string, string | undefined>): boolean;
+/**
+ * One bounded LLM call comparing a finished reply to the raw text its tools returned — the content
+ * check `verify()` (mechanical/environmental tiers only) has no way to make. Returns `not_checked`
+ * when there is nothing to compare or on any error, never a guessed `grounded`: a check that
+ * couldn't run must not upgrade a reply to `verified`.
+ */
+export declare function checkReplyGrounding(input: {
+    question: string;
+    reply: string;
+    sources: readonly AssistantSource[] | undefined;
+}, llmClient: ILLMClient, model?: string, onUsage?: (usage: TokenUsage) => void): Promise<GroundingResult>;

package/dist/harness-bridge.d.ts

@@ -1,4 +1,4 @@
-import { ExperienceStore, Task, CheckpointStore, LayerActivityEvent, HarnessCheckpoint, VerificationResult, HarnessRunResult, ToolExecutorContext, InvestigationRequestData, InvestigationFinding, UpdateChannel } from '@buildaharness/harness';
+import { ExperienceStore, Task, CheckpointStore, LayerActivityEvent, HarnessCheckpoint, VerificationResult, HarnessRunResult, ToolExecutorContext, InvestigationRequestData, InvestigationFinding, UpdateChannel, SemanticHypothesisEvent, SemanticHypothesisProposal, LayerPolicyMode } from '@buildaharness/harness';
 import { ILLMClient, MemoryAdapter, TokenUsage } from '@buildaharness/runtime';
 import { OneLoopMode } from './one-loop-flag.js';
 import { UserFact } from './fact-extraction.js';
@@ -9,6 +9,7 @@ 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';
+import { EscalationPlan } from './layer-policy-wiring.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
@@ -17,6 +18,29 @@ import { TraceEvent } from './trace-events.js';
  * one call site (below); no product path sets it. Same shape as `semanticContradictionEnabled()`.
  */
 export declare function verificationEnabled(env?: Record<string, string | undefined>): boolean;
+/**
+ * `AUDIT_EXPERIENCE_LEARNING` gate. Default **OFF**: the harness never writes its journal or updates the experience store, so
+ * `warmStart` / the recovery ladder keep reading an empty store, exactly as before. A truthy value (`1` / `true` / `on` / `yes` /
+ * `enabled`) makes HarnessBridge.run pass `experienceLearning: true` — see packages/harness/src/experience-learning.ts. It changes
+ * how a LATER run orders its recovery strategies, so it ships off until a benchmark shows it helps. Read at one site (below).
+ */
+export declare function experienceLearningEnabled(env?: Record<string, string | undefined>): boolean;
+/**
+ * `AUDIT_RETRY_FAILED_TASK` gate. Default **OFF**. On (`1`/`true`/`on`/`yes`/`enabled`) makes HarnessBridge.run pass
+ * `retryFailedTask: true`: after the recovery ladder switches strategy for a failed task, the failed task is re-queued so the
+ * new strategy actually gets an attempt (HarnessRunOptions.retryFailedTask). Off, a failed single task — or a multi-task turn
+ * whose tasks fail together — ends with nothing to run and the turn answers "could not complete". Read fresh each run.
+ */
+export declare function retryFailedTaskEnabled(env?: Record<string, string | undefined>): boolean;
+/**
+ * `AUDIT_RETRY_SYSTEM_ERRORS` gate. Default **ON** (`0`/`false`/`off`/`no`/`disabled` restores the old behaviour). Makes
+ * HarnessBridge.run pass `retryFailedSystemErrors: true`: after the recovery ladder switches strategy for a task whose failure
+ * was a SYSTEM error (the model or a tool call threw), the task is re-queued so the new strategy gets an attempt, instead of
+ * the turn giving up with "I couldn't complete this" after one transient error. An exhausted tool-loop budget, a rejected
+ * completion check and a failed verification are NOT retried (the wider `AUDIT_RETRY_FAILED_TASK` retries those too and stays
+ * off). Bounded by the ladder's MAX_SWITCHES and the stall rule. Read fresh each run.
+ */
+export declare function retrySystemErrorsEnabled(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).
@@ -31,11 +55,13 @@ export type HarnessOutcome = {
     checkpoint: HarnessCheckpoint;
     lastVerification: VerificationResult | null;
     layerActivity: LayerActivityEvent[];
+    taskNotes: Record<string, string>;
 } | {
     status: 'completed';
     result: HarnessRunResult;
     lastVerification: VerificationResult | null;
     layerActivity: LayerActivityEvent[];
+    taskNotes: Record<string, string>;
 };
 export interface HarnessRunParams {
     sessionId: string;
@@ -69,6 +95,41 @@ export interface HarnessRunParams {
      * flag is on is R3's scope.
      */
     oneLoopProposer?: (toolCtx: ToolExecutorContext) => unknown | Promise<unknown>;
+    /** Semantic change reviewer found a conflict — advisory (see HarnessRunOptions.onReviewConflict). The caller decides how to surface it. */
+    onReviewConflict?: (event: {
+        taskId: string;
+        reason: string;
+    }) => void;
+    /** Competing explanations were generated for an underdetermined request, or one was eliminated by evidence (AUDIT_SEMANTIC_HYPOTHESES). The caller decides how to surface it. */
+    onSemanticHypothesis?: (event: SemanticHypothesisEvent) => void;
+    /** The competing explanations were already asked for (a tool-less turn drafts its reply first): the harness registers this answer instead of making a second call. `null` = asked, none. `undefined` = not asked. */
+    precomputedHypotheses?: SemanticHypothesisProposal[] | null;
+    /** The opt-in layers' plan for this turn (adaptive mode only); see resolveOptInPlan. Absent: each layer's own flag decides. */
+    optInPlan?: EscalationPlan;
+    /** The reviewer pass's verdict sent the last answer back for one revision (AUDIT_REVIEWER_REVISION): the note to put in front of the proposer. */
+    onReviewerRevision?: (event: {
+        taskId: string;
+        note: string;
+    }) => void;
+    /** A constraint the user stated this turn was violated by the finished answer: the note to hand the proposer for its one second answer. */
+    onConstraintRevision?: (event: {
+        taskId: string;
+        note: string;
+    }) => void;
+    /** Tokens this turn's model calls have used so far (input + output) — what AUDIT_HARNESS_TOKEN_BUDGET reports to the harness. */
+    tokensUsed?: () => number;
+    /** A confident failure-mode match picked the recovery strategy — advisory (see HarnessRunOptions.onFailureModeSwitch). The caller decides how to surface it. */
+    onFailureModeSwitch?: (event: {
+        taskId: string;
+        failure_class: string;
+        strategy: string;
+    }) => void;
+    /** With AUDIT_EXPERIENCE_LEARNING on, a ranking learned from earlier runs picked the recovery strategy — advisory (see HarnessRunOptions.onLearnedStrategySwitch). */
+    onLearnedStrategySwitch?: (event: {
+        taskId: string;
+        failure_class: string;
+        strategy: string;
+    }) => void;
     /**
      * Trajectory Supervisor GATHER_EVIDENCE host (S5 of
      * the internal plan) — AgentLoop.runSupervisorInvestigation bound
@@ -115,6 +176,18 @@ export declare class HarnessBridge {
     private readonly assistantSession;
     private readonly onTrace;
     private readonly oneLoopMode;
-    constructor(memory: MemoryAdapter, experienceStore: ExperienceStore, checkpointStore: CheckpointStore, llmClient: ILLMClient, model: () => string | undefined, maxSteps: number, planService: PlanService, assistantSession: AssistantSession, onTrace: ((event: TraceEvent) => void) | undefined, oneLoopMode?: OneLoopMode);
+    private readonly layerPolicyMode;
+    constructor(memory: MemoryAdapter, experienceStore: ExperienceStore, checkpointStore: CheckpointStore, llmClient: ILLMClient, model: () => string | undefined, maxSteps: number, planService: PlanService, assistantSession: AssistantSession, onTrace: ((event: TraceEvent) => void) | undefined, oneLoopMode?: OneLoopMode, layerPolicyMode?: LayerPolicyMode);
+    /** AL9b: runId of the previous turn's outcome row, so this turn's `pushbackOnPriorTurn` can be recorded against it. */
+    private lastOutcomeRunId;
+    private outcomeSeq;
+    /** AL9b: persist the per-layer outcome row (and, under shadow, the shadow-vs-executed row). Never throws, never affects the turn. */
+    private recordTurnTelemetry;
+    /**
+     * Drops the paused harness run a `needs_clarification` left behind (its checkpoint and its resume-attempt counter),
+     * so the next ordinary run for this session starts fresh instead of resuming it. Used when a clarification answer
+     * is handed to the ordinary turn pipeline rather than fed back into the paused run.
+     */
+    discardPausedRun(sessionId: string): Promise<void>;
     run(params: HarnessRunParams): Promise<HarnessOutcome>;
 }

package/dist/harness-token-budget.d.ts

@@ -0,0 +1,9 @@
+/**
+ * `AUDIT_HARNESS_TOKEN_BUDGET` gate. Default **OFF**: the harness's memory layer keeps its `token_budget` at 0 used of 200,000,
+ * so its context-compression pressure test (90%) can never trip, exactly as before. A positive integer turns it on and IS the
+ * budget (`AUDIT_HARNESS_TOKEN_BUDGET=30000`): the turn's real model usage (input + output tokens, every call the turn made) is
+ * reported to the harness each iteration, and compression runs once usage passes 90% of the total. What it trims is the harness's
+ * own bookkeeping (compressed-structure and pruned-region records), never the model's conversation context — that is
+ * `semantic-compaction.ts`. Read at one site: harness-bridge.ts.
+ */
+export declare function harnessTokenBudgetTotal(env?: Record<string, string | undefined>): number | undefined;

package/dist/index.d.ts

@@ -1,7 +1,16 @@
 export { PersonalAssistant } from './assistant.js';
 export type { AssistantTurnResult, ProposerKind, PersonalAssistantOptions, AssistantProgress, AssistantTrace, AssistantSource, MemorySummary, TranscriptSearchHit, DebugLogEntry } from './assistant.js';
+export type { MemoryStatus, MemoryInjection, AuditEntry, ConsolidationOutcome } from './memory-service.js';
+export type { ConsolidationProposal } from './memory-consolidation.js';
+export type { SessionDigest } from './episodic-digest.js';
+export type { MemoryWriteMode } from './memory-governance.js';
+export { MEMORY_WRITE_MODES, DEFAULT_MEMORY_WRITE_MODE, resolveMemoryWriteMode } from './memory-governance.js';
+export type { GoalGraphState, GoalThreadView, GoalThreadVisibility, GoalTaskSummary } from './goal-graph-service.js';
 export type { AnswerClaim, AnswerClaimSourceType, AnswerClaimVerificationStatus } from './answer-claim.js';
+export { lowerConfidenceSourceLines } from './source-reliability.js';
 export { classifyRisk } from './risk-classifier.js';
+export { LEXICAL_FAMILIES, LEXICAL_CHECK_FAMILIES, DEFAULT_LEXICAL_MODE, lexicalActive, resolveLexicalMode, resolveLexicalOff, lexicalOffEnvValue, syncHarnessLexicalEnv } from './lexical/lexical-mode.js';
+export type { LexicalFamily, LexicalMode } from './lexical/lexical-mode.js';
 export type { RiskClassification } from './risk-classifier.js';
 export { classifyTurnIntent } from './turn-intent-classifier.js';
 export type { TurnIntentClassification, TurnIntentContext, RiskLevel } from './turn-intent-classifier.js';
@@ -41,18 +50,38 @@ export type { PlanRecord, PlanTaskRecord, PlanPosition, PlanMode } from './plan-
 export type { PlanDecision, PlanApprovalEdits } from './plan-approval-service.js';
 export { resolveConfig, validateConfig, ConfigValidationError, DEFAULT_CONFIG, CONFIG_KEYS } from './config.js';
 export type { AssistantConfig, ConfigStore, ResolvedConfig } from './config.js';
+export { LAYER_SETTINGS, applyLayerSettings, effectiveState, withLayerChoice, sanitizeLayerChoices, formatLayerListing, findLayer, isToggleable, LayerSettingError } from './layer-settings.js';
+export type { LayerSetting, LayerGroup, LayerChoices, AppliedLayers } from './layer-settings.js';
 export { resolveOneLoopMode, normalizeOneLoopMode, DEFAULT_ONE_LOOP_MODE } from './one-loop-flag.js';
 export type { OneLoopMode } from './one-loop-flag.js';
 export { resolveAskMode, normalizeAskMode, DEFAULT_ASK_MODE } from './ask-mode-flag.js';
 export type { AskMode } from './ask-mode-flag.js';
+export { resolveAmbiguityGuardMode, normalizeAmbiguityGuardMode, DEFAULT_AMBIGUITY_GUARD_MODE } from './ambiguity-guard-flag.js';
+export type { AmbiguityGuardMode } from './ambiguity-guard-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 { resolvePlanGraphMode, normalizePlanGraphMode, isPlanGraphEnabled, DEFAULT_PLAN_GRAPH_MODE } from './plan-graph-flag.js';
+export type { PlanGraphMode } from './plan-graph-flag.js';
+export { planToSnapshot } from './plan-viz/plan-snapshot.js';
+export type { PlanSnapshot, PlanSnapshotResult } from './plan-viz/plan-snapshot.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 { resolveLayerPolicyMode, normalizeLayerPolicyMode, isAdaptivePolicyEnabled, isPolicyRecordingEnabled, isLayerPolicyMode, resolveLayerPolicyModeFromConfig, DEFAULT_LAYER_POLICY_MODE } from './layer-policy-flag.js';
+export type { LayerPolicyMode } from './layer-policy-flag.js';
+export { resolveEscalationPlan, turnPolicyBudget, escalationEnabled, explicitEnvOverride, SEMANTIC_ESCALATIONS, harnessGatePolicy, decompositionReframeEnabled, injectionDetectionEnabled, decisionNote } from './layer-policy-wiring.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, formatMemoryHistory, formatMemoryArchive, formatMemoryInjection, formatMemoryStatus, memoryStatusChecks, 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,9 +1,9 @@
 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-DnSc6Hhx.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-DnSc6Hhx.js";
-import { MAX_OPTIONS_PER_QUESTION, MAX_QUESTIONS_PER_BATCH, MIN_OPTIONS_PER_QUESTION, validateAskResponse } from "@buildaharness/harness";
+import { bi as parseModelJson, a0 as classifyRiskLexical } from "./provider-setup-LFsaTkpf.js";
+import { A, a, b, C, c, D, e, f, g, h, i, j, k, l, m, o, F, p, I, L, q, r, s, t, u, v, w, x, M, P, y, z, B, R, G, S, H, J, W, K, N, O, Q, T, U, V, X, Y, Z, _, $, a1, a2, a3, a4, a5, a6, a7, a8, a9, aa, ac, ad, ae, ag, ah, ai, aj, ak, al, am, an, ap, aq, ar, as, au, av, ax, ay, aA, aB, aD, aE, aH, aJ, aK, aL, aM, aO, aP, aQ, aR, aS, aT, aV, aW, aX, aY, aZ, a_, a$, b0, b1, b3, b4, b5, b6, b7, b8, b9, ba, bb, bc, bd, be, bg, bj, bk, bl, bn, bo, bp, bq, br, bs, bt, bu, bv, bw, bx, by, bz, bA, bB, bC, bD, bF, bG, bI, bJ, bK, bL, bM, bN, bO, bP } from "./provider-setup-LFsaTkpf.js";
+import { DEFAULT_LAYER_POLICY_MODE, MAX_OPTIONS_PER_QUESTION, MAX_QUESTIONS_PER_BATCH, MIN_OPTIONS_PER_QUESTION, validateAskResponse } from "@buildaharness/harness";
 const PLAN_SCHEMA = {
   type: "object",
   properties: {
@@ -46,7 +46,7 @@ async function buildPlanFromTemplate(llmClient, message, template, model, onUsag
       void 0,
       { model, onUsage, structuredOutput: { schema: PLAN_SCHEMA } }
     );
-    const parsed = JSON.parse(response.content);
+    const parsed = parseModelJson(response.content);
     if (!Array.isArray(parsed.tasks)) return null;
     const rawTasks = parsed.tasks.filter(isRawPlanTask);
     if (rawTasks.length <= 1) return null;
@@ -57,14 +57,30 @@ async function buildPlanFromTemplate(llmClient, message, template, model, onUsag
     return null;
   }
 }
-const TURN_INTENT_MARKER = "eight independent judgments";
+const SIDE_CALL_MARKERS = [
+  ["You check whether a proposed action genuinely conflicts", '{"conflict":false}'],
+  ["You match a set of observed symptoms against a curated library", "null"],
+  ["You are a security classifier analyzing untrusted external content", '{"flagged":false}'],
+  ["You check whether an assistant's reply is faithful to the raw results", '{"verdict":"grounded"}'],
+  ["You judge whether an assistant actually accomplished a task", '{"done":true}'],
+  ["You condense the earlier part of a conversation", '{"summary":""}'],
+  ["You judge whether an assistant's reply violates constraints", '{"violations":[]}'],
+  ["You weigh the reliability of the sources an assistant read", '{"assessments":[],"weighed":true}'],
+  ["You propose competing explanations for an underdetermined request", '{"hypotheses":[]}'],
+  ["You decide which explanations a set of new observations rules out", '{"contradicted":[]}'],
+  ["You write a session handoff digest", '{"digest":null}'],
+  ["You consolidate a small store of remembered facts about a user", '{"proposals":[]}'],
+  ["You review what a user said across several turns", '{"ops":[]}'],
+  ["You check proposed memory entries against what a user actually said", '{"verdicts":[]}']
+];
+const TURN_INTENT_MARKER = " independent judgments";
 function isTurnIntentRequest(messages) {
   return messages.some((m2) => m2.role === "system" && m2.content.includes(TURN_INTENT_MARKER));
 }
 function deriveTurnIntentJSON(messages, override) {
   var _a;
   const userContent = ((_a = messages.find((m2) => m2.role === "user")) == null ? void 0 : _a.content) ?? "";
-  const risk = classifyRisk(userContent);
+  const risk = classifyRiskLexical(userContent);
   const isReminderRequest = risk.reason.includes("reminder");
   const base = {
     riskLevel: risk.riskLevel,
@@ -74,6 +90,8 @@ function deriveTurnIntentJSON(messages, override) {
     isReminderRequest,
     isBulkReminderRequest: isReminderRequest && risk.requiresApproval,
     isAbandonRequest: false,
+    isPlanQuestion: false,
+    isUnderdetermined: false,
     matchedPlanTemplate: null,
     needsMultiStepPlan: false,
     statesDurableFacts: []
@@ -99,11 +117,14 @@ class ScriptedLLMClient {
     return chunks.join("");
   }
   async callChatStructured(messages, _tools, _options) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     if (isTurnIntentRequest(messages)) {
       const userContent = ((_a = messages.find((m2) => m2.role === "user")) == null ? void 0 : _a.content) ?? "";
       return { content: deriveTurnIntentJSON(messages, (_c = (_b = this.script).classify) == null ? void 0 : _c.call(_b, userContent)) };
     }
+    const system = ((_d = messages.find((m2) => m2.role === "system")) == null ? void 0 : _d.content) ?? "";
+    const side = [...this.script.sideResponses ?? [], ...SIDE_CALL_MARKERS].find(([marker]) => system.includes(marker));
+    if (side) return { content: side[1] };
     this.toolCalls++;
     const responses = this.script.responses ?? [];
     if (this.responseIndex >= responses.length) {
@@ -124,89 +145,154 @@ export {
   b as AskClarificationService,
   C as CONFIG_KEYS,
   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,
+  D as DEFAULT_AMBIGUITY_GUARD_MODE,
+  e as DEFAULT_ASK_MODE,
+  f as DEFAULT_CONFIG,
+  g as DEFAULT_GOAL_GRAPH_MODE,
+  h as DEFAULT_GOAL_GRAPH_SUGGEST_MODE,
+  DEFAULT_LAYER_POLICY_MODE,
+  i as DEFAULT_LEXICAL_MODE,
+  j as DEFAULT_MEMORY_WRITE_MODE,
+  k as DEFAULT_ONE_LOOP_MODE,
+  l as DEFAULT_PLAN_GRAPH_MODE,
+  m as DEFAULT_PLAN_MODE,
+  o as EmailDeliveryError,
   F as FETCH_URL_TOOL,
-  j as FILE_TOOLS,
+  p 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,
+  q as LAYER_ORDER,
+  r as LAYER_SETTINGS,
+  s as LAYER_SHORT_CODE,
+  t as LEXICAL_CHECK_FAMILIES,
+  u as LEXICAL_FAMILIES,
+  v as LIST_DIRECTORY_TOOL,
+  w as LayerSettingError,
+  x as LiveSteeringChannel,
   MAX_OPTIONS_PER_QUESTION,
   MAX_QUESTIONS_PER_BATCH,
+  M as MEMORY_WRITE_MODES,
   MIN_OPTIONS_PER_QUESTION,
-  P as PathOutsideWorkspaceError,
-  n as PersonalAssistant,
-  o as PrivateNetworkTargetError,
+  P as PROVIDER_SETUP,
+  y as PathOutsideWorkspaceError,
+  z as PersonalAssistant,
+  B as PrivateNetworkTargetError,
   R as READ_FILE_TOOL,
-  p as RUN_SHELL_COMMAND_TOOL,
-  S as SEND_EMAIL_TOOL,
-  q as SHELL_TOOLS,
+  G as RUN_SHELL_COMMAND_TOOL,
+  S as SEMANTIC_ESCALATIONS,
+  H as SEND_EMAIL_TOOL,
+  J 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,
+  K as WEB_TOOLS,
+  N as WRITE_FILE_TOOL,
+  O as abandonPlan,
+  Q as applyLayerSettings,
+  T as applyPendingAction,
+  U as assertPublicHttpUrl,
+  V as braveSearch,
+  X as buildClaudePrompt,
   buildPlanFromTemplate,
-  y as buildWhyChain,
-  z as classifyError,
-  classifyRisk,
-  G as classifyToolYield,
-  H as classifyTurnIntent,
-  J as computePlanPosition,
-  K as createPlanRecord,
-  M as createResendSender,
+  Y as buildWhyChain,
+  Z as checkApiKeyFormat,
+  _ as classifyError,
+  $ as classifyRisk,
+  a1 as classifyToolYield,
+  a2 as classifyTurnIntent,
+  a3 as cleanApiKey,
+  a4 as computePlanPosition,
+  a5 as createPlanRecord,
+  a6 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,
+  a7 as createSmtpSender,
+  a8 as decisionNote,
+  a9 as decompositionReframeEnabled,
+  aa as defaultExportFilename,
+  ac as detectHomogeneousBatchList,
+  ad as discardPendingAction,
+  ae as effectiveState,
+  ag as escalationEnabled,
+  ah as estimateCostUsd,
+  ai as executeActionTool,
+  aj as executeFileTool,
+  ak as executeShellTool,
+  al as executeWebTool,
+  am as explicitEnvOverride,
+  an as findLayer,
+  ap as formatCostSummary,
+  aq as formatDoctorReport,
+  ar as formatEmailApprovalReason,
+  as as formatGoalGraphState,
+  au as formatLayerListing,
+  av as formatMemoryArchive,
+  ax as formatMemoryHistory,
+  ay as formatMemoryInjection,
+  aA as formatMemoryStatus,
+  aB as formatMemorySummary,
+  aD as formatPlanProgress,
+  aE as formatSearchResults,
+  aH as formatTranscriptMarkdown,
+  aJ as getProviderSetup,
+  aK as harnessGatePolicy,
+  aL as injectionDetectionEnabled,
+  aM as isAdaptivePolicyEnabled,
+  aO as isGoalGraphEnabled,
+  aP as isGoalGraphSuggestEnabled,
+  aQ as isLayerPolicyMode,
+  aR as isLikelyEmailAddress,
+  aS as isPlanGraphEnabled,
+  aT as isPolicyRecordingEnabled,
+  aV as isToggleable,
+  aW as lexicalActive,
+  aX as lexicalOffEnvValue,
+  aY as listTemplateNames,
+  aZ as loadActivePlan,
+  a_ as loadPendingAction,
+  a$ as loadTemplate,
+  b0 as lowerConfidenceSourceLines,
+  b1 as matchTemplateIfConfident,
+  b3 as memoryStatusChecks,
+  b4 as nextPendingTask,
+  b5 as nodeDisplayName,
+  b6 as nodeToLayer,
+  b7 as normalizeAmbiguityGuardMode,
+  b8 as normalizeAskMode,
+  b9 as normalizeGoalGraphMode,
+  ba as normalizeGoalGraphSuggestMode,
+  bb as normalizeLayerPolicyMode,
+  bc as normalizeOneLoopMode,
+  bd as normalizePlanGraphMode,
+  be as normalizePlanMode,
+  bg as parseClaudeCliOutput,
+  bj as pickTemplateForTask,
+  bk as planCompletionPct,
+  bl as planToSnapshot,
+  bn as resolveAmbiguityGuardMode,
+  bo as resolveAskMode,
+  bp as resolveConfig,
+  bq as resolveEscalationPlan,
+  br as resolveGoalGraphMode,
+  bs as resolveGoalGraphSuggestMode,
+  bt as resolveInWorkspace,
+  bu as resolveLayerPolicyMode,
+  bv as resolveLayerPolicyModeFromConfig,
+  bw as resolveLexicalMode,
+  bx as resolveLexicalOff,
+  by as resolveMemoryWriteMode,
+  bz as resolveOneLoopMode,
+  bA as resolvePlanGraphMode,
+  bB as resolvePlanMode,
+  bC as sanitizeLayerChoices,
+  bD as savePlan,
+  bF as stagePendingAction,
+  bG as stagedActionInput,
+  bI as stripMcpToolPrefix,
+  bJ as summarizeToolStep,
+  bK as syncHarnessLexicalEnv,
+  bL as testApiKey,
+  bM as turnPolicyBudget,
+  bN as updatePlanFromRun,
   validateAskResponse,
-  aI as validateConfig
+  bO as validateConfig,
+  bP as withLayerChoice
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../src/plan-builder.ts","../src/scripted-llm-client.ts"],"sourcesContent":["import type { ILLMClient, TokenUsage } from '@buildaharness/runtime'\nimport type { DecomposedTaskSpec } from './decomposition-classifier.js'\nimport type { PlanTemplate } from './plan-templates/index.js'\n\nexport interface Plan {\n  templateName: string\n  successCriteria: string\n  tasks: DecomposedTaskSpec[]\n  /**\n   * Why this approach, not just what the success criteria are — optional for now since neither\n   * buildPlanFromTemplate's template-personalization call nor any other current producer of a\n   * Plan asks the LLM for one; plan-store.ts's createPlanRecord defaults it to '' when absent.\n   * A future from-scratch drafting path (plan mode's P3) is expected to populate it.\n   */\n  rationale?: string\n}\n\nconst PLAN_SCHEMA = {\n  type: 'object',\n  properties: {\n    tasks: {\n      type: 'array',\n      items: {\n        type: 'object',\n        properties: {\n          id: { type: 'string' },\n          description: { type: 'string' },\n          depends_on: { type: 'array', items: { type: 'string' } },\n        },\n        required: ['id', 'description', 'depends_on'],\n      },\n    },\n  },\n  required: ['tasks'],\n}\n\nfunction buildSystemPrompt(template: PlanTemplate): string {\n  const skeleton = template.tasks\n    .map((t) => `- id: ${t.id}; title: ${t.title}; depends_on: [${t.depends_on.join(', ')}]`)\n    .join('\\n')\n  return (\n    `You are adapting a \"${template.name}\" plan template to a specific user request. ` +\n    `Here is the template's task skeleton — keep the exact same ids and depends_on structure, ` +\n    `one output task per skeleton task, but personalize each description to the actual request:\\n${skeleton}\\n\\n` +\n    `Success criteria for this kind of plan: ${template.success_criteria}\\n\\n` +\n    'Phrase each `description` starting with the concrete subject or object it acts on (e.g. \"the login tests: ' +\n    'rerun after the config fix\" rather than \"rerun the login tests after the config fix\"), so later comparisons ' +\n    \"against this task's completion/failure beliefs share matching vocabulary. \" +\n    'Respond with JSON only, no prose: {\"tasks\":[{\"id\": string, \"description\": string, \"depends_on\": ' +\n    'string[]}]}. `id` and `depends_on` values must exactly match the skeleton above.'\n  )\n}\n\n// Only the shape the LLM actually returns (id/description/depends_on) — riskLevel isn't asked for\n// here at all (see buildPlanFromTemplate's doc comment for why) and gets attached afterward from\n// the template's own already-curated risk_level, so this is deliberately narrower than\n// DecomposedTaskSpec itself.\ninterface RawPlanTask {\n  id: string\n  description: string\n  depends_on: string[]\n}\n\nfunction isRawPlanTask(value: unknown): value is RawPlanTask {\n  if (typeof value !== 'object' || value === null) return false\n  const v = value as Record<string, unknown>\n  return (\n    typeof v.id === 'string' &&\n    typeof v.description === 'string' &&\n    Array.isArray(v.depends_on) &&\n    v.depends_on.every((d) => typeof d === 'string')\n  )\n}\n\n/**\n * Spends one real LLM call personalizing `template`'s task skeleton to `message` —\n * only called once classifyTurnIntent has already named a matchedPlanTemplate, so an\n * ordinary turn never pays for this. Same \"malformed/incomplete JSON is the expected\n * failure mode, not the edge case\" fallback classifyTurnIntent itself uses: any parse\n * failure or a response with fewer than 2 usable tasks returns null, meaning \"fall back to\n * the caller's own ad hoc decomposition for this turn\" rather than throwing.\n *\n * Each output task's `riskLevel` is attached from the matching skeleton task's own\n * `risk_level` (curated by whoever wrote the template's JSON) by id, not asked of the LLM —\n * the template already has this, more accurately than an LLM re-deriving it from a\n * personalized one-line description would, and it costs zero extra output tokens. Falls back\n * to 'LOW' only for the pathological case of a task id the LLM invented that doesn't match any\n * skeleton task (the id/depends_on-must-match-skeleton instruction above means this should not\n * happen in practice).\n */\nexport async function buildPlanFromTemplate(\n  llmClient: ILLMClient,\n  message: string,\n  template: PlanTemplate,\n  model?: string,\n  onUsage?: (usage: TokenUsage) => void,\n): Promise<Plan | null> {\n  try {\n    const response = await llmClient.callChatStructured(\n      [\n        { role: 'system', content: buildSystemPrompt(template) },\n        { role: 'user', content: message },\n      ],\n      undefined,\n      { model, onUsage, structuredOutput: { schema: PLAN_SCHEMA } },\n    )\n    const parsed = JSON.parse(response.content) as { tasks?: unknown }\n    if (!Array.isArray(parsed.tasks)) return null\n    const rawTasks = parsed.tasks.filter(isRawPlanTask)\n    if (rawTasks.length <= 1) return null\n    const riskByTemplateId = new Map(template.tasks.map((t) => [t.id, t.risk_level]))\n    const tasks: DecomposedTaskSpec[] = rawTasks.map((t) => ({ ...t, riskLevel: riskByTemplateId.get(t.id) ?? 'LOW' }))\n    return { templateName: template.name, successCriteria: template.success_criteria, tasks }\n  } catch {\n    return null\n  }\n}\n","import type {\n  ChatMessage,\n  ChatOptions,\n  ILLMClient,\n  LLMStructuredResponse,\n  ToolDefinition,\n} from '@buildaharness/runtime'\nimport { classifyRisk } from './risk-classifier.js'\n\n/**\n * A deterministic, network-free {@link ILLMClient} for tests and demos — the one publicly\n * supported way to drive a real `PersonalAssistant` turn end to end without a proxy, an API key,\n * or a live model. Built for the internal plan phase B1 (the browser-e2e lane\n * that unblocks the `ASSISTANT_ONE_LOOP` default-flip), and reusable by chat-ui's `demo-seed.ts`.\n *\n * It mirrors the shape of the internal `ScriptedToolLLMClient` that `assistant.test.ts` has used\n * for a long time: every turn spends exactly one mandatory `classifyTurnIntent` call up front,\n * which this client recognises (by a distinctive phrase from that classifier's system prompt) and\n * answers on its own from a lightweight, deterministic default — so `responses` only has to\n * script the *tool loop / one-loop proposer's* own calls, not that bookkeeping call.\n *\n * `responses` entries are consumed in order, one per non-classifier `callChatStructured` call:\n *   - a plain `string` → `{ content: string }` (a final answer, no tool calls)\n *   - an `LLMStructuredResponse` → use as-is (set `toolCalls` to simulate the model calling a tool)\n *\n * `callChat`/`callChatSync` (the no-tools reply path, and post-approval synthesis) stream\n * `streamChunks` (default: `['']`).\n */\nexport interface ScriptedLLMClientScript {\n  /** Ordered structured responses for the tool loop / one-loop proposer. A bare string is shorthand for a final answer with no tool calls. */\n  responses?: Array<string | LLMStructuredResponse>\n  /** Chunks streamed from `callChat`/`callChatSync`. Defaults to `['']`. */\n  streamChunks?: string[]\n  /**\n   * Per-user-message override of the auto-answered `classifyTurnIntent` JSON fields (e.g.\n   * `{ isTrivial: true }`, `{ riskLevel: 'HIGH' }`, `{ decomposedTasks: [...] }`). Return\n   * `undefined` to keep the derived default for that message.\n   */\n  classify?: (userMessage: string) => Record<string, unknown> | undefined\n}\n\n/** The phrase that opens `turn-intent-classifier.ts`'s system prompt — stable, and how every scripted client tells that mandatory call apart from a real tool-loop call. */\nconst TURN_INTENT_MARKER = 'eight independent judgments'\n\nfunction isTurnIntentRequest(messages: ChatMessage[]): boolean {\n  return messages.some((m) => m.role === 'system' && m.content.includes(TURN_INTENT_MARKER))\n}\n\n/**\n * The deterministic stand-in for what a real model would return for `classifyTurnIntent` —\n * risk comes from the same lexical `classifyRisk` the real fallback path uses; everything else\n * is inert (not trivial, not a reminder, no decomposition, no plan template) unless `override`\n * says otherwise. `isTrivial` defaults to `false` so a scripted turn actually exercises the\n * harness loop (the interesting case for one-loop parity tests); pass `{ isTrivial: true }` via\n * `classify` for the triviality fast path.\n */\nfunction deriveTurnIntentJSON(messages: ChatMessage[], override?: Record<string, unknown>): string {\n  const userContent = messages.find((m) => m.role === 'user')?.content ?? ''\n  const risk = classifyRisk(userContent)\n  const isReminderRequest = risk.reason.includes('reminder')\n  const base = {\n    riskLevel: risk.riskLevel,\n    riskReason: risk.reason,\n    isTrivial: false,\n    decomposedTasks: [],\n    isReminderRequest,\n    isBulkReminderRequest: isReminderRequest && risk.requiresApproval,\n    isAbandonRequest: false,\n    matchedPlanTemplate: null,\n    needsMultiStepPlan: false,\n    statesDurableFacts: [],\n  }\n  return JSON.stringify({ ...base, ...override })\n}\n\nclass ScriptedLLMClient implements ILLMClient {\n  /** Non-classifier `callChatStructured` calls made so far — the index into `responses`. */\n  toolCalls = 0\n  private responseIndex = 0\n\n  constructor(private readonly script: ScriptedLLMClientScript) {}\n\n  private get streamChunks(): string[] {\n    return this.script.streamChunks && this.script.streamChunks.length > 0 ? this.script.streamChunks : ['']\n  }\n\n  async *callChat(_messages: ChatMessage[], _options?: ChatOptions): AsyncIterable<string> {\n    for (const chunk of this.streamChunks) yield chunk\n  }\n\n  async callChatSync(messages: ChatMessage[], options?: ChatOptions): Promise<string> {\n    const chunks: string[] = []\n    for await (const chunk of this.callChat(messages, options)) chunks.push(chunk)\n    return chunks.join('')\n  }\n\n  async callChatStructured(messages: ChatMessage[], _tools?: ToolDefinition[], _options?: ChatOptions): Promise<LLMStructuredResponse> {\n    if (isTurnIntentRequest(messages)) {\n      const userContent = messages.find((m) => m.role === 'user')?.content ?? ''\n      return { content: deriveTurnIntentJSON(messages, this.script.classify?.(userContent)) }\n    }\n    this.toolCalls++\n    const responses = this.script.responses ?? []\n    if (this.responseIndex >= responses.length) {\n      throw new Error(\n        `createScriptedLLMClient: no scripted response for tool-loop call #${this.responseIndex + 1} (scripted ${responses.length})`,\n      )\n    }\n    const next = responses[this.responseIndex++]\n    return typeof next === 'string' ? { content: next } : next\n  }\n}\n\n/**\n * Builds a scripted {@link ILLMClient}. See {@link ScriptedLLMClientScript}. The returned value\n * is a plain `ILLMClient` — pass it straight to `PersonalAssistant.create({ llmClient })`.\n */\nexport function createScriptedLLMClient(script: ScriptedLLMClientScript = {}): ILLMClient {\n  return new ScriptedLLMClient(script)\n}\n"],"names":["t","v","m"],"mappings":"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"}
+{"version":3,"file":"index.js","sources":["../src/plan-builder.ts","../src/scripted-llm-client.ts"],"sourcesContent":["import type { ILLMClient, TokenUsage } from '@buildaharness/runtime'\nimport type { DecomposedTaskSpec } from './decomposition-classifier.js'\nimport type { PlanTemplate } from './plan-templates/index.js'\nimport { parseModelJson } from './model-json.js'\n\nexport interface Plan {\n  templateName: string\n  successCriteria: string\n  tasks: DecomposedTaskSpec[]\n  /**\n   * Why this approach, not just what the success criteria are — optional for now since neither\n   * buildPlanFromTemplate's template-personalization call nor any other current producer of a\n   * Plan asks the LLM for one; plan-store.ts's createPlanRecord defaults it to '' when absent.\n   * A future from-scratch drafting path (plan mode's P3) is expected to populate it.\n   */\n  rationale?: string\n}\n\nconst PLAN_SCHEMA = {\n  type: 'object',\n  properties: {\n    tasks: {\n      type: 'array',\n      items: {\n        type: 'object',\n        properties: {\n          id: { type: 'string' },\n          description: { type: 'string' },\n          depends_on: { type: 'array', items: { type: 'string' } },\n        },\n        required: ['id', 'description', 'depends_on'],\n      },\n    },\n  },\n  required: ['tasks'],\n}\n\nfunction buildSystemPrompt(template: PlanTemplate): string {\n  const skeleton = template.tasks\n    .map((t) => `- id: ${t.id}; title: ${t.title}; depends_on: [${t.depends_on.join(', ')}]`)\n    .join('\\n')\n  return (\n    `You are adapting a \"${template.name}\" plan template to a specific user request. ` +\n    `Here is the template's task skeleton — keep the exact same ids and depends_on structure, ` +\n    `one output task per skeleton task, but personalize each description to the actual request:\\n${skeleton}\\n\\n` +\n    `Success criteria for this kind of plan: ${template.success_criteria}\\n\\n` +\n    'Phrase each `description` starting with the concrete subject or object it acts on (e.g. \"the login tests: ' +\n    'rerun after the config fix\" rather than \"rerun the login tests after the config fix\"), so later comparisons ' +\n    \"against this task's completion/failure beliefs share matching vocabulary. \" +\n    'Respond with JSON only, no prose: {\"tasks\":[{\"id\": string, \"description\": string, \"depends_on\": ' +\n    'string[]}]}. `id` and `depends_on` values must exactly match the skeleton above.'\n  )\n}\n\n// Only the shape the LLM actually returns (id/description/depends_on) — riskLevel isn't asked for\n// here at all (see buildPlanFromTemplate's doc comment for why) and gets attached afterward from\n// the template's own already-curated risk_level, so this is deliberately narrower than\n// DecomposedTaskSpec itself.\ninterface RawPlanTask {\n  id: string\n  description: string\n  depends_on: string[]\n}\n\nfunction isRawPlanTask(value: unknown): value is RawPlanTask {\n  if (typeof value !== 'object' || value === null) return false\n  const v = value as Record<string, unknown>\n  return (\n    typeof v.id === 'string' &&\n    typeof v.description === 'string' &&\n    Array.isArray(v.depends_on) &&\n    v.depends_on.every((d) => typeof d === 'string')\n  )\n}\n\n/**\n * Spends one real LLM call personalizing `template`'s task skeleton to `message` —\n * only called once classifyTurnIntent has already named a matchedPlanTemplate, so an\n * ordinary turn never pays for this. Same \"malformed/incomplete JSON is the expected\n * failure mode, not the edge case\" fallback classifyTurnIntent itself uses: any parse\n * failure or a response with fewer than 2 usable tasks returns null, meaning \"fall back to\n * the caller's own ad hoc decomposition for this turn\" rather than throwing.\n *\n * Each output task's `riskLevel` is attached from the matching skeleton task's own\n * `risk_level` (curated by whoever wrote the template's JSON) by id, not asked of the LLM —\n * the template already has this, more accurately than an LLM re-deriving it from a\n * personalized one-line description would, and it costs zero extra output tokens. Falls back\n * to 'LOW' only for the pathological case of a task id the LLM invented that doesn't match any\n * skeleton task (the id/depends_on-must-match-skeleton instruction above means this should not\n * happen in practice).\n */\nexport async function buildPlanFromTemplate(\n  llmClient: ILLMClient,\n  message: string,\n  template: PlanTemplate,\n  model?: string,\n  onUsage?: (usage: TokenUsage) => void,\n): Promise<Plan | null> {\n  try {\n    const response = await llmClient.callChatStructured(\n      [\n        { role: 'system', content: buildSystemPrompt(template) },\n        { role: 'user', content: message },\n      ],\n      undefined,\n      { model, onUsage, structuredOutput: { schema: PLAN_SCHEMA } },\n    )\n    const parsed = parseModelJson(response.content) as { tasks?: unknown }\n    if (!Array.isArray(parsed.tasks)) return null\n    const rawTasks = parsed.tasks.filter(isRawPlanTask)\n    if (rawTasks.length <= 1) return null\n    const riskByTemplateId = new Map(template.tasks.map((t) => [t.id, t.risk_level]))\n    const tasks: DecomposedTaskSpec[] = rawTasks.map((t) => ({ ...t, riskLevel: riskByTemplateId.get(t.id) ?? 'LOW' }))\n    return { templateName: template.name, successCriteria: template.success_criteria, tasks }\n  } catch {\n    return null\n  }\n}\n","import type {\n  ChatMessage,\n  ChatOptions,\n  ILLMClient,\n  LLMStructuredResponse,\n  ToolDefinition,\n} from '@buildaharness/runtime'\nimport { classifyRiskLexical } from './risk-classifier.js'\n\n/**\n * A deterministic, network-free {@link ILLMClient} for tests and demos — the one publicly\n * supported way to drive a real `PersonalAssistant` turn end to end without a proxy, an API key,\n * or a live model. Built for the internal plan phase B1 (the browser-e2e lane\n * that unblocks the `ASSISTANT_ONE_LOOP` default-flip), and reusable by chat-ui's `demo-seed.ts`.\n *\n * It mirrors the shape of the internal `ScriptedToolLLMClient` that `assistant.test.ts` has used\n * for a long time: every turn spends exactly one mandatory `classifyTurnIntent` call up front,\n * which this client recognises (by a distinctive phrase from that classifier's system prompt) and\n * answers on its own from a lightweight, deterministic default — so `responses` only has to\n * script the *tool loop / one-loop proposer's* own calls, not that bookkeeping call.\n *\n * `responses` entries are consumed in order, one per non-classifier, non-side-call\n * `callChatStructured` call:\n *   - a plain `string` → `{ content: string }` (a final answer, no tool calls)\n *   - an `LLMStructuredResponse` → use as-is (set `toolCalls` to simulate the model calling a tool)\n *\n * A handful of other calls are auxiliary semantic escalations (the change reviewer, the failure\n * matcher, the LLM injection classifier) that a tool-using turn can trigger without any script\n * author asking for them — with lexicalMode's default now `disabled`, the lexical checks these\n * sit on top of never short-circuit them, so they fire on every qualifying call, not just ones a\n * scenario is specifically testing. Answered from a safe, inert default (see SIDE_CALL_MARKERS)\n * so they never silently consume a `responses` slot meant for the real tool loop — the exact\n * silent-consumption bug that broke chat-ui's W5 proxy e2e test when the default flipped. Override\n * or add to this list via `sideResponses` for a test that specifically wants one of these calls to\n * answer something else (e.g. a genuine injection flag).\n *\n * `callChat`/`callChatSync` (the no-tools reply path, and post-approval synthesis) stream\n * `streamChunks` (default: `['']`).\n */\nexport interface ScriptedLLMClientScript {\n  /** Ordered structured responses for the tool loop / one-loop proposer. A bare string is shorthand for a final answer with no tool calls. */\n  responses?: Array<string | LLMStructuredResponse>\n  /** Chunks streamed from `callChat`/`callChatSync`. Defaults to `['']`. */\n  streamChunks?: string[]\n  /**\n   * Per-user-message override of the auto-answered `classifyTurnIntent` JSON fields (e.g.\n   * `{ isTrivial: true }`, `{ riskLevel: 'HIGH' }`, `{ decomposedTasks: [...] }`). Return\n   * `undefined` to keep the derived default for that message.\n   */\n  classify?: (userMessage: string) => Record<string, unknown> | undefined\n  /**\n   * Overrides/extends SIDE_CALL_MARKERS' default answers for a system-prompt substring — checked\n   * before the built-in defaults, so a test can make the change reviewer/failure matcher/injection\n   * classifier answer something other than \"nothing to see here\" without it consuming a\n   * `responses` slot either way. `[marker, rawJsonContent]` pairs, same shape as the built-ins.\n   */\n  sideResponses?: Array<[string, string]>\n}\n\n/**\n * Known auxiliary semantic-escalation system prompts and their safe, inert default answer — see\n * ScriptedLLMClientScript's doc comment. Kept in sync by hand with each check's own system prompt\n * (review-checker.ts, failure-mode-matcher.ts, trust-tagging.ts, grounding-check.ts, task-completion-check.ts, constraint-check.ts, semantic-compaction.ts, source-reliability.ts, semantic-hypotheses.ts, episodic-digest.ts, memory-consolidation.ts, memory-reviewer.ts) since there's no shared constant\n * to import without a circular dependency back into this package's own public surface.\n */\nexport const SIDE_CALL_MARKERS: Array<[string, string]> = [\n  ['You check whether a proposed action genuinely conflicts', '{\"conflict\":false}'],\n  ['You match a set of observed symptoms against a curated library', 'null'],\n  ['You are a security classifier analyzing untrusted external content', '{\"flagged\":false}'],\n  ['You check whether an assistant\\'s reply is faithful to the raw results', '{\"verdict\":\"grounded\"}'],\n  ['You judge whether an assistant actually accomplished a task', '{\"done\":true}'],\n  ['You condense the earlier part of a conversation', '{\"summary\":\"\"}'],\n  ['You judge whether an assistant\\'s reply violates constraints', '{\"violations\":[]}'],\n  ['You weigh the reliability of the sources an assistant read', '{\"assessments\":[],\"weighed\":true}'],\n  ['You propose competing explanations for an underdetermined request', '{\"hypotheses\":[]}'],\n  ['You decide which explanations a set of new observations rules out', '{\"contradicted\":[]}'],\n  ['You write a session handoff digest', '{\"digest\":null}'],\n  ['You consolidate a small store of remembered facts about a user', '{\"proposals\":[]}'],\n  ['You review what a user said across several turns', '{\"ops\":[]}'],\n  ['You check proposed memory entries against what a user actually said', '{\"verdicts\":[]}'],\n]\n\n/** The phrase that opens `turn-intent-classifier.ts`'s system prompt — stable, and how every scripted client tells that mandatory call apart from a real tool-loop call. */\nconst TURN_INTENT_MARKER = ' independent judgments'\n\nfunction isTurnIntentRequest(messages: ChatMessage[]): boolean {\n  return messages.some((m) => m.role === 'system' && m.content.includes(TURN_INTENT_MARKER))\n}\n\n/**\n * The deterministic stand-in for what a real model would return for `classifyTurnIntent` —\n * risk comes from the same lexical `classifyRisk` the real fallback path uses; everything else\n * is inert (not trivial, not a reminder, no decomposition, no plan template) unless `override`\n * says otherwise. `isTrivial` defaults to `false` so a scripted turn actually exercises the\n * harness loop (the interesting case for one-loop parity tests); pass `{ isTrivial: true }` via\n * `classify` for the triviality fast path.\n */\nfunction deriveTurnIntentJSON(messages: ChatMessage[], override?: Record<string, unknown>): string {\n  const userContent = messages.find((m) => m.role === 'user')?.content ?? ''\n  const risk = classifyRiskLexical(userContent)\n  const isReminderRequest = risk.reason.includes('reminder')\n  const base = {\n    riskLevel: risk.riskLevel,\n    riskReason: risk.reason,\n    isTrivial: false,\n    decomposedTasks: [],\n    isReminderRequest,\n    isBulkReminderRequest: isReminderRequest && risk.requiresApproval,\n    isAbandonRequest: false,\n    isPlanQuestion: false,\n    isUnderdetermined: false,\n    matchedPlanTemplate: null,\n    needsMultiStepPlan: false,\n    statesDurableFacts: [],\n  }\n  return JSON.stringify({ ...base, ...override })\n}\n\nclass ScriptedLLMClient implements ILLMClient {\n  /** Non-classifier `callChatStructured` calls made so far — the index into `responses`. */\n  toolCalls = 0\n  private responseIndex = 0\n\n  constructor(private readonly script: ScriptedLLMClientScript) {}\n\n  private get streamChunks(): string[] {\n    return this.script.streamChunks && this.script.streamChunks.length > 0 ? this.script.streamChunks : ['']\n  }\n\n  async *callChat(_messages: ChatMessage[], _options?: ChatOptions): AsyncIterable<string> {\n    for (const chunk of this.streamChunks) yield chunk\n  }\n\n  async callChatSync(messages: ChatMessage[], options?: ChatOptions): Promise<string> {\n    const chunks: string[] = []\n    for await (const chunk of this.callChat(messages, options)) chunks.push(chunk)\n    return chunks.join('')\n  }\n\n  async callChatStructured(messages: ChatMessage[], _tools?: ToolDefinition[], _options?: ChatOptions): Promise<LLMStructuredResponse> {\n    if (isTurnIntentRequest(messages)) {\n      const userContent = messages.find((m) => m.role === 'user')?.content ?? ''\n      return { content: deriveTurnIntentJSON(messages, this.script.classify?.(userContent)) }\n    }\n    const system = messages.find((m) => m.role === 'system')?.content ?? ''\n    const side = [...(this.script.sideResponses ?? []), ...SIDE_CALL_MARKERS].find(([marker]) => system.includes(marker))\n    if (side) return { content: side[1] }\n    this.toolCalls++\n    const responses = this.script.responses ?? []\n    if (this.responseIndex >= responses.length) {\n      throw new Error(\n        `createScriptedLLMClient: no scripted response for tool-loop call #${this.responseIndex + 1} (scripted ${responses.length})`,\n      )\n    }\n    const next = responses[this.responseIndex++]\n    return typeof next === 'string' ? { content: next } : next\n  }\n}\n\n/**\n * Builds a scripted {@link ILLMClient}. See {@link ScriptedLLMClientScript}. The returned value\n * is a plain `ILLMClient` — pass it straight to `PersonalAssistant.create({ llmClient })`.\n */\nexport function createScriptedLLMClient(script: ScriptedLLMClientScript = {}): ILLMClient {\n  return new ScriptedLLMClient(script)\n}\n"],"names":["t","v","m"],"mappings":"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"}

package/dist/layer-policy-flag.d.ts

@@ -0,0 +1,13 @@
+import { DEFAULT_LAYER_POLICY_MODE, LayerPolicyMode } from '@buildaharness/harness';
+export type { LayerPolicyMode };
+export { DEFAULT_LAYER_POLICY_MODE };
+export declare function isLayerPolicyMode(v: unknown): v is LayerPolicyMode;
+/** The mode a resolved config means; unset ⇒ the package default (static). */
+export declare function resolveLayerPolicyModeFromConfig(mode: LayerPolicyMode | undefined): LayerPolicyMode;
+/** The single place a resolved `config.layerPolicyMode` becomes "does adaptive behaviour execute?". Shadow does not. */
+export declare function isAdaptivePolicyEnabled(mode: LayerPolicyMode | undefined): boolean;
+/** True when decisions should be computed and recorded (shadow or adaptive). */
+export declare function isPolicyRecordingEnabled(mode: LayerPolicyMode | undefined): boolean;
+/** Unset/empty ⇒ default silently; an unrecognized value ⇒ default with a warning naming `varName`. */
+export declare function normalizeLayerPolicyMode(raw: string | undefined, varName?: string): LayerPolicyMode;
+export declare function resolveLayerPolicyMode(env: NodeJS.ProcessEnv): LayerPolicyMode;