@buildaharness/aielia 0.3.8 → 0.3.10

package/dist/proxy-health.d.ts

@@ -0,0 +1,8 @@
+import { DoctorCheck } from './cli-session.js';
+/**
+ * GET <proxyUrl>/health, expecting {status:'ok'} (see packages/proxy/src/index.ts), hard-timed so a dead proxy
+ * cannot hang /doctor or Settings. Shared by the CLI's /doctor and the apps' Settings diagnostics. Credentials in
+ * the URL (user:password, query values) are masked in the label. Only fetch and AbortController, so it is
+ * browser-safe; the desktop app can pass Tauri's fetch.
+ */
+export declare function checkProxyHealth(proxyUrl: string, fetchImpl?: typeof fetch): Promise<DoctorCheck>;

package/dist/redact-url.d.ts

@@ -0,0 +1,2 @@
+/** A URL with any user:password, and every query-string value, masked, so a credential embedded in proxyUrl is never printed. Text that is not a URL is returned unchanged. */
+export declare function redactUrlCredentials(text: string): string;

package/dist/reply-audit.d.ts

@@ -59,6 +59,8 @@ export declare function replyAuditNotice(audit: ReplyAudit, actions: string[]):
  * turns it off. Same shape as `semanticGroundingEnabled()`.
  */
 export declare function replyAuditEnabled(env?: Record<string, string | undefined>): boolean;
+/** Every automatic retry message starts with this; it is the system talking to the model, never something the user said. */
+export declare const AUDIT_NUDGE_PREFIX = "[automatic reply check]";
 /**
  * The message for the one automatic retry, or undefined when the reply needs none. A claim or promise of work the system
  * did not record asks for the work to be done now or the claim withdrawn; details that disagree with the command output

package/dist/response-service.d.ts

@@ -41,6 +41,16 @@ export declare class ResponseService {
      * thread, not be silently dropped). A no-op when `memory` wasn't wired in, or the caller never
      * resolved a `threadId` — exactly today's behavior either way (INV-43).
      */
