@wrongstack/core 0.54.1 → 0.66.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/core",
-  "version": "0.54.1",
+  "version": "0.66.13",
   "license": "MIT",
   "description": "WrongStack core: kernel, types, defaults, and shared utilities for the WrongStack CLI agent.",
   "repository": {

package/skills/multi-agent/SKILL.md

@@ -166,8 +166,6 @@ The session throws a clear error if the resolved file count exceeds the effectiv
 // ✅ Good — single package, limited files
 collab_debug(["packages/core/src/agents/**/*.ts"])
 
-// ✅ Dynamic — limit computed from contextWindow
-collab_debug({
 // ✅ Explicit — override limit directly
 collab_debug({
   targetPaths: ["packages/core/src/**/*.ts"],

package/dist/agent-subagent-runner-By7jruZ_.d.ts

@@ -1,182 +0,0 @@
-import { c as Agent, f as AgentInput } from './index-CI271MjL.js';
-import { E as EventBus } from './events-CbHTS4ZZ.js';
-import { n as SubagentConfig, v as TaskSpec, t as SubagentRunner } from './multi-agent-BmC_xiog.js';
-
-/**
- * Single fleet-wide event with subagent attribution. Whatever a child
- * agent emits on its own EventBus gets re-published here, prefixed with
- * `subagentId` so a single subscriber can multiplex across the fleet.
- *
- * The director uses `FleetBus.filter('tool.executed', …)` to see every
- * tool call across the fleet; the TUI uses
- * `FleetBus.subscribe(id, handler)` to render a per-subagent panel.
- */
-interface FleetEvent {
-    subagentId: string;
-    taskId?: string;
-    ts: number;
-    type: string;
-    payload: unknown;
-}
-type FleetHandler = (event: FleetEvent) => void;
-/**
- * Fan-in for per-subagent EventBuses. Each subagent's bus is plugged in
- * via `attach()`; the FleetBus re-emits every event with subagent
- * attribution. Detachment is automatic via the returned disposer — call
- * it when a subagent terminates so we don't leak listeners.
- *
- * The bus exposes two subscription modes: by `subagentId` (everything
- * from one child) and by `type` (one event-type across the fleet). They
- * compose — if you need a per-subagent + per-type slice, subscribe by
- * type and filter on `event.subagentId` in your handler.
- */
-declare class FleetBus {
-    private readonly byId;
-    private readonly byType;
-    private readonly any;
-    /**
-     * Hook a subagent's EventBus into the fleet. Uses `onAny()` (an alias for
-     * `onPattern('*')`) to forward all events with subagent attribution, so
-     * new kernel event types are automatically forwarded without any manual
-     * registration. `subagent.*` events are excluded because they originate
-     * from MultiAgentHost on the parent bus, not the subagent's own bus.
-     *
-     * Returns a disposer that detaches every subscription; call on
-     * subagent teardown so the listeners don't outlive the run.
-     */
-    attach(subagentId: string, bus: EventBus, taskId?: string): () => void;
-    /** Subscribe to every event from one subagent. */
-    subscribe(subagentId: string, handler: FleetHandler): () => void;
-    /** Subscribe to one event type across all subagents. */
-    filter(type: string, handler: FleetHandler): () => void;
-    /** Subscribe to literally everything. The fleet roll-up uses this. */
-    onAny(handler: FleetHandler): () => void;
-    emit(event: FleetEvent): void;
-}
-/**
- * Roll-up of token usage + cost across an entire director run. The
- * director's `fleet_status` tool returns this so the model can reason
- * about budget in its next turn ("the researcher already burned $0.40,
- * lean on summaries for the next task").
- */
-interface FleetUsage {
-    total: {
-        input: number;
-        output: number;
-        cacheRead: number;
-        cacheWrite: number;
-        cost: number;
-    };
-    perSubagent: Record<string, SubagentUsageSnapshot>;
-}
-interface SubagentUsageSnapshot {
-    subagentId: string;
-    provider?: string;
-    model?: string;
-    input: number;
-    output: number;
-    cacheRead: number;
-    cacheWrite: number;
-    cost: number;
-    toolCalls: number;
-    iterations: number;
-    startedAt: number;
-    lastEventAt: number;
-}
-/**
- * Aggregates provider.response + tool.executed events from the FleetBus
- * into a live `FleetUsage` snapshot. Costs are computed by the caller
- * via a `priceLookup(subagentId)` so we don't bake provider-pricing
- * coupling into core; the CLI/tests supply a function that resolves
- * each subagent's per-token rates from the models registry.
- */
-declare class FleetUsageAggregator {
-    private readonly priceLookup?;
-    private readonly metaLookup?;
-    private readonly perSubagent;
-    private readonly total;
-    private readonly unsub;
-    constructor(bus: FleetBus, priceLookup?: ((subagentId: string, provider?: string, model?: string) => {
-        input?: number;
-        output?: number;
-        cacheRead?: number;
-        cacheWrite?: number;
-    } | undefined) | undefined, metaLookup?: ((subagentId: string) => {
-        provider?: string;
-        model?: string;
-    } | undefined) | undefined);
-    /**
-     * Remove a terminated subagent's data from the aggregator and subtract its
-     * contribution from the running totals. Call this when a subagent is removed
-     * from the fleet so the aggregator doesn't accumulate unbounded data for
-     * entities that will never emit events again.
-     */
-    removeSubagent(subagentId: string): void;
-    /** Disposes all fleet-bus subscriptions. Call when the aggregator is no longer needed. */
-    dispose(): void;
-    /** Live snapshot — safe to call from a tool's execute() body. */
-    snapshot(): FleetUsage;
-    private ensure;
-    private onProviderResponse;
-    private onToolExecuted;
-    private onIterationStarted;
-}
-
-/**
- * Caller-supplied factory that builds an isolated `Agent` for a subagent.
- * The factory MUST construct a fresh `Context` per call — sharing context
- * between subagents defeats isolation. Each Agent should also use either
- * its own `EventBus` or a forwarded view, so per-subagent metrics can be
- * attributed correctly.
- */
-type AgentFactory = (config: SubagentConfig) => Promise<AgentFactoryResult>;
-interface AgentFactoryResult {
-    agent: Agent;
-    /** Event bus the factory wired to this agent — required for budget hookup. */
-    events: EventBus;
-    /**
-     * Optional cleanup hook invoked in the runner's `finally` block once
-     * the task ends (success, failure, abort — same exit path). Factories
-     * that own resources scoped to a single task (per-subagent JSONL
-     * writers, transient providers, throwaway containers) implement this
-     * to close them deterministically instead of relying on GC. Errors
-     * thrown here are swallowed so a flaky cleanup can't mask the task's
-     * real result.
-     */
-    dispose?: () => Promise<void> | void;
-}
-interface AgentRunnerOptions {
-    factory: AgentFactory;
-    /**
-     * Format a TaskSpec into the user input the agent will receive. Defaults
-     * to `task.description ?? ''`. Override when subagents expect structured
-     * input (e.g. JSON contracts, role-prefixed prompts).
-     */
-    formatTaskInput?: (task: TaskSpec, config: SubagentConfig) => AgentInput;
-    /**
-     * When set, the runner attaches the subagent's EventBus to this FleetBus
-     * on task start and detaches it when the task finishes. This is the
-     * injection seam that lets the TUI fleet panel observe subagent activity
-     * live — without it, FleetBus stays empty.
-     */
-    fleetBus?: FleetBus;
-}
-/**
- * Builds a `SubagentRunner` that drives a real `Agent` per task while honoring
- * the coordinator's budget and abort signal. This is the production adapter —
- * the coordinator's `runner` option in CLI/TUI assemblies points here.
- *
- * Lifecycle per task:
- *   1. factory(config) → fresh Agent + EventBus.
- *   2. Subscribe to events to feed the budget (tool calls, token usage).
- *   3. Call agent.run(input, { signal }) — the coordinator's signal cancels.
- *   4. Map RunResult.status onto a `SubagentRunOutcome` or throw on failure.
- *   5. Unsubscribe and let the factory's resources be GC'd.
- *
- * The budget is checked synchronously from event handlers — a runaway agent
- * that crosses its tool-call limit triggers `BudgetExceededError`, which the
- * coordinator surfaces as `status: 'failed'` on the task result.
- */
-declare function makeAgentSubagentRunner(opts: AgentRunnerOptions): SubagentRunner;
-
-export { type AgentFactory as A, FleetBus as F, type SubagentUsageSnapshot as S, type AgentFactoryResult as a, type AgentRunnerOptions as b, type FleetEvent as c, type FleetHandler as d, type FleetUsage as e, FleetUsageAggregator as f, makeAgentSubagentRunner as m };

package/dist/goal-store-DwcTDDiX.d.ts

@@ -1,188 +0,0 @@
-import { w as SessionEvent, B as SessionWriter } from './context-DtPKqKYV.js';
-
-type AuditLevel = 'minimal' | 'standard' | 'full';
-/**
- * Configuration for sampling high-volume events inside the bridge.
- * This allows callers (CLI, TUI, WebUI, plugins) to tune how aggressively
- * noisy events like tool progress are persisted.
- */
-interface ToolProgressSamplingOptions {
-    /**
-     * How often to persist 'log' and 'partial_output' progress events.
-     * - 1 = every message (no sampling)
-     * - 8 = keep the first message + every 8th after that (default)
-     */
-    sampleRate?: number;
-}
-interface SessionSamplingOptions {
-    /** Controls sampling behavior for `tool_progress` events (only relevant at auditLevel 'full'). */
-    toolProgress?: ToolProgressSamplingOptions;
-}
-interface SessionEventBridgeOptions {
-    /** Sampling rules for high-volume audit events. */
-    sampling?: SessionSamplingOptions;
-}
-/**
- * Small, safe helper that wraps a SessionWriter and enforces the
- * configured auditLevel.
- *
- * All appends are best-effort. Failures are swallowed (with optional
- * diagnostics) so they never crash the agent loop.
- */
-interface SessionEventBridge {
-    /** Append an event if allowed by the current audit level. */
-    append(event: SessionEvent): Promise<void>;
-    /** Current audit level this bridge was created with. */
-    readonly level: AuditLevel;
-    /** Returns true if an event of this type should be written at the current level. */
-    allows(type: SessionEvent['type']): boolean;
-}
-/** Core events that are always written regardless of auditLevel. */
-declare const CORE_RECONSTRUCT_EVENTS: Set<"error" | "tool_use" | "tool_result" | "session_start" | "session_resumed" | "user_input" | "llm_request" | "llm_response" | "compaction" | "session_end" | "mode_changed" | "task_created" | "task_updated" | "task_completed" | "task_failed" | "agent_spawned" | "agent_stopped" | "agent_error" | "spec_parsed" | "spec_analyzed" | "skill_activated" | "skill_deactivated" | "tool_call_start" | "tool_call_end" | "tool_progress" | "message_truncated" | "provider_retry" | "provider_error" | "checkpoint" | "file_snapshot" | "rewound" | "in_flight_start" | "in_flight_end">;
-/**
- * Events that are considered "standard" audit detail.
- * These are lightweight and high-value for forensics.
- */
-declare const STANDARD_AUDIT_EVENTS: Set<"error" | "tool_use" | "tool_result" | "session_start" | "session_resumed" | "user_input" | "llm_request" | "llm_response" | "compaction" | "session_end" | "mode_changed" | "task_created" | "task_updated" | "task_completed" | "task_failed" | "agent_spawned" | "agent_stopped" | "agent_error" | "spec_parsed" | "spec_analyzed" | "skill_activated" | "skill_deactivated" | "tool_call_start" | "tool_call_end" | "tool_progress" | "message_truncated" | "provider_retry" | "provider_error" | "checkpoint" | "file_snapshot" | "rewound" | "in_flight_start" | "in_flight_end">;
-/**
- * Create a safe, audit-level-aware bridge around a SessionWriter.
- *
- * The bridge can also apply sampling for high-volume events (e.g. `tool_progress`)
- * when `auditLevel` is set to `'full'`.
- *
- * @example
- * const bridge = createSessionEventBridge(sessionWriter, 'full', {
- *   sampling: {
- *     toolProgress: { sampleRate: 5 } // more aggressive sampling
- *   }
- * });
- */
-declare function createSessionEventBridge(writer: SessionWriter | undefined | null, level?: AuditLevel, options?: SessionEventBridgeOptions): SessionEventBridge;
-
-/**
- * Safely extract the auditLevel from a (possibly partial) Config object.
- * Falls back to 'standard' if not present or invalid.
- */
-declare function resolveAuditLevel(cfg?: {
-    session?: {
-        auditLevel?: AuditLevel;
-    };
-} | null): AuditLevel;
-/**
- * Fully resolves the session logging configuration with sensible defaults.
- * This is the recommended way for the CLI / TUI / WebUI to read session config.
- */
-declare function resolveSessionLoggingConfig(cfg?: {
-    session?: {
-        auditLevel?: AuditLevel;
-        sampling?: {
-            toolProgress?: {
-                sampleRate?: number;
-            };
-        };
-    };
-} | null): {
-    auditLevel: AuditLevel;
-    sampling: {
-        toolProgress: {
-            sampleRate: number;
-        };
-    };
-};
-
-/**
- * Long-running autonomous mission. A goal survives across sessions and
- * drives the EternalAutonomyEngine — every iteration of the engine
- * consults the goal to choose what to do next.
- *
- * Storage: `~/.wrongstack/projects/<hash>/goal.json`. Persistent and
- * project-scoped on purpose: the goal belongs to the codebase, not the
- * REPL session.
- */
-interface JournalEntry {
-    /** ISO timestamp of the iteration. */
-    at: string;
-    /** Sequential iteration counter (1-based, monotonically increasing). */
-    iteration: number;
-    /** Source that produced the action ('todo' | 'git' | 'brainstorm' | 'resume' | 'manual' | 'parallel'). */
-    source: 'todo' | 'git' | 'brainstorm' | 'resume' | 'manual' | 'parallel';
-    /** Short one-line description of what the iteration set out to do. */
-    task: string;
-    /** Outcome status. */
-    status: 'success' | 'failure' | 'aborted' | 'skipped';
-    /** Optional free-form note (error message, summary, etc.). */
-    note?: string;
-    /** Optional token usage delta for this iteration. */
-    tokens?: {
-        input: number;
-        output: number;
-    };
-    /** Optional USD cost delta for this iteration (provider-estimated). */
-    costUsd?: number;
-}
-interface GoalFile {
-    version: 1;
-    /** The mission statement. */
-    goal: string;
-    /** When the goal was first set or last replaced. */
-    setAt: string;
-    /** Updated on every iteration completion. */
-    lastActivityAt: string;
-    /** Total iterations the engine has run against this goal (cumulative). */
-    iterations: number;
-    /** Engine lifecycle state — 'running' means another process owns this goal. */
-    engineState: 'idle' | 'running' | 'stopped';
-    /**
-     * Mission-level lifecycle. `active` is the default; `completed` is set
-     * when the engine detects `[GOAL_COMPLETE]` in a successful iteration's
-     * final text AND a verification pass agrees; `abandoned` is set by the
-     * user (e.g. `/goal abandon`) or when the engine exceeds a configured
-     * failure ceiling. Once not `active`, the engine refuses to run further
-     * iterations against this goal — protects against accidental restarts
-     * burning through API quota after the work is done.
-     *
-     * Optional for backward compatibility — pre-existing `goal.json` files
-     * without this field load as `active`.
-     */
-    goalState?: 'active' | 'paused' | 'completed' | 'abandoned';
-    /**
-     * Per-todo attempt counter. Keyed by TodoItem id. Used by the engine
-     * to skip a todo that has failed N times rather than spinning on it
-     * forever. Persisted so attempt counts survive restarts (`/autonomy
-     * stop` + resume should not reset progress against a stuck task).
-     */
-    todoAttempts?: Record<string, number>;
-    /** Bounded ring buffer of recent iterations (newest last). */
-    journal: JournalEntry[];
-}
-/** Cap on persisted journal entries — older entries are evicted FIFO. */
-declare const MAX_JOURNAL_ENTRIES = 500;
-/**
- * Resolve the goal file path for a given project root.
- * Exposed so the engine and CLI use one canonical path.
- * Uses `~/.wrongstack/projects/<hash>/goal.json` .<hash>/`.
- */
-declare function goalFilePath(projectRoot: string): string;
-declare function loadGoal(filePath: string): Promise<GoalFile | null>;
-declare function saveGoal(filePath: string, goal: GoalFile): Promise<void>;
-declare function emptyGoal(goal: string): GoalFile;
-/**
- * Append a journal entry, bumping iteration counters and trimming the
- * ring buffer. Returns a new GoalFile — does not mutate the argument.
- */
-declare function appendJournal(goal: GoalFile, entry: Omit<JournalEntry, 'iteration' | 'at'>): GoalFile;
-/**
- * Aggregate cumulative cost + tokens across all journal entries. Entries
- * without telemetry are skipped (legacy entries from before the field
- * was added still load cleanly).
- */
-declare function summarizeUsage(goal: GoalFile): {
-    totalCostUsd: number;
-    totalInputTokens: number;
-    totalOutputTokens: number;
-    iterationsWithUsage: number;
-};
-/** Format the goal + recent journal as a human-readable status block. */
-declare function formatGoal(goal: GoalFile, journalLimit?: number): string;
-
-export { type AuditLevel as A, CORE_RECONSTRUCT_EVENTS as C, type GoalFile as G, type JournalEntry as J, MAX_JOURNAL_ENTRIES as M, STANDARD_AUDIT_EVENTS as S, type ToolProgressSamplingOptions as T, type SessionEventBridge as a, type SessionEventBridgeOptions as b, type SessionSamplingOptions as c, appendJournal as d, createSessionEventBridge as e, emptyGoal as f, formatGoal as g, goalFilePath as h, resolveSessionLoggingConfig as i, summarizeUsage as j, loadGoal as l, resolveAuditLevel as r, saveGoal as s };