@tangle-network/agent-interface 0.37.0 → 0.39.0

package/dist/agent-profile.d.ts

@@ -3,8 +3,13 @@
  *
  * These model portable agent intent at the application boundary. Individual
  * backends translate this shape into their own native profile/configuration
- * formats internally. This package is the canonical public home for these
- * symbols.
+ * formats internally. Profile content participates in unsalted public identity.
+ * Prompts, resources, metadata, commands, paths, and secret-reference keys are
+ * caller-declared public data; recognizable credential patterns are refused as
+ * defense in depth, not as proof that arbitrary text is non-secret. MCP and hook
+ * secret-capable fields structurally require tagged public values or opaque
+ * secret references, which a private executor resolves only after identity is
+ * fixed. This package is the canonical public home for these symbols.
  */
 import type { HarnessType } from "./harness.js";
 /**
@@ -96,7 +101,8 @@ export interface AgentProfileResources {
  * A backend without a matching native tier may clamp down to its strongest supported level, but it
  * must never turn reasoning on for `none` or silently increase a requested effort.
  */
-export type ReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "ultracode";
+export declare const REASONING_EFFORTS: readonly ["none", "minimal", "low", "medium", "high", "xhigh", "ultracode"];
+export type ReasoningEffort = (typeof REASONING_EFFORTS)[number];
 /**
  * Model selection hints for backends.
  */
@@ -136,6 +142,37 @@ export interface AgentProfilePrompt {
      */
     instructions?: string[];
 }
+/** Deliberately public configuration included in profile identity. */
+export interface AgentProfilePublicConfigValue {
+    kind: "public";
+    value: string;
+}
+/**
+ * Opaque reference resolved only inside the private prepared executor.
+ * `key` is caller-declared public identity naming provider/operator-owned
+ * secret material; callers must not put the secret value in it.
+ */
+export interface AgentProfileSecretRef {
+    kind: "secret-ref";
+    key: string;
+    /** Apply no decoration or a `Bearer ` prefix after private resolution. */
+    format?: "raw" | "bearer";
+}
+/** A configuration value is public bytes or an opaque secret identity. */
+export type AgentProfileConfigValue = AgentProfilePublicConfigValue | AgentProfileSecretRef;
+/**
+ * Private executor port for resolving one public secret-reference identity.
+ * Implementations return the raw undecorated value. Consumers must fail
+ * preparation on missing or blank values and must keep resolved values out of
+ * profiles, public plans, digests, receipts, diagnostics, and logs.
+ */
+export interface AgentProfileSecretProvider {
+    get(key: string): Promise<string | undefined>;
+}
+/** Mark an exact configuration value as public profile material. */
+export declare function defineAgentProfilePublicConfig(value: string): AgentProfilePublicConfigValue;
+/** Create a secret reference whose key is caller-declared public identity. */
+export declare function defineAgentProfileSecretRef(key: string, format?: AgentProfileSecretRef["format"]): AgentProfileSecretRef;
 /**
  * Generic subagent definition.
  */
