@produck/agent-toolkit 0.9.2 → 0.11.0

package/bin/agent-toolkit.mjs

@@ -42,6 +42,14 @@ import {
   printSyncPublishHelp,
   runSyncPublish,
 } from './command/sync-publish/index.mjs';
+import {
+  printSyncTypescriptHelp,
+  runSyncTypescript,
+} from './command/sync-typescript/index.mjs';
+import {
+  printSyncWorkspaceHelp,
+  runSyncWorkspace,
+} from './command/sync-workspace/index.mjs';
 import { hasFlag, parseCommonArgs } from './command/shared/args.mjs';
 import {
   printValidateCommitMsgHelp,
@@ -101,6 +109,14 @@ const COMMANDS = {
     printHelp: printSyncPublishHelp,
     run: runSyncPublish,
   },
+  'sync-typescript': {
+    printHelp: printSyncTypescriptHelp,
+    run: runSyncTypescript,
+  },
+  'sync-workspace': {
+    printHelp: printSyncWorkspaceHelp,
+    run: runSyncWorkspace,
+  },
 };
 
 const DEFAULT_COMMAND = 'enforce-node-baseline';

package/bin/build-publish-assets.mjs

@@ -49,6 +49,7 @@ const OUTPUT_LERNA_PATH = path.resolve(
   PACKAGE_ROOT,
   'publish-assets/lerna.json',
 );
+const ROOT_PACKAGE_JSON_PATH = path.resolve(REPO_ROOT, 'package.json');
 const LEGACY_OUTPUT_PATH = path.resolve(
   PACKAGE_ROOT,
   'publish-assets/instructions/org.instructions.md',
@@ -80,6 +81,10 @@ function validateSourceFile(fileName, text) {
   }
 }
 
+function resolveSemverExact(text) {
+  return text.replace(/^[\^~>=<]+\s*/, '').trim();
+}
+
 function readAndValidateToolingBaseline() {
   if (!fs.existsSync(SOURCE_TOOLING_BASELINE_PATH)) {
     throw new Error(
@@ -98,25 +103,40 @@ function readAndValidateToolingBaseline() {
     );
   }
 
-  const c8Version = baseline?.tools?.c8?.version;
-  const lernaVersion = baseline?.tools?.lerna?.version;
-  const coverageScriptTemplate = baseline?.coverage?.scriptTemplate;
-
   if (typeof baseline.schemaVersion !== 'number') {
     throw new Error(
       `Invalid tooling baseline schemaVersion in: ${SOURCE_TOOLING_BASELINE_PATH}`,
     );
   }
 
+  // Auto-resolve tool versions: only override version when set to "auto"
+  const rootPkg = JSON.parse(fs.readFileSync(ROOT_PACKAGE_JSON_PATH, 'utf8'));
+  const devDeps = rootPkg.devDependencies || {};
+
+  for (const [toolName, entry] of Object.entries(baseline.tools)) {
+    if (entry.version === 'auto') {
+      const depVersion = devDeps[toolName];
+      if (typeof depVersion === 'string' && depVersion.trim()) {
+        entry.version = resolveSemverExact(depVersion);
+      }
+    }
+  }
+
+  const c8Version = baseline?.tools?.c8?.version;
+  const lernaVersion = baseline?.tools?.lerna?.version;
+  const coverageScriptTemplate = baseline?.coverage?.scriptTemplate;
+
   if (typeof c8Version !== 'string' || c8Version.trim() === '') {
     throw new Error(
-      `Invalid tools.c8.version in: ${SOURCE_TOOLING_BASELINE_PATH}`,
+      `Invalid tools.c8.version in: ${SOURCE_TOOLING_BASELINE_PATH} ` +
+        '(c8 must be listed in root package.json devDependencies)',
     );
   }
 
   if (typeof lernaVersion !== 'string' || lernaVersion.trim() === '') {
     throw new Error(
-      `Invalid tools.lerna.version in: ${SOURCE_TOOLING_BASELINE_PATH}`,
+      `Invalid tools.lerna.version in: ${SOURCE_TOOLING_BASELINE_PATH} ` +
+        '(lerna must be listed in root package.json devDependencies)',
     );
   }
 
@@ -129,6 +149,7 @@ function readAndValidateToolingBaseline() {
     );
   }
 
+  // Dynamically inject @produck/eslint-rules version from its own package.json
   const eslintRulesPkgPath = path.resolve(
     PACKAGE_ROOT,
     '../eslint-rules/package.json',
@@ -146,6 +167,7 @@ function readAndValidateToolingBaseline() {
       };
     }
   }
