@agimon-ai/doompi-core 0.0.1-alpha.70

package/dist/types/config.d.mts

@@ -0,0 +1,20 @@
+//#region src/types/config.d.ts
+/**
+ * Cross-package service contract for the immutable configuration snapshot.
+ *
+ * The provider supplies the concrete snapshot and file-config types. Keeping
+ * this contract generic lets independently bundled consumers share the Cordis
+ * service definition without making the contracts package depend on config.
+ */
+export interface IDoomConfigService<TSnapshot = unknown, TFileConfig = unknown> {
+  /** Identifies the currently published session service for stale-work fencing. */
+  readonly generation: string;
+  /** Returns the immutable snapshot currently visible to consumers. */
+  getSnapshot(): TSnapshot;
+  /** Atomically replaces the immutable live snapshot after a successful transition. */
+  replaceSnapshot(snapshot: TSnapshot): TSnapshot;
+  /** Loads the package's file configuration outside the live session snapshot. */
+  load(repoRoot: string, homeDirectory?: string): TFileConfig;
+}
+//#endregion
+//# sourceMappingURL=config.d.mts.map

package/dist/types/config.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.mts","names":[],"sources":["../../src/types/config.ts"],"mappings":";;;;;;;;iBAOiB,mBAAmB,qBAAqB;;WAE9C;;EAET,eAAe;;EAEf,gBAAgB,UAAU,YAAY;;EAEtC,KAAK,kBAAkB,yBAAyB"}

package/dist/types/kernel.d.cts

@@ -0,0 +1,69 @@
+//#region src/types/kernel.d.ts
+/**
+ * Kernel contribution contracts.
+ *
+ * DESIGN PATTERNS:
+ * - One concept: a slot. Tools, commands, resources and hooks are all slots,
+ *   so a new surface costs a `defineSlot` call rather than a new registry.
+ * - Contributions are gated by the layer that owns them. A layer is the unit a
+ *   major mode selects, so recomputing the active union is the whole of a
+ *   major-mode switch.
+ * - Sinks receive the complete active list, never a delta. Whole-list
+ *   replacement makes removal inherent, which is what lets a switch take
+ *   effect without tearing the process down.
+ *
+ * AVOID:
+ * - Host types in this file. The kernel is host-neutral so the Pi facet and
+ *   the headless server facet can share one registry.
+ * - Mutating a contribution after registration. Re-register instead, so the
+ *   recomputed union stays a pure function of the registered set.
+ */
+/** A contribution the kernel may hand to a sink. */
+export interface KernelContribution<TValue> {
+  /** Owning package, for diagnostics and for `contributionsOf`. */
+  readonly source: string;
+  /**
+   * Layer that must be active for this contribution to apply. Omitted means
+   * always active, which is how host-owned contributions opt out of gating.
+   */
+  readonly layer?: string;
+  readonly value: TValue;
+}
+/** Receives the complete active list for one slot whenever it changes. */
+export type KernelSlotSink<TValue> = (active: readonly TValue[]) => void | Promise<void>;
+/** Removes a contribution or a slot. Calling it twice is a no-op. */
+export interface KernelRegistration {
+  dispose(): void;
+}
+export interface KernelSlotHandle<TValue> extends KernelRegistration {
+  readonly name: string;
+  /** Registers a contribution against this slot without naming it again. */
+  contribute(entry: KernelContribution<TValue>): KernelRegistration;
+}
+export interface DoomKernel {
+  /** Layers currently selected by the active major mode. */
+  readonly activeLayers: readonly string[];
+  /** Slot names defined so far, in definition order. */
+  readonly slots: readonly string[];
+  defineSlot<TValue>(name: string, sink: KernelSlotSink<TValue>): KernelSlotHandle<TValue>;
+  contribute<TValue>(slot: string, entry: KernelContribution<TValue>): KernelRegistration;
+  /**
+   * Replaces the active layer set and pushes every affected slot.
+   *
+   * Overlapping calls coalesce: a host converges on the last layer set rather
+   * than replaying each one, so tapping through modes costs one apply.
+   */
+  setActiveLayers(layers: readonly string[]): Promise<void>;
+  /**
+   * Re-pushes a slot whose contribution values now render differently, such as
+   * resources after a domain change. Omit the name to push every slot.
+   */
+  refresh(slot?: string): Promise<void>;
+  /** Active values for one slot, in registration order. Empty if undefined. */
+  activeValues<TValue>(slot: string): readonly TValue[];
+  /** All registered contributions for one slot, including inactive layers. */
+  contributions<TValue>(slot: string): readonly KernelContribution<TValue>[];
+  dispose(): void;
+}
+//#endregion
+//# sourceMappingURL=kernel.d.cts.map

