@a1hvdy/cc-openclaw 0.30.0 → 0.32.0

package/dist/src/proxy/thought-cache.d.ts

@@ -1,19 +0,0 @@
-/**
- * Thought Signature Cache — Gemini round-trip support
- *
- * Gemini 2.5+ with thinking requires `thought_signature` in tool_calls
- * for 2nd+ turns. We cache signatures from responses and inject on next request.
- *
- * Uses in-memory LRU cache (no file I/O needed in plugin context).
- */
-/** Cache a thought signature from a tool call response */
-export declare function cacheThoughtSig(toolCallId: string, signature: string): void;
-/** Get a cached thought signature for a tool call */
-export declare function getThoughtSig(toolCallId: string): string;
-/**
- * Inject cached thought signatures into messages for Gemini round-trip.
- * Mutates the messages array in place.
- */
-export declare function injectThoughtSigs(messages: Array<Record<string, unknown>>): void;
-/** Clear the cache (for testing) */
-export declare function clearCache(): void;

package/dist/src/session/embedded-server.d.ts

@@ -1,25 +0,0 @@
-/**
- * Embedded HTTP Server — auto-starts with plugin, serves CLI commands
- *
- * This is NOT a separate process. It runs inside the plugin (or standalone)
- * and provides HTTP endpoints for the CLI to connect to.
- *
- * Users never need to configure or manage this — it just works.
- */
-import { SessionManager } from './session-manager.js';
-export declare class EmbeddedServer {
-    private server;
-    private manager;
-    private port;
-    private authToken;
-    private _rateWindows;
-    private _rateLimitCleanupTimer;
-    private _rateLimit;
-    private host;
-    constructor(manager: SessionManager, port?: number, host?: string);
-    private _checkRateLimit;
-    start(): Promise<number>;
-    stop(): Promise<void>;
-    private handleRequest;
-    private route;
-}

package/dist/src/session/inbox-manager.d.ts

@@ -1,38 +0,0 @@
-/**
- * Cross-session messaging (inbox) manager.
- *
- * Manages message delivery between sessions. Idle sessions receive messages
- * immediately; busy sessions queue for later delivery via deliverInbox().
- */
-import type { InboxMessage, ISession } from '../types.js';
-/**
- * Callback interface — allows InboxManager to look up sessions
- * without depending on SessionManager directly.
- */
-export interface SessionLookup {
-    getSession(name: string): {
-        session: ISession;
-    } | undefined;
-    exists(name: string): boolean;
-    allNames(): Iterable<string>;
-}
-export declare class InboxManager {
-    private inboxes;
-    static escapeXmlAttr(s: string): string;
-    wrapCrossSessionMessage(msg: InboxMessage): string;
-    /**
-     * Send a message from one session to another (or broadcast with to='*').
-     * Returns whether the message was delivered immediately or queued.
-     */
-    sendTo(from: string, to: string, message: string, lookup: SessionLookup, summary?: string, onBroadcastError?: (name: string, err: Error) => void): Promise<{
-        delivered: boolean;
-        queued: boolean;
-    }>;
-    /** Read inbox messages for a session. */
-    inbox(name: string, unreadOnly?: boolean): InboxMessage[];
-    /** Deliver all queued unread messages to a session, mark as read. */
-    deliverInbox(name: string, lookup: SessionLookup): Promise<number>;
-    /** Clear inbox for a session. */
-    clear(name: string): void;
-    private _deliverOrQueue;
-}

package/dist/src/session/index.d.ts

@@ -1,3 +0,0 @@
-export * from './session-manager.js';
-export * from './inbox-manager.js';
-export * from './embedded-server.js';

package/dist/src/session/persisted-sessions.d.ts