@@ -153,7 +190,7 @@ export interface AgentProfileHookCommand {
     timeoutMs?: number;
     blocking?: boolean;
     matcher?: string;
-    env?: Record<string, string>;
+    env?: Record<string, AgentProfileConfigValue>;
 }
 export interface AgentProfileMode {
     description?: string;
@@ -198,8 +235,8 @@ interface AgentProfileLocalMcpServer extends AgentProfileMcpServerBase {
     enabled?: true;
     transport?: "stdio";
     command: string;
-    args?: string[];
-    env?: Record<string, string>;
+    args?: AgentProfileConfigValue[];
+    env?: Record<string, AgentProfileConfigValue>;
     cwd?: string;
     url?: never;
     headers?: never;
@@ -212,7 +249,7 @@ interface AgentProfileRemoteMcpServer extends AgentProfileMcpServerBase {
     env?: never;
     cwd?: never;
     url: string;
-    headers?: Record<string, string>;
+    headers?: Record<string, AgentProfileConfigValue>;
 }
 interface AgentProfileDisabledMcpServer extends AgentProfileMcpServerBase {
     enabled: false;

package/dist/agent-profile.js

@@ -3,8 +3,13 @@
  *
  * These model portable agent intent at the application boundary. Individual
  * backends translate this shape into their own native profile/configuration
- * formats internally. This package is the canonical public home for these
- * symbols.
+ * formats internally. Profile content participates in unsalted public identity.
+ * Prompts, resources, metadata, commands, paths, and secret-reference keys are
+ * caller-declared public data; recognizable credential patterns are refused as
+ * defense in depth, not as proof that arbitrary text is non-secret. MCP and hook
+ * secret-capable fields structurally require tagged public values or opaque
+ * secret references, which a private executor resolves only after identity is
+ * fixed. This package is the canonical public home for these symbols.
  */
 /**
  * Helper for creating typed inline resource refs.
@@ -24,6 +29,38 @@ export function defineGitHubResource(path, options = {}) {
         name: options.name,
     };
 }
+/**
+ * Portable reasoning/thinking effort. Backends map it to their native control at materialization:
+ * codex `model_reasoning_effort`, kimi `--thinking`/`--no-thinking`, claude thinking budget.
+ * Ordered low→high:
+ *   - `none`     — extended thinking OFF (no reasoning budget at all)
+ *   - `minimal`  — thinking ON, the lowest budget (distinct from `none`)
+ *   - `low` / `medium` / `high` / `xhigh`
+ *   - `ultracode` — maximum (Claude Code's `max` and Codex's `ultra` reconcile here).
+ * A backend without a matching native tier may clamp down to its strongest supported level, but it
+ * must never turn reasoning on for `none` or silently increase a requested effort.
+ */
+export const REASONING_EFFORTS = Object.freeze([
+    "none",
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "ultracode",
+]);
+/** Mark an exact configuration value as public profile material. */
+export function defineAgentProfilePublicConfig(value) {
+    return { kind: "public", value };
+}
+/** Create a secret reference whose key is caller-declared public identity. */
+export function defineAgentProfileSecretRef(key, format) {
+    return {
+        kind: "secret-ref",
+        key,
+        ...(format === undefined ? {} : { format }),
+    };
+}
 /**
  * Helper for declaring typed profiles in application code.
  */

package/dist/agent-workspace-lease.d.ts

@@ -0,0 +1,138 @@
+import { z } from "zod";
+import type { Sha256Digest } from "./agent-candidate.js";
+export declare const AGENT_WORKSPACE_LEASE_PHASES: readonly ["copy-ready", "workspace-sealed", "execution-bound", "destroying", "cleanup-failed", "destroyed"];
+export type AgentWorkspaceLeasePhase = (typeof AGENT_WORKSPACE_LEASE_PHASES)[number];
+/**
+ * Public identity of the provider-owned rules used to capture workspace state.
+ * The digest binds the exact canonical policy document retained by the provider;
+ * this descriptor does not claim that every provider captures the same fields.
+ */
+export interface AgentWorkspaceSourceSnapshotPolicy {
+    kind: "provider-declared";
+    name: string;
+    version: number;
+    digest: Sha256Digest;
+}
+/** Public allocation identity. `root` locates bytes; it grants no authority. */
+export interface AgentWorkspaceAllocationIdentity {
+    provider: string;
+    root: string;
+    /** Digest of the provider, lease/allocation identity, and canonical root. */
+    identityDigest: Sha256Digest;
+}
+interface AgentWorkspaceLeaseRecordBase {
+    kind: "agent-workspace-lease";
+    schemaVersion: 1;
+    leaseId: string;
+    ownerId: string;
+    workspace: AgentWorkspaceAllocationIdentity;
+    isolation: "per-run" | "shared";
+    sourceSnapshotDigest: Sha256Digest;
+    /** Governs both the source and prepared workspace digest interpretation. */
+    sourceSnapshotPolicy: AgentWorkspaceSourceSnapshotPolicy;
+    createdAtMs: number;
+    updatedAtMs: number;
+    expiresAtMs: number;
+}
+interface AgentWorkspaceUnpreparedEvidence {
+    preparedWorkspaceDigest?: never;
+    profileActivationDigest?: never;
+    executionPreparationDigest?: never;
+}
+interface AgentWorkspaceSealedEvidence {
+    preparedWorkspaceDigest: Sha256Digest;
+    profileActivationDigest: Sha256Digest;
+    executionPreparationDigest?: never;
+}
+interface AgentWorkspaceExecutionBoundEvidence {
+    preparedWorkspaceDigest: Sha256Digest;
+    profileActivationDigest: Sha256Digest;
+    executionPreparationDigest: Sha256Digest;
+}
+export type AgentWorkspaceCopyReadyLeaseRecordMaterial = AgentWorkspaceLeaseRecordBase & AgentWorkspaceUnpreparedEvidence & {
+    phase: "copy-ready";
+    cleanupAttempts: 0;
+    cleanupError?: never;
+};
+export type AgentWorkspaceSealedLeaseRecordMaterial = AgentWorkspaceLeaseRecordBase & AgentWorkspaceSealedEvidence & {
+    phase: "workspace-sealed";
+    cleanupAttempts: 0;
+    cleanupError?: never;
+};
+export type AgentWorkspaceExecutionBoundLeaseRecordMaterial = AgentWorkspaceLeaseRecordBase & AgentWorkspaceExecutionBoundEvidence & {
+    phase: "execution-bound";
+    cleanupAttempts: 0;
+    cleanupError?: never;
+};
+type AgentWorkspaceCleanupEvidence = AgentWorkspaceUnpreparedEvidence | AgentWorkspaceSealedEvidence | AgentWorkspaceExecutionBoundEvidence;
+export type AgentWorkspaceDestroyingLeaseRecordMaterial = AgentWorkspaceLeaseRecordBase & AgentWorkspaceCleanupEvidence & {
+    phase: "destroying";
+    cleanupAttempts: number;
+    cleanupError?: never;
+};
+export type AgentWorkspaceCleanupFailedLeaseRecordMaterial = AgentWorkspaceLeaseRecordBase & AgentWorkspaceCleanupEvidence & {
+    phase: "cleanup-failed";
+    cleanupAttempts: number;
+    /** Sanitized public diagnostic; providers remain responsible for redaction. */
+    cleanupError: string;
+};
+export type AgentWorkspaceDestroyedLeaseRecordMaterial = AgentWorkspaceLeaseRecordBase & AgentWorkspaceCleanupEvidence & {
+    phase: "destroyed";
+    cleanupAttempts: number;
+    cleanupError?: never;
+};
+export type AgentWorkspaceLeaseRecordMaterial = AgentWorkspaceCopyReadyLeaseRecordMaterial | AgentWorkspaceSealedLeaseRecordMaterial | AgentWorkspaceExecutionBoundLeaseRecordMaterial | AgentWorkspaceDestroyingLeaseRecordMaterial | AgentWorkspaceCleanupFailedLeaseRecordMaterial | AgentWorkspaceDestroyedLeaseRecordMaterial;
+type WithDigest<Material> = Material extends unknown ? Material & {
+    digest: Sha256Digest;
+} : never;
+/** Self-hashed public projection. Private authorization and durable state stay out. */
+export type AgentWorkspaceLeaseRecord = WithDigest<AgentWorkspaceLeaseRecordMaterial>;
+export type AgentWorkspaceCopyReadyLeaseRecord = WithDigest<AgentWorkspaceCopyReadyLeaseRecordMaterial>;
+export type AgentWorkspaceSealedLeaseRecord = WithDigest<AgentWorkspaceSealedLeaseRecordMaterial>;
+export type AgentWorkspaceExecutionBoundLeaseRecord = WithDigest<AgentWorkspaceExecutionBoundLeaseRecordMaterial>;
+export type AgentWorkspaceDestroyingLeaseRecord = WithDigest<AgentWorkspaceDestroyingLeaseRecordMaterial>;
+export type AgentWorkspaceCleanupFailedLeaseRecord = WithDigest<AgentWorkspaceCleanupFailedLeaseRecordMaterial>;
+export type AgentWorkspaceDestroyedLeaseRecord = WithDigest<AgentWorkspaceDestroyedLeaseRecordMaterial>;
+/**
+ * Request-only owner capability. Providers persist at most a one-way digest;
+ * this value never belongs in a public lease or execution receipt.
+ */
+export interface AgentWorkspaceLeaseAuthorization {
+    leaseId: string;
+    ownerToken: string;
+}
+export interface AgentWorkspaceSealRequest extends AgentWorkspaceLeaseAuthorization {
+    profileActivationDigest: Sha256Digest;
+}
+export interface AgentWorkspaceExecutionBindingRequest extends AgentWorkspaceLeaseAuthorization {
+    executionPreparationDigest: Sha256Digest;
+}
+export interface AgentWorkspaceLeaseRenewalRequest extends AgentWorkspaceLeaseAuthorization {
+    expiresAtMs: number;
+}
+export declare const agentWorkspaceLeasePhaseSchema: z.ZodEnum<{
+    "copy-ready": "copy-ready";
+    "workspace-sealed": "workspace-sealed";
+    "execution-bound": "execution-bound";
+    destroying: "destroying";
+    "cleanup-failed": "cleanup-failed";
+    destroyed: "destroyed";
+}>;
+export declare const agentWorkspaceSourceSnapshotPolicySchema: z.ZodObject<{
+    kind: z.ZodLiteral<"provider-declared">;
+    name: z.ZodString;
+    version: z.ZodNumber;
+    digest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+}, z.core.$strict>;
+export declare const agentWorkspaceAllocationIdentitySchema: z.ZodObject<{
+    provider: z.ZodString;
+    root: z.ZodString;
+    identityDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+}, z.core.$strict>;
+export declare const agentWorkspaceLeaseRecordMaterialSchema: z.ZodType<AgentWorkspaceLeaseRecordMaterial>;
+export declare const agentWorkspaceLeaseRecordSchema: z.ZodType<AgentWorkspaceLeaseRecord>;
+/** Canonical public identity; private token/state fields cannot enter its schema. */
+export declare function canonicalAgentWorkspaceLeaseRecordDigest(material: AgentWorkspaceLeaseRecordMaterial): Sha256Digest;
+/** Build and self-hash one phase-valid public workspace lease record. */
+export declare function buildAgentWorkspaceLeaseRecord<Material extends AgentWorkspaceLeaseRecordMaterial>(material: Material): WithDigest<Material>;
+export {};

package/dist/agent-workspace-lease.js

@@ -0,0 +1,203 @@
+import { z } from "zod";
+import { canonicalCandidateDigest, isCanonicalJsonValue, isWellFormedUnicode, looksLikeCredential, omitTopLevelDigest, sha256DigestSchema, } from "./agent-candidate-schema-common.js";
+export const AGENT_WORKSPACE_LEASE_PHASES = [
+    "copy-ready",
+    "workspace-sealed",
+    "execution-bound",
+    "destroying",
+    "cleanup-failed",
+    "destroyed",
+];
+const controlCharacterPattern = /[\u0000-\u001f\u007f]/;
+const publicIdentifierSchema = z
+    .string()
+    .min(1)
+    .max(500)
+    .refine((value) => value.trim().length > 0 &&
+    isWellFormedUnicode(value) &&
+    !controlCharacterPattern.test(value) &&
+    !looksLikeCredential(value), "public workspace identity cannot carry credential-like material");
+const publicLocatorSchema = z
+    .string()
+    .min(1)
+    .max(16_384)
+    .refine((value) => value.trim().length > 0 &&
+    isWellFormedUnicode(value) &&
+    !controlCharacterPattern.test(value) &&
+    !looksLikeCredential(value), "workspace locator must be public, well-formed text");
+const publicCleanupErrorSchema = z
+    .string()
+    .min(1)
+    .max(2_000)
+    .refine((value) => value.trim().length > 0 &&
+    isWellFormedUnicode(value) &&
+    !controlCharacterPattern.test(value) &&
+    !looksLikeCredential(value), "workspace cleanup error must be sanitized public text");
+const timestampSchema = z
+    .number()
+    .int()
+    .nonnegative()
+    .max(Number.MAX_SAFE_INTEGER);
+export const agentWorkspaceLeasePhaseSchema = z.enum(AGENT_WORKSPACE_LEASE_PHASES);
+export const agentWorkspaceSourceSnapshotPolicySchema = z.strictObject({
+    kind: z.literal("provider-declared"),
+    name: publicIdentifierSchema,
+    version: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+    digest: sha256DigestSchema,
+});
+export const agentWorkspaceAllocationIdentitySchema = z.strictObject({
+    provider: publicIdentifierSchema,
+    root: publicLocatorSchema,
+    identityDigest: sha256DigestSchema,
+});
+const agentWorkspaceLeaseRecordFields = {
+    kind: z.literal("agent-workspace-lease"),
+    schemaVersion: z.literal(1),
+    phase: agentWorkspaceLeasePhaseSchema,
+    leaseId: publicIdentifierSchema,
+    ownerId: publicIdentifierSchema,
+    workspace: agentWorkspaceAllocationIdentitySchema,
+    isolation: z.enum(["per-run", "shared"]),
+    sourceSnapshotDigest: sha256DigestSchema,
+    sourceSnapshotPolicy: agentWorkspaceSourceSnapshotPolicySchema,
+    preparedWorkspaceDigest: sha256DigestSchema.optional(),
+    profileActivationDigest: sha256DigestSchema.optional(),
+    executionPreparationDigest: sha256DigestSchema.optional(),
+    createdAtMs: timestampSchema,
+    updatedAtMs: timestampSchema,
+    expiresAtMs: timestampSchema,
+    cleanupAttempts: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+    cleanupError: publicCleanupErrorSchema.optional(),
+};
+const rawAgentWorkspaceLeaseRecordMaterialSchema = z
+    .strictObject(agentWorkspaceLeaseRecordFields)
+    .superRefine((record, context) => {
+    validateAgentWorkspaceLeaseState(record, context);
+    if (!isCanonicalJsonValue(record)) {
+        context.addIssue({
+            code: "custom",
+            message: "workspace lease material must contain only RFC 8785 JSON values",
+        });
+    }
+})
+    .transform((record) => record);
+export const agentWorkspaceLeaseRecordMaterialSchema = rawAgentWorkspaceLeaseRecordMaterialSchema;
+export const agentWorkspaceLeaseRecordSchema = z
+    .strictObject({
+    ...agentWorkspaceLeaseRecordFields,
+    digest: sha256DigestSchema,
+})
+    .superRefine((record, context) => {
+    validateAgentWorkspaceLeaseState(record, context);
+    if (!isCanonicalJsonValue(record)) {
+        context.addIssue({
+            code: "custom",
+            message: "workspace lease record must contain only RFC 8785 JSON values",
+        });
+    }
+    else if (canonicalCandidateDigest(omitTopLevelDigest(record)) !== record.digest) {
+        context.addIssue({
+            code: "custom",
+            path: ["digest"],
+            message: "workspace lease record digest is invalid",
+        });
+    }
+})
+    .transform((record) => record);
+/** Canonical public identity; private token/state fields cannot enter its schema. */
+export function canonicalAgentWorkspaceLeaseRecordDigest(material) {
+    return canonicalCandidateDigest(agentWorkspaceLeaseRecordMaterialSchema.parse(material));
+}
+/** Build and self-hash one phase-valid public workspace lease record. */
+export function buildAgentWorkspaceLeaseRecord(material) {
+    const parsed = agentWorkspaceLeaseRecordMaterialSchema.parse(material);
+    return agentWorkspaceLeaseRecordSchema.parse({
+        ...parsed,
+        digest: canonicalCandidateDigest(parsed),
+    });
+}
+function validateAgentWorkspaceLeaseState(record, context) {
+    if (record.updatedAtMs < record.createdAtMs) {
+        context.addIssue({
+            code: "custom",
+            path: ["updatedAtMs"],
+            message: "workspace lease update cannot precede creation",
+        });
+    }
+    if (record.expiresAtMs <= record.createdAtMs) {
+        context.addIssue({
+            code: "custom",
+            path: ["expiresAtMs"],
+            message: "workspace lease expiry must follow creation",
+        });
+    }
+    const hasPrepared = record.preparedWorkspaceDigest !== undefined;
+    const hasActivation = record.profileActivationDigest !== undefined;
+    const hasExecution = record.executionPreparationDigest !== undefined;
+    if (hasPrepared !== hasActivation) {
+        context.addIssue({
+            code: "custom",
+            message: "prepared workspace and profile activation evidence must appear together",
+        });
+    }
+    if (hasExecution && (!hasPrepared || !hasActivation)) {
+        context.addIssue({
+            code: "custom",
+            path: ["executionPreparationDigest"],
+            message: "execution binding requires sealed workspace evidence",
+        });
+    }
+    const active = record.phase === "copy-ready" ||
+        record.phase === "workspace-sealed" ||
+        record.phase === "execution-bound";
+    if (active && record.cleanupAttempts !== 0) {
+        context.addIssue({
+            code: "custom",
+            path: ["cleanupAttempts"],
+            message: "active workspace phases cannot have cleanup attempts",
+        });
+    }
+    if (!active && record.cleanupAttempts < 1) {
+        context.addIssue({
+            code: "custom",
+            path: ["cleanupAttempts"],
+            message: "cleanup workspace phases require at least one cleanup attempt",
+        });
+    }
+    if (record.phase === "copy-ready" && (hasPrepared || hasExecution)) {
+        context.addIssue({
+            code: "custom",
+            message: "copy-ready workspace cannot carry preparation evidence",
+        });
+    }
+    if (record.phase === "workspace-sealed" &&
+        (!hasPrepared || !hasActivation || hasExecution)) {
+        context.addIssue({
+            code: "custom",
+            message: "workspace-sealed phase requires preparation evidence without execution binding",
+        });
+    }
+    if (record.phase === "execution-bound" &&
+        (!hasPrepared || !hasActivation || !hasExecution)) {
+        context.addIssue({
+            code: "custom",
+            message: "execution-bound phase requires complete preparation evidence",
+        });
+    }
+    if (record.phase === "cleanup-failed") {
+        if (record.cleanupError === undefined) {
+            context.addIssue({
+                code: "custom",
+                path: ["cleanupError"],
+                message: "cleanup-failed phase requires a sanitized error",
+            });
+        }
+    }
+    else if (record.cleanupError !== undefined) {
+        context.addIssue({
+            code: "custom",
+            path: ["cleanupError"],
+            message: "cleanup error is valid only in cleanup-failed phase",
+        });
+    }
+}

package/dist/harness-capabilities.d.ts

@@ -1,4 +1,4 @@
-import type { ReasoningEffort } from "./agent-profile.js";
+import { type ReasoningEffort } from "./agent-profile.js";
 import type { HarnessType } from "./harness.js";
 /**
  * The unified harness capability layer — the single source of truth for:

package/dist/harness-capabilities.js

@@ -1,3 +1,4 @@
+import { REASONING_EFFORTS, } from "./agent-profile.js";
 /**
  * The unified harness capability layer — the single source of truth for:
  *   1. harness ↔ model compatibility (which models a harness can run), and
@@ -15,15 +16,7 @@
  * caller supplies.
  */
 /** low → high. `none` = thinking off; `ultracode` = max (claude-code mode). */
-export const reasoningLadder = [
-    "none",
-    "minimal",
-    "low",
-    "medium",
-    "high",
-    "xhigh",
-    "ultracode",
-];
+export const reasoningLadder = REASONING_EFFORTS;
 // ── Harness ↔ model compatibility ────────────────────────────────────────────
 /**
  * Provider prefixes a harness is vendor-locked to (canonical-id prefix, e.g. `anthropic`, `openai`).

package/dist/index.d.ts

@@ -623,6 +623,10 @@ export * from "./agent-profile-improvement.js";
 export * from "./agent-profile-improvement-schema.js";
 export * from "./agent-execution-limits.js";
 export * from "./agent-profile.js";
+export * from "./agent-profile-activation.js";
+export * from "./agent-profile-materialization.js";
+export * from "./agent-execution-preparation.js";
+export * from "./agent-workspace-lease.js";
 export * from "./certified-context.js";
 export * from "./profile-diff.js";
 export * from "./harness.js";

package/dist/index.js

@@ -135,6 +135,10 @@ export * from "./agent-profile-improvement.js";
 export * from "./agent-profile-improvement-schema.js";
 export * from "./agent-execution-limits.js";
 export * from "./agent-profile.js";
+export * from "./agent-profile-activation.js";
+export * from "./agent-profile-materialization.js";
+export * from "./agent-execution-preparation.js";
+export * from "./agent-workspace-lease.js";
 export * from "./certified-context.js";
 export * from "./profile-diff.js";
 export * from "./harness.js";

package/dist/profile-diff.d.ts

@@ -57,6 +57,17 @@ export interface AgentProfileDiff {
     metadata?: Record<string, unknown>;
 }
 export declare function defineAgentProfileDiff<T extends AgentProfileDiff>(diff: T): T;
+/**
+ * Construct deterministic ordered profile patches that reproduce `candidate`'s
+ * canonical profile value exactly when applied to `baseline`.
+ *
+ * Profile overlays append arrays and merge records, so changed fields are reset
+ * first and then replaced. Comparison and copied values follow the same
+ * undefined-entry normalization as profile identity. The returned values use
+ * the existing {@link AgentProfileDiff} contract; an unchanged profile returns
+ * no steps.
+ */
+export declare function diffAgentProfiles(baseline: AgentProfile, candidate: AgentProfile): AgentProfileDiff[];
 export declare function applyAgentProfileDiff(base: AgentProfile, diff: AgentProfileDiff): AgentProfile;
 export declare function changedAgentProfileAxes(diff: AgentProfileDiff): AgentProfileDiffAxis[];
 export declare function pruneAgentProfileDiff(diff: AgentProfileDiff, axesToRemove: readonly AgentProfileDiffAxis[]): AgentProfileDiff;