package/dist/types/kernel.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kernel.d.cts","names":[],"sources":["../../src/types/kernel.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;iBAqBiB,mBAAmB;;WAEzB;;;;;WAKA;WACA,OAAO;;;YAIN,eAAe,WAAW,iBAAiB,oBAAoB;;iBAG1D;EACf;;iBAGe,iBAAiB,gBAAgB;WACvC;;EAET,WAAW,OAAO,mBAAmB,UAAU;;iBAGhC;;WAEN;;WAEA;EACT,WAAW,QAAQ,cAAc,MAAM,eAAe,UAAU,iBAAiB;EACjF,WAAW,QAAQ,cAAc,OAAO,mBAAmB,UAAU;;;;;;;EAOrE,gBAAgB,4BAA4B;;;;;EAK5C,QAAQ,gBAAgB;;EAExB,aAAa,QAAQ,wBAAwB;;EAE7C,cAAc,QAAQ,wBAAwB,mBAAmB;EACjE"}

package/dist/types/kernel.d.mts

@@ -0,0 +1,69 @@
+//#region src/types/kernel.d.ts
+/**
+ * Kernel contribution contracts.
+ *
+ * DESIGN PATTERNS:
+ * - One concept: a slot. Tools, commands, resources and hooks are all slots,
+ *   so a new surface costs a `defineSlot` call rather than a new registry.
+ * - Contributions are gated by the layer that owns them. A layer is the unit a
+ *   major mode selects, so recomputing the active union is the whole of a
+ *   major-mode switch.
+ * - Sinks receive the complete active list, never a delta. Whole-list
+ *   replacement makes removal inherent, which is what lets a switch take
+ *   effect without tearing the process down.
+ *
+ * AVOID:
+ * - Host types in this file. The kernel is host-neutral so the Pi facet and
+ *   the headless server facet can share one registry.
+ * - Mutating a contribution after registration. Re-register instead, so the
+ *   recomputed union stays a pure function of the registered set.
+ */
+/** A contribution the kernel may hand to a sink. */
+export interface KernelContribution<TValue> {
+  /** Owning package, for diagnostics and for `contributionsOf`. */
+  readonly source: string;
+  /**
+   * Layer that must be active for this contribution to apply. Omitted means
+   * always active, which is how host-owned contributions opt out of gating.
+   */
+  readonly layer?: string;
+  readonly value: TValue;
+}
+/** Receives the complete active list for one slot whenever it changes. */
+export type KernelSlotSink<TValue> = (active: readonly TValue[]) => void | Promise<void>;
+/** Removes a contribution or a slot. Calling it twice is a no-op. */
+export interface KernelRegistration {
+  dispose(): void;
+}
+export interface KernelSlotHandle<TValue> extends KernelRegistration {
+  readonly name: string;
+  /** Registers a contribution against this slot without naming it again. */
+  contribute(entry: KernelContribution<TValue>): KernelRegistration;
+}
+export interface DoomKernel {
+  /** Layers currently selected by the active major mode. */
+  readonly activeLayers: readonly string[];
+  /** Slot names defined so far, in definition order. */
+  readonly slots: readonly string[];
+  defineSlot<TValue>(name: string, sink: KernelSlotSink<TValue>): KernelSlotHandle<TValue>;
+  contribute<TValue>(slot: string, entry: KernelContribution<TValue>): KernelRegistration;
+  /**
+   * Replaces the active layer set and pushes every affected slot.
+   *
+   * Overlapping calls coalesce: a host converges on the last layer set rather
+   * than replaying each one, so tapping through modes costs one apply.
+   */
+  setActiveLayers(layers: readonly string[]): Promise<void>;
+  /**
+   * Re-pushes a slot whose contribution values now render differently, such as
+   * resources after a domain change. Omit the name to push every slot.
+   */
+  refresh(slot?: string): Promise<void>;
+  /** Active values for one slot, in registration order. Empty if undefined. */
+  activeValues<TValue>(slot: string): readonly TValue[];
+  /** All registered contributions for one slot, including inactive layers. */
+  contributions<TValue>(slot: string): readonly KernelContribution<TValue>[];
+  dispose(): void;
+}
+//#endregion
+//# sourceMappingURL=kernel.d.mts.map

package/dist/types/kernel.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kernel.d.mts","names":[],"sources":["../../src/types/kernel.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;iBAqBiB,mBAAmB;;WAEzB;;;;;WAKA;WACA,OAAO;;;YAIN,eAAe,WAAW,iBAAiB,oBAAoB;;iBAG1D;EACf;;iBAGe,iBAAiB,gBAAgB;WACvC;;EAET,WAAW,OAAO,mBAAmB,UAAU;;iBAGhC;;WAEN;;WAEA;EACT,WAAW,QAAQ,cAAc,MAAM,eAAe,UAAU,iBAAiB;EACjF,WAAW,QAAQ,cAAc,OAAO,mBAAmB,UAAU;;;;;;;EAOrE,gBAAgB,4BAA4B;;;;;EAK5C,QAAQ,gBAAgB;;EAExB,aAAa,QAAQ,wBAAwB;;EAE7C,cAAc,QAAQ,wBAAwB,mBAAmB;EACjE"}

package/dist/types/remote.d.cts

@@ -0,0 +1,124 @@
+//#region src/types/remote.d.ts
+export type RemoteChannelScope = 'session' | 'protocol' | 'http';
+/**
+ * How the tunnel is established.
+ *
+ * `named` carries a hostname rather than discovering one, which is why it is
+ * the mode that supports passkeys, a service worker, and durable pairing: all
+ * three are bound to the origin, and a quick tunnel's hostname rotates on every
+ * start. The token is referenced by path, never stored inline, because it is a
+ * Cloudflare account credential and an inlined one ends up in a bug report.
+ */
+export type TunnelConfig = {
+  kind: 'quick';
+} | {
+  kind: 'named';
+  hostname: string;
+  name?: string;
+  tokenFile?: string;
+  configFile?: string;
+};
+/**
+ * Running the cockpit in a container.
+ *
+ * Tied to remote access rather than offered separately: the reason to contain
+ * the cockpit is that a paired device drives an agent holding a shell, and the
+ * containment only means anything if it is in place before the tunnel is.
+ *
+ * The workspace list is the boundary. A hub inside the container cannot create
+ * a session in a path that is not mounted, so arbitrary-directory spawning is
+ * closed by construction rather than by a check.
+ */
+export interface SandboxSettings {
+  enabled: boolean;
+  /** Absolute host directories the contained cockpit may work in. */
+  workspaces: string[];
+}
+/** Nullable numbers are not used: a disabled toggle keeps its value so flipping it back restores it. */
+export interface RemoteAccessSettings {
+  /** Close the tunnel on a timer. */
+  autoCloseEnabled: boolean;
+  autoCloseMinutes: number;
+  /** Expire paired sessions on idle and on total age. */
+  sessionExpiryEnabled: boolean;
+  idleMinutes: number;
+  absoluteHours: number;
+  tunnel: TunnelConfig;
+  sandbox: SandboxSettings;
+}
+export interface BundlePairingTrust {
+  publicKey: string;
+  fingerprint: string;
+  revision: number;
+}
+export type RemoteAccessStatus = 'off' | 'starting' | 'on' | 'failed';
+export interface PairedDeviceView {
+  id: string;
+  label: string;
+  userAgent: string;
+  /** ISO 8601. */
+  createdAt: string;
+  /** ISO 8601. */
+  lastSeenAt: string;
+  /** True for the device making the request, so the UI can say "this device". */
+  self: boolean;
+}
+export interface PairingRequestView {
+  id: string;
+  userAgent: string;
+  /**
+   * The address Cloudflare's edge reported. Display only: any local process can
+   * reach the tunnel listener directly and set this header to anything, so it
+   * never gates a decision. The UI labels it "reported by the edge".
+   */
+  edgeIp: string;
+  /** ISO 8601. */
+  createdAt: string;
+  /** ISO 8601. */
+  expiresAt: string;
+}
+export interface RemoteAccessStateView {
+  status: RemoteAccessStatus;
+  /** Present once the tunnel reports its hostname. */
+  publicUrl?: string;
+  /** ISO 8601, present while the tunnel is up. */
+  startedAt?: string;
+  /** ISO 8601, absent when auto-close is switched off. */
+  closesAt?: string;
+  /** Why the tunnel failed, once it has. */
+  error?: string;
+  devices: PairedDeviceView[];
+  /** Populated for local callers only; a paired phone must not see approval prompts. */
+  pending: PairingRequestView[];
+  settings: RemoteAccessSettings;
+}
+export type PairingStatus = 'pending' | 'approved' | 'denied' | 'expired' | 'consumed';
+export type TunnelFailure = 'not_installed' | 'spawn_failed' | 'timeout' | 'self_test_failed' | 'exited';
+export interface TunnelStartInput {
+  /** The loopback port the tunnel should publish. */
+  port: number;
+  config: TunnelConfig;
+  /** Arms the exact public origin before the launcher probes through it. */
+  acceptOrigin?: (origin: string) => void;
+  /** Cancels startup and asks the launcher to stop any process it has spawned. */
+  signal?: AbortSignal;
+}
+export type TunnelStartResult = {
+  ok: true;
+  publicOrigin: string;
+  stop: () => Promise<void>;
+} | {
+  ok: false;
+  failure: TunnelFailure;
+  message: string;
+};
+/**
+ * Starting a tunnel, as a port rather than a concrete process.
+ *
+ * Declared here so a test can inject a fake without pulling in the cloudflared
+ * adapter, and so `WebServerOptions` can name the seam without reaching across
+ * a layer to do it.
+ */
+export type TunnelLauncher = (input: TunnelStartInput) => Promise<TunnelStartResult>;
+//#endregion
+//# sourceMappingURL=remote.d.cts.map

