replicas-engine 0.1.703 → 0.1.704

package/dist/src/chunk-2RB7SIP3.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+
+// src/utils/type-guards.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+
+export {
+  isRecord
+};

package/dist/src/{chunk-U3XQBTVU.js → chunk-EC4MFY4M.js}

@@ -2,7 +2,7 @@
 import {
   HOOK_EXEC_MAX_BUFFER_BYTES,
   isVersionBelow
-} from "./chunk-LPJ6WYD4.js";
+} from "./chunk-WUJ4IALO.js";
 
 // src/utils/presigned-upload.ts
 import { createReadStream } from "fs";
@@ -267,7 +267,7 @@ var DEFAULT_CODEX_ARGS = [
 var MIN_CODEX_CLI_VERSION = "0.144.6";
 var CODEX_UPGRADE_TIMEOUT_MS = 12e4;
 var codexCliVersionEnsured = null;
-var ENGINE_PACKAGE_VERSION = "0.1.703";
+var ENGINE_PACKAGE_VERSION = "0.1.704";
 var INITIALIZE_METHOD = "initialize";
 var INITIALIZED_NOTIFICATION = "initialized";
 var ACCOUNT_LOGIN_START_METHOD = "account/login/start";

package/dist/src/chunk-GDCMH7YA.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import {
+  mayCreatePullRequest
+} from "./chunk-WUJ4IALO.js";
+
+// src/services/post-tool-pr-notifier.ts
+async function notifyPostToolUse(toolName, toolInput) {
+  if (!mayCreatePullRequest(toolName, toolInput)) return false;
+  const port = process.env.REPLICAS_ENGINE_PORT;
+  const secret = process.env.REPLICAS_ENGINE_SECRET;
+  if (!port || !secret) throw new Error("Replicas engine connection is unavailable.");
+  const response = await fetch(`http://127.0.0.1:${port}/pull-requests/check`, {
+    method: "POST",
+    headers: { "X-Replicas-Engine-Secret": secret },
+    signal: AbortSignal.timeout(3e4)
+  });
+  if (!response.ok) throw new Error(`Replicas pull request check failed (${response.status}).`);
+  return true;
+}
+
+export {
+  notifyPostToolUse
+};

package/dist/src/{chunk-LPJ6WYD4.js → chunk-WUJ4IALO.js}

@@ -1128,6 +1128,13 @@ async function raceWithTimeout(promise, ms) {
     });
   }
 }
