@wrongstack/cli 0.310.0 → 0.313.0

package/dist/wiring/proxy-probe.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Periodic health probe for the local WrongProxy / WrongTrace daemon.
+ *
+ * The daemon exposes `GET <base>/api/health` returning JSON like:
+ *   { "repo": "WrongTrace", "status": "ok", "timestamp": "...", ... }
+ *
+ * The probe:
+ *  1. Runs once on boot so the first request doesn't hit a dead proxy.
+ *  2. Re-runs every `intervalMs` (default 30s) while the toggle is on.
+ *  3. Aborts in-flight probes on every state change so we never accumulate
+ *     a backlog when the user toggles the proxy on/off rapidly.
+ *  4. Uses a small per-call AbortController + timeout (2s) so a hung
+ *     `localhost:3444` cannot stall the loop.
+ *
+ * The probe is intentionally minimal: the daemon's `/api/health` response
+ * shape is small and stable, so we don't try to parse it — a 2xx is
+ * enough to mark the proxy active. Failures (timeout, non-2xx, ECONNREFUSED)
+ * are treated as SOFT signals: a single transient failure (daemon mid-
+ * restart, one dropped 2xx) must not flip `active` to false and silently
+ * disable rewrites for every subsequent request. `active` flips to false
+ * only after `deactivateAfterFailures` consecutive failures; the periodic
+ * loop keeps retrying, so a recovered daemon re-activates on the next
+ * successful probe. Toggle-off (`enabled: false` / no URL) still deactivates
+ * immediately.
+ */
+interface ProbeRunnerOptions {
+    /** Override the default interval (30s). Useful for tests. */
+    intervalMs?: number;
+    /** Override the default per-request timeout (2s). Useful for tests. */
+    timeoutMs?: number;
+    /** Override `fetch` for tests. */
+    fetchImpl?: typeof fetch;
+    /** Override `setInterval` / `clearInterval` for tests. */
+    setIntervalImpl?: typeof setInterval;
+    clearIntervalImpl?: typeof clearInterval;
+    /**
+     * Number of CONSECUTIVE failed probes required before `active` flips to
+     * false. A single transient failure is a soft signal and leaves `active`
+     * untouched. Defaults to 2. Useful for tests wanting to exercise the
+     * threshold without waiting two ticks.
+     */
+    deactivateAfterFailures?: number;
+}
+export interface ProbeRunner {
+    /** Stop the periodic probe and abort any in-flight request. */
+    stop(): void;
+    /** Force an immediate probe (next tick). Resolves with whether the health check succeeded. */
+    poke(): Promise<boolean>;
+}
+/**
+ * Start the probe loop. Idempotent — repeated calls reuse the existing
+ * runner unless `stop()` was called in between.
+ */
+export declare function startProxyProbe(opts?: ProbeRunnerOptions): ProbeRunner;
+/**
+ * Stop any running probe. Safe to call when nothing is running.
+ */
+export declare function stopProxyProbe(): void;
+/** Test-only: clear module state without touching timers. */
+export declare function __resetProxyProbeForTests(): void;
+export {};
+//# sourceMappingURL=proxy-probe.d.ts.map

package/dist/wiring/proxy-wiring.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Bridge between the WS prefs pipeline and the proxy-rewrite runtime.
+ *
+ * Lives in `@wrongstack/cli/wiring/proxy-wiring.ts` because it owns the
+ * side-effectful boot of the probe loop — `proxy-rewrite` is pure logic
+ * and `proxy-probe` is the periodic side-effect loop, but neither knows
+ * about WS prefs. This module is the single owner of:
+ *
+ *   - the singleton probe runner
+ *   - pushing user prefs into the proxy-rewrite config
+ *   - kicking off the periodic /api/health probe when the toggle goes on
+ *
+ * Re-exported so `handlePrefsUpdate` in `@wrongstack/webui-server` can
+ * call `applyWrongProxyPrefs(payload)` without taking a direct dependency
+ * on `proxy-probe` (the WS server is intentionally provider-agnostic).
+ */
+/**
+ * Apply the `wrongProxyEnabled` + `wrongProxyUrl` portion of a prefs
+ * payload. Idempotent — safe to call on every `prefs.update`. Boots the
+ * probe on first call so the rewrite can be marked active before the
+ * next request hits the provider factory.
+ */
+export declare function applyWrongProxyPrefs(payload: Record<string, unknown>): void;
+/**
+ * Await one probe pass so the `ProxyConfig` singleton's `active` flag is
+ * settled before the caller reads it. Returns immediately when no probe
+ * runner exists (toggle never enabled). Each call triggers a fresh
+ * `runOnce()` probe — there is no memoization — so call it once per
+ * decision point, not per request.
+ *
+ * This closes the cli-main boot race: `bootstrapWrongProxy()` seeds
+ * `enabled` / `url` synchronously, but `startProxyProbe()` only schedules
+ * a 30 s `setInterval` and the first `poke()` resolves on the next
+ * macrotask. `setupProviderRuntime()` runs synchronously on the very
+ * next line, so without this gate providers are constructed with the raw
+ * base URL even when the toggle is on.
+ */
+export declare function awaitFirstWrongProxyProbe(): Promise<void>;
+/**
+ * Apply the initial prefs snapshot at boot. Same as `applyWrongProxyPrefs`
+ * but explicitly named for the boot site so future readers can find it.
+ *
+ * Accepts the canonical persisted shape (`config.tools.wrongProxy` —
+ * `{ enabled?, url? }`) directly. The `enabled` / `url` keys are mapped
+ * to the flat `wrongProxyEnabled` / `wrongProxyUrl` keys the proxy
+ * rewriter reads; any other keys in the snapshot are ignored. Callers
+ * that hold a `WrongProxyToolConfig` (the typed schema in
+ * `@wrongstack/core/types/config/tools.ts`) can pass it through without
+ * casting — the function never reads anything beyond `enabled` / `url`.
+ */
+export declare function bootstrapWrongProxy(snapshot: {
+    enabled?: boolean | undefined;
+    url?: string | undefined;
+} | Record<string, unknown> | undefined): void;
+/**
+ * Stop the probe. Intended for graceful shutdown / test cleanup.
+ */
+export declare function shutdownWrongProxy(): void;
+//# sourceMappingURL=proxy-wiring.d.ts.map

