@dzhechkov/harness-cli 0.3.250 → 0.3.252

package/.dz-manifest.json

@@ -9,7 +9,7 @@
       },
       {
         "path": "README.md",
-        "sha256": "1559995482381fd6ac146e6d229cb7d33476cdca8fad21fd361467dd698bd065"
+        "sha256": "ff1b1a2239a254f500c999c5c25ab9303561b433fb1cac420a2b28a7bd0d9fd6"
       },
       {
         "path": "coverage/coverage-final.json",
@@ -41,15 +41,15 @@
       },
       {
         "path": "dist/cli.d.ts.map",
-        "sha256": "e41e9538474ad80901474841e66f3be8b9f4fdc24f85b4168a13958f19f0762c"
+        "sha256": "c9b415287eda0a7c2ad32dbb7cfc3ecce19aa3b90c96d3fbeedd62d20fe34bc7"
       },
       {
         "path": "dist/cli.js",
-        "sha256": "038b4bf4c9295202129662e1caf3b8b139c91f69b2e292373066154b644cc97c"
+        "sha256": "56b4da2639c1721180387f28166d84d065718a4002f556307a6598570d335809"
       },
       {
         "path": "dist/cli.js.map",
-        "sha256": "dafbac9c642da206ddfadb9081f01ef2a4cfba98dee719ef64200241d2b76726"
+        "sha256": "4a172ba5384c9716fa48570979b7ffba969599ed5c639d7e7268a829d2b9b4e1"
       },
       {
         "path": "dist/index.d.ts",
@@ -73,7 +73,7 @@
       },
       {
         "path": "package.json",
-        "sha256": "4e22f0553a19181eea750db59bd3eec84fd880473ac523705a1a26197665e87e"
+        "sha256": "65e245ef567ccecdc382bb040f27dd98e01ce2c3a104935aa2dc0558b22220e2"
       },
       {
         "path": "src/bin.ts",
@@ -81,7 +81,7 @@
       },
       {
         "path": "src/cli.ts",
-        "sha256": "9a32862f99d3d0211e08ea49c7091f5697acdd2789ac05137203abd6ed7a9b3e"
+        "sha256": "1aceceef391cac55d00f7872632d28c4116a82025b9235343b81398fc515f944"
       },
       {
         "path": "src/index.ts",
@@ -89,7 +89,7 @@
       },
       {
         "path": "test/cli.test.ts",
-        "sha256": "2e013ab73b4eb3dd248ed0fbbd5c050911ad667bb78054fde0bb021fbd1815db"
+        "sha256": "7d6ba26ec1188db3b3ac89f50b015ba1f0c6117b5c30d99b22da41da10c96c12"
       },
       {
         "path": "tsconfig.json",
@@ -101,5 +101,5 @@
       }
     ]
   },
-  "signature": "d+++ms/ySpdJ2w5VE7F3b8IaZLWhIYcrvTRT1nPQmi2OHDdrQZ4YBHHW2KNxrauUdTXuUf/7tD//NQiGCQgQDw=="
+  "signature": "QkTucRDewQaD109O+GaZcrFfuzX3jp/bFPbLBYq5CmLT7BCzeHAGDdGfJogI8yZA81HE5oQLRzixyq6IdNPDCw=="
 }

package/README.md

