@aragon-agent/cli 0.6.44 → 0.6.45

package/dist/governance/engine/engine-core.js

@@ -0,0 +1,562 @@
+/**
+ * EngineCore - the state, persistence and event plumbing every engine module shares
+ * (governance-mode 8.6, 12.1, 14.1).
+ *
+ * ASCII ONLY (`governance/` is glyph-scanned).
+ *
+ * WHY MEMORY IS AUTHORITATIVE AND DISK IS A QUEUE. The child tools (`gov_submit_*`,
+ * `ledger_*`) are synchronous: a model's tool call returns text, and the executor does not
+ * wait for a disk round trip. The run store is asynchronous (atomic rename, fsync, a FIFO
+ * mutex). So every mutation lands in memory synchronously and is appended to ONE promise
+ * chain that preserves order; `flush()` is awaited at every point where the orchestrator
+ * is waiting anyway (end of a stage, start, close). The event log stays the truth: the
+ * engine owns the sequence counter and stamps each event BEFORE the write resolves, which
+ * is also what lets a ledger entry carry the same `seq` as the event that produced it
+ * (replay equivalence, I-G2).
+ *
+ * LEDGER MUTATIONS GO THROUGH `ledgerOp` AND NOWHERE ELSE (I-G1 / I-G7): one function that
+ * logs the op, applies it with the pure ledger, and reports the entries it booked. Nothing
+ * else in the tree touches `core.ledger`.
+ */
+import { GOV_LIMITS, GOV_SCHEMA_VERSION } from '../limits.js';
+import { applyOp, replay } from '../rules/ledger-replay.js';
+import { createLedger, labelFor, standings, teamHealth } from '../rules/ledger-state.js';
+import { INSPECTOR_ID } from '../rules/ledger-state.js';
+import { renderLedgerLine } from './report.js';
+import { buildRunDigest } from './run-digest.js';
+const EMIT_MIN_INTERVAL_MS = 250;
+/** Give an op the stored-event seq so replay stamps exactly what the live path stamped. */
+export function stampOp(op, seq) {
+    switch (op.op) {
+        case 'add_agent':
+            return op;
+        case 'event':
+            return { op: 'event', event: { ...op.event, seq } };
+        case 'collective':
+            return { op: 'collective', spec: { ...op.spec, seq } };
+        case 'incident':
+            return {
+                op: 'incident',
+                events: op.events.map((e) => ({ ...e, seq })),
+                ...(op.clawbacks ? { clawbacks: op.clawbacks.map((c) => ({ ...c, seq })) } : {}),
+            };
+        case 'confirm_escrow':
+            return { ...op, seq };
+        case 'clawback':
+            return { op: 'clawback', request: { ...op.request, seq } };
+        case 'reverse':
+            return { op: 'reverse', request: { ...op.request, seq } };
+        case 'eliminate':
+            return { op: 'eliminate', request: { ...op.request, seq } };
+        case 'respawn':
+            return { op: 'respawn', request: { ...op.request, seq } };
+        case 'tail_check':
+            return { ...op, seq };
+    }
+}
+export class EngineCore {
+    deps;
+    run = null;
+    ledger = createLedger([]);
+    /** Monotone event counter; the engine owns it (see file header). */
+    seq = 0;
+    /** True once the user left the run in a state a new `start` may replace. */
+    readOnly = false;
+    // --- Per-stage scratch, owned by the stage runner, written by the adjudication half ---
+    /** WP ids (or `insp`) that received a valid submission during the CURRENT stage run. */
+    stageSubmitted = new Set();
+    /** `${identity}|${wpId}` -> consecutive validation failures (>= maxValidationFailures => absent). */
+    validationFailures = new Map();
+    /** One line per result produced this stage (digest body). */
+    stageResults = [];
+    /** One line per ledger booking this stage (digest ledger section). */
+    stageLedgerLines = [];
+    /** Warnings to print under the digest (caps, escalations, tripwires). */
+    stageWarnings = [];
+    /** Set by `ledger_settle`; consumed (and cleared) by the stage runner. */
+    inspectorOutcome = null;
+    /**
+     * Accepted submissions and inspector reports by artifact id (adjudication half). The
+     * store is async but a child's tool call is not, so reads during a run come from here;
+     * the resume path repopulates it from the artifact store.
+     */
+    submissionCache = new Map();
+    /** Set when an artifact write was refused for the 20 MB budget (spec 12.1). */
+    storageExhausted = false;
+    /** Mechanical suspicion flags per 0-based phase (ownership violations), for the inspector. */
+    phaseFlags = new Map();
+    /** `gov_view` requests used per identity (D-9: at most one each). */
+    viewRequests = new Map();
+    /** Files each identity has written so far, from the team stream (best effort, 6.4). */
+    touchedFiles = new Map();
+    /** `gov_view` grants / denials per 0-based phase, shown to the inspector at settle. */
+    viewLog = new Map();
+    /** Set by whoever emitted this stage's `stage_ended` (exactly one per stage). */
+    stageEndedEmitted = false;
+    /** Set once the lazy retention prune ran for this engine instance. */
+    pruned = false;
+    /**
+     * `/gov pause` is waiting for the running stage to finish (governance-mode-v1-1 V-2).
+     * MEMORY ONLY: a request is never persisted, so a restart cannot surprise anyone with a
+     * run that "paused itself". Cleared when it is redeemed, cancelled, or the stage ends.
+     */
+    pauseRequested = false;
+    /**
+     * The current `paused` status came from `/gov pause`. Memory only, like the request; it
+     * lets `gov_dispatch` answer a user pause with the explicit "stop and wait" text while an
+     * Esc pause keeps its original refusal. Cleared by resume, a new run and close.
+     */
+    userPaused = false;
+    chain = Promise.resolve();
+    listeners = new Set();
+    rev = 0;
+    lastEmitAt = 0;
+    emitTimer = null;
+    agentStates = new Map();
+    activity = new Map();
+    lastDelta = new Map();
+    stageAbort = null;
+    teamUnsubscribe = null;
+    persistError = null;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    now() {
+        return this.deps.now();
+    }
+    config() {
+        return this.deps.getConfig();
+    }
+    requireRun() {
+        if (this.run === null)
+            throw new Error('governance: no active run');
+        return this.run;
+    }
+    wp(id) {
+        return this.run?.workPackages[id];
+    }
+    // -------------------------------------------------------------------------
+    // Persistence
+    // -------------------------------------------------------------------------
+    /** Public queue entry for modules that persist their own files in order with the rest. */
+    enqueueTask(job) {
+        this.enqueue(job);
+    }
+    enqueue(job) {
+        this.chain = this.chain.then(job).then(() => undefined, (error) => {
+            // A write failure must not poison the chain: later writes still run, and the first
+            // failure is surfaced to the orchestrator once (never swallowed silently).
+            this.persistError ??= error instanceof Error ? error.message : String(error);
+        });
+    }
+    /** Append one event to the truth log. Returns the seq it was stamped with. */
+    log(type, actor, payload) {
+        this.seq += 1;
+        const seq = this.seq;
+        const runId = this.run?.runId;
+        if (runId === undefined)
+            return seq;
+        const at = this.now();
+        this.enqueue(() => this.deps.store.appendEvent(runId, { type, actor, payload, at, seq }));
+        if (this.run)
+            this.run.seq = seq;
+        return seq;
+    }
+    /** Queue checkpoint writes for the current run and ledger. */
+    checkpoint() {
+        const run = this.run;
+        if (run === null)
+            return;
+        run.updatedAt = this.now();
+        run.seq = this.seq;
+        const runCopy = structuredClone(run);
+        // Stamped with the TAIL seq (not the last ledger op's), or the store would report
+        // `needsReplay` forever after any non-ledger event.
+        const ledgerCopy = structuredClone({ ...this.ledger, seq: this.seq });
+        // The `/gov runs` digest rides this write, from the same copies (governance-mode-v1-1
+        // V-6): no extra disk read, and it cannot disagree with the checkpoint it travels with.
+        const digest = buildRunDigest(runCopy, ledgerCopy);
+        this.enqueue(async () => {
+            await this.deps.store.writeRun(runCopy, digest);
+            await this.deps.store.writeLedger(runCopy.runId, ledgerCopy);
+        });
+    }
+    /** Queue a projection file write (`board.md`, reports, scoreboard). */
+    writeFile(rel, text) {
+        const runId = this.run?.runId;
+        if (runId === undefined)
+            return;
+        this.enqueue(() => this.deps.store.writeRunFile(runId, rel, text));
+    }
+    exportScoreboard() {
+        const runId = this.run?.runId;
+        if (runId === undefined)
+            return;
+        const ledger = structuredClone(this.ledger);
+        this.enqueue(() => this.deps.store.exportScoreboard(runId, ledger));
+    }
+    /** Wait for every queued write. Returns a note when a write failed (and clears it). */
+    async flush() {
+        await this.chain;
+        const note = this.persistError;
+        this.persistError = null;
+        return note === null ? null : `WARNING: some governance records failed to save (${note}).`;
+    }
+    // -------------------------------------------------------------------------
+    // Ledger (the ONLY mutation path)
+    // -------------------------------------------------------------------------
+    ledgerOp(op, actor = 'engine') {
+        const seq = this.log('ledger', actor, { op: stampOp(op, this.seq + 1) });
+        const stamped = stampOp(op, seq);
+        this.ledger = applyOp(this.ledger, stamped);
+        const booked = this.entriesAt(seq);
+        for (const b of booked)
+            this.noteDelta(b);
+        return { seq, booked };
+    }
+    /** Append ledger lines for a digest (call after `ledgerOp`). */
+    noteBooked(booked) {
+        for (const b of booked) {
+            if (typeof b.entry.code !== 'string' || b.entry.delta === 0)
+                continue;
+            this.stageLedgerLines.push(renderLedgerLine(b.entry, b.agentId));
+        }
+    }
+    resetStageScratch() {
+        this.stageSubmitted = new Set();
+        this.stageResults = [];
+        this.stageLedgerLines = [];
+        this.stageWarnings = [];
+        this.inspectorOutcome = null;
+        this.stageEndedEmitted = false;
+        this.touchedFiles.clear();
+    }
+    entriesAt(seq) {
+        const out = [];
+        for (const agent of Object.values(this.ledger.agents)) {
+            for (const entry of agent.history) {
+                if (entry.seq === seq)
+                    out.push({ agentId: agent.id, entry });
+            }
+        }
+        return out;
+    }
+    noteDelta(b) {
+        if (typeof b.entry.code !== 'string' || b.entry.delta === 0)
+            return;
+        this.lastDelta.set(b.agentId, {
+            delta: b.entry.delta,
+            code: b.entry.code,
+            at: b.entry.at,
+            provisional: b.entry.settlement === 'provisional',
+        });
+    }
+    standingRows() {
+        return standings(this.ledger);
+    }
+    health() {
+        return teamHealth(this.ledger);
+    }
+    /** Rebuild the ledger from an op log (used by `RunStore.load` replay). */
+    static replayLedger(events, tailSeq) {
+        const ops = events
+            .filter((e) => e.type === 'ledger' && typeof e.payload.op === 'object' && e.payload.op)
+            .sort((a, b) => a.seq - b.seq)
+            .map((e) => e.payload.op);
+        return { ...replay(createLedger([]), ops), seq: tailSeq };
+    }
+    // -------------------------------------------------------------------------
+    // Agent state, activity, team stream
+    // -------------------------------------------------------------------------
+    setAgentState(id, state) {
+        this.agentStates.set(id, state);
+    }
+    agentState(id) {
+        return this.agentStates.get(id);
+    }
+    /** Subscribe to the team stream for the duration of the engine (activity lines). */
+    attachTeam() {
+        this.teamUnsubscribe?.();
+        this.teamUnsubscribe = this.deps.runtime.subscribe((event) => {
+            if (event.type !== 'agent_update')
+                return;
+            const run = event.run;
+            if (this.run === null)
+                return;
+            this.activity.set(run.label, run.activity ?? run.lastTool ?? '');
+            if (run.filesTouched.length > 0)
+                this.touchedFiles.set(run.label, [...run.filesTouched]);
+            const phase = run.phase;
+            if (phase === 'queued')
+                this.setAgentState(run.label, 'queued');
+            else if (phase === 'done') {
+                if (this.agentStates.get(run.label) !== 'submitted')
+                    this.setAgentState(run.label, 'idle');
+            }
+            else if (phase === 'failed' || phase === 'aborted')
+                this.setAgentState(run.label, 'failed');
+            else
+                this.setAgentState(run.label, 'working');
+            this.scheduleEmit();
+        });
+    }
+    detachTeam() {
+        this.teamUnsubscribe?.();
+        this.teamUnsubscribe = null;
+    }
+    clearActivity() {
+        this.activity.clear();
+    }
+    // -------------------------------------------------------------------------
+    // Stage abort
+    // -------------------------------------------------------------------------
+    beginStage(external) {
+        const controller = new AbortController();
+        if (external) {
+            if (external.aborted)
+                controller.abort();
+            else
+                external.addEventListener('abort', () => controller.abort(), { once: true });
+        }
+        this.stageAbort = controller;
+        return controller;
+    }
+    endStage() {
+        this.stageAbort = null;
+        // A request survives only while the run can still be paused by it: after an Esc abort
+        // (`paused`) it would otherwise fire the moment the user resumes.
+        if (this.run?.status !== 'executing')
+            this.pauseRequested = false;
+    }
+    isStageRunning() {
+        return this.run?.stage?.status === 'running' && this.stageAbort !== null;
+    }
+    /**
+     * A `gov_dispatch` call is in flight from `beginStage` until `endStage`: wider than
+     * `isStageRunning`, which is false while the stage is being set up and again while it
+     * writes its last checkpoint. A pause requested in either gap must wait, not fire.
+     */
+    isStageActive() {
+        return this.stageAbort !== null;
+    }
+    abortStage() {
+        this.stageAbort?.abort();
+        this.deps.runtime.abortAll();
+    }
+    // -------------------------------------------------------------------------
+    // Events and snapshot
+    // -------------------------------------------------------------------------
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    emit(build) {
+        const snapshot = this.snapshot();
+        if (snapshot === null)
+            return;
+        this.cancelPendingEmit();
+        this.lastEmitAt = this.now();
+        const event = build(snapshot);
+        for (const listener of [...this.listeners]) {
+            try {
+                listener(event);
+            }
+            catch {
+                // A UI listener must never be able to break a governed run.
+            }
+        }
+    }
+    /** Coalesce chatty updates (activity lines) to one snapshot per interval (8.6). */
+    scheduleEmit() {
+        if (this.emitTimer !== null)
+            return;
+        const wait = Math.max(0, EMIT_MIN_INTERVAL_MS - (this.now() - this.lastEmitAt));
+        this.emitTimer = setTimeout(() => {
+            this.emitTimer = null;
+            this.emit((snapshot) => ({ type: 'agent_state', snapshot }));
+        }, wait);
+        this.emitTimer.unref?.();
+    }
+    cancelPendingEmit() {
+        if (this.emitTimer === null)
+            return;
+        clearTimeout(this.emitTimer);
+        this.emitTimer = null;
+    }
+    dispose() {
+        this.cancelPendingEmit();
+        this.detachTeam();
+        this.listeners.clear();
+    }
+    snapshot() {
+        const run = this.run;
+        if (run === null)
+            return null;
+        this.rev += 1;
+        const rows = this.standingRows();
+        const reworkWp = run.wpOrder
+            .map((id) => run.workPackages[id])
+            .find((w) => w !== undefined && w.reworkCount > 0);
+        const phaseIndex = currentDisplayPhase(run);
+        return {
+            runId: run.runId,
+            goal: run.goal,
+            status: run.status,
+            phase: phaseIndex + 1,
+            phaseCount: run.phases.length,
+            stage: run.stage?.kind ?? null,
+            stageRunning: run.stage?.status === 'running',
+            startedAt: run.createdAt,
+            pipeline: buildPipeline(run, phaseIndex),
+            roster: this.rosterRows(rows),
+            health: this.health(),
+            recent: this.recent(),
+            usage: { ...run.usage },
+            budgetTokens: run.limits.budgetTokens,
+            alerts: this.alerts(run),
+            reworkNote: reworkWp
+                ? `rework ${reworkWp.reworkCount}/${run.limits.maxRework} (${reworkWp.id})`
+                : null,
+            // Present only when true, so a snapshot without a pending pause is byte-identical
+            // to what it was before the field existed.
+            ...(this.pauseRequested ? { pauseRequested: true } : {}),
+            rev: this.rev,
+        };
+    }
+    rosterRows(rows) {
+        const out = rows.map((r) => ({
+            id: r.id,
+            role: r.role,
+            generation: r.generation,
+            state: r.status === 'eliminated' ? 'eliminated' : (this.agentStates.get(r.id) ?? 'idle'),
+            wpId: this.wpOf(r.id),
+            activity: r.status === 'eliminated' ? '' : (this.activity.get(r.id) ?? ''),
+            confirmed: r.confirmed,
+            provisional: r.provisional,
+            label: labelFor(r.confirmed),
+            lastDelta: this.lastDelta.get(r.id) ?? null,
+            replacedBy: r.replacedBy,
+        }));
+        out.push({
+            id: INSPECTOR_ID,
+            role: 'INSP',
+            generation: 0,
+            state: this.agentStates.get(INSPECTOR_ID) ?? 'idle',
+            wpId: null,
+            activity: this.activity.get(INSPECTOR_ID) ?? '',
+            confirmed: null,
+            provisional: 0,
+            label: 'NOT_SCORED',
+            lastDelta: null,
+            replacedBy: null,
+        });
+        return out;
+    }
+    wpOf(agentId) {
+        const run = this.run;
+        if (run === null)
+            return null;
+        for (const id of run.wpOrder) {
+            const wp = run.workPackages[id];
+            if (wp && (wp.assignee === agentId || wp.reviewer === agentId || wp.tester === agentId)) {
+                if (wp.status !== 'integrated' && wp.status !== 'dropped')
+                    return wp.id;
+            }
+        }
+        return null;
+    }
+    recent() {
+        const all = [];
+        for (const agent of Object.values(this.ledger.agents)) {
+            for (const e of agent.history.slice(-6)) {
+                if (typeof e.code !== 'string' || e.delta === 0)
+                    continue;
+                all.push({
+                    seq: e.seq,
+                    at: e.at,
+                    agentId: agent.id,
+                    code: e.code,
+                    delta: e.delta,
+                    provisional: e.settlement === 'provisional',
+                    reason: e.reason,
+                });
+            }
+        }
+        return all
+            .sort((a, b) => a.seq - b.seq)
+            .slice(-6)
+            .map(({ seq: _seq, ...row }) => row);
+    }
+    alerts(run) {
+        const out = [];
+        const open = run.escalations.filter((e) => e.status === 'open');
+        if (open.length > 0)
+            out.push(`${open.length} escalation(s) need the user`);
+        if (run.status === 'paused')
+            out.push('run paused - gov_run resume');
+        const budget = run.limits.budgetTokens;
+        if (budget > 0) {
+            const used = run.usage.inputTokens + run.usage.outputTokens;
+            if (used >= budget * GOV_LIMITS.budgetWarnFraction)
+                out.push('team token budget nearly used');
+        }
+        const health = this.health();
+        if (health !== null && health < GOV_LIMITS.healthWarnThreshold)
+            out.push('team health low');
+        return out;
+    }
+    static schemaVersion() {
+        return GOV_SCHEMA_VERSION;
+    }
+}
+/** The phase to display: the first not-integrated one, else the last. */
+export function currentDisplayPhase(run) {
+    if (run.phases.length === 0)
+        return 0;
+    const open = run.phases.find((p) => !p.integrated);
+    return open ? open.index : run.phases.length - 1;
+}
+const PIPELINE_ORDER = ['dev', 'review', 'test', 'settle', 'integrate'];
+function stageDone(run, phaseIndex, kind) {
+    const phase = run.phases[phaseIndex];
+    if (phase === undefined)
+        return false;
+    if (phase.integrated)
+        return true;
+    const wps = phase.wpIds
+        .map((id) => run.workPackages[id])
+        .filter((w) => w !== undefined && w.status !== 'dropped');
+    const none = (...statuses) => wps.every((w) => !statuses.includes(w.status));
+    switch (kind) {
+        case 'dev':
+            return none('pending', 'dev_running', 'rework');
+        case 'review':
+            return stageDone(run, phaseIndex, 'dev') && none('awaiting_review', 'review_running');
+        case 'test':
+            return stageDone(run, phaseIndex, 'review') && none('awaiting_test', 'test_running');
+        case 'settle':
+            return phase.settled;
+        case 'integrate':
+            return phase.integrated;
+        default:
+            return false;
+    }
+}
+export function buildPipeline(run, phaseIndex) {
+    const steps = [{ key: 'intake', state: 'done' }];
+    const running = run.stage?.status === 'running' ? run.stage.kind : null;
+    let activeAssigned = false;
+    for (const kind of PIPELINE_ORDER) {
+        const done = stageDone(run, phaseIndex, kind);
+        let state = done ? 'done' : 'pending';
+        const isRunning = running === kind || (kind === 'integrate' && running === 'fix');
+        if (!done && !activeAssigned && (isRunning || running === null)) {
+            state = 'active';
+            activeAssigned = true;
+        }
+        steps.push({ key: kind, state });
+    }
+    return steps;
+}