package/dist/wiring/wrongtrace-gate-counters.d.ts

@@ -0,0 +1,18 @@
+/**
+ * WrongTrace gate-decision counter — CLI re-export shim.
+ *
+ * The implementation lives in `@wrongstack/wrongtrace/src/gate-counters.ts`
+ * so EVERY process that runs the gate (CLI leader + fleet, standalone WebUI
+ * server) tallies against the same contract and the same counters file.
+ * This file exists only to keep the historical import path alive:
+ *   - `execution-cleanup.ts` (dynamic import for session-end persist)
+ *   - `brain-and-orchestration.ts` (fleet-runner emit-site recording)
+ *   - `subcommands/handlers/diag-doctor.ts` (proxy-status readout)
+ *   - `lifecycle-plugins.ts` (leader emit-site recording)
+ *   - `tests/wrongtrace-gate-counters.test.ts`
+ * All five resolve through this shim; nothing imports the adapter
+ * implementation directly from CLI source.
+ */
+export { createWrongTraceGateCounter, countersFilePath, formatGateCounterReport, loadWrongTraceGateCounters, persistWrongTraceGateCounters, recordGateDecision, resetGateDecisions, snapshotGateDecisions, } from '@wrongstack/wrongtrace';
+export type { WrongTraceGateCounter, WrongTraceGateCounterSnapshot, } from '@wrongstack/wrongtrace';
+//# sourceMappingURL=wrongtrace-gate-counters.d.ts.map

package/dist/wiring/wrongtrace-gate.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Re-export shim — the implementation moved into `@wrongstack/wrongtrace`
+ * so the CLI leader, fleet subagents, and the standalone WebUI server all
+ * share one gate without any of them importing `@wrongstack/cli` (the
+ * dependency direction cli → webui-server forbids the reverse edge).
+ *
+ * Every historical import path (`../wiring/wrongtrace-gate.js`) keeps
+ * working unchanged through this shim. NOTE: this is NOT core/utils'
+ * `withFileLock` (a local file lock) — same name, different mechanism.
+ */
+export { getWrongTrace, preflightFileEdit, resetWrongTraceGate, withFileLock, } from "@wrongstack/wrongtrace";
+export type { PreflightOptions, PreflightVerdict } from "@wrongstack/wrongtrace";
+//# sourceMappingURL=wrongtrace-gate.d.ts.map

package/dist/wiring/wrongtrace-hooks.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Re-export shim — the implementation moved into `@wrongstack/wrongtrace`
+ * (see wrongtrace-gate.ts for why). Same factories, same behaviour, now
+ * shared by every host process that executes tools.
+ */
+export { createWrongTraceHookPair, createWrongTracePostToolUseHook, createWrongTracePreToolUseHook, } from "@wrongstack/wrongtrace";
+export type { WrongTraceGateDecisionEvent, WrongTraceHookInput, WrongTraceHookOptions, WrongTraceHookPair, WrongTracePreToolUseOutcome, } from "@wrongstack/wrongtrace";
+//# sourceMappingURL=wrongtrace-hooks.d.ts.map

package/dist/wiring/wrongtrace-prompt-contributor.d.ts

@@ -0,0 +1,23 @@
+/**
+ * WrongTrace boot-prompt contributor — consumes the previously-unused
+ * `digestAtlas` and `summarizeFriction` helpers so the leader's system
+ * prompt, not just the executor gate, sees the daemon's observability.
+ *
+ * Contract:
+ *   - Fail-open: daemon offline / any throw → `[]` (no prompt block).
+ *   - Bounded: the gate singleton is warmed fire-and-forget at boot; this
+ *     contributor races discovery + atlas/friction fetches against short
+ *     deadlines so a cold/absent daemon can never stall the first build.
+ *     Each race is capped at CONTRIBUTOR_DEADLINE_MS; discovery + fetch is
+ *     at most ~2 × the deadline cold, far less once the singleton resolves
+ *     (a live local daemon answers in single-digit ms).
+ *   - Registered in `bindSystemPromptBuilder`'s contributors array, after
+ *     the ETERNAL AUTONOMY contributor (registration order is preserved).
+ */
+import type { SystemPromptContributor } from '@wrongstack/core/types';
+/**
+ * Build the contributor. Fresh instance per `bindSystemPromptBuilder` call
+ * (i.e. per process); cheap since the gate singleton is process-shared.
+ */
+export declare function createWrongTracePromptContributor(): SystemPromptContributor;
+//# sourceMappingURL=wrongtrace-prompt-contributor.d.ts.map

package/dist/wiring/wrongtrace-telemetry.d.ts

@@ -0,0 +1,53 @@
+/**
+ * WrongTrace session telemetry — the session-completion reporting hook.
+ *
+ * The daemon's /api/telemetry endpoint exists and answers 200 {ok:true}
+ * (verified live 2026-08-24), so WrongStack reports one summary per
+ * finished session: run id, agent/model/provider identity, token usage,
+ * and cost. This is what lets the daemon attribute activity (friction
+ * matrices, file lineage) to WrongStack sessions.
+ *
+ * Fail-open by construction: daemon offline → reportTelemetry returns
+ * null and this helper resolves without side effects; any throw is
+ * swallowed so session cleanup is never delayed or blocked by it.
+ */
+import type { WrongTraceTelemetryReport } from '@wrongstack/wrongtrace';
+/** Inputs the session-completion path already has in hand. */
+export interface WrongTraceTelemetryInput {
+    sessionId: string;
+    /** Stable agent identity, e.g. 'wrongstack-cli'. */
+    agentName: string;
+    model: string;
+    provider: string;
+    /** Cumulative session usage from tokenCounter.total(). */
+    usage: {
+        input: number;
+        output: number;
+        cacheRead?: number | undefined;
+        cacheWrite?: number | undefined;
+    };
+    /** Session cost in USD from tokenCounter.estimateCost().total. */
+    costUsd: number;
+}
+/**
+ * Pure mapping to the daemon's POST /api/telemetry contract. Cache fields
+ * ride along as extras (the payload allows free-form pass-through), so
+ * downstream attribution keeps the full token picture.
+ */
+export declare function buildWrongTraceTelemetryReport(input: WrongTraceTelemetryInput): WrongTraceTelemetryReport;
+/**
+ * Report session telemetry, best-effort. Never throws: an offline daemon,
+ * transport failure, or malformed response resolves silently — telemetry
+ * must never delay or fail session cleanup.
+ *
+ * Optional client injection is a test seam; production uses the singleton.
+ */
+export declare function reportWrongTraceSessionTelemetry(input: WrongTraceTelemetryInput, opts?: {
+    client?: {
+        isAvailable: boolean;
+        reportTelemetry: (r: WrongTraceTelemetryReport) => Promise<{
+            ok: boolean;
+        } | null>;
+    };
+}): Promise<void>;
+//# sourceMappingURL=wrongtrace-telemetry.d.ts.map

package/dist/wrongtrace-gate-counters-P5BCBXQN.js

@@ -0,0 +1,22 @@
+import {
+  countersFilePath,
+  createWrongTraceGateCounter,
+  formatGateCounterReport,
+  loadWrongTraceGateCounters,
+  persistWrongTraceGateCounters,
+  recordGateDecision,
+  resetGateDecisions,
+  snapshotGateDecisions
+} from "./chunk-7CECQDNH.js";
+import "./chunk-7OCVIDC7.js";
+export {
+  countersFilePath,
+  createWrongTraceGateCounter,
+  formatGateCounterReport,
+  loadWrongTraceGateCounters,
+  persistWrongTraceGateCounters,
+  recordGateDecision,
+  resetGateDecisions,
+  snapshotGateDecisions
+};
+//# sourceMappingURL=wrongtrace-gate-counters-P5BCBXQN.js.map

package/dist/wrongtrace-telemetry-6M2CCBX5.js

