niceeval 0.17.1 → 0.19.0

package/dist/plugin/contracts.d.ts

@@ -1,8 +1,14 @@
 import type { ExperimentHookContext } from "../runner/types.js";
 import type { JsonValue, ScopedFeedback } from "../shared/types.js";
 import { type SandboxLayer } from "../sandbox/layer.js";
+import type { SandboxAction, SandboxAfterAction } from "../sandbox/action.js";
+import type { SandboxCommandContext, SandboxCommandTarget } from "../sandbox/commands.js";
+import type { CodexConfig } from "../agents/codex.js";
+import type { ClaudeCodeConfig } from "../agents/claude-code.js";
+import type { BubConfig } from "../agents/bub.js";
+import type { SkillSpec, McpServer } from "../agents/types.js";
 export type PluginOwner = "experiment" | "group" | "eval";
-export type PluginScope = PluginOwner | "sandbox";
+export type PluginScope = "experiment" | "group" | "sandbox" | "attempt";
 export type PluginOnUnavailable = "stop-group" | "replace-sandbox";
 declare const PLUGIN_INSTANCE: unique symbol;
 export interface PluginInstance<Owners extends PluginOwner = PluginOwner> {
@@ -14,124 +20,130 @@ export interface GroupPluginContext extends ScopedFeedback {
     readonly evalGroupId: string;
     readonly signal: AbortSignal;
 }
-export interface EvalPluginContext extends ScopedFeedback {
+type EvalGroupRef = NonNullable<SandboxCommandContext["evalGroup"]>;
+export interface AttemptPluginContext extends ScopedFeedback {
     readonly experimentId: string;
     readonly evalId: string;
     readonly attempt: number;
-    readonly evalGroupId?: string;
+    readonly evalGroup?: EvalGroupRef;
     readonly signal: AbortSignal;
 }
 export type ExperimentPluginContext = ExperimentHookContext;
+export type PluginElements<Element> = Element | readonly Element[];
 export type PluginLifecycleFragment<Hook> = Readonly<{
-    readonly identity?: Readonly<globalThis.Record<string, JsonValue>>;
-} & ({
-    readonly setup: Hook;
-    readonly teardown?: Hook;
-} | {
-    readonly setup?: Hook;
-    readonly teardown: Hook;
-})>;
+    readonly before?: PluginElements<Hook>;
+    readonly after?: PluginElements<Hook>;
+}>;
 export type ExperimentPluginFragment = PluginLifecycleFragment<PluginHook<ExperimentHookContext>>;
 export type GroupPluginFragment = PluginLifecycleFragment<PluginHook<GroupPluginContext>>;
-export type SandboxPluginFragment = SandboxLayer<"command-only">;
-export type EvalPluginFragment = PluginLifecycleFragment<PluginHook<EvalPluginContext>>;
-export interface PluginDefinition<Options> {
-    readonly name: string;
-    readonly behaviorRevision: string;
-    readonly instanceKey?: (options: Options) => string;
-    readonly experiment?: (options: Options) => ExperimentPluginFragment;
-    readonly group?: (options: Options) => GroupPluginFragment;
-    readonly sandbox?: (options: Options) => SandboxPluginFragment;
-    readonly eval?: (options: Options) => EvalPluginFragment;
+type GroupContext<Context, Required extends boolean> = Required extends true ? Omit<Context, "evalGroup"> & {
+    readonly evalGroup: EvalGroupRef;
+} : Context;
+export type AttemptPluginFragment<Required extends boolean = false> = PluginLifecycleFragment<PluginHook<GroupContext<AttemptPluginContext, Required>>>;
+export interface SandboxPluginFragment<Required extends boolean = false> {
+    readonly before?: PluginElements<SandboxAction | ((sandbox: SandboxCommandTarget, context: GroupContext<SandboxCommandContext, Required>) => void | Promise<void>)>;
+    readonly after?: PluginElements<SandboxAfterAction | ((sandbox: SandboxCommandTarget, context: GroupContext<Omit<SandboxCommandContext, "onCleanup">, Required>) => void | Promise<void>)>;
+}
+export interface PluginAgentExtensions {
+    readonly skills?: readonly SkillSpec[];
+    readonly mcpServers?: readonly McpServer[];
+    readonly codex?: Pick<CodexConfig, "plugins" | "configFile" | "before" | "after">;
+    readonly claudeCode?: Pick<ClaudeCodeConfig, "plugins" | "settingsFile" | "before" | "after">;
+    readonly bub?: Pick<BubConfig, "pythonPlugins" | "before" | "after">;
 }
-type AtLeastOneScope<Options> = {
-    readonly experiment: (options: Options) => ExperimentPluginFragment;
+interface PluginFields<Required extends boolean> {
+    readonly agent?: PluginAgentExtensions;
+    readonly experiment?: ExperimentPluginFragment;
+    readonly group?: GroupPluginFragment;
+    readonly sandbox?: SandboxPluginFragment<Required>;
+    readonly attempt?: AttemptPluginFragment<Required>;
+}
+type NonEmptyFields<Required extends boolean> = PluginFields<Required> & ({
+    readonly agent: PluginAgentExtensions;
 } | {
-    readonly group: (options: Options) => GroupPluginFragment;
+    readonly experiment: ExperimentPluginFragment;
 } | {
-    readonly sandbox: (options: Options) => SandboxPluginFragment;
+    readonly group: GroupPluginFragment;
 } | {
-    readonly eval: (options: Options) => EvalPluginFragment;
-};
-type HostFragmentFactories<Options> = Readonly<{
-    experiment: (options: Options) => ExperimentPluginFragment;
-    group: (options: Options) => GroupPluginFragment;
-    eval: (options: Options) => EvalPluginFragment;
-}>;
-type ExactHostFragments<Options, Owners extends PluginOwner> = {
-    readonly [Owner in Owners]-?: HostFragmentFactories<Options>[Owner];
-} & {
-    readonly [Owner in Exclude<PluginOwner, Owners>]?: never;
-};
-type OptionedPluginDefinition<Options, Owners extends PluginOwner> = Omit<PluginDefinition<Options>, PluginOwner | "instanceKey"> & ExactHostFragments<Options, Owners> & {
-    readonly instanceKey: (options: Options) => string;
-};
-type OptionedSandboxOnlyPluginDefinition<Options> = Omit<PluginDefinition<Options>, PluginOwner | "sandbox" | "instanceKey"> & {
-    readonly [Owner in PluginOwner]?: never;
-} & {
-    readonly sandbox: (options: Options) => SandboxPluginFragment;
-    readonly instanceKey: (options: Options) => string;
-};
-type HostScopesOf<Definition> = (Definition extends {
-    readonly experiment: (...args: any[]) => unknown;
-} ? "experiment" : never) | (Definition extends {
-    readonly group: (...args: any[]) => unknown;
-} ? "group" : never) | (Definition extends {
-    readonly eval: (...args: any[]) => unknown;
-} ? "eval" : never);
-type ScopesOf<Definition> = [HostScopesOf<Definition>] extends [never] ? Definition extends {
-    readonly sandbox: (...args: any[]) => unknown;
-} ? PluginOwner : never : HostScopesOf<Definition>;
-type NormalizedPluginLifecycleFragment<Hook> = Readonly<{
+    readonly sandbox: SandboxPluginFragment<Required>;
+} | {
+    readonly attempt: AttemptPluginFragment<Required>;
+});
+interface PluginIdentity {
+    readonly behaviorRevision?: never;
+    readonly instanceKey?: never;
+    readonly eval?: never;
+    readonly name: string;
+    readonly key?: string;
     readonly identity: Readonly<globalThis.Record<string, JsonValue>>;
-    readonly setup?: Hook;
-    readonly teardown?: Hook;
-    readonly hostDeclared: boolean;
-}>;
+}
+type GroupRequiredPluginDefinition = PluginIdentity & {
+    readonly requires: {
+        readonly evalGroup: true;
+    };
+} & NonEmptyFields<true>;
+type OptionalGroupPluginDefinition = PluginIdentity & {
+    readonly requires?: {
+        readonly evalGroup?: false;
+    };
+} & NonEmptyFields<false>;
+export type PluginDefinition = GroupRequiredPluginDefinition | OptionalGroupPluginDefinition;
+type OwnersOf<Definition> = Definition extends {
+    readonly agent: unknown;
+} | {
+    readonly experiment: unknown;
+} ? "experiment" : Definition extends {
+    readonly group: unknown;
+} ? "experiment" | "group" : PluginOwner;
+interface NormalizedLifecycle<Context> {
+    readonly before: readonly PluginHook<Context>[];
+    readonly after: readonly PluginHook<Context>[];
+}
 export interface PluginInstanceData {
     readonly name: string;
-    readonly behaviorRevision: string;
-    readonly instanceKey: string;
-    readonly experiment?: NormalizedPluginLifecycleFragment<PluginHook<ExperimentHookContext>>;
-    readonly group?: NormalizedPluginLifecycleFragment<PluginHook<GroupPluginContext>>;
-    readonly sandbox?: SandboxPluginFragment;
-    readonly eval?: NormalizedPluginLifecycleFragment<PluginHook<EvalPluginContext>>;
+    readonly key: string;
+    readonly identity: Readonly<globalThis.Record<string, JsonValue>>;
+    readonly requires: Readonly<{
+        evalGroup?: true;
+    }>;
+    readonly agent?: PluginAgentExtensions;
+    readonly experiment?: NormalizedLifecycle<ExperimentHookContext>;
+    readonly group?: NormalizedLifecycle<GroupPluginContext>;
+    readonly attempt?: NormalizedLifecycle<AttemptPluginContext>;
+    readonly sandbox?: SandboxLayer<"command-only">;
+    readonly shape: JsonValue;
+    readonly agentProjection?: JsonValue;
 }
 export interface LinkedPluginLifecycle {
     readonly scope: PluginOwner;
     readonly name: string;
-    readonly behaviorRevision: string;
-    readonly instanceKey: string;
+    readonly key: string;
     readonly identity: Readonly<globalThis.Record<string, JsonValue>>;
+    readonly requires: PluginInstanceData["requires"];
+    readonly shape: JsonValue;
+    readonly agentProjection?: JsonValue;
     readonly arrayPosition: number;
+    readonly beforeCount: number;
+    readonly afterCount: number;
     readonly hasSetup: boolean;
     readonly hasTeardown: boolean;
     readonly hostDeclared: boolean;
-    readonly sandboxLayer?: SandboxPluginFragment;
+    readonly sandboxLayer?: SandboxLayer<"command-only">;
     readonly setup?: PluginHook<any>;
     readonly teardown?: PluginHook<any>;
 }
-export declare function definePlugin<Options, const Definition extends PluginDefinition<Options> & AtLeastOneScope<Options>>(definition: Definition & {
-    readonly instanceKey: (options: Options) => string;
-}): (options: Options) => PluginInstance<ScopesOf<Definition>>;
-export declare function definePlugin<Options>(definition: OptionedPluginDefinition<Options, PluginOwner>): (options: Options) => PluginInstance<PluginOwner>;
-export declare function definePlugin<Options>(definition: OptionedPluginDefinition<Options, "experiment" | "group">): (options: Options) => PluginInstance<"experiment" | "group">;
-export declare function definePlugin<Options>(definition: OptionedPluginDefinition<Options, "experiment" | "eval">): (options: Options) => PluginInstance<"experiment" | "eval">;
-export declare function definePlugin<Options>(definition: OptionedPluginDefinition<Options, "group" | "eval">): (options: Options) => PluginInstance<"group" | "eval">;
-export declare function definePlugin<Options>(definition: OptionedPluginDefinition<Options, "experiment">): (options: Options) => PluginInstance<"experiment">;
-export declare function definePlugin<Options>(definition: OptionedPluginDefinition<Options, "group">): (options: Options) => PluginInstance<"group">;
-export declare function definePlugin<Options>(definition: OptionedPluginDefinition<Options, "eval">): (options: Options) => PluginInstance<"eval">;
-export declare function definePlugin<Options>(definition: OptionedSandboxOnlyPluginDefinition<Options>): (options: Options) => PluginInstance<PluginOwner>;
-/** Broadly annotated dynamic definitions retain runtime owner validation. */
-export declare function definePlugin<Options>(definition: PluginDefinition<Options> & AtLeastOneScope<Options> & {
-    readonly instanceKey: (options: Options) => string;
-}): (options: Options) => PluginInstance<PluginOwner>;
-export declare function definePlugin<const Definition extends PluginDefinition<void> & AtLeastOneScope<void>>(definition: Definition & {
-    readonly instanceKey?: never;
-}): () => PluginInstance<ScopesOf<Definition>>;
+export declare function pluginSourceOf(declaration: object): string | undefined;
+export declare function definePlugin<const Definition extends GroupRequiredPluginDefinition>(spec: Definition): PluginInstance<OwnersOf<Definition>>;
+export declare function definePlugin<const Definition extends OptionalGroupPluginDefinition>(spec: Definition): PluginInstance<OwnersOf<Definition>>;
+export declare function definePlugin<Options, const Required extends boolean = false, const Definition extends PluginIdentity = PluginIdentity>(factory: (options: Options) => Definition & {
+    readonly requires?: {
+        readonly evalGroup: Required;
+    };
+} & NonEmptyFields<Required>): (options: Options) => PluginInstance<OwnersOf<Definition>>;
 export declare function isPluginInstance(value: unknown): value is PluginInstance;
 export declare function pluginInstanceDataOf(value: PluginInstance<any>): PluginInstanceData;
-export declare function linkPluginLifecycles<Scope extends PluginOwner>(plugins: readonly PluginInstance<Scope>[], scope: Scope): readonly LinkedPluginLifecycle[];
-export declare function pluginLifecycleIdentity({ scope, name, behaviorRevision, instanceKey, identity, arrayPosition, hasSetup, hasTeardown }: LinkedPluginLifecycle): JsonValue;
+export declare function assertPluginOwner(plugin: PluginInstance<any>, scope: PluginOwner, label: string): void;
+export declare function linkPluginLifecycles<Scope extends PluginOwner>(plugins: readonly PluginInstance<Scope>[], scope: Scope, field?: "experiment" | "group" | "attempt"): readonly LinkedPluginLifecycle[];
+export declare function pluginLifecycleIdentity({ scope, name, key, identity, requires, shape, agentProjection, arrayPosition }: LinkedPluginLifecycle): JsonValue;
 export declare function pluginLifecycleProjection(lifecycles: readonly LinkedPluginLifecycle[]): JsonValue;
 export {};

package/dist/plugin/contracts.js

@@ -1,16 +1,20 @@
 import { createRequire as __niceevalCreateRequire } from "node:module";
 const __niceevalRequire = __niceevalCreateRequire(import.meta.url);
 const __niceevalCanonical = __niceevalRequire("./contracts.cjs");
-const __niceevalExport0 = __niceevalCanonical["definePlugin"];
-export { __niceevalExport0 as definePlugin };
-const __niceevalExport1 = __niceevalCanonical["isPluginInstance"];
-export { __niceevalExport1 as isPluginInstance };
-const __niceevalExport2 = __niceevalCanonical["linkPluginLifecycles"];
-export { __niceevalExport2 as linkPluginLifecycles };
-const __niceevalExport3 = __niceevalCanonical["pluginInstanceDataOf"];
-export { __niceevalExport3 as pluginInstanceDataOf };
-const __niceevalExport4 = __niceevalCanonical["pluginLifecycleIdentity"];
-export { __niceevalExport4 as pluginLifecycleIdentity };
-const __niceevalExport5 = __niceevalCanonical["pluginLifecycleProjection"];
-export { __niceevalExport5 as pluginLifecycleProjection };
+const __niceevalExport0 = __niceevalCanonical["assertPluginOwner"];
+export { __niceevalExport0 as assertPluginOwner };
+const __niceevalExport1 = __niceevalCanonical["definePlugin"];
+export { __niceevalExport1 as definePlugin };
+const __niceevalExport2 = __niceevalCanonical["isPluginInstance"];
+export { __niceevalExport2 as isPluginInstance };
+const __niceevalExport3 = __niceevalCanonical["linkPluginLifecycles"];
+export { __niceevalExport3 as linkPluginLifecycles };
+const __niceevalExport4 = __niceevalCanonical["pluginInstanceDataOf"];
+export { __niceevalExport4 as pluginInstanceDataOf };
+const __niceevalExport5 = __niceevalCanonical["pluginLifecycleIdentity"];
+export { __niceevalExport5 as pluginLifecycleIdentity };
+const __niceevalExport6 = __niceevalCanonical["pluginLifecycleProjection"];
+export { __niceevalExport6 as pluginLifecycleProjection };
+const __niceevalExport7 = __niceevalCanonical["pluginSourceOf"];
+export { __niceevalExport7 as pluginSourceOf };
 //# sourceMappingURL=contracts.js.map

package/dist/plugin/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":";;;AAAA,4EAA4E;AAC5E,+CAA8C;AAArC,4GAAA,YAAY,OAAA","sourcesContent":["// Effect-backed Plugin API. Deliberately not re-exported by the root entry.\nexport { definePlugin } from \"./contracts.ts\";\nexport type { EvalPluginFragment, EvalPluginContext, ExperimentPluginFragment, ExperimentPluginContext, GroupPluginContext, GroupPluginFragment, PluginDefinition, PluginInstance, PluginLifecycleFragment, PluginOnUnavailable, PluginOwner, PluginScope, SandboxPluginFragment, } from \"./contracts.ts\";\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":";;;AAAA,4EAA4E;AAC5E,+CAA8C;AAArC,4GAAA,YAAY,OAAA","sourcesContent":["// Effect-backed Plugin API. Deliberately not re-exported by the root entry.\nexport { definePlugin } from \"./contracts.ts\";\nexport type { AttemptPluginFragment, AttemptPluginContext, ExperimentPluginFragment, ExperimentPluginContext, GroupPluginContext, GroupPluginFragment, PluginDefinition, PluginAgentExtensions, PluginInstance, PluginLifecycleFragment, PluginOnUnavailable, PluginOwner, PluginScope, SandboxPluginFragment, } from \"./contracts.ts\";\n"]}

package/dist/plugin/index.d.cts

@@ -1,2 +1,2 @@
 export { definePlugin } from "./contracts.cjs";
-export type { EvalPluginFragment, EvalPluginContext, ExperimentPluginFragment, ExperimentPluginContext, GroupPluginContext, GroupPluginFragment, PluginDefinition, PluginInstance, PluginLifecycleFragment, PluginOnUnavailable, PluginOwner, PluginScope, SandboxPluginFragment, } from "./contracts.cjs";
+export type { AttemptPluginFragment, AttemptPluginContext, ExperimentPluginFragment, ExperimentPluginContext, GroupPluginContext, GroupPluginFragment, PluginDefinition, PluginAgentExtensions, PluginInstance, PluginLifecycleFragment, PluginOnUnavailable, PluginOwner, PluginScope, SandboxPluginFragment, } from "./contracts.cjs";

package/dist/plugin/index.d.mts

@@ -1,2 +1,2 @@
 export { definePlugin } from "./contracts.mjs";
-export type { EvalPluginFragment, EvalPluginContext, ExperimentPluginFragment, ExperimentPluginContext, GroupPluginContext, GroupPluginFragment, PluginDefinition, PluginInstance, PluginLifecycleFragment, PluginOnUnavailable, PluginOwner, PluginScope, SandboxPluginFragment, } from "./contracts.mjs";
+export type { AttemptPluginFragment, AttemptPluginContext, ExperimentPluginFragment, ExperimentPluginContext, GroupPluginContext, GroupPluginFragment, PluginDefinition, PluginAgentExtensions, PluginInstance, PluginLifecycleFragment, PluginOnUnavailable, PluginOwner, PluginScope, SandboxPluginFragment, } from "./contracts.mjs";

package/dist/plugin/index.d.ts

@@ -1,2 +1,2 @@
 export { definePlugin } from "./contracts.js";
-export type { EvalPluginFragment, EvalPluginContext, ExperimentPluginFragment, ExperimentPluginContext, GroupPluginContext, GroupPluginFragment, PluginDefinition, PluginInstance, PluginLifecycleFragment, PluginOnUnavailable, PluginOwner, PluginScope, SandboxPluginFragment, } from "./contracts.js";
+export type { AttemptPluginFragment, AttemptPluginContext, ExperimentPluginFragment, ExperimentPluginContext, GroupPluginContext, GroupPluginFragment, PluginDefinition, PluginAgentExtensions, PluginInstance, PluginLifecycleFragment, PluginOnUnavailable, PluginOwner, PluginScope, SandboxPluginFragment, } from "./contracts.js";

package/dist/plugin/link.cjs

@@ -5,10 +5,13 @@ exports.pluginLinkErrorFromIssues = pluginLinkErrorFromIssues;
 exports.preparePluginRun = preparePluginRun;
 exports.linkPluginPair = linkPluginPair;
 exports.pluginBehaviorProjection = pluginBehaviorProjection;
-// @concord-file ne-surface-plugin-link
+exports.groupPluginLifecycles = groupPluginLifecycles;
+exports.attemptPluginLifecycles = attemptPluginLifecycles;
+// @concord-file
 // @concord-implements docs/feature/plugins/lifecycle.md
 // @concord-implements docs/feature/plugins/use-case/terminal-bench-harness.md
 const effect_1 = require("effect");
+const plugin_extensions_ts_1 = require("../agents/plugin-extensions.cjs");
 const node_path_1 = require("node:path");
 const layer_ts_1 = require("../sandbox/layer.cjs");
 const link_ts_1 = require("../sandbox/link.cjs");
@@ -39,44 +42,11 @@ function sandboxDeclaration(lifecycle) {
         });
 }
 function pluginLifecycleAttachmentIdentity(lifecycle) {
-    const sandbox = sandboxDeclaration(lifecycle);
-    if (sandbox === undefined)
-        return (0, contracts_ts_1.pluginLifecycleIdentity)(lifecycle);
-    return Object.freeze({
-        scope: lifecycle.scope,
-        name: lifecycle.name,
-        behaviorRevision: lifecycle.behaviorRevision,
-        instanceKey: lifecycle.instanceKey,
-        identity: lifecycle.identity,
-        arrayPosition: lifecycle.arrayPosition,
-        hasSetup: lifecycle.hasSetup,
-        hasTeardown: lifecycle.hasTeardown,
-        sandbox,
-    });
-}
-function pluginOccurrenceProjection(lifecycle) {
-    const sandbox = sandboxDeclaration(lifecycle);
-    return Object.freeze({
-        // Keep the established occurrence field order for attachments without a
-        // sandbox fragment; some persisted projections are byte-sensitive.
-        scope: lifecycle.scope,
-        name: lifecycle.name,
-        instanceKey: lifecycle.instanceKey,
-        behaviorRevision: lifecycle.behaviorRevision,
-        identity: lifecycle.identity,
-        arrayPosition: lifecycle.arrayPosition,
-        hasSetup: lifecycle.hasSetup,
-        hasTeardown: lifecycle.hasTeardown,
-        ...(sandbox === undefined ? {} : { sandbox }),
-    });
+    return { ...(0, contracts_ts_1.pluginLifecycleIdentity)(lifecycle), ...(sandboxDeclaration(lifecycle) === undefined ? {} : { sandbox: sandboxDeclaration(lifecycle) }) };
 }
+function pluginOccurrenceProjection(lifecycle) { return pluginLifecycleAttachmentIdentity(lifecycle); }
 function pluginAttachmentProjection(lifecycles) {
-    if (lifecycles.every((lifecycle) => lifecycle.sandboxLayer === undefined)) {
-        return (0, contracts_ts_1.pluginLifecycleProjection)(lifecycles);
-    }
-    const projection = lifecycles.map(pluginLifecycleAttachmentIdentity);
-    Object.freeze(projection);
-    return projection;
+    return lifecycles.map(pluginLifecycleAttachmentIdentity);
 }
 function occurrences(lifecycles, scope, ownerId, sourcePath) {
     return Object.freeze(lifecycles.map((lifecycle) => {
@@ -92,16 +62,16 @@ function occurrences(lifecycles, scope, ownerId, sourcePath) {
         ];
         return Object.freeze({
             name: lifecycle.name,
-            instanceKey: lifecycle.instanceKey,
-            behaviorRevision: lifecycle.behaviorRevision,
+            key: lifecycle.key,
             provenance,
             projection,
             audit: Object.freeze({
                 scope,
                 name: lifecycle.name,
-                instanceKey: lifecycle.instanceKey,
-                behaviorRevision: lifecycle.behaviorRevision,
+                key: lifecycle.key,
                 identity: lifecycle.identity,
+                requires: lifecycle.requires,
+                shape: lifecycle.shape,
                 arrayPosition: lifecycle.arrayPosition,
                 hasSetup: lifecycle.hasSetup,
                 hasTeardown: lifecycle.hasTeardown,
@@ -124,7 +94,6 @@ function appendPluginSandboxLayers(base, lifecycles) {
     return layer;
 }
 async function runTeardowns(lifecycles, activated, context) {
-    const failures = [];
     for (const lifecycle of lifecycles.slice(0, activated).reverse()) {
         if (lifecycle.teardown === undefined)
             continue;
@@ -132,32 +101,42 @@ async function runTeardowns(lifecycles, activated, context) {
             await lifecycle.teardown(context);
         }
         catch (error) {
-            failures.push(error);
+            context.diagnostic({ code: "plugin-after-failed", level: "warning", message: String(error) });
         }
     }
-    if (failures.length === 1)
-        throw failures[0];
-    if (failures.length > 1)
-        throw new AggregateError(failures, "Experiment Plugin teardown failed.");
 }
-// @concord-code ne-surface-prepare-plugin-run
+// @concord-code
 // @concord-implements docs/feature/plugins/lifecycle.md
 function preparePluginRun(run) {
     let lifecycles;
     try {
-        lifecycles = (0, contracts_ts_1.linkPluginLifecycles)(run.plugins, "experiment");
-        if (run.adapter.kind === "custom" && lifecycles.length > 0) {
-            throw new TypeError("Custom Adapter runs do not yet support Experiment lifecycle plugins.");
-        }
+        lifecycles = (0, contracts_ts_1.linkPluginLifecycles)(run.plugins ?? [], "experiment");
     }
     catch (error) {
         throw pluginError([{ code: "plugin-owner-unsupported", experimentId: run.experimentId, message: String(error), actions: ["Attach each plugin only to a scope it declares."] }]);
     }
+    const contributions = (run.plugins ?? []).flatMap((plugin, position) => {
+        const data = (0, contracts_ts_1.pluginInstanceDataOf)(plugin);
+        return data.agent === undefined ? [] : [{ extension: data.agent, source: `${run.experimentSourcePath}:plugins[${position}] ${data.name} (${data.key})` }];
+    });
+    let adapter = run.adapter;
+    if (contributions.length > 0) {
+        if (adapter.kind === "custom")
+            throw pluginError([{ code: "plugin-owner-unsupported", experimentId: run.experimentId,
+                    message: "Custom Adapters do not support Plugin agent extensions.", actions: ["Use a built-in coding Agent for agent extensions."] }]);
+        try {
+            adapter = (0, plugin_extensions_ts_1.extendCodingAgent)(adapter, contributions);
+        }
+        catch (error) {
+            throw pluginError([{ code: "plugin-owner-unsupported", experimentId: run.experimentId,
+                    message: String(error), actions: ["Resolve Agent extension conflicts at the reported declarations."] }]);
+        }
+    }
     const linkedOccurrences = occurrences(lifecycles, "experiment", run.experimentId, run.experimentSourcePath);
     const authorSetup = run.setup;
     const authorTeardown = run.teardown;
     let activated = 0;
-    const setup = authorSetup === undefined && lifecycles.every((entry) => entry.setup === undefined)
+    const setup = authorSetup === undefined && lifecycles.every((entry) => !entry.hostDeclared)
         ? undefined
         : async (context) => {
             if (authorSetup !== undefined)
@@ -191,34 +170,46 @@ function preparePluginRun(run) {
                 throw pluginFailure;
         };
     const pluginBehavior = Object.freeze({ version: 1, lifecycles: pluginAttachmentProjection(lifecycles) });
-    const effective = Object.freeze({ ...run, ...(setup === undefined ? {} : { setup }), ...(teardown === undefined ? {} : { teardown }), pluginBehavior });
+    const effective = Object.freeze({ ...run, adapter, ...(adapter.kind === "custom" ? {} : { agent: adapter }), ...(setup === undefined ? {} : { setup }), ...(teardown === undefined ? {} : { teardown }), pluginBehavior });
     return Object.freeze({ sourceRun: run, run: effective, experimentOccurrences: linkedOccurrences, experimentLifecycles: lifecycles });
 }
-// @concord-code ne-surface-link-plugin-pair
+// @concord-code
 // @concord-implements docs/feature/plugins/lifecycle.md
 function linkPluginPair(evalDef, preparedRun) {
     try {
-        const evalLifecycles = (0, contracts_ts_1.linkPluginLifecycles)(evalDef.plugins, "eval");
-        const groupLifecycles = evalDef.evalGroup === undefined
+        const ownEvalLifecycles = (0, contracts_ts_1.linkPluginLifecycles)(evalDef.plugins, "eval");
+        const ownGroupLifecycles = evalDef.evalGroup === undefined
             ? Object.freeze([])
             : (0, contracts_ts_1.linkPluginLifecycles)(evalDef.evalGroup.plugins ?? [], "group");
-        const allLifecycles = [...preparedRun.experimentLifecycles, ...groupLifecycles, ...evalLifecycles];
-        if (preparedRun.run.adapter.kind === "custom" && allLifecycles.length > 0) {
-            throw new TypeError("Custom Adapter runs do not yet support Experiment, Group, or Eval lifecycle plugins.");
+        const allLifecycles = [...preparedRun.experimentLifecycles, ...ownGroupLifecycles, ...ownEvalLifecycles];
+        const seen = new Map();
+        for (const lifecycle of allLifecycles) {
+            if (lifecycle.requires.evalGroup && evalDef.evalGroup === undefined) {
+                throw pluginError([{ code: "plugin-requires-eval-group", experimentId: preparedRun.run.experimentId, evalId: evalDef.id,
+                        message: `Plugin ${lifecycle.name} (${lifecycle.key}) requires an Eval Group: ${evalDef.id}.`, actions: ["Group every selected Eval in this Plugin's scope."] }]);
+            }
+            const id = JSON.stringify([lifecycle.name, lifecycle.key]);
+            const previous = seen.get(id);
+            if (previous !== undefined)
+                throw pluginError([{ code: "plugin-pair-instance-conflict", experimentId: preparedRun.run.experimentId, evalId: evalDef.id,
+                        message: `Duplicate Plugin (${lifecycle.name}, ${lifecycle.key}) at ${previous.scope}.plugins[${previous.arrayPosition}] and ${lifecycle.scope}.plugins[${lifecycle.arrayPosition}].`, actions: ["Use a distinct key for each condition in one Attempt."] }]);
+            seen.set(id, lifecycle);
         }
+        const groupLifecycles = groupPluginLifecycles(evalDef, preparedRun.run);
+        const evalLifecycles = attemptPluginLifecycles(evalDef, preparedRun.run);
         if (preparedRun.run.adapter.kind !== "sandbox" && allLifecycles.some((entry) => entry.sandboxLayer !== undefined)) {
             throw new TypeError("Plugin sandbox layer requires a Sandbox Agent and a physical Sandbox plan.");
         }
-        const evalOccurrences = occurrences(evalLifecycles, "eval", evalDef.id, evalDef.sourcePath);
+        const evalOccurrences = occurrences(ownEvalLifecycles, "eval", evalDef.id, evalDef.sourcePath);
         const groupOccurrences = evalDef.evalGroup === undefined
             ? Object.freeze([])
-            : occurrences(groupLifecycles, "group", evalDef.evalGroup.id, evalDef.evalGroup.sourcePath);
+            : occurrences(ownGroupLifecycles, "group", evalDef.evalGroup.id, evalDef.evalGroup.sourcePath);
         const all = Object.freeze([...preparedRun.experimentOccurrences, ...groupOccurrences, ...evalOccurrences]);
         const experimentLayer = appendPluginSandboxLayers(preparedRun.run.sandbox, preparedRun.experimentLifecycles);
         const groupLayer = evalDef.evalGroup === undefined
             ? undefined
-            : appendPluginSandboxLayers(evalDef.evalGroup.sandbox, groupLifecycles);
-        const evalLayer = appendPluginSandboxLayers(evalDef.sandbox, evalLifecycles);
+            : appendPluginSandboxLayers(evalDef.evalGroup.sandbox, ownGroupLifecycles);
+        const evalLayer = appendPluginSandboxLayers(evalDef.sandbox, ownEvalLifecycles);
         const noSandboxLifecycles = Object.freeze({
             experiment: Object.freeze([]),
             group: Object.freeze([]),
@@ -244,6 +235,8 @@ function linkPluginPair(evalDef, preparedRun) {
         });
     }
     catch (error) {
+        if (error instanceof PluginLinkError)
+            throw error;
         throw pluginError([{ code: "plugin-owner-unsupported", experimentId: preparedRun.run.experimentId, evalId: evalDef.id, message: String(error), actions: ["Attach each plugin only to a scope it declares, without duplicates in one scope."] }]);
     }
 }
@@ -254,4 +247,16 @@ function pluginBehaviorProjection(run) {
     Object.freeze(empty);
     return empty;
 }
+/** Expand host timing independently from the attachment owner. */
+function groupPluginLifecycles(evalDef, run) {
+    if (evalDef.evalGroup === undefined)
+        return [];
+    return [...(0, contracts_ts_1.linkPluginLifecycles)(run.plugins ?? [], "experiment", "group"),
+        ...(0, contracts_ts_1.linkPluginLifecycles)(evalDef.evalGroup.plugins ?? [], "group", "group")];
+}
+function attemptPluginLifecycles(evalDef, run) {
+    return [...(0, contracts_ts_1.linkPluginLifecycles)(run.plugins ?? [], "experiment", "attempt"),
+        ...(0, contracts_ts_1.linkPluginLifecycles)(evalDef.evalGroup?.plugins ?? [], "group", "attempt"),
+        ...(0, contracts_ts_1.linkPluginLifecycles)(evalDef.plugins, "eval", "attempt")];
+}
 //# sourceMappingURL=link.cjs.map