@h-rig/cli-surface-plugin 0.0.6-alpha.156 → 0.0.6-alpha.158

package/dist/src/commands/repo-git-harness.js

@@ -1,46 +1,2282 @@
 // @bun
 // packages/cli-surface-plugin/src/runner.ts
-import { EventBus } from "@rig/runtime/control-plane/runtime/events";
-import { CliError as RuntimeCliError } from "@rig/runtime/control-plane/errors";
-import { evaluate, loadPolicy, resolveAction } from "@rig/runtime/control-plane/runtime/guard";
-import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
+import { EventBus } from "@rig/core/runtime-events";
+import { CliError as RuntimeCliError } from "@rig/contracts";
 
+// packages/cli-surface-plugin/src/control-plane/guard.ts
+import { optimizeNextInvocation } from "bun:jsc";
+import { existsSync, readFileSync, statSync } from "fs";
+import { resolve } from "path";
+
+// packages/cli-surface-plugin/src/control-plane/scope.ts
+import { getScopeRules } from "@rig/core/scope-rules";
+var scopeRegexCache = new Map;
+function unique(values) {
+  return [...new Set(values)];
+}
+function normalizeRelativeScopePath(inputPath) {
+  let normalized = inputPath.replace(/^\.\//, "");
+  const rules = getScopeRules();
+  if (rules?.stripPrefixes) {
+    for (const prefix of rules.stripPrefixes) {
+      if (normalized.startsWith(prefix)) {
+        normalized = normalized.slice(prefix.length);
+      }
+    }
+  }
+  return normalized;
+}
+function normalizePathToScope(projectRoot, monorepoRoot, inputPath) {
+  let normalized = inputPath.replace(/^\.\//, "");
+  if (normalized.startsWith(projectRoot + "/")) {
+    normalized = normalized.slice(projectRoot.length + 1);
+  }
+  if (normalized.startsWith(monorepoRoot + "/")) {
+    normalized = normalized.slice(monorepoRoot.length + 1);
+  }
+  return normalizeRelativeScopePath(normalized);
+}
+function scopeGlobToRegex(glob) {
+  const cached = scopeRegexCache.get(glob);
+  if (cached) {
+    return cached;
+  }
+  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "__GLOBSTAR__").replace(/\*/g, "[^/]*").replace(/__GLOBSTAR__/g, ".*");
+  const compiled = new RegExp(`^${escaped}$`);
+  scopeRegexCache.set(glob, compiled);
+  return compiled;
+}
+function scopeMatches(path, scopes) {
+  const pathVariants = unique([path, normalizeRelativeScopePath(path)]);
+  for (const scope of scopes) {
+    const scopeVariants = unique([scope, normalizeRelativeScopePath(scope)]);
+    for (const candidatePath of pathVariants) {
+      for (const candidateScope of scopeVariants) {
+        if (candidatePath === candidateScope || scopeGlobToRegex(candidateScope).test(candidatePath)) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+
+// packages/cli-surface-plugin/src/control-plane/guard.ts
+import {
+  POLICY_VERSION
+} from "@rig/contracts";
+var DEFAULT_SCOPE = {
+  fail_closed: true,
+  harness_paths_exempt: true,
+  runtime_paths_exempt: true
+};
+var DEFAULT_SANDBOX = {
+  mode: "enforce",
+  network: true,
+  read_deny: [],
+  write_allow_from_runtime: true
+};
+var DEFAULT_ISOLATION = {
+  default_mode: "worktree",
+  repo_symlink_fallback: false,
+  strict_provisioning: true,
+  fail_closed_on_provision_error: true
+};
+var DEFAULT_COMPLETION = {
+  derive_checks_from_scope: true,
+  checks: [],
+  typescript_config_probe: ["tsconfig.json"],
+  eslint_config_probe: [".eslintrc.js", ".eslintrc.json", "eslint.config.js"]
+};
+var DEFAULT_RUNTIME_IMAGE = {
+  deps: {
+    monorepo_install: false,
+    hp_next_install: false
+  },
+  plugins_require_binaries: true
+};
+var DEFAULT_RUNTIME_SNAPSHOT = {
+  enabled: true
+};
+function defaultPolicy() {
+  return {
+    version: POLICY_VERSION,
+    mode: "enforce",
+    scope: { ...DEFAULT_SCOPE },
+    rules: [],
+    sandbox: { ...DEFAULT_SANDBOX },
+    isolation: { ...DEFAULT_ISOLATION },
+    completion: { ...DEFAULT_COMPLETION },
+    runtime_image: {
+      deps: { ...DEFAULT_RUNTIME_IMAGE.deps },
+      plugins_require_binaries: DEFAULT_RUNTIME_IMAGE.plugins_require_binaries
+    },
+    runtime_snapshot: { ...DEFAULT_RUNTIME_SNAPSHOT }
+  };
+}
+var policyCache = null;
+var policyCachePath = null;
+var seededPolicyConfig = null;
+var compiledRegexCache = new Map;
+function loadPolicy(projectRoot) {
+  if (seededPolicyConfig) {
+    return seededPolicyConfig;
+  }
+  const configPath = resolve(projectRoot, "rig/policy/policy.json");
+  if (!existsSync(configPath)) {
+    return defaultPolicy();
+  }
+  let mtimeMs;
+  try {
+    mtimeMs = statSync(configPath).mtimeMs;
+  } catch {
+    return defaultPolicy();
+  }
+  if (policyCache && policyCachePath === configPath && policyCache.mtimeMs === mtimeMs) {
+    return policyCache.config;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(configPath, "utf-8"));
+  } catch {
+    return defaultPolicy();
+  }
+  const config = mergeWithDefaults(parsed);
+  policyCache = { mtimeMs, config };
+  policyCachePath = configPath;
+  return config;
+}
+function mergeWithDefaults(parsed) {
+  const base = defaultPolicy();
+  if (typeof parsed.mode === "string" && isValidMode(parsed.mode)) {
+    base.mode = parsed.mode;
+  }
+  if (parsed.scope && typeof parsed.scope === "object" && !Array.isArray(parsed.scope)) {
+    const s = parsed.scope;
+    if (typeof s.fail_closed === "boolean")
+      base.scope.fail_closed = s.fail_closed;
+    if (typeof s.harness_paths_exempt === "boolean")
+      base.scope.harness_paths_exempt = s.harness_paths_exempt;
+    if (typeof s.runtime_paths_exempt === "boolean")
+      base.scope.runtime_paths_exempt = s.runtime_paths_exempt;
+  }
+  if (Array.isArray(parsed.rules)) {
+    base.rules = precompilePolicyRuleRegexes(parsed.rules.filter(isValidRule));
+  }
+  if (Array.isArray(parsed.deny) && base.rules.length === 0) {
+    base.rules = precompilePolicyRuleRegexes(migrateLegacyDeny(parsed.deny));
+  }
+  if (parsed.sandbox && typeof parsed.sandbox === "object" && !Array.isArray(parsed.sandbox)) {
+    const sb = parsed.sandbox;
+    if (typeof sb.mode === "string" && isValidMode(sb.mode))
+      base.sandbox.mode = sb.mode;
+    if (typeof sb.network === "boolean")
+      base.sandbox.network = sb.network;
+    if (Array.isArray(sb.read_deny))
+      base.sandbox.read_deny = sb.read_deny.filter((v) => typeof v === "string");
+    if (typeof sb.write_allow_from_runtime === "boolean")
+      base.sandbox.write_allow_from_runtime = sb.write_allow_from_runtime;
+  }
+  if (parsed.isolation && typeof parsed.isolation === "object" && !Array.isArray(parsed.isolation)) {
+    const iso = parsed.isolation;
+    if (iso.default_mode === "worktree")
+      base.isolation.default_mode = iso.default_mode;
+    if (typeof iso.repo_symlink_fallback === "boolean")
+      base.isolation.repo_symlink_fallback = iso.repo_symlink_fallback;
+    if (typeof iso.strict_provisioning === "boolean")
+      base.isolation.strict_provisioning = iso.strict_provisioning;
+    if (typeof iso.fail_closed_on_provision_error === "boolean")
+      base.isolation.fail_closed_on_provision_error = iso.fail_closed_on_provision_error;
+  }
+  if (parsed.completion && typeof parsed.completion === "object" && !Array.isArray(parsed.completion)) {
+    const comp = parsed.completion;
+    if (typeof comp.derive_checks_from_scope === "boolean")
+      base.completion.derive_checks_from_scope = comp.derive_checks_from_scope;
+    if (Array.isArray(comp.checks))
+      base.completion.checks = comp.checks.filter((v) => typeof v === "string");
+    if (Array.isArray(comp.typescript_config_probe))
+      base.completion.typescript_config_probe = comp.typescript_config_probe.filter((v) => typeof v === "string");
+    if (Array.isArray(comp.eslint_config_probe))
+      base.completion.eslint_config_probe = comp.eslint_config_probe.filter((v) => typeof v === "string");
+  }
+  if (parsed.runtime_image && typeof parsed.runtime_image === "object" && !Array.isArray(parsed.runtime_image)) {
+    const runtimeImage = parsed.runtime_image;
+    if (runtimeImage.deps && typeof runtimeImage.deps === "object" && !Array.isArray(runtimeImage.deps)) {
+      const deps = runtimeImage.deps;
+      if (typeof deps.monorepo_install === "boolean") {
+        base.runtime_image.deps.monorepo_install = deps.monorepo_install;
+      }
+      if (typeof deps.hp_next_install === "boolean") {
+        base.runtime_image.deps.hp_next_install = deps.hp_next_install;
+      }
+    }
+    if (typeof runtimeImage.plugins_require_binaries === "boolean") {
+      base.runtime_image.plugins_require_binaries = runtimeImage.plugins_require_binaries;
+    }
+  }
+  if (parsed.runtime_snapshot && typeof parsed.runtime_snapshot === "object" && !Array.isArray(parsed.runtime_snapshot)) {
+    const runtimeSnapshot = parsed.runtime_snapshot;
+    if (typeof runtimeSnapshot.enabled === "boolean") {
+      base.runtime_snapshot.enabled = runtimeSnapshot.enabled;
+    }
+  }
+  return base;
+}
+function isValidMode(value) {
+  return value === "off" || value === "observe" || value === "enforce";
+}
+function isValidRule(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const r = value;
+  return typeof r.id === "string" && typeof r.category === "string" && r.match != null && typeof r.match === "object";
+}
+function migrateLegacyDeny(deny) {
+  const rules = [];
+  for (const entry of deny) {
+    if (typeof entry.id !== "string")
+      continue;
+    const match = {};
+    if (typeof entry.pattern === "string")
+      match.pattern = entry.pattern;
+    if (typeof entry.regex === "string")
+      match.regex = entry.regex;
+    if (!match.pattern && !match.regex)
+      continue;
+    rules.push({
+      id: entry.id,
+      category: "command",
+      match,
+      action: "block",
+      ...typeof entry.description === "string" ? { description: entry.description } : {}
+    });
+  }
+  return rules;
+}
+function precompilePolicyRuleRegexes(rules) {
+  return rules.map((rule) => {
+    const compiledRegex = rule.match.regex ? compileSafeRegex(rule.match.regex, `rules.${rule.id}.match.regex`, true) : undefined;
+    const compiledUnlessRegex = rule.unless?.regex ? compileSafeRegex(rule.unless.regex, `rules.${rule.id}.unless.regex`, true) : undefined;
+    return {
+      ...rule,
+      ...compiledRegex ? { compiledRegex } : {},
+      ...compiledUnlessRegex ? { compiledUnlessRegex } : {}
+    };
+  });
+}
+function getRegexUnsafeReason(pattern) {
+  if (pattern.length > 512) {
+    return "pattern exceeds max safe length (512 chars)";
+  }
+  if (/\\[1-9]/.test(pattern)) {
+    return "pattern uses backreferences";
+  }
+  if (/\((?:[^()\\]|\\.)*[+*](?:[^()\\]|\\.)*\)\s*[*+{]/.test(pattern)) {
+    return "pattern contains nested quantifiers";
+  }
+  if (/\((?:[^()\\]|\\.)*\.\\?[+*](?:[^()\\]|\\.)*\)\s*[*+{]/.test(pattern)) {
+    return "pattern contains nested broad quantifiers";
+  }
+  return null;
+}
+function compileSafeRegex(pattern, sourceLabel, logOnFailure) {
+  const cached = compiledRegexCache.get(pattern);
+  if (cached !== undefined) {
+    return cached ?? undefined;
+  }
+  const unsafeReason = getRegexUnsafeReason(pattern);
+  if (unsafeReason) {
+    if (logOnFailure) {
+      console.warn(`[policy] Skipping unsafe regex in ${sourceLabel}: ${unsafeReason}`);
+    }
+    compiledRegexCache.set(pattern, null);
+    return;
+  }
+  try {
+    const compiled = new RegExp(pattern);
+    compiledRegexCache.set(pattern, compiled);
+    return compiled;
+  } catch (error) {
+    if (logOnFailure) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(`[policy] Skipping invalid regex in ${sourceLabel}: ${message}`);
+    }
+    compiledRegexCache.set(pattern, null);
+    return;
+  }
+}
+function matchRule(rule, input) {
+  const { match } = rule;
+  if (match.pattern && input.includes(match.pattern)) {
+    return true;
+  }
+  if (match.regex) {
+    const compiled = rule.compiledRegex || compileSafeRegex(match.regex, `rules.${rule.id}.match.regex`, false);
+    if (!compiled) {
+      return false;
+    }
+    try {
+      return compiled.test(input);
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+function matchRuleUnless(rule, command, taskId) {
+  if (!rule.unless)
+    return false;
+  if (rule.unless.regex) {
+    const compiled = rule.compiledUnlessRegex || compileSafeRegex(rule.unless.regex, `rules.${rule.id}.unless.regex`, false);
+    if (!compiled) {
+      return false;
+    }
+    try {
+      if (compiled.test(command))
+        return true;
+    } catch {}
+  }
+  if (rule.unless.task_in && taskId) {
+    if (rule.unless.task_in.includes(taskId))
+      return true;
+  }
+  return false;
+}
+function resolveAction(mode, matched) {
+  if (matched.length === 0)
+    return "allow";
+  if (mode === "off")
+    return "allow";
+  if (mode === "observe")
+    return "warn";
+  return "block";
+}
+function resolveAbsolutePath(projectRoot, rawPath) {
+  if (rawPath.startsWith("/"))
+    return resolve(rawPath);
+  return resolve(projectRoot, rawPath);
+}
+function isHarnessPath(projectRoot, rawPath) {
+  const absPath = resolveAbsolutePath(projectRoot, rawPath);
+  const managedRoots = [
+    resolve(projectRoot, "rig"),
+    resolve(projectRoot, ".rig"),
+    resolve(projectRoot, "artifacts")
+  ];
+  return managedRoots.some((root) => absPath === root || absPath.startsWith(root + "/"));
+}
+function isRuntimePath(projectRoot, rawPath, taskWorkspace) {
+  const absPath = resolveAbsolutePath(projectRoot, rawPath);
+  if (taskWorkspace) {
+    const workspaceRigRoot = resolve(taskWorkspace, ".rig");
+    const workspaceArtifactsRoot = resolve(taskWorkspace, "artifacts");
+    if (absPath === workspaceRigRoot || absPath.startsWith(workspaceRigRoot + "/") || absPath === workspaceArtifactsRoot || absPath.startsWith(workspaceArtifactsRoot + "/")) {
+      return true;
+    }
+  }
+  const runtimeRoot = resolve(projectRoot, ".rig/runtime/agents");
+  return absPath === runtimeRoot || absPath.startsWith(runtimeRoot + "/");
+}
+function isTestFile(path) {
+  return /\.(test|spec)\.(ts|tsx|js|jsx)$/.test(path) || /\/(__tests__|tests|test)\//.test(path);
+}
+function evaluate(context) {
+  const policy = loadPolicy(context.projectRoot);
+  switch (context.evaluation.type) {
+    case "tool-call":
+      return evaluateToolCall(policy, context);
+    case "command":
+      return evaluateCommand(policy, context);
+    case "content-write":
+      return evaluateContent(policy, context);
+    case "file-access":
+      return evaluateScope(policy, context, context.evaluation.file_path, context.evaluation.access);
+  }
+}
+function evaluateScope(policy, context, filePath, access) {
+  const allowed = () => ({
+    allowed: true,
+    matchedRules: [],
+    action: "allow",
+    failClosed: false
+  });
+  if (policy.scope.harness_paths_exempt && isHarnessPath(context.projectRoot, filePath)) {
+    return allowed();
+  }
+  if (policy.scope.runtime_paths_exempt && isRuntimePath(context.projectRoot, filePath, context.taskWorkspace)) {
+    return allowed();
+  }
+  if (!context.taskId) {
+    if (access === "write" && policy.scope.fail_closed) {
+      return {
+        allowed: false,
+        matchedRules: [],
+        action: resolveAction(policy.mode, [{ id: "scope:no-task", category: "command", reason: "No active task; fail-closed for write operations" }]),
+        failClosed: true
+      };
+    }
+    return allowed();
+  }
+  const scopes = context.taskScopes || [];
+  if (scopes.length === 0) {
+    return allowed();
+  }
+  if (context.taskWorkspace && context.taskWorkspace !== context.projectRoot && filePath.startsWith("/")) {
+    const absPath = resolve(filePath);
+    if (!absPath.startsWith(context.taskWorkspace + "/") && !isHarnessPath(context.projectRoot, filePath)) {
+      const reason2 = `Absolute path '${filePath}' is outside task runtime boundary. Allowed root: ${context.taskWorkspace}`;
+      const matched2 = [{ id: "scope:workspace-boundary", category: "command", reason: reason2 }];
+      return {
+        allowed: policy.mode !== "enforce",
+        matchedRules: matched2,
+        action: resolveAction(policy.mode, matched2),
+        failClosed: false
+      };
+    }
+  }
+  const monorepoRoot = context.monorepoRoot || process.env.MONOREPO_ROOT?.trim() || context.taskWorkspace || context.projectRoot;
+  let normalizedPath = filePath;
+  if (context.taskWorkspace && context.taskWorkspace !== context.projectRoot && filePath.startsWith(context.taskWorkspace + "/")) {
+    normalizedPath = filePath.slice(context.taskWorkspace.length + 1);
+  }
+  normalizedPath = normalizePathToScope(context.projectRoot, monorepoRoot, normalizedPath);
+  if (scopeMatches(filePath, scopes) || scopeMatches(normalizedPath, scopes)) {
+    return allowed();
+  }
+  const reason = `File '${filePath}' (normalized: '${normalizedPath}') is outside scope of task ${context.taskId}`;
+  const matched = [{ id: "scope:out-of-scope", category: "command", reason }];
+  return {
+    allowed: policy.mode !== "enforce",
+    matchedRules: matched,
+    action: resolveAction(policy.mode, matched),
+    failClosed: false
+  };
+}
+function evaluateCommand(policy, context) {
+  const evaluation = context.evaluation;
+  if (evaluation.type !== "command") {
+    return { allowed: true, matchedRules: [], action: "allow", failClosed: false };
+  }
+  const command = evaluation.command;
+  const matchedRules = [];
+  for (const rule of policy.rules) {
+    if (rule.category !== "command")
+      continue;
+    if (!matchRule(rule, command))
+      continue;
+    if (matchRuleUnless(rule, command, context.taskId))
+      continue;
+    matchedRules.push({
+      id: rule.id,
+      category: rule.category,
+      ...rule.description !== undefined ? { description: rule.description } : {},
+      reason: rule.description || `Matched rule ${rule.id}`
+    });
+  }
+  const writeTarget = extractWriteTarget(command);
+  if (writeTarget && !/^\/dev\//.test(writeTarget) && !/^\/proc\//.test(writeTarget)) {
+    const scopeResult = evaluateScope(policy, context, writeTarget, "write");
+    if (!scopeResult.allowed || scopeResult.matchedRules.length > 0) {
+      matchedRules.push(...scopeResult.matchedRules);
+    }
+  }
+  const action = resolveAction(policy.mode, matchedRules);
+  return {
+    allowed: action !== "block",
+    matchedRules,
+    action,
+    failClosed: false
+  };
+}
+function extractWriteTarget(command) {
+  const redirect = command.match(/>>?\s+([^\s;|&]+)/);
+  if (redirect?.[1])
+    return redirect[1];
+  const tee = command.match(/tee\s+(-a\s+)?([^\s;|&]+)/);
+  if (tee?.[2])
+    return tee[2];
+  return "";
+}
+function evaluateContent(policy, context) {
+  const evaluation = context.evaluation;
+  if (evaluation.type !== "content-write") {
+    return { allowed: true, matchedRules: [], action: "allow", failClosed: false };
+  }
+  const { content, file_path } = evaluation;
+  const matchedRules = [];
+  const scopeResult = evaluateScope(policy, context, file_path, "write");
+  if (scopeResult.matchedRules.length > 0) {
+    matchedRules.push(...scopeResult.matchedRules);
+  }
+  for (const rule of policy.rules) {
+    if (rule.category !== "content" && rule.category !== "import" && rule.category !== "test-integrity")
+      continue;
+    if (rule.applies_to === "test-files" && !isTestFile(file_path))
+      continue;
+    if (!matchRule(rule, content))
+      continue;
+    if (matchRuleUnless(rule, content, context.taskId))
+      continue;
+    matchedRules.push({
+      id: rule.id,
+      category: rule.category,
+      ...rule.description !== undefined ? { description: rule.description } : {},
+      reason: rule.description || `Matched rule ${rule.id}`
+    });
+  }
+  const action = resolveAction(policy.mode, matchedRules);
+  return {
+    allowed: action !== "block",
+    matchedRules,
+    action,
+    failClosed: false
+  };
+}
+function evaluateToolCall(policy, context) {
+  const evaluation = context.evaluation;
+  if (evaluation.type !== "tool-call") {
+    return { allowed: true, matchedRules: [], action: "allow", failClosed: false };
+  }
+  const { tool_name, tool_input } = evaluation;
+  const allMatched = [];
+  const filePaths = extractFilePathsFromToolInput(tool_name, tool_input);
+  for (const fp of filePaths) {
+    const access = isWriteTool(tool_name) ? "write" : "read";
+    const scopeResult = evaluateScope(policy, context, fp, access);
+    if (scopeResult.matchedRules.length > 0) {
+      allMatched.push(...scopeResult.matchedRules);
+    }
+  }
+  const content = extractContentFromToolInput(tool_input);
+  if (content) {
+    const filePath = filePaths[0] || "";
+    const contentContext = {
+      ...context,
+      evaluation: { type: "content-write", file_path: filePath, content }
+    };
+    const contentPolicy = loadPolicy(context.projectRoot);
+    for (const rule of contentPolicy.rules) {
+      if (rule.category !== "content" && rule.category !== "import" && rule.category !== "test-integrity")
+        continue;
+      if (rule.applies_to === "test-files" && !isTestFile(filePath))
+        continue;
+      if (!matchRule(rule, content))
+        continue;
+      if (matchRuleUnless(rule, content, context.taskId))
+        continue;
+      allMatched.push({
+        id: rule.id,
+        category: rule.category,
+        ...rule.description !== undefined ? { description: rule.description } : {},
+        reason: rule.description || `Matched rule ${rule.id}`
+      });
+    }
+  }
+  if (tool_name === "Bash") {
+    const command = String(tool_input.command || tool_input.cmd || "");
+    if (command) {
+      const cmdContext = {
+        ...context,
+        evaluation: { type: "command", command }
+      };
+      const cmdResult = evaluateCommand(policy, cmdContext);
+      if (cmdResult.matchedRules.length > 0) {
+        allMatched.push(...cmdResult.matchedRules);
+      }
+    }
+  }
+  const seen = new Set;
+  const deduplicated = [];
+  for (const rule of allMatched) {
+    if (!seen.has(rule.id)) {
+      seen.add(rule.id);
+      deduplicated.push(rule);
+    }
+  }
+  const action = resolveAction(policy.mode, deduplicated);
+  return {
+    allowed: action !== "block",
+    matchedRules: deduplicated,
+    action,
+    failClosed: false
+  };
+}
+function isWriteTool(toolName) {
+  return toolName === "Write" || toolName === "Edit" || toolName === "MultiEdit";
+}
+function extractFilePathsFromToolInput(toolName, input) {
+  const paths = [];
+  const add = (value) => {
+    if (typeof value === "string" && value.trim()) {
+      paths.push(value.trim());
+    }
+  };
+  if (toolName === "Read" || toolName === "Write" || toolName === "Edit" || toolName === "MultiEdit") {
+    add(input.file_path);
+    add(input.path);
+  } else if (toolName === "Glob") {
+    add(input.path);
+  } else if (toolName === "Grep") {
+    add(input.path);
+  } else {
+    add(input.file_path);
+    add(input.path);
+  }
+  return paths;
+}
+function extractContentFromToolInput(input) {
+  if (typeof input.content === "string")
+    return input.content;
+  if (typeof input.new_string === "string")
+    return input.new_string;
+  return "";
+}
+var guardHotPathPrimed = false;
+function primeGuardHotPaths() {
+  if (guardHotPathPrimed) {
+    return;
+  }
+  guardHotPathPrimed = true;
+  try {
+    optimizeNextInvocation(matchRule);
+    optimizeNextInvocation(evaluate);
+  } catch {}
+}
+primeGuardHotPaths();
+
+// packages/cli-surface-plugin/src/control-plane/agent-binary-build.ts
+import { runtimeProvisioningEnv } from "@rig/core/runtime-provisioning-env";
+
+// packages/cli-surface-plugin/src/runner.ts
 class CliError extends RuntimeCliError {
-  hint;
   constructor(message, exitCode = 1, options = {}) {
-    super(message, exitCode);
-    if (options.hint?.trim()) {
-      this.hint = options.hint.trim();
+    super(message, exitCode, options);
+  }
+}
+function formatCommand(parts) {
+  return parts.map((part) => /[^a-zA-Z0-9_./:-]/.test(part) ? JSON.stringify(part) : part).join(" ");
+}
+function takeFlag(args, flag) {
+  const rest = [];
+  let value = false;
+  for (const arg of args) {
+    if (arg === flag) {
+      value = true;
+      continue;
+    }
+    rest.push(arg);
+  }
+  return { value, rest };
+}
+function takeOption(args, option) {
+  const rest = [];
+  let value;
+  for (let index = 0;index < args.length; index += 1) {
+    const current = args[index];
+    if (current === option) {
+      const next = args[index + 1];
+      if (!next || next.startsWith("-")) {
+        throw new CliError(`Missing value for ${option}`, 1, { hint: `Provide a value after ${option}, e.g. \`${option} <value>\`.` });
+      }
+      value = next;
+      index += 1;
+      continue;
+    }
+    if (current !== undefined) {
+      rest.push(current);
+    }
+  }
+  return { value, rest };
+}
+function requireNoExtraArgs(args, usage) {
+  if (args.length > 0) {
+    throw new CliError(`Unexpected arguments: ${args.join(" ")}
+Usage: ${usage}`);
+  }
+}
+
+// packages/cli-surface-plugin/src/control-plane/native/git-ops.ts
+import { existsSync as existsSync4, lstatSync, mkdirSync, readFileSync as readFileSync3, unlinkSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { dirname, isAbsolute, resolve as resolve3 } from "path";
+import { fileURLToPath } from "url";
+import { loadDotEnvSecrets, resolveRuntimeSecrets } from "@rig/core/baked-secrets";
+import { loadRuntimeContext, loadRuntimeContextFromEnv } from "@rig/core/runtime-context";
+
+// packages/cli-surface-plugin/src/control-plane/task-data.ts
+import { TASK_DATA_SERVICE_CAPABILITY } from "@rig/contracts";
+import { defineCapability } from "@rig/core/capability";
+import { requireInstalledCapability } from "@rig/core/capability-loaders";
+var TaskDataCap = defineCapability(TASK_DATA_SERVICE_CAPABILITY);
+function taskData() {
+  return requireInstalledCapability(TaskDataCap, "task-data capability unavailable: load @rig/task-sources-plugin (default bundle) before running CLI git operations.");
+}
+
+// packages/cli-surface-plugin/src/control-plane/native/git-ops.ts
+import { nowIso, runCapture as baseRunCapture } from "@rig/core/exec";
+import { resolveCheckoutRoot as resolveMonorepoRoot } from "@rig/core/checkout-root";
+import { getScopeRules as getScopeRules2 } from "@rig/core/scope-rules";
+
+// packages/cli-surface-plugin/src/control-plane/native/github-auth-env.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+function cleanToken(value) {
+  const trimmed = value?.trim() ?? "";
+  return trimmed.length > 0 ? trimmed : null;
+}
+function authStateToken(env = process.env) {
+  const file = env.RIG_GITHUB_AUTH_STATE_FILE?.trim();
+  if (!file || !existsSync2(file))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync2(file, "utf8"));
+    return cleanToken(typeof parsed.token === "string" ? parsed.token : undefined);
+  } catch {
+    return null;
+  }
+}
+
+// packages/cli-surface-plugin/src/control-plane/native/git-ops.ts
+import { safePathSegment } from "@rig/core/safe-identifiers";
+
+// packages/cli-surface-plugin/src/control-plane/native/host-git.ts
+import { existsSync as existsSync3 } from "fs";
+import { resolve as resolve2 } from "path";
+function isRuntimeGatewayGitPath(candidate) {
+  return /\/\.rig\/bin\/git$/.test(candidate.replace(/\\/g, "/"));
+}
+function isRuntimeGatewayGhPath(candidate) {
+  return /\/\.rig\/bin\/gh$/.test(candidate.replace(/\\/g, "/"));
+}
+function resolveHostGitBinary() {
+  const candidates = [
+    process.env.RIG_GIT_BIN?.trim() || "",
+    "/usr/bin/git",
+    "/opt/homebrew/bin/git",
+    "/usr/local/bin/git"
+  ];
+  const bunResolved = Bun.which("git");
+  if (bunResolved && !isRuntimeGatewayGitPath(bunResolved))
+    candidates.push(bunResolved);
+  for (const candidate of candidates) {
+    if (candidate && !isRuntimeGatewayGitPath(candidate) && existsSync3(candidate))
+      return candidate;
+  }
+  return "git";
+}
+function resolveGithubCliBinary(options = {}) {
+  const candidates = new Set;
+  const explicit = process.env.RIG_GH_BIN?.trim();
+  if (explicit)
+    candidates.add(explicit);
+  for (const candidate of ["/usr/bin/gh", "/opt/homebrew/bin/gh", "/usr/local/bin/gh"])
+    candidates.add(candidate);
+  if (options.scanPath) {
+    for (const entry of (process.env.PATH || "").split(":").map((value) => value.trim()).filter(Boolean)) {
+      candidates.add(resolve2(entry, "gh"));
+    }
+  }
+  const bunResolved = Bun.which("gh");
+  if (bunResolved)
+    candidates.add(bunResolved);
+  for (const candidate of candidates) {
+    if (candidate && existsSync3(candidate) && !isRuntimeGatewayGhPath(candidate))
+      return candidate;
+  }
+  return "";
+}
+
+// packages/cli-surface-plugin/src/control-plane/native/git-ops.ts
+var TASK_RUNTIME_STAGE_EXCLUDES = [
+  ".rig/bin/**",
+  ".rig/cache/**",
+  ".rig/home/**",
+  ".rig/logs/**",
+  ".rig/runtime/**",
+  ".rig/session/**",
+  ".rig/state/**",
+  ".rig/runtime-context.json"
+];
+var GENERATED_STAGE_EXCLUDES = ["artifacts/*/runtime-snapshots/**"];
+var TASK_ARTIFACT_STAGE_FALLBACK = new Set([
+  "changed-files.txt",
+  "contract-changes.md",
+  "decision-log.md",
+  "git-state.txt",
+  "next-actions.md",
+  "pr-state.json",
+  "task-result.json",
+  "validation-summary.json"
+]);
+function resolveOptionalMonorepoRoot(projectRoot) {
+  const runtimeWorkspace = process.env.RIG_TASK_WORKSPACE?.trim();
+  if (runtimeWorkspace && existsSync4(resolve3(runtimeWorkspace, ".git"))) {
+    return resolve3(runtimeWorkspace);
+  }
+  try {
+    return resolveMonorepoRoot(projectRoot);
+  } catch {
+    return null;
+  }
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function safeCurrentTaskId(projectRoot) {
+  try {
+    const taskId = taskData().currentTaskId(projectRoot);
+    return /^bd-[a-z0-9-]+$/.test(taskId) ? taskId : "";
+  } catch {
+    return "";
+  }
+}
+function gitCmd(projectRoot, repoRoot, ...args) {
+  return [resolveHostGitBinary(), "-C", repoRoot, ...args];
+}
+function shouldScopeGitCommit(args, hasTaskContext) {
+  if (!hasTaskContext) {
+    return false;
+  }
+  return args.includes("--scoped");
+}
+function gitStatus(projectRoot, taskId) {
+  const monorepoRoot = resolveOptionalMonorepoRoot(projectRoot);
+  const resolvedTask = taskId || safeCurrentTaskId(projectRoot);
+  const expected = resolvedTask ? `rig/${resolveTaskBranchId(projectRoot, resolvedTask)}` : "";
+  console.log("=== Git Flow Status ===");
+  if (resolvedTask) {
+    console.log(`Task: ${resolvedTask}`);
+    console.log(`Expected monorepo branch: ${expected}`);
+  } else {
+    console.log("Task: (none active)");
+  }
+  console.log("");
+  printRepoStatus(projectRoot, "project-rig", projectRoot, "");
+  const monorepoPath = monorepoRoot || resolveMonorepoRoot(projectRoot);
+  if (monorepoPath !== projectRoot) {
+    printRepoStatus(projectRoot, "monorepo", monorepoPath, expected);
+  }
+}
+function gitChanged(projectRoot, taskId, scoped) {
+  if (scoped) {
+    const resolvedTask = taskId || taskData().currentTaskId(projectRoot);
+    if (!resolvedTask) {
+      throw new Error("No task specified and no active task in session. Use --task or omit --scoped.");
+    }
+    return taskData().changedFilesForTask(projectRoot, resolvedTask, true);
+  }
+  return taskData().changedFilesForTask(projectRoot, taskId || taskData().currentTaskId(projectRoot) || "", false);
+}
+function gitPreflight(projectRoot, taskId, strict) {
+  const monorepoRoot = resolveOptionalMonorepoRoot(projectRoot);
+  const resolvedTask = taskId || safeCurrentTaskId(projectRoot);
+  const expected = resolvedTask ? `rig/${resolveTaskBranchId(projectRoot, resolvedTask)}` : "";
+  console.log("=== Git Flow Preflight ===");
+  let issues = 0;
+  if (!existsSync4(resolve3(projectRoot, ".git"))) {
+    console.log(`ERROR: project root is not a git repo (${projectRoot})`);
+    issues += 1;
+  }
+  if (monorepoRoot && existsSync4(resolve3(monorepoRoot, ".git"))) {
+    const monoBranch = branchName(projectRoot, monorepoRoot);
+    if (expected && monoBranch !== expected) {
+      console.log(`WARN: monorepo branch is ${monoBranch}, expected ${expected} for task ${resolvedTask}`);
+      if (strict) {
+        issues += 1;
+      }
+    }
+    const monoChanges = changeCount(projectRoot, monorepoRoot);
+    if (monoChanges > 0 && !monoBranch.startsWith("rig/")) {
+      console.log(`WARN: monorepo has uncommitted changes on non-rig branch (${monoBranch})`);
+      issues += 1;
+    }
+  } else {
+    console.log(`WARN: monorepo repo unavailable.`);
+  }
+  const projectChanges = changeCount(projectRoot, projectRoot);
+  if (projectChanges > 0) {
+    console.log(`INFO: project-rig has ${projectChanges} changed file(s).`);
+  }
+  if (issues > 0) {
+    console.log(`Preflight: ${issues} issue(s) detected.`);
+    return false;
+  }
+  console.log("Preflight: OK");
+  return true;
+}
+function gitSyncBranch(projectRoot, taskId, targetRepo = "monorepo") {
+  const resolvedTask = taskId || safeCurrentTaskId(projectRoot);
+  if (!resolvedTask) {
+    throw new Error("No task specified and no active task in session.");
+  }
+  const repoRoot = targetRepo === "monorepo" ? resolveOptionalMonorepoRoot(projectRoot) || resolveMonorepoRoot(projectRoot) : projectRoot;
+  const repoLabel = targetRepo === "monorepo" ? "Monorepo" : "Project";
+  if (!existsSync4(resolve3(repoRoot, ".git"))) {
+    throw new Error(`${repoLabel} repo not found at ${repoRoot}`);
+  }
+  const branchId = resolveTaskBranchId(projectRoot, resolvedTask);
+  const branchTarget = `rig/${branchId}`;
+  const current = branchName(projectRoot, repoRoot);
+  if (current === branchTarget) {
+    console.log(`${repoLabel} branch: already on ${branchTarget}`);
+    return;
+  }
+  const hasBranch = runCapture(gitCmd(projectRoot, repoRoot, "show-ref", "--verify", "--quiet", `refs/heads/${branchTarget}`), projectRoot).exitCode === 0;
+  const cmd = hasBranch && current === "HEAD" ? gitCmd(projectRoot, repoRoot, "checkout", "-B", branchTarget) : hasBranch ? gitCmd(projectRoot, repoRoot, "checkout", branchTarget) : gitCmd(projectRoot, repoRoot, "checkout", "-b", branchTarget);
+  const checkout = runCapture(cmd, projectRoot);
+  if (checkout.exitCode !== 0) {
+    throw new Error(`Failed to sync ${repoLabel.toLowerCase()} branch: ${checkout.stderr || checkout.stdout}`);
+  }
+  const action = hasBranch && current === "HEAD" ? "reset" : hasBranch ? "checked out" : "created";
+  console.log(`${repoLabel} branch: ${action} ${branchTarget}`);
+}
+function gitCommit(options) {
+  const { projectRoot } = options;
+  const resolvedTask = options.taskId || safeCurrentTaskId(projectRoot);
+  const baseMessage = options.message || (resolvedTask ? `rig: ${resolvedTask}` : "rig: harness update");
+  const changedFilesManifest = resolvedTask && options.scoped === true ? refreshChangedFilesManifest(projectRoot, resolvedTask) : "";
+  const changedFiles = resolvedTask && options.scoped === true ? readChangedFilesManifest(projectRoot, resolvedTask) : resolvedTask ? taskData().changedFilesForTask(projectRoot, resolvedTask, false) : [];
+  if (options.target === "project" || options.target === "both") {
+    if (resolvedTask) {
+      gitSyncBranch(projectRoot, resolvedTask, "project");
+    }
+    const projectFiles = resolveScopedStageFilesForRepo(projectRoot, projectRoot, resolvedTask, changedFiles);
+    commitRepo(projectRoot, projectRoot, "project-rig", options.target === "both" ? `${baseMessage} [harness]` : baseMessage, options.allowEmpty, options.scoped === true, projectFiles, changedFilesManifest);
+  }
+  if (options.target === "monorepo" || options.target === "both") {
+    const monorepoRoot = resolveOptionalMonorepoRoot(projectRoot) || resolveMonorepoRoot(projectRoot);
+    if (resolvedTask) {
+      gitSyncBranch(projectRoot, resolvedTask, "monorepo");
+    }
+    const monorepoFiles = resolveScopedStageFilesForRepo(projectRoot, monorepoRoot, resolvedTask, changedFiles);
+    commitRepo(projectRoot, monorepoRoot, "monorepo", options.target === "both" ? `${baseMessage} [monorepo]` : baseMessage, options.allowEmpty, options.scoped === true, monorepoFiles, changedFilesManifest);
+  }
+}
+function gitSnapshot(projectRoot, taskId, outputPath) {
+  const monorepoRoot = resolveOptionalMonorepoRoot(projectRoot);
+  const resolvedTask = taskId || safeCurrentTaskId(projectRoot);
+  const output = outputPath || (resolvedTask ? resolveArtifactSnapshot(projectRoot, resolvedTask) : resolve3(resolve3(projectRoot, ".rig", "state"), "git-state.txt"));
+  mkdirSync(dirname(output), { recursive: true });
+  const lines = ["# Git Snapshot", `timestamp: ${nowIso()}`];
+  if (resolvedTask) {
+    lines.push(`task: ${resolvedTask}`);
+  }
+  lines.push("");
+  lines.push(...snapshotRepo(projectRoot, "project-rig", projectRoot));
+  if (monorepoRoot && monorepoRoot !== projectRoot) {
+    lines.push(...snapshotRepo(projectRoot, "monorepo", monorepoRoot));
+  }
+  writeFileSync(output, `${lines.join(`
+`)}
+`, "utf-8");
+  return output;
+}
+function gitOpenPr(options) {
+  const gh = resolveGithubCliBinary({ scanPath: true });
+  if (!gh) {
+    throw new Error("gh CLI is required for open-pr. Install and authenticate with: gh auth login");
+  }
+  const taskId = options.taskId || safeCurrentTaskId(options.projectRoot);
+  const target = options.target || (taskId ? "monorepo" : "project");
+  let repoRoot = options.projectRoot;
+  let repoLabel = "project-rig";
+  const envBase = target === "monorepo" ? process.env.RIG_PR_BASE_MONOREPO?.trim() || "" : process.env.RIG_PR_BASE_PROJECT?.trim() || "";
+  if (target === "monorepo") {
+    repoRoot = resolveOptionalMonorepoRoot(options.projectRoot) || resolveMonorepoRoot(options.projectRoot);
+    repoLabel = "monorepo";
+    if (taskId) {
+      gitSyncBranch(options.projectRoot, taskId, "monorepo");
+    }
+  } else if (taskId) {
+    gitSyncBranch(options.projectRoot, taskId, "project");
+  }
+  if (!existsSync4(resolve3(repoRoot, ".git"))) {
+    throw new Error(`Repository not available for open-pr target ${target}: ${repoRoot}`);
+  }
+  const branch = branchName(options.projectRoot, repoRoot);
+  if (!branch || branch === "HEAD") {
+    throw new Error(`Cannot open PR from detached HEAD in ${repoLabel}. Checkout a branch first.`);
+  }
+  const repoNameWithOwner = resolveRepoNameWithOwner(options.projectRoot, repoRoot);
+  const networkRemote = resolveNetworkRemoteName(options.projectRoot, repoRoot, repoNameWithOwner);
+  const base = options.base || envBase || inferRepositoryDefaultBase(options.projectRoot, repoRoot, repoNameWithOwner, networkRemote, target === "project" ? inferProjectBase(options.projectRoot, "main") : "main");
+  refreshRemoteBaseRef(options.projectRoot, repoRoot, base);
+  let reviewer = (options.reviewer || "").trim();
+  let reviewerSource = reviewer ? "flag" : undefined;
+  if (!reviewer && taskId) {
+    reviewer = defaultReviewerForTask(options.projectRoot, taskId);
+    if (reviewer) {
+      reviewerSource = "task-config";
+    }
+  }
+  if (!reviewer) {
+    reviewer = inferReviewerFromChangedFiles(options.projectRoot, repoRoot, base, branch);
+    if (reviewer) {
+      reviewerSource = "changed-files";
+    }
+  }
+  if (!reviewer) {
+    reviewer = (process.env.RIG_PR_REVIEWER || "").trim();
+    if (reviewer) {
+      reviewerSource = "env";
+    }
+  }
+  let title = options.title || "";
+  if (!title) {
+    if (taskId) {
+      title = `rig: ${taskId}`;
+    } else {
+      title = `rig: update ${branch}`;
+    }
+  }
+  const body = options.body || [
+    "## Summary",
+    "- Automated task output prepared in isolated runtime.",
+    "",
+    "## Task",
+    `- beads: ${taskId || "n/a"}`,
+    ...defaultPrRunLines(taskId, repoNameWithOwner),
+    "",
+    "## Review",
+    "- Completion verification will run validation, verifier review, and PR policy checks.",
+    "- When repository policy allows it, Rig attempts an immediate strict-gated, head-locked merge after approval."
+  ].join(`
+`);
+  const preCheck = runCapture(withGhRepo([gh, "pr", "list", "--state", "merged", "--head", branch, "--json", "url,mergedAt", "--jq", ".[0]"], repoNameWithOwner), repoRoot);
+  const preCheckEntry = preCheck.exitCode === 0 ? preCheck.stdout.trim() : "";
+  if (preCheckEntry && preCheckEntry !== "null" && currentHeadMatchesMergedBase(options.projectRoot, repoRoot, base, networkRemote)) {
+    const mergedPr = JSON.parse(preCheckEntry);
+    console.log(`Branch ${branch} was already merged: ${mergedPr.url}`);
+    const result2 = { url: mergedPr.url, target, repoLabel, branch, base };
+    if (taskId)
+      writePrMetadata(options.projectRoot, taskId, result2);
+    return result2;
+  }
+  const pushArgs = gitCmd(options.projectRoot, repoRoot, "push", "-u", networkRemote, branch);
+  const fetchResult = runCapture(gitCmd(options.projectRoot, repoRoot, "fetch", networkRemote, branch), repoRoot);
+  if (fetchResult.exitCode === 0) {
+    const remoteAhead = runCapture(gitCmd(options.projectRoot, repoRoot, "log", "--oneline", `HEAD..${networkRemote}/${branch}`), repoRoot);
+    if (remoteAhead.exitCode === 0 && remoteAhead.stdout.trim()) {
+      console.log(`Remote branch has diverged \u2014 force pushing task-owned branch ${branch} with --force-with-lease...`);
+      pushArgs.splice(4, 0, "--force-with-lease");
+    }
+  }
+  runOrThrow(options.projectRoot, pushArgs, `Failed to push branch ${branch} in ${repoLabel}`);
+  const existing = runCapture(withGhRepo([gh, "pr", "list", "--state", "open", "--head", branch, "--json", "url", "--jq", ".[0].url"], repoNameWithOwner), repoRoot);
+  const existingUrl = existing.exitCode === 0 ? existing.stdout.trim() : "";
+  if (!existingUrl || existingUrl === "null") {
+    const merged = runCapture(withGhRepo([gh, "pr", "list", "--state", "merged", "--head", branch, "--json", "url,mergedAt", "--jq", ".[0]"], repoNameWithOwner), repoRoot);
+    const mergedEntry = merged.exitCode === 0 ? merged.stdout.trim() : "";
+    if (mergedEntry && mergedEntry !== "null" && currentHeadMatchesMergedBase(options.projectRoot, repoRoot, base, networkRemote)) {
+      const mergedPr = JSON.parse(mergedEntry);
+      console.log(`Branch ${branch} was already merged: ${mergedPr.url}`);
+      const result2 = { url: mergedPr.url, target, repoLabel, branch, base };
+      if (taskId)
+        writePrMetadata(options.projectRoot, taskId, result2);
+      return result2;
+    }
+  }
+  let prUrl = "";
+  if (existingUrl && existingUrl !== "null") {
+    prUrl = existingUrl;
+  } else {
+    const createArgs = [
+      gh,
+      "pr",
+      "create",
+      ...ghRepoArgs(repoNameWithOwner),
+      "--base",
+      base,
+      "--head",
+      branch,
+      "--title",
+      title,
+      "--body",
+      body
+    ];
+    if (options.draft) {
+      createArgs.push("--draft");
+    }
+    const created = runCapture(createArgs, repoRoot);
+    if (created.exitCode !== 0) {
+      throw new Error(`Failed to create PR in ${repoLabel}: ${created.stderr || created.stdout}`);
+    }
+    prUrl = created.stdout.trim();
+  }
+  if (!prUrl) {
+    throw new Error(`Failed to resolve PR URL for branch ${branch}.`);
+  }
+  assertPrHasNoGitConflicts(readPrViewState(gh, repoRoot, repoNameWithOwner, prUrl), repoLabel, base);
+  if (reviewer) {
+    const edit = runCapture(withGhRepo([gh, "pr", "edit", prUrl, "--add-reviewer", reviewer], repoNameWithOwner), repoRoot);
+    if (edit.exitCode !== 0) {
+      throw new Error(`Failed to assign reviewer '${reviewer}': ${edit.stderr || edit.stdout}`);
+    }
+  }
+  const result = {
+    url: prUrl,
+    ...reviewer ? { reviewer } : {},
+    ...reviewerSource ? { reviewerSource } : {},
+    target,
+    repoLabel,
+    branch,
+    base
+  };
+  if (taskId) {
+    writePrMetadata(options.projectRoot, taskId, result);
+  }
+  return result;
+}
+function defaultPrRunLines(taskId, repoNameWithOwner) {
+  const lines = [];
+  const runId = process.env.RIG_SERVER_RUN_ID?.trim();
+  if (runId) {
+    lines.push(`- Run: ${runId}`);
+  }
+  const closeout = defaultPrCloseoutLine(taskId, repoNameWithOwner);
+  if (closeout) {
+    lines.push(`- ${closeout}`);
+  }
+  return lines;
+}
+function defaultPrCloseoutLine(taskId, repoNameWithOwner) {
+  const sourceIssueId = loadRuntimeContextFromEnv()?.sourceTask?.sourceIssueId;
+  if (sourceIssueId) {
+    const match = sourceIssueId.match(/^([^#]+)#(\d+)$/);
+    if (match?.[1] && match[2]) {
+      const sourceRepo = match[1];
+      const issueNumber = match[2];
+      return sourceRepo.toLowerCase() === repoNameWithOwner.toLowerCase() ? `Closes #${issueNumber}` : `Closes ${sourceRepo}#${issueNumber}`;
+    }
+  }
+  return /^\d+$/.test(taskId) ? `Closes #${taskId}` : "";
+}
+function readPrViewState(gh, repoRoot, repoNameWithOwner, prUrl) {
+  const view = runCapture(withGhRepo([
+    gh,
+    "pr",
+    "view",
+    prUrl,
+    "--json",
+    "state,isDraft,url,mergedAt,autoMergeRequest,mergeable,mergeStateStatus,reviewDecision,headRefOid,statusCheckRollup",
+    "--jq",
+    "."
+  ], repoNameWithOwner), repoRoot);
+  if (view.exitCode !== 0) {
+    throw new Error(`Failed to inspect PR ${prUrl}: ${view.stderr || view.stdout}`);
+  }
+  try {
+    const parsed = JSON.parse(view.stdout);
+    return {
+      state: parsed.state || "OPEN",
+      isDraft: parsed.isDraft === true,
+      url: typeof parsed.url === "string" ? parsed.url : prUrl,
+      mergedAt: typeof parsed.mergedAt === "string" ? parsed.mergedAt : null,
+      autoMergeRequest: parsed.autoMergeRequest ?? null,
+      mergeable: typeof parsed.mergeable === "string" ? parsed.mergeable : "",
+      mergeStateStatus: typeof parsed.mergeStateStatus === "string" ? parsed.mergeStateStatus : "",
+      reviewDecision: typeof parsed.reviewDecision === "string" ? parsed.reviewDecision : "",
+      headRefOid: typeof parsed.headRefOid === "string" ? parsed.headRefOid : null,
+      statusCheckRollup: Array.isArray(parsed.statusCheckRollup) ? parsed.statusCheckRollup : []
+    };
+  } catch {
+    return {
+      state: "OPEN",
+      isDraft: false,
+      url: prUrl,
+      mergedAt: null,
+      autoMergeRequest: null,
+      mergeable: "",
+      mergeStateStatus: "",
+      reviewDecision: "",
+      headRefOid: null,
+      statusCheckRollup: []
+    };
+  }
+}
+function assertPrHasNoGitConflicts(prState, repoLabel, baseRef) {
+  const mergeable = prState.mergeable.toUpperCase();
+  const mergeStateStatus = prState.mergeStateStatus.toUpperCase();
+  if (mergeable === "CONFLICTING" || mergeStateStatus === "DIRTY") {
+    throw new Error(`PR ${prState.url || "unknown"} conflicts with ${baseRef} in ${repoLabel} (mergeable=${prState.mergeable || "unknown"}, mergeStateStatus=${prState.mergeStateStatus || "unknown"}). Rebase or merge ${baseRef} and resolve conflicts before completion-verification.`);
+  }
+}
+function writePrMetadata(projectRoot, taskId, result) {
+  const dir = taskData().artifactDirForId(projectRoot, taskId);
+  mkdirSync(dir, { recursive: true });
+  const path = resolve3(dir, "pr-state.json");
+  let prs = {};
+  if (existsSync4(path)) {
+    try {
+      const parsed = JSON.parse(readFileSync3(path, "utf-8"));
+      if (parsed && typeof parsed === "object" && parsed.prs && typeof parsed.prs === "object") {
+        prs = parsed.prs;
+      }
+    } catch {
+      prs = {};
+    }
+  }
+  prs[result.target] = result;
+  const primary = prs.monorepo || prs.project;
+  const artifact = {
+    task_id: taskId,
+    prs,
+    ...primary || {},
+    updated_at: nowIso()
+  };
+  writeFileSync(path, `${JSON.stringify(artifact, null, 2)}
+`, "utf-8");
+}
+function resolveArtifactSnapshot(projectRoot, taskId) {
+  return resolve3(taskData().artifactDirForId(projectRoot, taskId), "git-state.txt");
+}
+function ensureFullGitHistory(projectRoot, repoRoot, remoteName = "origin") {
+  const shallow = runCapture(gitCmd(projectRoot, repoRoot, "rev-parse", "--is-shallow-repository"), projectRoot);
+  if (shallow.exitCode !== 0 || shallow.stdout.trim() !== "true") {
+    return;
+  }
+  const unshallow = runCapture(gitCmd(projectRoot, repoRoot, "fetch", "--unshallow", "--tags", remoteName), projectRoot);
+  if (unshallow.exitCode === 0) {
+    return;
+  }
+  const output = `${unshallow.stderr}
+${unshallow.stdout}`.trim();
+  if (/--unshallow on a complete repository|does not make sense/i.test(output)) {
+    return;
+  }
+  throw new Error(`Failed to expand git history for ${repoRoot}: ${output}`);
+}
+function refreshRemoteBaseRef(projectRoot, repoRoot, baseRef, repoNameWithOwner = "") {
+  const remoteName = resolveNetworkRemoteName(projectRoot, repoRoot, repoNameWithOwner || resolveRepoNameWithOwner(projectRoot, repoRoot));
+  const remoteUrl = runCapture(gitCmd(projectRoot, repoRoot, "remote", "get-url", remoteName), projectRoot);
+  if (remoteUrl.exitCode !== 0) {
+    return "";
+  }
+  ensureFullGitHistory(projectRoot, repoRoot, remoteName);
+  const fetch = runCapture(gitCmd(projectRoot, repoRoot, "fetch", "--prune", "--tags", remoteName, `+refs/heads/${baseRef}:refs/remotes/${remoteName}/${baseRef}`), projectRoot);
+  if (fetch.exitCode !== 0) {
+    throw new Error(`Failed to refresh ${remoteName}/${baseRef} at ${repoRoot}: ${fetch.stderr || fetch.stdout}`);
+  }
+  return remoteName;
+}
+function currentHeadMatchesMergedBase(projectRoot, repoRoot, baseRef, remoteName = "origin") {
+  const activeRemote = refreshRemoteBaseRef(projectRoot, repoRoot, baseRef) || remoteName;
+  const remoteBase = `${activeRemote}/${baseRef}`;
+  const hasRemoteBase = runCapture(gitCmd(projectRoot, repoRoot, "rev-parse", "--verify", "--quiet", remoteBase), repoRoot).exitCode === 0;
+  const targetRef = hasRemoteBase ? remoteBase : baseRef;
+  if (runCapture(gitCmd(projectRoot, repoRoot, "merge-base", "--is-ancestor", "HEAD", targetRef), repoRoot).exitCode === 0) {
+    return true;
+  }
+  return runCapture(gitCmd(projectRoot, repoRoot, "diff", "--quiet", "HEAD", targetRef, "--"), repoRoot).exitCode === 0;
+}
+function defaultReviewerForTask(projectRoot, taskId) {
+  if (!taskId) {
+    return "";
+  }
+  const entry = taskData().readTaskConfig(projectRoot)[taskId];
+  const reviewer = entry?.reviewer;
+  if (typeof reviewer === "string" && reviewer.trim()) {
+    return reviewer.trim();
+  }
+  const responsibleReviewer = entry?.responsible_reviewer;
+  if (typeof responsibleReviewer === "string" && responsibleReviewer.trim()) {
+    return responsibleReviewer.trim();
+  }
+  return "";
+}
+function resolveRepoNameWithOwner(projectRoot, repoRoot) {
+  const explicit = normalizeGithubRepoNameWithOwner(process.env.GH_REPO || "");
+  if (explicit) {
+    return explicit;
+  }
+  const visited = new Set;
+  return resolveGithubRepoNameWithOwnerFromGitRoot(projectRoot, repoRoot, repoRoot, visited);
+}
+function resolveGithubRepoNameWithOwnerFromGitRoot(projectRoot, gitRoot, cwd, visited) {
+  const normalizedGitRoot = resolve3(gitRoot);
+  if (visited.has(normalizedGitRoot)) {
+    return "";
+  }
+  visited.add(normalizedGitRoot);
+  const remotes = listGitRemotes(projectRoot, gitRoot, cwd);
+  for (const remote of remotes) {
+    const urls = listGitRemoteUrls(projectRoot, gitRoot, cwd, remote);
+    for (const url of urls) {
+      const direct = normalizeGithubRepoNameWithOwner(url);
+      if (direct) {
+        return direct;
+      }
+      const localGitRoot = resolveLocalGitRemoteRoot(url, gitRoot);
+      if (!localGitRoot) {
+        continue;
+      }
+      const viaMirror = resolveGithubRepoNameWithOwnerFromGitRoot(projectRoot, localGitRoot, cwd, visited);
+      if (viaMirror) {
+        return viaMirror;
+      }
+    }
+  }
+  return "";
+}
+function listGitRemotes(projectRoot, gitRoot, cwd) {
+  const result = gitQuery(projectRoot, gitRoot, cwd, "remote");
+  if (result.exitCode !== 0) {
+    return [];
+  }
+  return result.stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+}
+function listGitRemoteUrls(projectRoot, gitRoot, cwd, remote) {
+  const result = gitQuery(projectRoot, gitRoot, cwd, "remote", "get-url", "--all", remote);
+  if (result.exitCode !== 0) {
+    return [];
+  }
+  return result.stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+}
+function resolveNetworkRemoteName(projectRoot, repoRoot, repoNameWithOwner) {
+  const remotes = listGitRemotes(projectRoot, repoRoot, repoRoot);
+  if (remotes.length === 0) {
+    return "origin";
+  }
+  if (!repoNameWithOwner) {
+    return remotes.includes("origin") ? "origin" : remotes[0];
+  }
+  const expectedRepo = normalizeGithubRepoNameWithOwner(repoNameWithOwner).toLowerCase();
+  let directMatch = "";
+  for (const remote of remotes) {
+    const urls = listGitRemoteUrls(projectRoot, repoRoot, repoRoot, remote);
+    for (const url of urls) {
+      const direct = normalizeGithubRepoNameWithOwner(url);
+      if (direct && direct.toLowerCase() === expectedRepo) {
+        if (remote === "github") {
+          return remote;
+        }
+        if (!directMatch) {
+          directMatch = remote;
+        }
+      }
     }
   }
+  if (remotes.includes("github")) {
+    return "github";
+  }
+  if (directMatch) {
+    return directMatch;
+  }
+  return remotes.includes("origin") ? "origin" : remotes[0];
 }
-function formatCommand(parts) {
-  return parts.map((part) => /[^a-zA-Z0-9_./:-]/.test(part) ? JSON.stringify(part) : part).join(" ");
+function gitQuery(projectRoot, gitRoot, cwd, ...args) {
+  const gitArgs = existsSync4(resolve3(gitRoot, ".git")) ? gitCmd(projectRoot, gitRoot, ...args) : [resolveHostGitBinary(), "--git-dir", gitRoot, ...args];
+  return runCapture(gitArgs, cwd, projectRoot);
 }
-function takeFlag(args, flag) {
-  const rest = [];
-  let value = false;
-  for (const arg of args) {
-    if (arg === flag) {
-      value = true;
+function resolveLocalGitRemoteRoot(remoteUrl, gitRoot) {
+  const normalized = remoteUrl.trim();
+  if (!normalized) {
+    return "";
+  }
+  let candidate = normalized;
+  if (normalized.startsWith("file://")) {
+    try {
+      candidate = fileURLToPath(normalized);
+    } catch {
+      return "";
+    }
+  } else if (/^[a-z][a-z0-9+.-]*:\/\//i.test(normalized) || /^[^@]+@[^:]+:.+$/.test(normalized)) {
+    return "";
+  } else if (!isAbsolute(normalized)) {
+    candidate = resolve3(gitRoot, normalized);
+  }
+  return existsSync4(candidate) ? candidate : "";
+}
+function normalizeGithubRepoNameWithOwner(value) {
+  const normalized = value.trim();
+  if (!normalized) {
+    return "";
+  }
+  const scpMatch = normalized.match(/^(?:ssh:\/\/)?git@github\.com[:/](.+?)(?:\.git)?$/i);
+  if (scpMatch?.[1]) {
+    return scpMatch[1].replace(/^\/+|\/+$/g, "");
+  }
+  const httpMatch = normalized.match(/^https?:\/\/github\.com\/(.+?)(?:\.git)?(?:\/)?$/i);
+  if (httpMatch?.[1]) {
+    return httpMatch[1].replace(/^\/+|\/+$/g, "");
+  }
+  const bareMatch = normalized.match(/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/);
+  return bareMatch ? bareMatch[0] : "";
+}
+function ghRepoArgs(repoNameWithOwner) {
+  return repoNameWithOwner ? ["-R", repoNameWithOwner] : [];
+}
+function withGhRepo(command, repoNameWithOwner) {
+  if (!repoNameWithOwner || command.length < 3) {
+    return command;
+  }
+  return [command[0], command[1], command[2], ...ghRepoArgs(repoNameWithOwner), ...command.slice(3)];
+}
+function inferRepositoryDefaultBase(projectRoot, repoRoot, repoNameWithOwner, remoteName, fallback) {
+  const remote = remoteName || "origin";
+  const symbolic = runCapture(gitCmd(projectRoot, repoRoot, "symbolic-ref", "--short", `refs/remotes/${remote}/HEAD`), projectRoot);
+  if (symbolic.exitCode === 0) {
+    const ref = symbolic.stdout.trim().replace(new RegExp(`^${escapeRegExp(remote)}/`), "");
+    if (ref && ref !== "HEAD") {
+      return ref;
+    }
+  }
+  const lsRemote = runCapture(gitCmd(projectRoot, repoRoot, "ls-remote", "--symref", remote, "HEAD"), projectRoot);
+  if (lsRemote.exitCode === 0) {
+    const match = lsRemote.stdout.match(/^ref:\s+refs\/heads\/([^\t\r\n]+)\s+HEAD/m);
+    if (match?.[1]) {
+      return match[1];
+    }
+  }
+  const gh = resolveGithubCliBinary({ scanPath: true });
+  if (gh && repoNameWithOwner) {
+    const api = runCapture(withGhRepo([gh, "repo", "view", "--json", "defaultBranchRef", "--jq", ".defaultBranchRef.name"], repoNameWithOwner), repoRoot);
+    const branch = api.exitCode === 0 ? api.stdout.trim() : "";
+    if (branch) {
+      return branch;
+    }
+  }
+  return fallback;
+}
+function inferProjectBase(projectRoot, fallback) {
+  const containing = runCapture(gitCmd(projectRoot, projectRoot, "branch", "-r", "--contains", "HEAD"), projectRoot);
+  if (containing.exitCode !== 0) {
+    return fallback;
+  }
+  const candidates = containing.stdout.split(/\r?\n/).map((line) => line.replace(/^\*/, "").trim()).filter(Boolean).map((line) => line.replace(/^origin\//, "")).filter((line) => line !== "HEAD" && !line.startsWith("rig/"));
+  return candidates[0] || fallback;
+}
+function currentGithubLogin(repoRoot) {
+  const gh = resolveGithubCliBinary({ scanPath: true });
+  if (!gh) {
+    return "";
+  }
+  const result = runCapture([gh, "api", "user", "--jq", ".login"], repoRoot);
+  return result.exitCode === 0 ? result.stdout.trim() : "";
+}
+function collectPrChangedFiles(projectRoot, repoRoot, baseRef, branchRef) {
+  const repoNameWithOwner = resolveRepoNameWithOwner(projectRoot, repoRoot);
+  const remoteName = refreshRemoteBaseRef(projectRoot, repoRoot, baseRef, repoNameWithOwner);
+  const hasRemoteBase = remoteName ? runCapture(gitCmd(projectRoot, repoRoot, "rev-parse", "--verify", "--quiet", `${remoteName}/${baseRef}`), projectRoot).exitCode === 0 : false;
+  const hasLocalBase = runCapture(gitCmd(projectRoot, repoRoot, "rev-parse", "--verify", "--quiet", baseRef), projectRoot).exitCode === 0;
+  let changed = "";
+  if (hasRemoteBase) {
+    changed = runCapture(gitCmd(projectRoot, repoRoot, "diff", "--name-only", `${remoteName}/${baseRef}...${branchRef}`), projectRoot).stdout;
+  } else if (hasLocalBase) {
+    changed = runCapture(gitCmd(projectRoot, repoRoot, "diff", "--name-only", `${baseRef}...${branchRef}`), projectRoot).stdout;
+  } else {
+    const fallback = runCapture(gitCmd(projectRoot, repoRoot, "diff", "--name-only", `HEAD~1..${branchRef}`), projectRoot);
+    changed = fallback.exitCode === 0 ? fallback.stdout : runCapture(gitCmd(projectRoot, repoRoot, "diff", "--name-only"), projectRoot).stdout;
+  }
+  return changed.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).slice(0, 60);
+}
+function inferReviewerFromChangedFiles(projectRoot, repoRoot, baseRef, branchRef) {
+  const repoNameWithOwner = resolveRepoNameWithOwner(projectRoot, repoRoot);
+  if (!repoNameWithOwner) {
+    return "";
+  }
+  const actorLogin = currentGithubLogin(repoRoot);
+  const changedFiles = collectPrChangedFiles(projectRoot, repoRoot, baseRef, branchRef);
+  if (changedFiles.length === 0) {
+    return "";
+  }
+  const counts = new Map;
+  for (const path of changedFiles) {
+    const result = runCapture([
+      resolveGithubCliBinary({ scanPath: true }) || "gh",
+      "api",
+      `repos/${repoNameWithOwner}/commits`,
+      "-f",
+      `path=${path}`,
+      "-f",
+      `sha=${baseRef}`,
+      "-f",
+      "per_page=1",
+      "--jq",
+      ".[0].author.login // empty"
+    ], repoRoot);
+    const author = result.exitCode === 0 ? result.stdout.trim() : "";
+    if (!author || author === actorLogin) {
       continue;
     }
-    rest.push(arg);
+    counts.set(author, (counts.get(author) || 0) + 1);
   }
-  return { value, rest };
+  let best = "";
+  let max = -1;
+  for (const [author, count] of counts.entries()) {
+    if (count > max || count === max && author < best) {
+      best = author;
+      max = count;
+    }
+  }
+  return best;
 }
-function takeOption(args, option) {
+function snapshotRepo(projectRoot, label, repo) {
+  if (!existsSync4(resolve3(repo, ".git"))) {
+    return [`## ${label}`, `repo: ${repo}`, "status: unavailable", ""];
+  }
+  const status = runCapture(gitCmd(projectRoot, repo, "status", "--short"), projectRoot).stdout.trim();
+  const branch = branchName(projectRoot, repo);
+  const head = runCapture(gitCmd(projectRoot, repo, "rev-parse", "HEAD"), projectRoot).stdout.trim();
+  return [
+    `## ${label}`,
+    `repo: ${repo}`,
+    `branch: ${branch}`,
+    `head: ${head}`,
+    "status:",
+    status || "(clean)",
+    ""
+  ];
+}
+function commitRepo(projectRoot, repo, label, message, allowEmpty, scoped, files, changedFilesManifest) {
+  if (!existsSync4(resolve3(repo, ".git"))) {
+    console.log(`Skipping ${label}: repo not available (${repo})`);
+    return;
+  }
+  const scopedFiles = (files || []).filter(Boolean).filter((file) => !pathResolvesBeyondSymlink(repo, file));
+  const repoChanges = changeCount(projectRoot, repo);
+  if (scopedFiles.length === 0 && repoChanges === 0 && !allowEmpty) {
+    console.log(`Skipping ${label}: no changes to commit.`);
+    return;
+  }
+  if (scopedFiles.length > 0) {
+    const indexFiles = new Set(runCapture(gitCmd(projectRoot, repo, "ls-files"), projectRoot).stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean));
+    const stageable = scopedFiles.filter((file) => indexFiles.has(file) || existsSync4(resolve3(repo, file)));
+    if (stageable.length === 0) {
+      console.log(`Skipping ${label}: collected change list matched no stageable paths in ${repo}.`);
+      return;
+    }
+    const pathspecFile = resolve3(tmpdir(), `rig-stage-${process.pid}-${Date.now()}.txt`);
+    writeFileSync(pathspecFile, `${stageable.join(`
+`)}
+`, "utf-8");
+    try {
+      runOrThrow(projectRoot, gitCmd(projectRoot, repo, "add", `--pathspec-from-file=${pathspecFile}`), `Failed to stage changes for ${label}`);
+    } finally {
+      try {
+        unlinkSync(pathspecFile);
+      } catch {}
+    }
+  } else {
+    const addArgs = buildStageAddArgs(repo, scopedFiles, scoped);
+    if (addArgs) {
+      runOrThrow(projectRoot, gitCmd(projectRoot, repo, ...addArgs), `Failed to stage changes for ${label}`);
+    }
+  }
+  const stagedChanges = stagedChangeCount(projectRoot, repo);
+  if (stagedChanges === 0) {
+    if (allowEmpty) {
+      runOrThrow(projectRoot, gitCmd(projectRoot, repo, "commit", "--allow-empty", "-m", message), `Failed to commit ${label}`);
+      console.log(`Committed ${label}: ${message}`);
+      return;
+    }
+    if (scoped && repoChanges > 0) {
+      const manifestHint = changedFilesManifest ? ` Refresh ${changedFilesManifest} and retry, or use --all/--unscoped intentionally.` : "";
+      throw new Error(`Scoped commit for ${label} resolved no stageable files.${manifestHint}`);
+    }
+    console.log(`Skipping ${label}: no stageable changes to commit.`);
+    return;
+  }
+  runOrThrow(projectRoot, gitCmd(projectRoot, repo, "commit", ...allowEmpty ? ["--allow-empty"] : [], "-m", message), `Failed to commit ${label}`);
+  console.log(`Committed ${label}: ${message}`);
+}
+function readChangedFilesManifest(projectRoot, taskId) {
+  const manifestPath = resolve3(taskData().artifactDirForId(projectRoot, taskId), "changed-files.txt");
+  if (!existsSync4(manifestPath)) {
+    return [];
+  }
+  const files = readFileSync3(manifestPath, "utf-8").split(/\r?\n/).map((line) => normalizeChangedFilePath(line)).filter(Boolean);
+  return [...new Set(files)];
+}
+function refreshChangedFilesManifest(projectRoot, taskId) {
+  const manifestPath = resolve3(taskData().artifactDirForId(projectRoot, taskId), "changed-files.txt");
+  mkdirSync(dirname(manifestPath), { recursive: true });
+  const changedFiles = taskData().changedFilesForTask(projectRoot, taskId, true);
+  writeFileSync(manifestPath, `${changedFiles.join(`
+`)}
+`, "utf-8");
+  return manifestPath;
+}
+function normalizeChangedFilePath(file) {
+  return file.trim().replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function buildStageAddArgs(repoRoot, files, scoped) {
+  if (files.length > 0) {
+    return ["add", "--", ...files];
+  }
+  if (scoped) {
+    return null;
+  }
+  return ["add", "-A", "--", ".", ...stageExcludePathspecs(repoRoot)];
+}
+function resolveScopedStageFilesForRepo(projectRoot, repoRoot, taskId, files) {
+  const resolvedManifestFiles = resolveScopedFilesForRepo(projectRoot, repoRoot, files);
+  if (resolvedManifestFiles.length > 0 || !taskId) {
+    return resolvedManifestFiles;
+  }
+  return resolveChangedTaskArtifactFiles(projectRoot, repoRoot, taskId);
+}
+function resolveScopedFilesForRepo(projectRoot, repoRoot, files) {
+  const resolvedFiles = [];
+  const seen = new Set;
+  for (const file of files) {
+    const candidate = resolveScopedRepoPath(repoRoot, file);
+    if (!candidate || seen.has(candidate) || pathResolvesBeyondSymlink(repoRoot, candidate)) {
+      continue;
+    }
+    if (!repoHasPathChange(projectRoot, repoRoot, candidate)) {
+      continue;
+    }
+    seen.add(candidate);
+    resolvedFiles.push(candidate);
+  }
+  return resolvedFiles;
+}
+function resolveChangedTaskArtifactFiles(projectRoot, repoRoot, taskId) {
+  const safeTaskId = safePathSegment(taskId, { fallback: "task", maxLength: 96 });
+  const artifactPrefix = `artifacts/${safeTaskId}/`;
+  const resolvedFiles = [];
+  const seen = new Set;
+  for (const file of collectRepoPendingFiles(projectRoot, repoRoot)) {
+    if (!file.startsWith(artifactPrefix)) {
+      continue;
+    }
+    const artifactRelativePath = file.slice(artifactPrefix.length);
+    if (!TASK_ARTIFACT_STAGE_FALLBACK.has(artifactRelativePath)) {
+      continue;
+    }
+    if (seen.has(file) || pathResolvesBeyondSymlink(repoRoot, file)) {
+      continue;
+    }
+    seen.add(file);
+    resolvedFiles.push(file);
+  }
+  return resolvedFiles.sort();
+}
+function collectRepoPendingFiles(projectRoot, repoRoot) {
+  const files = new Set;
+  for (const args of [
+    ["diff", "--name-only"],
+    ["diff", "--cached", "--name-only"],
+    ["ls-files", "--others", "--exclude-standard"]
+  ]) {
+    const result = runCapture(gitCmd(projectRoot, repoRoot, ...args), projectRoot);
+    if (result.exitCode !== 0) {
+      continue;
+    }
+    for (const line of result.stdout.split(/\r?\n/)) {
+      const normalized = normalizeChangedFilePath(line);
+      if (!normalized) {
+        continue;
+      }
+      files.add(normalized);
+    }
+  }
+  return [...files].sort();
+}
+function resolveScopedRepoPath(repoRoot, file) {
+  const normalized = normalizeChangedFilePath(file);
+  if (!normalized) {
+    return "";
+  }
+  const rules = getScopeRules2();
+  if (rules?.stripPrefixes) {
+    let result = normalized;
+    for (const prefix of rules.stripPrefixes) {
+      if (result.startsWith(prefix)) {
+        result = result.slice(prefix.length);
+      }
+    }
+    return result;
+  }
+  return normalized;
+}
+function repoHasPathChange(projectRoot, repoRoot, relativePath) {
+  const result = runCapture(gitCmd(projectRoot, repoRoot, "status", "--short", "--", relativePath), projectRoot);
+  return result.exitCode === 0 && result.stdout.trim().length > 0;
+}
+function stageExcludePathspecs(repoRoot) {
+  const patterns = existsSync4(resolve3(repoRoot, ".rig", "task-config.json")) ? [...TASK_RUNTIME_STAGE_EXCLUDES, ...GENERATED_STAGE_EXCLUDES] : [".rig/**", ...GENERATED_STAGE_EXCLUDES];
+  return patterns.map((pattern) => `:(glob,exclude)${pattern}`);
+}
+function pathResolvesBeyondSymlink(repoRoot, relativePath) {
+  const parts = relativePath.split("/").filter(Boolean);
+  if (parts.length <= 1) {
+    return false;
+  }
+  let current = repoRoot;
+  for (let index = 0;index < parts.length - 1; index += 1) {
+    current = resolve3(current, parts[index]);
+    try {
+      if (lstatSync(current).isSymbolicLink()) {
+        return true;
+      }
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+function printRepoStatus(projectRoot, label, repo, expectedBranch) {
+  if (!existsSync4(resolve3(repo, ".git"))) {
+    console.log(`${label}: unavailable (${repo})`);
+    return;
+  }
+  const branch = branchName(projectRoot, repo);
+  const changes = changeCount(projectRoot, repo);
+  console.log(`${label}:`);
+  console.log(`  branch: ${branch || "unknown"}`);
+  console.log(`  changed files: ${changes}`);
+  if (expectedBranch && label !== "project-rig" && branch !== expectedBranch) {
+    console.log(`  warning: branch mismatch (expected ${expectedBranch})`);
+  }
+}
+function resolveTaskBranchId(projectRoot, taskId) {
+  if (/^bd-[a-z0-9-]+$/.test(taskId)) {
+    return taskId;
+  }
+  const normalizedTaskId = taskData().lookupTask(projectRoot, taskId);
+  if (normalizedTaskId) {
+    return normalizedTaskId;
+  }
+  const currentTask = taskData().currentTaskId(projectRoot);
+  if (currentTask && currentTask === taskId) {
+    return currentTask;
+  }
+  const runtimeIdFromEnv = (process.env.RIG_TASK_RUNTIME_ID || "").trim();
+  if (runtimeIdFromEnv.startsWith("task-") && runtimeIdFromEnv.length > "task-".length) {
+    return runtimeIdFromEnv.slice("task-".length);
+  }
+  try {
+    const runtimeIdFromContext = loadRuntimeContextFromEnv()?.runtimeId || "";
+    if (runtimeIdFromContext.startsWith("task-") && runtimeIdFromContext.length > "task-".length) {
+      return runtimeIdFromContext.slice("task-".length);
+    }
+  } catch {}
+  const artifactDir = taskData().artifactDirForId(projectRoot, taskId);
+  if (existsSync4(artifactDir)) {
+    return taskId;
+  }
+  throw new Error(`Unknown task id: ${taskId}`);
+}
+function branchName(projectRoot, repo) {
+  return runCapture(gitCmd(projectRoot, repo, "rev-parse", "--abbrev-ref", "HEAD"), projectRoot).stdout.trim();
+}
+function changeCount(projectRoot, repo) {
+  const status = runCapture(gitCmd(projectRoot, repo, "status", "--short"), projectRoot).stdout.trim();
+  return status ? status.split(/\r?\n/).filter(Boolean).length : 0;
+}
+function stagedChangeCount(projectRoot, repo) {
+  const staged = runCapture(gitCmd(projectRoot, repo, "diff", "--cached", "--name-only"), projectRoot).stdout.trim();
+  return staged ? staged.split(/\r?\n/).filter(Boolean).length : 0;
+}
+function runOrThrow(projectRoot, command, errorPrefix) {
+  const result = runCapture(command, projectRoot);
+  if (result.exitCode !== 0) {
+    throw new Error(`${errorPrefix}:
+${result.stderr || result.stdout}`);
+  }
+}
+function runCapture(command, cwd, projectRoot = cwd) {
+  return baseRunCapture(command, cwd, runtimeGitEnv(projectRoot));
+}
+function runtimeGitEnv(projectRoot) {
+  const { ctx, runtimeRoot } = resolveRuntimeMetadata(projectRoot);
+  const runtimeHome = runtimeRoot ? resolve3(runtimeRoot, "home") : "";
+  const runtimeTmp = runtimeRoot ? resolve3(runtimeRoot, "tmp") : "";
+  const runtimeCache = runtimeRoot ? resolve3(runtimeRoot, "cache") : "";
+  const runtimeKnownHosts = runtimeHome ? resolve3(runtimeHome, ".ssh", "known_hosts") : "";
+  const runtimeKey = runtimeHome ? resolve3(runtimeHome, ".ssh", "rig-agent-key") : "";
+  const env = {};
+  if (ctx?.workspaceDir) {
+    env.PROJECT_RIG_ROOT = projectRoot;
+    env.RIG_TASK_WORKSPACE = ctx.workspaceDir;
+    env.MONOREPO_ROOT = ctx.workspaceDir;
+    env.MONOREPO_MAIN_ROOT = resolveMonorepoRoot(projectRoot);
+  } else if (projectRoot) {
+    env.PROJECT_RIG_ROOT = projectRoot;
+  }
+  if (runtimeRoot) {
+    env.RIG_RUNTIME_HOME = runtimeRoot;
+  }
+  if (runtimeHome && existsSync4(runtimeHome)) {
+    env.HOME = runtimeHome;
+    env.OPENSSL_CONF = ensureRuntimeOpenSslConfig(runtimeHome);
+  }
+  if (runtimeTmp && existsSync4(runtimeTmp)) {
+    env.TMPDIR = runtimeTmp;
+  }
+  if (runtimeCache && existsSync4(runtimeCache)) {
+    env.XDG_CACHE_HOME = runtimeCache;
+  }
+  const workspaceSecrets = loadDotEnvSecrets(ctx?.workspaceDir || projectRoot, process.env);
+  for (const [key, value] of Object.entries(resolveRuntimeSecrets(process.env, workspaceSecrets))) {
+    if (key === "GITHUB_SSH_KEY" || !value) {
+      continue;
+    }
+    env[key] = value;
+  }
+  const rigGithubToken = process.env.RIG_GITHUB_TOKEN?.trim() || authStateToken(process.env) || "";
+  if (rigGithubToken && !env.GITHUB_TOKEN && !env.GH_TOKEN) {
+    env.GITHUB_TOKEN = rigGithubToken;
+  }
+  if (!env.GITHUB_TOKEN && env.GH_TOKEN) {
+    env.GITHUB_TOKEN = env.GH_TOKEN;
+  }
+  if (!env.GH_TOKEN && env.GITHUB_TOKEN) {
+    env.GH_TOKEN = env.GITHUB_TOKEN;
+  }
+  if (!env.GREPTILE_GITHUB_TOKEN && env.GITHUB_TOKEN) {
+    env.GREPTILE_GITHUB_TOKEN = env.GITHUB_TOKEN;
+  }
+  const persistedSecrets = loadPersistedRuntimeSecrets(runtimeRoot);
+  for (const [key, value] of Object.entries(persistedSecrets)) {
+    if (!value)
+      continue;
+    if (!env[key]) {
+      env[key] = value;
+    }
+  }
+  if (!env.GITHUB_TOKEN && env.GH_TOKEN) {
+    env.GITHUB_TOKEN = env.GH_TOKEN;
+  }
+  if (!env.GH_TOKEN && env.GITHUB_TOKEN) {
+    env.GH_TOKEN = env.GITHUB_TOKEN;
+  }
+  const gitHubToken = env.GITHUB_TOKEN || env.GH_TOKEN || env.RIG_GITHUB_TOKEN || rigGithubToken;
+  if (gitHubToken) {
+    env.RIG_GITHUB_TOKEN = gitHubToken;
+    env.GITHUB_TOKEN = env.GITHUB_TOKEN || gitHubToken;
+    env.GH_TOKEN = env.GH_TOKEN || gitHubToken;
+    applyGitHubCredentialHelperEnv(env);
+  }
+  if (runtimeKnownHosts && existsSync4(runtimeKnownHosts)) {
+    const sshParts = [
+      "ssh",
+      `-o UserKnownHostsFile="${runtimeKnownHosts}"`,
+      "-o StrictHostKeyChecking=yes",
+      "-F /dev/null"
+    ];
+    if (runtimeKey && existsSync4(runtimeKey)) {
+      sshParts.splice(1, 0, `-i "${runtimeKey}"`, "-o IdentitiesOnly=yes");
+    }
+    env.GIT_SSH_COMMAND = sshParts.join(" ");
+  } else if (process.env.GIT_SSH_COMMAND?.trim()) {
+    env.GIT_SSH_COMMAND = process.env.GIT_SSH_COMMAND;
+  }
+  return Object.keys(env).length > 0 ? env : undefined;
+}
+function applyGitHubCredentialHelperEnv(env) {
+  env.GIT_TERMINAL_PROMPT = "0";
+  env.GIT_CONFIG_COUNT = "2";
+  env.GIT_CONFIG_KEY_0 = "credential.helper";
+  env.GIT_CONFIG_VALUE_0 = "";
+  env.GIT_CONFIG_KEY_1 = "credential.helper";
+  env.GIT_CONFIG_VALUE_1 = '!f() { test "$1" = get || exit 0; token="${GITHUB_TOKEN:-${GH_TOKEN:-${RIG_GITHUB_TOKEN:-}}}"; test -n "$token" || exit 0; echo username=x-access-token; echo password="$token"; }; f';
+}
+function loadPersistedRuntimeSecrets(runtimeRoot) {
+  if (!runtimeRoot) {
+    return {};
+  }
+  const path = resolve3(runtimeRoot, "runtime-secrets.json");
+  if (!existsSync4(path)) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(readFileSync3(path, "utf-8"));
+    const allowed = new Set(["GITHUB_TOKEN", "GH_TOKEN", "RIG_GITHUB_TOKEN"]);
+    const entries = Object.entries(parsed).filter((entry) => typeof entry[1] === "string" && allowed.has(entry[0]));
+    return Object.fromEntries(entries);
+  } catch {
+    return {};
+  }
+}
+function ensureRuntimeOpenSslConfig(runtimeHome) {
+  const sslDir = resolve3(runtimeHome, ".ssl");
+  const sslConfig = resolve3(sslDir, "openssl.cnf");
+  if (!existsSync4(sslDir)) {
+    mkdirSync(sslDir, { recursive: true });
+  }
+  if (!existsSync4(sslConfig)) {
+    writeFileSync(sslConfig, `# Rig runtime OpenSSL config placeholder
+`);
+  }
+  return sslConfig;
+}
+function resolveRuntimeMetadata(projectRoot) {
+  const contextFile = process.env.RIG_RUNTIME_CONTEXT_FILE?.trim();
+  const runtimeHome = process.env.RIG_RUNTIME_HOME?.trim();
+  let ctx = loadRuntimeContextFromEnv();
+  if (runtimeHome) {
+    return {
+      ctx,
+      runtimeRoot: runtimeHome
+    };
+  }
+  if (contextFile) {
+    return {
+      ctx,
+      runtimeRoot: dirname(resolve3(contextFile))
+    };
+  }
+  const inferredContextFile = findRuntimeContextFile(projectRoot);
+  if (existsSync4(inferredContextFile)) {
+    try {
+      ctx = loadRuntimeContext(inferredContextFile);
+    } catch {}
+    return {
+      ctx,
+      runtimeRoot: dirname(inferredContextFile)
+    };
+  }
+  return { ctx, runtimeRoot: "" };
+}
+function findRuntimeContextFile(startPath) {
+  let current = resolve3(startPath);
+  while (true) {
+    const candidate = resolve3(current, "runtime-context.json");
+    if (existsSync4(candidate)) {
+      return candidate;
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      return "";
+    }
+    current = parent;
+  }
+}
+
+// packages/cli-surface-plugin/src/control-plane/harness-cli.ts
+import { setProfile, setReviewProfile, showProfile, showReviewProfile } from "@rig/core/profile-ops";
+import { resolveCheckoutRoot as resolveMonorepoRoot2 } from "@rig/core/checkout-root";
+import {
+  COMPLETION_VERIFICATION_CAPABILITY,
+  MEMORY,
+  REPO_OPERATIONS_CAPABILITY,
+  TASK_DATA_SERVICE_CAPABILITY as TASK_DATA_SERVICE_CAPABILITY2,
+  TASK_VERIFY_CAPABILITY
+} from "@rig/contracts";
+import { defineCapability as defineCapability2 } from "@rig/core/capability";
+import { loadCapabilityForRoot, requireInstalledCapability as requireInstalledCapability2 } from "@rig/core/capability-loaders";
+import { buildPluginHostContext } from "@rig/core/plugin-host-context";
+import { loadRuntimeContextFromEnv as loadRuntimeContextFromEnv2 } from "@rig/core/runtime-context";
+var MemoryCap = defineCapability2(MEMORY);
+var CompletionVerificationCap = defineCapability2(COMPLETION_VERIFICATION_CAPABILITY);
+var RepoOperationsCap = defineCapability2(REPO_OPERATIONS_CAPABILITY);
+var TaskVerifyCap = defineCapability2(TASK_VERIFY_CAPABILITY);
+var TaskDataCap2 = defineCapability2(TASK_DATA_SERVICE_CAPABILITY2);
+var taskData2 = () => requireInstalledCapability2(TaskDataCap2, "task-data capability unavailable: load @rig/task-sources-plugin (default bundle) before running task commands.");
+async function resolveRepoOperations(projectRoot, pluginHostCtx) {
+  const hostCtx = pluginHostCtx ?? await buildPluginHostContext(projectRoot);
+  const repoOps = hostCtx ? await RepoOperationsCap.resolve(hostCtx.pluginHost) : null;
+  if (!repoOps) {
+    throw new Error(`Repo operations require the @rig/repos-plugin plugin in rig.config for project root "${projectRoot}".`);
+  }
+  return repoOps;
+}
+async function executeHarnessCommand(projectRoot, args, eventBus, pluginHostCtx, deps) {
+  const [command = "help", ...rest] = args;
+  switch (command) {
+    case "memory": {
+      const runtimeContext = loadRuntimeContextFromEnv2();
+      const taskId = taskData2().currentTaskId(projectRoot) || runtimeContext?.taskId;
+      if (!taskId) {
+        throw new Error("Shared memory commands require an active task context.");
+      }
+      const memoryService = pluginHostCtx ? await MemoryCap.resolve(pluginHostCtx.pluginHost) : await loadCapabilityForRoot(projectRoot, MemoryCap);
+      if (!memoryService) {
+        throw new Error("Shared memory requires the @rig/memory-plugin plugin in rig.config.");
+      }
+      console.log(await memoryService.executeMemoryCommand({
+        projectRoot,
+        taskId,
+        runtimeContext,
+        args: rest,
+        ...eventBus !== undefined ? { eventBus } : {}
+      }));
+      return;
+    }
+    case "info":
+      await taskData2().taskInfo(projectRoot);
+      return;
+    case "scope": {
+      const expand = rest.includes("--files");
+      await taskData2().taskScope(projectRoot, expand);
+      return;
+    }
+    case "deps":
+      await taskData2().taskDeps(projectRoot);
+      return;
+    case "validate": {
+      const ok = await taskData2().taskValidate(projectRoot, undefined, pluginHostCtx?.validatorRegistry ?? undefined);
+      if (!ok) {
+        throw new Error("Validation failed.");
+      }
+      return;
+    }
+    case "completion-verification":
+    case "completition-verification": {
+      const run = pluginHostCtx ? await CompletionVerificationCap.resolve(pluginHostCtx.pluginHost) : null;
+      if (!run) {
+        throw new Error("Completion verification requires the @rig/bundle-default-lifecycle plugin in rig.config.");
+      }
+      const { ok } = await run({ projectRoot });
+      if (!ok) {
+        throw new Error("Completion verification failed.");
+      }
+      return;
+    }
+    case "verify": {
+      const task = rest[0];
+      const capabilityRun = pluginHostCtx ? await TaskVerifyCap.resolve(pluginHostCtx.pluginHost) : null;
+      const verify = deps?.taskVerify ?? (capabilityRun ? (root, taskId) => capabilityRun(taskId ? { projectRoot: root, taskId } : { projectRoot: root }) : undefined);
+      if (!verify) {
+        throw new Error("Task verification requires the @rig/bundle-default-lifecycle plugin in rig.config.");
+      }
+      const ok = await verify(projectRoot, task);
+      if (!ok) {
+        throw new Error("Verification rejected.");
+      }
+      return;
+    }
+    case "status":
+      taskData2().taskStatus(projectRoot);
+      return;
+    case "record": {
+      const type = rest[0];
+      const text = rest.slice(1).join(" ").trim();
+      if (!type || type !== "decision" && type !== "failure" || !text) {
+        throw new Error("Usage: rig-agent record <decision|failure> <text>");
+      }
+      taskData2().taskRecord(projectRoot, type, text);
+      return;
+    }
+    case "lookup": {
+      const id = rest[0];
+      if (!id) {
+        throw new Error("Usage: rig-agent lookup <beads-id>");
+      }
+      console.log(taskData2().taskLookup(projectRoot, id));
+      return;
+    }
+    case "artifacts":
+      taskData2().taskArtifacts(projectRoot);
+      return;
+    case "project-root":
+      console.log(projectRoot);
+      return;
+    case "monorepo-root":
+      console.log(resolveMonorepoRoot2(projectRoot));
+      return;
+    case "git":
+      await executeHarnessGit(projectRoot, rest);
+      return;
+    case "repo":
+    case "repo-sync":
+      await executeHarnessRepo(projectRoot, rest, pluginHostCtx);
+      return;
+    case "profile":
+      await executeHarnessProfile(projectRoot, rest);
+      return;
+    case "review":
+      await executeHarnessReview(projectRoot, rest);
+      return;
+    case "help":
+    case "--help":
+    case "-h":
+      printHelp();
+      return;
+    default:
+      throw new Error(`Unknown command: ${command}`);
+  }
+}
+function hasActiveTaskContext(projectRoot) {
+  try {
+    return Boolean(taskData2().currentTaskId(projectRoot));
+  } catch {
+    return false;
+  }
+}
+async function executeHarnessGit(projectRoot, args) {
+  const [command = "status", ...rest] = args;
+  switch (command) {
+    case "status": {
+      const task = takeOption2(rest, "--task");
+      gitStatus(projectRoot, task.value);
+      return;
+    }
+    case "changed": {
+      const task = takeOption2(rest, "--task");
+      const scoped = task.rest.includes("--scoped");
+      const files = gitChanged(projectRoot, task.value, scoped);
+      console.log(files.length > 0 ? files.join(`
+`) : "(none)");
+      return;
+    }
+    case "preflight": {
+      const task = takeOption2(rest, "--task");
+      const strict = task.rest.includes("--strict");
+      const ok = gitPreflight(projectRoot, task.value, strict);
+      if (!ok) {
+        throw new Error("Git preflight failed.");
+      }
+      return;
+    }
+    case "sync-branch":
+    case "ensure-branch": {
+      const task = takeOption2(rest, "--task");
+      gitSyncBranch(projectRoot, task.value);
+      return;
+    }
+    case "commit": {
+      const task = takeOption2(rest, "--task");
+      const target = takeOption2(task.rest, "--target");
+      const message = takeOption2(target.rest, "--message");
+      const allowEmpty = message.rest.includes("--allow-empty");
+      const scoped = shouldScopeGitCommit(message.rest, Boolean(task.value) || hasActiveTaskContext(projectRoot));
+      gitCommit({
+        projectRoot,
+        ...task.value !== undefined ? { taskId: task.value } : {},
+        target: target.value || "monorepo",
+        ...message.value !== undefined ? { message: message.value } : {},
+        allowEmpty,
+        scoped
+      });
+      return;
+    }
+    case "snapshot": {
+      const task = takeOption2(rest, "--task");
+      const output = takeOption2(task.rest, "--output");
+      const file = gitSnapshot(projectRoot, task.value, output.value);
+      console.log(`Snapshot written: ${file}`);
+      return;
+    }
+    case "open-pr": {
+      const task = takeOption2(rest, "--task");
+      const target = takeOption2(task.rest, "--target");
+      const reviewer = takeOption2(target.rest, "--reviewer");
+      const base = takeOption2(reviewer.rest, "--base");
+      const title = takeOption2(base.rest, "--title");
+      const body = takeOption2(title.rest, "--body");
+      const draft = body.rest.includes("--draft");
+      const result = gitOpenPr({
+        projectRoot,
+        ...task.value !== undefined ? { taskId: task.value } : {},
+        ...target.value !== undefined ? { target: target.value } : {},
+        ...reviewer.value !== undefined ? { reviewer: reviewer.value } : {},
+        ...base.value !== undefined ? { base: base.value } : {},
+        ...title.value !== undefined ? { title: title.value } : {},
+        ...body.value !== undefined ? { body: body.value } : {},
+        draft
+      });
+      console.log(`PR ready (${result.repoLabel}): ${result.url}`);
+      if (result.reviewer && result.reviewerSource) {
+        console.log(`Reviewer assigned: ${result.reviewer} (${result.reviewerSource})`);
+      } else if (result.reviewer) {
+        console.log(`Reviewer assigned: ${result.reviewer}`);
+      }
+      return;
+    }
+    default:
+      throw new Error(`Unknown harness git command: ${command}`);
+  }
+}
+async function executeHarnessRepo(projectRoot, args, pluginHostCtx) {
+  const [command = "ensure", ...rest] = args;
+  const task = takeOption2(rest, "--task");
+  const repoOps = await resolveRepoOperations(projectRoot, pluginHostCtx);
+  switch (command) {
+    case "sync":
+    case "ensure":
+      repoOps.repoEnsure(projectRoot, task.value);
+      return;
+    case "pins": {
+      const pins = repoOps.repoPins(projectRoot, task.value);
+      printPins(pins);
+      return;
+    }
+    case "verify": {
+      const ok = repoOps.repoVerify(projectRoot, task.value);
+      if (!ok) {
+        throw new Error("Repo pin verification failed.");
+      }
+      return;
+    }
+    case "discover": {
+      const pins = repoOps.repoDiscover(projectRoot, task.value);
+      printPins(pins);
+      return;
+    }
+    case "baseline": {
+      const refresh = task.rest.includes("--refresh");
+      const pins = repoOps.repoBaseline(projectRoot, refresh);
+      printPins(pins);
+      return;
+    }
+    default:
+      throw new Error(`Unknown harness repo command: ${command}`);
+  }
+}
+async function executeHarnessProfile(projectRoot, args) {
+  const [command = "show", ...rest] = args;
+  if (command === "show") {
+    await showProfile(projectRoot, rest.includes("--compact"));
+    return;
+  }
+  if (command === "set") {
+    const first = rest[0];
+    if (first && first !== "pi" && !first.startsWith("--")) {
+      throw new Error("Only the Pi runtime profile is supported by this Rig substrate.");
+    }
+    const model = takeOption2(rest, "--model");
+    const runtime = takeOption2(model.rest, "--runtime");
+    const plugin = takeOption2(runtime.rest, "--plugin");
+    await setProfile(projectRoot, {
+      ...model.value !== undefined ? { model: model.value } : {},
+      ...runtime.value !== undefined ? { runtime: runtime.value } : {},
+      ...plugin.value !== undefined ? { plugin: plugin.value } : {}
+    });
+    return;
+  }
+  throw new Error(`Unknown harness profile command: ${command}`);
+}
+async function executeHarnessReview(projectRoot, args) {
+  const [command = "show", ...rest] = args;
+  if (command === "show") {
+    await showReviewProfile(projectRoot);
+    return;
+  }
+  if (command === "set") {
+    const mode = rest[0];
+    if (!mode) {
+      throw new Error("Usage: rig-agent review set <off|advisory|required> [--provider github|greptile]");
+    }
+    const provider = takeOption2(rest.slice(1), "--provider");
+    await setReviewProfile(projectRoot, mode, provider.value);
+    return;
+  }
+  throw new Error(`Unknown harness review command: ${command}`);
+}
+function printPins(pins) {
+  if (Object.keys(pins).length === 0) {
+    console.log("(none)");
+    return;
+  }
+  for (const [key, value] of Object.entries(pins)) {
+    console.log(`${key}	${value}`);
+  }
+}
+function takeOption2(args, option) {
   const rest = [];
   let value;
-  for (let index = 0;index < args.length; index += 1) {
-    const current = args[index];
+  for (let i = 0;i < args.length; i += 1) {
+    const current = args[i];
     if (current === option) {
-      const next = args[index + 1];
+      const next = args[i + 1];
       if (!next || next.startsWith("-")) {
-        throw new CliError(`Missing value for ${option}`, 1, { hint: `Provide a value after ${option}, e.g. \`${option} <value>\`.` });
+        throw new Error(`Missing value for ${option}`);
       }
       value = next;
-      index += 1;
+      i += 1;
       continue;
     }
     if (current !== undefined) {
@@ -49,17 +2285,40 @@ function takeOption(args, option) {
   }
   return { value, rest };
 }
-function requireNoExtraArgs(args, usage) {
-  if (args.length > 0) {
-    throw new CliError(`Unexpected arguments: ${args.join(" ")}
-Usage: ${usage}`);
-  }
+function printHelp() {
+  console.log(`rig-agent \u2014 Agent CLI for Project Rig
+
+` + `NOTE: This is the legacy bash shim. Agents should use rig-agent.
+
+` + `ORIENTATION:
+` + `  rig-agent info               Your task, role, scope, deps
+` + `  rig-agent scope [--files]    Scope globs; --files expands to file list
+` + `  rig-agent deps               Read dependency artifacts (decisions, next-actions)
+` + `  rig-agent lookup <id>        Validate a beads task ID
+` + `  rig-agent status             Epic/task progress
+
+` + `EXECUTION:
+` + `  rig-agent validate           Run validation commands for your task
+` + `  rig-agent completion-verification  Run final validation/review gate
+` + `  rig-agent record decision "..."
+` + `  rig-agent record failure "..."
+` + `  rig-agent git ...            Task-aware git helper
+` + `  rig-agent repo sync          Ensure monorepo checkout + task repo pins
+` + `  rig-agent profile ...        Show/set runtime profile
+` + `  rig-agent review ...         Show/set AI review profile
+
+` + `COMPLETION:
+` + `  rig-agent artifacts          Scaffold completion artifacts
+` + `  rig-agent artifact-dir       Print absolute artifact directory path
+` + `  rig-agent project-root       Print absolute task worktree root
+` + `  rig-agent monorepo-root      Print absolute monorepo root in the task worktree
+` + `  rig-agent artifact-write <f> Write artifact from stdin`);
 }
 
 // packages/cli-surface-plugin/src/commands/repo-git-harness.ts
-import { executeHarnessCommand } from "@rig/runtime/control-plane/native/harness-cli";
-import { repoEnsure, resetBaseline } from "@rig/runtime/control-plane/native/repo-ops";
-import { taskVerify } from "@rig/bundle-default-lifecycle/control-plane/task-verify";
+import { REPO_OPERATIONS_CAPABILITY as REPO_OPERATIONS_CAPABILITY2 } from "@rig/contracts";
+import { defineCapability as defineCapability3 } from "@rig/core/capability";
+import { buildPluginHostContext as buildPluginHostContext2 } from "@rig/core/plugin-host-context";
 
 // packages/cli-surface-plugin/src/withMutedConsole.ts
 function isPromise(value) {
@@ -101,30 +2360,30 @@ function withMutedConsole(mute, fn) {
 }
 
 // packages/cli-surface-plugin/src/commands/_policy.ts
-import { appendFileSync, existsSync, mkdirSync, readFileSync } from "fs";
-import { resolve as resolve2 } from "path";
+import { appendFileSync, existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync4 } from "fs";
+import { resolve as resolve5 } from "path";
 
 // packages/cli-surface-plugin/src/commands/_paths.ts
-import { resolve } from "path";
-import { resolveMonorepoRoot } from "@rig/runtime/layout";
+import { resolve as resolve4 } from "path";
+import { resolveMonorepoRoot as resolveMonorepoRoot3 } from "@rig/core/layout";
 function resolveControlPlaneHostStateRoot(projectRoot) {
-  return resolve(projectRoot, ".rig");
+  return resolve4(projectRoot, ".rig");
 }
 function resolveControlPlaneHostLogsDir(projectRoot) {
-  return resolve(resolveControlPlaneHostStateRoot(projectRoot), "logs");
+  return resolve4(resolveControlPlaneHostStateRoot(projectRoot), "logs");
 }
 function resolveControlPlaneDefinitionRoot(projectRoot) {
-  return resolve(projectRoot, "rig");
+  return resolve4(projectRoot, "rig");
 }
 
 // packages/cli-surface-plugin/src/commands/_policy.ts
 function loadPolicyFile(projectRoot) {
-  const policyPath = resolve2(resolveControlPlaneDefinitionRoot(projectRoot), "policy", "policy.json");
-  if (!existsSync(policyPath)) {
+  const policyPath = resolve5(resolveControlPlaneDefinitionRoot(projectRoot), "policy", "policy.json");
+  if (!existsSync5(policyPath)) {
     return { mode: "observe", rules: [] };
   }
   try {
-    const parsed = JSON.parse(readFileSync(policyPath, "utf8"));
+    const parsed = JSON.parse(readFileSync4(policyPath, "utf8"));
     const mode = parsed.mode === "off" || parsed.mode === "observe" || parsed.mode === "enforce" ? parsed.mode : "observe";
     const rules = Array.isArray(parsed.rules) ? parsed.rules.filter((value) => Boolean(value && typeof value === "object" && !Array.isArray(value))).map((value, index) => {
       const rule = {
@@ -172,8 +2431,8 @@ function appendControlledBashAudit(context, mode, command, args, matchedRuleIds,
     return;
   }
   const logsDir = resolveControlPlaneHostLogsDir(context.projectRoot);
-  const logFile = resolve2(logsDir, "controlled-bash.jsonl");
-  mkdirSync(logsDir, { recursive: true });
+  const logFile = resolve5(logsDir, "controlled-bash.jsonl");
+  mkdirSync2(logsDir, { recursive: true });
   const payload = {
     timestamp: new Date().toISOString(),
     mode,
@@ -215,19 +2474,34 @@ async function enforceNativeCommandPolicy(context, args, options) {
 }
 
 // packages/cli-surface-plugin/src/commands/repo-git-harness.ts
+var RepoOperationsCap2 = defineCapability3(REPO_OPERATIONS_CAPABILITY2);
+async function resolveRepoOperations2(projectRoot) {
+  const hostCtx = await buildPluginHostContext2(projectRoot);
+  const repoOps = hostCtx ? await RepoOperationsCap2.resolve(hostCtx.pluginHost) : null;
+  if (!repoOps) {
+    throw new CliError(`No REPO_OPERATIONS capability is registered for project root "${projectRoot}".`, 2, { hint: "Install @rig/repos-plugin (it ships in the default bundle) before running repo operations." });
+  }
+  return repoOps;
+}
 async function executeRepo(context, args) {
   const [command = "sync", ...rest] = args;
   switch (command) {
     case "sync": {
       const { value: task, rest: remaining } = takeOption(rest, "--task");
       requireNoExtraArgs(remaining, "rig repo sync [--task <task-id>]");
-      withMutedConsole(context.outputMode === "json", () => repoEnsure(context.projectRoot, task || undefined));
+      await withMutedConsole(context.outputMode === "json", async () => {
+        const repoOps = await resolveRepoOperations2(context.projectRoot);
+        repoOps.repoEnsure(context.projectRoot, task || undefined);
+      });
       return { ok: true, group: "repo", command, details: { task: task || null } };
     }
     case "reset-baseline": {
       const { value: keepTaskStatusFlag, rest: remaining } = takeFlag(rest, "--keep-task-status");
       requireNoExtraArgs(remaining, "rig repo reset-baseline [--keep-task-status]");
-      withMutedConsole(context.outputMode === "json", () => resetBaseline(context.projectRoot, keepTaskStatusFlag));
+      await withMutedConsole(context.outputMode === "json", async () => {
+        const repoOps = await resolveRepoOperations2(context.projectRoot);
+        repoOps.resetBaseline(context.projectRoot, keepTaskStatusFlag);
+      });
       return { ok: true, group: "repo", command, details: { keepTaskStatus: keepTaskStatusFlag } };
     }
     default:
@@ -270,7 +2544,7 @@ async function executeHarness(context, args) {
     return { ok: true, group: "harness", command: args[0] ?? "harness" };
   }
   try {
-    await executeHarnessCommand(context.projectRoot, args, undefined, undefined, { taskVerify });
+    await executeHarnessCommand(context.projectRoot, args);
   } catch (error) {
     throw new CliError(error instanceof Error ? error.message : String(error), 2);
   }