harness-everything 0.30.4 → 0.30.6

package/plugins/harness-everything/skills/fable-mode/references/model-matrix.md

@@ -1,41 +1,46 @@
-# Fable model matrix and execution audit
+# Fable behavior profiles and runtime model floors
 
-Issue #27 defines three explicit execution modes. The mode selector is the
-machine-readable gate; this document is the human-facing contract.
+Fable profiles define **how work is performed and which role owns it**. They do not select or require a branded runtime model. The historical names `haiku`, `sonnet`/`sonnect`, and `opus` remain accepted aliases so existing prompts keep working.
 
-| Mode | Use for | Named agent |
-|---|---|---|
-| Haiku | Bulk mechanical work and format conversion | `fable-worker-haiku` |
-| Sonnet | Non-trivial implementation, research synthesis, bounded reasoning | `fable-worker-sonnet` |
-| Opus | Macro orchestration, cross-stage synthesis, high-stakes architecture and final decisions | `fable-orchestrator` |
+## Behavior Profile Matrix
+
+| Canonical profile | Legacy alias | Role | Typical work | Named agent |
+|---|---|---|---|---|
+| `mechanical` | `haiku` | Mechanical worker | Bulk edits, format conversion, boilerplate, structured extraction | `fable-worker-haiku` |
+| `reasoning` | `sonnet` / `sonnect` | Reasoning worker | Non-trivial implementation, research synthesis, analysis, bounded design | `fable-worker-sonnet` |
+| `orchestrator` | `opus` | Orchestrator | Stage decomposition, dependency management, cross-stage synthesis, architecture/final decisions | `fable-orchestrator` |
+| verifier | — | Cold reviewer | Spec-versus-artifact checks and independent re-verification | `fable-verifier` |
+
+The machine-readable source is `fable-mode/behavior-profile-matrix.json`.
+
+## Runtime Model Floor Matrix
 
-Use the explicit entrypoints `fable-haiku`, `fable-sonnet`, and `fable-opus`.
-The accepted input `sonnect` normalizes to Sonnet. A normal Tier 2 prompt does
-not select a fable model.
+Runtime floors are **host-specific recommendations**, not Fable identity and not an execution gate. A newer compatible model/effort may be used. If the active runtime is below or cannot be compared to the floor, Fable continues with the same behavior profile and records the status visibly.
 
-## Deterministic selection
+| Fable profile | Claude recommended floor | Codex recommended floor |
+|---|---|---|
+| `orchestrator` | Opus 5.5+ / medium+ | GPT-6 Sol+ / xhigh+ |
+| `reasoning` | Sonnet 5.5+ / medium+ | GPT-6 Sol+ / medium+ |
+| `mechanical` | Haiku 5.5+ | GPT-6 Luna 6+ / xhigh+ |
+
+The machine-readable source is `fable-mode/runtime-model-floor-matrix.json`. These are Harness support baselines, not claims that every host currently exposes every listed model.
 
-Before each stage, run `fable-mode/scripts/model-selector.js` with the requested
-mode, the runtime's available modes, the host model, and the stage contract:
+## Resolution
 
 ```text
-node fable-mode/scripts/model-selector.js --requested opus --available opus,sonnet,haiku --available-agents fable-orchestrator,fable-worker-sonnet,fable-worker-haiku --fallback stop --host-model opus --stage-brief "Synthesize the architecture" --pass-condition "ADR and dependency map exist" --verification-command "npm test" --verifier-result pending
+task
+  -> behavior profile
+  -> named role / agent
+  -> host adapter
+  -> advisory runtime floor
+  -> actual host-selected model
+  -> execute the SAME behavior contract
 ```
 
