@hifullmoon/aicommit 2.2.0 → 2.2.1

package/CHANGELOG.md

@@ -4,6 +4,17 @@ This file lists notable user-facing changes. Internal refactors, test-only chang
 
 ## [Unreleased]
 
+## [2.2.1] - 2026-08-29
+
+### Fixed
+
+- Combined repository commit policies with commitlint constraints without allowing either source to relax the other, including correct `never` and complete-header length handling.
+- Hardened split transactions against changes during snapshot capture, restricted plan exports to safe locations, and prevented existing output files from being overwritten.
+
+### Security
+
+- Redacted credential assignments with quoted JSON or YAML keys before diffs and untracked previews are sent to a model.
+
 ## [2.2.0] - 2026-08-28
 
 ### Added
@@ -153,7 +164,8 @@ This file lists notable user-facing changes. Internal refactors, test-only chang
 - Added file-level split planning and execution with Git-state concurrency checks.
 - Added provider presets and user/project configuration boundaries.
 
-[Unreleased]: https://github.com/hi-fullmoon/AICommit/compare/v2.2.0...HEAD
+[Unreleased]: https://github.com/hi-fullmoon/AICommit/compare/v2.2.1...HEAD
+[2.2.1]: https://github.com/hi-fullmoon/AICommit/releases/tag/v2.2.1
 [2.2.0]: https://github.com/hi-fullmoon/AICommit/releases/tag/v2.2.0
 [2.1.0]: https://github.com/hi-fullmoon/AICommit/releases/tag/v2.1.0
 [2.0.1]: https://github.com/hi-fullmoon/AICommit/releases/tag/v2.0.1

package/README.md

@@ -415,7 +415,7 @@ When reasoning mode is `on` (including via `--reasoning=<level>`), aicommit requ
 
 `aicommit split` (also available as the explicit `aicommit split run`) asks whether to group the staged index snapshot or all staged, unstaged, and untracked changes into file-level logical commits. Use `--scope=staged` or `--scope=all` when the boundary must be explicit, including every non-interactive run. You can review the plan, regenerate messages for selected groups, or edit the plan as JSON before committing. Sensitive-content detection fails closed before a non-interactive provider request or automatic staging.
 
-For an auditable two-step flow, `aicommit split plan --scope=staged|all --file=<path>` exports a versioned JSON artifact, and `aicommit split apply --file=<path>` rechecks its base commit, change set, and content fingerprint before touching the index. Keep plan files outside the worktree or under `.git` so they cannot become part of their own plan.
+For an auditable two-step flow, `aicommit split plan --scope=staged|all --file=<path>` exports a versioned JSON artifact, and `aicommit split apply --file=<path>` rechecks its base commit, change set, and content fingerprint before touching the index. Keep plan files outside the worktree or under the dedicated `.git/aicommit/` directory so they cannot become part of their own plan. Export never overwrites an existing destination.
 
 Execution uses temporary indexes and a code-free checkpoint under `.git/aicommit`. A hook, Git error, interruption, or crash leaves completed commits in history and preserves the pending snapshot; the failure report shows checkpointed, in-flight, pending, and current worktree/index state. Resolve the cause and run `aicommit split resume`. Resume reconciles the possible post-commit crash window before creating anything else, so a completed group is neither duplicated nor omitted. If you intentionally finished or replaced the interrupted work through another Git workflow, run `aicommit split abort`; it removes only the stale checkpoint and never rewrites HEAD, the index, or the worktree. New committing split runs detect a checkpoint before contacting the provider. If planning or preflight fails before the first group, no split commit is created and the real index remains unchanged.
 

package/README.zh-CN.md

@@ -417,7 +417,7 @@ exec zsh
 
 `aicommit split`（也可以显式写成 `aicommit split run`）会询问是对暂存 index 快照分组，还是对全部已暂存、未暂存和未跟踪变更做文件级分组。边界必须明确时请使用 `--scope=staged` 或 `--scope=all`，所有非交互运行都应显式指定范围。提交前可以审阅计划、为选中的组重新生成消息，或直接编辑 JSON 计划。敏感内容检测会在非交互 Provider 请求或自动暂存前 fail closed。
 