+async function withTimeout(promise, ms, message) {
+  const result = await raceWithTimeout(promise, ms);
+  if (result === TIMEOUT) {
+    throw new Error(message);
+  }
+  return result;
+}
 
 // ../shared/src/agent-quota.ts
 var OUT_OF_CREDITS_PATTERNS = [
@@ -3659,6 +3666,37 @@ function findGitCommitSignals(request) {
   const command = extractCommandProtectionCommandText(request, { stringifyFallback: true }) ?? "";
   return findGitCommitCommands(command).length > 0 ? ["git-commit"] : [];
 }
+function mayCreatePullRequest(toolName, toolInput) {
+  const input = normalizeCommandProtectionText(stringifyCommandProtectionInput(toolInput));
+  const combined = `${toolName.toLowerCase()} ${input}`;
+  return [
+    /\bgit\s+push\b/,
+    /\bgit\s+(?:branch|checkout|switch|pull|merge|rebase|reset)\b/,
+    /\bgit\s+worktree\s+add\b/,
+    /\bgh\b.{0,120}\bpr\s+(?:checkout|create|new|ready|reopen)\b/,
+    /\bgh\s+api\b[\s\S]*(?:\/repos\/[^/\s]+\/[^/\s]+\/pulls\b|\bcreatepullrequest\b)/,
+    /\b(?:glab|gitlab)\s+mr\s+(?:checkout|create)\b/,
+    /\bhub\s+pull-request\b/,
+    /\b(?:tea\s+pulls|bb\s+pr|az\s+repos\s+pr)\s+create\b/,
+    /\bcreatepullrequest\b/,
+    /\b(?:create|open|submit)[_-]?(?:pr|pull[_-]?request|mr|merge[_-]?request)\b/,
+    /\b(?:pr|pull[_-]?request|mr|merge[_-]?request)[_-]?(?:create|open|submit)\b/,
+    /\b(?:checkout|create|switch)[_-]?branch\b/,
+    /\bbranch[_-]?(?:checkout|create|switch)\b/,
+    /\b(?:switched to|checked out|created and switched to)(?: a new)? branch\b/,
+    /github\.com\/[^/\s]+\/[^/\s]+\/pull\/\d+\b/,
+    /\/merge_requests\/\d+\b/,
+    /\b(?:create|open|submit)(?:pull|merge)request\b/,
+    /\b(?:pull|merge)request(?:create|open|submit)\b/,
+    /\bmergerequestcreate\b/,
+    /api\.github\.com\/repos\/[^/\s]+\/[^/\s]+\/pulls\b/,
+    /\/projects\/[^/\s]+\/merge_requests\b/,
+    /\/pullrequests\b/,
+    /\/_apis\/git\/repositories\/[^/\s]+\/pullrequests\b/,
+    /\/pulls\b[\s\S]*\b(?:post|create)\b/,
+    /\/merge_requests\b[\s\S]*\b(?:post|create)\b/
+  ].some((pattern) => pattern.test(combined));
+}
 
 // ../shared/src/routes/plugin-catalog.ts
 var EXPLICIT_PLUGIN_CATALOG = [
@@ -6579,6 +6617,7 @@ export {
   isNonEmptyString,
   TIMEOUT,
   raceWithTimeout,
+  withTimeout,
   createSuccessResult,
   createErrorResult,
   AGENT,
@@ -6725,6 +6764,7 @@ export {
   extractCommandProtectionCommandText,
   findPrMergeSignals,
   findGitCommitSignals,
+  mayCreatePullRequest,
   coerceBackgroundTaskPayload,
   isTerminalBackgroundTaskStatus,
   areUserMessagesWithinMatchWindow,

package/dist/src/{chunk-RVDZXLBY.js → chunk-ZCBMGGAC.js}

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import {
+  isRecord as isRecord2
+} from "./chunk-2RB7SIP3.js";
 import {
   REPLICAS_RUNTIME_ENV_ALIASES,
   agentCredentialSnapshotSchema,
@@ -9,12 +12,7 @@ import {
   isValidAgentProvider,
   parsePosixEnvFile,
   readReplicasRuntimeEnv
-} from "./chunk-LPJ6WYD4.js";
-
-// src/utils/type-guards.ts
-function isRecord2(value) {
-  return typeof value === "object" && value !== null;
-}
+} from "./chunk-WUJ4IALO.js";
 
 // src/engine-env.ts
 import { readFileSync as readFileSync2 } from "fs";
@@ -275,7 +273,6 @@ function reportCommandProtectionBlock(options) {
 }
 
 export {
-  isRecord2 as isRecord,
   IS_WARMING_MODE,
   ENGINE_ENV,
   setAgentCredentialSnapshot,

package/dist/src/command-protection-hook.js

@@ -1,9 +1,11 @@
 #!/usr/bin/env node
 import {
-  evaluateCommandProtection,
+  evaluateCommandProtection
+} from "./chunk-ZCBMGGAC.js";
+import {
   isRecord
-} from "./chunk-RVDZXLBY.js";
-import "./chunk-LPJ6WYD4.js";
+} from "./chunk-2RB7SIP3.js";
+import "./chunk-WUJ4IALO.js";
 
 // src/command-protection-hook.ts
 var provider = process.argv[2];

package/dist/src/deepseek-command-protection-plugin.js

@@ -1,8 +1,12 @@
 #!/usr/bin/env node
 import {
   evaluateCommandProtection
-} from "./chunk-RVDZXLBY.js";
-import "./chunk-LPJ6WYD4.js";
+} from "./chunk-ZCBMGGAC.js";
+import {
+  notifyPostToolUse
+} from "./chunk-GDCMH7YA.js";
+import "./chunk-2RB7SIP3.js";
+import "./chunk-WUJ4IALO.js";
 
 // src/deepseek-command-protection-plugin.ts
 function replicasCommandProtection(context) {
@@ -17,6 +21,11 @@ function replicasCommandProtection(context) {
     });
     return result.allowed ? next() : { kind: "deny", reason: result.reason ?? "Blocked by Replicas command protection." };
   });
+  context.on("tools/post-execute", async (execution, _result, next) => {
+    await notifyPostToolUse(execution.name, execution.arguments).catch(() => {
+    });
+    return next();
+  });
 }
 export {
   replicasCommandProtection as default

package/dist/src/headless-agent.js

@@ -4,12 +4,12 @@ import {
   buildCodexAgentEnv,
   putPresignedFile,
   recoverCompletedTurn
-} from "./chunk-U3XQBTVU.js";
+} from "./chunk-EC4MFY4M.js";
 import {
   AGENT,
   getMemoryOutputSafetyViolation,
   headlessAgentRequestSchema
-} from "./chunk-LPJ6WYD4.js";
+} from "./chunk-WUJ4IALO.js";
 
 // src/headless-agent.ts
 import { createHash } from "crypto";

