@wrongstack/wrongtrace 0.313.0

package/dist/gate.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Shared WrongTrace pre-flight gate for every host process.
+ *
+ * Originally lived in `@wrongstack/cli/wiring`; moved here so the CLI
+ * leader, fleet subagents, AND the standalone WebUI server can all pass
+ * their mutating tool calls through the exact same lock gate without any
+ * of them importing `@wrongstack/cli` (dep direction cli -> webui-server
+ * forbids the reverse edge).
+ *
+ * Wraps the @wrongstack/wrongtrace client into tiny entry points a host
+ * can call without caring whether the daemon is running:
+ *
+ *   - `preflightFileEdit(path)`  -> health/lock check BEFORE a heavy edit.
+ *     Locked files hard-block; fragile files soften the edit strategy.
+ *   - `withFileLock(path, fn)`   -> claim the daemon's lock around a heavy
+ *     edit so peer agents don't thrash the same file; unlocks in `finally`.
+ *
+ * Design rules (kept deliberately):
+ *   - The daemon is OPTIONAL. Every path degrades to "allow" - an offline
+ *     WrongTrace must never block an edit (mirrors proxy-probe's soft
+ *     -signal philosophy).
+ *   - Discovery runs ONCE, lazily, fire-and-forget per process. Each host
+ *     process gets its own singleton here; the CLI additionally warms it
+ *     at boot (`void getWrongTrace()`).
+ *   - Stale locks (TTL already elapsed) do not block; the risk fusion in
+ *     agent-helpers already ignores them.
+ */
+import { type WrongTraceClientInternal } from "./client.js";
+import { type CrossAgentRisk } from "./agent-helpers.js";
+/** Outcome the caller dispatches on. `allow` is always the safe default. */
+export type PreflightVerdict = {
+    kind: "allow";
+    risk: CrossAgentRisk | null;
+} | {
+    kind: "blocked";
+    risk: CrossAgentRisk;
+};
+/** Lazily created singleton — resolves to isAvailable:false when offline. */
+export declare function getWrongTrace(): Promise<WrongTraceClientInternal>;
+/** Test seam: reset the singleton between suites. */
+export declare function resetWrongTraceGate(): void;
+export interface PreflightOptions {
+    /** Caller identity stamped on locks (e.g. session id / agent name). */
+    owner?: string;
+    ownerRunId?: string;
+}
+/**
+ * Pre-flight check before a heavy edit. Fast (single file-health fetch
+ * behind the adapter's risk fusion). Locked by ANOTHER owner → blocked;
+ * everything else, including daemon-offline → allow. A lock the caller
+ * itself holds (`selfOwner` matching the daemon's `lock_owner`) is exempted.
+ *
+ * Verified live (2026-08-24): `/api/file/health` returns `is_locked`,
+ * `lock_owner`, `lock_reason`, `lock_expires_at` while a lock is held, so
+ * this CAN return `blocked` on the current daemon schema.
+ */
+export declare function preflightFileEdit(path: string, selfOwner?: string): Promise<PreflightVerdict>;
+/**
+ * Run `fn` under the daemon's file lock. Best-effort: if the daemon is
+ * offline, or lock acquisition fails for any transport reason, `fn` still
+ * runs — coordination is an optimization, not a hard dependency.
+ */
+export declare function withFileLock<T>(path: string, reason: string, fn: () => Promise<T>, opts?: PreflightOptions): Promise<T>;
+//# sourceMappingURL=gate.d.ts.map

package/dist/gate.js

