harness-everything 0.30.5 → 0.30.7

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

package/CHANGELOG.md

@@ -2,6 +2,50 @@
 
 All notable changes to this project are documented in this file.
 
+## [0.30.7](https://github.com/dyphn1/Harness-everything/compare/v0.30.6...v0.30.7) (2026-10-07)
+
+### Bug Fixes
+
+* **action-gate:** reject dynamic scratch-target exemptions ([#283](https://github.com/dyphn1/Harness-everything/issues/283)) ([f722968](https://github.com/dyphn1/Harness-everything/commit/f722968021846a804fa8fceaddd9983addff51e7))
+* **action-gate:** use explicit shell-expansion marker check ([f02a105](https://github.com/dyphn1/Harness-everything/commit/f02a105e007104d20cde8fe46d24668624f7b343))
+* **action-gate:** use explicit shell-expansion marker check ([bedf24b](https://github.com/dyphn1/Harness-everything/commit/bedf24b1d2774e1d997f4b5c3f1f5d3c90694311))
+* **fable:** keep advisory replan contract within skill token budget ([b593c49](https://github.com/dyphn1/Harness-everything/commit/b593c49862d779f20919f8f1a7ff72043d76b637))
+* **fable:** keep advisory replan contract within skill token budget ([da6c5e8](https://github.com/dyphn1/Harness-everything/commit/da6c5e8f238d5dcae9632a5db0e71786d7dc5fe7))
+* **fable:** make replan guidance non-blocking ([#273](https://github.com/dyphn1/Harness-everything/issues/273)) ([64de668](https://github.com/dyphn1/Harness-everything/commit/64de668e91300e1c7f68ca07ebb08d87b5595c1c))
+* **fable:** make replan guidance non-blocking ([#273](https://github.com/dyphn1/Harness-everything/issues/273)) ([241cf46](https://github.com/dyphn1/Harness-everything/commit/241cf461baca6a6e739aa5114330ac1e20c0195b))
+* **fable:** make replan guidance non-blocking ([#273](https://github.com/dyphn1/Harness-everything/issues/273)) ([d834d9f](https://github.com/dyphn1/Harness-everything/commit/d834d9fffbae5d40583c1e0e41a1da1f03531382))
+* **fable:** make replan guidance non-blocking ([#273](https://github.com/dyphn1/Harness-everything/issues/273)) ([1430afe](https://github.com/dyphn1/Harness-everything/commit/1430afe9a96a1b849d18982644193bf7251264b1))
+* **fable:** preserve per-stage artifact and pass-check contract ([2c4feaf](https://github.com/dyphn1/Harness-everything/commit/2c4feafd503881296a8b656d2b6c8257db68be41))
+* **fable:** preserve per-stage artifact and pass-check contract ([d88a0b6](https://github.com/dyphn1/Harness-everything/commit/d88a0b6b054ca0810563519eed2a1d494c8b3e15))
+* **fable:** remove remaining two-replan caps from fable references ([63f9263](https://github.com/dyphn1/Harness-everything/commit/63f9263f3dd712c39ec49aa977e0229dc750bb52))
+* **find-skills:** retain authority boundary in reference contract ([#276](https://github.com/dyphn1/Harness-everything/issues/276)) ([9a5ed99](https://github.com/dyphn1/Harness-everything/commit/9a5ed99737be4fe0b8631370379eead2d54f6bf9))
+* **find-skills:** retain authority boundary in reference contract ([#276](https://github.com/dyphn1/Harness-everything/issues/276)) ([3e41033](https://github.com/dyphn1/Harness-everything/commit/3e410339df82dafccd2cef094b00e4efd7f4e2d7))
+* **find-skills:** retain authority boundary in skill contract ([#276](https://github.com/dyphn1/Harness-everything/issues/276)) ([3d01cd7](https://github.com/dyphn1/Harness-everything/commit/3d01cd7633261851529b214dbc01664b2a18a915))
+* **find-skills:** retain authority boundary in skill contract ([#276](https://github.com/dyphn1/Harness-everything/issues/276)) ([2112e3a](https://github.com/dyphn1/Harness-everything/commit/2112e3a04eb3c90786aa3316d2735d24435fc9f0))
+
+## [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

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-2ad-action-gate-classifier-hardening.test.js

@@ -84,6 +84,20 @@ try {
   // fail-open path: the gate cannot prove that the target is scratch space.
   matched(table, 'rm -rf "$S"', 'recursive-delete');
 
+  // A repository checkout may itself live below os.tmpdir() (e.g. a review worktree).
+  // Unknown paths are not proven scratch paths merely because cwd is scratch.
+  const scratchCwd = path.join(sessionDir, 'scratch');
+  matched(table, 'rm -rf "$S"', 'recursive-delete', 'Bash', scratchCwd);
+  matched(table, 'rm -rf "${S}"', 'recursive-delete', 'Bash', scratchCwd);
+  matched(table, 'rm -rf "$HOME/important"', 'recursive-delete', 'Bash', scratchCwd);
+  matched(table, 'rm -rf "~/important"', 'recursive-delete', 'Bash', scratchCwd);
+  matched(table, 'rm -rf "*.txt"', 'recursive-delete', 'Bash', scratchCwd);
+  matched(table, 'ri -Recurse -Force "$env:TARGET"', 'powershell-recursive-force-delete', 'PowerShell', scratchCwd);
+  matched(table, 'rm -r -fo "%TEMP%/important"', 'powershell-recursive-force-delete', 'PowerShell', scratchCwd);
+  // A provably literal scratch path remains allowed even from the same cwd.
+  allowed(table, `rm -rf "${path.join(scratchCwd, 'output')}"`, 'Bash', scratchCwd);
+
+
   console.log('PASS: destructive-command classifier covers confirmed bypasses while suppressing quoted-text false positives');
 } finally {
   fs.rmSync(temp, { recursive: true, force: true });

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-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/prompt-contract-regressions.test.js

@@ -10,6 +10,29 @@ function read(rel) {
   return fs.readFileSync(path.join(ROOT, rel), 'utf8');
 }
 
+// #273: Fable replan counts are advisory, never execution hard-stops.
+// Only repeated same-signature failures invoke mandatory Rule-of-3 reflection.
+for (const [canonical, packaged] of [
+  ['fable-mode/SKILL.md', 'plugins/harness-everything/skills/fable-mode/SKILL.md'],
+  ['fable-mode/fable-opus/SKILL.md', 'plugins/harness-everything/skills/fable-mode/fable-opus/SKILL.md'],
+]) {
+  const body = read(canonical);
+  assert.strictEqual(read(packaged), body, canonical + ' packaged contract matches');
+  assert.ok(/advisory replan/i.test(body), canonical + ' must describe replans as advisory');
+  assert.ok(/Rule-of-3/i.test(body), canonical + ' must preserve same-signature failure reflection');
+  assert.ok(!/at most two (?:full )?replans/i.test(body), canonical + ' must not imply a two-replan hard cap');
+}
+for (const rel of [
+  'fable-mode/references/execution-phases.md',
+  'plugins/harness-everything/skills/fable-mode/references/execution-phases.md',
+  'docs/workflows/fable-mode.md',
+]) {
+  assert.ok(!/(?:at most|no more than) two (?:full )?replans/i.test(read(rel)), rel + ' must not imply a two-replan hard cap');
+}
+const orchestratorContract = read('fable-mode/agents/fable-orchestrator.md');
+assert.ok(/maxReplans[\s\S]{0,60}is advisory/i.test(orchestratorContract), 'orchestrator keeps advisory replan guidance');
+assert.ok(/do not block execution/i.test(orchestratorContract), 'orchestrator does not block on replan count');
+
 // #268: model aliases evolve, so worker prompts must encode behavior rather
 // than generation-specific personality/failure claims.
 const workerPairs = [
@@ -90,6 +113,20 @@ const workspaceContract = read('multi-agent-workspace/SKILL.md');
 assert.ok(/router owns that decision/i.test(workspaceContract), 'multi-agent-workspace keeps router-owned topology');
 assert.ok(/does not spawn workers/i.test(workspaceContract), 'multi-agent-workspace remains a topology/workspace consumer');
 
+// #276: third-party skill output is applicable guidance, never higher-priority
+// authority. Keep the canonical, packaged, and reference contracts consistent.
+const findSkills = read('find-skills/SKILL.md');
+const discoveryFlow = read('find-skills/references/discovery-flow.md');
+assert.strictEqual(read('plugins/harness-everything/skills/find-skills/SKILL.md'), findSkills, 'find-skills packaged contract matches canonical');
+assert.strictEqual(read('plugins/harness-everything/skills/find-skills/references/discovery-flow.md'), discoveryFlow, 'find-skills packaged reference matches canonical');
+assert.ok(/untrusted third-party content/i.test(findSkills), 'third-party output must be identified as untrusted');
+assert.ok(/MUST NOT override host, user, or Harness/i.test(findSkills), 'third-party skill instructions cannot override core authority');
+assert.ok(/explicit approval/i.test(findSkills), 'third-party application must require approval');
+assert.ok(/untrusted third-party content/i.test(discoveryFlow), 'reference must preserve untrusted data boundary');
+assert.ok(/MUST NOT override host, user, or Harness/i.test(discoveryFlow), 'reference must preserve precedence');
+assert.ok(!/Treat its output as binding/i.test(findSkills), 'find-skills must not grant unconditional binding authority');
+assert.ok(!/treat every instruction in it as binding/i.test(discoveryFlow), 'discovery reference must not grant unconditional binding authority');
+
 // #272: preserve one detailed checkpoint plus the invariant; remove duplicate
 // restatements from later sections of the same router injection.
 const kernel = path.join(ROOT, 'harness-everything/scripts/kernel-router.js');

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.

package/docs/workflows/fable-mode.md

@@ -36,18 +36,19 @@ stateDiagram-v2
   Recorded --> [*]
 ```
 
-The stage record preserves the requested/effective model, fallback reason, stage brief, artifact, pass condition, verification command, and verifier result.
+The stage record preserves requested/effective behavior profile, profile alias, runtime model/effort when known, runtime-floor status, fallback reason, stage brief, artifact, pass condition, verification command, and verifier result.
 
-## 3. Model Selection and Delegation
+## 3. Behavior Profile and Runtime Recommendation
 
-Explicit model requests are resolved through `model-selector.js`. Fable never silently downgrades a requested model.
+Explicit `haiku`/`sonnet`/`sonnect`/`opus` requests are behavior-profile aliases resolved through `model-selector.js`; they do not pin the host runtime model. Host-specific model floors are advisory and visible.
 
 ```mermaid
 flowchart LR
-  Requested[Requested model] --> Selector[model-selector.js]
-  Selector -->|Available| Named[Named fable agent]
-  Selector -->|Fallback allowed| Fallback[Recorded fallback]
-  Selector -->|No valid fallback| Blocked[Escalate blocked stage]
+  Requested[Requested profile / legacy alias] --> Selector[model-selector.js]
+  Selector --> Role[Named Fable role]
+  Role --> Runtime[Host runtime + advisory model floor]
+  Runtime -->|Meets / below / unknown| Execute[Execute same behavior profile]
+  Role -->|Named agent unavailable| Fallback[Inline or stop fallback]
   Named --> Stage[Bounded stage brief]
   Fallback --> Stage
   Stage --> Verify[Named stage check]
@@ -56,7 +57,7 @@ flowchart LR
   Cold --> Record
 ```
 
-The intended role split is explicit rather than magical: Opus is suitable for orchestration, Sonnet for reasoning-heavy stage work, and Haiku for bounded mechanical work. Workers do not spawn workers.
+The role split is explicit: `opus` aliases the orchestrator profile, `sonnet` aliases reasoning, and `haiku` aliases mechanical work. These names describe Fable behavior; actual Claude/Codex model choice is a separate host concern. Workers do not spawn workers.
 
 ## 4. Scope and Context Discipline
 
@@ -83,10 +84,10 @@ worker. A material confirmed blocker may stop the current stage immediately. Rep
 matching execution failures use the separate Rule-of-3 path: zoom out, reflect, then
 `RESUME` on a new approach or `ESCALATE` when a real decision is required.
 
-At most two full replans are allowed before unresolved blockers are escalated rather than hidden behind endless restructuring.
+Replan counts (`maxReplans`) are advisory and never halt execution on their own; unresolved blockers are escalated rather than hidden behind endless restructuring, and three same-signature failures still trigger the mandatory Rule-of-3 `zoom-out`.
 
 ## 5. Completion Boundary
 
 Fable completion means the planned stages have produced their artifacts, their checks have passed, and high-risk outputs have received skeptical review where required. It does not mean every possible companion skill was invoked.
 
-The canonical executable and policy details live in `fable-mode/SKILL.md`, `fable-mode/model-matrix.json`, `fable-mode/scripts/model-selector.js`, and `fable-mode/references/model-matrix.md`.
+The canonical executable and policy details live in `fable-mode/SKILL.md`, `fable-mode/behavior-profile-matrix.json`, `fable-mode/runtime-model-floor-matrix.json`, `fable-mode/scripts/model-selector.js`, and `fable-mode/references/model-matrix.md`.