@@ -0,0 +1,34 @@
+import {
+  getWrongTrace
+} from "./chunk-4JRIWVJ4.js";
+import "./chunk-7OCVIDC7.js";
+
+// src/wiring/wrongtrace-telemetry.ts
+function buildWrongTraceTelemetryReport(input) {
+  return {
+    run_id: input.sessionId,
+    agent_name: input.agentName,
+    model_name: input.model,
+    provider: input.provider,
+    prompt_tokens: input.usage.input,
+    completion_tokens: input.usage.output,
+    cost_usd: input.costUsd,
+    intent: "session_complete",
+    cache_read_tokens: input.usage.cacheRead ?? 0,
+    cache_write_tokens: input.usage.cacheWrite ?? 0,
+    source: "wrongstack"
+  };
+}
+async function reportWrongTraceSessionTelemetry(input, opts = {}) {
+  try {
+    const wt = opts.client ?? await getWrongTrace();
+    if (!wt.isAvailable) return;
+    await wt.reportTelemetry(buildWrongTraceTelemetryReport(input));
+  } catch {
+  }
+}
+export {
+  buildWrongTraceTelemetryReport,
+  reportWrongTraceSessionTelemetry
+};
+//# sourceMappingURL=wrongtrace-telemetry-6M2CCBX5.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/cli",
-  "version": "0.310.0",
+  "version": "0.313.0",
   "license": "MIT",
   "description": "WrongStack CLI — terminal AI coding agent with provider catalog from models.dev. Provides `wrongstack` and `wstack` binaries.",
   "keywords": [
@@ -42,34 +42,35 @@
   ],
   "dependencies": {
     "ws": "^8.21.3",
-    "@wrongstack/acp": "0.310.0",
-    "@wrongstack/bench": "0.310.0",
-    "@wrongstack/core": "0.310.0",
-    "@wrongstack/persistence": "0.310.0",
-    "@wrongstack/kanban": "0.310.0",
-    "@wrongstack/plugins": "0.310.0",
-    "@wrongstack/plug-lsp": "0.310.0",
-    "@wrongstack/primitives": "0.310.0",
-    "@wrongstack/providers": "0.310.0",
-    "@wrongstack/runtime": "0.310.0",
-    "@wrongstack/sdd": "0.310.0",
-    "@wrongstack/mcp": "0.310.0",
-    "@wrongstack/requirement-intake": "0.310.0",
-    "@wrongstack/sage": "0.310.0",
-    "@wrongstack/security-scanner": "0.310.0",
-    "@wrongstack/techstack": "0.310.0",
-    "@wrongstack/telegram": "0.310.0",
-    "@wrongstack/simpleui": "0.310.0",
-    "@wrongstack/vector-memory": "0.310.0",
-    "@wrongstack/tools": "0.310.0",
-    "@wrongstack/webui": "0.310.0",
-    "@wrongstack/webui-server": "0.310.0",
-    "@wrongstack/webui-hq": "0.310.0",
-    "@wrongstack/tui": "0.310.0",
-    "@wrongstack/webui-protocol": "0.310.0"
+    "@wrongstack/acp": "0.313.0",
+    "@wrongstack/mcp": "0.313.0",
+    "@wrongstack/bench": "0.313.0",
+    "@wrongstack/primitives": "0.313.0",
+    "@wrongstack/plugins": "0.313.0",
+    "@wrongstack/core": "0.313.0",
+    "@wrongstack/kanban": "0.313.0",
+    "@wrongstack/plug-lsp": "0.313.0",
+    "@wrongstack/persistence": "0.313.0",
+    "@wrongstack/providers": "0.313.0",
+    "@wrongstack/requirement-intake": "0.313.0",
+    "@wrongstack/runtime": "0.313.0",
+    "@wrongstack/sage": "0.313.0",
+    "@wrongstack/simpleui": "0.313.0",
+    "@wrongstack/sdd": "0.313.0",
+    "@wrongstack/security-scanner": "0.313.0",
+    "@wrongstack/techstack": "0.313.0",
+    "@wrongstack/telegram": "0.313.0",
+    "@wrongstack/tui": "0.313.0",
+    "@wrongstack/tools": "0.313.0",
+    "@wrongstack/vector-memory": "0.313.0",
+    "@wrongstack/webui-protocol": "0.313.0",
+    "@wrongstack/webui": "0.313.0",
+    "@wrongstack/webui-hq": "0.313.0",
+    "@wrongstack/wrongtrace": "0.313.0",
+    "@wrongstack/webui-server": "0.313.0"
   },
   "optionalDependencies": {
-    "@wrongstack/desktop": "0.310.0"
+    "@wrongstack/desktop": "0.313.0"
   },
   "devDependencies": {
     "@types/node": "^26.2.0",