@tangle-network/agent-interface 2.20.1 → 3.1.0

package/dist/profile-diff.js

@@ -4,6 +4,7 @@ const agentProfileDiffPropertyAxes = [
     "prompt",
     "model",
     "harness",
+    "seats",
     "permissions",
     "tools",
     "mcp",
@@ -252,6 +253,8 @@ function applyRemoval(profile, remove) {
     }
     if (remove.harness !== undefined)
         delete next.harness;
+    if (remove.seats !== undefined)
+        delete next.seats;
     if (remove.permissions !== undefined) {
         setOrDelete(next, "permissions", removeKeys(next.permissions, remove.permissions));
     }
@@ -335,34 +338,3 @@ export function changedAgentProfileAxes(diff) {
     }
     return [...axes].sort();
 }
-export function pruneAgentProfileDiff(diff, axesToRemove) {
-    const removeSet = new Set(axesToRemove);
-    const set = diff.set ? { ...diff.set } : undefined;
-    const remove = diff.remove ? { ...diff.remove } : undefined;
-    if (removeSet.has("identity") && set) {
-        delete set.name;
-        delete set.description;
-        delete set.version;
-        delete set.tags;
-    }
-    if (removeSet.has("identity") && remove) {
-        delete remove.identity;
-        delete remove.tags;
-    }
-    for (const axis of agentProfileDiffPropertyAxes) {
-        if (!removeSet.has(axis))
-            continue;
-        if (set)
-            delete set[axis];
-        if (remove)
-            delete remove[axis];
-    }
-    const pruned = { ...diff };
-    setOrDelete(pruned, "set", set && Object.values(set).some((value) => value !== undefined)
-        ? set
-        : undefined);
-    setOrDelete(pruned, "remove", remove && Object.values(remove).some((value) => value !== undefined)
-        ? remove
-        : undefined);
-    return pruned;
-}

package/dist/profile-kb/index.d.ts

@@ -6,12 +6,11 @@
  * The data is plain, dated, and sourced. Composition is pure: the same profile
  * yields the same composed profile, so profile identity stays deterministic.
  */
-import { composeAgentProfileGuidance, type AgentProfile, type AgentProfileGuidanceBlock } from "../agent-profile.js";
+import { composeAgentProfileGuidance, type AgentProfile } from "../agent-profile.js";
 import type { HarnessType } from "../harness.js";
 import { profileKbHarnesses } from "./harnesses.js";
 import { profileKbModels } from "./models.js";
 import { profileKbDiscrepancies, profileKbLearnings } from "./records.js";
-import type { ProfileKbHarness, ProfileKbModel } from "./types.js";
 export type * from "./types.js";
 export type { AgentProfileGuidanceBlock, AgentProfileGuidanceChannel, AgentProfileGuidanceOptions, } from "../agent-profile.js";
 export { composeAgentProfileGuidance, profileKbDiscrepancies, profileKbHarnesses, profileKbLearnings, profileKbModels, };
@@ -20,31 +19,11 @@ export { composeAgentProfileGuidance, profileKbDiscrepancies, profileKbHarnesses
  * replaces blocks from these sources and keeps blocks any other layer added.
  */
 export declare const PROFILE_KB_SOURCES: readonly ["harness", "model", "learning"];
-/** Date of the latest source audit; individual historical observations retain their own dates. */
-export declare const PROFILE_KB_CHECKED_AT = "2026-10-04";
-/** Find a harness entry by its {@link HarnessType}. */
-export declare function findProfileKbHarness(harness: HarnessType | string | undefined): ProfileKbHarness | undefined;
-/**
- * Find a model entry by id or alias.
- *
- * Accepts the spellings harnesses and routers use: a provider prefix
- * (`anthropic/claude-opus-5-5`), a route prefix
- * (`pi/tangle-router/deepseek/deepseek-v4.1-flash`), and a trailing `:suffix`
- * such as pi's thinking level or a router's `:batch`. A different version is a
- * different model and never matches.
- */
-export declare function findProfileKbModel(model: string | undefined): ProfileKbModel | undefined;
 /** Which harness and model to compose guidance for. */
 export interface ProfileKbSelection {
     harness?: HarnessType | string;
     model?: string;
 }
-/**
- * The guidance blocks for one harness and model: the harness's, then the
- * model's, then any reproduced platform learnings for either. Unknown names
- * contribute nothing.
- */
-export declare function profileKbGuidance(selection: ProfileKbSelection): AgentProfileGuidanceBlock[];
 /**
  * Compose harness, model, and profile guidance into the profile's prompt.
  *

package/dist/profile-kb/index.js

@@ -18,14 +18,6 @@ export { composeAgentProfileGuidance, profileKbDiscrepancies, profileKbHarnesses
  * replaces blocks from these sources and keeps blocks any other layer added.
  */
 export const PROFILE_KB_SOURCES = ["harness", "model", "learning"];
-/** Date of the latest source audit; individual historical observations retain their own dates. */
-export const PROFILE_KB_CHECKED_AT = "2026-10-04";
-/** Find a harness entry by its {@link HarnessType}. */
-export function findProfileKbHarness(harness) {
-    if (!harness)
-        return undefined;
-    return profileKbHarnesses.find((entry) => entry.id === harness);
-}
 /*
  * Composition reads a frozen snapshot taken at load, never the exported
  * records. A consumer that edits an exported entry therefore cannot change
@@ -51,20 +43,6 @@ const modelIndex = (() => {
     });
     return index;
 })();
-/**
- * Find a model entry by id or alias.
- *
- * Accepts the spellings harnesses and routers use: a provider prefix
- * (`anthropic/claude-opus-5-5`), a route prefix
- * (`pi/tangle-router/deepseek/deepseek-v4.1-flash`), and a trailing `:suffix`
- * such as pi's thinking level or a router's `:batch`. A different version is a
- * different model and never matches.
- */
-export function findProfileKbModel(model) {
-    // Public lookups search the exported records as they are now; composition
-    // alone reads the frozen snapshot, so neither can desynchronize the other.
-    return matchModelName(model, (candidate) => profileKbModels.find((entry) => [entry.id, ...entry.aliases].some((name) => name.toLowerCase() === candidate)));
-}
 /**
  * Try the name as given, then without each leading `provider/` or route
  * segment, after dropping a trailing `:suffix`.
@@ -108,7 +86,7 @@ function bullets(lines) {
  * model's, then any reproduced platform learnings for either. Unknown names
  * contribute nothing.
  */
-export function profileKbGuidance(selection) {
+function profileKbGuidance(selection) {
     const harness = selection.harness
         ? harnessSnapshot[harnessPosition(selection.harness)]
         : undefined;

package/dist/profile-schema.d.ts

@@ -166,6 +166,35 @@ export declare const agentProfileModelHintsSchema: z.ZodObject<{
     maxTotalOutputTokens: z.ZodOptional<z.ZodNumber>;
     metadata: z.ZodOptional<z.ZodType<Record<string, unknown>, unknown, z.core.$ZodTypeInternals<Record<string, unknown>, unknown>>>;
 }, z.core.$strict>;
+/** Ordered account selection policy, without credentials or ambient model defaults. */
+export declare const agentProfileSeatSchema: z.ZodObject<{
+    harness: z.ZodEnum<{
+        acp: "acp";
+        amp: "amp";
+        "claude-code": "claude-code";
+        "cli-base": "cli-base";
+        codex: "codex";
+        cursor: "cursor";
+        "factory-droids": "factory-droids";
+        forge: "forge";
+        gemini: "gemini";
+        hermes: "hermes";
+        "kimi-code": "kimi-code";
+        nanoclaw: "nanoclaw";
+        openclaw: "openclaw";
+        opencode: "opencode";
+        pi: "pi";
+        prime: "prime";
+    }>;
+    provider: z.ZodString;
+    model: z.ZodString;
+    selector: z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"all-eligible">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"seat">;
+        id: z.ZodString;
+    }, z.core.$strict>]>;
+}, z.core.$strict>;
 /**
  * Replacement and addition are separate, independently optional fields, and the
  * pair is admitted on purpose: the effective prompt is `systemPrompt` followed
@@ -306,6 +335,7 @@ export declare const agentProfileDiffRemovalSchema: z.ZodObject<{
     }, z.core.$strict>]>>;
     model: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodArray<z.ZodString>]>>;
     harness: z.ZodOptional<z.ZodLiteral<true>>;
+    seats: z.ZodOptional<z.ZodLiteral<true>>;
     permissions: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodArray<z.ZodString>]>>;
     tools: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodArray<z.ZodString>]>>;
     mcp: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodArray<z.ZodString>]>>;
@@ -487,6 +517,34 @@ export declare const agentProfileSchema: z.ZodObject<{
         pi: "pi";
         prime: "prime";
     }>>;
+    seats: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        harness: z.ZodEnum<{
+            acp: "acp";
+            amp: "amp";
+            "claude-code": "claude-code";
+            "cli-base": "cli-base";
+            codex: "codex";
+            cursor: "cursor";
+            "factory-droids": "factory-droids";
+            forge: "forge";
+            gemini: "gemini";
+            hermes: "hermes";
+            "kimi-code": "kimi-code";
+            nanoclaw: "nanoclaw";
+            openclaw: "openclaw";
+            opencode: "opencode";
+            pi: "pi";
+            prime: "prime";
+        }>;
+        provider: z.ZodString;
+        model: z.ZodString;
+        selector: z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"all-eligible">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"seat">;
+            id: z.ZodString;
+        }, z.core.$strict>]>;
+    }, z.core.$strict>>>;
     permissions: z.ZodOptional<z.ZodType<Record<string, "allow" | "ask" | "deny" | Record<string, "allow" | "ask" | "deny">>, unknown, z.core.$ZodTypeInternals<Record<string, "allow" | "ask" | "deny" | Record<string, "allow" | "ask" | "deny">>, unknown>>>;
     tools: z.ZodOptional<z.ZodType<Record<string, boolean>, unknown, z.core.$ZodTypeInternals<Record<string, boolean>, unknown>>>;
     mcp: z.ZodOptional<z.ZodType<Record<string, AgentProfileMcpServer>, unknown, z.core.$ZodTypeInternals<Record<string, AgentProfileMcpServer>, unknown>>>;

package/dist/profile-schema.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { REASONING_EFFORTS, TRAINED_MODEL_PREFIX, trainedModelIdForArtifact, } from "./agent-profile.js";
 import { canonicalCandidateDigest, sha256DigestSchema, environmentNameSchema, headerNameSchema, isSafeExecutable, isSafeRelativePath, isWellFormedUnicode, looksLikeCredential, } from "./agent-candidate-schema-common.js";
 import { harnessTypeSchema } from "./harness.js";
+import { harnessHonorsEffort, harnessHonorsModel, harnessModelSupport, harnessReasoningEfforts, harnessSystemPromptIntents, resolveModelProvider, } from "./harness-capabilities.js";
 import { SANDBOX_SIZE_PRESET_NAMES, } from "./sandbox-size.js";
 /**
  * Zod records currently assign parsed values onto an ordinary object. The
@@ -130,6 +131,16 @@ export const agentProfileModelHintsBaseSchema = z.strictObject({
     metadata: ownPropertyRecordSchema(z.unknown()).optional(),
 });
 export const agentProfileModelHintsSchema = agentProfileModelHintsBaseSchema.superRefine(enforceModelTokenBounds);
+/** Ordered account selection policy, without credentials or ambient model defaults. */
+export const agentProfileSeatSchema = z.strictObject({
+    harness: harnessTypeSchema,
+    provider: z.string().regex(/^[a-z][a-z0-9-]*$/),
+    model: z.string().min(1).refine((value) => value.trim() === value, "model must be canonical"),
+    selector: z.union([
+        z.strictObject({ kind: z.literal("all-eligible") }),
+        z.strictObject({ kind: z.literal("seat"), id: z.string().min(1).refine((value) => value.trim() === value, "seat id must be canonical") }),
+    ]),
+});
 /**
  * Replacement and addition are separate, independently optional fields, and the
  * pair is admitted on purpose: the effective prompt is `systemPrompt` followed
@@ -308,6 +319,7 @@ export const agentProfileDiffRemovalSchema = z.strictObject({
         .optional(),
     model: removeListSchema.optional(),
     harness: z.literal(true).optional(),
+    seats: z.literal(true).optional(),
     permissions: removeListSchema.optional(),
     tools: removeListSchema.optional(),
     mcp: removeListSchema.optional(),
@@ -418,6 +430,7 @@ export const agentProfileSchema = z
     prompt: agentProfilePromptSchema.optional(),
     model: agentProfileModelHintsSchema.optional(),
     harness: harnessTypeSchema.optional(),
+    seats: z.array(agentProfileSeatSchema).nonempty().optional(),
     permissions: ownPropertyRecordSchema(agentProfilePermissionSchema).optional(),
     tools: ownPropertyRecordSchema(z.boolean()).optional(),
     mcp: ownPropertyRecordSchema(agentProfileMcpServerSchema).optional(),
@@ -432,6 +445,38 @@ export const agentProfileSchema = z
 })
     .superRefine((profile, context) => {
     validateNestedRecordKeys(profile, context, [], new Set());
+    if (profile.seats?.length) {
+        const first = profile.seats[0];
+        if (first.harness !== profile.harness || first.provider !== profile.model?.provider ||
+            first.model !== profile.model?.default) {
+            context.addIssue({ code: "custom", path: ["seats", 0], message: "first seat must match profile harness, model.provider, and model.default" });
+        }
+        for (const [index, seat] of profile.seats.entries()) {
+            const provider = resolveModelProvider(seat.model);
+            if (provider !== seat.provider) {
+                context.addIssue({ code: "custom", path: ["seats", index, "provider"], message: "seat provider must match the model provider" });
+            }
+            if (!harnessHonorsModel(seat.harness)) {
+                context.addIssue({ code: "custom", path: ["seats", index, "harness"], message: "seat harness does not honor an exact model choice" });
+            }
+            const support = harnessModelSupport(seat.harness, seat.model, { reasoningEffort: profile.model?.reasoningEffort });
+            if (!support.supported) {
+                context.addIssue({ code: "custom", path: ["seats", index, "model"], message: support.message });
+            }
+            const effort = profile.model?.reasoningEffort;
+            if (effort !== undefined && (!harnessHonorsEffort(seat.harness) ||
+                !harnessReasoningEfforts(seat.harness).includes(effort))) {
+                context.addIssue({ code: "custom", path: ["seats", index, "harness"], message: "seat harness cannot honor profile reasoning effort" });
+            }
+            const prompt = harnessSystemPromptIntents(seat.harness);
+            if (profile.prompt?.systemPrompt !== undefined && !prompt.replace) {
+                context.addIssue({ code: "custom", path: ["seats", index, "harness"], message: "seat harness cannot replace the system prompt" });
+            }
+            if (profile.prompt?.appendSystemPrompt !== undefined && !prompt.append) {
+                context.addIssue({ code: "custom", path: ["seats", index, "harness"], message: "seat harness cannot append the system prompt" });
+            }
+        }
+    }
     const training = agentProfileTrainingSchema.safeParse(profile.metadata?.training);
     if (profile.model?.default?.startsWith(TRAINED_MODEL_PREFIX) && !training.success) {
         context.addIssue({ code: "custom", path: ["metadata", "training"], message: "trained model requires a checkpoint receipt" });

package/dist/runtime-control.d.ts

@@ -103,67 +103,6 @@ export declare const AgentRunCancellationAcknowledgementSchema: z.ZodObject<{
     existingRequestDigest: z.ZodOptional<z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>>;
 }, z.core.$strict>;
 export declare function agentRunCancellationAcknowledgementMatchesRequest(request: AgentRunCancellationRequest, acknowledgement: AgentRunCancellationAcknowledgement): boolean;
-export type AgentRunControlAction = "steer" | "cancel" | "status" | "reconnect";
-export interface AgentRunControlRequestMaterial {
-    operationId: string;
-    action: AgentRunControlAction;
-    run: AgentExactRunControlRef;
-    payload?: Record<string, unknown>;
-}
-export interface AgentRunControlRequest extends AgentRunControlRequestMaterial {
-    requestDigest: Sha256Digest;
-}
-export declare function agentRunControlRequestDigest(request: AgentRunControlRequestMaterial): Sha256Digest;
-export declare const AgentRunControlRequestSchema: z.ZodObject<{
-    operationId: z.ZodString;
-    action: z.ZodEnum<{
-        cancel: "cancel";
-        reconnect: "reconnect";
-        status: "status";
-        steer: "steer";
-    }>;
-    run: z.ZodObject<{
-        runId: z.ZodString;
-        provider: z.ZodString;
-        environmentId: z.ZodString;
-        sessionId: z.ZodString;
-        executionId: z.ZodString;
-        requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
-    }, z.core.$strict>;
-    payload: z.ZodOptional<z.ZodCustom<Record<string, unknown>, Record<string, unknown>>>;
-    requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
-}, z.core.$strict>;
-export interface AgentRunControlAcknowledgement {
-    operationId: string;
-    requestDigest: Sha256Digest;
-    run: AgentExactRunControlRef;
-    status: "accepted" | "replayed" | "conflict" | "unknown";
-    message?: string;
-    retryable?: boolean;
-    existingRequestDigest?: Sha256Digest;
-}
-export declare const AgentRunControlAcknowledgementSchema: z.ZodObject<{
-    operationId: z.ZodString;
-    requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
-    run: z.ZodObject<{
-        runId: z.ZodString;
-        provider: z.ZodString;
-        environmentId: z.ZodString;
-        sessionId: z.ZodString;
-        executionId: z.ZodString;
-        requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
-    }, z.core.$strict>;
-    status: z.ZodEnum<{
-        accepted: "accepted";
-        conflict: "conflict";
-        replayed: "replayed";
-        unknown: "unknown";
-    }>;
-    message: z.ZodOptional<z.ZodString>;
-    retryable: z.ZodOptional<z.ZodBoolean>;
-    existingRequestDigest: z.ZodOptional<z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>>;
-}, z.core.$strict>;
-export declare function agentRunControlAcknowledgementMatchesRequest(request: AgentRunControlRequest, acknowledgement: AgentRunControlAcknowledgement): boolean;
 export declare const CanonicalStreamEventSchema: z.ZodType<StreamEvent>;
 /** Ordered, replayable envelope around the existing canonical event union. */
 export interface RuntimeEventEnvelope {

package/dist/runtime-control.js

@@ -125,82 +125,6 @@ export function agentRunCancellationAcknowledgementMatchesRequest(request, ackno
         exactAcknowledgement.data.requestDigest === exactRequest.data.requestDigest &&
         sameAgentRunControlRef(exactAcknowledgement.data.run, exactRequest.data.run));
 }
-export function agentRunControlRequestDigest(request) {
-    const parsed = AgentRunControlRequestMaterialSchema.parse(request);
-    return canonicalCandidateDigest({
-        operationId: parsed.operationId,
-        action: parsed.action,
-        run: parsed.run,
-        ...(parsed.payload === undefined ? {} : { payload: parsed.payload }),
-    });
-}
-const AgentRunControlRequestMaterialSchema = z.strictObject({
-    operationId: stableIdSchema,
-    action: z.enum(["steer", "cancel", "status", "reconnect"]),
-    run: AgentExactRunControlRefSchema,
-    payload: boundedJsonRecordSchema.optional(),
-});
-export const AgentRunControlRequestSchema = z
-    .strictObject({
-    ...AgentRunControlRequestMaterialSchema.shape,
-    requestDigest: sha256DigestSchema,
-})
-    .superRefine((request, refinement) => {
-    const { requestDigest: _requestDigest, ...material } = request;
-    if (request.requestDigest !== agentRunControlRequestDigest(material)) {
-        refinement.addIssue({
-            code: "custom",
-            path: ["requestDigest"],
-            message: "run control request digest does not match its content",
-        });
-    }
-});
-export const AgentRunControlAcknowledgementSchema = z
-    .strictObject({
-    operationId: stableIdSchema,
-    requestDigest: sha256DigestSchema,
-    run: AgentExactRunControlRefSchema,
-    status: z.enum(["accepted", "replayed", "conflict", "unknown"]),
-    message: boundedStringSchema.min(1).optional(),
-    retryable: z.boolean().optional(),
-    existingRequestDigest: sha256DigestSchema.optional(),
-})
-    .superRefine((acknowledgement, refinement) => {
-    if (acknowledgement.status === "conflict" &&
-        (acknowledgement.existingRequestDigest === undefined ||
-            acknowledgement.existingRequestDigest === acknowledgement.requestDigest)) {
-        refinement.addIssue({
-            code: "custom",
-            path: ["existingRequestDigest"],
-            message: "a control conflict must identify a different existing request",
-        });
-    }
-    if (acknowledgement.status !== "conflict" &&
-        acknowledgement.existingRequestDigest !== undefined) {
-        refinement.addIssue({
-            code: "custom",
-            path: ["existingRequestDigest"],
-            message: "only a control conflict may include an existing digest",
-        });
-    }
-    if (acknowledgement.status === "unknown" &&
-        (acknowledgement.message === undefined || acknowledgement.retryable !== false)) {
-        refinement.addIssue({
-            code: "custom",
-            path: ["retryable"],
-            message: "an unknown control outcome must be explicit and non-repeatable",
-        });
-    }
-});
-export function agentRunControlAcknowledgementMatchesRequest(request, acknowledgement) {
-    const exactRequest = AgentRunControlRequestSchema.safeParse(request);
-    const exactAcknowledgement = AgentRunControlAcknowledgementSchema.safeParse(acknowledgement);
-    if (!exactRequest.success || !exactAcknowledgement.success)
-        return false;
-    return (exactAcknowledgement.data.operationId === exactRequest.data.operationId &&
-        exactAcknowledgement.data.requestDigest === exactRequest.data.requestDigest &&
-        sameAgentRunControlRef(exactAcknowledgement.data.run, exactRequest.data.run));
-}
 const unknownRecordSchema = boundedJsonRecordSchema;
 const partBase = {
     id: stableIdSchema,

package/dist/workspace-confidentiality.d.ts

@@ -41,8 +41,6 @@ export declare const ConfidentialExecutionRequestSchema: z.ZodObject<{
     profileDigest: z.ZodOptional<z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>>;
 }, z.core.$strict>;
 export type ConfidentialExecutionRequest = z.infer<typeof ConfidentialExecutionRequestSchema>;
-/** Match one requested TEE against a provider-reported TEE identifier. */
-export declare function confidentialTeeMatchesRequest(requested: string | undefined, attested: string | undefined): boolean;
 export interface ConfidentialExecutionEnvironment {
     provider: string;
     environmentId: string;

package/dist/workspace-confidentiality.js

@@ -101,7 +101,7 @@ function normalizedTeeId(value) {
     }
 }
 /** Match one requested TEE against a provider-reported TEE identifier. */
-export function confidentialTeeMatchesRequest(requested, attested) {
+function confidentialTeeMatchesRequest(requested, attested) {
     if (attested === undefined)
         return requested === undefined;
     const normalizedAttested = normalizedTeeId(attested);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-interface",
-  "version": "2.20.1",
+  "version": "3.1.0",
   "type": "module",
   "sideEffects": false,
   "license": "MIT",
@@ -17,11 +17,6 @@
       "types": "./dist/environment-provider.d.ts",
       "default": "./dist/environment-provider.js"
     },
-    "./environment-interactive": {
-      "import": "./dist/environment-interactive.js",
-      "types": "./dist/environment-interactive.d.ts",
-      "default": "./dist/environment-interactive.js"
-    },
     "./environment-interactive-control": {
       "import": "./dist/environment-interactive-control.js",
       "types": "./dist/environment-interactive-control.d.ts",
@@ -32,11 +27,6 @@
       "types": "./dist/agent-profile.d.ts",
       "default": "./dist/agent-profile.js"
     },
-    "./agent-instance": {
-      "import": "./dist/agent-instance.js",
-      "types": "./dist/agent-instance.d.ts",
-      "default": "./dist/agent-instance.js"
-    },
     "./profile-snapshot": {
       "import": "./dist/agent-profile-snapshot.js",
       "types": "./dist/agent-profile-snapshot.d.ts",

package/dist/agent-instance.d.ts

@@ -1,98 +0,0 @@
-import { z } from "zod";
-import type { Sha256Digest } from "./agent-candidate.js";
-import type { AgentProfile } from "./agent-profile.js";
-import type { HarnessType } from "./harness.js";
-/** Lifecycle state of one managed Agent inside an execution environment. */
-export declare const AGENT_INSTANCE_STATUSES: readonly ["starting", "ready", "busy", "failed", "stopped"];
-export type AgentInstanceStatus = (typeof AGENT_INSTANCE_STATUSES)[number];
-/**
- * How one Agent sees the provider-owned workspace.
- *
- * `shared` is ordinary same-computer visibility. `isolated` requests a private
- * writable view with provider-defined inspect or commit behavior. Neither mode
- * is a security boundary between mutually untrusted Agents.
- */
-export declare const AGENT_INSTANCE_WORKSPACE_MODES: readonly ["shared", "isolated"];
-export type AgentInstanceWorkspaceMode = (typeof AGENT_INSTANCE_WORKSPACE_MODES)[number];
-export interface AgentInstanceWorkspace {
-    mode: AgentInstanceWorkspaceMode;
-}
-/**
- * Provider-neutral request to start one managed Agent inside an existing
- * execution environment.
- *
- * Omitting `profile` asks the provider for its default Agent configuration.
- * Omitting `workspace` selects the provider's documented default. A profile
- * never implies another VM.
- */
-export interface AgentInstanceSpec {
-    /** Stable caller-selected id or idempotency key, when supported. */
-    id?: string;
-    /** Human-readable label; not immutable identity. */
-    name?: string;
-    /** Exact portable profile for this Agent. */
-    profile?: AgentProfile;
-    /** Optional execution override; otherwise the profile or provider decides. */
-    harness?: HarnessType;
-    workspace?: AgentInstanceWorkspace;
-}
-/** Credential-free identity of the profile bound to an Agent instance. */
-export interface AgentInstanceProfileIdentity {
-    name?: string;
-    digest: Sha256Digest;
-}
-/**
- * Public failure summary. Providers must remove credentials and private
- * implementation details before publishing this value.
- */
-export interface AgentInstanceFailure {
-    code?: string;
-    message: string;
-}
-/**
- * Portable snapshot of one managed Agent.
- *
- * The record deliberately excludes the full profile, provider request,
- * credentials, grants, process ids, placement, and fencing state.
- */
-export interface AgentInstanceRecord {
-    kind: "agent-instance";
-    schemaVersion: 1;
-    id: string;
-    name?: string;
-    profile?: AgentInstanceProfileIdentity;
-    /** Effective harness after profile and caller override resolution. */
-    harness?: HarnessType;
-    workspace: AgentInstanceWorkspace;
-    status: AgentInstanceStatus;
-    failure?: AgentInstanceFailure;
-    createdAtMs: number;
-    updatedAtMs: number;
-}
-export interface AgentInstanceStopRequest {
-    agentId: string;
-    /** Provider-defined hard termination after graceful stop cannot complete. */
-    force?: boolean;
-}
-export interface AgentInstanceStopAcknowledgement {
-    agentId: string;
-    outcome: "stopped" | "already-stopped" | "not-found";
-}
-export declare const agentInstanceStatusSchema: z.ZodEnum<{
-    busy: "busy";
-    failed: "failed";
-    ready: "ready";
-    starting: "starting";
-    stopped: "stopped";
-}>;
-export declare const agentInstanceWorkspaceModeSchema: z.ZodEnum<{
-    isolated: "isolated";
-    shared: "shared";
-}>;
-export declare const agentInstanceWorkspaceSchema: z.ZodType<AgentInstanceWorkspace>;
-export declare const agentInstanceSpecSchema: z.ZodType<AgentInstanceSpec>;
-export declare const agentInstanceProfileIdentitySchema: z.ZodType<AgentInstanceProfileIdentity>;
-export declare const agentInstanceFailureSchema: z.ZodType<AgentInstanceFailure>;
-export declare const agentInstanceRecordSchema: z.ZodType<AgentInstanceRecord>;
-export declare const agentInstanceStopRequestSchema: z.ZodType<AgentInstanceStopRequest>;
-export declare const agentInstanceStopAcknowledgementSchema: z.ZodType<AgentInstanceStopAcknowledgement>;