@buildaharness/aielia 0.3.0

package/dist/file-tools.d.ts

@@ -0,0 +1,179 @@
+import { FsBackend, ToolDefinition } from '@buildaharness/runtime';
+import { SendEmail, SendEmailResult } from './email.js';
+/**
+ * Thrown by resolveInWorkspace/assertRealPathInWorkspace instead of returning
+ * a falsy value, so callers can't accidentally proceed past a rejected path.
+ */
+export declare class PathOutsideWorkspaceError extends Error {
+    readonly requestedPath: string;
+    constructor(requestedPath: string);
+}
+/**
+ * Resolves `requestedPath` against `workspaceRoot` and rejects anything that
+ * escapes it (`../` traversal, or an absolute path outside the root). Purely
+ * string-based — no real filesystem access, no node:path — so this module has
+ * no environment-specific dependency and stays safe to import from assistant.ts,
+ * which is bundled into both the Node CLI and the browser (chat-ui) builds.
+ *
+ * This alone cannot catch a symlink *inside* the workspace that points outside
+ * it; see assertRealPathInWorkspace for that (needs real I/O via FsBackend).
+ */
+export declare function resolveInWorkspace(workspaceRoot: string, requestedPath: string): string;
+/**
+ * Defense in depth beyond resolveInWorkspace's string-prefix check: resolves
+ * symlinks (via the injected backend's optional `realpath`) on the nearest
+ * existing ancestor of `resolvedPath` and re-verifies it's still under the
+ * workspace root's real path. A no-op (best-effort only) if the backend
+ * doesn't implement `realpath`.
+ */
+export declare function assertRealPathInWorkspace(backend: FsBackend, workspaceRoot: string, resolvedPath: string): Promise<void>;
+export declare const READ_FILE_TOOL: ToolDefinition;
+export declare const LIST_DIRECTORY_TOOL: ToolDefinition;
+export declare const WRITE_FILE_TOOL: ToolDefinition;
+export declare const FILE_TOOLS: ToolDefinition[];
+export interface FileToolsContext {
+    backend: FsBackend;
+    workspaceRoot: string;
+}
+export type FileToolResult = {
+    kind: 'text';
+    text: string;
+} | {
+    kind: 'staged_write';
+    id: string;
+    path: string;
+    content: string;
+};
+export declare function requireStringArg(input: Record<string, unknown>, key: string): string;
+/** Executes one of the three file tools by name. Real I/O for read/list; write_file only stages (see T2). */
+export declare function executeFileTool(ctx: FileToolsContext, toolName: string, input: Record<string, unknown>): Promise<FileToolResult>;
+export type PendingActionPayload = {
+    kind: 'write';
+    path: string;
+    content: string;
+} | {
+    kind: 'shell';
+    command: string;
+    cwd: string;
+}
+/**
+ * An email the model has proposed via send_email (action-tools.ts). Staged like write/shell and
+ * never delivered until a human approves — see applyPendingAction's email branch, which calls the
+ * injected SendEmail transport. Deliberately not in the undo-log: a sent email is one-shot and
+ * irreversible, the same reason `kind: 'revert'` below writes no undo entry either.
+ */
+ | {
+    kind: 'email';
+    to: string;
+    subject: string;
+    body: string;
+    cc?: string;
+    bcc?: string;
+}
+/**
+ * Staged by /undo-action (T3), never by the model — reverts a previously-applied write/shell
+ * action back to its pre-action state. `revertedEntryId` names the undo-log entry this reverts
+ * (deleted once applied — see applyPendingAction's revert branch). `restore`/`remove` are the
+ * concrete filesystem operations (see action-snapshot.ts's buildRevertPlan), computed once at
+ * staging time so apply doesn't need to re-derive them from a (possibly since-pruned) undo-log
+ * entry.
+ */
+ | {
+    kind: 'revert';
+    revertedEntryId: string;
+    restore: {
+        path: string;
+        content: string;
+    }[];
+    remove: string[];
+};
+/**
+ * `nextPendingActionId` chains a second (or later) approval-gated action staged from the same
+ * originating turn — e.g. the claude-cli MCP server (file-tools-mcp-server.mjs) links
+ * consecutive stagePendingAction calls within one `claude -p` subprocess this way, so
+ * resolvePendingAction (assistant.ts) can surface the next one as its own needs_approval instead
+ * of silently dropping it once the first resolves. Absent for a standalone staged action.
+ *
+ * `chainedFrom` marks a record as itself being the *target* of such a chain — i.e. a preceding
+ * action from the same turn was already resolved (approved-and-applied, or declined) before this
+ * one was ever shown for approval. resolvePendingAction's decline branch (assistant.ts) uses this
+ * to avoid claiming "nothing was written or run" when something from earlier in the same chain
+ * may already have been.
+ */
+export type PendingActionRecord = {
+    id: string;
+    stagedAt: string;
+    nextPendingActionId?: string;
+    chainedFrom?: boolean;
+} & PendingActionPayload;
+/** Result of actually running a previously staged shell command — see shell-executor.ts. */
+export interface ShellExecutionResult {
+    /** Combined stdout+stderr, truncated to a byte cap. */
+    output: string;
+    exitCode: number | null;
+    timedOut: boolean;
+}
+export type ApplyPendingActionResult = ({
+    kind: 'write';
+} & PendingActionRecord) | ({
+    kind: 'shell';
+} & PendingActionRecord & {
+    execution: ShellExecutionResult;
+}) | ({
+    kind: 'revert';
+} & PendingActionRecord) | ({
+    kind: 'email';
+} & PendingActionRecord & {
+    delivery: SendEmailResult;
+});
+/**
+ * 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):
+ * 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
+ * the concrete tool call, not the free text" pattern Claude Code and Codex CLI use (matching
+ * literal tool-call/command strings, not classifying natural-language risk). Any future
+ * consequential tool (an MCP-provided send_email, a payments API, a social-posting integration)
+ * must get this same unconditional stagePendingAction-style gate on its own call arguments — it
+ * must not rely solely on risk-classifier.ts catching the request first, since a classifier can
+ * always miss a phrasing it wasn't built to recognize.
+ */
+export declare function stagePendingAction(backend: FsBackend, workspaceRoot: string, payload: PendingActionPayload): Promise<{
+    id: string;
+}>;
+export declare function loadPendingAction(backend: FsBackend, workspaceRoot: string, id: string): Promise<PendingActionRecord | undefined>;
+/**
+ * Applies a previously staged action for real, then deletes its staging record. Throws if `id`
+ * isn't staged. `kind: 'write'` is applied directly (pure FsBackend I/O, safe in any environment
+ * this package runs in). `kind: 'shell'` requires an injected `executeShell` callback instead of
+ * this module spawning a process itself — file-tools.ts has no Node dependency of its own (it's
+ * bundled into the browser build via assistant.ts/index.ts), so the real child_process.spawn call
+ * lives in shell-executor.ts and is only ever wired in by Node-only callers (cli.ts).
+ */
+export declare function applyPendingAction(backend: FsBackend, workspaceRoot: string, id: string, options?: {
+    executeShell?: (command: string, cwd: string) => Promise<ShellExecutionResult>;
+    sendEmail?: SendEmail;
+}): Promise<ApplyPendingActionResult>;
+/** Deletes a staged action without applying it. Used when the user declines. No-op if `id` isn't staged. */
+export declare function discardPendingAction(backend: FsBackend, workspaceRoot: string, id: string): Promise<void>;
+/**
+ * A staged action left behind by a crashed or abandoned turn is harmless (never applied without
+ * its matching id — see applyPendingAction) but, left unswept, accumulates forever. Records older
+ * than this are considered abandoned rather than legitimately pending — mirrors the naming
+ * convention of action-snapshot.ts's UNDO_LOG_MAX_ENTRIES (T12 of the gap-coverage plan).
+ */
+export declare const PENDING_ACTION_MAX_AGE_MS: number;
+/**
+ * Deletes `.pending-actions/` records older than `PENDING_ACTION_MAX_AGE_MS`. Called from
+ * PersonalAssistant's startup sweep (see assistant.ts), which is itself responsible for first
+ * confirming no session has a checkpoint still eligible for resume — this function only applies
+ * the age cutoff and has no knowledge of checkpoints itself. `now` is a parameter (not read
+ * directly from Date.now()) so tests can pin a fixed reference time. Corrupt records are left in
+ * place rather than swept — not this function's job to repair malformed JSON.
+ */
+export declare function sweepAbandonedPendingActions(backend: FsBackend, workspaceRoot: string, now?: number): Promise<{
+    swept: string[];
+}>;