package/dist/types/remote.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote.d.cts","names":[],"sources":["../../src/types/remote.ts"],"mappings":";YACY;;;;;;;;;;YAWA;EACN;;EACA;EAAe;EAAkB;EAAe;EAAoB;;;;;;;;;;;;;iBAazD;EACf;;EAEA;;;iBAgBe;;EAEf;EACA;;EAEA;EACA;EACA;EACA,QAAQ;EACR,SAAS;;iBAGM;EACf;EACA;EACA;;YAGU;iBAEK;EACf;EACA;EACA;;EAEA;;EAEA;;EAEA;;iBAGe;EACf;EACA;;;;;;EAMA;;EAEA;;EAEA;;iBAGe;EACf,QAAQ;;EAER;;EAEA;;EAEA;;EAEA;EACA,SAAS;;EAET,SAAS;EACT,UAAU;;YAGA;YAEA;iBAEK;;EAEf;EACA,QAAQ;;EAER,gBAAgB;;EAEhB,SAAS;;YAGC;EACN;EAAU;EAAsB,YAAY;;EAC5C;EAAW,SAAS;EAAe;;;;;;;;;YAS7B,kBAAkB,OAAO,qBAAqB,QAAQ"}

package/dist/types/remote.d.mts

@@ -0,0 +1,124 @@
+//#region src/types/remote.d.ts
+export type RemoteChannelScope = 'session' | 'protocol' | 'http';
+/**
+ * How the tunnel is established.
+ *
+ * `named` carries a hostname rather than discovering one, which is why it is
+ * the mode that supports passkeys, a service worker, and durable pairing: all
+ * three are bound to the origin, and a quick tunnel's hostname rotates on every
+ * start. The token is referenced by path, never stored inline, because it is a
+ * Cloudflare account credential and an inlined one ends up in a bug report.
+ */
+export type TunnelConfig = {
+  kind: 'quick';
+} | {
+  kind: 'named';
+  hostname: string;
+  name?: string;
+  tokenFile?: string;
+  configFile?: string;
+};
+/**
+ * Running the cockpit in a container.
+ *
+ * Tied to remote access rather than offered separately: the reason to contain
+ * the cockpit is that a paired device drives an agent holding a shell, and the
+ * containment only means anything if it is in place before the tunnel is.
+ *
+ * The workspace list is the boundary. A hub inside the container cannot create
+ * a session in a path that is not mounted, so arbitrary-directory spawning is
+ * closed by construction rather than by a check.
+ */
+export interface SandboxSettings {
+  enabled: boolean;
+  /** Absolute host directories the contained cockpit may work in. */
+  workspaces: string[];
+}
+/** Nullable numbers are not used: a disabled toggle keeps its value so flipping it back restores it. */
+export interface RemoteAccessSettings {
+  /** Close the tunnel on a timer. */
+  autoCloseEnabled: boolean;
+  autoCloseMinutes: number;
+  /** Expire paired sessions on idle and on total age. */
+  sessionExpiryEnabled: boolean;
+  idleMinutes: number;
+  absoluteHours: number;
+  tunnel: TunnelConfig;
+  sandbox: SandboxSettings;
+}
+export interface BundlePairingTrust {
+  publicKey: string;
+  fingerprint: string;
+  revision: number;
+}
+export type RemoteAccessStatus = 'off' | 'starting' | 'on' | 'failed';
+export interface PairedDeviceView {
+  id: string;
+  label: string;
+  userAgent: string;
+  /** ISO 8601. */
+  createdAt: string;
+  /** ISO 8601. */
+  lastSeenAt: string;
+  /** True for the device making the request, so the UI can say "this device". */
+  self: boolean;
+}
+export interface PairingRequestView {
+  id: string;
+  userAgent: string;
+  /**
+   * The address Cloudflare's edge reported. Display only: any local process can
+   * reach the tunnel listener directly and set this header to anything, so it
+   * never gates a decision. The UI labels it "reported by the edge".
+   */
+  edgeIp: string;
+  /** ISO 8601. */
+  createdAt: string;
+  /** ISO 8601. */
+  expiresAt: string;
+}
+export interface RemoteAccessStateView {
+  status: RemoteAccessStatus;
+  /** Present once the tunnel reports its hostname. */
+  publicUrl?: string;
+  /** ISO 8601, present while the tunnel is up. */
+  startedAt?: string;
+  /** ISO 8601, absent when auto-close is switched off. */
+  closesAt?: string;
+  /** Why the tunnel failed, once it has. */
+  error?: string;
+  devices: PairedDeviceView[];
+  /** Populated for local callers only; a paired phone must not see approval prompts. */
+  pending: PairingRequestView[];
+  settings: RemoteAccessSettings;
+}
+export type PairingStatus = 'pending' | 'approved' | 'denied' | 'expired' | 'consumed';
+export type TunnelFailure = 'not_installed' | 'spawn_failed' | 'timeout' | 'self_test_failed' | 'exited';
+export interface TunnelStartInput {
+  /** The loopback port the tunnel should publish. */
+  port: number;
+  config: TunnelConfig;
+  /** Arms the exact public origin before the launcher probes through it. */
+  acceptOrigin?: (origin: string) => void;
+  /** Cancels startup and asks the launcher to stop any process it has spawned. */
+  signal?: AbortSignal;
+}
+export type TunnelStartResult = {
+  ok: true;
+  publicOrigin: string;
+  stop: () => Promise<void>;
+} | {
+  ok: false;
+  failure: TunnelFailure;
+  message: string;
+};
+/**
+ * Starting a tunnel, as a port rather than a concrete process.
+ *
+ * Declared here so a test can inject a fake without pulling in the cloudflared
+ * adapter, and so `WebServerOptions` can name the seam without reaching across
+ * a layer to do it.
+ */
+export type TunnelLauncher = (input: TunnelStartInput) => Promise<TunnelStartResult>;
+//#endregion
+//# sourceMappingURL=remote.d.mts.map