@@ -0,0 +1,94 @@
+/**
+ * Shared WrongTrace pre-flight gate for every host process.
+ *
+ * Originally lived in `@wrongstack/cli/wiring`; moved here so the CLI
+ * leader, fleet subagents, AND the standalone WebUI server can all pass
+ * their mutating tool calls through the exact same lock gate without any
+ * of them importing `@wrongstack/cli` (dep direction cli -> webui-server
+ * forbids the reverse edge).
+ *
+ * Wraps the @wrongstack/wrongtrace client into tiny entry points a host
+ * can call without caring whether the daemon is running:
+ *
+ *   - `preflightFileEdit(path)`  -> health/lock check BEFORE a heavy edit.
+ *     Locked files hard-block; fragile files soften the edit strategy.
+ *   - `withFileLock(path, fn)`   -> claim the daemon's lock around a heavy
+ *     edit so peer agents don't thrash the same file; unlocks in `finally`.
+ *
+ * Design rules (kept deliberately):
+ *   - The daemon is OPTIONAL. Every path degrades to "allow" - an offline
+ *     WrongTrace must never block an edit (mirrors proxy-probe's soft
+ *     -signal philosophy).
+ *   - Discovery runs ONCE, lazily, fire-and-forget per process. Each host
+ *     process gets its own singleton here; the CLI additionally warms it
+ *     at boot (`void getWrongTrace()`).
+ *   - Stale locks (TTL already elapsed) do not block; the risk fusion in
+ *     agent-helpers already ignores them.
+ */
+import { createWrongTraceClient } from "./client.js";
+import { getCrossAgentRisk } from "./agent-helpers.js";
+let clientPromise;
+/** Lazily created singleton — resolves to isAvailable:false when offline. */
+export function getWrongTrace() {
+    if (clientPromise === undefined) {
+        clientPromise = createWrongTraceClient().catch(() => {
+            // Never let a discovery rejection poison the singleton.
+            return { isAvailable: false };
+        });
+    }
+    return clientPromise;
+}
+/** Test seam: reset the singleton between suites. */
+export function resetWrongTraceGate() {
+    clientPromise = undefined;
+}
+/**
+ * Pre-flight check before a heavy edit. Fast (single file-health fetch
+ * behind the adapter's risk fusion). Locked by ANOTHER owner → blocked;
+ * everything else, including daemon-offline → allow. A lock the caller
+ * itself holds (`selfOwner` matching the daemon's `lock_owner`) is exempted.
+ *
+ * Verified live (2026-08-24): `/api/file/health` returns `is_locked`,
+ * `lock_owner`, `lock_reason`, `lock_expires_at` while a lock is held, so
+ * this CAN return `blocked` on the current daemon schema.
+ */
+export async function preflightFileEdit(path, selfOwner) {
+    const wt = await getWrongTrace();
+    if (!wt.isAvailable)
+        return { kind: "allow", risk: null };
+    const risk = await getCrossAgentRisk(wt, path, 50, selfOwner);
+    if (risk.band === "locked")
+        return { kind: "blocked", risk };
+    return { kind: "allow", risk };
+}
+/**
+ * Run `fn` under the daemon's file lock. Best-effort: if the daemon is
+ * offline, or lock acquisition fails for any transport reason, `fn` still
+ * runs — coordination is an optimization, not a hard dependency.
+ */
+export async function withFileLock(path, reason, fn, opts = {}) {
+    const wt = await getWrongTrace();
+    if (!wt.isAvailable)
+        return fn();
+    const lockOpts = {
+        // Generous TTL: heavy edits can run long; the lock self-reaps if we
+        // crash mid-edit so a dead session can never block the file forever.
+        ttlSeconds: 900,
+    };
+    if (opts.owner !== undefined)
+        lockOpts.owner = opts.owner;
+    if (opts.ownerRunId !== undefined)
+        lockOpts.ownerRunId = opts.ownerRunId;
+    const res = await wt.lockFile(path, reason, lockOpts);
+    // Conflict body carries ok:false + owner/expires_at — do NOT steal the
+    // file; run unlocked rather than forcing a peer's lock away.
+    const acquired = res?.ok === true;
+    try {
+        return await fn();
+    }
+    finally {
+        if (acquired)
+            await wt.unlockFile(path);
+    }
+}
+//# sourceMappingURL=gate.js.map

package/dist/hooks.d.ts

