@wrongstack/core 0.306.4 → 0.307.1

package/dist/storage/orphan-lock-cleaner.d.ts

@@ -0,0 +1,15 @@
+export interface OrphanLockCleanResult {
+    cleanedGitLocks: string[];
+    cleanedWorktrees: string[];
+    errors: string[];
+}
+/**
+ * Sweeps stale WrongStack worktree lockfiles left after an ungraceful
+ * crash (SIGKILL, power outage, OOM). Does not touch Git's own
+ * `.git/index.lock` — age is not a liveness signal for that mutex.
+ */
+export declare function cleanOrphanLocks(projectRoot: string, options?: {
+    isPidAlive?: (pid: number) => boolean;
+    maxLockAgeMs?: number;
+}): Promise<OrphanLockCleanResult>;
+//# sourceMappingURL=orphan-lock-cleaner.d.ts.map

package/dist/storage/queue-store.d.ts

@@ -11,6 +11,12 @@ export interface PersistedQueueItem {
     blocks: ContentBlock[];
     /** When true, the item will be refined via model.refine before entering the agent context. */
     shouldRefine?: boolean | undefined;
+    /**
+     * Raw (pre-refinement) user text for prompt-journal provenance. Carried on
+     * the item so the TUI drainer can stamp `PROMPT_JOURNAL_RAW_MARKER` per-item
+     * right before that item runs; survives restart rehydration.
+     */
+    journalRaw?: string | undefined;
 }
 /** Hard memory/disk budgets shared by QueueStore and the TUI reducer. */
 export declare const QUEUE_MAX_ITEMS = 100;

package/dist/storage/session-recovery.d.ts

@@ -42,6 +42,15 @@ export interface RecoveryPlan {
     /** Free-form context the agent was working on, if any. */
     context: string | null;
 }
+export interface InterruptedToolDetail {
+    name: string;
+    argsSummary?: string | undefined;
+    ts?: string | undefined;
+}
+/**
+ * Extracts any unresolved tool calls from a recovery plan's pending events.
+ */
+export declare function extractInterruptedTools(plan: RecoveryPlan): InterruptedToolDetail[];
 /**
  * Result of `SessionRecovery.recover(sessionId)`. Distinct from
  * `StaleSession`: a session is "stale" if its latest lifecycle

package/dist/storage/session-store/rename-session.d.ts

@@ -0,0 +1,16 @@
+import type { EventBus } from '../../kernel/events.js';
+import type { SecretScrubber } from '../../types/secret-scrubber.js';
+import type { SessionSummary } from '../../types/session.js';
+export interface RenameSessionParams {
+    id: string;
+    name: string;
+    manifest: string;
+    jsonlPath: string;
+    events?: EventBus | undefined;
+    secretScrubber: SecretScrubber;
+    readSummaryManifest: (id: string) => Promise<SessionSummary | null>;
+    summaryFor: (id: string) => Promise<SessionSummary>;
+    appendToIndexStrict: (summary: SessionSummary) => Promise<void>;
+}
+export declare function executeRenameSession(params: RenameSessionParams): Promise<SessionSummary>;
+//# sourceMappingURL=rename-session.d.ts.map

package/dist/storage/session-store/resume-session.d.ts

@@ -0,0 +1,26 @@
+import * as fsp from 'node:fs/promises';
+import type { EventBus } from '../../kernel/events.js';
+import type { SecretScrubber } from '../../types/secret-scrubber.js';
+import type { ResumedSession, SessionData, SessionEvent, SessionSummary } from '../../types/session.js';
+import type { SessionCheckpointCas } from '../session-checkpoint-cas.js';
+export interface ResumeSessionParams {
+    id: string;
+    canonicalId: string;
+    file: string;
+    projectRoot?: string | undefined;
+    events?: EventBus | undefined;
+    secretScrubber: SecretScrubber;
+    checkpointCas?: SessionCheckpointCas | undefined;
+    onAppend?: ((event: SessionEvent) => void) | undefined;
+    onAppendBatch?: ((events: SessionEvent[]) => void) | undefined;
+    load: (id: string) => Promise<SessionData>;
+    readSummaryManifest: (id: string) => Promise<SessionSummary | null>;
+    searchEvents: (id: string, predicate: (event: SessionEvent, index: number, ts: string) => boolean) => Promise<Array<{
+        event: SessionEvent;
+    }>>;
+    persistCatalogSummary: (summary: SessionSummary) => Promise<void>;
+    logWarn: (msg: string, ctx?: Record<string, unknown>) => void;
+}
+export declare function executeResumeSession(params: ResumeSessionParams): Promise<ResumedSession>;
+export declare function openSessionForAppend(file: string): Promise<fsp.FileHandle>;
+//# sourceMappingURL=resume-session.d.ts.map

package/dist/storage/session-store/session-store-clear.d.ts

@@ -0,0 +1,11 @@
+import type { SessionCatalogProjectClient } from '../../session-catalog/client.js';
+export interface ClearSessionHistoryParams {
+    id: string;
+    canonical: string;
+    catalogClient?: SessionCatalogProjectClient | undefined;
+    maintenanceHolderId: string;
+    ensureShardDir: (id: string) => Promise<string>;
+    sessionPath: (id: string, ext: '.jsonl' | '.summary.json') => string;
+}
+export declare function executeClearSessionHistory(params: ClearSessionHistoryParams): Promise<void>;
+//# sourceMappingURL=session-store-clear.d.ts.map

package/dist/storage/session-store/session-store-index.d.ts

@@ -0,0 +1,13 @@
+import type { SessionSummary } from '../../types/session.js';
+import type { IndexCacheEntry } from './types.js';
+export declare const COMPACT_EVERY = 30;
+export declare function appendToIndexStrict(dir: string, indexFile: string, summary: SessionSummary, invalidateShard: (id: string) => Promise<void>, onAppended: () => {
+    shouldCompact: boolean;
+}, compactInner: () => Promise<void>): Promise<void>;
+export declare function writeTombstone(dir: string, indexFile: string, id: string, invalidateShard: (id: string) => Promise<void>, onTombstone: () => void): Promise<void>;
+export declare function readIndexFile(indexFile: string, currentCache: IndexCacheEntry | null): Promise<{
+    summaries: readonly SessionSummary[];
+    cache: IndexCacheEntry | null;
+}>;
+export declare function compactIndexInner(indexFile: string, entries: readonly SessionSummary[]): Promise<void>;
+//# sourceMappingURL=session-store-index.d.ts.map

package/dist/storage/session-store.d.ts

@@ -11,108 +11,35 @@ export declare class DefaultSessionStore implements SessionStore {
     private readonly logger;
     private readonly onAppend?;
     private readonly onAppendBatch?;
-    /** Present in built production output; source-only tests retain the local compatibility path. */
     private readonly catalogClient;
     private readonly maintenanceHolderId;
-    /**
-     * In-memory cache for load() results, keyed by session ID. The cache is
-     * invalidated when the file's mtimeMs or size changes (indicating the
-     * file was written to). This eliminates redundant full-file reads and
-     * JSON parses when the same session is loaded multiple times within the
-     * store's lifetime (e.g., webui session detail views, list() fallbacks).
-     *
-     * Max size is capped to prevent unbounded memory growth in long-running
-     * processes. When the limit is reached, the oldest entry is evicted.
-     */
     private readonly _loadCache;
     private readonly loadCache;
     private _indexCache;
     private readonly shardManifestCache;
     private static readonly LIST_SCAN_CONCURRENCY;
+    private indexAppendCount;
     constructor(opts: SessionStoreOptions);
-    /**
-     * Emit a structured warning. Uses the configured Logger when available;
-     * falls back to console.warn(JSON) so warnings are never silently dropped.
-     */
     private logWarn;
     private scrubSummaries;
-    /**
-     * Clear the load() cache. Useful for testing or when the caller knows
-     * the file has changed externally (e.g., another process wrote to it).
-     */
     clearLoadCache(sessionId?: string): void;
     dispose(): Promise<void>;
-    /** Absolute path to the session index file. */
     private get indexFile();
-    /** Join session ID to its absolute path within the store directory. */
     private sessionPath;
     private shardManifestPath;
     private shardKeyForSessionId;
     private invalidateShardManifestBySessionId;
-    /**
-     * Ensure the directory implied by the session ID exists. When the ID
-     * contains a date prefix like `2026-06-06/...`, this creates the date
-     * subdirectory so sessions group naturally by day.
-     */
     private ensureShardDir;
     create(meta: Omit<SessionMetadata, 'startedAt'>): Promise<SessionWriter>;
     fork(id: string, opts?: SessionForkOptions): Promise<ForkedSession>;
-    /**
-     * Implements {@link SessionForkHost.readRawEvents} — the parent stream a fork
-     * inherits, unmodified.
-     *
-     * Deliberately NOT `load()`: that loader empties superseded snapshot payloads
-     * in place and front-drops events past its retention budget, both of which
-     * are correct for reconstructing a conversation and wrong for copying a
-     * journal prefix into a child. Streaming with an accept-everything predicate
-     * keeps the scrubbing contract (`searchEvents` scrubs each line the same way
-     * `load()` does) without either transformation.
-     */
     readRawEvents(id: string): Promise<SessionEvent[]>;
-    /**
-     * Capture the deterministic post-tool workspace identity through the store-owned CAS.
-     */
     captureWorkspaceCheckpoint(sessionId: string, promptIndex: number): Promise<WorkspaceCheckpointRef | undefined>;
-    /**
-     * Materialize a store-owned checkpoint into an already isolated workspace.
-     */
     materializeWorkspaceCheckpoint(checkpoint: WorkspaceCheckpointRef, targetRoot: string): Promise<import("../types/session.js").WorkspaceMaterializationResult>;
     resolveId(query: string): Promise<string>;
     resume(id: string): Promise<ResumedSession>;
     load(id: string): Promise<SessionData>;
-    /**
-     * Fast-path loader that skips message reconstruction and adjacency repair.
-     *
-     * Use this for callers that only need the raw event stream + session
-     * metadata — e.g. session listers, analytics, audit, and the TUI's
-     * "events only" views. It avoids the message array build and
-     * repairToolUseAdjacency cost on large session files (a long agent
-     * run can have 50k+ events; rebuilding messages is O(events) and
-     * allocates per-block, so skipping it is a meaningful win).
-     *
-     * The returned data.messages is an empty array; data.toolCallEnds
-     * is computed from the raw events. usage is the sum across all
-     * llm_response events — same as full load().
-     */
     loadEventsOnly(id: string): Promise<SessionData>;
     private loadInternal;