@@ -785,7 +785,7 @@ dz delivery-check --slug <slug> [--context-only] [--findings <f.json>] [--strict
 dz skills-verify     [--dir <project>] [--expect a,b] [--static] [--strict] [--timeout <s>] [--json]   # does .claude/skills/ actually REGISTER? --static = instant layout scan (CI-safe, no session): flags dirs that can never register; default also starts a real session and reads the authoritative system/init listing. exit 0 pass / 1 fail / 2 inconclusive — an unobservable registration is NEVER a pass
 dz compounding       [--project <dir>] [--json]   # honest learning-loop payoff report: pool write-only ratio, guard repeat-violation trajectory (rate per audit-half), cold-vs-warm replay readiness over unique untruncated prompt events, apply-leg staleness — a gate without enough data says INSUFFICIENT_DATA, never a verdict
 dz score             --slug <feature> [--project <dir>] [--json]   # process scorecard for ONE feature-adr run, from its artifacts: ADR confirmation, discrimination proof, cross-model QE grade, live verification, README-first, learning loop, amendments — DESCRIPTIVE-ONLY (a low score exits 0); evidence lines are shown so the reader judges the heuristics
-dz backlog <sub>     add "<idea>" | list | show <id> | goals | roulette [--seed n] | enrich <id> | jira <id> | harmonize [--apply]   # brain-backed idea backlog: capture an idea → semantic dedup against past ideas/features via the REUSED agentdb vector engine (DUPLICATE≥0.92 / RELATED / NEW) + GoalMap alignment ("map+compass") → weighted seeded roulette picks one to work on → enrich STAGES an idea2prd hand-off → jira writes an auditable outbox via a configurable MCP adapter seam (jira-mcp|copilot-mcp|none). No 2nd vector store; without agentdb it degrades to exact-text dedup (honest)
+dz backlog <sub>     add "<idea>" | list | show <id> | goals [--validate] | roulette [--seed n] [--commit <id>] | enrich <id> | jira <id> | harmonize [--apply]   # brain-backed idea backlog: capture an idea → semantic dedup against past ideas/features via the REUSED agentdb vector engine (DUPLICATE≥0.92 / RELATED / NEW) + GoalMap alignment ("map+compass") → weighted seeded roulette picks one to work on → enrich STAGES an idea2prd hand-off → jira writes an auditable outbox via a configurable MCP adapter seam (jira-mcp|copilot-mcp|none). No 2nd vector store; without agentdb it degrades to exact-text dedup (honest)
 dz sign --init --out <path>  |  --pack <dir> --key <path>   # --init: generate the Ed25519 keypair (private OUTSIDE the repo, prints the public key for keys/dz.pub); else sign a pack's manifest + CycloneDX SBOM
 dz sbom --pack <dir> [--out <file>]   # emit the CycloneDX 1.5 SBOM for a pack standalone (file-level bill of materials); print to stdout or write to a file
 dz guard check --op <publish|teach|consolidate|reindex> [--text <s>] [--json] [--force <reason>]   # declarative constraint layer before self-mutating ops: HARD violation → block (exit 1), SOFT → warn; zero-config defaults, .dz/guard.json to customise; dz guard --init | dz guard log (append-only audit). dz publish runs it automatically (--no-guard "<reason>" = logged escape hatch)
@@ -1175,6 +1175,60 @@ The `--bto` flag generates eval templates compatible with `/bto-test`:
 
 After scaffolding, fill in the SKILL.md protocol and run `/bto-test .claude/skills/my-skill` to evaluate.
 
+### dz backlog — brain-backed idea inbox (smart backlog)
+
+Throw ideas in as they come; the backlog dedups them semantically against everything you already
+captured (via the same agentdb vector engine the Brain uses — no second store), scores them against
+your goals, and picks what to work on when you have free time.
+
+```bash
+# 1. Capture an idea — it is instantly deduped + aligned
+dz backlog add "add a compounding metric to strengthen dz recall" --effort 3
+#   → [new]  e3  align 0.72   (or: [duplicate of 268d3cb1 @ cosine 0.95] / [related: …])
+#   A RELATED/DUPLICATE verdict now names the pair, so you can calibrate the 0.92 band on real data:
+#     dz backlog: RELATED — captured 67c5883e…
+#       top match 9286f5eb… @ cosine 0.793 (DUPLICATE band ≥ 0.92)
+#   An out-of-scale --effort is ECHOED, never silently clamped:
+dz backlog add "an idea I mis-scaled" --effort 13
+#   → dz backlog: effort 13 → clamped to 5 (scale 1-5)
+#   The first capture also gitignores its own store (`.dz/backlog/` — raw ideas are private): it adds
+#   the entry only when no existing rule covers it (`/.dz/`, `.dz/**`, … all count), the write is atomic
+#   and keeps the file's line endings, a `!.dz/backlog/` negation is obeyed as an explicit opt-out, and a
+#   FAILED scaffold is announced ("your ideas are visible to git") rather than passing in silence.
+
+# 2. Define your goals once ("map + compass") — alignment is scored against these
+dz backlog goals            # opens/creates .dz/backlog/goals.json; --validate checks it
+dz backlog goals --validate # a malformed entry is WARNED about, never silently dropped:
+#   → dz backlog goals: WARNING goal[0]: missing "statement" — dropped
+#     dz backlog goals: INVALID  (exit 1 when every entry was dropped — an empty compass is not "valid")
+#   A repaired field is reported with the value YOU wrote, not the clamped one the runtime uses:
+#   → dz backlog goals: WARNING goal[0] (g1): weight 7 is out of (0,1] — using 1
+
+# 3. When you have free time — spin the roulette (weighted: alignment^α · recency · 1/effort)
+dz backlog roulette --seed 7
+#   → 268d3cb1 — add a compounding metric …  align 0.72 · effort 3
+#     (start it with: dz backlog roulette --commit 268d3cb1)
+
+# 3b. Start it — --commit takes the id you were SHOWN (a bare --commit is refused: the pool can change
+#     between spins, so the spin must not decide a mutation). An id ALONE never mutates — a spin is
+#     read-only, and the --commit flag is the only thing that authorises a status change.
+dz backlog roulette --commit 268d3cb1   # → 268d3cb1 · → in-progress
+dz backlog roulette 268d3cb1            # → refused (exit 1): "an idea id alone does not start it"
+
+# 4. Work it: stage an idea2prd hand-off (writes the PRD-pipeline input scaffold)
+dz backlog enrich 268d3cb1  # → features/<slug>/ scaffold; run the idea2prd-manual skill on it
+
+# 5. Or push it to Jira via the configured adapter (jira-mcp | copilot-mcp | none)
+dz backlog jira 268d3cb1    # 'none' (default) writes an auditable .dz/backlog/jira-outbox/<id>.json
+
+# Housekeeping: cluster near-duplicates (dry-run by default; --apply prunes vectors too)
+dz backlog harmonize --apply
+```
+
+When to use: any time an idea strikes mid-work — capture beats context-switching. Without the
+agentdb memory backend installed the dedup honestly degrades to exact-text and alignment to 0
+(`dz setup --memory agentdb` enables the semantic tier).
+
 ### dz install — install skills from any npm package
 
 ```bash
@@ -1895,7 +1949,7 @@ invariants: HARD rules **block** the operation, SOFT rules warn. Zero config nee
 cover the known rakes; `.dz/guard.json` (via `dz guard --init`) exists only if you want to tune a severity
 or disable a rule.
 ```bash
-dz guard check --op publish        # no-workspace-star · no-skill-drift · no-secrets · readme-consistency · readme-first
+dz guard check --op publish        # no-workspace-star · no-skill-drift · no-secrets · readme-consistency · readme-first · skills-registrable · lockfile-in-sync
 dz guard check --op teach --text "the fix: export sk-abc..."   # → BLOCK (exit 1): looks like a credential
 dz guard log                       # append-only audit: every verdict + every forced override
 ```
@@ -1913,6 +1967,23 @@ site** in the contour: the command count on the Starlight CLI overview and the f
 match the cli README (the site once drifted 35→55 silently; now a mismatch is a warning here and a red
 test in CI). In a repo without the docs site those pairs simply aren't gathered — no false gate.
 
+The SOFT `lockfile-in-sync` rule closes the CI break that follows a dependency bump: when a workspace
+`packages/*/package.json` declares a `@dzhechkov/*` spec that differs from the specifier `pnpm-lock.yaml`
+records for that importer, CI's `pnpm install --frozen-lockfile` dies with `ERR_PNPM_OUTDATED_LOCKFILE`
+long after the commit. Now it is a warning at publish time:
+```
+  [warn] lockfile-in-sync: packages/@dzhechkov/harness-cli: @dzhechkov/harness-core = "^0.3.999" in
+         package.json but "^0.3.141" in pnpm-lock.yaml — run `pnpm install` to refresh the lockfile
+```
+It FAILS OPEN by construction — no lockfile, or one its parser cannot read, yields no warning at all (a
+guard that cannot read its evidence must never invent a violation), and it only compares `@dzhechkov/*`
+specs. "Tolerant" here means **recognise-or-refuse**, not *guess quietly*: the parser reads exactly the
+`lockfileVersion: 9`+ importer layout and returns nothing at all for a legacy v5/v6 file (whose deps are
+`dep: version` one-liners) or a truncated one — because a half-parse would find the importer keys, read
+zero specifiers, and then report every real dependency as "not recorded". The rule is also **SOFT-only**:
+`.dz/guard.json` cannot promote it to HARD, since a parser designed to admit "I may not understand this
+file" must never be able to block a publish.
+
 ### `dz feature-adr-setup --guards` — when a project rule should be a TEST, not a reviewer's memory
 
 A 700-line cap enforced by reviewer judgment catches one file and misses its sibling in the same change;

package/dist/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AA6TH,2EAA2E;AAC3E,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,iBAAiB,CAAC;CAC5C;AAED,yFAAyF;AACzF,MAAM,MAAM,iBAAiB,GAAG,CAC9B,GAAG,EAAE,MAAM,EACX,IAAI,EAAE;IAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAAE,KACvD;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAouM9E,wBAAsB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,GAAE,KAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CA0J5E"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAkUH,2EAA2E;AAC3E,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,iBAAiB,CAAC;CAC5C;AAED,yFAAyF;AACzF,MAAM,MAAM,iBAAiB,GAAG,CAC9B,GAAG,EAAE,MAAM,EACX,IAAI,EAAE;IAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAAE,KACvD;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAg2M9E,wBAAsB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,GAAE,KAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CA0J5E"}

package/dist/cli.js

@@ -9,9 +9,9 @@ import { fileURLToPath } from 'node:url';
 import { execSync, spawn } from 'node:child_process';
 import { homedir, tmpdir } from 'node:os';
 import { createRequire } from 'node:module';
-import { createSkill, getSkillInfo, getWorkflow, isTargetName, listSkills, runDoctor, runInit, benchmarkSkill, benchmarkSkills, scanMcp, reconcileCapabilities, RECONCILE_BANNER, buildRegistry, discoverSkillPackDirs, checkUpstream, compareSkills, checkAllUpstream, sweepSkillDrift, syncCanonicalSkill, checkUpgrades, discoverPackages, discoverSourcePackages, fetchAllDownloads, filterByCategory, pretrain, recommend, generatePlugin, publishPackages, runSetup, runMigrate, searchRegistry, runSync, runVerify, runInitAgentsMd, runInitGeminiMd, TARGET_NAMES, buildParityMatrix, TARGET_CAPABILITIES, TARGET_SHORT_LABELS, WORKFLOW_NAMES, importEcc, recordPattern, resolveLearningBackend, storeStats, consolidateSessions, pruneNoisePatterns, lessonDeltaReport, removePatternsByIds, snapshotStore, recallHybrid, teachGuard, mirrorPatternsToVector, mirrorEntriesToVector, patternVectorEntry, readMemoryLearningConfig, promotePatterns, quarantineExpiryCandidates, pruneQuarantinePatterns, clearAgentdbQuarantine, vectorMirrorEnabled, vectorTierStatus, resolveVectorEngine, reindexVectorStore, harmonizeVectorStore, importRvfCheckpoint, statuslineData, writeFeatureAdrState, computeUsage, deriveUsageCalibration, normalizeClaudeUsageModelKey, readUsageLimits, claimCheck, summarize, queryBookKnowledge, loadStorePatternsSync, patternRecordId, loadStoreRecords, recordToPattern, bundleSkills, brainHome, listBrain, promoteProjectToBrain, updateBrainSource, queryBrain, groundPrompt, expandKu, reindexBrainVectors, buildPrimer, exportBrainSlice, importBrainSlice, registerKusToBrain, RECALL_USAGE_LOG_RELATIVE, RECALL_USAGE_LOG_MAX_BYTES, parseRecallUsageLog, buildRecallUsageReport, buildManifest, buildSbom, resolveTrustRoot, decideVerifyPolicy, generateSigningKeypair, evaluateGuard, resolveRules, auditRecord, guardExitCode, DEFAULT_RULES, decideProvenance, isInsideTree, signManifest, verifyManifest, listSignablePackFiles, assertKeyOutsideTree, decidePublishGate, collectPackageFacts, planReleaseGates, selectAffectedPackages, classifyGateExecutions, buildFailureIssue, buildReleaseNotes, releaseTagName, firstOutputLine, formatPublishError, MANIFEST_NAME, SBOM_NAME, buildArchitectureMap, renderMapHuman, findArchitectureDrift, renderDriftReport, scanWorkspacePackages, loadSubsystemManifest, loadProductVision, checkFeatureAgainstArchitecture, renderArchCheck, planProjectSkills, guidanceForStage, renderInjectionReport, analyzeCorpus, renderRakeReport, renderCriticSection, rakeAsLesson, rakeReward, DEFAULT_RAKE_THRESHOLDS, streamSessionEvents, findLatestTranscript, detectProcessRakes, buildRetro, renderRetro, retroLessonText, PROCESS_SIGNATURES, RETRO_DOMAIN, scanForSetup, buildSetupPlan, scaffoldFromSpec, renderScaffoldPreview, readExistingForScaffold, assembleChallengeContext, buildChallengeBrief, planDiscriminationCheck, classifyDiscrimination, pickAdversaryModel, CHALLENGE_QUESTIONS, loadOutcomes, renderOutcomes, statsForKey, selectAutoCost, recordProvisional, finalizeOutcome, COST_LADDER, splitScenarios, budgetPlan, selectWinner, proseScopeOk, renderProseDiff, readScenarioIds, DEFAULT_MAX_JUDGE_RUNS, collectDeliveryFacts, planDeliveryCheck, renderDeliveryBrief, classifyDelivery, isUsablePlaneResult, renderDeliveryReview, scanSkillsLayout, parseInitFacts, verifyRegistration, buildContentProbePrompt, classifyContentProbe, renderContentProbe, findNonRegistrableSkillDirs, assembleCompoundingReport, scoreRun, renderScorecard, renderCompoundingReport, readReinforcementState, readQuarantineState, registrationExitCode, renderRegistrationReport, 
+import { createSkill, getSkillInfo, getWorkflow, isTargetName, listSkills, runDoctor, runInit, benchmarkSkill, benchmarkSkills, scanMcp, reconcileCapabilities, RECONCILE_BANNER, buildRegistry, discoverSkillPackDirs, checkUpstream, compareSkills, checkAllUpstream, sweepSkillDrift, syncCanonicalSkill, checkUpgrades, discoverPackages, discoverSourcePackages, fetchAllDownloads, filterByCategory, pretrain, recommend, generatePlugin, publishPackages, runSetup, runMigrate, searchRegistry, runSync, runVerify, runInitAgentsMd, runInitGeminiMd, TARGET_NAMES, buildParityMatrix, TARGET_CAPABILITIES, TARGET_SHORT_LABELS, WORKFLOW_NAMES, importEcc, recordPattern, resolveLearningBackend, storeStats, consolidateSessions, pruneNoisePatterns, lessonDeltaReport, removePatternsByIds, snapshotStore, recallHybrid, teachGuard, mirrorPatternsToVector, mirrorEntriesToVector, patternVectorEntry, readMemoryLearningConfig, promotePatterns, quarantineExpiryCandidates, pruneQuarantinePatterns, clearAgentdbQuarantine, vectorMirrorEnabled, vectorTierStatus, resolveVectorEngine, reindexVectorStore, harmonizeVectorStore, importRvfCheckpoint, statuslineData, writeFeatureAdrState, computeUsage, deriveUsageCalibration, normalizeClaudeUsageModelKey, readUsageLimits, claimCheck, summarize, queryBookKnowledge, loadStorePatternsSync, patternRecordId, loadStoreRecords, recordToPattern, bundleSkills, brainHome, listBrain, promoteProjectToBrain, updateBrainSource, queryBrain, groundPrompt, expandKu, reindexBrainVectors, buildPrimer, exportBrainSlice, importBrainSlice, registerKusToBrain, RECALL_USAGE_LOG_RELATIVE, RECALL_USAGE_LOG_MAX_BYTES, parseRecallUsageLog, buildRecallUsageReport, buildManifest, buildSbom, resolveTrustRoot, decideVerifyPolicy, generateSigningKeypair, evaluateGuard, resolveRules, auditRecord, guardExitCode, DEFAULT_RULES, parsePnpmLockImporters, decideProvenance, isInsideTree, signManifest, verifyManifest, listSignablePackFiles, assertKeyOutsideTree, decidePublishGate, collectPackageFacts, planReleaseGates, selectAffectedPackages, classifyGateExecutions, buildFailureIssue, buildReleaseNotes, releaseTagName, firstOutputLine, formatPublishError, MANIFEST_NAME, SBOM_NAME, buildArchitectureMap, renderMapHuman, findArchitectureDrift, renderDriftReport, scanWorkspacePackages, loadSubsystemManifest, loadProductVision, checkFeatureAgainstArchitecture, renderArchCheck, planProjectSkills, guidanceForStage, renderInjectionReport, analyzeCorpus, renderRakeReport, renderCriticSection, rakeAsLesson, rakeReward, DEFAULT_RAKE_THRESHOLDS, streamSessionEvents, findLatestTranscript, detectProcessRakes, buildRetro, renderRetro, retroLessonText, PROCESS_SIGNATURES, RETRO_DOMAIN, scanForSetup, buildSetupPlan, scaffoldFromSpec, renderScaffoldPreview, readExistingForScaffold, assembleChallengeContext, buildChallengeBrief, planDiscriminationCheck, classifyDiscrimination, pickAdversaryModel, CHALLENGE_QUESTIONS, loadOutcomes, renderOutcomes, statsForKey, selectAutoCost, recordProvisional, finalizeOutcome, COST_LADDER, splitScenarios, budgetPlan, selectWinner, proseScopeOk, renderProseDiff, readScenarioIds, DEFAULT_MAX_JUDGE_RUNS, collectDeliveryFacts, planDeliveryCheck, renderDeliveryBrief, classifyDelivery, isUsablePlaneResult, renderDeliveryReview, scanSkillsLayout, parseInitFacts, verifyRegistration, buildContentProbePrompt, classifyContentProbe, renderContentProbe, findNonRegistrableSkillDirs, assembleCompoundingReport, scoreRun, renderScorecard, renderCompoundingReport, readReinforcementState, readQuarantineState, registrationExitCode, renderRegistrationReport, 
 // Smart Backlog (feature smart-backlog) — goal-directed idea pipeline over the Brain vector engine.
-readBacklogConfig, readIdeas, writeIdeas, ideaId, dedupIdea, readGoalMap, alignIdea, mirrorIdeaVector, snapshotIdeas, spinRoulette, rankRoulette, seededRng, eligibleIdeas, stageEnrichment, buildJiraDraft, resolveJiraAdapter, makeBacklogIO, harmonizeBacklog, BACKLOG_BACKENDS, } from '@dzhechkov/harness-core';
+readBacklogConfig, readIdeas, writeIdeas, ideaId, dedupIdea, readGoalMap, readGoalMapDetailed, parseEffort, ensureBacklogGitignored, isSafeId, alignIdea, mirrorIdeaVector, snapshotIdeas, spinRoulette, rankRoulette, seededRng, eligibleIdeas, stageEnrichment, buildJiraDraft, resolveJiraAdapter, makeBacklogIO, harmonizeBacklog, BACKLOG_BACKENDS, } from '@dzhechkov/harness-core';
 import { getPreset, PRESET_NAMES } from '@dzhechkov/harness-presets';
 import { scanGitHub, analyzeRepo, generateReport, deepAnalyze, scanAllSources, ScoutMemory } from '@dzhechkov/scout';
 const USAGE = `dz - DZ cross-platform harness CLI
@@ -4501,18 +4501,15 @@ function gatherReadmeCounts(root) {
 function gatherGuardFacts(op, root, text, storeCap) {
     const facts = { op };
     if (op === 'publish') {
-        // Read every workspace manifest ONCE: build a name→version map, then resolve each `workspace:*` dep to the
-        // version pnpm WOULD publish it as. In a pnpm workspace (pnpm-workspace.yaml present) `workspace:*` in source
-        // is correct and gets rewritten at publish — so reporting it raw would be a FALSE gate. We mirror the rewrite:
-        // a resolvable workspace dep becomes its real semver (safe → the rule passes); an UNRESOLVABLE one (points at
-        // no workspace package, or not a pnpm workspace) stays `workspace:*` so the rule catches a dep that WOULD ship
-        // raw. That is the genuinely dangerous case the rule exists for.
         const manifests = [];
+        const located = [];
         try {
             const out = execSync('git ls-files "packages/@dzhechkov/*/package.json"', { cwd: root, encoding: 'utf-8' });
             for (const rel of out.split('\n').map((s) => s.trim()).filter(Boolean)) {
                 try {
-                    manifests.push(JSON.parse(readFileSync(join(root, rel), 'utf8')));
+                    const m = JSON.parse(readFileSync(join(root, rel), 'utf8'));
+                    manifests.push(m);
+                    located.push({ dir: rel.replace(/\/package\.json$/, ''), m });
                 }
                 catch { /* skip unreadable */ }
             }
@@ -4576,6 +4573,32 @@ function gatherGuardFacts(op, root, text, storeCap) {
             facts['skillPacks'] = skillPacks;
         }
         catch { /* unreadable packages dir — rule reports nothing rather than inventing a violation */ }
+        // lockfile-in-sync: the ERR_PNPM_OUTDATED_LOCKFILE class — a @dzhechkov/* dep spec bumped in a
+        // package.json while pnpm-lock.yaml still records the old specifier. FAIL-OPEN by construction: an
+        // unreadable/unparseable lockfile yields `{parsed:false}` and the rule reports NOTHING.
+        try {
+            const lockText = readFileSync(join(root, 'pnpm-lock.yaml'), 'utf8');
+            const importers = parsePnpmLockImporters(lockText);
+            if (importers === undefined) {
+                facts['lockfile'] = { parsed: false };
+            }
+            else {
+                const rows = located
+                    .map(({ dir, m }) => {
+                    const declared = {};
+                    for (const [dep, spec] of Object.entries({ ...(m.dependencies ?? {}), ...(m.devDependencies ?? {}) })) {
+                        if (dep.startsWith('@dzhechkov/') && typeof spec === 'string')
+                            declared[dep] = spec;
+                    }
+                    return { importer: dir, declared, locked: importers[dir] };
+                })
+                    .filter((r) => Object.keys(r.declared).length > 0);
+                facts['lockfile'] = { parsed: true, importers: rows };
+            }
+        }
+        catch {
+            facts['lockfile'] = { parsed: false }; /* no lockfile (not a pnpm workspace) — rule stays silent */
+        }
     }
     if (op === 'consolidate') {
         try {
@@ -5932,9 +5955,19 @@ async function cmdBacklog(options, flags, cwd, write) {
         const text = (options.get('_positional_1') ?? '').trim();
         if (text === '')
             return emitErr('an idea text is required: dz backlog add "<idea>"');
-        const effort = Number(options.get('effort') ?? cfg.roulette.defaultEffort);
+        // The clamp is ECHOED, never silent (idea 86096d6d): `--effort 13` used to store 5 and say nothing.
+        const eff = parseEffort(options.get('effort'), cfg.roulette.defaultEffort);
+        if (eff.adjusted && !json && eff.note !== undefined)
+            write(`dz backlog: ${eff.note}`);
         const dryRun = flags.has('dry-run');
         const verdict = await dedupIdea(projectRoot, text, cfg);
+        // The TOP-MATCH pair (id @ cosine) is the ADR-002 calibration surface (idea ce914ac2) — observational
+        // only: the band itself is unchanged, but a RELATED verdict now shows WHICH idea produced the cosine.
+        // A negative cosine is a VALID observation (anti-correlated embedding) — only non-finite is absent
+        // (Codex re-QE LOW: `>= 0` suppressed a legitimate negative top match).
+        const topMatch = verdict.topMatchId !== undefined && Number.isFinite(verdict.cosine)
+            ? { id: verdict.topMatchId, cosine: verdict.cosine }
+            : undefined;
         if (verdict.action === 'duplicate') {
             // DUPLICATE ⇒ snapshot + reinforce the existing root; NO new record (ADR-002 T-002b).
             const ideas = readIdeas(projectRoot);
@@ -5947,9 +5980,12 @@ async function cmdBacklog(options, flags, cwd, write) {
                 writeIdeas(projectRoot, ideas);
             }
             if (json)
-                write(JSON.stringify({ action: 'duplicate', matchedId: verdict.matchedId, cosine: verdict.cosine, exitCode: 0 }, null, 2));
-            else
+                write(JSON.stringify({ action: 'duplicate', matchedId: verdict.matchedId, cosine: verdict.cosine, ...(topMatch !== undefined ? { topMatch } : {}), ...(eff.note !== undefined ? { effortNote: eff.note } : {}), exitCode: 0 }, null, 2));
+            else {
                 write(`dz backlog: DUPLICATE of ${verdict.matchedId} (cosine ${verdict.cosine.toFixed(3)}${verdict.exactTextOnly ? ', exact-text' : ''}) — reinforced, no new record`);
+                if (topMatch !== undefined)
+                    write(`  top match ${topMatch.id} @ cosine ${topMatch.cosine.toFixed(3)} (DUPLICATE band ≥ ${cfg.dedup.duplicateThreshold})`);
+            }
             return 0;
         }
         const goalMap = readGoalMap(projectRoot);
@@ -5960,7 +5996,7 @@ async function cmdBacklog(options, flags, cwd, write) {
             text,
             status: 'new',
             createdTs,
-            effort: Number.isFinite(effort) ? Math.max(1, Math.min(5, Math.floor(effort))) : cfg.roulette.defaultEffort,
+            effort: eff.effort,
             goalId: align.goalId,
             goalAlignment: align.goalAlignment,
             relatedIds: [...verdict.relatedIds],
@@ -5972,23 +6008,45 @@ async function cmdBacklog(options, flags, cwd, write) {
             rec.proposal = proposal; // agent prose ONLY — the CLI never fabricates it
         if (dryRun) {
             if (json)
-                write(JSON.stringify({ action: verdict.action, dryRun: true, idea: rec, exitCode: 0 }, null, 2));
-            else
+                write(JSON.stringify({ action: verdict.action, dryRun: true, idea: rec, ...(topMatch !== undefined ? { topMatch } : {}), ...(eff.note !== undefined ? { effortNote: eff.note } : {}), exitCode: 0 }, null, 2));
+            else {
                 write(`dz backlog (dry-run): ${verdict.action.toUpperCase()} — would create ${rec.id}; align ${rec.goalAlignment.toFixed(3)}${rec.goalId !== null ? ` → ${rec.goalId}` : ''}`);
+                // The calibration surface belongs on the dry-run too (QE LOW-8) — a dry-run is exactly where a
+                // user checks whether a near-duplicate should have crossed the band.
+                if (topMatch !== undefined)
+                    write(`  top match ${topMatch.id} @ cosine ${topMatch.cosine.toFixed(3)} (DUPLICATE band ≥ ${cfg.dedup.duplicateThreshold})`);
+            }
             return 0;
         }
+        // Privacy scaffold (idea ec4cd60d): the store we are about to create holds raw prompt-class ideas —
+        // ensure `.dz/backlog/` is gitignored BEFORE the first write. No-op once covered.
+        const ignore = ensureBacklogGitignored(projectRoot);
         const ideas = readIdeas(projectRoot);
         ideas.push(rec);
         writeIdeas(projectRoot, ideas);
         const mirror = await mirrorIdeaVector(projectRoot, rec); // best-effort — never blocks capture
         if (json)
-            write(JSON.stringify({ action: verdict.action, idea: rec, related: verdict.relatedIds, exitCode: 0 }, null, 2));
+            write(JSON.stringify({ action: verdict.action, idea: rec, related: verdict.relatedIds, ...(topMatch !== undefined ? { topMatch } : {}), ...(eff.note !== undefined ? { effortNote: eff.note } : {}), gitignore: ignore, exitCode: 0 }, null, 2));
         else {
             write(`dz backlog: ${verdict.action.toUpperCase()} — captured ${rec.id}`);
+            if (verdict.action === 'related' && topMatch !== undefined) {
+                write(`  top match ${topMatch.id} @ cosine ${topMatch.cosine.toFixed(3)} (DUPLICATE band ≥ ${cfg.dedup.duplicateThreshold})`);
+            }
             if (rec.goalId !== null)
                 write(`  top goal: ${rec.goalId} (alignment ${rec.goalAlignment.toFixed(3)})`);
             if (verdict.relatedIds.length > 0)
                 write(`  related: ${verdict.relatedIds.join(', ')}`);
+            if (ignore.action === 'created' || ignore.action === 'appended') {
+                write(`  privacy: ${ignore.action} \`.dz/backlog/\` in ${ignore.path} (ideas are private prompt-class content)`);
+            }
+            else if (ignore.action === 'skipped') {
+                // A privacy scaffold that FAILED must never be silent (QE MED-5): the store now holds raw ideas
+                // that git can see, and only the user can fix it.
+                write(`  ⚠ privacy: could NOT gitignore \`.dz/backlog/\` (${ignore.reason ?? 'unknown error'}) — your ideas are visible to git; add \`.dz/backlog/\` to ${ignore.path} yourself`);
+            }
+            else if (ignore.action === 'user-opted-out') {
+                write('  privacy: `.dz/backlog/` is explicitly un-ignored (a `!` negation in .gitignore) — respecting that; ideas WILL be tracked by git');
+            }
             write('  proposal: (write your own — dz backlog add --proposal "<text>"; the CLI never fabricates it)');
             if (mirror.error !== undefined)
                 write(`  ↳ vector mirror deferred: ${mirror.error}`);
@@ -6027,9 +6085,23 @@ async function cmdBacklog(options, flags, cwd, write) {
         return 0;
     }
     if (sub === 'goals') {
-        const goalMap = readGoalMap(projectRoot);
         if (flags.has('validate')) {
+            // A vacuous "valid (0 goal(s))" HID the user's mistake (idea 960c9f26): the defensive reader silently
+            // dropped every malformed entry (e.g. `text` where `statement` belongs). Validate reads the DETAILED
+            // view, warns per dropped entry, and refuses to call a fully-dropped compass valid.
+            const detail = readGoalMapDetailed(projectRoot);
+            const goalMap = detail.goalMap;
             const problems = [];
+            const warnings = [];
+            if (detail.parseError !== undefined)
+                problems.push(detail.parseError);
+            for (const d of detail.dropped)
+                warnings.push(`goal[${d.index}]: ${d.reason} — dropped`);
+            // The reader CLAMPS a bad weight before any validation could see it, so validating the clamped
+            // value can only ever pass (QE MED-7 — the branch below was dead code). Warn from the RAW value
+            // the user wrote, and say which value the runtime is actually using.
+            for (const r of detail.repaired)
+                warnings.push(`goal[${r.index}] (${r.id}): ${r.reason} — using ${r.used}`);
             const seen = new Set();
             for (const g of goalMap.goals) {
                 if (seen.has(g.id))
@@ -6037,20 +6109,32 @@ async function cmdBacklog(options, flags, cwd, write) {
                 seen.add(g.id);
                 if (g.statement.trim() === '')
                     problems.push(`goal ${g.id} has an empty statement`);
+                // Defence in depth: the reader guarantees the clamp, so this can only fire if that ever regresses.
                 if (!(g.weight > 0 && g.weight <= 1))
                     problems.push(`goal ${g.id} weight ${g.weight} is out of (0,1]`);
             }
-            if (json)
-                write(JSON.stringify({ valid: problems.length === 0, problems, goals: goalMap.goals.length, exitCode: problems.length === 0 ? 0 : 1 }, null, 2));
-            else if (problems.length === 0)
-                write(`dz backlog goals: valid (${goalMap.goals.length} goal(s))`);
+            // A compass whose entries were ALL dropped is a user error, not an empty compass.
+            const allDropped = detail.present > 0 && goalMap.goals.length === 0;
+            if (allDropped)
+                problems.push(`all ${detail.present} goal entr${detail.present === 1 ? 'y was' : 'ies were'} dropped as malformed — the compass is EMPTY, not valid`);
+            const valid = problems.length === 0;
+            if (json) {
+                write(JSON.stringify({ valid, problems, warnings, dropped: detail.dropped, repaired: detail.repaired, goals: goalMap.goals.length, present: detail.present, exitCode: valid ? 0 : 1 }, null, 2));
+            }
             else {
-                write('dz backlog goals: INVALID');
-                for (const p of problems)
-                    write(`  - ${p}`);
+                for (const w of warnings)
+                    write(`dz backlog goals: WARNING ${w}`);
+                if (valid)
+                    write(`dz backlog goals: valid (${goalMap.goals.length} goal(s)${detail.dropped.length > 0 ? `, ${detail.dropped.length} dropped` : ''})`);
+                else {
+                    write('dz backlog goals: INVALID');
+                    for (const p of problems)
+                        write(`  - ${p}`);
+                }
             }
-            return problems.length === 0 ? 0 : 1;
+            return valid ? 0 : 1;
         }
+        const goalMap = readGoalMap(projectRoot);
         if (json) {
             write(JSON.stringify({ goals: goalMap.goals, exitCode: 0 }, null, 2));
             return 0;
@@ -6067,7 +6151,40 @@ async function cmdBacklog(options, flags, cwd, write) {
     if (sub === 'roulette') {
         const ideas = readIdeas(projectRoot);
         const pool = eligibleIdeas(ideas);
-        if (pool.length === 0) {
+        // ── Commit-argument validation runs BEFORE any early return (QE HIGH-2): an empty eligible pool
+        // used to return 0 first, so `--commit <garbage>` reported success having validated nothing. A
+        // mutation request is answered on its own merits, whatever the pool looks like.
+        // parseArgs turns `--commit <id>` into an OPTION and a bare `--commit` into a FLAG. A trailing
+        // positional id is only a commit target when --commit was actually passed (QE HIGH-1): a bare
+        // `dz backlog roulette <id>` must never mutate.
+        const positionalId = options.get('_positional_1');
+        const commitOpt = options.get('commit');
+        const wantsCommit = flags.has('commit') || commitOpt !== undefined;
+        if (!wantsCommit && positionalId !== undefined) {
+            return emitErr(`an idea id alone does not start it — a spin never mutates. Use: dz backlog roulette --commit ${positionalId}`);
+        }
+        const commitId = wantsCommit ? commitOpt ?? positionalId : undefined;
+        if (wantsCommit && commitId !== undefined) {
+            if (!isSafeId(commitId))
+                return emitErr(`refusing an unsafe idea id: ${JSON.stringify(commitId)}`);
+            const target = ideas.find((i) => i.id === commitId);
+            if (target === undefined)
+                return emitErr(`no idea ${commitId} — run dz backlog list to see the ids`);
+            // TERMINAL ideas must not be silently resurrected (Codex re-QE). in-progress is allowed —
+            // re-committing it is an idempotent no-op, not a resurrection.
+            if (target.status === 'shipped' || target.status === 'dropped') {
+                return emitErr(`idea ${commitId} is ${target.status} — a terminal idea cannot be (re)started`);
+            }
+        }
+        // `--pick N` is a read-only ranking view; combining it with a mutation request is ambiguous and was
+        // silently ignoring the commit (Codex re-QE) — refuse the combination explicitly.
+        if (wantsCommit && options.get('pick') !== undefined) {
+            return emitErr('--pick cannot be combined with --commit — commit a single explicit id without --pick');
+        }
+        if (pool.length === 0 && commitId === undefined) {
+            // A bare `--commit` with nothing to spin cannot name a pick to paste, so it says exactly that.
+            if (wantsCommit)
+                return emitErr('roulette --commit requires an idea id, and there is no eligible idea to suggest one — run dz backlog list');
             write(json ? JSON.stringify({ pick: null, eligible: 0, exitCode: 0 }) : 'dz backlog roulette: no eligible ideas (status new/enriched)');
             return 0;
         }
@@ -6087,19 +6204,34 @@ async function cmdBacklog(options, flags, cwd, write) {
         }
         const seedOpt = options.get('seed');
         const seed = seedOpt !== undefined && Number.isFinite(Number(seedOpt)) ? Number(seedOpt) : Math.floor(Math.random() * 2 ** 31);
-        const pick = spinRoulette(ideas, cfg.roulette, seededRng(seed), now);
+        // With an empty pool but a valid --commit id, there is nothing to spin — the commit still stands.
+        const spun = pool.length > 0 ? spinRoulette(ideas, cfg.roulette, seededRng(seed), now) : undefined;
+        if (wantsCommit && commitId === undefined) {
+            // --commit takes an EXPLICIT id (idea 5fcd9a2d): the spin is a function of the CURRENT pool, so a
+            // bare `--commit` after the pool changed could start a DIFFERENT idea than the dry-run showed. The
+            // id the user saw is the id that gets committed — the spin no longer decides a mutation.
+            const msg = `roulette --commit requires the idea id you are committing to: dz backlog roulette --commit ${spun.id} (this spin's pick) — a bare --commit could start a different idea than the one you were shown`;
+            if (json)
+                write(JSON.stringify({ error: msg, pickId: spun.id, exitCode: 1 }, null, 2));
+            else
+                write(`dz backlog: ${msg}`);
+            return 1;
+        }
+        let pick = spun;
         let committed = false;
-        if (flags.has('commit')) {
-            const idx = ideas.findIndex((i) => i.id === pick.id);
+        if (commitId !== undefined) {
+            // Validated above (safe id + known id) BEFORE any early return.
+            const idx = ideas.findIndex((i) => i.id === commitId);
             ideas[idx].status = 'in-progress';
             writeIdeas(projectRoot, ideas);
+            pick = ideas[idx];
             committed = true;
         }
         if (json)
-            write(JSON.stringify({ pick, seed, committed, exitCode: 0 }, null, 2));
-        else {
+            write(JSON.stringify({ pick: pick ?? null, seed, committed, exitCode: 0 }, null, 2));
+        else if (pick !== undefined) {
             write(`dz backlog roulette (seed ${seed}): ${pick.id} — ${pick.text.slice(0, 70)}`);
-            write(`  align ${pick.goalAlignment.toFixed(3)}${pick.goalId !== null ? ` (${pick.goalId})` : ''} · effort ${pick.effort}${committed ? ' · → in-progress' : ' · (add --commit to start it)'}`);
+            write(`  align ${pick.goalAlignment.toFixed(3)}${pick.goalId !== null ? ` (${pick.goalId})` : ''} · effort ${pick.effort}${committed ? ' · → in-progress' : ` · (start it with: dz backlog roulette --commit ${pick.id})`}`);
         }
         return 0;
     }
@@ -6175,7 +6307,7 @@ async function cmdBacklog(options, flags, cwd, write) {
     write('  list [--status <s>][--goal <id>]                       list ideas');
     write('  show <id>                                              full record');
     write('  goals [--validate]                                     the compass (.dz/backlog/goals.json)');
-    write('  roulette [--pick N][--seed n][--commit]                weighted draw for what to work on next');
+    write('  roulette [--pick N][--seed n][--commit <id>]           weighted draw; --commit takes the id you saw');
     write('  enrich <id>                                            stage the idea2prd hand-off (agent expands)');
     write(`  jira <id>                                              draft a Jira issue (adapter: ${[...BACKLOG_BACKENDS].join('|')})`);
     write('  harmonize [--apply][--threshold 0-1]                   batch semantic dedup of the backlog');