@wrongstack/core 0.267.0 → 0.269.0

package/dist/{pipeline-BfD2k1rT.d.ts → mailbox-types-Ct2hJq0P.d.ts}

@@ -1,6 +1,3 @@
-import { T as Tool, o as TextBlock, g as ContentBlock } from './context-dT5Ueund.js';
-import { H as HookEvent, f as HookMatcher, I as InProcessHook, S as ShellHook, g as HookEntry } from './config-Du3pYYln.js';
-
 /**
  * Mailbox — persistent inter-agent messaging system with cross-session support.
  *
@@ -345,244 +342,4 @@ interface Mailbox {
     getClientStatuses(): Promise<ClientStatus[]>;
 }
 
-/** Model capabilities relevant to prompt composition. */
-interface ModelCapabilities {
-    maxContextTokens: number;
-    supportsTools: boolean;
-    supportsVision: boolean;
-    supportsReasoning: boolean;
-}
-interface BuildContext {
-    cwd: string;
-    projectRoot: string;
-    tools: Tool[];
-    /** Provider id (e.g. "anthropic", "minimax-coding-plan"). */
-    provider?: string | undefined;
-    /** Model id (e.g. "claude-sonnet-4-6", "MiniMax-M2.7"). */
-    model?: string | undefined;
-    /**
-     * True when the prompt is being built for a SUBAGENT, not the host
-     * agent. Subagents are scoped to a single task — they should NOT see
-     * the host's strategic plan board (which is anchoring the host across
-     * turns, not steering individual subtasks). The plan-injection
-     * layer short-circuits when this flag is set.
-     */
-    subagent?: boolean | undefined;
-    /**
-     * List of currently online agents in the shared mailbox system.
-     * Includes agents from all sessions (TUI, WebUI, CLI) in the same project.
-     */
-    onlineAgents?: MailboxAgentStatus[] | undefined;
-}
-interface SystemPromptBuilder {
-    build(ctx: BuildContext): Promise<TextBlock[]>;
-}
-
-/**
- * Registry of lifecycle hooks (both in-process and shell). One instance is
- * shared per session: the boot path loads `config.hooks` as shell entries and
- * plugins add in-process entries via `PluginAPI.registerHook`. The
- * `HookRunner` reads from it at each lifecycle phase.
- */
-declare class HookRegistry {
-    private readonly entries;
-    /** Register an in-process hook. Returns an unsubscribe function. */
-    registerInProcess(event: HookEvent, matcher: HookMatcher | undefined, hook: InProcessHook, owner?: string | undefined): () => void;
-    /** Register a single shell hook. Returns an unsubscribe function. */
-    registerShell(event: HookEvent, hook: ShellHook): () => void;
-    /** Bulk-load shell hooks from a `config.hooks` map. */
-    loadShellHooks(hooks: Partial<Record<HookEvent, ShellHook[]>> | undefined): void;
-    /** All entries registered for an event, in registration order. */
-    list(event: HookEvent): readonly HookEntry[];
-    /** True when any entry is registered for the event. */
-    has(event: HookEvent): boolean;
-    /** Drop every registered hook (used in teardown / tests). */
-    clear(): void;
-    private remove;
-}
-/**
- * Does a hook matcher apply to a tool name? `*` (or empty) matches everything;
- * otherwise the matcher is a case-insensitive pipe-delimited list of exact
- * tool names (`"edit|write"`). Non-tool events pass `undefined` and always match.
- */
-declare function hookMatcherMatches(matcher: HookMatcher, toolName: string | undefined): boolean;
-
-interface Renderer {
-    write(text: string | TextBlock): void;
-    writeLine(text?: string): void;
-    writeBlock(block: ContentBlock): void;
-    writeToolCall(name: string, input: unknown): void;
-    writeToolResult(name: string, content: unknown, isError: boolean): void;
-    writeDiff(unifiedDiff: string): void;
-    writeWarning(text: string): void;
-    writeError(text: string): void;
-    writeInfo(text: string): void;
-    clear(): void;
-}
-
-/**
- * Container — dependency injection with explicit bind / override / decorate.
- *
- * Invariants:
- *   bind()     — throws if token already bound
- *   override() — throws if nothing to replace
- *   decorate() — stacks; cached value cleared on register
- */
-type Token<T> = symbol & {
-    readonly __type?: T;
-};
-type Factory<T> = (c: Container) => T;
-type Decorator<T> = (inner: T, c: Container) => T;
-interface BindOptions {
-    singleton?: boolean | undefined;
-    owner?: string | undefined;
-}
-declare class Container {
-    private readonly entries;
-    /**
-     * Tokens currently mid-resolve. Tracked so we can detect circular
-     * dependencies (A → B → A) and throw a structured error instead of
-     * overflowing the call stack with "Maximum call stack size exceeded".
-     *
-     * Not a memoization cache — the per-entry `cache` field is the source
-     * of truth for "have I built this before?". This set only lives for
-     * the duration of a single resolve call.
-     */
-    private readonly resolving;
-    bind<T>(token: Token<T>, factory: Factory<T>, opts?: BindOptions): void;
-    override<T>(token: Token<T>, factory: Factory<T>, opts?: BindOptions): void;
-    decorate<T>(token: Token<T>, decorator: Decorator<T>, owner?: string): void;
-    resolve<T>(token: Token<T>): T;
-    /**
-     * Build a human-readable description of the dependency cycle that
-     * caused the resolution to re-enter. Lists the tokens in the order
-     * they were entered, then appends the re-entered token to close the
-     * loop. Falls back to a generic message if the resolving set is
-     * somehow empty (shouldn't happen, but defensive).
-     */
-    private describeCycle;
-    has<T>(token: Token<T>): boolean;
-    /**
-     * Resolve a token if it is bound, otherwise return undefined.
-     * Unlike resolve(), this does not throw if the token is unbound.
-     */
-    safeResolve<T>(token: Token<T>): T | undefined;
-    ownerOf<T>(token: Token<T>): string | undefined;
-    /**
-     * Remove a token's binding (along with any decorators stacked on it).
-     * Returns true if the token existed. Use this to withdraw temporary
-     * bindings installed by a short-lived run or plugin — without it, the
-     * entry persists in the map forever.
-     */
-    unbind<T>(token: Token<T>): boolean;
-    /**
-     * Drop every binding. Intended for tests and short-lived CLI invocations
-     * that rebuild the container from scratch. Production code should prefer
-     * `unbind` on the specific tokens it owns.
-     */
-    clear(): void;
-    list(): Array<{
-        token: symbol;
-        owner: string;
-    }>;
-    /**
-     * Inspect a binding's full shape, including decorator count and whether
-     * a singleton value is cached. Returns null if the token is unbound.
-     * Decorator and factory function references are not exposed — only counts
-     * and metadata, to keep internal state hidden.
-     */
-    inspect<T>(token: Token<T>): {
-        owner: string;
-        singleton: boolean;
-        decoratorCount: number;
-        cached: boolean;
-    } | null;
-}
-
-/**
- * Pipeline — Koa-style middleware chain with named middleware
- * and position-aware insertion. Generic over input type T.
- */
-type NextFn<T> = (value: T) => Promise<T>;
-type MiddlewareHandler<T> = (value: T, next: NextFn<T>) => Promise<T>;
-/**
- * Called when a middleware crashes (throws or rejects). Used by the
- * Pipeline's error boundary to log the offender without aborting the run.
- *
- * Return `'rethrow'` to propagate the error (default for core middleware),
- * or `'swallow'` to skip past the crashing middleware and continue with the
- * value the previous one produced. Plugin middleware should usually be
- * swallowed so one bad plugin can't kill an agent run.
- */
-type PipelineErrorPolicy = 'rethrow' | 'swallow';
-interface PipelineErrorEvent {
-    middleware: string;
-    owner?: string | undefined;
-    err: unknown;
-}
-type PipelineErrorHandler = (ev: PipelineErrorEvent) => PipelineErrorPolicy | Promise<PipelineErrorPolicy>;
-interface Middleware<T> {
-    name: string;
-    handler: MiddlewareHandler<T>;
-    owner?: string | undefined;
-}
-interface PipelineOptions {
-    /** When true and the target middleware is not found, operations silently no-op instead of throwing. */
-    optional?: boolean | undefined;
-}
-/**
- * Read-only view of a pipeline. Returned to consumers (plugins, hooks)
- * so they can inspect but not mutate the chain.
- */
-interface ReadonlyPipeline<T> {
-    readonly size: number;
-    list(): readonly string[];
-    run(input: T): Promise<T>;
-}
-declare class Pipeline<T> {
-    private readonly chain;
-    private errorHandler?;
-    /**
-     * Install an error boundary. When a middleware throws or rejects, the
-     * handler is called and decides whether to swallow (continue with the
-     * pre-handler value) or rethrow. Without a handler, errors propagate.
-     *
-     * Wire one per pipeline at boot — the host CLI typically installs a
-     * single boundary that logs to the operational log and emits a
-     * `pipeline.error` event for /diag.
-     */
-    setErrorHandler(handler: PipelineErrorHandler | undefined): this;
-    use(mw: Middleware<T> | Middleware<unknown>): this;
-    prepend(mw: Middleware<T>): this;
-    /**
-     * Insert middleware at an explicit index. Out-of-range indices are clamped.
-     * Use this when insertBefore/insertAfter are insufficient (e.g. to place
-     * a middleware at a known position regardless of named targets).
-     */
-    insertAt(index: number, mw: Middleware<T>): this;
-    /**
-     * Insert mw immediately before the first occurrence of target.
-     * If called multiple times with the same target, each call inserts
-     * before the target's current position — so after insertBefore('B', X)
-     * then insertBefore('B', Y), the order is Y → X → B.
-     */
-    insertBefore(target: string, mw: Middleware<T>, opts?: PipelineOptions): this;
-    /**
-     * Insert mw immediately after the first occurrence of target.
-     * If called multiple times with the same target, each call inserts
-     * after the target's current position — so after insertAfter('B', X)
-     * then insertAfter('B', Y), the order is B → X → Y.
-     */
-    insertAfter(target: string, mw: Middleware<T>, opts?: PipelineOptions): this;
-    replace(target: string, mw: Middleware<T>, opts?: PipelineOptions): this;
-    remove(name: string, opts?: PipelineOptions): this;
-    list(): readonly string[];
-    size(): number;
-    /** Return a read-only view suitable for passing to plugins. */
-    asReadonly(): ReadonlyPipeline<T>;
-    run(input: T): Promise<T>;
-    private indexOf;
-    private ensureUnique;
-}
-
-export { type AgentHeartbeatInput as A, type BuildContext as B, Container as C, type Decorator as D, type Factory as F, HookRegistry as H, type MiddlewareHandler as M, type NextFn as N, Pipeline as P, type ReadonlyPipeline as R, type SystemPromptBuilder as S, type Token as T, type Renderer as a, type ModelCapabilities as b, type Mailbox as c, type MailboxMessage as d, type AgentRegistrationInput as e, type BindOptions as f, type MailboxAckInput as g, type MailboxAgentStatus as h, type MailboxMessageType as i, type MailboxQuery as j, type MailboxSendInput as k, type MailboxTaskContext as l, type Middleware as m, type PipelineOptions as n, type ReadReceipts as o, type RegisteredAgent as p, hookMatcherMatches as q, normalizeRecipient as r, type MailboxAckBatchInput as s, type PurgeOptions as t, type PurgeResult as u, type ClientRegistrationInput as v, type ClientHeartbeatInput as w, type ClientStatus as x };
+export { type AgentRegistrationInput as A, type ClientRegistrationInput as C, type MailboxMessage as M, type PurgeOptions as P, type ReadReceipts as R, type MailboxAgentStatus as a, type Mailbox as b, type MailboxSendInput as c, type MailboxQuery as d, type MailboxAckInput as e, type MailboxAckBatchInput as f, type AgentHeartbeatInput as g, type ClientHeartbeatInput as h, type ClientStatus as i, type PurgeResult as j, type MailboxMessageType as k, type MailboxTaskContext as l, type RegisteredAgent as m, normalizeRecipient as n };