@@ -1,50 +0,0 @@
-/**
- * Persisted sessions disk I/O — load + atomic-write + async-write of the
- * `claude-sessions.json` registry.
- *
- * Extracted from `session-manager.ts` 2026-05-13 to reduce that file's LOC.
- * The 3 functions form a coherent persistence layer; moving them together
- * is bounded and behavior-preserving (existing `tests/session.test.ts`
- * + `tests/cache-parity.test.ts` exercise the round-trip).
- */
-import type { EngineType } from '../types.js';
-import { type Logger } from '../logger.js';
-export interface PersistedSession {
-    name: string;
-    claudeSessionId: string;
-    cwd: string;
-    model?: string;
-    engine?: EngineType;
-    originalCreated: string;
-    lastResumed: string;
-    lastActivity: number;
-}
-/**
- * v0.27.4 (M4/M6) — resume-freshness gate. A persisted Claude session is
- * eligible for --resume only if its last activity is within `freshnessMs`.
- * This restores cross-restart / post-watchdog-kill conversation continuity for
- * openai-compat sessions WITHOUT reintroducing the stale-resume hazard that
- * motivated skipPersistence: a session idle longer than the window starts
- * fresh. Returns false for a missing entry, a non-numeric lastActivity, or a
- * non-positive/non-finite window (resume disabled). Pure + side-effect-free so
- * the decision is unit-testable independent of the disk layer.
- */
-export declare function isPersistedSessionFresh(persisted: Pick<PersistedSession, 'lastActivity'> | undefined, now: number, freshnessMs: number): boolean;
-/**
- * v0.27.11 — write-through decision for the resume id. The debounced disk save
- * loses an unflushed claudeSessionId on a hard kill (cc-install / watchdog
- * SIGTERM / detached pm2 restart) — exactly when post-restart resume matters.
- * So a freshness-resume session flushes its id to disk synchronously the first
- * time that id is seen. Returns true → caller does a synchronous save and
- * records the id as flushed; false → caller uses the debounced save (fine for
- * frequent same-id lastActivity bumps). Pure + side-effect-free for unit-testing.
- */
-export declare function shouldWriteThroughResumeId(opts: {
-    enabled: boolean;
-    optedFreshResume: boolean;
-    lastFlushedId: string | undefined;
-    newId: string | undefined;
-}): boolean;
-export declare function loadPersistedSessions(): Map<string, PersistedSession>;
-export declare function savePersistedSessions(sessions: Map<string, PersistedSession>, logger?: Logger): void;
-export declare function savePersistedSessionsAsync(sessions: Map<string, PersistedSession>, logger?: Logger): void;

package/dist/src/session/session-manager.d.ts

