omegon 0.8.3 → 0.9.0

package/node_modules/undici-types/webidl.d.ts

@@ -1,5 +1,4 @@
 // These types are not exported, and are only used internally
-import * as undici from './index'
 
 /**
  * Take in an unknown value and return one that is of type T
@@ -10,13 +9,15 @@ type SequenceConverter<T> = (object: unknown, iterable?: IterableIterator<T>) =>
 
 type RecordConverter<K extends string, V> = (object: unknown) => Record<K, V>
 
+interface ConvertToIntOpts {
+  clamp?: boolean
+  enforceRange?: boolean
+}
+
 interface WebidlErrors {
-  /**
-   * @description Instantiate an error
-   */
   exception (opts: { header: string, message: string }): TypeError
   /**
-   * @description Instantiate an error when conversion from one type to another has failed
+   * @description Throw an error when conversion from one type to another has failed
    */
   conversionFailed (opts: {
     prefix: string
@@ -33,24 +34,11 @@ interface WebidlErrors {
   }): TypeError
 }
 
-interface WebIDLTypes {
-  UNDEFINED: 1,
-  BOOLEAN: 2,
-  STRING: 3,
-  SYMBOL: 4,
-  NUMBER: 5,
-  BIGINT: 6,
-  NULL: 7
-  OBJECT: 8
-}
-
 interface WebidlUtil {
   /**
    * @see https://tc39.es/ecma262/#sec-ecmascript-data-types-and-values
    */
-  Type (object: unknown): WebIDLTypes[keyof WebIDLTypes]
-
-  TypeValueToString (o: unknown):
+  Type (object: unknown):
     | 'Undefined'
     | 'Boolean'
     | 'String'
@@ -60,8 +48,6 @@ interface WebidlUtil {
     | 'Null'
     | 'Object'
 
-  Types: WebIDLTypes
-
   /**
    * @see https://webidl.spec.whatwg.org/#abstract-opdef-converttoint
    */
@@ -69,11 +55,11 @@ interface WebidlUtil {
     V: unknown,
     bitLength: number,
     signedness: 'signed' | 'unsigned',
-    flags?: number
+    opts?: ConvertToIntOpts
   ): number
 
   /**
-   * @see https://webidl.spec.whatwg.org/#abstract-opdef-integerpart
+   * @see https://webidl.spec.whatwg.org/#abstract-opdef-converttoint
    */
   IntegerPart (N: number): number
 
@@ -82,24 +68,20 @@ interface WebidlUtil {
    */
   Stringify (V: any): string
 
-  MakeTypeAssertion <I>(I: I): (arg: any) => arg is I
-
   /**
    * Mark a value as uncloneable for Node.js.
    * This is only effective in some newer Node.js versions.
    */
   markAsUncloneable (V: any): void
-
-  IsResizableArrayBuffer (V: ArrayBufferLike): boolean
-
-  HasFlag (flag: number, attributes: number): boolean
 }
 
 interface WebidlConverters {
   /**
    * @see https://webidl.spec.whatwg.org/#es-DOMString
    */
-  DOMString (V: unknown, prefix: string, argument: string, flags?: number): string
+  DOMString (V: unknown, prefix: string, argument: string, opts?: {
+    legacyNullToEmptyString: boolean
+  }): string
 
   /**
    * @see https://webidl.spec.whatwg.org/#es-ByteString
@@ -139,140 +121,59 @@ interface WebidlConverters {
   /**
    * @see https://webidl.spec.whatwg.org/#es-unsigned-short
    */
-  ['unsigned short'] (V: unknown, flags?: number): number
+  ['unsigned short'] (V: unknown, opts?: ConvertToIntOpts): number
 
   /**
    * @see https://webidl.spec.whatwg.org/#idl-ArrayBuffer
    */
-  ArrayBuffer (
-    V: unknown,
-    prefix: string,
-    argument: string,
-    options?: { allowResizable: boolean }
-  ): ArrayBuffer
-
-  /**
-   * @see https://webidl.spec.whatwg.org/#idl-SharedArrayBuffer
-   */
-  SharedArrayBuffer (
-    V: unknown,
-    prefix: string,
-    argument: string,
-    options?: { allowResizable: boolean }
-  ): SharedArrayBuffer
+  ArrayBuffer (V: unknown): ArrayBufferLike
+  ArrayBuffer (V: unknown, opts: { allowShared: false }): ArrayBuffer
 
   /**
    * @see https://webidl.spec.whatwg.org/#es-buffer-source-types
    */
   TypedArray (
     V: unknown,
-    T: new () => NodeJS.TypedArray,
-    prefix: string,
-    argument: string,
-    flags?: number
-  ): NodeJS.TypedArray
-
-  /**
-   * @see https://webidl.spec.whatwg.org/#es-buffer-source-types
-   */
-  DataView (
+    TypedArray: NodeJS.TypedArray | ArrayBufferLike
+  ): NodeJS.TypedArray | ArrayBufferLike
+  TypedArray (
     V: unknown,
-    prefix: string,
-    argument: string,
-    flags?: number
-  ): DataView
+    TypedArray: NodeJS.TypedArray | ArrayBufferLike,
+    opts?: { allowShared: false }
+  ): NodeJS.TypedArray | ArrayBuffer
 
   /**
    * @see https://webidl.spec.whatwg.org/#es-buffer-source-types
    */
-  ArrayBufferView (
-    V: unknown,
-    prefix: string,
-    argument: string,
-    flags?: number
-  ): NodeJS.ArrayBufferView
+  DataView (V: unknown, opts?: { allowShared: boolean }): DataView
 
   /**
    * @see https://webidl.spec.whatwg.org/#BufferSource
    */
   BufferSource (
     V: unknown,
-    prefix: string,
-    argument: string,
-    flags?: number
-  ): ArrayBuffer | NodeJS.ArrayBufferView
-
-  /**
-   * @see https://webidl.spec.whatwg.org/#AllowSharedBufferSource
-   */
-  AllowSharedBufferSource (
-    V: unknown,
-    prefix: string,
-    argument: string,
-    flags?: number
-  ): ArrayBuffer | SharedArrayBuffer | NodeJS.ArrayBufferView
+    opts?: { allowShared: boolean }
+  ): NodeJS.TypedArray | ArrayBufferLike | DataView
 
   ['sequence<ByteString>']: SequenceConverter<string>
-
+  
   ['sequence<sequence<ByteString>>']: SequenceConverter<string[]>
 
   ['record<ByteString, ByteString>']: RecordConverter<string, string>
 
-  /**
-  * @see https://fetch.spec.whatwg.org/#requestinfo
-  */
-  RequestInfo (V: unknown): undici.Request | string
-
-  /**
-   * @see https://fetch.spec.whatwg.org/#requestinit
-   */
-  RequestInit (V: unknown): undici.RequestInit
-
-  /**
-   * @see https://html.spec.whatwg.org/multipage/webappapis.html#eventhandlernonnull
-   */
-  EventHandlerNonNull (V: unknown): Function | null
-
-  WebSocketStreamWrite (V: unknown): ArrayBuffer | NodeJS.TypedArray | string
-
   [Key: string]: (...args: any[]) => unknown
 }
 