+    /** Public entry for the tool-level approval path (a staged write/command pauses the turn before any result builder runs): records the tasks on the goal thread so Goals shows them. */
+    syncGoalThread(sessionId: string, threadId: string | undefined, tasks: {
+        id: string;
+        status: string;
+        description?: string;
+        depends_on?: string[];
+        risk_level?: string;
+    }[], onUsage?: (usage: TokenUsage) => void): Promise<void>;
+    /** Marks every counted task of `threadId` COMPLETE (the staged actions it was waiting on were approved and applied); a thread whose tasks all finish moves to DONE. */
+    completeGoalThread(sessionId: string, threadId: string | undefined, onUsage?: (usage: TokenUsage) => void): Promise<void>;
     private syncGoalThreadEvidence;
     buildTrivialResult(params: {
         sessionId: string;

package/dist/run-explain.d.ts

@@ -0,0 +1,58 @@
+import { AssistantTrace, AssistantSource, AssistantTurnResult } from './assistant.js';
+import { AnswerClaim } from './answer-claim.js';
+import { MemoryInjection } from './memory-service.js';
+import { AssistantToolStep } from './tool-step.js';
+import { GoalGraphState } from './goal-graph-service.js';
+/**
+ * The one place that explains a finished turn ("why", "layers", "sources", "steps", "plan").
+ * The CLI prints these lines and chat-ui shows the same lines in a panel, so what the user is told
+ * about a turn cannot drift between surfaces. Everything here is a pure function of data the turn
+ * already produced — no I/O, no UI.
+ */
+/** What a surface remembers about the last turn. All fields are optional: a staged, declined or fast-path turn has no trace. */
+export interface TurnExplainInput {
+    trace?: AssistantTrace;
+    /** True when the turn skipped the harness entirely (a self-contained trivial question). */
+    harnessSkipped?: boolean;
+    /** Why there is no trace, when the surface knows a more specific reason than the generic one. */
+    noTraceReason?: string;
+    answerClaim?: AnswerClaim;
+    memoryInjection?: MemoryInjection;
+    sources?: AssistantSource[];
+    toolSteps?: AssistantToolStep[];
+    planStatus?: AssistantTurnResult['planStatus'];
+    /** The session's goal threads. When there is no drafted plan but threads have tasks, /plan says the request was worked as tracked goal tasks instead of "No active plan". */
+    goalGraph?: GoalGraphState;
+}
+export declare const FAST_PATH_REASON = "No harness trace \u2014 the last turn was a simple, self-contained question answered directly without activating the harness (fast path).";
+export declare const GENERIC_NO_TRACE_REASON = "No harness trace for the last turn (nothing to explain yet, or it took the fast path).";
+export declare const NO_SOURCES_TEXT = "No sources for the last turn (it used no file/web tool calls).";
+export declare const NO_STEPS_TEXT = "No tool steps for the last turn.";
+export declare const NO_PLAN_TEXT = "No active plan for this session.";
+export declare const NO_DRAFTED_PLAN_BUT_GOAL_TASKS_TEXT = "No drafted plan for this session. The request was worked as tracked goal tasks (/goals):";
+/** Slash commands that open the explanations. Shared so the CLI's dispatch table and chat-ui's composer recognise the same words. */
+export declare const EXPLAIN_COMMANDS: readonly ["/why", "/layers", "/sources", "/steps", "/plan"];
+export type ExplainCommand = (typeof EXPLAIN_COMMANDS)[number];
+export declare function verificationHealthLabel({ strength, feasibility }: AssistantTrace['verificationHealth']): string;
+/**
+ * Turns AnswerClaim's mechanically-derived verification_status into the "this is true" vs "I found X
+ * but couldn't independently verify it" text. One pure function so a future change can't silently
+ * collapse the four branches back into one generic phrasing.
+ */
+export declare function answerClaimLabel(claim: AnswerClaim): string;
+type BatchBudget = NonNullable<AssistantTrace['batchBudget']>;
+/** One-line found / not found / truncated tally for a batch-research turn (absent on every other turn). */
+export declare function batchBudgetSummaryLine(batchBudget: BatchBudget): string;
+/** `/why` — confidence, whether the reply was checked against what was read, the layers that fired (in order), and what memory the prompt held. */
+export declare function explainWhy(input: TurnExplainInput): string[];
+/** `/layers` — every one of the 11 layers: fired or not, and why; plus the per-item batch breakdown on a batch turn. */
+export declare function explainLayers(input: TurnExplainInput): string[];
+/** `/sources` — the files and URLs the turn consulted, each once. */
+export declare function explainSources(input: TurnExplainInput): string[];
+/** `/steps` — the tool calls the turn made, in order. */
+export declare function explainSteps(input: TurnExplainInput): string[];
+/** `/plan` — the active plan's task checklist. */
+export declare function explainPlan(input: TurnExplainInput): string[];
+/** Dispatches a bare slash command to its explainer; undefined for anything else (including `/plan graph` and other arguments, which are not explanations). */
+export declare function explainCommand(message: string, input: TurnExplainInput): string[] | undefined;
+export {};

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

@@ -51,7 +51,7 @@ export interface ScriptedLLMClientScript {
 /**
  * Known auxiliary semantic-escalation system prompts and their safe, inert default answer — see
  * ScriptedLLMClientScript's doc comment. Kept in sync by hand with each check's own system prompt
- * (review-checker.ts, failure-mode-matcher.ts, trust-tagging.ts, grounding-check.ts, task-completion-check.ts, constraint-check.ts, semantic-compaction.ts, source-reliability.ts, semantic-hypotheses.ts, episodic-digest.ts, memory-consolidation.ts, memory-reviewer.ts) since there's no shared constant
+ * (review-checker.ts, failure-mode-matcher.ts, trust-tagging.ts, grounding-check.ts, task-completion-check.ts, constraint-check.ts, semantic-compaction.ts, source-reliability.ts, semantic-hypotheses.ts, episodic-digest.ts, memory-consolidation.ts, memory-reviewer.ts, writer/writer-chat-capture.ts) since there's no shared constant
  * to import without a circular dependency back into this package's own public surface.
  */
 export declare const SIDE_CALL_MARKERS: Array<[string, string]>;

package/dist/{tui-app-CcxiwZyM.js → tui-app-oWbIUcBW.js}

@@ -5,9 +5,9 @@ import { jsxs, jsx } from "react/jsx-runtime";
 import { Readable, Writable } from "node:stream";
 import { useState, useRef, useEffect, useMemo, useCallback, useSyncExternalStore } from "react";
 import { useWindowSize, usePaste, useInput, Box, Text, render, Static } from "ink";
-import { s as sanitizeLabel, r as renderPlan, t as toLines, a as runCli, P as PLAN_LINE_PREFIX, I as ICONS } from "./bin-DETwedpj.js";
+import { s as sanitizeLabel, r as renderPlan, t as toLines, a as runCli, P as PLAN_LINE_PREFIX, I as ICONS } from "./bin-Cz3FY6Ew.js";
 import { format } from "node:util";
-import { o as DIFF_INDENT, bM as stripTerminalControls } from "./provider-setup-wX2IBw2X.js";
+import { v as DIFF_INDENT, cW as stripTerminalControls } from "./provider-setup-DG8iYm_F.js";
 function classify(raw, stream) {
   if (raw.startsWith("\r")) {
     return { type: "progress", text: raw.replace(/\r/g, "").trimEnd() };
@@ -1057,4 +1057,4 @@ export {
   formatLivenessLabel,
   runTuiApp
 };
-//# sourceMappingURL=tui-app-CcxiwZyM.js.map
+//# sourceMappingURL=tui-app-oWbIUcBW.js.map