harness-everything 0.31.2 → 0.31.3

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.31.2",
+      "version": "0.31.3",
       "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.31.2",
+  "version": "0.31.3",
   "author": {
     "name": "Miya Daniel"
   },

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All notable changes to this project are documented in this file.
 
+## [0.31.3](https://github.com/dyphn1/Harness-everything/compare/v0.31.2...v0.31.3) (2026-10-16)
+
+### Bug Fixes
+
+* **codex:** build runtime from tracked files and check previous runtime ([6bbb2c4](https://github.com/dyphn1/Harness-everything/commit/6bbb2c4c21c8bdecc69148e19126d0fe2b168328)), closes [#323](https://github.com/dyphn1/Harness-everything/issues/323)
+* **codex:** guard stale-lock reclaim with token checks ([abf4026](https://github.com/dyphn1/Harness-everything/commit/abf40263766c33619f8a2c62dd3c16752774b654)), closes [#323](https://github.com/dyphn1/Harness-everything/issues/323)
+* **codex:** retain compat runtimes and isolate test installs ([c5ee4e8](https://github.com/dyphn1/Harness-everything/commit/c5ee4e8c54dec758d77625913f1096aa281626a6))
+* **codex:** scope source guards and isolate test runner homes ([c9cf30b](https://github.com/dyphn1/Harness-everything/commit/c9cf30b6bb1a336f4eff03037de0e08ab7bf49e7))
+* **codex:** serialize compat installs on an owner lock ([b67e1c0](https://github.com/dyphn1/Harness-everything/commit/b67e1c0b95f16d0eae37485ab23ae4dfb1dc954a)), closes [#323](https://github.com/dyphn1/Harness-everything/issues/323) [#323](https://github.com/dyphn1/Harness-everything/issues/323)
+
 ## [0.31.2](https://github.com/dyphn1/Harness-everything/compare/v0.31.1...v0.31.2) (2026-10-15)
 
 ### Bug Fixes
@@ -29,6 +39,13 @@ All notable changes to this project are documented in this file.
 
 ## [Unreleased]
 
+### Fixed
+
+- Codex source guards ignore unrelated repository dirtiness and untracked packaged copies; test runners isolate child HOME and CODEX_HOME directories (#323).
+- Codex compatibility runtimes copy only Git-tracked plugin files, so ignored files cannot enter the runtime and do not block installs; `codex-hooks status` reports a missing or modified previous runtime as unhealthy, and the mechanism test fixture uses a portable Git config on Windows (#323).
+- Codex compatibility install/update/uninstall serialize on an owner lock so concurrent installs cannot garbage-collect each other's current runtime; stale-lock recovery is guarded and token-checked so it cannot remove a live holder's lock (#323).
+- Codex compatibility updates retain the current and previous runtime, reject unreleased checkout sources without explicit opt-in, and isolate plugin-sync tests from the real user hook installation (#323).
+
 ### Changes
 
 * **workflow:** replace topology-wide skill/reference pushes with ordered active-step bindings; carry the same contract through dependency-ready Fable stages while keeping hooks and Stop fail-open (#297).
@@ -36,6 +53,8 @@ All notable changes to this project are documented in this file.
 * **workflow:** resolve step/stage binding availability against real files (workspace references stay workspace-scoped; only recognized Harness bindings search installed plugin layouts); preserve knowledge signals across strategy recomposition; keep self-evolved manifest skills discoverable as metadata-only ids; positive skill evals assert skill-specific candidate bindings (#303 review).
 * **workflow:** reject present non-array required/optional binding declarations before accepting a requirement plan, preserving workflow state on invalid input (#303 review).
 * **test:** isolate verification fixtures from an inherited project-check recursion guard while preserving explicit guard coverage.
+* **workflow:** document blocked Fable recovery by revising the stage map while retaining approved requirements (#316).
+* **fable:** align execution phases with correlated workflow stages and scope the legacy/manual path (#317).
 
 ### Security
 

package/bin/cli.js

@@ -111,6 +111,7 @@ Commands:
   codex-hooks        Explicit Codex user-hook compatibility fallback for hosts
                      that fail to mount enabled plugin-bundled hooks.
                      Usage: harness codex-hooks <install|status|uninstall>
+                     [--codex-home <path>] [--allow-unreleased-source]
                      Does not trust hooks or modify Codex config.toml.
   plugin-sync        Install or update the native Harness plugin on Claude Code
                      and Codex. Existing installations always take the update

package/ci/lib/isolated-test-process.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const { spawnSync } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+// Do not rely on the caller remembering HOME/CODEX_HOME: even a test that
+// accidentally invokes a real installer must inherit a disposable user home.
+function spawnTestNode(args, options = {}) {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-test-home-'));
+  try {
+    return spawnSync(process.execPath, args, {
+      ...options,
+      env: {
+        ...process.env,
+        ...options.env,
+        HOME: home,
+        USERPROFILE: home,
+        CODEX_HOME: path.join(home, '.codex'),
+        APPDATA: path.join(home, 'AppData', 'Roaming'),
+        LOCALAPPDATA: path.join(home, 'AppData', 'Local'),
+      },
+    });
+  } finally {
+    fs.rmSync(home, { recursive: true, force: true });
+  }
+}
+
+module.exports = { spawnTestNode };

package/ci/mechanism-2al-codex-hooks-compat.test.js

@@ -64,7 +64,7 @@ fs.writeFileSync(configFile, 'model = "test"\n# user trust/config state\n', 'utf
 const configBefore = fs.readFileSync(configFile, 'utf8');
 
 try {
-  const installed = compat.install({ codexHome });
+  const installed = compat.install({ allowUnreleasedSource: true, codexHome });
   check(installed.status === 'installed' && installed.entries > 0,
     'explicit install materializes compatibility entries');
   check(installed.trustChanged === false && fs.readFileSync(configFile, 'utf8') === configBefore,
@@ -95,7 +95,7 @@ try {
     'compatibility runtime is self-contained for hook and router dependencies');
 
   const countsBefore = Object.fromEntries(Object.entries(config.hooks).map(([event, entries]) => [event, entries.length]));
-  const updated = compat.install({ codexHome });
+  const updated = compat.install({ allowUnreleasedSource: true, codexHome });
   const configAfterUpdate = read(hooksFile);
   const countsAfter = Object.fromEntries(Object.entries(configAfterUpdate.hooks).map(([event, entries]) => [event, entries.length]));
   check(updated.status === 'updated' && JSON.stringify(countsAfter) === JSON.stringify(countsBefore),
@@ -105,7 +105,7 @@ try {
   const addedUserHook = { hooks: [{ type: 'command', command: 'node "/user/later.js"', timeout: 3 }] };
   configAfterUpdate.hooks.PostToolUse.unshift(addedUserHook);
   fs.writeFileSync(hooksFile, JSON.stringify(configAfterUpdate, null, 2) + '\n', 'utf8');
-  compat.install({ codexHome });
+  compat.install({ allowUnreleasedSource: true, codexHome });
   check(read(hooksFile).hooks.PostToolUse.some(entry => entry.hooks?.[0]?.command === 'node "/user/later.js"'),
     'update preserves user hooks added after the initial compatibility install');
 
@@ -125,7 +125,7 @@ try {
   fs.writeFileSync(hooksFile, JSON.stringify(tampered, null, 2) + '\n', 'utf8');
   const tamperedBytes = fs.readFileSync(hooksFile, 'utf8');
   let updateRefused = false;
-  try { compat.install({ codexHome }); } catch (error) { updateRefused = /modified/.test(error.message); }
+  try { compat.install({ allowUnreleasedSource: true, codexHome }); } catch (error) { updateRefused = /modified/.test(error.message); }
   check(updateRefused && fs.readFileSync(hooksFile, 'utf8') === tamperedBytes,
     'modified Harness compatibility entry makes update fail closed without rewriting user config');
 
@@ -136,7 +136,7 @@ try {
 
   // Restore the exact generated config by starting from the pre-tamper bytes.
   fs.writeFileSync(hooksFile, beforeTamper, 'utf8');
-  compat.install({ codexHome });
+  compat.install({ allowUnreleasedSource: true, codexHome });
   const removed = compat.uninstall({ codexHome });
   const finalConfig = read(hooksFile);
   check(removed.status === 'uninstalled' && removed.removed > 0 && removed.trustChanged === false,
@@ -153,7 +153,7 @@ try {
 
   const emptyHome = path.join(root, 'empty-codex');
   fs.mkdirSync(emptyHome, { recursive: true });
-  compat.install({ codexHome: emptyHome });
+  compat.install({ allowUnreleasedSource: true, codexHome: emptyHome });
   check(fs.existsSync(path.join(emptyHome, 'hooks.json')),
     'compatibility install can create a new hooks.json when none exists');
   compat.uninstall({ codexHome: emptyHome });
@@ -164,7 +164,7 @@ try {
   const marketplaceHome = path.join(root, 'marketplace-codex');
   fs.cpSync(compat.SOURCE_PLUGIN_ROOT, marketplaceSource, { recursive: true });
   fs.writeFileSync(path.join(marketplaceSource, 'hooks', 'marketplace-source-marker.txt'), 'newer marketplace source\n');
-  const marketplaceInstall = compat.install({ codexHome: marketplaceHome, sourcePluginRoot: marketplaceSource });
+  const marketplaceInstall = compat.install({ allowUnreleasedSource: true, codexHome: marketplaceHome, sourcePluginRoot: marketplaceSource });
   const marketplaceManifest = read(path.join(marketplaceHome, 'harness-everything', 'compat-hooks', 'manifest.json'));
   check(marketplaceInstall.sourcePluginSha256 === compat.treeHash(marketplaceSource) &&
     marketplaceManifest.sourcePluginSha256 === compat.treeHash(marketplaceSource) &&
@@ -174,7 +174,7 @@ try {
 
   const duplicateHome = path.join(root, 'duplicate-codex');
   fs.mkdirSync(duplicateHome, { recursive: true });
-  compat.install({ codexHome: duplicateHome });
+  compat.install({ allowUnreleasedSource: true, codexHome: duplicateHome });
   const duplicateConfig = read(path.join(duplicateHome, 'hooks.json'));
   duplicateConfig.hooks.PreToolUse.push(JSON.parse(JSON.stringify(duplicateConfig.hooks.PreToolUse[0])));
   fs.writeFileSync(path.join(duplicateHome, 'hooks.json'), JSON.stringify(duplicateConfig, null, 2) + '\n', 'utf8');
@@ -187,7 +187,7 @@ try {
   const removedConfigHome = path.join(root, 'removed-config-codex');
   fs.mkdirSync(removedConfigHome, { recursive: true });
   fs.writeFileSync(path.join(removedConfigHome, 'hooks.json'), JSON.stringify(original, null, 2) + '\n', 'utf8');
-  compat.install({ codexHome: removedConfigHome });
+  compat.install({ allowUnreleasedSource: true, codexHome: removedConfigHome });
   fs.rmSync(path.join(removedConfigHome, 'hooks.json'), { force: true });
   const removedConfigResult = compat.uninstall({ codexHome: removedConfigHome });
   check(removedConfigResult.status === 'uninstalled' && !fs.existsSync(path.join(removedConfigHome, 'hooks.json')),
@@ -206,7 +206,7 @@ try {
   fs.writeFileSync(path.join(preexistingHome, 'hooks.json'),
     JSON.stringify({ hooks: preexistingHooks }, null, 2) + '\n', 'utf8');
   const preexistingBefore = fs.readFileSync(path.join(preexistingHome, 'hooks.json'), 'utf8');
-  const preexistingInstall = compat.install({ codexHome: preexistingHome });
+  const preexistingInstall = compat.install({ allowUnreleasedSource: true, codexHome: preexistingHome });
   const preexistingManifest = read(path.join(preexistingHome, 'harness-everything', 'compat-hooks', 'manifest.json'));
   check(preexistingInstall.status === 'installed' && preexistingManifest.entries.length === 0,
     'byte-identical pre-existing user hooks are reused but never recorded as Harness-owned');
@@ -219,7 +219,7 @@ try {
   fs.mkdirSync(forgedManifestHome, { recursive: true });
   fs.writeFileSync(path.join(forgedManifestHome, 'hooks.json'),
     JSON.stringify({ hooks: { PreToolUse: [userHook] } }, null, 2) + '\n', 'utf8');
-  compat.install({ codexHome: forgedManifestHome });
+  compat.install({ allowUnreleasedSource: true, codexHome: forgedManifestHome });
   const forgedManifestPath = path.join(
     forgedManifestHome, 'harness-everything', 'compat-hooks', 'manifest.json');
   const forgedManifest = read(forgedManifestPath);
@@ -254,7 +254,7 @@ try {
     }
     return realRenameSync(source, destination);
   };
-  try { compat.install({ codexHome: failedInstallHome }); }
+  try { compat.install({ allowUnreleasedSource: true, codexHome: failedInstallHome }); }
   catch (error) { failedInstallRefused = /injected manifest commit failure/.test(error.message); }
   finally { fs.renameSync = realRenameSync; }
   check(failedInstallRefused &&
@@ -272,7 +272,7 @@ try {
     process.platform === 'win32' ? 'junction' : 'dir'
   );
   let linkedOwnerRefused = false;
-  try { compat.install({ codexHome: linkedOwnerHome }); }
+  try { compat.install({ allowUnreleasedSource: true, codexHome: linkedOwnerHome }); }
   catch (error) { linkedOwnerRefused = /linked|outside/.test(error.message); }
   check(linkedOwnerRefused && fs.readdirSync(linkedOwnerOutside).length === 0,
     'linked compatibility owner path cannot redirect writes outside Codex home');
@@ -283,7 +283,7 @@ try {
   fs.writeFileSync(malformed, '{ this is not json', 'utf8');
   const malformedBefore = fs.readFileSync(malformed, 'utf8');
   let malformedRefused = false;
-  try { compat.install({ codexHome: malformedHome }); } catch (_) { malformedRefused = true; }
+  try { compat.install({ allowUnreleasedSource: true, codexHome: malformedHome }); } catch (_) { malformedRefused = true; }
   check(malformedRefused && fs.readFileSync(malformed, 'utf8') === malformedBefore,
     'malformed user hooks.json fails closed without replacement');
 

package/ci/mechanism-2ao-plugin-sync.test.js

@@ -15,6 +15,17 @@ const {
 
 const ROOT = path.resolve(__dirname, '..');
 const codexHooksCompat = require('../scripts/codex-hooks-compat');
+// A fake host runner does not mock the compatibility installer's filesystem
+// writes. Fail closed if any case forgets to pass its explicit temporary home.
+const realInstall = codexHooksCompat.install;
+codexHooksCompat.install = options => {
+  assert(options && options.codexHome, 'tests must supply an explicit temporary Codex home');
+  const relative = path.relative(os.tmpdir(), path.resolve(options.codexHome));
+  assert(relative && !relative.startsWith('..') && !path.isAbsolute(relative),
+    'test Codex home must be inside the temporary directory');
+  return realInstall(options);
+};
+
 
 function fakeHost({ claudeInstalled = false, codexInstalled = false, codexPluginSourcePath = path.join(ROOT, 'plugins', 'harness-everything'), codexPluginSourceType = 'local', codexAvailableOnly = false, claudeMarketplace = true, codexMarketplace = true, unknownClaudePluginState = false, unknownClaudeYesFlag = false, unknownClaudeJsonFlag = false, clapCodexJsonFlag = false, missingCodexPluginCommand = false, codexHooksError = null } = {}) {
   const calls = [];
@@ -283,7 +294,9 @@ for (const sourceType of ['git', 'npm', 'remote', 'unknown']) {
 {
   const codexHome = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-plugin-sync-codex-home-'));
   try {
-    const fake = fakeHost({ codexInstalled: true });
+    const source = path.join(codexHome, 'plugin-cache');
+    fs.cpSync(codexHooksCompat.SOURCE_PLUGIN_ROOT, source, { recursive: true });
+    const fake = fakeHost({ codexInstalled: true, codexPluginSourcePath: source });
     const result = sync({ host: 'codex', codexHome }, {
       runner: fake.runner,
       commandAvailable: fake.commandAvailable,
@@ -368,18 +381,22 @@ for (const sourceType of ['git', 'npm', 'remote', 'unknown']) {
   // progress notice emitted before that work starts, the terminal stays
   // silent for the whole run, which is indistinguishable from a hang.
   const events = [];
+  const codexHome = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-progress-codex-'));
   const fake = fakeHost({ claudeInstalled: true, codexInstalled: true });
   const runner = (command, args, opts) => {
     events.push(`call:${command}`);
     return fake.runner(command, args, opts);
   };
-  const result = sync({ host: 'all', repository: 'dyphn1/Harness-everything', ref: 'main' }, {
+  const result = sync({ host: 'all', codexHome, repository: 'dyphn1/Harness-everything', ref: 'main' }, {
     runner,
+    codexHooksInstall: fake.codexHooksInstall,
     commandAvailable: () => true,
     log: () => {},
     warn: message => events.push(`warn:${message}`)
   });
   assert.strictEqual(result.failed, 0);
+  fs.rmSync(codexHome, { recursive: true, force: true });
+  assert.strictEqual(fake.codexHookInstalls.length, 1, 'progress test must mock hook installation as well as host commands');
   assert.ok(events.includes('warn:[...] claude: syncing'), 'a claude progress notice must be emitted');
   assert.ok(events.includes('warn:[...] codex: syncing'), 'a codex progress notice must be emitted');
   assert.ok(events.indexOf('warn:[...] claude: syncing') < events.indexOf('call:claude'), 'the claude notice must be emitted before its first host command, not buffered until the run finishes');

package/ci/mechanism-2at-fable-execution-phases.test.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+
+const ROOT = path.resolve(__dirname, '..');
+const guide = fs.readFileSync(path.join(ROOT, 'fable-mode/references/execution-phases.md'), 'utf8');
+const packagedGuide = fs.readFileSync(path.join(ROOT, 'plugins/harness-everything/skills/fable-mode/references/execution-phases.md'), 'utf8');
+const contract = fs.readFileSync(path.join(ROOT, 'fable-mode/CONTRACT-FORMAT.md'), 'utf8');
+const activeStart = guide.indexOf('## Active workflow');
+const recoveryStart = guide.indexOf('## Blocked recovery');
+const legacyStart = guide.indexOf('## Legacy/manual fallback');
+const active = guide.slice(activeStart, recoveryStart);
+const legacyPath = '.claude/harness-everything/state/contracts/';
+
+assert.strictEqual(packagedGuide, guide, 'OpenAI package includes the canonical execution phases reference');
+assert.ok(activeStart >= 0 && recoveryStart > activeStart, 'active workflow and blocked recovery are explicit sections');
+assert.ok(legacyStart > recoveryStart, 'legacy instructions are isolated after current recovery guidance');
+assert.match(active, /workflow-stages\.json/);
+assert.match(active, /workflow-disposition\.js.*start/s);
+assert.match(active, /stage-binding.*--session-id.*--stage-id.*--binding-id.*--disposition.*--evidence/s);
+assert.match(active, /contract-test\.js/);
+assert.match(active, /worker identity/i);
+assert.match(active, /exit code/i);
+assert.match(active, /semantic MUSTs/i);
+assert.match(active, /reminder-only/i);
+assert.match(active, /without locking\s+ordinary tools or Stop/i);
+assert.ok(!active.includes(legacyPath), 'active workflows never use the legacy contracts path');
+assert.match(contract, /workflow-stages\.json/);
+assert.match(contract, /stage results need observed worker identities and numeric exit codes/i);
+
+const recovery = guide.slice(recoveryStart, legacyStart);
+assert.match(recovery, /workflow already running; record a blocker before replanning/);
+assert.match(recovery, /workflow-disposition\.js.*block/s);
+assert.match(recovery, /workflow-stages\.json/);
+assert.match(recovery, /workflow-disposition\.js.*start/s);
+assert.match(recovery, /retaining|preserving/i);
+assert.match(recovery, /plan.*blocked|blocked.*plan/s);
+
+assert.match(guide, /behavior profile|role\/profile alias/i);
+assert.match(guide, /explicit user or\s+host runtime choice/i);
+assert.doesNotMatch(guide, /Resolve requested model|Opus macro work|do not silently change models/i);
+assert.match(guide.slice(legacyStart), /`\.claude\/harness-everything\/state\/contracts\//);
+
+console.log('PASS Fable execution phases match the active workflow contract and preserve a scoped legacy fallback');