@@ -1,247 +0,0 @@
-/**
- * SessionManager — manages multiple PersistentClaudeSession instances
- *
- * Replaces the Express server layer. Pure class with no HTTP dependency.
- * Can be used by Plugin tools, CLI, or any other consumer.
- */
-import { type PersistedSession } from './persisted-sessions.js';
-import { type Logger } from '../logger.js';
-import { type SessionConfig, type SessionInfo, type SendResult, type PluginConfig, type EffortLevel, type AgentInfo, type SkillInfo, type RuleInfo, type StreamEvent, type ISession, type CouncilConfig, type CouncilSession, type CouncilReviewResult, type CouncilAcceptResult, type CouncilRejectResult, type InboxMessage, type UltraplanResult, type UltrareviewResult } from '../types.js';
-interface SendOptions {
-    effort?: EffortLevel;
-    plan?: boolean;
-    autoResume?: boolean;
-    timeout?: number;
-    onEvent?: (event: StreamEvent) => void;
-    onChunk?: (chunk: string) => void;
-}
-/**
- * Decide whether a freshly-constructed SessionManager should reap orphaned PIDs.
- *
- * The orphan reaper reads the SHARED ~/.openclaw/session-pids.json and SIGKILLs
- * any live CLI process listed there. That is correct at gateway boot, but lethal
- * under a test runner: a test that does `new SessionManager()` would read the
- * LIVE gateway's pid file and kill its prewarm/session subprocesses. So skip
- * reaping when running under vitest / NODE_ENV=test. CC_OPENCLAW_ORPHAN_REAP
- * forces it: '1' = always reap (even in test), '0' = never reap. Pure for testing.
- */
-export declare function shouldReapOrphans(env?: NodeJS.ProcessEnv): boolean;
-export declare class SessionManager {
-    private sessions;
-    private _pendingSessions;
-    private cleanupTimer;
-    private stalledWatchTimer;
-    private _recentSpawns;
-    private pluginConfig;
-    private persistedSessions;
-    private _debouncedSave;
-    private _lastFlushedIds;
-    private _proxyServer;
-    private _proxyPort;
-    private _activePids;
-    private _circuitBreaker;
-    private _inbox;
-    private logger;
-    private _pool;
-    private _pooledNames;
-    constructor(config?: Partial<PluginConfig>, logger?: Logger);
-    startSession(config: Partial<SessionConfig> & {
-        name?: string;
-    }): Promise<SessionInfo>;
-    private _doStartSession;
-    sendMessage(name: string, message: string | unknown[], options?: SendOptions): Promise<SendResult>;
-    stopSession(name: string): Promise<void>;
-    listSessions(): SessionInfo[];
-    listPersistedSessions(): PersistedSession[];
-    getStatus(name: string): SessionInfo & {
-        stats: ReturnType<ISession['getStats']>;
-    };
-    grepSession(name: string, pattern: string, limit?: number): Promise<Array<{
-        time: string;
-        type: string;
-        content: string;
-    }>>;
-    compactSession(name: string, summary?: string): Promise<void>;
-    setEffort(name: string, level: EffortLevel): void;
-    /**
-     * Switch model for a session.
-     * Updates in-memory config only (takes effect on next restart/resume).
-     * For immediate effect, call restartWithConfig() explicitly.
-     */
-    setModel(name: string, model: string): void;
-    /**
-     * Switch model immediately by restarting the session with --resume.
-     * Conversation history is preserved via the claude session ID.
-     *
-     * Guards:
-     * - Rejects if session is currently processing a message (busy guard)
-     * - Validates model string against known aliases before restarting
-     * - Rolls back to old session if startSession fails
-     */
-    switchModel(name: string, model: string): Promise<SessionInfo>;
-    /**
-     * Update allowedTools or disallowedTools at runtime.
-     *
-     * The claude CLI does not support changing tool lists while running, so
-     * the only way to apply new constraints is to restart the process with
-     * the updated flags and --resume to replay conversation history.
-     *
-     * Guards:
-     * - Rejects if session is busy
-     * - Rolls back to old session if startSession fails
-     * - merge:true adds tools; removeTools removes specific tools from the list
-     */
-    updateTools(name: string, opts: {
-        allowedTools?: string[];
-        disallowedTools?: string[];
-        removeTools?: string[];
-        merge?: boolean;
-    }): Promise<SessionInfo>;
-    getCost(name: string): import("../types.js").CostBreakdown;
-    listAgents(cwd?: string): AgentInfo[];
-    createAgent(name: string, cwd?: string, description?: string, prompt?: string): string;
-    listSkills(cwd?: string): SkillInfo[];
-    createSkill(name: string, cwd?: string, opts?: {
-        description?: string;
-        prompt?: string;
-        trigger?: string;
-    }): string;
-    listRules(cwd?: string): RuleInfo[];
-    createRule(name: string, cwd?: string, opts?: {
-        description?: string;
-        content?: string;
-        paths?: string;
-        condition?: string;
-    }): string;
-    teamList(name: string): Promise<string>;
-    teamSend(name: string, teammate: string, message: string): Promise<SendResult>;
-    /**
-     * Returns an overview of all active sessions — analogous to a dashboard.
-     * Unlike claude_session_status (single session), this gives the aggregate
-     * view: how many sessions are running, which are busy, total uptime, etc.
-     */
-    health(): {
-        ok: boolean;
-        version: string;
-        sessions: number;
-        sessionNames: string[];
-        uptime: number;
-        details: Array<{
-            name: string;
-            ready: boolean;
-            busy: boolean;
-            paused: boolean;
-            turns: number;
-            costUsd: number;
-            contextPercent: number;
-            lastActivity: string | null;
-        }>;
-        circuitBreakers: Record<string, {
-            failures: number;
-            backoffUntil: string | null;
-        }>;
-    };
-    /** Return plugin version from package.json */
-    getVersion(): string;
-    /**
-     * Gracefully shut down the session manager.
-     *
-     * 1. Cancels the periodic TTL cleanup timer
-     * 2. Stops all ultrareview polling intervals
-     * 3. Sends SIGTERM to all active session child processes
-     * 4. Persists final session registry to disk
-     *
-     * After shutdown(), no new sessions can be started. Idempotent.
-     */
-    shutdown(): Promise<void>;
-    /**
-     * Read OpenClaw gateway config from ~/.openclaw/openclaw.json.
-     * Returns { url, key } or null if not configured.
-     */
-    private _readGatewayConfig;
-    /**
-     * Start a local proxy server (if not running) that converts Anthropic format
-     * to OpenAI format and forwards to the OpenClaw gateway.
-     * Returns the proxy port, or null if gateway is not available.
-     */
-    private _ensureProxyServer;
-    private _persistSession;
-    private static PID_FILE;
-    private _savePids;
-    /**
-     * Verify that a PID belongs to a known coding CLI before killing it.
-     * Prevents killing unrelated processes if the OS recycled the PID.
-     */
-    private _isKnownCliProcess;
-    private _cleanupOrphanedPids;
-    private _getSession;
-    private _toSessionInfo;
-    private _resolveModel;
-    private _listMdFiles;
-    private _ensurePool;
-    private _isPoolCompatible;
-    private _createSession;
-    private councils;
-    private councilCleanupTimers;
-    councilStart(task: string, config: CouncilConfig): CouncilSession;
-    private _scheduleCouncilCleanup;
-    councilStatus(id: string): CouncilSession | undefined;
-    councilAbort(id: string): void;
-    councilInject(id: string, message: string): void;
-    councilReview(id: string): Promise<CouncilReviewResult>;
-    councilAccept(id: string): Promise<CouncilAcceptResult>;
-    councilReject(id: string, feedback: string): Promise<CouncilRejectResult>;
-    private get _sessionLookup();
-    sessionSendTo(from: string, to: string, message: string, summary?: string): Promise<{
-        delivered: boolean;
-        queued: boolean;
-    }>;
-    sessionInbox(name: string, unreadOnly?: boolean): InboxMessage[];
-    sessionDeliverInbox(name: string): Promise<number>;
-    private ultraplans;
-    ultraplanStart(task: string, opts?: {
-        model?: string;
-        cwd?: string;
-        timeout?: number;
-    }): UltraplanResult;
-    private _runUltraplan;
-    ultraplanStatus(id: string): UltraplanResult | undefined;
-    private ultrareviews;
-    private ultrareviewPollers;
-    ultrareviewStart(cwd: string, opts?: {
-        agentCount?: number;
-        maxDurationMinutes?: number;
-        model?: string;
-        focus?: string;
-    }): UltrareviewResult;
-    ultrareviewStatus(id: string): UltrareviewResult | undefined;
-    private _cleanupIdleSessions;
-    /**
-     * v0.10.0 — runtime stalled-session watchdog.
-     *
-     * Fires every STALLED_WATCH_INTERVAL_MS. For each session that is
-     * currently `isBusy === true` (mid-turn) AND whose underlying
-     * PersistentClaudeSession has not received any subprocess event for
-     * STALLED_SESSION_KILL_MS, the watchdog:
-     *
-     *   1. Logs the stall
-     *   2. Emits a `session_stalled_killed` trajectory event
-     *   3. Calls session.stop() (SIGTERM, then SIGKILL after STOP_SIGKILL_DELAY_MS)
-     *   4. Removes the entry from the in-memory `sessions` Map
-     *
-     * The in-flight `sendMessage()` promise will reject with the existing
-     * `TURN_TIMEOUT_MS` error or a session-stop error. The outer agent-runner
-     * then fast-fails to the cross-engine fallback (`openai-codex/gpt-5.4`)
-     * rather than waiting the full provider envelope (900s).
-     *
-     * Threshold is overridable via `CC_OPENCLAW_STALLED_KILL_MS` env var.
-     *
-     * Mirrors `gateway-pm2-wrapper.sh:53-60` boot-time orphan reaper.
-     */
-    private _watchStalledSessions;
-    private _stalledThresholdMs;
-    private _recordSpawn;
-    private _isRunawayLoop;
-    private _runawayThreshold;
-}
-export {};

