@mestreyoda/fabrica 0.2.3 → 0.2.7

package/defaults/fabrica/prompts/reviewer.md

@@ -73,8 +73,7 @@ Do **not** treat the task envelope (`Repo:`, `Project:`, `Channel:`, branch hint
 
 - Read the PR diff carefully
 - Check the code against the review checklist
-- Call `review_submit` with your review findings so the artifact is written to the PR itself
-- Then call `work_finish`
+- Submit your review using **one of the two methods below** (prefer `review_submit` if available)
 
 ## Conventions
 
@@ -92,22 +91,50 @@ If you discover unrelated bugs or needed improvements, call `task_create`:
 
 ## Completing Your Task
 
-When you are done, submit the review artifact first, then **call `work_finish` yourself** — do not just announce in text.
+When you are done, submit your review using **Method A** if the tools are available, or **Method B** otherwise.
 
-- **Approve review artifact:** `review_submit({ channelId: "<project slug from 'Project:' field in task message>", issueId: <issue number>, result: "approve", body: "<what you checked>" })`
-- **Reject review artifact:** `review_submit({ channelId: "<project slug from 'Project:' field in task message>", issueId: <issue number>, result: "reject", body: "<specific issues>" })`
-- Capture the returned `artifactId` and `artifactType` from `review_submit`.
+### Method A — Fabrica tools (preferred)
 
-**Never call `task_comment` for review findings.** The orchestrator may mirror your result to the issue separately, but your authoritative feedback must live on the PR via `review_submit`.
-
-- **Approve:** `work_finish({ role: "reviewer", result: "approve", channelId: "<project slug from 'Project:' field in task message>", summary: "<what you checked>", reviewArtifactId: <artifactId>, reviewArtifactType: "<artifactType>" })`
-- **Reject:** `work_finish({ role: "reviewer", result: "reject", channelId: "<project slug from 'Project:' field in task message>", summary: "<specific issues>", reviewArtifactId: <artifactId>, reviewArtifactType: "<artifactType>" })`
-- **Blocked:** `work_finish({ role: "reviewer", result: "blocked", channelId: "<project slug from 'Project:' field in task message>", summary: "<what you need>" })`
+1. Call `review_submit` to write the review artifact to the PR:
+   - **Approve:** `review_submit({ channelId: "<project slug>", issueId: <issue number>, result: "approve", body: "<what you checked>" })`
+   - **Reject:** `review_submit({ channelId: "<project slug>", issueId: <issue number>, result: "reject", body: "<specific issues>" })`
+   - Capture the returned `artifactId` and `artifactType`.
+2. Then call `work_finish`:
+   - **Approve:** `work_finish({ role: "reviewer", result: "approve", channelId: "<project slug>", summary: "<what you checked>", reviewArtifactId: <artifactId>, reviewArtifactType: "<artifactType>" })`
+   - **Reject:** `work_finish({ role: "reviewer", result: "reject", channelId: "<project slug>", summary: "<specific issues>", reviewArtifactId: <artifactId>, reviewArtifactType: "<artifactType>" })`
+   - **Blocked:** `work_finish({ role: "reviewer", result: "blocked", channelId: "<project slug>", summary: "<what you need>" })`
 
 > **IMPORTANT:** The `channelId` parameter accepts the project slug (e.g., "gestao-notas").
 > Extract it from the "Project: <name>" line in your task message. Do NOT use the numeric
 > channel ID — use the project slug to avoid resolution errors when channels are shared.
 
+### Method B — GitHub CLI fallback (use only if `review_submit` / `work_finish` are unavailable)
+
+Extract from your task message:
+- `OWNER/REPO` from the `Repo:` line
+- `PR_NUMBER` from the PR URL in the diff header or the `Branch:` line
+- `ISSUE_NUMBER` from the `Issue:` field
+
+**Approve:**
+```bash
+gh pr review PR_NUMBER --repo OWNER/REPO --approve -b "$(cat <<'EOF'
+<your full review body here>
+EOF
+)"
+```
+
+**Reject (request changes):**
+```bash
+gh pr review PR_NUMBER --repo OWNER/REPO --request-changes -b "$(cat <<'EOF'
+<specific issues and how to fix them>
+EOF
+)"
+```
+
+After submitting via `gh pr review`, the Fabrica heartbeat will detect the PR review state and advance the pipeline automatically. **Do NOT manually edit issue labels.**
+
+**Never call `task_comment` for review findings.** Your review must be posted on the PR itself.
+
 ## Tools You Should NOT Use
 
 These are orchestrator-only tools. Do not call them:

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.3") {
-    return "0.2.3";
+  if ("0.2.7") {
+    return "0.2.7";
   }
   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);
   }
 }
 
@@ -130757,7 +130791,7 @@ async function reviewPass(opts) {
     const issues = await provider.listIssuesByLabel(state.label);
     for (const issue2 of issues) {
       const routing = detectStepRouting(issue2.labels, "review");
-      if (routing !== "human") continue;
+      if (routing !== "human" && routing !== "agent") continue;
       const isManaged = await provider.issueHasReaction(issue2.iid, "eyes");
       if (!isManaged) continue;
       const status = await provider.getPrStatus(issue2.iid);
@@ -132206,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;
@@ -139108,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,
@@ -139484,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;
@@ -139491,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;
@@ -139500,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;
@@ -139523,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}`);
+    }
   });
 }