harness-everything 0.30.9 → 0.31.0

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

@@ -27,7 +27,6 @@ const INVARIANT_TEXT = {
   'verify-before-claim': 'MUST verify before claim with objective evidence appropriate to the change.',
   'visible-status-updates': 'MUST render the single Markdown Harness Status with a visible heading, bullet-aligned bold labels, Current, Read / Evidence, and Next; add Risk / Blocked only when materially applicable.',
   'replan-after-repeated-failure': 'MUST stop micro-retrying after 3 same-signature failures and zoom out/re-diagnose.',
-  'evaluate-suggestions-before-skip': 'MUST read/evaluate each suggested skill\'s complete SKILL.md entry/basic flow before omission; an applicable skill core contract MUST be followed.',
   'loop-awareness': 'MUST reconsider assumptions/re-plan when evidence shows iterative stagnation; numeric iteration values MAY guide but never hard-stop.',
   'objective-verification': 'MUST use an objective check for iterative work; self-critique alone is not verification.',
   'stage-contracts': 'When Fable is selected, stages MUST have explicit stage contracts and pass conditions.',
@@ -43,16 +42,6 @@ const INVARIANT_TEXT = {
   'isolated-worktree-before-mutation': 'Tier-3/Fable broad mutation MUST resolve isolation: verified linked worktree or explicit degraded fallback.',
 };
 
-const SKILL_TEXT = {
-  'tdd': 'tdd: useful for behavioral changes where executable tests can drive the implementation.',
-  'verification-loop': 'verification-loop: useful for systematic build/lint/test/diff evidence before delivery.',
-  'using-git-worktrees': 'using-git-worktrees: resolves required Tier-3/Fable isolation disposition before broad mutation.',
-  'fable-mode': 'fable-mode / fable-discipline: useful for macro planning or deliberate multi-agent decomposition.',
-  'fable-discipline': null,
-  'multi-agent-workspace': 'multi-agent-workspace: useful when durable bounded delegation, handoffs, or workspace memory are required.',
-  'self-evolve': 'self-evolve: classify an evidence-backed lesson and use the authorized memory persistence path.',
-};
-
 function sanitizeClassifierOutput(stdout) {
   const lines = String(stdout || '').split(/\r?\n/);
   const filtered = [];
@@ -121,25 +110,12 @@ function printWorkflowPlan(plan) {
     fallback: plan.fallback,
     reasonCodes: plan.reasonCodes,
     requiredInvariants: plan.requiredInvariants,
-    suggestedSkills: plan.suggestedSkills,
+    knowledgeSignals: plan.knowledgeSignals,
     mutationIsolation: plan.mutationIsolation,
   };
   console.log(`\n=> ROUTER WORKFLOW PLAN (JSON): ${JSON.stringify(visible)}`);
 }
 
-function uniqueSuggestedSkills(plan) {
-  if (!Array.isArray(plan.suggestedSkills)) return [];
-  return [...new Set(plan.suggestedSkills.filter(skill => typeof skill === 'string' && skill.trim()))];
-}
-
-function enforceSuggestionEvaluation(plan) {
-  if (uniqueSuggestedSkills(plan).length === 0) return;
-  if (!Array.isArray(plan.requiredInvariants)) plan.requiredInvariants = [];
-  if (!plan.requiredInvariants.includes('evaluate-suggestions-before-skip')) {
-    plan.requiredInvariants.push('evaluate-suggestions-before-skip');
-  }
-}
-
 function displayTier(tier) {
   if (tier === 'tier1') return 'Tier 1';
   if (tier === 'tier2') return 'Tier 2';
@@ -149,19 +125,14 @@ function displayTier(tier) {
 
 function printRoutingCheckpoint(plan) {
   const invariants = Array.isArray(plan.requiredInvariants) ? plan.requiredInvariants : [];
-  const suggestions = uniqueSuggestedSkills(plan);
+  const signals = Array.isArray(plan.knowledgeSignals) ? plan.knowledgeSignals : [];
 
   console.log('\n=> HARNESS ROUTING CHECKPOINT (INTERNAL SOURCE STATE — DO NOT RENDER SEPARATELY):');
   console.log(`   - Tier: ${displayTier(plan.tier)}`);
   console.log(`   - Strategy: ${plan.strategy || 'deferred'}`);
   console.log(`   - Required invariants: ${invariants.length ? invariants.join(', ') : 'none'}`);
-  console.log(`   - Suggested skills: ${suggestions.length ? suggestions.join(', ') : 'none'}`);
-  console.log('   - User-visible progress: use this checkpoint as source state for the single Harness Status contract below; do not invent a per-skill progress format.');
-  if (suggestions.length > 0) {
-    console.log('   - Suggestion evaluation: MANDATORY. Before skipping any listed skill, read its complete SKILL.md entry and evaluate USE FOR, DO NOT USE FOR, workflow/basic flow, and hard rules.');
-    console.log('   - Skip evidence: do not reject from only the skill name, description, router summary, or a generic "routine/common task" judgement. If the entry cannot be resolved/read, mark it unresolved/unavailable rather than skipped.');
-    console.log('   - Suggestion disposition: applicability is conditional, but resolution is mandatory. If a skill is applicable, follow its core contract; if not-applicable, keep one brief flow-grounded reason. The selected workflow is a semantic execution contract, not optional advice.');
-  }
+  console.log(`   - Knowledge signals: ${signals.length ? signals.join(', ') : 'none'} (planning input only; not document selectors)`);
+  console.log('   - User-visible progress: use this checkpoint as source state for the single Harness Status contract below.');
 }
 
 function printKernelContract(plan) {
@@ -170,6 +141,11 @@ function printKernelContract(plan) {
     console.log(`   - ${invariant}: ${INVARIANT_TEXT[invariant] || 'Required by the selected workflow plan.'}`);
   }
 
+  if (plan.strategy && ['tier2', 'tier3'].includes(plan.tier)) {
+    console.log('\n=> PLANNING STEP: decompose → compose');
+    console.log('   - Define ordered requirement steps and their bindings before starting execution.');
+  }
+
   console.log('\n=> USER-VISIBLE HARNESS STATUS CONTRACT (MUST):');
   console.log('   - For non-trivial software/project work, the agent MUST render this single Markdown status shape:');
   console.log('     ### 🚦 Harness Status');
@@ -184,26 +160,10 @@ function printKernelContract(plan) {
   console.log('   - Emit it before substantive execution, after a major phase, when direction materially changes, at meaningful long-running phase boundaries, and before final completion (the final response may merge it naturally).');
   console.log('   - This is a semantic communication MUST, not a hard execution lock, counter, or reset condition.');
 
-  console.log('\n=> WORKFLOW SKILLS (APPLICABILITY MUST BE RESOLVED):');
-  if (Array.isArray(plan.suggestedSkills) && plan.suggestedSkills.length > 0) {
-    const emitted = new Set();
-    for (const skill of plan.suggestedSkills) {
-      if (emitted.has(skill)) continue;
-      const text = Object.prototype.hasOwnProperty.call(SKILL_TEXT, skill) ? SKILL_TEXT[skill] : `${skill}: evaluate applicability inside the selected topology.`;
-      if (text) console.log(`   - ${text}`);
-      emitted.add(skill);
-      if (skill === 'fable-mode') emitted.add('fable-discipline');
-    }
-    if (plan.strategy && plan.strategy.startsWith('fable-')) {
-      console.log('   - Fable is not a universal pipeline, but a selected Fable topology must be entered and resolved before completion.');
-    }
-  } else if (plan.strategy === 'direct-single') {
-    console.log('   - No domain skill was suggested. The bounded direct path SHOULD remain minimal; a focused skill MAY be loaded when it adds value.');
-  } else if (plan.strategySelection === 'deferred') {
-    console.log('   - Strategy is deferred/unclassified. Do not infer triviality; choose the smallest justified approach from task evidence.');
-  } else {
-    console.log('   - No additional skill suggestion from the workflow plan.');
-  }
+  console.log('\n=> ACTIVE-STEP KNOWLEDGE BINDINGS (MUST):');
+  console.log('   - Compose ordered requirement steps before execution. Each step declares the required/optional skills or references for that step.');
+  console.log('   - MUST load/resolve only bindings declared for the active step; future-step bindings remain undisclosed until that step becomes active.');
+  console.log('   - A required binding MUST be loaded and its core contract followed before the active step passes. An unknown/unavailable binding stays visible and unresolved; it does not hard-block ordinary tools or Stop.');
 
   if (plan.ensemble) {
     console.log(`\n=> ENSEMBLE REVIEW: bounded to ${plan.ensemble.maxCandidates} candidates; synthesis=${plan.ensemble.synthesis}; verifier=${plan.ensemble.verifier}. Preserve minority positions and do not claim improvement without paired evidence.`);
@@ -224,6 +184,44 @@ function printKernelContract(plan) {
   console.log('\n=> ORCHESTRATION POLICY: Selected-topology required obligations and applicable skill core contracts are semantic MUSTs; implementation tactics MAY adapt. Lifecycle hooks observe/remind rather than hard-block, except user/host permission boundaries and the Rule-of-3 zoom-out.');
 }
 
+function printRetainedWorkflow(plan, workflow, activeStep = null, activeStages = []) {
+  const invariants = Array.isArray(workflow?.requiredInvariants) ? workflow.requiredInvariants : plan.requiredInvariants || [];
+  const state = workflow?.state || 'unknown';
+  console.log('\n=> RETAINED EXECUTION CONTRACT (COMPACT):');
+  console.log(`   - Workflow: ${workflow?.workflowId || 'unavailable'}; state=${state}; tier=${displayTier(workflow?.tier || plan.tier)}; strategy=${workflow?.strategy || plan.strategy || 'deferred'}.`);
+  console.log(`   - Invariants remain active: ${invariants.length ? invariants.join(', ') : 'none'}.`);
+  console.log(`   - Action gate: ${plan.actionGate?.required ? `MUST remain ${plan.actionGate.disposition} (${plan.actionGate.reasonCodes.join(', ')})` : 'not required'}.`);
+  console.log(`   - Isolation: ${plan.mutationIsolation?.required ? 'MUST be resolved before broad mutation; missing host evidence remains visible, not a tool lock' : 'no topology-level isolation requirement'}.`);
+  if (activeStages.length) {
+    console.log(`   - Active Fable stage${activeStages.length === 1 ? '' : 's'}: ${activeStages.map(stage => `${stage.stageId} [${stage.status}]`).join(', ')}.`);
+    for (const stage of activeStages) {
+      console.log(`     - ${stage.stageId}: ${stage.goal}`);
+      for (const kind of ['requiredBindings', 'optionalBindings']) {
+        const bindings = stage[kind] || [];
+        if (bindings.length) {
+          console.log(`       - ${kind === 'requiredBindings' ? 'Required' : 'Optional'}: ${bindings.map(binding => `${binding.id} [${binding.status}; ${binding.path || 'path unavailable'}]`).join(', ')}.`);
+        }
+      }
+    }
+    console.log('   - Future-stage bindings remain undisclosed until their dependencies pass.');
+  } else if (activeStep) {
+    console.log(`   - Active step: ${activeStep.id} (${activeStep.stepType}) — ${activeStep.summary}; status=${activeStep.status}.`);
+    for (const kind of ['requiredBindings', 'optionalBindings']) {
+      const bindings = activeStep[kind] || [];
+      if (bindings.length) {
+        console.log(`   - ${kind === 'requiredBindings' ? 'Required' : 'Optional'} active bindings: ${bindings.map(binding => `${binding.id} [${binding.status}; ${binding.path || 'path unavailable'}]`).join(', ')}.`);
+      }
+    }
+    console.log('   - Do not resolve, load, or disclose bindings for future steps yet.');
+  } else if (String(workflow?.strategy || plan.strategy || '').startsWith('fable-')) {
+    console.log('   - No dependency-ready Fable stage bindings are currently available.');
+  } else {
+    console.log('   - Active step: planning/execution obligations; step bindings are not composed or started yet.');
+  }
+  console.log('   - Harness Status stays MUST: one block with Current, Read / Evidence, and Next; add Risk / Blocked only when material. Turn label stays MUST.');
+  console.log('   - Permission boundary and Rule-of-3 remain active; this reminder is non-blocking.');
+}
+
 function route(prompt, stdinPayload) {
   const classifierPath = path.join(__dirname, 'tier-router.js');
   const contractPath = path.join(os.tmpdir(), `harness-router-${process.pid}-${crypto.randomUUID()}.json`);
@@ -244,7 +242,6 @@ function route(prompt, stdinPayload) {
 
   const contract = readStructuredContract(contractPath);
   applyEnsemblePolicy(contract, resolvePrompt(prompt, stdinPayload));
-  enforceSuggestionEvaluation(contract.workflowPlan);
   try {
     fs.rmSync(contractPath, { force: true });
   } catch (err) {
@@ -279,4 +276,4 @@ if (prompt) {
 }
 }
 
-module.exports = { route, printWorkflowPlan, printRoutingCheckpoint, printKernelContract };
+module.exports = { route, printWorkflowPlan, printRoutingCheckpoint, printKernelContract, printRetainedWorkflow };

package/plugins/harness-everything/skills/harness-everything/scripts/kernel-router.js

@@ -105,6 +105,27 @@ function persistWorkflow(contract, payload, prompt) {
   return { ...context, hooksRoot, retained: false, memoryCapability };
 }
 
+function activeExecutionFor(persisted, plan) {
+  if (!persisted?.workflow || !persisted.hooksRoot) return null;
+  try {
+    if (String(persisted.workflow.strategy || '').startsWith('fable-')) {
+      const runtime = require(path.join(persisted.hooksRoot, 'lib/workflow-runtime'));
+      const match = runtime.matchingRun(persisted);
+      if (!match) return { activeStages: [] };
+      for (const relative of ['../../fable-mode/scripts/workflow-plan-consumer.js', '../../skills/fable-mode/scripts/workflow-plan-consumer.js']) {
+        const file = path.resolve(__dirname, relative);
+        if (fs.existsSync(file)) return { activeStages: require(file).activeStageBindings(match.runRoot, persisted.workflow.escapes) };
+      }
+      return { activeStages: [] };
+    }
+    const obligations = require(path.join(persisted.hooksRoot, 'lib/workflow-obligations'));
+    const loaded = obligations.loadObligationSet(persisted, plan);
+    return { activeStep: loaded.set ? obligations.activeStepSnapshot(loaded.set) : null };
+  } catch (_) {
+    return null;
+  }
+}
+
 // Printed last so it is the nearest instruction when the turn ends (docs/system-one-observations.md#label-line).
 function printLabelContract() {
   console.log('\n=> TURN LABEL LINE (MUST, EVERY TURN — short answers, lookups and trivial edits included):');
@@ -134,14 +155,35 @@ function run(raw) {
     if (persisted?.retained && persisted.workflow) plan = persisted.workflow.workflowPlan;
   } catch (error) { failure = error; }
   if (hostNotification && !persisted?.workflow) {
-    console.log('\n=> Host notification — no active execution contract; ignored for routing.');
+    console.log('\n=> Host notification: no active execution contract; ignored for routing.');
+    if (failure) console.error('[Workflow Reminder] routing state was not persisted: ' + failure.message);
+    printLabelContract();
+    return;
+  }
+  if (persisted?.retained && persisted.workflow) {
+    if (persisted.hostNotification) console.log('\n=> Host notification: routing unchanged; keeping the active execution contract.');
+    else console.log('\n=> Retaining unresolved workflow; showing its compact active contract.');
+    const activeExecution = activeExecutionFor(persisted, plan) || {};
+    const activeStep = activeExecution.activeStep || null;
+    const activeStages = activeExecution.activeStages || [];
+    core.printRetainedWorkflow(plan, persisted.workflow, activeStep, activeStages);
+    if (activeStep) {
+      const controller = path.join(persisted.hooksRoot, 'workflow-disposition.js');
+      console.log('   - Resolve only bindings for this active step, then pass this step with evidence.');
+      console.log('   - Controller: ' + controller + '; session: ' + persisted.sessionId + '; step: ' + activeStep.id + '.');
+      console.log('   - Resolve binding: node "' + controller + '" binding --session-id "' + persisted.sessionId + '" --step-id "' + activeStep.id + '" --binding-id "<active-binding-id>" --disposition <loaded|not-needed|unavailable> --evidence "<binding evidence>"');
+      console.log('   - Pass step: node "' + controller + '" step --session-id "' + persisted.sessionId + '" --step-id "' + activeStep.id + '" --disposition pass --evidence "<completion evidence>"');
+    } else if (activeStages.length) {
+      const controller = path.join(persisted.hooksRoot, 'workflow-disposition.js');
+      console.log('   - Resolve only declared bindings with stage-binding --stage-id <active-stage> --binding-id <binding> --disposition <loaded|not-needed|unavailable> --evidence <evidence>.');
+      console.log('   - Controller: ' + controller + '; session: ' + persisted.sessionId + '.');
+    }
+    printLabelContract();
     if (failure) console.error('[Workflow Reminder] routing state was not persisted: ' + failure.message);
     return;
   }
   if (result?.sanitized) console.log(result.sanitized);
   if (result?.stderr) process.stderr.write(result.stderr);
-  if (persisted?.hostNotification) console.log('\n=> Host notification — routing unchanged; keeping the active execution contract.');
-  else if (persisted?.retained) console.log('\n=> Retaining unresolved workflow from earlier prompts; the checkpoint below is the active execution contract.');
   core.printWorkflowPlan(plan);
   core.printRoutingCheckpoint(plan);
   core.printKernelContract(plan);
@@ -163,7 +205,8 @@ function run(raw) {
     if (plan.strategySelection === 'selected' && ['tier2', 'tier3'].includes(plan.tier)) {
       console.log('   - Planning contract: ' + path.join(persisted.sessionDir, 'workflow-obligations.json'));
       console.log('   - Requirements first: decompose intent into requirement fragments, then confirm the smallest sufficient workflow.');
-      console.log('   - Record plan: node "' + controller + '" plan --session-id "' + persisted.sessionId + '" --requirements-json "[{\\\"id\\\":\\\"req-1\\\",\\\"summary\\\":\\\"...\\\",\\\"acceptance\\\":\\\"...\\\"}]" --strategy "' + plan.strategy + '" --evidence "<why this workflow fits>"');
+      console.log('   - Record ordered step types (review, behavior-change, verification, commit) and their bindings before execution.');
+      console.log('   - Record plan: node "' + controller + '" plan --session-id "' + persisted.sessionId + '" --requirements-json "[{\\"id\\":\\"req-1\\",\\"stepType\\":\\"behavior-change\\",\\"summary\\":\\"...\\",\\"acceptance\\":\\"...\\"},{\\"id\\":\\"req-verify\\",\\"stepType\\":\\"verification\\",\\"summary\\":\\"...\\",\\"acceptance\\":\\"...\\"}]" --strategy "' + plan.strategy + '" --evidence "<why this workflow fits>"');
     }
     console.log('   - Enter selected workflow after planning: node "' + controller + '" start --session-id "' + persisted.sessionId + '"');
     console.log('   - Escape one declared stage: node "' + controller + '" escape --session-id "' + persisted.sessionId + '" --stage-id "<id>" --reason-code workflow-uncovered-scope --scope "<uncovered scope>" --evidence "<evidence>"');
@@ -175,7 +218,7 @@ function run(raw) {
   if (result && result.status !== 0) console.error('[Workflow Reminder] router returned status ' + result.status + '; contract observation is degraded, not blocking.');
 }
 
-if (typeof module !== 'undefined') module.exports = { isHostNotificationPrompt };
+if (typeof module !== 'undefined') module.exports = { isHostNotificationPrompt, activeExecutionFor };
 
 if (process.argv.length > 2 || process.stdin.isTTY) run('');
 else {  let input = '';

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

@@ -327,6 +327,7 @@ function planMetadataForStrategy(strategy) {
     patterns: ['router'],
     requiredInvariants: ['scope-lock', 'environment-alignment', 'verify-before-claim', 'replan-after-repeated-failure', 'visible-status-updates'],
     suggestedSkills: [],
+    knowledgeSignals: [],
     maxIterations: null,
     parallelAllowed: null,
     parallelReasonCodes: [],
@@ -355,7 +356,6 @@ function planMetadataForStrategy(strategy) {
       ...base,
       patterns: ['router', 'react'],
       requiredInvariants: [...base.requiredInvariants, 'loop-awareness', 'objective-verification'],
-      suggestedSkills: ['tdd', 'verification-loop'],
       maxIterations: ITERATIVE_MAX_ITERATIONS,
       parallelAllowed: false,
       parallelReasonCodes: ['single-agent-loop'],
@@ -371,7 +371,6 @@ function planMetadataForStrategy(strategy) {
       ...base,
       patterns: ['router', 'planner-executor', 'evaluator-optimizer'],
       requiredInvariants: [...base.requiredInvariants, 'stage-contracts', 'cold-verification', 'isolated-worktree-before-mutation'],
-      suggestedSkills: ['using-git-worktrees', 'fable-mode', 'fable-discipline', 'verification-loop'],
       parallelAllowed: false,
       parallelReasonCodes: ['dependent-or-unproven-independent-stages'],
       workspaceRequired: false,
@@ -386,7 +385,6 @@ function planMetadataForStrategy(strategy) {
       ...base,
       patterns: ['router', 'planner-executor', 'evaluator-optimizer'],
       requiredInvariants: [...base.requiredInvariants, 'stage-contracts', 'cold-verification', 'isolated-worktree-before-mutation', 'parallel-scope-contract', 'synthesis-barrier'],
-      suggestedSkills: ['using-git-worktrees', 'fable-mode', 'fable-discipline', 'verification-loop'],
       parallelAllowed: true,
       parallelReasonCodes: ['independent-read-only-or-disjoint-scopes'],
       workspaceRequired: false,
@@ -401,7 +399,6 @@ function planMetadataForStrategy(strategy) {
       ...base,
       patterns: ['router', 'planner-executor', 'evaluator-optimizer', 'multi-agent-memory'],
       requiredInvariants: [...base.requiredInvariants, 'stage-contracts', 'cold-verification', 'isolated-worktree-before-mutation', 'handoff-contracts', 'workspace-state'],
-      suggestedSkills: ['using-git-worktrees', 'multi-agent-workspace', 'fable-mode', 'fable-discipline', 'verification-loop'],
       parallelAllowed: false,
       parallelReasonCodes: ['workspace-orchestrator-controls-concurrency'],
       workspaceRequired: true,
@@ -427,13 +424,12 @@ function buildWorkflowPlan(input = {}) {
 
   const requiredInvariants = [...meta.requiredInvariants];
   const patterns = [...meta.patterns];
-  const suggestedSkills = [...meta.suggestedSkills];
+  const knowledgeSignals = Array.from(new Set((input.knowledgeSignals || []).filter(value => typeof value === 'string' && value.trim())));
   const memoryPersistenceRequested = Boolean(taskShape.observedSignals && taskShape.observedSignals.memoryPersistenceRequested);
   const memoryProhibited = Boolean(taskShape.explicitRequest && taskShape.explicitRequest.prohibitions && taskShape.explicitRequest.prohibitions.includes('memory'));
   const memoryWrite = memoryProhibited ? 'none' : (memoryPersistenceRequested ? 'persist-via-self-evolve' : meta.memoryWrite);
   if (memoryPersistenceRequested && !memoryProhibited) {
     requiredInvariants.push('memory-write-authorization');
-    suggestedSkills.push('self-evolve');
   }
   if (actionGateRequired) {
     requiredInvariants.push('pre-action-approval');
@@ -467,7 +463,8 @@ function buildWorkflowPlan(input = {}) {
     strategySelection: selection.strategySelection,
     patterns: Array.from(new Set(patterns)),
     requiredInvariants: Array.from(new Set(requiredInvariants)),
-    suggestedSkills: Array.from(new Set(suggestedSkills)),
+    suggestedSkills: [],
+    knowledgeSignals,
     actionGate: {
       required: actionGateRequired,
       reasonCodes: actionGateReasonCodes,
@@ -527,6 +524,7 @@ function buildRouterContract(input = {}) {
     routingStatus: input.routingStatus,
     tier,
     taskShape,
+    knowledgeSignals: input.knowledgeSignals,
     actionGateReasonCodes: input.actionGateReasonCodes,
     reasonCodes,
   });
@@ -570,6 +568,8 @@ function validateWorkflowPlan(plan) {
   if (plan.strategySelection === 'deferred' && plan.strategy !== null) errors.push('deferred strategy must be null');
   if (!Array.isArray(plan.requiredInvariants)) errors.push('requiredInvariants must be an array');
   if (!Array.isArray(plan.suggestedSkills)) errors.push('suggestedSkills must be an array');
+  if (!Array.isArray(plan.knowledgeSignals) || plan.knowledgeSignals.some(value => typeof value !== 'string' || !/^[a-z0-9][a-z0-9-]{0,63}$/.test(value)) ||
+      new Set(plan.knowledgeSignals).size !== plan.knowledgeSignals.length) errors.push('knowledgeSignals must be unique normalized signal ids');
   if (!plan.actionGate || typeof plan.actionGate.required !== 'boolean') errors.push('actionGate.required must be boolean');
   if (plan.actionGate && plan.actionGate.required && plan.actionGate.disposition !== 'pending-approval') errors.push('required actionGate must be pending-approval before execution');
   if (!plan.limits || !Object.prototype.hasOwnProperty.call(plan.limits, 'maxIterations')) errors.push('limits.maxIterations is required');

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

@@ -12,10 +12,8 @@ function isMajorWorkflow(plan) {
 function augmentWorkflowPlan(plan) {
   if (!plan || !isMajorWorkflow(plan)) return plan;
   const requiredInvariants = Array.isArray(plan.requiredInvariants) ? [...plan.requiredInvariants] : [];
-  const suggestedSkills = Array.isArray(plan.suggestedSkills) ? [...plan.suggestedSkills] : [];
   if (!requiredInvariants.includes('isolated-worktree-before-mutation')) requiredInvariants.push('isolated-worktree-before-mutation');
-  if (!suggestedSkills.includes('using-git-worktrees')) suggestedSkills.push('using-git-worktrees');
-  return { ...plan, requiredInvariants, suggestedSkills, mutationIsolation: {
+  return { ...plan, requiredInvariants, mutationIsolation: {
     required: true, mechanism: 'git-worktree', transition: 'before-first-mutation', onUnavailable: 'degraded',
   } };
 }