@ckanner/flywheel 0.32.1 → 0.33.1

package/node_modules/dsh-subagent-codex-pro/lib/types/usage.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Token usage observed over one delegation.
+ *
+ * Codex reports a thread-cumulative snapshot (`total`) and a last-model-call
+ * snapshot (`last`) through `thread/tokenUsage/updated`. A delegation can make
+ * several model calls, so `last` is never a delegation total, and `total` is an
+ * absolute high-water mark rather than an increment. Resume/attach replays the
+ * latest persisted snapshot for the new connection, so the first observation
+ * after a resume is history, not this run.
+ *
+ * The tracker therefore:
+ * - uses a baseline and computes a delta from later cumulative snapshots;
+ * - treats a replay after resume as the baseline;
+ * - ignores duplicate and out-of-order snapshots;
+ * - never derives a value by adding snapshots;
+ * - reports `unknown` rather than zero when no usable observation exists;
+ * - retains the last observed totals even when the run failed or was cancelled.
+ *
+ * `cachedInputTokens` is a subset of `inputTokens`, and
+ * `reasoningOutputTokens` is a subset of `outputTokens`. The fields are reported
+ * as Codex states them; they are never summed into a larger total.
+ *
+ * @module dsh-subagent-codex-pro/usage
+ */
+/** One token-usage breakdown exactly as Codex reports it. */
+export interface TokenUsageBreakdown {
+    readonly totalTokens: number;
+    readonly inputTokens: number;
+    /** Cached input, already included in `inputTokens`. */
+    readonly cachedInputTokens: number;
+    /** Cache writes, already included in `inputTokens`. */
+    readonly cacheWriteInputTokens: number;
+    readonly outputTokens: number;
+    /** Reasoning output, already included in `outputTokens`. */
+    readonly reasoningOutputTokens: number;
+}
+/** Whether a usage report covers the whole delegation, part of it, or nothing. */
+export type UsageStatus = 'complete' | 'partial' | 'unknown';
+/**
+ * Usage attributable to one delegation.
+ *
+ * `run` is the delta from the observed baseline, not a sum of notifications.
+ * `threadTotal` is the latest absolute thread snapshot, kept for diagnostics.
+ * A report with `status: 'unknown'` deliberately has no `run`; it is not zero.
+ */
+export interface CodexUsageReport {
+    readonly status: UsageStatus;
+    /** The usage of this run, when a baseline and at least one later snapshot exist. */
+    readonly run?: TokenUsageBreakdown;
+    /** The latest thread-cumulative snapshot observed, including pre-run history. */
+    readonly threadTotal?: TokenUsageBreakdown;
+    /** Thread model context window when Codex reported it. */
+    readonly modelContextWindow?: number | null;
+    /** Usable usage notifications observed for this thread. */
+    readonly observations: number;
+    /** Whether a resumed thread's baseline came from a replay notification. */
+    readonly replayedBaseline: boolean;
+    /** Why the report is partial or unknown. */
+    readonly reason?: string;
+}
+/** The shape of `thread/tokenUsage/updated` the wire accepts. */
+export interface TokenUsageNotificationLike {
+    readonly threadId?: unknown;
+    readonly turnId?: unknown;
+    readonly tokenUsage?: unknown;
+}
+/** One notification accepted by the tracker. */
+export interface UsageObservation {
+    readonly turnId: string;
+    readonly tokenUsage: unknown;
+    readonly modelContextWindow?: unknown;
+}
+/**
+ * Fold the usage notifications of one thread into one delegation report.
+ *
+ * One tracker belongs to one wire/thread. `resetForNewThread` is called after a
+ * successful `thread/start`; `resetForResume` after a successful
+ * `thread/resume`; `beginTurn` when the turn id becomes authoritative. The
+ * tracker is deliberately not a Codex client: it only accounts for snapshots,
+ * never issues requests.
+ */
+export declare class TokenUsageTracker {
+    #private;
+    /** Start accounting for a thread that has no history. */
+    resetForNewThread(threadId: string): void;
+    /**
+     * Start accounting for a resumed thread.
+     *
+     * Its first usage notification is normally the connection-scoped replay of
+     * the last persisted snapshot, so it becomes the baseline and contributes no
+     * run usage. If no replay arrives before the turn starts, the first live
+     * snapshot is still used as a baseline but the report is `partial`, because
+     * usage before that snapshot is unknowable from the protocol.
+     */
+    resetForResume(threadId: string): void;
+    /**
+     * Mark the turn/start request boundary.
+     *
+     * Notifications are buffered until the response proves the authoritative turn
+     * id; that keeps a resumed thread's replay and a current-turn live snapshot
+     * distinguishable even when the replay arrives after this request.
+     */
+    startTurnRequest(): void;
+    /** Associate early notifications after the response proves the turn id. */
+    beginTurn(turnId: string): void;
+    /** The current turn id, when the wire has adopted it. */
+    get turnId(): string | undefined;
+    /** The latest absolute thread total, if any observation was accepted. */
+    get latest(): TokenUsageBreakdown | undefined;
+    /** The latest model context window, if Codex reported one. */
+    get modelContextWindow(): number | null | undefined;
+    /** Begin a report's closing fold; further observations are ignored. */
+    close(): void;
+    /**
+     * Fold one `thread/tokenUsage/updated` notification.
+     *
+     * @param notification - the decoded notification parameters.
+     * @returns whether the notification was usable for accounting.
+     */
+    observe(notification: TokenUsageNotificationLike): boolean;
+    /** Record a malformed notification so the report can say so. */
+    observeInvalid(): void;
+    /**
+     * The report for this run.
+     *
+     * No observation is `unknown`, never a zero report. A known baseline plus a
+     * later snapshot is `complete` unless a reset/partial reason was recorded.
+     */
+    report(): CodexUsageReport;
+}
+//# sourceMappingURL=usage.d.ts.map

