@gitkraken/compose-tools 0.4.0 → 0.6.0

package/dist/tasks/partition/prompt.js

@@ -1,4 +1,4 @@
-import{partitionResultSchema as e}from"./schema.js";import{z as t}from"zod";const n=JSON.stringify(t.toJSONSchema(e),null,2);function r(e,t){let r=e?.branches&&e.branches.format!==`unknown`?`For each sub-branch, name it following the repository's branch naming conventions.\n\n${e.promptFragment}`:`For each sub-branch, provide a branch name derived from the source branch name (e.g., "feature/part-1-description").`;return`You are an advanced AI programming assistant tasked with determining whether an ordered list of commits on a single branch should be subdivided into stacked branches for a pull request workflow.
+import{partitionResultJsonSchema as e}from"./schema.js";const t=JSON.stringify(e,null,2);function n(e,n){let i=e?.branches&&e.branches.format!==`unknown`?`For each sub-branch, name it following the repository's branch naming conventions.\n\n${e.promptFragment}`:`For each sub-branch, provide a branch name derived from the source branch name (e.g., "feature/part-1-description").`;return`You are an advanced AI programming assistant tasked with determining whether an ordered list of commits on a single branch should be subdivided into stacked branches for a pull request workflow.
 
 Your goal is to examine the commits and decide whether they form one cohesive unit or whether there are natural subdivision points that would benefit from stacked PRs.
 
@@ -9,9 +9,9 @@ Rules:
 4. A single sub-branch (no subdivision) is a perfectly valid and common outcome
 5. A single-commit sub-branch is valid if that commit is independently mergeable
 
-${i(t?.splitting)}
+${r(n?.splitting)}
 
-${r}
+${i}
 - A short PR-style title (under 72 characters, imperative mood)
 - A description of what the sub-branch accomplishes
 - The commit IDs it contains (in order)
@@ -21,10 +21,10 @@ ${r}
 Output your partition as JSON inside a <output> tag matching this schema:
 
 \`\`\`json
-${n}
+${t}
 \`\`\`
 
-Return only the <output> tag and no other text.`}function i(e){let t=`Consider merge-order preference: even if sub-groups compile independently, keep them together if merging one without the other would be incomplete or confusing to reviewers.`;return e===`conservative`?`Keep commits as a single branch unless the sub-groups address completely different concerns with no merge-order preference between them.
+Return only the <output> tag and no other text.`}function r(e){let t=`Consider merge-order preference: even if sub-groups compile independently, keep them together if merging one without the other would be incomplete or confusing to reviewers.`;return e===`conservative`?`Keep commits as a single branch unless the sub-groups address completely different concerns with no merge-order preference between them.
 ${t}
 Changes addressing the same pattern across different files should stay together. When in doubt, do not partition.`:e===`aggressive`?`Subdivide whenever there is a clear concern boundary between contiguous groups of commits. Each sub-group should be as focused as possible.
 ${t}
@@ -34,10 +34,10 @@ Do NOT partition just because commits are distinct. A branch with a refactor com
 
 Changes addressing the same pattern across different files should stay together. For example, applying a similar fix to multiple functions belongs in one branch, not split across multiple stacked PRs.
 
-${t}`}function a(e){let{commits:t,orderedCommitIds:n,sourceBranchName:r,baseBranch:i,instructions:a}=e,o=n.map(e=>{let n=t.find(t=>t.id===e);return n?{id:n.id,message:n.message,explanation:n.explanation}:{id:e,message:`unknown`,explanation:``}}),s=`Determine whether these ordered commits should be subdivided into stacked branches:\n\n<commits>\n${JSON.stringify(o)}\n</commits>`,c=[];return r&&c.push(`Source branch: ${r}`),i&&c.push(`Base branch: ${i}`),c.length>0&&(s+=`\n\n<context>\n${c.join(`
+${t}`}function i(e){let{commits:t,orderedCommitIds:n,sourceBranchName:r,baseBranch:i,instructions:a}=e,o=n.map(e=>{let n=t.find(t=>t.id===e);return n?{id:n.id,message:n.message,explanation:n.explanation}:{id:e,message:`unknown`,explanation:``}}),s=`Determine whether these ordered commits should be subdivided into stacked branches:\n\n<commits>\n${JSON.stringify(o)}\n</commits>`,c=[];return r&&c.push(`Source branch: ${r}`),i&&c.push(`Base branch: ${i}`),c.length>0&&(s+=`\n\n<context>\n${c.join(`
 `)}\n</context>`),a&&(s+=`\n\nAdditional instructions:\n${a}`),s+=`
 
-Return the partition. Return only the <output> tag and no other text.`,s}function o(e){let t=s(e.strategy);return e.sourceBranchName&&(t+=`\n\nSource branch: ${e.sourceBranchName}`),e.baseBranch&&(t+=`\nBase branch: ${e.baseBranch}`),e.conventions?.promptFragment&&(t+=`\n\n${e.conventions.promptFragment}`),e.instructions&&(t+=`\n\nAdditional instructions:\n${e.instructions}`),t+=`
+Return the partition. Return only the <output> tag and no other text.`,s}function a(e){let t=o(e.strategy);return e.sourceBranchName&&(t+=`\n\nSource branch: ${e.sourceBranchName}`),e.baseBranch&&(t+=`\nBase branch: ${e.baseBranch}`),e.conventions?.promptFragment&&(t+=`\n\n${e.conventions.promptFragment}`),e.instructions&&(t+=`\n\nAdditional instructions:\n${e.instructions}`),t+=`
 
 Return the partition as JSON inside <output> tags:
 <output>
@@ -49,7 +49,7 @@ Return the partition as JSON inside <output> tags:
 }
 </output>
 
-Return only the <output> tag and no other text.`,t}function s(e){let t=e?.splitting??`balanced`,n=`Based on the ordered commits for this branch, determine whether they should be subdivided into stacked sub-branches. Each sub-branch must be a contiguous range of commits.`,r=`Consider merge-order preference: even if sub-groups compile independently, keep them together if merging one without the other would be incomplete or confusing.`;return t===`conservative`?`${n}
+Return only the <output> tag and no other text.`,t}function o(e){let t=e?.splitting??`balanced`,n=`Based on the ordered commits for this branch, determine whether they should be subdivided into stacked sub-branches. Each sub-branch must be a contiguous range of commits.`,r=`Consider merge-order preference: even if sub-groups compile independently, keep them together if merging one without the other would be incomplete or confusing.`;return t===`conservative`?`${n}
 
 Keep as a single branch unless sub-groups address completely different concerns with no merge-order preference. ${r}
 When in doubt, do not partition.`:t===`aggressive`?`${n}
@@ -58,4 +58,4 @@ Subdivide whenever there is a clear concern boundary. Each stacked PR should tel
 
 Only subdivide when the sub-groups are independently reviewable AND independently mergeable, and a reviewer would genuinely benefit from separate PRs. Do NOT partition just because commits are distinct — a refactor followed by a feature using it is a coherent single PR.
 
-${r}`}export{o as buildPartitionContinuationPrompt,r as buildPartitionSystemPrompt,a as buildPartitionUserPrompt};
+${r}`}export{a as buildPartitionContinuationPrompt,n as buildPartitionSystemPrompt,i as buildPartitionUserPrompt};

package/dist/tasks/partition/schema.d.ts

@@ -1,14 +1,48 @@
-import { z } from "zod";
-
 //#region src/tasks/partition/schema.d.ts
