@gitkraken/compose-tools 0.2.0 → 0.3.0

package/dist/tasks/compose-group/prompt.js

@@ -1,4 +1,4 @@
-import{groupingResultSchema as e}from"../group/schema.js";import{z as t}from"zod";const n=JSON.stringify(t.toJSONSchema(e),null,2),r=`
+import{hunkContentForPrompt as e}from"../utils/redact.js";import{groupingResultSchema as t}from"../group/schema.js";import{z as n}from"zod";const r=JSON.stringify(n.toJSONSchema(t),null,2),i=`
 In addition to the \`branches\` field, include an \`analysis\` field at the top level:
 
 \`\`\`json
@@ -10,15 +10,15 @@ In addition to the \`branches\` field, include an \`analysis\` field at the top
   "branches": [ ... ]
 }
 \`\`\`
-`,i=`5. Write a full commit message for each commit containing both a summary and a description:
+`,a=`5. Write a full commit message for each commit containing both a summary and a description:
    - **Summary** (first line): concise, 50 chars max, third-person singular present tense ("Fixes", "Adds", "Improves"). This line stands alone as the commit subject.
    - **Blank line**: mandatory separator between summary and description.
    - **Description** (body): one or more lines explaining *why* this change was made, not *what* it does. Focus on motivation, trade-offs, or context a reviewer needs. For non-trivial changes, always include a description — don't leave it at just the summary.
-   - Informal yet professional tone.`;function a(e,t=`branches`,n,r,i){return i?t===`commits`?u(e,n):d(e,n):t===`commits`?o(e,n,r):s(e,n,r)}function o(e,t,a){let o=e?.promptFragment?`5. Write a commit message for each commit following the repository's conventions (see below).
+   - Informal yet professional tone.`;function o(e,t=`branches`,n,r,i){return i?t===`commits`?d(e,n):f(e,n):t===`commits`?s(e,n,r):c(e,n,r)}function s(e,t,n){let o=e?.promptFragment?`5. Write a commit message for each commit following the repository's conventions (see below).
 6. Write a detailed explanation for each commit as if explaining to a reviewer.
 
-${e.promptFragment}`:`${i}
-6. Write a detailed explanation for each commit as if explaining to a reviewer`,s=l(t?.commitGranularity);return`You are an advanced AI programming assistant tasked with analyzing and organizing code changes into commits.
+${e.promptFragment}`:`${a}
+6. Write a detailed explanation for each commit as if explaining to a reviewer`,s=u(t?.commitGranularity);return`You are an advanced AI programming assistant tasked with analyzing and organizing code changes into commits.
 
 ## Critical constraints (output is rejected if violated)
 
@@ -29,14 +29,14 @@ ${e.promptFragment}`:`${i}
 
 Before producing the \`<output>\` tag, do a self-check: count the total number of hunk indices across every commit's \`hunks\` array. That count MUST equal the input hunk count. If it does not match, you have either duplicated or skipped a hunk — find and fix it before outputting.
 
-${a?`## Step 1: Analysis`:`## Step 1: Internal Analysis`}
+${n?`## Step 1: Analysis`:`## Step 1: Internal Analysis`}
 
 Before grouping, analyze the changes to understand:
 - **Concerns** — what distinct themes, features, or purposes exist across the hunks
 - **Dependencies** — which hunks provide things (define functions, types, files) that other hunks consume (import, call, reference)
 - **Ordering constraints** — if hunk A defines something hunk B uses, they should be in the same commit or A's commit should come before B's
 
-${a?"Output this analysis as a JSON field named `analysis` alongside your `branches` field. The `analysis` field should contain:\n- `concerns`: array of strings, each describing a distinct theme or feature in the changes\n- `key_dependencies`: array of strings, each describing an ordering dependency between concerns":`Do NOT output this analysis. Use it internally to inform your grouping decisions.`}
+${n?"Output this analysis as a JSON field named `analysis` alongside your `branches` field. The `analysis` field should contain:\n- `concerns`: array of strings, each describing a distinct theme or feature in the changes\n- `key_dependencies`: array of strings, each describing an ordering dependency between concerns":`Do NOT output this analysis. Use it internally to inform your grouping decisions.`}
 
 ## Step 2: Group hunks into commits
 
@@ -50,16 +50,16 @@ ${s}
 Output your organization as JSON inside a <output> tag matching this schema:
 
 \`\`\`json
-${n}
+${r}
 \`\`\`
-${a?r:``}
+${n?i:``}
 Wrap all commits in a single branch object with id "default", name "", title "", and description "".
 
-Return only the <output> tag and no other text.`}function s(e,t,a){let o=e?.promptFragment?`5. Write a commit message for each commit following the repository's conventions (see below).
+Return only the <output> tag and no other text.`}function c(e,t,n){let o=e?.promptFragment?`5. Write a commit message for each commit following the repository's conventions (see below).
 6. Write a detailed explanation for each commit as if explaining to a reviewer.
 
-${e.promptFragment}`:`${i}
-6. Write a detailed explanation for each commit as if explaining to a reviewer`,s=c(t?.branchSplitting,e),u=l(t?.commitGranularity);return`You are an advanced AI programming assistant tasked with analyzing and organizing code changes into commits and branches.
+${e.promptFragment}`:`${a}
+6. Write a detailed explanation for each commit as if explaining to a reviewer`,s=l(t?.branchSplitting,e),c=u(t?.commitGranularity);return`You are an advanced AI programming assistant tasked with analyzing and organizing code changes into commits and branches.
 
 ## Critical constraints (output is rejected if violated)
 
@@ -70,7 +70,7 @@ ${e.promptFragment}`:`${i}
 
 Before producing the \`<output>\` tag, do a self-check: count the total number of hunk indices across every commit's \`hunks\` array (across every branch). That count MUST equal the input hunk count. If it does not match, you have either duplicated or skipped a hunk — find and fix it before outputting.
 
-${a?`## Step 1: Analysis`:`## Step 1: Internal Analysis`}
+${n?`## Step 1: Analysis`:`## Step 1: Internal Analysis`}
 
 Before grouping, analyze the changes to understand:
 - **Concerns** — what distinct themes, features, or purposes exist across the hunks
@@ -78,7 +78,7 @@ Before grouping, analyze the changes to understand:
 - **Ordering constraints** — if hunk A defines something hunk B uses, they should be in the same commit or A's commit should come before B's
 - **Merge-order preference** — even if two concerns compile independently, would merging one without the other be confusing or incomplete?
 
-${a?"Output this analysis as a JSON field named `analysis` alongside your `branches` field. The `analysis` field should contain:\n- `concerns`: array of strings, each describing a distinct theme or feature in the changes\n- `key_dependencies`: array of strings, each describing an ordering dependency between concerns":`Do NOT output this analysis. Use it internally to inform your grouping decisions.`}
+${n?"Output this analysis as a JSON field named `analysis` alongside your `branches` field. The `analysis` field should contain:\n- `concerns`: array of strings, each describing a distinct theme or feature in the changes\n- `key_dependencies`: array of strings, each describing an ordering dependency between concerns":`Do NOT output this analysis. Use it internally to inform your grouping decisions.`}
 
 ## Step 2: Organize hunks into commits and branches
 
@@ -92,7 +92,7 @@ Your job has two levels:
 1. Group hunks into logical units that make sense together and can be applied atomically
 2. Ensure each commit is self-contained and atomic
 ${o}
-${u}
+${c}
 
 ### Branch guidelines
 
@@ -103,14 +103,14 @@ ${s}
 Output your organization as JSON inside a <output> tag matching this schema:
 
 \`\`\`json
-${n}
+${r}
 \`\`\`
-${a?r:``}
-Return only the <output> tag and no other text.`}function c(e,t){let n=`Each branch must have a descriptive name, a short PR-style title (under 72 characters, imperative mood), and at least one commit.`,r=`- Each commit belongs to exactly one branch.
+${n?i:``}
+Return only the <output> tag and no other text.`}function l(e,t){let n=`Each branch must have a descriptive name, a short PR-style title (under 72 characters, imperative mood), and at least one commit.`,r=`- Each commit belongs to exactly one branch.
 ${t?.promptFragment?`- ${n} Follow the repository's branch naming conventions (see above).`:`- ${n}`}
-- Changes addressing the same pattern across different files belong in ONE branch.`,i=`- Consider merge-order preference, not just code dependencies. Even if two concerns compile independently, they may need to be in the same branch if merging one without the other would be confusing or incomplete.`;return e===`conservative`?`${r}\n- Default to a single branch. Only create multiple branches when concerns are completely unrelated.\n${i}\n- When in doubt, use fewer branches.`:e===`aggressive`?`${r}\n- Create separate branches for each distinct concern.\n${i}\n- Prefer more branches over fewer.`:`${r}\n- Create separate branches when concerns are genuinely independent — meaning a reviewer would gain nothing from seeing them together.\n- Keep changes in the same branch when they form a coherent story.\n${i}\n- When in doubt: "Would a reviewer want to see these together?"`}function l(e){return e===`consolidated`?`
+- Changes addressing the same pattern across different files belong in ONE branch.`,i=`- Consider merge-order preference, not just code dependencies. Even if two concerns compile independently, they may need to be in the same branch if merging one without the other would be confusing or incomplete.`;return e===`conservative`?`${r}\n- Default to a single branch. Only create multiple branches when concerns are completely unrelated.\n${i}\n- When in doubt, use fewer branches.`:e===`aggressive`?`${r}\n- Create separate branches for each distinct concern.\n${i}\n- Prefer more branches over fewer.`:`${r}\n- Create separate branches when concerns are genuinely independent — meaning a reviewer would gain nothing from seeing them together.\n- Keep changes in the same branch when they form a coherent story.\n${i}\n- When in doubt: "Would a reviewer want to see these together?"`}function u(e){return e===`consolidated`?`
 Prefer fewer, larger commits. Combine related changes into a single commit when they serve the same purpose.`:e===`granular`?`
-Prefer more, smaller commits. Each distinct change should be its own commit.`:``}function u(e,t){return`Organize code hunks into clean, atomic commits.
+Prefer more, smaller commits. Each distinct change should be its own commit.`:``}function d(e,t){return`Organize code hunks into clean, atomic commits.
 
 ## Rules
 
@@ -121,7 +121,7 @@ Prefer more, smaller commits. Each distinct change should be its own commit.`:``
 5. ${e?.promptFragment?`Write commit messages following the repository's conventions (see below). Write a one-sentence explanation per commit.
 
 ${e.promptFragment}`:`Write commit messages: first line under 50 chars, imperative mood ("Add", "Fix", "Update"). Write a one-sentence explanation per commit.`}
-${l(t?.commitGranularity)}
+${u(t?.commitGranularity)}
 
 ## Output
 
@@ -131,9 +131,9 @@ JSON inside <output> tags. Use one branch with id "default", name "", title "",
 {"branches":[{"id":"default","name":"","title":"","description":"","commits":[{"id":"commit-1","message":"Add feature X","explanation":"Brief reason.","hunks":[0,1,2]}]}]}
 \`\`\`
 
-CRITICAL: Every hunk index must appear exactly once across all commits. Every commit must contain at least one hunk. Missing hunks, duplicate hunks, or empty commits will fail validation. Return only the <output> tag.`}function d(e,t){let n=e?.promptFragment?`Write commit messages following the repository's conventions (see below). Write a one-sentence explanation per commit.
+CRITICAL: Every hunk index must appear exactly once across all commits. Every commit must contain at least one hunk. Missing hunks, duplicate hunks, or empty commits will fail validation. Return only the <output> tag.`}function f(e,t){let n=e?.promptFragment?`Write commit messages following the repository's conventions (see below). Write a one-sentence explanation per commit.
 
-${e.promptFragment}`:`Write commit messages: first line under 50 chars, third-person singular present tense ("Fixes", "Adds", "Improves"). Write a one-sentence explanation per commit.`,r=c(t?.branchSplitting,e);return`Organize code hunks into clean, atomic commits and branches.
+${e.promptFragment}`:`Write commit messages: first line under 50 chars, third-person singular present tense ("Fixes", "Adds", "Improves"). Write a one-sentence explanation per commit.`,r=l(t?.branchSplitting,e);return`Organize code hunks into clean, atomic commits and branches.
 
 ## Commit rules
 
@@ -142,7 +142,7 @@ ${e.promptFragment}`:`Write commit messages: first line under 50 chars, third-pe
 3. Each commit needs a unique ID (e.g., "commit-1", "commit-2").
 4. Every commit must have at least one hunk. No empty commits.
 5. ${n}
-${l(t?.commitGranularity)}
+${u(t?.commitGranularity)}
 
 ## Branch guidelines
 
@@ -158,11 +158,11 @@ JSON inside <output> tags. Each branch needs a unique ID and non-empty name.
 
 CRITICAL: Every hunk index must appear exactly once across all commits in all branches. Every commit must contain at least one hunk. Missing hunks, duplicate hunks, or empty commits will fail validation. Each branch must have a unique ID and non-empty name.
 
-Return only the <output> tag and no other text.`}function f(e){let{hunks:t,commitMessages:n,commitOrder:r,branchName:i,baseBranch:a,issueUrl:o,pullRequestUrl:s,instructions:c,condensed:l}=e,u=JSON.stringify(l?t.map(e=>({index:e.index,fileName:e.fileName,hunkHeader:e.hunkHeader,additions:e.additions,deletions:e.deletions,...e.isBinary?{isBinary:!0}:{},...e.isRename?{isRename:!0}:{},...e.originalFileName?{originalFileName:e.originalFileName}:{}})):t.map(e=>({index:e.index,fileName:e.fileName,hunkHeader:e.hunkHeader,content:e.content,...e.isBinary?{isBinary:!0}:{},...e.isRename?{isRename:!0}:{},...e.originalFileName?{originalFileName:e.originalFileName}:{}}))),d=`Organize these ${t.length} code hunks (indices 0 to ${t.length-1}) into commits. Every index must appear exactly once.
+Return only the <output> tag and no other text.`}function p(t){let{hunks:n,commitMessages:r,commitOrder:i,branchName:a,baseBranch:o,issueUrl:s,pullRequestUrl:c,instructions:l,condensed:u,redactHunkContent:d}=t,f=JSON.stringify(u?n.map(e=>({index:e.index,fileName:e.fileName,hunkHeader:e.hunkHeader,additions:e.additions,deletions:e.deletions,...e.isBinary?{isBinary:!0}:{},...e.isRename?{isRename:!0}:{},...e.originalFileName?{originalFileName:e.originalFileName}:{}})):n.map(t=>({index:t.index,fileName:t.fileName,hunkHeader:t.hunkHeader,content:e(t,d),...t.isBinary?{isBinary:!0}:{},...t.isRename?{isRename:!0}:{},...t.originalFileName?{originalFileName:t.originalFileName}:{}}))),p=`Organize these ${n.length} code hunks (indices 0 to ${n.length-1}) into commits. Every index must appear exactly once.
 
 <hunks>
-${u}
-</hunks>`,f=[];return i&&f.push(`Branch: ${i}`),a&&f.push(`Base: ${a}`),o&&f.push(`Issue: ${o}`),s&&f.push(`PR: ${s}`),f.length>0&&(d+=`\n\nContext:\n${f.join(`
-`)}`),n?.length&&(d+=`\n\nOriginal commit messages (match their style):\n<commit_messages>\n${JSON.stringify(n)}\n</commit_messages>`),r?.length&&(d+=`\n\nOriginal commit order:\n${JSON.stringify(r)}`),c&&(d+=`\n\nAdditional instructions:\n${c}`),d+=`
+${f}
+</hunks>`,m=[];return a&&m.push(`Branch: ${a}`),o&&m.push(`Base: ${o}`),s&&m.push(`Issue: ${s}`),c&&m.push(`PR: ${c}`),m.length>0&&(p+=`\n\nContext:\n${m.join(`
+`)}`),r?.length&&(p+=`\n\nOriginal commit messages (match their style):\n<commit_messages>\n${JSON.stringify(r)}\n</commit_messages>`),i?.length&&(p+=`\n\nOriginal commit order:\n${JSON.stringify(i)}`),l&&(p+=`\n\nAdditional instructions:\n${l}`),p+=`
 
-Return only the <output> tag and no other text.`,d}export{a as buildComposeGroupSystemPrompt,f as buildComposeGroupUserPrompt};
+Return only the <output> tag and no other text.`,p}export{o as buildComposeGroupSystemPrompt,p as buildComposeGroupUserPrompt};

package/dist/tasks/compose-group/types.d.ts

@@ -2,6 +2,7 @@ import { ProgressEvent, TokenUsage } from "../../ai/types.js";
 import { ComposeHunk, PromptOverride } from "../types.js";
 import { ConventionDescriptor } from "../../git/utils/conventions.js";
 import { OnAfterModelCall, OnBeforeModelCall, OnBeforePrompt } from "../ai-loop.js";
+import { RedactHunkContent } from "../utils/redact.js";
 import { GroupingResult, GroupingStrategy } from "../group/types.js";
 import { ComposeSession } from "../session.js";
 import { AiModelPort } from "@gitkraken/shared-tools";
@@ -37,6 +38,8 @@ interface ComposeGroupInput {
   lightweight?: boolean;
   /** When true, sends only hunk metadata (fileName, hunkHeader, counts) without diff content. */
   condensed?: boolean;
+  /** No-op when `condensed: true`. See {@link RedactHunkContent}. */
+  redactHunkContent?: RedactHunkContent;
   model: AiModelPort;
   /** Prior session to resume from. When `completedSteps.composeGroup` is present, skip the AI call. */
   session?: ComposeSession;

package/dist/tasks/group/group.js

@@ -1 +1 @@
-import{TaskInputError as e}from"../../errors/task.js";import{runAiLoop as t}from"../ai-loop.js";import{applyUserPromptOverride as n}from"../types.js";import{validateGroupResponse as r}from"./validator.js";import{buildGroupContinuationPrompt as i,buildGroupSystemPrompt as a,buildGroupUserPrompt as o}from"./prompt.js";async function s(s){let c=s.hunks,l=s.mode??`branches`;if((!c||c.length===0)&&!s.session)throw new e(`No hunks provided: supply 'hunks' or run analyze() first with a session`);if(s.session?.completedSteps.group)return{result:s.session.completedSteps.group,session:s.session,attempts:0,durationMs:0,callIds:[]};let u=n(s.session?i(s,l):o({hunks:c,commitMessages:s.commitMessages,instructions:s.instructions,mode:l}),s.promptOverride),d=c?.length??s.session?.completedSteps.analyze?.hunkAnnotations.length??0;if(d===0)throw new e(`Cannot validate grouping: no hunk count available from input or session`);let f=await t({model:s.model,systemPrompt:s.session?void 0:s.promptOverride?.system??a(s.conventions,l,s.strategy),userPrompt:u,session:s.session,maxRetries:s.maxRetries,maxTokens:s.maxTokens,onProgress:s.onProgress,cancellation:s.cancellation,onBeforeModelCall:s.onBeforeModelCall,onAfterModelCall:s.onAfterModelCall,onBeforePrompt:s.onBeforePrompt,validate:e=>r(e,d,l,s.existingBranchNames),taskName:`group`}),p=s.session?.completedSteps??{},m={...f.session,completedSteps:{...p,group:f.result}};return{result:f.result,session:m,usage:f.usage,attempts:f.attempts,durationMs:f.durationMs,callIds:f.callIds}}export{s as group};
+import{TaskInputError as e}from"../../errors/task.js";import{runAiLoop as t}from"../ai-loop.js";import{applyUserPromptOverride as n}from"../types.js";import{validateGroupResponse as r}from"./validator.js";import{buildGroupContinuationPrompt as i,buildGroupSystemPrompt as a,buildGroupUserPrompt as o}from"./prompt.js";async function s(s){let c=s.hunks,l=s.mode??`branches`;if((!c||c.length===0)&&!s.session)throw new e(`No hunks provided: supply 'hunks' or run analyze() first with a session`);if(s.session?.completedSteps.group)return{result:s.session.completedSteps.group,session:s.session,attempts:0,durationMs:0,callIds:[]};let u=n(s.session?i(s,l):o({hunks:c,commitMessages:s.commitMessages,instructions:s.instructions,mode:l,redactHunkContent:s.redactHunkContent}),s.promptOverride),d=c?.length??s.session?.completedSteps.analyze?.hunkAnnotations.length??0;if(d===0)throw new e(`Cannot validate grouping: no hunk count available from input or session`);let f=await t({model:s.model,systemPrompt:s.session?void 0:s.promptOverride?.system??a(s.conventions,l,s.strategy),userPrompt:u,session:s.session,maxRetries:s.maxRetries,maxTokens:s.maxTokens,onProgress:s.onProgress,cancellation:s.cancellation,onBeforeModelCall:s.onBeforeModelCall,onAfterModelCall:s.onAfterModelCall,onBeforePrompt:s.onBeforePrompt,validate:e=>r(e,d,l,s.existingBranchNames),taskName:`group`}),p=s.session?.completedSteps??{},m={...f.session,completedSteps:{...p,group:f.result}};return{result:f.result,session:m,usage:f.usage,attempts:f.attempts,durationMs:f.durationMs,callIds:f.callIds}}export{s as group};

package/dist/tasks/group/prompt.d.ts

@@ -1,5 +1,6 @@
 import { ComposeHunk } from "../types.js";
 import { ConventionDescriptor } from "../../git/utils/conventions.js";
+import { RedactHunkContent } from "../utils/redact.js";
 import { GroupInput, GroupingStrategy } from "./types.js";
 
 //#region src/tasks/group/prompt.d.ts
@@ -9,6 +10,7 @@ declare function buildGroupUserPrompt(params: {
   commitMessages?: string[];
   instructions?: string;
   mode?: 'commits' | 'branches';
+  redactHunkContent?: RedactHunkContent;
 }): string;
 declare function buildGroupContinuationPrompt(input: GroupInput, mode: 'commits' | 'branches'): string;
 //#endregion

package/dist/tasks/group/prompt.js

@@ -1,8 +1,8 @@
-import{groupingResultSchema as e}from"./schema.js";import{z as t}from"zod";const n=JSON.stringify(t.toJSONSchema(e),null,2),r=`5. Write a full commit message for each commit containing both a summary and a description:
+import{hunkContentForPrompt as e}from"../utils/redact.js";import{groupingResultSchema as t}from"./schema.js";import{z as n}from"zod";const r=JSON.stringify(n.toJSONSchema(t),null,2),i=`5. Write a full commit message for each commit containing both a summary and a description:
    - **Summary** (first line): concise, 50 chars max, third-person singular present tense ("Fixes", "Adds", "Improves"). This line stands alone as the commit subject.
    - **Blank line**: mandatory separator between summary and description.
    - **Description** (body): one or more lines explaining *why* this change was made, not *what* it does. Focus on motivation, trade-offs, or context a reviewer needs. For non-trivial changes, always include a description — don't leave it at just the summary.
-   - Informal yet professional tone.`,i=`Each branch must have a descriptive name, a short PR-style title (under 72 characters, imperative mood), and at least one commit.`;function a(e,t=`branches`,n){return t===`commits`?o(e,n):s(e,n)}function o(e,t){return`You are an advanced AI programming assistant tasked with organizing code changes into commits. You will be working with individual code hunks.
+   - Informal yet professional tone.`,a=`Each branch must have a descriptive name, a short PR-style title (under 72 characters, imperative mood), and at least one commit.`;function o(e,t=`branches`,n){return t===`commits`?s(e,n):c(e,n)}function s(e,t){return`You are an advanced AI programming assistant tasked with organizing code changes into commits. You will be working with individual code hunks.
 
 ## Critical constraints (output is rejected if violated)
 
@@ -20,25 +20,25 @@ Before producing the \`<output>\` tag, do a self-check: count the total number o
 ${e?.promptFragment?`5. Write a commit message for each commit following the repository's conventions (see below).
 6. Write a detailed explanation for each commit as if explaining to a reviewer.
 
-${e.promptFragment}`:`${r}
+${e.promptFragment}`:`${i}
 6. Write a detailed explanation for each commit as if explaining to a reviewer`}
-${l(t?.commitGranularity)}
+${u(t?.commitGranularity)}
 
 ## Required Output Format
 
 Output your organization as JSON inside a <output> tag matching this schema:
 
 \`\`\`json
-${n}
+${r}
 \`\`\`
 
 Wrap all commits in a single branch object with id "default", name "", title "", and description "".
 
-Return only the <output> tag and no other text.`}function s(e,t){let i=e?.promptFragment?`5. Write a commit message for each commit following the repository's conventions (see below).
+Return only the <output> tag and no other text.`}function c(e,t){let n=e?.promptFragment?`5. Write a commit message for each commit following the repository's conventions (see below).
 6. Write a detailed explanation for each commit as if explaining to a reviewer.
 
-${e.promptFragment}`:`${r}
-6. Write a detailed explanation for each commit as if explaining to a reviewer`,a=c(t?.branchSplitting,e);return`You are an advanced AI programming assistant tasked with organizing code changes into commits and branches. You will be working with individual code hunks.
+${e.promptFragment}`:`${i}
+6. Write a detailed explanation for each commit as if explaining to a reviewer`,a=l(t?.branchSplitting,e);return`You are an advanced AI programming assistant tasked with organizing code changes into commits and branches. You will be working with individual code hunks.
 
 Your job has two levels:
 
@@ -58,8 +58,8 @@ Before producing the \`<output>\` tag, do a self-check: count the total number o
 
 1. Group hunks into logical units that make sense together and can be applied atomically
 2. Ensure each commit is self-contained and atomic
-${i}
-${l(t?.commitGranularity)}
+${n}
+${u(t?.commitGranularity)}
 
 ## Branch guidelines
 
@@ -70,11 +70,11 @@ ${a}
 Output your organization as JSON inside a <output> tag matching this schema:
 
 \`\`\`json
-${n}
+${r}
 \`\`\`
 
-Return only the <output> tag and no other text.`}function c(e,t){let n=`- Each commit belongs to exactly one branch.
-${t?.promptFragment?`- ${i} Follow the repository's branch naming conventions (see above).`:`- ${i}`}
+Return only the <output> tag and no other text.`}function l(e,t){let n=`- Each commit belongs to exactly one branch.
+${t?.promptFragment?`- ${a} Follow the repository's branch naming conventions (see above).`:`- ${a}`}
 - Changes addressing the same pattern across different files belong in ONE branch. For example, applying the same bug fix to multiple functions, or updating similar config across modules — these are the same concern even if the files are different.`,r=`- Consider merge-order preference, not just code dependencies. Even if two concerns compile independently, they may need to be in the same branch or stacked branches if merging one without the other would be confusing or incomplete (e.g., documentation that describes utilities introduced in other commits should be in the same branch or stacked after those utilities).`;return e===`conservative`?`${n}
 - Default to a single branch. Only create multiple branches when concerns are completely unrelated — different domains, different purposes, and no merge-order preference between them.
 ${r}
@@ -85,22 +85,22 @@ ${r}
 - Create separate branches when concerns are genuinely independent — meaning they address different problems or features, and a reviewer would gain nothing from seeing them together in one PR. Two commits that each add a separate utility function unrelated to each other are good candidates for independent branches.
 - Keep changes in the same branch when they form a coherent story that benefits from being reviewed together, even if they could technically stand alone.
 ${r}
-- When in doubt, consider: "Would a reviewer want to see these changes together, or would separating them make review easier?" If separating helps, split.`}function l(e){return e===`consolidated`?`
+- When in doubt, consider: "Would a reviewer want to see these changes together, or would separating them make review easier?" If separating helps, split.`}function u(e){return e===`consolidated`?`
 Prefer fewer, larger commits. Combine related changes into a single commit when they serve the same purpose. A commit can touch many files if they are all part of the same logical change.`:e===`granular`?`
-Prefer more, smaller commits. Each distinct change should be its own commit, even if multiple changes serve a similar purpose. Aim for commits that touch as few files as possible.`:``}function u(e){let{hunks:t,commitMessages:n,instructions:r,mode:i=`branches`}=e,a=JSON.stringify(t.map(e=>({index:e.index,fileName:e.fileName,hunkHeader:e.hunkHeader,content:e.content,...e.isBinary?{isBinary:!0}:{},...e.isRename?{isRename:!0}:{},...e.originalFileName?{originalFileName:e.originalFileName}:{}}))),o=`${i===`commits`?`Examine the following ${t.length} code hunks (indices 0 to ${t.length-1}) and organize them into commits. Every index must appear exactly once.`:`Examine the following ${t.length} code hunks (indices 0 to ${t.length-1}) and organize them into commits and branches. Every index must appear exactly once.`}
+Prefer more, smaller commits. Each distinct change should be its own commit, even if multiple changes serve a similar purpose. Aim for commits that touch as few files as possible.`:``}function d(t){let{hunks:n,commitMessages:r,instructions:i,mode:a=`branches`,redactHunkContent:o}=t,s=JSON.stringify(n.map(t=>({index:t.index,fileName:t.fileName,hunkHeader:t.hunkHeader,content:e(t,o),...t.isBinary?{isBinary:!0}:{},...t.isRename?{isRename:!0}:{},...t.originalFileName?{originalFileName:t.originalFileName}:{}}))),c=`${a===`commits`?`Examine the following ${n.length} code hunks (indices 0 to ${n.length-1}) and organize them into commits. Every index must appear exactly once.`:`Examine the following ${n.length} code hunks (indices 0 to ${n.length-1}) and organize them into commits and branches. Every index must appear exactly once.`}
 
 <hunks>
-${a}
-</hunks>`;return n?.length&&(o+=`
+${s}
+</hunks>`;return r?.length&&(c+=`
 
 The following commit messages are from the original commits. Use them to understand intent and match their style:
 
 <commit_messages>
-${JSON.stringify(n)}
-</commit_messages>`),r&&(o+=`
+${JSON.stringify(r)}
+</commit_messages>`),i&&(c+=`
 
 Carefully follow these additional instructions, but do not deviate from the output structure:
-${r}`),o+=`\n\n${i===`commits`?`Now organize the hunks into commits.`:`Now organize the hunks into commits and branches.`} Return only the <output> tag and no other text.`,o}function d(e,t){let n;return n=t===`commits`?`Based on your analysis of the changes, now organize the hunks into commits. Each hunk must be assigned to exactly one commit.`:f(e.strategy),e.conventions?.promptFragment&&(n+=`\n\n${e.conventions.promptFragment}`),e.commitMessages?.length&&(n+=`\n\nMatch the style of these original commit messages:\n${JSON.stringify(e.commitMessages)}`),e.instructions&&(n+=`\n\nAdditional instructions:\n${e.instructions}`),t===`commits`?n+=`
+${i}`),c+=`\n\n${a===`commits`?`Now organize the hunks into commits.`:`Now organize the hunks into commits and branches.`} Return only the <output> tag and no other text.`,c}function f(e,t){let n;return n=t===`commits`?`Based on your analysis of the changes, now organize the hunks into commits. Each hunk must be assigned to exactly one commit.`:p(e.strategy),e.conventions?.promptFragment&&(n+=`\n\n${e.conventions.promptFragment}`),e.commitMessages?.length&&(n+=`\n\nMatch the style of these original commit messages:\n${JSON.stringify(e.commitMessages)}`),e.instructions&&(n+=`\n\nAdditional instructions:\n${e.instructions}`),t===`commits`?n+=`
 
 Return your grouping as JSON inside <output> tags. Wrap all commits in a single branch with id "default", name "", title "", description "":
 <output>
@@ -148,7 +148,7 @@ Return your grouping as JSON inside <output> tags:
 }
 </output>
 
-Return only the <output> tag and no other text.`,n}function f(e){let t=e?.branchSplitting??`balanced`,n=`Based on your analysis of the changes, now organize the hunks into commits and branches. Each hunk must be assigned to exactly one commit, and each commit belongs to exactly one branch.`,r=`Consider merge-order preference: even if two concerns compile independently, they should be in the same branch or stacked if merging one without the other would be incomplete or confusing (e.g., documentation for utilities should be with or after those utilities).`;return t===`conservative`?`${n}
+Return only the <output> tag and no other text.`,n}function p(e){let t=e?.branchSplitting??`balanced`,n=`Based on your analysis of the changes, now organize the hunks into commits and branches. Each hunk must be assigned to exactly one commit, and each commit belongs to exactly one branch.`,r=`Consider merge-order preference: even if two concerns compile independently, they should be in the same branch or stacked if merging one without the other would be incomplete or confusing (e.g., documentation for utilities should be with or after those utilities).`;return t===`conservative`?`${n}
 
 Default to a single branch. Only create multiple branches when concerns are completely unrelated — different domains, different purposes, no merge-order preference.
 ${r}
@@ -161,4 +161,4 @@ Create separate branches when concerns are genuinely independent — different p
 
 Keep changes in the same branch when they form a coherent story that benefits from joint review, or when there is a merge-order preference between them.
 ${r}
-When in doubt, consider: "Would a reviewer want to see these together, or would separating them make review easier?"`}export{d as buildGroupContinuationPrompt,a as buildGroupSystemPrompt,u as buildGroupUserPrompt};
+When in doubt, consider: "Would a reviewer want to see these together, or would separating them make review easier?"`}export{f as buildGroupContinuationPrompt,o as buildGroupSystemPrompt,d as buildGroupUserPrompt};

package/dist/tasks/group/types.d.ts

@@ -2,6 +2,7 @@ import { ProgressEvent, TokenUsage } from "../../ai/types.js";
 import { BranchGroup, ComposeHunk, PromptOverride } from "../types.js";
 import { ConventionDescriptor } from "../../git/utils/conventions.js";
 import { OnAfterModelCall, OnBeforeModelCall, OnBeforePrompt } from "../ai-loop.js";
+import { RedactHunkContent } from "../utils/redact.js";
 import { AnalysisResult } from "../analyze/types.js";
 import { ComposeSession } from "../session.js";
 import { AiModelPort } from "@gitkraken/shared-tools";
@@ -35,6 +36,8 @@ interface GroupInput {
   strategy?: GroupingStrategy;
   /** Branch names that already exist in the repo — used to detect collisions during validation. */
   existingBranchNames?: Set<string>;
+  /** See {@link RedactHunkContent}. */
+  redactHunkContent?: RedactHunkContent;
   model: AiModelPort;
   session?: ComposeSession;
   maxRetries?: number;

package/dist/tasks/quick-compose/prompt.d.ts

@@ -1,5 +1,6 @@
 import { ComposeHunk } from "../types.js";
 import { ConventionDescriptor } from "../../git/utils/conventions.js";
+import { RedactHunkContent } from "../utils/redact.js";
 import { GroupingStrategy } from "../group/types.js";
 
 //#region src/tasks/quick-compose/prompt.d.ts
@@ -13,6 +14,7 @@ declare function buildQuickComposeUserPrompt(params: {
   issueUrl?: string;
   pullRequestUrl?: string;
   instructions?: string;
+  redactHunkContent?: RedactHunkContent;
 }): string;
 //#endregion
 export { buildQuickComposeSystemPrompt, buildQuickComposeUserPrompt };

package/dist/tasks/quick-compose/prompt.js

@@ -1,8 +1,8 @@
-import{quickComposeResultSchema as e}from"./schema.js";import{z as t}from"zod";const n=JSON.stringify(t.toJSONSchema(e),null,2);function r(e,t=`branches`,r,i=!1){let c=e?.promptFragment?`Write commit messages following the repository's conventions:\n\n${e.promptFragment}`:`Write commit messages:
+import{hunkContentForPrompt as e}from"../utils/redact.js";import{quickComposeResultSchema as t}from"./schema.js";import{z as n}from"zod";const r=JSON.stringify(n.toJSONSchema(t),null,2);function i(e,t=`branches`,n,i=!1){let a=e?.promptFragment?`Write commit messages following the repository's conventions:\n\n${e.promptFragment}`:`Write commit messages:
 Each commit message must contain both a summary and a description, separated by a blank line:
 - **Summary** (first line): concise, 50 chars max, third-person singular present tense ("Fixes", "Adds", "Improves"). Stands alone as the commit subject.
 - **Blank line**: mandatory separator.
-- **Description** (body): one or more lines explaining *why* the change was made, not *what* it does. Focus on motivation, trade-offs, or context a reviewer needs. For non-trivial changes, always include a description.`,l=a(r?.commitGranularity),u=t===`branches`?o(r?.branchSplitting,e):``,d=i?s():``;return`You are a fast AI code organizer. Given a set of code diff hunks, organize them into well-structured commits${t===`branches`?` and branches`:``} in a single pass.
+- **Description** (body): one or more lines explaining *why* the change was made, not *what* it does. Focus on motivation, trade-offs, or context a reviewer needs. For non-trivial changes, always include a description.`,l=o(n?.commitGranularity),u=t===`branches`?s(n?.branchSplitting,e):``,d=i?c():``;return`You are a fast AI code organizer. Given a set of code diff hunks, organize them into well-structured commits${t===`branches`?` and branches`:``} in a single pass.
 
 ## Your task
 
@@ -13,7 +13,7 @@ ${t===`branches`?`4. Assign commits to branches — each branch is a cohesive un
 ${i?`5. If a branch should be split into stacked sub-branches for review, provide partitions.`:``}
 
 ## Commit style
-${c}
+${a}
 ${l}
 ${u}
 ${d}
@@ -36,21 +36,21 @@ Before producing the \`<output>\` tag, do a self-check: count the total number o
 Output as JSON inside a <output> tag matching this schema:
 
 \`\`\`json
-${n}
+${r}
 \`\`\`
 
-Return only the <output> tag and no other text.`}function i(e){let{hunks:t,commitMessages:n,commitOrder:r,branchName:i,baseBranch:a,issueUrl:o,pullRequestUrl:s,instructions:c}=e,l=`Organize these code hunks into commits:
+Return only the <output> tag and no other text.`}function a(t){let{hunks:n,commitMessages:r,commitOrder:i,branchName:a,baseBranch:o,issueUrl:s,pullRequestUrl:c,instructions:l,redactHunkContent:u}=t,d=`Organize these code hunks into commits:
 
 <hunks>
-${JSON.stringify(t.map(e=>({index:e.index,fileName:e.fileName,hunkHeader:e.hunkHeader,content:e.content,...e.isBinary?{isBinary:!0}:{},...e.isRename?{isRename:!0}:{},...e.originalFileName?{originalFileName:e.originalFileName}:{}})))}
-</hunks>`,u=[];return i&&u.push(`Branch: ${i}`),a&&u.push(`Base: ${a}`),o&&u.push(`Issue: ${o}`),s&&u.push(`PR: ${s}`),u.length>0&&(l+=`\n\nContext:\n${u.join(`
-`)}`),n?.length&&(l+=`\n\nOriginal commit messages (match their style):\n<commit_messages>\n${JSON.stringify(n)}\n</commit_messages>`),r?.length&&(l+=`\n\nOriginal commit order:\n${JSON.stringify(r)}`),c&&(l+=`\n\nAdditional instructions:\n${c}`),l+=`
+${JSON.stringify(n.map(t=>({index:t.index,fileName:t.fileName,hunkHeader:t.hunkHeader,content:e(t,u),...t.isBinary?{isBinary:!0}:{},...t.isRename?{isRename:!0}:{},...t.originalFileName?{originalFileName:t.originalFileName}:{}})))}
+</hunks>`,f=[];return a&&f.push(`Branch: ${a}`),o&&f.push(`Base: ${o}`),s&&f.push(`Issue: ${s}`),c&&f.push(`PR: ${c}`),f.length>0&&(d+=`\n\nContext:\n${f.join(`
+`)}`),r?.length&&(d+=`\n\nOriginal commit messages (match their style):\n<commit_messages>\n${JSON.stringify(r)}\n</commit_messages>`),i?.length&&(d+=`\n\nOriginal commit order:\n${JSON.stringify(i)}`),l&&(d+=`\n\nAdditional instructions:\n${l}`),d+=`
 
-Return only the <output> tag and no other text.`,l}function a(e){return e===`consolidated`?`
+Return only the <output> tag and no other text.`,d}function o(e){return e===`consolidated`?`
 Prefer fewer, larger commits. Combine related changes into a single commit.`:e===`granular`?`
-Prefer more, smaller commits. Each distinct change gets its own commit.`:``}function o(e,t){let n=`\n## Branch guidelines\n- Each branch has a descriptive name, a short PR title (under 72 chars), and at least one commit.\n- ${t?.promptFragment?`Follow the repository's branch naming conventions.`:`Give each branch a descriptive name.`}`;return e===`conservative`?`${n}\n- Default to a single branch. Only split when concerns are completely unrelated.`:e===`aggressive`?`${n}\n- Create separate branches for each distinct concern. Maximize focus per PR.`:`${n}\n- Split when concerns are genuinely independent. Keep together when they form a coherent story.`}function s(){return`
+Prefer more, smaller commits. Each distinct change gets its own commit.`:``}function s(e,t){let n=`\n## Branch guidelines\n- Each branch has a descriptive name, a short PR title (under 72 chars), and at least one commit.\n- ${t?.promptFragment?`Follow the repository's branch naming conventions.`:`Give each branch a descriptive name.`}`;return e===`conservative`?`${n}\n- Default to a single branch. Only split when concerns are completely unrelated.`:e===`aggressive`?`${n}\n- Create separate branches for each distinct concern. Maximize focus per PR.`:`${n}\n- Split when concerns are genuinely independent. Keep together when they form a coherent story.`}function c(){return`
 ## Partition guidelines (stacked sub-branches)
 - If a branch has multiple distinct concerns, split it into partitions for stacked review.
 - Each partition is a contiguous range of commits from orderedCommitIds.
 - Each partition gets a unique, valid git branch name.
-- Single partition (no split) is a valid outcome.`}export{r as buildQuickComposeSystemPrompt,i as buildQuickComposeUserPrompt};
+- Single partition (no split) is a valid outcome.`}export{i as buildQuickComposeSystemPrompt,a as buildQuickComposeUserPrompt};

package/dist/tasks/quick-compose/quick-compose.js

@@ -1 +1 @@
-import{TaskInputError as e}from"../../errors/task.js";import{runAiLoop as t}from"../ai-loop.js";import{applyUserPromptOverride as n}from"../types.js";import{buildQuickComposeSystemPrompt as r,buildQuickComposeUserPrompt as i}from"./prompt.js";import{validateQuickComposeResponse as a}from"./validator.js";async function o(o){let s=o.hunks,c=o.mode??`branches`,l=o.includePartitions??!1;if(!s||s.length===0)throw new e(`No hunks provided for quick compose`);if(o.session?.completedSteps.quickCompose)return{result:o.session.completedSteps.quickCompose,session:o.session,attempts:0,durationMs:0,callIds:[]};let u=o.promptOverride?.system??r(o.conventions,c,o.strategy,l),d=n(i({hunks:s,commitMessages:o.commitMessages,commitOrder:o.commitOrder,branchName:o.branchName,baseBranch:o.baseBranch,issueUrl:o.issueUrl,pullRequestUrl:o.pullRequestUrl,instructions:o.instructions}),o.promptOverride),f=await t({model:o.model,systemPrompt:u,userPrompt:d,maxRetries:o.maxRetries,maxTokens:o.maxTokens,onProgress:o.onProgress,cancellation:o.cancellation,onBeforeModelCall:o.onBeforeModelCall,onAfterModelCall:o.onAfterModelCall,onBeforePrompt:o.onBeforePrompt,validate:e=>a(e,s.length,c,l,o.existingBranchNames),taskName:`quick-compose`}),p=o.session?.completedSteps??{},m={...f.session,completedSteps:{...p,quickCompose:f.result}};return{result:f.result,session:m,usage:f.usage,attempts:f.attempts,durationMs:f.durationMs,callIds:f.callIds}}export{o as quickCompose};
+import{TaskInputError as e}from"../../errors/task.js";import{runAiLoop as t}from"../ai-loop.js";import{applyUserPromptOverride as n}from"../types.js";import{buildQuickComposeSystemPrompt as r,buildQuickComposeUserPrompt as i}from"./prompt.js";import{validateQuickComposeResponse as a}from"./validator.js";async function o(o){let s=o.hunks,c=o.mode??`branches`,l=o.includePartitions??!1;if(!s||s.length===0)throw new e(`No hunks provided for quick compose`);if(o.session?.completedSteps.quickCompose)return{result:o.session.completedSteps.quickCompose,session:o.session,attempts:0,durationMs:0,callIds:[]};let u=o.promptOverride?.system??r(o.conventions,c,o.strategy,l),d=n(i({hunks:s,commitMessages:o.commitMessages,commitOrder:o.commitOrder,branchName:o.branchName,baseBranch:o.baseBranch,issueUrl:o.issueUrl,pullRequestUrl:o.pullRequestUrl,instructions:o.instructions,redactHunkContent:o.redactHunkContent}),o.promptOverride),f=await t({model:o.model,systemPrompt:u,userPrompt:d,maxRetries:o.maxRetries,maxTokens:o.maxTokens,onProgress:o.onProgress,cancellation:o.cancellation,onBeforeModelCall:o.onBeforeModelCall,onAfterModelCall:o.onAfterModelCall,onBeforePrompt:o.onBeforePrompt,validate:e=>a(e,s.length,c,l,o.existingBranchNames),taskName:`quick-compose`}),p=o.session?.completedSteps??{},m={...f.session,completedSteps:{...p,quickCompose:f.result}};return{result:f.result,session:m,usage:f.usage,attempts:f.attempts,durationMs:f.durationMs,callIds:f.callIds}}export{o as quickCompose};

package/dist/tasks/quick-compose/types.d.ts

@@ -2,6 +2,7 @@ import { ProgressEvent, TokenUsage } from "../../ai/types.js";
 import { BranchPartition, CommitSuggestion, ComposeHunk, PromptOverride } from "../types.js";
 import { ConventionDescriptor } from "../../git/utils/conventions.js";
 import { OnAfterModelCall, OnBeforeModelCall, OnBeforePrompt } from "../ai-loop.js";
+import { RedactHunkContent } from "../utils/redact.js";
 import { GroupingStrategy } from "../group/types.js";
 import { ComposeSession } from "../session.js";
 import { AiModelPort } from "@gitkraken/shared-tools";
@@ -25,6 +26,8 @@ interface QuickComposeInput {
   strategy?: GroupingStrategy;
   /** Branch names that already exist — used to detect collisions during validation. */
   existingBranchNames?: Set<string>;
+  /** See {@link RedactHunkContent}. */
+  redactHunkContent?: RedactHunkContent;
   model: AiModelPort;
   /** Prior session to resume from. When `completedSteps.quickCompose` is present, skip the AI call. */
   session?: ComposeSession;

package/dist/tasks/types.d.ts

@@ -7,18 +7,18 @@ interface ComposeHunk {
   content: string;
   additions: number;
   deletions: number;
-  source: 'staged' | 'unstaged' | 'untracked' | 'branch';
-  sourceCommitSha?: string;
   isRename?: boolean;
   originalFileName?: string;
   isBinary?: boolean;
   /** Full binary patch block (base85-encoded). Excluded from AI context, used only by patch builder. */
   binaryPatchData?: string;
   /**
-   * Original author of this hunk (e.g. when the hunk came from a branch source
-   * and the commit carrying it was authored by someone specific). The apply
-   * phase aggregates per-commit hunks through an attribution strategy to choose
-   * the commit's primary author and Co-authored-by trailers.
+   * Likely author of this hunk. For `commit-range` and `branch` sources the
+   * library populates this via a line-range-overlap heuristic against the
+   * per-commit hunks of the source range; the author with the highest
+   * cumulative overlap wins, and other authors land in `coAuthors`. The apply
+   * phase aggregates `author` across the hunks of each new commit to pick the
+   * commit's primary author and `Co-authored-by` trailers.
    *
    * `date` is the commit's author date when known — used by consumers for UI
    * display and, for the commit created by the apply path, as `GIT_AUTHOR_DATE`.
@@ -29,9 +29,10 @@ interface ComposeHunk {
     date?: Date;
   };
   /**
-   * Additional authors attached to this hunk (for merge commits or the AI's
-   * attribution hints). Combined with `author` from all hunks in a commit to
-   * produce the final Co-authored-by trailer list.
+   * Additional likely authors of this hunk (those whose per-commit overlap
+   * was non-zero but didn't win the primary slot). Combined with `author`
+   * from all hunks in a new commit to produce the final `Co-authored-by`
+   * trailer list.
    */
   coAuthors?: {
     name: string;

package/dist/tasks/utils/redact.d.ts

@@ -0,0 +1,14 @@
+import { ComposeHunk } from "../types.js";
+
+//#region src/tasks/utils/redact.d.ts
+/** Placeholder substituted for hunk content when {@link RedactHunkContent} returns true. */
+declare const REDACTED_HUNK_CONTENT = "[content redacted because this file is excluded from AI processing \u2014 still assign this hunk to a commit based on its filename]";
+/**
+ * Returns `true` for hunks whose content should be redacted from AI prompts. The library
+ * keeps the hunk's `fileName`, `hunkHeader`, `index`, line counts, and rename metadata in
+ * the prompt; only the patch body is replaced.
+ */
+type RedactHunkContent = (hunk: ComposeHunk) => boolean;
+declare function hunkContentForPrompt(hunk: ComposeHunk, redact: RedactHunkContent | undefined): string;
+//#endregion
+export { REDACTED_HUNK_CONTENT, RedactHunkContent, hunkContentForPrompt };

package/dist/tasks/utils/redact.js

@@ -0,0 +1 @@
+const e=`[content redacted because this file is excluded from AI processing — still assign this hunk to a commit based on its filename]`;function t(t,n){return n?.(t)?e:t.content}export{e as REDACTED_HUNK_CONTENT,t as hunkContentForPrompt};

package/dist/workflows/compose.d.ts

@@ -3,6 +3,7 @@ import { ComposeGitPort, SigningConfig } from "../ports/git.js";
 import { BranchPartition, CommitSuggestion, ComposeHunk, ComposeTaskName, PromptOverride } from "../tasks/types.js";
 import { ConventionDescriptor } from "../git/utils/conventions.js";
 import { OnAfterModelCall, OnBeforeModelCall, OnBeforePrompt } from "../tasks/ai-loop.js";
+import { RedactHunkContent } from "../tasks/utils/redact.js";
 import { AnalysisResult } from "../tasks/analyze/types.js";
 import { GroupingResult, GroupingStrategy } from "../tasks/group/types.js";
 import { OrderingResult } from "../tasks/order/types.js";
@@ -40,6 +41,8 @@ interface ComposePlanInput {
   onBeforePrompt?: OnBeforePrompt;
   /** See {@link ComposeInput.hunkFilter}. */
   hunkFilter?: ComposeInput['hunkFilter'];
+  /** See {@link ComposeInput.redactHunkContent}. */
+  redactHunkContent?: ComposeInput['redactHunkContent'];
   /** See {@link ComposeInput.session}. */
   session?: ComposeSession;
   /** See {@link ComposeInput.promptOverrides}. */
@@ -73,8 +76,8 @@ interface ApplyComposePlanInput {
   signing?: SigningConfig;
   /** How to pick the primary author for each commit. See {@link ComposeInput.authorAttribution}. */
   authorAttribution?: ComposeInput['authorAttribution'];
-  /** See {@link ComposeInput.applyUpTo}. */
-  applyUpTo?: ApplyUpTo;
+  /** See {@link ComposeInput.applyCommitIds}. */
+  applyCommitIds?: string[];
   /** See {@link ComposeInput.stashLabel}. */
   stashLabel?: string;
   /**
@@ -189,6 +192,16 @@ interface ComposeInput {
    * values so the plan still references the authoritative collection.
    */
   hunkFilter?: (hunks: ComposeHunk[]) => Promise<ComposeHunk[]> | ComposeHunk[];
+  /**
+   * Predicate that returns true for hunks whose patch body should be replaced with a
+   * placeholder in AI prompts. Matching hunks keep their filename, hunk header, index,
+   * line counts, and rename metadata; only the body is masked. The apply path still uses
+   * the real content.
+   *
+   * Intended for `.aiexclude`/`.aiignore`/`.cursorignore`-style features: the AI assigns
+   * matching hunks to commits by filename alone, never seeing the diff body.
+   */
+  redactHunkContent?: RedactHunkContent;
   /**
    * Per-task prompt overrides, keyed by {@link ComposeTaskName}. Consumers with
    * existing prompt template services (server-driven templates, provider-specific
@@ -242,20 +255,18 @@ interface ComposeInput {
     name: string;
     email: string;
   } | undefined);
-  /** Apply only a prefix of `plan.allOrderedCommits`. Hunks not in applied commits are restored to the working tree. */
-  applyUpTo?: ApplyUpTo;
+  /**
+   * Apply only the listed commit ids from `plan.allOrderedCommits`. Hunks belonging to omitted
+   * commits (plus unassigned hunks, e.g. those dropped by `hunkFilter`) become unstaged WIP on
+   * top of the rewritten branch. Undefined applies every commit.
+   *
+   * On destructive targets (`rewrite-range`, or `branch`/`auto` with `preserveOriginal: false`)
+   * with `branch`/`commit-range` sources, HEAD must be non-detached and at the source's tip.
+   */
+  applyCommitIds?: string[];
   /** Stash message used by the apply path when stashing pending workdir state. Defaults to `'compose backup'`. */
   stashLabel?: string;
 }
-type ApplyUpTo = {
-  kind: 'all';
-} | {
-  kind: 'commitId';
-  id: string;
-} | {
-  kind: 'count';
-  count: number;
-};
 interface ComposePlan {
   analysis?: AnalysisResult;
   grouping: GroupingResult;
@@ -436,4 +447,4 @@ declare function composePlan(input: ComposePlanInput): Promise<ComposePlanResult
  */
 declare function applyComposePlan(input: ApplyComposePlanInput): Promise<ApplyComposePlanResult>;
 //#endregion
-export { ApplyComposePlanInput, ApplyComposePlanResult, ApplyUpTo, ComposeApplyPlan, type ComposeBranchPlan, type ComposeContext, ComposeDepth, ComposeInput, ComposePlan, ComposePlanInput, ComposePlanResult, ComposeProgressEvent, ComposeResult, type ComposeSource, ComposeStrategy, type ComposeTarget, type StashConflict, applyComposePlan, compose, composePlan, defaultPhaseMessages };
+export { ApplyComposePlanInput, ApplyComposePlanResult, ComposeApplyPlan, type ComposeBranchPlan, type ComposeContext, ComposeDepth, ComposeInput, ComposePlan, ComposePlanInput, ComposePlanResult, ComposeProgressEvent, ComposeResult, type ComposeSource, ComposeStrategy, type ComposeTarget, type StashConflict, applyComposePlan, compose, composePlan, defaultPhaseMessages };