package/dist/first-run.d.ts

@@ -0,0 +1,22 @@
+import { AssistantConfig, ConfigStore } from './config.js';
+export interface FirstRunDeps {
+    configStore: ConfigStore;
+    /** Result of `configStore.load()` — the setup is skipped entirely if this already names a backend/key. */
+    persisted: Partial<AssistantConfig>;
+    /** Keys pinned by an env var (ASSISTANT_LLM_BACKEND etc.) — also a signal the user has already chosen. */
+    overriddenKeys: ReadonlySet<keyof AssistantConfig>;
+    /** False for piped/scripted stdin — setup is skipped and today's behavior (proxy default) is kept. */
+    isInteractive: boolean;
+    /** Reads one line from the user, already trimmed. */
+    ask: (question: string) => Promise<string>;
+    /** True when an authenticated `claude` CLI is available on PATH. */
+    detectClaudeCli: () => Promise<boolean>;
+    /** Where to print prompts/status (defaults to process.stdout in cli.ts). */
+    log: (line: string) => void;
+}
+/**
+ * Runs the first-run pass if needed. Returns the persisted config to use from
+ * here on — unchanged when setup was skipped or the user bailed out, or a fresh
+ * object reflecting what was just written.
+ */
+export declare function maybeRunFirstRunSetup(deps: FirstRunDeps): Promise<Partial<AssistantConfig>>;

