@gaia-ai/conductor 0.5.5 → 0.6.1

package/dist/src/core/conductor.js

@@ -1,4 +1,6 @@
-import { conductorId, selectAgent, } from '@gaia-ai/core';
+import { existsSync } from 'node:fs';
+import { conductorId } from '@gaia-ai/core';
+import { selectAgent } from '../plugins/plugins.js';
 function sleep(ms, signal) {
     return new Promise((resolve) => {
         if (signal?.aborted) {
@@ -370,14 +372,11 @@ export class Conductor {
         };
         const env = resolveRunEnv(t.effectiveEnvVars, core, this.logger);
         const ws = await this.workspace.ensure(t.identifier, t.branchName, baseRef);
-        // A claimable state has no deterministic policy without a WORKFLOW.md
-        // (SKILL.md dispatch reads its `## State: <state>` sections). The human
-        // steered this to WARN-and-proceed (not a hard fail): the agent runs on
-        // engine defaults, and the gap is observable in the conductor log rather
-        // than wedging the run. `ws.instructions` IS the loaded WORKFLOW.md (null
-        // when absent), so no extra stat.
+        // A claimable state has no project policy without a WORKFLOW.md. Warn and
+        // proceed so the missing project instructions are observable without
+        // wedging the run. `ws.instructions` is the loaded file (null when absent).
         if (!ws.instructions) {
-            this.logger.warn({ ticket: t.identifier, workspace: ws.path }, 'WORKFLOW.md missing — dispatching on engine defaults');
+            this.logger.warn({ ticket: t.identifier, workspace: ws.path }, 'WORKFLOW.md missing — no project instructions dispatched');
         }
         // Lifecycle hooks are executor-owned + best-effort (GAIA-84): runHook never
         // throws, so neither call can abort dispatch or wedge a run in `claimed`.
@@ -397,7 +396,7 @@ export class Conductor {
         const prompt = ws.instructions
             ? renderPrompt(this.config.prompt, {
                 identifier: t.identifier,
-                state: t.state || 'triage',
+                state: t.state || 'qualification',
                 runUuid: run.runUuid,
             })
             : '';
@@ -436,8 +435,28 @@ export class Conductor {
     async serve(signal) {
         await this.pollLoop(signal);
     }
+    /**
+     * True once this conductor's own checkout has been removed from disk (its
+     * worktree was reaped while the process kept running). Such a conductor is a
+     * pure liability: it still heartbeats and still claims runs, but every
+     * dispatch fails — no git command and no relative path can resolve from a
+     * deleted directory — so each claim burns one attempt and three of them park
+     * the ticket behind the circuit breaker. Observed as 30 orphans claiming and
+     * failing tickets they could never dispatch.
+     */
+    checkoutGone() {
+        return !existsSync(this.checkoutRoot);
+    }
     async pollLoop(signal) {
         while (!signal?.aborted) {
+            if (this.checkoutGone()) {
+                // Stop claiming and let the loop end — the process exits and the cron
+                // reaper flips status to offline on lease expiry, same as any crash.
+                // Deliberately NOT an offline write from here: the loop never owns that
+                // transition (see the note at the end of this method).
+                this.logger.error({ conductorId: this.id, workspace: this.checkoutRoot }, 'checkout is gone — stopping conductor instead of claiming runs it cannot dispatch');
+                return;
+            }
             try {
                 await this.tick();
             }

package/dist/src/index.d.ts

@@ -1,8 +1,10 @@
 export type * from '@gaia-ai/core';
+export type { ConductorRegistryEntry } from '@gaia-ai/core';
 export { conductorId } from '@gaia-ai/core';
-export { DrupalGaiaRemote, drupalRemote, FakeGaiaRemote, FakeWorkspace, fakeRemote, fakeWorkspace, GitWorkspace, gitWorkspace, selectExecutor, selectRemote, selectWorkspace, } from '@gaia-ai/core/plugins';
-export type { GaiaCliDeps } from './cli/gaia.js';
-export { main, runGaiaCli } from './cli/gaia.js';
-export type { ConductorRegistryEntry } from './cli/local-registry.js';
-export { DEFAULT_AGENT_PROMPT, loadConductorConfig } from './config.js';
+export { renderGaiaConfig } from './cli/init.js';
+export { type AddonRenameResult, type ConfigSurface, migrateAddonNames, migrateAddonNamesInFile, RENAMED_ADDONS, runAddonRenameMigration, } from './cli/migrate-addon-names.js';
+export { hasProjectConnection, type ProjectConnectionChoice, runConnectionUpgrade, runUpgrade, type UpgradeReport, } from './cli/upgrade.js';
+export { default as conductorCommandPlugin, type GaiaCliDeps, runConductorCli, } from './commands/conductor.js';
+export { composeConductorConfig, DEFAULT_AGENT_PROMPT, loadConductorConfig, stripLegacyConnectionFromConfigSource, } from './config.js';
+export * from './contract.js';
 export { Conductor } from './core/conductor.js';

package/dist/src/index.js

@@ -1,5 +1,28 @@
 export { conductorId } from '@gaia-ai/core';
-export { DrupalGaiaRemote, drupalRemote, FakeGaiaRemote, FakeWorkspace, fakeRemote, fakeWorkspace, GitWorkspace, gitWorkspace, selectExecutor, selectRemote, selectWorkspace, } from '@gaia-ai/core/plugins';
-export { main, runGaiaCli } from './cli/gaia.js';
-export { DEFAULT_AGENT_PROMPT, loadConductorConfig } from './config.js';
+// GAIA-201: the connection-config template, reused by `gaia upgrade` to seed a
+// `gaia.config.js`.
+export { renderGaiaConfig } from './cli/init.js';
+// GAIA-224 (Finding 8b): the addon package-name rename pass `gaia upgrade` runs
+// as its last step (`@gaia-ai/plugin-*` + the deleted `@gaia-ai/core/builtins`
+// and `@gaia-ai/core/plugins` → `@gaia-ai/addon-*`).
+export { migrateAddonNames, migrateAddonNamesInFile, RENAMED_ADDONS, runAddonRenameMigration, } from './cli/migrate-addon-names.js';
+// GAIA-216: the seed/migration routine, hoisted from the host so `conductor init`
+// (intra-package) and `gaia upgrade` (host→engine) share one implementation.
+export { hasProjectConnection, runConnectionUpgrade, runUpgrade, } from './cli/upgrade.js';
+// GAIA-201: the conductor is now a COMMAND PLUGIN mounted by the `@gaia-ai/gaia`
+// host, not the CLI entrypoint. `main`/`runGaiaCli` are gone; the default export
+// is the `GaiaCommandPlugin`, exposed here as `./commands/conductor` too.
+export { default as conductorCommandPlugin, runConductorCli, } from './commands/conductor.js';
+// GAIA-218: the balanced strip is exported for the host/tests + reuse.
+export { composeConductorConfig, DEFAULT_AGENT_PROMPT, loadConductorConfig, stripLegacyConnectionFromConfigSource, } from './config.js';
+// GAIA-224 (Finding 6): this package now OWNS the conductor-surface contract —
+// the interfaces, the config types, the preset view and the slot selectors — and
+// re-exports the whole of it here. The runtime-light subpath
+// `@gaia-ai/conductor/contract` is the one an ADDON should import (this main
+// entry pulls the engine + the command plugin). The built-in IMPLEMENTATIONS it
+// used to re-export from the deleted `@gaia-ai/core/plugins` barrel now live in
+// their own addons (`@gaia-ai/addon-remote-drupal`,
+// `@gaia-ai/addon-workspace-git`, `@gaia-ai/addon-fake`) and are deliberately NOT
+// re-exported: the engine must not edge an addon (acyclic layer rule).
+export * from './contract.js';
 export { Conductor } from './core/conductor.js';

package/dist/src/plugins/agent.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Per-agent effort footprint parsed from that agent's run transcript
+ * (GAIA-132). The metrics are transcript-derived and therefore
+ * **agent-specific** (each agent's transcript has its own format), so parsing
+ * lives behind the agent abstraction (see {@link GaiaAgent.parseFootprint}) —
+ * the conductor stays agent-agnostic and writes the footprint verbatim.
+ * `duration_s` is likewise derived from the transcript (its first→last entry
+ * timestamps), NOT recomputed by the conductor from a re-read `started_at`
+ * (GAIA-151): the log is the single source of the run's wall-clock length, so
+ * there is no timestamp round-trip through JSON:API to mis-parse.
+ */
+export interface AgentFootprint {
+    /** Total tokens across every usage bucket of every assistant turn. */
+    tokens: number;
+    /**
+     * Wall-clock run length in seconds, derived from the transcript's first→last
+     * entry timestamps (GAIA-151). 0 when the transcript has fewer than two
+     * timestamped entries (empty/absent log).
+     */
+    duration_s: number;
+    /** Number of assistant turns in the transcript. */
+    agent_turns: number;
+    /** Number of tool-use calls across all assistant turns. */
+    tool_calls: number;
+    /** Number of user-submitted prompts. */
+    user_prompts: number;
+    /** Total words across those user prompts. */
+    user_prompt_words: number;
+    /** Model of the last assistant turn, when present (informational). */
+    model?: string;
+}
+/** An all-zero footprint — the honest result for an empty/absent transcript. */
+export declare function emptyAgentFootprint(): AgentFootprint;
+/**
+ * A GAIA agent: the program the conductor runs to work a ticket (e.g. claude).
+ * It knows how it is launched (CLI + model + flags) and where its per-run
+ * transcript/log lives — so the conductor stays agent-agnostic and the CLI can
+ * attach the run log on release without agent-specific knowledge.
+ */
+export interface GaiaAgent {
+    /** Stable id, e.g. 'claude'. */
+    readonly id: string;
+    /**
+     * Build the full agent CLI invocation for a GAIA prompt. With an empty
+     * prompt, returns the bare launch command (no prompt argument).
+     */
+    launchCommand(prompt: string): string;
+    /**
+     * Locate and read this agent's run transcript for a run that executed in
+     * `worktreePath`. MUST return '' (never throw) when nothing is found.
+     */
+    getRunLog(worktreePath: string): Promise<string>;
+    /**
+     * Parse this agent's run transcript (as returned by {@link getRunLog}) into
+     * a footprint of effort metrics (GAIA-132). The transcript format is
+     * agent-specific, so each agent owns its own parser. MUST be tolerant of
+     * blank/partial/absent input (never throw) — an empty log yields
+     * {@link emptyAgentFootprint}.
+     */
+    parseFootprint(log: string): AgentFootprint;
+}

package/dist/src/plugins/agent.js

@@ -0,0 +1,11 @@
+/** An all-zero footprint — the honest result for an empty/absent transcript. */
+export function emptyAgentFootprint() {
+    return {
+        tokens: 0,
+        duration_s: 0,
+        agent_turns: 0,
+        tool_calls: 0,
+        user_prompts: 0,
+        user_prompt_words: 0,
+    };
+}

package/dist/src/plugins/executor.d.ts

@@ -0,0 +1,104 @@
+export interface SpawnedSession {
+    sessionRef: string;
+}
+export interface ExecutorCapabilities {
+    persistent: boolean;
+}
+export interface SpawnRunInput {
+    ticket: {
+        uuid: string;
+        identifier: string;
+        title: string;
+        branchName: string;
+        state: string;
+        url?: string;
+    };
+    run: {
+        uuid: string;
+        id: number;
+        handler: string;
+    };
+    workspacePath: string;
+    instructions: {
+        path: string;
+        sha256: string;
+        text: string;
+    } | null;
+    command?: string;
+    env?: Record<string, string>;
+}
+/** The four lifecycle-hook slots, keyed exactly like `config.hooks`. */
+export type HookName = 'after_create' | 'before_run' | 'after_run' | 'after_done';
+/** Context for a hook invocation — carries the ticket for observable logging. */
+export interface HookContext {
+    /** The ticket identifier/uuid the hook is running for (log context). */
+    ticket: string;
+}
+export interface GaiaExecutor {
+    id: string;
+    capabilities(): ExecutorCapabilities;
+    /**
+     * Run the lifecycle hook `name` (command from `config.hooks[name]`) in `cwd`,
+     * best-effort. This is the SINGLE catch point for all lifecycle hooks:
+     *
+     * - MUST NEVER throw. No configured command → silent no-op. A failing command
+     *   → `logger.error({hook,worktree,ticket,err}, 'lifecycle hook failed')` then
+     *   return. So a hook failure never aborts dispatch or wedges a run in
+     *   `claimed`.
+     * - The underlying shell command still fails honestly (a non-zero exit
+     *   rejects); only the executor catches + logs + continues.
+     *
+     * `env`, when given, is the run's resolved environment (per-ticket env_vars
+     * merged with the core GAIA_* vars, GAIA-99), merged over the hook process's
+     * inherited env. Values may be sensitive — implementations must never log
+     * them (log key names only).
+     */
+    runHook(name: HookName, cwd: string, ctx: HookContext, env?: Record<string, string>): Promise<void>;
+    startRun(input: SpawnRunInput): Promise<SpawnedSession>;
+    /**
+     * Signal the run's agent to stop. Called by the conductor's run-finalise pass
+     * BEFORE it captures the agent transcript (GAIA-132), so a stop must not
+     * destroy the log. For herdr this is a NO-OP: at finalise time the agent is
+     * idle and its jsonl transcript is already fully written to disk, and the
+     * subsequent {@link cleanupRun} tab-close kills the PTY (the agent dies with
+     * it). The seam exists for executors whose agent outlives its UI surface.
+     * Best-effort; gated by the conductor on `capabilities().persistent`.
+     */
+    stopRun(branch: string): Promise<void>;
+    /**
+     * Tear down ONE run's hosted UI surface — for herdr, close only the tab whose
+     * label carries the `#<runId>` token (`startRun` labels every tab
+     * `<identifier> · <state> #<run.id>`), via `herdr tab close <tab_id>` (killing
+     * that PTY). Run-scoped by design (GAIA-183): a sibling run's tab in the same
+     * branch workspace — a still-open prior-state run or a concurrent re-claim —
+     * and any non-run tab are left untouched. Called as the LAST finalisation step,
+     * strictly after the transcript is captured, and again at dispatch to clear a
+     * reused workspace's leftover tab for the run being (re-)started. No matching
+     * tab → a quiet no-op. Does NOT touch the branch worktree (that is the
+     * reap/{@link removeWorktree} lifecycle). Best-effort: a failing tab-close is
+     * swallowed and never aborts finalisation or dispatch. A no-op for
+     * non-persistent executors.
+     */
+    cleanupRun(branch: string, runId: number): Promise<void>;
+    /**
+     * Tear down the branch's entire worktree (git worktree + hosted workspace),
+     * reclaiming its disk. Called by the conductor's ticket-cleanup pass once a
+     * ticket is done. A no-op for non-persistent executors (no hosted workspace);
+     * the conductor gates the call on `capabilities().persistent`.
+     *
+     * `worktreePath` is the stable, identifier-derived worktree path (from the
+     * ticket's latest run). Prefer it over `branch` to resolve the worktree: the
+     * checked-out branch is mutable (the coding agent may rename/switch it), the
+     * path is not.
+     *
+     * Returns whether the worktree was actually present on THIS host and torn
+     * down (or reclaimed on disk) — i.e. whether the teardown happened locally.
+     * `false` means nothing matched here: the worktree is either already gone or
+     * lives on another conductor's host. The reaper uses this to avoid marking a
+     * ticket `cleaned_up` for a worktree it did not actually tear down (a
+     * cross-host false-teardown), leaving it for the host that physically holds
+     * it. A genuine failure still throws (surfaced as a teardown miss); a `false`
+     * return is a clean "not here", not an error.
+     */
+    removeWorktree(branch: string, worktreePath?: string): Promise<boolean>;
+}

package/dist/src/plugins/executor.js

@@ -0,0 +1 @@
+export {};

package/dist/src/plugins/plugins.d.ts

@@ -0,0 +1,60 @@
+import type { ConductorLogger } from '@gaia-ai/core';
+import type { DropSHPlugin } from 'dropsh/plugin';
+import type { ConductorFileConfig } from '../types.js';
+import type { GaiaAgent } from './agent.js';
+import type { GaiaExecutor } from './executor.js';
+import type { GaiaRemote, Ticket } from './remote.js';
+import type { GaiaWorkspace } from './workspace.js';
+/** Runtime dependencies handed to a plugin factory at selection time. */
+export interface ExecutorDeps {
+    /** The in-scope conductor logger — the executor logs hook failures through it. */
+    logger: ConductorLogger;
+}
+export interface RemotePlugin extends DropSHPlugin {
+    readonly kind: 'remote';
+    readonly id: string;
+    readonly requiredModules: string[];
+    createRemote(config: ConductorFileConfig): Promise<GaiaRemote>;
+}
+export interface ExecutorPlugin extends DropSHPlugin {
+    readonly kind: 'executor';
+    readonly id: string;
+    readonly requiredModules: string[];
+    createExecutor(config: ConductorFileConfig, deps: ExecutorDeps): Promise<GaiaExecutor>;
+}
+export interface WorkspacePlugin extends DropSHPlugin {
+    readonly kind: 'workspace';
+    readonly id: string;
+    readonly requiredModules: string[];
+    createWorkspace(config: ConductorFileConfig): Promise<GaiaWorkspace>;
+}
+export interface AgentPlugin extends DropSHPlugin {
+    readonly kind: 'agent';
+    readonly id: string;
+    readonly requiredModules: string[];
+    createAgent(config: ConductorFileConfig): Promise<GaiaAgent>;
+}
+/** Resolves the remote from its named config slot. */
+export declare function selectRemote(config: ConductorFileConfig): Promise<GaiaRemote>;
+/** Resolves the executor from its named config slot, injecting the logger. */
+export declare function selectExecutor(config: ConductorFileConfig, logger: ConductorLogger): Promise<GaiaExecutor>;
+/** Resolves the workspace from its named config slot. */
+export declare function selectWorkspace(config: ConductorFileConfig): Promise<GaiaWorkspace>;
+/** A config-side agent choice: an agent plugin + an optional static priority over the ticket. */
+export interface AgentCandidate {
+    agent: AgentPlugin;
+    priority?: (ticket: Ticket) => number;
+}
+/** A constructed candidate: the agent id, its GaiaAgent, and the config-side priority. */
+export interface ResolvedAgent {
+    id: string;
+    agent: GaiaAgent;
+    priority?: (ticket: Ticket) => number;
+}
+/**
+ * Pick the agent for a ticket: highest `priority(ticket)` wins; a candidate with
+ * no `priority` scores lowest; ties resolve by config array order (stable sort).
+ */
+export declare function selectAgent(candidates: ResolvedAgent[], ticket: Ticket): ResolvedAgent;
+/** Constructs every agent candidate from the resolved config slot (single or array). */
+export declare function selectAgents(config: ConductorFileConfig): Promise<ResolvedAgent[]>;

package/dist/src/plugins/plugins.js

@@ -0,0 +1,42 @@
+/** Resolves the remote from its named config slot. */
+export async function selectRemote(config) {
+    return config.remote.createRemote(config);
+}
+/** Resolves the executor from its named config slot, injecting the logger. */
+export async function selectExecutor(config, logger) {
+    return config.executor.createExecutor(config, { logger });
+}
+/** Resolves the workspace from its named config slot. */
+export async function selectWorkspace(config) {
+    return config.workspace.createWorkspace(config);
+}
+/** A missing `priority` scores strictly below any real number (AC-4). */
+const DEFAULT_PRIORITY = Number.NEGATIVE_INFINITY;
+/**
+ * Pick the agent for a ticket: highest `priority(ticket)` wins; a candidate with
+ * no `priority` scores lowest; ties resolve by config array order (stable sort).
+ */
+export function selectAgent(candidates, ticket) {
+    const best = candidates
+        .map((c, index) => ({
+        c,
+        index,
+        score: c.priority ? c.priority(ticket) : DEFAULT_PRIORITY,
+    }))
+        .sort((a, b) => b.score - a.score || a.index - b.index)[0];
+    if (!best) {
+        throw new Error('selectAgent: no agent candidates configured');
+    }
+    return best.c;
+}
+/** Constructs every agent candidate from the resolved config slot (single or array). */
+export async function selectAgents(config) {
+    const candidates = Array.isArray(config.agent)
+        ? config.agent
+        : [config.agent];
+    return Promise.all(candidates.map(async (c) => ({
+        id: c.agent.id,
+        agent: await c.agent.createAgent(config),
+        ...(c.priority ? { priority: c.priority } : {}),
+    })));
+}

package/dist/src/plugins/preset.d.ts

@@ -0,0 +1,48 @@
+import type { AddonEntry, DiscoveredContributions, GaiaPreset } from '@gaia-ai/core';
+import type { AgentCandidate, ExecutorPlugin, RemotePlugin, WorkspacePlugin } from './plugins.js';
+import type { Ticket } from './remote.js';
+/**
+ * The conductor surface's concrete contributions — the strongly-typed view of
+ * the four conductor accumulators `discoverAddons(entries, 'conductor', …)`
+ * fills. Core returns them as opaque `unknown[]`; the engine narrows once, at
+ * the discovery call site (see {@link narrowConductorContributions}).
+ */
+export interface ConductorContributions {
+    remotes: RemotePlugin[];
+    executors: ExecutorPlugin[];
+    workspaces: WorkspacePlugin[];
+    agents: AgentCandidate[];
+}
+/**
+ * One `addons[]` entry on the conductor surface: core's surface-agnostic
+ * `AddonEntry` with the agent `priority` narrowed to the real `Ticket`.
+ */
+export type ConductorAddonEntry = string | (Exclude<AddonEntry, string> & {
+    priority?: (ticket: Ticket) => number;
+});
+/**
+ * A preset as a CONDUCTOR-surface addon writes it: core's `GaiaPreset` with the
+ * four conductor accumulators concretely typed.
+ *
+ * It literally `extends GaiaPreset`, so the compiler — not a comment — enforces
+ * that this view stays a faithful narrowing of the kernel contract. That only
+ * type-checks because core's `OpaqueAccumulator` takes `never[]` on the input
+ * side: `never[]` is assignable to `RemotePlugin[]`, so the concrete member below
+ * satisfies the opaque one contravariantly. If core ever widened that parameter
+ * to `unknown[]`, this `extends` would fail loudly here instead of the two views
+ * silently drifting apart.
+ */
+export interface Preset<O = unknown> extends GaiaPreset<O> {
+    remotes?: (acc: RemotePlugin[], opts: O) => RemotePlugin[] | Promise<RemotePlugin[]>;
+    executors?: (acc: ExecutorPlugin[], opts: O) => ExecutorPlugin[] | Promise<ExecutorPlugin[]>;
+    workspaces?: (acc: WorkspacePlugin[], opts: O) => WorkspacePlugin[] | Promise<WorkspacePlugin[]>;
+    agents?: (acc: AgentCandidate[], opts: O) => AgentCandidate[] | Promise<AgentCandidate[]>;
+}
+/**
+ * The single, reviewed narrowing at the engine's discovery seam: reinterpret
+ * core's opaque conductor accumulators as this surface's concrete contribution
+ * lists. Safe because every conductor-surface preset is typed against
+ * {@link Preset}, and `resolveConductorSlots` still runs the runtime `.kind`
+ * guard on whatever actually landed in a singleton slot.
+ */
+export declare function narrowConductorContributions(discovered: Pick<DiscoveredContributions, 'remotes' | 'executors' | 'workspaces' | 'agents'>): ConductorContributions;

package/dist/src/plugins/preset.js

@@ -0,0 +1,23 @@
+// GAIA-224 (Finding 6, decision 7): the CONDUCTOR-SURFACE view of the preset
+// contract. `@gaia-ai/core` owns the surface-AGNOSTIC machinery — it knows the
+// accumulator NAMES (`SURFACE_KEYS`) and threads them (`discoverAddons`), but its
+// per-surface accumulators are OPAQUE (`OpaqueAccumulator`), because the element
+// types of the conductor surface (`RemotePlugin`, `ExecutorPlugin`,
+// `WorkspacePlugin`, `AgentCandidate`) live HERE, in the package that owns the
+// surface. Without that split, `core/src/plugins/preset.ts` would have to import
+// the conductor contract and core would edge `@gaia-ai/conductor` — breaking the
+// "core has zero @gaia-ai/* edges" rule.
+//
+// A conductor-surface addon therefore types its `./preset` accumulators against
+// THIS `Preset` (e.g. `export const agents: Preset['agents'] = …`) instead of
+// core's `GaiaPreset`, and stays structurally assignable to it.
+/**
+ * The single, reviewed narrowing at the engine's discovery seam: reinterpret
+ * core's opaque conductor accumulators as this surface's concrete contribution
+ * lists. Safe because every conductor-surface preset is typed against
+ * {@link Preset}, and `resolveConductorSlots` still runs the runtime `.kind`
+ * guard on whatever actually landed in a singleton slot.
+ */
+export function narrowConductorContributions(discovered) {
+    return discovered;
+}