harness-everything 0.12.2 → 0.13.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
       "name": "harness-everything",
       "source": "./",
       "description": "Harness OS: an orchestrated agent operating system — tier routing, circuit breaker guardrails, verification gates, WAL session memory, and self-evolving workspace rules.",
-      "version": "0.12.2",
+      "version": "0.13.0",
       "author": {
         "name": "Miya Daniel"
       },

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "harness-everything",
   "description": "Harness OS: an orchestrated agent operating system — tier routing, circuit breaker guardrails, verification gates, WAL session memory, and self-evolving workspace rules.",
-  "version": "0.12.2",
+  "version": "0.13.0",
   "author": {
     "name": "Miya Daniel"
   },

package/.github/workflows/ci.yml

@@ -82,6 +82,8 @@ jobs:
           chmod +x "$HOME/bin/waza"
           echo "$HOME/bin" >> "$GITHUB_PATH"
           "$HOME/bin/waza" --version
+      - name: Run Harness Waza adapter against canonical skills
+        run: npm run waza:check
       - name: Check every canonical SKILL.md passes waza readiness gates
         run: |
           fail=0

package/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 All notable changes to this project are documented in this file.
 
+## [0.13.0](https://github.com/dyphn1/Harness-everything/compare/v0.12.3...v0.13.0) (2026-09-19)
+
+### Features
+
+* **waza:** expose non-link readiness failures ([f9c7d24](https://github.com/dyphn1/Harness-everything/commit/f9c7d242eece2af76fd68a6686eaa9521dcce443))
+
+### Bug Fixes
+
+* **waza:** add Harness reference adapter ([5223690](https://github.com/dyphn1/Harness-everything/commit/52236905be8a3660b89bf43396ea3d7bca984126))
+* **waza:** align reference adapter with main ([87b634d](https://github.com/dyphn1/Harness-everything/commit/87b634df1d5d7de57b1c5ca45e8505423764e240))
+* **waza:** normalize template and repo-scope links ([25558ca](https://github.com/dyphn1/Harness-everything/commit/25558caaa39b8bafb4a825c1299ff746ffbae91b))
+* **waza:** preserve Harness placeholder delimiters ([f697ae8](https://github.com/dyphn1/Harness-everything/commit/f697ae83b6de54718b2e969041adfaa20b5e8efc))
+* **waza:** scope checks to canonical skills ([de7b78b](https://github.com/dyphn1/Harness-everything/commit/de7b78b1702b412466337a1ea84ec524cf864e60))
+
+## [0.12.3](https://github.com/dyphn1/Harness-everything/compare/v0.12.2...v0.12.3) (2026-09-19)
+
+### Bug Fixes
+
+* **workflow:** degrade oversized fingerprints conservatively ([ea90f30](https://github.com/dyphn1/Harness-everything/commit/ea90f30a4495e6144017373463c5279fae563252))
+* **workflow:** degrade oversized fingerprints conservatively ([a618d22](https://github.com/dyphn1/Harness-everything/commit/a618d2216955ab3594ecb31b45635dea94e9b109))
+* **workflow:** settle oversized fingerprint probes conservatively ([aafce50](https://github.com/dyphn1/Harness-everything/commit/aafce508551d6564afc884da17555ed71f989836))
+* **workflow:** settle oversized fingerprint probes conservatively ([3092dd6](https://github.com/dyphn1/Harness-everything/commit/3092dd60ed19de97c096f57278c26813f77c3ff7))
+
+### Performance Improvements
+
+* **workflow:** batch workspace content hashing ([ad0fc18](https://github.com/dyphn1/Harness-everything/commit/ad0fc18260c5a716d7711cb4b83cf9f5059dd21d))
+* **workflow:** batch workspace content hashing ([2cdd6e3](https://github.com/dyphn1/Harness-everything/commit/2cdd6e3dc568c9d6007ca10de76b06b47ff39880))
+
 ## [0.12.2](https://github.com/dyphn1/Harness-everything/compare/v0.12.1...v0.12.2) (2026-09-19)
 
 ### Bug Fixes

package/ci/mechanism-2ai-workspace-fingerprint-batch.test.js

@@ -0,0 +1,216 @@
+#!/usr/bin/env node
+'use strict';
+
+const assert = require('assert');
+const crypto = require('crypto');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const ROOT = path.resolve(__dirname, '..');
+const isolation = require(path.join(ROOT, 'hooks/scripts/lib/workflow-isolation'));
+const pluginIsolation = require(path.join(ROOT, 'plugins/harness-everything/hooks/scripts/lib/workflow-isolation'));
+const state = require(path.join(ROOT, 'hooks/scripts/lib/harness-state'));
+
+const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-workspace-fingerprint-'));
+const repo = path.join(temp, 'repo');
+fs.mkdirSync(repo);
+const env = {
+  ...process.env,
+  HARNESS_STATE_HOME: path.join(temp, 'state'),
+  HARNESS_WORKSPACE_ROOT: repo,
+};
+process.env.HARNESS_STATE_HOME = env.HARNESS_STATE_HOME;
+process.env.HARNESS_WORKSPACE_ROOT = env.HARNESS_WORKSPACE_ROOT;
+
+let passed = 0;
+function check(value, message) {
+  assert.ok(value, message);
+  passed++;
+  console.log('PASS ' + message);
+}
+
+function run(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    cwd: options.cwd || repo,
+    env,
+    input: options.input,
+    encoding: 'utf8',
+    windowsHide: true,
+    maxBuffer: 64 * 1024 * 1024,
+  });
+  assert.strictEqual(result.status, 0, result.stderr || result.stdout);
+  return result.stdout;
+}
+
+function git(args) {
+  return run('git', args);
+}
+
+function node(script, payload, args = []) {
+  return spawnSync(process.execPath, [path.join(ROOT, script), ...args], {
+    cwd: repo,
+    env,
+    input: payload === undefined ? undefined : JSON.stringify(payload),
+    encoding: 'utf8',
+    windowsHide: true,
+    maxBuffer: 64 * 1024 * 1024,
+  });
+}
+
+function gitRaw(args) {
+  return run('git', args);
+}
+
+function legacyHashWorktreePath(root, relative) {
+  const target = path.join(root, relative);
+  let stat;
+  try {
+    stat = fs.lstatSync(target);
+  } catch (error) {
+    if (error.code === 'ENOENT') return null;
+    throw error;
+  }
+  if (stat.isDirectory()) {
+    const result = spawnSync('git', ['-C', target, 'rev-parse', 'HEAD'], {
+      encoding: 'utf8',
+      windowsHide: true,
+    });
+    return { mode: '160000', oid: result.status === 0 ? result.stdout.trim() : 'directory' };
+  }
+  const mode = stat.isSymbolicLink() ? '120000' : ((stat.mode & 0o111) ? '100755' : '100644');
+  const result = spawnSync('git', ['hash-object', '--path=' + relative, '--', relative], {
+    cwd: root,
+    encoding: 'utf8',
+    windowsHide: true,
+  });
+  if (result.status !== 0) throw new Error('legacy fingerprint failed for ' + relative);
+  return { mode, oid: result.stdout.trim() };
+}
+
+function legacyFingerprint(cwd) {
+  const root = isolation.canonical(gitRaw(['rev-parse', '--show-toplevel']).trim());
+  const entries = new Map();
+  for (const record of gitRaw(['ls-files', '-s', '-z']).split('\0')) {
+    if (!record) continue;
+    const tab = record.indexOf('\t');
+    assert.ok(tab >= 0, 'legacy index record has a tab');
+    const meta = record.slice(0, tab).trim().split(/\s+/);
+    const relative = record.slice(tab + 1);
+    entries.set(relative, { relative, mode: meta[0], oid: meta[1] });
+  }
+  for (const relative of gitRaw(['diff-files', '--name-only', '-z']).split('\0').filter(Boolean)) {
+    const value = legacyHashWorktreePath(root, relative);
+    if (value) entries.set(relative, { relative, mode: value.mode, oid: value.oid });
+    else entries.delete(relative);
+  }
+  for (const relative of gitRaw(['ls-files', '--others', '--exclude-standard', '-z']).split('\0').filter(Boolean)) {
+    const value = legacyHashWorktreePath(root, relative);
+    if (value) entries.set(relative, { relative, mode: value.mode, oid: value.oid });
+  }
+  const digest = crypto.createHash('sha256');
+  digest.update('harness-workspace-fingerprint-v1\0');
+  for (const entry of [...entries.values()].sort((a, b) => a.relative.localeCompare(b.relative))) {
+    digest.update(entry.relative); digest.update('\0');
+    digest.update(entry.mode); digest.update('\0');
+    digest.update(entry.oid); digest.update('\0');
+  }
+  return digest.digest('hex');
+}
+
+try {
+  git(['init']);
+  fs.writeFileSync(path.join(repo, 'tracked.txt'), 'tracked\n');
+  fs.writeFileSync(path.join(repo, 'delete-me.txt'), 'delete me\n');
+  git(['add', '.']);
+  git(['-c', 'user.name=Harness Test', '-c', 'user.email=harness@example.invalid', 'commit', '-m', 'fixture']);
+
+  const cleanLegacy = legacyFingerprint(repo);
+  check(isolation.workspaceFingerprint(repo) === cleanLegacy,
+    '#169 batched fingerprint matches the legacy clean-worktree fingerprint');
+  check(pluginIsolation.workspaceFingerprint(repo) === cleanLegacy,
+    '#169 packaged plugin fingerprint matches canonical/legacy on a clean worktree');
+
+  fs.writeFileSync(path.join(repo, 'tracked.txt'), 'tracked changed\n');
+  fs.writeFileSync(path.join(repo, 'untracked.txt'), 'untracked\n');
+  const dirtyLegacy = legacyFingerprint(repo);
+  const dirtyBatched = isolation.workspaceFingerprint(repo);
+  check(dirtyBatched === dirtyLegacy,
+    '#169 batched fingerprint matches legacy for dirty tracked + untracked content');
+  check(pluginIsolation.workspaceFingerprint(repo) === dirtyLegacy,
+    '#169 packaged plugin batched fingerprint matches legacy dirty semantics');
+
+  git(['add', 'tracked.txt', 'untracked.txt']);
+  check(isolation.workspaceFingerprint(repo) === dirtyBatched,
+    '#169 staging visible content does not change the workspace fingerprint');
+
+  fs.unlinkSync(path.join(repo, 'delete-me.txt'));
+  check(isolation.workspaceFingerprint(repo) === legacyFingerprint(repo),
+    '#169 tracked deletion keeps legacy fingerprint semantics');
+
+  git(['reset', '--hard', 'HEAD']);
+  git(['clean', '-fdx']);
+  const bulk = path.join(repo, 'bulk');
+  fs.mkdirSync(bulk);
+  for (let i = 0; i < 1000; i++) {
+    fs.writeFileSync(path.join(bulk, 'file-' + String(i).padStart(4, '0') + '.txt'), 'x\n');
+  }
+
+  const startedAt = process.hrtime.bigint();
+  const bulkFingerprint = isolation.workspaceFingerprint(repo);
+  const elapsedMs = Number(process.hrtime.bigint() - startedAt) / 1e6;
+  check(/^[a-f0-9]{64}$/.test(bulkFingerprint),
+    '#169 1000-untracked-file fingerprint returns a valid digest');
+  check(elapsedMs < 5000,
+    '#169 1000-untracked-file fingerprint stays below 5s regression ceiling (actual ' + elapsedMs.toFixed(1) + 'ms)');
+  check(pluginIsolation.workspaceFingerprint(repo) === bulkFingerprint,
+    '#169 packaged plugin fingerprint remains byte-identical for 1000 untracked files');
+
+  let limitError = null;
+  try {
+    isolation.workspaceFingerprint(repo, { maxPaths: 10 });
+  } catch (error) {
+    limitError = error;
+  }
+  check(limitError?.code === 'HARNESS_FINGERPRINT_LIMIT' &&
+    limitError.count === 1000 &&
+    limitError.maxPaths === 10,
+    '#169 explicit fingerprint cap reports a structured conservative-fallback signal');
+
+  for (let i = 1000; i < 5101; i++) {
+    fs.writeFileSync(path.join(bulk, 'file-' + String(i).padStart(4, '0') + '.txt'), 'x\n');
+  }
+  const sessionId = 'workspace-fingerprint-limit';
+  const payload = { session_id: sessionId, cwd: repo };
+  const routed = node('harness-everything/scripts/kernel-router.js', {
+    ...payload,
+    prompt: 'Fix this checkout bug with a regression test',
+  });
+  check(routed.status === 0, '#169 large-workspace Tier-2 fixture routes normally');
+  const started = node('hooks/scripts/workflow-disposition.js', undefined, ['start', '--session-id', sessionId]);
+  check(started.status === 0, '#169 large-workspace Tier-2 fixture starts normally');
+
+  const admitted = node('hooks/scripts/workflow-gate.js', {
+    ...payload,
+    tool_name: 'Bash',
+    tool_use_id: 'toolu_fingerprint_limit',
+    tool_input: { command: 'node large-fingerprint.js' },
+  });
+  check(admitted.status === 0,
+    '#169 >5000 observed paths degrade conservatively instead of blocking the shell call');
+  const workflowFile = path.join(state.getSessionDir(repo, sessionId), 'workflow-run.json');
+  const workflow = JSON.parse(fs.readFileSync(workflowFile, 'utf8'));
+  check(workflow.state === 'running' &&
+    workflow.budget?.counters?.iterations === 1 &&
+    workflow.lastMutationAt > 0 &&
+    workflow.budget?.events?.at(-1)?.evidence === 'shell:fingerprint-limit',
+    '#169 fingerprint-limit fallback records one auditable conservative mutation');
+
+  console.log('PASS: batched workspace fingerprint (' + passed + ' assertions, 1000-file ' + elapsedMs.toFixed(1) + 'ms)');
+} finally {
+  if (!temp.startsWith(path.join(os.tmpdir(), 'harness-workspace-fingerprint-'))) {
+    throw new Error('unsafe fixture cleanup');
+  }
+  fs.rmSync(temp, { recursive: true, force: true });
+}

package/ci/mechanism-2aj-waza-reference-adapter.test.js

@@ -0,0 +1,223 @@
+#!/usr/bin/env node
+'use strict';
+
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const ROOT = path.resolve(__dirname, '..');
+const { discoverSkills, extractCandidates } = require('./reference-check');
+const {
+  harnessReachableReferenceFiles,
+  classifyReportedLink,
+  normalizeSkillReport,
+  normalizeReport,
+  runCanonicalWazaChecks,
+} = require('../scripts/waza-harness-check');
+
+let passed = 0;
+function check(value, message) {
+  assert.ok(value, message);
+  passed++;
+  console.log('PASS ' + message);
+}
+
+const skills = discoverSkills(ROOT);
+check(skills.length >= 20, 'discovers the canonical Harness skill set');
+
+const invoked = [];
+const fakeSpawn = (command, args, options) => {
+  invoked.push({ command, args, cwd: options.cwd });
+  const skillPath = args[1];
+  const name = path.basename(skillPath);
+  return {
+    status: 0,
+    stdout: JSON.stringify({
+      timestamp: new Date(0).toISOString(),
+      skills: [{
+        name,
+        path: path.join(skillPath, 'SKILL.md'),
+        ready: true,
+        compliance: { level: 'High' },
+        tokenBudget: { exceeded: false },
+        specCompliance: [],
+        links: { passed: true },
+      }],
+    }),
+    stderr: '',
+  };
+};
+const scoped = runCanonicalWazaChecks(ROOT, 'waza', fakeSpawn);
+check(scoped.skills.length === skills.length && invoked.length === skills.length,
+  'adapter invokes Waza exactly once per canonical top-level skill');
+check(invoked.every((call, index) =>
+  call.command === 'waza' &&
+  call.args[0] === 'check' &&
+  call.args[1] === path.join(ROOT, skills[index]) &&
+  call.args[2] === '--format' &&
+  call.args[3] === 'json' &&
+  call.cwd === ROOT),
+  'Waza receives explicit canonical skill paths instead of recursive workspace discovery');
+
+let skillsWithPlaceholderReferences = 0;
+let totalResolved = 0;
+for (const skill of skills) {
+  const skillFile = path.join(ROOT, skill, 'SKILL.md');
+  const text = fs.readFileSync(skillFile, 'utf8');
+  const directReferenceTargets = extractCandidates(text)
+    .filter(value => /^<this-skill-dir>\/references\//.test(value))
+    .map(value => value.replace(/^<this-skill-dir>\//, ''));
+  if (!directReferenceTargets.length) continue;
+
+  skillsWithPlaceholderReferences++;
+  const reachable = harnessReachableReferenceFiles(ROOT, skill);
+  for (const target of directReferenceTargets) {
+    check(reachable.has(target), skill + ' placeholder reference is reachable: ' + target);
+  }
+
+  const simulated = {
+    name: skill,
+    path: path.join(ROOT, skill),
+    ready: false,
+    compliance: { level: 'High' },
+    tokenBudget: { exceeded: false },
+    specCompliance: [{ name: 'spec-frontmatter', passed: true }],
+    schema: { valid: true },
+    links: {
+      passed: false,
+      orphanedFiles: [...new Set(directReferenceTargets)],
+    },
+  };
+  const normalized = normalizeSkillReport(ROOT, simulated);
+  check(normalized.harnessCompatibility.remainingOrphanedFiles.length === 0,
+    skill + ' removes Waza orphan advisories for Harness-reachable references');
+  check(normalized.harnessCompatibility.resolvedPlaceholderOrphans.length === new Set(directReferenceTargets).size,
+    skill + ' reports the suppressed advisories explicitly');
+  check(normalized.harnessCompatibility.harnessReady === true,
+    skill + ' recomputes readiness without false local-orphan failures');
+  totalResolved += normalized.harnessCompatibility.resolvedPlaceholderOrphans.length;
+}
+
+check(skillsWithPlaceholderReferences > 0, 'at least one canonical skill uses the Harness placeholder reference contract');
+check(totalResolved > 0, 'adapter resolves canonical placeholder-orphan advisories');
+
+const nestedReferenceContract = {
+  'fable-mode': ['references/execution-phases.md'],
+  'harness-everything': ['references/router-workflow-plan.md', 'references/skill-registry.md'],
+  'multi-agent-workspace': ['references/agency-agents.md'],
+  'skill-creator': [
+    'references/authoring-workflow.md',
+    'references/testing-workflow.md',
+    'references/quality-principles.md',
+    'references/dynamic-generation-contract.md',
+  ],
+  tdd: ['references/quality-model.md', 'references/unit-testing.md', 'references/integration-testing.md'],
+};
+for (const [skill, expected] of Object.entries(nestedReferenceContract)) {
+  const reachable = harnessReachableReferenceFiles(ROOT, skill);
+  for (const reference of expected) {
+    check(reachable.has(reference), skill + ' nested reference remains reachable: ' + reference);
+  }
+  const normalized = normalizeSkillReport(ROOT, {
+    name: skill,
+    path: path.join(ROOT, skill),
+    ready: false,
+    compliance: { level: 'High' },
+    tokenBudget: { exceeded: false },
+    specCompliance: [],
+    links: { passed: false, orphanedFiles: expected },
+  });
+  check(normalized.harnessCompatibility.remainingOrphanedFiles.length === 0,
+    skill + ' nested reference advisories are resolved through the reachable reference graph');
+}
+
+const fableContract = classifyReportedLink(ROOT, 'fable-mode', {
+  source: 'SKILL.md',
+  target: '<skills-repo-root>/harness-everything/scripts/verify-gate.js',
+  reason: 'link escapes skill directory',
+});
+check(fableContract.category === 'resolved-contract',
+  '<skills-repo-root> existing target is a resolved Harness contract link');
+
+const genericTemplate = classifyReportedLink(ROOT, 'repo-docs', {
+  source: 'SKILL.md',
+  target: '<workspace>/docs/generated.md',
+  reason: 'target does not exist',
+});
+check(genericTemplate.category === 'template',
+  'generic runtime placeholder is classified as a template advisory');
+
+const badPlaceholder = classifyReportedLink(ROOT, 'repo-docs', {
+  source: 'SKILL.md',
+  target: '<this-folder>/references/missing.md',
+  reason: 'target does not exist',
+});
+check(badPlaceholder.category === 'local',
+  'unknown placeholder remains a real local-link problem');
+
+const repoScopeLink = classifyReportedLink(ROOT, 'multi-agent-workspace', {
+  source: 'workflows/01-init.md',
+  target: '../../README.md#supported-ai-ides--tools',
+  reason: 'link escapes skill directory',
+});
+check(repoScopeLink.category === 'resolved-contract' && repoScopeLink.issue.resolved === 'README.md',
+  'existing repo-scope relative link is resolved by the Harness repository contract');
+
+const missingRepoScopeLink = classifyReportedLink(ROOT, 'multi-agent-workspace', {
+  source: 'workflows/01-init.md',
+  target: '../../definitely-missing.md',
+  reason: 'link escapes skill directory',
+});
+check(missingRepoScopeLink.category === 'local',
+  'missing repo-scope relative link remains a hard local-link problem');
+
+const templateLink = classifyReportedLink(ROOT, 'repo-docs', {
+  source: 'templates/multi-skills-readme-template.md',
+  target: './skills/category/{skill-name}/SKILL.md',
+  reason: 'target does not exist',
+});
+check(templateLink.category === 'template',
+  'links inside generated-document templates remain visible template advisories');
+
+const synthetic = normalizeReport(ROOT, {
+  timestamp: new Date(0).toISOString(),
+  skills: [{
+    name: 'harness-everything',
+    path: path.join(ROOT, 'harness-everything'),
+    ready: false,
+    compliance: { level: 'High' },
+    tokenBudget: { exceeded: false },
+    specCompliance: [{ name: 'spec-frontmatter', passed: true }],
+    links: {
+      passed: false,
+      orphanedFiles: ['references/triage-and-tiers.md'],
+      deadURLs: [{ source: 'SKILL.md', target: 'https://example.invalid', reason: 'DNS lookup failed' }],
+      brokenLinks: [{ source: 'SKILL.md', target: '<workspace>/generated.md', reason: 'target does not exist' }],
+    },
+  }],
+});
+const compatibility = synthetic.skills[0].harnessCompatibility;
+check(compatibility.localLinksPassed === true,
+  'network and generic-template findings do not masquerade as broken local links');
+check(compatibility.networkAdvisories.length === 1 && compatibility.templateAdvisories.length === 1,
+  'network and template findings are retained in separate advisory categories');
+check(compatibility.harnessReady === true,
+  'normalized readiness remains green when only false-orphan/network/template advisories remain');
+
+const nonLinkFailure = normalizeSkillReport(ROOT, {
+  name: 'repo-docs',
+  path: path.join(ROOT, 'repo-docs'),
+  ready: false,
+  compliance: { level: 'Medium' },
+  tokenBudget: { exceeded: true },
+  specCompliance: [{ name: 'frontmatter', passed: false }],
+  schema: { valid: false },
+  links: { passed: true },
+});
+check(nonLinkFailure.harnessCompatibility.harnessReady === false &&
+  nonLinkFailure.harnessCompatibility.nonLinkFailures.includes('compliance:Medium') &&
+  nonLinkFailure.harnessCompatibility.nonLinkFailures.includes('token-budget-exceeded') &&
+  nonLinkFailure.harnessCompatibility.nonLinkFailures.includes('spec:frontmatter') &&
+  nonLinkFailure.harnessCompatibility.nonLinkFailures.includes('schema-invalid'),
+  'non-link readiness failures remain explicit machine-readable blockers');
+
+console.log('PASS: Waza/Harness reference adapter (' + passed + ' assertions across ' + skills.length + ' skills)');

package/docs/repository-contract.md

@@ -19,7 +19,7 @@ This page is generated from checked-in runtime and workflow sources. Do not edit
 | Workflow | Node.js versions | Explicit triggers | npm quality gates |
 | --- | --- | --- | --- |
 | `behavioral-evals.yml` | 24 | schedule, workflow_dispatch | n/a |
-| `ci.yml` | 22, 24 | workflow_call | `test`, `test:mutations`, `test:release:semantics`, `test:consistency`, `test:references`, `test:release`, `test:collision`, `test:plugin:openai`, `test:plugin:submission`, `test:platform:compatibility` |
+| `ci.yml` | 22, 24 | workflow_call | `test`, `test:mutations`, `test:release:semantics`, `waza:check`, `test:consistency`, `test:references`, `test:release`, `test:collision`, `test:plugin:openai`, `test:plugin:submission`, `test:platform:compatibility` |
 | `release.yml` | 24 | workflow_dispatch | n/a |
 
 ## Drift prevention

package/evals/multi-agent-workspace/tasks/positive-trigger.yaml

@@ -1,6 +1,6 @@
 id: positive-multi-agent-workspace-001
 name: On-scope prompt triggers multi-agent-workspace
-description: "Scaffold a verified multi-agent workspace and select bounded specialists from an external agency-agents catalog without vendoring the full roster."
+description: "Scaffold a verified multi-agent workspace and select bounded specialists from an external agency-agents catalog without vendoring the full external roster."
 tags:
   - positive-trigger
 inputs:

package/fable-mode/SKILL.md

@@ -4,7 +4,7 @@ description: "Stage large, multi-source or multi-session tasks through a written
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.9.0
+  version: 0.13.0
 ---
 
 # Fable Mode (v3)

package/fable-mode/execution-guardrails/SKILL.md

@@ -7,7 +7,7 @@ description: >-
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.9.0
+  version: 0.13.0
 ---
 
 # Execution Guardrails

package/fable-mode/fable-haiku/SKILL.md

@@ -4,7 +4,7 @@ description: "Run staged fable work on Haiku for bulk mechanical tasks with expl
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.9.0
+  version: 0.13.0
 ---
 
 # Fable Mode — Haiku

package/fable-mode/fable-opus/SKILL.md

@@ -4,7 +4,7 @@ description: "Run staged fable orchestration on Opus for cross-stage synthesis,
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.9.0
+  version: 0.13.0
 ---
 
 # Fable Mode — Opus

package/fable-mode/fable-sonnet/SKILL.md

@@ -4,7 +4,7 @@ description: "Run staged fable work on Sonnet for non-trivial implementation, re
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.9.0
+  version: 0.13.0
 ---
 
 # Fable Mode — Sonnet

package/fable-mode/references/model-matrix.md

@@ -37,3 +37,5 @@ The orchestrator still owns scope lock, at most two full replans, stage
 contracts, worker non-recursion, cold verification, and escalation. The native
 host TODO tracker or a Markdown checklist records stage progress; no CLI TODO
 state machine is part of this contract.
+
+See [execution phases](execution-phases.md) for the staged run contract.

package/harness-everything/SKILL.md

@@ -4,7 +4,7 @@ description: "Route software/project work through the Harness kernel: classify T
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.11.7
+  version: 0.13.0
 ---
 
 # Harness Everything

package/harness-everything/references/triage-and-tiers.md

@@ -177,3 +177,5 @@ node "<this-skill-dir>/scripts/self-heal.js" --check
 ```
 
 Respect an explicit user choice to remove/disable an integration.
+
+Related contracts: [router workflow plan](router-workflow-plan.md) and [skill registry](skill-registry.md).