package/dist/src/index.js

@@ -4,12 +4,11 @@ import {
   IS_WARMING_MODE,
   evaluateCommandProtection,
   extractToolCommand,
-  isRecord as isRecord2,
   monolithRequest,
   monolithService,
   reportCommandProtectionBlock,
   setAgentCredentialSnapshot
-} from "./chunk-RVDZXLBY.js";
+} from "./chunk-ZCBMGGAC.js";
 import {
   ACCOUNT_RATE_LIMITS_UPDATED_METHOD,
   AGENT_MESSAGE_DELTA_METHOD,
@@ -36,7 +35,10 @@ import {
   execFileAsync,
   putPresignedFile,
   recoverCompletedTurn
-} from "./chunk-U3XQBTVU.js";
+} from "./chunk-EC4MFY4M.js";
+import {
+  isRecord as isRecord2
+} from "./chunk-2RB7SIP3.js";
 import {
   ACCEPTED_USER_MESSAGE_SOURCE,
   AGENT,
@@ -182,6 +184,7 @@ import {
   isTransientErrorText,
   isValidAgentProvider,
   isValidEngineLogSessionId,
+  mayCreatePullRequest,
   mergeSlashCommands,
   normalizeAutoCompactThreshold,
   normalizeClaudeModel,
@@ -207,8 +210,9 @@ import {
   sendChatMessageRequestSchema,
   serializeCanvasContentResponse,
   shellQuotePosix,
-  stripAgentDiagnosticErrors
-} from "./chunk-LPJ6WYD4.js";
+  stripAgentDiagnosticErrors,
+  withTimeout
+} from "./chunk-WUJ4IALO.js";
 
 // src/index.ts
 import { serve } from "@hono/node-server";
@@ -3949,6 +3953,92 @@ var LinearEventForwarder = class {
   }
 };
 
