@h-rig/run-worker 0.0.6-alpha.156 → 0.0.6-alpha.158

package/dist/src/utils.js

@@ -1,7 +1,286 @@
 // @bun
 // packages/run-worker/src/utils.ts
-import { createWorkflowStatusChanged, RIG_WORKFLOW_STATUS_CHANGED } from "@rig/contracts";
-import { resolveRegistryBaseUrl, resolveRelayUrl } from "@rig/runtime/control-plane/remote-config";
+import { RIG_WORKFLOW_STATUS_CHANGED as RIG_WORKFLOW_STATUS_CHANGED2 } from "@rig/contracts";
+
+// packages/run-worker/src/session-journal.ts
+import { Schema } from "effect";
+import {
+  CUSTOM_TYPE_FOR,
+  RIG_CONTROL_SENTINEL_END,
+  RIG_INBOX_RESOLUTION_SENTINEL,
+  RIG_PAUSE_SENTINEL,
+  RIG_RESUME_SENTINEL,
+  RIG_STOP_SENTINEL,
+  RIG_STOP_SENTINEL_END,
+  RIG_WORKFLOW_STATUS_CHANGED,
+  RunJournalEvent,
+  TYPE_FOR_CUSTOM
+} from "@rig/contracts";
+var decodeRunJournalEvent = Schema.decodeUnknownSync(RunJournalEvent);
+var RUN_STATUS_TRANSITIONS = {
+  created: ["queued", "preparing", "running", "failed", "stopped"],
+  queued: ["preparing", "running", "failed", "stopped"],
+  preparing: ["queued", "running", "needs-attention", "failed", "stopped"],
+  running: [
+    "queued",
+    "waiting-approval",
+    "waiting-user-input",
+    "paused",
+    "validating",
+    "reviewing",
+    "closing-out",
+    "needs-attention",
+    "completed",
+    "failed",
+    "stopped"
+  ],
+  "waiting-approval": ["running", "needs-attention", "failed", "stopped"],
+  "waiting-user-input": ["running", "needs-attention", "failed", "stopped"],
+  paused: ["running", "failed", "stopped"],
+  validating: ["running", "reviewing", "closing-out", "needs-attention", "completed", "failed", "stopped"],
+  reviewing: ["running", "validating", "closing-out", "needs-attention", "completed", "failed", "stopped"],
+  "closing-out": ["running", "needs-attention", "completed", "failed", "stopped"],
+  "needs-attention": ["queued", "preparing", "running", "closing-out", "completed", "failed", "stopped"],
+  completed: [],
+  failed: ["queued", "preparing", "running", "closing-out"],
+  stopped: ["queued", "preparing", "running", "closing-out"]
+};
+var TERMINAL_RUN_STATUSES = ["completed", "failed", "stopped"];
+function isTerminalRunStatus(status) {
+  return TERMINAL_RUN_STATUSES.includes(status);
+}
+function canTransitionRunStatus(from, to) {
+  if (from === null)
+    return true;
+  if (from === to)
+    return true;
+  return RUN_STATUS_TRANSITIONS[from].includes(to);
+}
+function assertRunStatusTransition(from, to) {
+  if (!canTransitionRunStatus(from, to)) {
+    throw new Error(`Illegal run status transition: ${from ?? "(none)"} -> ${to}. ` + `Allowed from ${from ?? "(none)"}: ${from ? RUN_STATUS_TRANSITIONS[from].join(", ") : "(any)"}.`);
+  }
+}
+function reduceRunJournal(events, runId = null) {
+  let record = {};
+  let status = null;
+  const statusHistory = [];
+  const pendingApprovals = new Map;
+  const resolvedApprovals = [];
+  const pendingUserInputs = new Map;
+  const resolvedUserInputs = [];
+  const closeoutPhases = [];
+  let resolvedPipeline = null;
+  const stageOutcomes = [];
+  const anomalies = [];
+  let steeringCount = 0;
+  let stallCount = 0;
+  let lastSeq = 0;
+  let lastEventAt = null;
+  const projectedRunId = runId ?? events[0]?.runId ?? null;
+  for (const event of events) {
+    lastSeq = event.seq;
+    lastEventAt = event.at;
+    switch (event.type) {
+      case "status-changed": {
+        if (!canTransitionRunStatus(status, event.to)) {
+          anomalies.push({ seq: event.seq, kind: "illegal-transition", detail: `${status ?? "(none)"} -> ${event.to}` });
+        }
+        statusHistory.push({ seq: event.seq, at: event.at, from: status, to: event.to, reason: event.reason ?? null });
+        const wasTerminal = status !== null && isTerminalRunStatus(status);
+        status = event.to;
+        record = { ...record, updatedAt: event.at };
+        if (isTerminalRunStatus(event.to) && !record.completedAt)
+          record = { ...record, completedAt: event.at };
+        if (!isTerminalRunStatus(event.to) && wasTerminal)
+          record = { ...record, completedAt: null };
+        if (event.to === "running" && !record.startedAt)
+          record = { ...record, startedAt: event.at };
+        break;
+      }
+      case "record-patch": {
+        const next = { ...record };
+        for (const [key, value] of Object.entries(event.patch)) {
+          if (value !== undefined)
+            next[key] = value;
+        }
+        next.updatedAt = event.patch.updatedAt ?? event.at;
+        record = next;
+        break;
+      }
+      case "approval-requested": {
+        pendingApprovals.set(event.requestId, {
+          requestId: event.requestId,
+          requestKind: event.requestKind,
+          actionId: event.actionId ?? null,
+          payload: event.payload,
+          requestedAt: event.at
+        });
+        break;
+      }
+      case "approval-resolved": {
+        const pending = pendingApprovals.get(event.requestId);
+        if (!pending) {
+          const alreadyResolved = resolvedApprovals.some((entry) => entry.requestId === event.requestId);
+          anomalies.push({ seq: event.seq, kind: alreadyResolved ? "duplicate-resolution" : "unknown-request", detail: `approval ${event.requestId}` });
+          break;
+        }
+        pendingApprovals.delete(event.requestId);
+        resolvedApprovals.push({ ...pending, decision: event.decision, note: event.note ?? null, actor: event.actor, resolvedAt: event.at });
+        break;
+      }
+      case "input-requested": {
+        pendingUserInputs.set(event.requestId, {
+          requestId: event.requestId,
+          requestKind: "user-input",
+          actionId: null,
+          payload: event.payload,
+          requestedAt: event.at
+        });
+        break;
+      }
+      case "input-resolved": {
+        const pending = pendingUserInputs.get(event.requestId);
+        if (!pending) {
+          const alreadyResolved = resolvedUserInputs.some((entry) => entry.requestId === event.requestId);
+          anomalies.push({ seq: event.seq, kind: alreadyResolved ? "duplicate-resolution" : "unknown-request", detail: `user-input ${event.requestId}` });
+          break;
+        }
+        pendingUserInputs.delete(event.requestId);
+        resolvedUserInputs.push({ ...pending, answers: event.answers, actor: event.actor, resolvedAt: event.at });
+        break;
+      }
+      case "steering":
+        steeringCount += 1;
+        break;
+      case "adopted":
+        record = { ...record, pid: event.pid, updatedAt: event.at };
+        break;
+      case "stall-detected":
+        stallCount += 1;
+        break;
+      case "closeout-phase":
+        closeoutPhases.push({ seq: event.seq, at: event.at, phase: event.phase, outcome: event.outcome, detail: event.detail ?? null });
+        break;
+      case "pipeline-resolved":
+        resolvedPipeline = event.pipeline;
+        break;
+      case "stage-outcome":
+        stageOutcomes.push({ seq: event.seq, at: event.at, outcome: event.outcome });
+        break;
+      case "timeline-entry":
+      case "log-entry":
+        break;
+    }
+  }
+  return {
+    runId: projectedRunId,
+    record,
+    status,
+    statusHistory,
+    pendingApprovals: [...pendingApprovals.values()],
+    resolvedApprovals,
+    pendingUserInputs: [...pendingUserInputs.values()],
+    resolvedUserInputs,
+    steeringCount,
+    stallCount,
+    closeoutPhases,
+    resolvedPipeline,
+    stageOutcomes,
+    lastSeq,
+    lastEventAt,
+    anomalies
+  };
+}
+function isRunSessionCustomType(customType) {
+  return customType !== undefined && Object.hasOwn(TYPE_FOR_CUSTOM, customType);
+}
+function foldRunSessionEntries(entries, runId) {
+  const events = [];
+  entries.forEach((entry, index) => {
+    if (entry.type !== "custom" || !isRunSessionCustomType(entry.customType))
+      return;
+    const data = entry.data !== null && typeof entry.data === "object" ? entry.data : {};
+    const stamped = {
+      v: 1,
+      seq: index + 1,
+      at: typeof data.at === "string" ? data.at : new Date(0).toISOString(),
+      runId,
+      ...data,
+      type: TYPE_FOR_CUSTOM[entry.customType]
+    };
+    try {
+      events.push(decodeRunJournalEvent(stamped));
+    } catch {}
+  });
+  return reduceRunJournal(events, runId);
+}
+function asCustomEntries(entries) {
+  return entries.filter((entry) => entry.type === "custom");
+}
+
+class RunSessionJournal {
+  sm;
+  runId;
+  constructor(sm, runId) {
+    this.sm = sm;
+    this.runId = runId;
+  }
+  #append(init) {
+    this.sm.appendCustomEntry(CUSTOM_TYPE_FOR[init.type], { ...init, at: new Date().toISOString() });
+  }
+  appendStatus(to, opts = {}) {
+    const from = foldRunSessionEntries(asCustomEntries(this.sm.getEntries()), this.runId).status;
+    if (!opts.force)
+      assertRunStatusTransition(from, to);
+    if (opts.errorText !== undefined)
+      this.#append({ type: "record-patch", patch: { errorText: opts.errorText } });
+    this.#append({
+      type: "status-changed",
+      from,
+      to,
+      ...opts.reason !== undefined ? { reason: opts.reason } : {},
+      ...opts.actor !== undefined ? { actor: opts.actor } : {}
+    });
+  }
+  appendTimeline(payload) {
+    this.#append({ type: "timeline-entry", payload });
+  }
+  appendCloseoutPhase(input) {
+    this.#append({
+      type: "closeout-phase",
+      phase: input.phase,
+      outcome: input.outcome,
+      ...input.detail !== undefined ? { detail: input.detail } : {}
+    });
+  }
+  appendApprovalResolved(input) {
+    this.#append({
+      type: "approval-resolved",
+      requestId: input.requestId,
+      decision: input.decision,
+      actor: input.actor,
+      ...input.note !== undefined ? { note: input.note } : {}
+    });
+  }
+  appendInputResolved(input) {
+    this.#append({ type: "input-resolved", requestId: input.requestId, answers: input.answers, actor: input.actor });
+  }
+  appendStall(input) {
+    this.#append({ type: "stall-detected", detail: input.detail });
+  }
+}
+function createWorkflowStatusChanged(input) {
+  return {
+    schemaVersion: 1,
+    status: input.status,
+    ...input.detail ? { detail: input.detail } : {},
+    changedAt: input.changedAt ?? new Date().toISOString()
+  };
+}
+
+// packages/run-worker/src/utils.ts
+import { resolveRegistryBaseUrl, resolveRelayUrl } from "@rig/core/remote-config";
 function isRecord(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
@@ -14,7 +293,7 @@ function customEntries(entries) {
   return customs;
 }
 function appendStatus(api, status, detail) {
-  api.appendEntry(RIG_WORKFLOW_STATUS_CHANGED, createWorkflowStatusChanged({
+  api.appendEntry(RIG_WORKFLOW_STATUS_CHANGED2, createWorkflowStatusChanged({
     status,
     ...detail ? { detail } : {}
   }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@h-rig/run-worker",
-  "version": "0.0.6-alpha.156",
+  "version": "0.0.6-alpha.158",
   "type": "module",
   "description": "Rig package",
   "license": "UNLICENSED",
@@ -13,9 +13,9 @@
       "types": "./dist/src/index.d.ts",
       "import": "./dist/src/index.js"
     },
-    "./runs": {
-      "types": "./dist/src/runs/index.d.ts",
-      "import": "./dist/src/runs/index.js"
+    "./host": {
+      "types": "./dist/src/host.d.ts",
+      "import": "./dist/src/host.js"
     }
   },
   "engines": {
@@ -30,15 +30,12 @@
     ]
   },
   "dependencies": {
+    "@oh-my-pi/omp-stats": "16.0.4",
     "@oh-my-pi/pi-coding-agent": "16.0.4",
-    "@rig/bundle-default-lifecycle": "npm:@h-rig/bundle-default-lifecycle@0.0.6-alpha.156",
-    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.156",
-    "@rig/core": "npm:@h-rig/core@0.0.6-alpha.156",
-    "@rig/github-provider-plugin": "npm:@h-rig/github-provider-plugin@0.0.6-alpha.156",
-    "@rig/kernel": "npm:@h-rig/kernel@0.0.6-alpha.156",
-    "@rig/notifications-plugin": "npm:@h-rig/notifications-plugin@0.0.6-alpha.156",
-    "@rig/relay-registry": "npm:@h-rig/relay-registry@0.0.6-alpha.156",
-    "@rig/runtime": "npm:@h-rig/runtime@0.0.6-alpha.156",
+    "@oh-my-pi/pi-utils": "16.0.4",
+    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.158",
+    "@rig/core": "npm:@h-rig/core@0.0.6-alpha.158",
+    "@rig/kernel-seed": "npm:@h-rig/kernel-seed@0.0.6-alpha.158",
     "effect": "4.0.0-beta.90"
   }
 }

package/dist/src/journal.d.ts

@@ -1,33 +0,0 @@
-import type { ExtensionContext } from "@oh-my-pi/pi-coding-agent";
-import type { ApprovalDecision, RunActor, RunCloseoutPhase, RunCloseoutPhaseOutcome, RunStatus } from "@rig/contracts";
-import { type JournalSessionProvider } from "@rig/kernel/journal-session-provider";
-export type RunJournal = {
-    readonly kernel: JournalSessionProvider;
-    appendStatus(to: RunStatus, opts?: {
-        reason?: string | null;
-        actor?: RunActor;
-        errorText?: string | null;
-        force?: boolean;
-    }): void;
-    appendTimeline(payload: unknown): void;
-    appendCloseoutPhase(input: {
-        phase: RunCloseoutPhase;
-        outcome: RunCloseoutPhaseOutcome;
-        detail?: string | null;
-    }): void;
-    appendApprovalResolved(input: {
-        requestId: string;
-        decision: ApprovalDecision;
-        note?: string | null;
-        actor: RunActor;
-    }): void;
-    appendInputResolved(input: {
-        requestId: string;
-        answers: Record<string, string>;
-        actor: RunActor;
-    }): void;
-    appendStall(input: {
-        detail: string;
-    }): void;
-};
-export declare function createRunJournal(sessionManager: ExtensionContext["sessionManager"], runId: string): Promise<RunJournal | null>;

package/dist/src/journal.js

@@ -1,31 +0,0 @@
-// @bun
-// packages/run-worker/src/journal.ts
-import { createJournalSessionProvider } from "@rig/kernel/journal-session-provider";
-import { RunSessionJournal } from "@rig/runtime/control-plane/run-session-writer";
-async function createRunJournal(sessionManager, runId) {
-  try {
-    const journal = new RunSessionJournal(sessionManager, runId);
-    const kernel = createJournalSessionProvider({
-      runId,
-      store: {
-        appendCustomEntry: (customType, data) => sessionManager.appendCustomEntry(customType, data),
-        getEntries: () => sessionManager.getEntries?.() ?? sessionManager.getBranch?.() ?? []
-      }
-    });
-    return {
-      kernel,
-      appendStatus: journal.appendStatus.bind(journal),
-      appendTimeline: journal.appendTimeline.bind(journal),
-      appendCloseoutPhase: journal.appendCloseoutPhase.bind(journal),
-      appendApprovalResolved: journal.appendApprovalResolved.bind(journal),
-      appendInputResolved: journal.appendInputResolved.bind(journal),
-      appendStall: journal.appendStall.bind(journal)
-    };
-  } catch (error) {
-    console.warn(`[rig-run] RunSessionJournal unavailable; run-state arming deferred: ${error instanceof Error ? error.message : String(error)}`);
-    return null;
-  }
-}
-export {
-  createRunJournal
-};