-The JSON result always records `requestedModel`, `effectiveModel`,
-`fallbackReason`, `stageBrief`, `passCondition`, `verificationCommand`, and
-`verifierResult`, plus available agents, status, agent, and escalation state. The
-CLI appends the same record as one JSON line to
-`.claude/harness-everything/state/fable-mode/audit.jsonl` (or the path supplied by
-`--audit-file`).
-
-If the requested model is unavailable, `--fallback inline` records the declared
-host model and a visible reason. `--fallback stop` emits `status: blocked`, a
-null effective model, and exit code 2. Neither path silently downgrades.
-
-The orchestrator still owns scope lock, at most two full replans, stage
-contracts, worker non-recursion, cold verification, and escalation. The native
-host TODO tracker or a Markdown checklist records stage progress; no CLI TODO
-state machine is part of this contract.
+`fable on haiku` normalizes to `mechanical`; `fable on sonnect` normalizes to `reasoning`; `fable on opus` normalizes to `orchestrator`. None of these aliases means switching the host to that branded model.
+
+The audit record uses `requestedProfile`, `effectiveProfile`, `profileAlias`, `assignedRole`, `runtimeModel`, `runtimeEffort`, `recommendedRuntimeFloor`, `runtimeFloorStatus`, and `runtimeFloorReason`, plus stage verification fields.
+
+A `below-recommended` or `unknown` runtime-floor result is advisory and does not block Fable. Missing named-agent capability is separate: the existing `inline` or `stop` fallback policy decides whether the same profile runs inline or the stage is blocked.
 
 See [execution phases](execution-phases.md) for the staged run contract.

package/plugins/harness-everything/skills/fable-mode/references/profile-lookup.md

@@ -0,0 +1,19 @@
+# Profile lookup
+
+Use for explanation or a profile-only JSON record. No stage, audit-log mutation, delegation, or model switch is implied. Execution requests retain their selected workflow obligations.
+
+| Alias | Profile | Role | Named agent |
+|---|---|---|---|
+| haiku | mechanical | mechanical-worker | fable-worker-haiku |
+| sonnet / sonnect | reasoning | reasoning-worker | fable-worker-sonnet |
+| opus | orchestrator | orchestrator | fable-orchestrator |
+
+Preserve the input alias. Profiles describe behavior; the host chooses the actual runtime model. Report runtime fields as unknown when they were not supplied; never infer a model from an alias. Runtime floors are advisory, including unknown or below-recommended results.
+
+For a lookup, these fields suffice: `requestedProfile`, `effectiveProfile`, `profileAlias`, `assignedRole`, `runtimeModel`, `runtimeEffort`. If the user requests a computed floor comparison, read the relevant entry in `runtime-model-floor-matrix.json` and the resolution rules in [runtime-floor rules](model-matrix.md); use `scripts/model-selector.js` for a stage audit, not by reading its implementation for a lookup.
+
+Example for `fable on sonnect` with no supplied runtime:
+
+```json
+{"requestedProfile":"reasoning","effectiveProfile":"reasoning","profileAlias":"sonnect","assignedRole":"reasoning-worker","runtimeModel":null,"runtimeEffort":null}
+```

package/plugins/harness-everything/skills/fable-mode/runtime-model-floor-matrix.json

@@ -0,0 +1,47 @@
+{
+  "schemaVersion": 1,
+  "policy": "advisory-floor",
+  "belowFloorDisposition": "continue-with-visible-status",
+  "hosts": {
+    "claude": {
+      "orchestrator": {
+        "family": "opus",
+        "minVersion": "5.5",
+        "minEffort": "medium",
+        "display": "Opus 5.5+ / medium+"
+      },
+      "reasoning": {
+        "family": "sonnet",
+        "minVersion": "5.5",
+        "minEffort": "medium",
+        "display": "Sonnet 5.5+ / medium+"
+      },
+      "mechanical": {
+        "family": "haiku",
+        "minVersion": "5.5",
+        "minEffort": null,
+        "display": "Haiku 5.5+"
+      }
+    },
+    "codex": {
+      "orchestrator": {
+        "family": "sol",
+        "minGeneration": 6,
+        "minEffort": "xhigh",
+        "display": "GPT-6 Sol+ / xhigh+"
+      },
+      "reasoning": {
+        "family": "sol",
+        "minGeneration": 6,
+        "minEffort": "medium",
+        "display": "GPT-6 Sol+ / medium+"
+      },
+      "mechanical": {
+        "family": "luna",
+        "minGeneration": 6,
+        "minEffort": "xhigh",
+        "display": "GPT-6 Luna 6+ / xhigh+"
+      }
+    }
+  }
+}

package/plugins/harness-everything/skills/fable-mode/scripts/model-selector.js

@@ -5,7 +5,6 @@ const os = require('os');
 const path = require('path');
 const crypto = require('crypto');
 
-const MATRIX_PATH = path.join(__dirname, '..', 'model-matrix.json');
 const SESSION_REGISTRY_DIR = 'session-workspaces';
 const SESSION_REGISTRY_VERSION = 1;
 const UNBOUND_WORKSPACE_KEY = 'unbound-workspace';
@@ -136,89 +135,140 @@ function getWorkspaceStateDir(root) {
 }
 const REQUIRED = ['stageBrief', 'passCondition', 'verificationCommand', 'verifierResult'];
 const VALID_VERIFIER_RESULTS = new Set(['pending', 'pass', 'fail', 'not-run', 'blocked']);
+const PROFILE_MATRIX_PATH = path.join(__dirname, '..', 'behavior-profile-matrix.json');
+const RUNTIME_FLOOR_PATH = path.join(__dirname, '..', 'runtime-model-floor-matrix.json');
+const EFFORT_ORDER = ['low', 'medium', 'high', 'xhigh', 'max'];
 
-function loadMatrix() {
-  return JSON.parse(fs.readFileSync(MATRIX_PATH, 'utf8'));
+function loadBehaviorMatrix() {
+  return JSON.parse(fs.readFileSync(PROFILE_MATRIX_PATH, 'utf8'));
 }
 
-function normalizeModel(value, matrix) {
+function loadRuntimeFloors() {
+  return JSON.parse(fs.readFileSync(RUNTIME_FLOOR_PATH, 'utf8'));
+}
+
+function normalizeProfile(value, matrix = loadBehaviorMatrix()) {
   const input = String(value || '').trim().toLowerCase();
-  for (const [model, definition] of Object.entries(matrix.modes)) {
-    if (definition.aliases.includes(input)) return model;
+  for (const [profile, definition] of Object.entries(matrix.profiles)) {
+    if (profile === input || definition.aliases.includes(input)) return { profile, alias: input, definition };
   }
   return null;
 }
 
+function normalizeHost(value) {
+  const input = String(value || '').trim().toLowerCase();
+  if (input === 'claude' || input === 'claude-code' || input === 'claude code') return 'claude';
+  if (input === 'codex' || input === 'openai-codex' || input === 'openai codex') return 'codex';
+  return input || 'unknown';
+}
+
+function normalizeEffort(value) {
+  const input = String(value || '').trim().toLowerCase().replace(/[_ -]/g, '');
+  if (!input) return null;
+  if (input === 'extrahigh' || input === 'xhigh') return 'xhigh';
+  return input;
+}
+
+function claudeVersion(model, family) {
+  const text = String(model || '').toLowerCase();
+  const match = text.match(new RegExp(family + '[^0-9]*(\\d+)(?:[.-](\\d+))?'));
+  if (!match) return null;
+  return Number(match[1] + '.' + (match[2] || '0'));
+}
+
+function codexGeneration(model) {
+  const match = String(model || '').toLowerCase().match(/\bgpt-(\d+(?:\.\d+)?)/);
+  return match ? Number(match[1]) : null;
+}
+
+function evaluateRuntimeFloor(profile, input, floors = loadRuntimeFloors()) {
+  const host = normalizeHost(input.host);
+  const floor = floors.hosts[host] && floors.hosts[host][profile] ? floors.hosts[host][profile] : null;
+  const runtimeModel = String(input.runtimeModel || input.hostModel || '').trim() || null;
+  const runtimeEffort = normalizeEffort(input.runtimeEffort || input.effort);
+  if (!floor) return { host, runtimeModel, runtimeEffort, floor: null, status: 'not-configured', reason: 'no runtime floor configured for host ' + host };
+  if (!runtimeModel) return { host, runtimeModel, runtimeEffort, floor, status: 'unknown', reason: 'runtime model was not reported by the host' };
+
+  const lower = runtimeModel.toLowerCase();
+  if (!lower.includes(floor.family)) return { host, runtimeModel, runtimeEffort, floor, status: 'unknown', reason: 'runtime model family is not comparable to recommended ' + floor.family };
+
+  if (floor.minVersion) {
+    const actual = claudeVersion(runtimeModel, floor.family);
+    if (actual === null) return { host, runtimeModel, runtimeEffort, floor, status: 'unknown', reason: 'runtime model version could not be parsed' };
+    if (actual < Number(floor.minVersion)) return { host, runtimeModel, runtimeEffort, floor, status: 'below-recommended', reason: 'runtime model version ' + actual + ' is below ' + floor.minVersion };
+  }
+
+  if (floor.minGeneration) {
+    const actual = codexGeneration(runtimeModel);
+    if (actual === null) return { host, runtimeModel, runtimeEffort, floor, status: 'unknown', reason: 'runtime model generation could not be parsed' };
+    if (actual < Number(floor.minGeneration)) return { host, runtimeModel, runtimeEffort, floor, status: 'below-recommended', reason: 'runtime model generation ' + actual + ' is below ' + floor.minGeneration };
+  }
+
+  if (floor.minEffort) {
+    if (!runtimeEffort) return { host, runtimeModel, runtimeEffort, floor, status: 'unknown', reason: 'runtime reasoning effort was not reported by the host' };
+    const actualRank = EFFORT_ORDER.indexOf(runtimeEffort);
+    const floorRank = EFFORT_ORDER.indexOf(normalizeEffort(floor.minEffort));
+    if (actualRank < 0 || floorRank < 0) return { host, runtimeModel, runtimeEffort, floor, status: 'unknown', reason: 'runtime effort is not comparable to configured floor' };
+    if (actualRank < floorRank) return { host, runtimeModel, runtimeEffort, floor, status: 'below-recommended', reason: 'runtime effort ' + runtimeEffort + ' is below ' + floor.minEffort };
+  }
+
+  return { host, runtimeModel, runtimeEffort, floor, status: 'meets-recommended', reason: 'runtime meets the configured advisory floor' };
+}
+
 function parseArgs(argv) {
   const args = {};
   for (let i = 0; i < argv.length; i += 1) {
     const token = argv[i];
     if (token === '--help' || token === '-h') return { help: true };
-    if (!token.startsWith('--')) throw new Error(`unknown argument: ${token}`);
+    if (!token.startsWith('--')) throw new Error('unknown argument: ' + token);
     const key = token.slice(2).replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
     const value = argv[i + 1];
-    if (typeof value === 'undefined' || value.startsWith('--')) throw new Error(`missing value for --${key}`);
+    if (typeof value === 'undefined' || value.startsWith('--')) throw new Error('missing value for --' + key);
     args[key] = value;
     i += 1;
   }
   return args;
 }
 
-function resolveMode(input, matrix = loadMatrix()) {
-  const requestedModel = normalizeModel(input.requested, matrix);
-  if (!requestedModel) throw new Error('requested model must be one of haiku, sonnet, sonnect, or opus');
-
-  const availableModels = String(input.available || '')
-    .split(/[\s,]+/)
-    .map(model => normalizeModel(model, matrix))
-    .filter(Boolean);
-  const availableAgents = String(input.availableAgents || '')
-    .split(/[\s,]+/)
-    .map(agent => agent.trim())
-    .filter(Boolean);
-  const fallback = input.fallback || 'stop';
-  if (!Object.prototype.hasOwnProperty.call(matrix.fallbacks, fallback)) {
-    throw new Error('fallback must be inline or stop');
-  }
+function resolveMode(input, matrix = loadBehaviorMatrix(), floors = loadRuntimeFloors()) {
+  const normalized = normalizeProfile(input.requested, matrix);
+  if (!normalized) throw new Error('requested profile must be one of mechanical, reasoning, orchestrator, haiku, sonnet, sonnect, or opus');
 
+  const availableAgents = String(input.availableAgents || '').split(/[\s,]+/).map(agent => agent.trim()).filter(Boolean);
+  const fallback = input.fallback || 'stop';
+  if (!['inline', 'stop'].includes(fallback)) throw new Error('fallback must be inline or stop');
   for (const field of REQUIRED) {
-    if (!String(input[field] || '').trim()) throw new Error(`${field} is required for an auditable stage`);
-  }
-  if (!VALID_VERIFIER_RESULTS.has(input.verifierResult)) {
-    throw new Error(`verifierResult must be one of ${[...VALID_VERIFIER_RESULTS].join(', ')}`);
+    if (!String(input[field] || '').trim()) throw new Error(field + ' is required for an auditable stage');
   }
+  if (!VALID_VERIFIER_RESULTS.has(input.verifierResult)) throw new Error('verifierResult must be one of ' + [...VALID_VERIFIER_RESULTS].join(', '));
 
-  const requestedAgent = matrix.modes[requestedModel].agent;
-  const modelAvailable = availableModels.includes(requestedModel);
+  const requestedProfile = normalized.profile;
+  const requestedAgent = normalized.definition.agent;
   const agentAvailable = availableAgents.includes(requestedAgent);
-  const selected = modelAvailable && agentAvailable;
-  const hostModel = String(input.hostModel || 'current-host').trim();
-  const fallbackDefinition = matrix.fallbacks[fallback];
-  const status = selected ? 'selected' : fallbackDefinition.status;
-  const effectiveModel = selected
-    ? requestedModel
-    : fallback === 'inline'
-      ? hostModel
-      : fallbackDefinition.effectiveModel;
-  const missing = [];
-  if (!modelAvailable) missing.push(`${requestedModel} is not in availableModels`);
-  if (!agentAvailable) missing.push(`${requestedAgent} is not in availableAgents`);
-  const fallbackReason = selected
-    ? 'none'
-    : `${fallbackDefinition.reason}: ${missing.join('; ')}`;
+  const status = agentAvailable ? 'selected' : fallback === 'inline' ? 'fallback' : 'blocked';
+  const runtime = evaluateRuntimeFloor(requestedProfile, input, floors);
+  const fallbackReason = agentAvailable ? 'none' : fallback === 'inline'
+    ? requestedAgent + ' is not in availableAgents; execute the same ' + requestedProfile + ' behavior profile inline'
+    : requestedAgent + ' is not in availableAgents and inline fallback was not authorized';
 
   return {
     schemaVersion: matrix.schemaVersion,
     status,
-    requestedModel,
+    requestedProfile,
+    effectiveProfile: status === 'blocked' ? null : requestedProfile,
+    profileAlias: normalized.alias,
     requestedInput: String(input.requested).trim(),
-    effectiveModel,
-    availableModels: [...new Set(availableModels)],
+    assignedRole: normalized.definition.role,
+    agent: agentAvailable ? requestedAgent : null,
     availableAgents: [...new Set(availableAgents)],
     fallbackPolicy: fallback,
     fallbackReason,
-    agent: selected ? requestedAgent : null,
-    modelRole: matrix.modes[requestedModel].role,
+    host: runtime.host,
+    runtimeModel: runtime.runtimeModel,
+    runtimeEffort: runtime.runtimeEffort,
+    recommendedRuntimeFloor: runtime.floor,
+    runtimeFloorStatus: runtime.status,
+    runtimeFloorReason: runtime.reason,
     stageBrief: String(input.stageBrief).trim(),
     passCondition: String(input.passCondition).trim(),
     verificationCommand: String(input.verificationCommand).trim(),
@@ -228,33 +278,29 @@ function resolveMode(input, matrix = loadMatrix()) {
 }
 
 function printHelp() {
-  console.log('Usage: node fable-mode/scripts/model-selector.js --requested <haiku|sonnet|sonnect|opus> --available <models> --available-agents <agent names> --stage-brief <text> --pass-condition <text> --verification-command <command> --verifier-result <pending|pass|fail|not-run|blocked> [--fallback <inline|stop>] [--host-model <model>] [--audit-file <path>]');
+  console.log('Usage: node fable-mode/scripts/model-selector.js --requested <mechanical|reasoning|orchestrator|haiku|sonnet|sonnect|opus> --available-agents <agent names> --stage-brief <text> --pass-condition <text> --verification-command <command> --verifier-result <pending|pass|fail|not-run|blocked> [--host <claude|codex>] [--runtime-model <model>] [--runtime-effort <effort>] [--fallback <inline|stop>] [--audit-file <path>]');
 }
 
 function appendAuditRecord(record, auditFile, context) {
-  const target = auditFile || process.env.FABLE_AUDIT_FILE ||
-    path.join(getWorkspaceStateDir(getWorkspaceRoot(context)), 'state', 'fable-mode', 'audit.jsonl');
+  const target = auditFile || process.env.FABLE_AUDIT_FILE || path.join(getWorkspaceStateDir(getWorkspaceRoot(context)), 'state', 'fable-mode', 'audit.jsonl');
   fs.mkdirSync(path.dirname(path.resolve(target)), { recursive: true });
-  fs.appendFileSync(target, `${JSON.stringify(record)}\n`, 'utf8');
+  fs.appendFileSync(target, JSON.stringify(record) + '\n', 'utf8');
 }
 
 function main(argv = process.argv.slice(2)) {
   try {
     const input = parseArgs(argv);
-    if (input.help) {
-      printHelp();
-      return 0;
-    }
+    if (input.help) { printHelp(); return 0; }
     const record = resolveMode(input);
     appendAuditRecord(record, input.auditFile, input);
     console.log(JSON.stringify(record, null, 2));
     return record.status === 'blocked' ? 2 : 0;
   } catch (error) {
-    console.error(`[fable-mode/model-selector] ${error.message}`);
+    console.error('[fable-mode/model-selector] ' + error.message);
     return 2;
   }
 }
 
 if (require.main === module) process.exitCode = main();
 
-module.exports = { loadMatrix, normalizeModel, parseArgs, resolveMode, main };
+module.exports = { loadBehaviorMatrix, loadMatrix: loadBehaviorMatrix, loadRuntimeFloors, normalizeProfile, normalizeModel: normalizeProfile, parseArgs, evaluateRuntimeFloor, resolveMode, main };

package/plugins/harness-everything/skills/fable-mode/scripts/workflow-plan-consumer.js

@@ -272,7 +272,7 @@ function prepareRun({ routerContract, stages, workspaceRoot, runId, sessionId =
       verification: plan.verification,
       workspace: plan.workspace,
       memory: plan.memory,
-      modelSelection: plan.modelSelection,
+      profileSelection: plan.profileSelection,
       limits: plan.limits,
     },
     stageIds: normalizedStages.map(stage => stage.stageId),

package/plugins/harness-everything/skills/harness-everything/SKILL.md

@@ -4,35 +4,32 @@ description: "Route software/project work through Harness: classify tier/topolog
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.30.3
+  version: 0.30.6
 ---
 
 # Harness Everything
 
-Kernel routing entry.
-
 ## USE FOR:
 - Software/project triage, routing, re-routing, workflow selection.
-- Work that names or matches another skill.
+- Work naming or matching another skill.
 
 ## DO NOT USE FOR:
 - General Q&A or non-software writing.
 
 ## Invariants
-1. **Route (MUST)** — establish scope/tier and selected/deferred topology.
-2. **Verify (MUST)** — completion claims need objective evidence; `verify-gate.js --json` distinguishes passed, failed, discovered-but-unrun, and absent project checks.
+1. **Route (MUST)** — scope/tier plus selected/deferred topology.
+2. **Verify (MUST)** — objective evidence via `verify-gate.js --json`.
 3. **Zoom out (MUST)** — after 3 same-signature failures, use `zoom-out`.
-4. **Resolve suggestions (MUST)** — read/evaluate each suggested `SKILL.md`; applicable core contracts MUST run, otherwise retain a flow-grounded reason.
-5. **Surface status (MUST)** — non-trivial work renders `### 🚦 Harness Status` with bold `Current`, `Read / Evidence`, `Next`; optional `Risk / Blocked`.
-6. **Keep agency** — required obligations are MUST; tactics MAY adapt. Numeric planning values MAY guide, never hard-stop.
+4. **Resolve suggestions (MUST)** — evaluate each suggested `SKILL.md`; run applicable core contracts or retain a flow-grounded reason.
+5. **Surface status (MUST)** — non-trivial work renders `### 🚦 Harness Status` with bold `Current`, `Read / Evidence`, `Next`; `Risk / Blocked` optional.
+6. **Keep agency** — required obligations are MUST; tactics MAY adapt. Numeric planning MAY guide, never hard-stop; only Rule-of-3 reflection and explicit user/host permission boundaries may block.
+7. **Windows PowerShell (MUST)** — `Get-Content -Encoding UTF8 -Raw`; npm `.cmd` shims (`npx.cmd`); never weaken `ExecutionPolicy`.
 
 ## Workflow
 1. Reuse kernel output or run `node "<this-skill-dir>/scripts/kernel-router.js" "<prompt summary>"`.
 2. Keep the routing checkpoint internal.
-3. Resolve each suggestion as `use`, `not-applicable`, or `unresolved`; `use` follows its core contract.
-4. Resolve selected-topology required invariants/stages/checks before completion.
-5. Tier-3/Fable broad mutation MUST resolve isolation: linked worktree or explicit degraded fallback.
-
-**Rule:** semantic MUST is not hard blocking; only Rule-of-3 reflection and explicit user/host permission boundaries may block.
+3. Resolve suggestions as `use`, `not-applicable`, or `unresolved`.
+4. Complete selected-topology invariants/stages/checks.
+5. Tier-3/Fable broad mutation MUST use a linked worktree or explicit degraded fallback.
 
 Deep dive: <this-skill-dir>/references/triage-and-tiers.md

package/plugins/harness-everything/skills/harness-everything/references/router-workflow-plan.md

@@ -68,7 +68,7 @@ The Phase 2 `iterative-single` plan exposes **8 iterations** as advisory plannin
 The task-shape contract records:
 
 - an explicit requested strategy, when named;
-- an explicit Fable model request, still delegated to `fable-mode/scripts/model-selector.js`;
+- an explicit Fable behavior-profile request; legacy aliases `haiku`/`sonnet`/`opus` are delegated to `fable-mode/scripts/model-selector.js`;
 - prohibitions such as no Fable, no subagents, no parallel execution, or no workspace.
 
 Explicit choices override derived topology. Contradictory choice + prohibition is visible as a blocked fallback rather than silently guessing which instruction to ignore.
@@ -82,7 +82,7 @@ Examples:
 - missing parallel calls or `concurrency: 1` serializes `fable-parallel` to `fable-staged` with a `reduced/serialized` fallback;
 - unavailable subagents may reduce staged execution to visible inline execution;
 - missing durable state for a required multi-agent workspace is `blocked`, not silently downgraded;
-- a requested Fable model with known unavailable model capability is `blocked`; the router never substitutes another branded model;
+- Fable profile choice is independent of runtime-model availability; host-specific model floors are advisory and recorded by Fable rather than blocking routing;
 - a required `actionGate` with known unavailable hook capability is `blocked`.
 
 Fallbacks carry deterministic reason codes.

package/plugins/harness-everything/skills/harness-everything/schemas/router-task-shape.schema.json

@@ -56,10 +56,11 @@
     },
     "explicitRequest": {
       "type": "object",
-      "required": ["fableModel", "strategy", "prohibitions"],
+      "required": ["fableProfile", "fableAlias", "strategy", "prohibitions"],
       "additionalProperties": false,
       "properties": {
-        "fableModel": { "enum": ["haiku", "sonnet", "opus", null] },
+        "fableProfile": { "enum": ["mechanical", "reasoning", "orchestrator", null] },
+        "fableAlias": { "enum": ["mechanical", "reasoning", "orchestrator", "haiku", "sonnet", "sonnect", "opus", null] },
         "strategy": {
           "enum": ["direct-single", "iterative-single", "fable-staged", "fable-parallel", "fable-multi-agent-workspace", null]
         },

package/plugins/harness-everything/skills/harness-everything/schemas/router-workflow-plan.schema.json

@@ -19,7 +19,7 @@
     "memory",
     "verification",
     "ensemble",
-    "modelSelection",
+    "profileSelection",
     "fallback",
     "reasonCodes"
   ],
@@ -120,13 +120,14 @@
         }
       ]
     },
-    "modelSelection": {
+    "profileSelection": {
       "type": "object",
-      "required": ["requested", "policy"],
+      "required": ["requested", "alias", "policy"],
       "additionalProperties": false,
       "properties": {
-        "requested": { "enum": ["haiku", "sonnet", "opus", null] },
-        "policy": { "enum": ["defer-to-fable-selector"] }
+        "requested": { "enum": ["mechanical", "reasoning", "orchestrator", null] },
+        "alias": { "enum": ["mechanical", "reasoning", "orchestrator", "haiku", "sonnet", "sonnect", "opus", null] },
+        "policy": { "enum": ["behavior-profile-with-advisory-runtime-floor"] }
       }
     },
     "fallback": {

package/plugins/harness-everything/skills/harness-everything/scripts/router-contract-core.js

@@ -59,13 +59,23 @@ function normalizeConstraints(raw = {}) {
   };
 }
 
+function normalizeFableProfile(value) {
+  const input = String(value || '').trim().toLowerCase();
+  if (input === 'mechanical' || input === 'haiku') return { profile: 'mechanical', alias: input };
+  if (input === 'reasoning' || input === 'sonnet' || input === 'sonnect') return { profile: 'reasoning', alias: input };
+  if (input === 'orchestrator' || input === 'opus') return { profile: 'orchestrator', alias: input };
+  return { profile: null, alias: null };
+}
+
 function normalizeExplicitRequest(raw = {}) {
   const requestedStrategy = STRATEGIES.has(raw.strategy) ? raw.strategy : null;
   const prohibitions = Array.isArray(raw.prohibitions)
     ? raw.prohibitions.filter(value => PROHIBITIONS.has(value))
     : [];
+  const fable = normalizeFableProfile(raw.fableAlias || raw.fableProfile || raw.fableModel);
   return {
-    fableModel: ['haiku', 'sonnet', 'opus'].includes(raw.fableModel) ? raw.fableModel : null,
+    fableProfile: fable.profile,
+    fableAlias: fable.alias,
     strategy: requestedStrategy,
     prohibitions: Array.from(new Set(prohibitions)),
   };
@@ -77,7 +87,7 @@ function buildTaskShape(input = {}) {
   const hostCapabilities = normalizeHostCapabilities(input.hostCapabilities);
   const constraints = normalizeConstraints(input.constraints);
   const explicitRequest = normalizeExplicitRequest(input.explicitRequest || {
-    fableModel: input.requestedFableModel,
+    fableProfile: input.requestedFableProfile || input.requestedFableModel,
   });
 
   let scopeSize = 'unknown';
@@ -299,11 +309,6 @@ function selectWorkflowStrategy(input = {}) {
       fallback.reasonCodes.push(prohibitions.includes('subagents') ? 'user-prohibited-subagents' : 'subagents-unavailable');
     }
 
-    if (explicit.fableModel && taskShape.hostCapabilities.modelAvailability === 'unavailable') {
-      fallback.disposition = 'blocked';
-      fallback.mode = 'blocked';
-      fallback.reasonCodes.push('requested-model-capability-unavailable');
-    }
   }
 
   return {
@@ -494,9 +499,10 @@ function buildWorkflowPlan(input = {}) {
       independent: meta.verificationIndependent,
     },
     ensemble: null,
-    modelSelection: {
-      requested: taskShape.explicitRequest.fableModel,
-      policy: 'defer-to-fable-selector',
+    profileSelection: {
+      requested: taskShape.explicitRequest.fableProfile,
+      alias: taskShape.explicitRequest.fableAlias,
+      policy: 'behavior-profile-with-advisory-runtime-floor',
     },
     fallback,
     reasonCodes,
@@ -507,7 +513,7 @@ function buildRouterContract(input = {}) {
   const tier = normalizeTierLabel(input.recommendedTier);
   const reasonCodes = uniqueReasonCodes(input.reasonCodes);
   const explicitRequest = normalizeExplicitRequest(input.explicitRequest || {
-    fableModel: input.requestedFableModel,
+    fableProfile: input.requestedFableProfile || input.requestedFableModel,
   });
   const taskShape = buildTaskShape({
     tier,
@@ -546,7 +552,7 @@ function createDegradedRouterContract(reasonCode, message) {
     rationale: message || 'Structured router contract unavailable.',
     reasonCodes: [reasonCode || 'router-contract-unavailable'],
     signals: {},
-    requestedFableModel: null,
+    requestedFableProfile: null,
   });
 }
 
@@ -624,6 +630,7 @@ module.exports = {
   createDegradedRouterContract,
   normalizeConstraints,
   normalizeExplicitRequest,
+  normalizeFableProfile,
   normalizeHostCapabilities,
   normalizeTierLabel,
   selectWorkflowStrategy,