@dzhechkov/harness-core 0.8.38 → 0.8.39

package/src/skills-verify.ts

@@ -6,8 +6,8 @@
  * the PROPERTY (registration). This module makes the property observable.
  *
  * Two layers:
- *   L1 `scanSkillsLayout`  — instant, no Claude session: which names CAN register, plus the three
- *                            layout shapes that produced the 1.2.0 defect.
+ *   L1 `scanSkillsLayout`  — instant, no Claude session: names whose on-disk form passes the
+ *                            static checks, plus known issue shapes.
  *   L2 `parseInitFacts`    — the authoritative listing, parsed from the `system/init` event of
  *      + `classifyRegistration`  `claude -p --output-format stream-json --verbose`. No model prose.
  *
@@ -19,13 +19,15 @@ import { basename, isAbsolute, join, resolve } from 'node:path';
 
 // ── Layer 1: static layout scan ─────────────────────────────────────
 
-/** The three non-registrable shapes, all observed in the health-advisor 1.2.0 defect. */
+/** The seven static issue shapes this scanner reports. */
 export type SkillIssueKind =
   | 'no-skill-md'          // a skill dir with no SKILL.md at depth 1 → never registers
   | 'buried-skill-md'      // a SKILL.md at depth >= 2 → the loader does not scan that deep
   | 'plugin-manifest-trap' // .claude-plugin/plugin.json under .claude/skills → does NOT auto-register
   | 'wildcard-allowed-tools' // `allowed-tools: *` → every tool granted; a FINDING (see below)
