@wrongstack/cli 0.309.1 → 0.310.1

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:8000` 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/session-establishment.d.ts

@@ -0,0 +1,45 @@
+import type { CliContext } from '../cli-context.js';
+import type { loadOnlineAgentsForPrompt } from '../cli-main-helpers.js';
+import { setupSession } from './session.js';
+export interface SessionEstablishmentArgs {
+    /** Container used to resolve SessionStore + TokenCounter. */
+    container: Pick<CliContext['container'], 'resolve'>;
+    config: {
+        provider: string;
+        model: string;
+    };
+    wpaths: Parameters<typeof setupSession>[0]['wpaths'];
+    projectRoot: string;
+    cwd: string;
+    systemPrompt: Parameters<typeof setupSession>[0]['systemPrompt'];
+    provider: Parameters<typeof setupSession>[0]['provider'];
+    renderer: Parameters<typeof setupSession>[0]['renderer'];
+    flags: Parameters<typeof setupSession>[0]['flags'];
+    events: NonNullable<Parameters<typeof setupSession>[0]['events']>;
+    logger: Parameters<typeof setupSession>[0]['logger'];
+    /** Live ref so /resume writer swaps are picked up without re-wiring. */
+    sessionRef: {
+        current: {
+            id?: string;
+            flushSync?: () => void;
+        } | undefined;
+    };
+    onlineAgents: Awaited<ReturnType<typeof loadOnlineAgentsForPrompt>>;
+    /** Owned by the teardown-registrar phase; consumed here for clientType. */
+    tuiOwnsScreen: boolean;
+}
+export declare function setupSessionEstablishment(args: SessionEstablishmentArgs): Promise<{
+    sessionStore: import("@wrongstack/core").SessionStore;
+    tokenCounter: import("@wrongstack/core").TokenCounter;
+    context: import("@wrongstack/core").Context;
+    planPath: string;
+    session: import("@wrongstack/core").SessionWriter;
+    attachments: import("@wrongstack/core/storage").DefaultAttachmentStore;
+    queueStore: import("@wrongstack/core/storage").QueueStore;
+    detachTodosCheckpoint: () => void | Promise<void>;
+    priorFleetState: import("@wrongstack/core/storage").DirectorStateSnapshot | undefined;
+    /** Full SessionResult, passed through for downstream consumers
+     *  (runCliExecution, multi-agent setup read traceId/resumed* off it). */
+    sessResult: import("./session.js").SessionResult;
+}>;
+//# sourceMappingURL=session-establishment.d.ts.map

package/dist/wiring/session-registry.d.ts

@@ -20,7 +20,7 @@ export interface SetupSessionRegistryDeps {
 }
 export interface SetupSessionRegistryResult {
     /** AgentStatusTracker when the dynamic import and setup succeeded, else undefined. */
-    tracker: InstanceType<typeof import('@wrongstack/core/storage').AgentStatusTracker> | undefined;
+    tracker: InstanceType<typeof import('@wrongstack/core/coordination').AgentStatusTracker> | undefined;
     /**
      * Atomically move this process's registry ownership to another session.
      * Used by explicit resume; unrelated sessions in other processes are untouched.

package/dist/wiring/session-runtime.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Session-runtime wiring for the interactive CLI (card #7C slice 4).
+ *
+ * Extracted verbatim from cli-main.ts. Owns the post-establishment session
+ * surface:
+ *
+ * - `wireSessionEvents` (error ring, session bridge, chronicle) plus the
+ *   `process.once('beforeExit')` hook that flushes the chronicle on the way
+ *   out — the last teardown hook that lived inline in the orchestrator.
+ * - `SessionStats` fed by the shared EventBus + token counter.
+ * - The active reasoning-config refresher (best-effort modelsRegistry lookup)
+ *   and the warning-dedup set behind `model-runtime` pipeline warnings.
+ * - `setupPipelines` with the modelRuntime overlay, then the governance
+ *   tool-boundary install when replay-governance is active.
+ *
+ * `getActiveReasoningConfig()` exposes the CURRENT reasoning config exactly
+ * the way the orchestrator's inline `let` did when `runCliExecution` read it
+ * by value at call time.
+ */
+import type { Context } from '@wrongstack/core/agent';
+import type { Provider } from '@wrongstack/core/types';
+import type { CliContext } from '../cli-context.js';
+import { wireSessionEvents } from '../session-event-wiring.js';
+import { SessionStats } from '../session-stats.js';
+import type { setupReplayAndGovernance } from './replay-governance-setup.js';
+type WireArgs = Parameters<typeof wireSessionEvents>[0];
+type GovernanceHandle = Awaited<ReturnType<typeof setupReplayAndGovernance>>['governanceHandle'];
+export interface SessionRuntimeArgs {
+    evOn: WireArgs['evOn'];
+    events: NonNullable<WireArgs['events']>;
+    /** Live config binding; provider/model are read once at setup time. */
+    config: CliContext['config'];
+    context: Context;
+    session: WireArgs['session'];
+    sessionRef: WireArgs['sessionRef'];
+    wpaths: WireArgs['wpaths'];
+    projectRoot: WireArgs['projectRoot'];
+    renderer: NonNullable<WireArgs['renderer']>;
+    tuiOwnsScreen: boolean;
+    tokenCounter: ConstructorParameters<typeof SessionStats>[1];
+    modelsRegistry: CliContext['modelsRegistry'];
+    configStore: CliContext['configStore'];
+    provider: {
+        capabilities: Provider['capabilities'];
+    };
+    logger: CliContext['logger'];
+    governanceHandle: GovernanceHandle;
+}
+export declare function setupSessionRuntime(args: SessionRuntimeArgs): {
+    errorRing: import("../session-event-wiring.js").ErrorEntry[];
+    sessionBridge: import("@wrongstack/core").SessionEventBridge;
+    stats: SessionStats;
+    pipelines: import("@wrongstack/core/agent").AgentPipelines;
+    refreshActiveReasoningConfig: (providerId: string, modelId: string) => Promise<void>;
+    getActiveReasoningConfig: () => import("@wrongstack/core/types").ReasoningConfig | undefined;
+    /**
+     * Lifecycle registration is intentionally NOT done here — this module is
+     * reusable and must not install process-level hooks (chimera review).
+     * The composition root owns `process.once('beforeExit', ...)` wiring.
+     */
+    disposeChronicle: () => Promise<void>;
+};
+export {};
+//# sourceMappingURL=session-runtime.d.ts.map

package/dist/wiring/teardown-registrar.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Teardown-registrar phase (card #7C-2), extracted verbatim from
+ * `cli-main.ts` (was lines 164-179).
+ *
+ * Two concerns that must stay together because of the LIFO teardown
+ * contract:
+ *
+ * 1. `createTeardownEventRegistrar` wraps `events` so event-driven
+ *    subscriptions unregister themselves on shutdown (their disposers go
+ *    to the same chain).
+ * 2. The vector-memory SQLite `close()` teardown is pushed *after* the
+ *    registrar — in the original file the store-close push sat at line
+ *    170, after the mirror-dispose push at line 168 from the setup
+ *    phase, so on LIFO teardown close runs before the mirror dispose.
+ *    Keeping this registration inside the same function preserves that
+ *    exact ordering; moving it back into the setup phase would invert
+ *    the shutdown sequence.
+ *
+ * `tuiOwnsScreen` is resolved here as well (was line 164): it derives
+ * purely from flags and is consumed by the event wiring below.
+ */
+import type { VectorMemoryStore } from '@wrongstack/vector-memory';
+import { createTeardownEventRegistrar } from '../cli-main-helpers.js';
+export interface TeardownRegistrarArgs {
+    flags: {
+        tui?: unknown;
+        'no-tui'?: unknown;
+    };
+    events: Parameters<typeof createTeardownEventRegistrar>[0];
+    logger: {
+        debug?: (message: string) => void;
+    };
+    teardownHandlers: Array<() => void>;
+    vectorMemoryStore: VectorMemoryStore | undefined;
+}
+export interface TeardownRegistrarResult {
+    tuiOwnsScreen: boolean;
+    evOn: ReturnType<typeof createTeardownEventRegistrar>;
+}
+export declare function setupTeardownRegistrar(args: TeardownRegistrarArgs): TeardownRegistrarResult;
+//# sourceMappingURL=teardown-registrar.d.ts.map

package/dist/wiring/vector-memory-setup.d.ts

@@ -0,0 +1,30 @@
+import type { MemoryPort } from '@wrongstack/core/types';
+import { VectorMemoryStore } from '@wrongstack/vector-memory';
+export interface VectorMemoryArgs {
+    projectRoot: string;
+    flags: {
+        'vector-sync'?: unknown;
+    };
+    logger: {
+        warn: (message: string) => void;
+        info: (message: string) => void;
+        debug?: (message: string) => void;
+    };
+    /** The SAGE memory port; returned wrapped when the vector store comes up. */
+    memoryStore: MemoryPort;
+    /** Disposer chain; the mirror-dispose handler is pushed from inside. */
+    teardownHandlers: Array<() => void>;
+}
+export interface VectorMemoryResult {
+    memoryStore: MemoryPort;
+    vectorMemoryStore: VectorMemoryStore | undefined;
+    /**
+     * Model-cache directory (`.wrongstack/cache/transformers-models` under the
+     * project root). Surfaced because `session-start-payload` advertises the
+     * cache location to the WebUI — callers pass it onward (original
+     * cli-main.ts line 801 shorthand).
+     */
+    vectorMemoryModelCacheDir: string;
+}
+export declare function setupVectorMemory(args: VectorMemoryArgs): Promise<VectorMemoryResult>;
+//# sourceMappingURL=vector-memory-setup.d.ts.map

package/package.json

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