harness-everything 0.30.5 → 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.5",
+      "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.5",
+  "version": "0.30.6",
   "author": {
     "name": "Miya Daniel"
   },

package/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 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

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-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.

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
 
@@ -89,4 +90,4 @@ At most two full replans are allowed before unresolved blockers are escalated ra
 
 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`.

package/evals/fable-mode/tasks/negative-tier2-no-model.yaml

@@ -1,6 +1,6 @@
 id: negative-fable-model-005
-name: Ordinary Tier 2 work does not select a fable model
-description: A normal Tier 2 bugfix must not route to a model-pinned fable entrypoint.
+name: Ordinary Tier 2 work does not select a fable profile
+description: A normal Tier 2 bugfix must not route to an explicit Fable behavior profile.
 tags:
   - negative-trigger
   - tier-2
@@ -10,7 +10,7 @@ expected:
   should_trigger: false
 graders:
   - type: text
-    name: no-model-pinned-route
+    name: no-explicit-profile-route
     config:
       contains:
         - "fable-opus"

package/evals/fable-mode/tasks/positive-haiku-mode.yaml

@@ -1,6 +1,6 @@
 id: positive-fable-haiku-002
 name: Explicit Haiku mode routes mechanical work
-description: "Stage large, multi-source or multi-session tasks through a written plan, named fable agents, failable per-stage checks, and skeptical delivery review; use fable-opus, fable-sonnet, or fable-haiku for explicit model selection."
+description: "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."
 tags:
   - positive-trigger
   - fable-haiku

package/evals/fable-mode/tasks/positive-opus-mode.yaml

@@ -1,6 +1,6 @@
 id: positive-fable-opus-004
 name: Explicit Opus mode routes macro orchestration
-description: "Stage large, multi-source or multi-session tasks through a written plan, named fable agents, failable per-stage checks, and skeptical delivery review; use fable-opus, fable-sonnet, or fable-haiku for explicit model selection."
+description: "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."
 tags:
   - positive-trigger
   - fable-opus

package/evals/fable-mode/tasks/positive-sonnet-mode.yaml

@@ -1,6 +1,6 @@
 id: positive-fable-sonnet-003
 name: Explicit Sonnet mode routes reasoning work
-description: "Stage large, multi-source or multi-session tasks through a written plan, named fable agents, failable per-stage checks, and skeptical delivery review; use fable-opus, fable-sonnet, or fable-haiku for explicit model selection."
+description: "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."
 tags:
   - positive-trigger
   - fable-sonnet

package/evals/fable-mode/tasks/positive-trigger.yaml

@@ -1,6 +1,6 @@
 id: positive-fable-mode-001
 name: On-scope prompt triggers fable-mode
-description: "Stage large, multi-source or multi-session tasks through a written plan, named fable agents, failable per-stage checks, and skeptical delivery review; use fable-opus, fable-sonnet, or fable-haiku for explicit model selection."
+description: "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."
 tags:
   - positive-trigger
 inputs:

package/fable-mode/SKILL.md

@@ -1,39 +1,45 @@
 ---
 name: fable-mode
-description: "Stage large, multi-source or multi-session tasks through a written plan, named fable agents, failable per-stage checks, and skeptical delivery review; use fable-opus, fable-sonnet, or fable-haiku for explicit model selection."
+description: "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."
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.30.2
+  version: 0.30.6
 ---
 
-# Fable Mode (v3)
+# Fable Mode
 
 ## Skill Contract
 
 | Component | Specification |
 | :--- | :--- |
-| **Trigger / Input** | Tier 3 work spanning multiple files, sources, or sessions. |
-| **Expected Output** | Stage map, named-agent briefs, failable checks, and skeptical review. |
-| **State Mutations** | Native host TODO tracker or a Markdown checklist; one JSON audit record per stage. |
-| **Enforcement Gate** | `<this-skill-dir>/scripts/model-selector.js`, stage contracts, and `<skills-repo-root>/harness-everything/scripts/verify-gate.js`. |
+| **Trigger / Input** | Profile lookup or Tier 3 execution. |
+| **Expected Output** | Profile record or verified stages. |
+| **State Mutations** | Execution only: stage checklist and audit records. |
+| **Enforcement Gate** | Execution: `<this-skill-dir>/scripts/model-selector.js`, stage contracts, and `<skills-repo-root>/harness-everything/scripts/verify-gate.js`. |
 
 ## USE FOR:
 - Large multi-file, multi-source, or multi-session work
-- Explicit `fable on haiku`, `fable on sonnet`, or `fable on opus` requests
+- Fable profile explanations or explicit Fable execution requests
 - Work needing named delegation and cold verification
 
 ## DO NOT USE FOR:
 - One obvious single-pass edit
 - Ordinary Tier 2 implementation or bugfix work
 
+## Select Operation First
+
+For explanation/profile-only lookup, read only `<this-skill-dir>/references/profile-lookup.md` and answer. No stage state, delegation, or selector source reads. Quoted aliases do not start Fable. Mixed execution retains its topology.
+
+Execution follows the workflow below.
+
 ## Workflow
 
 1. Discover the runtime and lock the authorized file scope before edits.
 2. Write a numbered stage map with one artifact and pass condition per stage; allow at most two full replans.
-3. Resolve the requested model with `model-selector.js`; never silently downgrade.
-4. Delegate by named agent where available: Opus orchestrates, Sonnet reasons, Haiku handles mechanical work, and workers never spawn workers.
-5. Write a stage contract, run its named check, then cold-review high-stakes artifacts with `fable-verifier`.
-6. Record requested/effective model, fallback reason, stage brief, pass condition, verification command, and verifier result for every stage. Escalate unresolved blockers.
+3. Resolve the requested behavior profile with `model-selector.js`; `opus`, `sonnet`/`sonnect`, and `haiku` are compatibility aliases, not model bindings.
+4. Delegate by profile: orchestrator coordinates, reasoning handles bounded judgment, mechanical handles low-ambiguity work, and workers never spawn workers.
+5. Treat the host runtime-model floor as advisory; record its status without blocking Fable solely for model choice.
+6. Run each stage check, cold-review high-stakes artifacts, and audit profile/runtime/fallback fields.
 
 Deep dive: <this-skill-dir>/references/model-matrix.md