package/node_modules/dsh-subagent-codex-pro/lib/types/usage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usage.d.ts","sourceRoot":"","sources":["../../src/usage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,6DAA6D;AAC7D,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,uDAAuD;IACvD,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAA;IAClC,uDAAuD;IACvD,QAAQ,CAAC,qBAAqB,EAAE,MAAM,CAAA;IACtC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,4DAA4D;IAC5D,QAAQ,CAAC,qBAAqB,EAAE,MAAM,CAAA;CACvC;AAED,kFAAkF;AAClF,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,SAAS,GAAG,SAAS,CAAA;AAE5D;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAA;IAC5B,oFAAoF;IACpF,QAAQ,CAAC,GAAG,CAAC,EAAE,mBAAmB,CAAA;IAClC,iFAAiF;IACjF,QAAQ,CAAC,WAAW,CAAC,EAAE,mBAAmB,CAAA;IAC1C,0DAA0D;IAC1D,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3C,2DAA2D;IAC3D,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,2EAA2E;IAC3E,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAA;IAClC,4CAA4C;IAC5C,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CACzB;AAED,iEAAiE;AACjE,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;IAC3B,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAA;CAC9B;AAoED,gDAAgD;AAChD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAA;IAC5B,QAAQ,CAAC,kBAAkB,CAAC,EAAE,OAAO,CAAA;CACtC;AAED;;;;;;;;GAQG;AACH,qBAAa,iBAAiB;;IAsB5B,yDAAyD;IACzD,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAuBzC;;;;;;;;OAQG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAOtC;;;;;;OAMG;IACH,gBAAgB,IAAI,IAAI;IAIxB,2EAA2E;IAC3E,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAM/B,yDAAyD;IACzD,IAAI,MAAM,IAAI,MAAM,GAAG,SAAS,CAE/B;IAED,yEAAyE;IACzE,IAAI,MAAM,IAAI,mBAAmB,GAAG,SAAS,CAE5C;IAED,8DAA8D;IAC9D,IAAI,kBAAkB,IAAI,MAAM,GAAG,IAAI,GAAG,SAAS,CAElD;IAED,uEAAuE;IACvE,KAAK,IAAI,IAAI;IAKb;;;;;OAKG;IACH,OAAO,CAAC,YAAY,EAAE,0BAA0B,GAAG,OAAO;IA4G1D,gEAAgE;IAChE,cAAc,IAAI,IAAI;IAMtB;;;;;OAKG;IACH,MAAM,IAAI,gBAAgB;CA2C3B"}

package/node_modules/dsh-subagent-codex-pro/lib/types/wire.d.ts

