@a5c-ai/agent-platform 5.0.1-staging.b436b3b3e611

package/dist/mcp/transport/websocket.js

@@ -0,0 +1,271 @@
+"use strict";
+/**
+ * Status: NOT INTEGRATED YET
+ * Moved from @a5c-ai/babysitter-sdk.
+ * GAP-REMOTE-003: WebSocket server transport for MCP.
+ *
+ * Creates a WebSocket server where each connection gets its own MCP Transport,
+ * enabling per-connection McpServer instances for session multiplexing.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketConnectionTransport = void 0;
+exports.authenticateUpgrade = authenticateUpgrade;
+exports.createWebSocketTransport = createWebSocketTransport;
+const ws_1 = require("ws");
+const http = __importStar(require("node:http"));
+const crypto = __importStar(require("node:crypto"));
+const session_1 = require("./session");
+const DEFAULT_PING_INTERVAL_MS = 30_000;
+const DEFAULT_MAX_MESSAGES_PER_SECOND = 100;
+const SESSION_GRACE_PERIOD_MS = 60_000;
+function authenticateUpgrade(request, expectedToken) {
+    if (!expectedToken)
+        return true;
+    const authHeader = request.headers.authorization;
+    if (!authHeader)
+        return false;
+    const expected = `Bearer ${expectedToken}`;
+    if (authHeader.length !== expected.length)
+        return false;
+    try {
+        return crypto.timingSafeEqual(Buffer.from(authHeader), Buffer.from(expected));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * A Transport implementation backed by a single WebSocket connection.
+ * Bridges WS messages to/from the MCP server.
+ */
+class WebSocketConnectionTransport {
+    onclose;
+    onerror;
+    onmessage;
+    sessionId;
+    _ws;
+    _rateLimiter;
+    _maxMps;
+    constructor(ws, sessionId, maxMessagesPerSecond) {
+        this._ws = ws;
+        this.sessionId = sessionId;
+        this._maxMps = maxMessagesPerSecond;
+        this._rateLimiter = { count: 0, resetAt: Date.now() + 1000 };
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await -- Transport interface requires Promise
+    async start() {
+        this._ws.on("message", (data) => {
+            // Rate limit check
+            const now = Date.now();
+            if (now >= this._rateLimiter.resetAt) {
+                this._rateLimiter.count = 0;
+                this._rateLimiter.resetAt = now + 1000;
+            }
+            this._rateLimiter.count++;
+            if (this._rateLimiter.count > this._maxMps) {
+                const errorResponse = JSON.stringify({
+                    jsonrpc: "2.0",
+                    error: { code: -32000, message: "Rate limit exceeded" },
+                    id: null,
+                });
+                this._ws.send(errorResponse);
+                return;
+            }
+            try {
+                const message = JSON.parse(data.toString());
+                if (this.onmessage) {
+                    this.onmessage(message);
+                }
+            }
+            catch (err) {
+                if (this.onerror) {
+                    this.onerror(err instanceof Error ? err : new Error(String(err)));
+                }
+            }
+        });
+        this._ws.on("close", () => {
+            if (this.onclose)
+                this.onclose();
+        });
+        this._ws.on("error", (err) => {
+            if (this.onerror)
+                this.onerror(err);
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await -- Transport interface requires Promise
+    async send(message, _options) {
+        if (this._ws.readyState === ws_1.WebSocket.OPEN) {
+            this._ws.send(JSON.stringify(message));
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await -- Transport interface requires Promise
+    async close() {
+        this._ws.close(1001, "Server shutting down");
+    }
+    setProtocolVersion;
+}
+exports.WebSocketConnectionTransport = WebSocketConnectionTransport;
+async function createWebSocketTransport(options) {
+    const { port, host = "127.0.0.1", authToken, pingIntervalMs = DEFAULT_PING_INTERVAL_MS, maxMessagesPerSecond = DEFAULT_MAX_MESSAGES_PER_SECOND, sessionGracePeriodMs = SESSION_GRACE_PERIOD_MS, } = options;
+    const sessionManager = new session_1.WebSocketSessionManager();
+    const server = http.createServer();
+    const wss = new ws_1.WebSocketServer({ noServer: true });
+    const connections = new Set();
+    const pingTimers = new Map();
+    const sessionGraceTimers = new Map();
+    let onconnection;
+    server.on("upgrade", (request, socket, head) => {
+        if (!authenticateUpgrade(request, authToken)) {
+            socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
+            socket.destroy();
+            return;
+        }
+        wss.handleUpgrade(request, socket, head, (ws) => {
+            // Check for session restore
+            const restoreId = request.headers["x-session-id"];
+            let session;
+            if (restoreId) {
+                session = sessionManager.restoreSession(restoreId);
+                if (session) {
+                    // Cancel any pending grace period cleanup
+                    const graceTimer = sessionGraceTimers.get(restoreId);
+                    if (graceTimer) {
+                        clearTimeout(graceTimer);
+                        sessionGraceTimers.delete(restoreId);
+                    }
+                }
+            }
+            if (!session) {
+                session = sessionManager.createSession();
+            }
+            connections.add(ws);
+            // Set up ping/pong keepalive
+            let alive = true;
+            const pingTimer = setInterval(() => {
+                if (!alive) {
+                    ws.terminate();
+                    return;
+                }
+                alive = false;
+                ws.ping();
+            }, pingIntervalMs);
+            ws.on("pong", () => {
+                alive = true;
+            });
+            // Create per-connection MCP transport
+            const transport = new WebSocketConnectionTransport(ws, session.sessionId, maxMessagesPerSecond);
+            ws.on("close", () => {
+                connections.delete(ws);
+                clearInterval(pingTimer);
+                pingTimers.delete(ws);
+                // Grace period: don't delete session immediately — allow reconnection
+                const sid = transport.sessionId;
+                if (sid) {
+                    const graceTimer = setTimeout(() => {
+                        sessionManager.removeSession(sid);
+                        sessionGraceTimers.delete(sid);
+                    }, sessionGracePeriodMs);
+                    sessionGraceTimers.set(sid, graceTimer);
+                }
+            });
+            pingTimers.set(ws, pingTimer);
+            // Notify consumer so they can connect a McpServer to this transport
+            if (onconnection) {
+                onconnection(transport);
+            }
+            // Send session info
+            ws.send(JSON.stringify({
+                jsonrpc: "2.0",
+                method: "session/initialized",
+                params: { sessionId: session.sessionId },
+            }));
+        });
+    });
+    return new Promise((resolve, reject) => {
+        server.on("error", reject);
+        server.listen(port, host, () => {
+            const addr = server.address();
+            const actualPort = typeof addr === "object" && addr ? addr.port : port;
+            const result = {
+                port: actualPort,
+                sessionManager,
+                get onconnection() {
+                    return onconnection;
+                },
+                set onconnection(handler) {
+                    onconnection = handler;
+                },
+                async close() {
+                    // Clear all grace timers
+                    for (const timer of sessionGraceTimers.values()) {
+                        clearTimeout(timer);
+                    }
+                    sessionGraceTimers.clear();
+                    // Send close frame to all connections
+                    for (const ws of connections) {
+                        ws.close(1001, "Server shutting down");
+                    }
+                    // Clear all ping timers
+                    for (const timer of pingTimers.values()) {
+                        clearInterval(timer);
+                    }
+                    pingTimers.clear();
+                    // Wait for connections to close (max 5s)
+                    await Promise.race([
+                        new Promise((res) => {
+                            if (connections.size === 0) {
+                                res();
+                                return;
+                            }
+                            const check = setInterval(() => {
+                                if (connections.size === 0) {
+                                    clearInterval(check);
+                                    res();
+                                }
+                            }, 100);
+                        }),
+                        new Promise((res) => setTimeout(res, 5000)),
+                    ]);
+                    wss.close();
+                    await new Promise((res, rej) => {
+                        server.close((err) => (err ? rej(err) : res()));
+                    });
+                },
+            };
+            resolve(result);
+        });
+    });
+}

package/dist/observability/health.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Run Health Model (GAP-STATE-008).
+ *
+ * Computes a point-in-time health snapshot from journal events.
+ * Pure function — no file I/O, takes events as input.
+ */
+import type { JournalEvent } from "@a5c-ai/babysitter-sdk";
+import type { RunHealthSnapshot, HealthConfig } from "./types";
+interface HealthOptions {
+    config?: Partial<HealthConfig>;
+    /** Override "now" for testing. */
+    now?: number;
+}
+/**
+ * Compute a health snapshot from an array of journal events.
+ */
+export declare function computeRunHealthFromEvents(events: JournalEvent[], options?: HealthOptions): RunHealthSnapshot;
+export {};
+//# sourceMappingURL=health.d.ts.map

package/dist/observability/health.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"health.d.ts","sourceRoot":"","sources":["../../src/observability/health.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,KAAK,EACV,iBAAiB,EAGjB,YAAY,EACb,MAAM,SAAS,CAAC;AAiBjB,UAAU,aAAa;IACrB,MAAM,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC;IAC/B,kCAAkC;IAClC,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,YAAY,EAAE,EACtB,OAAO,CAAC,EAAE,aAAa,GACtB,iBAAiB,CAiInB"}

package/dist/observability/health.js

@@ -0,0 +1,129 @@
+"use strict";
+/**
+ * Run Health Model (GAP-STATE-008).
+ *
+ * Computes a point-in-time health snapshot from journal events.
+ * Pure function — no file I/O, takes events as input.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeRunHealthFromEvents = computeRunHealthFromEvents;
+// ---------------------------------------------------------------------------
+// Defaults
+// ---------------------------------------------------------------------------
+const DEFAULT_CONFIG = {
+    stuckThresholdMs: 300_000, // 5 minutes
+    degradedErrorRate: 0.3,
+    failedErrorRate: 0.7,
+    maxPendingAge: 600_000, // 10 minutes
+};
+/**
+ * Compute a health snapshot from an array of journal events.
+ */
+function computeRunHealthFromEvents(events, options) {
+    const config = { ...DEFAULT_CONFIG, ...options?.config };
+    const now = options?.now ?? Date.now();
+    // Track effects
+    const requestedAt = new Map(); // effectId → timestamp ms
+    const resolvedEffects = new Set();
+    let failedEffects = 0;
+    let totalLatency = 0;
+    let latencyCount = 0;
+    let lastActivityAt = null;
+    let hasRunFailed = false;
+    const iterations = new Set();
+    for (const event of events) {
+        lastActivityAt = event.recordedAt;
+        const ts = new Date(event.recordedAt).getTime();
+        if (event.type === "RUN_FAILED") {
+            hasRunFailed = true;
+        }
+        if (event.type === "EFFECT_REQUESTED") {
+            const effectId = typeof event.data.effectId === "string" ? event.data.effectId : undefined;
+            if (effectId) {
+                requestedAt.set(effectId, ts);
+            }
+            const iteration = typeof event.data.iteration === "number" ? event.data.iteration : undefined;
+            if (iteration != null) {
+                iterations.add(iteration);
+            }
+        }
+        if (event.type === "EFFECT_RESOLVED") {
+            const effectId = typeof event.data.effectId === "string" ? event.data.effectId : undefined;
+            if (effectId) {
+                resolvedEffects.add(effectId);
+                const reqTs = requestedAt.get(effectId);
+                if (reqTs != null) {
+                    totalLatency += ts - reqTs;
+                    latencyCount++;
+                }
+                const status = typeof event.data.status === "string" ? event.data.status : undefined;
+                if (status === "error") {
+                    failedEffects++;
+                }
+            }
+        }
+    }
+    // Compute metrics
+    const totalEffects = requestedAt.size;
+    const resolvedCount = resolvedEffects.size;
+    const pendingCount = totalEffects - resolvedCount;
+    const errorRate = resolvedCount > 0 ? failedEffects / resolvedCount : 0;
+    const avgEffectLatencyMs = latencyCount > 0 ? Math.round(totalLatency / latencyCount) : 0;
+    // Oldest pending effect age
+    let oldestPendingAgeMs = 0;
+    for (const [effectId, reqTs] of requestedAt) {
+        if (!resolvedEffects.has(effectId)) {
+            const age = now - reqTs;
+            if (age > oldestPendingAgeMs) {
+                oldestPendingAgeMs = age;
+            }
+        }
+    }
+    const metrics = {
+        errorRate,
+        avgEffectLatencyMs,
+        pendingCount,
+        oldestPendingAgeMs,
+        iterationCount: iterations.size,
+        lastActivityAt,
+        totalEffects,
+        resolvedEffects: resolvedCount,
+        failedEffects,
+    };
+    // Determine status and issues
+    const issues = [];
+    let status = "healthy";
+    if (hasRunFailed) {
+        status = "failed";
+        issues.push("Run failed: RUN_FAILED event detected");
+    }
+    else if (errorRate >= config.failedErrorRate && resolvedCount > 0) {
+        status = "failed";
+        issues.push(`High error rate: ${(errorRate * 100).toFixed(1)}% exceeds failed threshold (${(config.failedErrorRate * 100).toFixed(1)}%)`);
+    }
+    else if (lastActivityAt != null &&
+        now - new Date(lastActivityAt).getTime() > config.stuckThresholdMs &&
+        pendingCount > 0) {
+        status = "stuck";
+        const idleMs = now - new Date(lastActivityAt).getTime();
+        issues.push(`Run stuck: no activity for ${Math.round(idleMs / 1000)}s (threshold: ${Math.round(config.stuckThresholdMs / 1000)}s)`);
+    }
+    else if (errorRate >= config.degradedErrorRate && resolvedCount > 0) {
+        status = "degraded";
+        issues.push(`Elevated error rate: ${(errorRate * 100).toFixed(1)}% exceeds degraded threshold (${(config.degradedErrorRate * 100).toFixed(1)}%)`);
+    }
+    // Additional issues (additive, don't change status)
+    if (oldestPendingAgeMs > config.maxPendingAge &&
+        status !== "failed") {
+        issues.push(`Oldest pending effect age: ${Math.round(oldestPendingAgeMs / 1000)}s exceeds max pending age (${Math.round(config.maxPendingAge / 1000)}s)`);
+        if (status === "healthy") {
+            status = "degraded";
+        }
+    }
+    return {
+        status,
+        metrics,
+        issues,
+        computedAt: new Date(now).toISOString(),
+    };
+}

package/dist/observability/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Re-export shim — canonical implementation lives in @a5c-ai/agent-runtime.
+ * Internal agent-platform consumers continue to import via relative paths
+ * through this barrel file.
+ */
+export { buildPhaseTimeline, buildPhaseTimelineFromEvents, computeRunHealthFromEvents, getRunHealthSnapshot, getOrchestrationStatus, getPendingWorkItems, type OrchestrationStatus, type OrchestrationPhase, type PendingWorkItem, type PhaseTimeline, type PhaseEntry, type PhaseName, type Milestone, type IterationTimeline, type RunHealthSnapshot, type RunHealthStatus, type RunHealthMetrics, type HealthConfig, registerWebhook, unregisterWebhook, listWebhooks, buildWebhookEvent, evaluateAlertLevel, filterRegistrations, type AlertLevel, type WebhookEventType, type WebhookRegistration, type WebhookEvent, type WebhookDeliveryResult, type WebhookRegistry, type WebhookRegistrationInput, WEBHOOK_SCHEMA_VERSION, } from "@a5c-ai/agent-runtime/observability";
+//# sourceMappingURL=index.d.ts.map

package/dist/observability/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/observability/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EACL,kBAAkB,EAClB,4BAA4B,EAC5B,0BAA0B,EAC1B,oBAAoB,EACpB,sBAAsB,EACtB,mBAAmB,EACnB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,UAAU,EACf,KAAK,SAAS,EACd,KAAK,SAAS,EACd,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,YAAY,EACjB,eAAe,EACf,iBAAiB,EACjB,YAAY,EACZ,iBAAiB,EACjB,kBAAkB,EAClB,mBAAmB,EACnB,KAAK,UAAU,EACf,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,KAAK,YAAY,EACjB,KAAK,qBAAqB,EAC1B,KAAK,eAAe,EACpB,KAAK,wBAAwB,EAC7B,sBAAsB,GACvB,MAAM,qCAAqC,CAAC"}

package/dist/observability/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WEBHOOK_SCHEMA_VERSION = exports.filterRegistrations = exports.evaluateAlertLevel = exports.buildWebhookEvent = exports.listWebhooks = exports.unregisterWebhook = exports.registerWebhook = exports.getPendingWorkItems = exports.getOrchestrationStatus = exports.getRunHealthSnapshot = exports.computeRunHealthFromEvents = exports.buildPhaseTimelineFromEvents = exports.buildPhaseTimeline = void 0;
+/**
+ * Re-export shim — canonical implementation lives in @a5c-ai/agent-runtime.
+ * Internal agent-platform consumers continue to import via relative paths
+ * through this barrel file.
+ */
+var observability_1 = require("@a5c-ai/agent-runtime/observability");
+Object.defineProperty(exports, "buildPhaseTimeline", { enumerable: true, get: function () { return observability_1.buildPhaseTimeline; } });
+Object.defineProperty(exports, "buildPhaseTimelineFromEvents", { enumerable: true, get: function () { return observability_1.buildPhaseTimelineFromEvents; } });
+Object.defineProperty(exports, "computeRunHealthFromEvents", { enumerable: true, get: function () { return observability_1.computeRunHealthFromEvents; } });
+Object.defineProperty(exports, "getRunHealthSnapshot", { enumerable: true, get: function () { return observability_1.getRunHealthSnapshot; } });
+Object.defineProperty(exports, "getOrchestrationStatus", { enumerable: true, get: function () { return observability_1.getOrchestrationStatus; } });
+Object.defineProperty(exports, "getPendingWorkItems", { enumerable: true, get: function () { return observability_1.getPendingWorkItems; } });
+Object.defineProperty(exports, "registerWebhook", { enumerable: true, get: function () { return observability_1.registerWebhook; } });
+Object.defineProperty(exports, "unregisterWebhook", { enumerable: true, get: function () { return observability_1.unregisterWebhook; } });
+Object.defineProperty(exports, "listWebhooks", { enumerable: true, get: function () { return observability_1.listWebhooks; } });
+Object.defineProperty(exports, "buildWebhookEvent", { enumerable: true, get: function () { return observability_1.buildWebhookEvent; } });
+Object.defineProperty(exports, "evaluateAlertLevel", { enumerable: true, get: function () { return observability_1.evaluateAlertLevel; } });
+Object.defineProperty(exports, "filterRegistrations", { enumerable: true, get: function () { return observability_1.filterRegistrations; } });
+Object.defineProperty(exports, "WEBHOOK_SCHEMA_VERSION", { enumerable: true, get: function () { return observability_1.WEBHOOK_SCHEMA_VERSION; } });

package/dist/observability/runStatus.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Run status and inspection APIs (GAP-OBS-001, GAP-UX-005, GAP-UX-006).
+ *
+ * - getRunHealthSnapshot: wraps computeRunHealthFromEvents with journal loading
+ * - getOrchestrationStatus: structured status view combining metadata, health, effects
+ * - getPendingWorkItems: detailed inspection of pending effects
+ */
+import type { RunHealthSnapshot } from "./types";
+/**
+ * Compute a health snapshot for a run by loading its journal.
+ */
+export declare function getRunHealthSnapshot(runDir: string): Promise<RunHealthSnapshot>;
+export type OrchestrationPhase = "created" | "running" | "waiting" | "completed" | "failed";
+export interface OrchestrationStatus {
+    runId: string;
+    processId: string;
+    phase: OrchestrationPhase;
+    iterationCount: number;
+    totalEffects: number;
+    pendingEffects: number;
+    resolvedEffects: number;
+    failedEffects: number;
+    health: RunHealthSnapshot;
+    createdAt: string;
+    lastActivityAt: string | null;
+}
+/**
+ * Get structured orchestration status for a run.
+ */
+export declare function getOrchestrationStatus(runDir: string): Promise<OrchestrationStatus>;
+export interface PendingWorkItem {
+    effectId: string;
+    taskId?: string;
+    kind?: string;
+    title?: string;
+    requestedAt: string;
+    ageMs: number;
+    labels?: string[];
+}
+/**
+ * List pending (unresolved) effects with rich detail.
+ */
+export declare function getPendingWorkItems(runDir: string): Promise<PendingWorkItem[]>;
+//# sourceMappingURL=runStatus.d.ts.map

package/dist/observability/runStatus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runStatus.d.ts","sourceRoot":"","sources":["../../src/observability/runStatus.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAMjD;;GAEG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,iBAAiB,CAAC,CAG5B;AAMD,MAAM,MAAM,kBAAkB,GAC1B,SAAS,GACT,SAAS,GACT,SAAS,GACT,WAAW,GACX,QAAQ,CAAC;AAEb,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,kBAAkB,CAAC;IAC1B,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED;;GAEG;AACH,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,mBAAmB,CAAC,CAqC9B;AAMD,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,eAAe,EAAE,CAAC,CA4E5B"}

package/dist/observability/runStatus.js

@@ -0,0 +1,169 @@
+"use strict";
+/**
+ * Run status and inspection APIs (GAP-OBS-001, GAP-UX-005, GAP-UX-006).
+ *
+ * - getRunHealthSnapshot: wraps computeRunHealthFromEvents with journal loading
+ * - getOrchestrationStatus: structured status view combining metadata, health, effects
+ * - getPendingWorkItems: detailed inspection of pending effects
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRunHealthSnapshot = getRunHealthSnapshot;
+exports.getOrchestrationStatus = getOrchestrationStatus;
+exports.getPendingWorkItems = getPendingWorkItems;
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+const babysitter_sdk_1 = require("@a5c-ai/babysitter-sdk");
+const health_1 = require("./health");
+// ---------------------------------------------------------------------------
+// GAP-OBS-001: Run Health Snapshot
+// ---------------------------------------------------------------------------
+/**
+ * Compute a health snapshot for a run by loading its journal.
+ */
+async function getRunHealthSnapshot(runDir) {
+    const events = await (0, babysitter_sdk_1.loadJournal)(runDir);
+    return (0, health_1.computeRunHealthFromEvents)(events);
+}
+/**
+ * Get structured orchestration status for a run.
+ */
+async function getOrchestrationStatus(runDir) {
+    const [metadata, events] = await Promise.all([
+        (0, babysitter_sdk_1.readRunMetadata)(runDir),
+        (0, babysitter_sdk_1.loadJournal)(runDir),
+    ]);
+    const health = (0, health_1.computeRunHealthFromEvents)(events);
+    // Determine phase from events
+    let phase = "created";
+    const hasCompleted = events.some((e) => e.type === "RUN_COMPLETED");
+    const hasFailed = events.some((e) => e.type === "RUN_FAILED");
+    const hasPending = health.metrics.pendingCount > 0;
+    if (hasFailed) {
+        phase = "failed";
+    }
+    else if (hasCompleted) {
+        phase = "completed";
+    }
+    else if (hasPending) {
+        phase = "waiting";
+    }
+    else if (events.length > 1) {
+        phase = "running";
+    }
+    return {
+        runId: metadata.runId,
+        processId: metadata.processId,
+        phase,
+        iterationCount: health.metrics.iterationCount,
+        totalEffects: health.metrics.totalEffects,
+        pendingEffects: health.metrics.pendingCount,
+        resolvedEffects: health.metrics.resolvedEffects,
+        failedEffects: health.metrics.failedEffects,
+        health,
+        createdAt: metadata.createdAt,
+        lastActivityAt: health.metrics.lastActivityAt,
+    };
+}
+/**
+ * List pending (unresolved) effects with rich detail.
+ */
+async function getPendingWorkItems(runDir) {
+    const events = await (0, babysitter_sdk_1.loadJournal)(runDir);
+    const now = Date.now();
+    // Track requested and resolved effect IDs
+    const requested = new Map();
+    const resolved = new Set();
+    for (const event of events) {
+        if (event.type === "EFFECT_REQUESTED") {
+            const effectId = typeof event.data.effectId === "string"
+                ? event.data.effectId
+                : undefined;
+            if (effectId) {
+                requested.set(effectId, {
+                    effectId,
+                    requestedAt: event.recordedAt,
+                    data: event.data,
+                });
+            }
+        }
+        if (event.type === "EFFECT_RESOLVED") {
+            const effectId = typeof event.data.effectId === "string"
+                ? event.data.effectId
+                : undefined;
+            if (effectId) {
+                resolved.add(effectId);
+            }
+        }
+    }
+    // Build pending items
+    const items = [];
+    for (const [effectId, req] of requested) {
+        if (resolved.has(effectId))
+            continue;
+        const reqTs = new Date(req.requestedAt).getTime();
+        // Try to read task definition for richer details
+        let title;
+        let kind;
+        let taskId;
+        let labels;
+        try {
+            const taskPath = path.join(runDir, "tasks", effectId, "task.json");
+            const raw = await node_fs_1.promises.readFile(taskPath, "utf-8");
+            const taskDef = JSON.parse(raw);
+            title = typeof taskDef.title === "string" ? taskDef.title : undefined;
+            kind = typeof taskDef.kind === "string" ? taskDef.kind : undefined;
+            taskId = typeof taskDef.taskId === "string" ? taskDef.taskId : undefined;
+            labels = Array.isArray(taskDef.labels) ? taskDef.labels : undefined;
+        }
+        catch {
+            // Task def may not exist for all effect types
+            kind = typeof req.data.kind === "string" ? req.data.kind : undefined;
+            taskId = typeof req.data.taskId === "string" ? req.data.taskId : undefined;
+        }
+        items.push({
+            effectId,
+            taskId,
+            kind,
+            title,
+            requestedAt: req.requestedAt,
+            ageMs: now - reqTs,
+            labels,
+        });
+    }
+    // Sort by age descending (oldest first)
+    items.sort((a, b) => b.ageMs - a.ageMs);
+    return items;
+}