@@ -0,0 +1,120 @@
+/**
+ * WrongTrace guardrail hooks — shared by every host that executes tools.
+ *
+ * Originally lived in `@wrongstack/cli/wiring`; moved here so the CLI
+ * leader, fleet subagents, the standalone WebUI server, and runtime-package
+ * light subagents register the identical gate without cross-importing each
+ * other. These are STRUCTURAL functions: they deliberately avoid an
+ * `@wrongstack/core` dependency (the adapter package stays decoupled from
+ * every runtime inside WrongStack), so hosts register them on their own
+ * `HookRegistry` and the structural parameter types accept core's richer
+ * `HookInput`.
+ *
+ * Behaviour:
+ *   preToolUse:  resolve the target path from toolInput; run the
+ *                WrongTrace pre-flight (health + lock state). A file
+ *                locked by ANOTHER owner DENIES the call with the
+ *                owner/expiry in the reason — the model sees it and can
+ *                pick another file. A lock owned by THIS session is
+ *                treated as available (self-owner exemption) so the
+ *                acquire-in-pre/release-in-post pairing stays usable —
+ *                a leaked own lock (executor denied/threw before postToolUse)
+ *                never blocks the session's own retry. Healthy/fragile/
+ *                offline daemons ALLOW; fragile files additionally get a
+ *                one-line "prefer surgical edits" nudge via additionalContext.
+ *                On allow we also ACQUIRE the daemon lock for the edit
+ *                (owner = session id) so peers see the claim.
+ *   postToolUse: release the lock acquired in preToolUse (path-keyed).
+ *                The daemon TTL is the leak backstop if execution never
+ *                completes.
+ *
+ * Concurrency: lock bookkeeping is scoped PER HOOK PAIR (per runner), not
+ * process-global, and reference-counted. A shared module-level map would let
+ * one executor's postToolUse release another executor's active lock when the
+ * same path is claimed by two in-process runners. `createWrongTraceHookPair`
+ * allocates its own counter map; it is also safe to share ONE pair across
+ * concurrent executors (standalone WebUI parent + SDD-wizard workers, or the
+ * fleet runner across subagents) — overlapping claims increment the count and
+ * the daemon lock is only released when the LAST finisher's postToolUse
+ * decrements it to zero.
+ *
+ * Failure philosophy: COORDINATION optimization, never a hard dependency.
+ * Daemon offline → everything allows. Any throw inside the hooks must be
+ * swallowed by the caller-side catch below so a slow daemon (timeout) can
+ * never add latency surprises to the edit path.
+ */
+/**
+ * Structural subset of the host's `HookInput` this hook actually reads.
+ * Core's `HookInput` (and any host equivalent carrying `toolName` +
+ * `toolInput`) is structurally assignable to this, which is what lets the
+ * same factory serve every host without a framework dependency here.
+ */
+export interface WrongTraceHookInput {
+    toolName?: string | undefined;
+    toolInput?: unknown;
+}
+/** Mutually-exclusive pre-flight verdict, mirroring core's contract. */
+export type WrongTracePreToolUseOutcome = {
+    action: "allow";
+    additionalContext?: string | undefined;
+} | {
+    action: "deny";
+    reason: string;
+};
+/**
+ * Typed gate-decision events emitted by the hooks when a host supplies an
+ * `emit` callback. One event per decision point — denied edit, fragile
+ * nudge, lock acquired / race-lost / released. Hosts map these onto their
+ * EventBus (e.g. `events.emit('wrongtrace.gate.decision', e)`); the
+ * adapter itself stays transport-agnostic.
+ */
+export type WrongTraceGateDecisionEvent = {
+    kind: "deny";
+    path: string;
+    reason: string;
+} | {
+    kind: "allow-fragile";
+    path: string;
+    reasons: readonly string[];
+} | {
+    kind: "lock-acquired";
+    path: string;
+    owner: string;
+} | {
+    kind: "lock-conflict-race";
+    path: string;
+} | {
+    kind: "lock-released";
+    path: string;
+};
+export interface WrongTraceHookPair {
+    /** Pre-flight + claim. Denies when another owner holds the file. */
+    preToolUse: (input: WrongTraceHookInput, runtime?: unknown) => Promise<WrongTracePreToolUseOutcome | undefined>;
+    /** Release the lock claimed by `preToolUse` for the same path. */
+    postToolUse: (input: WrongTraceHookInput) => Promise<void>;
+}
+export interface WrongTraceHookOptions {
+    /** Typed gate-decision event sink (host maps it onto its EventBus). */
+    emit?: (event: WrongTraceGateDecisionEvent) => void;
+}
+/**
+ * Per-runner lock bookkeeping. Reference-counted: when one hook pair is
+ * shared across concurrent executors (standalone WebUI parent + SDD-wizard
+ * workers, or the fleet runner across subagents), overlapping claims on the
+ * same path increment the count and the daemon lock is only released when
+ * the LAST finisher's postToolUse decrements it to zero — a sibling finishing
+ * early can never unlock a path another in-flight edit still holds.
+ */
+export declare function newWrongTraceLockCounter(): Map<string, number>;
+/**
+ * Create a pre/post hook PAIR sharing one per-runner reference-counted lock
+ * map. Every host should use this when wiring both phases: the pairing
+ * guarantees `postToolUse` only releases locks this exact pair's
+ * `preToolUse` claimed (see concurrency note at the top of this file), and
+ * the reference count keeps the daemon lock held while any sibling executor
+ * sharing the pair still has the path in flight.
+ */
+export declare function createWrongTraceHookPair(sessionId: () => string, opts?: WrongTraceHookOptions, counters?: Map<string, number>): WrongTraceHookPair;
+export declare function createWrongTracePreToolUseHook(sessionId: () => string, opts?: WrongTraceHookOptions): (input: WrongTraceHookInput, runtime?: unknown) => Promise<WrongTracePreToolUseOutcome | undefined>;
+export declare function createWrongTracePostToolUseHook(opts?: WrongTraceHookOptions): (input: WrongTraceHookInput) => Promise<void>;
+//# sourceMappingURL=hooks.d.ts.map