-  | 'empty-allowed-tools';   // `allowed-tools:` with no value → looks restrictive, restricts nothing
+  | 'empty-allowed-tools'    // `allowed-tools:` with no value → looks restrictive, restricts nothing
+  | 'missing-frontmatter-fence' // measured absent from the registry without an opening `---`
+  | 'missing-description';      // measured absent from the registry without a non-empty description
 
 export interface SkillLayoutFinding {
   readonly dir: string;
@@ -38,7 +40,10 @@ export interface StaticScan {
   readonly projectDir: string;
   readonly skillsRoot: string;
   readonly exists: boolean;
-  /** Names that CAN register: a dir with SKILL.md exactly one level deep. */
+  /**
+   * Bare skill names whose on-disk form passes static layout and measured frontmatter checks.
+   * Actual registration is established only by the Layer-2 session listing.
+   */
   readonly registrable: readonly string[];
   /** Load-blocking problems: these make the verdict FAIL. */
   readonly findings: readonly SkillLayoutFinding[];
@@ -228,6 +233,39 @@ export function parseAllowedTools(markdown: string): AllowedToolsState {
   return { state: 'listed', values, wildcard: values.includes('*') };
 }
 
+type SkillFrontmatterIssue = 'missing-frontmatter-fence' | 'missing-description';
+
+/**
+ * Read the registration-relevant frontmatter fields, line by line and only before its closing fence.
+ * Scanning the whole file would let `description:` in skill documentation suppress a real finding,
+ * the same false-positive/false-negative boundary guarded by `parseAllowedTools` above.
+ *
+ * The two conditions are measured as absence from the registry, not refusal of invocation. Each
+ * measurement used a fresh session, so it also does not establish appearance in the same response
+ * without a restart.
+ */
+function findSkillFrontmatterIssue(markdown: string): SkillFrontmatterIssue | null {
+  const lines = markdown.split(/\r?\n/);
+  // NO explicit BOM strip, and that is deliberate: `String.prototype.trim()` already removes U+FEFF
+  // (it is <ZWNBSP>, part of the WhiteSpace production), so a BOM-prefixed fence compares equal to
+  // a bare one. MEASURED 2026-09-19: adding a strip left the mutant "don't strip" 70/70 green —
+  // dead code. The tolerance is pinned by a test instead, so replacing `trim()` with anything
+  // stricter goes red rather than silently rejecting every BOM-prefixed skill.
+  if (lines[0]?.trim() !== '---') return 'missing-frontmatter-fence';
+
+  let description: string | null = null;
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i] ?? '';
+    if (line.trim() === '---') break;
+    const match = /^description:(.*)$/.exec(line);
+    if (match) {
+      description = match[1] ?? '';
+      break;
+    }
+  }
+  return description === null || description.trim() === '' ? 'missing-description' : null;
+}
+
 /**
  * Privilege findings for one skill directory.
  *
@@ -426,16 +464,38 @@ export function scanSkillsLayout(projectDir: string): StaticScan {
     const isPluginContainer = hasPluginManifest(dir);
     const bucket = isPluginContainer ? advisories : findings;
 
+    // Read under a guard, exactly like scanSkillPrivileges: an unreadable SKILL.md is another
+    // check's business, and this scanner's contract is to REPORT findings, never to throw out of
+    // the whole sweep over one bad file.
+    let frontmatterIssue: SkillFrontmatterIssue | null = null;
+    if (registers) {
+      try {
+        frontmatterIssue = findSkillFrontmatterIssue(readFileSync(join(dir, 'SKILL.md'), 'utf8'));
+      } catch {
+        frontmatterIssue = null;
+      }
+    }
+    if (frontmatterIssue) {
+      findings.push({
+        dir: name,
+        kind: frontmatterIssue,
+        detail: frontmatterIssue === 'missing-frontmatter-fence'
+          ? 'SKILL.md has no opening frontmatter fence — measured absent from the registry without it'
+          : 'SKILL.md has no non-empty frontmatter description — measured absent from the registry without one',
+      });
+    }
+
     // Права проверяются у КАЖДОГО навыка с читаемым SKILL.md, включая одно-навыковый плагин: щедрая
     // выдача не становится безопаснее оттого, что навык лежит в контейнере.
     if (registers) scanSkillPrivileges(dir, name, findings, advisories);
 
-    if (registers && !isPluginContainer) {
-      registrable.push(name);
-    } else if (registers && isPluginContainer) {
+    if (registers) {
+      if (!isPluginContainer && !frontmatterIssue) {
+        registrable.push(name);
+      }
       // A single-skill plugin: it has a depth-1 SKILL.md AND a manifest, so it registers NAMESPACED.
       // Expecting the bare directory name here was a false FAIL (QE5 #2); the container check below
-      // accepts either form.
+      // accepts either form. A frontmatter finding likewise keeps the bare name out of registrable.
     } else {
       // A dir with no markdown was never meant to be a skill — advisory, not a failure (QE5 #7).
       const intended = looksLikeSkillDir(dir);

package/src/store-guard-prune.ts

@@ -0,0 +1,81 @@
+import { sep } from 'node:path';
+
+export type StoreGuardPruneBucket = 'stale-temp' | 'live' | 'gone-outside-tmp' | 'unreadable';
+
+export interface StoreGuardPruneEntry {
+  readonly file: string;
+  readonly project: string | null;
+  readonly bytes: number;
+  readonly bucket: StoreGuardPruneBucket;
+}
+
+export interface StoreGuardPrunePlan {
+  readonly entries: readonly StoreGuardPruneEntry[];
+  readonly counts: Readonly<Record<StoreGuardPruneBucket, number>>;
+  readonly reclaimableBytes: number;
+}
+
+export interface StoreGuardPruneDeps {
+  readonly exists: (path: string) => boolean;
+  readonly tmpDirs: readonly string[];
+}
+
+/**
+ * A temp-root candidate that authorizes deletion must be a REAL directory path, never the filesystem
+ * root or an empty string. MEASURED 2026-09-20 (cross-family review, P1): `TMPDIR=/` makes
+ * `os.tmpdir()` return the single character `"/"` (node strips a trailing slash only when the path is
+ * longer than one character), and `isUnder` then matches EVERY absolute path — so every
+ * `gone-outside-tmp` mark, which FR-3 exists to protect, would be classified `stale-temp` and deleted.
+ * A degenerate candidate authorizes nothing and is dropped here, in the pure half, where it is testable.
+ */
+function isUsableTmpDir(tmpDir: string): boolean {
+  const trimmed = tmpDir.trim();
+  return trimmed.length > 1 && trimmed !== sep && trimmed !== '/';
+}
+
+function isUnder(project: string, tmpDir: string): boolean {
+  const prefix = tmpDir.endsWith(sep) ? tmpDir : `${tmpDir}${sep}`;
+  return project === tmpDir || project.startsWith(prefix);
+}
+
+export function planStoreGuardPrune(
+  input: readonly { readonly file: string; readonly bytes: number; readonly text: string }[],
+  deps: StoreGuardPruneDeps,
+): StoreGuardPrunePlan {
+  const counts: Record<StoreGuardPruneBucket, number> = {
+    'stale-temp': 0,
+    live: 0,
+    'gone-outside-tmp': 0,
+    unreadable: 0,
+  };
+  let reclaimableBytes = 0;
+
+  const entries = input.map(({ file, bytes, text }): StoreGuardPruneEntry => {
+    let value: unknown;
+    try {
+      value = JSON.parse(text);
+    } catch {
+      counts.unreadable += 1;
+      return { file, project: null, bytes, bucket: 'unreadable' };
+    }
+
+    if (typeof value !== 'object' || value === null
+      || typeof (value as { project?: unknown }).project !== 'string'
+      || (value as { project: string }).project.length === 0) {
+      counts.unreadable += 1;
+      return { file, project: null, bytes, bucket: 'unreadable' };
+    }
+
+    const project = (value as { project: string }).project;
+    const bucket: StoreGuardPruneBucket = deps.exists(project)
+      ? 'live'
+      : deps.tmpDirs.filter(isUsableTmpDir).some((tmpDir) => isUnder(project, tmpDir))
+        ? 'stale-temp'
+        : 'gone-outside-tmp';
+    counts[bucket] += 1;
+    if (bucket === 'stale-temp') reclaimableBytes += bytes;
+    return { file, project, bytes, bucket };
+  });
+
+  return { entries, counts, reclaimableBytes };
+}

