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

package/dist/src/local-run-changes.d.ts

@@ -0,0 +1,3 @@
+import { Stream } from "effect";
+export declare function isRelevantLocalRunChange(filename: string | Buffer | null | undefined): boolean;
+export declare const localRunChanges: (projectRoot: string) => Stream.Stream<void>;

package/dist/src/local-run-changes.js

@@ -0,0 +1,65 @@
+// @bun
+// packages/run-worker/src/local-run-changes.ts
+import { existsSync, mkdirSync, watch } from "fs";
+import { dirname, resolve } from "path";
+import { Effect, Queue, Stream } from "effect";
+function findNearestGitCheckoutRoot(startDir) {
+  let current = resolve(startDir);
+  for (;; ) {
+    if (existsSync(resolve(current, ".git")))
+      return current;
+    const parent = dirname(current);
+    if (parent === current)
+      return null;
+    current = parent;
+  }
+}
+function resolveCheckoutRoot(projectRoot) {
+  const normalizedProjectRoot = resolve(projectRoot);
+  const explicit = process.env.MONOREPO_ROOT?.trim();
+  if (explicit) {
+    const explicitRoot = resolve(explicit);
+    const gitRoot = findNearestGitCheckoutRoot(explicitRoot);
+    if (gitRoot)
+      return gitRoot;
+    throw new Error(`MONOREPO_ROOT points to ${explicitRoot}, but no git checkout was found there or above it.`);
+  }
+  return findNearestGitCheckoutRoot(normalizedProjectRoot) ?? normalizedProjectRoot;
+}
+function isRelevantLocalRunChange(filename) {
+  if (filename === null || filename === undefined)
+    return true;
+  const raw = filename.toString();
+  if (!raw.trim())
+    return true;
+  const segments = raw.split(/[\\/]+/).filter(Boolean);
+  if (segments.some((segment) => segment === ".git" || segment === "node_modules" || segment === "build" || segment === "dist" || segment === "out" || segment === ".next" || segment === "coverage")) {
+    return false;
+  }
+  const rigIndex = segments.lastIndexOf(".rig");
+  if (rigIndex < 0)
+    return false;
+  const rigChild = segments[rigIndex + 1];
+  if (rigChild === "session")
+    return true;
+  return rigChild === "runtime-context.json" && segments[rigIndex + 2] === undefined;
+}
+var localRunChanges = (projectRoot) => Stream.callback((queue) => Effect.gen(function* () {
+  const worktreesRoot = resolve(resolveCheckoutRoot(projectRoot), ".worktrees");
+  if (!existsSync(worktreesRoot)) {
+    try {
+      mkdirSync(worktreesRoot, { recursive: true });
+    } catch {}
+  }
+  const watcher = watch(worktreesRoot, { recursive: true }, (_event, filename) => {
+    if (!isRelevantLocalRunChange(filename))
+      return;
+    Queue.offerUnsafe(queue, undefined);
+  });
+  watcher.on("error", () => {});
+  yield* Effect.addFinalizer(() => Effect.sync(() => watcher.close()));
+}), { bufferSize: 1, strategy: "sliding" });
+export {
+  localRunChanges,
+  isRelevantLocalRunChange
+};

package/dist/src/notifications.js

@@ -1,15 +1,23 @@
 // @bun
+// packages/run-worker/src/notify-cap.ts
+import { NOTIFY_SERVICE_CAPABILITY } from "@rig/contracts";
+import { defineCapability } from "@rig/core/capability";
+import { resolvePluginHost } from "@rig/core/project-plugins";
+var NotifyCap = defineCapability(NOTIFY_SERVICE_CAPABILITY);
+async function resolveNotifyService(projectRoot) {
+  const { host } = await resolvePluginHost(projectRoot);
+  return NotifyCap.resolve(host);
+}
+
 // packages/run-worker/src/notifications.ts
