harness-everything 0.30.4 → 0.30.6

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

package/CHANGELOG.md

@@ -2,6 +2,44 @@
 
 All notable changes to this project are documented in this file.
 
+## [0.30.6](https://github.com/dyphn1/Harness-everything/compare/v0.30.5...v0.30.6) (2026-10-06)
+
+### Bug Fixes
+
+* **fable-mode:** align Claude nested skill contract ([aadfe34](https://github.com/dyphn1/Harness-everything/commit/aadfe349e6f9a6ce9623f9b408ad8c6d9958208e))
+* **fable-mode:** compress guardrail reference contract ([302efcd](https://github.com/dyphn1/Harness-everything/commit/302efcd0433c75be10619dbad7aa2b925b57400f))
+* **fable-mode:** preserve unknown audit states and raw aliases ([2716be9](https://github.com/dyphn1/Harness-everything/commit/2716be9feb3e6b986c0f5da884ed4a686b95791b))
+* **fable-mode:** remove residual model-gated routing ([32fee42](https://github.com/dyphn1/Harness-everything/commit/32fee423e9af7416172bf146cb876f72d61e331e))
+* **fable-mode:** stay within skill token budget ([d934d36](https://github.com/dyphn1/Harness-everything/commit/d934d36cef17d5e0b30dfffd888cdab5d7c9a747))
+* **fable:** accept curly-quoted lookups and restore execution deep dive ([08517e4](https://github.com/dyphn1/Harness-everything/commit/08517e4469bab46042358df136446e2495144a7f)), closes [#290](https://github.com/dyphn1/Harness-everything/issues/290)
+* **fable:** dispatch profile lookups before loading stage references ([58ce883](https://github.com/dyphn1/Harness-everything/commit/58ce8834d3fa0ab288f9106f26758d4945ca49b6)), closes [#290](https://github.com/dyphn1/Harness-everything/issues/290)
+* **router:** preserve Fable profile alias across normalization ([50e84da](https://github.com/dyphn1/Harness-everything/commit/50e84da3f14216800e4c757996663debfb7a8f7a))
+* **router:** scope fable lookup negations to their own list ([032b52b](https://github.com/dyphn1/Harness-everything/commit/032b52bba809237c4b891e44fc7ee7b082262ddb)), closes [#290](https://github.com/dyphn1/Harness-everything/issues/290)
+* **router:** select bounded Fable profile lookups before staged topology ([0d6fdac](https://github.com/dyphn1/Harness-everything/commit/0d6fdac675a9225f9425fcb699444992032371a3)), closes [#290](https://github.com/dyphn1/Harness-everything/issues/290)
+
+## [Unreleased]
+
+### Fixed
+
+- Select a bounded Fable profile lookup before loading staged workflow references; preserve execution topology and required obligations (#290).
+- Validate entire Fable lookup clauses so same-clause execution keeps its obligations, while canonical JSON field lists remain bounded lookups (#294).
+- Scope lookup negations to their own noun list so an un-negated action after a negation keeps execution routing (#294).
+
+## [0.30.5](https://github.com/dyphn1/Harness-everything/compare/v0.30.4...v0.30.5) (2026-10-06)
+
+### Bug Fixes
+
+* align Windows PowerShell quick-start contract ([f780f77](https://github.com/dyphn1/Harness-everything/commit/f780f777559d14f9bcf929793d954ddcaf2c6cf7))
+* enforce Windows-safe shell contract ([a373a16](https://github.com/dyphn1/Harness-everything/commit/a373a16f5bdd3659e290715c971f530e66ffe2c1))
+* fit Harness routing contract within budget ([6fa9065](https://github.com/dyphn1/Harness-everything/commit/6fa90657611bcbc85f669e864a3245b469e99d23))
+* keep host-shell invariant within skill budget ([1381dc9](https://github.com/dyphn1/Harness-everything/commit/1381dc9877a0facccbea8f31a3047055eabaf5b2))
+* preserve semantic contract phrases within Waza budget ([ab29217](https://github.com/dyphn1/Harness-everything/commit/ab292175cc691c6bd01d1e0da219a15c6779f7be))
+* preserve skill metadata while restoring token budget ([189660a](https://github.com/dyphn1/Harness-everything/commit/189660ad6283ecad84d8a07232515fd80da6691c))
+* restore Harness skill token budget ([80b1eee](https://github.com/dyphn1/Harness-everything/commit/80b1eeeceb681d9551bfbe4d3c881ae2c3e5747f))
+* restore required skill sections within Waza budget ([acbb314](https://github.com/dyphn1/Harness-everything/commit/acbb314ec4e7769c2a2c253918ac67e1158052fe))
+* show Windows-safe npx entry point ([d208b77](https://github.com/dyphn1/Harness-everything/commit/d208b7735912b7282dc158068b3e5c17a5c62e0d))
+* sync packaged Windows shell contract ([201eb5a](https://github.com/dyphn1/Harness-everything/commit/201eb5a53cbea4e696db633f857b6c30c15f1855))
+
 ## [0.30.4](https://github.com/dyphn1/Harness-everything/compare/v0.30.3...v0.30.4) (2026-10-01)
 
 ### Bug Fixes

package/README.md

@@ -56,12 +56,14 @@ Harness integrates directly into your workspace. There is no heavy daemon, no pa
 #   /plugin install harness-everything
 
 # Option B: install Harness hooks/skills/advisory integrations into your workspace
-npx github:dyphn1/Harness-everything install
+npx github:dyphn1/Harness-everything install                 # POSIX shells / Git Bash
+npx.cmd github:dyphn1/Harness-everything install             # Windows PowerShell
 
 # Option C: install or update the native Claude Code/Codex plugin
-#   npx github:dyphn1/Harness-everything plugin-sync
-#   ./scripts/plugin-sync.sh              # POSIX shells / Git Bash
-#   powershell -File scripts/plugin-sync.ps1  # Windows PowerShell
+#   npx github:dyphn1/Harness-everything plugin-sync       # POSIX shells / Git Bash
+#   npx.cmd github:dyphn1/Harness-everything plugin-sync   # Windows PowerShell
+#   ./scripts/plugin-sync.sh                               # POSIX shells / Git Bash
+#   node scripts/plugin-sync.js                            # Windows-safe direct entry
 
 # OpenAI/Codex local plugin packaging is repository-owned under:
 #   .agents/plugins/marketplace.json
@@ -69,6 +71,8 @@ npx github:dyphn1/Harness-everything install
 # See docs/openai-plugin.md for local import/install and public Skills-only submission.
 ```
 
+**Windows PowerShell:** use npm-family `.cmd` shims such as `npx.cmd` rather than weakening `ExecutionPolicy`. When reading Harness Markdown from Windows PowerShell 5.1, specify UTF-8 explicitly, for example `Get-Content -Encoding UTF8 -Raw <path>`.
+
 ### Expected Behavior After Installation:
 1. **Use the selected surface's real mechanism:** Claude Code hooks, the local OpenAI plugin lifecycle hooks, OpenCode's plugin API, or advisory instructions depending on what you installed.
 2. **Preflight / session context where packaged:** Hook-capable surfaces can inject environment/session context automatically; advisory-only surfaces must not be described as if they do.
@@ -100,9 +104,15 @@ The native `plugin-sync` command detects the installed host CLIs and applies the
 The installer records its state directories in `.git/info/exclude` — a local-only git ignore file — so Harness state never lands in a commit and your working tree (including `.gitignore`) is never modified. Everything owned by the general installer is removed with the built-in uninstaller:
 
 ```bash
-npx github:dyphn1/Harness-everything uninstall            # interactive
-npx github:dyphn1/Harness-everything uninstall --local --skills -y   # non-interactive, workspace only
-npx github:dyphn1/Harness-everything uninstall --global   # also remove Harness-owned global state
+# POSIX shells / Git Bash
+npx github:dyphn1/Harness-everything uninstall
+npx github:dyphn1/Harness-everything uninstall --local --skills -y
+npx github:dyphn1/Harness-everything uninstall --global
+
+# Windows PowerShell
+npx.cmd github:dyphn1/Harness-everything uninstall
+npx.cmd github:dyphn1/Harness-everything uninstall --local --skills -y
+npx.cmd github:dyphn1/Harness-everything uninstall --global
 ```
 
 ---

package/bin/cli.js

@@ -55,6 +55,11 @@ Harness OS - AI Agent Operating System CLI
 
 Usage:
   npx github:dyphn1/Harness-everything <command> [options]
+  npx.cmd github:dyphn1/Harness-everything <command> [options]  # Windows PowerShell
+
+Windows PowerShell note:
+  Use npx.cmd so restrictive ExecutionPolicy cannot redirect this command to npx.ps1.
+  Harness does not require changing ExecutionPolicy.
   
 Commands:
   install            Install Harness OS hooks & skills into the local repository

package/ci/fable-mode-test.js

@@ -5,6 +5,7 @@ const fs = require('fs');
 const os = require('os');
 const { spawnSync } = require('child_process');
 const path = require('path');
+const { evaluateRuntimeFloor } = require('../fable-mode/scripts/model-selector.js');
 
 const root = path.resolve(__dirname, '..');
 const selector = path.join(root, 'fable-mode', 'scripts', 'model-selector.js');
@@ -13,19 +14,17 @@ const auditDir = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-fable-mode-'));
 const auditFile = path.join(auditDir, 'audit.jsonl');
 
 function runNode(file, args) {
-  return spawnSync(process.execPath, [file, ...args], {
-    cwd: root,
-    encoding: 'utf8'
-  });
+  return spawnSync(process.execPath, [file, ...args], { cwd: root, encoding: 'utf8' });
 }
 
 function selectorArgs(overrides = {}) {
   const input = {
     requested: 'opus',
-    available: 'opus,sonnet,haiku',
     'available-agents': 'fable-orchestrator,fable-worker-sonnet,fable-worker-haiku',
     fallback: 'stop',
-    'host-model': 'opus',
+    host: 'codex',
+    'runtime-model': 'gpt-6.1-sol',
+    'runtime-effort': 'xhigh',
     'audit-file': auditFile,
     'stage-brief': 'Choose the architecture',
     'pass-condition': 'ADR exists and names the decision',
@@ -33,104 +32,166 @@ function selectorArgs(overrides = {}) {
     'verifier-result': 'pending',
     ...overrides
   };
-  return Object.entries(input).flatMap(([key, value]) => [`--${key}`, value]);
+  return Object.entries(input).flatMap(([key, value]) => ['--' + key, String(value)]);
 }
 
 function readRecord(result) {
-  assert.ok(result.stdout.trim(), `selector produced no JSON: ${result.stderr}`);
+  assert.ok(result.stdout.trim(), 'selector produced no JSON: ' + result.stderr);
   return JSON.parse(result.stdout);
 }
 
-console.log('=== Fable model mode contract tests ===');
+console.log('=== Fable behavior profile + runtime floor contract tests ===');
+
+const publicDescription = 'Stage large tasks through plans, named fable agents, failable checks, and skeptical review; fable on opus|sonnet|haiku selects a behavior profile, not a runtime model.';
+const fableSkillText = fs.readFileSync(path.join(root, 'fable-mode', 'SKILL.md'), 'utf8');
+assert.ok(fableSkillText.includes('description: "' + publicDescription + '"'));
+
+for (const task of ['positive-opus-mode.yaml', 'positive-sonnet-mode.yaml', 'positive-haiku-mode.yaml', 'positive-trigger.yaml']) {
+  const source = fs.readFileSync(path.join(root, 'evals', 'fable-mode', 'tasks', task), 'utf8');
+  assert.ok(source.includes('description: "' + publicDescription + '"'), task + ' must keep the exact public fable-mode description');
+}
+
+const behavior = JSON.parse(fs.readFileSync(path.join(root, 'fable-mode', 'behavior-profile-matrix.json'), 'utf8'));
+assert.strictEqual(behavior.profiles.orchestrator.legacyAlias, 'opus');
+assert.ok(behavior.profiles.reasoning.aliases.includes('sonnect'));
+
+const floors = JSON.parse(fs.readFileSync(path.join(root, 'fable-mode', 'runtime-model-floor-matrix.json'), 'utf8'));
+assert.strictEqual(floors.hosts.claude.orchestrator.minVersion, '5.5');
+assert.strictEqual(floors.hosts.claude.orchestrator.minEffort, 'medium');
+assert.strictEqual(floors.hosts.claude.reasoning.minVersion, '5.5');
+assert.strictEqual(floors.hosts.claude.mechanical.minVersion, '5.5');
+assert.strictEqual(floors.hosts.codex.orchestrator.minGeneration, 6);
+assert.strictEqual(floors.hosts.codex.orchestrator.minEffort, 'xhigh');
+assert.strictEqual(floors.hosts.codex.reasoning.minEffort, 'medium');
+assert.strictEqual(floors.hosts.codex.mechanical.family, 'luna');
+assert.strictEqual(floors.hosts.codex.mechanical.minEffort, 'xhigh');
+
+for (const profile of ['fable-opus', 'fable-sonnet', 'fable-haiku']) {
+  const source = fs.readFileSync(path.join(root, 'fable-mode', profile, 'SKILL.md'), 'utf8');
+  assert.match(source, /Reference profile, not a standalone plugin skill/);
+}
+for (const agent of ['fable-orchestrator.md', 'fable-worker-sonnet.md', 'fable-worker-haiku.md', 'fable-verifier.md']) {
+  const source = fs.readFileSync(path.join(root, 'fable-mode', 'agents', agent), 'utf8');
+  assert.match(source, /^model: inherit$/m, agent + ' must not pin a branded runtime model');
+}
+
+const guardrailSource = fs.readFileSync(path.join(root, 'fable-mode', 'execution-guardrails', 'SKILL.md'), 'utf8');
+assert.match(guardrailSource, /reference-only, not an always-on carrier/);
+assert.doesNotMatch(guardrailSource, /These rules are always-on/);
 
 const selected = runNode(selector, selectorArgs());
 assert.strictEqual(selected.status, 0, selected.stderr);
 const selectedRecord = readRecord(selected);
 assert.strictEqual(selectedRecord.status, 'selected');
-assert.strictEqual(selectedRecord.requestedModel, 'opus');
-assert.strictEqual(selectedRecord.effectiveModel, 'opus');
-assert.strictEqual(selectedRecord.fallbackReason, 'none');
+assert.strictEqual(selectedRecord.requestedProfile, 'orchestrator');
+assert.strictEqual(selectedRecord.effectiveProfile, 'orchestrator');
+assert.strictEqual(selectedRecord.profileAlias, 'opus');
 assert.strictEqual(selectedRecord.agent, 'fable-orchestrator');
+assert.strictEqual(selectedRecord.runtimeFloorStatus, 'meets-recommended');
 
-const sonnect = runNode(selector, selectorArgs({ requested: 'sonnect', available: 'haiku,sonnet' }));
+const sonnect = runNode(selector, selectorArgs({
+  requested: 'sonnect',
+  host: 'claude',
+  'runtime-model': 'claude-sonnet-5.5',
+  'runtime-effort': 'medium'
+}));
 assert.strictEqual(sonnect.status, 0, sonnect.stderr);
 const sonnectRecord = readRecord(sonnect);
-assert.strictEqual(sonnectRecord.requestedModel, 'sonnet');
-assert.strictEqual(sonnectRecord.requestedInput, 'sonnect');
+assert.strictEqual(sonnectRecord.requestedProfile, 'reasoning');
+assert.strictEqual(sonnectRecord.profileAlias, 'sonnect');
+assert.strictEqual(sonnectRecord.runtimeFloorStatus, 'meets-recommended');
 
-const inline = runNode(selector, selectorArgs({
+const belowFloor = runNode(selector, selectorArgs({
   requested: 'opus',
-  available: 'sonnet',
-  fallback: 'inline',
-  'host-model': 'sonnet'
+  host: 'codex',
+  'runtime-model': 'gpt-6-sol',
+  'runtime-effort': 'medium'
+}));
+assert.strictEqual(belowFloor.status, 0, belowFloor.stderr);
+const belowFloorRecord = readRecord(belowFloor);
+assert.strictEqual(belowFloorRecord.status, 'selected');
+assert.strictEqual(belowFloorRecord.effectiveProfile, 'orchestrator');
+assert.strictEqual(belowFloorRecord.runtimeFloorStatus, 'below-recommended');
+assert.strictEqual(belowFloorRecord.escalationRequired, false);
+
+const unknownFamily = evaluateRuntimeFloor('reasoning', {
+  host: 'codex',
+  runtimeModel: 'vendor-private-model',
+  runtimeEffort: 'xhigh'
+});
+assert.strictEqual(unknownFamily.status, 'unknown');
+assert.match(unknownFamily.reason, /not comparable/);
+
+const unknownEffort = evaluateRuntimeFloor('reasoning', {
+  host: 'codex',
+  runtimeModel: 'gpt-6.1-sol',
+  runtimeEffort: 'custom-effort'
+});
+assert.strictEqual(unknownEffort.status, 'unknown');
+assert.match(unknownEffort.reason, /not comparable/);
+
+const inline = runNode(selector, selectorArgs({
+  requested: 'sonnet',
+  'available-agents': 'fable-worker-haiku',
+  fallback: 'inline'
 }));
 assert.strictEqual(inline.status, 0, inline.stderr);
 const inlineRecord = readRecord(inline);
 assert.strictEqual(inlineRecord.status, 'fallback');
-assert.strictEqual(inlineRecord.effectiveModel, 'sonnet');
-assert.match(inlineRecord.fallbackReason, /opus is not in availableModels/);
-assert.strictEqual(inlineRecord.escalationRequired, false);
+assert.strictEqual(inlineRecord.effectiveProfile, 'reasoning');
+assert.match(inlineRecord.fallbackReason, /execute the same reasoning behavior profile inline/);
 
-const blocked = runNode(selector, selectorArgs({ requested: 'opus', available: 'sonnet' }));
+const blocked = runNode(selector, selectorArgs({
+  requested: 'sonnet',
+  'available-agents': 'fable-worker-haiku',
+  fallback: 'stop'
+}));
 assert.strictEqual(blocked.status, 2);
 const blockedRecord = readRecord(blocked);
 assert.strictEqual(blockedRecord.status, 'blocked');
-assert.strictEqual(blockedRecord.effectiveModel, null);
+assert.strictEqual(blockedRecord.effectiveProfile, null);
 assert.strictEqual(blockedRecord.escalationRequired, true);
 assert.match(blockedRecord.fallbackReason, /inline fallback was not authorized/);
 
-const missingAgent = runNode(selector, selectorArgs({
-  requested: 'sonnet',
-  available: 'sonnet',
-  'available-agents': 'fable-worker-haiku',
-  fallback: 'inline',
-  'host-model': 'opus'
-}));
-assert.strictEqual(missingAgent.status, 0, missingAgent.stderr);
-const missingAgentRecord = readRecord(missingAgent);
-assert.strictEqual(missingAgentRecord.status, 'fallback');
-assert.strictEqual(missingAgentRecord.effectiveModel, 'opus');
-assert.match(missingAgentRecord.fallbackReason, /fable-worker-sonnet is not in availableAgents/);
-
 const missingField = runNode(selector, selectorArgs({ 'pass-condition': '' }));
 assert.strictEqual(missingField.status, 2);
 assert.match(missingField.stderr, /passCondition is required/);
 
 const explicitRoute = runNode(router, ['fable on sonnect for architecture synthesis']);
 assert.strictEqual(explicitRoute.status, 0);
-assert.match(explicitRoute.stdout, /REQUESTED FABLE MODEL MODE: sonnet/);
-assert.match(explicitRoute.stdout, /fable-mode\/fable-sonnet\/SKILL\.md/);
+assert.match(explicitRoute.stdout, /REQUESTED FABLE PROFILE: sonnect/);
+assert.match(explicitRoute.stdout, /=> ROUTE: fable-mode\/SKILL\.md/);
+assert.doesNotMatch(explicitRoute.stdout, /REQUESTED FABLE MODEL MODE/);
+assert.doesNotMatch(explicitRoute.stdout, /=> ROUTE: fable-mode\/fable-sonnet\/SKILL\.md/);
 
 const ordinaryTier2 = runNode(router, ['Fix this checkout bug and add a regression test.']);
 assert.strictEqual(ordinaryTier2.status, 0);
 assert.match(ordinaryTier2.stdout, /RECOMMENDED TIER: Tier 2/);
-assert.doesNotMatch(ordinaryTier2.stdout, /REQUESTED FABLE MODEL MODE/);
-assert.doesNotMatch(ordinaryTier2.stdout, /fable-opus\/SKILL\.md/);
+assert.doesNotMatch(ordinaryTier2.stdout, /REQUESTED FABLE PROFILE/);
 
 const warningBatchContract = '**Warning batching.** Collect minor concerns and list them together in the next natural report or handoff; their count alone MUST NOT stop, pause, or return the worker/stage. An independently material, confirmed concern may stop the current stage and be surfaced immediately.';
 for (const rel of [
   'fable-mode/agents/fable-worker-haiku.md',
   'fable-mode/agents/fable-worker-sonnet.md',
   'fable-mode/agents/fable-orchestrator.md',
-  'fable-mode/execution-guardrails/SKILL.md',
+  'fable-mode/execution-guardrails/SKILL.md'
 ]) {
   const prompt = fs.readFileSync(path.join(root, rel), 'utf8').replace(/\s+/g, ' ');
-  assert.ok(prompt.includes(warningBatchContract), `${rel} must keep minor-concern batching reporting-only`);
-  assert.doesNotMatch(
-    prompt,
-    /minor concerns.{0,200}stop and surface all at once before continuing/i,
-    `${rel} must not introduce a warning-count stop condition`
-  );
+  assert.ok(prompt.includes(warningBatchContract), rel + ' must keep minor-concern batching reporting-only');
 }
 
 const auditLines = fs.readFileSync(auditFile, 'utf8').trim().split(/\r?\n/).filter(Boolean);
 assert.strictEqual(auditLines.length, 5);
 for (const line of auditLines) {
   const record = JSON.parse(line);
-  for (const field of ['requestedModel', 'effectiveModel', 'fallbackReason', 'stageBrief', 'passCondition', 'verificationCommand', 'verifierResult']) {
-    assert.ok(Object.prototype.hasOwnProperty.call(record, field), `audit missing ${field}`);
+  for (const field of [
+    'requestedProfile', 'effectiveProfile', 'profileAlias', 'runtimeModel', 'runtimeEffort',
+    'recommendedRuntimeFloor', 'runtimeFloorStatus', 'runtimeFloorReason', 'fallbackReason',
+    'stageBrief', 'passCondition', 'verificationCommand', 'verifierResult'
+  ]) {
+    assert.ok(Object.prototype.hasOwnProperty.call(record, field), 'audit missing ' + field);
   }
 }
 fs.rmSync(auditDir, { recursive: true, force: true });
 
-console.log('PASS: selected, sonnect alias, inline fallback, blocked escalation, audit fields, and routing separation');
+console.log('PASS: profiles are behavior contracts; runtime floors are advisory; agent fallback remains explicit');

package/ci/mechanism-2t-workspace-identity.test.js

@@ -131,7 +131,9 @@ check('hooks can resolve state from a bound session after cwd changes', result.s
 const installed = path.join(fixture, 'installed', 'fable-mode', 'scripts');
 fs.mkdirSync(installed, { recursive: true });
 fs.copyFileSync(path.join(root, 'fable-mode', 'scripts', 'model-selector.js'), path.join(installed, 'model-selector.js'));
-fs.copyFileSync(path.join(root, 'fable-mode', 'model-matrix.json'), path.join(installed, '..', 'model-matrix.json'));
+for (const matrix of ['behavior-profile-matrix.json', 'runtime-model-floor-matrix.json']) {
+  fs.copyFileSync(path.join(root, 'fable-mode', matrix), path.join(installed, '..', matrix));
+}
 const fable = path.join(installed, 'model-selector.js');
 const fableArgs = ['--requested', 'haiku', '--available', 'haiku', '--available-agents', 'fable-worker-haiku', '--stage-brief', 'identity', '--pass-condition', 'audit', '--verification-command', 'node test', '--verifier-result', 'pass', '--session-id', 'issue-42-fable-session'];
 result = spawnSync(process.execPath, [fable, ...fableArgs], { cwd: outer, env: baseEnv, encoding: 'utf8' });

package/ci/mechanism-2w-platform-compatibility.test.js

@@ -152,7 +152,46 @@ try {
   fs.rmSync(tempOutput.replace(/\.zip$/i, '') + '.manifest.json', { force: true });
 }
 
+// Windows PowerShell 5.1 treats BOM-less UTF-8 as a legacy code page when
+// Get-Content has no explicit encoding, and resolves bare npm-family commands
+// to .ps1 shims before .cmd. The routing skill is the agent-facing boundary
+// that must prevent both failures before Harness itself starts.
+const canonicalHarnessSkill = fs.readFileSync(path.join(ROOT, 'harness-everything', 'SKILL.md'), 'utf8');
+const packagedHarnessSkill = fs.readFileSync(path.join(ROOT, 'plugins', 'harness-everything', 'skills', 'harness-everything', 'SKILL.md'), 'utf8');
+assert.match(canonicalHarnessSkill, /Windows PowerShell/);
+assert.match(canonicalHarnessSkill, /npx\.cmd/);
+assert.match(canonicalHarnessSkill, /Get-Content -Encoding UTF8 -Raw/);
+assert.strictEqual(packagedHarnessSkill, canonicalHarnessSkill, 'packaged Harness skill must preserve the Windows shell contract byte-for-text');
+assert.match(canonicalHarnessSkill, /—/u, 'UTF-8 em dash must remain intact');
+assert.match(canonicalHarnessSkill, /🚦 Harness Status/u, 'UTF-8 Harness Status marker must remain intact');
+
+const readme = fs.readFileSync(path.join(ROOT, 'README.md'), 'utf8');
+assert.match(readme, /npx\.cmd github:dyphn1\/Harness-everything install/);
+assert.match(readme, /npx\.cmd github:dyphn1\/Harness-everything uninstall/);
+assert.match(readme, /npx\.cmd github:dyphn1\/Harness-everything uninstall --local --skills -y/);
+assert.match(readme, /npx\.cmd github:dyphn1\/Harness-everything uninstall --global/);
+assert.match(readme, /Get-Content -Encoding UTF8 -Raw/);
+assert.doesNotMatch(readme, /powershell -File scripts\/plugin-sync\.ps1/);
+
+const troubleshootingDocs = fs.readFileSync(path.join(ROOT, 'docs', 'troubleshooting.md'), 'utf8');
+for (const command of [
+  'install',
+  'install --global',
+  'uninstall',
+  'install --cursor',
+  'install --codex',
+  'plugin-sync --json'
+]) {
+  assert.ok(
+    troubleshootingDocs.includes(`npx.cmd github:dyphn1/Harness-everything ${command}`),
+    `troubleshooting must include Windows PowerShell form for: ${command}`
+  );
+}
+
 const capabilityDocs = fs.readFileSync(path.join(ROOT, 'docs', 'platform-capabilities.md'), 'utf8');
+assert.match(capabilityDocs, /npx\.cmd github:dyphn1\/Harness-everything plugin-sync/);
+assert.match(capabilityDocs, /node scripts\/plugin-sync\.js/);
+assert.doesNotMatch(capabilityDocs, /powershell -File scripts\/plugin-sync\.ps1/);
 assert.match(capabilityDocs, /platform-compatibility\.json/);
 assert.match(capabilityDocs, /Continue\.dev[\s\S]*`Unknown` for standalone `SKILL\.md` discovery/);
 assert.match(capabilityDocs, /live-host evidence|Partial` live-host loading/i);

package/ci/mechanism-2z-claude-plugin-manifest.test.js

@@ -81,6 +81,18 @@ if (manifestHooks !== undefined) {
 }
 
 assert.ok(Array.isArray(manifest.skills) && manifest.skills.length > 0, 'Claude plugin must declare packaged skills');
+assert.ok(manifest.skills.includes('./fable-mode'), 'Claude plugin must expose fable-mode as the public Fable entrypoint');
+for (const nestedRef of [
+  './fable-mode/fable-opus',
+  './fable-mode/fable-sonnet',
+  './fable-mode/fable-haiku',
+  './fable-mode/execution-guardrails',
+]) {
+  assert.ok(
+    !manifest.skills.includes(nestedRef),
+    `${nestedRef} is a nested reference contract, not an independently routable Claude skill`
+  );
+}
 for (const skillRef of manifest.skills) {
   const skillDir = resolvePluginPath(skillRef, `skill ${skillRef}`);
   assert.ok(fs.statSync(skillDir).isDirectory(), `skill path must be a directory: ${skillRef}`);

package/ci/router-workflow-plan.test.js

@@ -202,10 +202,95 @@ if (validContract(fableTypo, 'fable keyword trivial edit')) {
 }
 
 const explicitFable = runTier('fable on opus audit the entire repository architecture');
-if (validContract(explicitFable, 'explicit Fable model')) {
+if (validContract(explicitFable, 'explicit Fable profile')) {
   check(explicitFable.contract.workflowPlan.strategy === 'fable-staged', 'explicit Fable request selects Fable topology');
-  check(explicitFable.contract.workflowPlan.modelSelection.requested === 'opus', 'explicit Fable model stays delegated to model selector');
-  check(explicitFable.result.stdout.includes('REQUESTED FABLE MODEL MODE: opus'), 'legacy explicit Fable route remains visible');
+  check(explicitFable.contract.workflowPlan.profileSelection.requested === 'orchestrator', 'legacy opus alias normalizes to orchestrator profile');
+  check(explicitFable.contract.workflowPlan.profileSelection.alias === 'opus', 'legacy alias remains auditable');
+  check(explicitFable.result.stdout.includes('REQUESTED FABLE PROFILE: opus'), 'explicit Fable profile remains visible');
+}
+
+const explicitSonnect = runTier('fable on sonnect for architecture synthesis');
+if (validContract(explicitSonnect, 'explicit Fable sonnect alias')) {
+  check(explicitSonnect.contract.workflowPlan.profileSelection.requested === 'reasoning', 'sonnect normalizes to reasoning profile');
+  check(explicitSonnect.contract.workflowPlan.profileSelection.alias === 'sonnect', 'raw sonnect alias remains auditable end-to-end');
+  check(explicitSonnect.result.stdout.includes('REQUESTED FABLE PROFILE: sonnect'), 'router output preserves raw sonnect alias');
+}
+
+// #290: mentioning a profile in a bounded lookup must not launch orchestration.
+for (const prompt of [
+  "Explain what 'fable on sonnect' means; return only a small JSON selection record.",
+  "Resolve fable on haiku into a profile JSON record; no orchestration or delegation.",
+  "解釋 fable on opus 的意思，只回傳 JSON。",
+  "Explain what 'run fable on sonnect' means; return only JSON.",
+  'Explain fable on sonnet; return JSON with requestedProfile, effectiveProfile.',
+  "Explain what 'fable on sonnect' means; return only a small JSON selection record with requestedProfile, effectiveProfile, profileAlias, assignedRole, runtimeModel, runtimeEffort. No orchestration or delegation.",
+  'Explain fable on haiku; output JSON with `requestedProfile`, `runtimeModel` and `runtimeEffort`.',
+  '解釋 fable on opus 的意思，只回傳 JSON，包含 requestedProfile、effectiveProfile、runtimeEffort。',
+  "Explain what 'use fable on opus' means; no execution or model switching.",
+  'Explain fable on sonnet; return JSON; no stages, delegation or execution.',
+  '請說明 fable on sonnet 的意思，並只回傳含 requestedProfile 的 JSON。',
+  'Explain fable on sonnet, please return JSON.',
+  'Explain fable on sonnet and please return only JSON.',
+  '請說明 fable on sonnet，請只回傳 JSON。',
+  'Explain what “run fable on sonnect” means; return only JSON.',
+  'Explain what ‘use fable on opus’ means.',
+  'Explain fable on sonnet; no model switching.',
+  "Explain fable on sonnet; don't switch model or delegate.",
+  'Explain fable on sonnet; no stages and no delegation.',
+  '解釋 fable on sonnet，不要委派或切換模型。',
+]) {
+  const lookup = runTier(prompt);
+  const repeat = runTier(prompt);
+  if (validContract(lookup, 'bounded Fable lookup')) {
+    check(lookup.contract.classification.tier === 'tier1', 'lookup remains a bounded Tier 1 operation');
+    check(lookup.contract.workflowPlan.strategy === 'direct-single', 'lookup selects direct-single before loading references');
+    check(lookup.contract.workflowPlan.parallelism.allowed === false, 'lookup does not delegate');
+    check(lookup.result.stdout.includes('references/profile-lookup.md'), 'lookup selects only compact reference');
+    check(!lookup.result.stdout.includes('RECOMMENDED KNOWLEDGE GUIDES'), 'lookup omits unrelated keyword guides');
+    check(!lookup.result.stdout.includes('with fable-mode/scripts/model-selector.js'), 'lookup does not send agent to selector implementation');
+    check(JSON.stringify(lookup.contract) === JSON.stringify(repeat.contract), 'lookup contract is deterministic');
+  }
+}
+for (const prompt of [
+  'Use fable on sonnect to implement a multi-stage architecture migration.',
+  'Explain fable on opus and then implement a repository-wide migration.',
+  'Explain how to run fable-staged across all modules.',
+  'Explain fable on sonnet then run it to analyze security.',
+  'Explain fable on sonnet and analyze the authentication design.',
+  'Explain fable on sonnet; then send the findings to Slack.',
+  'Explain fable on sonnet and update README.',
+  'Explain fable on haiku, add a regression test.',
+  'Explain fable on opus and commit the documentation change.',
+  '說明 fable on sonnet 並更新 README。',
+  '解釋 fable on haiku，新增回歸測試。',
+  '解析 fable on opus 並刪除過期文件。',
+  'Explain fable on sonnet before updating README.',
+  'Explain fable on sonnet; return JSON after updating README.',
+  "Explain fable on sonnet before updating README.md to change 'Instalation' to 'Installation'.",
+  '解釋 fable on sonnet 後更新 README。',
+  'Explain fable on sonnet; no delegation before deleting stale files.',
+  'Explain fable on sonnet; return JSON with requestedProfile, update README.',
+  'Explain fable on sonnet; output JSON with requestedProfile and then publish the result.',
+  'Explain fable on sonnet; return JSON after restarting the server.',
+  'Explain fable on sonnet; no execution except updating README.',
+  'Explain fable on sonnet; provide a profile result while running the tests.',
+  'Explain fable on sonnet; return JSON with unknownField.',
+  'Explain fable on sonnet; some unknown continuation.',
+  // A negation scopes only its own noun list; affirmative actions after it execute.
+  'Explain fable on sonnet; no delegation, do execution.',
+  'Explain fable on sonnet; no delegation, switch model.',
+  'Explain fable on sonnet; no delegation and stage execution.',
+  'Explain fable on sonnet; without orchestration do execution.',
+  'Explain fable on sonnet; no delegation or switch model.',
+  '解釋 fable on sonnet，不要委派，執行。',
+  '解釋 fable on sonnet，不要委派，切換模型。',
+]) {
+  const execution = runTier(prompt);
+  if (validContract(execution, 'Fable execution boundary')) {
+    check(execution.contract.workflowPlan.strategy === 'fable-staged', 'execution/macro scope preserves staged topology');
+    check(!execution.contract.workflowPlan.reasonCodes.includes('fable-profile-lookup'), 'mixed execution never records the bounded lookup reason');
+    check(execution.contract.workflowPlan.requiredInvariants.includes('isolated-worktree-before-mutation'), 'execution retains isolation obligation');
+  }
 }
 
 const explicitOverride = runTier('Use iterative-single to audit the entire repository architecture.');
@@ -250,10 +335,10 @@ if (validContract(noWorkspaceState, 'workspace state block')) {
 const unavailableModel = runTier('fable on opus audit the entire repository architecture', {
   context: { hostCapabilities: { modelAvailability: 'unavailable', subagents: 'available' } },
 });
-if (validContract(unavailableModel, 'model capability block')) {
-  check(unavailableModel.contract.workflowPlan.modelSelection.requested === 'opus', 'router never remaps requested branded model');
-  check(unavailableModel.contract.workflowPlan.fallback.disposition === 'blocked', 'known unavailable model is visibly blocked');
-  check(unavailableModel.contract.workflowPlan.fallback.reasonCodes.includes('requested-model-capability-unavailable'), 'model capability block reason is recorded');
+if (validContract(unavailableModel, 'runtime model capability advisory')) {
+  check(unavailableModel.contract.workflowPlan.profileSelection.requested === 'orchestrator', 'opus remains a behavior-profile alias');
+  check(unavailableModel.contract.workflowPlan.fallback.disposition !== 'blocked', 'runtime model availability does not block Fable profile selection');
+  check(!unavailableModel.contract.workflowPlan.fallback.reasonCodes.includes('requested-model-capability-unavailable'), 'router no longer treats a branded model as a Fable requirement');
 }
 
 const hookUnavailable = runTier('Drop the prod database table.', {

package/docs/platform-capabilities.md

@@ -38,6 +38,14 @@ This is a **repository/agent contract**, not an automatic upgrade to any platfor
 
 The full ten-dimension entries and official source URLs are in [platform-compatibility.json](platform-compatibility.json). “Supported” in the standalone-skills column refers to the host’s documented skill surface plus the repository’s verified path contract; it does not mean that a live Harness session was run on every platform.
 
+### Claude Code Fable entrypoint boundary
+
+The Claude plugin registers `./fable-mode` as the public Fable skill. The nested `fable-opus`, `fable-sonnet`, `fable-haiku`, and `execution-guardrails` directories are reference contracts inside that skill tree; they are not independently registered or host-routable Claude skills. The legacy prompts `fable on opus`, `fable on sonnet`/`sonnect`, and `fable on haiku` select Fable behavior profiles (orchestrator/reasoning/mechanical), not branded runtime models. `model-selector.js` records the profile and separately evaluates the host-specific advisory runtime floor; a below-floor or unknown runtime does not block Fable by itself.
+
+The router distinguishes bounded profile explanations from Fable execution. Supported lookup prompts select `direct-single` and `references/profile-lookup.md`; the public skill dispatches before loading stage references. Entire explanation, format and negative-constraint clauses are checked against a bounded lookup vocabulary; comma/and-separated canonical output fields remain lookup data. Unknown continuations, same-clause actions (including `before`/`after`), mixed execution or macro scope retain execution routing and required invariants. This is a deterministic routing and packaged instruction contract, not a host-enforced reference-read limit or a measured token-cost guarantee.
+
+The nested execution-guardrails file is also not an always-on carrier. Fable agents that need those rules carry them inline; any non-Fable surface must load, copy, or inject the rules through a carrier the host actually executes before claiming that they apply there.
+
 ## Installer target contract
 
 The general installer’s target paths are tested independently from host discovery. This prevents a successful file copy from being reported as proof that an agent will load the file.
@@ -69,10 +77,15 @@ The package is tested at the mechanism layer and remains subject to the host’s
 The repository also ships a host-facing synchronization command for the native marketplace/plugin surfaces:
 
 ```bash
+# POSIX shells / Git Bash
 npx github:dyphn1/Harness-everything plugin-sync
 # or, from a checkout:
 ./scripts/plugin-sync.sh
-powershell -File scripts/plugin-sync.ps1
+
+# Windows PowerShell
+npx.cmd github:dyphn1/Harness-everything plugin-sync
+# or, from a checkout:
+node scripts/plugin-sync.js
 ```
 
 The command detects Claude Code and Codex independently, ensures the Harness marketplace is configured, reads the installed-plugin state, then refreshes that marketplace before choosing the operation: