@methodts/runtime 0.1.0

package/dist/ports/cross-app-invoker.d.ts

@@ -0,0 +1,198 @@
+/**
+ * CrossAppInvoker — transport-free port for cross-app strategy invocation (PRD-067).
+ *
+ * Frozen (Track A simulator surfaces): 2026-04-15 — see
+ * `.method/sessions/fcd-design-prd-067-multi-app-strategy/prd.md` §6.1.
+ *
+ * Owner:    @methodts/runtime (defines port)
+ * Producer: @methodts/agent-runtime/cortex (CortexCrossAppInvoker — BLOCKED on
+ *           Cortex PRD-080) and @methodts/runtime (InProcessCrossAppInvoker
+ *           simulator — shipping in this PR)
+ * Consumer: @methodts/runtime/strategy (DagStrategyExecutor cross-app-invoke node dispatch)
+ *
+ * Gates:
+ *   - G-BOUNDARY: zero `@cortex/*` imports in this file — only port-local types.
+ *   - G-PORT: strategy executor MUST dispatch through this port, never directly
+ *     through `ctx.apps.invoke`.
+ *
+ * PRD-067 §12.3 ships `InProcessCrossAppInvoker` now so tests + single-process
+ * demos can exercise cross-app DAG flows without waiting for Cortex PRD-080
+ * (`🔜 deferred`, Wave 5). Swapping the simulator for the live adapter is a
+ * single composition-root line change once PRD-080 thaws.
+ */
+/** Delegation context carried into any RFC 8693 token exchange on dispatch.
+ *
+ * Constructed by the strategy executor from the pact's token context (see S3
+ * `CortexTokenExchangeMiddleware`). Tenant-app code does not build this.
+ */
+export interface DelegationCarry {
+    /** The caller's ctx-issued token (agent-scoped). Opaque to method; the
+     *  Cortex adapter threads it into `ctx.auth.exchangeForAgent`. */
+    readonly parentToken: string;
+    /** Exchange depth the caller has already consumed (RFC 8693). The adapter
+     *  rejects when `currentDepth >= maxDelegationDepth` per PRD-061/PRD-080. */
+    readonly currentDepth: number;
+    /** Originating request id — flows into the caller-side audit entry and
+     *  correlates with `tokenContext.originatingRequestId` on the envelope. */
+    readonly originatingRequestId: string;
+}
+/** Request to invoke an operation on a target Cortex tenant app. */
+export interface CrossAppInvokeRequest<Input = unknown> {
+    /** Target Cortex app id. MUST be present in the caller's `requires.apps[]`
+     *  manifest block. Enforced by Cortex at runtime; the Method adapter also
+     *  pre-checks via `capabilities().allowedTargetAppIds` to fail fast. */
+    readonly targetAppId: string;
+    /** Operation name on the target app. PRD-080 constrains cross-app calls to
+     *  operations, never tools. */
+    readonly operation: string;
+    /** Typed payload. Shape contract belongs to the target app's operation
+     *  schema — the invoker does NOT validate it; the caller's strategy DAG
+     *  node config declares its expected shape via `input_projection`. */
+    readonly input: Input;
+    /** Optional per-call timeout (milliseconds). Default: executor's
+     *  `defaultTimeoutMs`. */
+    readonly timeoutMs?: number;
+    /** Optional idempotency key. If the same
+     *  `(targetAppId, operation, idempotencyKey)` triple is seen twice the
+     *  target returns the first result. Recommended: the strategy DAG's
+     *  `${sessionId}:${nodeId}` tuple to dedupe across retries. */
+    readonly idempotencyKey?: string;
+    /** Delegation context for RFC 8693 token exchange. */
+    readonly delegation: DelegationCarry;
+    /** Strategy correlation identifiers — flow into the caller-side audit
+     *  entry and the continuation envelope's `crossApp.callerNodeId`. */
+    readonly caller: {
+        readonly sessionId: string;
+        readonly nodeId: string;
+    };
+}
+/** Result of a cross-app invocation. */
+export interface CrossAppInvokeResult<Output = unknown> {
+    /** The target operation's output, opaque to the port. */
+    readonly output: Output;
+    /** Target app's decisionId as returned by `ctx.apps.invoke` (PRD-080 §5.7).
+     *  Method appends this to its caller-side audit entry so the dual-audit
+     *  correlation works end-to-end. */
+    readonly targetDecisionId: string;
+    /** Wall-clock latency (ms) measured at the call site — includes token
+     *  exchange, scope check, transport, and target execution. */
+    readonly latencyMs: number;
+    /** Cost attributed to the CALLER's budget (USD) as reported by `ctx.llm`
+     *  at dispatch time. Callee's own `ctx.llm` cost is NOT included here —
+     *  the callee debits its own budget separately and the caller never sees
+     *  the callee's line item. */
+    readonly callerCostUsd: number;
+}
+/** Declarative capabilities of a concrete invoker implementation, asked at
+ *  compose time by the strategy executor so dev-mode bridges can fail fast
+ *  rather than at execution. */
+export interface CrossAppInvokerCapabilities {
+    /** True when the invoker can actually dispatch; false for null invokers. */
+    readonly enabled: boolean;
+    /** Max RFC 8693 delegation depth this invoker will accept before rejecting
+     *  at dispatch time. Echoes the PRD-061/PRD-080 default of 2. Adapters
+     *  MAY declare a lower cap (e.g. a simulator that runs depth 1 only). */
+    readonly maxDelegationDepth: number;
+    /** Allowed target app ids — derived from the tenant app's
+     *  `requires.apps[]` manifest block. Empty `undefined` means "adapter
+     *  doesn't enforce — trust the Cortex runtime check". A non-empty set
+     *  lets the strategy compose-time validator reject DAGs targeting
+     *  undeclared apps before execution starts. */
+    readonly allowedTargetAppIds?: ReadonlySet<string>;
+}
+/**
+ * Transport-free port the strategy DAG executor calls to dispatch a
+ * `cross-app-invoke` node. The `@methodts/runtime` layer knows nothing about
+ * Cortex; the adapter in `@methodts/agent-runtime/cortex` implements this port
+ * by calling `ctx.apps.invoke` (Cortex PRD-080).
+ *
+ * Implementations (per PRD-067 §6.1):
+ *   - `InProcessCrossAppInvoker` — in-memory map of registered simulator
+ *     apps; dispatches synchronously in-process. Shipping in this PR.
+ *   - `CortexCrossAppInvoker` — wraps `ctx.apps.invoke`. BLOCKED on Cortex
+ *     PRD-080 freeze.
+ *   - `NullCrossAppInvoker` — throws `CrossAppNotConfiguredError` on every
+ *     call; the default when no cross-app capability is wired.
+ *
+ * Fire-and-forget is explicitly not supported (PRD-080 §4 OOS): every call
+ * is request/reply.
+ */
+export interface CrossAppInvoker {
+    /** Invoke a named operation on a target app. */
+    invoke<Input = unknown, Output = unknown>(request: CrossAppInvokeRequest<Input>): Promise<CrossAppInvokeResult<Output>>;
+    /** Declare capabilities the strategy executor can check at compose time. */
+    capabilities(): CrossAppInvokerCapabilities;
+}
+/** Thrown when a `cross-app-invoke` node runs but no invoker is wired
+ *  (composition root received `NullCrossAppInvoker` or none at all). */
+export declare class CrossAppNotConfiguredError extends Error {
+    readonly code: "CROSS_APP_NOT_CONFIGURED";
+    constructor(message?: string);
+}
+/** Thrown at compose time when a DAG targets an app not in the manifest
+ *  `requires.apps[]` block (i.e. not in `capabilities().allowedTargetAppIds`). */
+export declare class CrossAppTargetNotDeclaredError extends Error {
+    readonly code: "CROSS_APP_TARGET_NOT_DECLARED";
+    readonly targetAppId: string;
+    readonly allowedTargetAppIds: ReadonlySet<string>;
+    constructor(targetAppId: string, allowedTargetAppIds: ReadonlySet<string>);
+}
+/** Surfaces Cortex PRD-080's `cross_app_scope_missing` 403 as a typed error. */
+export declare class CrossAppScopeMissingError extends Error {
+    readonly code: "CROSS_APP_SCOPE_MISSING";
+    readonly targetAppId: string;
+    readonly operation: string;
+    constructor(targetAppId: string, operation: string);
+}
+/** Thrown when the delegation depth would exceed the invoker's declared
+ *  max (PRD-067 §9.1 conflict point — default cap is 2). */
+export declare class CrossAppDelegationDepthExceededError extends Error {
+    readonly code: "CROSS_APP_DELEGATION_DEPTH_EXCEEDED";
+    readonly currentDepth: number;
+    readonly maxDepth: number;
+    constructor(currentDepth: number, maxDepth: number);
+}
+/** Thrown when the target app/operation is registered but its handler threw
+ *  — the invoker captures the target error and re-raises so the strategy
+ *  gate/retry machinery can resolve it as a node failure (PRD-067 §9 risk:
+ *  "Failure isolation"). */
+export declare class CrossAppTargetError extends Error {
+    readonly code: "CROSS_APP_TARGET_ERROR";
+    readonly targetAppId: string;
+    readonly operation: string;
+    readonly targetDecisionId: string;
+    readonly cause: unknown;
+    constructor(targetAppId: string, operation: string, targetDecisionId: string, cause: unknown);
+}
+/** Thrown when a target app is not registered with the invoker (simulator
+ *  analogue of Cortex's deploy-time app-dep graph check). */
+export declare class CrossAppTargetUnknownError extends Error {
+    readonly code: "CROSS_APP_TARGET_UNKNOWN";
+    readonly targetAppId: string;
+    readonly operation: string;
+    constructor(targetAppId: string, operation: string, knownAppIds: readonly string[]);
+}
+/** Default invoker used when the composition root did not wire a real one.
+ *
+ *  `invoke()` throws `CrossAppNotConfiguredError` on every call; `capabilities()`
+ *  reports `{ enabled: false }` so the strategy parser can refuse cross-app
+ *  nodes at compose time rather than at runtime.
+ */
+export declare class NullCrossAppInvoker implements CrossAppInvoker {
+    invoke<Input, Output>(_request: CrossAppInvokeRequest<Input>): Promise<CrossAppInvokeResult<Output>>;
+    capabilities(): CrossAppInvokerCapabilities;
+}
+/** Default delegation depth cap, matching PRD-061/PRD-080 RFC 8693 defaults. */
+export declare const CROSS_APP_DEFAULT_MAX_DELEGATION_DEPTH = 2;
+/**
+ * Compose-time validator — given a strategy's declared set of target apps,
+ * fails fast if any are not in the invoker's allowlist. Strategy executors
+ * call this before walking the DAG so a misconfigured manifest surfaces at
+ * compose time rather than at node dispatch.
+ *
+ * Behavior: when `capabilities().allowedTargetAppIds` is `undefined` the
+ * check is skipped (adapter declared "trust Cortex runtime check"). When
+ * the set is present (even empty), every declared target must be a member.
+ */
+export declare function assertCrossAppTargetsAllowed(invoker: CrossAppInvoker, declaredTargetAppIds: readonly string[]): void;
+//# sourceMappingURL=cross-app-invoker.d.ts.map

