@senad-d/branchme 0.1.8 → 0.1.9

package/src/git.ts

@@ -24,6 +24,8 @@ import {
 import { redactSecrets } from "./redaction.ts";
 import type {
   AheadBehindCount,
+  BranchAncestryDetails,
+  BranchStatusAncestryQuery,
   BranchStatusDetails,
   ChangeBranchDetails,
   CreateBranchDetails,
@@ -157,6 +159,23 @@ export async function getGitRoot(
   return root;
 }
 
+export async function getCanonicalGitWorktreeRoot(
+  pi: Pick<ExtensionAPI, "exec">,
+  ctx: GitCommandContext,
+  signal?: AbortSignal,
+): Promise<string> {
+  const repoRoot = await getGitRoot(pi, ctx, signal);
+  if (!isAbsolute(repoRoot) || /[\p{Cc}\p{Cf}\u2028\u2029]/u.test(repoRoot)) {
+    throw new Error("Unable to verify the active worktree root: Git returned an invalid path.");
+  }
+
+  try {
+    return await realpath(repoRoot);
+  } catch {
+    throw new Error("Unable to verify the active worktree root: the path could not be resolved.");
+  }
+}
+
 export async function getCurrentBranch(
   pi: Pick<ExtensionAPI, "exec">,
   ctx: GitCommandContext,
@@ -667,12 +686,16 @@ function safeWorktreeBranchLabel(branchName: string): string {
   return JSON.stringify(safeWorktreeValue(branchName, GIT_CONTEXT_VALUE_LIMIT_CHARS));
 }
 
+export function isLosslessGitMetadata(value: string, limit: number): boolean {
+  return safeWorktreeValue(value, limit) === value;
+}
+
 export function requireLosslessWorktreeIdentity(
   value: string,
   identity: "cwd" | "branch",
 ): string {
   const limit = identity === "cwd" ? GIT_WORKTREE_PATH_LIMIT_CHARS : GIT_CONTEXT_VALUE_LIMIT_CHARS;
-  if (safeWorktreeValue(value, limit) === value) return value;
+  if (isLosslessGitMetadata(value, limit)) return value;
 
   const label = identity === "cwd" ? "canonical worktree path" : "local branch name";
   throw new Error(
@@ -775,13 +798,13 @@ function stripSingleLineTerminator(value: string): string {
   return value;
 }
 
-async function getCommonGitDirectory(
+export async function getCanonicalCommonGitDirectory(
   pi: Pick<ExtensionAPI, "exec">,
-  repoRoot: string,
+  ctx: GitCommandContext,
   signal?: AbortSignal,
 ): Promise<string> {
   const args = ["rev-parse", "--path-format=absolute", "--git-common-dir"];
-  const result = await runGit(pi, { cwd: repoRoot }, args, {
+  const result = await runGit(pi, ctx, args, {
     signal,
     timeout: GIT_STATUS_TIMEOUT_MS,
   });
@@ -791,14 +814,77 @@ async function getCommonGitDirectory(
     !isAbsolute(commonGitDir) ||
     /[\p{Cc}\p{Cf}\u2028\u2029]/u.test(commonGitDir)
   ) {
-    throw new Error("Unable to validate worktree path: Git returned an invalid common directory.");
+    throw new Error("Unable to verify repository identity: Git returned an invalid common directory.");
   }
 
   try {
     return await realpath(commonGitDir);
   } catch {
-    throw new Error("Unable to validate worktree path: Git common directory could not be resolved.");
+    throw new Error("Unable to verify repository identity: the common Git directory could not be resolved.");
+  }
+}
+
+export type GitOperationKind = "merge" | "rebase" | "cherry-pick" | "revert" | "sequencer";
+
+export interface GitOperationState {
+  active: GitOperationKind[];
+  mergeHeadPresent: boolean;
+  autoMergePresent: boolean;
+}
+
+const GIT_OPERATION_MARKERS: ReadonlyArray<readonly [path: string, operation: GitOperationKind]> = [
+  ["MERGE_HEAD", "merge"],
+  ["AUTO_MERGE", "merge"],
+  ["rebase-merge", "rebase"],
+  ["rebase-apply", "rebase"],
+  ["CHERRY_PICK_HEAD", "cherry-pick"],
+  ["REVERT_HEAD", "revert"],
+  ["sequencer", "sequencer"],
+];
+
+async function gitOperationMarkerExists(path: string): Promise<boolean> {
+  try {
+    await lstat(path);
+    return true;
+  } catch (error) {
+    if (isMissingFilesystemPath(error)) return false;
+    throw new Error("Unable to inspect repository operation state: a Git state path could not be inspected.");
+  }
+}
+
+export async function getGitOperationState(
+  pi: Pick<ExtensionAPI, "exec">,
+  ctx: GitCommandContext,
+  signal?: AbortSignal,
+): Promise<GitOperationState> {
+  const args = ["rev-parse", "--path-format=absolute"];
+  for (const [path] of GIT_OPERATION_MARKERS) args.push("--git-path", path);
+  const result = await runGit(pi, ctx, args, {
+    signal,
+    timeout: GIT_STATUS_TIMEOUT_MS,
+  });
+  const paths = stripSingleLineTerminator(result.stdout).split(/\r?\n/u);
+  if (
+    paths.length !== GIT_OPERATION_MARKERS.length ||
+    paths.some((path) => !isAbsolute(path) || /[\p{Cc}\p{Cf}\u2028\u2029]/u.test(path))
+  ) {
+    throw new Error("Unable to inspect repository operation state: Git returned invalid state paths.");
   }
+
+  const active: GitOperationKind[] = [];
+  const presentMarkers: boolean[] = [];
+  for (const [index, path] of paths.entries()) {
+    const present = await gitOperationMarkerExists(path);
+    presentMarkers.push(present);
+    if (!present) continue;
+    const operation = GIT_OPERATION_MARKERS[index][1];
+    if (!active.includes(operation)) active.push(operation);
+  }
+  return {
+    active,
+    mergeHeadPresent: presentMarkers[0] === true,
+    autoMergePresent: presentMarkers[1] === true,
+  };
 }
 
 async function prepareWorktreeCreation(
@@ -820,7 +906,11 @@ async function prepareWorktreeCreation(
     }
   }
 
-  const commonGitDir = await getCommonGitDirectory(pi, inventory.repoRoot, signal);
+  const commonGitDir = await getCanonicalCommonGitDirectory(
+    pi,
+    { cwd: inventory.repoRoot },
+    signal,
+  );
   if (pathIsInsideOrEqual(canonicalPath, commonGitDir)) {
     throw new Error("worktreePath destination cannot be inside the repository common Git directory.");
   }
@@ -1764,6 +1854,64 @@ export async function getLocalBranchCommit(
   return commit;
 }
 
+export async function requireExistingLocalBranch(
+  pi: Pick<ExtensionAPI, "exec">,
+  ctx: GitCommandContext,
+  branchName: string,
+  label: "Source" | "Target",
+  signal?: AbortSignal,
+): Promise<void> {
+  if (await localBranchExists(pi, ctx, branchName, signal)) return;
+  throw new Error(`${label} local branch '${safeGitContextValue(branchName)}' does not exist.`);
+}
+
+export async function isCommitAncestor(
+  pi: Pick<ExtensionAPI, "exec">,
+  ctx: GitCommandContext,
+  ancestorCommit: string,
+  descendantCommit: string,
+  signal?: AbortSignal,
+): Promise<boolean> {
+  if (!/^[0-9a-f]{40,64}$/iu.test(ancestorCommit) || !/^[0-9a-f]{40,64}$/iu.test(descendantCommit)) {
+    throw new Error("Ancestry verification requires two valid full commit identities.");
+  }
+
+  const args = ["merge-base", "--is-ancestor", ancestorCommit, descendantCommit];
+  const result = await runGit(pi, ctx, args, {
+    signal,
+    timeout: GIT_STATUS_TIMEOUT_MS,
+    allowFailure: true,
+  });
+  if (result.code !== 0 && result.code !== 1) throw new Error(formatGitFailure(args, result));
+  return result.code === 0;
+}
+
+export async function getLocalBranchAncestry(
+  pi: Pick<ExtensionAPI, "exec">,
+  ctx: GitCommandContext,
+  query: BranchStatusAncestryQuery,
+  signal?: AbortSignal,
+): Promise<BranchAncestryDetails> {
+  validateBranchNameInput(query.sourceBranch, "Source branch");
+  validateBranchNameInput(query.targetBranch, "Target branch");
+  await validateBranchName(pi, ctx, query.sourceBranch, signal);
+  await validateBranchName(pi, ctx, query.targetBranch, signal);
+  await requireExistingLocalBranch(pi, ctx, query.sourceBranch, "Source", signal);
+  await requireExistingLocalBranch(pi, ctx, query.targetBranch, "Target", signal);
+
+  const sourceHead = await getLocalBranchCommit(pi, ctx, query.sourceBranch, signal);
+  const targetHead = await getLocalBranchCommit(pi, ctx, query.targetBranch, signal);
+  const isAncestor = await isCommitAncestor(pi, ctx, sourceHead, targetHead, signal);
+
+  return {
+    sourceBranch: query.sourceBranch,
+    targetBranch: query.targetBranch,
+    sourceHead,
+    targetHead,
+    isAncestor,
+  };
+}
+
 export async function createLocalBranch(
   pi: Pick<ExtensionAPI, "exec">,
   ctx: GitCommandContext,

package/src/tools/branchme-tools.ts

@@ -7,7 +7,9 @@ import {
   CREATE_BRANCH_TOOL_NAME,
   CREATE_WORKTREE_TOOL_NAME,
   FETCH_BRANCH_TOOL_NAME,
+  GIT_INTEGRATION_SUMMARY_LIMIT_CHARS,
   GIT_WORKTREE_SUMMARY_LIMIT_CHARS,
+  INTEGRATE_BRANCH_TOOL_NAME,
   LIST_WORKTREES_TOOL_NAME,
   PULL_BRANCH_TOOL_NAME,
   PULL_REQUEST_TOOL_NAME,
@@ -35,6 +37,7 @@ import {
   withRepositoryMutationQueue,
 } from "../git.ts";
 import { collectGitContext, formatGitContext } from "../git-context.ts";
+import { integrateBranch } from "../git-integration.ts";
 import {
   createGitHubPullRequest,
   ensureGitHubBranchExists,
@@ -49,6 +52,7 @@ import type {
   ChangeBranchDetails,
   CreateWorktreeDetails,
   GitContextDetails,
+  IntegrateBranchDetails,
   ListWorktreesDetails,
   PullRequestDetails,
   PullRequestInput,
@@ -61,6 +65,29 @@ import type {
 
 const EmptyParametersSchema = Type.Object({}, { additionalProperties: false });
 
+const BranchStatusParametersSchema = Type.Object(
+  {
+    ancestry: Type.Optional(
+      Type.Object(
+        {
+          sourceBranch: Type.String({ minLength: 1, description: "Exact existing local source branch to verify." }),
+          targetBranch: Type.String({ minLength: 1, description: "Exact existing local target branch to verify." }),
+        },
+        { additionalProperties: false },
+      ),
+    ),
+  },
+  { additionalProperties: false },
+);
+
+const IntegrateBranchParametersSchema = Type.Object(
+  {
+    sourceBranch: Type.String({ minLength: 1, description: "Exact existing local source branch to integrate." }),
+    targetBranch: Type.String({ minLength: 1, description: "Exact existing local target branch already checked out in the clean control worktree." }),
+  },
+  { additionalProperties: false },
+);
+
 const CreateBranchParametersSchema = Type.Object(
   {
     branchName: Type.String({ minLength: 1, description: "Name of the new branch to create from current HEAD." }),
@@ -224,6 +251,56 @@ export function formatRemoveWorktree(details: RemoveWorktreeDetails): string {
   return `Removed linked worktree directory ${path}. Verified it is no longer registered and retained local branch ${branch} at HEAD ${shortCommit(details.handoff.head)}; the removed cwd is not ready for handoff.`;
 }
 
+function integrationConflictOmissionLine(omitted: number): string {
+  return `${omitted} conflict path${omitted === 1 ? "" : "s"} omitted.`;
+}
+
+function formatIntegrationConflict(details: Extract<IntegrateBranchDetails, { status: "conflict" }>): string {
+  const source = safeWorktreeFormatValue(details.request.sourceBranch, WORKTREE_FORMAT_BRANCH_LIMIT_CHARS);
+  const target = safeWorktreeFormatValue(details.request.targetBranch, WORKTREE_FORMAT_BRANCH_LIMIT_CHARS);
+  const lines = [
+    `integrate_branch found conflicts while integrating ${source} into ${target}; the merge was automatically aborted and exact restoration was verified at target HEAD ${shortCommit(details.verified.heads.after.targetHead)}.`,
+    "Conflict paths:",
+  ];
+  let omitted = details.conflict.omitted;
+
+  for (const [index, entry] of details.conflict.paths.entries()) {
+    const path = safeWorktreeFormatValue(entry.path, WORKTREE_FORMAT_PATH_LIMIT_CHARS);
+    const line = `- ${path}`;
+    const remaining = details.conflict.paths.length - index - 1;
+    const candidateOmitted = details.conflict.omitted + remaining;
+    const candidate = [
+      ...lines,
+      line,
+      ...(candidateOmitted > 0 ? [integrationConflictOmissionLine(candidateOmitted)] : []),
+    ].join("\n");
+    if (candidate.length > GIT_INTEGRATION_SUMMARY_LIMIT_CHARS) {
+      omitted += details.conflict.paths.length - index;
+      break;
+    }
+    lines.push(line);
+  }
+
+  if (omitted > 0) lines.push(integrationConflictOmissionLine(omitted));
+  return lines.join("\n");
+}
+
+export function formatIntegrateBranch(details: IntegrateBranchDetails): string {
+  if (details.status === "conflict") return formatIntegrationConflict(details);
+
+  const source = safeWorktreeFormatValue(details.request.sourceBranch, WORKTREE_FORMAT_BRANCH_LIMIT_CHARS);
+  const target = safeWorktreeFormatValue(details.request.targetBranch, WORKTREE_FORMAT_BRANCH_LIMIT_CHARS);
+  const beforeTarget = shortCommit(details.verified.heads.before.targetHead);
+  const afterTarget = shortCommit(details.verified.heads.after.targetHead);
+  if (details.status === "already_integrated") {
+    return `integrate_branch verified ${source} was already integrated into ${target}; no merge ran and target HEAD remained ${afterTarget}.`;
+  }
+  if (details.status === "fast_forward") {
+    return `integrate_branch fast-forwarded ${target} from ${beforeTarget} to ${afterTarget}, integrating ${source}.`;
+  }
+  return `integrate_branch created and verified a merge commit ${afterTarget} on ${target} from previous target ${beforeTarget} and source ${source}.`;
+}
+
 const PULL_REQUEST_INPUT_FIELDS: PullRequestInputField[] = ["headBranch", "baseBranch", "title", "body", "draft"];
 
 interface ResolvedPullRequestBranches {
@@ -381,16 +458,18 @@ export function registerBranchMeTools(pi: Pick<ExtensionAPI, "registerTool" | "e
   pi.registerTool({
     name: BRANCH_STATUS_TOOL_NAME,
     label: "Branch Status",
-    description: "branch_status explicitly refreshes the current Git repository snapshot, including branch, working tree, unstaged changes, related pull request, and recent commits. branch_status is read-only and never mutates files, Git state, or GitHub state.",
-    promptSnippet: "branch_status: explicitly refresh current-repository branch, working tree, changes, related PR, and recent commits without mutation",
+    description: "branch_status explicitly refreshes the current Git repository snapshot and can optionally verify whether one captured local branch commit is an ancestor of another. branch_status is read-only and never mutates files, Git state, or GitHub state.",
+    promptSnippet: "branch_status: explicitly refresh current-repository Git state and optionally verify targeted local-branch ancestry without mutation",
     promptGuidelines: [
       "Use the automatic Git context for start-of-run questions; call branch_status only for an explicit refresh or after Git state changes during the current run.",
       "Use branch_status as a read-only refresh; branch_status never mutates files, Git state, or GitHub state.",
+      "Use targeted branch_status ancestry verification only after integrate_branch completes; do not issue branch_status in the same parallel tool batch as integrate_branch.",
     ],
-    parameters: EmptyParametersSchema,
-    async execute(_toolCallId, _params, signal, _onUpdate, ctx) {
+    parameters: BranchStatusParametersSchema,
+    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
       const details = await collectGitContext(pi, ctx, {
         signal,
+        ancestry: params.ancestry,
         env: options.env,
         fetchImpl: options.fetchImpl,
       });
@@ -514,6 +593,29 @@ export function registerBranchMeTools(pi: Pick<ExtensionAPI, "registerTool" | "e
     },
   });
 
+  pi.registerTool({
+    name: INTEGRATE_BRANCH_TOOL_NAME,
+    label: "Integrate Branch",
+    description: "integrate_branch verifies and merges one exact existing local source branch into one exact existing local target branch from the current clean control worktree, returning an already-integrated, fast-forward, merge-commit, or automatically aborted conflict result. integrate_branch never fetches or pushes.",
+    promptSnippet: "integrate_branch: merge an exact local source branch into the checked-out clean local target with verified outcomes and automatic conflict abort",
+    promptGuidelines: [
+      "Use integrate_branch only when the user explicitly wants one exact existing local source branch integrated into one exact existing local target branch.",
+      "Before integrate_branch, require the current clean control worktree to already have targetBranch checked out; integrate_branch never switches branches, stashes, or discards changes.",
+      "Use integrate_branch only after local refs already contain the commits to integrate; integrate_branch never fetches or pushes.",
+      "Call integrate_branch by itself and wait for it to complete; never batch integrate_branch with other Git mutations.",
+      "After integrate_branch completes, run any targeted branch_status ancestry proof separately; never place integrate_branch and branch_status in the same parallel tool batch.",
+      "A conflict result from integrate_branch means the merge was automatically aborted and restoration was verified; semantic conflict analysis belongs to a separate delegated workflow, not integrate_branch.",
+    ],
+    parameters: IntegrateBranchParametersSchema,
+    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+      const details = await integrateBranch(pi, ctx, params, signal);
+      return {
+        content: [{ type: "text", text: formatIntegrateBranch(details) }],
+        details,
+      };
+    },
+  });
+
   pi.registerTool({
     name: PUSH_BRANCH_TOOL_NAME,
     label: "Push Branch",

package/src/types.ts

@@ -20,6 +20,20 @@ export interface WorkingTreeDetails {
   untracked: number;
 }
 
+export interface BranchStatusAncestryQuery {
+  sourceBranch: string;
+  targetBranch: string;
+}
+
+export interface BranchStatusToolInput {
+  ancestry?: BranchStatusAncestryQuery;
+}
+
+export interface IntegrateBranchToolInput {
+  sourceBranch: string;
+  targetBranch: string;
+}
+
 export type CreateWorktreeMode = "new" | "existing";
 
 export type ListWorktreesToolInput = Record<string, never>;
@@ -165,6 +179,12 @@ export type RelatedPullRequest =
   | { status: "none" }
   | { status: "unavailable"; reason: string };
 
+export interface BranchAncestryDetails extends BranchStatusAncestryQuery {
+  sourceHead: string;
+  targetHead: string;
+  isAncestor: boolean;
+}
+
 export interface BranchStatusDetails {
   repoRoot: string;
   currentBranch: string | null;
@@ -173,6 +193,7 @@ export interface BranchStatusDetails {
   hasChanges: boolean;
   ahead: number | null;
   behind: number | null;
+  ancestry?: BranchAncestryDetails;
   warnings?: string[];
   githubRepository?: GitHubRepository;
 }
@@ -239,6 +260,100 @@ export interface PushBranchDetails {
   output: string;
 }
 
+export type IntegrateBranchStatus = "already_integrated" | "fast_forward" | "merge_commit" | "conflict";
+
+export interface IntegrateBranchHeads {
+  sourceHead: string;
+  targetHead: string;
+}
+
+export interface IntegrateBranchRepositoryVerification {
+  worktreeRoot: string;
+  canonicalCommonGitDirectory: string;
+  identityPreserved: true;
+}
+
+export interface IntegrateBranchControlWorktreeVerification {
+  targetBranch: string;
+  currentBranchPreserved: true;
+  cleanBefore: true;
+  cleanAfter: true;
+  operationStateAbsentBefore: true;
+  operationStateAbsentAfter: true;
+}
+
+export interface IntegrateBranchFinalAncestryProof {
+  sourceHead: string;
+  previousTargetHead: string;
+  targetHead: string;
+  sourceIsAncestorOfTarget: boolean;
+  previousTargetIsAncestorOfTarget: boolean;
+}
+
+export interface IntegrateBranchVerification {
+  repository: IntegrateBranchRepositoryVerification;
+  controlWorktree: IntegrateBranchControlWorktreeVerification;
+  heads: {
+    before: IntegrateBranchHeads;
+    after: IntegrateBranchHeads;
+  };
+  finalAncestry: IntegrateBranchFinalAncestryProof;
+}
+
+export interface IntegrateBranchDetailsBase {
+  action: "integrate_branch";
+  request: IntegrateBranchToolInput;
+  verified: IntegrateBranchVerification;
+}
+
+export interface IntegrateBranchAlreadyIntegratedDetails extends IntegrateBranchDetailsBase {
+  status: "already_integrated";
+  mergeExecuted: false;
+}
+
+export interface IntegrateBranchFastForwardDetails extends IntegrateBranchDetailsBase {
+  status: "fast_forward";
+  mergeExecuted: true;
+}
+
+export interface IntegrateBranchMergeCommitDetails extends IntegrateBranchDetailsBase {
+  status: "merge_commit";
+  mergeExecuted: true;
+}
+
+export interface IntegrateBranchConflictPathEntry {
+  /** Exact repository-relative identity; human-readable renderers must sanitize a separate display copy. */
+  path: string;
+}
+
+export interface IntegrateBranchConflictDetails extends IntegrateBranchDetailsBase {
+  status: "conflict";
+  mergeExecuted: true;
+  conflict: {
+    paths: IntegrateBranchConflictPathEntry[];
+    omitted: number;
+    abort: {
+      attempted: true;
+      succeeded: true;
+    };
+    restoration: {
+      verified: true;
+      repositoryIdentityPreserved: true;
+      controlWorktreeBranchPreserved: true;
+      sourceHeadPreserved: true;
+      targetHeadRestored: true;
+      operationStateCleared: true;
+      cleanControlWorktree: true;
+    };
+  };
+}
+
+export type IntegrateBranchDetails =
+  | IntegrateBranchAlreadyIntegratedDetails
+  | IntegrateBranchFastForwardDetails
+  | IntegrateBranchMergeCommitDetails
+  | IntegrateBranchConflictDetails;
+
 export interface PullRequestDetails {
   repository: GitHubRepository;
   number: number;

package/src/ui/branchme-panel.ts

@@ -24,14 +24,14 @@ type PanelCell =
       preserveLeading?: boolean;
     };
 
-export type BranchMePanelSection = "status" | "workflow" | "worktrees";
+export type BranchMePanelSection = "status" | "workflow" | "integration" | "worktrees";
 
 const NARROW_MIN_WIDTH = 24;
 const WIDE_MIN_WIDTH = 72;
 const MAX_PANEL_WIDTH = 96;
 const MAX_PANEL_HEIGHT = 16;
 const BODY_HEIGHT = 9;
-const PANEL_SECTIONS: BranchMePanelSection[] = ["status", "workflow", "worktrees"];
+const PANEL_SECTIONS: BranchMePanelSection[] = ["status", "workflow", "integration", "worktrees"];
 const ANSI_RESET = "\u001b[0m";
 
 function truncateVisible(value: string, width: number, ellipsis = "…", pad = false): string {
@@ -144,7 +144,7 @@ function statusDetailRow(label: string, value: string): PanelCell {
 }
 
 function workflowDetailRow(tool: string, description: string): PanelCell {
-  return layoutCell(`  ${tool.padEnd(16, " ")}-> ${sanitize(description)}`);
+  return layoutCell(`  ${tool.padEnd(17, " ")}-> ${sanitize(description)}`);
 }
 
 function sectionTitle(section: BranchMePanelSection): string {
@@ -153,6 +153,8 @@ function sectionTitle(section: BranchMePanelSection): string {
       return "STATUS";
     case "workflow":
       return "WORKFLOW";
+    case "integration":
+      return "INTEGRATION";
     case "worktrees":
       return "WORKTREES";
   }
@@ -180,6 +182,8 @@ function sectionFooter(section: BranchMePanelSection, data: BranchMePanelData):
       return "status • current repository only • tools perform actions";
     case "workflow":
       return "workflow • inspect → change → fetch/pull/rebase → create → push → PR";
+    case "integration":
+      return "integration • local refs • clean target • conflicts auto-abort";
     case "worktrees":
       return "worktrees • create → handoff cwd → next session • remove retains branch";
   }
@@ -208,6 +212,15 @@ function sectionRows(section: BranchMePanelSection, data: BranchMePanelData): Pa
         workflowDetailRow("push_branch", "current branch"),
         workflowDetailRow("pull_request", "after push"),
       ];
+    case "integration":
+      return [
+        heading("INTEGRATION"),
+        workflowDetailRow("integrate_branch", "exact local source -> target"),
+        workflowDetailRow("control target", "checked out + clean"),
+        workflowDetailRow("remote effects", "never fetch or push"),
+        workflowDetailRow("conflict", "automatic verified abort"),
+        workflowDetailRow("semantic intent", "separate developer workflow"),
+      ];
     case "worktrees":
       return [
         heading("WORKTREES"),