package/dist/{mcp-servers-C2cBTxUR.d.ts → mcp-servers-DJdZiRcv.d.ts}

@@ -1,6 +1,6 @@
-import { C as Compactor } from './compactor-iMZ84CXq.js';
-import { M as Message, T as Tool } from './context-dT5Ueund.js';
-import { c as MCPServerConfig } from './config-Du3pYYln.js';
+import { C as Compactor } from './compactor-C2RKEBtC.js';
+import { M as Message, T as Tool } from './context-Dp87Bcaq.js';
+import { c as MCPServerConfig } from './config-C_ae2k86.js';
 
 type ContextManagerAction = 'check' | 'summary' | 'prune' | 'add_note' | 'compact' | 'repair';
 interface ContextManagerInput {
@@ -154,7 +154,13 @@ declare const playwrightServer: () => MCPServerConfig;
  * Requires MINIMAX_API_KEY and uvx on PATH.
  */
 declare const miniMaxVisionServer: () => MCPServerConfig;
+/**
+ * SSH Manager — remote SSH execution, file transfer, tunnels, health checks, and deployment ops.
+ * Server credentials are intentionally NOT embedded here. Configure hosts via mcp-ssh-manager's
+ * env/TOML config (for example SSH_SERVER_<NAME>_HOST, USER, KEYPATH/PASSWORD) or ssh-agent.
+ */
+declare const sshManagerServer: () => MCPServerConfig;
 /** Everything bundled — full set of built-in servers. Useful for `wstack mcp add --all`. */
 declare const allServers: () => Record<string, MCPServerConfig>;
 
-export { type ContextManagerAction as C, type ContextManagerInput as a, type ContextManagerResult as b, type ContextManagerToolOptions as c, allServers as d, awsServer as e, blockServer as f, braveSearchServer as g, context7Server as h, contextManagerTool as i, createContextManagerTool as j, everArtServer as k, filesystemServer as l, githubServer as m, googleMapsServer as n, miniMaxVisionServer as o, playwrightServer as p, slackServer as q, sentinelServer as s, zaiVisionServer as z };
+export { type ContextManagerAction as C, type ContextManagerInput as a, type ContextManagerResult as b, type ContextManagerToolOptions as c, allServers as d, awsServer as e, blockServer as f, braveSearchServer as g, context7Server as h, contextManagerTool as i, createContextManagerTool as j, everArtServer as k, filesystemServer as l, githubServer as m, googleMapsServer as n, miniMaxVisionServer as o, playwrightServer as p, slackServer as q, sshManagerServer as r, sentinelServer as s, zaiVisionServer as z };

package/dist/models/index.d.ts

@@ -1,9 +1,9 @@
-export { D as DefaultModelsRegistry, a as DefaultModelsRegistryOptions, c as classifyFamily } from '../models-registry-BqGZNJQ-.js';
-export { D as DefaultModeStore, L as LLMSelector, a as LLMSelectorOptions, M as ModeLoaderOptions, P as ProviderModelDescriptor, d as describeCatalogModel, l as loadProjectModes, b as loadUserModes, r as resolveProviderModelList } from '../provider-model-resolve-BNRsNuJx.js';
-import { d as ModelMatrixEntry, P as ProviderConfig } from '../config-Du3pYYln.js';
+export { D as DefaultModelsRegistry, a as DefaultModelsRegistryOptions, c as classifyFamily } from '../models-registry-C3a-2-Yd.js';
+export { D as DefaultModeStore, L as LLMSelector, a as LLMSelectorOptions, M as ModeLoaderOptions, P as ProviderModelDescriptor, d as describeCatalogModel, l as loadProjectModes, b as loadUserModes, r as resolveProviderModelList } from '../provider-model-resolve-d5poT5y0.js';
+import { d as ModelMatrixEntry, P as ProviderConfig } from '../config-C_ae2k86.js';
 import '../mode-CZlO9iU1.js';
-import '../context-dT5Ueund.js';
-import '../selector-Bc7eWtT3.js';
+import '../context-Dp87Bcaq.js';
+import '../selector-CXl2_y9W.js';
 
 /**
  * Model Intelligence — knowledge base of model capabilities, strengths,

package/dist/models/index.js

@@ -349,10 +349,11 @@ var DefaultModelsRegistry = class {
       capabilities: {
         tools: model.tool_call ?? false,
         vision: Boolean(model.modalities?.input?.includes("image")),
-        reasoning: model.reasoning ?? false,
+        reasoning: model.reasoning ?? model.reasoningConfig !== void 0,
         maxContext: model.limit?.context ?? 0,
         maxOutput: model.limit?.output,
-        knowledge: model.knowledge
+        knowledge: model.knowledge,
+        reasoningConfig: model.reasoningConfig
       },
       cost: model.cost
     };
@@ -837,7 +838,7 @@ function expectDefined(value, label) {
 // src/utils/token-estimate.ts
 var RoughTokenEstimate = (text, charsPerToken = 3.5) => Math.max(1, Math.ceil(text.length / charsPerToken));
 var ESTIMATE_CACHE = /* @__PURE__ */ new Map();
-var ESTIMATE_CACHE_MAX_SIZE = 1e4;
+var ESTIMATE_CACHE_MAX_SIZE = 5e4;
 function getCachedEstimate(key, compute) {
   const existing = ESTIMATE_CACHE.get(key);
   if (existing !== void 0) return existing;