package/dist/types/remote.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote.d.mts","names":[],"sources":["../../src/types/remote.ts"],"mappings":";YACY;;;;;;;;;;YAWA;EACN;;EACA;EAAe;EAAkB;EAAe;EAAoB;;;;;;;;;;;;;iBAazD;EACf;;EAEA;;;iBAgBe;;EAEf;EACA;;EAEA;EACA;EACA;EACA,QAAQ;EACR,SAAS;;iBAGM;EACf;EACA;EACA;;YAGU;iBAEK;EACf;EACA;EACA;;EAEA;;EAEA;;EAEA;;iBAGe;EACf;EACA;;;;;;EAMA;;EAEA;;EAEA;;iBAGe;EACf,QAAQ;;EAER;;EAEA;;EAEA;;EAEA;EACA,SAAS;;EAET,SAAS;EACT,UAAU;;YAGA;YAEA;iBAEK;;EAEf;EACA,QAAQ;;EAER,gBAAgB;;EAEhB,SAAS;;YAGC;EACN;EAAU;EAAsB,YAAY;;EAC5C;EAAW,SAAS;EAAe;;;;;;;;;YAS7B,kBAAkB,OAAO,qBAAqB,QAAQ"}

package/dist/types/server/directHarnessRuntime.d.cts

