skynet-graph 1.2.0

package/lib/authoring/stock.js

@@ -0,0 +1,101 @@
+/*
+ * Copyright 2026 Nathanael Braun
+ * @author : Nathanael BRAUN <pp9ping@gmail.com>
+ *
+ * AGPL-3.0-or-later. See <https://www.gnu.org/licenses/>.
+ */
+'use strict';
+/**
+ * stock — the reusable CORE of gold-gated concept-method STOCK-BUILDING (host-side, ZERO-CORE, engine-free).
+ * The WikiSQL pilot (2026-07-05) proved a stock of .sgc methods can be accumulated from a REAL externally-
+ * labelled corpus: `record → forge model decomposition → crystallizeFrom → GOLD-GATE → .sgc`. That pilot
+ * inlined the gate + the yield lever; THIS brick promotes them to the library so any dataset adapter reuses
+ * them — a host writes only the small per-dataset `{ sigOf, goldStepsOf, problemOf }` adapter + a forge, and
+ * the SOUNDNESS-bearing pieces (the gate that keeps the stock clean, the packaging) live here, tested once.
+ *
+ * The two findings the pilot measured, both captured here:
+ *   1. THE VALUE IS THE GATE, not the generation. `goldGate` admits a class method into the stock ONLY IF
+ *      the model's decomposition is CONSISTENT across the class's instances AND MATCHES the gold shape AND
+ *      crystallize admitted it (K1-sound). So the stock stays 100% clean (0 false admitted) whatever the
+ *      small model renders — the oracle (the dataset's gold) + the gate carry soundness, not the model.
+ *   2. YIELD IS BOUNDED BY MODEL CONSISTENCY (the pilot's small model omitted/inconsistently-added a step).
+ *      `consistencyVote` is the cheap, SOUNDNESS-PRESERVING lever: sample N decompositions of one instance,
+ *      take the majority shape. It raises the fraction of instances that reach a consistent shape WITHOUT
+ *      bypassing the gate (the gate still verifies the voted shape against gold) — never a soundness risk.
+ *
+ * Pure functions over shapes (arrays of typed step kinds) — NO engine, NO fs, NO model. The trace-producing
+ * run (a Plan decomposition through the engine) stays the host's; this brick verifies + packages its output.
+ */
+
+const packMethods = require('./method-pack.js').packMethods;
+
+/** the canonical SHAPE of a typed decomposition — the ordered step kinds joined (the class-method identity). */
+function shapeOf( steps ) { return (steps || []).join('>'); }
+
+/**
+ * CONSISTENCY VOTE (the yield lever) — given N sampled decompositions of the SAME instance, return the
+ * MAJORITY shape + the agreement fraction. Deterministic on ties (first-seen mode wins). Empty samples vote
+ * to an empty shape with agreement 0. Soundness-preserving: the voted shape is still gold-gated downstream.
+ * @param samples  array of step-arrays (each a decomposition of one instance).
+ * @returns {{ steps, shape, agreement, votes:{ <shape>: count }, n }}
+ */
+function consistencyVote( samples ) {
+	samples = (samples || []).filter( Array.isArray );
+	const votes = {}, first = {};
+	let bestShape = '', bestCount = 0;
+	for ( let i = 0; i < samples.length; i++ ) {
+		const sh = shapeOf(samples[i]);
+		if ( !sh ) continue;                                     // an empty decomposition is not a vote
+		votes[sh] = (votes[sh] || 0) + 1;
+		if ( first[sh] === undefined ) first[sh] = i;
+		if ( votes[sh] > bestCount || (votes[sh] === bestCount && first[sh] < first[bestShape]) ) { bestShape = sh; bestCount = votes[sh]; }
+	}
+	const n = samples.length;
+	const steps = bestShape ? bestShape.split('>') : [];
+	return { steps, shape: bestShape, agreement: n ? bestCount / n : 0, votes, n };
+}
+
+/**
+ * THE GOLD-GATE — the verification rule that keeps a stock clean. Admit a class method into the stock iff:
+ *   (a) the model's per-instance shapes are CONSISTENT (all equal + non-empty across the class's instances),
+ *   (b) that shape MATCHES the gold shape (the dataset oracle), and
+ *   (c) crystallize ADMITTED the method (K1-sound: the trace carried typed content, not free prose).
+ * By construction it NEVER admits a shape≠gold method — the stock's 0-false property is structural, not
+ * model-dependent. Reports a discriminating `reason` on refusal (for the LOG / a curator).
+ * @param opts { modelShapes:[…], goldSteps:[…]|goldShape:string, crystallized:bool }
+ * @returns {{ admitted, consistent, goldMatch, crystallized, modelShape, goldShape, reason }}
+ */
+function goldGate( opts ) {
+	opts = opts || {};
+	const modelShapes = (opts.modelShapes || []).map( ( s ) => Array.isArray(s) ? shapeOf(s) : String(s || '') );
+	const goldShape = opts.goldShape != null ? opts.goldShape : shapeOf(opts.goldSteps);
+	const crystallized = !!opts.crystallized;
+	const consistent = modelShapes.length > 0 && modelShapes.every( ( s ) => s === modelShapes[0] && s.length > 0 );
+	const modelShape = consistent ? modelShapes[0] : (modelShapes[0] || '');
+	const goldMatch = consistent && modelShape === goldShape;
+	const admitted = consistent && goldMatch && crystallized;
+	const reason = admitted ? 'admit'
+		: !consistent ? 'model-inconsistent'
+		: !goldMatch ? 'shape-mismatches-gold'
+		: 'crystallize-refused';
+	return { admitted, consistent, goldMatch, crystallized, modelShape, goldShape, reason };
+}
+
+/**
+ * Pack the ADMITTED class methods into a portable `.sgc` stock (thin over method-pack). Each admitted class
+ * is a recall-index entry keyed on its class signature (structure = `{ taskKind: sig }`).
+ * @param admitted  array of `{ sig, candidate }` (the gold-verified class methods).
+ * @param opts      { name, version, description, structureKey } — structureKey defaults to 'taskKind'.
+ * @returns a `.sgc kind:'methods'` bundle.
+ */
+function packStock( admitted, opts ) {
+	opts = opts || {};
+	const sk = opts.structureKey || 'taskKind';
+	const entries = (admitted || []).filter( ( a ) => a && a.candidate ).map( ( a ) => {
+		const structure = {}; structure[sk] = a.sig;
+		return { structure, content: {}, method: a.candidate };
+	} );
+	return packMethods({ entries: entries }, { name: opts.name || 'stock', version: opts.version || '0.0.0', description: opts.description || '' });
+}
+
+module.exports = { shapeOf, consistencyVote, goldGate, packStock };

