@produck/agent-toolkit 0.2.0 → 0.3.3

package/bin/command/sync-instructions/index.mjs

@@ -0,0 +1,272 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { getSingle, hasFlag } from '../shared/args.mjs';
+import { loadTextResource, printTextResource } from '../shared/text-resource.mjs';
+
+const COMMAND_DIR = path.dirname(fileURLToPath(import.meta.url));
+const PACKAGE_ROOT = path.resolve(COMMAND_DIR, '../../..');
+const PUBLISH_ASSETS_ROOT = path.resolve(PACKAGE_ROOT, 'publish-assets');
+const PUBLISH_INSTRUCTIONS_ROOT = path.resolve(PUBLISH_ASSETS_ROOT, 'instructions');
+const PUBLISH_NAMESPACE_ROOT = path.resolve(PUBLISH_INSTRUCTIONS_ROOT, 'produck');
+const MANAGED_MARKER = '<!-- managed-by: @produck/agent-toolkit -->';
+const DEFAULT_NAMESPACE_OUT_DIR = '.github/instructions/produck';
+const USER_SPACE_ENTRYPOINT = '.github/copilot-instructions.md';
+const HELP_FILE = path.resolve(COMMAND_DIR, 'help.txt');
+const USER_SPACE_BOOTSTRAP_FILE = path.resolve(COMMAND_DIR, 'user-space-bootstrap.md');
+
+export function printSyncInstructionsHelp() {
+  printTextResource(HELP_FILE);
+}
+
+function loadDefaultInstructionsTemplate() {
+  if (fs.existsSync(PUBLISH_NAMESPACE_ROOT)) {
+    const names = fs
+      .readdirSync(PUBLISH_NAMESPACE_ROOT)
+      .filter((name) => name.endsWith('.instructions.md'))
+      .sort((a, b) => a.localeCompare(b));
+    const entries = names.map((name) => {
+      const abs = path.resolve(PUBLISH_NAMESPACE_ROOT, name);
+      let text = fs.readFileSync(abs, 'utf8');
+      if (!text.endsWith('\n')) {
+        text = `${text}\n`;
+      }
+      return {
+        fileName: name,
+        content: text,
+        sourcePath: abs,
+      };
+    });
+    return {
+      type: 'dir',
+      sourcePath: PUBLISH_NAMESPACE_ROOT,
+      entries,
+    };
+  }
+
+  console.error('No built-in instruction assets found.');
+  console.error('Run prepack/publish to generate publish-assets, or pass --source explicitly.');
+  process.exit(2);
+}
+
+function readInstructionEntriesFromDirectory(sourceDir) {
+  const names = fs
+    .readdirSync(sourceDir)
+    .filter((name) => name.endsWith('.instructions.md'))
+    .sort((a, b) => a.localeCompare(b));
+  return names.map((name) => {
+    const sourcePath = path.resolve(sourceDir, name);
+    let content = fs.readFileSync(sourcePath, 'utf8');
+    if (!content.endsWith('\n')) {
+      content = `${content}\n`;
+    }
+    return {
+      fileName: name,
+      content,
+      sourcePath,
+    };
+  });
+}
+
+function isManagedFile(filePath) {
+  const content = fs.readFileSync(filePath, 'utf8');
+  return content.includes(MANAGED_MARKER);
+}
+
+function buildUserSpaceBootstrapContent(namespaceDirPath, cwd) {
+  const namespaceDisplayPath = path.relative(cwd, namespaceDirPath).replace(/\\/g, '/');
+  let content = loadTextResource(USER_SPACE_BOOTSTRAP_FILE);
+  content = content.replace(/\{\{NAMESPACE_GLOB\}\}/g, `${namespaceDisplayPath}/*.instructions.md`);
+  if (!content.endsWith('\n')) {
+    content = `${content}\n`;
+  }
+  return content;
+}
+
+export function runSyncInstructions(options) {
+  const cwd = path.resolve(getSingle(options, '--cwd', process.cwd()));
+  const outArg = getSingle(options, '--out', DEFAULT_NAMESPACE_OUT_DIR);
+  const sourceArg = getSingle(options, '--source', '');
+  const force = hasFlag(options, '--force');
+  const dryRun = hasFlag(options, '--dry-run');
+  const prune = hasFlag(options, '--prune');
+
+  if (!fs.existsSync(cwd)) {
+    console.error(`CWD does not exist: ${cwd}`);
+    process.exit(2);
+  }
+
+  const defaults = loadDefaultInstructionsTemplate();
+  let sourceType = defaults.type;
+  let sourceResolved = defaults.sourcePath;
+  let entries = defaults.entries;
+
+  if (sourceArg) {
+    const sourcePath = path.resolve(cwd, sourceArg);
+    if (!fs.existsSync(sourcePath)) {
+      console.error(`Source path does not exist: ${sourcePath}`);
+      process.exit(2);
+    }
+    const stat = fs.statSync(sourcePath);
+    if (stat.isDirectory()) {
+      sourceType = 'dir';
+      sourceResolved = sourcePath;
+      entries = readInstructionEntriesFromDirectory(sourcePath);
+      if (entries.length === 0) {
+        console.error(`No .instructions.md files in source directory: ${sourcePath}`);
+        process.exit(2);
+      }
+    } else {
+      sourceType = 'file';
+      sourceResolved = sourcePath;
+      let content = fs.readFileSync(sourcePath, 'utf8');
+      if (!content.endsWith('\n')) {
+        content = `${content}\n`;
+      }
+      entries = [
+        {
+          fileName: path.basename(sourcePath),
+          content,
+          sourcePath,
+        },
+      ];
+    }
+  }
+
+  const outPath = path.resolve(cwd, outArg);
+  const outLooksLikeFile = outArg.endsWith('.md');
+
+  if (outLooksLikeFile && entries.length > 1) {
+    console.error('Target --out is a file path but source has multiple instruction files.');
+    console.error('Use an output directory for multi-file sync.');
+    process.exit(2);
+  }
+
+  if (outLooksLikeFile) {
+    const entry = entries[0];
+    const exists = fs.existsSync(outPath);
+    if (exists && !force) {
+      const current = fs.readFileSync(outPath, 'utf8');
+      if (current !== entry.content) {
+        console.error(`Target already exists: ${outPath}`);
+        console.error('Use --force to overwrite.');
+        process.exit(2);
+      }
+    }
+
+    const report = {
+      mode: 'single-file',
+      cwd,
+      sourceType,
+      source: sourceResolved,
+      outPath,
+      exists,
+      overwritten: exists && force,
+      dryRun,
+      prune: false,
+      initializedUserSpaceEntry: false,
+      userSpaceEntryPath: null,
+    };
+
+    if (dryRun) {
+      process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+      process.exit(0);
+    }
+
+    fs.mkdirSync(path.dirname(outPath), { recursive: true });
+    fs.writeFileSync(outPath, entry.content, 'utf8');
+    process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+    return;
+  }
+
+  const outDir = outPath;
+  const planned = entries.map((entry) => {
+    return {
+      fileName: entry.fileName,
+      sourcePath: entry.sourcePath,
+      targetPath: path.resolve(outDir, entry.fileName),
+      content: entry.content,
+    };
+  });
+
+  const targetSet = new Set(planned.map((item) => item.targetPath));
+  const unchanged = [];
+  for (const item of planned) {
+    if (fs.existsSync(item.targetPath)) {
+      const current = fs.readFileSync(item.targetPath, 'utf8');
+      if (current === item.content) {
+        unchanged.push(item.targetPath);
+      }
+    }
+  }
+
+  const toWrite = planned.filter((item) => !unchanged.includes(item.targetPath));
+  const conflicts = toWrite.filter((item) => fs.existsSync(item.targetPath));
+  if (conflicts.length > 0 && !force) {
+    console.error('Some target files already exist and would change:');
+    for (const item of conflicts) {
+      console.error(`- ${item.targetPath}`);
+    }
+    console.error('Use --force to overwrite.');
+    process.exit(2);
+  }
+
+  const pruneDeletes = [];
+  if (prune && fs.existsSync(outDir)) {
+    const existing = fs
+      .readdirSync(outDir)
+      .filter((name) => name.endsWith('.instructions.md'))
+      .map((name) => path.resolve(outDir, name));
+    for (const existingPath of existing) {
+      if (!targetSet.has(existingPath) && isManagedFile(existingPath)) {
+        pruneDeletes.push(existingPath);
+      }
+    }
+  }
+
+  const userSpaceEntryPath = path.resolve(cwd, USER_SPACE_ENTRYPOINT);
+  const shouldInitUserSpaceEntry = !fs.existsSync(userSpaceEntryPath);
+
+  const report = {
+    mode: 'directory',
+    cwd,
+    sourceType,
+    source: sourceResolved,
+    outDir,
+    dryRun,
+    force,
+    prune,
+    initializedUserSpaceEntry: shouldInitUserSpaceEntry,
+    userSpaceEntryPath,
+    files: planned.map((item) => ({
+      fileName: item.fileName,
+      sourcePath: item.sourcePath,
+      targetPath: item.targetPath,
+      unchanged: unchanged.includes(item.targetPath),
+    })),
+    deleteFiles: pruneDeletes,
+  };
+
+  if (dryRun) {
+    process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+    process.exit(0);
+  }
+
+  fs.mkdirSync(outDir, { recursive: true });
+  for (const item of toWrite) {
+    fs.writeFileSync(item.targetPath, item.content, 'utf8');
+  }
+
+  if (shouldInitUserSpaceEntry) {
+    fs.mkdirSync(path.dirname(userSpaceEntryPath), { recursive: true });
+    const userSpaceBootstrap = buildUserSpaceBootstrapContent(outDir, cwd);
+    fs.writeFileSync(userSpaceEntryPath, userSpaceBootstrap, 'utf8');
+  }
+
+  for (const filePath of pruneDeletes) {
+    fs.unlinkSync(filePath);
+  }
+
+  process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+}

