@h-rig/run-plugin 0.0.6-alpha.186

package/dist/src/worker/run-control-service.d.ts

@@ -0,0 +1,2 @@
+import { type RunControlService } from "@rig/contracts";
+export declare const runControlService: RunControlService;

package/dist/src/worker/run-control-service.js

@@ -0,0 +1,210 @@
+// @bun
+var __require = import.meta.require;
+
+// packages/run-plugin/src/worker/run-control-service.ts
+import { defineCapability } from "@rig/core/capability";
+import { loadCapabilityForRoot } from "@rig/core/capability-loaders";
+import {
+  RIG_CONTROL_SENTINEL_END,
+  RIG_INBOX_RESOLUTION_SENTINEL,
+  RIG_PAUSE_SENTINEL,
+  RIG_RESUME_SENTINEL,
+  RIG_STOP_SENTINEL,
+  RIG_STOP_SENTINEL_END,
+  RUN_READ_MODEL,
+  RUN_SESSION_JOURNAL_WRITER
+} from "@rig/contracts";
+var RunReadModelCap = defineCapability(RUN_READ_MODEL);
+async function readModel(projectRoot) {
+  const service = await loadCapabilityForRoot(projectRoot, RunReadModelCap);
+  if (!service)
+    throw new Error("RUN_READ_MODEL capability unavailable: load @rig/run-plugin before using run control.");
+  return service;
+}
+function buildPauseSentinel(runId) {
+  return `${RIG_PAUSE_SENTINEL} runId=${runId} requestedBy=operator ${RIG_CONTROL_SENTINEL_END}`;
+}
+function buildResumeSentinel(runId) {
+  return `${RIG_RESUME_SENTINEL} runId=${runId} requestedBy=operator ${RIG_CONTROL_SENTINEL_END}`;
+}
+function buildStopSentinel(runId, reason) {
+  return `${RIG_STOP_SENTINEL} runId=${runId} reason=${reason} ${RIG_STOP_SENTINEL_END}`;
+}
+function buildInboxResolutionSentinel(runId, payload) {
+  return `${RIG_INBOX_RESOLUTION_SENTINEL} runId=${runId} data=${encodeURIComponent(JSON.stringify(payload))} requestedBy=operator ${RIG_CONTROL_SENTINEL_END}`;
+}
+function collabControlFrames(runId, control) {
+  switch (control.kind) {
+    case "steer":
+      return [{ t: "prompt", text: control.message }];
+    case "resume":
+      return [{ t: "prompt", text: `${buildResumeSentinel(runId)}
+Continue the run from where it paused.` }];
+    case "pause":
+      return [
+        { t: "prompt", text: `${buildPauseSentinel(runId)}
+Pause this run after the current interruption settles.` },
+        { t: "abort" }
+      ];
+    case "stop":
+      return [
+        { t: "prompt", text: `${buildStopSentinel(runId, control.reason)}
+Stop this run and do not continue after the interruption settles.` },
+        { t: "abort" }
+      ];
+  }
+}
+async function loadCollabControlDeps() {
+  const [{ importRoomKey, seal }, { COLLAB_PROTO, packEnvelope, parseCollabLink }] = await Promise.all([
+    import("@oh-my-pi/pi-coding-agent/collab/crypto"),
+    import("@oh-my-pi/pi-coding-agent/collab/protocol")
+  ]);
+  return { importRoomKey, seal, COLLAB_PROTO, packEnvelope, parseCollabLink };
+}
+async function sendSealedCollabFrames(joinLink, frames) {
+  const { importRoomKey, seal, COLLAB_PROTO, packEnvelope, parseCollabLink } = await loadCollabControlDeps();
+  const parsed = parseCollabLink(joinLink);
+  if ("error" in parsed)
+    throw new Error(parsed.error);
+  if (!parsed.writeToken)
+    throw new Error("Run collab link is read-only; cannot send control.");
+  const key = await importRoomKey(parsed.key);
+  const ws = new WebSocket(`${parsed.wsUrl}?role=guest`);
+  await new Promise((resolveOpen, rejectOpen) => {
+    ws.addEventListener("open", () => resolveOpen(), { once: true });
+    ws.addEventListener("error", () => rejectOpen(new Error("collab websocket error")), { once: true });
+  });
+  const hello = {
+    t: "hello",
+    proto: COLLAB_PROTO,
+    name: "rig-operator",
+    writeToken: Buffer.from(parsed.writeToken).toString("base64url")
+  };
+  ws.send(packEnvelope(0, await seal(key, hello)));
+  for (const frame of frames)
+    ws.send(packEnvelope(0, await seal(key, frame)));
+  try {
+    ws.close();
+  } catch {}
+}
+function isSteerableStatus(status, classification) {
+  switch (status) {
+    case "needs-attention":
+    case "waiting-approval":
+    case "waiting-user-input":
+    case "paused":
+      return false;
+    default:
+      return classification.isActive;
+  }
+}
+function controlAffordance(readModel2, run, purpose) {
+  const writable = Boolean(run.joinLink && !run.stale);
+  if (!writable)
+    return { allowed: false, reason: run.stale ? "run is stale" : "run has no join link" };
+  const classification = readModel2.classifyRun(run);
+  switch (purpose) {
+    case "steer":
+      return classification.phase === "active" || classification.phase === "starting" || classification.isNeedsAttention && isSteerableStatus(classification.status, classification) ? { allowed: true } : { allowed: false, reason: "run cannot be steered in its current phase" };
+    case "stop":
+      return classification.isActive && !classification.isTerminal ? { allowed: true } : { allowed: false, reason: "run cannot be stopped in its current phase" };
+    case "pause":
+      return classification.phase === "active" || classification.phase === "starting" ? { allowed: true } : { allowed: false, reason: "run cannot be paused in its current phase" };
+    case "resume":
+      return classification.phase === "paused" ? { allowed: true } : { allowed: false, reason: "run cannot be resumed in its current phase" };
+    case "restart":
+    case "delete":
+    case "prune":
+      return !run.live || run.stale ? { allowed: true } : { allowed: false, reason: "run is still live" };
+    case "attach":
+    case "resolve-inbox":
+    case undefined:
+      return { allowed: true };
+  }
+}
+async function selectedRun(projectRoot, runId, discoveryFilter) {
+  const service = await readModel(projectRoot);
+  const run = await service.getRun({ projectRoot, selector: { id: runId, kind: "any" }, ...discoveryFilter !== undefined ? { discoveryFilter } : {} });
+  return { service, run };
+}
+function targetFromRun(service, run, purpose) {
+  const affordance = controlAffordance(service, run, purpose);
+  return {
+    runId: run.runId,
+    taskId: run.taskId,
+    sessionId: run.runId,
+    sessionPath: run.sessionPath,
+    joinLink: run.joinLink,
+    webLink: run.webLink,
+    relayUrl: run.relayUrl,
+    collabCwd: run.collabCwd,
+    live: run.live,
+    stale: run.stale,
+    canDeliver: affordance.allowed,
+    reason: affordance.allowed ? null : affordance.reason ?? null
+  };
+}
+function inboxResolutionControl(runId, resolution) {
+  return { kind: "steer", message: buildInboxResolutionSentinel(runId, resolution) };
+}
+var runControlService = {
+  async resolveControlTarget(input) {
+    const { service, run } = await selectedRun(input.projectRoot, input.runId, input.discoveryFilter);
+    return run ? targetFromRun(service, run, input.purpose) : null;
+  },
+  async deliverControl(input) {
+    const { service, run } = await selectedRun(input.projectRoot, input.runId, input.discoveryFilter);
+    if (!run)
+      return { runId: input.runId, kind: input.control.kind, status: "not-found", delivered: false, detail: "run not found" };
+    const affordance = controlAffordance(service, run, input.control.kind);
+    if (!affordance.allowed) {
+      return { runId: run.runId, kind: input.control.kind, status: run.joinLink && !run.stale ? "unsupported" : "not-live", delivered: false, detail: affordance.reason ?? `Run ${run.runId} is not writable in its current phase.` };
+    }
+    try {
+      if (!run.joinLink)
+        throw new Error(`Run ${run.runId} has no writable collab join link; attach interactively to ${input.control.kind}.`);
+      await sendSealedCollabFrames(run.joinLink, collabControlFrames(run.runId, input.control));
+      return { runId: run.runId, kind: input.control.kind, status: "delivered", delivered: true };
+    } catch (error) {
+      return { runId: run.runId, kind: input.control.kind, status: "unsupported", delivered: false, detail: error instanceof Error ? error.message : String(error) };
+    }
+  },
+  async resolveInboxRequest(input) {
+    const target = await this.resolveControlTarget({ projectRoot: input.projectRoot, runId: input.runId, purpose: "resolve-inbox", ...input.discoveryFilter !== undefined ? { discoveryFilter: input.discoveryFilter } : {} });
+    if (!target)
+      return { runId: input.runId, requestId: input.resolution.requestId, kind: input.resolution.kind, status: "not-found", delivered: false, detail: "run not found" };
+    if (!target.canDeliver)
+      return { runId: target.runId, requestId: input.resolution.requestId, kind: input.resolution.kind, status: "not-live", delivered: false, detail: target.reason ?? "run is not deliverable" };
+    const result = await this.deliverControl({ projectRoot: input.projectRoot, runId: target.runId, control: inboxResolutionControl(target.runId, input.resolution), ...input.discoveryFilter !== undefined ? { discoveryFilter: input.discoveryFilter } : {} });
+    const status = result.delivered ? "resolved" : result.status === "delivered" ? "resolved" : result.status;
+    return { runId: target.runId, requestId: input.resolution.requestId, kind: input.resolution.kind, status, delivered: result.delivered, ...result.detail !== undefined ? { detail: result.detail } : {} };
+  },
+  async resolveResumePlan(input) {
+    const { service, run } = await selectedRun(input.projectRoot, input.runId, input.discoveryFilter);
+    if (!run)
+      return null;
+    const affordance = controlAffordance(service, run, "resume");
+    if (affordance.allowed)
+      return { kind: "deliver-control", runId: run.runId, run };
+    if (!run.live || run.stale) {
+      return run.taskId ? { kind: "redispatch-task", runId: run.runId, taskId: run.taskId, title: run.title } : { kind: "unavailable", runId: run.runId, reason: "run is not live and has no task id to re-dispatch" };
+    }
+    return { kind: "unavailable", runId: run.runId, reason: affordance.reason ?? "run cannot be resumed in its current phase" };
+  },
+  async reconcileDeadPid(input) {
+    const RunSessionJournalWriterCap = defineCapability(RUN_SESSION_JOURNAL_WRITER);
+    const writer = await loadCapabilityForRoot(input.projectRoot, RunSessionJournalWriterCap);
+    if (!writer) {
+      return { runId: input.runId, updated: false, status: "unavailable", detail: "RUN_SESSION_JOURNAL_WRITER capability unavailable" };
+    }
+    return writer.reconcileDeadPid({
+      projectRoot: input.projectRoot,
+      runId: input.runId,
+      sessionPath: input.sessionPath,
+      ...input.reason !== undefined ? { reason: input.reason } : {}
+    });
+  }
+};
+export {
+  runControlService
+};

package/dist/src/worker/session-journal-writer.d.ts

@@ -0,0 +1,4 @@
+import { type RunDeadPidJournalReconciliationInput, type RunDeadPidJournalReconciliationResult, type RunJournal, type RunJournalSessionManager, type RunSessionJournalWriterService } from "@rig/contracts";
+export declare function createRunJournal(sessionManager: RunJournalSessionManager, runId: string): Promise<RunJournal | null>;
+export declare function reconcileDeadPid(input: RunDeadPidJournalReconciliationInput): Promise<RunDeadPidJournalReconciliationResult>;
+export declare const runSessionJournalWriterService: RunSessionJournalWriterService;

package/dist/src/worker/session-journal-writer.js

@@ -0,0 +1,184 @@
+// @bun
+var __require = import.meta.require;
+
+// packages/run-plugin/src/worker/session-journal-writer.ts
+import { defineCapability } from "@rig/core/capability";
+import { getInstalledCapability, installCapability, loadCapabilityForRoot } from "@rig/core/capability-loaders";
+import {
+  CUSTOM_TYPE_FOR,
+  RUN_SESSION_JOURNAL
+} from "@rig/contracts";
+var RunSessionJournalCap = defineCapability(RUN_SESSION_JOURNAL);
+function requireReadCodec() {
+  const codec = getInstalledCapability(RunSessionJournalCap);
+  if (!codec) {
+    throw new Error("RUN_SESSION_JOURNAL codec capability unavailable: the run-worker autohost / run-host preboot install it before binding the journal writer; ensure @rig/run-plugin (default bundle) is installed.");
+  }
+  return codec;
+}
+function asCustomEntries(entries) {
+  return entries.filter((entry) => Boolean(entry && typeof entry === "object" && entry.type === "custom"));
+}
+function dataRecord(entry) {
+  return entry.data && typeof entry.data === "object" && !Array.isArray(entry.data) ? entry.data : null;
+}
+function entryBelongsToRun(entry, runId, defaultRunId) {
+  const data = dataRecord(entry);
+  if (!data)
+    return runId === defaultRunId;
+  const candidate = data.runId;
+  return candidate === undefined ? runId === defaultRunId : candidate === runId;
+}
+function isRunJournalEventInit(event) {
+  if (event === null || typeof event !== "object")
+    return false;
+  const type = event.type;
+  return typeof type === "string" && Object.hasOwn(CUSTOM_TYPE_FOR, type);
+}
+function createJournalSessionProvider(options) {
+  const now = options.now ?? (() => new Date);
+  const appendRunEvent = async (event, runId = options.runId) => {
+    options.store.appendCustomEntry(CUSTOM_TYPE_FOR[event.type], { ...event, runId, at: now().toISOString() });
+  };
+  const readEntries = () => asCustomEntries(options.store.getEntries());
+  const entriesForRun = (runId) => readEntries().filter((entry) => entryBelongsToRun(entry, runId, options.runId));
+  const readProjection = () => {
+    const entries = entriesForRun(options.runId);
+    return requireReadCodec().projectRunFromSession(entries, options.runId);
+  };
+  return {
+    runId: options.runId,
+    async append(event) {
+      if (isRunJournalEventInit(event))
+        await appendRunEvent(event);
+    },
+    appendRunEvent,
+    async recordPipeline(runId, pipeline) {
+      await appendRunEvent({ type: "pipeline-resolved", pipeline }, runId);
+    },
+    async recordStageOutcome(runId, outcome) {
+      await appendRunEvent({ type: "stage-outcome", outcome }, runId);
+    },
+    async read(runId) {
+      return entriesForRun(runId);
+    },
+    readEntries,
+    readProjection
+  };
+}
+
+class RunSessionJournal {
+  sm;
+  runId;
+  readProjection;
+  constructor(sm, runId, readProjection) {
+    this.sm = sm;
+    this.runId = runId;
+    this.readProjection = readProjection;
+  }
+  #append(init) {
+    this.sm.appendCustomEntry(CUSTOM_TYPE_FOR[init.type], { ...init, at: new Date().toISOString() });
+  }
+  appendStatus(to, opts = {}) {
+    const from = this.readProjection().status;
+    if (!opts.force)
+      requireReadCodec().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 });
+  }
+}
+async function createRunJournal(sessionManager, runId) {
+  try {
+    const writableSessionManager = sessionManager;
+    if (typeof writableSessionManager.appendCustomEntry !== "function")
+      return null;
+    const kernel = createJournalSessionProvider({
+      runId,
+      store: {
+        appendCustomEntry: (customType, data) => writableSessionManager.appendCustomEntry(customType, data),
+        getEntries: () => sessionManager.getEntries?.() ?? sessionManager.getBranch?.() ?? []
+      }
+    });
+    const journal = new RunSessionJournal(writableSessionManager, runId, kernel.readProjection);
+    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 writer unavailable; run-state arming deferred: ${error instanceof Error ? error.message : String(error)}`);
+    return null;
+  }
+}
+async function reconcileDeadPid(input) {
+  if (!input.sessionPath.trim()) {
+    return { runId: input.runId, updated: false, status: "not-found", detail: "session path missing" };
+  }
+  try {
+    const codec = await loadCapabilityForRoot(input.projectRoot, RunSessionJournalCap);
+    if (!codec) {
+      return { runId: input.runId, updated: false, status: "unavailable", detail: "RUN_SESSION_JOURNAL codec capability unavailable" };
+    }
+    installCapability(RunSessionJournalCap, codec);
+    const { SessionManager } = await import("@oh-my-pi/pi-coding-agent/session/session-manager");
+    const session = await SessionManager.open(input.sessionPath, undefined, undefined, { suppressBreadcrumb: true });
+    const journal = await createRunJournal(session, input.runId);
+    if (!journal) {
+      return { runId: input.runId, updated: false, status: "not-found", detail: "run journal not found" };
+    }
+    journal.appendStatus("failed", {
+      reason: input.reason ?? "lazy-reconcile:dead-pid",
+      actor: { kind: "agent" },
+      force: true
+    });
+    return { runId: input.runId, updated: true, status: "reconciled" };
+  } catch (error) {
+    return { runId: input.runId, updated: false, status: "unavailable", detail: error instanceof Error ? error.message : String(error) };
+  }
+}
+var runSessionJournalWriterService = {
+  createRunJournal,
+  reconcileDeadPid
+};
+export {
+  runSessionJournalWriterService,
+  reconcileDeadPid,
+  createRunJournal
+};

package/dist/src/worker/stall.d.ts

@@ -0,0 +1,21 @@
+type StallJournal = {
+    appendStall(input: {
+        detail: string;
+    }): void;
+};
+export declare function timestampMs(value: number | string | Date | null | undefined): number | null;
+export declare function computeRunStall(input: {
+    readonly lastActivityAt: number | string | Date | null | undefined;
+    readonly now: number | string | Date;
+    readonly thresholdMs: number;
+}): boolean;
+export declare function appendRunStallDetected(journal: StallJournal | null | undefined, detail?: string): boolean;
+export declare function startRunProcessStallMonitor(opts: {
+    readonly journal: StallJournal | null | undefined;
+    readonly lastActivityAt: () => number;
+    readonly alreadyStalled?: boolean;
+    readonly thresholdMs?: number;
+    readonly intervalMs?: number;
+    readonly now?: () => number;
+}): () => void;
+export {};

package/dist/src/worker/stall.js

@@ -0,0 +1,55 @@
+// @bun
+// packages/run-plugin/src/worker/constants.ts
+var TRACKED_RUN_STALL_MS = 20 * 60 * 1000;
+var RUN_PROCESS_STALL_SWEEP_MS = 60 * 1000;
+var RUN_PROCESS_STALL_DETAIL = "Run process made no OMP session progress for 20+ minutes; recording a stall so recovery can requeue or resume the session.";
+
+// packages/run-plugin/src/worker/stall.ts
+function timestampMs(value) {
+  if (value === null || value === undefined)
+    return null;
+  const ms = value instanceof Date ? value.getTime() : typeof value === "number" ? value : Date.parse(value);
+  return Number.isFinite(ms) ? ms : null;
+}
+function computeRunStall(input) {
+  const lastActivityAt = timestampMs(input.lastActivityAt);
+  const now = timestampMs(input.now);
+  if (lastActivityAt === null || now === null || input.thresholdMs <= 0)
+    return false;
+  return now - lastActivityAt >= input.thresholdMs;
+}
+function appendRunStallDetected(journal, detail = RUN_PROCESS_STALL_DETAIL) {
+  if (!journal)
+    return false;
+  try {
+    journal.appendStall({ detail });
+    return true;
+  } catch (error) {
+    console.warn(`[rig-run] stall-detected append failed: ${error instanceof Error ? error.message : String(error)}`);
+    return false;
+  }
+}
+function startRunProcessStallMonitor(opts) {
+  if (!opts.journal)
+    return () => {};
+  let stallDetected = opts.alreadyStalled === true;
+  const thresholdMs = opts.thresholdMs ?? TRACKED_RUN_STALL_MS;
+  const now = opts.now ?? (() => Date.now());
+  const timer = setInterval(() => {
+    if (stallDetected)
+      return;
+    if (!computeRunStall({ lastActivityAt: opts.lastActivityAt(), now: now(), thresholdMs }))
+      return;
+    stallDetected = true;
+    appendRunStallDetected(opts.journal);
+  }, opts.intervalMs ?? RUN_PROCESS_STALL_SWEEP_MS);
+  if (typeof timer.unref === "function")
+    timer.unref();
+  return () => clearInterval(timer);
+}
+export {
+  timestampMs,
+  startRunProcessStallMonitor,
+  computeRunStall,
+  appendRunStallDetected
+};

package/dist/src/worker/utils.d.ts

@@ -0,0 +1,21 @@
+import type { ExtensionAPI, ExtensionContext } from "@oh-my-pi/pi-coding-agent";
+import type { ExtensionCollabFacade, CollabRegistryFilter, CollabSessionProjection, ExtensionJoinCollabSessionInput, ExtensionStartCollabHostInput, LiveCollabProjection } from "@oh-my-pi/pi-coding-agent/collab-api";
+import type { CustomEntry } from "@oh-my-pi/pi-coding-agent/session/session-entries";
+import { type RigWorkflowStatus } from "@rig/contracts";
+export type CompatCollabFacade = ExtensionCollabFacade & {
+    listActiveCollabSessions?: (filter?: CollabRegistryFilter) => Promise<readonly LiveCollabProjection[]>;
+    get?: (sessionId: string) => Promise<LiveCollabProjection | null>;
+    getCollabForSession?: (sessionId: string) => Promise<LiveCollabProjection | null>;
+    startCollabHost?: (input: ExtensionStartCollabHostInput) => Promise<LiveCollabProjection>;
+    joinCollabSession?: (input: ExtensionJoinCollabSessionInput) => Promise<void>;
+    listSessions?: (filter?: CollabRegistryFilter) => Promise<readonly CollabSessionProjection[]>;
+};
+export type RigCollabContext = ExtensionContext & {
+    collab?: CompatCollabFacade;
+};
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function customEntries(entries: readonly {
+    type: string;
+}[]): CustomEntry[];
+export declare function appendStatus(api: ExtensionAPI, status: RigWorkflowStatus, detail?: string): void;
+export { rigProjectRootFromEnv as rigProjectRoot } from "@rig/core/root-resolver";

package/dist/src/worker/utils.js

@@ -0,0 +1,29 @@
+// @bun
+// packages/run-plugin/src/worker/utils.ts
+import { RIG_WORKFLOW_STATUS_CHANGED } from "@rig/contracts";
+import { rigProjectRootFromEnv } from "@rig/core/root-resolver";
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function customEntries(entries) {
+  const customs = [];
+  for (const entry of entries) {
+    if (entry.type === "custom")
+      customs.push(entry);
+  }
+  return customs;
+}
+function appendStatus(api, status, detail) {
+  api.appendEntry(RIG_WORKFLOW_STATUS_CHANGED, {
+    schemaVersion: 1,
+    status,
+    ...detail ? { detail } : {},
+    changedAt: new Date().toISOString()
+  });
+}
+export {
+  rigProjectRootFromEnv as rigProjectRoot,
+  isRecord,
+  customEntries,
+  appendStatus
+};

package/dist/src/worker/workflow-journal-writer.d.ts

@@ -0,0 +1,7 @@
+import { type RigWorkflowJournalWriterService, type RigWorkflowOperatorNote, type RigWorkflowOperatorNoteInput, type RigWorkflowStarted, type RigWorkflowStartedInput, type RigWorkflowStatusChanged, type RigWorkflowStatusChangedInput, type RigWorkflowTargetSelected, type RigWorkflowTargetSelectedInput, type RigWorkflowTaskSelected, type RigWorkflowTaskSelectedInput } from "@rig/contracts";
+export declare function createWorkflowStarted(input: RigWorkflowStartedInput): RigWorkflowStarted;
+export declare function createWorkflowTargetSelected(input: RigWorkflowTargetSelectedInput): RigWorkflowTargetSelected;
+export declare function createWorkflowTaskSelected(input: RigWorkflowTaskSelectedInput): RigWorkflowTaskSelected;
+export declare function createWorkflowStatusChanged(input: RigWorkflowStatusChangedInput): RigWorkflowStatusChanged;
+export declare function createWorkflowOperatorNote(input: RigWorkflowOperatorNoteInput): RigWorkflowOperatorNote;
+export declare const workflowJournalWriterService: RigWorkflowJournalWriterService;

package/dist/src/worker/workflow-journal-writer.js

@@ -0,0 +1,76 @@
+// @bun
+// packages/run-plugin/src/worker/workflow-journal-writer.ts
+import {
+  RIG_WORKFLOW_OPERATOR_NOTE,
+  RIG_WORKFLOW_STARTED,
+  RIG_WORKFLOW_STATUS_CHANGED,
+  RIG_WORKFLOW_TARGET_SELECTED,
+  RIG_WORKFLOW_TASK_SELECTED
+} from "@rig/contracts";
+function createWorkflowStarted(input) {
+  return {
+    schemaVersion: 1,
+    workflowId: input.workflowId,
+    target: input.target,
+    selectedRepo: input.selectedRepo,
+    owner: input.owner,
+    createdAt: input.createdAt ?? new Date().toISOString()
+  };
+}
+function createWorkflowTargetSelected(input) {
+  return {
+    schemaVersion: 1,
+    target: input.target,
+    ...input.reason ? { reason: input.reason } : {},
+    selectedAt: input.selectedAt ?? new Date().toISOString()
+  };
+}
+function createWorkflowTaskSelected(input) {
+  return {
+    schemaVersion: 1,
+    taskId: input.taskId,
+    ...input.title ? { title: input.title } : {},
+    selectedAt: input.selectedAt ?? new Date().toISOString()
+  };
+}
+function createWorkflowStatusChanged(input) {
+  return {
+    schemaVersion: 1,
+    status: input.status,
+    ...input.detail ? { detail: input.detail } : {},
+    changedAt: input.changedAt ?? new Date().toISOString()
+  };
+}
+function createWorkflowOperatorNote(input) {
+  return {
+    schemaVersion: 1,
+    ...input.noteId ? { noteId: input.noteId } : {},
+    note: input.note,
+    notedAt: input.notedAt ?? new Date().toISOString()
+  };
+}
+var workflowJournalWriterService = {
+  appendStarted(appender, input) {
+    appender.appendEntry(RIG_WORKFLOW_STARTED, createWorkflowStarted(input));
+  },
+  appendTargetSelected(appender, input) {
+    appender.appendEntry(RIG_WORKFLOW_TARGET_SELECTED, createWorkflowTargetSelected(input));
+  },
+  appendTaskSelected(appender, input) {
+    appender.appendEntry(RIG_WORKFLOW_TASK_SELECTED, createWorkflowTaskSelected(input));
+  },
+  appendStatusChanged(appender, input) {
+    appender.appendEntry(RIG_WORKFLOW_STATUS_CHANGED, createWorkflowStatusChanged(input));
+  },
+  appendOperatorNote(appender, input) {
+    appender.appendEntry(RIG_WORKFLOW_OPERATOR_NOTE, createWorkflowOperatorNote(input));
+  }
+};
+export {
+  workflowJournalWriterService,
+  createWorkflowTaskSelected,
+  createWorkflowTargetSelected,
+  createWorkflowStatusChanged,
+  createWorkflowStarted,
+  createWorkflowOperatorNote
+};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@h-rig/run-plugin",
+  "version": "0.0.6-alpha.186",
+  "type": "module",
+  "description": "Run execution + run read-model: the one owner of run state (worker write path, projection read path).",
+  "license": "UNLICENSED",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/src/plugin.d.ts",
+      "import": "./dist/src/plugin.js"
+    },
+    "./plugin": {
+      "types": "./dist/src/plugin.d.ts",
+      "import": "./dist/src/plugin.js"
+    },
+    "./worker": {
+      "types": "./dist/src/worker/index.d.ts",
+      "import": "./dist/src/worker/index.js"
+    },
+    "./worker/host": {
+      "types": "./dist/src/worker/host.d.ts",
+      "import": "./dist/src/worker/host.js"
+    },
+    "./session-journal": {
+      "types": "./dist/src/read-model/session-journal.d.ts",
+      "import": "./dist/src/read-model/session-journal.js"
+    }
+  },
+  "engines": {
+    "bun": ">=1.3.11"
+  },
+  "dependencies": {
+    "@oh-my-pi/omp-stats": "16.2.4",
+    "@oh-my-pi/pi-coding-agent": "16.2.4",
+    "@oh-my-pi/pi-tui": "16.2.4",
+    "@oh-my-pi/pi-utils": "16.2.4",
+    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.186",
+    "@rig/core": "npm:@h-rig/core@0.0.6-alpha.186",
+    "@rig/std-shared": "npm:@h-rig/std-shared@0.0.6-alpha.186",
+    "effect": "4.0.0-beta.90",
+    "picocolors": "^1.1.1"
+  }
+}