valent-pipeline 0.19.23 → 0.19.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "valent-pipeline",
-  "version": "0.19.23",
+  "version": "0.19.25",
   "description": "v3 multi-agent AI pipeline for software development lifecycle",
   "type": "module",
   "bin": {

package/pipeline/orchestrators/claude-code/sprint.workflow.js

@@ -2030,11 +2030,30 @@ async function runStory(story) {
     }
   }
 
+  // Shift-left pre-handoff self-gate (review 2026-06-15): the dev fan-out used to hand off WITHOUT
+  // knowing which deterministic checks the pre-CRITIC STATIC gate would run the instant it did — so
+  // lint/type failures and un-waived test skips reached the gate and cost a full rework round-trip
+  // (a re-spawn), the dominant avoidable-rework pattern in the field (a soft correction-directive
+  // reduced it but did not close it). Thread the gate's OWN checks into the build prompt so the dev
+  // runs them IN its build turn (same context, no re-spawn) and hands off clean. The gate
+  // (runPreCriticGate) stays the mechanical backstop; this just makes it pass first-try, cutting both
+  // the round-trip cost and the rework-cycle count. Same preCriticChecks the gate runs; the
+  // skip-waiver / spec-conformance rules are always named. Static + args only => journal-replay safe.
+  const preHandoffStaticCmds = preCriticChecks.map((c) => subCmd(c, storyId, effectiveWorkspaces))
+  const preHandoffNote = (preHandoffStaticCmds.length || specConformanceEnabled || traceCheckEnabled)
+    ? '\n\n## Definition of done — run these BEFORE you write your handoff\n' +
+      'The deterministic pre-CRITIC gate runs the moment you hand off; a failure costs a full rework cycle (a re-spawn). Pass them first-try:\n' +
+      preHandoffStaticCmds.map((c) => `  - \`${c}\` — must exit 0 (lint / type / static).\n`).join('') +
+      '  - Every deliberately skipped or pending test MUST carry an inline `// valent-waiver: <reason>` (on the skip line or in the test name) — an un-waived skip is rejected by the spec-conformance check.\n' +
+      '  - Do NOT drop a spec\'d assertion target or omit a spec\'d case to make a suite pass.\n' +
+      'Run them locally, fix EVERYTHING they flag, and only then write your handoff — this is part of the build, not the gate\'s job to find for you.'
+    : ''
+
   phase('Build')
   // Genuine barrier: CRITIC needs ALL active dev agents' work before reviewing.
   const builds = await parallel(
     devTasks.map((t) => () =>
-      spawn(t.agent, `${t.agent.toLowerCase()}.md`, (t.subject || 'Implement production code and tests per the brief and test spec.') + atddReadOnlyNote, {
+      spawn(t.agent, `${t.agent.toLowerCase()}.md`, (t.subject || 'Implement production code and tests per the brief and test spec.') + atddReadOnlyNote + preHandoffNote, {
         label: `build:${t.ref}:${storyId}`,
         phase: 'Build',
       })),

package/pipeline/templates/eslint.config.standard.mjs

@@ -0,0 +1,107 @@
+// valent-pipeline — STANDARD hardened ESLint baseline.
+// Seeded by `valent-pipeline init` into TypeScript projects that have NO ESLint config of their own;
+// it never overwrites an existing one. This is the universal base — add project-specific guards in
+// your own block.
+//
+// What it enforces (ONE `eslint .` pass, prod vs tests differentiated by file glob):
+//   • Strict TypeScript correctness — typescript-eslint `strict`, the hardest SYNTACTIC tier — on
+//     production code AND tests (a broken test is false confidence).
+//   • Maintainability caps (complexity / depth / length) on PRODUCTION code only — off for tests,
+//     where long/repetitive is fine.
+//
+// Requires (devDependencies — the standard uses NO others):
+//   eslint  @typescript-eslint/parser  @typescript-eslint/eslint-plugin
+// Recommended package.json scripts:
+//   "lint": "eslint . --max-warnings 0"      "typecheck": "tsc --noEmit"
+// Make them a blocking gate by adding both to pipeline-config.yaml `pre_critic_gate.commands`.
+//
+// Project-specific guards (e.g. banning Math.random for deterministic sims, NodeNext import-extension
+// rules, module-boundary guards) are intentionally NOT here — add them in your own config block.
+// Type-aware rules (no-floating-promises, …) are the fast-follow — see the commented block at the bottom.
+
+import tseslint from '@typescript-eslint/eslint-plugin';
+import tsParser from '@typescript-eslint/parser';
+
+// CORRECTNESS — applies to prod AND tests. STRICT = hardest syntactic tier (recommended spread first
+// so the base set is present even if strict's `.rules` is delta-only).
+const correctness = {
+  ...tseslint.configs.recommended.rules,
+  ...tseslint.configs.strict.rules,
+  '@typescript-eslint/no-explicit-any': 'error',
+  '@typescript-eslint/no-unused-vars': ['error', { argsIgnorePattern: '^_' }],
+  eqeqeq: ['error', 'smart'],
+  'no-var': 'error',
+  'prefer-const': 'error',
+  'no-loop-func': 'error',
+  '@typescript-eslint/no-empty-function': 'error',
+};
+
+// MAINTAINABILITY — PRODUCTION code only (off for tests). Caps start strict; loosen per project if a
+// codebase legitimately needs it, or tighten over time.
+const maintainability = {
+  complexity: ['error', { max: 10 }],
+  'max-depth': ['error', { max: 3 }],
+  'max-lines-per-function': ['error', { max: 100, skipBlankLines: true, skipComments: true }],
+  'max-lines': ['error', { max: 500, skipBlankLines: true, skipComments: true }],
+  'no-console': ['error', { allow: ['warn', 'error'] }],
+  'no-warning-comments': ['error', { terms: ['fixme', 'xxx', 'hack'], location: 'anywhere' }],
+  'func-names': ['error', 'as-needed'],
+};
+
+// Lenient naming convention — enforces common casing without fighting external/snake_case APIs.
+const naming = ['error',
+  { selector: 'default', format: ['camelCase'], leadingUnderscore: 'allow' },
+  { selector: 'variable', format: ['camelCase', 'PascalCase', 'UPPER_CASE'], leadingUnderscore: 'allow' },
+  { selector: 'typeLike', format: ['PascalCase'] },
+  { selector: 'enumMember', format: ['PascalCase', 'UPPER_CASE'] },
+  { selector: 'parameter', format: ['camelCase'], leadingUnderscore: 'allow' },
+  { selector: 'variable', modifiers: ['destructured'], format: null },
+  { selector: 'objectLiteralProperty', format: null },
+];
+
+const tsLang = { parser: tsParser, parserOptions: { ecmaVersion: 2022, sourceType: 'module', ecmaFeatures: { jsx: true } } };
+
+export default [
+  {
+    ignores: ['dist/**', 'build/**', 'node_modules/**', 'coverage/**', 'test-results/**',
+      '.valent-pipeline/**', 'stories/**', 'knowledge/**', '**/*.config.{js,cjs,mjs,ts}'],
+  },
+
+  // ── PRODUCTION code: strict correctness + maintainability + naming ──
+  {
+    files: ['**/*.ts', '**/*.tsx'],
+    languageOptions: tsLang,
+    plugins: { '@typescript-eslint': tseslint },
+    rules: {
+      ...correctness,
+      ...maintainability,
+      '@typescript-eslint/naming-convention': naming,
+    },
+  },
+
+  // ── TESTS (dedicated + colocated): correctness ONLY — size/cosmetics off. MUST stay last. ──
+  {
+    files: ['tests/**/*.ts', 'tests/**/*.tsx', '**/*.test.ts', '**/*.test.tsx', '**/*.spec.ts', '**/*.spec.tsx'],
+    languageOptions: tsLang,
+    plugins: { '@typescript-eslint': tseslint },
+    rules: {
+      ...correctness,
+      complexity: 'off',
+      'max-depth': 'off',
+      'max-lines': 'off',
+      'max-lines-per-function': 'off',
+      'no-console': 'off',
+      'func-names': 'off',
+      'no-warning-comments': 'off',
+      '@typescript-eslint/no-non-null-assertion': 'off', // `!` is idiomatic in test assertions
+    },
+  },
+];
+
+/* ════ TYPE-AWARE FAST-FOLLOW — the eventual ceiling (strict-type-checked). Requires type info.
+   After `npm i -D typescript-eslint` (the unified pkg) and a tsconfig that includes your source:
+     • PRODUCTION block: parserOptions.projectService = true; spread ...strictTypeChecked (scoped) —
+       adds no-floating-promises, no-misused-promises, await-thenable, no-unnecessary-condition, …
+     • TESTS block: add '@typescript-eslint/no-floating-promises':'error' + no-misused-promises — the
+       highest-value test rules (they catch false-green un-awaited async assertions).
+   Needs a typescript-eslint release that supports your TypeScript major. ════ */

package/src/commands/init.js

@@ -105,6 +105,27 @@ export async function init(options = {}) {
     console.log('  Created knowledge/correction-directives.yaml');
   }
 
+  // 6b. Seed the standard hardened ESLint config for TypeScript projects — inherited ONLY when the
+  //     project has no ESLint config of its own (never clobbers an existing setup). The standard uses
+  //     just @typescript-eslint/{parser,eslint-plugin}; see the config header for the lint/typecheck
+  //     scripts to wire into pre_critic_gate.commands.
+  const projectLanguage = (config.tech_stack?.language || 'TypeScript').toLowerCase();
+  const isTsProject = projectLanguage.includes('typescript') || /\bts\b/.test(projectLanguage);
+  if (isTsProject) {
+    const eslintConfigNames = [
+      'eslint.config.js', 'eslint.config.mjs', 'eslint.config.cjs', 'eslint.config.ts',
+      '.eslintrc', '.eslintrc.js', '.eslintrc.cjs', '.eslintrc.json', '.eslintrc.yml', '.eslintrc.yaml',
+    ];
+    const hasEslintConfig = eslintConfigNames.some((n) => fileExists(join(projectRoot, n)));
+    const stdEslintSrc = join(PACKAGE_ROOT, 'pipeline', 'templates', 'eslint.config.standard.mjs');
+    if (hasEslintConfig) {
+      console.log('  ESLint config already present — kept the project\'s own (standard not seeded)');
+    } else if (existsSync(stdEslintSrc)) {
+      writeFileSafe(join(projectRoot, 'eslint.config.mjs'), readFileSync(stdEslintSrc, 'utf-8'));
+      console.log('  Seeded standard hardened ESLint config -> eslint.config.mjs');
+    }
+  }
+
   // 7. Write the vendored CLI's runtime package.json and install its deps. The CLI needs
   //    commander/yaml/ajv to run AT ALL (resolve-graph, validate-handoff, sprint-pack, …);
   //    sqlite knowledge mode additionally needs better-sqlite3 (FTS5 is compiled in — the whole