@@ -0,0 +1,156 @@
+import { HistoryOwnership, HistoryOwnershipLease } from "../../history-import.cjs";
+import { Context } from "@earendil-works/chord";
+import { AgentHarness, AgentHarnessOptions, AgentHarnessResources, AgentHarnessTool, AgentLane, AgentMessage, CompactionSettings, Entry, EntryProjector, HarnessEvent, HookMap, QueueMode, Session, SessionStats, ThinkingLevel } from "@earendil-works/pi-agent-core";
+import { Api, CredentialStore, ImageContent, Model, Models, MutableModels, Provider, RetryPolicy, Usage } from "@earendil-works/pi-ai";
+//#region src/types/server/directHarnessRuntime.d.ts
+export interface SqliteSessionStorage {
+  session: Session;
+  sessionFile: string;
+  repository: {
+    close(context: Context): Promise<void>;
+  };
+  historyLease: HistoryOwnershipLease;
+}
+/** The opaque frame shape consumed by the existing server compatibility facade. */
+export type DirectHarnessFrame = Record<string, unknown>;
+export type DirectHarnessModel = Model<Api> | {
+  provider: string;
+  id: string;
+};
+export interface DirectHarnessModelBoundary {
+  phase: 'turn' | 'request';
+  model?: Model<Api>;
+  prompt?: AgentMessage[];
+  resources: AgentHarnessResources;
+}
+export interface DirectHarnessRuntimeOptions<TContext extends object | undefined = object | undefined> {
+  /** Stable session identity. Existing session files are authoritative when omitted. */
+  sessionId?: string;
+  /** Working directory used by NodeExecutionEnv and newly-created sessions. */
+  cwd: string;
+  /** Stable lane identity. Defaults to `main`. */
+  lane?: string;
+  /** Stable host identity exposed to the parent orchestrator. */
+  harnessId?: string;
+  sessionName?: string;
+  /** Injecting a Session is supported for tests and hosts that already own storage. */
+  session?: Session;
+  /** Server hosts select SQLite; terminal hosts retain JSONL. */
+  storage?: 'jsonl' | 'sqlite';
+  /** Existing v4 JSONL session path. Requires historyOwnership for its lifetime. */
+  sessionPath?: string;
+  /** Existing v3 JSONL path. It is never opened for writing. */
+  legacySessionPath?: string;
+  /** Parent identity recorded on newly-created sessions. */
+  parentSessionId?: string;
+  sessionsRoot?: string;
+  /** Required when opening any existing session or importing legacy history. */
+  historyOwnership?: HistoryOwnership;
+  historyOriginalPath?: string;
+  historyStatePath?: string;
+  /** Public pi-ai model/provider/credential registries. */
+  models?: Models | MutableModels;
+  providers?: readonly Provider[];
+  credentials?: CredentialStore;
+  model?: DirectHarnessModel;
+  /** Public AgentHarness tools and resources are explicit, replaceable inputs. */
+  tools?: AgentHarnessTool<TContext>[];
+  resources?: AgentHarnessResources;
+  toolContext?: AgentHarnessOptions<TContext>['toolContext'];
+  systemPrompt?: AgentHarnessOptions<TContext>['systemPrompt'];
+  streamOptions?: AgentHarnessOptions<TContext>['streamOptions'];
+  retry?: RetryPolicy;
+  compaction?: CompactionSettings;
+  thinkingLevel?: ThinkingLevel;
+  activeToolNames?: string[];
+  steeringMode?: QueueMode;
+  followUpMode?: QueueMode;
+  toolExecution?: 'sequential' | 'parallel';
+  toProviderMessages?: AgentHarnessOptions<TContext>['toProviderMessages'];
+  entryProjectors?: Record<string, EntryProjector>;
+  context?: Context;
+  /** Synchronous admission check at the public Models dispatch boundary, before auth/provider work starts. */
+  guardModelRequest?: () => void;
+  beforeModelRequest?: (boundary: DirectHarnessModelBoundary, context: Context) => void | Promise<void>;
+  /** Active AgentHarness execution-hook bridges. */
+  transformContext?: (event: HookMap['transform_context']['event'], context: Context) => HookMap['transform_context']['result'] | Promise<HookMap['transform_context']['result']>;
+  beforePayload?: (event: HookMap['before_payload']['event'], context: Context) => HookMap['before_payload']['result'] | Promise<HookMap['before_payload']['result']>;
+  beforeTool?: (event: HookMap['before_tool']['event'], context: Context) => HookMap['before_tool']['result'] | Promise<HookMap['before_tool']['result']>;
+  afterTool?: (event: HookMap['after_tool']['event'], context: Context) => HookMap['after_tool']['result'] | Promise<HookMap['after_tool']['result']>;
+  beforeCompaction?: (event: HookMap['before_compaction']['event'], context: Context) => HookMap['before_compaction']['result'] | Promise<HookMap['before_compaction']['result']>;
+  /** Active package commands advertised through the compatibility protocol. */
+  listCommands?: () => readonly {
+    name: string;
+    description: string;
+  }[];
+  /** Returns false when the text is not an active package command, preserving normal prompt handling. */
+  dispatchCommand?: (text: string) => Promise<boolean>;
+}
+export interface DirectHarnessEventListener {
+  (event: HarnessEvent, context: Context): void | Promise<void>;
+}
+/** Direct, same-process AgentHarness runtime owned by one session host. */
+export interface DirectHarnessRuntime<TContext extends object | undefined = object | undefined> {
+  readonly sessionId: string;
+  readonly laneName: string;
+  readonly harnessId: string;
+  readonly session: Session;
+  readonly harness: AgentHarness<TContext>;
+  readonly lane: AgentLane;
+  readonly exited: Promise<number>;
+  readonly storageQuarantined: boolean;
+  onPresentationFrame(listener: (frame: DirectHarnessFrame) => void): () => void;
+  onEvent(listener: DirectHarnessEventListener): () => void;
+  stop(): void;
+  readState(): Promise<Record<string, unknown>>;
+  readEntries(): Promise<{
+    entries: Entry[];
+    leafId: string | null;
+  }>;
+  listCommands(): readonly {
+    name: string;
+    description: string;
+  }[];
+  setModel(model: {
+    provider: string;
+    id: string;
+  }): Promise<void>;
+  availableModels(): Promise<readonly Model<Api>[]>;
+  /** Shares the harness dispatch guards with host-owned auxiliary model requests. */
+  completeModel?: Models['complete'];
+  availableThinkingLevels(): Promise<ThinkingLevel[]>;
+  setThinkingLevel(level: ThinkingLevel): Promise<void>;
+  setSteeringMode(mode: QueueMode): Promise<void>;
+  setFollowUpMode(mode: QueueMode): Promise<void>;
+  navigateTree(targetId: string | null, options?: Record<string, unknown>): Promise<{
+    cancelled: boolean;
+    entries: Entry[];
+  }>;
+  clearQueue(): Promise<{
+    steering: never[];
+    followUp: never[];
+  }>;
+  setName(name: string): Promise<void>;
+  getSessionStats(): Promise<SessionStats>;
+  replaceTools(tools: AgentHarnessTool<TContext>[]): Promise<void>;
+  replaceResources(resources: AgentHarnessResources): Promise<void>;
+  readResources(): Promise<AgentHarnessResources>;
+  appendCustomEntry(customType: string, data?: unknown): Promise<string>;
+  recordUsage(usage: Usage, options?: {
+    entryId?: string;
+    details?: import('@earendil-works/pi-agent-core').JsonValue;
+  }): Promise<string>;
+  submitPrompt(text: string, images?: ImageContent[]): Promise<{
+    settled: Promise<void>;
+    handledCommand?: boolean;
+  }>;
+  prompt(text: string, images?: ImageContent[]): Promise<void>;
+  steer(text: string, images?: ImageContent[]): Promise<void>;
+  followUp(text: string, images?: ImageContent[]): Promise<void>;
+  abort(): Promise<void>;
+  compact(customInstructions?: string): Promise<void>;
+  resume(): Promise<void>;
+  dispose(): Promise<void>;
+}
+//#endregion
+//# sourceMappingURL=directHarnessRuntime.d.cts.map

