harness-everything 0.8.1 → 0.9.0

package/plugins/harness-everything/hooks/scripts/lib/workflow-runtime.js

@@ -34,6 +34,158 @@ function loadWorkflow(payload) {
 
 function saveWorkflow(context) { atomicWriteJson(context.file, context.workflow); }
 
+function budgetLimits(workflow) {
+  const limits = workflow?.workflowPlan?.limits || {};
+  return {
+    maxIterations: Number.isInteger(limits.maxIterations) && limits.maxIterations > 0 ? limits.maxIterations : null,
+    maxRevisionRounds: Number.isInteger(limits.maxRevisionRounds) && limits.maxRevisionRounds >= 0 ? limits.maxRevisionRounds : 0,
+    maxReplans: Number.isInteger(limits.maxReplans) && limits.maxReplans >= 0 ? limits.maxReplans : 0,
+    maxWorkers: Number.isInteger(limits.maxWorkers) && limits.maxWorkers > 0 ? limits.maxWorkers : 1,
+  };
+}
+
+function ensureWorkflowBudget(workflow) {
+  if (workflow.budget && workflow.budget.schemaVersion === 1) return workflow.budget;
+  const now = new Date().toISOString();
+  workflow.budget = {
+    schemaVersion: 1,
+    epoch: 0,
+    state: 'active',
+    limits: budgetLimits(workflow),
+    counters: { iterations: 0, revisionRounds: 0, replans: 0 },
+    activeWorkers: {},
+    reasonCode: null,
+    exhaustedAt: null,
+    resets: [],
+    events: [],
+    createdAt: now,
+    updatedAt: now,
+  };
+  return workflow.budget;
+}
+
+function syncBudgetToRun(context) {
+  const match = matchingRun(context);
+  if (!match || !context.workflow?.budget) return;
+  const updated = {
+    ...match.run,
+    budget: JSON.parse(JSON.stringify(context.workflow.budget)),
+  };
+  atomicWriteJson(path.join(match.runRoot, 'run.json'), updated);
+}
+
+function persistBudget(context) {
+  saveWorkflow(context);
+  syncBudgetToRun(context);
+}
+
+function budgetError(message) {
+  const error = new Error(message);
+  error.code = 'HARNESS_WORKFLOW_BUDGET';
+  return error;
+}
+
+function appendBudgetEvent(budget, event) {
+  budget.events = [...(budget.events || []), event].slice(-64);
+  budget.updatedAt = event.observedAt;
+}
+
+function exhaustBudget(context, reasonCode, evidence) {
+  const budget = ensureWorkflowBudget(context.workflow);
+  const now = new Date().toISOString();
+  budget.state = 'budget-exhausted';
+  budget.reasonCode = reasonCode;
+  budget.exhaustedAt = now;
+  appendBudgetEvent(budget, { type: 'budget-exhausted', reasonCode, evidence: evidence || null, observedAt: now });
+  context.workflow.state = 'blocked';
+  context.workflow.blockReason = reasonCode;
+  persistBudget(context);
+  throw budgetError(`budget-exhausted: ${reasonCode}`);
+}
+
+function recordBudgetEvent(context, type, options = {}) {
+  const { workflow } = context;
+  if (!workflow) throw budgetError('no workflow available for budget accounting');
+  const budget = ensureWorkflowBudget(workflow);
+  if (budget.state !== 'active') throw budgetError(`workflow budget is ${budget.state}: ${budget.reasonCode || 'unavailable'}`);
+  const now = new Date().toISOString();
+  const evidence = options.evidence || null;
+
+  const consume = (counter, limitName, reasonCode) => {
+    const limit = budget.limits[limitName];
+    if (limit === null) return { applicable: false, value: budget.counters[counter] };
+    if (budget.counters[counter] >= limit) return exhaustBudget(context, reasonCode, evidence);
+    budget.counters[counter]++;
+    appendBudgetEvent(budget, { type, counter, value: budget.counters[counter], limit, evidence, observedAt: now });
+    persistBudget(context);
+    return { applicable: true, value: budget.counters[counter], limit };
+  };
+
+  if (type === 'iteration') return consume('iterations', 'maxIterations', 'iteration-budget-exhausted');
+  if (type === 'revision') return consume('revisionRounds', 'maxRevisionRounds', 'revision-budget-exhausted');
+  if (type === 'replan') return consume('replans', 'maxReplans', 'replan-budget-exhausted');
+
+  if (type === 'worker-acquire') {
+    const workerId = String(options.workerId || '').trim();
+    if (!SAFE_ID.test(workerId)) throw budgetError('worker-acquire requires a stable safe worker id');
+    if (budget.activeWorkers[workerId]) return { active: Object.keys(budget.activeWorkers).length, idempotent: true };
+    const active = Object.keys(budget.activeWorkers).length;
+    if (active >= budget.limits.maxWorkers) return exhaustBudget(context, 'worker-budget-exhausted', evidence || workerId);
+    budget.activeWorkers[workerId] = { acquiredAt: now, evidence };
+    appendBudgetEvent(budget, { type, workerId, active: active + 1, limit: budget.limits.maxWorkers, evidence, observedAt: now });
+    persistBudget(context);
+    return { active: active + 1, limit: budget.limits.maxWorkers };
+  }
+
+  if (type === 'worker-release') {
+    const workerId = String(options.workerId || '').trim();
+    if (!SAFE_ID.test(workerId)) throw budgetError('worker-release requires a stable safe worker id');
+    const existed = Boolean(budget.activeWorkers[workerId]);
+    delete budget.activeWorkers[workerId];
+    appendBudgetEvent(budget, { type, workerId, existed, active: Object.keys(budget.activeWorkers).length, evidence, observedAt: now });
+    persistBudget(context);
+    return { active: Object.keys(budget.activeWorkers).length, existed };
+  }
+
+  throw budgetError(`unknown workflow budget event: ${type}`);
+}
+
+function resetWorkflowBudget(context, evidence) {
+  const { workflow } = context;
+  if (!workflow) throw budgetError('no workflow available for budget reset');
+  const previous = ensureWorkflowBudget(workflow);
+  if (previous.state !== 'budget-exhausted' || workflow.state !== 'blocked') {
+    throw budgetError('budget reset is allowed only after explicit budget exhaustion');
+  }
+  if (!String(evidence || '').trim()) throw budgetError('budget reset requires audit evidence');
+  const now = new Date().toISOString();
+  const resets = [...(previous.resets || []), {
+    epoch: previous.epoch,
+    reasonCode: previous.reasonCode,
+    counters: previous.counters,
+    evidence: String(evidence).trim(),
+    resetAt: now,
+  }].slice(-16);
+  workflow.budget = {
+    schemaVersion: 1,
+    epoch: previous.epoch + 1,
+    state: 'active',
+    limits: budgetLimits(workflow),
+    counters: { iterations: 0, revisionRounds: 0, replans: 0 },
+    activeWorkers: {},
+    reasonCode: null,
+    exhaustedAt: null,
+    resets,
+    events: [{ type: 'budget-reset', evidence: String(evidence).trim(), observedAt: now }],
+    createdAt: previous.createdAt || now,
+    updatedAt: now,
+  };
+  workflow.state = 'pending';
+  delete workflow.blockReason;
+  persistBudget(context);
+  return workflow.budget;
+}
+
 function matchingRun(context) {
   const { workflow, root, sessionId } = context;
   if (!workflow || !SAFE_ID.test(workflow.runId || '') || !workflow.workflowId || !sessionId) return null;
@@ -99,4 +251,4 @@ function readHookInput(decide) {
   process.stdin.on('error', finish);
 }
 
-module.exports = { OPEN_STATES, SAFE_ID, isMajorWorkflow, loadWorkflow, saveWorkflow, matchingRun, unresolvedStages, readHookInput };
+module.exports = { OPEN_STATES, SAFE_ID, isMajorWorkflow, loadWorkflow, saveWorkflow, budgetLimits, ensureWorkflowBudget, recordBudgetEvent, resetWorkflowBudget, syncBudgetToRun, matchingRun, unresolvedStages, readHookInput };

package/plugins/harness-everything/hooks/scripts/subagent-scope-guard.js

@@ -30,6 +30,17 @@ const {
   getWorkerId,
   stagesForChangedPath,
 } = require('./lib/fable-contracts');
+const { loadWorkflow, recordBudgetEvent } = require('./lib/workflow-runtime');
+
+function accountWorker(payload, event) {
+  const context = loadWorkflow(payload);
+  const workflow = context.workflow;
+  if (!workflow || workflow.state !== 'running' || !String(workflow.strategy || '').startsWith('fable-')) return;
+  const workerId = getWorkerId(payload);
+  if (!workerId) return;
+  const type = event === 'PreToolUse' || event === 'SubagentStart' ? 'worker-acquire' : 'worker-release';
+  recordBudgetEvent(context, type, { workerId, evidence: event });
+}
 
 function gitStatus(root) {
   try {
@@ -112,6 +123,7 @@ process.stdin.on('end', () => {
     const stateFile = path.join(sessionDir, 'subagent-scope-state.json');
 
     if (event === 'PreToolUse' || event === 'SubagentStart') {
+      accountWorker(payload, event);
       if (!fs.existsSync(stateFile)) {
         const status = gitStatus(root);
         if (status !== null) {
@@ -126,6 +138,7 @@ process.stdin.on('end', () => {
     }
 
     if (event === 'PostToolUse' || event === 'SubagentStop') {
+      accountWorker(payload, event);
       if (!fs.existsSync(stateFile)) process.exit(0);
 
       let state;
@@ -182,9 +195,13 @@ process.stdin.on('end', () => {
     }
 
     process.exit(0);
-  } catch (_) {
-    // This is a post-execution visibility gate. Runtime errors fail open; the
-    // actionGate in Phase 5 has a stricter fail-ask policy for side effects.
+  } catch (error) {
+    if (error && error.code === 'HARNESS_WORKFLOW_BUDGET') {
+      console.error(`[Subagent Scope Guard] ${error.message}`);
+      process.exit(2);
+    }
+    // This is otherwise a post-execution visibility gate. Runtime errors fail open;
+    // actionGate has a stricter fail-ask policy for side effects.
     process.exit(0);
   }
 });

package/plugins/harness-everything/hooks/scripts/workflow-disposition.js

@@ -3,7 +3,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { loadWorkflow, saveWorkflow, matchingRun, OPEN_STATES } = require('./lib/workflow-runtime');
+const { loadWorkflow, saveWorkflow, matchingRun, OPEN_STATES, ensureWorkflowBudget, recordBudgetEvent, resetWorkflowBudget, syncBudgetToRun } = require('./lib/workflow-runtime');
 const { getWorkspaceRoot, readCurrentSession } = require('./lib/harness-state');
 const { atomicWriteJson, readJson } = require('./lib/fable-contracts');
 
@@ -38,13 +38,14 @@ function main() {
   if (args.command === 'start') {
     if (!workflow.workflowId || !workflow.workflowPlan) throw new Error('legacy workflow lacks a correlated plan; cannot start it implicitly');
     if (workflow.state === 'running') throw new Error('workflow already running; record a blocker before replanning');
-    const max = workflow.workflowPlan.limits?.maxRevisionRounds ?? 2;
-    if (workflow.revision > max) throw new Error('replan budget exhausted; workflow remains blocked');
+    const isReplan = workflow.revision > 0 || Boolean(workflow.runId);
+    if (isReplan) recordBudgetEvent(context, 'replan', { evidence: 'workflow-disposition:start' });
     const plan = workflow.pendingPlan || workflow.workflowPlan;
     if (!String(plan.strategy || '').startsWith('fable-')) {
       workflow.revision++;
       workflow.state = 'running';
       delete workflow.blockReason;
+      ensureWorkflowBudget(workflow);
       saveWorkflow(context);
       process.stdout.write(JSON.stringify({ state: workflow.state, workflowId: workflow.workflowId, revision: workflow.revision }) + '\n');
       return;
@@ -71,6 +72,11 @@ function main() {
     workflow.escapes = [];
     delete workflow.pendingPlan;
     delete workflow.blockReason;
+    ensureWorkflowBudget(workflow);
+  } else if (args.command === 'revision') {
+    recordBudgetEvent(context, 'revision', { evidence: args.evidence || 'workflow-disposition:revision' });
+  } else if (args.command === 'reset-budget') {
+    resetWorkflowBudget(context, args.evidence);
   } else if (args.command === 'escape') {
     if (!ALLOWED_ESCAPE_REASONS.has(args.reasonCode)) throw new Error('generic simple/routine/already-clear reasons are intentionally rejected');
     if (!args.scope?.trim()) throw new Error('--scope is required');
@@ -90,8 +96,9 @@ function main() {
     if (!args.evidence?.trim()) throw new Error('--evidence is required');
     workflow.state = 'blocked';
     workflow.blockReason = args.evidence.trim();
-  } else throw new Error('Usage: workflow-disposition.js <start|escape|block> --session-id <id> [--stage-id <id> --reason-code <reason> --scope <scope> --evidence <evidence>]');
+  } else throw new Error('Usage: workflow-disposition.js <start|revision|reset-budget|escape|block> --session-id <id> [--stage-id <id> --reason-code <reason> --scope <scope> --evidence <evidence>]');
   saveWorkflow(context);
+  syncBudgetToRun(context);
   process.stdout.write(JSON.stringify({ state: workflow.state, workflowId: workflow.workflowId, runId: workflow.runId, revision: workflow.revision, escapes: workflow.escapes }) + '\n');
 }
 try { main(); } catch (error) { console.error('[Workflow Disposition] ' + error.message); process.exitCode = 2; }

package/plugins/harness-everything/hooks/scripts/workflow-gate.js

@@ -3,7 +3,7 @@
 
 const path = require('path');
 const fs = require('fs');
-const { loadWorkflow, saveWorkflow, isMajorWorkflow, matchingRun, readHookInput } = require('./lib/workflow-runtime');
+const { loadWorkflow, saveWorkflow, isMajorWorkflow, matchingRun, recordBudgetEvent, readHookInput } = require('./lib/workflow-runtime');
 const { key, classifyShell, cwdOf, commandOf, mutationPaths, linkedWorktree, assertTargets, assertShellScope } = require('./lib/workflow-isolation');
 
 const DIRECT = new Set(['Edit', 'Write', 'apply_patch']);
@@ -46,6 +46,9 @@ function decide(payload) {
   if (String(workflow.strategy || '').startsWith('fable-') && !matchingRun(context)) {
     throw new Error('selected Fable workflow has no correlated run. Write workflow-stages.json at the displayed session path, then use workflow-disposition.js start.');
   }
+  if (workflow.strategy === 'iterative-single') {
+    recordBudgetEvent(context, 'iteration', { evidence: `${tool}:${commandClass}` });
+  }
   workflow.lastMutationAt = Date.now();
   saveWorkflow(context);
 }

package/plugins/harness-everything/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "harness-everything",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "description": "Invariant-first engineering harness for routing, verification, and failure recovery while preserving agent autonomy.",
   "author": {
     "name": "Miya Daniel",

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

@@ -4,7 +4,7 @@ description: "Stage large, multi-source or multi-session tasks through a written
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.8.1
+  version: 0.9.0
 ---
 
 # Fable Mode (v3)

package/plugins/harness-everything/skills/fable-mode/agents/fable-orchestrator.md

@@ -53,9 +53,10 @@ overlap reject dispatch instead of becoming a verbal warning.
 
 The stage map remains a living orchestration document only inside those
 constraints. When new information invalidates it, re-plan and create revised
-stage contracts before dispatching new work. Replan budget: at most two full
-replans per run; a third means the task is ambiguous at the requirements level —
-return the ambiguity to the caller instead of burning stages. Scope rule:
+stage contracts before dispatching new work. Replan budget comes from `workflowPlan.limits.maxReplans` and is accounted by
+the runtime controller. Re-enter through `workflow-disposition.js start`; a
+third full replan under the default budget is machine-blocked as
+`replan-budget-exhausted` instead of being only an orchestration reminder. Scope rule:
 deliver the task as specified; new scope discovered mid-run is surfaced as a
 recommendation at delivery, not silently built.
 
@@ -75,10 +76,11 @@ spawn workers.
 
 For `fable-parallel`, spawn only stages in the same validated execution batch;
 never invent an additional parallel edge. A stage depending on another stage is
-not in the same ready batch. Cap concurrent workers at four — this remains
-Fable's single source of truth for the numeric worker cap. For other Fable
-strategies, serialize the returned batches unless a later validated plan says
-otherwise.
+not in the same ready batch. Never exceed `workflowPlan.limits.maxWorkers`. The router plan is the numeric
+source of truth; `workflow-plan-consumer.js` chunks ready sets to that cap and
+runtime worker leases enforce it when the host exposes stable worker IDs. For
+other Fable strategies, serialize the returned batches unless a later validated
+plan says otherwise.
 
 **3. Verify with a check that can fail — external artifacts only.** Each stage
 defines a pass condition an external artifact satisfies: a test that runs, a file

package/plugins/harness-everything/skills/fable-mode/execution-guardrails/SKILL.md

@@ -7,7 +7,7 @@ description: >-
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.8.1
+  version: 0.9.0
 ---
 
 # Execution Guardrails

package/plugins/harness-everything/skills/fable-mode/fable-haiku/SKILL.md

@@ -4,7 +4,7 @@ description: "Run staged fable work on Haiku for bulk mechanical tasks with expl
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.8.1
+  version: 0.9.0
 ---
 
 # Fable Mode — Haiku

package/plugins/harness-everything/skills/fable-mode/fable-opus/SKILL.md

@@ -4,7 +4,7 @@ description: "Run staged fable orchestration on Opus for cross-stage synthesis,
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.8.1
+  version: 0.9.0
 ---
 
 # Fable Mode — Opus

package/plugins/harness-everything/skills/fable-mode/fable-sonnet/SKILL.md

@@ -4,7 +4,7 @@ description: "Run staged fable work on Sonnet for non-trivial implementation, re
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.8.1
+  version: 0.9.0
 ---
 
 # Fable Mode — Sonnet

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

@@ -155,20 +155,23 @@ function validateParallelBatch(stages) {
   }
 }
 
-function dependencyBatches(stages, validateWrites) {
+function dependencyBatches(stages, validateWrites, maxBatchSize = Infinity) {
   const byId = new Map(stages.map(stage => [stage.stageId, stage]));
   const remaining = new Set(byId.keys());
   const completed = new Set();
   const batches = [];
+  const boundedSize = Number.isInteger(maxBatchSize) && maxBatchSize > 0 ? maxBatchSize : Infinity;
 
   while (remaining.size > 0) {
     const ready = [...remaining]
       .filter(stageId => byId.get(stageId).dependsOn.every(dep => completed.has(dep)))
       .sort();
     if (ready.length === 0) throw new Error('unresolved or cyclic dependency graph');
-    const batch = ready.map(stageId => byId.get(stageId));
-    if (validateWrites) validateParallelBatch(batch);
-    batches.push(batch.map(stage => stage.stageId));
+    const readyStages = ready.map(stageId => byId.get(stageId));
+    if (validateWrites) validateParallelBatch(readyStages);
+    for (let offset = 0; offset < readyStages.length; offset += boundedSize) {
+      batches.push(readyStages.slice(offset, offset + boundedSize).map(stage => stage.stageId));
+    }
     for (const stageId of ready) {
       remaining.delete(stageId);
       completed.add(stageId);
@@ -177,8 +180,8 @@ function dependencyBatches(stages, validateWrites) {
   return batches;
 }
 
-function topologicalBatches(stages) {
-  return dependencyBatches(stages, true);
+function topologicalBatches(stages, maxWorkers) {
+  return dependencyBatches(stages, true, maxWorkers);
 }
 
 function sequentialBatches(stages) {
@@ -222,7 +225,7 @@ function prepareRun({ routerContract, stages, workspaceRoot, runId, sessionId =
   if (fs.existsSync(runRoot)) throw new Error(`runId already exists in this workspace: ${resolvedRunId}`);
 
   const batches = plan.strategy === 'fable-parallel'
-    ? topologicalBatches(normalizedStages)
+    ? topologicalBatches(normalizedStages, plan.limits && plan.limits.maxWorkers)
     : sequentialBatches(normalizedStages);
 
   const createdAt = new Date().toISOString();

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

@@ -4,7 +4,7 @@ description: "Route software/project work through the Harness kernel: classify T
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.8.1
+  version: 0.9.0
 ---
 
 # Harness Everything

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

@@ -91,7 +91,8 @@
         "crossDomain",
         "highUncertainty",
         "irreversibleAction",
-        "externalSideEffect"
+        "externalSideEffect",
+        "memoryPersistenceRequested"
       ],
       "additionalProperties": false,
       "properties": {
@@ -113,7 +114,8 @@
         "crossDomain": { "type": "boolean" },
         "highUncertainty": { "type": "boolean" },
         "irreversibleAction": { "type": "boolean" },
-        "externalSideEffect": { "type": "boolean" }
+        "externalSideEffect": { "type": "boolean" },
+        "memoryPersistenceRequested": { "type": "boolean" }
       }
     },
     "reasonCodes": {

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

@@ -47,12 +47,13 @@
     },
     "limits": {
       "type": "object",
-      "required": ["maxIterations", "maxRevisionRounds", "maxWorkers"],
+      "required": ["maxIterations", "maxRevisionRounds", "maxReplans", "maxWorkers"],
       "additionalProperties": false,
       "properties": {
         "maxIterations": { "type": ["integer", "null"], "minimum": 1 },
         "maxRevisionRounds": { "type": "integer", "minimum": 0, "maximum": 2 },
-        "maxWorkers": { "enum": ["fable-orchestrator-cap"] }
+        "maxReplans": { "type": "integer", "minimum": 0, "maximum": 2 },
+        "maxWorkers": { "type": "integer", "minimum": 1, "maximum": 4 }
       }
     },
     "parallelism": {

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

@@ -35,6 +35,7 @@ const INVARIANT_TEXT = {
   'handoff-contracts': 'Multi-agent workspace work uses orchestrator-owned handoff contracts; workers do not form a peer mesh.',
   'workspace-state': 'Durable workspace state remains scoped to the workspace and existing state conventions.',
   'pre-action-approval': 'Irreversible/external side effects require approval before the exact payload executes.',
+  'memory-write-authorization': 'Durable memory writes must match the current session/workflow memory.write contract; retrieved memory remains untrusted data.',
   'preserve-disagreement': 'Ensemble synthesis must retain unresolved minority positions and evidence gaps.',
   'independent-ensemble-verifier': 'Ensemble delivery requires a verifier independent from the candidate identities; agreement alone is not proof.',
   'isolated-worktree-before-mutation': 'Major engineering must mutate only inside a verified Git worktree; unavailable isolation means blocked.',
@@ -46,6 +47,7 @@ const SKILL_TEXT = {
   '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) {

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

@@ -14,6 +14,25 @@ function loadRuntime() {
   throw new Error('workflow runtime unavailable in this installation');
 }
 
+function issueMemoryCapability(workflow) {
+  if (!workflow || !workflow.workflowPlan || workflow.workflowPlan.memory?.write === 'none') {
+    if (workflow) delete workflow.memoryAuthorization;
+    return null;
+  }
+  const token = crypto.randomBytes(24).toString('base64url');
+  workflow.memoryAuthorization = {
+    schemaVersion: 1,
+    capabilityHash: crypto.createHash('sha256').update(token, 'utf8').digest('hex'),
+    writerRole: 'coordinator',
+    sessionId: workflow.sessionId,
+    workflowId: workflow.workflowId,
+    writeDisposition: workflow.workflowPlan.memory.write,
+    issuedAt: new Date().toISOString(),
+    usedAt: null,
+  };
+  return token;
+}
+
 function persistWorkflow(plan, payload, prompt) {
   if (!payload || !(payload.session_id || payload.sessionId)) return null;
   const { runtime, hooksRoot } = loadRuntime();
@@ -31,8 +50,9 @@ function persistWorkflow(plan, payload, prompt) {
       context.workflow.mutationIsolation = plan.mutationIsolation;
     }
     context.workflow.lastPromptHash = crypto.createHash('sha256').update(prompt).digest('hex').slice(0, 24);
+    const memoryCapability = issueMemoryCapability(context.workflow);
     runtime.saveWorkflow(context);
-    return { ...context, hooksRoot, retained: true };
+    return { ...context, hooksRoot, retained: true, memoryCapability };
   }
   const selected = plan.strategySelection === 'selected' && Boolean(plan.strategy);
   const now = Date.now();
@@ -61,8 +81,9 @@ function persistWorkflow(plan, payload, prompt) {
       reasoningPolicy: 'model-controls-how',
     },
   };
+  const memoryCapability = issueMemoryCapability(context.workflow);
   runtime.saveWorkflow(context);
-  return { ...context, hooksRoot, retained: false };
+  return { ...context, hooksRoot, retained: false, memoryCapability };
 }
 
 function run(raw) {
@@ -99,6 +120,8 @@ function run(raw) {
   if (persisted) {
     const controller = path.join(persisted.hooksRoot, 'workflow-disposition.js');
     console.log('   - Workflow id: ' + persisted.workflow.workflowId);
+    console.log('   - Memory write disposition: ' + (persisted.workflow.workflowPlan.memory?.write || 'none'));
+    if (persisted.memoryCapability) console.log('   - Memory capability (single-use, workflow/session-bound): ' + persisted.memoryCapability);
     console.log('   - Stage specification: ' + path.join(persisted.sessionDir, 'workflow-stages.json'));
     console.log('   - Enter/replan: 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>"');

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

@@ -5,6 +5,9 @@ const path = require('path');
 
 const SCHEMA_VERSION = 1;
 const ITERATIVE_MAX_ITERATIONS = 8;
+const WORKFLOW_MAX_REVISION_ROUNDS = 2;
+const FABLE_MAX_REPLANS = 2;
+const FABLE_MAX_WORKERS = 4;
 const TIERS = new Set(['tier1', 'tier2', 'tier3', 'unclassified']);
 const ROUTING_STATUSES = new Set(['ok', 'degraded']);
 const STRATEGIES = new Set([
@@ -154,6 +157,7 @@ function buildTaskShape(input = {}) {
       highUncertainty: Boolean(signals.highUncertainty),
       irreversibleAction: Boolean(signals.irreversibleAction),
       externalSideEffect: Boolean(signals.externalSideEffect),
+      memoryPersistenceRequested: Boolean(signals.memoryPersistenceRequested),
     },
     reasonCodes: uniqueReasonCodes(input.reasonCodes),
   };
@@ -418,6 +422,14 @@ function buildWorkflowPlan(input = {}) {
 
   const requiredInvariants = [...meta.requiredInvariants];
   const patterns = [...meta.patterns];
+  const suggestedSkills = [...meta.suggestedSkills];
+  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');
     patterns.push('verifier-gated');
@@ -438,6 +450,8 @@ function buildWorkflowPlan(input = {}) {
     ...selection.reasonCodes,
     ...fallback.reasonCodes,
     ...actionGateReasonCodes,
+    ...(memoryPersistenceRequested ? ['memory-persistence-requested'] : []),
+    ...(memoryPersistenceRequested && memoryProhibited ? ['memory-persistence-prohibited'] : []),
   ]);
 
   return {
@@ -448,7 +462,7 @@ function buildWorkflowPlan(input = {}) {
     strategySelection: selection.strategySelection,
     patterns: Array.from(new Set(patterns)),
     requiredInvariants: Array.from(new Set(requiredInvariants)),
-    suggestedSkills: Array.from(new Set(meta.suggestedSkills)),
+    suggestedSkills: Array.from(new Set(suggestedSkills)),
     actionGate: {
       required: actionGateRequired,
       reasonCodes: actionGateReasonCodes,
@@ -457,8 +471,9 @@ function buildWorkflowPlan(input = {}) {
     },
     limits: {
       maxIterations: meta.maxIterations,
-      maxRevisionRounds: 2,
-      maxWorkers: 'fable-orchestrator-cap',
+      maxRevisionRounds: WORKFLOW_MAX_REVISION_ROUNDS,
+      maxReplans: FABLE_MAX_REPLANS,
+      maxWorkers: FABLE_MAX_WORKERS,
     },
     parallelism: {
       allowed: meta.parallelAllowed,
@@ -472,7 +487,7 @@ function buildWorkflowPlan(input = {}) {
     memory: {
       read: meta.memoryRead,
       scope: 'task-relevant-only',
-      write: meta.memoryWrite,
+      write: memoryWrite,
     },
     verification: {
       mode: meta.verificationMode,
@@ -553,6 +568,9 @@ function validateWorkflowPlan(plan) {
   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');
   if (plan.strategy === 'iterative-single' && (!Number.isInteger(plan.limits.maxIterations) || plan.limits.maxIterations < 1)) errors.push('iterative-single requires maxIterations');
+  if (!Number.isInteger(plan.limits?.maxRevisionRounds) || plan.limits.maxRevisionRounds < 0) errors.push('limits.maxRevisionRounds must be a non-negative integer');
+  if (!Number.isInteger(plan.limits?.maxReplans) || plan.limits.maxReplans < 0) errors.push('limits.maxReplans must be a non-negative integer');
+  if (!Number.isInteger(plan.limits?.maxWorkers) || plan.limits.maxWorkers < 1) errors.push('limits.maxWorkers must be a positive integer');
   if (plan.strategy === 'fable-parallel' && (!plan.parallelism || plan.parallelism.allowed !== true)) errors.push('fable-parallel requires parallelism.allowed=true');
   if (!plan.fallback || !['none', 'reduced', 'blocked'].includes(plan.fallback.disposition)) errors.push('fallback.disposition is invalid');
   if (!Array.isArray(plan.reasonCodes)) errors.push('reasonCodes must be an array');
@@ -597,6 +615,9 @@ function writeRouterContract(contractPath, contract) {
 module.exports = {
   SCHEMA_VERSION,
   ITERATIVE_MAX_ITERATIONS,
+  WORKFLOW_MAX_REVISION_ROUNDS,
+  FABLE_MAX_REPLANS,
+  FABLE_MAX_WORKERS,
   buildRouterContract,
   buildTaskShape,
   buildWorkflowPlan,