package/lib/authoring/store.js

@@ -0,0 +1,94 @@
+/*
+ * Copyright 2026 Nathanael Braun
+ * @author : Nathanael BRAUN <pp9ping@gmail.com>
+ *
+ * AGPL-3.0-or-later. See <https://www.gnu.org/licenses/>.
+ */
+'use strict';
+/**
+ * store — DISK-BACKED PERSISTENCE for the method library (host-side, opt-in; uses fs, like `lib/load.js` —
+ * the engine core stays fs-free). M2 of the productization campaign: the derivation cache `store` and the
+ * master-loop `cache` are both pluggable Map-likes, so a file-backed store makes the warm library SURVIVE a
+ * restart — a cold process re-loads it and replays recurrent methods at 0 model calls (cross-session
+ * amortization, the master-graph study's persistence rung U5).
+ *
+ *   const store = createFileStore('./.sg-cache.json');
+ *   const cache = createProviderCache({ store });          // the derivation cache persists
+ *   const loop  = createMasterLoop({ ..., cache: store }); // or the master-loop cache persists
+ *
+ * It is a write-through Map: load on construct, persist the whole map on each mutation (simple + correct at
+ * reasoning-grade volume; swap in an append-log/LRU for high throughput). Values must be JSON-serializable
+ * (the cached templates/results already are — they round-trip through `serialize`/the rev-log).
+ */
+const fs = require('fs');
+
+function createFileStore( file, opts ) {
+	opts = opts || {};
+	const max = opts.max || 0;                 // 0 = unbounded; else oldest-eviction like createProviderCache
+	let map = new Map();
+	// LOAD: re-hydrate the library from disk (a "restart"). A missing/corrupt file → empty (fail-open).
+	try {
+		if ( fs.existsSync(file) ) {
+			const arr = JSON.parse(fs.readFileSync(file, 'utf8'));
+			if ( Array.isArray(arr) ) map = new Map(arr);
+		}
+	} catch ( e ) { map = new Map(); }
+
+	let timer = null;
+	function persist() {
+		// debounce-free, synchronous write-through (deterministic for tests); coalesce via opts.async if wanted.
+		const data = JSON.stringify([...map.entries()]);
+		if ( opts.async ) { clearTimeout(timer); timer = setTimeout(() => { try { fs.writeFileSync(file, data); } catch ( e ) {} }, opts.async); }
+		else try { fs.writeFileSync(file, data); } catch ( e ) {}
+	}
+	function evict() { if ( max && map.size > max ) map.delete(map.keys().next().value); }
+
+	return {
+		has( k ) { return map.has(k); },
+		get( k ) { return map.get(k); },
+		set( k, v ) { map.set(k, v); evict(); persist(); return this; },
+		delete( k ) { const r = map.delete(k); persist(); return r; },
+		clear() { map.clear(); persist(); },
+		keys() { return map.keys(); },
+		get size() { return map.size; },
+		flush() { const data = JSON.stringify([...map.entries()]); try { fs.writeFileSync(file, data); } catch ( e ) {} },
+		file
+	};
+}
+
+/**
+ * Persist / re-hydrate a recall INDEX (so fuzzy recall + partial reuse also survive a restart). The index
+ * stores { sig, method } entries (the vectors are recomputed on load — they are a pure function of sig).
+ */
+function saveIndex( index, file ) {
+	const entries = (index.entries || []).map(( e ) => ({ sig: e.sig, method: e.method }));
+	try { fs.writeFileSync(file, JSON.stringify(entries)); } catch ( e ) {}
+	return entries.length;
+}
+function loadIndex( index, file ) {
+	try {
+		if ( !fs.existsSync(file) ) return 0;
+		const arr = JSON.parse(fs.readFileSync(file, 'utf8'));
+		for ( const e of (Array.isArray(arr) ? arr : []) ) index.add(e.sig, e.method);
+		return arr.length;
+	} catch ( e ) { return 0; }
+}
+
+/**
+ * Generic `.sgc` bundle file IO (works for BOTH a corpus-pack and a method-pack bundle — anything with
+ * `format:'sgc'`). The pack modules stay fs-free (they return/consume plain bundle objects); the disk
+ * round-trip lives here, the fs layer. `saveSgc` writes pretty JSON (a `.sgc` is meant to be inspected/
+ * diffed); `loadSgc` returns the parsed bundle or null on a missing/corrupt file (fail-open).
+ */
+function saveSgc( bundle, file ) {
+	try { fs.writeFileSync(file, JSON.stringify(bundle, null, 2)); return true; } catch ( e ) { return false; }
+}
+function loadSgc( file ) {
+	try {
+		if ( !fs.existsSync(file) ) return null;
+		const b = JSON.parse(fs.readFileSync(file, 'utf8'));
+		return (b && b.format === 'sgc') ? b : null;
+	} catch ( e ) { return null; }
+}
+
+module.exports = { createFileStore, saveIndex, loadIndex, saveSgc, loadSgc };

package/lib/authoring/supervise.js

@@ -0,0 +1,138 @@
+/*
+ * Copyright 2026 Nathanael Braun
+ * @author : Nathanael BRAUN <pp9ping@gmail.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+'use strict';
+/**
+ * Hypothesis-and-test self-modification regime (roadmap #11.c.3, doc/MODELISATION.md
+ * §6.4) — the capstone of #11. Zero core change: it composes the now-complete safe
+ * instruments — re-entrant `add`/`patchConcept` (#11.a), the apply-ceiling backstop
+ * (#11.c.1), and concept-lib-versioned `rollbackTo` (#11.c.2 / N6) — into a supervised
+ * loop that may *try* a self-modification and cleanly *undo* it if it doesn't help.
+ *
+ * Design (per the engine author):
+ *   - `Stuck` is a human-vocabulary fact (a sub-problem that exhausted its strategies /
+ *     blew its budget) — the loop's TRIGGER, surfaced by `detectStuck`;
+ *   - the "is it better / worse?" call is NOT an engine metric. Budget-spent is only the
+ *     trigger; the judgment is a *supervisor* decision rendered by a higher-level concept
+ *     with a better model → injected as `evaluate` (the better-model hook);
+ *   - the repair STRATEGY is open R&D / plural → injected as `hypothesize`. Different
+ *     strategies plug in here without touching the loop.
+ *
+ * The loop is HOST-orchestrated because `rollbackTo` must run at a quiescent boundary
+ * (it re-mounts; it is not queued like add/patchConcept). A fully-reactive supervisor
+ * concept (with queued rollback) is the next R&D step.
+ *
+ *   const { supervise } = require('./supervise');
+ *   const res = await supervise(graph, {
+ *     detectStuck: (g) => <stuckId|null>,                         // the trigger (Stuck fact / budget)
+ *     hypothesize: async (g, stuckId, ctx) => { ...self-mod...; return <label> },  // a strategy
+ *     evaluate:    async (g, stuckId, hyp) => ({ better: <bool>, ... }),           // the supervisor model
+ *     maxAttempts: 5,
+ *   });
+ *   // res = { resolved, attempts: [{ hyp, outcome:'kept'|'reverted', verdict }] }
+ */
+
+// Await the next settle, or resolve immediately if the graph is already quiescent
+// (finding #13: `stabilize(cb)` only fires `cb` on an actual settle — a no-op has none).
+function nextStable( graph ) {
+	return new Promise(function ( resolve ) {
+		var done = false;
+		var fin = function () { if ( !done ) { done = true; resolve(); } };
+		graph.stabilize(fin);
+		if ( !graph._unstable.length && !graph._triggeredCastCount ) setTimeout(fin);
+	});
+}
+
+async function supervise( graph, spec ) {
+	var detectStuck = spec.detectStuck;
+	var hypothesize = spec.hypothesize;
+	var evaluate    = spec.evaluate;
+	var maxAttempts = spec.maxAttempts || 5;
+	var attempts    = [];
+
+	await nextStable(graph);
+
+	for ( var i = 0; i < maxAttempts; i++ ) {
+		var stuck = detectStuck(graph);
+		if ( !stuck ) return { resolved: true, attempts: attempts };
+
+		// checkpoint BEFORE the hypothesis: the snapshot captured at the last settle, keyed
+		// by this rev, carries both the facts AND the concept-lib (N6) — so a rollback here
+		// fully undoes whatever the hypothesis adds/patches.
+		var rev = graph.getCurrentRevision();
+
+		var hyp = await hypothesize(graph, stuck, { attempt: i, attempts: attempts });
+		await nextStable(graph);                       // apply the hypothesis (its self-mod re-stabilizes)
+
+		var verdict = await evaluate(graph, stuck, hyp);
+		if ( verdict && verdict.better ) {
+			attempts.push({ hyp: hyp, outcome: 'kept', verdict: verdict });
+		} else {
+			graph.rollbackTo(rev);                     // safe at this quiescent boundary; N6 restores rules too
+			await nextStable(graph);
+			attempts.push({ hyp: hyp, outcome: 'reverted', verdict: verdict });
+		}
+	}
+
+	return { resolved: !detectStuck(graph), attempts: attempts };
+}
+
+/**
+ * The supervisor as a REACTIVE concept flow (vs the host-orchestrated `supervise` loop).
+ * Enabled by queued rollback (#11.c.4): a concept's provider can now trigger a rollback
+ * mid-stabilize and it defers safely. The flow:
+ *   Stuck ──require──▶ Supervise (hypothesizes a self-mod, records a rollback checkpoint)
+ *   Supervise+hypothesized ──require──▶ Evaluate (the supervisor/better-model verdict)
+ *   Evaluate, ensure verdict=='worse' ──▶ Revert (queued rollbackTo the checkpoint)
+ *
+ * Inject the policy (open R&D):
+ *   opts.hypothesize(graph, scope)  — apply a self-mod; the added/patched fix MUST post
+ *                                     `hypothesized: true` so Evaluate can fire after it lands
+ *                                     (and `resolved: true` + `Stuck: null` if it solves it).
+ *   opts.evaluate(graph, scope)     — return 'better' | 'worse' (the supervisor judgment).
+ *
+ * NOTE (open R&D): the rollback checkpoint is `graph._lastSettledRev` — the last clean
+ * snapshot. A robust multi-attempt reactive loop (a checkpoint that holds the problem but
+ * not the attempt, + strategy memory so retries differ) is the next research step; this
+ * tree demonstrates the reactive wiring and the queued-rollback Revert path.
+ */
+function reactiveSupervisorTree() {
+	return { childConcepts: {
+		Supervise: { _id: 'Supervise', _name: 'Supervise', require: ['Stuck'], provider: ['Sup::propose'] },
+		Evaluate:  { _id: 'Evaluate', _name: 'Evaluate', require: ['Supervise', 'hypothesized'], provider: ['Sup::judge'] },
+		Revert:    { _id: 'Revert', _name: 'Revert', require: ['Evaluate'], ensure: ["$verdict=='worse'"], provider: ['Sup::revert'] }
+	} };
+}
+
+function makeSupervisorProviders( opts ) {
+	var hypothesize = opts.hypothesize, evaluate = opts.evaluate;
+	return { Sup: {
+		propose: function ( graph, concept, scope, argz, cb ) {
+			hypothesize(graph, scope);// a self-mod (queued); its fix posts `hypothesized:true`
+			cb(null, { $_id: '_parent', Supervise: true, supRev: graph._lastSettledRev });
+		},
+		judge: function ( graph, concept, scope, argz, cb ) {
+			cb(null, { $_id: '_parent', Evaluate: true, verdict: evaluate(graph, scope) });
+		},
+		revert: function ( graph, concept, scope, argz, cb ) {
+			graph.rollbackTo(scope._.supRev);// queued (#11.c.4) -> applied at the quiescent boundary
+			cb(null, { $_id: '_parent', Revert: true });
+		}
+	} };
+}
+
+module.exports = { supervise, nextStable, reactiveSupervisorTree, makeSupervisorProviders };

package/lib/authoring/support.js

@@ -0,0 +1,131 @@
+/*
+ * Copyright 2026 Nathanael Braun
+ * @author : Nathanael BRAUN <pp9ping@gmail.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+'use strict';
+/**
+ * The SUPPORT GRAMMAR (host-side authoring brick) — the support-grammar study made runnable
+ * (doc/WIP/studies/2026-06-25-grammaire-de-support-resolution-probleme.md). It composes two
+ * already-shipped pieces so a SMALL model only has to be locally competent on a bounded segment
+ * while the GRAPH holds the structure and runs the search:
+ *
+ *   (structure, J1) the decompose loop (lib/authoring/loop.js): a Task DAG that splits a problem
+ *      into segments and synthesizes bottom-up (reactive Rollup) — the whole is NEVER in the
+ *      model's context, only `${label}` of one segment;
+ *   (alternatives, J2) the per-segment SELECT cluster (lib/providers/semiring.js#selectConceptTree):
+ *      an atomic segment GENERATES several candidate answers (`Propose`), the `pareto` semiring
+ *      keeps the non-dominated trade-offs and picks one (`Select`), and `Adopt` makes the selected
+ *      candidate the segment's answer. Multi-criteria selection is reified in the graph (not flattened
+ *      by the model), keyed on DISCRETE bands (barrier-clean, deterministic).
+ *
+ *   const { supportConceptTree, makeSupportProviders } = require('./support');
+ *   const providers = makeSupportProviders({ evalFn, expandFn, proposeFn, rollupFn });
+ *   register(Graph, [ providers ]);                       // or Graph._providers = {...}
+ *   new Graph(seed, conf, { common: supportConceptTree({ criteria, lex }) });
+ *
+ * Content (eval/expand/propose/rollup) is INJECTED — deterministic in tests, an LLM in production.
+ * Zero core change: everything is concepts + providers over the existing engine.
+ */
+const { makeDecomposeProviders } = require('./loop.js');
+const { createSemiring, selectConceptTree } = require('../providers');
+const { rankOf } = require('../providers/semiring.js');
+
+/**
+ * The support-grammar concept set: the decompose scaffold + the per-segment Propose→Select→Adopt
+ * alternative-selection trio + reactive bottom-up synthesis.
+ * @param opts.criteria  the SELECT comparison criteria (band lists or {dir}) — see semiring.js
+ * @param opts.lex       criterion priority for the tie-break (default: criteria key order)
+ * @param opts.idKey     candidate id key (default 'id')
+ */
+function supportConceptTree( opts ) {
+	opts = opts || {};
+	var sel = selectConceptTree({
+		criteria: opts.criteria || {}, lex: opts.lex, idKey: opts.idKey,
+		contribKey: 'candidates', require: ['Task', 'Atomic']
+	});
+	return { childConcepts: { Task: {
+		_id: 'Task', _name: 'Task', require: 'Segment',
+		childConcepts: {
+			// structure (J1): classify, and split a compound segment into sub-segments
+			EvalComplexity: { _id: 'EvalComplexity', _name: 'EvalComplexity', require: ['Task'], provider: ['AI::evalComplexity'] },
+			Expand        : { _id: 'Expand', _name: 'Expand', require: ['Task', 'NeedsSplit'], provider: ['AI::expand'] },
+			// alternatives (J2): an atomic segment proposes candidates, the pareto SELECT picks one
+			Propose       : { _id: 'Propose', _name: 'Propose', require: ['Task', 'Atomic'], provider: ['Support::propose'] },
+			Select        : sel.childConcepts.Select,
+			Adopt         : { _id: 'Adopt', _name: 'Adopt', require: ['Task', 'selectedId'], provider: ['Support::adopt'] },
+			// reactive synthesis: report up to the parent, roll up once all children answered
+			ReportUp      : { _id: 'ReportUp', _name: 'ReportUp', require: ['Task', 'Answered', 'parentSeg'], provider: ['AI::reportUp'] },
+			Rollup        : { _id: 'Rollup', _name: 'Rollup', require: ['Task', 'expandedInto'],
+				ensure: ['$answeredBy.length == $expandedInto.length'], provider: ['AI::rollup'] }
+		}
+	} } };
+}
+
+/**
+ * The support-grammar providers. Reuses the decompose providers (AI::evalComplexity/expand/reportUp/
+ * rollup, lib/authoring/loop.js) + the pareto reducer (Semiring::reduce) and adds the two tiny
+ * Support providers (propose/adopt) that bracket the SELECT.
+ * @param opts.proposeFn(scope) -> [{ id, ...criteria, content }]   candidate alternatives for a segment
+ * @param opts.escalateFn(scope) -> [{ id, ...criteria, content }]  J3: a BETTER-tier proposer, called
+ *        ONLY for a segment whose own candidates all fall below the bar (Stuck). The better model is
+ *        spent only where the small one is locally insufficient.
+ * @param opts.escalateBar { criterion, order, min }  the quality gate: escalate iff no candidate's
+ *        `criterion` band reaches `min` (band order worst→best). Omit to disable escalation.
+ *        (+ evalFn/expandFn/answerFn/rollupFn/maxDepth/maxBranch passed through to makeDecomposeProviders)
+ */
+function makeSupportProviders( opts ) {
+	opts = opts || {};
+	var proposeFn = opts.proposeFn || function () { return []; },
+	    escalateFn = opts.escalateFn,
+	    bar = opts.escalateBar;
+	// does the candidate set already clear the quality bar? (a `min` band reached on `criterion`)
+	function clearsBar( cands ) {
+		if ( !bar ) return true;
+		var minRank = rankOf(bar.min, bar.order), best = -Infinity;
+		for ( var i = 0; i < cands.length; i++ ) best = Math.max(best, rankOf(cands[i][bar.criterion], bar.order));
+		return best >= minRank;
+	}
+	var support = { Support: {
+		// generate the segment's candidate alternatives (canned/LLM); if none clears the bar, ESCALATE
+		// to the better tier (J3) — recording the weak ones as memory — then arm the cardinality gate.
+		propose: function ( graph, concept, scope, argz, cb ) {
+			Promise.resolve(proposeFn(scope)).then(function ( cands ) {
+				cands = cands || [];
+				if ( escalateFn && bar && cands.length && !clearsBar(cands) ) {
+					return Promise.resolve(escalateFn(scope)).then(function ( better ) {
+						better = better || [];
+						var pool = cands.concat(better);
+						cb(null, { $_id: '_parent', Propose: true, Stuck: true, Escalated: true,
+							escalatedFrom: cands.map(function ( c ) { return c.id; }),   // nogood memory of the dead-ends
+							candidates: pool, expected: pool.length });
+					});
+				}
+				cb(null, { $_id: '_parent', Propose: true, candidates: cands, expected: cands.length });
+			}).catch(function ( e ) {
+				cb(null, { $_id: '_parent', Propose: true, candidates: [], expected: 0, llmError: e.message });
+			});
+		},
+		// adopt the SELECTed candidate (by its discrete selectedId) as the segment's answer
+		adopt: function ( graph, concept, scope, argz, cb ) {
+			var id = scope._.selectedId, cands = scope._.candidates || [], sel = null;
+			for ( var i = 0; i < cands.length; i++ ) if ( cands[i].id === id ) { sel = cands[i]; break; }
+			cb(null, { $_id: '_parent', Adopt: true, Answered: true, answer: sel ? sel.content : '(none selected)' });
+		}
+	} };
+	return Object.assign({}, makeDecomposeProviders(opts), support, createSemiring(opts.semiringOpts));
+}
+
+module.exports = { supportConceptTree: supportConceptTree, makeSupportProviders: makeSupportProviders };