package/src/sweep-failure-classify.ts

@@ -0,0 +1,88 @@
+/**
+ * Различитель красных обхода: ЛОГИЧЕСКИЙ отказ против отказа ПОД НАГРУЗКОЙ.
+ *
+ * ЗАЧЕМ. Запись 9e48a975 установила класс: набор harness-core детерминирован В ОДИНОЧКУ и
+ * краснеет ТОЛЬКО под параллельной нагрузкой (пять последовательных прогонов — ноль красных;
+ * те же тесты под фоновым вторым набором — красные поодиночке и в разных сочетаниях).
+ * Подпись класса: тест (а) читает собранный `dist`, (б) порождает процессы, (в) несёт явный
+ * таймаут, близкий к измеренному времени.
+ *
+ * ИЗМЕРЕНО 2026-09-19, новый экземпляр того же класса: `scout` прошёл в одном обходе и упал в
+ * следующем через 17 минут — `deep-analyzer.test.ts`, `Test timed out in 5000ms`, 192 из 193
+ * зелёные; тот же файл в одиночку 5 из 5. Единственное различие между прогонами — загрузка
+ * машины (подкачка 2342 → 2671 МБ).
+ *
+ * Класс диагностирован, но МЕХАНИЗМА не имел: каждый экземпляр стоил ручного разбора. Этот
+ * модуль — чистая половина механизма: он извлекает из журнала обхода ИМЕНА упавших файлов и
+ * классифицирует результат ПЕРЕПРОГОНА В ОДИНОЧКУ. Запуск живёт в скрипте, здесь его нет.
+ *
+ * ТРЁХЗНАЧНОСТЬ ОБЯЗАТЕЛЬНА. Перепрогон, который не удалось выполнить, — это НЕ «прошёл»;
+ * прибор, который не смог посмотреть, не имеет права на вердикт.
+ */
+
+/** Вердикт перепрогона одного файла в одиночку. */
+export type RerunVerdict = 'does-not-reproduce-alone' | 'reproduces-alone' | 'inconclusive';
+
+/**
+ * Имена упавших тестовых файлов из журнала набора. Понимает ОБА формата, которые даёт обход:
+ *   vitest    ` FAIL  test/x.test.ts > describe > it`
+ *   node:test `    location: '/abs/.../test/x.test.mjs:95:1'`
+ *
+ * Пути приводятся к виду, относительному каталогу пакета, потому что перепрогон запускается
+ * из него. Порядок сохраняется, дубликаты убираются: один файл перепрогоняется один раз.
+ */
+export function parseFailedTestFiles(logText: string, packageDir?: string): string[] {
+  const out: string[] = [];
+  const seen = new Set<string>();
+  const add = (raw: string): void => {
+    let p = raw.trim();
+    if (packageDir !== undefined && p.startsWith(packageDir)) {
+      p = p.slice(packageDir.length).replace(/^\/+/, '');
+    }
+    // Абсолютный путь к ЧУЖОМУ пакету перепрогонять нельзя: он не относителен нашему каталогу.
+    if (p.startsWith('/')) return;
+    if (p === '' || seen.has(p)) return;
+    seen.add(p);
+    out.push(p);
+  };
+  for (const line of logText.split('\n')) {
+    const vitest = /^\s*FAIL\s+(?:\|[^|]*\|\s*)?(\S+\.(?:test|spec)\.[cm]?[jt]s)\b/.exec(line);
+    if (vitest?.[1] !== undefined) { add(vitest[1]); continue; }
+    const node = /location:\s*'([^']+\.(?:test|spec)\.[cm]?[jt]s):\d+/.exec(line);
+    if (node?.[1] !== undefined) { add(node[1]); }
+  }
+  return out;
+}
+
+/**
+ * Вердикт по исходу перепрогона.
+ *
+ * @param sweepFailed упал ли файл в обходе (иначе классифицировать нечего)
+ * @param rerun       результат одиночного прогона, или null если запустить не удалось
+ */
+export function classifyRerun(
+  sweepFailed: boolean,
+  rerun: { readonly exitCode: number; readonly ranAnyTest: boolean } | null,
+): RerunVerdict {
+  if (!sweepFailed) return 'inconclusive';
+  if (rerun === null) return 'inconclusive';
+  // «Ни одного теста не запустилось» — это не зелёный прогон, а несостоявшаяся проба: так
+  // выглядит и опечатка в пути, и набор, который не грузится. Читать это как «прошёл» значит
+  // объявить файл нагрузочно-зависимым на основании того, что его никто не проверил.
+  if (!rerun.ranAnyTest) return 'inconclusive';
+  return rerun.exitCode === 0 ? 'does-not-reproduce-alone' : 'reproduces-alone';
+}
+
+/** Человеческая расшифровка вердикта — одна строка, называющая, что делать дальше. */
+export function describeVerdict(verdict: RerunVerdict): string {
+  if (verdict === 'does-not-reproduce-alone') {
+    // НЕ «зависит от нагрузки»: у зелёного одиночного прогона есть ДВЕ причины, и различить их
+    // перепрогоном нельзя — нагрузка обхода ЛИБО починка, внесённая уже после него. Называть
+    // одну из двух значило бы выдать догадку за измерение.
+    return 'в одиночку ЗЕЛЁНЫЙ — либо отказ зависел от нагрузки обхода, либо починка легла после него; перепрогон эти две причины не различает';
+  }
+  if (verdict === 'reproduces-alone') {
+    return 'в одиночку ТОЖЕ красный — настоящий дефект, нагрузка ни при чём';
+  }
+  return 'НЕ УСТАНОВЛЕНО — перепрогон не состоялся; это не «прошёл»';
+}

