harness-everything 0.30.9 → 0.31.0

package/plugins/harness-everything/hooks/scripts/contract-test.js

@@ -39,16 +39,26 @@ function resultState(payload) {
   return { failed, exitCode, evidence };
 }
 
+function unresolvedBindings(contract) {
+  const bindings = [...(contract.requiredBindings || []), ...(contract.optionalBindings || [])];
+  return bindings.filter(binding => binding.required !== false
+    ? binding.status !== 'loaded'
+    : !['loaded', 'not-needed'].includes(binding.status));
+}
+
 function updateRunContract(entry, payload, command, sessionId) {
   const { failed, exitCode, evidence } = resultState(payload);
+  const unresolved = unresolvedBindings(entry.contract);
+  const status = failed ? 'fail' : unresolved.length ? 'binding-unresolved' : 'pass';
   const observedAt = new Date().toISOString();
   const contract = {
     ...entry.contract,
     workerId: entry.contract.workerId || getWorkerId(payload),
-    status: failed ? 'fail' : 'pass',
+    status,
     lastObservedCommand: command,
     lastObservedExitCode: exitCode ?? null,
     evidence,
+    unresolvedBindings: unresolved.map(binding => binding.id),
     verifiedAt: observedAt,
     updatedAt: observedAt,
   };
@@ -63,7 +73,9 @@ function updateRunContract(entry, payload, command, sessionId) {
     sessionId: sessionId || contract.sessionId || null,
     workerId: contract.workerId || null,
     checkCommand: command,
-    status: failed ? 'fail' : 'pass',
+    status,
+    checkStatus: failed ? 'fail' : 'pass',
+    unresolvedBindings: unresolved.map(binding => binding.id),
     exitCode: exitCode ?? null,
     evidence,
     observedAt,
@@ -72,6 +84,15 @@ function updateRunContract(entry, payload, command, sessionId) {
   return contract;
 }
 
+function activeFableStages(runRoot) {
+  for (const relative of ['../../fable-mode/scripts/workflow-plan-consumer.js', '../../skills/fable-mode/scripts/workflow-plan-consumer.js']) {
+    const file = path.resolve(__dirname, relative);
+    if (!fs.existsSync(file)) continue;
+    try { return require(file).activeStageBindings(runRoot); } catch (_) { return []; }
+  }
+  return [];
+}
+
 function resolveLegacyContract(stateRoot, command, payload) {
   const contractsDir = path.join(stateRoot, 'contracts');
   let files = [];
@@ -110,7 +131,7 @@ process.stdin.on('end', () => {
     const workflowContext = loadWorkflow(payload);
     const activeRun = workflowContext.workflow?.workflowId ? matchingRun(workflowContext) : null;
     const runMatches = listRunContracts(stateRoot).filter(({ contract }) =>
-      (contract.workflowId ? ['pending', 'planned', 'running', 'fail', 'pass'] : ['pending', 'planned', 'running']).includes(contract.status) && commandMatches(contract, command) &&
+      (contract.workflowId ? ['pending', 'planned', 'running', 'fail', 'pass', 'binding-unresolved'] : ['pending', 'planned', 'running', 'fail', 'binding-unresolved']).includes(contract.status) && commandMatches(contract, command) &&
       (!workflowContext.workflow?.workflowId || (activeRun && contract.runId === activeRun.run.runId && contract.sessionId === sessionId))
     );
 
@@ -163,6 +184,11 @@ process.stdin.on('end', () => {
         }
       }
       console.log(`[Contract Test] ${contract.planId}/${contract.runId}/${contract.stageId}: ${contract.status.toUpperCase()} ${contract.checkCommand}`);
+      if (contract.status === 'binding-unresolved') {
+        console.error(`Resolve declared stage bindings before this stage can pass: ${contract.unresolvedBindings.join(', ')}`);
+      }
+      const activeStages = activeFableStages(entry.runRoot);
+      if (activeStages.length) console.log('[Contract Test] Active stage bindings: ' + JSON.stringify(activeStages));
       if (contract.status === 'fail') {
         console.error(`Evidence: ${contract.evidence || '(no output captured)'}`);
         console.error(`Review this failed stage before relying on its output. Artifact: ${contract.outputPath || '(no path recorded)'}`);

package/plugins/harness-everything/hooks/scripts/lib/binding-resolver.js

@@ -0,0 +1,76 @@
+'use strict';
+
+// Resolves a declared step/stage binding to a real, readable file. A binding
+// path is availability evidence only after it resolves under the workspace or
+// an installed Harness skill root; path syntax alone proves nothing.
+const fs = require('fs');
+const path = require('path');
+
+function loadGeneratedSkills() {
+  const file = path.resolve(__dirname, '..', '..', '..', 'scripts', 'lib', 'generated-skills.js');
+  return fs.existsSync(file) ? require(file) : null;
+}
+
+// Source checkout and Claude plugin keep skills at the package root; the
+// Codex plugin keeps them under skills/. Host-provided plugin roots win.
+function packageRoots() {
+  const packageRoot = path.resolve(__dirname, '..', '..', '..');
+  const roots = [];
+  for (const root of [process.env.CLAUDE_PLUGIN_ROOT, process.env.PLUGIN_ROOT, packageRoot]) {
+    if (!root) continue;
+    roots.push(path.resolve(root), path.resolve(root, 'skills'));
+  }
+  return [...new Set(roots)];
+}
+
+function readableFile(file) {
+  try {
+    if (!fs.statSync(file).isFile()) return false;
+    fs.accessSync(file, fs.constants.R_OK);
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+
+// Registered Harness bindings and the path each one loads.
+const PACKAGED_BINDING_PATHS = {
+  tdd: 'tdd/SKILL.md',
+  'verification-loop': 'verification-loop/SKILL.md',
+  'git-commit': 'git-commit/SKILL.md',
+  'security-review': 'security-review/SKILL.md',
+  'review-guidance': 'harness-everything/references/triage-and-tiers.md',
+};
+const SKILL_ID = /^[a-z0-9][a-z0-9-]{0,63}$/;
+
+// Only a recognized Harness binding may search installation roots: a
+// registered id at its registered path, or a skill id naming its own
+// `<id>/SKILL.md`. Any other path is a workspace reference and must never
+// resolve to an unrelated file that happens to exist in the Harness package.
+function isPackagedBinding(binding) {
+  if (!binding.path) return false;
+  if (PACKAGED_BINDING_PATHS[binding.id]) return PACKAGED_BINDING_PATHS[binding.id] === binding.path;
+  return SKILL_ID.test(binding.id || '') && binding.path === `${binding.id}/SKILL.md`;
+}
+
+// Returns { availability, file }: `available` with an absolute readable file,
+// `missing` when a declared path resolves nowhere, or `unknown` when neither a
+// path nor a registered generated skill names a location.
+function resolveBinding(binding, workspaceRoot) {
+  const roots = isPackagedBinding(binding) ? [...packageRoots(), workspaceRoot] : [workspaceRoot];
+  if (binding.path) {
+    for (const root of roots.filter(Boolean)) {
+      const file = path.resolve(root, binding.path);
+      if (readableFile(file)) return { availability: 'available', file };
+    }
+    return { availability: 'missing', file: null };
+  }
+  const generated = loadGeneratedSkills()?.findGeneratedSkill(binding.id, workspaceRoot);
+  if (generated) {
+    const file = path.join(generated.dirPath, 'SKILL.md');
+    return readableFile(file) ? { availability: 'available', file } : { availability: 'missing', file: null };
+  }
+  return { availability: 'unknown', file: null };
+}
+
+module.exports = { resolveBinding, packageRoots, isPackagedBinding, PACKAGED_BINDING_PATHS };

package/plugins/harness-everything/hooks/scripts/lib/fable-contracts.js

@@ -102,7 +102,7 @@ function stagesForChangedPath(filePath, contractEntries) {
 
 function getActiveRunContracts(stateRoot, sessionId) {
   return listRunContracts(stateRoot).filter(({ contract }) => {
-    if (!['pending', 'planned', 'running'].includes(contract.status)) return false;
+    if (!['pending', 'planned', 'running', 'fail', 'binding-unresolved'].includes(contract.status)) return false;
     return !sessionId || !contract.sessionId || contract.sessionId === sessionId;
   });
 }

package/plugins/harness-everything/hooks/scripts/lib/observations.js

@@ -370,15 +370,16 @@ function routerState(payload) {
   }
 }
 
-function withLock(root, fn) {
+function withLock(root, fn, options = {}) {
   fs.mkdirSync(root, { recursive: true, mode: 0o700 });
   const lock = path.join(root, '.index.lock');
-  const deadline = Date.now() + 2000;
+  const timeoutMs = Number.isFinite(options.timeoutMs) && options.timeoutMs >= 0 ? options.timeoutMs : 2000;
+  const deadline = Date.now() + timeoutMs;
   let fd = null;
   while (fd === null) {
     try { fd = fs.openSync(lock, 'wx'); } catch (_) {
       try { if (Date.now() - fs.statSync(lock).mtimeMs > 5000) fs.unlinkSync(lock); } catch (__) { /* raced */ }
-      if (Date.now() > deadline) return false;
+      if (Date.now() >= deadline) return false;
       const until = Date.now() + 10;
       while (Date.now() < until) { /* short spin; hooks are short-lived */ }
     }
@@ -432,18 +433,88 @@ function sweep(root, now = Date.now()) {
   });
 }
 
-function appendRecord(root, record, text) {
-  return withLock(root, () => {
+function appendRecordDetailed(root, record, text, options = {}) {
+  let outcome = null;
+  const locked = withLock(root, () => {
+    const file = path.join(root, 'observations-index.json');
+    const index = readJson(file, null) || { schemaVersion: 1, kind: 'system-one-observations', records: [] };
+    if (options.dedupeById && index.records.some(existing => existing.id === record.id)) {
+      outcome = 'duplicate';
+      return;
+    }
+    if (options.dedupeByTurn) {
+      const match = observationTurnMatch(index.records, record);
+      if (match) {
+        outcome = match === 'ambiguous-legacy-turn' ? 'ambiguous' : 'duplicate';
+        return;
+      }
+    }
     // The blob is written under the lock, so a concurrent sweep cannot remove it before its record lands.
     const textDir = path.join(root, 'text');
     fs.mkdirSync(textDir, { recursive: true, mode: 0o700 });
-    if (text) fs.writeFileSync(path.join(textDir, `${record.contentSha256}.json`), JSON.stringify(text), { mode: 0o600 });
-    const file = path.join(root, 'observations-index.json');
-    const index = readJson(file, null) || { schemaVersion: 1, kind: 'system-one-observations', records: [] };
+    if (text) fs.writeFileSync(path.join(textDir, record.contentSha256 + '.json'), JSON.stringify(text), { mode: 0o600 });
     index.records.push(record);
     sweepLocked(root, index, Date.now());
     writeJsonAtomic(file, index);
-  });
+    outcome = 'appended';
+  }, { timeoutMs: options.lockTimeoutMs });
+  if (!locked) return { status: 'lock-timeout' };
+  return { status: outcome || 'appended' };
+}
+
+function appendRecord(root, record, text, options = {}) {
+  return appendRecordDetailed(root, record, text, options).status === 'appended';
+}
+
+function observationTurnMatch(records, record) {
+  const writer = record && record.writer || {};
+  const sessionId = String(writer.sessionId || '');
+  const turnId = String(writer.turnId || '');
+  if (!sessionId || !record.host) return null;
+  const sameSession = (Array.isArray(records) ? records : []).filter(existing =>
+    existing && existing.host === record.host &&
+    String(existing.writer && existing.writer.sessionId || '') === sessionId
+  );
+  if (!sameSession.length) return null;
+
+  if (turnId && sameSession.some(existing => String(existing.writer && existing.writer.turnId || '') === turnId)) {
+    return 'same-turn-id';
+  }
+
+  // Older live records have no turn ID. Only treat matching ordinal plus text
+  // as a definite duplicate; a partial match is ambiguous and the importer
+  // skips it instead of risking a second training row for the same turn.
+  const legacy = sameSession.filter(existing => existing.captureMethod !== 'session-backfill' &&
+    (!turnId || !String(existing.writer && existing.writer.turnId || '')));
+  if (!legacy.length) return null;
+  const sameTurn = existing => Number.isInteger(existing.turn) && existing.turn === record.turn;
+  const sameText = existing => Boolean(existing.contentSha256 && existing.contentSha256 === record.contentSha256);
+  if (legacy.some(existing => sameTurn(existing) && sameText(existing))) return 'legacy-same-turn';
+  if (legacy.some(existing => sameTurn(existing) || sameText(existing))) return 'ambiguous-legacy-turn';
+  return null;
+}
+
+function findObservationTurnMatch(root, record) {
+  const index = readJson(path.join(root, 'observations-index.json'), null);
+  return observationTurnMatch(index && index.records, record);
+}
+
+function markSessionBackfillBehaviorUnobserved(root, options = {}) {
+  const file = path.join(root, 'observations-index.json');
+  if (!fs.existsSync(file)) return 0;
+  let changed = 0;
+  const locked = withLock(root, () => {
+    const index = readJson(file, null);
+    if (!index || !Array.isArray(index.records)) return;
+    for (const record of index.records) {
+      if (record.captureMethod === 'session-backfill' && record.behavior !== null) {
+        record.behavior = null;
+        changed++;
+      }
+    }
+    if (changed) writeJsonAtomic(file, index);
+  }, { timeoutMs: options.lockTimeoutMs });
+  return locked ? changed : null;
 }
 
 // Tool events are immutable files, one per event, so parallel hooks never
@@ -484,6 +555,7 @@ function startTurn(payload, root) {
   session.turn++;
   session.pending = {
     turn: session.turn,
+    turnId: String(payload.turn_id || payload.turnId || ''),
     startedAt: new Date().toISOString(),
     prompt: redact(typeof payload.prompt === 'string' ? payload.prompt : ''),
     previous: session.lastFinal || '',
@@ -505,6 +577,7 @@ function toolTurn(payload, root, failed, codex) {
 
 function finishPending(session, payload, root, final) {
   const pending = session.pending;
+  const turnId = String(payload.turn_id || payload.turnId || pending.turnId || '');
   const { label, reason } = final.text === null && final.reason ? { label: null, reason: final.reason } : parseLabelLine(final.text);
   const collected = collectEvents(root, payload.session_id, pending.turn);
   const behavior = { ...collected };
@@ -531,7 +604,10 @@ function finishPending(session, payload, root, final) {
     contentSha256,
     host: detectHost(payload, { codex: final.codex || collected._codex }),
     turn: pending.turn,
-    writer: { sessionId: String(payload.session_id || 'unknown') },
+    writer: {
+      sessionId: String(payload.session_id || 'unknown'),
+      ...(turnId ? { turnId } : {}),
+    },
     scope: { taskTerms: normalizeTerms(pending.prompt), requirementTerms: [], roles: [] },
     promptBytes: Buffer.byteLength(pending.prompt, 'utf8'),
     router: routerState(payload),
@@ -575,7 +651,7 @@ function handle(payload, env = process.env) {
 }
 
 module.exports = {
-  INTENTS, TIERS, STRATEGIES, enabled, storeRoot, redact, parseLabelLine, classifyCommand, labelTier, contradictions,
-  normalizeTerms, transcriptMessage, recordTool, emptyBehavior, mergeBehavior, toolFailed, handle, readJson,
+  INTENTS, TIERS, STRATEGIES, RETENTION_MS, PREVIOUS_BYTES, enabled, storeRoot, redact, parseLabelLine, stripLabels, tailBytes, sha, classifyCommand, labelTier, contradictions,
+  normalizeTerms, transcriptMessage, recordTool, emptyBehavior, mergeBehavior, toolFailed, handle, readJson, appendRecord, appendRecordDetailed, observationTurnMatch, findObservationTurnMatch, markSessionBackfillBehaviorUnobserved,
   expired, recordText, sweep,
 };