-declare const partitionResultSchema: z.ZodObject<{
-  partitions: z.ZodArray<z.ZodObject<{
-    branchName: z.ZodString;
-    title: z.ZodString;
-    description: z.ZodString;
-    commitIds: z.ZodArray<z.ZodString>;
-  }, z.core.$strip>>;
-  rationale: z.ZodString;
-}, z.core.$strip>;
+declare const partitionResultJsonSchema: {
+  readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+  readonly type: "object";
+  readonly properties: {
+    readonly partitions: {
+      readonly minItems: 1;
+      readonly type: "array";
+      readonly items: {
+        readonly type: "object";
+        readonly properties: {
+          readonly branchName: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly description: "Valid git branch name";
+          };
+          readonly title: {
+            readonly type: "string";
+            readonly description: "Short PR-style title for this sub-branch (under 72 chars, imperative mood, e.g. 'Refactor authentication middleware')";
+          };
+          readonly description: {
+            readonly type: "string";
+            readonly description: "What this sub-branch accomplishes";
+          };
+          readonly commitIds: {
+            readonly minItems: 1;
+            readonly type: "array";
+            readonly items: {
+              readonly type: "string";
+            };
+            readonly description: "Commit IDs in this partition (contiguous range)";
+          };
+        };
+        readonly required: readonly ["branchName", "title", "description", "commitIds"];
+        readonly additionalProperties: false;
+      };
+      readonly description: "Contiguous partitions of commits into stacked branches";
+    };
+    readonly rationale: {
+      readonly type: "string";
+      readonly description: "Explanation of why this partition was chosen";
+    };
+  };
+  readonly required: readonly ["partitions", "rationale"];
+  readonly additionalProperties: false;
+};
 //#endregion
-export { partitionResultSchema };
+export { partitionResultJsonSchema };

package/dist/tasks/partition/schema.js

@@ -1 +1 @@
-import{z as e}from"zod";const t=e.object({branchName:e.string().min(1).describe(`Valid git branch name`),title:e.string().describe(`Short PR-style title for this sub-branch (under 72 chars, imperative mood, e.g. 'Refactor authentication middleware')`),description:e.string().describe(`What this sub-branch accomplishes`),commitIds:e.array(e.string()).min(1).describe(`Commit IDs in this partition (contiguous range)`)}),n=e.object({partitions:e.array(t).min(1).describe(`Contiguous partitions of commits into stacked branches`),rationale:e.string().describe(`Explanation of why this partition was chosen`)});export{n as partitionResultSchema};
+const e={$schema:`https://json-schema.org/draft/2020-12/schema`,type:`object`,properties:{partitions:{minItems:1,type:`array`,items:{type:`object`,properties:{branchName:{type:`string`,minLength:1,description:`Valid git branch name`},title:{type:`string`,description:`Short PR-style title for this sub-branch (under 72 chars, imperative mood, e.g. 'Refactor authentication middleware')`},description:{type:`string`,description:`What this sub-branch accomplishes`},commitIds:{minItems:1,type:`array`,items:{type:`string`},description:`Commit IDs in this partition (contiguous range)`}},required:[`branchName`,`title`,`description`,`commitIds`],additionalProperties:!1},description:`Contiguous partitions of commits into stacked branches`},rationale:{type:`string`,description:`Explanation of why this partition was chosen`}},required:[`partitions`,`rationale`],additionalProperties:!1};export{e as partitionResultJsonSchema};

package/dist/tasks/partition/validator.js