package/dist/ports/cross-app-invoker.d.ts.map

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

package/dist/ports/cross-app-invoker.js

@@ -0,0 +1,157 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * CrossAppInvoker — transport-free port for cross-app strategy invocation (PRD-067).
+ *
+ * Frozen (Track A simulator surfaces): 2026-04-15 — see
+ * `.method/sessions/fcd-design-prd-067-multi-app-strategy/prd.md` §6.1.
+ *
+ * Owner:    @methodts/runtime (defines port)
+ * Producer: @methodts/agent-runtime/cortex (CortexCrossAppInvoker — BLOCKED on
+ *           Cortex PRD-080) and @methodts/runtime (InProcessCrossAppInvoker
+ *           simulator — shipping in this PR)
+ * Consumer: @methodts/runtime/strategy (DagStrategyExecutor cross-app-invoke node dispatch)
+ *
+ * Gates:
+ *   - G-BOUNDARY: zero `@cortex/*` imports in this file — only port-local types.
+ *   - G-PORT: strategy executor MUST dispatch through this port, never directly
+ *     through `ctx.apps.invoke`.
+ *
+ * PRD-067 §12.3 ships `InProcessCrossAppInvoker` now so tests + single-process
+ * demos can exercise cross-app DAG flows without waiting for Cortex PRD-080
+ * (`🔜 deferred`, Wave 5). Swapping the simulator for the live adapter is a
+ * single composition-root line change once PRD-080 thaws.
+ */
+// ── Typed error classes ─────────────────────────────────────────
+/** Thrown when a `cross-app-invoke` node runs but no invoker is wired
+ *  (composition root received `NullCrossAppInvoker` or none at all). */
+export class CrossAppNotConfiguredError extends Error {
+    code = 'CROSS_APP_NOT_CONFIGURED';
+    constructor(message) {
+        super(message ??
+            'CrossAppInvoker not configured — strategy DAG declares a cross-app-invoke node but the runtime has no invoker wired. Inject CortexCrossAppInvoker (prod) or InProcessCrossAppInvoker (simulator/test).');
+        this.name = 'CrossAppNotConfiguredError';
+    }
+}
+/** Thrown at compose time when a DAG targets an app not in the manifest
+ *  `requires.apps[]` block (i.e. not in `capabilities().allowedTargetAppIds`). */
+export class CrossAppTargetNotDeclaredError extends Error {
+    code = 'CROSS_APP_TARGET_NOT_DECLARED';
+    targetAppId;
+    allowedTargetAppIds;
+    constructor(targetAppId, allowedTargetAppIds) {
+        super(`Cross-app target "${targetAppId}" is not declared in the caller's requires.apps[] manifest block. ` +
+            `Allowed: [${[...allowedTargetAppIds].sort().join(', ') || '<none>'}]. ` +
+            `Add "${targetAppId}" to the tenant app's manifest or remove the cross-app-invoke node from the strategy.`);
+        this.name = 'CrossAppTargetNotDeclaredError';
+        this.targetAppId = targetAppId;
+        this.allowedTargetAppIds = allowedTargetAppIds;
+    }
+}
+/** Surfaces Cortex PRD-080's `cross_app_scope_missing` 403 as a typed error. */
+export class CrossAppScopeMissingError extends Error {
+    code = 'CROSS_APP_SCOPE_MISSING';
+    targetAppId;
+    operation;
+    constructor(targetAppId, operation) {
+        super(`Cross-app call to "${targetAppId}.${operation}" rejected: token is missing the required app:${targetAppId}:${operation} scope. ` +
+            `The caller's ctx-issued token must carry that scope claim. ` +
+            `This maps to Cortex PRD-080's cross_app_scope_missing 403.`);
+        this.name = 'CrossAppScopeMissingError';
+        this.targetAppId = targetAppId;
+        this.operation = operation;
+    }
+}
+/** Thrown when the delegation depth would exceed the invoker's declared
+ *  max (PRD-067 §9.1 conflict point — default cap is 2). */
+export class CrossAppDelegationDepthExceededError extends Error {
+    code = 'CROSS_APP_DELEGATION_DEPTH_EXCEEDED';
+    currentDepth;
+    maxDepth;
+    constructor(currentDepth, maxDepth) {
+        super(`Cross-app invocation rejected: delegation depth ${currentDepth} would exceed the cap of ${maxDepth}. ` +
+            `Per PRD-061/PRD-080 the hard cap is 2 — user → agent → cross-app is the deepest valid chain. ` +
+            `PRD-067 §9.1 default mitigation: re-compose deep sub-agent trees as siblings via additional cross-app-invoke calls (flatten the tree).`);
+        this.name = 'CrossAppDelegationDepthExceededError';
+        this.currentDepth = currentDepth;
+        this.maxDepth = maxDepth;
+    }
+}
+/** Thrown when the target app/operation is registered but its handler threw
+ *  — the invoker captures the target error and re-raises so the strategy
+ *  gate/retry machinery can resolve it as a node failure (PRD-067 §9 risk:
+ *  "Failure isolation"). */
+export class CrossAppTargetError extends Error {
+    code = 'CROSS_APP_TARGET_ERROR';
+    targetAppId;
+    operation;
+    targetDecisionId;
+    cause;
+    constructor(targetAppId, operation, targetDecisionId, cause) {
+        const causeMsg = cause instanceof Error ? cause.message : String(cause);
+        super(`Cross-app target "${targetAppId}.${operation}" failed (decisionId=${targetDecisionId}): ${causeMsg}`);
+        this.name = 'CrossAppTargetError';
+        this.targetAppId = targetAppId;
+        this.operation = operation;
+        this.targetDecisionId = targetDecisionId;
+        this.cause = cause;
+    }
+}
+/** Thrown when a target app is not registered with the invoker (simulator
+ *  analogue of Cortex's deploy-time app-dep graph check). */
+export class CrossAppTargetUnknownError extends Error {
+    code = 'CROSS_APP_TARGET_UNKNOWN';
+    targetAppId;
+    operation;
+    constructor(targetAppId, operation, knownAppIds) {
+        super(`Cross-app target "${targetAppId}.${operation}" unknown to invoker. ` +
+            `Registered apps: [${[...knownAppIds].sort().join(', ') || '<none>'}]. ` +
+            `In the simulator, register the app via InProcessCrossAppInvoker.registerApp(); ` +
+            `in production, confirm the app is deployed and declared in requires.apps[].`);
+        this.name = 'CrossAppTargetUnknownError';
+        this.targetAppId = targetAppId;
+        this.operation = operation;
+    }
+}
+// ── Default null invoker ────────────────────────────────────────
+/** Default invoker used when the composition root did not wire a real one.
+ *
+ *  `invoke()` throws `CrossAppNotConfiguredError` on every call; `capabilities()`
+ *  reports `{ enabled: false }` so the strategy parser can refuse cross-app
+ *  nodes at compose time rather than at runtime.
+ */
+export class NullCrossAppInvoker {
+    async invoke(_request) {
+        throw new CrossAppNotConfiguredError();
+    }
+    capabilities() {
+        return {
+            enabled: false,
+            maxDelegationDepth: 2,
+            allowedTargetAppIds: new Set(),
+        };
+    }
+}
+/** Default delegation depth cap, matching PRD-061/PRD-080 RFC 8693 defaults. */
+export const CROSS_APP_DEFAULT_MAX_DELEGATION_DEPTH = 2;
+/**
+ * Compose-time validator — given a strategy's declared set of target apps,
+ * fails fast if any are not in the invoker's allowlist. Strategy executors
+ * call this before walking the DAG so a misconfigured manifest surfaces at
+ * compose time rather than at node dispatch.
+ *
+ * Behavior: when `capabilities().allowedTargetAppIds` is `undefined` the
+ * check is skipped (adapter declared "trust Cortex runtime check"). When
+ * the set is present (even empty), every declared target must be a member.
+ */
+export function assertCrossAppTargetsAllowed(invoker, declaredTargetAppIds) {
+    const caps = invoker.capabilities();
+    const allowed = caps.allowedTargetAppIds;
+    if (allowed === undefined)
+        return;
+    for (const targetAppId of declaredTargetAppIds) {
+        if (!allowed.has(targetAppId)) {
+            throw new CrossAppTargetNotDeclaredError(targetAppId, allowed);
+        }
+    }
+}
+//# sourceMappingURL=cross-app-invoker.js.map

