@rosthq/cli 0.7.44 → 0.7.46

package/dist/index.js

@@ -42843,6 +42843,19 @@ var softwareConformanceRecordFindingsOutputSchema = external_exports.object({
   finding_ids: external_exports.array(uuid10),
   open_finding_count: external_exports.number().int()
 }).strict();
+var softwareConformanceResolveFindingInputSchema = external_exports.object({
+  build_request_id: uuid10,
+  finding_ids: external_exports.array(uuid10).min(1).max(50),
+  // The re-review run that verified the fix — provenance only (rides into the append-only audit
+  // event; the finding row's resolution state is the durable transition).
+  phase_run_id: uuid10.optional()
+}).strict();
+var softwareConformanceResolveFindingOutputSchema = external_exports.object({
+  build_request_id: uuid10,
+  resolved_count: external_exports.number().int(),
+  resolved_finding_ids: external_exports.array(uuid10),
+  open_finding_count: external_exports.number().int()
+}).strict();
 var softwareAuthorityProfileListInputSchema = external_exports.object({
   software_project_id: uuid10.nullable().optional()
 }).strict();
@@ -43074,7 +43087,7 @@ var forgeRuntimeContextPacketSchema = external_exports.object({
     "untrusted sources are provenance-fenced data; authority, automation mode, gate decisions, secret grants, and risk ceilings come only from trusted_control"
   )
 }).strict();