package/bin/command/validate-commit-msg/help.txt

@@ -0,0 +1,9 @@
+Usage:
+  agent-toolkit validate-commit-msg --file <message-file>
+
+Rules:
+  - In monorepo mode, a section header is required before tagged lines
+  - Non-empty lines must be either a section header (for example workspace: or @scope/pkg:) or start with [TAG]
+  - If section headers are used, each section header must be followed by at least one tagged line
+  - No empty lines are allowed
+  - Optional target form: [TAG] <target>: <summary>

package/bin/command/validate-commit-msg/index.mjs

@@ -0,0 +1,183 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { getSingle } from '../shared/args.mjs';
+import { printTextResource } from '../shared/text-resource.mjs';
+
+const ALLOWED_TAGS = ['INIT', 'ADD', 'REMOVE', 'FIX', 'REFACTOR', 'UPGRADE', 'PUBLISH'];
+const ALLOWED_TARGETS = ['docs', 'test', 'ci', 'deps', 'api', 'schema', 'infra', 'fmt'];
+const SECTION_HEADER_RE = /^(?:@[\w.-]+\/)?[\w.-]+:$/;
+const COMMAND_DIR = path.dirname(fileURLToPath(import.meta.url));
+const HELP_FILE = path.resolve(COMMAND_DIR, 'help.txt');
+const ROOT_PACKAGE_FILE = path.resolve(COMMAND_DIR, '../../../../../package.json');
+
+export function printValidateCommitMsgHelp() {
+  printTextResource(HELP_FILE);
+}
+
+function validateCommitLine(line, lineNo) {
+  if (line.trim() === '') {
+    return `Line ${lineNo}: empty line is not allowed`;
+  }
+
+  const head = line.match(/^\[([A-Z]+)\]\s+/);
+  if (!head) {
+    return `Line ${lineNo}: must start with [TAG] followed by a space`;
+  }
+
+  const tag = head[1];
+  if (!ALLOWED_TAGS.includes(tag)) {
+    return `Line ${lineNo}: tag [${tag}] is not allowed`;
+  }
+
+  const rest = line.slice(head[0].length);
+  if (rest.trim() === '') {
+    return `Line ${lineNo}: summary is required after tag`;
+  }
+
+  const targetMatch = rest.match(/^<([^>]+)>:\s+(.+)$/);
+  if (targetMatch) {
+    const target = targetMatch[1];
+    const summary = targetMatch[2];
+    if (!ALLOWED_TARGETS.includes(target)) {
+      return `Line ${lineNo}: target <${target}> is not allowed`;
+    }
+    if (summary.trim() === '') {
+      return `Line ${lineNo}: summary is required after target`;
+    }
+  }
+
+  return null;
+}
+
+function isSectionHeaderLine(line) {
+  return SECTION_HEADER_RE.test(line.trim());
+}
+
+function isMonorepoRoot() {
+  if (!fs.existsSync(ROOT_PACKAGE_FILE)) {
+    return false;
+  }
+
+  try {
+    const rootPackage = JSON.parse(fs.readFileSync(ROOT_PACKAGE_FILE, 'utf8'));
+    return Array.isArray(rootPackage.workspaces) && rootPackage.workspaces.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+function validateSectionFormat(lines) {
+  const errors = [];
+  let currentSection = '';
+  let currentSectionLineNo = 0;
+  let currentSectionHasTaggedLine = false;
+
+  for (let i = 0; i < lines.length; i += 1) {
+    const lineNo = i + 1;
+    const line = lines[i];
+
+    if (line.trim() === '') {
+      errors.push(`Line ${lineNo}: empty line is not allowed`);
+      continue;
+    }
+
+    if (isSectionHeaderLine(line)) {
+      if (currentSection && !currentSectionHasTaggedLine) {
+        errors.push(
+          `Line ${currentSectionLineNo}: section header "${currentSection}" must be followed by at least one tagged line`,
+        );
+      }
+
+      currentSection = line.trim();
+      currentSectionLineNo = lineNo;
+      currentSectionHasTaggedLine = false;
+      continue;
+    }
+
+    if (!currentSection) {
+      errors.push(
+        `Line ${lineNo}: section header is required before tagged lines when package/workspace sections are used`,
+      );
+      continue;
+    }
+
+    const err = validateCommitLine(line, lineNo);
+    if (err) {
+      errors.push(err);
+      continue;
+    }
+
+    currentSectionHasTaggedLine = true;
+  }
+
+  if (currentSection && !currentSectionHasTaggedLine) {
+    errors.push(
+      `Line ${currentSectionLineNo}: section header "${currentSection}" must be followed by at least one tagged line`,
+    );
+  }
+
+  return errors;
+}
+
+export function runValidateCommitMsg(options) {
+  const file = getSingle(options, '--file', '');
+  if (!file) {
+    printValidateCommitMsgHelp();
+    process.exit(2);
+  }
+
+  const filePath = path.resolve(file);
+  if (!fs.existsSync(filePath)) {
+    console.error(`Message file not found: ${filePath}`);
+    process.exit(2);
+  }
+
+  const raw = fs.readFileSync(filePath, 'utf8').replace(/\r\n/g, '\n');
+  const lines = raw.endsWith('\n') ? raw.slice(0, -1).split('\n') : raw.split('\n');
+
+  if (lines.length === 0 || (lines.length === 1 && lines[0].trim() === '')) {
+    console.error('Commit message is empty');
+    process.exit(2);
+  }
+
+  const mustUseSectionHeaders = isMonorepoRoot();
+  const hasSectionHeaders = lines.some((line) => isSectionHeaderLine(line));
+
+  // [PUBLISH] is generated by lerna and is always a repo-wide tag.
+  // In independent mode lerna appends package/version lines after the tag.
+  // Neither section headers nor a summary are required for this special tag.
+  const isPublishOnlyMessage = /^\[PUBLISH\](\s+.*)?$/.test(lines[0].trim());
+
+  if (isPublishOnlyMessage) {
+    console.log('Commit message validation passed');
+    return;
+  }
+
+  if (mustUseSectionHeaders && !hasSectionHeaders) {
+    console.error('Commit message validation failed:');
+    console.error('- Line 1: section header is required before tagged lines in monorepo mode');
+    process.exit(1);
+  }
+
+  const errors = hasSectionHeaders ? validateSectionFormat(lines) : [];
+  if (!hasSectionHeaders) {
+    for (let i = 0; i < lines.length; i += 1) {
+      const err = validateCommitLine(lines[i], i + 1);
+      if (err) {
+        errors.push(err);
+      }
+    }
+  }
+
+  if (errors.length > 0) {
+    console.error('Commit message validation failed:');
+    for (const err of errors) {
+      console.error(`- ${err}`);
+    }
+    process.exit(1);
+  }
+
+  console.log('Commit message validation passed');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@produck/agent-toolkit",
-  "version": "0.2.0",
+  "version": "0.3.3",
   "description": "Central CLI toolkit for organization AI execution workflows",
   "type": "module",
   "repository": {
@@ -13,12 +13,14 @@
   },
   "scripts": {
     "prepack": "node ./bin/build-publish-assets.mjs",
+    "coverage": "npm exec --yes -- c8 --reporter=lcov --reporter=html --reporter=text-summary node --test test/index.mjs",
+    "coverage:check": "npm exec --yes -- c8 --check-coverage --lines 100 --functions 100 --branches 100 --statements 100 node --test test/index.mjs",
+    "test": "node --test test/index.mjs",
     "verify": "node ./bin/agent-toolkit.mjs --help && node ./bin/agent-toolkit.mjs preflight --cwd . --require package.json",
     "pack:check": "npm pack --dry-run"
   },
   "files": [
     "bin",
-    "templates",
     "publish-assets"
   ],
   "publishConfig": {
@@ -28,5 +30,5 @@
     "node": ">=18.0.0"
   },
   "license": "MIT",
-  "gitHead": "8fbe9d26ada86a17e4f0444c2342e3904ba0f7f2"
+  "gitHead": "45bc825ac6c290ca99b58881ee3b052bd0c2265e"
 }

package/publish-assets/instructions/produck/00-produck-base.instructions.md

@@ -79,11 +79,7 @@ indent_style = space
 indent_size = 2
 trim_trailing_whitespace = true
 
-[*.yml]
-indent_style = space
-indent_size = 2
-
-[*.yaml]
+[*.{yml,yaml}]
 indent_style = space
 indent_size = 2
 
@@ -118,8 +114,11 @@ max_line_length = 80
   be present in repository lint configuration.
 - Apply minimal patching only: keep existing repository/framework structure and
   add the smallest necessary changes.
-- Repository-specific overrides are allowed, but should layer on top of
-  `@produck/eslint-rules` instead of bypassing it.
+- Repository-specific overrides are optional and should be added only when
+  behavior intentionally differs from shared presets.
+- In ESLint flat config, "layer on top" means local override items must appear
+  after shared preset items in exported order.
+- No-op overrides that repeat inherited values should be avoided.
 
 ## Language conventions
 
@@ -142,24 +141,16 @@ max_line_length = 80
 - If details are needed, use additional tagged lines.
 - Do not keep summary as an untagged standalone line.
 - Recommended local validation:
-  `npm exec --package=@produck/agent-toolkit@latest agent-toolkit
-validate-commit-msg --file <message-file>`.
-- Use uppercase tags from this whitelist: `[INIT]`, `[ADD]`, `[REMOVE]`,
-  `[FIX]`, `[REFACTOR]`, `[UPGRADE]`.
-- Legacy tag mapping for migration is `[ADDED]` -> `[ADD]`, `[REMOVED]` ->
-  `[REMOVE]`, and `[FIXED]` -> `[FIX]`.
-- To express content domain, summary may use target syntax: `[TAG] <target>:
-  <summary>`.
-- Allowed targets are `docs`, `test`, `ci`, `deps`, `api`, `schema`, and
-  `infra`.
-- If target syntax is used, target must be wrapped in angle brackets and must be
-  from the allowed target list.
+  `npm exec -- agent-toolkit validate-commit-msg --file <message-file>`.
+- Commit precheck policy follows
+  `.github/distribution/produck/20-produck-commit.instructions.md`.
+- Canonical source for commit tag/target whitelists, legacy mapping, and
+  target syntax is
+  `.github/distribution/produck/20-produck-commit.instructions.md`.
+- Do not redefine commit tag or target whitelists in other instruction files.
 - For non-monorepo repositories, use `[TAG] summary` directly (no
   package/workspace section headers).
 - Bracketed commit summaries should be in English
-- `[UPGRADE] deps` is allowed for pure dependency upgrades; if IFF artifacts or
-  IPC-related artifacts/calls are updated, the summary must name those updates
-  explicitly.
 - PR title format is repository-defined; no organization-level title format
   restriction
 - In PR descriptions, summarize what changed, why it changed, how it was
@@ -189,14 +180,10 @@ Recommended three-step flow:
 
 Recommended local tools:
 
-- `npm exec --package=@produck/agent-toolkit@latest agent-toolkit preflight
---cwd . --require package.json --ensure-dir logs`
-- `npm exec --package=@produck/agent-toolkit@latest agent-toolkit run-capture
---out logs/run.log --cmd "<command>"`
-- `npm exec --package=@produck/agent-toolkit@latest agent-toolkit summarize-log
---file logs/run.log --last 120`
-- `npm exec --package=@produck/agent-toolkit@latest agent-toolkit summarize-log
---file logs/run.log --match "FAIL|ERROR"`
+- `npm exec -- agent-toolkit preflight --cwd . --require package.json --ensure-dir logs`
+- `npm exec -- agent-toolkit run-capture --out logs/run.log --cmd "<command>"`
+- `npm exec -- agent-toolkit summarize-log --file logs/run.log --last 120`
+- `npm exec -- agent-toolkit summarize-log --file logs/run.log --match "FAIL|ERROR"`
 
 Guardrails:
 
@@ -247,21 +234,31 @@ When CI enforcement is deferred, use manual sync per repository:
    `.github/instructions/produck/`.
 2. Keep repository-specific exceptions in `.github/copilot-instructions.md`.
 3. Validate critical policies manually in each update cycle.
+4. After instruction sync, validate duplicated policy sections remain
+   consistent across instruction files, especially commit tag and target
+   whitelists.
 
 Recommended command:
 
-- `npm exec --package=@produck/agent-toolkit@latest -- agent-toolkit sync-instructions --cwd . --source <path-to-org>/.github/distribution/produck --force --prune`
+- `npm exec -- agent-toolkit sync-instructions --cwd . --source <path-to-org>/.github/distribution/produck --force --prune`
 
-If the package has been published, `--source` can be omitted to use built-in
-assets from `@produck/agent-toolkit`.
+If the installed package includes bundled assets, `--source` can be omitted to
+use those built-in assets.
 
 This keeps instruction entrypoints aligned without requiring submodule or
 automatic PR rollout.
 
 ### Central package execution policy
 
-When bridge mechanism uses a central npm package, default execution strategy is
-`@latest` to deliver new capabilities quickly.
+When bridge mechanism uses a central npm package, the package is installed
+locally in downstream repositories at a fixed version managed by the
+organization baseline.
+
+- Local install and pinned version are deployed by
+  `agent-toolkit sync-husky-hooks`.
+- Invocation uses the locally installed copy:
+  `npm exec -- <bin> ...`.
+- Do not use `npm exec --package=<pkg>@latest` for routine invocations.
 
 Local implementation reference in this repository:
 
@@ -270,12 +267,12 @@ Local implementation reference in this repository:
 - This local path is the implementation source, not an automatic runtime mount
   for other repositories.
 
-Required safeguards for `@latest`:
+Required safeguards for central tooling:
 
 - Print resolved package version before running high-impact commands.
 - For high-risk operations, run dry-run/preview first, then execute.
 - Keep an emergency fallback path to a pinned version for incident mitigation.
-- Prefer `npm exec --package=<pkg>@latest <bin> ...` for predictable invocation.
+- Prefer `npm exec -- <bin> ...` for predictable invocation.
 
 Version observability (required before high-impact operations):
 
@@ -307,7 +304,8 @@ Use the following template text in organization AI instructions:
   - For large output tasks, use two phases: capture full output, then analyze.
   - Avoid fragile shell pipeline post-processing for long-output commands.
 - Central package policy:
-  - Default to `<pkg>@latest` for organization tooling commands.
+  - Central package is installed locally at a fixed organization-baseline version.
+  - Invoke via `npm exec -- <bin> ...` to use the locally installed copy.
   - Print resolved package version before high-impact execution.
   - Use dry-run first for risky operations; keep rollback path to pinned version.
 - Commit message policy:
@@ -316,7 +314,7 @@ Use the following template text in organization AI instructions:
   - Use only allowed tags: `[INIT]`, `[ADD]`, `[REMOVE]`, `[FIX]`,
     `[REFACTOR]`, `[UPGRADE]`.
   - Optional target syntax is `[TAG] <target>: <summary>` with target in:
-    `docs`, `test`, `ci`, `deps`, `api`, `schema`, `infra`.
+    `docs`, `test`, `ci`, `deps`, `api`, `schema`, `infra`, `fmt`.
 - Do not assume scripts from organization `.github` repository exist in target
   repositories.
 - If a repository provides stricter rules, repository rules override