+
   return `${JSON.stringify(baseline, null, 2)}\n`;
 }
 

package/bin/command/enforce-node-baseline/index.mjs

@@ -168,6 +168,16 @@ export function runEnforceNodeBaseline(options) {
     syncEslintConfigArgs.push('--dry-run');
   }
 
+  const syncWorkspaceArgs = ['sync-workspace', '--cwd', cwd];
+  for (const workspacePath of workspaces) {
+    syncWorkspaceArgs.push('--workspace', workspacePath);
+  }
+  if (check) {
+    syncWorkspaceArgs.push('--check');
+  } else if (dryRun) {
+    syncWorkspaceArgs.push('--dry-run');
+  }
+
   const plan = [
     { name: 'preflight', args: preflightArgs },
     { name: 'sync-instructions', args: syncInstructionsArgs },
@@ -177,6 +187,7 @@ export function runEnforceNodeBaseline(options) {
     { name: 'sync-install', args: syncInstallArgs },
     { name: 'sync-git', args: syncGitArgs },
     { name: 'sync-coverage', args: syncCoverageArgs },
+    { name: 'sync-workspace', args: syncWorkspaceArgs },
     { name: 'sync-publish', args: syncPublishArgs },
   ];
 

package/bin/command/main/help.txt

@@ -5,13 +5,15 @@ agent-toolkit commands:
   summarize-log
   sync-coverage
   sync-editorconfig
-  sync-git
   sync-format
+  sync-git
   sync-install
+  sync-instructions
   sync-lint
   sync-publish
+  sync-typescript
+  sync-workspace
   validate-commit-msg
-  sync-instructions
 
 Default:
   agent-toolkit

package/bin/command/sync-coverage/help.txt

@@ -1,30 +1,15 @@
 Usage:
   agent-toolkit sync-coverage [--cwd <dir>]
-    [--workspace <path>] ... [--check] [--dry-run] [--json <file>]
+    [--check] [--dry-run] [--json <file>]
 
 Behavior:
-  - Adds or updates root scripts.produck:coverage, root .c8rc.json, and root devDependencies.c8.
-  - Adds or updates scripts.produck:coverage and devDependencies.c8 in each workspace package.json.
-  - Enforces scripts.test in each workspace package.json.
-  - If scripts.test is missing, generates:
-    node -e "console.log('No tests configured')"
-  - The produck:coverage script in subpackages is for local and AI development use only.
-  - Subpackage produck:coverage is NOT enforced by organization CI or .c8rc.json.
-  - Only the root workspace (monorepo root) is subject to org-level coverage enforcement and .c8rc.json.
+  - Adds or updates root scripts.produck:coverage, root .c8rc.json,
+    and root devDependencies.c8.
+  - Only the root workspace (monorepo root) is subject to org-level
+    coverage enforcement and .c8rc.json.
   - Organization-reserved script key is scripts.produck:coverage
-  - Target script is rendered from organization tooling baseline file
-    (lookup order):
-    1) .github/distribution/produck/tooling-version-baseline.json
-    2) publish-assets/instructions/produck/tooling-version-baseline.json
-  - Baseline template:
-    c8 --reporter=lcov --reporter=html --reporter=text-summary npm test
+  - c8 version is resolved from organization tooling baseline file
 
 Rules:
-  - When --workspace is omitted, root package.json workspaces are used
-  - Root workspaces must be explicit paths (no glob tokens)
-  - Workspace package.json files must include scripts.test
-  - Workspace package.json files must pin devDependencies.c8 to baseline version
-  - Subpackage produck:coverage is not a CI or org gate; it is for local/dev use only
-  - Only the root workspace is enforced by org CI and .c8rc.json
   - --check validates without writing and exits non-zero on mismatch
   - --dry-run prints planned changes without writing

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

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
-import { getMulti, getSingle, hasFlag } from '../shared/args.mjs';
+import { getSingle, hasFlag } from '../shared/args.mjs';
 import { printTextResource } from '../shared/text-resource.mjs';
 
 const COMMAND_DIR = path.dirname(fileURLToPath(import.meta.url));
@@ -19,7 +19,6 @@ const TOOLING_BASELINE_CANDIDATE_PATHS = [
     'publish-assets/instructions/produck/tooling-version-baseline.json',
   ),
 ];
-const GLOB_TOKEN_PATTERN = /[*?{}[\]]/;
 const REQUIRED_ROOT_COVERAGE_SCRIPT_KEY = 'produck:coverage';
 const REQUIRED_ROOT_COVERAGE_SCRIPT_VALUE = [
   'c8',
@@ -28,10 +27,6 @@ const REQUIRED_ROOT_COVERAGE_SCRIPT_VALUE = [
   '--workspaces',
   '--if-present',
 ].join(' ');
-const REQUIRED_COVERAGE_SCRIPT_KEY = 'produck:coverage';
-const REQUIRED_TEST_SCRIPT_KEY = 'test';
-const DEFAULT_TEST_SCRIPT_VALUE =
-  'node -e "console.log(\'No tests configured\')"';
 const REQUIRED_C8_CONFIG_FILE = '.c8rc.json';
 const REQUIRED_C8_CONFIG_TEMPLATE_FILE = path.resolve(
   COMMAND_DIR,
@@ -51,6 +46,35 @@ function parseJsonFile(filePath, label) {
   }
 }
 
+function resolveSemverExact(text) {
+  return text.replace(/^[\^~>=<]+\s*/, '').trim();
+}
+
+function resolveToolVersionFromDevDeps(baseline, toolName) {
+  // If baseline has a concrete version (not "auto"), use it directly.
+  // This is the case when reading the published publish-assets baseline.
+  const baselineVersion = String(
+    baseline?.tools?.[toolName]?.version || '',
+  ).trim();
+  if (baselineVersion && baselineVersion !== 'auto') {
+    return baselineVersion;
+  }
+
+  // Fall back to resolving from local root package.json devDependencies.
+  // This covers source baseline with version="auto" during local dev.
+  const repoRoot = path.resolve(PACKAGE_ROOT, '../..');
+  const pkgJsonPath = path.resolve(repoRoot, 'package.json');
+  if (fs.existsSync(pkgJsonPath)) {
+    const pkg = parseJsonFile(pkgJsonPath, 'root package.json');
+    const dep = pkg?.devDependencies?.[toolName];
+    if (typeof dep === 'string' && dep.trim()) {
+      return resolveSemverExact(dep);
+    }
+  }
+
+  return '';
+}
+
 function loadToolingBaseline() {
   const toolingBaselinePath = TOOLING_BASELINE_CANDIDATE_PATHS.find(
     (candidatePath) => {
@@ -76,7 +100,7 @@ function loadToolingBaseline() {
     process.exit(2);
   }
 
-  const c8Version = baseline?.tools?.c8?.version;
+  const c8Version = resolveToolVersionFromDevDeps(baseline, 'c8');
   if (typeof c8Version !== 'string' || c8Version.trim() === '') {
     console.error(
       `Tooling baseline tools.c8.version must be a non-empty string: ${toolingBaselinePath}`,
@@ -98,12 +122,6 @@ function loadToolingBaseline() {
   };
 }
 
-function buildRequiredCoverageScript(baseline) {
-  const c8Version = String(baseline.tools.c8.version);
-  const coverageTemplate = String(baseline.coverage.scriptTemplate);
-  return coverageTemplate.replace(/\{c8\.version\}/g, c8Version);
-}
-
 function buildRequiredC8DevDependency(baseline) {
   return String(baseline.tools.c8.version);
 }
@@ -131,37 +149,6 @@ function loadRequiredC8ConfigContent() {
   return `${JSON.stringify(template, null, 2)}\n`;
 }
 
-function resolveWorkspacePaths(cwd, options) {
-  const manual = getMulti(options, '--workspace');
-  if (manual.length > 0) {
-    return manual;
-  }
-
-  const rootPackageJsonPath = path.resolve(cwd, 'package.json');
-  const rootPackageJson = parseJsonFile(
-    rootPackageJsonPath,
-    'Root package.json',
-  );
-  if (!Array.isArray(rootPackageJson.workspaces)) {
-    return [];
-  }
-
-  const workspaces = rootPackageJson.workspaces.map((entry) => String(entry));
-  if (workspaces.length === 0) {
-    return [];
-  }
-
-  const hasGlob = workspaces.some((entry) => GLOB_TOKEN_PATTERN.test(entry));
-  if (hasGlob) {
-    console.error(
-      'Root package.json `workspaces` must use explicit paths without glob tokens',
-    );
-    process.exit(2);
-  }
-
-  return workspaces;
-}
-
 function syncRootCoverage(
   cwd,
   mode,
@@ -245,130 +232,6 @@ function syncRootCoverage(
   };
 }
 
-function reconcileCoverageScript(
-  cwd,
-  workspacePath,
-  mode,
-  requiredCoverageScript,
-  requiredC8Version,
-) {
-  const packageDir = path.resolve(cwd, workspacePath);
-  const packageJsonPath = path.resolve(packageDir, 'package.json');
-
-  const result = {
-    workspacePath,
-    packageDir,
-    packageJsonPath,
-    exists: false,
-    validJson: false,
-    previousCoverage: null,
-    coverageScript: null,
-    previousTestScript: null,
-    testScript: null,
-    previousC8DevDependency: null,
-    c8DevDependency: null,
-    matchesRequiredCoverageBefore: false,
-    matchesRequiredCoverageAfter: false,
-    hasRequiredTestScriptBefore: false,
-    hasRequiredTestScriptAfter: false,
-    matchesRequiredC8DevDependencyBefore: false,
-    matchesRequiredC8DevDependencyAfter: false,
-    updated: false,
-    error: '',
-  };
-
-  if (!fs.existsSync(packageJsonPath)) {
-    result.error = `Workspace package.json does not exist: ${workspacePath}`;
-    return result;
-  }
-  result.exists = true;
-
-  let pkg;
-  try {
-    pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-    result.validJson = true;
-  } catch {
-    result.error = `Workspace package.json is not valid JSON: ${workspacePath}`;
-    return result;
-  }
-
-  const scripts =
-    pkg.scripts &&
-    typeof pkg.scripts === 'object' &&
-    !Array.isArray(pkg.scripts)
-      ? { ...pkg.scripts }
-      : {};
-  const devDependencies =
-    pkg.devDependencies &&
-    typeof pkg.devDependencies === 'object' &&
-    !Array.isArray(pkg.devDependencies)
-      ? { ...pkg.devDependencies }
-      : {};
-
-  const previousCoverage =
-    typeof scripts[REQUIRED_COVERAGE_SCRIPT_KEY] === 'string'
-      ? scripts[REQUIRED_COVERAGE_SCRIPT_KEY]
-      : null;
-  const previousTestScript =
-    typeof scripts[REQUIRED_TEST_SCRIPT_KEY] === 'string' &&
-    scripts[REQUIRED_TEST_SCRIPT_KEY].trim() !== ''
-      ? scripts[REQUIRED_TEST_SCRIPT_KEY]
-      : null;
-  const previousC8DevDependency =
-    typeof devDependencies.c8 === 'string' ? devDependencies.c8 : null;
-  result.previousCoverage = previousCoverage;
-  result.previousTestScript = previousTestScript;
-  result.previousC8DevDependency = previousC8DevDependency;
-  result.matchesRequiredCoverageBefore =
-    previousCoverage === requiredCoverageScript;
-  result.hasRequiredTestScriptBefore = previousTestScript !== null;
-  result.matchesRequiredC8DevDependencyBefore =
-    previousC8DevDependency === requiredC8Version;
-
-  if (
-    (!result.matchesRequiredCoverageBefore ||
-      !result.hasRequiredTestScriptBefore ||
-      !result.matchesRequiredC8DevDependencyBefore) &&
-    mode === 'sync'
-  ) {
-    scripts[REQUIRED_COVERAGE_SCRIPT_KEY] = requiredCoverageScript;
-    if (!result.hasRequiredTestScriptBefore) {
-      scripts[REQUIRED_TEST_SCRIPT_KEY] = DEFAULT_TEST_SCRIPT_VALUE;
-    }
-    devDependencies.c8 = requiredC8Version;
-    pkg.scripts = scripts;
-    pkg.devDependencies = devDependencies;
-    fs.writeFileSync(
-      packageJsonPath,
-      `${JSON.stringify(pkg, null, 2)}\n`,
-      'utf8',
-    );
-    result.updated = true;
-  }
-
-  result.coverageScript =
-    mode === 'sync' && !result.matchesRequiredCoverageBefore
-      ? requiredCoverageScript
-      : previousCoverage;
-  result.testScript =
-    mode === 'sync' && !result.hasRequiredTestScriptBefore
-      ? DEFAULT_TEST_SCRIPT_VALUE
-      : previousTestScript;
-  result.c8DevDependency =
-    mode === 'sync' && !result.matchesRequiredC8DevDependencyBefore
-      ? requiredC8Version
-      : previousC8DevDependency;
-
-  result.matchesRequiredCoverageAfter =
-    result.updated || result.matchesRequiredCoverageBefore;
-  result.hasRequiredTestScriptAfter =
-    (mode === 'sync' && !result.hasRequiredTestScriptBefore) ||
-    result.hasRequiredTestScriptBefore;
-  result.matchesRequiredC8DevDependencyAfter =
-    result.updated || result.matchesRequiredC8DevDependencyBefore;
-  return result;
-}
-
 export function runSyncCoverage(options) {
   const cwd = path.resolve(getSingle(options, '--cwd', process.cwd()));
   const check = hasFlag(options, '--check');
@@ -376,7 +239,6 @@ export function runSyncCoverage(options) {
   const jsonFile = getSingle(options, '--json', '');
   const { baseline: toolingBaseline, toolingBaselinePath } =
     loadToolingBaseline();
-  const requiredCoverageScript = buildRequiredCoverageScript(toolingBaseline);
   const requiredC8Version = buildRequiredC8DevDependency(toolingBaseline);
   const requiredC8ConfigContent = loadRequiredC8ConfigContent();
 
@@ -392,7 +254,6 @@ export function runSyncCoverage(options) {
     requiredC8Version,
     requiredC8ConfigContent,
   );
-  const workspacePaths = resolveWorkspacePaths(cwd, options);
 
   const report = {
     cwd,
@@ -402,12 +263,8 @@ export function runSyncCoverage(options) {
       schemaVersion: toolingBaseline.schemaVersion,
       c8Version: toolingBaseline.tools.c8.version,
     },
-    requiredCoverageScript,
-    requiredTestScript: DEFAULT_TEST_SCRIPT_VALUE,
     requiredC8DevDependency: requiredC8Version,
     root,
-    workspaces: workspacePaths,
-    results: [],
     ok: true,
   };
 
@@ -420,32 +277,6 @@ export function runSyncCoverage(options) {
     report.ok = false;
   }
 
-  for (const workspacePath of workspacePaths) {
-    const effectiveMode = mode === 'sync' ? 'sync' : 'check';
-    const item = reconcileCoverageScript(
-      cwd,
-      workspacePath,
-      effectiveMode,
-      requiredCoverageScript,
-      requiredC8Version,
-    );
-    report.results.push(item);
-
-    if (item.error) {
-      report.ok = false;
-      continue;
-    }
-
-    if (
-      mode === 'check' &&
-      (!item.matchesRequiredCoverageAfter ||
-        !item.hasRequiredTestScriptAfter ||
-        !item.matchesRequiredC8DevDependencyAfter)
-    ) {
-      report.ok = false;
-    }
-  }
-
   if (jsonFile) {
     const outPath = path.resolve(cwd, jsonFile);
     fs.mkdirSync(path.dirname(outPath), { recursive: true });

package/bin/command/sync-coverage/required-c8-config.json

@@ -1,15 +1,20 @@
 {
+  "branches": 99.5,
   "check-coverage": true,
   "exclude": [
     "**/node_modules/**",
     "**/coverage/**",
     "**/dist/**",
     "**/build/**",
-    "**/out/**"
+    "**/out/**",
+    "**/test/**"
   ],
-  "reporter": ["lcov", "html", "text-summary"],
-  "branches": 99.5,
   "functions": 99.5,
-  "statements": 99.5,
-  "lines": 99.5
+  "lines": 99.5,
+  "reporter": [
+    "lcov",
+    "html",
+    "text-summary"
+  ],
+  "statements": 99.5
 }

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

@@ -99,6 +99,35 @@ function parseJsonFile(filePath, label) {
   }
 }
 
+function resolveSemverExact(text) {
+  return text.replace(/^[\^~>=<]+\s*/, '').trim();
+}
+
+function resolveToolVersionFromDevDeps(baseline, toolName) {
+  // If baseline has a concrete version (not "auto"), use it directly.
+  // This is the case when reading the published publish-assets baseline.
+  const baselineVersion = String(
+    baseline?.tools?.[toolName]?.version || '',
+  ).trim();
+  if (baselineVersion && baselineVersion !== 'auto') {
+    return baselineVersion;
+  }
+
+  // Fall back to resolving from local root package.json devDependencies.
+  // This covers source baseline with version="auto" during local dev.
+  const repoRoot = path.resolve(PACKAGE_ROOT, '../..');
+  const pkgJsonPath = path.resolve(repoRoot, 'package.json');
+  if (fs.existsSync(pkgJsonPath)) {
+    const pkg = parseJsonFile(pkgJsonPath, 'root package.json');
+    const dep = pkg?.devDependencies?.[toolName];
+    if (typeof dep === 'string' && dep.trim()) {
+      return resolveSemverExact(dep);
+    }
+  }
+
+  return '';
+}
+
 function loadToolingBaseline() {
   const toolingBaselinePath = TOOLING_BASELINE_CANDIDATE_PATHS.find(
     (candidatePath) => {
@@ -117,9 +146,7 @@ function loadToolingBaseline() {
   }
 
   const baseline = parseJsonFile(toolingBaselinePath, 'Tooling baseline file');
-  const prettierVersion = String(
-    baseline?.tools?.prettier?.version || '',
-  ).trim();
+  const prettierVersion = resolveToolVersionFromDevDeps(baseline, 'prettier');
 
   if (!prettierVersion) {
     console.error(

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

@@ -116,6 +116,35 @@ function getRequiredToolkitDevDependency() {
   return version;
 }
 
+function resolveSemverExact(text) {
+  return text.replace(/^[\^~>=<]+\s*/, '').trim();
+}
+
+function resolveToolVersionFromDevDeps(baseline, toolName) {
+  // If baseline has a concrete version (not "auto"), use it directly.
+  // This is the case when reading the published publish-assets baseline.
+  const baselineVersion = String(
+    baseline?.tools?.[toolName]?.version || '',
+  ).trim();
+  if (baselineVersion && baselineVersion !== 'auto') {
+    return baselineVersion;
+  }
+
+  // Fall back to resolving from local root package.json devDependencies.
+  // This covers source baseline with version="auto" during local dev.
+  const repoRoot = path.resolve(PACKAGE_ROOT, '../..');
+  const pkgJsonPath = path.resolve(repoRoot, 'package.json');
+  if (fs.existsSync(pkgJsonPath)) {
+    const pkg = parseJsonFile(pkgJsonPath, 'root package.json');
+    const dep = pkg?.devDependencies?.[toolName];
+    if (typeof dep === 'string' && dep.trim()) {
+      return resolveSemverExact(dep);
+    }
+  }
+
+  return '';
+}
+
 function loadToolingBaseline() {
   const toolingBaselinePath = TOOLING_BASELINE_CANDIDATE_PATHS.find(
     (candidatePath) => {
@@ -134,8 +163,8 @@ function loadToolingBaseline() {
   }
 
   const baseline = parseJsonFile(toolingBaselinePath, 'Tooling baseline file');
-  const huskyVersion = String(baseline?.tools?.husky?.version || '').trim();
-  const lernaVersion = String(baseline?.tools?.lerna?.version || '').trim();
+  const huskyVersion = resolveToolVersionFromDevDeps(baseline, 'husky');
+  const lernaVersion = resolveToolVersionFromDevDeps(baseline, 'lerna');
 
   if (!huskyVersion || !lernaVersion) {
     console.error(

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

@@ -128,16 +128,38 @@ function getRequiredEslintDevDependencies() {
     eslintRulesVersion = v;
   }
 
+  function resolveSemverExact(text) {
+    return text.replace(/^[\^~>=<]+\s*/, '').trim();
+  }
+
+  function resolveToolVersionFromDevDeps(name) {
+    // If baseline has a concrete version (not "auto"), use it directly.
+    // This is the case when reading the published publish-assets baseline.
+    const entry = baseline?.tools?.[name];
+    const v = typeof entry?.version === 'string' ? entry.version.trim() : '';
+    if (v && v !== 'auto') {
+      return v;
+    }
+
+    // Fall back to resolving from local root package.json devDependencies.
+    // This covers source baseline with version="auto" during local dev.
+    const repoRoot = path.resolve(PACKAGE_ROOT, '../..');
+    const pkgJsonPath = path.resolve(repoRoot, 'package.json');
+    if (fs.existsSync(pkgJsonPath)) {
+      const pkg = parseJsonFile(pkgJsonPath, 'root package.json');
+      const dep = pkg?.devDependencies?.[name];
+      if (typeof dep === 'string' && dep.trim()) {
+        return resolveSemverExact(dep);
+      }
+    }
+
+    return '';
+  }
+
   const deps = { [ESLINT_RULES_PACKAGE_NAME]: eslintRulesVersion };
 
   for (const name of ESLINT_TOOLING_PACKAGE_NAMES) {
-    const entry = baseline?.tools?.[name];
-    const v =
-      typeof entry?.version === 'string'
-        ? entry.version.trim()
-        : /* c8 ignore next */
-        '';
-    /* c8 ignore next 6 */
+    const v = resolveToolVersionFromDevDeps(name);
     if (!v) {
       console.error(
         `Tooling baseline tools["${name}"].version must be a non-empty string: ${toolingBaselinePath}`,

package/bin/command/sync-publish/help.txt

@@ -10,7 +10,7 @@ Behavior:
 - Sync mode applies organization-required root publish scripts:
   - scripts.produck:publish:check = npm run produck:install && npm run produck:format && npm run produck:lint && npm run produck:coverage
   - scripts.produck:publish = npm run produck:publish:check && npm run publish --
-    when scripts.publish exists; otherwise it falls back to lerna publish
+  - If scripts.publish is missing, defaults to "lerna publish"
   - Enforces lerna.json command.version.commitHooks = false so publish/version commits skip git commit hooks
 
 Rules: