@produck/agent-toolkit 0.3.3 → 0.5.0

package/bin/command/sync-workspace-config/index.mjs

@@ -0,0 +1,290 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+import { getSingle, hasFlag } from '../shared/args.mjs';
+import { printTextResource } from '../shared/text-resource.mjs';
+import { validateRequiredExactEntries } from '../shared/workspace-validation.mjs';
+
+const COMMAND_DIR = path.dirname(fileURLToPath(import.meta.url));
+const HELP_FILE = path.resolve(COMMAND_DIR, 'help.txt');
+const PACKAGE_ROOT = path.resolve(COMMAND_DIR, '../../..');
+const REPO_ROOT = path.resolve(PACKAGE_ROOT, '../..');
+const TOOLKIT_PACKAGE_JSON = path.resolve(PACKAGE_ROOT, 'package.json');
+const TOOLING_BASELINE_CANDIDATE_PATHS = [
+  path.resolve(REPO_ROOT, '.github/distribution/produck/tooling-version-baseline.json'),
+  path.resolve(PACKAGE_ROOT, 'publish-assets/instructions/produck/tooling-version-baseline.json'),
+];
+
+const REQUIRED_BASELINE_SCRIPT_KEY = 'produck:baseline';
+const REQUIRED_BASELINE_SCRIPT_VALUE =
+  'npm exec --package=@produck/agent-toolkit@latest -- agent-toolkit enforce-node-baseline --cwd .';
+const REQUIRED_WORKSPACE_COVERAGE_SCRIPT_KEY = 'produck:coverage';
+const REQUIRED_WORKSPACE_COVERAGE_SCRIPT_VALUE =
+  'c8 --config .c8rc.json npm run test --workspaces --if-present';
+const REQUIRED_PRECOMMIT_CHECK_SCRIPT_KEY = 'produck:precommit-check';
+const REQUIRED_PRECOMMIT_CHECK_SCRIPT_VALUE = 'npm run produck:format && npm run produck:lint';
+const REQUIRED_C8_CONFIG_FILE = '.c8rc.json';
+const REQUIRED_C8_CONFIG_CONTENT = `${JSON.stringify(
+  {
+    reporter: ['lcov', 'html', 'text-summary'],
+  },
+  null,
+  2,
+)}\n`;
+
+export function printSyncWorkspaceConfigHelp() {
+  printTextResource(HELP_FILE);
+}
+
+function parseJsonFile(filePath, label) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    console.error(`${label} is not valid JSON: ${filePath}`);
+    process.exit(2);
+  }
+}
+
+function getRequiredToolkitDevDependency() {
+  const overrideVersion = String(process.env.PRODUCK_TOOLKIT_VERSION_OVERRIDE || '').trim();
+  if (overrideVersion) {
+    return overrideVersion;
+  }
+
+  const npmCommand = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+  const latestResult = spawnSync(npmCommand, ['view', '@produck/agent-toolkit', 'version'], {
+    encoding: 'utf8',
+  });
+
+  const latestVersion = String(latestResult.stdout || '').trim();
+  if (latestResult.status === 0 && latestVersion) {
+    return latestVersion;
+  }
+
+  const pkg = parseJsonFile(TOOLKIT_PACKAGE_JSON, 'Toolkit package.json');
+  const version = typeof pkg.version === 'string' ? pkg.version.trim() : '';
+
+  if (!version) {
+    console.error(`Toolkit package version is missing: ${TOOLKIT_PACKAGE_JSON}`);
+    process.exit(2);
+  }
+
+  return version;
+}
+
+function loadToolingBaseline() {
+  const toolingBaselinePath = TOOLING_BASELINE_CANDIDATE_PATHS.find((candidatePath) => {
+    return fs.existsSync(candidatePath);
+  });
+
+  if (!toolingBaselinePath) {
+    console.error('Tooling baseline file does not exist in expected locations:');
+    for (const candidatePath of TOOLING_BASELINE_CANDIDATE_PATHS) {
+      console.error(`- ${candidatePath}`);
+    }
+    process.exit(2);
+  }
+
+  const baseline = parseJsonFile(toolingBaselinePath, 'Tooling baseline file');
+  const c8Version = String(baseline?.tools?.c8?.version || '').trim();
+  const huskyVersion = String(baseline?.tools?.husky?.version || '').trim();
+  const lernaVersion = String(baseline?.tools?.lerna?.version || '').trim();
+
+  if (!c8Version || !huskyVersion || !lernaVersion) {
+    console.error(
+      `Tooling baseline must define fixed tools.c8/husky/lerna.version: ${toolingBaselinePath}`,
+    );
+    process.exit(2);
+  }
+
+  return {
+    toolingBaselinePath,
+    c8Version,
+    huskyVersion,
+    lernaVersion,
+  };
+}
+
+function buildScriptState(pkg) {
+  const scripts =
+    pkg.scripts && typeof pkg.scripts === 'object' && !Array.isArray(pkg.scripts)
+      ? { ...pkg.scripts }
+      : {};
+
+  return {
+    scripts,
+    previousBaseline:
+      typeof scripts[REQUIRED_BASELINE_SCRIPT_KEY] === 'string'
+        ? scripts[REQUIRED_BASELINE_SCRIPT_KEY]
+        : null,
+    previousCoverage:
+      typeof scripts[REQUIRED_WORKSPACE_COVERAGE_SCRIPT_KEY] === 'string'
+        ? scripts[REQUIRED_WORKSPACE_COVERAGE_SCRIPT_KEY]
+        : null,
+    previousPrecommitCheck:
+      typeof scripts[REQUIRED_PRECOMMIT_CHECK_SCRIPT_KEY] === 'string'
+        ? scripts[REQUIRED_PRECOMMIT_CHECK_SCRIPT_KEY]
+        : null,
+  };
+}
+
+function readFileIfExists(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+
+  return fs.readFileSync(filePath, 'utf8');
+}
+
+function buildDevDependencyState(pkg) {
+  const devDependencies =
+    pkg.devDependencies &&
+    typeof pkg.devDependencies === 'object' &&
+    !Array.isArray(pkg.devDependencies)
+      ? { ...pkg.devDependencies }
+      : {};
+
+  return {
+    devDependencies,
+    previousManaged: {
+      c8: typeof devDependencies.c8 === 'string' ? devDependencies.c8 : null,
+      husky: typeof devDependencies.husky === 'string' ? devDependencies.husky : null,
+      lerna: typeof devDependencies.lerna === 'string' ? devDependencies.lerna : null,
+      '@produck/agent-toolkit':
+        typeof devDependencies['@produck/agent-toolkit'] === 'string'
+          ? devDependencies['@produck/agent-toolkit']
+          : null,
+    },
+  };
+}
+
+export function runSyncWorkspaceConfig(options) {
+  const cwd = path.resolve(getSingle(options, '--cwd', process.cwd()));
+  const check = hasFlag(options, '--check');
+  const dryRun = hasFlag(options, '--dry-run') && !check;
+  const jsonFile = getSingle(options, '--json', '');
+  const mode = check ? 'check' : dryRun ? 'dry-run' : 'sync';
+
+  if (!fs.existsSync(cwd)) {
+    console.error(`CWD does not exist: ${cwd}`);
+    process.exit(2);
+  }
+
+  const rootPackageJsonPath = path.resolve(cwd, 'package.json');
+  if (!fs.existsSync(rootPackageJsonPath)) {
+    console.error(`Root package.json does not exist: ${rootPackageJsonPath}`);
+    process.exit(2);
+  }
+
+  const pkg = parseJsonFile(rootPackageJsonPath, 'Root package.json');
+  const toolingBaseline = loadToolingBaseline();
+  const requiredToolkitDependency = getRequiredToolkitDevDependency();
+  const requiredDevDependencies = {
+    c8: toolingBaseline.c8Version,
+    husky: toolingBaseline.huskyVersion,
+    lerna: toolingBaseline.lernaVersion,
+    '@produck/agent-toolkit': requiredToolkitDependency,
+  };
+
+  const scriptState = buildScriptState(pkg);
+  const dependencyState = buildDevDependencyState(pkg);
+  const c8ConfigPath = path.resolve(cwd, REQUIRED_C8_CONFIG_FILE);
+  const currentC8ConfigContent = readFileIfExists(c8ConfigPath);
+
+  const scriptValidation = validateRequiredExactEntries(scriptState.scripts, {
+    [REQUIRED_BASELINE_SCRIPT_KEY]: REQUIRED_BASELINE_SCRIPT_VALUE,
+    [REQUIRED_WORKSPACE_COVERAGE_SCRIPT_KEY]: REQUIRED_WORKSPACE_COVERAGE_SCRIPT_VALUE,
+    [REQUIRED_PRECOMMIT_CHECK_SCRIPT_KEY]: REQUIRED_PRECOMMIT_CHECK_SCRIPT_VALUE,
+  });
+  const dependencyValidation = validateRequiredExactEntries(
+    dependencyState.devDependencies,
+    requiredDevDependencies,
+  );
+
+  const matchesRequiredBaseline = !(REQUIRED_BASELINE_SCRIPT_KEY in scriptValidation.mismatches);
+  const matchesRequiredWorkspaceCoverage = !(
+    REQUIRED_WORKSPACE_COVERAGE_SCRIPT_KEY in scriptValidation.mismatches
+  );
+  const matchesRequiredPrecommitCheck = !(
+    REQUIRED_PRECOMMIT_CHECK_SCRIPT_KEY in scriptValidation.mismatches
+  );
+  const matchesRequiredManagedDevDependencies = dependencyValidation.ok;
+  const matchesRequiredC8Config = currentC8ConfigContent === REQUIRED_C8_CONFIG_CONTENT;
+
+  const requiresUpdate =
+    !matchesRequiredBaseline ||
+    !matchesRequiredWorkspaceCoverage ||
+    !matchesRequiredPrecommitCheck ||
+    !matchesRequiredManagedDevDependencies ||
+    !matchesRequiredC8Config;
+
+  if (mode === 'sync' && requiresUpdate) {
+    scriptState.scripts[REQUIRED_BASELINE_SCRIPT_KEY] = REQUIRED_BASELINE_SCRIPT_VALUE;
+    scriptState.scripts[REQUIRED_WORKSPACE_COVERAGE_SCRIPT_KEY] =
+      REQUIRED_WORKSPACE_COVERAGE_SCRIPT_VALUE;
+    scriptState.scripts[REQUIRED_PRECOMMIT_CHECK_SCRIPT_KEY] =
+      REQUIRED_PRECOMMIT_CHECK_SCRIPT_VALUE;
+    pkg.scripts = scriptState.scripts;
+
+    for (const [name, version] of Object.entries(requiredDevDependencies)) {
+      dependencyState.devDependencies[name] = version;
+    }
+    pkg.devDependencies = dependencyState.devDependencies;
+
+    fs.writeFileSync(rootPackageJsonPath, `${JSON.stringify(pkg, null, 2)}\n`, 'utf8');
+    fs.writeFileSync(c8ConfigPath, REQUIRED_C8_CONFIG_CONTENT, 'utf8');
+  }
+
+  const report = {
+    cwd,
+    mode,
+    ok: true,
+    rootPackageJsonPath,
+    toolingBaselinePath: toolingBaseline.toolingBaselinePath,
+    required: {
+      baselineScriptKey: REQUIRED_BASELINE_SCRIPT_KEY,
+      baselineScriptValue: REQUIRED_BASELINE_SCRIPT_VALUE,
+      workspaceCoverageScriptKey: REQUIRED_WORKSPACE_COVERAGE_SCRIPT_KEY,
+      workspaceCoverageScriptValue: REQUIRED_WORKSPACE_COVERAGE_SCRIPT_VALUE,
+      precommitCheckScriptKey: REQUIRED_PRECOMMIT_CHECK_SCRIPT_KEY,
+      precommitCheckScriptValue: REQUIRED_PRECOMMIT_CHECK_SCRIPT_VALUE,
+      c8ConfigFile: REQUIRED_C8_CONFIG_FILE,
+      managedDevDependencies: requiredDevDependencies,
+    },
+    status: {
+      matchesRequiredBaselineBefore: matchesRequiredBaseline,
+      matchesRequiredWorkspaceCoverageBefore: matchesRequiredWorkspaceCoverage,
+      matchesRequiredPrecommitCheckBefore: matchesRequiredPrecommitCheck,
+      matchesRequiredManagedDevDependenciesBefore: matchesRequiredManagedDevDependencies,
+      matchesRequiredC8ConfigBefore: matchesRequiredC8Config,
+      matchesRequiredBaselineAfter:
+        requiresUpdate && mode === 'sync' ? true : matchesRequiredBaseline,
+      matchesRequiredWorkspaceCoverageAfter:
+        requiresUpdate && mode === 'sync' ? true : matchesRequiredWorkspaceCoverage,
+      matchesRequiredPrecommitCheckAfter:
+        requiresUpdate && mode === 'sync' ? true : matchesRequiredPrecommitCheck,
+      matchesRequiredManagedDevDependenciesAfter:
+        requiresUpdate && mode === 'sync' ? true : matchesRequiredManagedDevDependencies,
+      matchesRequiredC8ConfigAfter:
+        requiresUpdate && mode === 'sync' ? true : matchesRequiredC8Config,
+      updated: requiresUpdate && mode === 'sync',
+    },
+  };
+
+  if (mode === 'check' && requiresUpdate) {
+    report.ok = false;
+  }
+
+  if (jsonFile) {
+    const outPath = path.resolve(cwd, jsonFile);
+    fs.mkdirSync(path.dirname(outPath), { recursive: true });
+    fs.writeFileSync(outPath, `${JSON.stringify(report, null, 2)}\n`, 'utf8');
+  }
+
+  process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+  if (!report.ok) {
+    process.exit(2);
+  }
+}

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

@@ -3,7 +3,8 @@ Usage:
 
 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]
+  - In monorepo mode, section headers must use one of: workspace:, *:, or a workspace package name section (for example @produck/agent-toolkit:)
+  - Non-empty lines must be either a section header 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

@@ -7,10 +7,12 @@ 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 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');
+const WORKSPACE_SCOPE = 'workspace';
+const WILDCARD_SCOPE = '*';
 
 export function printValidateCommitMsgHelp() {
   printTextResource(HELP_FILE);
@@ -68,7 +70,47 @@ function isMonorepoRoot() {
   }
 }
 
-function validateSectionFormat(lines) {
+function getMonorepoAllowedSectionScopes() {
+  if (!fs.existsSync(ROOT_PACKAGE_FILE)) {
+    return null;
+  }
+
+  let rootPackage;
+  try {
+    rootPackage = JSON.parse(fs.readFileSync(ROOT_PACKAGE_FILE, 'utf8'));
+  } catch {
+    return null;
+  }
+
+  if (!Array.isArray(rootPackage.workspaces) || rootPackage.workspaces.length === 0) {
+    return null;
+  }
+
+  const rootDir = path.dirname(ROOT_PACKAGE_FILE);
+  const allowedScopes = new Set([WORKSPACE_SCOPE, WILDCARD_SCOPE]);
+
+  for (const workspaceEntry of rootPackage.workspaces) {
+    const workspacePath = path.resolve(rootDir, String(workspaceEntry));
+    const workspacePackageJsonPath = path.resolve(workspacePath, 'package.json');
+
+    if (!fs.existsSync(workspacePackageJsonPath)) {
+      continue;
+    }
+
+    try {
+      const workspacePackage = JSON.parse(fs.readFileSync(workspacePackageJsonPath, 'utf8'));
+      if (typeof workspacePackage.name === 'string' && workspacePackage.name.trim() !== '') {
+        allowedScopes.add(workspacePackage.name.trim());
+      }
+    } catch {
+      continue;
+    }
+  }
+
+  return allowedScopes;
+}
+
+function validateSectionFormat(lines, allowedSectionScopes = null) {
   const errors = [];
   let currentSection = '';
   let currentSectionLineNo = 0;
@@ -90,6 +132,13 @@ function validateSectionFormat(lines) {
         );
       }
 
+      const sectionName = line.trim().slice(0, -1);
+      if (allowedSectionScopes && !allowedSectionScopes.has(sectionName)) {
+        errors.push(
+          `Line ${lineNo}: section header "${line.trim()}" is not allowed in monorepo mode`,
+        );
+      }
+
       currentSection = line.trim();
       currentSectionLineNo = lineNo;
       currentSectionHasTaggedLine = false;
@@ -143,6 +192,7 @@ export function runValidateCommitMsg(options) {
   }
 
   const mustUseSectionHeaders = isMonorepoRoot();
+  const allowedSectionScopes = mustUseSectionHeaders ? getMonorepoAllowedSectionScopes() : null;
   const hasSectionHeaders = lines.some((line) => isSectionHeaderLine(line));
 
   // [PUBLISH] is generated by lerna and is always a repo-wide tag.
@@ -161,7 +211,7 @@ export function runValidateCommitMsg(options) {
     process.exit(1);
   }
 
-  const errors = hasSectionHeaders ? validateSectionFormat(lines) : [];
+  const errors = hasSectionHeaders ? validateSectionFormat(lines, allowedSectionScopes) : [];
   if (!hasSectionHeaders) {
     for (let i = 0; i < lines.length; i += 1) {
       const err = validateCommitLine(lines[i], i + 1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@produck/agent-toolkit",
-  "version": "0.3.3",
+  "version": "0.5.0",
   "description": "Central CLI toolkit for organization AI execution workflows",
   "type": "module",
   "repository": {
@@ -13,11 +13,10 @@
   },
   "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"
+    "pack:check": "npm pack --dry-run",
+    "produck:coverage": "c8 --reporter=lcov --reporter=html --reporter=text-summary npm test"
   },
   "files": [
     "bin",
@@ -30,5 +29,8 @@
     "node": ">=18.0.0"
   },
   "license": "MIT",
-  "gitHead": "45bc825ac6c290ca99b58881ee3b052bd0c2265e"
+  "devDependencies": {
+    "c8": "11.0.0"
+  },
+  "gitHead": "fb8c64919617ff5a76b1c736d1fe3903206ed131"
 }

package/publish-assets/instructions/produck/10-produck-node.instructions.md

@@ -41,14 +41,31 @@ Notes:
     `npm exec -- agent-toolkit sync-coverage-script --cwd .`.
   - Use central remediation command to deploy local anti-drift hook baseline:
     `npm exec -- agent-toolkit sync-husky-hooks --cwd .`.
+  - Use central remediation command to deploy root format script/config
+    baseline:
+    `npm exec -- agent-toolkit sync-prettier-config --cwd .`.
+  - Use central remediation command to deploy root lint script/config and
+    eslint integration baseline:
+    `npm exec -- agent-toolkit sync-eslint-config --cwd .`.
+  - Use central remediation command to deploy root shared scripts/dependencies
+    baseline:
+    `npm exec -- agent-toolkit sync-workspace-config --cwd .`.
   - `c8` execution baseline for deployed coverage scripts is fixed to the
     version specified in `tooling-version-baseline.json`.
   - Downstream repositories must not use unversioned `npx c8` or `c8@latest`
     in shared scripts/CI.
-  - Root `devDependencies.c8` and root `devDependencies.lerna` must be pinned
-    to organization baseline fixed versions via `agent-toolkit sync-husky-hooks`.
+  - Root local governance must pin `devDependencies.c8`,
+    `devDependencies.husky`, `devDependencies.lerna`, and
+    `devDependencies.@produck/agent-toolkit` via
+    `agent-toolkit sync-workspace-config`.
+  - Root local governance must pin `devDependencies.@produck/eslint-rules`
+    via `agent-toolkit sync-eslint-config`.
 
 - Testing strategy and framework are repository-defined.
+- `verify` scripts are optional repository-local health checks and are not
+  organization-required script keys.
+- `verify` is not part of organization commit gates; style gates remain
+  repository `format:check` and `lint` policy.
 - `test` script implementation is repository-defined and is not overwritten by
   organization coverage remediation.
 - Repositories should keep `npm run test` and `npm run produck:coverage`
@@ -70,7 +87,15 @@ Central toolkit command role model:
   governance and is mandatory in monorepo mode.
 - `agent-toolkit sync-husky-hooks` is the hard guard for local anti-drift hook
   governance and is mandatory in monorepo mode.
-- For simplified downstream execution of mandatory flow (1 -> 2 -> 3 -> 4),
+- `agent-toolkit sync-prettier-config` is the hard guard for root format
+  script/config governance and is mandatory in monorepo mode.
+- `agent-toolkit sync-eslint-config` is the hard guard for root lint
+  script/config and eslint integration governance and is mandatory in monorepo
+  mode.
+- `agent-toolkit sync-workspace-config` is the hard guard for root shared
+  scripts/dependencies governance and is mandatory in monorepo mode.
+- For simplified downstream execution of mandatory flow (1 -> 2 -> 3 -> 4 ->
+  5 -> 6 -> 7),
   use:
   `npm exec -- agent-toolkit`.
 - Equivalent explicit form:
@@ -157,18 +182,38 @@ Script placement:
   and `lint` orchestration scripts.
 - Root `package.json` must reserve `produck:precommit-check` for organization
   anti-drift gate with required value:
-  `npm run format:check && npm run lint`.
+  `npm run produck:format && npm run produck:lint`.
 - Root `package.json` must reserve `prepare` for husky setup with required
   value: `husky`.
+- Root `package.json` must reserve `produck:format` and `produck:lint` for
+  organization-controlled format/lint gates.
 - `publish` may be defined at root or package level based on release workflow.
 - Workspace subpackage `produck:coverage` scripts must be synchronized by
   `agent-toolkit sync-coverage-script`.
 - Root local hook governance must be synchronized by
   `agent-toolkit sync-husky-hooks`.
-- Root local hook governance must pin root `devDependencies.c8`,
-  `devDependencies.husky`, `devDependencies.lerna`, and
+- Root local format governance must be synchronized by
+  `agent-toolkit sync-prettier-config`.
+- Root local lint governance must be synchronized by
+  `agent-toolkit sync-eslint-config`.
+- Root local shared script/dependency governance must be synchronized by
+  `agent-toolkit sync-workspace-config`.
+- Root local shared script/dependency governance must pin root
+  `devDependencies.c8`,
+  `devDependencies.husky`, `devDependencies.lerna`,
   `devDependencies.@produck/agent-toolkit` via
-  `agent-toolkit sync-husky-hooks`.
+  `agent-toolkit sync-workspace-config`.
+- Root local shared script/dependency governance must initialize
+  `scripts.produck:coverage` with workspace-level execution behavior:
+  attempt `test` on all workspace packages using `--workspaces --if-present`.
+- Root local shared script/dependency governance must initialize `.c8rc.json`
+  via `agent-toolkit sync-workspace-config`.
+- Root local format governance must initialize `.prettierrc` and
+  `scripts.produck:format` via `agent-toolkit sync-prettier-config`.
+- Root local lint governance must initialize `eslint.config.mjs`,
+  `scripts.produck:lint`, and `devDependencies.@produck/eslint-rules`
+  (including append-mode integration for existing eslint config) via
+  `agent-toolkit sync-eslint-config`.
 - Root `package.json` must define a `produck:baseline` script for organization
   baseline enforcement:
   ```json

package/publish-assets/instructions/produck/20-produck-commit.instructions.md

@@ -28,6 +28,11 @@ Monorepo format (required for multi-package repositories):
 
 - Package/workspace labels appear as **section headers** followed by a colon
   (format: `package-name:` or `@scope/package:`).
+- Section scope naming convention:
+  - For subpackage changes, use the package `name` as section header
+    (for example `@produck/agent-toolkit:`).
+  - For non-subpackage or root-level changes, use `workspace:`.
+  - For complex mixed commits across multiple scopes, `*:` is allowed.
 - All lines under a package header belong to that package.
 - Every line under a package header must start with `[TAG]`.
 - No empty lines between tagged lines within a package section.
@@ -172,6 +177,8 @@ Commit precheck gate (AI-agent required, human recommended):
 - For AI-agent-authored operations, complete repository style gates before both
   `git commit` and `git commit --amend` (for example `format:check` and
   `lint`).
+- For AI-agent-authored operations, `git commit --no-verify` and
+  `git commit --amend --no-verify` are forbidden.
 - For human engineer-authored operations, style gates are recommended baseline
   practice unless repository-specific hooks/CI enforce them.
 - Temporary non-executable state or failing tests are allowed for