+// src/services/upload-repo-state.ts
+var uploadQueue = Promise.resolve();
+async function sendRepoState(repos) {
+  const form = new FormData();
+  form.append(
+    "file",
+    new Blob([JSON.stringify({ repos })], { type: "application/json" }),
+    "repo-state.json"
+  );
+  const response = await monolithRequest("/v1/engine/repo-state", { body: form });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`upload failed: ${response.status} ${errorText}`);
+  }
+}
+function uploadRepoState(repos) {
+  const upload = uploadQueue.then(() => sendRepoState(repos));
+  uploadQueue = upload.catch(() => {
+  });
+  return upload;
+}
+async function flushRepoState() {
+  try {
+    const { repos, complete } = await gitService.listReposWithCompleteness({ includeDiffs: true });
+    if (!complete) return { flushed: 0, skipped: 1, failed: 0 };
+    await uploadRepoState(repos);
+    return { flushed: 1, skipped: 0, failed: 0 };
+  } catch (err) {
+    console.error("[RepoStateUploader] upload failed:", err);
+    return { flushed: 0, skipped: 0, failed: 1 };
+  }
+}
+
+// src/services/refresh-repo-state.ts
+async function refreshRepoStatuses(observedBranchesByRepo, includeDiffs = false) {
+  await Promise.all([
+    githubTokenManager.refreshOnce().catch(() => {
+    }),
+    gitlabTokenManager.refreshOnce().catch(() => {
+    })
+  ]);
+  const { repos, complete } = await gitService.refreshReposWithCompleteness(
+    observedBranchesByRepo,
+    { includeDiffs }
+  );
+  if (complete) {
+    uploadRepoState(repos).catch((error) => {
+      console.error("[RefreshRepoState] Failed to upload repository state:", error);
+    });
+  }
+  return repos;
+}
+
+// src/services/pull-request-check-service.ts
+var CHECK_TIMEOUT_MS = 3e4;
+var PullRequestCheckService = class {
+  running = null;
+  trailing = null;
+  // Plain single-flight would hand a caller a result gathered before its PR
+  // existed, so callers arriving mid-run instead share one trailing run that
+  // starts after the current one settles.
+  check() {
+    const running = this.running;
+    if (!running) return this.start();
+    this.trailing ??= running.catch(() => {
+    }).then(() => {
+      this.trailing = null;
+      return this.start();
+    });
+    return this.trailing;
+  }
+  start() {
+    const run = withTimeout(this.refresh(), CHECK_TIMEOUT_MS, "Pull request check timed out").finally(() => {
+      if (this.running === run) this.running = null;
+    });
+    this.running = run;
+    return run;
+  }
+  async refresh() {
+    const repoStatuses = await refreshRepoStatuses();
+    await monolithService.sendEvent({ type: "pull_request_check", payload: { repoStatuses } });
+    return repoStatuses;
+  }
+};
+var pullRequestCheckService = new PullRequestCheckService();
+
 // src/services/skill-registry-service.ts
 import { readFile as readFile8, readdir as readdir3, stat as stat2 } from "fs/promises";
 import { dirname as dirname3, isAbsolute, join as join14, relative, resolve } from "path";
@@ -5152,6 +5242,17 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
             matcher: "*",
             hooks: [this.buildCommandProtectionHook()],
             timeout: 30
+          }],
+          PostToolUse: [{
+            matcher: "*",
+            hooks: [async (input) => {
+              if (input.hook_event_name === "PostToolUse" && mayCreatePullRequest(input.tool_name, input.tool_input)) {
+                pullRequestCheckService.check().catch(() => {
+                });
+              }
+              return {};
+            }],
+            timeout: 30
           }]
         }
       }
@@ -7101,6 +7202,11 @@ var CodexAspManager = class extends CodingAgentManager {
         );
         this.emitTranscriptUpdated(notification.params.threadId, { immediate: true });
         linearForwarder.sendEvent(convertCodexAspNotification(notification, linearSessionId ?? ""));