package/lib/authoring/task-mirror.js

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2026 Nathanael Braun
+ * @author : Nathanael BRAUN <pp9ping@gmail.com>
+ *
+ * AGPL-3.0-or-later. See <https://www.gnu.org/licenses/>.
+ */
+'use strict';
+/**
+ * task-mirror — the graph plan DRIVES the host agent's native task list (owner 2026-07-10). The graph instance is
+ * the authoritative multistep state (typed steps, needs/produces, frontier, JTMS); agent hosts (Claude Code,
+ * OpenCode, …) have their own task tools. MCP is host→server — a server cannot invoke host tools — so the correct
+ * realization is a TYPED DELTA the host applies VERBATIM to its own task system, AT ITS OWN CHOICE (SOFT lane,
+ * pull-based: the LLM calls the sync when it wants a mirror, or never).
+ *
+ * `diffPlanToTaskOps(plan, mirror)` → { ops, mirror } — pure, deterministic (id-ordered), idempotent (same state
+ * twice → empty delta). Neutral op vocabulary, host-agnostic:
+ *   {op:'create',  id, subject, blockedBy[]}   a new step (blockedBy = its still-open needs)
+ *   {op:'update',  id, subject}                the step title changed
+ *   {op:'complete',id}                         the step reached done (a GATE-ADMITTED result, not a claim)
+ *   {op:'reopen',  id, reason}                 ⟐ the JTMS differentiator: a completed step whose premise DRIFTED
+ *                                              was retracted → the mirrored task must reopen. No host does this.
+ * A step that VANISHES from the plan emits nothing (the mirror keeps it; the host decides its own hygiene).
+ *
+ * @param plan    { steps: [{ id, title, needs: [ids], status: 'open'|'done'|'retracted', reason? }] }
+ * @param mirror  the previous return's `mirror` (or null on first sync).
+ * @returns { ops: [...], mirror }   — feed `mirror` back on the next call.
+ */
+function diffPlanToTaskOps( plan, mirror ) {
+	var steps = (plan && plan.steps || []).slice().sort(function ( a, b ) { return a.id < b.id ? -1 : 1; });
+	var prev = (mirror && mirror.tasks) || {};
+	var ops = [], tasks = {};
+	var open = {}; steps.forEach(function ( s ) { if ( s.status !== 'done' ) open[s.id] = true; });
+	steps.forEach(function ( s ) {
+		var p = prev[s.id];
+		var status = s.status === 'done' ? 'done' : 'open';
+		if ( !p ) {
+			ops.push({ op: 'create', id: s.id, subject: s.title, blockedBy: (s.needs || []).filter(function ( n ) { return open[n]; }) });
+			if ( s.status === 'done' ) ops.push({ op: 'complete', id: s.id });
+		} else {
+			if ( p.subject !== s.title ) ops.push({ op: 'update', id: s.id, subject: s.title });
+			if ( p.status !== 'done' && s.status === 'done' ) ops.push({ op: 'complete', id: s.id });
+			if ( p.status === 'done' && s.status !== 'done' ) ops.push({ op: 'reopen', id: s.id, reason: s.reason || 'premise drifted (JTMS retraction)' });
+		}
+		tasks[s.id] = { subject: s.title, status: status };
+	});
+	// steps gone from the plan stay in the mirror untouched (no phantom deletes pushed at the host).
+	Object.keys(prev).forEach(function ( id ) { if ( !tasks[id] ) tasks[id] = prev[id]; });
+	return { ops: ops, mirror: { tasks: tasks } };
+}
+
+module.exports = { diffPlanToTaskOps: diffPlanToTaskOps };