-type WebidlIsFunction<T> = (arg: any) => arg is T
-
-interface WebidlIs {
-  Request: WebidlIsFunction<undici.Request>
-  Response: WebidlIsFunction<undici.Response>
-  ReadableStream: WebidlIsFunction<ReadableStream>
-  Blob: WebidlIsFunction<Blob>
-  URLSearchParams: WebidlIsFunction<URLSearchParams>
-  File: WebidlIsFunction<File>
-  FormData: WebidlIsFunction<undici.FormData>
-  URL: WebidlIsFunction<URL>
-  WebSocketError: WebidlIsFunction<undici.WebSocketError>
-  AbortSignal: WebidlIsFunction<AbortSignal>
-  MessagePort: WebidlIsFunction<MessagePort>
-  USVString: WebidlIsFunction<string>
-  /**
-   * @see https://webidl.spec.whatwg.org/#BufferSource
-   */
-  BufferSource: WebidlIsFunction<ArrayBuffer | NodeJS.TypedArray>
-}
-
 export interface Webidl {
   errors: WebidlErrors
   util: WebidlUtil
   converters: WebidlConverters
-  is: WebidlIs
-  attributes: WebIDLExtendedAttributes
 
   /**
    * @description Performs a brand-check on {@param V} to ensure it is a
    * {@param cls} object.
    */
-  brandCheck <Interface extends new () => unknown>(V: unknown, cls: Interface): asserts V is Interface
-
-  brandCheckMultiple <Interfaces extends (new () => unknown)[]> (list: Interfaces): (V: any) => asserts V is Interfaces[number]
+  brandCheck <Interface>(V: unknown, cls: Interface, opts?: { strict?: boolean }): asserts V is Interface
 
   /**
    * @see https://webidl.spec.whatwg.org/#es-sequence
@@ -295,11 +196,10 @@ export interface Webidl {
    * Similar to {@link Webidl.brandCheck} but allows skipping the check if third party
    * interfaces are allowed.
    */
-  interfaceConverter <Interface>(typeCheck: WebidlIsFunction<Interface>, name: string): (
+  interfaceConverter <Interface>(cls: Interface): (
     V: unknown,
-    prefix: string,
-    argument: string
-  ) => asserts V is Interface
+    opts?: { strict: boolean }
+  ) => asserts V is typeof cls
 
   // TODO(@KhafraDev): a type could likely be implemented that can infer the return type
   // from the converters given?
@@ -326,16 +226,3 @@ export interface Webidl {
 
   argumentLengthCheck (args: { length: number }, min: number, context: string): void
 }
-
-interface WebIDLExtendedAttributes {
-  /** https://webidl.spec.whatwg.org/#Clamp */
-  Clamp: number
-  /** https://webidl.spec.whatwg.org/#EnforceRange */
-  EnforceRange: number
-  /** https://webidl.spec.whatwg.org/#AllowShared */
-  AllowShared: number
-  /** https://webidl.spec.whatwg.org/#AllowResizable */
-  AllowResizable: number
-  /** https://webidl.spec.whatwg.org/#LegacyNullToEmptyString */
-  LegacyNullToEmptyString: number
-}

package/node_modules/undici-types/websocket.d.ts

@@ -1,8 +1,7 @@
 /// <reference types="node" />
 
-import type { Blob } from 'node:buffer'
-import type { ReadableStream, WritableStream } from 'node:stream/web'
-import type { MessagePort } from 'node:worker_threads'
+import type { Blob } from 'buffer'
+import type { MessagePort } from 'worker_threads'
 import {
   EventInit,
   EventListenerOptions,
@@ -23,7 +22,7 @@ interface WebSocketEventMap {
 
 interface WebSocket extends EventTarget {
   binaryType: BinaryType
-
+  
   readonly bufferedAmount: number
   readonly extensions: string
 
@@ -96,16 +95,16 @@ interface MessageEventInit<T = any> extends EventInit {
   data?: T
   lastEventId?: string
   origin?: string
-  ports?: MessagePort[]
-  source?: MessagePort | null
+  ports?: (typeof MessagePort)[]
+  source?: typeof MessagePort | null
 }
 
 interface MessageEvent<T = any> extends Event {
   readonly data: T
   readonly lastEventId: string
   readonly origin: string
-  readonly ports: readonly MessagePort[]
-  readonly source: MessagePort | null
+  readonly ports: ReadonlyArray<typeof MessagePort>
+  readonly source: typeof MessagePort | null
   initMessageEvent(
     type: string,
     bubbles?: boolean,
@@ -113,8 +112,8 @@ interface MessageEvent<T = any> extends Event {
     data?: any,
     origin?: string,
     lastEventId?: string,
-    source?: MessagePort | null,
-    ports?: MessagePort[]
+    source?: typeof MessagePort | null,
+    ports?: (typeof MessagePort)[]
   ): void;
 }
 
@@ -136,7 +135,7 @@ interface ErrorEvent extends Event {
   readonly filename: string
   readonly lineno: number
   readonly colno: number
-  readonly error: Error
+  readonly error: any
 }
 
 export declare const ErrorEvent: {
@@ -149,38 +148,3 @@ interface WebSocketInit {
   dispatcher?: Dispatcher,
   headers?: HeadersInit
 }
-
-interface WebSocketStreamOptions {
-  protocols?: string | string[]
-  signal?: AbortSignal
-}
-
-interface WebSocketCloseInfo {
-  closeCode: number
-  reason: string
-}
-
-interface WebSocketStream {
-  closed: Promise<WebSocketCloseInfo>
-  opened: Promise<{
-    extensions: string
-    protocol: string
-    readable: ReadableStream
-    writable: WritableStream
-  }>
-  url: string
-}
-
-export declare const WebSocketStream: {
-  prototype: WebSocketStream
-  new (url: string | URL, options?: WebSocketStreamOptions): WebSocketStream
-}
-
-interface WebSocketError extends Event, WebSocketCloseInfo {}
-
-export declare const WebSocketError: {
-  prototype: WebSocketError
-  new (type: string, init?: WebSocketCloseInfo): WebSocketError
-}
-
-export declare const ping: (ws: WebSocket, body?: Buffer) => void

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "omegon",
-	"version": "0.8.3",
+	"version": "0.9.0",
 	"description": "Omegon — an opinionated distribution of pi (by Mario Zechner) with extensions for lifecycle management, memory, orchestration, and visualization",
 	"bin": {
 		"omegon": "bin/omegon.mjs",
@@ -99,6 +99,7 @@
 		"better-sqlite3": "^12.6.2"
 	},
 	"devDependencies": {
+		"@types/node": "^22.0.0",
 		"typescript": "^5.9.3"
 	}
 }

package/skills/cleave/SKILL.md

@@ -173,6 +173,55 @@ Skills can hint at the model complexity needed. The resolution order is:
 3. Skill-based tier hint (highest `preferredTier` wins)
 4. Default: sonnet
 
+## Child Dispatch: RPC Mode (Phase 1)
+
+Since Phase 1 of cleave-process-tree, child processes are spawned in **RPC mode**
+(`--mode rpc --no-session`) by default. This replaces the legacy pipe mode for
+task execution while keeping pipe mode for adversarial review.
+
+### How It Works
+
+1. The dispatcher spawns the child with `--mode rpc --no-session`
+2. The task prompt is sent as a JSON command on stdin via `sendRpcCommand()`
+3. The child emits structured JSON events on stdout (one per line, JSONL framing)
+4. Events are parsed by `parseRpcEventStream()` and mapped to `RpcProgressUpdate`
+5. Progress updates drive the dashboard in real time (tool starts, lifecycle, errors)
+
+### Key Types
+
+- **`RpcChildEvent`** — Union of all structured events from the child (agent/turn/message
+  lifecycle, tool execution, compaction, retry, pipe_closed sentinel)
+- **`RpcProgressUpdate`** — Dashboard-friendly summary: `{ kind, summary, toolName? }`
+
+### The `useRpc` Flag
+
+`spawnChild()` accepts `useRpc?: boolean` (default: `true`).
+- **`true`** → RPC mode with structured event streaming and dashboard progress
+- **`false`** → Legacy pipe mode with debounced last-line output
+
+### Pipe-Mode Fallback
+
+Adversarial review (`review.ts`) continues to use **pipe mode**. RPC mode is used
+only for task execution dispatch. If RPC stdout breaks mid-stream, the parser emits
+a synthetic `pipe_closed` event for graceful degradation.
+
+### Task File Contract
+
+The task file format (`tasks.md`) is **unchanged** by RPC mode. OpenSpec task parsing,
+dependency markers, spec-domain annotations, and skill annotations all work exactly
+as before. RPC mode changes only the coordination channel between dispatcher and child,
+not the planning or task contract layer.
+
+### Phase 1 vs Phase 2
+
+| Capability | Phase 1 (current) | Phase 2 (future) |
+|------------|-------------------|-------------------|
+| Dispatch mode | RPC for tasks, pipe for review | RPC for both |
+| Event streaming | Structured JSON on stdout | Same |
+| Dashboard progress | Real-time tool/lifecycle updates | + resource metrics |
+| Graceful degradation | pipe_closed sentinel | + reconnect |
+| Process tree control | spawn + timeout | + pause/resume/cancel |
+
 ## Architecture
 
 ```
@@ -182,15 +231,26 @@ extensions/cleave/
   planner.ts      — LLM prompt builder, JSON plan parser, wave computation
   openspec.ts     — OpenSpec tasks.md parser → ChildPlan[] conversion
   dispatcher.ts   — Child process dispatch, AsyncSemaphore, wave execution
-  review.ts       — Adversarial review loop, severity gating, churn detection
+  rpc-child.ts    — RPC child communication: JSON framing, event parsing, progress mapping
+  review.ts       — Adversarial review loop, severity gating, churn detection (pipe mode)
   skills.ts       — Skill matching, resolution, model tier hints
   conflicts.ts    — 4-step conflict detection (file overlap, decision
                     contradiction, interface mismatch, assumption violation)
   workspace.ts    — Workspace management under ~/.pi/cleave/
   worktree.ts     — Git worktree create/merge/cleanup under ~/.pi/cleave/wt/
-  types.ts        — Shared type definitions
+  types.ts        — Shared type definitions (includes RpcChildEvent, RpcProgressUpdate)
 ```
 
+### Coordination Channel
+
+The dispatcher uses RPC mode as the primary coordination channel between the parent
+cleave process and child agent processes. Communication is bidirectional:
+
+- **Parent → Child**: JSON commands on stdin (`sendRpcCommand`, `buildPromptCommand`)
+- **Child → Parent**: Structured JSONL events on stdout (`parseRpcEventStream`)
+- **Progress**: Events are mapped to `RpcProgressUpdate` via `mapEventToProgress()`
+  and forwarded to the dashboard via `emitCleaveChildProgress()`
+
 ## Workspace Layout
 
 Workspaces and worktrees live outside the target repo:

package/node_modules/@types/node/inspector/promises.d.ts

@@ -1,41 +0,0 @@
-/**
- * The `node:inspector/promises` module provides an API for interacting with the V8
- * inspector.
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/inspector/promises.js)
- * @since v19.0.0
- */
-declare module "node:inspector/promises" {
-    import { EventEmitter } from "node:events";
-    export { close, console, NetworkResources, open, url, waitForDebugger } from "node:inspector";
-    /**
-     * The `inspector.Session` is used for dispatching messages to the V8 inspector
-     * back-end and receiving message responses and notifications.
-     * @since v19.0.0
-     */
-    export class Session extends EventEmitter {
-        /**
-         * Create a new instance of the inspector.Session class.
-         * The inspector session needs to be connected through `session.connect()` before the messages can be dispatched to the inspector backend.
-         */
-        constructor();
-        /**
-         * Connects a session to the inspector back-end.
-         */
-        connect(): void;
-        /**
-         * Connects a session to the inspector back-end.
-         * An exception will be thrown if this API was not called on a Worker thread.
-         * @since v12.11.0
-         */
-        connectToMainThread(): void;
-        /**
-         * Immediately close the session. All pending message callbacks will be called with an error.
-         * `session.connect()` will need to be called to be able to send messages again.
-         * Reconnected session will lose all inspector state, such as enabled agents or configured breakpoints.
-         */
-        disconnect(): void;
-    }
-}
-declare module "inspector/promises" {
-    export * from "node:inspector/promises";
-}

package/node_modules/@types/node/path/posix.d.ts

@@ -1,8 +0,0 @@
-declare module "node:path/posix" {
-    import path = require("node:path");
-    export = path.posix;
-}
-declare module "path/posix" {
-    import path = require("path");
-    export = path.posix;
-}

package/node_modules/@types/node/path/win32.d.ts

@@ -1,8 +0,0 @@
-declare module "node:path/win32" {
-    import path = require("node:path");
-    export = path.win32;
-}
-declare module "path/win32" {
-    import path = require("path");
-    export = path.win32;
-}