package/dist/hooks.js

@@ -0,0 +1,228 @@
+/**
+ * WrongTrace guardrail hooks — shared by every host that executes tools.
+ *
+ * Originally lived in `@wrongstack/cli/wiring`; moved here so the CLI
+ * leader, fleet subagents, the standalone WebUI server, and runtime-package
+ * light subagents register the identical gate without cross-importing each
+ * other. These are STRUCTURAL functions: they deliberately avoid an
+ * `@wrongstack/core` dependency (the adapter package stays decoupled from
+ * every runtime inside WrongStack), so hosts register them on their own
+ * `HookRegistry` and the structural parameter types accept core's richer
+ * `HookInput`.
+ *
+ * Behaviour:
+ *   preToolUse:  resolve the target path from toolInput; run the
+ *                WrongTrace pre-flight (health + lock state). A file
+ *                locked by ANOTHER owner DENIES the call with the
+ *                owner/expiry in the reason — the model sees it and can
+ *                pick another file. A lock owned by THIS session is
+ *                treated as available (self-owner exemption) so the
+ *                acquire-in-pre/release-in-post pairing stays usable —
+ *                a leaked own lock (executor denied/threw before postToolUse)
+ *                never blocks the session's own retry. Healthy/fragile/
+ *                offline daemons ALLOW; fragile files additionally get a
+ *                one-line "prefer surgical edits" nudge via additionalContext.
+ *                On allow we also ACQUIRE the daemon lock for the edit
+ *                (owner = session id) so peers see the claim.
+ *   postToolUse: release the lock acquired in preToolUse (path-keyed).
+ *                The daemon TTL is the leak backstop if execution never
+ *                completes.
+ *
+ * Concurrency: lock bookkeeping is scoped PER HOOK PAIR (per runner), not
+ * process-global, and reference-counted. A shared module-level map would let
+ * one executor's postToolUse release another executor's active lock when the
+ * same path is claimed by two in-process runners. `createWrongTraceHookPair`
+ * allocates its own counter map; it is also safe to share ONE pair across
+ * concurrent executors (standalone WebUI parent + SDD-wizard workers, or the
+ * fleet runner across subagents) — overlapping claims increment the count and
+ * the daemon lock is only released when the LAST finisher's postToolUse
+ * decrements it to zero.
+ *
+ * Failure philosophy: COORDINATION optimization, never a hard dependency.
+ * Daemon offline → everything allows. Any throw inside the hooks must be
+ * swallowed by the caller-side catch below so a slow daemon (timeout) can
+ * never add latency surprises to the edit path.
+ */
+import { getWrongTrace, preflightFileEdit } from "./gate.js";
+/** Tools that mutate a single target file and must pass the gate. */
+const EDIT_TOOLS = new Set([
+    "edit",
+    "write",
+    "replace",
+    "patch",
+    "codebase-ast-replace",
+]);
+/**
+ * Extract the target file path from a mutating tool's input, if present.
+ *
+ * Order matters: `file` (codebase-ast-replace) MUST come before any
+ * selector-ish field — `target` is the body/full AST selector, never a
+ * path, so it must not be treated as one. Multi-file inputs resolve to
+ * their first concrete file; `patch` has no single derivable target (the
+ * diff payload names its own files), so its optional `directory` is the
+ * coarsest honest claim and a bare `patch` input (no directory) yields
+ * `undefined` → gate allows without a claim.
+ */
+function targetPathOf(toolInput) {
+    if (!toolInput || typeof toolInput !== "object")
+        return undefined;
+    const t = toolInput;
+    // Single-file keys: edit/write → `path`, codebase-ast-replace → `file`.
+    for (const key of ["path", "file_path", "file"]) {
+        const v = t[key];
+        if (typeof v === "string" && v.length > 0)
+            return v;
+    }
+    // `replace` accepts files: string | string[].
+    const files = t["files"];
+    if (typeof files === "string" && files.length > 0)
+        return files;
+    if (Array.isArray(files) && files.length > 0) {
+        const first = files[0];
+        if (typeof first === "string" && first.length > 0)
+            return first;
+    }
+    // `patch` accepts an optional directory.
+    const dir = t["directory"];
+    if (typeof dir === "string" && dir.length > 0)
+        return dir;
+    return undefined;
+}
+/** Emit a gate-decision event without ever letting a throw escape. */
+function emitSafe(emit, event) {
+    try {
+        emit?.(event);
+    }
+    catch {
+        // Observability must never break the edit path.
+    }
+}
+/**
+ * Per-runner lock bookkeeping. Reference-counted: when one hook pair is
+ * shared across concurrent executors (standalone WebUI parent + SDD-wizard
+ * workers, or the fleet runner across subagents), overlapping claims on the
+ * same path increment the count and the daemon lock is only released when
+ * the LAST finisher's postToolUse decrements it to zero — a sibling finishing
+ * early can never unlock a path another in-flight edit still holds.
+ */
+export function newWrongTraceLockCounter() {
+    return new Map();
+}
+function acquireLock(counters, path) {
+    counters.set(path, (counters.get(path) ?? 0) + 1);
+}
+function releaseLock(counters, path, onZero) {
+    const next = (counters.get(path) ?? 1) - 1;
+    if (next > 0) {
+        counters.set(path, next);
+        return;
+    }
+    counters.delete(path);
+    onZero();
+}
+/**
+ * Create a pre/post hook PAIR sharing one per-runner reference-counted lock
+ * map. Every host should use this when wiring both phases: the pairing
+ * guarantees `postToolUse` only releases locks this exact pair's
+ * `preToolUse` claimed (see concurrency note at the top of this file), and
+ * the reference count keeps the daemon lock held while any sibling executor
+ * sharing the pair still has the path in flight.
+ */
+export function createWrongTraceHookPair(sessionId, opts = {}, counters = newWrongTraceLockCounter()) {
+    const emit = opts.emit;
+    return {
+        async preToolUse(input, _runtime) {
+            if (!EDIT_TOOLS.has(input.toolName ?? ""))
+                return undefined;
+            const path = targetPathOf(input.toolInput);
+            if (!path)
+                return undefined;
+            try {
+                // Self-owner exemption: OUR OWN held lock (leaked by an interrupted
+                // earlier edit) must not deny this session's retry. lock_owner from
+                // the daemon's file-health response is compared against this pair's
+                // owner identity by preflightFileEdit.
+                const verdict = await preflightFileEdit(path, `wrongstack:${sessionId()}`);
+                if (verdict.kind === "blocked") {
+                    const owner = verdict.risk.reasons.join("; ");
+                    emitSafe(emit, { kind: "deny", path, reason: `WrongTrace lock: ${owner}` });
+                    return { action: "deny", reason: `WrongTrace lock: ${owner}` };
+                }
+                // Allow — and claim the lock so peers see this edit in flight.
+                const wt = await getWrongTrace();
+                if (wt.isAvailable) {
+                    const owner = `wrongstack:${sessionId()}`;
+                    const res = await wt.lockFile(path, "WrongStack edit in progress", {
+                        owner,
+                        ttlSeconds: 900,
+                    });
+                    if (res?.ok === true) {
+                        acquireLock(counters, path);
+                        emitSafe(emit, { kind: "lock-acquired", path, owner });
+                    }
+                    else {
+                        // Peer grabbed it between the pre-flight and the claim (or our
+                        // own earlier leak still holds it — the exemption let us through).
+                        // Either way the file is being edited by someone: we proceed
+                        // without re-claiming; coordination stays advisory.
+                        emitSafe(emit, { kind: "lock-conflict-race", path });
+                    }
+                }
+                if (verdict.risk && verdict.risk.band === "fragile") {
+                    emitSafe(emit, { kind: "allow-fragile", path, reasons: verdict.risk.reasons });
+                    return {
+                        action: "allow",
+                        additionalContext: `WrongTrace: ${path} is fragile (${verdict.risk.reasons.join("; ")}). Prefer surgical AST diffs over rewrites.`,
+                    };
+                }
+                return { action: "allow" };
+            }
+            catch {
+                // Fail-open: coordination must never break the edit path.
+                return undefined;
+            }
+        },
+        async postToolUse(input) {
+            if (!EDIT_TOOLS.has(input.toolName ?? ""))
+                return;
+            const path = targetPathOf(input.toolInput);
+            // Only release a lock THIS pair claimed — a shared (module-level) map
+            // would let one executor free another's active lock. Reference counts:
+            // the daemon unlock happens only when the LAST sibling release lands.
+            if (!path || !counters.has(path))
+                return;
+            let shouldUnlock = false;
+            releaseLock(counters, path, () => {
+                shouldUnlock = true;
+            });
+            if (!shouldUnlock)
+                return; // a sibling still holds this path
+            emitSafe(emit, { kind: "lock-released", path });
+            try {
+                const wt = await getWrongTrace();
+                if (wt.isAvailable)
+                    await wt.unlockFile(path);
+            }
+            catch {
+                // TTL backstop will reap it.
+            }
+        },
+    };
+}
+// ── Legacy single-phase factories ─────────────────────────────────────────
+// Old consumers register pre/post separately. They share the module-level
+// reference-counted lock map, preserving the historical behaviour; new code
+// should use `createWrongTraceHookPair` (per-runner scoping) instead.
+//
+// IMPORTANT: paired and legacy hooks use SEPARATE counters — a legacy
+// postToolUse can never release a paired pair's claim (and vice versa). Do
+// not mix the two styles for the same path in one process: the intended
+// release would no-op and the daemon TTL would reap the lock.
+const legacyLocks = newWrongTraceLockCounter();
+export function createWrongTracePreToolUseHook(sessionId, opts) {
+    return createWrongTraceHookPair(sessionId, opts, legacyLocks).preToolUse;
+}
+export function createWrongTracePostToolUseHook(opts) {
+    return createWrongTraceHookPair(() => "", opts, legacyLocks).postToolUse;
+}
+//# sourceMappingURL=hooks.js.map

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Public surface of the @wrongstack/wrongtrace package.
+ *
+ * Callers do this and never worry about whether the daemon is running:
+ *
+ *   import { getWrongTraceClient } from "@wrongstack/wrongtrace";
+ *   const wt = await getWrongTraceClient();
+ *   if (wt.isAvailable) { /* safe to use lock/lineage/telemetry APIs *\/ }
+ */
+export type { WrongTraceAtlasFile, WrongTraceAtlasQuery, WrongTraceAtlasSummary, WrongTraceClient, WrongTraceFileHealth, WrongTraceFrictionRow, WrongTraceHealth, WrongTraceLockInfo, WrongTraceLockOwnership, WrongTraceLockRequest, WrongTraceLockResult, WrongTraceRecentEvent, WrongTraceRecentEventsQuery, WrongTraceSymbolEvent, WrongTraceTelemetryReport, WrongTraceUnlockRequest, } from "./types.js";
+export { discover, defaultSocketPath } from "./discovery.js";
+export type { DiscoveryOptions, DiscoveryResult } from "./discovery.js";
+export { createWrongTraceClient } from "./client.js";
+export type { WrongTraceClientOptions, WrongTraceClientInternal } from "./client.js";
+export { getCrossAgentRisk, summarizeFriction, getRecentActivity, digestAtlas, } from "./agent-helpers.js";
+export type { CrossAgentRisk, FrictionSummary, AtlasDigest, RecentActivityEntry, } from "./agent-helpers.js";
+export { createIpcTransport } from "./adapters/ipc.js";
+export type { IpcTransport, IpcCallResult, IpcTimeouts } from "./adapters/ipc.js";
+export { createMcpTransport } from "./adapters/mcp.js";
+export type { McpTransport, McpToolBag, McpToolHandler, McpToolName } from "./adapters/mcp.js";
+export { getWrongTrace, preflightFileEdit, resetWrongTraceGate, withFileLock, } from "./gate.js";
+export type { PreflightOptions, PreflightVerdict } from "./gate.js";
+export { createWrongTraceHookPair, createWrongTracePostToolUseHook, createWrongTracePreToolUseHook, } from "./hooks.js";
+export type { WrongTraceGateDecisionEvent, WrongTraceHookInput, WrongTraceHookOptions, WrongTraceHookPair, WrongTracePreToolUseOutcome, } from "./hooks.js";
+export { createWrongTraceGateCounter, countersFilePath, formatGateCounterReport, loadWrongTraceGateCounters, persistWrongTraceGateCounters, recordGateDecision, resetGateDecisions, snapshotGateDecisions, } from "./gate-counters.js";
+export type { WrongTraceGateCounter, WrongTraceGateCounterSnapshot, } from "./gate-counters.js";
+/**
+ * Drop-in replacement for the legacy `getWrongTraceClient()` from the
+ * reference TypeScript snippet. Kept as a one-liner alias for caller
+ * familiarity — implementation lives in `client.ts`.
+ */
+export declare function getWrongTraceClient(): Promise<import("./client.js").WrongTraceClientInternal>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,28 @@
+/**
+ * Public surface of the @wrongstack/wrongtrace package.
+ *
+ * Callers do this and never worry about whether the daemon is running:
+ *
+ *   import { getWrongTraceClient } from "@wrongstack/wrongtrace";
+ *   const wt = await getWrongTraceClient();
+ *   if (wt.isAvailable) { /* safe to use lock/lineage/telemetry APIs *\/ }
+ */
+export { discover, defaultSocketPath } from "./discovery.js";
+export { createWrongTraceClient } from "./client.js";
+export { getCrossAgentRisk, summarizeFriction, getRecentActivity, digestAtlas, } from "./agent-helpers.js";
+export { createIpcTransport } from "./adapters/ipc.js";
+export { createMcpTransport } from "./adapters/mcp.js";
+// ── Shared guardrail gate + hooks (CLI leader, fleet subagents, WebUI server) ──
+export { getWrongTrace, preflightFileEdit, resetWrongTraceGate, withFileLock, } from "./gate.js";
+export { createWrongTraceHookPair, createWrongTracePostToolUseHook, createWrongTracePreToolUseHook, } from "./hooks.js";
+export { createWrongTraceGateCounter, countersFilePath, formatGateCounterReport, loadWrongTraceGateCounters, persistWrongTraceGateCounters, recordGateDecision, resetGateDecisions, snapshotGateDecisions, } from "./gate-counters.js";
+/**
+ * Drop-in replacement for the legacy `getWrongTraceClient()` from the
+ * reference TypeScript snippet. Kept as a one-liner alias for caller
+ * familiarity — implementation lives in `client.ts`.
+ */
+export async function getWrongTraceClient() {
+    const { createWrongTraceClient } = await import("./client.js");
+    return createWrongTraceClient();
+}
+//# sourceMappingURL=index.js.map