package/dist/types/server/directHarnessRuntime.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"directHarnessRuntime.d.cts","names":[],"sources":["../../../src/types/server/directHarnessRuntime.ts"],"mappings":";;;;;iBAkCiB;EACf,SAAS;EACT;EACA;IAAc,MAAM,SAAS,UAAU;;EACvC,cAAc;;;YAIJ,qBAAqB;YAErB,qBAAqB,MAAM;EAAS;EAAkB;;iBAEjD;EACf;EACA,QAAQ,MAAM;EACd,SAAS;EACT,WAAW;;iBAGI,4BAA4B;;EAE3C;;EAEA;;EAEA;;EAEA;EACA;;EAGA,UAAU;;EAEV;;EAEA;;EAEA;;EAEA;EACA;;EAEA,mBAAmB;EACnB;EACA;;EAGA,SAAS,SAAS;EAClB,qBAAqB;EACrB,cAAc;EACd,QAAQ;;EAGR,QAAQ,iBAAiB;EACzB,YAAY;EACZ,cAAc,oBAAoB;EAClC,eAAe,oBAAoB;EACnC,gBAAgB,oBAAoB;EACpC,QAAQ;EACR,aAAa;EACb,gBAAgB;EAChB;EACA,eAAe;EACf,eAAe;EACf;EACA,qBAAqB,oBAAoB;EACzC,kBAAkB,eAAe;EACjC,UAAU;;EAEV;EACA,sBAAsB,UAAU,4BAA4B,SAAS,mBAAmB;;EAExF,oBACE,OAAO,uCACP,SAAS,YACN,yCAAyC,QAAQ;EACtD,iBACE,OAAO,oCACP,SAAS,YACN,sCAAsC,QAAQ;EACnD,cACE,OAAO,iCACP,SAAS,YACN,mCAAmC,QAAQ;EAChD,aACE,OAAO,gCACP,SAAS,YACN,kCAAkC,QAAQ;EAC/C,oBACE,OAAO,uCACP,SAAS,YACN,yCAAyC,QAAQ;;EAEtD;IAAgC;IAAc;;;EAE9C,mBAAmB,iBAAiB;;iBAGrB;GACd,OAAO,cAAc,SAAS,iBAAiB;;;iBAIjC,qBAAqB;WAC3B;WACA;WACA;WACA,SAAS;WACT,SAAS,aAAa;WACtB,MAAM;WACN,QAAQ;WACR;EAET,oBAAoB,WAAW,OAAO;EACtC,QAAQ,UAAU;EAClB;EAEA,aAAa,QAAQ;EACrB,eAAe;IAAU,SAAS;IAAS;;EAC3C;IAA2B;IAAc;;EACzC,SAAS;IAAS;IAAkB;MAAe;EACnD,mBAAmB,iBAAiB,MAAM;;EAE1C,gBAAgB;EAChB,2BAA2B,QAAQ;EACnC,iBAAiB,OAAO,gBAAgB;EACxC,gBAAgB,MAAM,YAAY;EAClC,gBAAgB,MAAM,YAAY;EAClC,aACE,yBACA,UAAU,0BACT;IAAU;IAAoB,SAAS;;EAC1C,cAAc;IAAU;IAAmB;;EAC3C,QAAQ,eAAe;EACvB,mBAAmB,QAAQ;EAC3B,aAAa,OAAO,iBAAiB,cAAc;EACnD,iBAAiB,WAAW,wBAAwB;EACpD,iBAAiB,QAAQ;EACzB,kBAAkB,oBAAoB,iBAAiB;EACvD,YACE,OAAO,OACP;IAAY;IAAkB,kDAAkD;MAC/E;EACH,aAAa,cAAc,SAAS,iBAAiB;IAAU,SAAS;IAAe;;EACvF,OAAO,cAAc,SAAS,iBAAiB;EAC/C,MAAM,cAAc,SAAS,iBAAiB;EAC9C,SAAS,cAAc,SAAS,iBAAiB;EACjD,SAAS;EACT,QAAQ,8BAA8B;EACtC,UAAU;EACV,WAAW"}