package/src/workflow-run-dispatch.ts

@@ -11,6 +11,7 @@
  * a convention whose reason is lost is the next thing somebody "cleans up".
  */
 
+import { CODEX_EXEC_PROMPT_CEILING_CHARS } from './feature-adr-routing.js';
 import type { Deliverable } from './loop-plan.js';
 import { claudeProbeArgs, claudeReviewArgs, extractClaudeResult, interpretClaudeProbe, type BridgeFamily } from './qe-bridge.js';
 import type { WfRunReason } from './workflow-run.js';
@@ -149,13 +150,24 @@ export const CODEX_SCOPING_PREFIX =
   'Answer directly from this prompt text alone; no commands, no files, no tools.';
 
 /**
- * The REAL prompt ceiling for `codex exec`.
+ * The REAL prompt ceiling for `codex exec` — RE-EXPORTED, never re-declared.
  *
  * The folk value 1200 is refuted history: it came from an era when the prompt travelled through a
  * fire-and-forget wrapper. Over-ceiling ⇒ a LOUD `prompt-over-ceiling`, never truncation — a
  * truncated prompt produces a confident answer to a question nobody asked.
+ *
+ * ONE NUMBER, ONE DEFINITION. Until 2026-09-20 this module declared its own `= 24_000` beside the
+ * one in `feature-adr-routing.ts`, and NOTHING compared them: no test imported both, so the two
+ * could diverge in silence and `codexExecPlan` would route to Claude at a different threshold than
+ * `makeCodexExecDispatcher` rejects at. Measured: `feature-adr-codex-dispatch.test.ts` asserts only
+ * `> 4000`, and the mirror guard in `codex-scoped-review.test.ts` ties routing.ts to the four
+ * workflow copies but knows nothing about this file.
+ *
+ * The definition lives in `feature-adr-routing.ts` and not here because THAT module is lifted
+ * verbatim into the workflow sandbox by `scripts/gen-loop-blobs.mjs` and therefore may not import
+ * anything. The dependency can only point this way.
  */
-export const CODEX_EXEC_PROMPT_CEILING_CHARS = 24_000;
+export { CODEX_EXEC_PROMPT_CEILING_CHARS };
 
 /**
  * argv for one codex dispatch. The prompt travels as ONE argv element (no shell, no quoting), and