package/dist/ports/cross-app-invoker.js.map

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

package/dist/ports/dlq-observer.d.ts

@@ -0,0 +1,40 @@
+/**
+ * DLQ observability port — PRD-062 / S5 §2.4.
+ *
+ * When Cortex's retry policy exhausts (attempt=4 failed, moved to DLQ),
+ * the tenant app MUST give the runtime a chance to observe and emit a
+ * terminal `AgentEvent`. This port is attached to the DLQ inspection hook.
+ *
+ * Two emission paths (G-DLQ-SINGLE-EMIT, S5 §7):
+ *   - INLINE: from the continuation handler when pacta classifies "ack +
+ *     signal DLQ" (budget exhaustion, checkpoint corruption, budget_expired).
+ *   - EXTERNAL: from Cortex's DLQ — the tenant's inspection job calls
+ *     `onDeadLetter(envelope, record)` which emits the same event.
+ *
+ * The observer MUST emit at most one `PactDeadLetterEvent` per
+ * `sessionId`, regardless of how many times either path fires. The
+ * executor coordinates via SessionStore finalize-status.
+ */
+import type { ContinuationEnvelope } from './continuation-envelope.js';
+import type { PactDeadLetterEvent } from '@methodts/pacta';
+export interface DlqObserver {
+    /**
+     * Called by the tenant app when a DLQ record is observed for a
+     * `method.pact.continue` job. The observer unpacks the envelope,
+     * emits a `PactDeadLetterEvent` on the host's event channel, and
+     * finalises the session (unless already terminal).
+     *
+     * Returns the emitted event (or `null` if suppressed because the
+     * session was already terminal — idempotent).
+     */
+    onDeadLetter(envelope: ContinuationEnvelope, dlqRecord: DlqRecord): Promise<PactDeadLetterEvent | null>;
+}
+export interface DlqRecord {
+    jobId: string;
+    attempts: number;
+    lastError: string;
+    deadLetteredAt: number;
+}
+/** Re-export for convenient import from the ports barrel. */
+export type { PactDeadLetterEvent } from '@methodts/pacta';
+//# sourceMappingURL=dlq-observer.d.ts.map