package/dist/src/session/watchdogs.d.ts

@@ -1,92 +0,0 @@
-/**
- * Session watchdogs — stalled-session killer + runaway-loop spawn-rate guard.
- *
- * v0.21.0 E3a — Extracted from `session-manager.ts` (was lines 1728-1838) to
- * make these defensive policies independently testable and reduce the
- * 1839-line god-module footprint. The SessionManager class now delegates to
- * these pure-ish helpers; public API is unchanged.
- *
- * Both watchdogs:
- *   - read thresholds via central env-overrides resolvers (so `CC_OPENCLAW_*=0`
- *     disables them per the v0.20.0 direct-CLI parity contract)
- *   - emit trajectory events for observability
- *   - never throw — best-effort recovery, observability-must-not-block-recovery
- *
- * Tests:
- *   - tests/session-watchdog.test.ts (existing)
- *   - tests/session/watchdogs.test.ts (added with this extraction, covers the
- *     pure-function shape that the existing instance tests can't reach
- *     without spinning up a full SessionManager)
- */
-/** Minimal shape of a managed session that watchdogs need to inspect. */
-export interface WatchdogManagedSession {
-    session: {
-        isBusy: boolean;
-        /** Returns at least { lastActivity, lastProgressAt }. The watchdog prefers
-         *  lastProgressAt (excludes api_retry pings); other stats fields ignored. */
-        getStats(): {
-            lastActivity?: string | null | undefined;
-            lastProgressAt?: string | null | undefined;
-            /** v0.27.6 — count of in-flight tool calls; > 0 means a tool is running
-             *  (alive), so the stalled check is skipped no matter how quiet it is. */
-            inFlightTools?: number | undefined;
-        };
-        stop(): void;
-    };
-    config: {
-        model: string;
-    };
-    cwd: string;
-    claudeSessionId?: string | undefined;
-    /** Wall-clock ms of last activity tracked by SessionManager (vs subprocess). */
-    lastActivity: number;
-}
-/** Minimal logger shape watchdogs need. */
-export interface WatchdogLogger {
-    warn(msg: string): void;
-}
-/** Re-export central resolver for consumers that want raw threshold value. */
-export declare function stalledThresholdMs(): number;
-/** Re-export central resolver for consumers that want raw threshold value. */
-export declare function runawayThreshold(): number;
-/**
- * Walk active sessions; SIGTERM any whose subprocess hasn't emitted an event
- * for `thresholdMs` (defaults to env-resolved). When threshold ≤ 0 the
- * watchdog is a no-op (v0.20.0 direct-CLI parity).
- *
- * Mutates `sessions` in place — removes killed entries. Does NOT touch any
- * persistent-session-disk record (caller's GC handles that).
- */
-export declare function watchStalledSessions(opts: {
-    sessions: Map<string, WatchdogManagedSession>;
-    logger: WatchdogLogger;
-    thresholdMs?: number;
-}): void;
-/**
- * Trim stale spawn timestamps (older than RUNAWAY_LOOP_WINDOW_MS).
- * Used by both `recordSpawn` and `isRunawayLoop`. Mutates the array in place.
- *
- * Internal — exported only for direct unit testing.
- */
-export declare function _trimStaleSpawns(recentSpawns: number[]): void;
-/**
- * Record a fresh subprocess spawn for the runaway-loop watchdog. Trims entries
- * older than RUNAWAY_LOOP_WINDOW_MS so the array length is bounded.
- *
- * Mutates `recentSpawns` in place.
- */
-export declare function recordSpawn(recentSpawns: number[]): void;
-/**
- * True when the spawn rate over RUNAWAY_LOOP_WINDOW_MS reaches the configured
- * threshold (env-overridable). Caller invokes this BEFORE recording the new
- * spawn — i.e. the check fires when the (N+1)-th spawn attempt would push the
- * count over.
- *
- * When `threshold ≤ 0` the guard is disabled entirely (v0.20.0 off semantic).
- *
- * Mutates `recentSpawns` in place to trim stale entries before deciding.
- */
-export declare function isRunawayLoop(opts: {
-    recentSpawns: number[];
-    threshold?: number;
-}): boolean;

