harness-everything 0.31.2 → 0.32.0

package/plugins/harness-everything/hooks/scripts/workflow-stop-gate.js

@@ -3,35 +3,58 @@
 const path = require('path');
 const { readJson } = require('./lib/fable-contracts');
 const { loadWorkflow, saveWorkflow, matchingRun, unresolvedStages, readHookInput } = require('./lib/workflow-runtime');
-const { planningUnresolved, unresolvedObligations } = require('./lib/workflow-obligations');
+
+const REGISTRY_UNAVAILABLE = 'step-type-registry-unavailable';
+const STEP_TYPE_REGISTRY_UNAVAILABLE = 'STEP_TYPE_REGISTRY_UNAVAILABLE';
 
 function warn(message) { console.error('[Workflow Reminder] ' + message); }
 
 function decide(payload) {
   if (!payload) return;
   try {
+    const { planningUnresolved, unresolvedObligations } = require('./lib/workflow-obligations');
     const context = loadWorkflow(payload);
     const { workflow, sessionDir } = context;
     if (!workflow || workflow.state === 'deferred') return;
     const handoff = readJson(path.join(sessionDir, 'handoff-state.json'));
-    let unresolved = planningUnresolved(context);
+    const unresolved = [];
+    const diagnostics = [];
+    let requiredFault = false;
+
+    // Only a validation that actually reads the registry can fail here. It records the
+    // semantic diagnostic and the unresolved token itself; other checks keep running.
+    const required = check => {
+      try {
+        unresolved.push(...check());
+      } catch (error) {
+        if (error.code !== STEP_TYPE_REGISTRY_UNAVAILABLE) throw error;
+        diagnostics.push(error.message);
+        unresolved.push(REGISTRY_UNAVAILABLE);
+        requiredFault = true;
+      }
+    };
 
+    required(() => planningUnresolved(context));
     if (String(workflow.strategy || '').startsWith('fable-')) {
       const match = matchingRun(context);
       unresolved.push(...(match ? unresolvedStages(match, workflow, handoff?.lastEditAt || 0) : ['correlated-run-missing']));
     } else {
-      unresolved.push(...unresolvedObligations(context));
+      required(() => unresolvedObligations(context));
       const lastEdit = Math.max(workflow.lastMutationAt || 0, handoff?.lastEditAt || 0);
       if (lastEdit && (handoff?.lastVerifyAt || 0) < lastEdit) unresolved.push('verification-after-edit-missing');
     }
 
-    unresolved = [...new Set(unresolved)];
+    const pending = [...new Set(unresolved)];
     const wasBlocked = workflow.state === 'blocked';
     if (wasBlocked) warn('Workflow is marked BLOCKED; report or revisit the recorded blocker, but Harness will not trap the session.');
-    if (unresolved.length) {
-      workflow.unresolved = unresolved;
-      saveWorkflow(context);
-      warn('Unresolved workflow evidence: ' + unresolved.join(', ') + '. Resolve/verify before claiming completion.');
+    [...new Set(diagnostics)].forEach(message => warn(message));
+    if (pending.length) {
+      // A failed required validation leaves the workflow file as recorded; it is never marked satisfied.
+      if (!requiredFault) {
+        workflow.unresolved = pending;
+        saveWorkflow(context);
+      }
+      warn('Unresolved workflow evidence: ' + pending.join(', ') + '. Resolve/verify before claiming completion.');
       return;
     }
     if (wasBlocked) return;

package/plugins/harness-everything/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "harness-everything",
-  "version": "0.31.2",
+  "version": "0.32.0",
   "description": "Invariant-first engineering harness for routing, verification, and failure recovery while preserving agent autonomy.",
   "author": {
     "name": "Miya Daniel",

package/plugins/harness-everything/skills/fable-mode/SKILL.md

@@ -4,7 +4,7 @@ description: "Stage large tasks through plans, named fable agents, failable chec
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.31.0
+  version: 0.31.3
 ---
 
 # Fable Mode

package/plugins/harness-everything/skills/fable-mode/execution-guardrails/SKILL.md

@@ -4,7 +4,7 @@ description: "Reference guardrails for verified warnings and safe replacements;
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.31.0
+  version: 0.31.3
 ---
 
 # Execution Guardrails

package/plugins/harness-everything/skills/fable-mode/fable-haiku/SKILL.md

@@ -4,7 +4,7 @@ description: "Reference mechanical behavior profile (legacy alias haiku) for bul
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.31.0
+  version: 0.31.3
 ---
 
 # Fable Mode — Haiku

package/plugins/harness-everything/skills/fable-mode/fable-opus/SKILL.md

@@ -4,7 +4,7 @@ description: "Reference orchestrator behavior profile (legacy alias opus) for st
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.31.0
+  version: 0.31.3
 ---
 
 # Fable Mode — Opus

package/plugins/harness-everything/skills/fable-mode/fable-sonnet/SKILL.md

@@ -4,7 +4,7 @@ description: "Reference reasoning behavior profile (legacy alias sonnet/sonnect)
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.31.0
+  version: 0.31.3
 ---
 
 # Fable Mode — Sonnet

package/plugins/harness-everything/skills/fable-mode/references/execution-phases.md

@@ -2,37 +2,105 @@
 
 ```mermaid
 flowchart TD
-  Start[Qualifying Tier 3 task] --> Discover[Discover sources, runtime, and authorized scope]
-  Discover --> Plan[Write stage map and pass conditions]
-  Plan --> Select[Resolve requested model and write audit record]
-  Select --> Delegate[Delegate to named agent or visible inline fallback]
-  Delegate --> Contract[Write stage contract]
-  Contract --> Verify[Run the named failable check]
-  Verify --> Review[Cold-review high-stakes deliverables]
-  Review --> Done[Record result or escalate blocker]
+  Start[Qualifying Tier 3 task] --> Discover[Discover runtime and authorized scope]
+  Discover --> Profile[Resolve behavior profile and runtime choice]
+  Profile --> Plan[Write dependency-aware stage map and checks]
+  Plan --> Register[Write workflow-stages.json in session state]
+  Register --> Execute[Start workflow-disposition and execute ready stages]
+  Execute --> Check[Run exact check and record correlated evidence]
+  Check --> Review[Cold-review when the selected plan requires it]
+  Review --> Done[Record result or blocker]
 ```
 
 ## Discovery and planning
 
-Read the relevant files and sources before producing an artifact. Lock the
-authorized write scope in the handoff. Number the stages, assign one artifact
-and one pass condition to each. Replan counts are advisory and never a hard
-stop; three same-signature failures still require Rule-of-3 `zoom-out`.
+Read relevant files and sources before producing an artifact. Record the
+authorized write scope. Give each stage an objective, dependencies, write set,
+expected output, exact check command, and pass condition. Required and optional
+bindings belong on the stage that needs them. Replan counts are advisory; after
+three same-signature failures, use Rule-of-3 `zoom-out`.
 
-## Delegation
+## Profiles and delegation
 
-Use `fable-orchestrator` for Opus macro work, `fable-worker-sonnet` for
-reasoning and synthesis, and `fable-worker-haiku` for mechanical work. Brief
-each worker with its exact output path, context, audit record, and check.
-Workers do not spawn workers. If the named agent is unavailable, choose the
-explicit inline fallback or stop and escalate; do not silently change models.
+Resolve a requested behavior profile with Fable's profile selector and record
+it separately from the runtime choice. `fable-orchestrator`,
+`fable-worker-sonnet`, and `fable-worker-haiku` name coordination,
+reasoning/synthesis, and mechanical-work roles. These are behavior-profile
+aliases; they do not switch the runtime model. Preserve an explicit user or
+host runtime choice. Workers do not spawn workers. If a named worker is
+unavailable, use a declared inline fallback or report the gap.
 
-## Verification and handoff
+## Active workflow
+
+For an active mandatory workflow, use the router-displayed session path for
+`workflow-stages.json` and the router-displayed `workflow-disposition.js`
+controller. Do not register active stages in a repository-local contracts
+directory. Every required stage needs `dependsOn`, `writeSet`, `checkCommand`,
+and `passCondition`; an independent plan also needs a read-only `fable-verifier`
+stage that depends on all implementation stages.
+
+Start the selected run with the controller path and session id from the router:
+
+```bash
+node "<workflow-disposition.js path from the router>" start --session-id "<session-id>"
+```
+
+The controller creates correlated run-scoped contracts. Load only bindings on
+dependency-ready stages. Record each disposition with evidence:
+
+```bash
+node "<workflow-disposition.js path from the router>" stage-binding \
+  --session-id "<session-id>" --stage-id "<stage-id>" \
+  --binding-id "<binding-id>" --disposition loaded \
+  --evidence "Read the resolved required reference for this stage."
+```
+
+Run the exact `checkCommand`; the post-tool `contract-test.js` records the
+session, run, stage, worker identity, numeric exit code, and check evidence. If
+bindings are unresolved, resolve them and rerun the exact check before passing
+the stage. Keep results under the run's `contracts/<stageId>.json` and
+`evidence/<stageId>.json` records. Stage checks, required bindings, and selected
+independent verification remain semantic MUSTs. The controller and lifecycle
+hooks are reminder-only: unresolved evidence stays visible without locking
+ordinary tools or Stop. See [`../CONTRACT-FORMAT.md`](../CONTRACT-FORMAT.md) for
+the schema and correlation rules.
+
+## Blocked recovery
 
-Before each spot-check, create `.claude/harness-everything/state/contracts/<stage>.json`
-using `CONTRACT-FORMAT.md`, then run the exact command in that contract. A
-stage is not complete until the command passes and the audit record contains
-the verifier result. Use `fable-verifier` with only the spec and artifact for
-high-stakes or unsupervised delivery. Review scope-guard output before merging.
+If `start` is called while the workflow is running, it exits 2 with
+`workflow already running; record a blocker before replanning`. From that
+running state, record evidence with `block`:
+
+```bash
+node "<workflow-disposition.js path from the router>" block \
+  --session-id "<session-id>" \
+  --evidence "The current stage map needs a bounded recovery update."
+```
+
+Update the same session's `workflow-stages.json`, retaining the approved
+requirements, workflow selection, dependencies, and required bindings. Then
+start the revised stage map:
+
+```bash
+node "<workflow-disposition.js path from the router>" start --session-id "<session-id>"
+```
+
+This starts a new run and clears the recorded block reason. If the session is
+already `blocked`, update its stage map and run `start` directly. Do not call
+`plan` from `blocked`: planning is accepted only while the workflow is pending
+or active. When an explicitly authorized scope change requires new requirement
+composition, route a new session instead of replacing approved requirements.
+
+## Legacy/manual fallback
+
+The path `.claude/harness-everything/state/contracts/<stage>.json` belongs only
+to an explicitly selected legacy/manual workflow without an active mandatory
+run. It does not register stages or correlated evidence for the current
+workflow controller. Do not use it for an active Fable workflow.
+
+## Verification and handoff
 
-When macro scaffolding ends, transition to `tdd` for focused implementation.
+Run each named check and review scope-guard evidence before delivery. When the
+selected plan requires independent verification, the verifier is read-only and
+uses a distinct worker identity after all other stages pass. Record a blocker
+or an evidence-backed result; do not discard unresolved requirements.

package/plugins/harness-everything/skills/harness-everything/SKILL.md

@@ -4,7 +4,7 @@ description: "Route software/project work through Harness: classify tier/topolog
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.31.0
+  version: 0.32.0
 ---
 
 # Harness Everything

package/plugins/harness-everything/skills/harness-everything/references/router-workflow-plan.md

@@ -118,6 +118,24 @@ Examples:
 
 There is no universal `TODO → TDD → verification` pipeline.
 
+## Step types
+
+The allowed step types are the entries of `hooks/scripts/lib/step-types.json`. The list below is rendered from that registry and checked against it by `ci/mechanism-2ba-step-type-docs.test.js`; examples elsewhere may name a subset.
+
+<!-- step-types:start -->
+- `behavior-change` — required bindings: `tdd` — forbidden bindings: none
+- `commit` — required bindings: `git-commit` — forbidden bindings: none
+- `doc-change` — required bindings: none — forbidden bindings: none
+- `review` — required bindings: none — forbidden bindings: `tdd`
+- `verification` — required bindings: `verification-loop` — forbidden bindings: none
+<!-- step-types:end -->
+
+`doc-change` is declared-only: a plan author chooses it explicitly, and router classification, keyword routing and System One never infer or insert it. It has no default bindings, and an explicitly declared `tdd` binding stays legal. Mixed documentation and code work is written as ordered `doc-change` and `behavior-change` steps, and one shared verification step may verify both.
+
+Old runtimes reject a persisted non-Fable `doc-change` plan visibly at the controller and Stop boundaries (`planning:steps-invalid`). The old retained router does not show that rejection: it shows no active step. Persisted bytes are not renamed or reset. Inert Fable planning metadata is not rejected by old runtimes, because step bindings are disabled there.
+
+Registry revisions: binding defaults and required/forbidden binding policy are materialized when a plan is recorded and are not reapplied on ordinary load. Existing typed plans must still reference currently registered step types; removing a type can invalidate a plan rather than migrate or waive its stored bindings. A policy fingerprint or migration path is future work and is not implemented today.
+
 ## Binding and disclosure rule
 
 Each ordered requirement or Fable stage may declare `requiredBindings` and `optionalBindings` by stable id and concrete repository-relative path. Only the active requirement or dependency-ready stage exposes its paths. Required bindings must resolve before that step/stage passes; unknown required bindings remain visible and unresolved. Future-step paths and keyword-matched documents are never preloaded.

package/plugins/harness-everything/skills/harness-everything/scripts/kernel-router.js

@@ -33,6 +33,14 @@ function issueMemoryCapability(workflow) {
   return token;
 }
 
+function needsStepTypeRegistry(plan) {
+  return Boolean(
+    plan && plan.strategySelection === 'selected' &&
+    ['tier2', 'tier3'].includes(plan.tier) && plan.strategy &&
+    !String(plan.strategy).startsWith('fable-')
+  );
+}
+
 // Host-generated background-task notifications arrive as UserPromptSubmit
 // hook payloads but are not user input (#168). Routing them like prompts
 // replaces the workflow contract mid-turn (e.g. deferred -> a new Tier-2).
@@ -44,11 +52,28 @@ function isHostNotificationPrompt(prompt) {
   return /^<task-notification[\s>][\s\S]*<\/task-notification>\s*$/i.test(text);
 }
 
+function stepTypeIdsFor(hooksRoot) {
+  try {
+    return require(path.join(hooksRoot, 'lib/workflow-obligations')).stepTypeIds();
+  } catch {
+    return null;
+  }
+}
+
 function persistWorkflow(contract, payload, prompt) {
   const plan = contract && contract.workflowPlan;
   if (!payload || !(payload.session_id || payload.sessionId)) return null;
   const { runtime, hooksRoot } = loadRuntime();
   const context = runtime.loadWorkflow(payload);
+  const hasRetainedWorkflow = Boolean(context.workflow && runtime.OPEN_STATES.has(context.workflow.state));
+  const activePlan = hasRetainedWorkflow ? context.workflow.workflowPlan : plan;
+  if (needsStepTypeRegistry(activePlan)) {
+    try { require(path.join(hooksRoot, 'lib/workflow-obligations')).loadStepTypeRegistry(); }
+    catch (error) {
+      if (hasRetainedWorkflow) return { ...context, hooksRoot, retained: true, registryError: error };
+      throw error;
+    }
+  }
   const { writeCurrentSession } = require(path.join(hooksRoot, 'lib/harness-state'));
   writeCurrentSession(context.root, context.sessionId);
   if (isHostNotificationPrompt(prompt)) {
@@ -121,8 +146,8 @@ function activeExecutionFor(persisted, plan) {
     const obligations = require(path.join(persisted.hooksRoot, 'lib/workflow-obligations'));
     const loaded = obligations.loadObligationSet(persisted, plan);
     return { activeStep: loaded.set ? obligations.activeStepSnapshot(loaded.set) : null };
-  } catch (_) {
-    return null;
+  } catch (error) {
+    return { error: error && error.message ? error.message : String(error) };
   }
 }
 
@@ -163,10 +188,15 @@ function run(raw) {
   if (persisted?.retained && persisted.workflow) {
     if (persisted.hostNotification) console.log('\n=> Host notification: routing unchanged; keeping the active execution contract.');
     else console.log('\n=> Retaining unresolved workflow; showing its compact active contract.');
-    const activeExecution = activeExecutionFor(persisted, plan) || {};
+    const activeExecution = persisted.registryError
+      ? { error: persisted.registryError.message || String(persisted.registryError) }
+      : activeExecutionFor(persisted, plan) || {};
     const activeStep = activeExecution.activeStep || null;
     const activeStages = activeExecution.activeStages || [];
     core.printRetainedWorkflow(plan, persisted.workflow, activeStep, activeStages);
+    if (activeExecution.error) {
+      console.log('   - [Workflow Reminder] Active-step context unavailable: ' + activeExecution.error);
+    }
     if (activeStep) {
       const controller = path.join(persisted.hooksRoot, 'workflow-disposition.js');
       console.log('   - Resolve only bindings for this active step, then pass this step with evidence.');
@@ -205,8 +235,10 @@ function run(raw) {
     if (plan.strategySelection === 'selected' && ['tier2', 'tier3'].includes(plan.tier)) {
       console.log('   - Planning contract: ' + path.join(persisted.sessionDir, 'workflow-obligations.json'));
       console.log('   - Requirements first: decompose intent into requirement fragments, then confirm the smallest sufficient workflow.');
-      console.log('   - Record ordered step types (review, behavior-change, verification, commit) and their bindings before execution.');
-      console.log('   - Record plan: node "' + controller + '" plan --session-id "' + persisted.sessionId + '" --requirements-json "[{\\"id\\":\\"req-1\\",\\"stepType\\":\\"behavior-change\\",\\"summary\\":\\"...\\",\\"acceptance\\":\\"...\\"},{\\"id\\":\\"req-verify\\",\\"stepType\\":\\"verification\\",\\"summary\\":\\"...\\",\\"acceptance\\":\\"...\\"}]" --strategy "' + plan.strategy + '" --evidence "<why this workflow fits>"');
+      const stepTypeIds = stepTypeIdsFor(persisted.hooksRoot);
+      console.log('   - Record ordered step types' + (stepTypeIds ? ' (' + stepTypeIds.join(', ') + ')' : '') + ' and their bindings before execution.');
+      console.log('   - Replace <step-type-id> with a registered type you choose explicitly; mixed docs+code work uses separate doc-change and behavior-change steps; keep the verification step.');
+      console.log('   - Record plan: node "' + controller + '" plan --session-id "' + persisted.sessionId + '" --requirements-json "[{\\"id\\":\\"req-1\\",\\"stepType\\":\\"<step-type-id>\\",\\"summary\\":\\"...\\",\\"acceptance\\":\\"...\\"},{\\"id\\":\\"req-verify\\",\\"stepType\\":\\"verification\\",\\"summary\\":\\"...\\",\\"acceptance\\":\\"...\\"}]" --strategy "' + plan.strategy + '" --evidence "<why this workflow fits>"');
     }
     console.log('   - Enter selected workflow after planning: node "' + controller + '" start --session-id "' + persisted.sessionId + '"');
     console.log('   - Escape one declared stage: node "' + controller + '" escape --session-id "' + persisted.sessionId + '" --stage-id "<id>" --reason-code workflow-uncovered-scope --scope "<uncovered scope>" --evidence "<evidence>"');

package/plugins/harness-everything/skills/self-evolve/SKILL.md

@@ -4,7 +4,7 @@ description: "Extract root causes from resolved problems and persist them as def
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.12.0
+  version: 0.31.3
 ---
 
 # Self-evolve

package/plugins/harness-everything/skills/self-evolve/scripts/self-regression.js

@@ -6,7 +6,6 @@
  * their results must not be confused with a local tracker simulation.
  */
 
-const { spawnSync } = require('child_process');
 const path = require('path');
 const fs = require('fs');
 
@@ -22,12 +21,15 @@ if (pkgName !== 'harness-everything') {
   process.exit(0);
 }
 
+// This development-only helper is absent from installed skill packages.
+const { spawnTestNode } = require('../../ci/lib/isolated-test-process');
+
 console.log('=================================================');
 console.log('     Harness OS - Self-Regression Test Suite     ');
 console.log('=================================================');
 
 function runNode(label, script, args = [], options = {}) {
-  const result = spawnSync('node', [script, ...args], {
+  const result = spawnTestNode([script, ...args], {
     cwd: projectRoot,
     stdio: 'inherit',
     ...options,
@@ -54,7 +56,7 @@ function walkDir(dir) {
 }
 for (const folder of foldersToScan) walkDir(path.join(projectRoot, folder));
 for (const file of jsFiles) {
-  const check = spawnSync('node', ['--check', file]);
+  const check = spawnTestNode(['--check', file]);
   if (check.status !== 0) {
     console.error(`  FAIL syntax: ${path.relative(projectRoot, file)}`);
     console.error(check.stderr.toString().trim());
@@ -65,7 +67,7 @@ console.log(`  PASS syntax: ${jsFiles.length} JavaScript file(s)`);
 
 console.log('\n[Phase 1b] CLI Command Smoke Test...');
 const cliPath = path.join(projectRoot, 'bin', 'cli.js');
-const nextCheck = spawnSync('node', [cliPath, 'next', 'add a new login endpoint with tests'], { cwd: projectRoot });
+const nextCheck = spawnTestNode([cliPath, 'next', 'add a new login endpoint with tests'], { cwd: projectRoot });
 if (nextCheck.status !== 0 || !nextCheck.stdout.toString().includes('RECOMMENDED TIER')) {
   console.error('  FAIL `harness next` did not produce a routing recommendation.');
   hasErrors = true;
@@ -73,7 +75,7 @@ if (nextCheck.status !== 0 || !nextCheck.stdout.toString().includes('RECOMMENDED
   console.error('  FAIL `harness next` did not establish the invariant-first kernel contract.');
   hasErrors = true;
 } else console.log('  PASS `harness next` produced routing + invariant contract.');
-const verifyCheck = spawnSync('node', [cliPath, 'verify'], {
+const verifyCheck = spawnTestNode([cliPath, 'verify'], {
   cwd: projectRoot,
   env: { ...process.env, HARNESS_SKIP_PROJECT_CHECKS: '1' },
 });
@@ -105,7 +107,7 @@ runNode('behavioral case validation', path.join(projectRoot, 'behavioral-evals',
 console.log('\n[Phase 3b] Fable Model Mode Contract Tests...');
 const fableModeTestPath = path.join(projectRoot, 'ci', 'fable-mode-test.js');
 if (fs.existsSync(fableModeTestPath)) {
-  const fableModeCheck = spawnSync('node', [fableModeTestPath], { stdio: 'inherit', cwd: projectRoot });
+  const fableModeCheck = spawnTestNode([fableModeTestPath], { stdio: 'inherit', cwd: projectRoot });
   if (fableModeCheck.status !== 0) {
     console.error("\n  ❌ Fable model mode contract suite failed!");
     hasErrors = true;

package/sbom.cdx.json

@@ -2,23 +2,23 @@
   "$schema": "https://cyclonedx.org/schema/bom-1.7.schema.json",
   "bomFormat": "CycloneDX",
   "specVersion": "1.7",
-  "serialNumber": "urn:uuid:9d3ce484-1be2-5a01-aaf1-830f69f479f8",
+  "serialNumber": "urn:uuid:10a4f889-cc27-520f-b5d1-1a628d22d914",
   "version": 1,
   "metadata": {
-    "timestamp": "2026-10-15T15:15:14.070Z",
+    "timestamp": "2026-10-17T13:06:24.281Z",
     "tools": [
       {
         "vendor": "Harness Everything",
         "name": "generate-sbom.js",
-        "version": "0.31.2"
+        "version": "0.32.0"
       }
     ],
     "component": {
       "type": "application",
-      "bom-ref": "pkg:npm/harness-everything@0.31.2",
+      "bom-ref": "pkg:npm/harness-everything@0.32.0",
       "name": "harness-everything",
-      "version": "0.31.2",
-      "purl": "pkg:npm/harness-everything@0.31.2"
+      "version": "0.32.0",
+      "purl": "pkg:npm/harness-everything@0.32.0"
     }
   },
   "components": [
@@ -1999,7 +1999,7 @@
       ]
     },
     {
-      "ref": "pkg:npm/harness-everything@0.31.2",
+      "ref": "pkg:npm/harness-everything@0.32.0",
       "dependsOn": [
         "pkg:npm/%40commitlint/cli@19.8.1",
         "pkg:npm/%40commitlint/config-conventional@19.8.1",