harness-everything 0.38.0 → 0.40.0

package/plugins/harness-everything/hooks/scripts/lib/doc-reconciliation-producer.js

@@ -0,0 +1,206 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+const { _internals: U } = require('./doc-reconciliation-core');
+const { scanWorkspaceFiles } = U.runtimeModule('doc-lifecycle.js');
+const { resolveDocsConfigCaptured } = U.runtimeModule('project-docs-resolver.js');
+const { deriveDocFacts, deriveDocObligations } = U.runtimeModule('doc-obligations.js');
+
+const MAX_FILES = 10000;
+const MAX_BYTES = 64 * 1024 * 1024;
+const POSIX_MODES = process.platform !== 'win32';
+function fail(code) { throw new Error(code); }
+// The JS realpath keeps Windows 8.3 spellings (RUNNER~1) while Git reports the long name, so
+// directory identity uses native resolution and is case-insensitive on Windows (as workflow-isolation).
+function canonicalPath(value) { return fs.realpathSync.native(path.resolve(value)); }
+function samePath(a, b) {
+  const left = canonicalPath(a);
+  const right = canonicalPath(b);
+  return process.platform === 'win32' ? left.toLowerCase() === right.toLowerCase() : left === right;
+}
+function git(root, args, options = {}) {
+  const env = { ...process.env };
+  for (const key of Object.keys(env)) if (key.startsWith('GIT_')) delete env[key];
+  try {
+    return execFileSync('git', ['-C', root, ...args], { env, timeout: 10000, maxBuffer: MAX_BYTES, stdio: ['pipe', 'pipe', 'pipe'], ...options });
+  } catch { fail('baseline-unavailable'); }
+}
+function fileRecord(relative, mode, storedBytes, presence = 'present') {
+  return { path: relative, presence, type: presence === 'present' ? 'file' : '', mode,
+    storedBytes: Buffer.from(storedBytes), digest: U.sha(storedBytes) };
+}
+function validatePaths(records) {
+  const names = new Set();
+  for (const item of records) {
+    const name = item.path;
+    if (!name || name.includes('\\') || name.includes('\ufffd') || name.startsWith('/')
+      || name.split('/').some(segment => !segment || segment === '..' || segment === '.')) fail('inventory-unsupported');
+    const folded = name.normalize('NFC').toLowerCase();
+    if (names.has(folded)) fail('inventory-unsupported');
+    names.add(folded);
+  }
+}
+function captureBaseline(root, pin) {
+  if (!U.record(pin) || !/^[a-f0-9]{40,64}$/.test(pin.commit || '') || !U.text(pin.root)
+    || !samePath(pin.root, root)) fail('baseline-unavailable');
+  const actualRoot = git(root, ['rev-parse', '--show-toplevel']).toString('utf8').trim();
+  if (!samePath(actualRoot, root)) fail('baseline-unavailable');
+  const commit = git(root, ['rev-parse', '--verify', '--end-of-options', `${pin.commit}^{commit}`]).toString('utf8').trim();
+  const treeRef = git(root, ['rev-parse', '--verify', '--end-of-options', `${commit}^{tree}`]).toString('utf8').trim();
+  const entries = git(root, ['ls-tree', '-r', '-z', '--full-tree', treeRef]).toString('utf8').split('\0').filter(Boolean);
+  if (entries.length > MAX_FILES) fail('inventory-unsupported');
+  const records = [];
+  let total = 0;
+  for (const entry of entries) {
+    const match = entry.match(/^(100644|100755) blob ([a-f0-9]{40,64})\t(.+)$/s);
+    if (!match) fail('inventory-unsupported');
+    const storedBytes = git(root, ['cat-file', 'blob', match[2]]);
+    total += storedBytes.length;
+    if (total > MAX_BYTES) fail('inventory-unsupported');
+    records.push(fileRecord(match[3], match[1], storedBytes));
+  }
+  validatePaths(records);
+  return { commit, treeRef, records };
+}
+function captureCandidate(root, baseline) {
+  const raw = [];
+  let total = 0;
+  let visited = 0;
+  function walk(dir, prefix) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true }).sort((a, b) => U.compare(a.name, b.name));
+    for (const entry of entries) {
+      if (!prefix && entry.name === '.git') continue;
+      if (++visited > MAX_FILES) fail('inventory-unsupported');
+      const relative = prefix ? `${prefix}/${entry.name}` : entry.name;
+      const absolute = path.join(dir, entry.name);
+      const stat = fs.lstatSync(absolute);
+      if (stat.isDirectory()) {
+        // Windows stats carry no POSIX permission bits (directories report 0o666); an unreadable
+        // path there makes readdir/readFile throw instead.
+        if (POSIX_MODES && (!(stat.mode & 0o444) || !(stat.mode & 0o111))) fail('inventory-incomplete');
+        walk(absolute, relative);
+        continue;
+      }
+      if (!stat.isFile()) fail('inventory-unsupported');
+      // Unreadable files must remain unavailable even when the process has elevated read access.
+      if (POSIX_MODES && !(stat.mode & 0o444)) fail('inventory-incomplete');
+      const bytes = fs.readFileSync(absolute);
+      total += bytes.length;
+      if (raw.length >= MAX_FILES || total > MAX_BYTES) fail('inventory-unsupported');
+      raw.push({ path: relative, raw: bytes, mode: stat.mode & 0o111 ? '100755' : '100644' });
+    }
+  }
+  walk(root, '');
+  validatePaths(raw);
+  // Refuse filters/encodings that the existing stored-byte reader does not model.
+  if (raw.length) {
+    const attrs = git(root, ['check-attr', '-z', '--stdin', 'filter', 'working-tree-encoding', 'ident'], { input: Buffer.from(raw.map(r => r.path).join('\0') + '\0') }).toString('utf8').split('\0');
+    for (let i = 0; i + 2 < attrs.length; i += 3) {
+      if (!['unspecified', 'unset'].includes(attrs[i + 2])) fail('inventory-unsupported');
+    }
+  }
+  // Lifecycle owns text/eol/autocrlf conversion. A completeness walk above detects its skipped paths.
+  const stored = new Map(scanWorkspaceFiles(root).map(item => [item.path, item.bytes]));
+  const records = raw.map(item => {
+    const converted = stored.get(item.path);
+    if (!converted) fail('inventory-unsupported');
+    // An unexplained non-CR difference means the two readers observed different bytes.
+    if (!item.raw.includes(13) && !item.raw.equals(converted)) fail('snapshot-changed');
+    return fileRecord(item.path, item.mode, converted);
+  });
+  for (const item of baseline.records) if (!stored.has(item.path)) records.push(fileRecord(item.path, '', Buffer.alloc(0), 'deleted'));
+  return records;
+}
+const progressKeys = new Set(['status', 'state', 'evidence', 'loaded', 'loadedAt', 'updatedAt', 'createdAt', 'completedAt', 'timestamp', 'report', 'reports']);
+// Progress fields are excluded only at their defined record locations (top-level task/workflow, each
+// requirement, each requirement binding). Nested objects keep every key: a nested `status`/`state` there
+// is semantic and must change taskScopeDigest (PR #353 review P2).
+function withoutProgress(value, keys = progressKeys) {
+  if (!U.record(value)) return U.clone(value);
+  return Object.fromEntries(Object.keys(value).filter(key => !keys.has(key)).map(key => [key, U.clone(value[key])]));
+}
+// A binding's `report`/`reports` object configures the binding; only its load/status records are progress.
+const bindingProgressKeys = new Set([...progressKeys].filter(key => key !== 'report' && key !== 'reports'));
+function taskSemantics(task) {
+  const semantic = withoutProgress(task);
+  if (Array.isArray(task?.requirements)) {
+    semantic.requirements = task.requirements.map(requirement => {
+      const item = withoutProgress(requirement);
+      if (U.record(requirement) && Array.isArray(requirement.bindings)) item.bindings = requirement.bindings.map(binding => withoutProgress(binding, bindingProgressKeys));
+      return item;
+    });
+  }
+  return semantic;
+}
+function contextFor(input, provider) {
+  if (!provider || typeof provider.resolveContext !== 'function') fail('origin-unavailable');
+  const response = provider.resolveContext({ workspaceRoot: input.workspaceRoot, workflowId: input.workflow.workflowId, sessionId: input.workflow.sessionId });
+  if (response?.status !== 'accepted') fail(response?.status === 'rejected' ? 'origin-untrusted' : 'origin-unavailable');
+  const c = response.context;
+  if (!U.record(c) || !U.text(response.originRef) || !U.text(c.workspaceId) || !U.text(c.baselineReference)
+    || !U.text(c.principals?.author) || !Array.isArray(c.principals?.executors) || !c.principals.executors.every(U.text)) fail('origin-untrusted');
+  for (const key of ['sessionId', 'workflowId', 'workflowRevision']) if (c[key] !== input.workflow[key]) fail('identity-mismatch');
+  if (c.taskId !== input.task.taskId || U.stable(c.activeHost) !== U.stable(input.activeHost)) fail('identity-mismatch');
+  if (c.workspaceRoot && !samePath(c.workspaceRoot, input.workspaceRoot)) fail('identity-mismatch');
+  // The provider must bind the concrete workflow-start pin; a bare reference cannot authorize a
+  // re-anchored baseline (PR #353 review P1).
+  if (!U.record(c.baseline) || !U.text(c.baseline.commit) || !U.text(c.baseline.root)
+    || !U.record(input.baseline) || c.baseline.commit !== input.baseline.commit || !samePath(c.baseline.root, input.baseline.root)) fail('baseline-unavailable');
+  const root = canonicalPath(input.workspaceRoot);
+  return U.clone({ ...c, baseline: { ...c.baseline, root }, workspaceRoot: root, originRef: response.originRef });
+}
+function filesOf(records, config) {
+  // The inventory is whole-project: binary records keep their stored bytes in the identity framing and are
+  // omitted from semantic derivation unless the derive contract can observe them (PR #353 review P2).
+  return U.deriveFiles(records, config);
+}
+function produceDocSnapshot(input, dependencies = {}) {
+  const originProvider = dependencies?.originProvider;
+  try {
+    if (!U.record(input) || !U.text(input.workspaceRoot) || !U.record(input.workflow) || !U.record(input.task)
+      || !U.text(input.task.taskId) || !Array.isArray(input.task.requirements) || !U.record(input.scope)
+      || !Number.isInteger(input.workflow.workflowRevision) || input.workflow.workflowRevision < 0) fail('invalid-input');
+    if ((input.prdRoot === undefined ? 'docs/prd/' : input.prdRoot) !== 'docs/prd/' || (input.scope.prdRoot && input.scope.prdRoot !== 'docs/prd/')) fail('unsupported-prd-root');
+    const root = canonicalPath(input.workspaceRoot);
+    const detached = U.clone(input);
+    const originContext = contextFor(detached, originProvider);
+    const baseline = captureBaseline(root, detached.baseline);
+    const config = resolveDocsConfigCaptured(root, { activeHost: detached.activeHost });
+    if (!['project', 'host'].includes(config.resolution.status) || config.capture.sources.some(s => s.presence === 'unreadable')) fail('config-unavailable');
+    const coverage = { kind: 'whole-project', excluded: ['.git'], scope: U.clone(detached.scope) };
+    const candidate = { records: captureCandidate(root, baseline), coverage };
+    // Same owned config bytes must be the bytes covered by the working-tree capture.
+    for (const source of config.capture.sources) {
+      const file = candidate.records.find(r => r.path === source.path && r.presence === 'present');
+      if (source.presence === 'present' ? !file || !U.bytes(source.bytes).equals(file.storedBytes) : Boolean(file)) fail('snapshot-changed');
+    }
+    config.digest = U.configDigest(config);
+    baseline.digest = U.snapshotDigest('baseline', baseline, coverage, baseline.records);
+    candidate.digest = U.snapshotDigest('candidate', baseline, coverage, candidate.records);
+    const planIdentity = { task: taskSemantics(detached.task), scope: U.clone(detached.scope), workflow: withoutProgress(detached.workflow), coverage, configDigest: config.digest, prdRoot: 'docs/prd/' };
+    const identity = { workspaceId: originContext.workspaceId, sessionId: originContext.sessionId, workflowId: originContext.workflowId,
+      workflowRevision: originContext.workflowRevision, taskId: originContext.taskId, taskScopeDigest: U.structuredDigest('doc-task-scope-v1', planIdentity),
+      baselineDigest: baseline.digest, candidateDigest: candidate.digest, configDigest: config.digest, prdRoot: 'docs/prd/' };
+    const derived = deriveDocFacts({ base: { files: filesOf(baseline.records, config.resolution.config) },
+      candidate: { files: filesOf(candidate.records, config.resolution.config) }, config: config.resolution.config });
+    if (!derived.facts?.inputKnown) fail('inventory-incomplete');
+    const facts = derived.facts;
+    const obligations = deriveDocObligations(facts);
+    const derivationReasons = Object.fromEntries(obligations.map(o => [o.id, { applicability: o.applicability, reason: `captured facts derive ${o.capability}: ${o.applicability}`, factRefs: ['facts', ...(o.scope?.paths || []).map(p => `inventory:${p}`)] }]));
+    const again = captureCandidate(root, baseline);
+    const configAgain = resolveDocsConfigCaptured(root, { activeHost: detached.activeHost });
+    let finalContext;
+    try { finalContext = contextFor(detached, originProvider); }
+    catch { fail('snapshot-changed'); }
+    if (U.snapshotDigest('candidate', baseline, coverage, again) !== candidate.digest || U.configDigest(configAgain) !== config.digest
+      || U.stable(originContext) !== U.stable(finalContext)) fail('snapshot-changed');
+    return { state: 'ready', snapshot: { identity, baseline, candidate, config, originContext, taskSemantics: planIdentity, facts, obligations, derivationReasons }, diagnostics: [] };
+  } catch (error) {
+    const codes = ['invalid-input', 'baseline-unavailable', 'inventory-incomplete', 'inventory-unsupported', 'snapshot-changed', 'config-unavailable', 'unsupported-prd-root', 'identity-mismatch', 'origin-unavailable', 'origin-untrusted'];
+    const code = codes.includes(error.message) ? error.message : 'inventory-unsupported';
+    return { state: 'unavailable', snapshot: null, diagnostics: [U.diagnostic(code)] };
+  }
+}
+module.exports = { produceDocSnapshot };

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.38.0",
+  "version": "0.40.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/code-review/SKILL.md

@@ -4,7 +4,7 @@ description: "Independently review a PR, diff or finished implementation for cor
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.33.0
+  version: 0.40.0
 ---
 
 # Code Review
@@ -30,10 +30,10 @@ Independently review completed changes for correctness, contract violations, and
 
 ## Workflow
 
-1. Pin repository, contract, base/head, changed scope, and CI state; inspect relevant callers and consumers.
+1. Pin repository, verbatim acceptance contract, base/head, changed scope, and CI state; inspect relevant callers and consumers.
 2. Independently trace behavior and test applicable counterexamples. Separate severity from safety conditions.
 3. Report only supported findings with evidence tier, smallest correction, regression, and positive control. Use `<this-skill-dir>/templates/finding.template.md`.
-4. On re-review, disposition every prior finding at the new HEAD, then inspect for regressions.
+4. On re-review, disposition every prior finding at the new HEAD, re-trace the acceptance path, then inspect for regressions.
 5. Keep review read-only unless explicitly authorized. Do not claim “bug-free.”
 
 In the interim, bind explicitly on an existing review step: `{"stepType":"review","optionalBindings":["code-review"]}`.

package/plugins/harness-everything/skills/code-review/references/review-playbook.md

@@ -5,6 +5,7 @@ Use this checklist for the applicable risks; do not force irrelevant categories.
 ## Establish scope and evidence
 
 - [ ] Pin repository, PR, base/head SHA, user requirement or PRD/ADR, changed files, relevant callers/callees, and current CI state. Avoid unrelated checkout areas.
+- [ ] Quote the acceptance clauses and owner bounds verbatim, with their source. Keep them apart from the chosen implementation (designs, existing tests) and the evidence: a design choice or a test expectation is not a requirement.
 - [ ] Make an independent pass. Treat author explanations and tests as leads, not proof; derive expected behavior from contracts and source.
 - [ ] Label evidence honestly: **executed/reproduced** (command, result, environment, SHA); **source-traced** (concrete path and preconditions); **inconclusive** (missing facts or ambiguous semantics; do not present as a proven blocker).
 - [ ] Inventory user-facing entry points and configuration handoffs (CLI flags, cwd, path spellings, config loading). Exercise them end-to-end, not only the recently edited internals.
@@ -24,10 +25,13 @@ Use this checklist for the applicable risks; do not force irrelevant categories.
 - [ ] When output text changes, compare the intended changed lines with literal templates; do not exclude changed lines from assertions.
 - [ ] Dedupe findings. Use P1 for severe merge blockers, P2 for meaningful correctness/contract defects, P3 for low-risk issues; avoid speculation.
 - [ ] For each finding, include exact path:line or diff anchor at HEAD SHA, trigger, observed behavior, violated contract and impact, evidence tier, smallest fix, negative regression, positive control, and disposition.
+- [ ] Name the exact acceptance clause each finding violates, with a witness (starting state, input, expected result, actual result) and the trust assumption. A finding that maps to no clause gets scope `unresolved` for the owner; do not drop it, and do not present it as a blocker. Record severity and scope separately.
 
 ## Re-review and conclude
 
 - [ ] Pin the new HEAD. Disposition every prior finding separately: resolved, still open, superseded, or inconclusive. Then inspect fix-induced side effects and new changes.
+- [ ] Re-trace one normal acceptance path end to end plus the consumers the fix affects, even when the request names only the last fix. A diff-only re-review misses unchanged sites that make the same decision.
+- [ ] If this round and the previous one each found new defects in the same decision class, say so and recommend `zoom-out` (site inventory against the violated clause) before another point fix.
 - [ ] Stay read-only unless the user/workflow explicitly authorizes action. Do not edit, comment, label, or merge on review authority alone.
 - [ ] Summarize scope/SHA, CI, covered and unexamined risks, fixed/open/new counts, and evidence-grounded merge recommendation. “No actionable findings in examined scope” does not mean “bug-free.” Distinguish repository tests from live-host evidence.
 

package/plugins/harness-everything/skills/code-review/templates/finding.template.md

@@ -5,6 +5,8 @@
 - Repository / PR:
 - Base SHA → reviewed HEAD SHA:
 - Requirement / PRD / ADR:
+- Scope anchor (acceptance clauses and owner bounds, verbatim, with source):
+- Prior rounds (findings per decision class, for re-review):
 - Changed files and relevant callers/consumers:
 - CI state and commands observed:
 - Counterexample categories covered:
@@ -17,6 +19,9 @@
 - **Location:** `<path>:<line or diff anchor> @ <HEAD SHA>`
 - **Trigger:** <minimal input, state transition, or interleaving>
 - **Behavior → impact:** <observed or source-traced behavior and violated contract>
+- **Violates:** <exact acceptance clause from the scope anchor>
+- **Witness:** <starting state → input → expected result → actual result; trust assumption>
+- **Scope:** <in-scope | out-of-scope (known limit) | unresolved (owner decision)>
 - **Evidence tier:** <executed/reproduced | source-traced | inconclusive; include exact command/result or preconditions>
 - **Minimal correction:** <smallest feasible fix>
 - **Regression:** Negative case: <case that fails before fix>; positive control: <valid behavior that remains valid>
@@ -30,4 +35,5 @@
 - **CI evidence:**
 - **Covered / unexamined risks:**
 - **Findings:** <fixed / open / new counts on re-review>
+- **Convergence:** <new findings per decision class this round vs the previous round; recommend `zoom-out` when a class keeps producing new findings>
 - **Conclusion:** <merge recommendation grounded in evidence; “no actionable findings in examined scope” is not a claim of bug-free code>

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.38.0
+  version: 0.40.0
 ---
 
 # Harness Everything

package/plugins/harness-everything/skills/harness-everything/scripts/project-docs-resolver.js

@@ -122,15 +122,17 @@ function readHostProjectDocsConfigs(workspaceRoot) {
   return manifests;
 }
 
-function inspectHostProjectDocs(workspaceRoot) {
+function inspectHostProjectDocs(workspaceRoot, readSource = null) {
   const entries = [];
   for (const home of PLATFORM_HOMES) {
     const file = path.join(workspaceRoot, home, 'harness-everything', 'manifest.json');
-    if (!fs.existsSync(file)) continue;
+    const captured = readSource ? readSource(file) : null;
+    if (captured ? captured.presence === 'absent' : !fs.existsSync(file)) continue;
     const entry = { file, home, projectDocs: null, warnings: [], diagnostics: [], hasProjectDocs: false };
     let manifest;
     try {
-      manifest = JSON.parse(fs.readFileSync(file, 'utf8'));
+      if (captured && captured.presence !== 'present') throw new Error('unreadable source');
+      manifest = JSON.parse(captured ? captured.bytes.toString('utf8') : fs.readFileSync(file, 'utf8'));
     } catch {
       entry.diagnostics.push({
         code: 'invalid-host-config',
@@ -349,16 +351,18 @@ function configSource(workspaceRoot, file) {
   return relativePath(workspaceRoot, file);
 }
 
-function resolveDocsConfig(workspaceRoot, options = {}) {
+function resolveDocsConfigSelection(workspaceRoot, options, readSource) {
   const resolvedRoot = workspaceRoot || getWorkspaceRoot();
   if (!resolvedRoot) throw new Error('cannot resolve project docs outside a git workspace; pass a workspace root explicitly');
   const root = path.resolve(resolvedRoot);
   const projectFile = projectDocsConfigPath(root);
-  if (fs.existsSync(projectFile)) {
+  const capturedProject = readSource(projectFile);
+  if (capturedProject.presence !== 'absent') {
     const source = configSource(root, projectFile);
     let config;
     try {
-      config = JSON.parse(fs.readFileSync(projectFile, 'utf8'));
+      if (capturedProject.presence !== 'present') throw new Error('unreadable source');
+      config = JSON.parse(capturedProject.bytes.toString('utf8'));
     } catch {
       return {
         status: 'invalid',
@@ -376,7 +380,7 @@ function resolveDocsConfig(workspaceRoot, options = {}) {
       return { status: 'invalid', sources: [source], config: null, warnings, diagnostics };
     }
 
-    const hosts = inspectHostProjectDocs(root);
+    const hosts = inspectHostProjectDocs(root, readSource);
     const hostDiagnostics = hosts.flatMap(entry => entry.diagnostics);
     const hostWarnings = hosts.flatMap(entry => entry.warnings);
     const validHosts = hosts.filter(entry => entry.projectDocs);
@@ -393,7 +397,7 @@ function resolveDocsConfig(workspaceRoot, options = {}) {
     return { status: 'project', sources: [source], config, warnings: [...warnings, ...hostWarnings], diagnostics: [...diagnostics, ...hostDiagnostics] };
   }
 
-  const hosts = inspectHostProjectDocs(root);
+  const hosts = inspectHostProjectDocs(root, readSource);
   const hostDiagnostics = hosts.flatMap(entry => entry.diagnostics);
   const hostWarnings = hosts.flatMap(entry => entry.warnings);
   const activeHome = normalizedHostHome(options.activeHost);
@@ -457,6 +461,35 @@ function resolveDocsConfig(workspaceRoot, options = {}) {
   };
 }
 
+function resolveDocsConfigCaptured(workspaceRoot, options = {}) {
+  const resolvedRoot = workspaceRoot || getWorkspaceRoot();
+  if (!resolvedRoot) throw new Error('cannot resolve project docs outside a git workspace; pass a workspace root explicitly');
+  const root = path.resolve(resolvedRoot);
+  const records = new Map();
+  const readSource = file => {
+    const key = configSource(root, file);
+    if (!records.has(key)) {
+      let bytes = Buffer.alloc(0);
+      let presence = 'present';
+      try { bytes = Buffer.from(fs.readFileSync(file)); }
+      catch (error) { presence = error.code === 'ENOENT' ? 'absent' : 'unreadable'; }
+      records.set(key, { path: key, presence, bytes, digest: crypto.createHash('sha256').update(bytes).digest('hex') });
+    }
+    return records.get(key);
+  };
+  const resolution = resolveDocsConfigSelection(root, options, readSource);
+  let activeHost = null;
+  try { activeHost = JSON.parse(JSON.stringify(options.activeHost)); } catch { /* no serializable host context */ }
+  const sources = [...records.values()].sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+  const selectionInputs = sources.map(({ path: sourcePath, presence }) => ({ path: sourcePath, presence }));
+  selectionInputs.push({ status: resolution.status, sources: [...resolution.sources], activeHost, config: resolution.config });
+  return { resolution, capture: { activeHost, sources, selectionInputs } };
+}
+
+function resolveDocsConfig(workspaceRoot, options = {}) {
+  return resolveDocsConfigCaptured(workspaceRoot, options).resolution;
+}
+
 function cleanConfiguredPath(value) {
   if (typeof value !== 'string') return null;
   const trimmed = value.trim();
@@ -769,6 +802,7 @@ module.exports = {
   getRepoManifestHomes,
   readProjectDocs,
   resolveDocsConfig,
+  resolveDocsConfigCaptured,
   validateDocsConfig,
   normalizeHostProjectDocs,
   parseContextMap,

package/plugins/harness-everything/skills/harness-everything/scripts/routing-keywords.json

@@ -598,6 +598,10 @@
         "cease fire",
         "rule-of-3",
         "rule of 3",
+        "every round finds a new edge case",
+        "every review round finds a new edge case",
+        "又陷入反覆修正",
+        "反覆測試地獄",
         "卡住",
         "失敗",
         "重複",

package/plugins/harness-everything/skills/multi-agent-workspace/SKILL.md

@@ -4,7 +4,7 @@ description: "Scaffold a verified multi-agent workspace and select bounded speci
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.36.3
+  version: 0.39.0
 ---
 
 # Multi-Agent Workspace

package/plugins/harness-everything/skills/multi-agent-workspace/scripts/project-docs-resolver.js

@@ -122,15 +122,17 @@ function readHostProjectDocsConfigs(workspaceRoot) {
   return manifests;
 }
 
-function inspectHostProjectDocs(workspaceRoot) {
+function inspectHostProjectDocs(workspaceRoot, readSource = null) {
   const entries = [];
   for (const home of PLATFORM_HOMES) {
     const file = path.join(workspaceRoot, home, 'harness-everything', 'manifest.json');
-    if (!fs.existsSync(file)) continue;
+    const captured = readSource ? readSource(file) : null;
+    if (captured ? captured.presence === 'absent' : !fs.existsSync(file)) continue;
     const entry = { file, home, projectDocs: null, warnings: [], diagnostics: [], hasProjectDocs: false };
     let manifest;
     try {
-      manifest = JSON.parse(fs.readFileSync(file, 'utf8'));
+      if (captured && captured.presence !== 'present') throw new Error('unreadable source');
+      manifest = JSON.parse(captured ? captured.bytes.toString('utf8') : fs.readFileSync(file, 'utf8'));
     } catch {
       entry.diagnostics.push({
         code: 'invalid-host-config',
@@ -349,16 +351,18 @@ function configSource(workspaceRoot, file) {
   return relativePath(workspaceRoot, file);
 }
 
-function resolveDocsConfig(workspaceRoot, options = {}) {
+function resolveDocsConfigSelection(workspaceRoot, options, readSource) {
   const resolvedRoot = workspaceRoot || getWorkspaceRoot();
   if (!resolvedRoot) throw new Error('cannot resolve project docs outside a git workspace; pass a workspace root explicitly');
   const root = path.resolve(resolvedRoot);
   const projectFile = projectDocsConfigPath(root);
-  if (fs.existsSync(projectFile)) {
+  const capturedProject = readSource(projectFile);
+  if (capturedProject.presence !== 'absent') {
     const source = configSource(root, projectFile);
     let config;
     try {
-      config = JSON.parse(fs.readFileSync(projectFile, 'utf8'));
+      if (capturedProject.presence !== 'present') throw new Error('unreadable source');
+      config = JSON.parse(capturedProject.bytes.toString('utf8'));
     } catch {
       return {
         status: 'invalid',
@@ -376,7 +380,7 @@ function resolveDocsConfig(workspaceRoot, options = {}) {
       return { status: 'invalid', sources: [source], config: null, warnings, diagnostics };
     }
 
-    const hosts = inspectHostProjectDocs(root);
+    const hosts = inspectHostProjectDocs(root, readSource);
     const hostDiagnostics = hosts.flatMap(entry => entry.diagnostics);
     const hostWarnings = hosts.flatMap(entry => entry.warnings);
     const validHosts = hosts.filter(entry => entry.projectDocs);
@@ -393,7 +397,7 @@ function resolveDocsConfig(workspaceRoot, options = {}) {
     return { status: 'project', sources: [source], config, warnings: [...warnings, ...hostWarnings], diagnostics: [...diagnostics, ...hostDiagnostics] };
   }
 
-  const hosts = inspectHostProjectDocs(root);
+  const hosts = inspectHostProjectDocs(root, readSource);
   const hostDiagnostics = hosts.flatMap(entry => entry.diagnostics);
   const hostWarnings = hosts.flatMap(entry => entry.warnings);
   const activeHome = normalizedHostHome(options.activeHost);
@@ -457,6 +461,35 @@ function resolveDocsConfig(workspaceRoot, options = {}) {
   };
 }
 
+function resolveDocsConfigCaptured(workspaceRoot, options = {}) {
+  const resolvedRoot = workspaceRoot || getWorkspaceRoot();
+  if (!resolvedRoot) throw new Error('cannot resolve project docs outside a git workspace; pass a workspace root explicitly');
+  const root = path.resolve(resolvedRoot);
+  const records = new Map();
+  const readSource = file => {
+    const key = configSource(root, file);
+    if (!records.has(key)) {
+      let bytes = Buffer.alloc(0);
+      let presence = 'present';
+      try { bytes = Buffer.from(fs.readFileSync(file)); }
+      catch (error) { presence = error.code === 'ENOENT' ? 'absent' : 'unreadable'; }
+      records.set(key, { path: key, presence, bytes, digest: crypto.createHash('sha256').update(bytes).digest('hex') });
+    }
+    return records.get(key);
+  };
+  const resolution = resolveDocsConfigSelection(root, options, readSource);
+  let activeHost = null;
+  try { activeHost = JSON.parse(JSON.stringify(options.activeHost)); } catch { /* no serializable host context */ }
+  const sources = [...records.values()].sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+  const selectionInputs = sources.map(({ path: sourcePath, presence }) => ({ path: sourcePath, presence }));
+  selectionInputs.push({ status: resolution.status, sources: [...resolution.sources], activeHost, config: resolution.config });
+  return { resolution, capture: { activeHost, sources, selectionInputs } };
+}
+
+function resolveDocsConfig(workspaceRoot, options = {}) {
+  return resolveDocsConfigCaptured(workspaceRoot, options).resolution;
+}
+
 function cleanConfiguredPath(value) {
   if (typeof value !== 'string') return null;
   const trimmed = value.trim();
@@ -769,6 +802,7 @@ module.exports = {
   getRepoManifestHomes,
   readProjectDocs,
   resolveDocsConfig,
+  resolveDocsConfigCaptured,
   validateDocsConfig,
   normalizeHostProjectDocs,
   parseContextMap,

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

@@ -4,7 +4,7 @@ description: "Turn the conversation into a written spec — feature PRD, CLI/API
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.36.3
+  version: 0.39.0
 ---
 
 # To Spec

package/plugins/harness-everything/skills/to-spec/scripts/project-docs-resolver.js

@@ -122,15 +122,17 @@ function readHostProjectDocsConfigs(workspaceRoot) {
   return manifests;
 }
 
-function inspectHostProjectDocs(workspaceRoot) {
+function inspectHostProjectDocs(workspaceRoot, readSource = null) {
   const entries = [];
   for (const home of PLATFORM_HOMES) {
     const file = path.join(workspaceRoot, home, 'harness-everything', 'manifest.json');
-    if (!fs.existsSync(file)) continue;
+    const captured = readSource ? readSource(file) : null;
+    if (captured ? captured.presence === 'absent' : !fs.existsSync(file)) continue;
     const entry = { file, home, projectDocs: null, warnings: [], diagnostics: [], hasProjectDocs: false };
     let manifest;
     try {
-      manifest = JSON.parse(fs.readFileSync(file, 'utf8'));
+      if (captured && captured.presence !== 'present') throw new Error('unreadable source');
+      manifest = JSON.parse(captured ? captured.bytes.toString('utf8') : fs.readFileSync(file, 'utf8'));
     } catch {
       entry.diagnostics.push({
         code: 'invalid-host-config',
@@ -349,16 +351,18 @@ function configSource(workspaceRoot, file) {
   return relativePath(workspaceRoot, file);
 }
 
-function resolveDocsConfig(workspaceRoot, options = {}) {
+function resolveDocsConfigSelection(workspaceRoot, options, readSource) {
   const resolvedRoot = workspaceRoot || getWorkspaceRoot();
   if (!resolvedRoot) throw new Error('cannot resolve project docs outside a git workspace; pass a workspace root explicitly');
   const root = path.resolve(resolvedRoot);
   const projectFile = projectDocsConfigPath(root);
-  if (fs.existsSync(projectFile)) {
+  const capturedProject = readSource(projectFile);
+  if (capturedProject.presence !== 'absent') {
     const source = configSource(root, projectFile);
     let config;
     try {
-      config = JSON.parse(fs.readFileSync(projectFile, 'utf8'));
+      if (capturedProject.presence !== 'present') throw new Error('unreadable source');
+      config = JSON.parse(capturedProject.bytes.toString('utf8'));
     } catch {
       return {
         status: 'invalid',
@@ -376,7 +380,7 @@ function resolveDocsConfig(workspaceRoot, options = {}) {
       return { status: 'invalid', sources: [source], config: null, warnings, diagnostics };
     }
 
-    const hosts = inspectHostProjectDocs(root);
+    const hosts = inspectHostProjectDocs(root, readSource);
     const hostDiagnostics = hosts.flatMap(entry => entry.diagnostics);
     const hostWarnings = hosts.flatMap(entry => entry.warnings);
     const validHosts = hosts.filter(entry => entry.projectDocs);
@@ -393,7 +397,7 @@ function resolveDocsConfig(workspaceRoot, options = {}) {
     return { status: 'project', sources: [source], config, warnings: [...warnings, ...hostWarnings], diagnostics: [...diagnostics, ...hostDiagnostics] };
   }
 
-  const hosts = inspectHostProjectDocs(root);
+  const hosts = inspectHostProjectDocs(root, readSource);
   const hostDiagnostics = hosts.flatMap(entry => entry.diagnostics);
   const hostWarnings = hosts.flatMap(entry => entry.warnings);
   const activeHome = normalizedHostHome(options.activeHost);
@@ -457,6 +461,35 @@ function resolveDocsConfig(workspaceRoot, options = {}) {
   };
 }
 
+function resolveDocsConfigCaptured(workspaceRoot, options = {}) {
+  const resolvedRoot = workspaceRoot || getWorkspaceRoot();
+  if (!resolvedRoot) throw new Error('cannot resolve project docs outside a git workspace; pass a workspace root explicitly');
+  const root = path.resolve(resolvedRoot);
+  const records = new Map();
+  const readSource = file => {
+    const key = configSource(root, file);
+    if (!records.has(key)) {
+      let bytes = Buffer.alloc(0);
+      let presence = 'present';
+      try { bytes = Buffer.from(fs.readFileSync(file)); }
+      catch (error) { presence = error.code === 'ENOENT' ? 'absent' : 'unreadable'; }
+      records.set(key, { path: key, presence, bytes, digest: crypto.createHash('sha256').update(bytes).digest('hex') });
+    }
+    return records.get(key);
+  };
+  const resolution = resolveDocsConfigSelection(root, options, readSource);
+  let activeHost = null;
+  try { activeHost = JSON.parse(JSON.stringify(options.activeHost)); } catch { /* no serializable host context */ }
+  const sources = [...records.values()].sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+  const selectionInputs = sources.map(({ path: sourcePath, presence }) => ({ path: sourcePath, presence }));
+  selectionInputs.push({ status: resolution.status, sources: [...resolution.sources], activeHost, config: resolution.config });
+  return { resolution, capture: { activeHost, sources, selectionInputs } };
+}
+
+function resolveDocsConfig(workspaceRoot, options = {}) {
+  return resolveDocsConfigCaptured(workspaceRoot, options).resolution;
+}
+
 function cleanConfiguredPath(value) {
   if (typeof value !== 'string') return null;
   const trimmed = value.trim();
@@ -769,6 +802,7 @@ module.exports = {
   getRepoManifestHomes,
   readProjectDocs,
   resolveDocsConfig,
+  resolveDocsConfigCaptured,
   validateDocsConfig,
   normalizeHostProjectDocs,
   parseContextMap,