package/dist/governance/engine/engine.d.ts

@@ -0,0 +1,68 @@
+/**
+ * GovernanceEngine - the facade the tools, the wiring and the UI call
+ * (governance-mode 14.1).
+ *
+ * ASCII ONLY (`governance/` is glyph-scanned).
+ *
+ * Thin on purpose: the work lives in `lifecycle.ts` (run state), `stage-runner.ts`
+ * (dispatch), `submissions.ts` / `inspector.ts` (what children submit) and `engine-core.ts`
+ * (state, persistence, events). This class composes them and adds the read-side child
+ * entry points (`gov_read`, `gov_view`, `ledger_standings`, scan) that need nothing but the
+ * visibility matrix and the submission cache.
+ *
+ * NOTHING HERE THROWS TO THE MODEL. Every entry point converts an unexpected failure into a
+ * `NOT ACCEPTED: internal error` result: a thrown exception inside a tool call becomes an
+ * error result that invites an identical retry, and a governed run has no way to explain
+ * "the engine crashed" to a child in any other voice.
+ */
+import type { GovernanceEngineApi, GovernanceEventListener, GovernanceSnapshot, Identity, ToolText } from '../types.js';
+import { EngineCore, type EngineDeps } from './engine-core.js';
+import { type PauseOutcome } from './pause.js';
+export declare class GovernanceEngine implements GovernanceEngineApi {
+    private readonly core;
+    constructor(deps: EngineDeps);
+    /** Exposed for tests and the wiring's persistence helpers; not part of the tool surface. */
+    get internals(): EngineCore;
+    start(input: unknown, signal?: AbortSignal): Promise<ToolText>;
+    status(): ToolText;
+    resume(runId?: string): Promise<ToolText>;
+    dispatchStage(input: unknown, signal?: AbortSignal): Promise<ToolText>;
+    close(summary?: string): Promise<ToolText>;
+    abandon(reason: string): Promise<ToolText>;
+    resolve(input: unknown): Promise<ToolText>;
+    private guard;
+    snapshot(): GovernanceSnapshot | null;
+    isStageRunning(): boolean;
+    abortStage(): void;
+    /**
+     * `/gov pause`: stop at the next clean boundary (governance-mode-v1-1 6). A human
+     * decision, so it is NOT on `GovernanceEngineApi` and no tool can reach it.
+     */
+    requestPause(): Promise<PauseOutcome>;
+    /** `/gov pause cancel`: true when a pending request was withdrawn. */
+    cancelPause(): boolean;
+    subscribe(listener: GovernanceEventListener): () => void;
+    /**
+     * Stop timers and release the run lock WITHOUT closing the run: quitting the CLI leaves
+     * the run resumable (D-12), exactly as an Esc does.
+     */
+    dispose(): void;
+    submitWork(identity: Identity, input: unknown): ToolText;
+    submitReview(identity: Identity, input: unknown): ToolText;
+    submitTest(identity: Identity, input: unknown): ToolText;
+    inspectorApply(input: unknown): ToolText;
+    inspectorRule(input: unknown): ToolText;
+    inspectorSettle(input: unknown): ToolText;
+    private child;
+    standings(): ToolText;
+    private refs;
+    private deny;
+    readArtifact(identity: Identity, input: unknown): ToolText;
+    private doRead;
+    requestView(identity: Identity, input: unknown): ToolText;
+    private doView;
+    private failingFiles;
+    private scopedFindings;
+    scan(_identity: Identity, input: unknown): ToolText | Promise<ToolText>;
+}
+export declare function createGovernanceEngine(deps: EngineDeps): GovernanceEngine;