+        const completedItem = notification.params.item;
+        if (completedItem.type === "commandExecution" && completedItem.exitCode === 0 && mayCreatePullRequest("commandExecution", { command: completedItem.command }) || completedItem.type === "mcpToolCall" && completedItem.status === "completed" && mayCreatePullRequest(completedItem.tool, completedItem.arguments) || completedItem.type === "dynamicToolCall" && completedItem.success !== false && mayCreatePullRequest(completedItem.tool, completedItem.arguments)) {
+          pullRequestCheckService.check().catch(() => {
+          });
+        }
       },
       [AGENT_MESSAGE_DELTA_METHOD]: (notification) => {
         if (!matchesTurn(notification.params.threadId, notification.params.turnId)) return;
@@ -7823,15 +7929,28 @@ var hookPath = [
   join18(moduleDirectory, "command-protection-hook.js"),
   join18(moduleDirectory, "..", "command-protection-hook.ts")
 ].find(existsSync6);
-function shellCommand(provider) {
-  if (!hookPath) throw new Error("Replicas command protection hook executable is missing.");
-  const args = hookPath.endsWith(".ts") && basename(process.execPath) !== "bun" ? [process.execPath, "--import", "tsx", hookPath, provider] : [process.execPath, hookPath, provider];
+var postToolHookPath = [
+  join18(moduleDirectory, "post-tool-pr-hook.js"),
+  join18(moduleDirectory, "..", "post-tool-pr-hook.ts")
+].find(existsSync6);
+function shellCommand(path6, provider) {
+  if (!path6) throw new Error("Replicas hook executable is missing.");
+  const args = [
+    process.execPath,
+    ...path6.endsWith(".ts") && basename(process.execPath) !== "bun" ? ["--import", "tsx"] : [],
+    path6,
+    ...provider ? [provider] : []
+  ];
   return args.map((value) => `'${value.replaceAll("'", "'\\''")}'`).join(" ");
 }
 function getCommandProtectionHookPath() {
   if (!hookPath) throw new Error("Replicas command protection hook executable is missing.");
   return hookPath;
 }
+function getPostToolPrHookPath() {
+  if (!postToolHookPath) throw new Error("Replicas post-tool PR hook executable is missing.");
+  return postToolHookPath;
+}
 async function ensureCursorCommandProtectionHook() {
   const path6 = join18(ENGINE_ENV.HOME_DIR, ".cursor", "hooks.json");
   let config = {};
@@ -7846,7 +7965,12 @@ async function ensureCursorCommandProtectionHook() {
   const existing = Array.isArray(hooks.preToolUse) ? hooks.preToolUse : [];
   hooks.preToolUse = [
     ...existing.filter((entry) => !isRecord2(entry) || typeof entry.command !== "string" || !entry.command.includes("command-protection-hook")),
-    { command: shellCommand("cursor") }
+    { command: shellCommand(hookPath, "cursor") }
+  ];
+  const existingPost = Array.isArray(hooks.postToolUse) ? hooks.postToolUse : [];
+  hooks.postToolUse = [
+    ...existingPost.filter((entry) => !isRecord2(entry) || typeof entry.command !== "string" || !entry.command.includes("post-tool-pr-hook")),
+    { command: shellCommand(postToolHookPath) }
   ];
   await mkdir11(dirname5(path6), { recursive: true });
   await writeFile6(path6, `${JSON.stringify({ ...config, version: 1, hooks }, null, 2)}
@@ -7865,7 +7989,12 @@ async function ensureKimiCommandProtectionHook() {
   const block = `${start}
 [[hooks]]
 event = "PreToolUse"
-command = ${JSON.stringify(shellCommand("kimi"))}
+command = ${JSON.stringify(shellCommand(hookPath, "kimi"))}
+timeout = 30
+
+[[hooks]]
+event = "PostToolUse"
+command = ${JSON.stringify(shellCommand(postToolHookPath))}
 timeout = 30
 ${end}`;
   const markerStart = config.indexOf(start);
@@ -9635,6 +9764,7 @@ var OpencodeManager = class extends CodingAgentManager {
       await copyFile(OPENCODE_COMMAND_PROTECTION_PLUGIN_SOURCE, OPENCODE_COMMAND_PROTECTION_PLUGIN_PATH);
       await rm2(OPENCODE_LEGACY_COMMAND_PROTECTION_PLUGIN_PATH, { force: true });
       process.env.REPLICAS_COMMAND_PROTECTION_HOOK_PATH = getCommandProtectionHookPath();
+      process.env.REPLICAS_POST_TOOL_PR_HOOK_PATH = getPostToolPrHookPath();
       process.env.REPLICAS_COMMAND_PROTECTION_RUNTIME_PATH = process.execPath;
       this.eventAbortController?.abort();
       this.server?.close();
@@ -10022,6 +10152,12 @@ function registerCommandProtection(cwd, historyFile, recordHistoryEvent) {
       }
       return void 0;
     });
+    pi.on("tool_result", (event) => {
+      if (!event.isError && mayCreatePullRequest(event.toolName, event.input)) {
+        pullRequestCheckService.check().catch(() => {
+        });
+      }
+    });
   };
 }
 var PiManager = class extends CodingAgentManager {
@@ -12152,39 +12288,6 @@ async function uploadChatTranscript(chatId, filePath, chat, capture) {
   return artifact;
 }
 
-// src/services/upload-repo-state.ts
-var uploadQueue = Promise.resolve();
-async function sendRepoState(repos) {
-  const form = new FormData();
-  form.append(
-    "file",
-    new Blob([JSON.stringify({ repos })], { type: "application/json" }),
-    "repo-state.json"
-  );
-  const response = await monolithRequest("/v1/engine/repo-state", { body: form });
-  if (!response.ok) {
-    const errorText = await response.text();
-    throw new Error(`upload failed: ${response.status} ${errorText}`);
-  }
-}
-function uploadRepoState(repos) {
-  const upload = uploadQueue.then(() => sendRepoState(repos));
-  uploadQueue = upload.catch(() => {
-  });
-  return upload;
-}
-async function flushRepoState() {
-  try {
-    const { repos, complete } = await gitService.listReposWithCompleteness({ includeDiffs: true });
-    if (!complete) return { flushed: 0, skipped: 1, failed: 0 };
-    await uploadRepoState(repos);
-    return { flushed: 1, skipped: 0, failed: 0 };
-  } catch (err) {
-    console.error("[RepoStateUploader] upload failed:", err);
-    return { flushed: 0, skipped: 0, failed: 1 };
-  }
-}
-
 // src/services/upload-engine-logs.ts
 import { createReadStream as createReadStream2 } from "fs";
 import { readdir as readdir9, stat as stat5 } from "fs/promises";
@@ -13451,12 +13554,6 @@ var ChatService = class {
     }
   }
   async publishAgentTurnCompleteWebhook(chat, completedAt, processing = false) {
-    await Promise.all([
-      githubTokenManager.refreshOnce().catch(() => {
-      }),
-      gitlabTokenManager.refreshOnce().catch(() => {
-      })
-    ]);
     const linearSessionId = ENGINE_ENV.REPLICAS_LINEAR_SESSION_ID;
     const observedBranches = chat.observedBranchesByRepo;
     chat.observedBranchesByRepo = /* @__PURE__ */ new Map();
@@ -13465,20 +13562,12 @@ var ChatService = class {
     const errorNotificationTarget = chat.activeErrorNotificationTarget;
     chat.activeErrorNotificationTarget = null;
     let repoStatuses = [];
-    let repoStateComplete = false;
     try {
-      const refreshed = await gitService.refreshReposWithCompleteness(observedBranches, { includeDiffs: true });
-      repoStatuses = refreshed.repos;
-      repoStateComplete = refreshed.complete;
+      repoStatuses = await refreshRepoStatuses(observedBranches, true);
       console.log(`Repository Statuses Refreshed: `, repoStatuses);
     } catch (error) {
       console.error("[ChatService] Failed to refresh repo statuses:", error);
     }
-    if (repoStateComplete) {
-      uploadRepoState(repoStatuses).catch((err) => {
-        console.error("[ChatService] Failed to upload repository state:", err);
-      });
-    }
     try {
       const payload = {
         ...linearSessionId ? { linearSessionId } : {},
@@ -14319,6 +14408,11 @@ function jsonError(message, details) {
 }
 function createV1Routes(deps) {
   const app2 = new Hono();
+  app2.post("/pull-requests/check", (c) => {
+    pullRequestCheckService.check().catch(() => {
+    });
+    return c.json({ accepted: true }, 202);
+  });
   const loadChatHistory = async (c, chatId, page, failureMessage, unexpectedStatus, legacy = false) => {
     try {
       const history = await deps.chatService.getChatHistory(chatId, legacy && page.limit !== void 0 ? {} : page);

package/dist/src/post-tool-pr-hook.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import {
+  notifyPostToolUse
+} from "./chunk-GDCMH7YA.js";
+import {
+  isRecord
+} from "./chunk-2RB7SIP3.js";
+import "./chunk-WUJ4IALO.js";
+
+// src/post-tool-pr-hook.ts
+async function main() {
+  let stdin = "";
+  for await (const chunk of process.stdin) stdin += chunk;
+  try {
+    const input = JSON.parse(stdin);
+    const record = isRecord(input) ? input : {};
+    const toolName = [record.tool_name, record.tool, record.name].find((value) => typeof value === "string") ?? "";
+    const toolInput = record.tool_input ?? record.arguments ?? record.args ?? ("command" in record ? { command: record.command } : record);
+    await notifyPostToolUse(toolName, toolInput);
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+  }
+  process.stdout.write("{}\n");
+}
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replicas-engine",
-  "version": "0.1.703",
+  "version": "0.1.704",
   "description": "Lightweight API server for Replicas workspaces",
   "type": "module",
   "main": "dist/src/index.js",
@@ -8,6 +8,7 @@
     "replicas-engine": "./dist/src/index.js",
     "replicas-headless-agent": "./dist/src/headless-agent.js",
     "replicas-command-protection-hook": "./dist/src/command-protection-hook.js",
+    "replicas-post-tool-pr-hook": "./dist/src/post-tool-pr-hook.js",
     "replicas-engine-watchdog": "./scripts/engine-watchdog.sh"
   },
   "files": [

package/scripts/opencode-command-protection-plugin.ts

@@ -14,6 +14,8 @@ interface ToolExecuteBeforeOutput {
   args: unknown;
 }
 
+const toolInputs = new Map<string, unknown>();
+
 function evaluate(tool: string, args: unknown, callId: string, cwd: string): Promise<PolicyResult> {
   return new Promise((resolve) => {
     let settled = false;
@@ -65,5 +67,22 @@ export const ReplicasCommandProtection = async ({ directory }: { directory: stri
   'tool.execute.before': async (input: ToolExecuteBeforeInput, output: ToolExecuteBeforeOutput) => {
     const result = await evaluate(input.tool, output.args, input.callID, directory);
     if (!result.allowed) throw new Error(result.reason ?? 'Blocked by Replicas command protection.');
+    toolInputs.set(input.callID, output.args);
+  },
+  'tool.execute.after': async (input: ToolExecuteBeforeInput) => {
+    const args = toolInputs.get(input.callID);
+    toolInputs.delete(input.callID);
+    const hookPath = process.env.REPLICAS_POST_TOOL_PR_HOOK_PATH;
+    const runtimePath = process.env.REPLICAS_COMMAND_PROTECTION_RUNTIME_PATH;
+    if (!hookPath || !runtimePath) return;
+    const hookArgs = hookPath.endsWith('.ts') && !runtimePath.endsWith('/bun')
+      ? ['--import', 'tsx', hookPath]
+      : [hookPath];
+    await new Promise<void>((resolve) => {
+      const child = spawn(runtimePath, hookArgs, { cwd: directory, stdio: ['pipe', 'ignore', 'ignore'] });
+      child.on('error', () => resolve());
+      child.on('exit', () => resolve());
+      child.stdin.end(JSON.stringify({ tool: input.tool, args }));
+    });
   },
 });