@hy-sde-org/dsh-tool-git 0.1.1-rc.2

package/LICENSE

@@ -0,0 +1,37 @@
+MIT License
+
+Copyright (c) 2026 hy-sde
+
+This repository is a port of the oh-my-pi memory surface (retain / recall /
+reflect / memory_edit / learn and the durable project-scoped local memory
+backend) onto the DeepSeek Harness `ctx.memory` service contract — see
+port_omp.md item 4 in the hy-sde fork. The ported portions are distributed
+under the same MIT license with their original copyright held by their
+respective authors:
+
+  Copyright (c) 2025 Mario Zechner
+  Copyright (c) 2025-2026 Can Bölük
+
+See THIRD-PARTY-NOTICES.md for full provenance per module.
+
+Parts of this repository are derived from DeepSeek Haarness
+(https://github.com/deepseek-ai/deepseek-harness), MIT License,
+Copyright (c) 2026 DeepSeek.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,34 @@
+# @hy-sde-org/dsh-tool-git
+
+Model-facing agentic git tools over the host `ctx.git` service:
+
+- **`commit`** — analyze the current git changes and produce a
+  conventional-commit split proposal (read-only; never edits the repo).
+- **`commit_apply`** — execute a validated split-commit plan: hunk-aware
+  staging, lock-file autoplacement, topological dependency order, cycle
+  rejection before any write, atomic per-commit execution, `dryRun` preview.
+- **`review`** — fan the diff out to parallel reviewer subagents, rank every
+  finding P0–P3 with confidence, and aggregate a ship/reject verdict.
+
+Plus the `git:tools` system-prompt section. Agent-plane: the package mounts
+as a preset row (`inject` = tools, systemPrompt, git) and resolves the host
+`git` service; it registers no service of its own.
+
+## Install & mount
+
+```bash
+dsh plugin --profile web add @hy-sde-org/dsh-git @hy-sde-org/dsh-tool-git
+```
+
+Copy `examples/agent-preset/` to `~/.dsh/.agent-presets/<id>/` and select it
+in the Web UI preset picker. The preset row configures
+`reviewProvider: spawn` and `maxReviewers: 4`.
+
+## Development
+
+```bash
+pnpm install
+pnpm run check   # tsc --noEmit
+pnpm run build   # tsc -p tsconfig.build.json → dist/
+pnpm run test    # vitest (commit + review end-to-end on real temp repos)
+```

package/dist/commit.d.ts

@@ -0,0 +1,63 @@
+/**
+ * The two commit tools over `ctx.git`: `commit` analyzes the staged/working
+ * tree and returns ground truth plus a suggested split plan, and
+ * `commit_apply` validates and executes a plan the model authors (dependency
+ * order, cycle rejection, lock-file placement, hunk staging, atomic commits).
+ *
+ * Port of omp (oh-my-pi)'s agentic commit flow, re-architected for the harness:
+ * omp runs its own hidden LLM session; here the model scripts the plan between
+ * the two tool calls, so every decision is visible and reviewable (see
+ * port_omp.md item: commit). The deterministic parts — validation, topo order,
+ * lock-file assignment, execution — are direct ports.
+ * @module @hy-sde-org/dsh-tool-git/commit
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { ToolExecution } from '@deepseek-ai/dsh-tools';
+import type { CommitType, NumstatEntry } from '@hy-sde-org/dsh-git';
+/** Call working directory resolution shared by the git tools. */
+export declare function resolveCwd(exec: ToolExecution, cwdArg: string | undefined): string;
+/** Configuration consumed by the commit tools. */
+export interface CommitToolConfig {
+    /** Char cap on the diff text included in a `commit` analysis (default 60000). */
+    maxDiffChars?: number;
+}
+export interface CommitChangeSuggestion {
+    path: string;
+    additions: number;
+    deletions: number;
+}
+export interface CommitAnalysisValue {
+    cwd: string;
+    branch?: string;
+    staged: boolean;
+    files: NumstatEntry[];
+    untrackedFiles: string[];
+    diff: string;
+    diffTruncated: boolean;
+    trivial?: {
+        type: CommitType;
+        summary: string;
+    };
+    lockFilesPending: string[];
+    suggestedPlan: readonly unknown[];
+    warnings: string[];
+    analysisGuidance: string;
+}
+export declare function applyCommitTool(ctx: Context, config?: CommitToolConfig): void;
+export interface CommitCreated {
+    position: number;
+    hash: string;
+    message: string;
+    changes: string[];
+}
+export interface CommitApplyValue {
+    mode: 'single' | 'split';
+    created: CommitCreated[];
+    messages: string[];
+    warnings: string[];
+    dryRun: boolean;
+}
+export declare function applyCommitApplyTool(ctx: Context, _config?: {
+    timeoutMs?: number;
+}): void;
+//# sourceMappingURL=commit.d.ts.map

package/dist/commit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commit.d.ts","sourceRoot":"","sources":["../src/commit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAA;AAS3D,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAqC,MAAM,qBAAqB,CAAA;AAOtG,iEAAiE;AACjE,wBAAgB,UAAU,CAAC,IAAI,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAMlF;AAOD,kDAAkD;AAClD,MAAM,WAAW,gBAAgB;IAC/B,iFAAiF;IACjF,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAmBD,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,mBAAmB;IAClC,GAAG,EAAE,MAAM,CAAA;IACX,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,OAAO,CAAA;IACf,KAAK,EAAE,YAAY,EAAE,CAAA;IACrB,cAAc,EAAE,MAAM,EAAE,CAAA;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ,aAAa,EAAE,OAAO,CAAA;IACtB,OAAO,CAAC,EAAE;QAAE,IAAI,EAAE,UAAU,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAA;IAC/C,gBAAgB,EAAE,MAAM,EAAE,CAAA;IAC1B,aAAa,EAAE,SAAS,OAAO,EAAE,CAAA;IACjC,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClB,gBAAgB,EAAE,MAAM,CAAA;CACzB;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,GAAE,gBAAqB,GAAG,IAAI,CA4JjF;AAuFD,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,EAAE,CAAA;CAClB;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAA;IACxB,OAAO,EAAE,aAAa,EAAE,CAAA;IACxB,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClB,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClB,MAAM,EAAE,OAAO,CAAA;CAChB;AA0BD,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,GAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,IAAI,CAuO7F"}

package/dist/commit.js

@@ -0,0 +1,534 @@
+/**
+ * The two commit tools over `ctx.git`: `commit` analyzes the staged/working
+ * tree and returns ground truth plus a suggested split plan, and
+ * `commit_apply` validates and executes a plan the model authors (dependency
+ * order, cycle rejection, lock-file placement, hunk staging, atomic commits).
+ *
+ * Port of omp (oh-my-pi)'s agentic commit flow, re-architected for the harness:
+ * omp runs its own hidden LLM session; here the model scripts the plan between
+ * the two tool calls, so every decision is visible and reviewable (see
+ * port_omp.md item: commit). The deterministic parts — validation, topo order,
+ * lock-file assignment, execution — are direct ports.
+ * @module @hy-sde-org/dsh-tool-git/commit
+ */
+import { defineTool } from '@deepseek-ai/dsh-tools';
+import { formatCommitMessage, assignLockFilesToPlan, detectTrivialChange, computeDependencyOrder, validateHunkSelections, EXCLUDED_LOCK_FILES, } from '@hy-sde-org/dsh-git';
+/** Commit-type vocabulary for schema + validation (kept in sync with types). */
+const COMMIT_TYPES = [
+    'feat', 'fix', 'refactor', 'perf', 'docs', 'test', 'build', 'ci', 'chore', 'style', 'revert',
+];
+/** Call working directory resolution shared by the git tools. */
+export function resolveCwd(exec, cwdArg) {
+    const base = exec.agent?.session.header.cwd;
+    if (typeof base === 'string' && base.length > 0) {
+        return cwdArg === undefined ? base : (cwdArg.startsWith('/') ? cwdArg : joinPath(base, cwdArg));
+    }
+    return cwdArg ?? process.cwd();
+}
+function joinPath(base, rel) {
+    if (rel === '.' || rel === './')
+        return base;
+    return `${base.replace(/\/+$/, '')}/${rel.replace(/^\/+/, '')}`;
+}
+const DEFAULT_MAX_DIFF_CHARS = 60_000;
+export function applyCommitTool(ctx, config = {}) {
+    const maxDiffChars = config.maxDiffChars ?? DEFAULT_MAX_DIFF_CHARS;
+    ctx.tools.register(defineTool({
+        name: 'commit',
+        description: 'Analyze the current git changes and produce a conventional-commit split proposal. '
+            + 'Reads the staged (or auto-staged working) tree, returns per-file add/delete counts, the bounded diff text, '
+            + 'lock-file hints, and a suggested plan skeleton. After reading the analysis, author a precise `SplitCommitPlan` '
+            + '(types, scopes, summaries, dependencies) and pass it to `commit_apply` to execute. Never edit files here: this '
+            + 'tool is read-only and never writes to the repository.',
+        parameters: {
+            stagedOnly: { type: 'boolean', description: 'Analyze only what is already staged; when false and nothing is staged, stage all changes first (default false).' },
+            context: { type: 'string', description: 'Optional user context for planning: intent, headline change, reviewers, issue refs.' },
+            cwd: { type: 'string', description: 'Working directory; defaults to the session workspace.' },
+        },
+        output: {
+            schema: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    cwd: { type: 'string', required: true },
+                    branch: { type: 'string' },
+                    staged: { type: 'boolean', required: true },
+                    files: {
+                        type: 'array',
+                        required: true,
+                        items: {
+                            type: 'object',
+                            additionalProperties: false,
+                            properties: {
+                                path: { type: 'string', required: true },
+                                additions: { type: 'integer', required: true },
+                                deletions: { type: 'integer', required: true },
+                            },
+                        },
+                    },
+                    untrackedFiles: { type: 'array', required: true, items: { type: 'string' } },
+                    diff: { type: 'string', required: true },
+                    diffTruncated: { type: 'boolean', required: true },
+                    trivial: {
+                        type: 'object',
+                        additionalProperties: false,
+                        properties: {
+                            type: { type: 'string', required: true, enum: [...COMMIT_TYPES] },
+                            summary: { type: 'string', required: true },
+                        },
+                    },
+                    lockFilesPending: { type: 'array', required: true, items: { type: 'string' } },
+                    suggestedPlan: {
+                        type: 'array',
+                        required: true,
+                        items: { type: 'json' },
+                    },
+                    warnings: { type: 'array', required: true, items: { type: 'string' } },
+                    analysisGuidance: { type: 'string', required: true },
+                },
+            },
+            render: (_args, value) => [{
+                    type: 'text',
+                    text: renderCommitAnalysis(value),
+                }],
+        },
+        isConcurrencySafe: () => false,
+        async execute(args, exec) {
+            const git = ctx.git;
+            const cwd = resolveCwd(exec, args.cwd);
+            if (!(await git.isRepo(cwd, exec.signal))) {
+                throw new Error(`commit requires a git repository: ${cwd} is not inside a working tree`);
+            }
+            const warnings = [];
+            let stagedFiles = await git.diff.changedFiles(cwd, { cached: true, signal: exec.signal });
+            if (stagedFiles.length === 0 && !args.stagedOnly) {
+                const status = await git.status(cwd, exec.signal);
+                if (status.unstaged > 0 || status.untracked > 0) {
+                    await git.addAll(cwd, [], exec.signal);
+                    warnings.push('nothing was staged; staged all working-tree changes automatically for analysis');
+                }
+                stagedFiles = await git.diff.changedFiles(cwd, { cached: true, signal: exec.signal });
+            }
+            if (stagedFiles.length === 0) {
+                const status = await git.status(cwd, exec.signal);
+                if (status.untracked > 0) {
+                    warnings.push(`detected ${status.untracked} untracked file(s) not included — rerun without stagedOnly to stage them`);
+                }
+                return {
+                    cwd,
+                    staged: false,
+                    files: [],
+                    untrackedFiles: [],
+                    diff: '',
+                    diffTruncated: false,
+                    lockFilesPending: [],
+                    suggestedPlan: [],
+                    warnings,
+                    analysisGuidance: 'No staged changes and nothing was auto-staged. Nothing to commit.',
+                };
+            }
+            const numstat = await git.diff.numstat(cwd, { cached: true, signal: exec.signal });
+            const branch = (await git.branch(cwd, exec.signal)) ?? undefined;
+            let diffText = await git.diffText(cwd, { cached: true, binary: true }, exec.signal);
+            let diffTruncated = false;
+            if (diffText.length > maxDiffChars) {
+                diffText = diffText.slice(0, maxDiffChars);
+                diffTruncated = true;
+                warnings.push('diff truncated: use read/grep on the listed files for the full picture');
+            }
+            const trivial = detectTrivialChange(diffText);
+            const lockFilesPending = stagedFiles.filter((file) => {
+                const parts = file.split('/');
+                const basename = parts[parts.length - 1] ?? '';
+                return EXCLUDED_LOCK_FILES.has(basename);
+            });
+            // Lock files are auto-placed by commit_apply; keep them out of the
+            // plan skeleton so the model plans only real changes.
+            const planSource = stagedFiles.filter((file) => {
+                const parts = file.split('/');
+                const basename = parts[parts.length - 1] ?? '';
+                return !EXCLUDED_LOCK_FILES.has(basename);
+            });
+            const suggestedPlan = trivial
+                ? [{
+                        changes: planSource.map(path => ({ path, hunks: { type: 'all' } })),
+                        type: trivial.type,
+                        scope: null,
+                        summary: trivial.summary,
+                        details: [],
+                        issueRefs: [],
+                        dependencies: [],
+                        rationale: 'trivial change detected (formatted/imports); single commit',
+                    }]
+                : buildSuggestedGroups(planSource);
+            const analysisGuidance = buildAnalysisGuidance(trivial, planSource.length, suggestedPlan.length);
+            return {
+                cwd,
+                ...(branch !== undefined ? { branch } : {}),
+                staged: true,
+                files: numstat,
+                untrackedFiles: [],
+                diff: diffText,
+                diffTruncated,
+                ...(trivial !== null ? { trivial } : {}),
+                lockFilesPending,
+                suggestedPlan: suggestedPlan,
+                warnings,
+                analysisGuidance,
+            };
+        },
+    }));
+}
+/** Deterministic per-top-directory grouping skeleton for the model to refine. */
+function buildSuggestedGroups(stagedFiles) {
+    const byDir = new Map();
+    for (const file of stagedFiles) {
+        const slash = file.indexOf('/');
+        const dir = slash === -1 ? '(root)' : file.slice(0, slash);
+        const list = byDir.get(dir);
+        if (list)
+            list.push(file);
+        else
+            byDir.set(dir, [file]);
+    }
+    const groups = [];
+    for (const [dir, files] of byDir) {
+        groups.push({
+            changes: files.map(path => ({ path, hunks: { type: 'all' } })),
+            type: 'chore',
+            scope: dir === '(root)' ? null : dir,
+            summary: '',
+            details: [],
+            issueRefs: [],
+            dependencies: [],
+            rationale: `placeholder group for ${files.length} file(s) under "${dir}" — edit type/scope/summary and add dependencies`,
+        });
+    }
+    return groups;
+}
+function buildAnalysisGuidance(trivial, fileCount, groupCount) {
+    if (trivial) {
+        return `Trivial change (${trivial.type}: ${trivial.summary}) — call commit_apply with the suggested single commit group to commit directly.`;
+    }
+    return 'Author a split plan in `commit_apply`: pick a conventional type per group, write a concise imperative summary, '
+        + 'group related files together, and declare explicit `dependencies` indices when ordering matters (e.g. a lock file '
+        + 'after its manifest, generated code after the generator). Order is derived topologically; cycles are rejected. '
+        + `The suggested skeleton groups ${fileCount} file(s) into ${groupCount} group(s) — refine it, do not copy summaries verbatim.`;
+}
+function renderCommitAnalysis(value) {
+    const lines = [];
+    lines.push(`commit analysis — ${value.cwd}${value.branch ? ` (branch ${value.branch})` : ''}`);
+    if (value.files.length === 0) {
+        lines.push('No staged changes to commit.');
+        return lines.join('\n');
+    }
+    lines.push(`Files (${value.files.length} staged):`);
+    for (const file of value.files) {
+        lines.push(`  ${file.path}  +${file.additions} -${file.deletions}`);
+    }
+    if (value.lockFilesPending.length > 0) {
+        lines.push(`Lock files auto-placed by commit_apply: ${value.lockFilesPending.join(', ')}`);
+    }
+    if (value.trivial) {
+        lines.push(`Trivial: ${value.trivial.type} — ${value.trivial.summary}`);
+    }
+    if (value.diff.length > 0) {
+        lines.push(value.diffTruncated ? 'Diff (truncated):' : 'Diff:');
+        lines.push(value.diff);
+    }
+    for (const warning of value.warnings)
+        lines.push(`warning: ${warning}`);
+    return lines.join('\n');
+}
+/** Validate a plan's group fields; returns a readable error per problem. */
+function validateGroupFields(commits) {
+    const errors = [];
+    for (const [i, group] of commits.entries()) {
+        const label = `group ${i + 1}`;
+        if (!COMMIT_TYPES.includes(group.type)) {
+            errors.push(`${label}: unknown commit type "${String(group.type)}"; use one of ${COMMIT_TYPES.join(', ')}`);
+        }
+        if (typeof group.summary !== 'string' || group.summary.trim().length === 0) {
+            errors.push(`${label}: summary is required and must be non-empty`);
+        }
+        if (!Array.isArray(group.changes) || group.changes.length === 0) {
+            errors.push(`${label}: changes is required and must list at least one path`);
+        }
+        if (group.scope !== undefined && group.scope !== null && typeof group.scope !== 'string') {
+            errors.push(`${label}: scope must be a string or null`);
+        }
+        if (!Array.isArray(group.dependencies)) {
+            errors.push(`${label}: dependencies must be an array of group indices`);
+        }
+    }
+    return errors;
+}
+export function applyCommitApplyTool(ctx, _config = {}) {
+    ctx.tools.register(defineTool({
+        name: 'commit_apply',
+        description: 'Execute a validated split-commit plan on the staged changes. Requires the plan produced with `commit`: every staged '
+            + 'file must be covered exactly once, lock files are placed automatically, hunk selectors are validated against the '
+            + 'real diff, dependencies are resolved topologically (cycles rejected before anything is written), and each commit is '
+            + 'created atomically in dependency order. Use `dryRun: true` to preview exact messages before writing anything.',
+        parameters: {
+            commits: {
+                type: 'array',
+                description: 'Commit groups of the split plan (see commit_apply contract): each has changes [{path, hunks}], type, scope, summary, details, dependencies.',
+                items: {
+                    type: 'object',
+                    additionalProperties: false,
+                    properties: {
+                        changes: {
+                            type: 'array',
+                            required: true,
+                            description: 'Files (and optional hunk selectors) this commit covers; paths must name staged files.',
+                            items: {
+                                type: 'object',
+                                additionalProperties: false,
+                                properties: {
+                                    path: { type: 'string', required: true },
+                                    hunks: {
+                                        type: 'object',
+                                        description: 'Which part of the file to commit: all (default), indices (1-based hunk numbers), or lines (new-file line range).',
+                                        additionalProperties: false,
+                                        properties: {
+                                            type: { type: 'string', required: true, enum: ['all', 'indices', 'lines'] },
+                                            indices: { type: 'array', items: { type: 'integer' } },
+                                            start: { type: 'integer' },
+                                            end: { type: 'integer' },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                        type: { type: 'string', required: true, enum: [...COMMIT_TYPES], description: 'Conventional-commit type.' },
+                        scope: { type: 'string', description: 'Optional conventional scope.' },
+                        summary: { type: 'string', required: true, description: 'Imperative summary line, ≤72 chars.' },
+                        details: {
+                            type: 'array',
+                            description: 'Optional body bullet lines.',
+                            items: {
+                                type: 'object',
+                                additionalProperties: false,
+                                properties: {
+                                    text: { type: 'string', required: true },
+                                    userVisible: { type: 'boolean' },
+                                },
+                            },
+                        },
+                        issueRefs: { type: 'array', items: { type: 'string' } },
+                        dependencies: { type: 'array', items: { type: 'integer' }, description: 'Zero-based indices of groups that must commit first.' },
+                    },
+                },
+            },
+            dryRun: { type: 'boolean', description: 'Validate and print the exact commit messages without writing anything (default false).' },
+            push: { type: 'boolean', description: 'Push the branch after committing (default false).' },
+            cwd: { type: 'string', description: 'Working directory; defaults to the session workspace.' },
+        },
+        output: {
+            schema: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    mode: { type: 'string', required: true, enum: ['single', 'split'] },
+                    created: {
+                        type: 'array',
+                        required: true,
+                        items: {
+                            type: 'object',
+                            additionalProperties: false,
+                            properties: {
+                                position: { type: 'integer', required: true },
+                                hash: { type: 'string', required: true },
+                                message: { type: 'string', required: true },
+                                changes: { type: 'array', required: true, items: { type: 'string' } },
+                            },
+                        },
+                    },
+                    messages: { type: 'array', required: true, items: { type: 'string' } },
+                    warnings: { type: 'array', required: true, items: { type: 'string' } },
+                    dryRun: { type: 'boolean', required: true },
+                },
+            },
+            render: (_args, value) => [{
+                    type: 'text',
+                    text: renderCommitApply(value),
+                }],
+        },
+        isConcurrencySafe: () => false,
+        async execute(args, exec) {
+            const git = ctx.git;
+            const cwd = resolveCwd(exec, args.cwd);
+            if (!(await git.isRepo(cwd, exec.signal))) {
+                throw new Error(`commit_apply requires a git repository: ${cwd} is not inside a working tree`);
+            }
+            if (!Array.isArray(args.commits) || args.commits.length === 0) {
+                throw new Error('commit_apply requires a non-empty commits plan (call `commit` first to analyze)');
+            }
+            // Snapshot the actual staged state; validation and execution trust this,
+            // never the plan author's stale view.
+            const stagedDiff = await git.diffText(cwd, { cached: true, binary: true }, exec.signal);
+            const stagedFiles = await git.diff.changedFiles(cwd, { cached: true, signal: exec.signal });
+            const plan = { commits: args.commits.map(cloneGroup), warnings: [] };
+            const warnings = [...plan.warnings];
+            if (stagedFiles.length === 0) {
+                throw new Error('nothing is staged; run `commit` (adds changes) or `git add` first, or review `commit` with stagedOnly');
+            }
+            assignLockFilesToPlan(plan, stagedFiles);
+            // Coverage: every staged file planned exactly once.
+            const planned = new Set();
+            const duplicates = [];
+            for (const group of plan.commits) {
+                for (const change of group.changes) {
+                    if (planned.has(change.path))
+                        duplicates.push(change.path);
+                    planned.add(change.path);
+                }
+            }
+            const missing = stagedFiles.filter(file => !planned.has(file));
+            if (duplicates.length > 0) {
+                throw new Error(`Split commit plan assigns files to multiple groups: ${[...new Set(duplicates)].join(', ')}`);
+            }
+            if (missing.length > 0) {
+                throw new Error(`Split commit plan missing staged files: ${missing.join(', ')}`);
+            }
+            // Hunk selectors must resolve against the real diff.
+            const hunkErrors = validateHunkSelections(stagedDiff, plan.commits.flatMap(group => group.changes));
+            if (hunkErrors.length > 0) {
+                throw new Error(`Invalid hunk selections:\n${hunkErrors.map(error => `- ${error}`).join('\n')}`);
+            }
+            const fieldErrors = validateGroupFields(plan.commits);
+            if (fieldErrors.length > 0) {
+                throw new Error(fieldErrors.map(error => `- ${error}`).join('\n'));
+            }
+            const order = computeDependencyOrder(plan.commits);
+            if ('error' in order) {
+                throw new Error(`Plan rejected before anything was written: ${order.error}`);
+            }
+            const messages = order.map((index) => {
+                const group = plan.commits[index];
+                if (!group) {
+                    throw new Error('Plan rejected before anything was written: commit order references an unknown group');
+                }
+                return formatCommitMessage({ type: group.type, scope: group.scope, details: group.details ?? [], issueRefs: group.issueRefs ?? [] }, normalizeSummary(group.summary));
+            });
+            if (args.dryRun) {
+                return {
+                    mode: order.length === 1 ? 'single' : 'split',
+                    created: [],
+                    messages,
+                    warnings,
+                    dryRun: true,
+                };
+            }
+            const created = [];
+            await git.resetIndex(cwd, [], exec.signal);
+            try {
+                for (let position = 0; position < order.length; position++) {
+                    const index = order[position];
+                    const group = index === undefined ? undefined : plan.commits[index];
+                    if (index === undefined || group === undefined) {
+                        throw new Error('Plan rejected before anything was written: commit order references an unknown group');
+                    }
+                    try {
+                        await git.stageHunks(cwd, group.changes, { rawDiff: stagedDiff, signal: exec.signal });
+                    }
+                    catch (error) {
+                        const message = error instanceof Error ? error.message : String(error);
+                        throw new Error(`${position} of ${order.length} commits created so far; failed to stage group ${position + 1}: ${message}. `
+                            + 'No changes were lost — remaining changes are unstaged.');
+                    }
+                    const message = formatCommitMessage({ type: group.type, scope: group.scope, details: group.details ?? [], issueRefs: group.issueRefs ?? [] }, normalizeSummary(group.summary));
+                    try {
+                        await git.commit(cwd, message, { signal: exec.signal });
+                    }
+                    catch (error) {
+                        const detail = error instanceof Error ? error.message : String(error);
+                        throw new Error(`Commit ${position + 1} of ${order.length} failed: ${detail}. `
+                            + `${position} of ${order.length} commits created; no changes were lost.`);
+                    }
+                    const hash = (await git.log(cwd, { max: 1, signal: exec.signal }))[0]?.hash ?? '';
+                    created.push({
+                        position: position + 1,
+                        hash,
+                        message,
+                        changes: group.changes.map(change => change.path),
+                    });
+                    await git.resetIndex(cwd, [], exec.signal);
+                }
+            }
+            catch (error) {
+                // Leave the index empty so the user's worktree changes stay intact and
+                // inspectable; nothing was lost, no partial staging is leaked.
+                await git.resetIndex(cwd, [], exec.signal).catch(() => undefined);
+                throw error;
+            }
+            if (args.push) {
+                await git.push(cwd, { signal: exec.signal });
+            }
+            return {
+                mode: created.length === 1 ? 'single' : 'split',
+                created,
+                messages,
+                warnings,
+                dryRun: false,
+            };
+        },
+    }));
+}
+/** Deep-clone an input group into the service's own table (schema-validated fields). */
+function cloneGroup(group) {
+    return {
+        changes: (group.changes ?? []).map(change => ({
+            path: change.path,
+            hunks: normalizeHunks(change.hunks),
+        })),
+        type: group.type,
+        scope: group.scope ?? null,
+        summary: normalizeSummary(group.summary),
+        details: (group.details ?? []).map(detail => ({
+            text: detail.text,
+            userVisible: detail.userVisible ?? true,
+        })),
+        issueRefs: group.issueRefs ?? [],
+        dependencies: group.dependencies ?? [],
+        ...group.rationale !== undefined ? { rationale: group.rationale } : {},
+    };
+}
+function normalizeSummary(summary) {
+    return summary.trim().replace(/\s+/g, ' ');
+}
+function normalizeHunks(hunks) {
+    if (hunks === undefined || hunks === null)
+        return { type: 'all' };
+    const value = hunks;
+    if (value.type === 'indices')
+        return { type: 'indices', indices: (value.indices ?? []).map(Math.floor) };
+    if (value.type === 'lines') {
+        return { type: 'lines', start: Math.floor(value.start ?? 0), end: Math.floor(value.end ?? 0) };
+    }
+    return { type: 'all' };
+}
+function renderCommitApply(value) {
+    const lines = [];
+    if (value.dryRun) {
+        lines.push('Split commit plan (dry run):');
+    }
+    else if (value.created.length === 0) {
+        lines.push('Nothing committed.');
+    }
+    else {
+        lines.push(value.mode === 'split' ? `Created ${value.created.length} commits:` : 'Created 1 commit:');
+    }
+    for (const item of value.messages)
+        lines.push(`  ${item.replace(/\n/g, '\n  ')}`);
+    if (!value.dryRun && value.created.length > 0) {
+        for (const item of value.created) {
+            lines.push(`  [${item.position}/${value.created.length}] ${item.hash.slice(0, 8)} ${item.message.split('\n')[0]}`);
+        }
+    }
+    for (const warning of value.warnings)
+        lines.push(`warning: ${warning}`);
+    return lines.join('\n');
+}
+//# sourceMappingURL=commit.js.map