@ckanner/flywheel 0.32.1 → 0.33.0

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

@@ -0,0 +1,266 @@
+/**
+ * A Codex delegation that can carry a model and a reasoning effort.
+ *
+ * ## Why this exists
+ *
+ * `@deepseek-ai/dsh-subagent-codex` declares `NO_START_CAPABILITIES`, so its
+ * `tool-subagent` row cannot enable `modelSelectionSettings` — that requires a
+ * provider declaring `agentOptions`, which the Codex provider does not. The
+ * Codex protocol supports the choices this package exposes: `model` on
+ * `thread/start`, per-turn `effort` on `turn/start`, and model/cwd/permission
+ * overrides on `thread/resume` (0.165+). The official adapter sends none of
+ * them; a thinking level is not a `thread/start` field in 0.165/0.166.
+ *
+ * Enabling the flag on a Codex row of our own provider was tried and did not
+ * work: the row vanished with no tool and no error, while a control row — same
+ * provider, same row, flag off — registered fine. That defect belongs to the
+ * flag, not to the provider, and is reported upstream.
+ *
+ * ## What this does instead
+ *
+ * Two things, both under this package's control:
+ *
+ * 1. **Execution** is a port of the official app-server adapter (`wire.ts`,
+ *    `run.ts`), with `model` on `thread/start`, `effort` on `turn/start`, and
+ *    explicit model/cwd/permission overrides plus effective-config verification
+ *    on `thread/resume`. That is the same protocol the official provider speaks,
+ *    including its initialize handshake, ephemeral thread, unattended approval
+ *    decisions, and terminal-answer selection.
+ * 2. **The tool** is registered on `agent/created` into that Agent's own context
+ *    — the path `dsh-plugin-lcu` uses — so the harness's preset-row machinery
+ *    stays out of the way. `presets` names the presets that get it.
+ *
+ * `model` and `reasoning_effort` appear while this plugin's independent
+ * modelSelection setting is enabled. Codex model ids are not DSH LLM routes.
+ *
+ * @module dsh-subagent-codex-pro
+ */
+import type { Context, SubagentProviderLike, SubagentRunLike, SubagentStartRequestLike } from './dsh-types.ts';
+import type { CodexPermissionMode } from './wire.ts';
+/** Cordis plugin name. */
+export declare const name = "codex-pro";
+/**
+ * The services this plugin cannot work without.
+ *
+ * `subagents` is the provider registry. Everything else — the Agent registry,
+ * the preset registry, the host opt-in — is looked up with `ctx.get`, so a
+ * deployment missing one degrades instead of failing to load.
+ */
+export declare const inject: string[];
+/** Plugin configuration. */
+export interface Config {
+    /** Provider name to register under. Must differ from the official `codex`. */
+    providerName?: string;
+    /** Codex executable; the app-server is started as `<command> app-server --stdio`. */
+    command?: string;
+    /** Default model when a call does not name one. */
+    model?: string;
+    /** Default reasoning effort when a call does not name one. */
+    reasoningEffort?: string;
+    /**
+     * Whether an Agent may name a model and a thinking level for a delegation.
+     *
+     * This plugin's own control, deliberately independent of the Host's
+     * `subagent-model-selection` setting. That setting authorizes a child **LLM
+     * route** chosen from the DSH model catalog and billed as tokens; a Codex
+     * delegation names a **Codex model id** governed by the Codex CLI's own
+     * subscription. The two are different resources with different namespaces, so
+     * the Host's list can neither authorize nor constrain this choice — reading it
+     * would only couple this tool to a setting that has nothing to say about it.
+     *
+     * Defaults to true: being able to name the model is the point of this package.
+     */
+    modelSelection?: boolean;
+    /** Unattended permission policy for the child thread. */
+    permissionMode?: CodexPermissionMode;
+    /** Extra environment entries for the child. */
+    env?: Record<string, string>;
+    /** Agent preset ids whose sessions receive the delegation tool. */
+    presets?: string[];
+    /**
+     * How long a delegated Codex thread lives.
+     *
+     * - `ephemeral` (the default) is a throwaway run: nothing is written that the
+     *   Codex CLI or the Codex application can list afterwards.
+     * - `persistent` gives every delegation its own durable thread, which the Codex
+     *   CLI and application list under the session's working directory and
+     *   `thread_id` can continue.
+     * - `session` reuses one durable thread for the whole Agent session, so a
+     *   session that delegates ten times leaves one thread rather than ten, and
+     *   after the first delegation each call continues the same conversation —
+     *   which keeps the prompt prefix stable and lets the model's cache do its
+     *   work. A call may still override either choice, and pass `thread_id` to
+     *   continue a thread of its own.
+     */
+    threadMode?: 'ephemeral' | 'persistent' | 'session';
+    /**
+     * Deadline for one delegation in milliseconds; `0` disables it.
+     *
+     * A delegation that hangs is otherwise invisible: the job stays `running`, the
+     * session waits, and nothing is logged. The deadline turns that into a failure
+     * with a reason. Defaults to ten minutes, which is generous against a task
+     * class whose own documentation says "a minute or more".
+     */
+    runTimeoutMs?: number;
+    /**
+     * What the app-server records as the thread's originator.
+     *
+     * This is what decides whether the Codex desktop application lists a thread:
+     * that client filters its list to the single value `Codex Desktop`, so the
+     * default here is that literal. Overriding it trades desktop visibility for an
+     * honest name — a thread the application will not show is still listed by the
+     * Codex CLI and still resumable.
+     */
+    originator?: string;
+}
+/**
+ * Check a caller-named deadline.
+ *
+ * A duration, so it must be a whole number of milliseconds: negative and
+ * fractional values have no meaning, and silently rounding one would give a
+ * caller a deadline it did not ask for. `0` is allowed and means no deadline,
+ * which is what the plugin's own configuration uses to disable it.
+ *
+ * @param value - the deadline a call named.
+ * @returns the deadline, unchanged.
+ * @throws when it is not a whole non-negative number of milliseconds.
+ */
+export declare function checkedTimeout(value: number): number;
+/**
+ * Check a caller-named output schema's shape.
+ *
+ * The harness applies the same rule to a schema it passes a provider —
+ * `assertObjectJsonSchema` — so matching it means a schema this tool accepts is
+ * one the harness would too. Only the root is checked: it must be an object with
+ * `type: "object"`, because Codex constrains a whole answer and a bare array or
+ * scalar has nowhere to put the shape.
+ *
+ * @param value - the schema a call named.
+ * @returns the schema, unchanged.
+ * @throws when it is not an object-rooted JSON Schema.
+ */
+export declare function checkedOutputSchema(value: unknown): Record<string, unknown>;
+/**
+ * Check one caller-named image path.
+ *
+ * The path must be absolute and must name a file this plugin could hand the
+ * app-server. Whether it exists is checked where the run is prepared, next to
+ * the check for the working directory, because that is where a real path is.
+ *
+ * @param requested - the path a call named.
+ * @returns the path, unchanged.
+ * @throws when it is not an absolute path.
+ */
+export declare function checkedImagePath(requested: string): string;
+/**
+ * Check a caller-named working directory's shape.
+ *
+ * Only the shape is checked — absolute and non-empty — so the rule is testable
+ * without a filesystem. Whether the path exists and is a directory is checked
+ * where the run is prepared, because that is where a real path matters.
+ *
+ * @param requested - the path a call named.
+ * @returns the path, unchanged.
+ * @throws when it is not an absolute path.
+ */
+export declare function checkedWorkdir(requested: string): string;
+/**
+ * Whether a model route's declared modalities refuse images.
+ *
+ * This is the harness's own rule, and matching it exactly is the point: an image
+ * is refused only when the route **declares** input modalities and `image` is not
+ * among them. An undeclared route is left to the harness, which rejects an
+ * attachment for a model that cannot read it anyway.
+ *
+ * Being stricter cost a real screenshot. The default `deepseek-flash` entry
+ * declares `['text', 'image']`, and an earlier guard here failed closed whenever
+ * the route could not be resolved — which turned every image into a text note in
+ * a session that could have displayed it.
+ *
+ * @param info - the resolved model route, when it could be resolved.
+ * @returns whether the route says it cannot take images.
+ */
+export declare function routeRefusesImages(info: {
+    readonly inputModalities?: readonly string[];
+} | undefined): boolean;
+/**
+ * A line naming where each image is, appended to the text.
+ *
+ * A foreground call carries the pictures as blocks, but a background call's
+ * result is a string by contract — its reader sees this text and nothing else. So
+ * the paths go in the text as well: a screenshot a background delegation took is
+ * still a file on this host, and naming it is the difference between the work
+ * being usable and being lost.
+ *
+ * @param text - the delegation's answer.
+ * @param images - the images the run produced.
+ * @returns the answer with the image line appended.
+ */
+export declare function withImageNote(text: string, images: readonly {
+    readonly path?: string;
+}[]): string;
+/** Tool calls may narrow their configured policy, never expand it implicitly. */
+export declare function resolvePermissionOverride(configured: CodexPermissionMode, requested: CodexPermissionMode | undefined): CodexPermissionMode;
+/**
+ * One delegation to Codex, exposed as a provider the harness can start.
+ *
+ * Exported so the provider adapter can be exercised against the same fake
+ * app-server as the tool path; the plugin's `apply` is its only production
+ * constructor.
+ */
+export declare class CodexExecProvider implements SubagentProviderLike {
+    readonly name: string;
+    readonly inheritsParentContext = false;
+    /**
+     * The declaration that unlocks the delegation tool's model surface.
+     *
+     * `agentOptions: true` is what `tool-subagent` checks before accepting either a
+     * configured `agentOptions` or `modelSelectionSettings: true` on its row.
+     */
+    readonly capabilities: {
+        readonly agentOptions: true;
+        readonly agentPreset: false;
+        readonly outputSchema: true;
+        readonly depthLimit: false;
+    };
+    /**
+     * The resolved configuration.
+     *
+     * A plain field rather than a constructor parameter property: Node's
+     * type-stripping mode rejects that syntax outright, which made this module
+     * unimportable from a test and left its pure helpers untestable.
+     */
+    readonly resolved: Required<Pick<Config, 'command' | 'providerName' | 'permissionMode'>> & Config;
+    constructor(resolved: Required<Pick<Config, 'command' | 'providerName' | 'permissionMode'>> & Config);
+    /**
+     * Start one Codex run over the app-server protocol.
+     *
+     * @param request - the delegation the harness resolved.
+     * @returns a run handle; its `result` settles with the child's final message.
+     */
+    start(request: SubagentStartRequestLike): Promise<SubagentRunLike>;
+}
+/**
+ * Register the provider and the delegation tool.
+ *
+ * @param ctx - context carrying the subagent registry.
+ * @param config - provider name, defaults, and the presets to serve.
+ */
+export declare function apply(ctx: Context, config?: Config): void;
+/**
+ * Append the thread marker to a human-text delegation result.
+ *
+ * A machine-readable answer (one carrying `output_schema`) must stay valid JSON:
+ * appending a marker would make the whole result unparseable. Such a run keeps
+ * its thread id in the result envelope/diagnostic log instead of in the text.
+ *
+ * @param outcome - the finished run.
+ * @param mode - the thread mode the run used.
+ * @param machineOutput - whether the answer is schema-constrained JSON.
+ * @returns the text to report.
+ */
+export declare function withThreadMarker(outcome: {
+    readonly text: string;
+    readonly threadId: string | undefined;
+}, mode: 'ephemeral' | 'persistent', machineOutput: boolean): string;
+//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -0,0 +1,34 @@
+/**
+ * Job settlement for one background delegation.
+ *
+ * The jobs contract is specific and unforgiving: a producer's `done` must
+ * resolve to a `JobOutcome` — `{ status, detail?, result? }` — and it must never
+ * reject. Returning the delegation's text directly leaves a bare string where the
+ * registry expects that record, which then fails validation on *every* read of
+ * the job, so `job_output` **and** `job_list` both report "value is not lossless
+ * JSON" and the model can never collect its own result.
+ *
+ * @module dsh-subagent-codex-pro/jobs
+ */
+/** The settlement record a producer's `done` must resolve to. */
+export interface JobOutcomeLike {
+    readonly status: 'completed' | 'killed' | 'failed';
+    readonly detail?: string;
+    /** The delegation's final message, handed out once by the model's next read. */
+    readonly result?: string;
+}
+/**
+ * Wrap one delegation as a job outcome.
+ *
+ * Never rejects: the contract requires a settlement record even when the work
+ * failed, so a rejection becomes `status: 'failed'` with the reason in `detail`.
+ *
+ * @param delegation - the running delegation's promise, already carrying the
+ * thread marker the runner appended.
+ * @returns the outcome record the jobs registry accepts.
+ */
+export declare function settleJob(delegation: Promise<{
+    readonly text: string;
+    readonly threadId: string | undefined;
+}>): Promise<JobOutcomeLike>;
+//# sourceMappingURL=jobs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"jobs.d.ts","sourceRoot":"","sources":["../../src/jobs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,iEAAiE;AACjE,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,MAAM,EAAE,WAAW,GAAG,QAAQ,GAAG,QAAQ,CAAA;IAClD,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;IACxB,gFAAgF;IAChF,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CACzB;AAED;;;;;;;;;GASG;AACH,wBAAsB,SAAS,CAC7B,UAAU,EAAE,OAAO,CAAC;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAC,GACpF,OAAO,CAAC,cAAc,CAAC,CAUzB"}

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

@@ -0,0 +1,113 @@
+/**
+ * Newline-delimited JSON-RPC 2.0 over a child process's stdio.
+ *
+ * The official Codex provider gets this from
+ * `@deepseek-ai/dsh-sdk-protocol`'s `JsonRpcLineTransport`. This plugin keeps
+ * zero runtime dependencies, so the transport lives here — and it is a small,
+ * well-understood piece: frame by line, correlate by id, surface every failure
+ * instead of leaving a caller pending forever.
+ *
+ * Framing: one JSON object per line, `\n`-terminated, on both directions. A
+ * partial line is buffered; a malformed line is reported and skipped, because a
+ * protocol peer that emits one bad frame should not take the session down.
+ *
+ * @module dsh-subagent-codex-pro/jsonrpc
+ */
+/** One decoded JSON-RPC message. */
+export interface JsonRpcMessage {
+    readonly jsonrpc?: string;
+    readonly id?: number | string;
+    readonly method?: string;
+    readonly params?: unknown;
+    readonly result?: unknown;
+    readonly error?: {
+        readonly code?: number;
+        readonly message?: string;
+        readonly data?: unknown;
+    };
+}
+/** What the owner does with messages that are not responses. */
+export interface TransportHooks {
+    /**
+     * Handle a request from the peer. The resolved value becomes its `result`; a
+     * throw becomes its `error`.
+     *
+     * @param method - the JSON-RPC method.
+     * @param params - its params.
+     * @returns the result to send back.
+     */
+    onRequest?(method: string, params: unknown): Promise<unknown> | unknown;
+    /**
+     * Handle a notification.
+     *
+     * @param method - the JSON-RPC method.
+     * @param params - its params.
+     */
+    onNotification?(method: string, params: unknown): void;
+    /**
+     * Report a transport-level failure (bad frame, write error).
+     *
+     * @param error - what went wrong.
+     */
+    onProblem?(error: Error): void;
+}
+/** The writable side of a transport. */
+export interface TransportWritable {
+    write(chunk: string): unknown;
+}
+/** The readable side of a transport. */
+export interface TransportReadable {
+    on(event: 'data', listener: (chunk: Buffer | string) => void): unknown;
+}
+/** A JSON-RPC peer speaking one object per line. */
+export declare class LineTransport {
+    #private;
+    constructor(toPeer: TransportWritable, fromPeer: TransportReadable, hooks?: TransportHooks);
+    /**
+     * Replace the message hooks.
+     *
+     * The wire installs its handlers after construction, which keeps the transport
+     * independent of the product methods layered on top of it.
+     *
+     * @param hooks - the handlers to install.
+     */
+    setHooks(hooks: TransportHooks): void;
+    /**
+     * Wait until everything written so far has left this process.
+     *
+     * Writes go to the peer's stream synchronously, so there is nothing to drain;
+     * the method exists because the protocol's handshake uses it as an explicit
+     * write barrier between `initialized` and `thread/start`.
+     *
+     * @returns a promise that is already settled.
+     */
+    flush(): Promise<void>;
+    /**
+     * Send one request and await its response.
+     *
+     * @param method - the JSON-RPC method.
+     * @param params - its params.
+     * @param options - optional caller cancellation and a response deadline.
+     * @returns the peer's `result`.
+     */
+    request(method: string, params: unknown, options?: {
+        signal?: AbortSignal | undefined;
+        timeoutMs?: number | undefined;
+    }): Promise<unknown>;
+    /**
+     * Send one notification; nothing is awaited.
+     *
+     * @param method - the JSON-RPC method.
+     * @param params - its params.
+     */
+    notify(method: string, params?: unknown): void;
+    /**
+     * Fail every in-flight request and stop reading.
+     *
+     * @param reason - why the transport is going away.
+     */
+    dispose(reason?: Error): void;
+    /** How many requests are still awaiting a response. */
+    get pendingCount(): number;
+}
+//# sourceMappingURL=jsonrpc.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"jsonrpc.d.ts","sourceRoot":"","sources":["../../src/jsonrpc.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,oCAAoC;AACpC,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IAC7B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,KAAK,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAA;KAAE,CAAA;CAChG;AAED,gEAAgE;AAChE,MAAM,WAAW,cAAc;IAC7B;;;;;;;OAOG;IACH,SAAS,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAA;IACvE;;;;;OAKG;IACH,cAAc,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI,CAAA;IACtD;;;;OAIG;IACH,SAAS,CAAC,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;CAC/B;AAED,wCAAwC;AACxC,MAAM,WAAW,iBAAiB;IAChC,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAA;CAC9B;AAED,wCAAwC;AACxC,MAAM,WAAW,iBAAiB;IAChC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,KAAK,IAAI,GAAG,OAAO,CAAA;CACvE;AAgBD,oDAAoD;AACpD,qBAAa,aAAa;;gBAYZ,MAAM,EAAE,iBAAiB,EAAE,QAAQ,EAAE,iBAAiB,EAAE,KAAK,GAAE,cAAmB;IAS9F;;;;;;;OAOG;IACH,QAAQ,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI;IAIrC;;;;;;;;OAQG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAItB;;;;;;;OAOG;IACH,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAE;QAAE,MAAM,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;KAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IA8C9I;;;;;OAKG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI;IAK9C;;;;OAIG;IACH,OAAO,CAAC,MAAM,QAA2C,GAAG,IAAI;IAUhE,uDAAuD;IACvD,IAAI,YAAY,IAAI,MAAM,CAEzB;CAmEF"}

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

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=machine-cli.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"machine-cli.d.ts","sourceRoot":"","sources":["../../src/machine-cli.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,4 @@
+import { type MachineRequest, type MachineOptions, type MachineReceipt } from './machine.ts';
+/** Private supervisor entry; callers use runMachine so caller death cannot lose cleanup persistence. */
+export declare function runMachineLocal(value: MachineRequest, options?: MachineOptions, id?: string, persistReceipt?: (receipt: MachineReceipt) => void): Promise<MachineReceipt>;
+//# sourceMappingURL=machine-local.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"machine-local.d.ts","sourceRoot":"","sources":["../../src/machine-local.ts"],"names":[],"mappings":"AAIA,OAAO,EAAuB,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,cAAc,CAAA;AAoBjH,wGAAwG;AACxG,wBAAsB,eAAe,CAAC,KAAK,EAAE,cAAc,EAAE,OAAO,GAAE,cAAmB,EAAE,EAAE,GAAE,MAAqB,EAClH,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,IAAI,GAAG,OAAO,CAAC,cAAc,CAAC,CAyF7E"}

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

@@ -0,0 +1,53 @@
+import type { MachineReceipt } from './machine.ts';
+export declare const MACHINE_LIFECYCLE_VERSION: 1;
+export declare const MACHINE_LIFECYCLE_CAPABILITIES: Readonly<{
+    version: 1;
+    durableJournal: true;
+    readOnlyRecovery: true;
+    threadReadyBeforeDispatch: true;
+}>;
+export interface MachineLifecycleEvent {
+    readonly lifecycleVersion: 1;
+    readonly type: 'lifecycle';
+    readonly requestId: string;
+    readonly runId: string;
+    readonly sequence: number;
+    readonly event: 'thread-ready' | 'dispatch-intent' | 'dispatch-possible' | 'turn-accepted' | 'terminal' | 'cleanup-confirmed';
+    readonly threadId: string | null;
+    readonly turnId: string | null;
+    /** Requested history mode; thread-ready configuration carries the backend evidence. */
+    readonly persistent: boolean;
+    readonly configuration: Readonly<Record<string, unknown>> | null;
+    readonly dispatch: 'not-dispatched' | 'possible' | 'accepted';
+    readonly outcome: 'unknown' | 'completed' | 'failed' | 'cancelled';
+    readonly cleanupConfirmed: boolean;
+}
+export interface MachineRecoveryRequest {
+    readonly protocol: 1;
+    readonly requestId: string;
+    readonly runId: string;
+    readonly recoveryDirectory: string;
+}
+export interface MachineRecoveryReceipt {
+    readonly protocol: 1;
+    readonly type: 'recovery';
+    readonly requestId: string;
+    readonly runId: string;
+    readonly status: 'terminal' | 'pending' | 'unknown';
+    readonly receipt: MachineReceipt | null;
+    readonly lifecycle: MachineLifecycleEvent | null;
+    readonly reason: string;
+}
+/** A recovery path is deliberately not a search root, an alias or a symlink. */
+export declare function validateRecoveryDirectory(value: unknown, existing?: boolean): asserts value is string;
+export declare function validLifecycle(value: unknown, requestId: string, runId: string): value is MachineLifecycleEvent;
+/** One writer, exclusive directory admission, atomic replacement and directory fsync. */
+export declare class MachineJournal {
+    #private;
+    constructor(directory: string, requestId: string, runId: string);
+    lifecycle(event: MachineLifecycleEvent): void;
+    receipt(receipt: MachineReceipt): void;
+}
+/** Read exactly one owned journal. Never starts a process, contacts a model or changes files. */
+export declare function recoverMachine(value: MachineRecoveryRequest): Promise<MachineRecoveryReceipt>;
+//# sourceMappingURL=machine-recovery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"machine-recovery.d.ts","sourceRoot":"","sources":["../../src/machine-recovery.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAElD,eAAO,MAAM,yBAAyB,EAAG,CAAU,CAAA;AACnD,eAAO,MAAM,8BAA8B;;;;;EAEzC,CAAA;AAEF,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,gBAAgB,EAAE,CAAC,CAAA;IAC5B,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,KAAK,EAAE,cAAc,GAAG,iBAAiB,GAAG,mBAAmB,GAAG,eAAe,GAAG,UAAU,GAAG,mBAAmB,CAAA;IAC7H,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;IAC9B,uFAAuF;IACvF,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAA;IAC5B,QAAQ,CAAC,aAAa,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,IAAI,CAAA;IAChE,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,GAAG,UAAU,GAAG,UAAU,CAAA;IAC7D,QAAQ,CAAC,OAAO,EAAE,SAAS,GAAG,WAAW,GAAG,QAAQ,GAAG,WAAW,CAAA;IAClE,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAA;CACnC;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAA;IACpB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAA;CACnC;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAA;IACpB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,MAAM,EAAE,UAAU,GAAG,SAAS,GAAG,SAAS,CAAA;IACnD,QAAQ,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,CAAA;IACvC,QAAQ,CAAC,SAAS,EAAE,qBAAqB,GAAG,IAAI,CAAA;IAChD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AAaD,gFAAgF;AAChF,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,UAAQ,GAAG,OAAO,CAAC,KAAK,IAAI,MAAM,CAYnG;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,qBAAqB,CAe/G;AAeD,yFAAyF;AACzF,qBAAa,cAAc;;gBAGb,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAU/D,SAAS,CAAC,KAAK,EAAE,qBAAqB,GAAG,IAAI;IAM7C,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI;CAmBvC;AAED,iGAAiG;AACjG,wBAAsB,cAAc,CAAC,KAAK,EAAE,sBAAsB,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAiCnG"}

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

@@ -0,0 +1,8 @@
+import type { MachineOptions, MachineReceipt, MachineRequest } from './machine.ts';
+export interface MachineHostOptions {
+    readonly env: Readonly<Record<string, string | undefined>>;
+    readonly recoveryDirectory?: string;
+}
+/** This promise rejects on incomplete evidence; it never fabricates a successful receipt. */
+export declare function superviseMachine(request: MachineRequest, options: MachineOptions): Promise<MachineReceipt>;
+//# sourceMappingURL=machine-supervision.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"machine-supervision.d.ts","sourceRoot":"","sources":["../../src/machine-supervision.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAGlF,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,CAAA;IAC1D,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAA;CACpC;AAED,6FAA6F;AAC7F,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC,CA0FhH"}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=machine-supervisor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"machine-supervisor.d.ts","sourceRoot":"","sources":["../../src/machine-supervisor.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,70 @@
+import type { CodexRunFailure, CodexRunOutcome } from './run.ts';
+import { type MachineLifecycleEvent } from './machine-recovery.ts';
+export { MACHINE_LIFECYCLE_VERSION, MACHINE_LIFECYCLE_CAPABILITIES, recoverMachine } from './machine-recovery.ts';
+export type { MachineLifecycleEvent, MachineRecoveryRequest, MachineRecoveryReceipt } from './machine-recovery.ts';
+export declare const MACHINE_PROTOCOL_VERSION: 1;
+/** Caller input contains no credentials. Child authentication stays in its environment. */
+export interface MachineRequest {
+    readonly protocol: 1;
+    readonly requestId: string;
+    readonly prompt: string;
+    readonly cwd: string;
+    readonly model: string;
+    readonly effort: string;
+    readonly permissionMode: 'read-only' | 'workspace-write' | 'dangerously-bypass-approvals-and-sandbox';
+    readonly command?: string;
+    readonly timeoutMs?: number;
+    readonly maxOutputBytes?: number;
+    readonly threadMode?: 'ephemeral' | 'persistent';
+    readonly threadId?: string;
+    readonly images?: readonly string[];
+    readonly outputSchema?: Record<string, unknown>;
+}
+export interface MachineOptions {
+    readonly signal?: AbortSignal;
+    readonly env?: Readonly<Record<string, string>>;
+    readonly onProgress?: (text: string) => void;
+    /** Returning resolves the caller's durable checkpoint ACK. Rejection stops dispatch. */
+    readonly onLifecycle?: (event: MachineLifecycleEvent) => Promise<void> | void;
+    /** A NEW private directory; its canonical parent must already exist. Never reused. */
+    readonly recoveryDirectory?: string;
+}
+/** The result is not mixed into the model's structured answer or human thread marker. */
+export interface MachineReceipt {
+    readonly protocol: 1;
+    readonly type: 'result';
+    readonly requestId: string;
+    readonly runId: string;
+    readonly ok: boolean;
+    readonly requested: {
+        readonly cwd: string;
+        readonly model: string;
+        readonly effort: string;
+        readonly permissionMode: MachineRequest['permissionMode'];
+        readonly threadId: string | null;
+    };
+    readonly outcome: CodexRunOutcome | null;
+    readonly failure: {
+        readonly stage: string;
+        readonly category: string;
+        readonly diagnostic: string;
+        readonly execution: CodexRunFailure['execution'] | null;
+        readonly configuration: CodexRunFailure['configuration'] | null;
+        readonly usage: CodexRunFailure['usage'] | null;
+        readonly rateLimits: CodexRunFailure['rateLimits'] | null;
+        readonly turnConfiguration: CodexRunFailure['turnConfiguration'] | null;
+        readonly cleanup: CodexRunFailure['cleanup'] | null;
+    } | null;
+    readonly costUSD: null;
+    readonly costStatus: 'unknown';
+}
+export declare class MachineInputError extends Error {
+    readonly code = "INVALID_REQUEST";
+    constructor(message: string);
+}
+/** Validate before starting any process; unknown options never silently disappear. */
+export declare function parseMachineRequest(value: unknown): MachineRequest;
+/** A machine run never invents an exit code, usage, effective effort, or dollar cost. */
+export declare function runMachine(value: MachineRequest, options?: MachineOptions): Promise<MachineReceipt>;
+export type { CodexRunOutcome } from './run.ts';
+//# sourceMappingURL=machine.d.ts.map

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

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

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

@@ -0,0 +1,22 @@
+/**
+ * Private POSIX group guardian for one Codex app-server.
+ *
+ * The caller creates this process as a group leader and establishes the IPC
+ * lifeline in the same spawn operation. Codex inherits this group, but never
+ * the IPC descriptor. An abruptly killed caller therefore closes the lifeline
+ * even if Codex is hung, before or after initialization. The guardian then
+ * terminates only its own group with a finite TERM/KILL sequence.
+ *
+ * A live caller can request a normal stop with SIGTERM/SIGINT. In that case the
+ * caller keeps ownership and confirms the group itself, so this process exits
+ * as soon as the app-server exits instead of making every normal delegation
+ * sleep the whole dispose grace. A caller death (IPC disconnect) keeps the
+ * full grace: there the guardian is the last group owner and must clean up
+ * descendants that outlive the app-server.
+ *
+ * Normal cleanup is confirmed by the surviving caller with kill(-pgid, 0).
+ * Emergency cleanup cannot write a final receipt after killing this guardian;
+ * missing app-server exit facts must remain unknown in the caller's receipt.
+ */
+export {};
+//# sourceMappingURL=process-guardian.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"process-guardian.d.ts","sourceRoot":"","sources":["../../src/process-guardian.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG"}