package/dist/src/session-bootstrap/boot-self-heal.d.ts

@@ -1,32 +0,0 @@
-/**
- * Boot-time self-healing helpers — idempotent filesystem probes that fix
- * what they can and log what they found.
- *
- * Extracted from `cwd-patch.ts` 2026-05-14. Two helpers share a theme
- * (boot-time FS validation/repair) and a contract (return void, log results,
- * never throw). Bundling them in one module preserves the family pattern.
- *
- * Dependencies are passed explicitly (PATHS entries, logger) so this module
- * has no implicit module-level coupling to cwd-patch.ts.
- */
-interface SelfHealLogger {
-    info(msg: string): void;
-    warn(msg: string): void;
-    error(msg: string): void;
-}
-/**
- * Warn if critical CC plugin files are missing. Boot continues — this is
- * advisory, not blocking. The eager-server path will surface a clearer
- * error later if a missing file genuinely breaks routing.
- */
-export declare function validatePaths(paths: {
-    ccPlugin: string;
-    ccServer: string;
-}, logger: SelfHealLogger, tag: string): void;
-/**
- * Restore +x on Claude Code sandbox binaries that lost the bit during
- * a previous chown/copy cycle. Common after laptop syncs or fresh
- * npm-global installs.
- */
-export declare function ensureSandboxPermissions(seccompBinaries: readonly string[], logger: SelfHealLogger, tag: string): void;
-export {};