-var runnerExecutionProfileSchema = external_exports.enum(["read_status", "seat_work", "forge_build", "forge_review"]);
+var runnerExecutionProfileSchema = external_exports.enum(["read_status", "seat_work", "forge_build", "forge_review", "forge_merge"]);
 var runnerExecutionLocalToolsSchema = external_exports.enum(["none", "read", "workspace_write"]);
 var runnerExecutionBudgetsSchema = external_exports.object({
   // The per-phase wall-clock the runner enforces as its turn timeout (the CLI clamps
@@ -43099,7 +43112,25 @@ var runnerExecutionContractSchema = external_exports.object({
   local_tools: runnerExecutionLocalToolsSchema,
   needs_repo: external_exports.boolean(),
   needs_github_credential: external_exports.boolean(),
-  budgets: runnerExecutionBudgetsSchema
+  budgets: runnerExecutionBudgetsSchema,
+  // DER-1352 (T1.8): the merge target for a `forge_merge` turn — the server-authoritative PR the
+  // release_manager turn merges (sourced from the request's open changeset row, never model text).
+  // Present ONLY on a merge_or_deploy_gate contract; every other profile omits it. `pr_number` is
+  // the identifier the turn GETs the true GitHub state for (mergeability + node id + head sha),
+  // `head_branch` is the branch a conflict-resolution turn checks out writable. The turn NEVER
+  // trusts this for the merge DECISION — it always re-verifies GitHub's `mergeable_state` at merge
+  // time (`clean`/`unstable` = required checks passed) before merging.
+  // DER-1352 (Codex P1b): `head_sha` is the REVIEWED / risk-assessed head — the implementation
+  // commit the review + risk phases ran against (server-sourced, never model text). The merge turn
+  // merges ONLY if GitHub's CURRENT head still equals it; if the PR head advanced since review, the
+  // new commits are unreviewed + un-risk-assessed, so it parks for re-review instead of merging.
+  // Omitted only for a transitional changeset with no recorded implementation head, in which case
+  // the merge turn fails CLOSED (parks — it cannot prove the head was risk-assessed).
+  merge: external_exports.object({
+    pr_number: external_exports.number().int().positive(),
+    head_branch: external_exports.string().trim().min(1).max(255),
+    head_sha: external_exports.string().trim().regex(/^[0-9a-f]{7,40}$/i, "head_sha must be a git SHA (7\u201340 hex chars)").optional()
+  }).strict().optional()
 }).strict();
 var turnReportText = external_exports.string().trim().min(1).max(2e3);
 var runnerTurnReportIssueSchema = external_exports.object({
@@ -45270,7 +45301,7 @@ External connectors are being rolled out provider by provider, conservatively (r
     order: 48,
     title: "CLI and MCP installation guide",
     summary: "Install the public CLI, register remote token-backed MCP clients, and find the full command and tool catalog.",
-    version: "2026-07-05.6",
+    version: "2026-07-05.7",
     public: true,
     audiences: ["human", "cli", "mcp", "in_app_agent"],
     stages: ["company_setup", "staffing"],
@@ -46060,6 +46091,7 @@ Seat-scoped MCP tokens expose the operating protocol below. The server still che
 | \`rost_request_a_forge_secret_grant\` | \`software_factory.secret.request\` | Request access to a project secret by key. It creates a durable credential request and approval Task, never accepts a secret value, and does not grant access by itself. | Seat | Call with \`{"software_project_id":"<project-id>","environment":"preview","seat_id":"<seat-id>","action":"test.run","key_name":"OPENAI_API_KEY"}\`. |
 | \`rost_verify_forge_secret_broker_access\` | \`software_factory.secret.use\` | Verify broker authorization for a Forge secret without opening the vault. Missing grants create or reuse a credential request + approval Task; allowed grants return a redacted authorization summary only. Runtime vault use happens runner-side. | Seat | Call with \`{"software_project_id":"<project-id>","environment":"preview","seat_id":"<seat-id>","action":"test.run","key_name":"OPENAI_API_KEY","operation":"test_execution"}\`. |
 | \`rost_record_forge_conformance_findings\` | \`software_factory.conformance.record_findings\` | A Forge review seat (plan conformance, security, or QA) records structured findings as reviewer evidence. Set \`changeset_id\` on a finding that targets a specific changeset. Open findings route the request back to implementation; accepting a gap remains a separate human gate. Requires the seat's signed manifest grant. | Seat | Call with \`{"build_request_id":"<request-id>","findings":[{"severity":"major","category":"scope_gap","summary":"Missing migration verification","changeset_id":"<changeset-id>"}]}\`. |
+| \`rost_resolve_forge_conformance_finding\` | \`software_factory.conformance.resolve_finding\` | A Forge review seat marks a prior open finding resolved after re-reviewing the changeset and verifying it is fixed (reviewer verification, not human gap-acceptance). A resolved finding stops routing the request back to implementation, so the recycle loop converges. Requires the seat's signed manifest grant. | Seat | Call with \`{"build_request_id":"<request-id>","finding_ids":["<finding-id>"]}\`. |
 
 ### MCP operation resources
 
@@ -49232,6 +49264,7 @@ var COMMAND_MANIFEST = [
   { "id": "software_factory.config.list", "namespace": "software_factory", "action": "config.list", "title": "List Forge config", "description": "List active Forge config metadata for project environments. Plain config values may be returned; secret refs are represented only as has_secret_ref.", "requiredScope": "tenant", "confirmation": "none", "exposeOverMcp": true, "fields": [{ "name": "software_project_id", "flag": "software-project-id", "type": "string", "required": false }, { "name": "environment", "flag": "environment", "type": "enum", "required": false, "enumValues": ["development", "preview", "production"] }], "hasComplexInput": false, "help": "List active Forge config entries. Plain config may be shown; secret refs are represented only as metadata." },
   { "id": "software_factory.config.set", "namespace": "software_factory", "action": "config.set", "title": "Set Forge config", "description": "Create or rotate a Forge project config entry. Secret config stores only a vault ref pointer; raw values are never accepted for secret_ref entries.", "requiredScope": "tenant_admin", "confirmation": "human_required", "exposeOverMcp": true, "fields": [{ "name": "software_project_id", "flag": "software-project-id", "type": "string", "required": true }, { "name": "environment", "flag": "environment", "type": "enum", "required": true, "enumValues": ["development", "preview", "production"] }, { "name": "key_name", "flag": "key-name", "type": "string", "required": true }, { "name": "value_kind", "flag": "value-kind", "type": "enum", "required": true, "enumValues": ["plain", "secret_ref"] }, { "name": "plain_value", "flag": "plain-value", "type": "string", "required": false }, { "name": "vault_ref", "flag": "vault-ref", "type": "string", "required": false }], "hasComplexInput": false, "help": "Set or rotate a Forge project config key. Secret entries store only vault refs and are human-gated." },
   { "id": "software_factory.conformance.record_findings", "namespace": "software_factory", "action": "conformance.record_findings", "title": "Record Forge conformance findings", "description": "The plan-conformance reviewer records one or more findings against a build request; open findings route the request back to implementation. Recording is evidence, not a decision \u2014 accepting a gap is a separate human gate. Requires the Forge add-on.", "requiredScope": "tenant", "confirmation": "none", "exposeOverMcp": true, "fields": [{ "name": "build_request_id", "flag": "build-request-id", "type": "string", "required": true }, { "name": "phase_run_id", "flag": "phase-run-id", "type": "string", "required": false }], "hasComplexInput": true, "help": "Record structured Forge plan-conformance findings as reviewer evidence. Open findings route the request back to implementation; accepting a gap remains a separate human gate." },
+  { "id": "software_factory.conformance.resolve_finding", "namespace": "software_factory", "action": "conformance.resolve_finding", "title": "Resolve Forge conformance finding", "description": "A Forge review seat marks one or more prior open conformance findings resolved after re-reviewing the changeset and verifying they are fixed. This is reviewer verification, not gap-acceptance (accepting a gap stays a separate human gate). A resolved finding stops routing the request back to implementation, letting the recycle loop converge. Requires the Forge add-on.", "requiredScope": "tenant", "confirmation": "none", "exposeOverMcp": true, "fields": [{ "name": "build_request_id", "flag": "build-request-id", "type": "string", "required": true }, { "name": "finding_ids", "flag": "finding-ids", "type": "array", "required": true, "itemType": "string" }, { "name": "phase_run_id", "flag": "phase-run-id", "type": "string", "required": false }], "hasComplexInput": false, "help": "Resolve a prior open Forge conformance finding after re-reviewing the changeset and verifying it is fixed (reviewer verification, not human gap-acceptance). A resolved finding stops routing the request back to implementation, letting the recycle loop converge." },
   { "id": "software_factory.developer_team.install", "namespace": "software_factory", "action": "developer_team.install", "title": "Install Forge Developer Team", "description": "Install AND activate the governed Forge Developer Team: 8 seats (1 human lead + 7 agents), first-party skills, authority presets, and a conservative token budget. Approving this ACTIVATES the 7 agents as live occupancies at a pr_only, observe-first posture: they open pull requests but never merge or deploy without a human (the Release Manager auto-merges only after a human raises the automation-mode ceiling). Entitlement-gated and human-confirmed.", "requiredScope": "tenant_admin", "confirmation": "human_required", "exposeOverMcp": true, "fields": [{ "name": "steward_seat_id", "flag": "steward-seat-id", "type": "string", "required": true }, { "name": "software_project_id", "flag": "software-project-id", "type": "string", "required": false }, { "name": "assign_skills", "flag": "assign-skills", "type": "boolean", "required": false }, { "name": "acknowledge_autonomy_ceiling", "flag": "acknowledge-autonomy-ceiling", "type": "boolean", "required": false }], "hasComplexInput": true, "help": "Install the governed Forge Developer Team template with seats, draft Charters, skills, project authority grants, and audit records. Tenant-admin and human-gated; creates no live agent occupancy." },
   { "id": "software_factory.developer_team.uninstall", "namespace": "software_factory", "action": "developer_team.uninstall", "title": "Uninstall Forge Developer Team", "description": "Tear down the governed Forge Developer Team (ADR-0018 \xA76): end the auto-staffed agent occupancies in a no-orphan-safe order, decommission the agents, and revoke the team's project authority and secret grants. The human Forge Lead seat is left intact; re-installing re-staffs the team. The entitlement-lapse variant runs the same teardown path without re-checking the Forge paywall. Owner-only, human-gated, and audited.", "requiredScope": "tenant_admin", "confirmation": "human_required", "exposeOverMcp": true, "fields": [{ "name": "reason", "flag": "reason", "type": "string", "required": false }, { "name": "trigger", "flag": "trigger", "type": "enum", "required": false, "enumValues": ["manual", "entitlement_lapse"] }], "hasComplexInput": false, "help": "Tear down the Forge Developer Team (teardown \u2014 ADR-0018 \xA76): end the agent occupancies in a no-orphan-safe order, decommission the agents, and revoke the team's authority and secret grants. The human Forge Lead seat stays. Owner-only and human-gated; the entitlement-lapse variant runs the same teardown path." },
   { "id": "software_factory.gate.decide", "namespace": "software_factory", "action": "gate.decide", "title": "Decide a Forge gate", "description": "A human approves or rejects a Forge gate. The resolver is recorded (never an agent \u2014 invariant #7); sensitive gates (security sign-off, merge/deploy, authority change, production deploy) also write a linked human decision. Requires confirmation.", "requiredScope": "tenant_admin", "confirmation": "human_required", "exposeOverMcp": true, "fields": [{ "name": "gate_id", "flag": "gate-id", "type": "string", "required": true }, { "name": "decision", "flag": "decision", "type": "enum", "required": true, "enumValues": ["approve", "reject"] }, { "name": "rationale", "flag": "rationale", "type": "string", "required": false }], "hasComplexInput": false, "help": "A human approves or rejects a Forge gate; an agent caller routes to /approvals and can never self-approve. Sensitive gates record a human decision." },
@@ -52112,22 +52145,18 @@ async function configureForgeIdentity(baseRepo) {
   await runGit(["config", "user.name", FORGE_GIT_AUTHOR_NAME], baseRepo);
   await runGit(["config", "user.email", FORGE_GIT_AUTHOR_EMAIL], baseRepo);
 }
-async function prepareForgeWorkspace(options) {
-  if (options.profile === "review" && !options.headSha) {
-    throw new Error("prepareForgeWorkspace: review profile requires headSha");
-  }
-  const baseRepo = baseRepoDir(options.baseDir, options.buildRequestId);
-  const url2 = remoteUrlFor(options);
+async function ensureBaseClone(input) {
+  const baseRepo = baseRepoDir(input.baseDir, input.buildRequestId);
   await mkdir2(path3.dirname(baseRepo), { recursive: true, mode: 448 });
-  await withLedgerStep(options.ledger, "clone", (retryCounter) => withAskpass(options.credential, async (netEnv) => {
+  await withLedgerStep(input.ledger, "clone", (retryCounter) => withAskpass(input.credential, async (netEnv) => {
     if (await isGitRepo(baseRepo)) {
-      await runGitNetwork("git fetch", ["fetch", "--prune", "--quiet", url2, "+refs/heads/*:refs/remotes/origin/*"], netEnv, baseRepo, FETCH_TIMEOUT_MS, retryCounter);
+      await runGitNetwork("git fetch", ["fetch", "--prune", "--quiet", input.url, "+refs/heads/*:refs/remotes/origin/*"], netEnv, baseRepo, FETCH_TIMEOUT_MS, retryCounter);
     } else {
       await runGitNetwork(
         "git clone",
         // Non-shallow (no --depth) so merge-base/ancestry survive for later phases;
         // --no-checkout keeps the base a bare-ish object store the worktrees hang off.
-        ["clone", "--no-checkout", "--quiet", url2, baseRepo],
+        ["clone", "--no-checkout", "--quiet", input.url, baseRepo],
         netEnv,
         void 0,
         CLONE_TIMEOUT_MS,
@@ -52136,11 +52165,52 @@ async function prepareForgeWorkspace(options) {
     }
   }));
   await configureForgeIdentity(baseRepo);
+  return baseRepo;
+}
+async function prepareForgeWorkspace(options) {
+  if (options.profile === "review" && !options.headSha) {
+    throw new Error("prepareForgeWorkspace: review profile requires headSha");
+  }
+  const baseRepo = await ensureBaseClone({
+    baseDir: options.baseDir,
+    buildRequestId: options.buildRequestId,
+    url: remoteUrlFor(options),
+    credential: options.credential,
+    ledger: options.ledger
+  });
   if (options.profile === "review") {
     return await prepareReviewWorktree(options, baseRepo);
   }
   return await prepareBuildWorktree(options, baseRepo);
 }
+async function prepareMergeWorkspace(options) {
+  if (!options.headBranch || options.headBranch.trim().length === 0) {
+    throw new Error("prepareMergeWorkspace: headBranch is required");
+  }
+  const url2 = options.remoteUrl ?? `https://github.com/${options.repo.owner}/${options.repo.name}.git`;
+  const baseRepo = await ensureBaseClone({
+    baseDir: options.baseDir,
+    buildRequestId: options.buildRequestId,
+    url: url2,
+    credential: options.credential,
+    ledger: options.ledger
+  });
+  const branch = options.headBranch;
+  const worktreeDir = path3.join(requestRoot(options.baseDir, options.buildRequestId), "merge");
+  const originDefault = `origin/${options.repo.default_branch}`;
+  const originHead = `origin/${branch}`;
+  await withLedgerStep(options.ledger, "branch", async () => {
+    if (await worktreeRegistered(baseRepo, worktreeDir)) {
+      await removeWorktree(baseRepo, worktreeDir);
+    }
+    if (await localBranchExists(baseRepo, branch)) {
+      await runGit(["branch", "-D", branch], baseRepo);
+    }
+    await runGit(["worktree", "add", "-b", branch, worktreeDir, originHead], baseRepo);
+  });
+  const baseSha = (await runGit(["merge-base", "HEAD", originDefault], worktreeDir)).trim();
+  return { baseRepo, worktreeDir, branch, readOnly: false, baseSha, remoteUrl: url2 };
+}
 async function prepareBuildWorktree(options, baseRepo) {
   const branch = branchName(options.buildRequestId, options.changeset);
   const worktreeDir = buildWorktreeDir(options.baseDir, options.buildRequestId, options.changeset.ordinal);
@@ -52351,6 +52421,147 @@ async function openDraftPullRequestInner(options, retryCounter) {
   }
   throw new Error(`github pr create failed ${created.status}: ${redactSecrets(await readErrorText(created)).slice(0, 500)}`);
 }
+function classifyMergeReadiness(state) {
+  if (state.merged) {
+    return "already_merged";
+  }
+  if (state.draft) {
+    return "draft";
+  }
+  if (state.mergeable === false || state.mergeableState === "dirty") {
+    return "conflicted";
+  }
+  switch (state.mergeableState) {
+    // clean = all required checks passed, no conflicts. unstable = only NON-required checks are
+    // failing/pending (GitHub still permits the merge) — treat as mergeable.
+    case "clean":
+    case "unstable":
+      return "mergeable";
+    case "blocked":
+      return "blocked";
+    case "behind":
+      return "behind";
+    case "unknown":
+    case "":
+      return "unknown";
+    default:
+      return "blocked";
+  }
+}
+function toPullRequestState(json2) {
+  const record2 = json2 && typeof json2 === "object" && !Array.isArray(json2) ? json2 : {};
+  const head2 = record2.head && typeof record2.head === "object" ? record2.head : {};
+  const number4 = typeof record2.number === "number" ? record2.number : Number.NaN;
+  const nodeId = typeof record2.node_id === "string" ? record2.node_id : "";
+  if (!Number.isFinite(number4) || !nodeId) {
+    throw new Error("github pr response missing number or node_id");
+  }
+  return {
+    number: number4,
+    nodeId,
+    merged: record2.merged === true,
+    draft: record2.draft === true,
+    mergeable: typeof record2.mergeable === "boolean" ? record2.mergeable : null,
+    mergeableState: typeof record2.mergeable_state === "string" ? record2.mergeable_state : "unknown",
+    headSha: typeof head2.sha === "string" ? head2.sha : "",
+    mergedSha: typeof record2.merge_commit_sha === "string" && record2.merged === true ? record2.merge_commit_sha : null
+  };
+}
+async function fetchPullRequestState(options) {
+  const baseUrl = (options.apiBaseUrl ?? GITHUB_API_BASE_URL).replace(/\/+$/u, "");
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const response = await withGithubRetries(
+    "github pr get",
+    async () => fetchImpl(`${baseUrl}/repos/${options.repo.owner}/${options.repo.name}/pulls/${options.prNumber}`, {
+      method: "GET",
+      headers: githubHeaders(options.credential)
+    })
+  );
+  if (response.status !== 200) {
+    throw new Error(`github pr get failed ${response.status}: ${redactSecrets(await readErrorText(response)).slice(0, 500)}`);
+  }
+  return toPullRequestState(await response.json());
+}
+async function mergePullRequest(options) {
+  const baseUrl = (options.apiBaseUrl ?? GITHUB_API_BASE_URL).replace(/\/+$/u, "");
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const { owner, name } = options.repo;
+  if (options.state.merged) {
+    return { status: "merged", mergedSha: options.state.mergedSha };
+  }
+  const merge2 = await withGithubRetries(
+    "github pr merge",
+    async () => fetchImpl(`${baseUrl}/repos/${owner}/${name}/pulls/${options.state.number}/merge`, {
+      method: "PUT",
+      headers: githubHeaders(options.credential),
+      // SHA guard: merge ONLY the head we verified — never pass a merge_method (the repo default
+      // wins; a queue owns the strategy). A stale sha → 409, re-checked by the caller.
+      body: JSON.stringify({ sha: options.state.headSha })
+    })
+  );
+  if (merge2.status === 405) {
+    const detail = await readErrorText(merge2);
+    if (/merge queue/i.test(detail)) {
+      await enablePullRequestAutoMerge({ repo: options.repo, nodeId: options.state.nodeId, credential: options.credential, fetchImpl, apiBaseUrl: baseUrl });
+      return { status: "queued" };
+    }
+    throw new Error(`github pr merge failed 405: ${redactSecrets(detail).slice(0, 500)}`);
+  }
+  if (merge2.status !== 200) {
+    throw new Error(`github pr merge failed ${merge2.status}: ${redactSecrets(await readErrorText(merge2)).slice(0, 500)}`);
+  }
+  const confirmed = await fetchPullRequestState({ repo: options.repo, prNumber: options.state.number, credential: options.credential, fetchImpl, apiBaseUrl: baseUrl });
+  if (!confirmed.merged) {
+    throw new Error("github pr merge postcondition failed: PR is not merged after the merge call");
+  }
+  return { status: "merged", mergedSha: confirmed.mergedSha };
+}
+async function enablePullRequestAutoMerge(options) {
+  const baseUrl = (options.apiBaseUrl ?? GITHUB_API_BASE_URL).replace(/\/+$/u, "");
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const response = await withGithubRetries(
+    "github enable auto-merge",
+    async () => fetchImpl(`${baseUrl}/graphql`, {
+      method: "POST",
+      headers: githubHeaders(options.credential),
+      body: JSON.stringify({
+        query: "mutation($id:ID!){enablePullRequestAutoMerge(input:{pullRequestId:$id}){clientMutationId}}",
+        variables: { id: options.nodeId }
+      })
+    })
+  );
+  if (response.status !== 200) {
+    throw new Error(`github enable auto-merge failed ${response.status}: ${redactSecrets(await readErrorText(response)).slice(0, 500)}`);
+  }
+  const body = await response.json();
+  if (Array.isArray(body.errors) && body.errors.length > 0) {
+    throw new Error("github enable auto-merge returned errors");
+  }
+}
+async function forcePushWithLease(ws, credential) {
+  if (ws.readOnly || ws.branch.length === 0) {
+    throw new Error("force-push requires a writable build worktree on a branch");
+  }
+  const head2 = (await runGit(["rev-parse", "HEAD"], ws.worktreeDir)).trim();
+  await withAskpass(credential, async (netEnv) => {
+    const before = await runGitNetwork("git ls-remote", ["ls-remote", ws.remoteUrl, `refs/heads/${ws.branch}`], netEnv, ws.worktreeDir, FETCH_TIMEOUT_MS);
+    const beforeSha = before.split(/\s+/)[0]?.trim() ?? "";
+    const forceArg = beforeSha ? `--force-with-lease=refs/heads/${ws.branch}:${beforeSha}` : null;
+    await runGitNetwork(
+      "git push --force-with-lease",
+      ["push", ...forceArg ? [forceArg] : [], "--quiet", ws.remoteUrl, `HEAD:refs/heads/${ws.branch}`],
+      netEnv,
+      ws.worktreeDir,
+      PUSH_TIMEOUT_MS
+    );
+    const remote = await runGitNetwork("git ls-remote", ["ls-remote", ws.remoteUrl, `refs/heads/${ws.branch}`], netEnv, ws.worktreeDir, FETCH_TIMEOUT_MS);
+    const remoteSha = remote.split(/\s+/)[0]?.trim() ?? "";
+    if (remoteSha !== head2) {
+      throw new Error(`git force-push postcondition failed: remote ${ws.branch} is ${remoteSha || "absent"}, expected ${head2}`);
+    }
+  });
+  return { commitSha: head2 };
+}
 async function removeWorktree(baseRepo, worktreeDir) {
   try {
     await runGit(["worktree", "remove", "--force", worktreeDir], baseRepo);
@@ -52978,7 +53189,7 @@ async function detectCapabilities(cliVersion, env, homeDir) {
     claude: { ...claude, account_alias: accountAlias, rate_limited_until: null },
     codex: { ...codex, account_alias: accountAlias, rate_limited_until: null },
     turn_executions: { report_supported: true },
-    ...cliVersion ? { forge_build: cliVersion, seat_work: cliVersion } : {},
+    ...cliVersion ? { forge_build: cliVersion, seat_work: cliVersion, forge_merge: cliVersion } : {},
     git,
     gh,
     scheduler: { max_parallel_sessions_estimate: null },
@@ -53134,6 +53345,11 @@ async function executeClaimedUnit(fetchImpl, appUrl2, state, config2, io, runtim
     ...result.commitSha ? { commit_sha: result.commitSha } : {},
     ...result.evidence && result.evidence.length > 0 ? { evidence: result.evidence } : {},
     ...result.changedPaths && result.changedPaths.length > 0 ? { changed_paths: result.changedPaths } : {},
+    // DER-1352 (T1.8): the merge-turn postcondition. Only sent when the harness GET-verified the PR
+    // merged on GitHub — the driver's completion writer marks the changeset merged + writes the
+    // decisions row ONLY on this. Gated on result.ok so a failed turn can never carry it.
+    ...result.ok && result.merged === true ? { merged: true } : {},
+    ...result.ok && result.merged === true && result.mergedCommitSha ? { merged_commit_sha: result.mergedCommitSha } : {},
     // DER-1331 (T1.9): the step ledger + the model's (already redacted, bounded) transcript.
     // Only the work-orders result route accepts these today (turn-executions is a separate,
     // narrower endpoint — T1.9 scope); its Zod schema strips unrecognized keys on a non-strict
@@ -53447,6 +53663,7 @@ function buildTurnPrompt(input) {
   const isForgeReview = execution?.profile === "forge_review";
   const isSeatWork = execution?.profile === "seat_work";
   const canFileFindings = execution?.allowed_mcp_tools.includes("rost_record_forge_conformance_findings") ?? false;
+  const canResolveFindings = execution?.allowed_mcp_tools.includes("rost_resolve_forge_conformance_finding") ?? false;
   return [
     hasForgeContext ? `Call rost_get_context first to load your full ${cliBrand.name} charter, then call rost_get_build_context with forge.phase_run_id from the claimed context to load the approved plan, open findings, prior phase summaries, and remaining budgets. Next call rost_list_my_skills and load any assigned Skill you need with rost_get_my_skill_file. Then perform the assigned phase work, address every open finding, report a concise phase status, and stop.` : hasAicosTurnContext ? `Call rost_get_context first to load your full ${cliBrand.name} charter, then call rost_aicos_turn_load_context with turn_execution_id from the claimed context. Answer the AICOS user turn using only that loaded context plus seat-authorized tools. Return only the final concise Markdown answer; no hidden reasoning, tool chatter, raw JSON, secrets, local paths, or unauthorized memory.` : hasAicosContext ? `Call rost_get_context first to load your full ${cliBrand.name} charter, answer the AICOS user turn using only seat-authorized context and tools, return only the final answer as concise Markdown with short paragraphs or real lists, and stop.` : isSeatWork ? `Call rost_get_context first to load your full ${cliBrand.name} charter and current tasks, then carry out the scheduled work your charter authorizes \u2014 accept and complete assigned tasks, record signal readings, file friction, create or attach deliverables, and log your work through your seat tools. Every tool call is re-authorized server-side against your permission manifest, so use only the actions your charter grants and escalate anything beyond your autonomous scope. Report a concise status when done and stop.` : `Call rost_get_context first to load your full ${cliBrand.name} charter, report one read-only status, and stop.`,
     // Forge workspace guidance (phase-specific). The harness owns all git network ops; the
@@ -53456,6 +53673,9 @@ function buildTurnPrompt(input) {
     // T1.6: the review/QA seats record findings through their manifest-granted writer. Only
     // emitted when the seat actually holds the tool (so the builder is never told to file findings).
     canFileFindings ? "When you find a plan-conformance, security, or QA gap, record it with rost_record_forge_conformance_findings \u2014 set changeset_id when the finding targets a specific changeset. A finding is reviewer evidence, not a decision (accepting a gap is a separate human gate). If rost_get_build_context returned a `review` block, review ONLY changesets where review.changesets[].needs_review is true; never re-review an unchanged passing changeset or re-file a prior finding listed in review.prior_findings \u2014 verify those are resolved instead." : "",
+    // DER-1355: on a re-review the seat must RESOLVE a prior finding it verified as fixed —
+    // otherwise the still-open finding routes the request back forever and the loop never converges.
+    canResolveFindings ? "For each finding in your build context's open_findings on a changeset you re-review, verify it against the current diff: if the diff now fixes it, RESOLVE it with rost_resolve_forge_conformance_finding (this is reviewer verification, not human gap-acceptance); if it is still not fixed, leave it open. A resolved finding stops routing the request back to implementation, so the build can converge instead of thrashing to a budget block." : "",
     input.hasWorkspace ? "Load your assigned Skills with rost_list_my_skills and rost_get_my_skill_file before starting; if none are assigned, proceed with your charter and the loaded build context." : "",
     isSeatWork ? "If seat skill tools are available, load your assigned skills before starting; if none are exposed, proceed with your charter and assigned tasks." : "",
     hasAicosTurnContext ? "For AICOS turns, the governed load tool returns the authoritative tenant clock, route context, transcript window, session summary, source counts, read models, and output contract. Never substitute local runtime time or model priors for that loaded tenant clock." : "",
@@ -53473,6 +53693,9 @@ function buildTurnPrompt(input) {
 }
 async function spawnRunnerTurn(ctx, workOrder, runtime, kind) {
   const execution = parseRunnerExecutionContract(workOrder);
+  if (execution?.profile === "forge_merge") {
+    return runForgeMergeTurn(ctx, workOrder, execution, runtime);
+  }
   let forgePrep = null;
   if (execution?.needs_repo) {
     const prepared = await prepareForgeTurn(ctx, workOrder, execution);
@@ -53555,6 +53778,271 @@ async function spawnRunnerTurn(ctx, workOrder, runtime, kind) {
   }
   return result;
 }
+var MERGE_MERGEABILITY_POLLS = 5;
+var MERGE_MERGEABILITY_POLL_MS = 2e3;
+var MERGE_QUEUE_POLLS = 10;
+var MERGE_QUEUE_POLL_MS = 3e3;
+var MERGE_CONFLICT_SUMMARY_MAX = 12e3;
+function mergeParkResult(note, extra) {
+  return { ok: true, summary: `[forge-merge] ${note}`.slice(0, MERGE_CONFLICT_SUMMARY_MAX), ...extra };
+}
+function mergeMergedResult(mergedSha, note) {
+  return {
+    ok: true,
+    merged: true,
+    ...mergedSha ? { mergedCommitSha: mergedSha } : {},
+    summary: `[forge-merge] ${note}${mergedSha ? ` (${mergedSha})` : ""}`.slice(0, MERGE_CONFLICT_SUMMARY_MAX)
+  };
+}
+async function brokerForgeMergeCredential(ctx, workOrder) {
+  const workOrderId = typeof workOrder.id === "string" ? workOrder.id : "";
+  const forge = typeof workOrder.forge === "object" && workOrder.forge !== null ? workOrder.forge : null;
+  const buildRequestId = typeof forge?.build_request_id === "string" ? forge.build_request_id : "";
+  if (!workOrderId || !buildRequestId) {
+    return { ok: false, summary: "[forge-merge] work order missing id or build request id" };
+  }
+  const credentialMintStartedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const brokered = await post2(
+    ctx.fetchImpl,
+    ctx.appUrl,
+    `/api/runner/work-orders/${encodeURIComponent(workOrderId)}/github-credential`,
+    {},
+    ctx.state.runner_secret
+  );
+  ctx.ledger.record({
+    step: "credential_mint",
+    started_at: credentialMintStartedAt,
+    ended_at: (/* @__PURE__ */ new Date()).toISOString(),
+    ok: brokered.status === 200,
+    retry_count: 0,
+    ...brokered.status === 200 ? {} : { error_class: classifyHttpStatus(brokered.status) }
+  });
+  if (brokered.status !== 200) {
+    return { ok: false, summary: `[forge-merge] credential broker failed ${brokered.status}: ${redactForLog(JSON.stringify(brokered.json))}` };
+  }
+  const repoRaw = typeof brokered.json.repo === "object" && brokered.json.repo !== null ? brokered.json.repo : null;
+  const token = typeof brokered.json.token === "string" ? brokered.json.token : "";
+  const expiresAt = typeof brokered.json.expires_at === "string" ? brokered.json.expires_at : "";
+  const owner = typeof repoRaw?.owner === "string" ? repoRaw.owner : "";
+  const name = typeof repoRaw?.name === "string" ? repoRaw.name : "";
+  const defaultBranch = typeof repoRaw?.default_branch === "string" ? repoRaw.default_branch : "";
+  if (!token || !expiresAt || !owner || !name || !defaultBranch) {
+    return { ok: false, summary: "[forge-merge] credential broker returned an incomplete credential" };
+  }
+  return { ok: true, credential: { token, expiresAt }, repo: { owner, name, default_branch: defaultBranch }, buildRequestId };
+}
+async function fetchSettledPullRequestState(ctx, input) {
+  let state = await fetchPullRequestState({ repo: input.repo, prNumber: input.prNumber, credential: input.credential, fetchImpl: ctx.fetchImpl });
+  for (let attempt = 0; attempt < MERGE_MERGEABILITY_POLLS && state.mergeable === null && !state.merged; attempt += 1) {
+    await sleep3(MERGE_MERGEABILITY_POLL_MS);
+    state = await fetchPullRequestState({ repo: input.repo, prNumber: input.prNumber, credential: input.credential, fetchImpl: ctx.fetchImpl });
+  }
+  return state;
+}
+async function pollForQueueMerge(ctx, input) {
+  for (let attempt = 0; attempt < MERGE_QUEUE_POLLS; attempt += 1) {
+    await sleep3(MERGE_QUEUE_POLL_MS);
+    const state = await fetchPullRequestState({ repo: input.repo, prNumber: input.prNumber, credential: input.credential, fetchImpl: ctx.fetchImpl });
+    if (state.merged) {
+      return { mergedSha: state.mergedSha };
+    }
+  }
+  return null;
+}
+async function resolveMergeConflictTurn(ctx, input) {
+  const tenantId = typeof input.workOrder.tenant_id === "string" ? input.workOrder.tenant_id : ctx.state.tenant_id ?? "runner";
+  let workspace;
+  try {
+    workspace = await prepareMergeWorkspace({
+      baseDir: path5.join(ctx.config.homeDir, ".rost", "forge", ctx.state.runner_id),
+      tenantId,
+      buildRequestId: input.buildRequestId,
+      repo: input.repo,
+      credential: input.credential,
+      headBranch: input.headBranch,
+      ledger: ctx.ledger
+    });
+  } catch (error51) {
+    return { pushed: false, result: { ok: false, summary: `[forge-merge] conflict workspace preparation failed: ${redactForLog(error51 instanceof Error ? error51.message : String(error51))}`.slice(0, MERGE_CONFLICT_SUMMARY_MAX) } };
+  }
+  const sandbox = resolveSandboxSpec({
+    mode: ctx.config.sandboxMode,
+    platform: process.platform,
+    workspaceDir: workspace.worktreeDir,
+    tmpDir: tmpdir2(),
+    homeDir: ctx.config.homeDir,
+    stateFile: ctx.config.stateFile,
+    runnerBaseDir: path5.join(ctx.config.homeDir, ".rost"),
+    allowWritePaths: [workspace.baseRepo],
+    denyWritePaths: [
+      `${path5.join(workspace.baseRepo, ".git", "hooks")}/`,
+      path5.join(workspace.baseRepo, ".git", "config"),
+      path5.join(workspace.worktreeDir, ".git")
+    ],
+    allowNetwork: ctx.config.sandboxAllowNetwork
+  });
+  const modelResult = await spawnMergeConflictModel(ctx, {
+    workOrder: input.workOrder,
+    execution: input.execution,
+    runtime: input.runtime,
+    workspace,
+    sandbox,
+    defaultBranch: input.repo.default_branch
+  });
+  if (!modelResult.ok) {
+    await removeWorkspace(workspace).catch(() => void 0);
+    return { pushed: false, result: mergeParkResult(`could not resolve the merge conflict (${modelResult.summary.slice(0, 400)}); parking for a human.`) };
+  }
+  try {
+    const pushed = await forcePushWithLease(workspace, input.credential);
+    await removeWorkspace(workspace).catch(() => void 0);
+    return { pushed: true, result: mergeParkResult(`resolved the conflict and force-pushed ${pushed.commitSha}`, { commitSha: pushed.commitSha }) };
+  } catch (error51) {
+    await removeWorkspace(workspace).catch(() => void 0);
+    return { pushed: false, result: { ok: false, summary: `[forge-merge] conflict resolution force-push failed: ${redactForLog(error51 instanceof Error ? error51.message : String(error51))}`.slice(0, MERGE_CONFLICT_SUMMARY_MAX) } };
+  }
+}
+async function spawnMergeConflictModel(ctx, input) {
+  const mcp = typeof input.workOrder.mcp === "object" && input.workOrder.mcp !== null ? input.workOrder.mcp : {};
+  const token = typeof mcp.token === "string" ? mcp.token : "";
+  const url2 = typeof mcp.url === "string" ? `${ctx.appUrl.replace(/\/+$/, "")}${mcp.url}` : `${ctx.appUrl.replace(/\/+$/, "")}/mcp`;
+  const mcpConfig = JSON.stringify({ mcpServers: { rost: { type: "http", url: url2, headers: { Authorization: `Bearer ${token}` } } } });
+  const configPath = path5.join(tmpdir2(), `rost-runner-mcp-${createHash2("sha256").update(`${url2}:${Date.now()}:${Math.random()}`).digest("hex").slice(0, 16)}.json`);
+  await writeFile3(configPath, `${mcpConfig}
+`, { mode: 384 });
+  await chmod2(configPath, 384);
+  const plan = resolveTurnPlan({ kind: "work_order", execution: input.execution, repoDir: input.workspace.worktreeDir });
+  const prompt = [
+    "You are resolving a merge conflict on a pull request branch so it can merge into the base branch.",
+    `A WRITABLE checkout of the PR's head branch is at your current working directory. Run \`git merge origin/${input.defaultBranch}\` to merge the base branch in, resolve EVERY conflict so the result is correct and builds, then \`git add\` the resolved files and \`git commit\` the merge. If the project has a fast build or test, run it to confirm the resolution.`,
+    "Do NOT run git push, git remote, or any network git command, and never request or handle GitHub tokens \u2014 the harness pushes and merges after you finish. If the conflict cannot be resolved safely, do NOT force a bad merge: leave the branch uncommitted and stop with a short explanation.",
+    "End with a single concise final message summarizing exactly what you resolved."
+  ].join("\n");
+  let sandboxProfilePath = null;
+  if (input.sandbox.kind === "seatbelt") {
+    sandboxProfilePath = path5.join(tmpdir2(), `rost-runner-sandbox-${createHash2("sha256").update(`${configPath}:${Math.random()}`).digest("hex").slice(0, 16)}.sb`);
+    await writeFile3(sandboxProfilePath, input.sandbox.profile, { mode: 384 });
+    await chmod2(sandboxProfilePath, 384);
+  }
+  const built = buildTurnCommand({ runtime: input.runtime, prompt, configPath, plan });
+  const { command, args } = wrapCommandWithSandbox(input.sandbox, built.command, built.args, sandboxProfilePath);
+  const spawnStartedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const result = await runModelProcess({
+    command,
+    args,
+    cwd: input.workspace.worktreeDir,
+    timeoutMs: plan.timeoutMs,
+    // The model gets the EXPLICIT allowlist env — never the merge token, GIT_ASKPASS, or the bearer.
+    env: buildModelSpawnEnv(process.env),
+    expectSessionEnvelope: false
+  });
+  const exitClass = classifyModelExit(result);
+  ctx.ledger.record({
+    step: "model_exit",
+    started_at: spawnStartedAt,
+    ended_at: (/* @__PURE__ */ new Date()).toISOString(),
+    ok: result.ok,
+    retry_count: 0,
+    ...exitClass.errorClass ? { error_class: exitClass.errorClass } : {}
+  });
+  void rm4(configPath, { force: true });
+  if (sandboxProfilePath) {
+    void rm4(sandboxProfilePath, { force: true });
+  }
+  return result;
+}
+async function runForgeMergeTurn(ctx, workOrder, execution, runtime) {
+  const merge2 = execution.merge;
+  if (!merge2) {
+    return mergeParkResult("no merge target bound on the execution contract; parking for a human.");
+  }
+  const prepared = await brokerForgeMergeCredential(ctx, workOrder);
+  if (!prepared.ok) {
+    return { ok: false, summary: prepared.summary };
+  }
+  const { credential, repo, buildRequestId } = prepared;
+  const mergeStartedAt = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    const outcome = await executeForgeMerge(ctx, {
+      workOrder,
+      execution,
+      runtime,
+      repo,
+      credential,
+      buildRequestId,
+      prNumber: merge2.pr_number,
+      headBranch: merge2.head_branch
+    });
+    ctx.ledger.record({
+      step: "merge",
+      started_at: mergeStartedAt,
+      ended_at: (/* @__PURE__ */ new Date()).toISOString(),
+      ok: outcome.ok,
+      retry_count: 0,
+      ...outcome.ok ? {} : { error_class: "conflict" }
+    });
+    return outcome;
+  } catch (error51) {
+    ctx.ledger.record({
+      step: "merge",
+      started_at: mergeStartedAt,
+      ended_at: (/* @__PURE__ */ new Date()).toISOString(),
+      ok: false,
+      retry_count: 0,
+      error_class: "server_error"
+    });
+    return { ok: false, summary: `[forge-merge] merge turn failed: ${redactForLog(error51 instanceof Error ? error51.message : String(error51))}`.slice(0, MERGE_CONFLICT_SUMMARY_MAX) };
+  }
+}
+async function executeForgeMerge(ctx, input) {
+  const { repo, credential, prNumber } = input;
+  let state = await fetchSettledPullRequestState(ctx, { repo, prNumber, credential });
+  let readiness = classifyMergeReadiness(state);
+  if (readiness === "already_merged") {
+    return mergeMergedResult(state.mergedSha, "PR already merged on GitHub");
+  }
+  const reviewedHeadSha = input.execution.merge?.head_sha;
+  if (!reviewedHeadSha) {
+    return mergeParkResult("no reviewed head SHA bound on the merge contract; parking for a human (cannot verify the PR head was risk-assessed).");
+  }
+  if (state.headSha !== reviewedHeadSha) {
+    return mergeParkResult(`PR head advanced since review (reviewed ${reviewedHeadSha.slice(0, 12)}, GitHub now ${state.headSha.slice(0, 12) || "unknown"}); the new commits need re-review/re-risk \u2014 parking.`);
+  }
+  if (readiness === "blocked" || readiness === "draft" || readiness === "unknown") {
+    return mergeParkResult(`PR is not ready to merge (state=${state.mergeableState}); parking for a human.`);
+  }
+  if (readiness === "conflicted" || readiness === "behind") {
+    const resolved = await resolveMergeConflictTurn(ctx, {
+      workOrder: input.workOrder,
+      execution: input.execution,
+      runtime: input.runtime,
+      repo: input.repo,
+      credential: input.credential,
+      buildRequestId: input.buildRequestId,
+      headBranch: input.headBranch
+    });
+    if (!resolved.pushed) {
+      return resolved.result ?? mergeParkResult("could not resolve the merge conflict; parking for a human.");
+    }
+    state = await fetchSettledPullRequestState(ctx, { repo, prNumber, credential });
+    readiness = classifyMergeReadiness(state);
+    if (readiness === "already_merged") {
+      return mergeMergedResult(state.mergedSha, "PR merged during conflict resolution");
+    }
+    if (readiness !== "mergeable") {
+      return mergeParkResult(`conflict resolved and pushed, but the PR is not yet mergeable (state=${state.mergeableState}); parking for a re-check.`, resolved.result?.commitSha ? { commitSha: resolved.result.commitSha } : void 0);
+    }
+  }
+  const outcome = await mergePullRequest({ repo, state, credential, fetchImpl: ctx.fetchImpl });
+  if (outcome.status === "merged") {
+    return mergeMergedResult(outcome.mergedSha, "PR merged");
+  }
+  const merged = await pollForQueueMerge(ctx, { repo, prNumber, credential });
+  if (merged) {
+    return mergeMergedResult(merged.mergedSha, "PR merged via the merge queue");
+  }
+  return mergeParkResult("auto-merge enabled (merge queue); the merge was not confirmed within the turn \u2014 parking for a re-check.");
+}
 function scrubTranscriptSessionIds(value) {
   return value.replace(/("?(?:session_id|sessionId)"?\s*[:=]\s*"?)[A-Za-z0-9._-]+("?)/gi, "$1[redacted]$2");
 }