-如需可审计的两步流程，使用 `aicommit split plan --scope=staged|all --file=<path>` 导出版本化 JSON 工件，再用 `aicommit split apply --file=<path>` 在接触 index 前重新校验 base commit、变更集和内容指纹。计划文件应保存在工作区之外或 `.git` 下，避免被纳入自身计划。
+如需可审计的两步流程，使用 `aicommit split plan --scope=staged|all --file=<path>` 导出版本化 JSON 工件，再用 `aicommit split apply --file=<path>` 在接触 index 前重新校验 base commit、变更集和内容指纹。计划文件应保存在工作区之外或专用的 `.git/aicommit/` 目录下，避免被纳入自身计划；导出不会覆盖已有目标文件。
 
 执行过程使用临时 index，并在 `.git/aicommit` 下保存不含代码内容的 checkpoint。hook、Git 错误、中断或崩溃发生后，已完成提交仍保留在历史中，待处理快照也会保留；失败报告会显示已 checkpoint、执行中、待处理，以及当前工作区 / index 状态。解决问题后运行 `aicommit split resume`。恢复流程会先协调“提交完成后崩溃”的可能窗口，再创建任何新提交，因此不会重复或遗漏已完成分组。如果你通过其他 Git 流程有意完成或替换了中断工作，请运行 `aicommit split abort`；它只删除过期 checkpoint，绝不会改写 HEAD、index 或工作区。新的 split 提交流程会在联系 Provider 前检测现有 checkpoint。如果规划或预检在第一组之前失败，不会创建任何 split 提交，真实 index 也保持不变。
 

package/docs/distribution.md

@@ -26,7 +26,7 @@ The release workflow uses npm Trusted Publishing without a long-lived `NPM_TOKEN
 ```bash
 workdir=$(mktemp -d)
 cd "$workdir"
