@buildaharness/aielia 0.3.8 → 0.3.10

package/dist/layer-settings.d.ts

@@ -5,10 +5,11 @@
  * layer needed a second code path. An env value the operator set themselves always wins and renders as pinned,
  * the same precedence `explicitEnvOverride` already gives it.
  *
- * Floor layers (safety, approval, tool policy, verification, diagnostics) are listed but locked: there is no
- * flag for them and the adaptive policy's types make them un-decidable on purpose.
+ * Floor layers: control state, tool policy and verification each have a gate flag and may be switched off (they carry
+ * a `caution`). Approval staging is locked on purpose, and diagnostics and template hypotheses have no effect of their own
+ * (they only feed the control state), so they follow `control_state`.
  */
-export type LayerGroup = 'escalation' | 'opt_in' | 'floor';
+export type LayerGroup = 'escalation' | 'behaviour' | 'opt_in' | 'floor';
 export interface LayerSetting {
     id: string;
     group: LayerGroup;
@@ -21,10 +22,22 @@ export interface LayerSetting {
     cost: string;
     /** What the audit found, in plain words — the record, not a promise. */
     evidence: string;
+    /** What switching it off gives up; set on floor layers a user may still switch off. */
+    caution?: string;
+    /** A layer with no gate of its own: it is on exactly when this layer is. */
+    followsLayer?: string;
+    /** Layers this one does nothing without. Switching it on while one of them is off is allowed but reported. */
+    requires?: readonly string[];
 }
 export declare const LAYER_SETTINGS: readonly LayerSetting[];
 export type LayerChoices = Readonly<Record<string, boolean>>;
 export declare function findLayer(id: string): LayerSetting | undefined;
+/** The layers that have no switch of their own and are on exactly when `leader` is. */
+export declare function followersOf(leader: LayerSetting): LayerSetting[];
+/** The layers `layer` needs that are currently off. Empty when `layer` is off itself: nothing is lost then. */
+export declare function unmetRequirements(layer: LayerSetting, choices: LayerChoices | undefined, pinned: ReadonlySet<string>, env: Env): LayerSetting[];
+/** One line per switched-on layer that has no effect because a layer it needs is off. */
+export declare function layerWarnings(choices: LayerChoices | undefined, pinned: ReadonlySet<string>, env: Env): string[];
 /** The layers a user may change: everything except the locked floor. */
 export declare function isToggleable(layer: LayerSetting): boolean;
 type Env = Record<string, string | undefined>;

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

@@ -0,0 +1,13 @@
+import { ILLMClient } from '@buildaharness/runtime';
+import { AssistantConfig } from './config.js';
+export interface LlmClientFactoryOptions {
+    /** Passed to every HTTP client. The desktop app supplies Tauri's fetch, because its webview CSP blocks the global one. */
+    fetchImpl?: typeof fetch;
+    /**
+     * Builds the surface's own claude-cli client (the CLI's file/shell/web/action tools, desktop's Tauri bridge).
+     * Return undefined where `claude -p` cannot run (a plain browser tab) and the factory falls back to the proxy.
+     */
+    claudeCli: () => ILLMClient | undefined;
+}
+/** The one switch over the five backends. Only the claude-cli client and `fetch` differ per surface, and both come in through the options. */
+export declare function createLlmClient(config: AssistantConfig, { fetchImpl, claudeCli }: LlmClientFactoryOptions): ILLMClient;

package/dist/memory-events.d.ts

@@ -0,0 +1,177 @@
+import { z } from 'zod';
+import { UserFact } from './fact-extraction.js';
+/**
+ * One record per memory transition: what changed, WHY (a closed, countable reason code) and which
+ * sources justified it. Pure (no I/O, no clock): `MemoryService` builds events from the changes it
+ * makes and hands them to an `EventSink`. The wire enums come from the shared contract
+ * (`spec/memory-core.json`), so the Python twin sees the same names.
+ *
+ * Privacy: an event holds ids and codes, never fact text, unless the caller asks for images
+ * (`withImages`, tied to the audit log flag). `factKey()` is a one-way id, so an event about a
+ * forgotten fact reveals nothing; `scrubForgotten()` also drops the quotes and images of every
+ * earlier event about it.
+ */
+export declare const MEMORY_EVENTS_KEY: string;
+export declare const MEMORY_EVENTS_KEEP: number;
+export declare const MemoryEventKindSchema: z.ZodEnum<["promote", "decline", "correct", "contradict", "supersede", "retire", "forget", "expire", "restore", "recall"]>;
+export declare const ReasonCodeSchema: z.ZodEnum<["user_stated", "user_corrected", "user_confirmed", "user_rejected", "inferred_high_conf", "inferred_pending_confirmation", "inferred_low_conf_session_only", "conflicts_with_fact", "superseded_by_newer", "explicit_forget", "retention_expired", "gate_blocked_secret", "gate_blocked_instruction", "duplicate"]>;
+export declare const SourceRefSchema: z.ZodObject<{
+    type: z.ZodEnum<["user_message", "assistant_message", "tool_result", "prior_fact", "user_command"]>;
+    /** messageId | toolCallId | factKey | command name. */
+    ref: z.ZodString;
+    /** Short justification the reader sees; present only with images on, and removed when the fact is forgotten. */
+    quote: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "user_message" | "assistant_message" | "tool_result" | "prior_fact" | "user_command";
+    ref: string;
+    quote?: string | undefined;
+}, {
+    type: "user_message" | "assistant_message" | "tool_result" | "prior_fact" | "user_command";
+    ref: string;
+    quote?: string | undefined;
+}>;
+export declare const MemoryEventSchema: z.ZodObject<{
+    seq: z.ZodNumber;
+    at: z.ZodString;
+    session: z.ZodString;
+    turn: z.ZodString;
+    kind: z.ZodEnum<["promote", "decline", "correct", "contradict", "supersede", "retire", "forget", "expire", "restore", "recall"]>;
+    /** `factKey()` of the fact the event is about (the pre-image for a supersession). */
+    factId: z.ZodString;
+    /** `factKey()` of the replacement, for a supersession. */
+    afterFactId: z.ZodOptional<z.ZodString>;
+    attributeKey: z.ZodOptional<z.ZodString>;
+    store: z.ZodOptional<z.ZodEnum<["durable", "pending", "rejected", "session"]>>;
+    before: z.ZodOptional<z.ZodObject<{
+        text: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        text: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        text: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>>;
+    after: z.ZodOptional<z.ZodObject<{
+        text: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        text: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        text: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>>;
+    reason: z.ZodEnum<["user_stated", "user_corrected", "user_confirmed", "user_rejected", "inferred_high_conf", "inferred_pending_confirmation", "inferred_low_conf_session_only", "conflicts_with_fact", "superseded_by_newer", "explicit_forget", "retention_expired", "gate_blocked_secret", "gate_blocked_instruction", "duplicate"]>;
+    sources: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<["user_message", "assistant_message", "tool_result", "prior_fact", "user_command"]>;
+        /** messageId | toolCallId | factKey | command name. */
+        ref: z.ZodString;
+        /** Short justification the reader sees; present only with images on, and removed when the fact is forgotten. */
+        quote: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "user_message" | "assistant_message" | "tool_result" | "prior_fact" | "user_command";
+        ref: string;
+        quote?: string | undefined;
+    }, {
+        type: "user_message" | "assistant_message" | "tool_result" | "prior_fact" | "user_command";
+        ref: string;
+        quote?: string | undefined;
+    }>, "many">;
+    decidedBy: z.ZodEnum<["user", "classifier", "reviewer", "consolidation", "rule"]>;
+    confidence: z.ZodOptional<z.ZodEnum<["high", "medium", "low"]>>;
+    group: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    at: string;
+    kind: "retire" | "restore" | "promote" | "decline" | "correct" | "contradict" | "supersede" | "forget" | "expire" | "recall";
+    reason: "user_stated" | "user_corrected" | "user_confirmed" | "user_rejected" | "inferred_high_conf" | "inferred_pending_confirmation" | "inferred_low_conf_session_only" | "conflicts_with_fact" | "superseded_by_newer" | "explicit_forget" | "retention_expired" | "gate_blocked_secret" | "gate_blocked_instruction" | "duplicate";
+    session: string;
+    seq: number;
+    factId: string;
+    turn: string;
+    sources: {
+        type: "user_message" | "assistant_message" | "tool_result" | "prior_fact" | "user_command";
+        ref: string;
+        quote?: string | undefined;
+    }[];
+    decidedBy: "reviewer" | "rule" | "user" | "consolidation" | "classifier";
+    confidence?: "high" | "medium" | "low" | undefined;
+    before?: z.objectOutputType<{
+        text: z.ZodString;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    after?: z.objectOutputType<{
+        text: z.ZodString;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    store?: "rejected" | "durable" | "pending" | "session" | undefined;
+    group?: string | undefined;
+    afterFactId?: string | undefined;
+    attributeKey?: string | undefined;
+}, {
+    at: string;
+    kind: "retire" | "restore" | "promote" | "decline" | "correct" | "contradict" | "supersede" | "forget" | "expire" | "recall";
+    reason: "user_stated" | "user_corrected" | "user_confirmed" | "user_rejected" | "inferred_high_conf" | "inferred_pending_confirmation" | "inferred_low_conf_session_only" | "conflicts_with_fact" | "superseded_by_newer" | "explicit_forget" | "retention_expired" | "gate_blocked_secret" | "gate_blocked_instruction" | "duplicate";
+    session: string;
+    seq: number;
+    factId: string;
+    turn: string;
+    sources: {
+        type: "user_message" | "assistant_message" | "tool_result" | "prior_fact" | "user_command";
+        ref: string;
+        quote?: string | undefined;
+    }[];
+    decidedBy: "reviewer" | "rule" | "user" | "consolidation" | "classifier";
+    confidence?: "high" | "medium" | "low" | undefined;
+    before?: z.objectInputType<{
+        text: z.ZodString;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    after?: z.objectInputType<{
+        text: z.ZodString;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    store?: "rejected" | "durable" | "pending" | "session" | undefined;
+    group?: string | undefined;
+    afterFactId?: string | undefined;
+    attributeKey?: string | undefined;
+}>;
+export type MemoryEventKind = z.infer<typeof MemoryEventKindSchema>;
+export type ReasonCode = z.infer<typeof ReasonCodeSchema>;
+export type SourceRef = z.infer<typeof SourceRefSchema>;
+export type MemoryEvent = z.infer<typeof MemoryEventSchema>;
+export type MemoryEventDraft = Omit<MemoryEvent, 'seq' | 'at'>;
+export interface EventSink {
+    emit(events: MemoryEvent[]): void | Promise<void>;
+}
+export declare class InMemoryEventSink implements EventSink {
+    readonly events: MemoryEvent[];
+    emit(events: MemoryEvent[]): void;
+}
+/** Stable, non-reversible id for a fact (FNV-1a over `text|extractedAt`): lets events point at a fact without carrying its words. */
+export declare function factKey(fact: Pick<UserFact, 'text' | 'extractedAt'>): string;
+export declare function keyOfFactId(id: string): string;
+/** The slice of an audit entry an event is derived from (structural, so this module never imports the service). */
+export interface AuditLike {
+    op: 'add' | 'replace' | 'retire' | 'remove' | 'confirm' | 'reject' | 'undo' | 'archive' | 'restore';
+    factId: string;
+    before?: UserFact;
+    after?: UserFact;
+    store: 'durable' | 'pending' | 'rejected';
+    writer: string;
+    turn: string;
+    group?: string;
+}
+/** Project one audit change onto its event: kind, reason, decider and sources, from the op, the writer and the fact's own provenance bits (never its wording). */
+export declare function eventFromAudit(a: AuditLike, withImages: boolean): MemoryEventDraft;
+/** Drops quotes and images from every earlier event about a forgotten fact, so the log cannot be used to read it back. */
+export declare function scrubForgotten(log: MemoryEvent[], forgottenKeys: Set<string>): MemoryEvent[];
+/** Keeps the newest `keep` events. */
+export declare function trimEvents(log: MemoryEvent[], keep?: number): MemoryEvent[];
+/**
+ * Replays an event stream from empty and returns the ids of the durable facts, in order. This is
+ * the correctness check for the log: it must equal `factKey()` over the stored durable list.
+ * `unsupported` counts events it cannot replay (an undo reinserts at a recorded position).
+ */
+export declare function foldDurable(events: MemoryEvent[]): {
+    ids: string[];
+    unsupported: number;
+};
+export interface EventFilter {
+    /** A fact id as printed by `formatMemoryEvents` (`f_xxxxxxxx`), or an attribute key. */
+    fact?: string;
+    kind?: MemoryEventKind;
+}
+export declare function filterEvents(events: MemoryEvent[], f?: EventFilter): MemoryEvent[];
+/** `/memory history events [fact]`: one line per event, with the reason and its sources. Shared by the CLI and chat-ui. */
+export declare function formatMemoryEvents(events: MemoryEvent[]): string;

package/dist/memory-service.d.ts

@@ -4,6 +4,7 @@ import { UserFact } from './fact-extraction.js';
 import { Corroboration } from './contradiction-checker.js';
 import { DigestStore, SessionDigest } from './episodic-digest.js';
 import { StatedFact, FactCategory } from './turn-intent-classifier.js';
+import { EventSink, EventFilter, MemoryEvent } from './memory-events.js';
 import { MemoryWriteMode, CrossTurnWriter } from './memory-governance.js';
 import { ConsolidationProposal } from './memory-consolidation.js';
 import { VerifiedReviewOp } from './memory-reviewer.js';
@@ -47,6 +48,8 @@ export interface AuditEntry {
     undoes?: number;
     /** M6: the user erased this fact from history (`/memory archive forget`); before/after were removed and the entry can no longer be undone. */
     erased?: boolean;
+    /** Export only: the images of a forgotten fact are left out of `/memory export`; the stored log still has them so `/memory undo` works. */
+    withheld?: boolean;
     /** M5: entries applied together (one consolidation proposal) share a group; undoing one undoes the group. */
     group?: string;
     /** M5: position the pre-image held in the durable list, so undo restores order exactly. */
@@ -203,6 +206,8 @@ export declare function memoryBudgetedRenderEnabled(env?: Record<string, string
 export declare function memoryWriteGateEnabled(env?: Record<string, string | undefined>): boolean;
 /** `AUDIT_MEMORY_AUDIT_LOG`: append-only `memory:audit`. Default OFF until the pilot; `=0` restores the unlogged path. */
 export declare function memoryAuditLogEnabled(env?: Record<string, string | undefined>): boolean;
+/** `AUDIT_MEMORY_EVENTS`: metadata-only transition events (kind, reason code, source refs, ids; no fact text unless the audit log is on). Default ON; `=0`/`off` restores no events. */
+export declare function memoryEventsEnabled(env?: Record<string, string | undefined>): boolean;
 /** Outcome of `admitCandidate()` for one candidate. `session` = kept session-scoped only, never durable or pending. */
 export interface AdmitDecision {
     action: 'admit' | 'session' | 'flag' | 'drop';
@@ -278,6 +283,8 @@ export declare class MemoryService {
     private readonly writeMode;
     /** Time source for every timestamp this service writes (extractedAt of stated facts, audit `at`, retiredAt, usage flush). Injectable so the cross-runtime conformance fixtures are byte-reproducible; default is wall-clock, i.e. no behaviour change. */
     private readonly clock;
+    /** Every fact list goes through this seam (see fact-repository.ts); the key-value implementation keeps today's keys. */
+    private readonly repo;
     constructor(memory: MemoryAdapter, reminderStore: ReminderStore, experienceStore: ExperienceStore, llmClient: ILLMClient, model: () => string | undefined, 
     /** Resolves to `config.activeProject` if the user set one via `/project <name>`, else the workspace root — read through a getter (same convention as `model` above) so a mid-session `/project`/`/config set activeProject` change takes effect on the very next turn. See UserFact.project's doc comment for how this is used. */
     currentProject?: () => string, 
@@ -356,6 +363,16 @@ export declare class MemoryService {
     private flushChain;
     private serialized;
     private appendAudit;
+    /** Extra destinations for events (the eval collector); each receives every event, whether or not the stored log is on. */
+    private eventSinks;
+    private eventSeqLocal;
+    addEventSink(sink: EventSink): void;
+    /** Stamps seq/at, appends to the stored event log (when `AUDIT_MEMORY_EVENTS` is on) and fans out to the extra sinks. A sink that throws never blocks the memory write. */
+    private emitEvents;
+    /** `/memory history events [fact]`: the newest transition events, optionally for one fact id or attribute key. */
+    getEvents(limit?: number, filter?: EventFilter): Promise<MemoryEvent[]>;
+    /** A decision that wrote nothing (a promotion declined, a duplicate, a contradiction found) still leaves an event. */
+    private decisionEvent;
     private appendAuditNow;
     /** `/memory history` — newest last; the last `limit` entries. */
     getAuditLog(limit?: number): Promise<AuditEntry[]>;

package/dist/model-pricing.d.ts

@@ -1,19 +1,25 @@
 /**
- * Static, approximate per-model pricing — a fallback used only by the proxy backend's /cost
- * display. The proxy (packages/proxy/src/forward.ts) is a thin pass-through to Anthropic/
- * OpenAI and never computes or returns a dollar cost itself, only the raw token counts each
- * provider's response already includes. This table is NOT billing-accurate: it doesn't account
- * for prompt-caching discounts, batch pricing, or any rate change since it was last updated —
- * update the numbers below if Anthropic's published pricing changes. The Claude CLI backend
- * needs no such table; its costUsd comes from Claude's own real accounting (see
- * claude-cli-prompt.ts's parseClaudeCliOutput).
+ * Static, approximate per-model pricing — a fallback for every backend whose response carries
+ * token counts but no dollar figure. Anthropic and OpenAI responses report tokens only; OpenRouter
+ * (usage.cost) and the Claude CLI (total_cost_usd) report a real cost, which callers prefer over
+ * this table. This table is NOT billing-accurate: it ignores batch pricing, long-context tiers and
+ * any rate change since it was last updated — update the numbers below when published pricing changes.
  */
 export interface ModelPriceUsd {
     inputPerMTok: number;
     outputPerMTok: number;
+    /** Rate for input tokens served from the provider's prompt cache; absent = same as inputPerMTok. */
+    cachedInputPerMTok?: number;
+    /** Rate for input tokens written to the prompt cache; absent = same as inputPerMTok. */
+    cacheWritePerMTok?: number;
 }
-/** Returns undefined (rather than a misleading number) when the model is unset or not a recognized Claude tier — callers must not silently treat "no estimate" as "free". */
+/**
+ * Returns undefined (rather than a misleading number) when the model is unset or not a recognized one — callers must not silently treat "no estimate" as "free".
+ * `cachedInputTokens` follows OpenAI's convention (a subset of inputTokens, billed at the cached rate); it is ignored for models with no cached rate.
+ */
 export declare function estimateCostUsd(model: string | undefined, usage: {
     inputTokens: number;
     outputTokens: number;
+    cachedInputTokens?: number;
+    cacheWriteTokens?: number;
 }): number | undefined;

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

@@ -20,7 +20,7 @@ export interface WhyChainItem {
  * Collapses a turn's raw layerActivity (one event per layer per main-loop iteration — see
  * harness-runtime.ts's onLayerActivity doc comment) down to just the layers that fired, in the
  * order they fired, merging consecutive re-fires of the same layer (back-to-back loop
- * iterations) into a single link. Shared by the CLI's `/why` and chat-ui's "Why?" panel so both
+ * iterations) into a single link. Used by run-explain.ts, which both the CLI's `/why` and chat-ui's `/why` print, so both
  * surfaces summarize a turn identically instead of drifting apart.
  */
 export declare function buildWhyChain(layerActivity: LayerActivityEvent[]): WhyChainItem[];

package/dist/project-command.d.ts

@@ -0,0 +1,16 @@
+/**
+ * `/project [name]` for every surface: no argument shows the active project, `clear` reverts to the workspace
+ * default, anything else switches to that name. Pure: the surface persists the config change and shows the message.
+ */
+export type ProjectCommand = {
+    kind: 'show';
+    message: string;
+} | {
+    kind: 'set';
+    project: string;
+    message: string;
+} | {
+    kind: 'clear';
+    message: string;
+};
+export declare function parseProjectCommand(args: readonly string[], currentProject: string | undefined): ProjectCommand;