@gitkraken/compose-tools 0.8.1 → 0.10.0

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

@@ -1,4 +1,4 @@
-import{assembleHunkPrompt as e}from"../utils/budget.js";import{groupingResultJsonSchema as t}from"../group/schema.js";const n=JSON.stringify(t,null,2),r=`
+import{renderAuthoringContext as e}from"../utils/authoring-context.js";import{assembleHunkPrompt as t}from"../utils/budget.js";import{renderHunkSummaries as n}from"../utils/hunk-summaries.js";import{groupingResultJsonSchema as r}from"../group/schema.js";import{renderSuppliedAnalysis as i}from"../utils/analysis-prompt.js";const a=JSON.stringify(r,null,2),o=`
 In addition to the \`branches\` field, include an \`analysis\` field at the top level:
 
 \`\`\`json
@@ -10,12 +10,12 @@ 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:
+`,s=`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.`,a=`5. Write a concise single-line commit message for each commit — a subject only, no body: 50 chars max, third-person singular present tense ("Fixes", "Adds", "Improves"). This repository's history overwhelmingly uses one-line commit messages, so do not add a description.`;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,o){let s=`${e?.commits.bodyStyle===`minimal`?a:i}
-6. Write a detailed explanation for each commit as if explaining to a reviewer.${e?.promptFragment?`\n\n${e.promptFragment}`:``}`,c=u(t?.commitGranularity);return`You are an advanced AI programming assistant tasked with analyzing and organizing code changes into commits.
+   - Informal yet professional tone.`,c=`5. Write a concise single-line commit message for each commit — a subject only, no body: 50 chars max, third-person singular present tense ("Fixes", "Adds", "Improves"). This repository's history overwhelmingly uses one-line commit messages, so do not add a description.`;function l(e,t=`branches`,n,r,i){return i?t===`commits`?m(e,n):h(e,n):t===`commits`?u(e,n,r):d(e,n,r)}function u(e,t,n){let r=`${e?.commits.bodyStyle===`minimal`?c:s}
+6. Write a detailed explanation for each commit as if explaining to a reviewer.${e?.promptFragment?`\n\n${e.promptFragment}`:``}`,i=p(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)
 
@@ -26,34 +26,34 @@ In addition to the \`branches\` field, include an \`analysis\` field at the top
 
 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.
 
-${o?`## 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
 
-${o?"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
 
 1. Group hunks into logical units that make sense together and can be applied atomically
 2. Ensure each commit is self-contained and atomic
-${s}
-${c}
+${r}
+${i}
 
 ## Required Output Format
 
 Output your organization as JSON inside a <output> tag matching this schema:
 
 \`\`\`json
-${n}
+${a}
 \`\`\`
-${o?r:``}
+${n?o:``}
 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 c(e,t,o){let s=`${e?.commits.bodyStyle===`minimal`?a:i}
-6. Write a detailed explanation for each commit as if explaining to a reviewer.${e?.promptFragment?`\n\n${e.promptFragment}`:``}`,c=l(t?.branchSplitting,e),d=u(t?.commitGranularity);return`You are an advanced AI programming assistant tasked with analyzing and organizing code changes into commits and branches.
+Return only the <output> tag and no other text.`}function d(e,t,n){let r=`${e?.commits.bodyStyle===`minimal`?c:s}
+6. Write a detailed explanation for each commit as if explaining to a reviewer.${e?.promptFragment?`\n\n${e.promptFragment}`:``}`,i=f(t?.branchSplitting,e),l=p(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)
 
@@ -64,7 +64,7 @@ Return only the <output> tag and no other text.`}function c(e,t,o){let s=`${e?.c
 
 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.
 
-${o?`## 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
@@ -72,7 +72,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?
 
-${o?"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
 
@@ -85,26 +85,26 @@ 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
-${s}
-${d}
+${r}
+${l}
 
 ### Branch guidelines
 
-${c}
+${i}
 
 ## Required Output Format
 
 Output your organization as JSON inside a <output> tag matching this schema:
 
 \`\`\`json
-${n}
+${a}
 \`\`\`
-${o?r:``}
-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.
+${n?o:``}
+Return only the <output> tag and no other text.`}function f(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 u(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 p(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 d(e,t){return`Organize code hunks into clean, atomic commits.
+Prefer more, smaller commits. Each distinct change should be its own commit.`:``}function m(e,t){return`Organize code hunks into clean, atomic commits.
 
 ## Rules
 
@@ -115,7 +115,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.`}
-${u(t?.commitGranularity)}
+${p(t?.commitGranularity)}
 
 ## Output
 
@@ -125,9 +125,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 f(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 h(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=l(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=f(t?.branchSplitting,e);return`Organize code hunks into clean, atomic commits and branches.
 
 ## Commit rules
 
@@ -136,7 +136,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}
-${u(t?.commitGranularity)}
+${p(t?.commitGranularity)}
 
 ## Branch guidelines
 
@@ -152,11 +152,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 p(t){let{hunks:n,commitMessages:r,commitOrder:i,branchName:a,baseBranch:o,issueUrl:s,pullRequestUrl:c,instructions:l,condensed:u,redactHunkContent:d,inputTokenBudget:f,systemPromptChars:p,onBudgetReduction:m}=t,h=n.map(e=>e.index).join(`, `),{prompt:g,hunksCondensedForBudget:_}=e({hunks:n,assemble:e=>{let t=`Organize these ${n.length} code hunks (indices: ${h}) into commits. Every listed index must appear exactly once.
+Return only the <output> tag and no other text.`}function g(r){let{hunks:a,commitMessages:o,commitOrder:s,branchName:c,baseBranch:l,issueUrl:u,pullRequestUrl:d,authoring:f,analysis:p,hunkSummaries:m,instructions:h,condensed:g,redactHunkContent:_,inputTokenBudget:v,systemPromptChars:y,onBudgetReduction:b}=r,x=i(p),S=n(m,a),C=a.map(e=>e.index).join(`, `),{prompt:w,hunksCondensedForBudget:T}=t({hunks:a,assemble:t=>{let n=`Organize these ${a.length} code hunks (indices: ${C}) into commits. Every listed index must appear exactly once.
 
 <hunks>
-${e}
-</hunks>`,u=[];return a&&u.push(`Branch: ${a}`),o&&u.push(`Base: ${o}`),s&&u.push(`Issue: ${s}`),c&&u.push(`PR: ${c}`),u.length>0&&(t+=`\n\nContext:\n${u.join(`
-`)}`),r?.length&&(t+=`\n\nOriginal commit messages (match their style):\n<commit_messages>\n${JSON.stringify(r)}\n</commit_messages>`),i?.length&&(t+=`\n\nOriginal commit order:\n${JSON.stringify(i)}`),l&&(t+=`\n\nAdditional instructions:\n${l}`),t+=`
+${t}
+</hunks>`,r=e(f,{issueUrl:u,pullRequestUrl:d}),i=[];return c&&i.push(`Branch: ${c}`),l&&i.push(`Base: ${l}`),i.push(...r.lines),i.length>0&&(n+=`\n\nContext:\n${i.join(`
+`)}`),S&&(n+=`\n\n${S}`),x&&(n+=`\n\n${x}`),r.block&&(n+=`\n\n${r.block}`),o?.length&&(n+=`\n\nOriginal commit messages (match their style):\n<commit_messages>\n${JSON.stringify(o)}\n</commit_messages>`),s?.length&&(n+=`\n\nOriginal commit order:\n${JSON.stringify(s)}`),h&&(n+=`\n\nAdditional instructions:\n${h}`),n+=`
 
-Return only the <output> tag and no other text.`,t},condensed:u,redactHunkContent:d,inputTokenBudget:f,systemPromptChars:p});return m?.(_),g}export{o as buildComposeGroupSystemPrompt,p as buildComposeGroupUserPrompt};
+Return only the <output> tag and no other text.`,n},condensed:g,redactHunkContent:_,inputTokenBudget:v,systemPromptChars:y});return b?.(T),w}export{l as buildComposeGroupSystemPrompt,g as buildComposeGroupUserPrompt};

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

@@ -1,8 +1,10 @@
 import { ProgressEvent } from "../../ai/types.js";
+import { AuthoringContext } from "../../context.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 { AnalysisResult } from "../analyze/types.js";
 import { GroupOutput, GroupingStrategy } from "../group/types.js";
 import { ComposeSession } from "../session.js";
 import { AiModelPort } from "@gitkraken/shared-tools";
@@ -24,6 +26,20 @@ interface ComposeGroupInput {
   baseBranch?: string;
   issueUrl?: string;
   pullRequestUrl?: string;
+  /**
+   * What the author knows that the hunks cannot show — intent, issue text, per-file rationale,
+   * ordering constraints. Rendered into the prompt as escaped, tagged data, never as instructions;
+   * for guidance the model should act on, use {@link instructions}.
+   */
+  authoring?: AuthoringContext;
+  /**
+   * Analysis supplied by the caller. Rendered into the prompt as the authoritative breakdown of the
+   * change, so the model reuses it instead of deriving one. Makes {@link includeAnalysis}
+   * unnecessary — there is nothing left for the model to produce.
+   */
+  analysis?: AnalysisResult;
+  /** One-line summaries of what individual hunks do, keyed by index. See `ComposeInput.hunkSummaries`. */
+  hunkSummaries?: Record<number, string>;
   instructions?: string;
   conventions?: ConventionDescriptor;
   /** "commits" = flat commit list. "branches" = AI decides branches (default). */

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=s.session?void 0:s.promptOverride?.system??a(s.conventions,l,s.strategy),d,f=n(s.session?i(s,l):o({hunks:c,commitMessages:s.commitMessages,instructions:s.instructions,mode:l,redactHunkContent:s.redactHunkContent,inputTokenBudget:s.inputTokenBudget,systemPromptChars:u?.length,onBudgetReduction:e=>{d=e}}),s.promptOverride),p=c?.length?new Set(c.map(e=>e.index)):new Set(s.session?.completedSteps.analyze?.hunkAnnotations.map(e=>e.hunkIndex)??[]);if(p.size===0)throw new e(`Cannot validate grouping: no hunk indices available from input or session`);let m=await t({model:s.model,systemPrompt:u,userPrompt:f,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,p,l,s.existingBranchNames),taskName:`group`}),h=s.session?.completedSteps??{},g={...m.session,completedSteps:{...h,group:m.result}};return{result:m.result,session:g,usage:m.usage,attempts:m.attempts,durationMs:m.durationMs,callIds:m.callIds,hunksCondensedCount:d,repairs:m.repairs}}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=s.session?void 0:s.promptOverride?.system??a(s.conventions,l,s.strategy),d,f=n(s.session?i(s,l):o({hunks:c,commitMessages:s.commitMessages,instructions:s.instructions,authoring:s.authoring,analysis:s.analysis,hunkSummaries:s.hunkSummaries,condensed:s.condensed,mode:l,redactHunkContent:s.redactHunkContent,inputTokenBudget:s.inputTokenBudget,systemPromptChars:u?.length,onBudgetReduction:e=>{d=e}}),s.promptOverride),p=c?.length?new Set(c.map(e=>e.index)):new Set(s.session?.completedSteps.analyze?.hunkAnnotations.map(e=>e.hunkIndex)??[]);if(p.size===0)throw new e(`Cannot validate grouping: no hunk indices available from input or session`);let m=await t({model:s.model,systemPrompt:u,userPrompt:f,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,p,l,s.existingBranchNames,c?.length?{repairContext:{hunks:c,condensed:s.condensed,redactHunkContent:s.redactHunkContent,inputTokenBudget:s.inputTokenBudget}}:void 0),taskName:`group`}),h=s.session?.completedSteps??{},g={...m.session,completedSteps:{...h,group:m.result}};return{result:m.result,session:g,usage:m.usage,attempts:m.attempts,durationMs:m.durationMs,callIds:m.callIds,hunksCondensedCount:d,repairs:m.repairs}}export{s as group};

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

@@ -1,6 +1,8 @@
+import { AuthoringContext } from "../../context.js";
 import { ComposeHunk } from "../types.js";
 import { ConventionDescriptor } from "../../git/utils/conventions.js";
 import { RedactHunkContent } from "../utils/redact.js";
+import { AnalysisResult } from "../analyze/types.js";
 import { GroupInput, GroupingStrategy } from "./types.js";
 
 //#region src/tasks/group/prompt.d.ts
@@ -8,7 +10,11 @@ declare function buildGroupSystemPrompt(conventions?: ConventionDescriptor, mode
 declare function buildGroupUserPrompt(params: {
   hunks: ComposeHunk[];
   commitMessages?: string[];
-  instructions?: string;
+  instructions?: string; /** What the author knows that the hunks cannot show. Rendered as escaped, tagged data. */
+  authoring?: AuthoringContext; /** Caller-supplied analysis, used in place of one derived by a prior `analyze` call. */
+  analysis?: AnalysisResult; /** One-line summaries of what individual hunks do, keyed by index. See `ComposeInput.hunkSummaries`. */
+  hunkSummaries?: Record<number, string>; /** Send hunk metadata only, omitting every patch body. See `ComposeInput.condenseHunks`. */
+  condensed?: boolean;
   mode?: 'commits' | 'branches';
   redactHunkContent?: RedactHunkContent; /** Input-token ceiling that triggers progressive hunk reduction. Defaults to the shared budget. */
   inputTokenBudget?: number; /** Char count of the system prompt, folded into the budget estimate. Defaults to 0. */

package/dist/tasks/group/prompt.js

@@ -1,8 +1,8 @@
-import{assembleHunkPrompt as e}from"../utils/budget.js";import{groupingResultJsonSchema as t}from"./schema.js";const n=JSON.stringify(t,null,2),r=`5. Write a full commit message for each commit containing both a summary and a description:
+import{authoringContextBlock as e}from"../utils/authoring-context.js";import{assembleHunkPrompt as t}from"../utils/budget.js";import{renderHunkSummaries as n}from"../utils/hunk-summaries.js";import{groupingResultJsonSchema as r}from"./schema.js";import{renderSuppliedAnalysis as i}from"../utils/analysis-prompt.js";const a=JSON.stringify(r,null,2),o=`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=`5. Write a concise single-line commit message for each commit — a subject only, no body: 50 chars max, third-person singular present tense ("Fixes", "Adds", "Improves"). This repository's history overwhelmingly uses one-line commit messages, so do not add a description.`,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.
+   - Informal yet professional tone.`,s=`5. Write a concise single-line commit message for each commit — a subject only, no body: 50 chars max, third-person singular present tense ("Fixes", "Adds", "Improves"). This repository's history overwhelmingly uses one-line commit messages, so do not add a description.`,c=`Each branch must have a descriptive name, a short PR-style title (under 72 characters, imperative mood), and at least one commit.`;function l(e,t=`branches`,n){return t===`commits`?u(e,n):d(e,n)}function u(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)
 
@@ -17,22 +17,22 @@ 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
-${`${e?.commits.bodyStyle===`minimal`?i:r}
+${`${e?.commits.bodyStyle===`minimal`?s:o}
 6. Write a detailed explanation for each commit as if explaining to a reviewer.${e?.promptFragment?`\n\n${e.promptFragment}`:``}`}
-${u(t?.commitGranularity)}
+${p(t?.commitGranularity)}
 
 ## Required Output Format
 
 Output your organization as JSON inside a <output> tag matching this schema:
 
 \`\`\`json
-${n}
+${a}
 \`\`\`
 
 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 c(e,t){let a=`${e?.commits.bodyStyle===`minimal`?i:r}
-6. Write a detailed explanation for each commit as if explaining to a reviewer.${e?.promptFragment?`\n\n${e.promptFragment}`:``}`,o=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.
+Return only the <output> tag and no other text.`}function d(e,t){let n=`${e?.commits.bodyStyle===`minimal`?s:o}
+6. Write a detailed explanation for each commit as if explaining to a reviewer.${e?.promptFragment?`\n\n${e.promptFragment}`:``}`,r=f(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:
 
@@ -52,23 +52,23 @@ 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
-${a}
-${u(t?.commitGranularity)}
+${n}
+${p(t?.commitGranularity)}
 
 ## Branch guidelines
 
-${o}
+${r}
 
 ## Required Output Format
 
 Output your organization as JSON inside a <output> tag matching this schema:
 
 \`\`\`json
-${n}
+${a}
 \`\`\`
 
-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}`}
+Return only the <output> tag and no other text.`}function f(e,t){let n=`- Each commit belongs to exactly one branch.
+${t?.promptFragment?`- ${c} Follow the repository's branch naming conventions (see above).`:`- ${c}`}
 - 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}
@@ -79,22 +79,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 u(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 p(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 d(t){let{hunks:n,commitMessages:r,instructions:i,mode:a=`branches`,redactHunkContent:o,inputTokenBudget:s,systemPromptChars:c,onBudgetReduction:l}=t,u=n.map(e=>e.index).join(`, `),d=a===`commits`?`Examine the following ${n.length} code hunks (indices: ${u}) and organize them into commits. Every listed index must appear exactly once.`:`Examine the following ${n.length} code hunks (indices: ${u}) and organize them into commits and branches. Every listed index must appear exactly once.`,{prompt:f,hunksCondensedForBudget:p}=e({hunks:n,assemble:e=>{let t=`${d}
+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 m(r){let{hunks:a,commitMessages:o,instructions:s,authoring:c,analysis:l,hunkSummaries:u,condensed:d,mode:f=`branches`,redactHunkContent:p,inputTokenBudget:m,systemPromptChars:h,onBudgetReduction:g}=r,_=e(c),v=i(l),y=n(u,a),b=a.map(e=>e.index).join(`, `),x=f===`commits`?`Examine the following ${a.length} code hunks (indices: ${b}) and organize them into commits. Every listed index must appear exactly once.`:`Examine the following ${a.length} code hunks (indices: ${b}) and organize them into commits and branches. Every listed index must appear exactly once.`,{prompt:S,hunksCondensedForBudget:C}=t({hunks:a,assemble:e=>{let t=`${x}
 
 <hunks>
 ${e}
-</hunks>`;return r?.length&&(t+=`
+</hunks>`;return o?.length&&(t+=`
 
 The following commit messages are from the original commits. Use them to understand intent and match their style:
 
 <commit_messages>
-${JSON.stringify(r)}
-</commit_messages>`),i&&(t+=`
+${JSON.stringify(o)}
+</commit_messages>`),y&&(t+=`\n\n${y}`),v&&(t+=`\n\n${v}`),_&&(t+=`\n\n${_}`),s&&(t+=`
 
 Carefully follow these additional instructions, but do not deviate from the output structure:
-${i}`),t+=`\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.`,t},redactHunkContent:o,inputTokenBudget:s,systemPromptChars:c});return l?.(p),f}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+=`
+${s}`),t+=`\n\n${f===`commits`?`Now organize the hunks into commits.`:`Now organize the hunks into commits and branches.`} Return only the <output> tag and no other text.`,t},condensed:d,redactHunkContent:p,inputTokenBudget:m,systemPromptChars:h});return g?.(C),S}function h(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.`:g(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>
@@ -142,7 +142,7 @@ Return your grouping as JSON inside <output> tags:
 }
 </output>
 
-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}
+Return only the <output> tag and no other text.`,n}function g(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}
@@ -155,4 +155,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{f as buildGroupContinuationPrompt,o as buildGroupSystemPrompt,d as buildGroupUserPrompt};
+When in doubt, consider: "Would a reviewer want to see these together, or would separating them make review easier?"`}export{h as buildGroupContinuationPrompt,l as buildGroupSystemPrompt,m as buildGroupUserPrompt};

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

@@ -0,0 +1,39 @@
+import { ValidationRepair } from "../../ai/types.js";
+import { BranchGroup, ComposeHunk } from "../types.js";
+import { TargetedRepair } from "../ai-loop.js";
+import { RedactHunkContent } from "../utils/redact.js";
+import { GroupingResult } from "./types.js";
+
+//#region src/tasks/group/repair.d.ts
+/**
+ * What the missing-hunk repair needs from the task to build its prompt. Omitted in conversation
+ * mode, where the hunks live in the model's context rather than in the task input — without hunk
+ * bodies there is nothing to ask about, so a short response falls straight through to a retry.
+ */
+interface MissingHunksRepairContext {
+  hunks: readonly ComposeHunk[];
+  /** The caller asked for metadata only. Honoured here too: the repair never sends a hunk body. */
+  condensed?: boolean;
+  /** See {@link RedactHunkContent}. Honoured here too: a repair prompt must not leak excluded content. */
+  redactHunkContent?: RedactHunkContent;
+  /** Ceiling above which the repair prompt drops hunk bodies and asks on metadata alone. */
+  inputTokenBudget?: number;
+}
+/**
+ * Plans the repair for a grouping that left hunks unassigned: ask the model where the orphans
+ * belong instead of re-sending the whole diff. The question is deliberately narrow — an
+ * assignment map for the missing indices, never a fresh grouping — so a response cannot
+ * restructure decisions the first response already made.
+ *
+ * Returns undefined when the repair cannot be posed (no body for a missing index), or when so many
+ * hunks are missing that the question is most of the diff again.
+ */
+declare function planMissingHunksRepair(params: {
+  branches: BranchGroup[];
+  mode: 'commits' | 'branches';
+  missingIndices: number[];
+  priorRepairs?: ValidationRepair[];
+  context: MissingHunksRepairContext;
+}): TargetedRepair<GroupingResult> | undefined;
+//#endregion
+export { MissingHunksRepairContext, planMissingHunksRepair };

package/dist/tasks/group/repair.js

@@ -0,0 +1,16 @@
+import{extractOutputTag as e}from"../ai-loop.js";import{DEFAULT_INPUT_TOKEN_BUDGET as t,estimateTokens as n,serializeHunk as r}from"../utils/budget.js";import{validateJsonSchema as i}from"../utils/json-schema.js";const a={$schema:`https://json-schema.org/draft/2020-12/schema`,type:`object`,properties:{assignments:{minItems:1,type:`array`,items:{type:`object`,properties:{hunkIndex:{type:`integer`,description:`Index of an unassigned hunk`},commitId:{type:`string`,minLength:1,description:`ID of the commit this hunk belongs to`}},required:[`hunkIndex`,`commitId`],additionalProperties:!1},description:`One entry per unassigned hunk`}},required:[`assignments`],additionalProperties:!1};function o(e){let{branches:t,mode:n,missingIndices:r,priorRepairs:i,context:a}=e;if(r.length>Math.max(2,a.hunks.length*.25))return;let o=new Map(a.hunks.map(e=>[e.index,e])),l=r.map(e=>o.get(e));if(l.some(e=>e===void 0))return;let u=t.flatMap(e=>e.commits.map(t=>n===`branches`?{id:t.id,message:t.message,branch:e.name,branchTitle:e.title}:{id:t.id,message:t.message}));if(u.length!==0)return{prompt:s({hunks:l.map(e=>e),commits:u,condensed:a.condensed,redactHunkContent:a.redactHunkContent,inputTokenBudget:a.inputTokenBudget}),apply:e=>c(e,{branches:t,missingIndices:r,priorRepairs:i})}}function s(e){let{hunks:i,commits:a,condensed:o,redactHunkContent:s,inputTokenBudget:c=t}=e,l=e=>{let t=JSON.stringify(i.map(t=>r(t,e?s?.(t)?`redacted`:`full`:`condensed`))),n=i.length===1?`hunk`:`hunks`,o=a.some(e=>e.branch!==void 0),c=JSON.stringify({assignments:[{hunkIndex:i[0].index,commitId:a[0].id}]},null,2);return`A grouping of code hunks into commits left ${i.length} ${n} unassigned. Decide which existing commit each one belongs to. Do not regroup anything else: the commits below are fixed, and every other hunk is already assigned.${o?` Each commit sits on the branch named next to it; choose the branch whose work the hunk belongs to, then the commit on it.`:``}
+
+<unassigned_hunks>
+${t}
+</unassigned_hunks>
+
+<commits>
+${JSON.stringify(a)}
+</commits>
+
+Return JSON inside <output> tags with exactly one entry per unassigned hunk — the ${i.length} indices above, no others — each pointing at one of the commit IDs above:
+<output>
+${c}
+</output>
+
+Return only the <output> tag and no other text.`};if(o)return l(!1);let u=l(!0);return n(u.length)>c?l(!1):u}function c(t,n){let{branches:r,missingIndices:o,priorRepairs:s}=n,c=e(t);if(!c)return{valid:!1,errors:[`Repair response has no <output> tag`]};let l;try{l=JSON.parse(c)}catch(e){return{valid:!1,errors:[`Repair response is not valid JSON: ${e instanceof Error?e.message:String(e)}`]}}let u=i(a,l);if(!u.success)return{valid:!1,errors:u.issues.map(e=>`Repair response ${e.path.join(`.`)}: ${e.message}`)};let d=new Set(r.flatMap(e=>e.commits.map(e=>e.id))),f=new Set(o),p=new Map,m=[];for(let{hunkIndex:e,commitId:t}of u.data.assignments){if(!f.has(e)){m.push(`Repair assigned hunk ${e}, which was not one of the unassigned hunks`);continue}if(p.has(e)){m.push(`Repair assigned hunk ${e} more than once`);continue}if(!d.has(t)){m.push(`Repair assigned hunk ${e} to unknown commit '${t}'`);continue}p.set(e,t)}let h=o.filter(e=>!p.has(e));if(h.length>0&&m.push(`Repair left hunks unassigned: ${h.join(`, `)}`),m.length>0)return{valid:!1,errors:m};let g={branches:r.map(e=>({...e,commits:e.commits.map(e=>{let t=[...p].filter(([,t])=>t===e.id).map(([e])=>e);return t.length===0?e:{...e,hunkIndices:[...e.hunkIndices,...t].sort((e,t)=>e-t)}})}))},_=[...p].sort(([e],[t])=>e-t).map(([e,t])=>`hunk ${e} → ${t}`).join(`; `);return{valid:!0,result:g,repairs:[...s??[],{kind:`missing-hunks`,hunkIndices:[...o].sort((e,t)=>e-t),detail:`Placed ${o.length} unassigned hunk(s) via a targeted repair call: ${_}`}]}}export{o as planMissingHunksRepair};

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

@@ -1,4 +1,5 @@
 import { ProgressEvent, TokenUsage, ValidationRepair } from "../../ai/types.js";
+import { AuthoringContext } from "../../context.js";
 import { BranchGroup, ComposeHunk, PromptOverride } from "../types.js";
 import { ConventionDescriptor } from "../../git/utils/conventions.js";
 import { OnAfterModelCall, OnBeforeModelCall, OnBeforePrompt } from "../ai-loop.js";
@@ -26,9 +27,24 @@ interface GroupingStrategy {
 }
 interface GroupInput {
   hunks?: ComposeHunk[];
+  /**
+   * Analysis to group against, in place of running `analyze` first. Rendered into the prompt as the
+   * authoritative breakdown of the change. Ignored in session mode, where the analysis is already
+   * in the conversation.
+   */
   analysis?: AnalysisResult;
+  /** One-line summaries of what individual hunks do, keyed by index. See `ComposeInput.hunkSummaries`. */
+  hunkSummaries?: Record<number, string>;
   commitMessages?: string[];
   instructions?: string;
+  /**
+   * What the author knows that the hunks cannot show — intent, issue text, per-file rationale,
+   * ordering constraints. Rendered into the prompt as escaped, tagged data, never as instructions;
+   * for guidance the model should act on, use {@link instructions}.
+   */
+  authoring?: AuthoringContext;
+  /** Send hunk metadata only, omitting every patch body. See `ComposeInput.condenseHunks`. */
+  condensed?: boolean;
   conventions?: ConventionDescriptor;
   /** "commits" = flat commit list (no branch naming). "branches" = AI decides branches (default). */
   mode?: 'commits' | 'branches';
@@ -70,7 +86,7 @@ interface GroupOutput {
   /** Hunks condensed to metadata to fit the input-token budget. Undefined when the AI call was skipped. */
   hunksCondensedCount?: number;
   /**
-   * Deterministic repairs applied to the accepted AI response instead of spending a retry on it.
+   * Repairs applied to the accepted AI response instead of spending a retry on it.
    * Undefined when the response needed no repair.
    */
   repairs?: ValidationRepair[];

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

@@ -1,5 +1,6 @@
 import { ValidationResult } from "../ai-loop.js";
 import { GroupingResult } from "./types.js";
+import { MissingHunksRepairContext } from "./repair.js";
 
 //#region src/tasks/group/validator.d.ts
 interface GroupValidationOptions {
@@ -9,6 +10,11 @@ interface GroupValidationOptions {
    * be told the hunk is missing or duplicated when it did neither.
    */
   lockedCommitIds?: ReadonlySet<string>;
+  /**
+   * Enables the targeted repair for a response that left hunks unassigned. Omit it and such a
+   * response is rejected outright, as it was before the repair existed.
+   */
+  repairContext?: MissingHunksRepairContext;
 }
 declare function validateGroupResponse(responseText: string, expectedHunkIndices: ReadonlySet<number>, mode?: 'commits' | 'branches', existingBranchNames?: Set<string>, options?: GroupValidationOptions): ValidationResult<GroupingResult>;
 //#endregion

package/dist/tasks/group/validator.js

@@ -1,9 +1,9 @@
-import{extractOutputTag as e}from"../ai-loop.js";import{validateJsonSchema as t}from"../utils/json-schema.js";import{groupingResultJsonSchema as n}from"./schema.js";function r(r,o,s=`branches`,c,l){let u=null;try{if(u=e(r),!u)return i([`No <output> tag found in response`],a(s));let d=t(n,JSON.parse(u));if(!d.success)return i(d.issues.map(e=>`${e.path.join(`.`)}: ${e.message}`),a(s));let f=d.data,p=[],m=new Set,h=[],g=new Map,_=new Map,v=new Set,y=[],b=[],x=[],S=new Set,C=new Set;for(let e of f.branches){if(S.has(e.id))return i([`Duplicate branch ID: '${e.id}'`],a(s));if(S.add(e.id),s===`branches`&&e.name.length===0)return i([`Branch '${e.id}': missing or empty 'name'`],a(s));if(s===`branches`&&e.name.length>0){if(C.has(e.name))return i([`Duplicate branch name: '${e.name}'`],`Multiple branches use the name '${e.name}'. Each branch must have a unique name. Please rename one of them.`);if(C.add(e.name),c?.has(e.name))return i([`Branch name '${e.name}' already exists in the repository`],`The branch name '${e.name}' already exists in the repository. Please choose a different name for branch '${e.id}'.`)}for(let t of e.commits){v.has(t.id)&&y.push(t.id),v.add(t.id);let n=s===`branches`?`${e.id}/${t.id}`:t.id;for(let r of t.hunks){let i=g.get(r);i?i.push(n):g.set(r,[n]);let a=_.get(r);a?a.push({branchId:e.id,commitId:t.id,label:n}):_.set(r,[{branchId:e.id,commitId:t.id,label:n}])}}}let w=new Map,T=[],E=!1;for(let[e,t]of _){if(t.length<2)continue;if(h.push(e),s===`branches`&&new Set(t.map(e=>e.branchId)).size>1){E=!0;continue}let n=t.find(e=>l?.lockedCommitIds?.has(e.commitId))??t[0];w.set(e,n.label),T.push({hunkIndex:e,keptIn:n.label,droppedFrom:t.filter(e=>e!==n).map(e=>e.label),scope:new Set(t.map(e=>e.commitId)).size===1?`within-commit`:`across-commits`})}let D=h.length>0&&!E;for(let e of f.branches){let t=[];for(let n of e.commits){let r=s===`branches`?`${e.id}/${n.id}`:n.id,i=[],a=!1;for(let e of n.hunks){if(w.has(e)&&w.get(e)!==r){a=!0;continue}m.has(e)||(m.add(e),i.push(e))}n.hunks.length===0?b.push(n.id):i.length===0&&a&&x.push(n.id),t.push({id:n.id,message:n.message,explanation:n.explanation,hunkIndices:i})}p.push({id:e.id,name:e.name,title:e.title,description:e.description,commits:t})}if(y.length>0)return i([`Duplicate commit IDs: ${y.join(`, `)}`],`Some commit IDs appear multiple times. Each must be unique.\n\nDuplicates: ${y.join(`, `)}`);if(b.length>0)return i([`Empty commits (no hunks assigned): ${b.join(`, `)}`],`Every commit must contain at least one hunk. These commits have an empty \`hunks\` array: ${b.join(`, `)}.
+import{extractOutputTag as e}from"../ai-loop.js";import{validateJsonSchema as t}from"../utils/json-schema.js";import{planMissingHunksRepair as n}from"./repair.js";import{groupingResultJsonSchema as r}from"./schema.js";function i(i,s,c=`branches`,l,u){let d=null;try{if(d=e(i),!d)return a([`No <output> tag found in response`],o(c));let f=t(r,JSON.parse(d));if(!f.success)return a(f.issues.map(e=>`${e.path.join(`.`)}: ${e.message}`),o(c));let p=f.data,m=[],h=new Set,g=[],_=new Map,v=new Map,y=new Set,b=[],x=[],S=[],C=new Set,w=new Set;for(let e of p.branches){if(C.has(e.id))return a([`Duplicate branch ID: '${e.id}'`],o(c));if(C.add(e.id),c===`branches`&&e.name.length===0)return a([`Branch '${e.id}': missing or empty 'name'`],o(c));if(c===`branches`&&e.name.length>0){if(w.has(e.name))return a([`Duplicate branch name: '${e.name}'`],`Multiple branches use the name '${e.name}'. Each branch must have a unique name. Please rename one of them.`);if(w.add(e.name),l?.has(e.name))return a([`Branch name '${e.name}' already exists in the repository`],`The branch name '${e.name}' already exists in the repository. Please choose a different name for branch '${e.id}'.`)}for(let t of e.commits){y.has(t.id)&&b.push(t.id),y.add(t.id);let n=c===`branches`?`${e.id}/${t.id}`:t.id;for(let r of t.hunks){let i=_.get(r);i?i.push(n):_.set(r,[n]);let a=v.get(r);a?a.push({branchId:e.id,commitId:t.id,label:n}):v.set(r,[{branchId:e.id,commitId:t.id,label:n}])}}}let T=new Map,E=[],D=!1;for(let[e,t]of v){if(t.length<2)continue;if(g.push(e),c===`branches`&&new Set(t.map(e=>e.branchId)).size>1){D=!0;continue}let n=t.find(e=>u?.lockedCommitIds?.has(e.commitId))??t[0];T.set(e,n.label),E.push({hunkIndex:e,keptIn:n.label,droppedFrom:t.filter(e=>e!==n).map(e=>e.label),scope:new Set(t.map(e=>e.commitId)).size===1?`within-commit`:`across-commits`})}let O=g.length>0&&!D;for(let e of p.branches){let t=[];for(let n of e.commits){let r=c===`branches`?`${e.id}/${n.id}`:n.id,i=[],a=!1;for(let e of n.hunks){if(T.has(e)&&T.get(e)!==r){a=!0;continue}h.has(e)||(h.add(e),i.push(e))}n.hunks.length===0?x.push(n.id):i.length===0&&a&&S.push(n.id),t.push({id:n.id,message:n.message,explanation:n.explanation,hunkIndices:i})}m.push({id:e.id,name:e.name,title:e.title,description:e.description,commits:t})}if(b.length>0)return a([`Duplicate commit IDs: ${b.join(`, `)}`],`Some commit IDs appear multiple times. Each must be unique.\n\nDuplicates: ${b.join(`, `)}`);if(x.length>0)return a([`Empty commits (no hunks assigned): ${x.join(`, `)}`],`Every commit must contain at least one hunk. These commits have an empty \`hunks\` array: ${x.join(`, `)}.
 
-Either assign at least one hunk to each of these commits, or remove them entirely. If a commit's purpose is already covered by another commit, remove the duplicate. If a commit is supposed to cover specific hunks, assign those hunk indices to it. Every hunk index still needs to appear in exactly one commit.`);let O=[...o].filter(e=>!m.has(e)).sort((e,t)=>e-t),k=[...m].filter(e=>!o.has(e)).sort((e,t)=>e-t),A=[...new Set(h)].sort((e,t)=>e-t),j=A.length>0&&!D;if(O.length>0||k.length>0||x.length>0||j){let e=[],t=[];if(A.length>0){let n=A.map(e=>`  hunk ${e} → ${(g.get(e)??[]).join(`, `)}`).join(`
-`);e.push(`Duplicate hunks (each must appear in exactly ONE commit):\n${n}`),t.push(`Duplicate hunks: ${A.join(`, `)}`)}O.length>0&&(e.push(`Missing hunks (not assigned to any commit): ${O.join(`, `)}`),t.push(`Missing hunks: ${O.join(`, `)}`)),k.length>0&&(e.push(`Extra hunks (not present in the input): ${k.join(`, `)}`),t.push(`Extra hunks: ${k.join(`, `)}`)),x.length>0&&(e.push(`Commits whose only hunks were already claimed by an earlier commit: ${x.join(`, `)}`),t.push(`Empty commits after dropping duplicate hunks: ${x.join(`, `)}`));let n=[...o].sort((e,t)=>e-t),r=[...g.values()].reduce((e,t)=>e+t.length,0);return i(t,`There are ${n.length} hunks, with indices: ${n.join(`, `)}. Every one of these indices must appear in exactly one commit — no duplicates, no omissions, no other indices. Use the indices exactly as given; do not renumber them.
+Either assign at least one hunk to each of these commits, or remove them entirely. If a commit's purpose is already covered by another commit, remove the duplicate. If a commit is supposed to cover specific hunks, assign those hunk indices to it. Every hunk index still needs to appear in exactly one commit.`);let k=[...s].filter(e=>!h.has(e)).sort((e,t)=>e-t),A=[...h].filter(e=>!s.has(e)).sort((e,t)=>e-t),j=[...new Set(g)].sort((e,t)=>e-t),M=[...E].sort((e,t)=>e.hunkIndex-t.hunkIndex),N=M.length>0?{kind:`duplicate-hunks`,hunkIndices:M.map(e=>e.hunkIndex),claims:M,detail:`Dropped duplicate claims on ${M.length} hunk(s): ${M.map(e=>`hunk ${e.hunkIndex} kept in ${e.keptIn}`).join(`; `)}`}:void 0,P=j.length>0&&!O;if(k.length>0||A.length>0||S.length>0||P){let e=[],t=[];if(j.length>0){let n=j.map(e=>`  hunk ${e} → ${(_.get(e)??[]).join(`, `)}`).join(`
+`);e.push(`Duplicate hunks (each must appear in exactly ONE commit):\n${n}`),t.push(`Duplicate hunks: ${j.join(`, `)}`)}k.length>0&&(e.push(`Missing hunks (not assigned to any commit): ${k.join(`, `)}`),t.push(`Missing hunks: ${k.join(`, `)}`)),A.length>0&&(e.push(`Extra hunks (not present in the input): ${A.join(`, `)}`),t.push(`Extra hunks: ${A.join(`, `)}`)),S.length>0&&(e.push(`Commits whose only hunks were already claimed by an earlier commit: ${S.join(`, `)}`),t.push(`Empty commits after dropping duplicate hunks: ${S.join(`, `)}`));let r=[...s].sort((e,t)=>e-t),i=[..._.values()].reduce((e,t)=>e+t.length,0),o=`There are ${r.length} hunks, with indices: ${r.join(`, `)}. Every one of these indices must appear in exactly one commit — no duplicates, no omissions, no other indices. Use the indices exactly as given; do not renumber them.
 
-Your response listed ${r} hunk references across ${g.size} unique indices. Expected: ${n.length} references across ${n.length} unique indices.
+Your response listed ${i} hunk references across ${_.size} unique indices. Expected: ${r.length} references across ${r.length} unique indices.
 
 Specific problems:
 ${e.map(e=>`- ${e}`).join(`
@@ -11,7 +11,7 @@ ${e.map(e=>`- ${e}`).join(`
 
 To fix duplicates: for each duplicated hunk index, decide which one commit it truly belongs in and remove it from the others. Do not split a single hunk across two commits — git only knows how to apply a hunk once.
 
-Return the corrected JSON inside <output> tags.`)}if(T.length>0){let e=[...T].sort((e,t)=>e.hunkIndex-t.hunkIndex),t=e.map(e=>`hunk ${e.hunkIndex} kept in ${e.keptIn}`).join(`; `);return{valid:!0,result:{branches:p},repairs:[{kind:`duplicate-hunks`,hunkIndices:e.map(e=>e.hunkIndex),claims:e,detail:`Dropped duplicate claims on ${e.length} hunk(s): ${t}`}]}}return{valid:!0,result:{branches:p}}}catch(e){let t=e instanceof Error?e.message:String(e),n=(u??r).slice(-300);return i([`Failed to parse response as valid JSON: ${t}`,`Response tail: ${n}`],a(s))}}function i(e,t){return{valid:!1,errors:e,retryFeedback:t}}function a(e){return e===`commits`?`Your response has an invalid structure. Please return JSON inside <output> tags. Use a single branch with id "default", name "", description "":
+Return the corrected JSON inside <output> tags.`;if(u?.repairContext&&k.length>0&&A.length===0&&S.length===0&&!P){let e=n({branches:m,mode:c,missingIndices:k,priorRepairs:N?[N]:void 0,context:u.repairContext});if(e)return{...a(t,o),repair:e}}return a(t,o)}return N?{valid:!0,result:{branches:m},repairs:[N]}:{valid:!0,result:{branches:m}}}catch(e){let t=e instanceof Error?e.message:String(e),n=(d??i).slice(-300);return a([`Failed to parse response as valid JSON: ${t}`,`Response tail: ${n}`],o(c))}}function a(e,t){return{valid:!1,errors:e,retryFeedback:t}}function o(e){return e===`commits`?`Your response has an invalid structure. Please return JSON inside <output> tags. Use a single branch with id "default", name "", description "":
 <output>
 {
   "branches": [
@@ -55,4 +55,4 @@ Return only the <output> tag and no other text.`:`Your response has an invalid s
 }
 </output>
 
-Return only the <output> tag and no other text.`}export{r as validateGroupResponse};
+Return only the <output> tag and no other text.`}export{i as validateGroupResponse};

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

@@ -1,3 +1,4 @@
+import { AuthoringContext } from "../../context.js";
 import { ComposeHunk } from "../types.js";
 import { ConventionDescriptor } from "../../git/utils/conventions.js";
 import { RedactHunkContent } from "../utils/redact.js";
@@ -12,7 +13,8 @@ declare function buildQuickComposeUserPrompt(params: {
   branchName?: string;
   baseBranch?: string;
   issueUrl?: string;
-  pullRequestUrl?: string;
+  pullRequestUrl?: string; /** What the author knows that the hunks cannot show. Rendered as escaped, tagged data. */
+  authoring?: AuthoringContext;
   instructions?: string;
   redactHunkContent?: RedactHunkContent;
 }): string;