@wrongstack/core 0.265.1 → 0.268.0

package/dist/{goal-preamble-DvHDSKSe.d.ts → goal-preamble-CrYjmdw4.d.ts}

@@ -1,14 +1,14 @@
 import { S as SkillLoader, a as SkillManifest, b as SkillEntry } from './skill-DGIXCtdv.js';
 import { W as WstackPaths } from './wstack-paths-hOpNLmvf.js';
-import { P as Provider, C as Context } from './context-MRk5PhNv.js';
-import { C as Compactor, a as CompactReport } from './compactor-B8pOf45Y.js';
-import { M as MessageSelector } from './selector-CzHh_igB.js';
-import { E as EventBus } from './brain-BXd_61kQ.js';
-import { M as MiddlewareHandler } from './pipeline-DPDxH_7m.js';
-import { S as SessionEventBridge } from './session-event-bridge-BUI6Jf-4.js';
-import { C as ContextWindowAggressiveOn, g as ContextWindowPolicy } from './config-BMCj_XDs.js';
-import { g as Agent, D as DoneCondition } from './agent-subagent-runner-DM2pP-B6.js';
-import { R as RunResult, S as SystemPromptContributor } from './index-CEDeNodM.js';
+import { P as Provider, C as Context } from './context-C0U8B9NF.js';
+import { C as Compactor, a as CompactReport } from './compactor-CBQAJoDc.js';
+import { M as MessageSelector } from './selector-47LBnBVk.js';
+import { E as EventBus } from './brain-69wzMKp1.js';
+import { M as MiddlewareHandler } from './pipeline-BDNvENyV.js';
+import { S as SessionEventBridge } from './session-event-bridge-Cw7oqmW2.js';
+import { C as ContextWindowAggressiveOn, h as ContextWindowPolicy } from './config-VKfOZ-6X.js';
+import { g as Agent, D as DoneCondition } from './agent-subagent-runner-Bvtf1o9K.js';
+import { R as RunResult, S as SystemPromptContributor } from './index-gCv830d7.js';
 
 interface SkillLoaderOptions {
     paths: WstackPaths;
@@ -178,8 +178,15 @@ declare class SelectiveCompactor implements Compactor {
     private computeTargetBudget;
     private eliseOldToolResults;
     private hasTextContent;
+    /**
+     * Estimate message-array tokens via the shared `estimateMessages` primitive
+     * so SelectiveCompactor's before/after/load figures agree with the
+     * middleware threshold math and the other compactors. Previously this used a
+     * private `ceil(len/3.5)` walk that diverged from the calibrated shared
+     * estimator, causing the selective `load`/`targetBudget` comparison to mix
+     * two incompatible token scales.
+     */
     private estimateTokens;
-    private roughTokenEstimate;
 }
 
 type CompactorStrategy = 'hybrid' | 'intelligent' | 'selective';
@@ -224,6 +231,16 @@ interface StrategyCompactorOptions {
  */
 declare function createStrategyCompactor(opts?: StrategyCompactorOptions): Compactor;
 
+interface ContextWindowBudgetSnapshot {
+    maxContext: number;
+    inputTokens: number;
+    availableInputTokens: number;
+    remainingInputTokens: number;
+    reservedOutputTokens: number;
+    reservedSafetyTokens: number;
+    load: number;
+    overflowTokens: number;
+}
 type CompactionFailureMode = 'throw' | 'throw_on_hard' | 'continue';
 interface AutoCompactionOptions {
     aggressiveOn?: ContextWindowAggressiveOn | undefined;
@@ -451,4 +468,4 @@ declare function makeAutonomyPromptContributor(opts: AutonomyPromptContributorOp
  */
 declare function buildGoalPreamble(goal: string, deliverables?: string[]): string;
 
-export { AutoCompactionMiddleware as A, type CompactorStrategy as C, DefaultSkillLoader as D, IntelligentCompactor as I, SelectiveCompactor as S, AutonomousRunner as a, type AutonomousRunnerOptions as b, type AutonomyPromptContributorOptions as c, type DoneCheckResult as d, DoneConditionChecker as e, type IntelligentCompactorOptions as f, type SelectiveCompactorOptions as g, type SkillLoaderOptions as h, type StrategyCompactorOptions as i, buildGoalPreamble as j, createStrategyCompactor as k, makeAutonomyPromptContributor as m };
+export { AutoCompactionMiddleware as A, type CompactorStrategy as C, DefaultSkillLoader as D, IntelligentCompactor as I, SelectiveCompactor as S, AutonomousRunner as a, type AutonomousRunnerOptions as b, type AutonomyPromptContributorOptions as c, type DoneCheckResult as d, DoneConditionChecker as e, type IntelligentCompactorOptions as f, type SelectiveCompactorOptions as g, type SkillLoaderOptions as h, type StrategyCompactorOptions as i, buildGoalPreamble as j, createStrategyCompactor as k, type ContextWindowBudgetSnapshot as l, makeAutonomyPromptContributor as m };

package/dist/{goal-store-DtLMySNb.d.ts → goal-store-Y_zdLZ3q.d.ts}

@@ -1,4 +1,4 @@
-import { E as EventBus } from './brain-BXd_61kQ.js';
+import { E as EventBus } from './brain-69wzMKp1.js';
 
 /**
  * Long-running autonomous mission. A goal survives across sessions and

package/dist/hq/index.d.ts

@@ -0,0 +1,195 @@
+import { W as HqRedactionPolicy, p as HqEventEnvelope, R as HqPublisher, l as HqClientIdentity, a2 as HqSocketFactory, G as GlobalMailbox } from '../global-mailbox-KByEFFBa.js';
+export { D as DEFAULT_HQ_REDACTION_POLICY, H as HQ_PROTOCOL_VERSION, a as HqAlertMessage, b as HqBrowserEventMessage, c as HqBrowserMessage, d as HqBrowserSnapshotMessage, e as HqClientCapability, f as HqClientCommandAckMessage, g as HqClientCommandPollMessage, h as HqClientEventMessage, i as HqClientHeartbeatPayload, j as HqClientHelloMessage, k as HqClientHelloPayload, m as HqClientKind, n as HqClientMessage, o as HqClientRecord, q as HqEventPayloadResult, r as HqEventType, s as HqFleetEventPayload, t as HqFleetSnapshotPayload, u as HqFleetSummary, v as HqGitSnapshotPayload, w as HqMailboxAgentStatus, x as HqMailboxAgentSummary, y as HqMailboxEventAction, z as HqMailboxEventPayload, A as HqMailboxMappingOptions, B as HqMailboxMessageSummary, C as HqMailboxMessageType, E as HqMailboxPriority, F as HqMailboxSnapshotOptions, I as HqMailboxSnapshotPayload, J as HqMailboxSummary, K as HqParseResult, L as HqPathPolicy, M as HqProjectIdentity, N as HqProjectRecord, O as HqProjectStatus, P as HqProtocolVersion, Q as HqPublishEventOptions, S as HqPublisherCommandHandler, T as HqPublisherCommandResult, U as HqPublisherOptions, V as HqQueuedCommand, X as HqServerCommandBatchMessage, Y as HqServerMessage, Z as HqSessionStartedPayload, _ as HqSessionStatus, $ as HqSessionStatusPayload, a0 as HqSessionSummary, a1 as HqSnapshot, a3 as HqSocketLike, a4 as HqSubagentSummary, a5 as HqToolArgsPolicy, a6 as HqToolCompletedPayload, a7 as HqToolStartedPayload, a8 as HqUsagePayload, a9 as HqWelcomePayload, aa as HqWorklistCounts, ab as HqWorklistSnapshotPayload, ac as HqWorkspaceKind, ad as createHqEventEnvelope, ae as createMailboxEventPayload, af as createMailboxSnapshotPayload, ag as createMailboxSnapshotPayloadFromMailbox, ah as mapMailboxAgentToHqSummary, ai as mapMailboxMessageToHqSummary, aj as parseHqEventPayload, ak as parseHqFrame } from '../global-mailbox-KByEFFBa.js';
+import { E as EventBus } from '../brain-69wzMKp1.js';
+import { w as HqClientConfig } from '../config-VKfOZ-6X.js';
+import '../mailbox-types-Ct2hJq0P.js';
+import '../context-C0U8B9NF.js';
+
+interface HqRedactOptions {
+    policy?: Partial<HqRedactionPolicy>;
+    projectRoot?: string;
+    maxSummaryLength?: number;
+}
+interface HqRedactionResult<T> {
+    value: T;
+    redacted: boolean;
+}
+/**
+ * Scrub a free-text preview field and truncate it to a maximum length so
+ * it is safe to embed in HQ event envelopes and broadcast to browsers
+ * without leaking secrets or running away on unbounded input.
+ *
+ * Returns `undefined` when the input is empty or non-string. Truncation
+ * suffix is `"…[truncated:N]"` where N is the number of dropped chars.
+ */
+declare function scrubAndTruncateHqPreview(value: unknown, maxLength?: number): string | undefined;
+declare function redactHqValue<T>(value: T, options?: HqRedactOptions): HqRedactionResult<T>;
+declare function redactHqEvent<TPayload>(event: HqEventEnvelope<TPayload>, options?: HqRedactOptions): HqRedactionResult<HqEventEnvelope<TPayload>>;
+declare function summarizeHqToolArgs(value: unknown, options?: HqRedactOptions): unknown;
+
+interface HqPublisherEnvConfig {
+    url: string;
+    token?: string;
+    enabled?: boolean;
+    rawContent?: boolean;
+    projectAlias?: string;
+}
+declare function resolveHqConfigFromEnv(env?: NodeJS.ProcessEnv): HqPublisherEnvConfig | undefined;
+declare function resolveHqConfig(options?: {
+    env?: NodeJS.ProcessEnv | undefined;
+    config?: HqClientConfig | undefined;
+}): HqPublisherEnvConfig | undefined;
+interface CreateHqPublisherOptions {
+    clientKind: HqClientIdentity['kind'];
+    projectRoot: string;
+    projectName?: string;
+    machineId?: string;
+    hostnameOverride?: string;
+    socketFactory?: HqSocketFactory;
+    config?: HqPublisherEnvConfig;
+    appConfig?: {
+        hq?: HqClientConfig | undefined;
+    } | undefined;
+    redactionPolicy?: Partial<HqRedactionPolicy>;
+}
+declare function createHqPublisherFromEnv(options: CreateHqPublisherOptions): HqPublisher | undefined;
+interface CreateGlobalMailboxOptions {
+    projectDir: string;
+    events?: EventBus;
+    hqPublisher?: HqPublisher;
+}
+declare function createGlobalMailbox(options: CreateGlobalMailboxOptions): GlobalMailbox;
+
+/** Current auth-file schema version. Bump on breaking shape changes. */
+declare const HQ_AUTH_FILE_VERSION: 1;
+/** Default HQ data directory: `~/.wrongstack/hq` (honors WRONGSTACK_HOME). */
+declare function defaultHqDataDir(): string;
+/**
+ * Resolve an HQ data directory from an optional override.
+ *
+ * Resolution order:
+ *   1. Explicit `override` (from `--data-dir`) — resolved against
+ *      `process.cwd()` if relative.
+ *   2. `WRONGSTACK_HQ_DATA_DIR` env var (same resolution rules).
+ *   3. `defaultHqDataDir()` — `~/.wrongstack/hq`.
+ *
+ * The env var exists so tests (and sandboxed runs) can redirect HQ state
+ * away from the real user home without threading a CLI flag everywhere.
+ */
+declare function resolveHqDataDir(override?: string, env?: NodeJS.ProcessEnv): string;
+/**
+ * A generic HQ-issued token. Used for both browser tokens (validated on
+ * `/ws/browser`) and client tokens (validated on `/ws/client`). The two
+ * are stored in separate lists so a browser-only token cannot be replayed
+ * against the client channel and vice versa.
+ */
+interface HqToken {
+    id: string;
+    token: string;
+    label?: string;
+    createdAt: string;
+    lastUsedAt?: string;
+}
+/**
+ * Alias kept for backward-compat with Phase 3 callers/tests. New code
+ * should prefer `HqToken`.
+ */
+type HqBrowserToken = HqToken;
+/** On-disk shape of `<dataDir>/auth.json`. */
+interface HqAuthFile {
+    version: typeof HQ_AUTH_FILE_VERSION;
+    updatedAt: string;
+    /**
+     * Operator-configured redaction policy override. When present, the HQ
+     * server applies these settings AFTER any publisher-declared policy —
+     * i.e. the operator can always tighten, never loosen.
+     */
+    redactionPolicy?: Partial<HqRedactionPolicy>;
+    /** Browser tokens — validated on `/ws/browser` upgrades (Phase 3). */
+    browserTokens?: HqToken[];
+    /** Client tokens — validated on `/ws/client` upgrades (Phase 4). */
+    clientTokens?: HqToken[];
+}
+/** An empty auth file — what a brand-new HQ install starts with. */
+declare function emptyHqAuthFile(): HqAuthFile;
+/** Path to `auth.json` under the given data directory. */
+declare function hqAuthFilePath(dataDir: string): string;
+/**
+ * Read `auth.json` from disk. Returns `emptyHqAuthFile()` when:
+ *   - the file does not exist (ENOENT), or
+ *   - the file cannot be parsed (the `warn` callback surfaces the error).
+ *
+ * Never throws for routine I/O — a missing or corrupt auth file should not
+ * prevent the HQ server from starting. The operator can recover by editing
+ * or deleting the file.
+ */
+declare function readHqAuthFile(dataDir: string, opts?: {
+    warn?: (msg: string) => void;
+}): Promise<HqAuthFile>;
+/**
+ * Write `auth.json` atomically with mode 0o600. Creates the data directory
+ * if needed. Throws on I/O failure — callers (CLI commands) should surface
+ * the error to the operator.
+ */
+declare function writeHqAuthFile(dataDir: string, file: HqAuthFile): Promise<void>;
+interface EnsureHqFirstRunAuthResult {
+    authFile: HqAuthFile;
+    created: boolean;
+    browserToken?: HqToken;
+    clientToken?: HqToken;
+}
+/**
+ * Ensure a brand-new HQ data directory has the auth required for safe
+ * first-run operation. Only a missing auth.json is bootstrapped; an existing
+ * file, including one with empty token arrays, is treated as operator intent.
+ */
+declare function ensureHqFirstRunAuthFile(dataDir: string, opts?: {
+    warn?: (msg: string) => void;
+}): Promise<EnsureHqFirstRunAuthResult>;
+/**
+ * Load → mutate → write. The mutator receives the current file (or an empty
+ * one) and returns the next file. Use this for any read-modify-write cycle
+ * to avoid clobbering concurrent edits from another CLI invocation.
+ *
+ * Note: this does NOT take a file lock. HQ auth edits are rare (operator
+ * running `wstack --hq-token add` etc.) and the atomic rename protects
+ * against torn writes; a race between two concurrent edits would be
+ * last-write-wins, which is acceptable for this low-frequency file.
+ */
+declare function mutateHqAuthFile(dataDir: string, mutator: (current: HqAuthFile) => HqAuthFile | Promise<HqAuthFile>, opts?: {
+    warn?: (msg: string) => void;
+}): Promise<HqAuthFile>;
+/**
+ * Mint a fresh token. Used for both browser and client tokens; the caller
+ * decides which list to append to.
+ */
+declare function mintHqToken(label?: string): HqToken;
+/**
+ * Backward-compat alias for `mintHqToken`. Phase 3 callers/tests use this.
+ */
+declare const mintHqBrowserToken: typeof mintHqToken;
+/**
+ * Watch `auth.json` for changes and invoke `onChange` with the freshly-read
+ * file. Returns a `close()` function that stops watching.
+ *
+ * The watcher debounces events (default 200ms) because most editors do a
+ * tmp+rename dance that emits multiple events. On any read failure (file
+ * deleted, corrupt, etc.) the `warn` callback is invoked with the same
+ * semantics as `readHqAuthFile`; the watcher stays active so a future
+ * valid write re-triggers the callback.
+ *
+ * Notes:
+ * - `fs.watch` is best-effort across platforms. On some network
+ *   filesystems events may not fire; the operator must restart the server
+ *   to pick up changes in that case.
+ * - The watcher polls the parent directory (not the file itself) so that
+ *   atomic rename events surface reliably.
+ */
+declare function watchHqAuthFile(dataDir: string, onChange: (file: HqAuthFile) => void, opts?: {
+    warn?: (msg: string) => void;
+    debounceMs?: number;
+}): {
+    close: () => void;
+};
+
+export { type CreateGlobalMailboxOptions, type CreateHqPublisherOptions, type EnsureHqFirstRunAuthResult, HQ_AUTH_FILE_VERSION, type HqAuthFile, type HqBrowserToken, HqClientIdentity, HqEventEnvelope, HqPublisher, type HqPublisherEnvConfig, type HqRedactOptions, HqRedactionPolicy, type HqRedactionResult, HqSocketFactory, type HqToken, createGlobalMailbox, createHqPublisherFromEnv, defaultHqDataDir, emptyHqAuthFile, ensureHqFirstRunAuthFile, hqAuthFilePath, mintHqBrowserToken, mintHqToken, mutateHqAuthFile, readHqAuthFile, redactHqEvent, redactHqValue, resolveHqConfig, resolveHqConfigFromEnv, resolveHqDataDir, scrubAndTruncateHqPreview, summarizeHqToolArgs, watchHqAuthFile, writeHqAuthFile };