-import { resolve } from "path";
-import { dispatchEventToTargets, loadNotificationConfig } from "@rig/notifications-plugin/notifications";
 async function dispatchRunNotifications(projectRoot, runId, taskId, outcome, detail) {
   try {
-    const config = await loadNotificationConfig(resolve(projectRoot, ".rig", "notifications.json"));
-    if (config.targets.length === 0)
+    const notifier = await resolveNotifyService(projectRoot);
+    if (!notifier)
       return;
     const event = { runId, type: `run.${outcome}`, timestamp: new Date().toISOString(), payload: { taskId, detail } };
     await Promise.race([
-      dispatchEventToTargets(event, config.targets),
+      notifier.notify(event),
       new Promise((resolveCap) => setTimeout(resolveCap, 5000))
     ]);
   } catch {}

package/dist/src/notify-cap.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Cross-plugin seam: run-exec dispatches run notifications off the host's
+ * NOTIFY capability instead of importing `@rig/notifications-plugin`'s impl
+ * (`dispatchEventToTargets`/`loadNotificationConfig`). `@rig/notifications-plugin`
+ * OWNS the policy (target selection + `.rig/notifications.json` load) and
+ * registers it under {@link NOTIFY_SERVICE_CAPABILITY}; this module is the
+ * run-exec-side resolver so no run-exec file imports the provider impl.
+ */
+import { type NotifyService } from "@rig/contracts";
+/** Resolve the notify service from the project's plugin host, or `null` if unregistered. */
+export declare function resolveNotifyService(projectRoot: string): Promise<NotifyService | null>;

package/dist/src/notify-cap.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/run-worker/src/notify-cap.ts
+import { NOTIFY_SERVICE_CAPABILITY } from "@rig/contracts";
+import { defineCapability } from "@rig/core/capability";
+import { resolvePluginHost } from "@rig/core/project-plugins";
+var NotifyCap = defineCapability(NOTIFY_SERVICE_CAPABILITY);
+async function resolveNotifyService(projectRoot) {
+  const { host } = await resolvePluginHost(projectRoot);
+  return NotifyCap.resolve(host);
+}
+export {
+  resolveNotifyService
+};

package/dist/src/panel-plugin.js

@@ -1,6 +1,6 @@
 // @bun
 // packages/run-worker/src/panel-plugin.ts
-import { createProjectPluginHost, projectPluginResolutionWarningMessages } from "@rig/core/project-plugins";
+import { createProjectPluginHost } from "@rig/core/project-plugins";
 import { RIG_CAPABILITY_PANEL_SLOT, RIG_RUN_STOP_PANEL_ACTION, RIG_SUPERVISOR_PANEL_ID } from "@rig/contracts";
 var RIG_PANELS_CUSTOM_MESSAGE_TYPE = "rig-panels";
 var PANEL_PRODUCER_TIMEOUT_MS = 2000;
@@ -20,13 +20,9 @@ async function produceWorkerPanelPayload(producer, context) {
   }
 }
 async function loadWorkerPanelRegistry(projectRoot) {
-  const { host, resolved } = await createProjectPluginHost(projectRoot, {
-    mode: "strict-config-only",
-    surfaceName: "run-worker-panel-registry"
+  const { host } = await createProjectPluginHost(projectRoot, {
+    mode: "strict-config-only"
   });
-  for (const message of projectPluginResolutionWarningMessages(resolved)) {
-    console.warn(`[rig-run] ${message}`);
-  }
   return {
     registrations: host.listPanels().filter((registration) => registration.slot === RIG_CAPABILITY_PANEL_SLOT),
     producers: host.listExecutablePanels().filter((registration) => registration.slot === RIG_CAPABILITY_PANEL_SLOT)

package/dist/src/plugin.d.ts

@@ -1,14 +1,3 @@
 import { type RigPlugin } from "@rig/core/config";
-/**
- * The run lifecycle is a real plugin contribution: it installs the run-worker
- * session extension (plan→implement→validate→commit→PR→merge→closeout) into
- * an agent session.
- *
- * CRITICAL: `install` lazily `await import("./extension")` rather than a
- * top-level import so that config-time evaluation of this plugin does NOT drag
- * the heavy autohost execution stack into every plugin-host load (architecture
- * §8). The heavy module is only pulled in when an agent session actually
- * installs the extension.
- */
 export declare const runWorkerPlugin: RigPlugin;
 export declare function createRunWorkerPlugin(): RigPlugin;