package/dist/harness-bridge.d.ts

@@ -0,0 +1,103 @@
+import { ExperienceStore, Task, CheckpointStore, LayerActivityEvent, HarnessCheckpoint, VerificationResult, HarnessRunResult, ToolExecutorContext, InvestigationRequestData, InvestigationFinding, UpdateChannel } from '@buildaharness/harness';
+import { ILLMClient, MemoryAdapter, TokenUsage } from '@buildaharness/runtime';
+import { OneLoopMode } from './one-loop-flag.js';
+import { UserFact } from './fact-extraction.js';
+import { AssistantSession } from './assistant-session.js';
+import { PlanRecord } from './plan-store.js';
+import { PlanService } from './plan-service.js';
+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';
+export type HarnessOutcome = {
+    status: 'paused';
+    checkpoint: HarnessCheckpoint;
+    lastVerification: VerificationResult | null;
+    layerActivity: LayerActivityEvent[];
+} | {
+    status: 'completed';
+    result: HarnessRunResult;
+    lastVerification: VerificationResult | null;
+    layerActivity: LayerActivityEvent[];
+};
+export interface HarnessRunParams {
+    sessionId: string;
+    userMessage: string;
+    facts: UserFact[];
+    /**
+     * Phase 4 of plans/personal_assistant_fact_extraction_llm_confidence_plan.html: 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
+     * `extractFactsFromTurn(objective, runId)` call, which only ever saw the free lexical pass and
+     * left a same-turn LLM-caught fact invisible to contradiction detection until (if ever) a later
+     * turn's re-seed. Defaults to `[]` when omitted, matching pre-Phase-4 behavior for a caller that
+     * doesn't supply it.
+     */
+    currentTurnFacts?: UserFact[];
+    draftReply: string;
+    classification: TurnIntentClassification;
+    initialTasks: Task[];
+    activePlan: PlanRecord | null;
+    sources: AssistantSource[] | undefined;
+    onProgress?: (progress: AssistantProgress) => void;
+    onUsage: (usage: TokenUsage) => void;
+    /**
+     * R2 of plans/harness_d2_one_loop_rewire_plan.html: 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
+     * back to `() => draftReply` regardless of the flag — R2 only builds the mechanism and proves it
+     * against a caller that supplies this directly; wiring runTurn to always supply one when the
+     * flag is on is R3's scope.
+     */
+    oneLoopProposer?: (toolCtx: ToolExecutorContext) => unknown | Promise<unknown>;
+    /**
+     * Trajectory Supervisor GATHER_EVIDENCE host (S5 of
+     * plans/harness_trajectory_supervisor_plan.html) — 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
+     * default exactly like onSupervisorDirective.
+     */
+    runInvestigation?: (req: InvestigationRequestData) => Promise<InvestigationFinding[]>;
+    /**
+     * Q2 of plans/ask_question_and_plan_mode_plan.html — 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
+     * a populated `blocker.questions` gets to keep its checkpoint alive (see the `finally` block
+     * below) instead of being deleted as a terminal escalation. Defaults to false — byte-identical
+     * to pre-Q2 behavior when omitted.
+     */
+    askModeEnabled?: boolean;
+    /**
+     * Q2 — AskClarificationService.resolvePendingClarification's one-shot channel carrying the
+     * user's AskResponse back into the paused run's `callerState` via the harness's own
+     * checkCallerUpdates/applyConstraintChangePropagation path (nodes/check-caller-updates.ts).
+     * Passed straight through to HarnessRunOptions.updateChannel; undefined (every caller before
+     * Q2) defaults to a no-op channel inside the harness, unchanged.
+     */
+    updateChannel?: UpdateChannel;
+}
+/**
+ * HarnessRuntime construction + invocation: the runOptions assembly, checkpoint load +
+ * RESUME_ATTEMPT_CAP logic, runtime.run()/.resume() dispatch, and the paused-vs-completed
+ * outcome split — split out of runTurn in Phase 4d of the architecture remediation plan.
+ * `EscalationHalt` is deliberately NOT caught here — it propagates out of `run()` so the
+ * sequencer's single try/catch still handles it (assistant.ts's runTurn/ResponseService).
+ */
+export declare class HarnessBridge {
+    private readonly memory;
+    private readonly experienceStore;
+    private readonly checkpointStore;
+    private readonly llmClient;
+    private readonly model;
+    private readonly maxSteps;
+    private readonly planService;
+    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);
+    run(params: HarnessRunParams): Promise<HarnessOutcome>;
+}