@@ -0,0 +1,321 @@
+/**
+ * Codex app-server protocol adapter.
+ *
+ * A faithful port of `@deepseek-ai/dsh-subagent-codex`'s wire module, extended
+ * with the per-call choices this package exists for: `model` and the unattended
+ * permission policy on `thread/start`, per-turn `effort` on `turn/start`, and
+ * explicit model/cwd/permission overrides plus effective-configuration checks
+ * on `thread/resume` (0.165+). A thinking level is **not** a `thread/start`
+ * field in 0.165/0.166. The module also accounts for token usage and account
+ * rate limits, keeping them separate.
+ *
+ * Everything else is carried over as-is, because the surrounding behaviour is
+ * load-bearing and was tuned against a real app-server: the initialize
+ * handshake, thread/turn association (including notifications that arrive
+ * before `turn/start` returns), unattended approval decisions, terminal-answer
+ * selection by phase, and the failure taxonomy.
+ *
+ * Differences from the source, all mechanical:
+ * - `JsonRpcLineTransport` is this package's own `LineTransport`, so the
+ *   transport method shape is `request(method, params, { signal })` rather than
+ *   a positional signal.
+ * - Error text uses this package's prefix.
+ * - Model and permission choices are constructor state; `effort` travels through
+ *   `runTurn`; resume overrides are per call.
+ *
+ * @module dsh-subagent-codex-pro/wire
+ */
+import type { LineTransport } from './jsonrpc.ts';
+import { type CodexUsageReport } from './usage.ts';
+/** Explicit thread permissions; approval policy never implies a sandbox. */
+declare const THREAD_PERMISSION_PARAMS: {
+    readonly 'read-only': {
+        readonly approvalPolicy: "never";
+        readonly sandbox: "read-only";
+    };
+    readonly 'workspace-write': {
+        readonly approvalPolicy: "never";
+        readonly sandbox: "workspace-write";
+    };
+    readonly never: {
+        readonly approvalPolicy: "never";
+    };
+    readonly 'approve-for-me': {
+        readonly approvalPolicy: "on-request";
+        readonly approvalsReviewer: "auto_review";
+        readonly sandbox: "workspace-write";
+    };
+    readonly 'dangerously-bypass-approvals-and-sandbox': {
+        readonly approvalPolicy: "never";
+        readonly sandbox: "danger-full-access";
+    };
+};
+/** The permission params one mode sends to thread/start and thread/resume. */
+export type CodexPermissionParams = (typeof THREAD_PERMISSION_PARAMS)[CodexPermissionMode];
+/** The configured permission mode. */
+export type CodexPermissionMode = keyof typeof THREAD_PERMISSION_PARAMS;
+/** The model/cwd/permission facts a start or resume request asked for. */
+export interface RequestedConfiguration {
+    readonly model?: string;
+    readonly cwd?: string;
+    readonly approvalPolicy?: string;
+    readonly approvalsReviewer?: string;
+    readonly sandbox?: string;
+}
+/** The facts the app-server reports after applying a start or resume request. */
+export interface EffectiveConfiguration {
+    readonly model?: string;
+    readonly cwd?: string;
+    readonly approvalPolicy?: string;
+    readonly approvalsReviewer?: string;
+    readonly sandbox?: string;
+    /** Full server-reported policy; matching the mode alone does not prove its roots/network scope. */
+    readonly sandboxPolicy?: Readonly<Record<string, unknown>>;
+    /** Historical thread default, not evidence of this run's per-turn effort. */
+    readonly reasoningEffort?: string | null;
+}
+/** One path's requested/effective facts, kept for observability and comparison. */
+export interface AppliedConfiguration {
+    readonly source: 'thread/start' | 'thread/resume';
+    readonly requested: RequestedConfiguration;
+    readonly effective: EffectiveConfiguration;
+    readonly matched: boolean;
+    /** Requested facts whose effective value is absent, malformed, or unsupported. */
+    readonly missing: readonly (keyof RequestedConfiguration)[];
+    /** Names of requested facts whose effective value differs; values are not echoed. */
+    readonly mismatches: readonly (keyof RequestedConfiguration)[];
+}
+/** Codex acknowledges the turn, but 0.165/0.166 do not echo its effective effort. */
+export interface TurnConfiguration {
+    readonly requestedEffort?: string;
+    readonly effectiveEffort: null;
+    readonly evidence: 'turn/start-request';
+    readonly accepted: boolean;
+}
+/** Overrides sent on `thread/resume` instead of silently preserving history. */
+export interface CodexResumeOverrides {
+    /** Model override, when the caller/configuration supplied one. */
+    readonly model?: string;
+    /** Working directory override applied to the resumed thread. */
+    readonly cwd?: string;
+    /** Permission mode override. Omitted means preserve the thread's history. */
+    readonly permission?: CodexPermissionMode;
+}
+/** The rate-limit snapshot Codex sends separately from token usage. */
+export interface CodexRateLimitsReport {
+    readonly observations: number;
+    /** Latest `rateLimits` object, exactly as reported. */
+    readonly latest?: Record<string, unknown>;
+}
+/**
+ * One image the run produced.
+ *
+ * Two shapes reach here. `imageView` names a file on this host, which the caller
+ * can read directly — the app-server never inlines it. An MCP tool result carries
+ * the bytes, which is how a computer-use screenshot arrives.
+ */
+export interface CodexImage {
+    /** A host path to read, for `imageView`. */
+    readonly path?: string;
+    /** Base64 bytes, for an image an MCP tool returned. */
+    readonly data?: string;
+    /** The bytes' media type, when the source named one. */
+    readonly mimeType?: string;
+}
+/** The stop reasons one run can end with. */
+export type CodexStopReason = 'completed' | 'max-tokens' | 'error' | 'aborted' | 'timeout';
+/**
+ * How long a thread lives.
+ *
+ * `ephemeral` is what this provider always did: the app-server's own notion of a
+ * throwaway thread, deleted when the connection ends, leaving nothing behind.
+ * `persistent` writes a rollout the Codex CLI can list and `thread/resume` can
+ * continue, which is also what puts it in front of the Codex desktop application.
+ */
+export type CodexThreadMode = 'ephemeral' | 'persistent';
+/** One text-only task submitted to a turn. */
+export type TaskText = string;
+/** The structured failure facts observed for a turn. */
+export interface CodexFailureFacts {
+    readonly stage: string;
+    readonly category: string;
+    readonly httpStatus?: number;
+}
+/** One thing that ends a turn. */
+export interface TurnCompletion {
+    readonly params: {
+        readonly turn: unknown;
+    };
+    readonly order: number;
+}
+/** The end of one run. */
+export interface WireRunResult {
+    readonly output: readonly {
+        readonly type: 'text';
+        readonly text: string;
+    }[];
+    readonly stopReason: CodexStopReason;
+    /** Images the run produced, for a caller that can deliver them. */
+    readonly images: readonly CodexImage[];
+}
+/** A decoded protocol object. */
+type Record0 = Record<string, unknown>;
+/**
+ * Race one pending operation against a cancellation signal.
+ *
+ * @param pending - the operation.
+ * @param signal - cancellation.
+ * @returns the operation's value.
+ */
+export declare function raceAbort<T>(pending: Promise<T>, signal: AbortSignal | undefined): Promise<T>;
+/** The stream surface the wire reads for lifecycle events. */
+export interface WireInput {
+    on(event: 'error', listener: (error: Error) => void): unknown;
+    on(event: 'end', listener: () => void): unknown;
+    off(event: 'end', listener: () => void): unknown;
+}
+/** The stream surface the wire writes to. */
+export interface WireOutput {
+    on(event: 'error', listener: (error: Error) => void): unknown;
+}
+/**
+ * What one wire needs beyond its transport.
+ *
+ * Bundled rather than positional: the caller's choice set grew past the point
+ * where six positional arguments stayed readable, and every one of them is a
+ * named decision the caller already holds.
+ */
+export interface CodexWireOptions {
+    /** Unattended permission policy for the thread. */
+    readonly permissionMode: CodexPermissionMode;
+    /** Model for `thread/start`, when the caller chose one. */
+    readonly model?: string | undefined;
+    /** How long the thread lives. Defaults to `ephemeral`. */
+    readonly threadMode?: CodexThreadMode | undefined;
+    /**
+     * What the app-server records as the thread's originator.
+     *
+     * This is `initialize`'s `clientInfo.name`, and for a thread to appear in the
+     * Codex desktop application it must be exactly `Codex Desktop` — that client
+     * filters its list by this one value. The default here is therefore that
+     * literal, and overriding it trades desktop visibility for an honest name.
+     */
+    readonly originator?: string | undefined;
+}
+/** The originator the Codex desktop client lists. */
+export declare const DEFAULT_ORIGINATOR = "Codex Desktop";
+/**
+ * One app-server connection and its single ephemeral thread/turn.
+ *
+ * Deliberately exposes no generic request surface: supporting another product
+ * method must first become part of the provider contract.
+ */
+export declare class CodexAppServerWire {
+    #private;
+    constructor(input: WireInput, output: WireOutput, transport: LineTransport, options: CodexWireOptions);
+    /**
+     * Install a progress narrator.
+     *
+     * A delegation can run for minutes, so a caller that reports progress needs
+     * the child's intermediate activity rather than only its final answer. Never
+     * lets a reporter's failure reach the protocol loop.
+     *
+     * @param onProgress - called with one line per notable event.
+     */
+    setProgressReporter(onProgress: (text: string) => void): void;
+    /** Whether protocol output ended before a terminal turn notification. */
+    get endedBeforeTerminal(): boolean;
+    /**
+     * Perform the required initialize/initialized handshake.
+     *
+     * @param signal - cancellation for an unpublished start.
+     */
+    initialize(signal?: AbortSignal): Promise<void>;
+    /**
+     * Create the run's thread and retain its identity.
+     *
+     * `ephemeral` follows this wire's thread mode. The app-server reports the
+     * decision back, and the check below is what proves it honoured the request:
+     * a `persistent` thread that came back ephemeral would be a silent downgrade,
+     * and the caller is about to promise the user a thread they can resume.
+     *
+     * @param cwd - the parent session's workspace.
+     * @param signal - cancellation for an unpublished start.
+     */
+    startThread(cwd: string, signal?: AbortSignal): Promise<void>;
+    /**
+     * Continue an existing thread instead of creating one.
+     *
+     * Codex 0.165+ accepts configuration overrides on `thread/resume`. Parameters
+     * that are present replace the thread's historical values; absent parameters
+     * leave history alone. The response is compared with the requested facts so a
+     * caller never mistakes a requested model, cwd, or permission policy for an
+     * effective one.
+     *
+     * The app-server refuses a thread with no rollout yet, so a thread becomes
+     * resumable only after it has carried one turn.
+     *
+     * @param threadId - the thread to continue, as a previous run reported it.
+     * @param overrides - explicit model/cwd/permission facts to apply.
+     * @param signal - cancellation for an unpublished resume.
+     */
+    resumeThread(threadId: string, overrides?: CodexResumeOverrides, signal?: AbortSignal): Promise<void>;
+    /**
+     * Give the thread a name.
+     *
+     * The name is what a person sees in the Codex application's thread list. It
+     * matters here because a thread this provider creates has to report itself as
+     * `Codex Desktop` to be listed at all, so the name is the only place left to
+     * say that the work came from DSH and what it was. Best effort: a thread that
+     * ran is worth more than a naming failure, so the caller is told rather than
+     * thrown at.
+     *
+     * @param name - the name to record.
+     * @param signal - cancellation for an unpublished request.
+     * @returns whether the app-server accepted it.
+     */
+    setThreadName(name: string, signal?: AbortSignal): Promise<boolean>;
+    /** The images this run produced, in arrival order. */
+    get images(): readonly CodexImage[];
+    /** The thread this wire is working in, once it has one. */
+    get threadId(): string | undefined;
+    /** Authoritative turn id, adopted only after the start response agrees. */
+    get turnId(): string | undefined;
+    /** Conservative request boundary, not inferred from progress or a known PID. */
+    get dispatch(): 'not-dispatched' | 'possible' | 'accepted';
+    /** Token usage attributable to this one delegation; never a zero guess. */
+    get usageReport(): CodexUsageReport;
+    /** Account rate limits, kept separate from token usage. */
+    get rateLimitsReport(): CodexRateLimitsReport;
+    /** The requested and effective configuration of the one start/resume. */
+    get configuration(): AppliedConfiguration | undefined;
+    get turnConfiguration(): TurnConfiguration | undefined;
+    /**
+     * Submit the one text-only task and wait for this thread/turn's terminal
+     * notification.
+     *
+     * @param texts - already validated task text blocks.
+     * @param signal - local cancellation for the published run.
+     * @param effort - per-turn thinking level, if the caller chose one.
+     * @returns the selected output and its stop reason.
+     */
+    runTurn(texts: readonly TaskText[], signal?: AbortSignal, effort?: string, images?: readonly string[], outputSchema?: Record0, lifecycle?: (stage: 'dispatch-intent' | 'dispatch-possible' | 'turn-accepted') => Promise<void>): Promise<WireRunResult>;
+    /** The best non-commentary answer observed so far, preserving exact bytes. */
+    get partialOutput(): readonly {
+        readonly type: 'text';
+        readonly text: string;
+    }[];
+    /**
+     * Best-effort remote cancellation. Local settlement and process teardown stay
+     * authoritative when the child no longer accepts protocol requests.
+     */
+    interrupt(): void;
+    /** The latest safe unattended permission fact observed for this run. */
+    collectDiagnostic(): string | undefined;
+    /** The structured failure fact observed for this published turn. */
+    collectFailure(): CodexFailureFacts | undefined;
+    /** Detach listeners and fail outstanding requests. Idempotent. */
+    close(): void;
+}
+export {};
+//# sourceMappingURL=wire.d.ts.map

package/node_modules/dsh-subagent-codex-pro/lib/types/wire.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wire.d.ts","sourceRoot":"","sources":["../../src/wire.ts"],"names":[],"mappings":"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"}