package/dist/src/session-bootstrap/cwd-patch.d.ts

@@ -1,50 +0,0 @@
-/**
- * cwd-patch — OpenClaw plugin module
- *
- * Ports the core CWD-patching and compat-bridge infrastructure from
- * savvy-claude-code/cwd-enhancer.js.
- *
- * Two jobs:
- *
- * 1. EAGER SERVER START — Creates a SessionManager + EmbeddedServer eagerly
- *    at boot so :18796 is available immediately (before the first tool call).
- *    When the main plugin's lazy init eventually fires, it sees EADDRINUSE
- *    and gracefully skips.
- *
- * 2. CWD REDIRECT — Patches SessionManager.prototype.startSession so that
- *    openai-compat-* sessions use the workspace directory instead of /tmp.
- *    Gives Claude Code full project context when acting as Savvy's brain.
- *
- * Also includes:
- *   - Resume registry mirror (parallel write-ahead for claude-sessions.json)
- *   - Cache parity registry (Track B: OPENCLAW_CACHE_PARITY=1)
- *   - CoS session naming helpers (cosSessionStore used by think-conflict-resolver)
- *   - Runtime stub injection (ensureStatusRuntimeStubs)
- *   - Sandbox binary permission self-healing (ensureSandboxPermissions)
- *   - Route patch (applyRoutePatch: stable session keys, tool strip, sysprompt inline)
- *   - Metrics endpoint (/enhancer/metrics)
- *
- * Source: savvy-claude-code/cwd-enhancer.js lines 1–1357 (primary concern)
- */
-export interface PluginApi {
-    on(event: string, handler: (...args: unknown[]) => unknown | Promise<unknown>): void;
-    logger?: Console;
-    config?: {
-        plugins?: {
-            entries?: Record<string, {
-                config?: Record<string, unknown>;
-            }>;
-        };
-    };
-    registerService(service: {
-        id: string;
-        start: () => Promise<void>;
-        stop: () => Promise<void> | void;
-    }): void;
-}
-export declare function ensureStatusRuntimeStubs(): void;
-/**
- * Register the CWD-patch plugin.
- * Idempotent: subsequent calls on the same api are no-ops.
- */
-export declare function register(api: PluginApi): void;

package/dist/src/session-bootstrap/index.d.ts

@@ -1,3 +0,0 @@
-export { register as registerCwdPatch, ensureStatusRuntimeStubs } from './cwd-patch.js';
-export { register as registerSyspromptStrip, stripSysprompt } from './sysprompt-strip.js';
-export { register as registerThinkConflictResolver } from './think-conflict-resolver.js';

package/dist/src/session-bootstrap/resume-registry.d.ts

@@ -1,27 +0,0 @@
-/**
- * Savvy resume-registry helpers — read/write the dual JSON files used to
- * seed SessionManager state at boot time.
- *
- * Extracted from `cwd-patch.ts` 2026-05-13. The two functions form a coherent
- * persistence pair operating on the same on-disk JSON contract; their
- * coupling makes them appropriate to live in one module.
- *
- * Logger is passed explicitly so this module is fully self-contained — no
- * implicit module-level globals.
- */
-interface ResumeLogger {
-    info(msg: string): void;
-    warn(msg: string): void;
-}
-/**
- * Seed claude-sessions.json from savvy-resume-registry.json on cold boot
- * (only when claude-sessions.json is empty or missing). One-shot recovery
- * for v0.6.0+ — preserves Savvy session state across cc-openclaw upgrades.
- */
-export declare function restoreClaudeSessionsFromBackup(logger: ResumeLogger): void;
-/**
- * Write Savvy resume registry — advisory mirror; dist plugin still runs
- * its own debounced save independently.
- */
-export declare function writeBackupRegistry(entriesArray: unknown[]): void;
-export {};