-    /**
-     * Streaming search over a session's JSONL. Walks the file once, parses
-     * each event lazily, and yields only the events that match `predicate`.
-     * Stops as soon as `opts.limit` matches are collected.
-     *
-     * Why this exists: `load()` parses the entire file into memory and
-     * rebuilds `messages`/`toolCallEnds` for every caller. `search()` only
-     * needs to know which events contain matching text — a per-line
-     * predicate is enough. The full parse work (and the `_loadCache` poll)
-     * is wasted in that case.
-     *
-     * Memory: O(hits) regardless of file size. Disk: one linear scan,
-     * terminated at `limit` if the caller asked for one.
-     *
-     * Errors: missing file yields []. Corrupt lines are skipped (same
-     * policy as `load()`). Aborting via `signal` rejects with `AbortError`.
-     */
     searchEvents(id: string, predicate: (event: SessionEvent, eventIndex: number, ts: string) => boolean, opts?: {
         limit?: number | undefined;
         signal?: AbortSignal | undefined;
@@ -122,16 +49,6 @@ export declare class DefaultSessionStore implements SessionStore {
         ts: string;
     }>>;
     list(limit?: number): Promise<SessionSummary[]>;
-    /**
-     * List sessions matching filter criteria, using the cached index.
-     * Filters are applied BEFORE sorting and slicing, so the caller gets
-     * exactly `limit` matching sessions — not a slice of a larger fetch.
-     *
-     * This avoids the DefaultSessionReader pattern of fetching 1000 sessions
-     * then linear-filtering: the index is already in memory (readIndex
-     * caches it), and the filter runs over the cached array without any
-     * additional disk I/O.
-     */
     listFiltered(criteria: {
         since?: string | undefined;
         until?: string | undefined;
@@ -141,69 +58,24 @@ export declare class DefaultSessionStore implements SessionStore {
         titleContains?: string | undefined;
         limit?: number | undefined;
     }): Promise<SessionSummary[]>;
-    private indexAppendCount;
-    private static readonly COMPACT_EVERY;
-    /** Append a session summary to the index, propagating persistence failures. */
     private appendToIndexStrict;
-    /** Best-effort index append used by writer close. */
     private appendToIndex;
-    /** Final summary boundary: daemon is authoritative when available. */
     private persistCatalogSummary;
-    /** Append a tombstone entry for a deleted session. */
     private writeTombstone;
-    /**
-     * Compact the index: read all entries, drop tombstones, deduplicate
-     * (keep latest per session), and rewrite atomically. Acquires the index
-     * file lock so a concurrent append (this process or another wstack in the
-     * same project) can't be overwritten by the rewrite.
-     */
     private compactIndex;
-    /**
-     * Lock-free compaction body. The caller MUST already hold the index file
-     * lock (via withFileLock(this.indexFile, ...)). Uses atomicWrite for the
-     * rewrite so the temp file gets a random suffix (no collision between two
-     * compactions) and the Windows transient-EPERM rename retry.
-     */
     private compactIndexInner;
-    /**
-     * Read the index file and return deduplicated session summaries.
-     * Entries with a matching tombstone are filtered out.
-     * Returns empty array when the index doesn't exist or is corrupt.
-     */
     private readIndex;
-    /**
-     * Rebuild the index from disk by scanning all sessions and writing a
-     * fresh _index.jsonl. Useful after manual cleanup or index corruption.
-     */
     rebuildIndex(): Promise<number>;
     private listFromDirectoryScan;
     private collectShardKeys;
     private readOrBuildShardManifest;
-    /**
-     * Shard manifests are invalidated by other store processes via atomic
-     * delete/rebuild. Validate the in-memory projection against the persisted
-     * file so one long-lived process cannot retain another process's stale view.
-     */
     private freshShardManifestCacheEntry;
     private collectSessionFilesInShard;
     private collectSessionFiles;
-    /** Recursively collect session IDs from date-shard subdirectories.
-     *  IDs include the date-prefix path (e.g. "2026-06-06/17-46-57Z_…").
-     *  Skips `.jsonl`/`.summary.json` root files, dot-files, and
-     *  sub-directories that belong to fleet/subagent sessions. */
     private collectSessionIds;
     private summaryFor;
     private readSummaryManifest;
     private summaryHeaderFor;
-    /**
-     * Delete a session and all associated files: JSONL, summary, plan/todos
-     * sidecars, and the session directory (fleet.json, shared/, subagents/).
-     *
-     * Individual file deletions are best-effort (logged as structured warnings),
-     * but a tombstone is always written so readIndex() filters this session out.
-     * If the session directory itself can't be removed, the error is surfaced
-     * to the caller so prune() can report it.
-     */
     private deleteSession;
     isEmpty(id: string): Promise<boolean>;
     delete(id: string): Promise<void>;

package/dist/storage/session-summary-tracker.d.ts

@@ -0,0 +1,39 @@
+import type { SessionEvent, SessionMetadata, SessionSummary } from '../types/session.js';
+export interface SessionSummaryTrackerOptions {
+    id: string;
+    startedAt: string;
+    meta: Omit<SessionMetadata, 'startedAt'>;
+    resumed?: boolean | undefined;
+    initialSummary?: SessionSummary | undefined;
+    resolveName?: (() => Promise<Pick<SessionSummary, 'name'> | null>) | undefined;
+}
+export declare class SessionSummaryTracker {
+    private readonly id;
+    private readonly startedAt;
+    private readonly meta;
+    private readonly resumed;
+    private readonly resolveNameCb?;
+    private summary;
+    private tokenIn;
+    private tokenOut;
+    private baseTokenTotal;
+    private iterationCount;
+    private toolCallCount;
+    private toolErrorCount;
+    private toolBreakdown;
+    private fileChangeCount;
+    private compactionCount;
+    private messageCount;
+    private lastUserMessage;
+    private lastActivityAt;
+    private outcome;
+    private openToolUses;
+    constructor(opts: SessionSummaryTrackerOptions);
+    get currentSummary(): Readonly<SessionSummary>;
+    get pendingToolUses(): string[];
+    observe(event: SessionEvent): void;
+    recomputeFromDisk(filePath: string): Promise<void>;
+    finalize(): Promise<SessionSummary>;
+    reset(resetAt: string): void;
+}
+//# sourceMappingURL=session-summary-tracker.d.ts.map

package/dist/storage/session-write-buffer.d.ts

@@ -0,0 +1,43 @@
+import * as fsp from 'node:fs/promises';
+import type { EventBus } from '../kernel/events.js';
+import type { SessionEvent } from '../types/session.js';
+export interface SessionWriteBufferOptions {
+    sessionId: string;
+    filePath: string;
+    getHandle: () => fsp.FileHandle;
+    setHandle: (handle: fsp.FileHandle) => void;
+    events?: EventBus | undefined;
+    getTraceId?: () => string | undefined;
+}
+export declare class SessionWriteBuffer {
+    private readonly opts;
+    private static readonly FLUSH_INTERVAL_MS;
+    private static readonly FLUSH_SIZE;
+    private static readonly WRITE_BUFFER_MAX_EVENTS;
+    private static readonly WRITE_BUFFER_MAX_BYTES;
+    private writeBuffer;
+    private writeBufferBytes;
+    private flushTimer;
+    private bufferOverflowCount;
+    private lastBufferOverflowWarnAt;
+    private appendFailCount;
+    private lastAppendWarnAt;
+    private writeChain;
+    private flushPromise;
+    constructor(opts: SessionWriteBufferOptions);
+    get isClosed(): boolean;
+    get length(): number;
+    private eventBytes;
+    push(event: SessionEvent): boolean;
+    enqueueWrite(data: string): Promise<void>;
+    scheduleFlush(isClosed?: boolean): void;
+    cancelTimer(): void;
+    flushBuffer(isClosed?: boolean): Promise<void>;
+    private flushBufferOnce;
+    drainWriteChain(): Promise<void>;
+    drainFlushPromise(): Promise<void>;
+    flushSync(): void;
+    clear(): void;
+    shouldFlushNow(): boolean;
+}
+//# sourceMappingURL=session-write-buffer.d.ts.map

package/dist/storage/session-writer/session-writer-flush.d.ts

@@ -0,0 +1,4 @@
+import type { SessionEvent } from '../../types/session.js';
+export declare function isClosedHandleError(err: unknown): boolean;
+export declare function flushBufferSync(filePath: string, events: SessionEvent[]): void;
+//# sourceMappingURL=session-writer-flush.d.ts.map

package/dist/storage/session-writer/session-writer-summary-tracker.d.ts

@@ -0,0 +1,28 @@
+import type { SessionEvent, SessionMetadata, SessionSummary } from '../../types/session.js';
+export declare class SessionWriterSummaryTracker {
+    readonly id: string;
+    readonly startedAt: string;
+    readonly meta: Omit<SessionMetadata, 'startedAt'>;
+    summary: SessionSummary;
+    tokenIn: number;
+    tokenOut: number;
+    baseTokenTotal: number;
+    iterationCount: number;
+    toolCallCount: number;
+    toolErrorCount: number;
+    toolBreakdown: Record<string, number>;
+    fileChangeCount: number;
+    compactionCount: number;
+    messageCount: number;
+    lastUserMessage: string | undefined;
+    lastActivityAt: string;
+    outcome: SessionSummary['outcome'];
+    openToolUses: Set<string>;
+    constructor(id: string, startedAt: string, meta: Omit<SessionMetadata, 'startedAt'>, resumed: boolean, initialSummary?: SessionSummary | undefined);
+    get pendingToolUses(): string[];
+    observe(event: SessionEvent): void;
+    recomputeFromDisk(filePath: string): Promise<void>;
+    finalize(endedAt: string): SessionSummary;
+    reset(resetAt: string): void;
+}
+//# sourceMappingURL=session-writer-summary-tracker.d.ts.map

package/dist/tools/fallback-agent-model-assign-tool.d.ts

@@ -0,0 +1,18 @@
+import type { Tool } from '../types/tool.js';
+import type { FallbackManageToolOptions } from './fallback-manage-tool-options.js';
+export declare const AGENT_MODEL_ASSIGN_TOOL_NAME = "agent_model_assign";
+interface AgentModelAssignInput {
+    role: string;
+    provider?: string | undefined;
+    model?: string | undefined;
+    profile?: string | undefined;
+    clear?: boolean | undefined;
+}
+interface AgentModelAssignOutput {
+    status: 'ok' | 'error';
+    message: string;
+    role?: string;
+}
+export declare function createAgentModelAssignTool(opts: FallbackManageToolOptions): Tool<AgentModelAssignInput, AgentModelAssignOutput>;
+export {};
+//# sourceMappingURL=fallback-agent-model-assign-tool.d.ts.map

package/dist/tools/fallback-leader-model-set-tool.d.ts

@@ -0,0 +1,18 @@
+import type { Tool } from '../types/tool.js';
+import type { FallbackManageToolOptions } from './fallback-manage-tool-options.js';
+export declare const LEADER_MODEL_SET_TOOL_NAME = "leader_model_set";
+interface LeaderModelSetInput {
+    action: 'show' | 'set' | 'profile' | 'toggle';
+    provider?: string | undefined;
+    model?: string | undefined;
+    profile?: string | undefined;
+    toggle?: 'fallbackAuto' | 'favoriteModelsOnly' | undefined;
+    value?: boolean | undefined;
+}
+interface LeaderModelSetOutput {
+    status: 'ok' | 'error';
+    message: string;
+}
+export declare function createLeaderModelSetTool(opts: FallbackManageToolOptions): Tool<LeaderModelSetInput, LeaderModelSetOutput>;
+export {};
+//# sourceMappingURL=fallback-leader-model-set-tool.d.ts.map

package/dist/tools/fallback-manage-tools.d.ts

@@ -2,56 +2,19 @@
  * LLM-accessible tools covering every provider/model/fallback configurable area
  * in the system: favorites, fallback chains & profiles, provider management,
  * API key handling, leader model, per-role model assignment, and system view.
- *
- * DESIGN: Every operation that accepts a provider/model reference validates
- * the entry against the user's `favoriteModels` list FIRST. This means all
- * fallback additions, profiles, and role assignments are restricted to
- * user-curated favorites — the LLM cannot add arbitrary unknown models.
- *
- * Exceptions:
- * - Removing entries (chain, profile, favorites) works on any existing entry.
- * - Listing/viewing works unconditionally.
- * - The active leader model itself is not restricted (it's already set).
- *
- * Tools (8 total):
- *   favorite_manage      — List, add, remove favorite models.
- *   fallback_chain_manage — View, add, insert, remove, clear the active chain.
- *   fallback_profile_manage — List, create/update, delete named profiles.
- *   agent_model_assign   — Assign model/profile to role/phase/* in the matrix.
- *   provider_manage      — List, add, configure, remove provider entries.
- *   provider_key_set     — Set API key via env var, direct key, or interactive prompt.
- *   leader_model_set     — View/set leader model, derive from profile, toggle settings.
- *   system_config_view   — Comprehensive view + validation doctor for full config.
- *
- * Usage from an agent:
- * ```
- * favorite_manage({ action: "list" })
- * favorite_manage({ action: "add", model: "anthropic/claude-sonnet-4" })
- * fallback_chain_manage({ action: "add", model: "anthropic/claude-haiku-3" })
- * fallback_profile_manage({ action: "set", name: "fast", chain: ["openai/gpt-4o-mini"] })
- * agent_model_assign({ role: "security-scanner", provider: "anthropic", model: "claude-haiku-3" })
- * provider_key_set({ provider: "openai", envVar: "OPENAI_API_KEY" })
- * leader_model_set({ action: "show" })
- * system_config_view({ section: "all" })
- * ```
  */
 import type { Tool } from '../types/tool.js';
+import { FALLBACK_CHAIN_MANAGE_TOOL_NAME } from './fallback-chain-manage-tool.js';
+import { FAVORITE_MANAGE_TOOL_NAME } from './fallback-favorite-manage-tool.js';
 import type { FallbackManageToolOptions } from './fallback-manage-tool-options.js';
-export { FALLBACK_CHAIN_MANAGE_TOOL_NAME } from './fallback-chain-manage-tool.js';
-export declare const FALLBACK_PROFILE_MANAGE_TOOL_NAME = "fallback_profile_manage";
-export declare const AGENT_MODEL_ASSIGN_TOOL_NAME = "agent_model_assign";
-export { FAVORITE_MANAGE_TOOL_NAME } from './fallback-favorite-manage-tool.js';
+import { FALLBACK_PROFILE_MANAGE_TOOL_NAME } from './fallback-profile-manage-tool.js';
+import { AGENT_MODEL_ASSIGN_TOOL_NAME } from './fallback-agent-model-assign-tool.js';
+import { PROVIDER_MANAGE_TOOL_NAME, validateProviderBaseUrl } from './fallback-provider-manage-tool.js';
+import { PROVIDER_KEY_SET_TOOL_NAME } from './fallback-provider-key-set-tool.js';
+import { LEADER_MODEL_SET_TOOL_NAME } from './fallback-leader-model-set-tool.js';
+export { FALLBACK_CHAIN_MANAGE_TOOL_NAME, FALLBACK_PROFILE_MANAGE_TOOL_NAME, AGENT_MODEL_ASSIGN_TOOL_NAME, FAVORITE_MANAGE_TOOL_NAME, PROVIDER_MANAGE_TOOL_NAME, PROVIDER_KEY_SET_TOOL_NAME, LEADER_MODEL_SET_TOOL_NAME, validateProviderBaseUrl, };
 export * from './fallback-system-config-view-tool.js';
 export type { FallbackManageToolOptions } from './fallback-manage-tool-options.js';
-export declare const PROVIDER_MANAGE_TOOL_NAME = "provider_manage";
-/**
- * Reject provider base URLs that are malformed, non-HTTP, or carry embedded
- * credentials (WS-013). Private and loopback hosts stay allowed on purpose —
- * Ollama, LM Studio and omniroute are first-class local providers.
- */
-export declare function validateProviderBaseUrl(raw: string): string | null;
-export declare const PROVIDER_KEY_SET_TOOL_NAME = "provider_key_set";
-export declare const LEADER_MODEL_SET_TOOL_NAME = "leader_model_set";
 /**
  * Create all 8 provider/model/fallback management tools that LLMs can call.
  *

package/dist/tools/fallback-profile-manage-tool.d.ts

@@ -0,0 +1,16 @@
+import type { Tool } from '../types/tool.js';
+import type { FallbackManageToolOptions } from './fallback-manage-tool-options.js';
+export declare const FALLBACK_PROFILE_MANAGE_TOOL_NAME = "fallback_profile_manage";
+interface FallbackProfileInput {
+    action: 'list' | 'set' | 'delete';
+    name?: string | undefined;
+    chain?: string[] | undefined;
+}
+interface FallbackProfileOutput {
+    status: 'ok' | 'error';
+    message: string;
+    profiles?: Record<string, string[]>;
+}
+export declare function createFallbackProfileManageTool(opts: FallbackManageToolOptions): Tool<FallbackProfileInput, FallbackProfileOutput>;
+export {};
+//# sourceMappingURL=fallback-profile-manage-tool.d.ts.map

package/dist/tools/fallback-provider-key-set-tool.d.ts

@@ -0,0 +1,17 @@
+import type { Tool } from '../types/tool.js';
+import type { FallbackManageToolOptions } from './fallback-manage-tool-options.js';
+export declare const PROVIDER_KEY_SET_TOOL_NAME = "provider_key_set";
+interface ProviderKeySetInput {
+    provider: string;
+    key?: string | undefined;
+    envVar?: string | undefined;
+    label?: string | undefined;
+    setActive?: boolean | undefined;
+}
+interface ProviderKeySetOutput {
+    status: 'ok' | 'error' | 'needs_key';
+    message: string;
+}
+export declare function createProviderKeySetTool(opts: FallbackManageToolOptions): Tool<ProviderKeySetInput, ProviderKeySetOutput>;
+export {};
+//# sourceMappingURL=fallback-provider-key-set-tool.d.ts.map

package/dist/tools/fallback-provider-manage-tool.d.ts

@@ -0,0 +1,26 @@
+import type { Tool } from '../types/tool.js';
+import type { FallbackManageToolOptions } from './fallback-manage-tool-options.js';
+export declare const PROVIDER_MANAGE_TOOL_NAME = "provider_manage";
+interface ProviderManageInput {
+    action: 'list' | 'add' | 'configure' | 'remove';
+    provider?: string | undefined;
+    type?: string | undefined;
+    models?: string[] | undefined;
+    baseUrl?: string | undefined;
+    family?: string | undefined;
+    envVars?: string[] | undefined;
+    autoDiscoverModels?: boolean | undefined;
+    apiKey?: string | undefined;
+}
+interface ProviderManageOutput {
+    status: 'ok' | 'error';
+    message: string;
+    providers?: string[];
+}
+export declare const CREDENTIAL_SELECTOR_FIELDS: readonly ['apiKey', 'apiKeys', 'activeKey', 'envVars'];
+export declare function envVarsClaimedByOtherProviders(providers: Record<string, Record<string, unknown>>, exceptProvider: string): Map<string, string>;
+export declare function rejectBorrowedEnvVars(providers: Record<string, Record<string, unknown>>, provider: string, requested: readonly unknown[] | undefined): string | null;
+export declare function validateProviderBaseUrl(raw: string): string | null;
+export declare function createProviderManageTool(opts: FallbackManageToolOptions): Tool<ProviderManageInput, ProviderManageOutput>;
+export {};
+//# sourceMappingURL=fallback-provider-manage-tool.d.ts.map