package/dist/index.d.ts

@@ -0,0 +1,58 @@
+export { PersonalAssistant } from './assistant.js';
+export type { AssistantTurnResult, ProposerKind, PersonalAssistantOptions, AssistantProgress, AssistantTrace, AssistantSource, MemorySummary, TranscriptSearchHit, DebugLogEntry } from './assistant.js';
+export type { AnswerClaim, AnswerClaimSourceType, AnswerClaimVerificationStatus } from './answer-claim.js';
+export { classifyRisk } from './risk-classifier.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';
+export { nodeDisplayName, nodeToLayer, buildWhyChain, LAYER_ORDER, LAYER_DISPLAY_NAME, LAYER_SHORT_CODE } from './node-display-names.js';
+export type { LayerSlug, WhyChainItem } from './node-display-names.js';
+export { classifyError } from './error-classifier.js';
+export type { ErrorClassification } from './error-classifier.js';
+export { FILE_TOOLS, READ_FILE_TOOL, LIST_DIRECTORY_TOOL, WRITE_FILE_TOOL, resolveInWorkspace, executeFileTool, stagePendingAction, loadPendingAction, applyPendingAction, discardPendingAction, PathOutsideWorkspaceError, } from './file-tools.js';
+export type { FileToolsContext, FileToolResult, PendingActionRecord, PendingActionPayload, ApplyPendingActionResult, ShellExecutionResult, } from './file-tools.js';
+export { SHELL_TOOLS, RUN_SHELL_COMMAND_TOOL, executeShellTool } from './shell-tools.js';
+export type { ShellToolsContext, ShellStagingContext, ShellToolResult, ShellCommandExecutor } from './shell-tools.js';
+export { ACTION_TOOLS, SEND_EMAIL_TOOL, executeActionTool, InvalidEmailArgsError } from './action-tools.js';
+export type { ActionToolsContext, ActionStagingContext, ActionToolResult } from './action-tools.js';
+export { createResendSender, formatEmailApprovalReason, isLikelyEmailAddress, EmailDeliveryError } from './email.js';
+export type { EmailMessage, SendEmail, SendEmailResult, ResendSenderOptions } from './email.js';
+export { createSmtpSender } from './email-smtp.js';
+export type { SmtpSenderOptions } from './email-smtp.js';
+export { WEB_TOOLS, WEB_SEARCH_TOOL, FETCH_URL_TOOL, executeWebTool, assertPublicHttpUrl, PrivateNetworkTargetError } from './web-tools.js';
+export type { WebToolsContext, WebToolResult, WebSearchResult, DnsResolver } from './web-tools.js';
+export { braveSearch } from './web-search-provider.js';
+export type { BraveSearchOptions } from './web-search-provider.js';
+export { buildClaudePrompt, parseClaudeCliOutput, ALREADY_STAGED_ACTION_TOOL, stagedActionInput } from './claude-cli-prompt.js';
+export type { ParsedClaudeCliOutput } from './claude-cli-prompt.js';
+export { stripMcpToolPrefix, summarizeToolStep } from './tool-step.js';
+export type { AssistantToolStep } from './tool-step.js';
+export type { DecomposedTaskSpec } from './decomposition-classifier.js';
+export { detectHomogeneousBatchList } from './batch-list-detector.js';
+export type { BatchListDetection } from './batch-list-detector.js';
+export { classifyToolYield } from './tool-yield-classifier.js';
+export type { ToolYield } from './tool-yield-classifier.js';
+export { buildPlanFromTemplate } from './plan-builder.js';
+export type { Plan } from './plan-builder.js';
+export { loadTemplate, listTemplateNames, pickTemplateForTask, matchTemplateIfConfident } from './plan-templates/index.js';
+export type { PlanTask, PlanTemplate } from './plan-templates/index.js';
+export { loadActivePlan, createPlanRecord, savePlan, abandonPlan, updatePlanFromRun, planCompletionPct, computePlanPosition, nextPendingTask, formatPlanProgress, } from './plan-store.js';
+export type { PlanRecord, PlanTaskRecord, PlanPosition, PlanMode } from './plan-store.js';
+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 { 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 { resolvePlanMode, normalizePlanMode, DEFAULT_PLAN_MODE } from './plan-mode-flag.js';
+export type { PlanRolloutMode } from './plan-mode-flag.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 type { CostSummaryInfo, DoctorCheck } from './cli-session.js';
+export { estimateCostUsd } from './model-pricing.js';

package/dist/index.js

@@ -0,0 +1,212 @@
+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 { MAX_OPTIONS_PER_QUESTION, MAX_QUESTIONS_PER_BATCH, MIN_OPTIONS_PER_QUESTION, validateAskResponse } from "@buildaharness/harness";
+const PLAN_SCHEMA = {
+  type: "object",
+  properties: {
+    tasks: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          id: { type: "string" },
+          description: { type: "string" },
+          depends_on: { type: "array", items: { type: "string" } }
+        },
+        required: ["id", "description", "depends_on"]
+      }
+    }
+  },
+  required: ["tasks"]
+};
+function buildSystemPrompt(template) {
+  const skeleton = template.tasks.map((t2) => `- id: ${t2.id}; title: ${t2.title}; depends_on: [${t2.depends_on.join(", ")}]`).join("\n");
+  return `You are adapting a "${template.name}" plan template to a specific user request. Here is the template's task skeleton — keep the exact same ids and depends_on structure, one output task per skeleton task, but personalize each description to the actual request:
+${skeleton}
+
+Success criteria for this kind of plan: ${template.success_criteria}
+
+Phrase each \`description\` starting with the concrete subject or object it acts on (e.g. "the login tests: rerun after the config fix" rather than "rerun the login tests after the config fix"), so later comparisons against this task's completion/failure beliefs share matching vocabulary. Respond with JSON only, no prose: {"tasks":[{"id": string, "description": string, "depends_on": string[]}]}. \`id\` and \`depends_on\` values must exactly match the skeleton above.`;
+}
+function isRawPlanTask(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v2 = value;
+  return typeof v2.id === "string" && typeof v2.description === "string" && Array.isArray(v2.depends_on) && v2.depends_on.every((d) => typeof d === "string");
+}
+async function buildPlanFromTemplate(llmClient, message, template, model, onUsage) {
+  try {
+    const response = await llmClient.callChatStructured(
+      [
+        { role: "system", content: buildSystemPrompt(template) },
+        { role: "user", content: message }
+      ],
+      void 0,
+      { model, onUsage, structuredOutput: { schema: PLAN_SCHEMA } }
+    );
+    const parsed = JSON.parse(response.content);
+    if (!Array.isArray(parsed.tasks)) return null;
+    const rawTasks = parsed.tasks.filter(isRawPlanTask);
+    if (rawTasks.length <= 1) return null;
+    const riskByTemplateId = new Map(template.tasks.map((t2) => [t2.id, t2.risk_level]));
+    const tasks = rawTasks.map((t2) => ({ ...t2, riskLevel: riskByTemplateId.get(t2.id) ?? "LOW" }));
+    return { templateName: template.name, successCriteria: template.success_criteria, tasks };
+  } catch {
+    return null;
+  }
+}
+const TURN_INTENT_MARKER = "eight 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 isReminderRequest = risk.reason.includes("reminder");
+  const base = {
+    riskLevel: risk.riskLevel,
+    riskReason: risk.reason,
+    isTrivial: false,
+    decomposedTasks: [],
+    isReminderRequest,
+    isBulkReminderRequest: isReminderRequest && risk.requiresApproval,
+    isAbandonRequest: false,
+    matchedPlanTemplate: null,
+    needsMultiStepPlan: false,
+    statesDurableFacts: []
+  };
+  return JSON.stringify({ ...base, ...override });
+}
+class ScriptedLLMClient {
+  constructor(script) {
+    /** Non-classifier `callChatStructured` calls made so far — the index into `responses`. */
+    __publicField(this, "toolCalls", 0);
+    __publicField(this, "responseIndex", 0);
+    this.script = script;
+  }
+  get streamChunks() {
+    return this.script.streamChunks && this.script.streamChunks.length > 0 ? this.script.streamChunks : [""];
+  }
+  async *callChat(_messages, _options) {
+    for (const chunk of this.streamChunks) yield chunk;
+  }
+  async callChatSync(messages, options) {
+    const chunks = [];
+    for await (const chunk of this.callChat(messages, options)) chunks.push(chunk);
+    return chunks.join("");
+  }
+  async callChatStructured(messages, _tools, _options) {
+    var _a, _b, _c;
+    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)) };
+    }
+    this.toolCalls++;
+    const responses = this.script.responses ?? [];
+    if (this.responseIndex >= responses.length) {
+      throw new Error(
+        `createScriptedLLMClient: no scripted response for tool-loop call #${this.responseIndex + 1} (scripted ${responses.length})`
+      );
+    }
+    const next = responses[this.responseIndex++];
+    return typeof next === "string" ? { content: next } : next;
+  }
+}
+function createScriptedLLMClient(script = {}) {
+  return new ScriptedLLMClient(script);
+}
+export {
+  A as ACTION_TOOLS,
+  a as ALREADY_STAGED_ACTION_TOOL,
+  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,
+  h as EmailDeliveryError,
+  F as FETCH_URL_TOOL,
+  i 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,
+  MAX_OPTIONS_PER_QUESTION,
+  MAX_QUESTIONS_PER_BATCH,
+  MIN_OPTIONS_PER_QUESTION,
+  P as PathOutsideWorkspaceError,
+  m as PersonalAssistant,
+  n as PrivateNetworkTargetError,
+  R as READ_FILE_TOOL,
+  o as RUN_SHELL_COMMAND_TOOL,
+  S as SEND_EMAIL_TOOL,
+  p 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,
+  buildPlanFromTemplate,
+  x as buildWhyChain,
+  y as classifyError,
+  classifyRisk,
+  B as classifyToolYield,
+  G as classifyTurnIntent,
+  H as computePlanPosition,
+  J as createPlanRecord,
+  K 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,
+  validateAskResponse,
+  aH as validateConfig
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +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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"}

package/dist/ink-test-render.d.ts

@@ -0,0 +1,24 @@
+import { EventEmitter } from 'node:events';
+import { ReactElement } from 'react';
+declare class TestStdin extends EventEmitter {
+    isTTY: boolean;
+    private data;
+    write: (chunk: string) => void;
+    setEncoding(): void;
+    setRawMode(): void;
+    resume(): void;
+    pause(): void;
+    ref(): void;
+    unref(): void;
+    read: () => string | null;
+}
+export interface TestInkInstance {
+    stdin: TestStdin;
+    lastFrame: () => string | undefined;
+    /** See `TestStdout.fullOutput`'s doc comment — needed to assert on `<Static>` content. */
+    fullOutput: () => string;
+    rerender: (tree: ReactElement) => void;
+    unmount: () => void;
+}
+export declare function renderInk(tree: ReactElement): TestInkInstance;
+export {};

package/dist/lexical/patterns/batch-list-markers.json

@@ -0,0 +1,8 @@
+{
+  "en": {
+    "connectorWords": [
+      "a", "an", "the", "of", "and", "or", "in", "on", "at", "to", "for", "with",
+      "am", "im", "an", "der", "die", "das", "von", "zu", "de", "la", "le", "van", "al"
+    ]
+  }
+}

package/dist/lexical/patterns/batch-list-markers.json.d.ts

@@ -0,0 +1,11 @@
+declare const _default: {
+  "en": {
+    "connectorWords": [
+      "a", "an", "the", "of", "and", "or", "in", "on", "at", "to", "for", "with",
+      "am", "im", "an", "der", "die", "das", "von", "zu", "de", "la", "le", "van", "al"
+    ]
+  }
+}
+;
+
+export default _default;