package/dist/ports/dlq-observer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dlq-observer.d.ts","sourceRoot":"","sources":["../../src/ports/dlq-observer.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AACvE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAE3D,MAAM,WAAW,WAAW;IAC1B;;;;;;;;OAQG;IACH,YAAY,CACV,QAAQ,EAAE,oBAAoB,EAC9B,SAAS,EAAE,SAAS,GACnB,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC,CAAC;CACxC;AAED,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,6DAA6D;AAC7D,YAAY,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/ports/dlq-observer.js

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * DLQ observability port — PRD-062 / S5 §2.4.
+ *
+ * When Cortex's retry policy exhausts (attempt=4 failed, moved to DLQ),
+ * the tenant app MUST give the runtime a chance to observe and emit a
+ * terminal `AgentEvent`. This port is attached to the DLQ inspection hook.
+ *
+ * Two emission paths (G-DLQ-SINGLE-EMIT, S5 §7):
+ *   - INLINE: from the continuation handler when pacta classifies "ack +
+ *     signal DLQ" (budget exhaustion, checkpoint corruption, budget_expired).
+ *   - EXTERNAL: from Cortex's DLQ — the tenant's inspection job calls
+ *     `onDeadLetter(envelope, record)` which emits the same event.
+ *
+ * The observer MUST emit at most one `PactDeadLetterEvent` per
+ * `sessionId`, regardless of how many times either path fires. The
+ * executor coordinates via SessionStore finalize-status.
+ */
+export {};
+//# sourceMappingURL=dlq-observer.js.map