@@ -1,4 +1,4 @@
-import{extractOutputTag as e}from"../ai-loop.js";import{partitionResultSchema as t}from"./schema.js";function n(n,s,c){let l=null;try{if(l=e(n),!l)return a([`No <output> tag found in response`],o());let u=JSON.parse(l),d=t.safeParse(u);if(!d.success)return a(d.error.issues.map(e=>`${e.path.join(`.`)}: ${e.message}`),o());let f=d.data,p=[],m=[],h=new Set;for(let e=0;e<f.partitions.length;e++){let t=f.partitions[e];if(!i(t.branchName))return a([`Partition ${e}: '${t.branchName}' is not a valid git branch name`],`The branch name '${t.branchName}' is invalid. Git branch names cannot contain spaces, '..', '~', '^', ':', '\\', or end with '.lock'. Please provide a valid name.`);if(h.has(t.branchName))return a([`Duplicate partition branch name: '${t.branchName}'`],`Multiple partitions use the branch name '${t.branchName}'. Each partition must have a unique branch name. Please rename one of them.`);if(h.add(t.branchName),c?.has(t.branchName))return a([`Branch name '${t.branchName}' already exists in the repository`],`The branch name '${t.branchName}' already exists in the repository. Please choose a different name for partition ${e}.`);for(let e of t.commitIds)m.push(e);p.push({branchName:t.branchName,title:t.title,description:t.description,commitIds:t.commitIds})}let g=new Set,_=[];for(let e of m)g.has(e)&&_.push(e),g.add(e);if(_.length>0)return a([`Duplicate commit IDs: ${_.join(`, `)}`],`Some commits appear in multiple partitions. Each must be in exactly one.\n\nDuplicates: ${_.join(`, `)}`);let v=new Set(s),y=s.filter(e=>!g.has(e)),b=m.filter(e=>!v.has(e));return y.length>0?a([`Missing commits: ${y.join(`, `)}`],`Some commits are not assigned to any partition.\n\nMissing: ${y.join(`, `)}`):b.length>0?a([`Unknown commits: ${b.join(`, `)}`],`Some commit IDs don't match any known commit.\n\nUnknown: ${b.join(`, `)}`):r(p,s)?{valid:!0,result:{partitions:p,rationale:f.rationale}}:a([`Partitions are not contiguous`],`Each partition must contain a contiguous range of commits in the provided order. Please regroup into contiguous ranges.`)}catch(e){let t=e instanceof Error?e.message:String(e),r=(l??n).slice(-300);return a([`Failed to parse response as valid JSON: ${t}`,`Response tail: ${r}`],o())}}function r(e,t){let n=new Map(t.map((e,t)=>[e,t])),r=0;for(let t of e)for(let e of t.commitIds){let t=n.get(e);if(t===void 0||t!==r)return!1;r++}return r===t.length}function i(e){return e.startsWith(`-`)||e.startsWith(`.`)||e.endsWith(`.lock`)||e.endsWith(`.`)||e.endsWith(`/`)||e.includes(`..`)||e.includes(`~`)||e.includes(`^`)||e.includes(`:`)||e.includes(`\\`)||e.includes(` `)||e.includes(`?`)||e.includes(`*`)||e.includes(`[`)||e.includes(`@{`)?!1:e.length>0}function a(e,t){return{valid:!1,errors:e,retryFeedback:t}}function o(){return`Your response has an invalid structure. Return JSON inside <output> tags:
+import{extractOutputTag as e}from"../ai-loop.js";import{validateJsonSchema as t}from"../utils/json-schema.js";import{partitionResultJsonSchema as n}from"./schema.js";function r(r,c,l){let u=null;try{if(u=e(r),!u)return o([`No <output> tag found in response`],s());let d=t(n,JSON.parse(u));if(!d.success)return o(d.issues.map(e=>`${e.path.join(`.`)}: ${e.message}`),s());let f=d.data,p=[],m=[],h=new Set;for(let e=0;e<f.partitions.length;e++){let t=f.partitions[e];if(!a(t.branchName))return o([`Partition ${e}: '${t.branchName}' is not a valid git branch name`],`The branch name '${t.branchName}' is invalid. Git branch names cannot contain spaces, '..', '~', '^', ':', '\\', or end with '.lock'. Please provide a valid name.`);if(h.has(t.branchName))return o([`Duplicate partition branch name: '${t.branchName}'`],`Multiple partitions use the branch name '${t.branchName}'. Each partition must have a unique branch name. Please rename one of them.`);if(h.add(t.branchName),l?.has(t.branchName))return o([`Branch name '${t.branchName}' already exists in the repository`],`The branch name '${t.branchName}' already exists in the repository. Please choose a different name for partition ${e}.`);for(let e of t.commitIds)m.push(e);p.push({branchName:t.branchName,title:t.title,description:t.description,commitIds:t.commitIds})}let g=new Set,_=[];for(let e of m)g.has(e)&&_.push(e),g.add(e);if(_.length>0)return o([`Duplicate commit IDs: ${_.join(`, `)}`],`Some commits appear in multiple partitions. Each must be in exactly one.\n\nDuplicates: ${_.join(`, `)}`);let v=new Set(c),y=c.filter(e=>!g.has(e)),b=m.filter(e=>!v.has(e));return y.length>0?o([`Missing commits: ${y.join(`, `)}`],`Some commits are not assigned to any partition.\n\nMissing: ${y.join(`, `)}`):b.length>0?o([`Unknown commits: ${b.join(`, `)}`],`Some commit IDs don't match any known commit.\n\nUnknown: ${b.join(`, `)}`):i(p,c)?{valid:!0,result:{partitions:p,rationale:f.rationale}}:o([`Partitions are not contiguous`],`Each partition must contain a contiguous range of commits in the provided order. Please regroup into contiguous ranges.`)}catch(e){let t=e instanceof Error?e.message:String(e),n=(u??r).slice(-300);return o([`Failed to parse response as valid JSON: ${t}`,`Response tail: ${n}`],s())}}function i(e,t){let n=new Map(t.map((e,t)=>[e,t])),r=0;for(let t of e)for(let e of t.commitIds){let t=n.get(e);if(t===void 0||t!==r)return!1;r++}return r===t.length}function a(e){return e.startsWith(`-`)||e.startsWith(`.`)||e.endsWith(`.lock`)||e.endsWith(`.`)||e.endsWith(`/`)||e.includes(`..`)||e.includes(`~`)||e.includes(`^`)||e.includes(`:`)||e.includes(`\\`)||e.includes(` `)||e.includes(`?`)||e.includes(`*`)||e.includes(`[`)||e.includes(`@{`)?!1:e.length>0}function o(e,t){return{valid:!1,errors:e,retryFeedback:t}}function s(){return`Your response has an invalid structure. Return JSON inside <output> tags:
 <output>
 {
   "partitions": [
@@ -8,4 +8,4 @@ import{extractOutputTag as e}from"../ai-loop.js";import{partitionResultSchema as
 }
 </output>
 
-Return only the <output> tag and no other text.`}export{n as validatePartitionResponse};
+Return only the <output> tag and no other text.`}export{r as validatePartitionResponse};

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

@@ -1,8 +1,7 @@
-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:
+import{hunkContentForPrompt as e}from"../utils/redact.js";import{quickComposeResultJsonSchema as t}from"./schema.js";const n=JSON.stringify(t,null,2);function r(e,t=`branches`,r,i=!1){let c=`Write commit messages:\n${e?.commits.bodyStyle===`minimal`?`Each commit message is a single subject line with no body: concise, 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.`:`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=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.
+- **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.`}${e?.promptFragment?`\n\n${e.promptFragment}`:``}`,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.
 
 ## Your task
 
@@ -13,7 +12,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
-${a}
+${c}
 ${l}
 ${u}
 ${d}
@@ -36,21 +35,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
-${r}
+${n}
 \`\`\`
 
-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:
+Return only the <output> tag and no other text.`}function i(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(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.`,d}function o(e){return e===`consolidated`?`
+Return only the <output> tag and no other text.`,d}function a(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 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`
+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`
 ## 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{i as buildQuickComposeSystemPrompt,a as buildQuickComposeUserPrompt};
+- Single partition (no split) is a valid outcome.`}export{r as buildQuickComposeSystemPrompt,i as buildQuickComposeUserPrompt};

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

@@ -1,27 +1,144 @@
-import { z } from "zod";
-
 //#region src/tasks/quick-compose/schema.d.ts
-declare const quickComposeResultSchema: z.ZodObject<{
-  branches: z.ZodArray<z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodString;
-    title: z.ZodString;
-    description: z.ZodString;
-    commits: z.ZodArray<z.ZodObject<{
-      id: z.ZodString;
-      message: z.ZodString;
-      explanation: z.ZodString;
-      hunks: z.ZodArray<z.ZodNumber>;
-    }, z.core.$strip>>;
-    orderedCommitIds: z.ZodArray<z.ZodString>;
-    partitions: z.ZodOptional<z.ZodArray<z.ZodObject<{
-      branchName: z.ZodString;
-      title: z.ZodString;
-      description: z.ZodString;
-      commitIds: z.ZodArray<z.ZodString>;
-    }, z.core.$strip>>>;
-  }, z.core.$strip>>;
-  rationale: z.ZodString;
-}, z.core.$strip>;
+/** Shape of the LLM JSON output before the validator maps it to public types (`hunks` → `hunkIndices`). */
+interface QuickComposeWire {
+  branches: QuickComposeWireBranch[];
+  rationale: string;
+}
+interface QuickComposeWireBranch {
+  id: string;
+  name: string;
+  title: string;
+  description: string;
+  commits: QuickComposeWireCommit[];
+  orderedCommitIds: string[];
+  partitions?: QuickComposeWirePartition[];
+}
+interface QuickComposeWireCommit {
+  id: string;
+  message: string;
+  explanation: string;
+  hunks: number[];
+}
+interface QuickComposeWirePartition {
+  branchName: string;
+  title: string;
+  description: string;
+  commitIds: string[];
+}
+declare const quickComposeResultJsonSchema: {
+  readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+  readonly type: "object";
+  readonly properties: {
+    readonly branches: {
+      readonly minItems: 1;
+      readonly type: "array";
+      readonly items: {
+        readonly type: "object";
+        readonly properties: {
+          readonly id: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly description: "Unique branch ID";
+          };
+          readonly name: {
+            readonly type: "string";
+            readonly description: "Branch name (empty string for commits-only mode)";
+          };
+          readonly title: {
+            readonly type: "string";
+            readonly description: "Short PR-style title (under 72 chars, imperative mood)";
+          };
+          readonly description: {
+            readonly type: "string";
+            readonly description: "What this branch accomplishes";
+          };
+          readonly commits: {
+            readonly minItems: 1;
+            readonly type: "array";
+            readonly items: {
+              readonly type: "object";
+              readonly properties: {
+                readonly id: {
+                  readonly type: "string";
+                  readonly description: "Unique commit ID (e.g. commit-1)";
+                };
+                readonly message: {
+                  readonly type: "string";
+                  readonly description: "Commit message";
+                };
+                readonly explanation: {
+                  readonly type: "string";
+                  readonly description: "Detailed explanation of the commit";
+                };
+                readonly hunks: {
+                  readonly type: "array";
+                  readonly items: {
+                    readonly type: "integer";
+                    readonly minimum: -9007199254740991;
+                    readonly maximum: 9007199254740991;
+                    readonly description: "Hunk index";
+                  };
+                  readonly description: "Hunk indices included in this commit";
+                };
+              };
+              readonly required: readonly ["id", "message", "explanation", "hunks"];
+              readonly additionalProperties: false;
+            };
+            readonly description: "Commits in this branch";
+          };
+          readonly orderedCommitIds: {
+            readonly minItems: 1;
+            readonly type: "array";
+            readonly items: {
+              readonly type: "string";
+            };
+            readonly description: "Commit IDs in optimal order";
+          };
+          readonly partitions: {
+            readonly description: "Stacked sub-branches (only for multi-branch mode)";
+            readonly type: "array";
+            readonly items: {
+              readonly type: "object";
+              readonly properties: {
+                readonly branchName: {
+                  readonly type: "string";
+                  readonly minLength: 1;
+                  readonly description: "Git branch name for this partition";
+                };
+                readonly title: {
+                  readonly type: "string";
+                  readonly description: "Short PR-style title";
+                };
+                readonly description: {
+                  readonly type: "string";
+                  readonly description: "What this partition accomplishes";
+                };
+                readonly commitIds: {
+                  readonly minItems: 1;
+                  readonly type: "array";
+                  readonly items: {
+                    readonly type: "string";
+                  };
+                  readonly description: "Ordered commit IDs in this partition";
+                };
+              };
+              readonly required: readonly ["branchName", "title", "description", "commitIds"];
+              readonly additionalProperties: false;
+            };
+          };
+        };
+        readonly required: readonly ["id", "name", "title", "description", "commits", "orderedCommitIds"];
+        readonly additionalProperties: false;
+      };
+      readonly description: "Branches with grouped, ordered commits";
+    };
+    readonly rationale: {
+      readonly type: "string";
+      readonly description: "Brief explanation of the grouping and ordering rationale";
+    };
+  };
+  readonly required: readonly ["branches", "rationale"];
+  readonly additionalProperties: false;
+};
 //#endregion
-export { quickComposeResultSchema };
+export { QuickComposeWire, QuickComposeWireBranch, QuickComposeWireCommit, QuickComposeWirePartition, quickComposeResultJsonSchema };

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

@@ -1 +1 @@
-import{z as e}from"zod";const t=e.object({id:e.string().describe(`Unique commit ID (e.g. commit-1)`),message:e.string().describe(`Commit message`),explanation:e.string().describe(`Detailed explanation of the commit`),hunks:e.array(e.number().int().describe(`Hunk index`)).describe(`Hunk indices included in this commit`)}),n=e.object({branchName:e.string().min(1).describe(`Git branch name for this partition`),title:e.string().describe(`Short PR-style title`),description:e.string().describe(`What this partition accomplishes`),commitIds:e.array(e.string()).min(1).describe(`Ordered commit IDs in this partition`)}),r=e.object({id:e.string().min(1).describe(`Unique branch ID`),name:e.string().describe(`Branch name (empty string for commits-only mode)`),title:e.string().describe(`Short PR-style title (under 72 chars, imperative mood)`),description:e.string().describe(`What this branch accomplishes`),commits:e.array(t).min(1).describe(`Commits in this branch`),orderedCommitIds:e.array(e.string()).min(1).describe(`Commit IDs in optimal order`),partitions:e.array(n).optional().describe(`Stacked sub-branches (only for multi-branch mode)`)}),i=e.object({branches:e.array(r).min(1).describe(`Branches with grouped, ordered commits`),rationale:e.string().describe(`Brief explanation of the grouping and ordering rationale`)});export{i as quickComposeResultSchema};
+const e={$schema:`https://json-schema.org/draft/2020-12/schema`,type:`object`,properties:{branches:{minItems:1,type:`array`,items:{type:`object`,properties:{id:{type:`string`,minLength:1,description:`Unique branch ID`},name:{type:`string`,description:`Branch name (empty string for commits-only mode)`},title:{type:`string`,description:`Short PR-style title (under 72 chars, imperative mood)`},description:{type:`string`,description:`What this branch accomplishes`},commits:{minItems:1,type:`array`,items:{type:`object`,properties:{id:{type:`string`,description:`Unique commit ID (e.g. commit-1)`},message:{type:`string`,description:`Commit message`},explanation:{type:`string`,description:`Detailed explanation of the commit`},hunks:{type:`array`,items:{type:`integer`,minimum:-9007199254740991,maximum:9007199254740991,description:`Hunk index`},description:`Hunk indices included in this commit`}},required:[`id`,`message`,`explanation`,`hunks`],additionalProperties:!1},description:`Commits in this branch`},orderedCommitIds:{minItems:1,type:`array`,items:{type:`string`},description:`Commit IDs in optimal order`},partitions:{description:`Stacked sub-branches (only for multi-branch mode)`,type:`array`,items:{type:`object`,properties:{branchName:{type:`string`,minLength:1,description:`Git branch name for this partition`},title:{type:`string`,description:`Short PR-style title`},description:{type:`string`,description:`What this partition accomplishes`},commitIds:{minItems:1,type:`array`,items:{type:`string`},description:`Ordered commit IDs in this partition`}},required:[`branchName`,`title`,`description`,`commitIds`],additionalProperties:!1}}},required:[`id`,`name`,`title`,`description`,`commits`,`orderedCommitIds`],additionalProperties:!1},description:`Branches with grouped, ordered commits`},rationale:{type:`string`,description:`Brief explanation of the grouping and ordering rationale`}},required:[`branches`,`rationale`],additionalProperties:!1};export{e as quickComposeResultJsonSchema};

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

@@ -1,14 +1,14 @@
-import{extractOutputTag as e}from"../ai-loop.js";import{quickComposeResultSchema as t}from"./schema.js";function n(n,s,c=`branches`,l=!1,u){let d=null;try{if(d=e(n),!d)return a([`No <output> tag found in response`],o(c,l));let f=JSON.parse(d),p=t.safeParse(f);if(!p.success)return a(p.error.issues.map(e=>`${e.path.join(`.`)}: ${e.message}`),o(c,l));let m=p.data,h=new Set,g=new Set,_=new Set,v=[],y=new Map,b=new Set,x=[],S=[],C=[];for(let e of m.branches){if(h.has(e.id))return a([`Duplicate branch ID: '${e.id}'`],o(c,l));if(h.add(e.id),c===`branches`&&e.name.length===0)return a([`Branch '${e.id}': missing or empty 'name'`],o(c,l));if(c===`branches`&&e.name.length>0){if(g.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(g.add(e.name),u?.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}'.`)}let t=[],n=new Set;for(let r of e.commits){b.has(r.id)&&x.push(r.id),b.add(r.id),n.add(r.id);let i=[],a=c===`branches`?`${e.id}/${r.id}`:r.id;for(let e of r.hunks){_.has(e)&&v.push(e),_.add(e),i.push(e);let t=y.get(e);t?t.push(a):y.set(e,[a])}i.length===0&&S.push(r.id),t.push({id:r.id,message:r.message,explanation:r.explanation,hunkIndices:i})}let s=new Set(e.orderedCommitIds);if(s.size!==e.orderedCommitIds.length)return a([`Branch '${e.id}': orderedCommitIds contains duplicates`],`The orderedCommitIds list for branch '${e.id}' contains duplicates. Each commit ID must appear exactly once.`);let d=[...n].filter(e=>!s.has(e)),f=e.orderedCommitIds.filter(e=>!n.has(e));if(d.length>0)return a([`Branch '${e.id}': orderedCommitIds is missing commits: ${d.join(`, `)}`],`The orderedCommitIds for branch '${e.id}' must include every commit. Missing: ${d.join(`, `)}`);if(f.length>0)return a([`Branch '${e.id}': orderedCommitIds references unknown commits: ${f.join(`, `)}`],`The orderedCommitIds for branch '${e.id}' references commits that don't exist. Unknown: ${f.join(`, `)}`);let p=e.partitions?[...e.partitions]:void 0;if(p){let t=new Set,n=[];for(let r=0;r<p.length;r++){let o=p[r];if(!i(o.branchName))return a([`Branch '${e.id}', partition ${r}: '${o.branchName}' is not a valid git branch name`],`The branch name '${o.branchName}' is invalid. Git branch names cannot contain spaces, '..', '~', '^', ':', '\\', or end with '.lock'. Please provide a valid name.`);if(t.has(o.branchName))return a([`Branch '${e.id}': duplicate partition name '${o.branchName}'`],`Multiple partitions use the branch name '${o.branchName}'. Each must be unique.`);if(t.add(o.branchName),u?.has(o.branchName))return a([`Partition branch name '${o.branchName}' already exists in the repository`],`The branch name '${o.branchName}' already exists in the repository. Please choose a different name.`);for(let e of o.commitIds)n.push(e)}let o=new Set(n),c=e.orderedCommitIds.filter(e=>!o.has(e)),l=n.filter(e=>!s.has(e));if(c.length>0)return a([`Branch '${e.id}': partition is missing commits: ${c.join(`, `)}`],`All commits must be assigned to a partition. Missing: ${c.join(`, `)}`);if(l.length>0)return a([`Branch '${e.id}': partition references unknown commits: ${l.join(`, `)}`],`Partition references unknown commits: ${l.join(`, `)}`);if(!r(p,e.orderedCommitIds))return a([`Branch '${e.id}': partitions are not contiguous`],`Each partition must contain a contiguous range of commits in the ordered list. Please regroup into contiguous ranges.`)}C.push({id:e.id,name:e.name,title:e.title,description:e.description,commits:t,orderedCommitIds:e.orderedCommitIds,partitions:p})}if(x.length>0)return a([`Duplicate commit IDs: ${x.join(`, `)}`],`Some commit IDs appear multiple times. Each must be unique.\n\nDuplicates: ${x.join(`, `)}`);if(S.length>0)return a([`Empty commits (no hunks assigned): ${S.join(`, `)}`],`Every commit must contain at least one hunk. These commits have an empty \`hunks\` array: ${S.join(`, `)}.
+import{extractOutputTag as e}from"../ai-loop.js";import{validateJsonSchema as t}from"../utils/json-schema.js";import{quickComposeResultJsonSchema as n}from"./schema.js";function r(r,c,l=`branches`,u=!1,d){let f=null;try{if(f=e(r),!f)return o([`No <output> tag found in response`],s(l,u));let p=t(n,JSON.parse(f));if(!p.success)return o(p.issues.map(e=>`${e.path.join(`.`)}: ${e.message}`),s(l,u));let m=p.data,h=new Set,g=new Set,_=new Set,v=[],y=new Map,b=new Set,x=[],S=[],C=[];for(let e of m.branches){if(h.has(e.id))return o([`Duplicate branch ID: '${e.id}'`],s(l,u));if(h.add(e.id),l===`branches`&&e.name.length===0)return o([`Branch '${e.id}': missing or empty 'name'`],s(l,u));if(l===`branches`&&e.name.length>0){if(g.has(e.name))return o([`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(g.add(e.name),d?.has(e.name))return o([`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}'.`)}let t=[],n=new Set;for(let r of e.commits){b.has(r.id)&&x.push(r.id),b.add(r.id),n.add(r.id);let i=[],a=l===`branches`?`${e.id}/${r.id}`:r.id;for(let e of r.hunks){_.has(e)&&v.push(e),_.add(e),i.push(e);let t=y.get(e);t?t.push(a):y.set(e,[a])}i.length===0&&S.push(r.id),t.push({id:r.id,message:r.message,explanation:r.explanation,hunkIndices:i})}let r=new Set(e.orderedCommitIds);if(r.size!==e.orderedCommitIds.length)return o([`Branch '${e.id}': orderedCommitIds contains duplicates`],`The orderedCommitIds list for branch '${e.id}' contains duplicates. Each commit ID must appear exactly once.`);let c=[...n].filter(e=>!r.has(e)),f=e.orderedCommitIds.filter(e=>!n.has(e));if(c.length>0)return o([`Branch '${e.id}': orderedCommitIds is missing commits: ${c.join(`, `)}`],`The orderedCommitIds for branch '${e.id}' must include every commit. Missing: ${c.join(`, `)}`);if(f.length>0)return o([`Branch '${e.id}': orderedCommitIds references unknown commits: ${f.join(`, `)}`],`The orderedCommitIds for branch '${e.id}' references commits that don't exist. Unknown: ${f.join(`, `)}`);let p=e.partitions?[...e.partitions]:void 0;if(p){let t=new Set,n=[];for(let r=0;r<p.length;r++){let i=p[r];if(!a(i.branchName))return o([`Branch '${e.id}', partition ${r}: '${i.branchName}' is not a valid git branch name`],`The branch name '${i.branchName}' is invalid. Git branch names cannot contain spaces, '..', '~', '^', ':', '\\', or end with '.lock'. Please provide a valid name.`);if(t.has(i.branchName))return o([`Branch '${e.id}': duplicate partition name '${i.branchName}'`],`Multiple partitions use the branch name '${i.branchName}'. Each must be unique.`);if(t.add(i.branchName),d?.has(i.branchName))return o([`Partition branch name '${i.branchName}' already exists in the repository`],`The branch name '${i.branchName}' already exists in the repository. Please choose a different name.`);for(let e of i.commitIds)n.push(e)}let s=new Set(n),c=e.orderedCommitIds.filter(e=>!s.has(e)),l=n.filter(e=>!r.has(e));if(c.length>0)return o([`Branch '${e.id}': partition is missing commits: ${c.join(`, `)}`],`All commits must be assigned to a partition. Missing: ${c.join(`, `)}`);if(l.length>0)return o([`Branch '${e.id}': partition references unknown commits: ${l.join(`, `)}`],`Partition references unknown commits: ${l.join(`, `)}`);if(!i(p,e.orderedCommitIds))return o([`Branch '${e.id}': partitions are not contiguous`],`Each partition must contain a contiguous range of commits in the ordered list. Please regroup into contiguous ranges.`)}C.push({id:e.id,name:e.name,title:e.title,description:e.description,commits:t,orderedCommitIds:e.orderedCommitIds,partitions:p})}if(x.length>0)return o([`Duplicate commit IDs: ${x.join(`, `)}`],`Some commit IDs appear multiple times. Each must be unique.\n\nDuplicates: ${x.join(`, `)}`);if(S.length>0)return o([`Empty commits (no hunks assigned): ${S.join(`, `)}`],`Every commit must contain at least one hunk. These commits have an empty \`hunks\` array: ${S.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.`);if(v.length>0){let e=[...new Set(v)].sort((e,t)=>e-t),t=e.map(e=>`  hunk ${e} → ${(y.get(e)??[]).join(`, `)}`).join(`
-`),n=[...y.values()].reduce((e,t)=>e+t.length,0);return a([`Duplicate hunks: ${e.join(`, `)}`],`Some hunks appear in multiple commits. Each hunk can only be used once.
+`),n=[...y.values()].reduce((e,t)=>e+t.length,0);return o([`Duplicate hunks: ${e.join(`, `)}`],`Some hunks appear in multiple commits. Each hunk can only be used once.
 
-Your response listed ${n} hunk references across ${y.size} unique indices. Expected: ${s} references across ${s} unique indices.
+Your response listed ${n} hunk references across ${y.size} unique indices. Expected: ${c} references across ${c} unique indices.
 
 Duplicates (each hunk index → the commits it landed in):
 ${t}
 
-To fix: 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.`)}let w=new Set(Array.from({length:s},(e,t)=>t)),T=[...w].filter(e=>!_.has(e)),E=[..._].filter(e=>!w.has(e));return T.length>0?a([`Missing hunks: ${T.join(`, `)}`],`Some hunks are not assigned to any commit. All hunks must be included.\n\nMissing: ${T.join(`, `)}`):E.length>0?a([`Extra hunks: ${E.join(`, `)}`],`Some hunks in your response don't exist in the input.\n\nExtra: ${E.join(`, `)}`):{valid:!0,result:{branches:C,rationale:m.rationale}}}catch(e){let t=e instanceof Error?e.message:String(e),r=(d??n).slice(-300);return a([`Failed to parse response as valid JSON: ${t}`,`Response tail: ${r}`],o(c,l))}}function r(e,t){let n=new Map(t.map((e,t)=>[e,t])),r=0;for(let t of e)for(let e of t.commitIds){let t=n.get(e);if(t===void 0||t!==r)return!1;r++}return r===t.length}function i(e){return e.startsWith(`-`)||e.startsWith(`.`)||e.endsWith(`.lock`)||e.endsWith(`.`)||e.endsWith(`/`)||e.includes(`..`)||e.includes(`~`)||e.includes(`^`)||e.includes(`:`)||e.includes(`\\`)||e.includes(` `)||e.includes(`?`)||e.includes(`*`)||e.includes(`[`)||e.includes(`@{`)?!1:e.length>0}function a(e,t){return{valid:!1,errors:e,retryFeedback:t}}function o(e,t){return`Your response has an invalid structure. Please return JSON inside <output> tags:
+To fix: 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.`)}let w=new Set(Array.from({length:c},(e,t)=>t)),T=[...w].filter(e=>!_.has(e)),E=[..._].filter(e=>!w.has(e));return T.length>0?o([`Missing hunks: ${T.join(`, `)}`],`Some hunks are not assigned to any commit. All hunks must be included.\n\nMissing: ${T.join(`, `)}`):E.length>0?o([`Extra hunks: ${E.join(`, `)}`],`Some hunks in your response don't exist in the input.\n\nExtra: ${E.join(`, `)}`):{valid:!0,result:{branches:C,rationale:m.rationale}}}catch(e){let t=e instanceof Error?e.message:String(e),n=(f??r).slice(-300);return o([`Failed to parse response as valid JSON: ${t}`,`Response tail: ${n}`],s(l,u))}}function i(e,t){let n=new Map(t.map((e,t)=>[e,t])),r=0;for(let t of e)for(let e of t.commitIds){let t=n.get(e);if(t===void 0||t!==r)return!1;r++}return r===t.length}function a(e){return e.startsWith(`-`)||e.startsWith(`.`)||e.endsWith(`.lock`)||e.endsWith(`.`)||e.endsWith(`/`)||e.includes(`..`)||e.includes(`~`)||e.includes(`^`)||e.includes(`:`)||e.includes(`\\`)||e.includes(` `)||e.includes(`?`)||e.includes(`*`)||e.includes(`[`)||e.includes(`@{`)?!1:e.length>0}function o(e,t){return{valid:!1,errors:e,retryFeedback:t}}function s(e,t){return`Your response has an invalid structure. Please return JSON inside <output> tags:
 <output>
 {
   "branches": [
@@ -30,4 +30,4 @@ To fix: for each duplicated hunk index, decide which one commit it truly belongs
 }
 </output>
 
-Return only the <output> tag and no other text.`}export{n as validateQuickComposeResponse};
+Return only the <output> tag and no other text.`}export{r as validateQuickComposeResponse};

package/dist/tasks/refine/refine.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{buildRefinementPrompt as r}from"./prompt.js";import{validateRefineResponse as i}from"./validator.js";async function a(a){if(a.session.messages.length===0)throw new e(`refine: session must contain prior messages from a previous compose call.`);if(a.hunkCount<=0)throw new e(`refine: hunkCount must be a positive integer.`);let o=a.mode??`branches`,s=new Map;for(let e of a.lockedCommits??[])s.set(e.id,e);let c=n(r({instructions:a.instructions,lockedCommits:a.lockedCommits??[],clientContext:a.clientContext,hunkCount:a.hunkCount,mode:o}),a.promptOverride),l=await t({model:a.model,systemPrompt:void 0,userPrompt:c,session:a.session,maxRetries:a.maxRetries,maxTokens:a.maxTokens,onProgress:a.onProgress,cancellation:a.cancellation,onBeforeModelCall:a.onBeforeModelCall,onAfterModelCall:a.onAfterModelCall,onBeforePrompt:a.onBeforePrompt,validate:e=>i(e,{hunkCount:a.hunkCount,mode:o,lockedCommits:s}),taskName:`refine`}),u={...l.session,completedSteps:a.session.completedSteps};return{result:l.result,session:u,usage:l.usage,attempts:l.attempts,durationMs:l.durationMs,callIds:l.callIds}}export{a as refine};
+import{TaskInputError as e}from"../../errors/task.js";import{runAiLoop as t}from"../ai-loop.js";import{applyUserPromptOverride as n}from"../types.js";import{buildRefinementPrompt as r}from"./prompt.js";import{validateRefineResponse as i}from"./validator.js";async function a(a){if(a.session.messages.length===0)throw new e(`refine: session must contain prior messages from a previous compose call.`);if(a.hunkCount<=0)throw new e(`refine: hunkCount must be a positive integer.`);let o=a.mode??`branches`,s=new Map;for(let e of a.lockedCommits??[])s.set(e.id,e);let c=n(r({instructions:a.instructions,lockedCommits:a.lockedCommits??[],clientContext:a.clientContext,hunkCount:a.hunkCount,mode:o}),a.promptOverride),l=await t({model:a.model,systemPrompt:void 0,userPrompt:c,session:a.session,maxRetries:a.maxRetries,maxTokens:a.maxTokens,onProgress:a.onProgress,cancellation:a.cancellation,onBeforeModelCall:a.onBeforeModelCall,onAfterModelCall:a.onAfterModelCall,onBeforePrompt:a.onBeforePrompt,validate:e=>i(e,{hunkCount:a.hunkCount,mode:o,lockedCommits:s,lockedRuns:a.lockedRuns}),taskName:`refine`}),u={...l.session,completedSteps:a.session.completedSteps};return{result:l.result,session:u,usage:l.usage,attempts:l.attempts,durationMs:l.durationMs,callIds:l.callIds}}export{a as refine};

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

@@ -25,6 +25,20 @@ interface RefineInput {
    *  prompt and enforces their presence + substitutes their content (id, message,
    *  explanation, hunkIndices) into the AI's response after validation. */
   lockedCommits?: readonly CommitSuggestion[];
+  /**
+   * The locked commits partitioned into the maximal runs of *consecutive* locked commits
+   * (no commit between them) within each branch of the prior plan, in that plan's original
+   * order — one entry per run, singletons included. Flattening yields the locked commits'
+   * original relative order.
+   *
+   * The validator uses this to undo AI reshuffling in the post-substitution cleanup: it
+   * restores the locked commits' relative order within each output branch and pulls each
+   * multi-commit run back together contiguously. Adjacency can't be derived from
+   * `lockedCommits` alone (which carries no positional context), so callers driving the task
+   * directly must supply it; the workflow computes it from the prior plan. Omit for no
+   * reordering.
+   */
+  lockedRuns?: readonly (readonly string[])[];
   /** Per-call user instructions appended to the refinement prompt. */
   instructions?: string;
   /** Free-text consumer-supplied context (e.g. UI-ordering notes) injected verbatim into

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

@@ -7,13 +7,17 @@ interface ValidateRefineParams {
   hunkCount: number;
   mode: 'commits' | 'branches';
   lockedCommits: Map<string, CommitSuggestion>;
+  /** Maximal runs of consecutive locked commits per prior-plan branch, in original order.
+   *  See {@link import('./types.js').RefineInput.lockedRuns}. */
+  lockedRuns?: readonly (readonly string[])[];
 }
 /**
  * Two-stage validation for the refine task:
  *
  * 1. Base structural validation via `validateGroupResponse` — same invariants the rest of
  *    the library enforces (hunk index uniqueness + coverage, non-empty commits, unique ids).
- * 2. Locked-commits check + content substitution + post-substitution invariant check.
+ * 2. Locked-commits check + content substitution + post-substitution invariant check +
+ *    locked-order restoration (see {@link restoreLockedOrdering}).
  *
  * The substitution step is what makes refine resilient to minor AI drift: when the AI emits
  * a commit with a locked id but slightly different message text, we silently restore the

package/dist/tasks/refine/validator.js

@@ -1 +1 @@
-import{validateGroupResponse as e}from"../group/validator.js";function t(t,r){let i=e(t,r.hunkCount,r.mode);if(!i.valid||i.result===void 0)return i;let a=i.result;if(r.lockedCommits.size===0)return i;let o=new Map;for(let e of a.branches)for(let t=0;t<e.commits.length;t++)o.set(e.commits[t].id,{branch:e,commitIndex:t});let s=[];for(let e of r.lockedCommits.keys())o.has(e)||s.push(e);if(s.length>0){let e=s.map(e=>`'${e}'`).join(`, `);return{valid:!1,errors:[`Missing locked commits: ${e}`],retryFeedback:`Your response is missing the following LOCKED commits, which must always appear in the output: ${e}. Re-emit the plan with these commits present (preserving their id, message, explanation, and hunks exactly).`}}for(let[e,t]of r.lockedCommits){let n=o.get(e);if(n==null)continue;let r=n.branch.commits[n.commitIndex];n.branch.commits[n.commitIndex]={...r,id:t.id,message:t.message,explanation:t.explanation,hunkIndices:[...t.hunkIndices]}}let c=n(a,r.hunkCount);return c==null?{valid:!0,result:a}:{valid:!1,errors:[c],retryFeedback:`After restoring the locked commits' original hunk assignments, the resulting plan is structurally invalid: ${c}. This means you assigned hunks belonging to a locked commit to a different commit. Locked commits' hunks must remain exclusive to them — do not move those hunks elsewhere.`}}function n(e,t){let n=new Set,r=[],i=[],a=new Set,o=[];for(let t of e.branches)for(let e of t.commits){if(a.has(e.id)&&o.push(e.id),a.add(e.id),e.hunkIndices.length===0){i.push(e.id);continue}for(let t of e.hunkIndices)n.has(t)&&r.push(t),n.add(t)}if(o.length>0)return`duplicate commit ids after substitution: ${o.join(`, `)}`;if(i.length>0)return`empty commits after substitution (no hunks assigned): ${i.join(`, `)}`;if(r.length>0)return`hunk indices appear in more than one commit: ${[...new Set(r)].join(`, `)}`;let s=[];for(let e=0;e<t;e++)n.has(e)||s.push(e);if(s.length>0)return`hunk indices missing from the plan: ${s.join(`, `)}`;let c=[...n].filter(e=>e>=t||e<0);if(c.length>0)return`hunk indices outside the valid range 0..${String(t-1)}: ${c.join(`, `)}`}export{t as validateRefineResponse};
+import{validateGroupResponse as e}from"../group/validator.js";function t(t,r){let i=e(t,r.hunkCount,r.mode);if(!i.valid||i.result===void 0)return i;let o=i.result;if(r.lockedCommits.size===0)return i;let s=new Map;for(let e of o.branches)for(let t=0;t<e.commits.length;t++)s.set(e.commits[t].id,{branch:e,commitIndex:t});let c=[];for(let e of r.lockedCommits.keys())s.has(e)||c.push(e);if(c.length>0){let e=c.map(e=>`'${e}'`).join(`, `);return{valid:!1,errors:[`Missing locked commits: ${e}`],retryFeedback:`Your response is missing the following LOCKED commits, which must always appear in the output: ${e}. Re-emit the plan with these commits present (preserving their id, message, explanation, and hunks exactly).`}}for(let[e,t]of r.lockedCommits){let n=s.get(e);if(n==null)continue;let r=n.branch.commits[n.commitIndex];n.branch.commits[n.commitIndex]={...r,id:t.id,message:t.message,explanation:t.explanation,hunkIndices:[...t.hunkIndices]}}let l=a(o,r.hunkCount);return l==null?(n(o,r.lockedRuns),{valid:!0,result:o}):{valid:!1,errors:[l],retryFeedback:`After restoring the locked commits' original hunk assignments, the resulting plan is structurally invalid: ${l}. This means you assigned hunks belonging to a locked commit to a different commit. Locked commits' hunks must remain exclusive to them — do not move those hunks elsewhere.`}}function n(e,t){if(t==null||t.length===0)return;let n=t.flat(),a=new Map(n.map((e,t)=>[e,t])),o=new Set(n);for(let t of e.branches)r(t,o,a);for(let n of t)n.length>=2&&i(e,n)}function r(e,t,n){let r=[],i=[];for(let n=0;n<e.commits.length;n++)t.has(e.commits[n].id)&&(r.push(n),i.push(e.commits[n]));if(!(i.length<2)){i.sort((e,t)=>(n.get(e.id)??0)-(n.get(t.id)??0));for(let t=0;t<r.length;t++)e.commits[r[t]]=i[t]}}function i(e,t){let n=new Set(t),r=e.branches.filter(e=>e.commits.some(e=>n.has(e.id)));if(r.length!==1)return;let i=r[0],a=[];for(let e of t){let t=i.commits.find(t=>t.id===e);t!=null&&a.push(t)}if(a.length<2)return;let o=Math.min(...a.map(e=>i.commits.indexOf(e))),s=i.commits.slice(0,o).filter(e=>!n.has(e.id)).length,c=i.commits.filter(e=>!n.has(e.id));c.splice(s,0,...a),i.commits=c}function a(e,t){let n=new Set,r=[],i=[],a=new Set,o=[];for(let t of e.branches)for(let e of t.commits){if(a.has(e.id)&&o.push(e.id),a.add(e.id),e.hunkIndices.length===0){i.push(e.id);continue}for(let t of e.hunkIndices)n.has(t)&&r.push(t),n.add(t)}if(o.length>0)return`duplicate commit ids after substitution: ${o.join(`, `)}`;if(i.length>0)return`empty commits after substitution (no hunks assigned): ${i.join(`, `)}`;if(r.length>0)return`hunk indices appear in more than one commit: ${[...new Set(r)].join(`, `)}`;let s=[];for(let e=0;e<t;e++)n.has(e)||s.push(e);if(s.length>0)return`hunk indices missing from the plan: ${s.join(`, `)}`;let c=[...n].filter(e=>e>=t||e<0);if(c.length>0)return`hunk indices outside the valid range 0..${String(t-1)}: ${c.join(`, `)}`}export{t as validateRefineResponse};

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

@@ -0,0 +1,40 @@
+import { ComposeHunk } from "../types.js";
+import { RedactHunkContent } from "./redact.js";
+
+//#region src/tasks/utils/budget.d.ts
+/**
+ * Ceiling on estimated input tokens for a single hunk-bearing prompt.
+ *
+ * Production p99 for the composer sits around 150k input tokens; pathological diffs
+ * (lockfile-dominated) reach 700k-1.7M. 180k leaves headroom above normal usage while
+ * still forcing degradation on the pathological tail, and stays comfortably inside the
+ * 200k context window of the models the composer targets.
+ */
+declare const DEFAULT_INPUT_TOKEN_BUDGET = 180000;
+/** Rough char→token estimate shared with `runAiLoop`'s prompt-gate heuristic. */
+declare function estimateTokens(chars: number): number;
+interface AssembledHunkPrompt {
+  prompt: string;
+  /**
+   * Hunks that lost their real body to budget pressure (full to condensed). Non-zero means
+   * content-dependent reasoning (analyze/group dependency detection) saw less than the full diff.
+   */
+  hunksCondensedForBudget: number;
+}
+/**
+ * Serializes `hunks` into the `<hunks>` JSON block and assembles the full prompt via
+ * `assemble`, keeping estimated input tokens under `inputTokenBudget`. Noise hunks (per
+ * `redactHunkContent`) start redacted, `condensed` forces metadata-only, else full; over
+ * budget, hunks are condensed biggest-first, throwing {@link DiffTooLargeError} if they still
+ * cannot fit. `assemble` is called with `''` to measure fixed overhead, so it must be pure.
+ */
+declare function assembleHunkPrompt(params: {
+  hunks: ComposeHunk[];
+  assemble: (hunksJson: string) => string;
+  condensed?: boolean;
+  redactHunkContent?: RedactHunkContent;
+  inputTokenBudget?: number;
+  systemPromptChars?: number;
+}): AssembledHunkPrompt;
+//#endregion
+export { AssembledHunkPrompt, DEFAULT_INPUT_TOKEN_BUDGET, assembleHunkPrompt, estimateTokens };

package/dist/tasks/utils/budget.js

@@ -0,0 +1 @@
+import{DiffTooLargeError as e}from"../../errors/task.js";import{estimatedCharactersPerToken as t}from"../ai-loop.js";import{REDACTED_HUNK_CONTENT as n}from"./redact.js";const r=18e4;function i(e){return Math.ceil(e/t)}function a(e,t){let r={...e.isBinary?{isBinary:!0}:{},...e.isRename?{isRename:!0}:{},...e.originalFileName?{originalFileName:e.originalFileName}:{}};return t===`condensed`?{index:e.index,fileName:e.fileName,hunkHeader:e.hunkHeader,additions:e.additions,deletions:e.deletions,...r}:t===`redacted`?{index:e.index,fileName:e.fileName,hunkHeader:e.hunkHeader,additions:e.additions,deletions:e.deletions,content:n,...r}:{index:e.index,fileName:e.fileName,hunkHeader:e.hunkHeader,content:e.content,...r}}function o(e,t){return JSON.stringify(a(e,t)).length}function s(e,t,n,r){let a=new Map(t),s=2+Math.max(0,e.length-1),c=0,l=e.map(e=>{let t=a.get(e.index),n=o(e,`condensed`),r=t===`condensed`?n:o(e,t);return c+=r,{hunk:e,currentLen:r,condensedLen:n}}),u=()=>i(r+s+c),d=()=>u()>n;if(d()){let e=l.map(e=>({hunk:e.hunk,savings:e.currentLen-e.condensedLen})).filter(e=>e.savings>0).sort((e,t)=>t.savings-e.savings);for(let{hunk:t,savings:n}of e){if(!d())break;c-=n,a.set(t.index,`condensed`)}}return{modes:a,estimatedTokens:u(),tooLarge:d()}}function c(t){let{hunks:n,assemble:i,condensed:o,redactHunkContent:c,inputTokenBudget:l=r,systemPromptChars:u=0}=t,d=new Map(n.map(e=>o?[e.index,`condensed`]:c?.(e)?[e.index,`redacted`]:[e.index,`full`])),{modes:f,estimatedTokens:p,tooLarge:m}=s(n,d,l,i(``).length+u);if(m)throw new e(p,l);let h=0;for(let e of n)d.get(e.index)===`full`&&f.get(e.index)===`condensed`&&h++;return{prompt:i(JSON.stringify(n.map(e=>a(e,f.get(e.index))))),hunksCondensedForBudget:h}}export{r as DEFAULT_INPUT_TOKEN_BUDGET,c as assembleHunkPrompt,i as estimateTokens};

package/dist/tasks/utils/json-schema.d.ts

@@ -0,0 +1,61 @@
+//#region src/tasks/utils/json-schema.d.ts
+interface SchemaIssue {
+  path: (string | number)[];
+  message: string;
+}
+type SchemaResult<T> = {
+  success: true;
+  data: T;
+} | {
+  success: false;
+  issues: SchemaIssue[];
+};
+interface SchemaAnnotations {
+  $schema?: string;
+  description?: string;
+}
+interface ObjectSchemaDef extends SchemaAnnotations {
+  type: 'object';
+  properties: Readonly<Record<string, JsonSchemaDef>>;
+  required: readonly string[];
+  additionalProperties: false;
+}
+interface ArraySchemaDef extends SchemaAnnotations {
+  type: 'array';
+  items: JsonSchemaDef;
+  minItems?: number;
+  default?: readonly unknown[];
+}
+interface StringSchemaDef extends SchemaAnnotations {
+  type: 'string';
+  minLength?: number;
+  maxLength?: number;
+  enum?: readonly string[];
+}
+interface NumberSchemaDef extends SchemaAnnotations {
+  type: 'number' | 'integer';
+  minimum?: number;
+  maximum?: number;
+}
+interface BooleanSchemaDef extends SchemaAnnotations {
+  type: 'boolean';
+}
+/**
+ * The JSON-Schema subset used by the task output schemas. Deliberately closed: no `anyOf`,
+ * `const`, `$ref`, `pattern`, `format`, record types, or type arrays — widen only when a task
+ * schema actually needs more, and keep prompt snapshots byte-stable when doing so.
+ */
+type JsonSchemaDef = ObjectSchemaDef | ArraySchemaDef | StringSchemaDef | NumberSchemaDef | BooleanSchemaDef;
+/**
+ * Validates `value` against `schema` with the same observable semantics the previous zod
+ * schemas had: every issue is collected in one pass, unknown object keys are silently
+ * stripped, a `required` property whose subschema carries `default` is filled with a fresh
+ * clone of that default when absent, and issue messages mirror zod v4 wording so telemetry
+ * and error logs stay comparable across the migration. One deliberate divergence: on a type
+ * mismatch zod could add a second size-constraint issue keyed off the wrong-typed value's
+ * `.length`; this validator reports only the type issue (same failure outcome, one issue
+ * fewer). On success `data` is a rebuilt tree, never the input by reference.
+ */
+declare function validateJsonSchema<T>(schema: JsonSchemaDef, value: unknown): SchemaResult<T>;
+//#endregion
+export { ArraySchemaDef, BooleanSchemaDef, JsonSchemaDef, NumberSchemaDef, ObjectSchemaDef, SchemaIssue, SchemaResult, StringSchemaDef, validateJsonSchema };