-npm install --package-lock-only @hifullmoon/aicommit@2.2.0
+npm install --package-lock-only @hifullmoon/aicommit@2.2.1
 npm audit signatures
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hifullmoon/aicommit",
-  "version": "2.2.0",
+  "version": "2.2.1",
   "description": "Safe, local-first AI commit message generator for Git workflows",
   "type": "module",
   "bin": {

package/src/completion.js

@@ -46,7 +46,9 @@ complete -F _aicommit aicommit
 
 const ZSH = `#compdef aicommit
 _aicommit() {
+  local curcontext="$curcontext" state state_descr line
   local -a commands options
+  typeset -A opt_args
   commands=(
     'setup:interactive configuration wizard'
     'doctor:diagnose configuration and connectivity'
@@ -71,15 +73,17 @@ _aicommit() {
     '--output=[output mode]:output:(text json)'
     '--debug[show debug details]'
   )
-  _arguments -C $options '*::argument:->args'
+  _arguments -C $options '1:command:->command' '*::argument:->args'
   case $state in
+    command)
+      _describe 'command' commands
+      ;;
     args)
-      case $words[2] in
+      case $line[1] in
         config) _values 'config action' show validate path ;;
         policy) _values 'policy action' template check ;;
         completion) _values 'shell' bash zsh fish ;;
         split) _values 'split action' run plan apply resume abort ;;
-        *) _describe 'command' commands ;;
       esac
       ;;
   esac

package/src/context.js

@@ -381,20 +381,22 @@ function quotedValues(text) {
 
 function enumRule(text, name) {
   const index = text.search(new RegExp(`['"]?${name}['"]?\\s*:`));
-  if (index < 0) return [];
+  if (index < 0) return null;
   const window = text.slice(index, index + 3000);
   const nested = window.match(
-    /\[\s*[012]\s*,\s*['"](?:always|never)['"]\s*,\s*\[([\s\S]*?)\]\s*\]/i,
+    /\[\s*([012])\s*,\s*['"](always|never)['"]\s*,\s*\[([\s\S]*?)\]\s*\]/i,
   );
-  return nested ? quotedValues(nested[1]) : [];
+  if (!nested || nested[1] === '0') return null;
+  return { condition: nested[2].toLowerCase(), values: quotedValues(nested[3]) };
 }
 
 function numberRule(text, name) {
   const index = text.search(new RegExp(`['"]?${name}['"]?\\s*:`));
   if (index < 0) return null;
   const window = text.slice(index, index + 500);
-  const match = window.match(/\[\s*[012]\s*,\s*['"](?:always|never)['"]\s*,\s*(\d{1,3})\s*\]/i);
-  return match ? Number(match[1]) : null;
+  const match = window.match(/\[\s*([012])\s*,\s*['"](always|never)['"]\s*,\s*(\d{1,3})\s*\]/i);
+  if (!match || match[1] === '0') return null;
+  return { condition: match[2].toLowerCase(), value: Number(match[3]) };
 }
 
 export function detectCommitlintConstraints(
@@ -410,22 +412,53 @@ export function detectCommitlintConstraints(
     ) {
       continue;
     }
-    const types = enumRule(text, 'type-enum').filter((value) => /^[a-z][a-z0-9-]*$/.test(value));
-    const scopes = enumRule(text, 'scope-enum').filter((value) => /^[a-z0-9._/-]+$/i.test(value));
-    const subjectMaxLength = numberRule(text, 'subject-max-length');
-    const headerMaxLength = numberRule(text, 'header-max-length');
-    if (!types.length && !scopes.length && !subjectMaxLength && !headerMaxLength) continue;
+    const typeRule = enumRule(text, 'type-enum');
+    const scopeRule = enumRule(text, 'scope-enum');
+    const subjectLengthRule = numberRule(text, 'subject-max-length');
+    const headerLengthRule = numberRule(text, 'header-max-length');
+    const validTypes = (typeRule?.values || []).filter((value) => /^[a-z][a-z0-9-]*$/.test(value));
+    const validScopes = (scopeRule?.values || []).filter((value) => /^[a-z0-9._/-]+$/i.test(value));
+    const types = typeRule?.condition === 'always' ? validTypes : [];
+    const disallowedTypes = typeRule?.condition === 'never' ? validTypes : [];
+    const scopes = scopeRule?.condition === 'always' ? validScopes : [];
+    const disallowedScopes = scopeRule?.condition === 'never' ? validScopes : [];
+    const subjectMaxLength =
+      subjectLengthRule?.condition === 'always' ? subjectLengthRule.value : null;
+    const headerMaxLength =
+      headerLengthRule?.condition === 'always' ? headerLengthRule.value : null;
+    const unsupported = [];
+    if (subjectLengthRule?.condition === 'never') unsupported.push('subject-max-length: never');
+    if (headerLengthRule?.condition === 'never') unsupported.push('header-max-length: never');
+    if (
+      !types.length &&
+      !disallowedTypes.length &&
+      !scopes.length &&
+      !disallowedScopes.length &&
+      !subjectMaxLength &&
+      !headerMaxLength &&
+      !unsupported.length
+    ) {
+      continue;
+    }
     const lines = [`Detected commitlint constraints from ${path}:`];
     if (types.length) lines.push(`- allowed types: ${types.join(', ')}`);
+    if (disallowedTypes.length) lines.push(`- disallowed types: ${disallowedTypes.join(', ')}`);
     if (scopes.length) lines.push(`- allowed scopes: ${scopes.join(', ')}`);
+    if (disallowedScopes.length) {
+      lines.push(`- disallowed scopes: ${disallowedScopes.join(', ')}`);
+    }
     if (subjectMaxLength) lines.push(`- subject max length: ${subjectMaxLength}`);
     if (headerMaxLength) lines.push(`- header max length: ${headerMaxLength}`);
+    if (unsupported.length) lines.push(`- unsupported inverted rules: ${unsupported.join(', ')}`);
     return {
       path,
       types,
+      disallowedTypes,
       scopes,
+      disallowedScopes,
       subjectMaxLength,
       headerMaxLength,
+      unsupported,
       text: truncate(lines.join('\n'), settings.maxChars),
     };
   }
@@ -436,17 +469,72 @@ export function applyCommitlintPolicy(commitPolicy, constraints, fallbackLanguag
   if (!constraints) return commitPolicy;
   const current = normalizeCommitPolicy(commitPolicy, fallbackLanguage);
   const patch = {};
-  if (constraints.types?.length) patch.types = constraints.types;
+  if (constraints.unsupported?.length) {
+    throw new Error(
+      `Invalid config: unsupported inverted commitlint rules: ${constraints.unsupported.join(', ')}.`,
+    );
+  }
+
+  let types = [...current.types];
+  if (constraints.types?.length) {
+    types = types.filter((type) => constraints.types.includes(type));
+  }
+  if (constraints.disallowedTypes?.length) {
+    types = types.filter((type) => !constraints.disallowedTypes.includes(type));
+  }
+  if (!types.length) {
+    throw new Error('Invalid config: commitPolicy and commitlint allow no common commit types.');
+  }
+  if (types.length !== current.types.length) patch.types = types;
+
+  let scopeMode = current.scope.mode;
+  let scopes = [...current.scope.values];
+  const disallowedScopes = new Set(current.scope.disallowedValues || []);
+  const hasFiniteScopeAllowlist = Boolean(
+    current.scope.values.length || constraints.scopes?.length,
+  );
   if (constraints.scopes?.length) {
-    patch.scope = {
+    scopes = scopes.length
+      ? scopes.filter((scope) => constraints.scopes.includes(scope))
+      : [...constraints.scopes];
+  }
+  for (const scope of constraints.disallowedScopes || []) disallowedScopes.add(scope);
+  if (scopes.length) scopes = scopes.filter((scope) => !disallowedScopes.has(scope));
+  if (!scopes.length && hasFiniteScopeAllowlist) {
+    if (scopeMode === 'required') {
+      throw new Error('Invalid config: commitPolicy and commitlint allow no common scopes.');
+    }
+    scopeMode = 'forbidden';
+    disallowedScopes.clear();
+  }
+  if (
+    scopeMode !== current.scope.mode ||
+    JSON.stringify(scopes) !== JSON.stringify(current.scope.values) ||
+    JSON.stringify([...disallowedScopes]) !== JSON.stringify(current.scope.disallowedValues || [])
+  ) {
+    const nextScope = {
       ...current.scope,
-      values: constraints.scopes,
+      mode: scopeMode,
+      values: scopes,
+      ...(disallowedScopes.size ? { disallowedValues: [...disallowedScopes] } : {}),
     };
+    if (!disallowedScopes.size) delete nextScope.disallowedValues;
+    patch.scope = nextScope;
   }
-  if (constraints.subjectMaxLength) {
+  if (constraints.subjectMaxLength || constraints.headerMaxLength) {
     patch.subject = {
       ...current.subject,
-      maxLength: Math.min(current.subject.maxLength, constraints.subjectMaxLength),
+      maxLength: constraints.subjectMaxLength
+        ? Math.min(current.subject.maxLength, constraints.subjectMaxLength)
+        : current.subject.maxLength,
+      ...(constraints.headerMaxLength
+        ? {
+            headerMaxLength: Math.min(
+              current.subject.headerMaxLength ?? Infinity,
+              constraints.headerMaxLength,
+            ),
+          }
+        : {}),
     };
   }
   const merged = mergeCommitPolicy(current, patch);

package/src/git.js

@@ -336,7 +336,7 @@ const SENSITIVE_FILE_RE =
 const PRIVATE_KEY_RE = /-----BEGIN (?:[A-Z0-9 ]+ )?PRIVATE KEY-----/i;
 const AWS_KEY_RE = /\b(?:AKIA|ASIA)[A-Z0-9]{16}\b/g;
 const ASSIGNED_SECRET_RE =
-  /(\b(?:api[_-]?key|access[_-]?token|auth(?:orization)?|client[_-]?secret|password|passwd|secret|token)\b\s*[:=]\s*["']?)([^\s,"'}]{8,})/gi;
+  /(\b(?:api[_-]?key|access[_-]?token|auth(?:orization)?|client[_-]?secret|password|passwd|secret|token)\b["']?\s*[:=]\s*["']?)([^\s,"'}]{8,})/gi;
 
 export function isSensitiveFile(path) {
   const normalized = String(path || '').replace(/\\/g, '/');

package/src/policy-command.js

@@ -21,8 +21,19 @@ function normalizedPolicyDocument(policy) {
   return {
     version: policy.version,
     types: [...policy.types],
-    scope: { mode: policy.scope.mode, values: [...policy.scope.values] },
-    subject: { maxLength: policy.subject.maxLength },
+    scope: {
+      mode: policy.scope.mode,
+      values: [...policy.scope.values],
+      ...(policy.scope.disallowedValues?.length
+        ? { disallowedValues: [...policy.scope.disallowedValues] }
+        : {}),
+    },
+    subject: {
+      maxLength: policy.subject.maxLength,
+      ...(policy.subject.headerMaxLength
+        ? { headerMaxLength: policy.subject.headerMaxLength }
+        : {}),
+    },
     body: { mode: policy.body.mode, maxLines: policy.body.maxLines },
     breakingChange: policy.breakingChange,
     language: policy.language,

package/src/policy.js

@@ -46,7 +46,13 @@ function clonePolicy(policy) {
   return {
     ...policy,
     types: [...policy.types],
-    scope: { ...policy.scope, values: [...policy.scope.values] },
+    scope: {
+      ...policy.scope,
+      values: [...policy.scope.values],
+      ...(policy.scope.disallowedValues
+        ? { disallowedValues: [...policy.scope.disallowedValues] }
+        : {}),
+    },
     subject: { ...policy.subject },
     body: { ...policy.body },
   };
@@ -69,6 +75,14 @@ export function mergeCommitPolicy(base = DEFAULT_COMMIT_POLICY, override = {}) {
               : base.scope.values,
           }
         : override.scope;
+  if (object(scope)) {
+    if (Array.isArray(scope.values)) scope.values = [...scope.values];
+    if (Array.isArray(scope.disallowedValues)) {
+      scope.disallowedValues = [...scope.disallowedValues];
+    } else {
+      delete scope.disallowedValues;
+    }
+  }
   const subject =
     override.subject === undefined
       ? { ...base.subject }
@@ -111,6 +125,25 @@ function assertStringArray(values, name, { max = 64, pattern } = {}) {
   }
 }
 
+function assertOptionalStringArray(values, name, { max = 64, pattern } = {}) {
+  if (values === undefined) return;
+  if (!Array.isArray(values) || values.length > max) {
+    throw new Error(`Invalid config "${name}": expected at most ${max} strings.`);
+  }
+  if (
+    values.some(
+      (value) =>
+        typeof value !== 'string' ||
+        !value ||
+        value.length > 64 ||
+        (pattern && !pattern.test(value)),
+    ) ||
+    new Set(values).size !== values.length
+  ) {
+    throw new Error(`Invalid config "${name}": contains an invalid or duplicate value.`);
+  }
+}
+
 export function validateCommitPolicyConfig(value) {
   if (!object(value)) throw new Error('Invalid config "commitPolicy": expected an object.');
   if (value.version !== 1) {
@@ -137,6 +170,14 @@ export function validateCommitPolicyConfig(value) {
   ) {
     throw new Error('Invalid config "commitPolicy.scope.values": contains an invalid value.');
   }
+  assertOptionalStringArray(value.scope.disallowedValues, 'commitPolicy.scope.disallowedValues', {
+    pattern: SCOPE_RE,
+  });
+  if (value.scope.disallowedValues?.some((scope) => value.scope.values.includes(scope))) {
+    throw new Error(
+      'Invalid config "commitPolicy.scope": allowed and disallowed values must not overlap.',
+    );
+  }
 
   if (!object(value.subject)) {
     throw new Error('Invalid config "commitPolicy.subject": expected an object.');
@@ -150,6 +191,16 @@ export function validateCommitPolicyConfig(value) {
       'Invalid config "commitPolicy.subject.maxLength": expected an integer between 1 and 200.',
     );
   }
+  if (
+    value.subject.headerMaxLength !== undefined &&
+    (!Number.isInteger(value.subject.headerMaxLength) ||
+      value.subject.headerMaxLength < 1 ||
+      value.subject.headerMaxLength > 1000)
+  ) {
+    throw new Error(
+      'Invalid config "commitPolicy.subject.headerMaxLength": expected an integer between 1 and 1000.',
+    );
+  }
 
   if (!object(value.body)) {
     throw new Error('Invalid config "commitPolicy.body": expected an object.');
@@ -197,7 +248,10 @@ function scopeRule(policy) {
   const allowed = policy.scope.values.length
     ? `; allowed values: ${policy.scope.values.join(', ')}`
     : '';
-  return `${policy.scope.mode}${allowed}`;
+  const disallowed = policy.scope.disallowedValues?.length
+    ? `; disallowed values: ${policy.scope.disallowedValues.join(', ')}`
+    : '';
+  return `${policy.scope.mode}${allowed}${disallowed}`;
 }
 
 export function buildCommitPolicyPrompt(policy, customPrompt = '') {
@@ -219,6 +273,9 @@ export function buildCommitPolicyPrompt(policy, customPrompt = '') {
     `- Allowed types: ${policy.types.join(', ')}`,
     `- Scope: ${scopeRule(policy)}`,
     `- Subject text: required, at most ${policy.subject.maxLength} characters`,
+    ...(policy.subject.headerMaxLength
+      ? [`- Complete header: at most ${policy.subject.headerMaxLength} characters`]
+      : []),
     `- Body: ${policy.body.mode}, at most ${policy.body.maxLines} non-empty lines, separated from the subject by a blank line`,
     `- Breaking change: ${policy.breakingChange}; use "!" and/or a "BREAKING CHANGE:" footer`,
     `- Language: ${targetLanguage}`,
@@ -344,6 +401,9 @@ export function validateCommitCandidate(message, { policy, diff = '' } = {}) {
         ),
       );
     }
+    if (parsed.scope && normalizedPolicy.scope.disallowedValues?.includes(parsed.scope)) {
+      issues.push(issue('scope_value', `Scope "${parsed.scope}" is forbidden.`));
+    }
     if ([...parsed.subject].length > normalizedPolicy.subject.maxLength) {
       issues.push(
         issue(
@@ -352,6 +412,17 @@ export function validateCommitCandidate(message, { policy, diff = '' } = {}) {
         ),
       );
     }
+    if (
+      normalizedPolicy.subject.headerMaxLength &&
+      [...parsedMessage.header].length > normalizedPolicy.subject.headerMaxLength
+    ) {
+      issues.push(
+        issue(
+          'header_length',
+          `Header exceeds ${normalizedPolicy.subject.headerMaxLength} characters.`,
+        ),
+      );
+    }
     if (effectiveLanguage === 'zh' && !/\p{Script=Han}/u.test(parsed.subject)) {
       issues.push(issue('language', 'The subject must be written in Simplified Chinese.'));
     }
@@ -414,6 +485,9 @@ export function buildPolicyCorrectionPrompt(badReply, errors, policy) {
     `Allowed types: ${policy.types.join(', ')}`,
     `Scope rule: ${scopeRule(policy)}`,
     `Maximum subject length: ${policy.subject.maxLength}`,
+    ...(policy.subject.headerMaxLength
+      ? [`Maximum complete header length: ${policy.subject.headerMaxLength}`]
+      : []),
     `Body rule: ${policy.body.mode}, maximum ${policy.body.maxLines} non-empty lines`,
     `Breaking-change rule: ${policy.breakingChange}`,
     'Rewrite it once. Output only the complete corrected commit message; do not include explanations or fences.',

package/src/split-plan.js

@@ -1,4 +1,4 @@
-import { lstat, mkdir, readFile, rename, unlink, writeFile } from 'node:fs/promises';
+import { link, lstat, mkdir, readFile, unlink, writeFile } from 'node:fs/promises';
 import { dirname, isAbsolute, resolve } from 'node:path';
 
 import { normalizeCommitPolicy, validateCommitCandidate } from './policy.js';
@@ -35,7 +35,13 @@ function clonePolicy(policy, language) {
   return {
     version: normalized.version,
     types: [...normalized.types],
-    scope: { ...normalized.scope, values: [...normalized.scope.values] },
+    scope: {
+      ...normalized.scope,
+      values: [...normalized.scope.values],
+      ...(normalized.scope.disallowedValues
+        ? { disallowedValues: [...normalized.scope.disallowedValues] }
+        : {}),
+    },
     subject: { ...normalized.subject },
     body: { ...normalized.body },
     breakingChange: normalized.breakingChange,
@@ -310,12 +316,19 @@ export async function writeSplitPlanArtifact(path, artifact) {
     await writeFile(temporary, JSON.stringify(validated, null, 2) + '\n', {
       encoding: 'utf8',
       mode: 0o600,
+      flag: 'wx',
     });
-    await rename(temporary, absolute);
+    // A same-directory hard link installs the completed file atomically while
+    // failing with EEXIST instead of replacing an unrelated destination.
+    await link(temporary, absolute);
   } catch (err) {
     await unlink(temporary).catch(() => {});
+    if (err.code === 'EEXIST') {
+      throw new Error(`Split plan output already exists: ${absolute}`, { cause: err });
+    }
     throw err;
   }
+  await unlink(temporary).catch(() => {});
   return absolute;
 }
 

package/src/split.js

@@ -117,17 +117,22 @@ function canonicalDestination(path) {
   }
 }
 
-function safeExportPlanPath(projectRoot, path) {
+export function safeExportPlanPath(projectRoot, path) {
   const absolute = resolve(path);
   const rawGitDir = readGit(['rev-parse', '--git-dir'], projectRoot).trim();
   const gitDir = isAbsolute(rawGitDir) ? rawGitDir : resolve(projectRoot, rawGitDir);
   const canonicalRoot = canonicalExistingPath(projectRoot);
   const canonicalGitDir = canonicalDestination(gitDir);
+  const canonicalAicommitDir = canonicalDestination(join(gitDir, 'aicommit'));
   const canonicalPlan = canonicalDestination(absolute);
-  if (pathIsWithin(canonicalRoot, canonicalPlan) && !pathIsWithin(canonicalGitDir, canonicalPlan)) {
+  const insideAicommitDir = pathIsWithin(canonicalAicommitDir, canonicalPlan);
+  if (
+    (pathIsWithin(canonicalRoot, canonicalPlan) && !insideAicommitDir) ||
+    (pathIsWithin(canonicalGitDir, canonicalPlan) && !insideAicommitDir)
+  ) {
     throw fail(
       ERROR_CATEGORIES.CONFIG,
-      'Split plan output must be outside the working tree or inside the repository Git directory.',
+      "Split plan output must be outside the working tree or inside the repository Git directory's dedicated .git/aicommit/ metadata subdirectory.",
     );
   }
   return absolute;
@@ -336,8 +341,13 @@ export async function generateSplitPlan(
       : []),
     'Rules:',
     `- Each group must represent ONE logical change and use one allowed type: ${policy.types.join(', ')}.`,
-    `- Scope mode: ${policy.scope.mode}${policy.scope.values.length ? `; allowed scopes: ${policy.scope.values.join(', ')}` : ''}.`,
+    `- Scope mode: ${policy.scope.mode}${policy.scope.values.length ? `; allowed scopes: ${policy.scope.values.join(', ')}` : ''}${policy.scope.disallowedValues?.length ? `; disallowed scopes: ${policy.scope.disallowedValues.join(', ')}` : ''}.`,
     `- Subject text must not exceed ${policy.subject.maxLength} characters.`,
+    ...(policy.subject.headerMaxLength
+      ? [
+          `- The complete commit header must not exceed ${policy.subject.headerMaxLength} characters.`,
+        ]
+      : []),
     `- Body mode: ${policy.body.mode}; at most ${policy.body.maxLines} non-empty lines.`,
     `- Breaking changes: ${policy.breakingChange}.`,
     '- Give every message a short subject line; when the subject alone does not say it all, add a body of bullet lines (what changed and why), each starting with "- " — the same format the single-commit flow produces.',
@@ -1277,13 +1287,39 @@ export function executeSplit(
           groups,
           hunkMode: allFiles.some((change) => change.hunks?.length),
         });
+      const fingerprintBeforeSnapshot = getSplitStateFingerprint(
+        projectRoot,
+        hasHead(projectRoot),
+        undefined,
+        scope,
+      );
+      if (fingerprintBeforeSnapshot !== plan.fingerprint) {
+        throw fail(
+          ERROR_CATEGORIES.CONCURRENT_MODIFICATION,
+          'Split state changed before the transaction snapshot was captured.',
+        );
+      }
+      options.faultInjector?.('before_snapshot_capture', { plan });
       const snapshots = captureCheckpointSnapshots(projectRoot, scope, allFiles);
+      const fingerprintAfterSnapshot = getSplitStateFingerprint(
+        projectRoot,
+        hasHead(projectRoot),
+        undefined,
+        scope,
+      );
+      if (fingerprintAfterSnapshot !== plan.fingerprint) {
+        throw fail(
+          ERROR_CATEGORIES.CONCURRENT_MODIFICATION,
+          'Split state changed while the transaction snapshot was being captured.',
+        );
+      }
       hunkExecution = validateHunkTransaction(projectRoot, plan, snapshots);
       transaction = {
         ...createSplitCheckpoint(projectRoot, plan, snapshots),
         faultInjector: options.faultInjector,
       };
     } catch (err) {
+      if (err?.category === ERROR_CATEGORIES.CONCURRENT_MODIFICATION) throw err;
       throw fail(ERROR_CATEGORIES.GIT_STATE, `Failed to create split checkpoint: ${err.message}`, {
         cause: err,
       });