package/dist/ports/dlq-observer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dlq-observer.js","sourceRoot":"","sources":["../../src/ports/dlq-observer.ts"],"names":[],"mappings":"AAAA,sCAAsC;AACtC;;;;;;;;;;;;;;;;GAgBG"}

package/dist/ports/event-bus.d.ts

@@ -0,0 +1,169 @@
+/**
+ * EventBus — Port interface for the Universal Event Bus (PRD 026).
+ *
+ * The event bus is runtime-level infrastructure. Domains emit typed events
+ * through the port. Consumers (WebSocket, persistence, Genesis, parent agents)
+ * subscribe through the same interface. Neither producers nor consumers
+ * know about each other.
+ *
+ * PRD-057: Moved from @methodts/bridge/ports/event-bus.ts. The type was
+ * renamed `BridgeEvent` → `RuntimeEvent` to reflect that the bus now serves
+ * multiple consumers (bridge, agent-runtime, future SLM server). Event
+ * `type` strings (wire format) are unchanged.
+ *
+ * Design: DR-15 compliant — domains accept the port via injection.
+ * The composition root (server-entry.ts in bridge) creates the bus, registers
+ * sinks, and injects the bus into domains.
+ */
+/**
+ * Domain classification for events. Extensible — new domains can be added
+ * without modifying this type. The union is a type-level hint, not a runtime enum.
+ * The `(string & {})` escape hatch keeps this neutral across downstream consumers.
+ */
+export type EventDomain = 'session' | 'strategy' | 'trigger' | 'project' | 'methodology' | 'system' | 'agent' | (string & {});
+export type EventSeverity = 'info' | 'warning' | 'error' | 'critical';
+/**
+ * Canonical event shape for the entire runtime. Every domain event is expressed
+ * as a RuntimeEvent. Bus assigns id, timestamp, and sequence on emit.
+ *
+ * Renamed from `BridgeEvent` per PRD-057 / S2 §4. A back-compat alias lives in
+ * `@methodts/bridge/ports/event-bus.ts`.
+ */
+export interface RuntimeEvent {
+    /** UUID, globally unique. Assigned by the bus. */
+    id: string;
+    /** Schema version for future evolution. */
+    version: 1;
+    /** ISO 8601 timestamp. Assigned by the bus. */
+    timestamp: string;
+    /** Monotonic sequence number. Assigned by the bus. */
+    sequence: number;
+    /** Which domain produced this event. */
+    domain: EventDomain;
+    /** Domain-owned type string (e.g., 'session.spawned', 'strategy.gate_failed'). */
+    type: string;
+    /** Event severity level. */
+    severity: EventSeverity;
+    /** Which project this event belongs to (if applicable). */
+    projectId?: string;
+    /** Which session produced this event (if applicable). */
+    sessionId?: string;
+    /** Domain-specific data. */
+    payload: Record<string, unknown>;
+    /** Which component emitted (e.g., 'bridge/sessions/pool', 'runtime/event-bus/persistence-sink'). */
+    source: string;
+    /** Links related events (e.g., all events from one strategy execution). */
+    correlationId?: string;
+    /** Originating bridge node ID (set when event is federated from another bridge). */
+    sourceNodeId?: string;
+    /** True if this event was received from another bridge via cluster federation. */
+    federated?: boolean;
+}
+/**
+ * Input to EventBus.emit() — bus-assigned fields (id, timestamp, sequence)
+ * are omitted since the bus fills them in.
+ *
+ * Renamed from `BridgeEventInput` per PRD-057 / S2 §4.
+ */
+export type RuntimeEventInput = Omit<RuntimeEvent, 'id' | 'timestamp' | 'sequence'>;
+export interface EventFilter {
+    domain?: EventDomain | EventDomain[];
+    /** Glob-style patterns: 'session.*', 'strategy.gate_*'. */
+    type?: string | string[];
+    projectId?: string;
+    sessionId?: string;
+    severity?: EventSeverity | EventSeverity[];
+}
+export interface EventSubscription {
+    unsubscribe: () => void;
+}
+/**
+ * A sink receives all events from the bus. Sinks are registered in
+ * the composition root — no domain registers sinks directly.
+ */
+export interface EventSink {
+    name: string;
+    onEvent(event: RuntimeEvent): void | Promise<void>;
+    onError?: (error: Error, event: RuntimeEvent) => void;
+}
+/**
+ * Health status for a connector.
+ */
+export interface ConnectorHealth {
+    connected: boolean;
+    lastEventAt: string | null;
+    errorCount: number;
+}
+/**
+ * An EventConnector extends EventSink with lifecycle management for
+ * long-lived external connections (webhooks, Slack, external APIs).
+ *
+ * Connectors manage their own retry/backoff. The composition root
+ * calls connect() after registration and disconnect() on shutdown.
+ */
+export interface EventConnector extends EventSink {
+    /** Establish connection to the external system. */
+    connect(): Promise<void>;
+    /** Graceful teardown. */
+    disconnect(): Promise<void>;
+    /** Current health status. */
+    health(): ConnectorHealth;
+}
+/**
+ * Payload shape for domain='strategy', type='gate.awaiting_approval'.
+ * Emitted by bridge/strategies when a human_approval gate fires and the
+ * executor suspends waiting for a human decision.
+ */
+export interface StrategyGateAwaitingApprovalPayload {
+    strategy_id: string;
+    execution_id: string;
+    gate_id: string;
+    node_id: string;
+    /** GlyphJS markdown to display in the dashboard (surface contract, PRD excerpt, etc.) */
+    artifact_markdown: string;
+    artifact_type: 'surface_record' | 'prd' | 'plan' | 'review_report' | 'custom';
+    /** Milliseconds before oversight escalation fires. */
+    timeout_ms: number;
+}
+/**
+ * Payload shape for domain='strategy', type='gate.approval_response'.
+ * Sent by the frontend dashboard to resume a suspended human_approval gate.
+ */
+export interface StrategyGateApprovalResponsePayload {
+    execution_id: string;
+    gate_id: string;
+    decision: 'approved' | 'rejected' | 'changes_requested';
+    /** Passed as retry context when decision is rejected or changes_requested. */
+    feedback?: string;
+}
+/**
+ * Port interface for the Universal Event Bus.
+ *
+ * - emit(): non-blocking, bus assigns id/timestamp/sequence. No sink failure blocks emit.
+ * - subscribe(): filter-based subscription for in-process consumers.
+ * - query(): historical query (requires persistence sink).
+ * - registerSink(): register a sink to receive all events.
+ */
+export interface EventBus {
+    /**
+     * Emit an event to all subscribers and sinks.
+     * Bus assigns id, timestamp, and sequence. Non-blocking.
+     */
+    emit(event: RuntimeEventInput): RuntimeEvent;
+    /**
+     * Import a pre-existing event (e.g., from replay) without reassigning
+     * id, timestamp, or sequence. Pushes to ring buffer and dispatches to
+     * sinks/subscribers. Updates internal sequence counter to avoid collisions.
+     */
+    importEvent(event: RuntimeEvent): void;
+    /** Subscribe to events matching a filter. */
+    subscribe(filter: EventFilter, handler: (event: RuntimeEvent) => void): EventSubscription;
+    /** Query past events from the ring buffer. */
+    query(filter: EventFilter, options?: {
+        limit?: number;
+        since?: string;
+    }): RuntimeEvent[];
+    /** Register a sink that receives all events. */
+    registerSink(sink: EventSink): void;
+}
+//# sourceMappingURL=event-bus.d.ts.map

package/dist/ports/event-bus.d.ts.map

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

package/dist/ports/event-bus.js

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * EventBus — Port interface for the Universal Event Bus (PRD 026).
+ *
+ * The event bus is runtime-level infrastructure. Domains emit typed events
+ * through the port. Consumers (WebSocket, persistence, Genesis, parent agents)
+ * subscribe through the same interface. Neither producers nor consumers
+ * know about each other.
+ *
+ * PRD-057: Moved from @methodts/bridge/ports/event-bus.ts. The type was
+ * renamed `BridgeEvent` → `RuntimeEvent` to reflect that the bus now serves
+ * multiple consumers (bridge, agent-runtime, future SLM server). Event
+ * `type` strings (wire format) are unchanged.
+ *
+ * Design: DR-15 compliant — domains accept the port via injection.
+ * The composition root (server-entry.ts in bridge) creates the bus, registers
+ * sinks, and injects the bus into domains.
+ */
+export {};
+//# sourceMappingURL=event-bus.js.map

package/dist/ports/event-bus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-bus.js","sourceRoot":"","sources":["../../src/ports/event-bus.ts"],"names":[],"mappings":"AAAA,sCAAsC;AACtC;;;;;;;;;;;;;;;;GAgBG"}