@buildaharness/aielia 0.3.1 → 0.3.2

package/dist/file-tools-mcp-server.mjs

@@ -3,7 +3,7 @@
  * MCP stdio server exposing read_file/list_directory/write_file/fetch_url/
  * create_reminder/list_reminders/run_shell_command to the Claude CLI — the same
  * MCP mechanism already proven for the coaching/planner agents (see
- * adapter/agents/coaching/mcp_server.py, adapter/agents/planner/mcp_server.py: both
+ * the coaching and planner agents' MCP servers: both
  * FastMCP stdio servers started via --mcp-config, alongside --dangerously-skip-permissions
  * so a headless `claude -p` call can actually invoke them without an interactive
  * permission prompt — this server is started the same way, for the same reason).
@@ -468,7 +468,7 @@ export async function fetchUrlSafely(url) {
 // DuckDuckGo's HTML endpoint resets the TLS connection outright for any
 // non-browser client, a block beneath the HTTP layer no request header or retry
 // can work around (confirmed live during
-// plans/browser_web_tools_via_proxy_plan.html's W8).
+// the internal plan's W8).
 
 const WEB_SEARCH_MAX_RESULTS = 5
 const NO_WEB_RESULTS_LITERAL = 'No results found.'

package/dist/file-tools.d.ts

@@ -27,6 +27,12 @@ export declare function resolveInWorkspace(workspaceRoot: string, requestedPath:
  * doesn't implement `realpath`.
  */
 export declare function assertRealPathInWorkspace(backend: FsBackend, workspaceRoot: string, resolvedPath: string): Promise<void>;
+/**
+ * Reads a file's current on-disk content for building a diff preview against a proposed write
+ * (see diff-format.ts's formatWriteDiff) — `undefined` if the file doesn't exist yet, the same
+ * "nothing to diff against" signal `applyPendingAction`'s own `previousContent` uses.
+ */
+export declare function readCurrentFileContent(backend: FsBackend, workspaceRoot: string, requestedPath: string): Promise<string | undefined>;
 export declare const READ_FILE_TOOL: ToolDefinition;
 export declare const LIST_DIRECTORY_TOOL: ToolDefinition;
 export declare const WRITE_FILE_TOOL: ToolDefinition;
@@ -115,7 +121,9 @@ export interface ShellExecutionResult {
 }
 export type ApplyPendingActionResult = ({
     kind: 'write';
-} & PendingActionRecord) | ({
+} & PendingActionRecord & {
+    previousContent?: string;
+}) | ({
     kind: 'shell';
 } & PendingActionRecord & {
     execution: ShellExecutionResult;
@@ -130,7 +138,7 @@ export type ApplyPendingActionResult = ({
  * Stages an action for later approval. `id` is a random UUID, not derived from the session — see
  * T4 of the file-tools plan.
  *
- * Structural hardening principle (plans/lexical_functions_hardening_plan.html Phase 4 step 1):
+ * Structural hardening principle (the internal plan Phase 4 step 1):
  * this gate runs unconditionally on the tool call's own concrete arguments (the literal path/
  * content or command/cwd being proposed), independent of whatever risk-classifier.ts's pre-flight
  * text patterns concluded about the user's phrasing. That's deliberate — it's the same "gate on

package/dist/harness-bridge.d.ts

@@ -25,7 +25,7 @@ export interface HarnessRunParams {
     userMessage: string;
     facts: UserFact[];
     /**
-     * Phase 4 of plans/personal_assistant_fact_extraction_llm_confidence_plan.html: this turn's
+     * Phase 4 of the internal plan: this turn's
      * merged lexical+LLM fact list — memory-service.ts's `buildTurnFacts()`, the exact helper
      * `recordFacts()` itself uses to decide what to write to the fact stores — fed into
      * `factExtractor` below as this turn's "isNew" belief seed. Replaces this file's former direct
@@ -43,7 +43,7 @@ export interface HarnessRunParams {
     onProgress?: (progress: AssistantProgress) => void;
     onUsage: (usage: TokenUsage) => void;
     /**
-     * R2 of plans/harness_d2_one_loop_rewire_plan.html: a harness-driven proposer (built by
+     * R2 of the internal plan: a harness-driven proposer (built by
      * AgentLoop.createHarnessProposer) swapped in as the toolExecutors 'default' entry instead of
      * `() => draftReply`, when the one-loop flag is enabled and a caller actually supplies one.
      * `undefined` (every caller today, before R3 wires runTurn to build one) means `run()` falls
@@ -54,7 +54,7 @@ export interface HarnessRunParams {
     oneLoopProposer?: (toolCtx: ToolExecutorContext) => unknown | Promise<unknown>;
     /**
      * Trajectory Supervisor GATHER_EVIDENCE host (S5 of
-     * plans/harness_trajectory_supervisor_plan.html) — AgentLoop.runSupervisorInvestigation bound
+     * the internal plan) — AgentLoop.runSupervisorInvestigation bound
      * to this turn's read-only tools + risk hint. Passed straight through to
      * HarnessRunOptions.runInvestigation. `undefined` (every caller until a supervisorDecider is
      * also wired) → GATHER_EVIDENCE degrades to CONTINUE inside the harness, so this is inert by
@@ -62,7 +62,7 @@ export interface HarnessRunParams {
      */
     runInvestigation?: (req: InvestigationRequestData) => Promise<InvestigationFinding[]>;
     /**
-     * Q2 of plans/ask_question_and_plan_mode_plan.html — the already-resolved effective askMode
+     * Q2 of the internal plan — the already-resolved effective askMode
      * (Q1's three-tier INV-29 resolution), threaded straight into HarnessRunOptions.askMode so the
      * harness's own supervisor ASK_USER path (S3) batches questions consistently with
      * AskClarificationService's own gating. Also decides whether a thrown EscalationHalt carrying

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 { z as classifyRisk } from "./cli-session-D0uLdT2A.js";
-import { A, a, b, C, c, D, e, f, g, h, F, i, I, L, j, k, l, P, m, n, R, o, S, p, W, q, r, s, t, u, v, w, x, y, B, G, H, J, K, M, N, Q, T, V, X, Y, Z, _, a0, a1, a2, a6, a7, a8, ab, ae, af, ag, ah, ai, aj, ak, al, am, an, ao, ap, aq, as, at, au, av, aw, ax, ay, az, aB, aC, aE, aF, aG, aH } from "./cli-session-D0uLdT2A.js";
+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 { MAX_OPTIONS_PER_QUESTION, MAX_QUESTIONS_PER_BATCH, MIN_OPTIONS_PER_QUESTION, validateAskResponse } from "@buildaharness/harness";
 const PLAN_SCHEMA = {
   type: "object",
@@ -128,85 +128,85 @@ export {
   e as DEFAULT_CONFIG,
   f as DEFAULT_ONE_LOOP_MODE,
   g as DEFAULT_PLAN_MODE,
-  h as EmailDeliveryError,
+  i as EmailDeliveryError,
   F as FETCH_URL_TOOL,
-  i as FILE_TOOLS,
+  j as FILE_TOOLS,
   I as InvalidEmailArgsError,
   L as LAYER_DISPLAY_NAME,
-  j as LAYER_ORDER,
-  k as LAYER_SHORT_CODE,
-  l as LIST_DIRECTORY_TOOL,
+  k as LAYER_ORDER,
+  l as LAYER_SHORT_CODE,
+  m as LIST_DIRECTORY_TOOL,
   MAX_OPTIONS_PER_QUESTION,
   MAX_QUESTIONS_PER_BATCH,
   MIN_OPTIONS_PER_QUESTION,
   P as PathOutsideWorkspaceError,
-  m as PersonalAssistant,
-  n as PrivateNetworkTargetError,
+  n as PersonalAssistant,
+  o as PrivateNetworkTargetError,
   R as READ_FILE_TOOL,
-  o as RUN_SHELL_COMMAND_TOOL,
+  p as RUN_SHELL_COMMAND_TOOL,
   S as SEND_EMAIL_TOOL,
-  p as SHELL_TOOLS,
+  q as SHELL_TOOLS,
   W as WEB_SEARCH_TOOL,
-  q as WEB_TOOLS,
-  r as WRITE_FILE_TOOL,
-  s as abandonPlan,
-  t as applyPendingAction,
-  u as assertPublicHttpUrl,
-  v as braveSearch,
-  w as buildClaudePrompt,
+  r as WEB_TOOLS,
+  s as WRITE_FILE_TOOL,
+  t as abandonPlan,
+  u as applyPendingAction,
+  v as assertPublicHttpUrl,
+  w as braveSearch,
+  x as buildClaudePrompt,
   buildPlanFromTemplate,
-  x as buildWhyChain,
-  y as classifyError,
+  y as buildWhyChain,
+  z as classifyError,
   classifyRisk,
-  B as classifyToolYield,
-  G as classifyTurnIntent,
-  H as computePlanPosition,
-  J as createPlanRecord,
-  K as createResendSender,
+  G as classifyToolYield,
+  H as classifyTurnIntent,
+  J as computePlanPosition,
+  K as createPlanRecord,
+  M as createResendSender,
   createScriptedLLMClient,
-  M as createSmtpSender,
-  N as defaultExportFilename,
-  Q as detectHomogeneousBatchList,
-  T as discardPendingAction,
-  V as estimateCostUsd,
-  X as executeActionTool,
-  Y as executeFileTool,
-  Z as executeShellTool,
-  _ as executeWebTool,
-  a0 as formatCostSummary,
-  a1 as formatDoctorReport,
-  a2 as formatEmailApprovalReason,
-  a6 as formatMemorySummary,
-  a7 as formatPlanProgress,
-  a8 as formatSearchResults,
-  ab as formatTranscriptMarkdown,
-  ae as isLikelyEmailAddress,
-  af as listTemplateNames,
-  ag as loadActivePlan,
-  ah as loadPendingAction,
-  ai as loadTemplate,
-  aj as matchTemplateIfConfident,
-  ak as nextPendingTask,
-  al as nodeDisplayName,
-  am as nodeToLayer,
-  an as normalizeAskMode,
-  ao as normalizeOneLoopMode,
-  ap as normalizePlanMode,
-  aq as parseClaudeCliOutput,
-  as as pickTemplateForTask,
-  at as planCompletionPct,
-  au as resolveAskMode,
-  av as resolveConfig,
-  aw as resolveInWorkspace,
-  ax as resolveOneLoopMode,
-  ay as resolvePlanMode,
-  az as savePlan,
-  aB as stagePendingAction,
-  aC as stagedActionInput,
-  aE as stripMcpToolPrefix,
-  aF as summarizeToolStep,
-  aG as updatePlanFromRun,
+  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,
   validateAskResponse,
-  aH as validateConfig
+  aI as validateConfig
 };
 //# 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 plans/chat_ui_browser_e2e_plan.html 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'\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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"}

package/dist/ink-select-prompt.d.ts

@@ -0,0 +1,21 @@
+import { SelectOption } from './cli.js';
+export interface SelectPromptProps {
+    /** The question text, rendered the same bold-yellow way `TuiInput`'s own `promptLabel` renders a pending askYesNo/askLine question. */
+    question: string;
+    /** Rendered in order, top to bottom — the highlighted (arrow-key-selected) option starts at index 0. Each option's `key` also doubles as its single-keystroke shortcut. */
+    options: SelectOption[];
+    /** Called once, with the chosen option's `key` — either Enter on the highlighted row, or a direct keystroke matching an option's `key`. */
+    onSubmit: (key: string) => void;
+    isActive?: boolean;
+}
+/**
+ * Phase 7 of the internal plan: an arrow-key + numbered/shortcut-key
+ * selector, replacing free-text `y`/`N` typed into the same box used for chat (the report's
+ * finding — Codex/Claude Code both use a dedicated selector for this). Deliberately a standalone
+ * component rather than a mode bolted onto `TuiInput`: `TuiInput` is a general-purpose free-text
+ * editor (word-wrap, cursor movement, history recall) that has no notion of a fixed option list,
+ * and grafting one on would tangle two unrelated input models together for no shared benefit — the
+ * two components share only the surrounding visual grammar (bold label above a round-bordered
+ * box), which each renders independently.
+ */
+export declare function SelectPrompt(props: SelectPromptProps): React.JSX.Element;

package/dist/markdown-line.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Recognizes one line of `diff-format.ts`'s output by shape: `DIFF_INDENT` followed by a
+ * right-aligned line number and a unified-diff sign character. That combination — a fixed
+ * two-space indent no ordinary assistant prose produces, paired with a line-number gutter no
+ * markdown construct produces — doesn't occur in natural writing (a markdown bullet is always
+ * `- text`, dash *then* a space with no number in front, which `CHECKBOX_RE`/plain rendering
+ * already own), so this can't misfire on a real bullet list. Context lines (sign is a plain
+ * space) are recognized too, with `color: undefined` — they still need to short-circuit
+ * `renderMarkdownLine`'s plain-text fallback below (which would otherwise prepend `ASSISTANT_BULLET`
+ * to them as if they were ordinary prose), they just aren't colored the way a real diff tool
+ * doesn't color its context lines either.
+ */
+export declare function matchDiffLine(text: string): {
+    content: string;
+    color: 'green' | 'red' | undefined;
+} | undefined;
+/**
+ * Renders one line as colored diff content if `matchDiffLine` recognizes it, otherwise
+ * `undefined` so the caller falls back to its own plain/markdown rendering. Used by
+ * `renderMarkdownLine` below (the `'assistant'`-kind, post-write confirmation) and by
+ * `tui-app.tsx`'s `'system'`-kind branch (the pre-approval preview) — the two `LogLine` kinds a
+ * `formatWriteDiff()` string actually reaches, per `classifyLineKind`.
+ */
+export declare function renderDiffLine(text: string, key: React.Key): React.JSX.Element | undefined;
+/**
+ * Colors the `[needs approval — write/shell command/…]`/`[needs approval — HIGH/…]` tag
+ * `cli.ts` prints ahead of every approval prompt (see its own `console.log` call sites) yellow —
+ * the same "worth your attention" color `StatusLine`'s own `⚠`-prefixed indicators already use —
+ * leaving the reason text after it in the default color. This line is `'system'`-classified (see
+ * `classifyLineKind`), not `'assistant'`, so it's checked from `tui-app.tsx`'s own `'system'`
+ * branch rather than from `renderMarkdownLine`.
+ */
+export declare function renderNeedsApprovalLine(text: string, key: React.Key): React.JSX.Element | undefined;
+/**
+ * Renders one committed line of assistant/system text, recognizing a leading `#`/`##`/… header or
+ * `- [ ]`/`- [x]` checkbox before falling back to plain inline-styled text. `key` is the React key
+ * for the returned element (the caller already has a per-line index from `<Static>`'s own render
+ * prop — see `tui-app.tsx`'s `LogLineText`). `continuation` is `LogLine.continuation` — true for
+ * every line of a multi-line reply after the first, which suppresses `ASSISTANT_BULLET` (the
+ * marker belongs once at the front of the whole message, not on every wrapped line).
+ */
+export declare function renderMarkdownLine(text: string, key: React.Key, continuation?: boolean): React.JSX.Element;

package/dist/mcp-server-asset.d.ts

@@ -0,0 +1,24 @@
+export declare const MCP_SERVER_FILE_NAME = "file-tools-mcp-server.mjs";
+/**
+ * The lexical pattern files file-tools-mcp-server.mjs reads at startup via
+ * `join(__dirname, 'lexical/patterns/<name>')` — they have to sit beside the extracted server,
+ * so they are embedded as SEA assets (under this same relative key) and extracted with it.
+ */
+export declare const MCP_SERVER_PATTERN_FILES: readonly ["injection-patterns.json", "fact-markers.json", "risk-patterns.json"];
+export interface SeaModule {
+    isSea(): boolean;
+    getRawAsset(key: string): ArrayBuffer;
+}
+/** `node:sea` if this process is a Node single executable application, else null. Never throws. */
+export declare function loadSea(): SeaModule | null;
+/**
+ * Absolute on-disk path to file-tools-mcp-server.mjs, which the claude-cli backend hands to the
+ * separate `claude` binary to spawn as a `node <path>` MCP subprocess.
+ *
+ * - Inside a SEA binary, `import.meta.url` is not a real file location, so the embedded asset is
+ *   extracted once (version-gated, see sea-cache.ts) and that path returned.
+ * - Otherwise (npm install, tsx), it is the file sitting next to this module, as before.
+ *
+ * `seaOverride` and `home` exist for tests; production callers pass nothing.
+ */
+export declare function resolveMcpServerPath(seaOverride?: SeaModule | null, home?: string): string;

package/dist/memory-service.d.ts

@@ -8,7 +8,7 @@ export declare const DURABLE_FACTS_KEY = "facts:durable";
 /**
  * Global, never cleared by `/new` — same retention shape as DURABLE_FACTS_KEY (a pending fact
  * shouldn't vanish just because the session changed). Phase 3 of
- * plans/personal_assistant_fact_extraction_llm_confidence_plan.html: a `model_inferred` fact
+ * the internal plan: a `model_inferred` fact
  * that reached `durable: true, confidence: 'medium'` lands here instead of being silently
  * promoted or silently dropped — see `recordFacts()`'s promotion policy and
  * `confirmPendingFact()`/`rejectPendingFact()` below.
@@ -77,7 +77,7 @@ export interface RecordFactsResult {
 }
 /**
  * The exact lexical+LLM merge `recordFacts()` uses to decide what to write to the fact stores,
- * exposed (Phase 4 of plans/personal_assistant_fact_extraction_llm_confidence_plan.html) so a
+ * exposed (Phase 4 of the internal plan) so a
  * caller can seed `HarnessRunParams.currentTurnFacts` (harness-bridge.ts's `factExtractor`) with
  * the identical merged, deduplicated list — instead of harness-bridge.ts recomputing only the free
  * lexical half and never seeing an LLM-caught fact at all, which left a same-turn LLM-caught fact

package/dist/network-containment.d.ts

@@ -1,6 +1,6 @@
 /**
  * Node-level network containment for an approved run_shell_command execution — Decision 6 of
- * plans/lexical_functions_hardening_plan.html (Phase 4 step 2). This is the network-reachability
+ * the internal plan (Phase 4 step 2). This is the network-reachability
  * half of that decision; the env-stripping half already existed in shell-executor.ts's
  * allowlistedEnv(). Deliberately not a real OS sandbox (see the plan's Decision 6 for why that
  * tradeoff was chosen): a minimal loopback-only forward proxy that relays a CONNECT tunnel

package/dist/node-display-names.d.ts

@@ -1,7 +1,7 @@
 import { LayerActivityEvent } from '@buildaharness/harness';
 export declare function nodeDisplayName(node: string | undefined): string | undefined;
 /**
- * The 11 harness layer slugs, in the fixed order CLAUDE.md's architecture table lists them —
+ * The 11 harness layer slugs, in the fixed order the internal developer notes' architecture table lists them —
  * used by both the CLI's `/layers` and chat-ui's layer grid to render a stable 2-3 letter
  * code per layer (Phase 3.3 of the harness layer activation plan). Matches the `layer` field
  * on the `layer_activity` TraceEvent (see trace-events.ts) and HarnessRunOptions'

package/dist/one-loop-flag.d.ts

@@ -5,7 +5,7 @@
  * a module-level default resolved once from process.env, threaded as an injectable constructor
  * option so tests never touch real process.env.
  *
- * Backs plans/harness_d2_one_loop_rewire_plan.html's R2 phase: the harness-driven proposer that
+ * Backs the internal plan's R2 phase: the harness-driven proposer that
  * lets HarnessRuntime's driveMainLoop actually call AgentLoop's tool-calling machinery once per
  * main-loop iteration, instead of receiving an already-finished draftReply after the fact. R2
  * landed it default OFF; R3/R4 built the rest of the wiring behind it; R5 gathered the rollout

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

@@ -23,7 +23,7 @@ export type PlanDraftOutcome = {
     fallThrough: true;
 } | AssistantTurnResult;
 /**
- * P3 of plans/ask_question_and_plan_mode_plan.html — how `assistant.ts`'s auto-trigger tells
+ * P3 of the internal plan — how `assistant.ts`'s auto-trigger tells
  * `draftTurn` what to seed a *fresh* draft with (ignored on every later revision of an
  * already-drafting plan). `templateName` set means a template matched — the draft starts from
  * that template's own skeleton (today's personalization behavior, reused, not discarded — see

package/dist/plan-drafting.d.ts

@@ -3,7 +3,7 @@ import { AskQuestion } from '@buildaharness/harness';
 import { DecomposedTaskSpec } from './decomposition-classifier.js';
 import { PlanTaskRecord } from './plan-store.js';
 /**
- * P1 of plans/ask_question_and_plan_mode_plan.html — the "plan-drafting revision call" P1's
+ * P1 of the internal plan — the "plan-drafting revision call" P1's
  * routing (assistant.ts's runTurn, PlanDraftingService) sends every message to while
  * `planMode.active`. Deliberately narrower than P3's eventual version: no tools at all (P3 adds
  * read_file/list_directory grounding for a from-scratch draft — see Section & non-goals),
@@ -18,7 +18,7 @@ export interface PlanDraftTurn {
     successCriteria: string;
     rationale: string;
     /**
-     * P2 of plans/ask_question_and_plan_mode_plan.html — true only once the model judges the user
+     * P2 of the internal plan — true only once the model judges the user
      * has clearly signaled they're satisfied with the current draft and want to proceed, at which
      * point PlanDraftingService hands off to PlanApprovalService instead of returning another plain
      * drafting reply. Defaults false on any malformed/missing value (see parsing below) — a
@@ -26,7 +26,7 @@ export interface PlanDraftTurn {
      */
     readyForApproval: boolean;
     /**
-     * P8 of plans/ask_question_and_plan_mode_plan.html — set only when this revision hit a genuine
+     * P8 of the internal plan — set only when this revision hit a genuine
      * ambiguity worth pausing on instead of guessing (an ambiguous scope boundary, or a
      * MEDIUM/HIGH-risk branch point with more than one viable approach) — e.g. "which of these two
      * frameworks should the plan target?" A drafting call that sets this always also leaves
@@ -48,7 +48,7 @@ export interface PlanDraftTurn {
  */
 export declare function draftPlanRevision(llmClient: ILLMClient, userMessage: string, currentTasks: PlanTaskRecord[], currentSuccessCriteria: string, currentRationale: string, model?: string, onUsage?: (usage: TokenUsage) => void, 
 /**
- * P3 of plans/ask_question_and_plan_mode_plan.html — grounding text for a from-scratch (no
+ * P3 of the internal plan — grounding text for a from-scratch (no
  * template match) draft, gathered from a bounded read_file/list_directory investigation walk
  * (see AgentLoop.runSupervisorInvestigation, reused rather than building a new search engine —
  * Scope & non-goals) so a code-shaped request's draft can reference real repo state instead of

package/dist/plan-mode-flag.d.ts

@@ -3,7 +3,7 @@
  * unit-testable in isolation, mirroring one-loop-flag.ts/ask-mode-flag.ts's exact shape
  * (module-level default, an injectable resolver so tests never touch real process.env).
  *
- * P11 of plans/ask_question_and_plan_mode_plan.html — the rollout flag gating P1-P8's whole
+ * P11 of the internal plan — the rollout flag gating P1-P8's whole
  * plan-mode behavior change (exclusive drafting, mandatory approval, the generalized trigger,
  * auto-advance, the markdown/delegate/trust-mode extensions) behind one switch. 'legacy' (the
  * default, for the whole rollout window, per `DEFAULT_PLAN_MODE`): P3's judgment-based

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

@@ -3,7 +3,7 @@ import { AssistantTurnResult } from './assistant-types.js';
 import { TraceEvent } from './trace-events.js';
 import { AgentLoop } from './agent-loop.js';
 /**
- * P9 of plans/ask_question_and_plan_mode_plan.html — the lightweight plan-sketch delegate: one
+ * P9 of the internal plan — the lightweight plan-sketch delegate: one
  * bounded LLM call (grounded, best-effort, via the same read_file/list_directory investigation
  * walk P3's from-scratch drafting reuses — AgentLoop.runSupervisorInvestigation, not a new search
  * engine) that returns a plain proposed task list in the chat reply itself. Deliberately NOT

package/dist/plan-sketch.d.ts

@@ -1,6 +1,6 @@
 import { ILLMClient, TokenUsage } from '@buildaharness/runtime';
 /**
- * P9 of plans/ask_question_and_plan_mode_plan.html — the lightweight plan-sketch delegate's one
+ * P9 of the internal plan — the lightweight plan-sketch delegate's one
  * bounded LLM call. Deliberately the cheapest possible shape: a single plain-text reply the
  * caller shows directly in the chat, not a structured task list staged anywhere — there is no
  * PlanRecord, no PlanTaskRecord, nothing for P2's approval gate to see (INV-35). Distinct from

package/dist/plan-store.d.ts

@@ -113,7 +113,7 @@ export declare function loadPlanRecord(memory: MemoryAdapter, sessionId: string,
 export declare function loadActivePlan(memory: MemoryAdapter, sessionId: string, fsPersistence?: PlanFsPersistence): Promise<PlanRecord | null>;
 /**
  * Builds an immediately-`active` PlanRecord with no drafting/approval step at all. Before P3 of
- * plans/ask_question_and_plan_mode_plan.html, TurnInterpreter.resolveTasks called this the instant
+ * the internal plan, TurnInterpreter.resolveTasks called this the instant
  * classifyTurnIntent matched a template; P3 retired that call site — a template match (or the
  * newer general needsMultiStepPlan judgment) now always routes through plan mode's exclusive
  * drafting+approval loop instead (see assistant.ts's auto-trigger and
@@ -227,6 +227,6 @@ export declare function computePlanPosition(plan: PlanRecord, taskGraphTasks: {
 }[]): PlanPosition | null;
 /** The next not-yet-COMPLETE task in plan order — used to phrase a pause/resume prompt ("Ready to continue with: <description>?"). Returns null once every task is COMPLETE. */
 export declare function nextPendingTask(plan: PlanRecord): PlanTaskRecord | null;
-/** Human-readable plan status — mirrors agents/planner/utils.py's format_plan_progress, for callers (the CLI) that want text instead of the structured planStatus field. */
+/** Human-readable plan status — mirrors the Python planner agent's format_plan_progress, for callers (the CLI) that want text instead of the structured planStatus field. */
 export declare function formatPlanProgress(plan: PlanRecord): string;
 export {};

package/dist/plan-templates/index.d.ts

@@ -20,7 +20,7 @@ export declare function listTemplateNames(): string[];
 /**
  * Heuristic: match description keywords to a template name. Always returns a
  * template — falls back to 'problem_solving' on zero keyword hits, exactly like
- * agents/planner/utils.py's pick_template_for_task. Used by buildPlanFromTemplate
+ * the Python planner agent's pick_template_for_task. Used by buildPlanFromTemplate
  * once a template has already been chosen some other way (e.g. matchTemplateIfConfident).
  */
 export declare function pickTemplateForTask(description: string): string;

package/dist/plan-verification.d.ts

@@ -1,7 +1,7 @@
 import { ILLMClient, TokenUsage } from '@buildaharness/runtime';
 import { PlanTaskRecord } from './plan-store.js';
 /**
- * P6 of plans/ask_question_and_plan_mode_plan.html — runs between drafting (P1/P3) and staging
+ * P6 of the internal plan — runs between drafting (P1/P3) and staging
  * for approval (P2). Two independent checks, deliberately ordered cheapest-and-most-certain
  * first: (1) dependency-graph validity (pure, synchronous, no LLM call — the same three checks
  * `adapter/harness/task_graph.py`'s `validate_task_graph` runs Python-side: orphaned `depends_on`

package/dist/scripted-llm-client.d.ts

@@ -2,7 +2,7 @@ import { ILLMClient, LLMStructuredResponse } from '@buildaharness/runtime';
 /**
  * A deterministic, network-free {@link ILLMClient} for tests and demos — the one publicly
  * supported way to drive a real `PersonalAssistant` turn end to end without a proxy, an API key,
- * or a live model. Built for plans/chat_ui_browser_e2e_plan.html phase B1 (the browser-e2e lane
+ * or a live model. Built for the internal plan phase B1 (the browser-e2e lane
  * that unblocks the `ASSISTANT_ONE_LOOP` default-flip), and reusable by chat-ui's `demo-seed.ts`.
  *
  * It mirrors the shape of the internal `ScriptedToolLLMClient` that `assistant.test.ts` has used

package/dist/sea-cache.d.ts

@@ -0,0 +1,9 @@
+/** `~/.buildaharness/personal-assistant/sea-cache/<version>` — same data dir as cli.ts's `defaultDataDir`. */
+export declare function seaCacheDir(version: string, home?: string): string;
+/**
+ * Writes `read()`'s bytes to `<dir>/<fileName>` unless that exact path already exists, and returns
+ * the path. Version-gated by construction: `dir` embeds the CLI version, so a new release never
+ * reuses a stale extraction. Written via a temp file + rename so a crash or a concurrent second
+ * launch can never observe (and then import) a half-written file.
+ */
+export declare function extractAssetOnce(dir: string, fileName: string, read: () => string | ArrayBuffer): string;