package/dist/src/session-bootstrap/session-hygiene.d.ts

@@ -1,23 +0,0 @@
-/**
- * Post-boot session hygiene — operates on a live SessionManager instance
- * to clean up unhealthy bridge sessions that survived a previous process.
- *
- * Extracted from `cwd-patch.ts` 2026-05-14. Distinct lifecycle from
- * `boot-self-heal.ts`: that module runs against the filesystem at boot
- * before any SessionManager exists; this module operates on a live manager
- * after `applyPatch` resolves.
- *
- * Logger is passed explicitly so this module is decoupled from cwd-patch.ts
- * module state.
- */
-interface HygieneLogger {
-    info(msg: string): void;
-    warn(msg: string): void;
-}
-/**
- * Stop any bridge sessions reporting `stats.isReady === false`. Idempotent:
- * if all sessions are healthy, just logs the count. Failures are swallowed
- * — this is best-effort cleanup, not a correctness guarantee.
- */
-export declare function cleanStaleSessions(manager: unknown, logger: HygieneLogger, tag: string): void;
-export {};

package/dist/src/session-bootstrap/sysprompt-strip.d.ts

@@ -1,24 +0,0 @@
-/**
- * sysprompt-strip — OpenClaw plugin module
- *
- * Plugin lifecycle wiring: registers the before_prompt_build hook.
- * Strip logic lives in src/lib/sysprompt-strip.ts (canonical pure function).
- *
- * Default-ON in cc-openclaw (P2 flip from P1's opt-in default-off).
- * Opt-out: set OPENCLAW_AGGRESSIVE_STRIP=0 (or 'false' / 'off').
- *
- * Source: savvy-claude-code/cwd-enhancer.js lines 800–856 (inside applyRoutePatch)
- */
-export interface PluginApi {
-    on(event: string, handler: (...args: unknown[]) => unknown | Promise<unknown>): void;
-    logger?: Console;
-    config?: Record<string, unknown>;
-}
-export { stripSysprompt, isStripEnabled } from '../lib/sysprompt-strip.js';
-/**
- * Register sysprompt-strip's before_prompt_build hook.
- *
- * Default-ON (P2 flip): strip runs unless OPENCLAW_AGGRESSIVE_STRIP=0/false/off.
- * Idempotent: subsequent calls on the same api are no-ops (register-guard).
- */
-export declare function register(api: PluginApi): void;

package/dist/src/session-bootstrap/think-conflict-resolver.d.ts

@@ -1,32 +0,0 @@
-/**
- * think-conflict-resolver — OpenClaw plugin module
- *
- * Resolves the conflict between the gateway's built-in /think directive
- * (sets thinking level) and the /think SKILL.md skill (deep analysis).
- *
- * The gateway reserves 'think' as a builtin directive; when the user sends
- * `/think [non-level topic]`, the directive parser strips the /think prefix
- * and passes the residual text to the agent — but skill dispatch is blocked
- * because 'think' is in the reserved set.
- *
- * Fix: two-hook pattern —
- *   Hook 1 (before_dispatch): detect non-level /think, store topic in TTL store.
- *   Hook 2 (before_prompt_build): inject prependSystemContext so the agent sees
- *   the skill instruction alongside the residual user text.
- *
- * Also handles CoS (Chief of Staff) session identity injection:
- *   Hook 3 (before_dispatch): activate CoS session name on /cos invocation.
- *   Hook 4 (before_prompt_build): inject CoS session name into prompt context.
- *
- * Source: savvy-claude-code/cwd-enhancer.js lines 277–295, 1259–1353
- */
-export interface PluginApi {
-    on(event: string, handler: (...args: unknown[]) => unknown | Promise<unknown>): void;
-    logger?: Console;
-    config?: Record<string, unknown>;
-}
-/**
- * Register the /think conflict resolver + CoS session identity hooks.
- * Idempotent: subsequent calls on the same api are no-ops.
- */
-export declare function register(api: PluginApi): void;