@mestreyoda/fabrica 0.2.2 → 0.2.6

package/dist/index.js

@@ -110821,7 +110821,7 @@ var init_registry = __esm({
 });
 
 // lib/config/merge.ts
-function mergeConfig(base, overlay) {
+function mergeConfig(base, overlay, traceOpts) {
   const merged = {};
   if (base.roles || overlay.roles) {
     merged.roles = { ...base.roles };
@@ -110872,6 +110872,44 @@ function mergeConfig(base, overlay) {
       } : void 0
     };
   }
+  if (traceOpts) {
+    const { baseLabel, overlayLabel } = traceOpts;
+    const trace2 = {};
+    if (merged.workflow) {
+      for (const key of ["initial", "reviewPolicy", "testPolicy", "roleExecution", "maxWorkersPerLevel"]) {
+        if (merged.workflow[key] !== void 0) {
+          const fromOverlay = overlay.workflow?.[key] !== void 0;
+          trace2[`workflow.${key}`] = fromOverlay ? overlayLabel : baseLabel;
+        }
+      }
+    }
+    if (merged.timeouts) {
+      for (const [key, value] of Object.entries(merged.timeouts)) {
+        if (value !== void 0) {
+          const fromOverlay = overlay.timeouts?.[key] !== void 0;
+          trace2[`timeouts.${key}`] = fromOverlay ? overlayLabel : baseLabel;
+        }
+      }
+    }
+    if (merged.roles) {
+      for (const [roleId, roleValue] of Object.entries(merged.roles)) {
+        if (roleValue === false) {
+          trace2[`roles.${roleId}`] = overlay.roles?.[roleId] === false ? overlayLabel : baseLabel;
+          continue;
+        }
+        if (typeof roleValue === "object") {
+          for (const key of ["defaultLevel", "levels", "completionResults"]) {
+            if (roleValue[key] !== void 0) {
+              const overlayRole = overlay.roles?.[roleId];
+              const fromOverlay = typeof overlayRole === "object" && overlayRole?.[key] !== void 0;
+              trace2[`roles.${roleId}.${key}`] = fromOverlay ? overlayLabel : baseLabel;
+            }
+          }
+        }
+      }
+    }
+    return Object.assign(merged, { _trace: trace2 });
+  }
   return merged;
 }
 function mergeWorkflowStates(base, overlay) {
@@ -110917,42 +110955,10 @@ function mergeRoleOverride(base, overlay) {
   };
 }
 function mergeConfigWithTrace(base, overlay, baseLabel, overlayLabel) {
-  const merged = mergeConfig(base, overlay);
-  const trace2 = {};
-  if (merged.workflow) {
-    for (const key of ["initial", "reviewPolicy", "testPolicy", "roleExecution", "maxWorkersPerLevel"]) {
-      if (merged.workflow[key] !== void 0) {
-        const fromOverlay = overlay.workflow?.[key] !== void 0;
-        trace2[`workflow.${key}`] = fromOverlay ? overlayLabel : baseLabel;
-      }
-    }
-  }
-  if (merged.timeouts) {
-    for (const [key, value] of Object.entries(merged.timeouts)) {
-      if (value !== void 0) {
-        const fromOverlay = overlay.timeouts?.[key] !== void 0;
-        trace2[`timeouts.${key}`] = fromOverlay ? overlayLabel : baseLabel;
-      }
-    }
-  }
-  if (merged.roles) {
-    for (const [roleId, roleValue] of Object.entries(merged.roles)) {
-      if (roleValue === false) {
-        trace2[`roles.${roleId}`] = overlay.roles?.[roleId] === false ? overlayLabel : baseLabel;
-        continue;
-      }
-      if (typeof roleValue === "object") {
-        for (const key of ["defaultLevel", "levels", "completionResults"]) {
-          if (roleValue[key] !== void 0) {
-            const overlayRole = overlay.roles?.[roleId];
-            const fromOverlay = typeof overlayRole === "object" && overlayRole?.[key] !== void 0;
-            trace2[`roles.${roleId}.${key}`] = fromOverlay ? overlayLabel : baseLabel;
-          }
-        }
-      }
-    }
-  }
-  return { merged, trace: trace2 };
+  const result = mergeConfig(base, overlay, { baseLabel, overlayLabel });
+  const trace2 = result._trace ?? {};
+  delete result._trace;
+  return { merged: result, trace: trace2 };
 }
 var init_merge = __esm({
   "lib/config/merge.ts"() {
@@ -111324,8 +111330,8 @@ import fsSync from "node:fs";
 import path5 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function getCurrentVersion() {
-  if ("0.2.2") {
-    return "0.2.2";
+  if ("0.2.6") {
+    return "0.2.6";
   }
   try {
     const pkgPath = path5.join(THIS_DIR, "..", "..", "package.json");
@@ -117132,6 +117138,8 @@ var GitHubRateLimitError = class extends Error {
     this.name = "GitHubRateLimitError";
   }
 };
+var MAX_RATE_LIMIT_RETRIES = 2;
+var JITTER_MAX_MS = 5e3;
 var MAX_ENTRIES = 50;
 var policyCache = /* @__PURE__ */ new Map();
 var accessOrder = [];
@@ -117167,9 +117175,27 @@ function getProviderPolicy(providerKey) {
   accessOrder.push(providerKey);
   return policy;
 }
-function withResilience(fn, providerKey) {
+async function withResilience(fn, providerKey, opts) {
   const policy = providerKey ? getProviderPolicy(providerKey) : getProviderPolicy("__global__");
-  return policy.execute(() => fn());
+  const jitterMax = opts?.jitterMaxMs ?? JITTER_MAX_MS;
+  const withRateLimitRetry = async () => {
+    let lastError;
+    for (let attempt = 0; attempt <= MAX_RATE_LIMIT_RETRIES; attempt++) {
+      try {
+        return await fn();
+      } catch (err) {
+        if (err instanceof GitHubRateLimitError && attempt < MAX_RATE_LIMIT_RETRIES) {
+          lastError = err;
+          const jitter = jitterMax > 0 ? Math.floor(Math.random() * jitterMax) : 0;
+          await new Promise((resolve3) => setTimeout(resolve3, err.retryAfterMs + jitter));
+          continue;
+        }
+        throw err;
+      }
+    }
+    throw lastError;
+  };
+  return policy.execute(withRateLimitRetry);
 }
 var providerPolicy = getProviderPolicy("__legacy_global__");
 
@@ -118078,7 +118104,9 @@ var GitHubProvider = class {
       if (result.code != null && result.code !== 0) {
         const errText = result.stderr?.trim() ?? "";
         if (errText.includes("rate limit") || errText.includes("429")) {
-          throw new GitHubRateLimitError(6e4);
+          const retryMatch = errText.match(/retry after (\d+)/i);
+          const retryMs = retryMatch ? parseInt(retryMatch[1], 10) * 1e3 : 6e4;
+          throw new GitHubRateLimitError(retryMs);
         }
         throw new Error(errText || `gh api ${method} ${endpoint} failed with exit code ${result.code}`);
       }
@@ -122967,7 +122995,8 @@ ${roleInstructions}`;
   return effortPrefix ?? roleInstructions ?? "";
 }
 function sendToAgent(sessionKey, taskMessage, opts) {
-  const idempotencyKey = `fabrica-${opts.projectName}-${opts.issueId}-${opts.role}-${opts.level ?? "unknown"}-${opts.slotIndex ?? 0}-${opts.fromLabel ?? "unknown"}-${sessionKey}`;
+  const epoch = opts.dispatchEpoch ?? (/* @__PURE__ */ new Date()).toISOString();
+  const idempotencyKey = `fabrica-${opts.projectName}-${opts.issueId}-${opts.role}-${opts.level ?? "unknown"}-${opts.slotIndex ?? 0}-${opts.fromLabel ?? "unknown"}-${sessionKey}-${epoch}`;
   if (opts.runtime?.subagent?.run) {
     opts.runtime.subagent.run({
       sessionKey,
@@ -123388,6 +123417,7 @@ async function dispatchTask(opts) {
       error: err.message ?? String(err)
     }).catch((auditErr) => console.error("[fabrica] silent-catch:", auditErr.message));
   });
+  const dispatchEpoch = (/* @__PURE__ */ new Date()).toISOString();
   sendToAgent(sessionKey, taskMessage, {
     agentId,
     projectName: project.name,
@@ -123405,7 +123435,8 @@ async function dispatchTask(opts) {
       roleInstructions.trim() || void 0
     ) || void 0,
     runCommand: rc,
-    runtime
+    runtime,
+    dispatchEpoch
   });
   await recordIssueLifecycle({
     workspaceDir,
@@ -130457,7 +130488,10 @@ async function cleanupExpired(workspaceDir, ttlMs = DEFAULT_TTL_MS2) {
   const cutoff = Date.now() - ttlMs;
   const kept = entries.filter((e2) => e2.ts >= cutoff);
   if (kept.length < entries.length) {
-    await fs28.writeFile(filePath, kept.map((e2) => JSON.stringify(e2)).join("\n") + (kept.length > 0 ? "\n" : ""), "utf-8");
+    const content = kept.map((e2) => JSON.stringify(e2)).join("\n") + (kept.length > 0 ? "\n" : "");
+    const tmpPath = filePath + ".tmp";
+    await fs28.writeFile(tmpPath, content, "utf-8");
+    await fs28.rename(tmpPath, filePath);
   }
 }
 
@@ -130543,30 +130577,52 @@ async function projectTick(opts) {
     }
     if (role === "reviewer" || role === "tester") {
       const issueRuntime = getIssueRuntime(fresh, issue2.iid);
-      const prSelector = getCanonicalPrSelector(fresh, issue2.iid);
+      let prSelector = getCanonicalPrSelector(fresh, issue2.iid);
       if (!prSelector?.prNumber) {
-        const feedbackLabel = getFeedbackQueueLabel(workflow);
-        if (!dryRun && feedbackLabel && feedbackLabel !== currentLabel) {
-          try {
-            await provider.transitionLabel(issue2.iid, currentLabel, feedbackLabel);
-            await log(workspaceDir, "queue_pr_guard", {
-              project: project.name,
-              projectSlug,
-              issueId: issue2.iid,
-              role,
-              from: currentLabel,
-              to: feedbackLabel,
-              prState: issueRuntime?.currentPrState ?? null,
-              prUrl: issueRuntime?.currentPrUrl ?? null,
-              prNumber: null,
-              currentIssueMatch: null,
-              reason: "missing_canonical_pr"
+        const fallbackStatus = await provider.getPrStatus(issue2.iid).catch(() => null);
+        const hasFallbackPr = !!fallbackStatus?.url && !!fallbackStatus.number && fallbackStatus.state !== PrState.MERGED && fallbackStatus.state !== PrState.CLOSED && fallbackStatus.currentIssueMatch !== false;
+        if (hasFallbackPr && fallbackStatus?.number) {
+          if (!dryRun) {
+            await updateIssueRuntime(workspaceDir, projectSlug, issue2.iid, {
+              currentPrNumber: fallbackStatus.number,
+              currentPrUrl: fallbackStatus.url,
+              currentPrState: fallbackStatus.state ?? null
+            }).catch(() => {
             });
-          } catch {
           }
+          const runtimeKey = String(issue2.iid);
+          fresh.issueRuntime = fresh.issueRuntime ?? {};
+          fresh.issueRuntime[runtimeKey] = {
+            ...fresh.issueRuntime[runtimeKey] ?? {},
+            currentPrNumber: fallbackStatus.number,
+            currentPrUrl: fallbackStatus.url ?? null,
+            currentPrState: fallbackStatus.state ?? null
+          };
+          prSelector = { prNumber: fallbackStatus.number };
+        } else {
+          const feedbackLabel = getFeedbackQueueLabel(workflow);
+          if (!dryRun && feedbackLabel && feedbackLabel !== currentLabel) {
+            try {
+              await provider.transitionLabel(issue2.iid, currentLabel, feedbackLabel);
+              await log(workspaceDir, "queue_pr_guard", {
+                project: project.name,
+                projectSlug,
+                issueId: issue2.iid,
+                role,
+                from: currentLabel,
+                to: feedbackLabel,
+                prState: issueRuntime?.currentPrState ?? null,
+                prUrl: issueRuntime?.currentPrUrl ?? null,
+                prNumber: null,
+                currentIssueMatch: null,
+                reason: "missing_canonical_pr"
+              });
+            } catch {
+            }
+          }
+          skipped.push({ role, reason: "No canonical bound PR for review/test cycle" });
+          continue;
         }
-        skipped.push({ role, reason: "No canonical bound PR for review/test cycle" });
-        continue;
       }
       const prStatus = await provider.getPrStatus(issue2.iid, prSelector);
       const hasReviewablePr = !!prStatus.url && prStatus.state !== PrState.MERGED && prStatus.state !== PrState.CLOSED && prStatus.currentIssueMatch !== false;
@@ -132184,23 +132240,46 @@ async function checkProjectActive(workspaceDir, slug) {
   );
 }
 
+// lib/services/heartbeat/wake-bridge.ts
+var _wakeCallback = null;
+function setPluginWakeHandler(cb) {
+  _wakeCallback = cb;
+}
+async function wakeHeartbeat(reason) {
+  await _wakeCallback?.(reason);
+}
+
 // lib/services/heartbeat/index.ts
 function registerHeartbeatService(api, pluginCtx) {
   let sharedIntervalId = null;
-  let tickCount = 0;
+  let _pendingWake = false;
   api.registerService({
     id: "fabrica-heartbeat",
     start: async (svcCtx) => {
       const { intervalSeconds } = resolveHeartbeatConfig(pluginCtx.pluginConfig);
       const intervalMs = intervalSeconds * 1e3;
-      setTimeout(() => runHeartbeatTick(pluginCtx, svcCtx.logger, "repair"), 2e3);
+      setTimeout(() => runHeartbeatTick(pluginCtx, svcCtx.logger, "full"), 2e3);
       sharedIntervalId = setInterval(() => {
-        const mode = tickCount % 2 === 0 ? "repair" : "triage";
-        tickCount++;
-        runHeartbeatTick(pluginCtx, svcCtx.logger, mode);
+        runHeartbeatTick(pluginCtx, svcCtx.logger, "full").finally(() => {
+          if (_pendingWake) {
+            _pendingWake = false;
+            svcCtx.logger.info("heartbeat_wake: running deferred full tick");
+            runHeartbeatTick(pluginCtx, svcCtx.logger, "full");
+          }
+        });
       }, intervalMs);
+      setPluginWakeHandler(async (reason) => {
+        if (_anyTickRunning) {
+          _pendingWake = true;
+          svcCtx.logger.info(`heartbeat_wake: deferred (tick-in-progress), reason=${reason}`);
+          return;
+        }
+        svcCtx.logger.info(`heartbeat_wake: running full tick, reason=${reason}`);
+        await runHeartbeatTick(pluginCtx, svcCtx.logger, "full");
+      });
     },
     stop: async (svcCtx) => {
+      setPluginWakeHandler(null);
       if (sharedIntervalId) {
         clearInterval(sharedIntervalId);
         sharedIntervalId = null;
@@ -139086,7 +139165,7 @@ function registerTelegramBootstrapHook(api, ctx) {
         ctx.logger.info(`[telegram-bootstrap] stale received session (expired) \u2014 restarting pipeline for conversation ${conversationId}`);
       }
     }
-    if (!parsed.projectName && ctx.runtime?.subagent?.run) {
+    if (!parsed.projectName && ctx.runtime?.subagent?.run != null) {
       await upsertTelegramBootstrapSession(workspaceDir, {
         conversationId,
         rawIdea: parsed.rawIdea,
@@ -139462,6 +139541,8 @@ function registerReactiveDispatchHooks(api, ctx) {
   api.on("after_tool_call", async (event, _eventCtx) => {
     if (!COMPLETION_TOOLS.has(event.toolName)) return;
     ctx.runtime?.system.requestHeartbeatNow({ reason: "work_finish", coalesceMs: 2e3 });
+    wakeHeartbeat("work_finish").catch(() => {
+    });
   });
   api.on("agent_end", async (_event, eventCtx) => {
     const sessionKey = eventCtx.sessionKey;
@@ -139469,6 +139550,8 @@ function registerReactiveDispatchHooks(api, ctx) {
     const parsed = parseFabricaSessionKey(sessionKey);
     if (!parsed) return;
     ctx.runtime?.system.requestHeartbeatNow({ reason: "agent_end", coalesceMs: 2e3 });
+    wakeHeartbeat("agent_end").catch(() => {
+    });
   });
   api.on("subagent_spawned", async (event, _eventCtx) => {
     const sessionKey = event.childSessionKey;
@@ -139478,6 +139561,7 @@ function registerReactiveDispatchHooks(api, ctx) {
 }
 
 // lib/dispatch/subagent-lifecycle-hook.ts
+init_workflow();
 function registerSubagentLifecycleHook(api, ctx) {
   const workspaceDir = resolveWorkspaceDir(ctx.config);
   if (!workspaceDir) return;
@@ -139501,6 +139585,67 @@ function registerSubagentLifecycleHook(api, ctx) {
     ctx.logger.info(
       `subagent_ended: worker ${role} in "${projectName}" ended with outcome=${event.outcome ?? "unknown"} (session=${sessionKey})`
     );
+    try {
+      const projects = await readProjects(workspaceDir);
+      const projectEntry = Object.entries(projects.projects).find(
+        ([, p]) => p.name === projectName
+      );
+      if (!projectEntry) return;
+      const [projectSlug, project] = projectEntry;
+      const roleWorker = project.workers[role];
+      if (!roleWorker) return;
+      let foundLevel;
+      let foundSlotIndex;
+      let foundSlot;
+      for (const [level, slots] of Object.entries(roleWorker.levels)) {
+        for (let i2 = 0; i2 < slots.length; i2++) {
+          if (slots[i2].sessionKey === sessionKey && slots[i2].active) {
+            foundLevel = level;
+            foundSlotIndex = i2;
+            foundSlot = slots[i2];
+            break;
+          }
+        }
+        if (foundSlot) break;
+      }
+      if (!foundSlot || foundLevel == null || foundSlotIndex == null) return;
+      const issueId = foundSlot.issueId;
+      await deactivateWorker(workspaceDir, projectSlug, role, {
+        level: foundLevel,
+        slotIndex: foundSlotIndex
+      });
+      if (issueId) {
+        try {
+          const config2 = await loadConfig(workspaceDir, projectSlug);
+          const activeLabel = getActiveLabel(config2.workflow, role);
+          const revertLabel = getRevertLabel(config2.workflow, role);
+          const { provider } = await createProvider({
+            repo: project.repo,
+            provider: project.provider,
+            runCommand: ctx.runCommand
+          });
+          const issue2 = await provider.getIssue(Number(issueId));
+          if (issue2.labels.includes(activeLabel)) {
+            await provider.transitionLabel(Number(issueId), activeLabel, revertLabel);
+          }
+        } catch {
+        }
+      }
+      await log(workspaceDir, "subagent_ended_slot_cleanup", {
+        sessionKey,
+        project: projectName,
+        role,
+        level: foundLevel,
+        slotIndex: foundSlotIndex,
+        issueId,
+        outcome: event.outcome ?? "unknown"
+      }).catch(() => {
+      });
+      wakeHeartbeat("subagent_ended").catch(() => {
+      });
+    } catch (err) {
+      ctx.logger.warn(`subagent_ended_slot_cleanup failed: ${err.message}`);
+    }
   });
 }