@autohq/cli 0.1.609 → 0.1.611

package/dist/index.js

@@ -15474,6 +15474,8 @@ var init_auth = __esm({
       "tools:write",
       "environments:read",
       "environments:write",
+      "runtimes:read",
+      "runtimes:write",
       "profiles:read",
       "profiles:write",
       "sessions:read",
@@ -15592,6 +15594,7 @@ var init_auth = __esm({
     });
     SERVICE_ACCOUNT_READ_ONLY_SCOPES = [
       "environments:read",
+      "runtimes:read",
       "tools:read",
       "agents:read",
       "sessions:read",
@@ -18943,6 +18946,289 @@ var init_secrets = __esm({
   }
 });
 
+// ../../packages/schemas/src/environments.ts
+function environmentSetupSchema(cachePathSchema) {
+  return external_exports.object({
+    name: ResourceNameSchema,
+    commands: external_exports.array(external_exports.string().trim().min(1)).min(1),
+    cache: external_exports.object({
+      key: ResourceNameSchema.optional(),
+      files: external_exports.array(
+        external_exports.string().trim().refine(isSafeRelativePath, {
+          message: "Expected a relative path without traversal"
+        })
+      ).default([]),
+      paths: external_exports.array(cachePathSchema).default([])
+    }).strict().default({ files: [], paths: [] })
+  }).strict();
+}
+function environmentSpecSchema({
+  imageSchema,
+  setupSchema
+}) {
+  return external_exports.object({
+    image: imageSchema,
+    env: SecretEnvSchema.default({}),
+    resources: EnvironmentResourcesSchema.optional(),
+    steps: external_exports.array(external_exports.string()).default([]),
+    setup: external_exports.array(setupSchema).default([]),
+    setupCache: EnvironmentSetupCacheSchema.optional(),
+    // Optional rather than defaulted: a default would materialize the key
+    // into stored specs and session environment snapshots the moment the web
+    // app deploys, and this strict schema on a not-yet-deployed worker would
+    // reject those rows (web and workers do not deploy atomically). Absent
+    // means `bypass`; consumers default at the read boundary.
+    approvals: EnvironmentApprovalsSchema.optional()
+  }).strict();
+}
+function isSafeSandboxUserHomePath(value, options = {}) {
+  return (options.allowedHomes ?? [CURRENT_SANDBOX_USER_HOME]).some(
+    (home) => isSafePathUnderHome(value, home)
+  );
+}
+function isSafePathUnderHome(value, home) {
+  const prefix = `${home}/`;
+  if (!value.startsWith(prefix)) {
+    return false;
+  }
+  const relative2 = value.slice(prefix.length);
+  return relative2.split("/").every((segment) => segment !== "" && segment !== "." && segment !== "..");
+}
+function isSafeRelativePath(value) {
+  if (!value || value.startsWith("/")) {
+    return false;
+  }
+  return value.split("/").every((segment) => segment !== "" && segment !== "." && segment !== "..");
+}
+function isSafeBaseImageRef(value) {
+  return !value.startsWith("-") && /^[^\s#\\]+$/.test(value);
+}
+function isSetupCacheTtl(value) {
+  return /^[1-9][0-9]*(s|m|h|d)$/.test(value);
+}
+var RESOURCE_KIND_ENVIRONMENT, CURRENT_SANDBOX_USER_HOME, LEGACY_SANDBOX_USER_HOMES, STORED_SANDBOX_USER_HOMES, EnvironmentSetupCachePathSchema, StoredEnvironmentSetupCachePathSchema, EnvironmentImageSchema, StoredEnvironmentImageSchema, ENVIRONMENT_APPROVALS_MODES, EnvironmentApprovalsSchema, EnvironmentSetupSchema, EnvironmentApplySetupSchema, EnvironmentSetupCacheSchema, EnvironmentResourcesSchema, EnvironmentSpecSchema, EnvironmentApplySpecSchema, EnvironmentCandidateSpecSchema, EnvironmentResourceSchema, EnvironmentApplyRequestSchema;
+var init_environments = __esm({
+  "../../packages/schemas/src/environments.ts"() {
+    "use strict";
+    init_zod();
+    init_resources();
+    init_secrets();
+    RESOURCE_KIND_ENVIRONMENT = "environment";
+    CURRENT_SANDBOX_USER_HOME = "/home/user";
+    LEGACY_SANDBOX_USER_HOMES = ["/home/auto", "/home/node"];
+    STORED_SANDBOX_USER_HOMES = [
+      CURRENT_SANDBOX_USER_HOME,
+      ...LEGACY_SANDBOX_USER_HOMES
+    ];
+    EnvironmentSetupCachePathSchema = external_exports.string().trim().refine((value) => isSafeSandboxUserHomePath(value), {
+      message: `Expected an absolute path under ${CURRENT_SANDBOX_USER_HOME}`
+    });
+    StoredEnvironmentSetupCachePathSchema = external_exports.string().trim().refine(
+      (value) => isSafeSandboxUserHomePath(value, {
+        allowedHomes: STORED_SANDBOX_USER_HOMES
+      }),
+      {
+        message: `Expected an absolute path under ${CURRENT_SANDBOX_USER_HOME}`
+      }
+    );
+    EnvironmentImageSchema = external_exports.discriminatedUnion("kind", [
+      external_exports.object({
+        kind: external_exports.literal("preset"),
+        name: ResourceNameSchema
+      }).strict(),
+      external_exports.object({
+        kind: external_exports.literal("base"),
+        ref: external_exports.string().trim().min(1).max(512).refine(isSafeBaseImageRef, {
+          message: "Expected a single Docker/OCI image reference"
+        })
+      }).strict()
+    ]);
+    StoredEnvironmentImageSchema = external_exports.discriminatedUnion("kind", [
+      external_exports.object({
+        kind: external_exports.literal("preset"),
+        name: external_exports.string().trim().min(1)
+      }).strict(),
+      external_exports.object({
+        kind: external_exports.literal("base"),
+        ref: external_exports.string().trim().min(1).refine(isSafeBaseImageRef, {
+          message: "Expected a single Docker/OCI image reference"
+        })
+      }).strict()
+    ]);
+    ENVIRONMENT_APPROVALS_MODES = ["bypass", "prompt"];
+    EnvironmentApprovalsSchema = external_exports.enum(ENVIRONMENT_APPROVALS_MODES);
+    EnvironmentSetupSchema = environmentSetupSchema(
+      StoredEnvironmentSetupCachePathSchema
+    );
+    EnvironmentApplySetupSchema = environmentSetupSchema(
+      EnvironmentSetupCachePathSchema
+    );
+    EnvironmentSetupCacheSchema = external_exports.object({
+      ttl: external_exports.string().trim().refine(isSetupCacheTtl, {
+        message: "Expected a positive setup cache TTL such as 30m, 24h, or 7d"
+      })
+    }).strict();
+    EnvironmentResourcesSchema = external_exports.object({
+      cpuCount: external_exports.number().int().min(1).optional(),
+      memoryMB: external_exports.number().int().min(128).optional()
+    }).strict().refine(
+      (resources) => resources.cpuCount !== void 0 || resources.memoryMB !== void 0,
+      {
+        message: "Expected at least one runtime resource setting"
+      }
+    );
+    EnvironmentSpecSchema = environmentSpecSchema({
+      imageSchema: StoredEnvironmentImageSchema,
+      setupSchema: EnvironmentSetupSchema
+    });
+    EnvironmentApplySpecSchema = environmentSpecSchema({
+      imageSchema: EnvironmentImageSchema,
+      setupSchema: EnvironmentApplySetupSchema
+    });
+    EnvironmentCandidateSpecSchema = EnvironmentApplySpecSchema;
+    EnvironmentResourceSchema = resourceEnvelopeSchema(
+      EnvironmentSpecSchema
+    );
+    EnvironmentApplyRequestSchema = resourceApplySchema(
+      EnvironmentApplySpecSchema
+    );
+  }
+});
+
+// ../../packages/schemas/src/hosted-runtimes.ts
+var HOSTED_RUNTIME_STATUSES, HOSTED_RUNTIME_OUTCOMES, HOSTED_RUNTIME_COMMAND_STATUSES, HOSTED_RUNTIME_CLOSE_REASONS, HOSTED_RUNTIME_MAX_COMMAND_BUDGET_SECONDS, HostedRuntimeEnvironmentInputSchema, HostedRuntimeEnvironmentSourceSchema, HostedRuntimeEnvironmentSnapshotSchema, HostedRuntimeCommandInputSchema, HostedRuntimeIdempotencyKeySchema, CreateHostedRuntimeRequestSchema, HostedRuntimeStatusSchema, HostedRuntimeOutcomeSchema, HostedRuntimeCommandStatusSchema, HostedRuntimeCloseReasonSchema, HostedRuntimeCommandRecordSchema, HostedRuntimeRecordSchema, HostedRuntimeDispatchStatusSchema, HostedRuntimeReceiptSchema, HostedRuntimeWorkflowInputSchema;
+var init_hosted_runtimes = __esm({
+  "../../packages/schemas/src/hosted-runtimes.ts"() {
+    "use strict";
+    init_zod();
+    init_environments();
+    init_ids();
+    init_resources();
+    HOSTED_RUNTIME_STATUSES = [
+      "queued",
+      "provisioning",
+      "running",
+      "closing",
+      "closed"
+    ];
+    HOSTED_RUNTIME_OUTCOMES = [
+      "succeeded",
+      "failed",
+      "cancelled"
+    ];
+    HOSTED_RUNTIME_COMMAND_STATUSES = [
+      "pending",
+      "running",
+      "succeeded",
+      "failed",
+      "cancelled"
+    ];
+    HOSTED_RUNTIME_CLOSE_REASONS = [
+      "completed",
+      "command_failed",
+      "provision_failed",
+      "requested",
+      "internal_error"
+    ];
+    HOSTED_RUNTIME_MAX_COMMAND_BUDGET_SECONDS = 45 * 60;
+    HostedRuntimeEnvironmentInputSchema = external_exports.discriminatedUnion(
+      "kind",
+      [
+        external_exports.object({
+          kind: external_exports.literal("inline"),
+          spec: EnvironmentCandidateSpecSchema
+        }).strict(),
+        external_exports.object({
+          kind: external_exports.literal("applied"),
+          name: ResourceNameSchema
+        }).strict()
+      ]
+    );
+    HostedRuntimeEnvironmentSourceSchema = external_exports.discriminatedUnion(
+      "kind",
+      [
+        external_exports.object({ kind: external_exports.literal("inline") }).strict(),
+        external_exports.object({
+          kind: external_exports.literal("applied"),
+          name: ResourceNameSchema,
+          resourceId: external_exports.string().trim().min(1),
+          generation: external_exports.number().int().positive()
+        }).strict()
+      ]
+    );
+    HostedRuntimeEnvironmentSnapshotSchema = external_exports.object({
+      source: HostedRuntimeEnvironmentSourceSchema,
+      spec: EnvironmentSpecSchema
+    }).strict();
+    HostedRuntimeCommandInputSchema = external_exports.object({
+      command: external_exports.string().trim().min(1).max(4096),
+      timeoutSeconds: external_exports.number().int().min(1).max(300).default(60)
+    }).strict();
+    HostedRuntimeIdempotencyKeySchema = external_exports.string().trim().min(1).max(200);
+    CreateHostedRuntimeRequestSchema = external_exports.object({
+      environment: HostedRuntimeEnvironmentInputSchema,
+      commands: external_exports.array(HostedRuntimeCommandInputSchema).min(1).max(20)
+    }).strict().superRefine((request, context) => {
+      const totalTimeoutSeconds = request.commands.reduce(
+        (total, command) => total + command.timeoutSeconds,
+        0
+      );
+      if (totalTimeoutSeconds > HOSTED_RUNTIME_MAX_COMMAND_BUDGET_SECONDS) {
+        context.addIssue({
+          code: "custom",
+          message: `Total command timeout must not exceed ${HOSTED_RUNTIME_MAX_COMMAND_BUDGET_SECONDS} seconds`,
+          path: ["commands"]
+        });
+      }
+    });
+    HostedRuntimeStatusSchema = external_exports.enum(HOSTED_RUNTIME_STATUSES);
+    HostedRuntimeOutcomeSchema = external_exports.enum(HOSTED_RUNTIME_OUTCOMES);
+    HostedRuntimeCommandStatusSchema = external_exports.enum(
+      HOSTED_RUNTIME_COMMAND_STATUSES
+    );
+    HostedRuntimeCloseReasonSchema = external_exports.enum(
+      HOSTED_RUNTIME_CLOSE_REASONS
+    );
+    HostedRuntimeCommandRecordSchema = external_exports.object({
+      ordinal: external_exports.number().int().positive(),
+      command: external_exports.string(),
+      timeoutSeconds: external_exports.number().int().positive(),
+      status: HostedRuntimeCommandStatusSchema,
+      startedAt: external_exports.string().datetime().nullable(),
+      finishedAt: external_exports.string().datetime().nullable(),
+      durationMs: external_exports.number().int().nonnegative().nullable(),
+      exitCode: external_exports.number().int().nullable(),
+      stdout: external_exports.string().nullable(),
+      stderr: external_exports.string().nullable(),
+      error: external_exports.string().nullable()
+    }).strict();
+    HostedRuntimeRecordSchema = external_exports.object({
+      id: RuntimeIdSchema,
+      status: HostedRuntimeStatusSchema,
+      outcome: HostedRuntimeOutcomeSchema.nullable(),
+      environment: HostedRuntimeEnvironmentSourceSchema,
+      commands: external_exports.array(HostedRuntimeCommandRecordSchema),
+      error: external_exports.string().nullable(),
+      closeReason: HostedRuntimeCloseReasonSchema.nullable(),
+      closeRequestedAt: external_exports.string().datetime().nullable(),
+      startedAt: external_exports.string().datetime().nullable(),
+      finishedAt: external_exports.string().datetime().nullable(),
+      createdAt: external_exports.string().datetime(),
+      updatedAt: external_exports.string().datetime()
+    }).strict();
+    HostedRuntimeDispatchStatusSchema = external_exports.enum([
+      "started",
+      "deferred"
+    ]);
+    HostedRuntimeReceiptSchema = external_exports.object({
+      runtime: HostedRuntimeRecordSchema,
+      workflowId: external_exports.string().trim().min(1),
+      dispatchStatus: HostedRuntimeDispatchStatusSchema
+    }).strict();
+    HostedRuntimeWorkflowInputSchema = external_exports.object({ runtimeId: RuntimeIdSchema }).strip();
+  }
+});
+
 // ../../packages/schemas/src/session-bindings.ts
 var BINDING_TARGET_TYPES, TRIGGER_BINDING_TARGET_TYPES, OWNER_RELEASABLE_HELD_BINDING_TARGET_TYPES, OBSERVED_TARGET_EVENT_KEYS, SESSION_BINDING_SOURCES, SESSION_BINDING_STATUSES, SESSION_BINDING_RELEASE_POLICIES, SESSION_BINDING_CONTINUITIES, SESSION_BINDING_RELEASED_BY, BINDING_TRANSITION_CAUSES, BindingTargetTypeSchema, TriggerBindingTargetTypeSchema, OwnerReleasableHeldBindingTargetTypeSchema, SessionBindingSourceSchema, SessionBindingStatusSchema, SessionBindingReleasePolicySchema, SessionBindingContinuitySchema, SessionBindingReleasedBySchema, BindingTransitionCauseSchema, BindingTargetSchema, BINDING_AUTO_BIND_VALUES, BindingAutoBindSchema, AUTO_BIND_LEGAL_TARGETS;
 var init_session_bindings = __esm({
@@ -20883,154 +21169,6 @@ var init_identities = __esm({
   }
 });
 
-// ../../packages/schemas/src/environments.ts
-function environmentSetupSchema(cachePathSchema) {
-  return external_exports.object({
-    name: ResourceNameSchema,
-    commands: external_exports.array(external_exports.string().trim().min(1)).min(1),
-    cache: external_exports.object({
-      key: ResourceNameSchema.optional(),
-      files: external_exports.array(
-        external_exports.string().trim().refine(isSafeRelativePath, {
-          message: "Expected a relative path without traversal"
-        })
-      ).default([]),
-      paths: external_exports.array(cachePathSchema).default([])
-    }).strict().default({ files: [], paths: [] })
-  }).strict();
-}
-function environmentSpecSchema({
-  imageSchema,
-  setupSchema
-}) {
-  return external_exports.object({
-    image: imageSchema,
-    env: SecretEnvSchema.default({}),
-    resources: EnvironmentResourcesSchema.optional(),
-    steps: external_exports.array(external_exports.string()).default([]),
-    setup: external_exports.array(setupSchema).default([]),
-    setupCache: EnvironmentSetupCacheSchema.optional(),
-    // Optional rather than defaulted: a default would materialize the key
-    // into stored specs and session environment snapshots the moment the web
-    // app deploys, and this strict schema on a not-yet-deployed worker would
-    // reject those rows (web and workers do not deploy atomically). Absent
-    // means `bypass`; consumers default at the read boundary.
-    approvals: EnvironmentApprovalsSchema.optional()
-  }).strict();
-}
-function isSafeSandboxUserHomePath(value, options = {}) {
-  return (options.allowedHomes ?? [CURRENT_SANDBOX_USER_HOME]).some(
-    (home) => isSafePathUnderHome(value, home)
-  );
-}
-function isSafePathUnderHome(value, home) {
-  const prefix = `${home}/`;
-  if (!value.startsWith(prefix)) {
-    return false;
-  }
-  const relative2 = value.slice(prefix.length);
-  return relative2.split("/").every((segment) => segment !== "" && segment !== "." && segment !== "..");
-}
-function isSafeRelativePath(value) {
-  if (!value || value.startsWith("/")) {
-    return false;
-  }
-  return value.split("/").every((segment) => segment !== "" && segment !== "." && segment !== "..");
-}
-function isSafeBaseImageRef(value) {
-  return !value.startsWith("-") && /^[^\s#\\]+$/.test(value);
-}
-function isSetupCacheTtl(value) {
-  return /^[1-9][0-9]*(s|m|h|d)$/.test(value);
-}
-var RESOURCE_KIND_ENVIRONMENT, CURRENT_SANDBOX_USER_HOME, LEGACY_SANDBOX_USER_HOMES, STORED_SANDBOX_USER_HOMES, EnvironmentSetupCachePathSchema, StoredEnvironmentSetupCachePathSchema, EnvironmentImageSchema, StoredEnvironmentImageSchema, ENVIRONMENT_APPROVALS_MODES, EnvironmentApprovalsSchema, EnvironmentSetupSchema, EnvironmentApplySetupSchema, EnvironmentSetupCacheSchema, EnvironmentResourcesSchema, EnvironmentSpecSchema, EnvironmentApplySpecSchema, EnvironmentResourceSchema, EnvironmentApplyRequestSchema;
-var init_environments = __esm({
-  "../../packages/schemas/src/environments.ts"() {
-    "use strict";
-    init_zod();
-    init_resources();
-    init_secrets();
-    RESOURCE_KIND_ENVIRONMENT = "environment";
-    CURRENT_SANDBOX_USER_HOME = "/home/user";
-    LEGACY_SANDBOX_USER_HOMES = ["/home/auto", "/home/node"];
-    STORED_SANDBOX_USER_HOMES = [
-      CURRENT_SANDBOX_USER_HOME,
-      ...LEGACY_SANDBOX_USER_HOMES
-    ];
-    EnvironmentSetupCachePathSchema = external_exports.string().trim().refine((value) => isSafeSandboxUserHomePath(value), {
-      message: `Expected an absolute path under ${CURRENT_SANDBOX_USER_HOME}`
-    });
-    StoredEnvironmentSetupCachePathSchema = external_exports.string().trim().refine(
-      (value) => isSafeSandboxUserHomePath(value, {
-        allowedHomes: STORED_SANDBOX_USER_HOMES
-      }),
-      {
-        message: `Expected an absolute path under ${CURRENT_SANDBOX_USER_HOME}`
-      }
-    );
-    EnvironmentImageSchema = external_exports.discriminatedUnion("kind", [
-      external_exports.object({
-        kind: external_exports.literal("preset"),
-        name: ResourceNameSchema
-      }).strict(),
-      external_exports.object({
-        kind: external_exports.literal("base"),
-        ref: external_exports.string().trim().min(1).max(512).refine(isSafeBaseImageRef, {
-          message: "Expected a single Docker/OCI image reference"
-        })
-      }).strict()
-    ]);
-    StoredEnvironmentImageSchema = external_exports.discriminatedUnion("kind", [
-      external_exports.object({
-        kind: external_exports.literal("preset"),
-        name: external_exports.string().trim().min(1)
-      }).strict(),
-      external_exports.object({
-        kind: external_exports.literal("base"),
-        ref: external_exports.string().trim().min(1).refine(isSafeBaseImageRef, {
-          message: "Expected a single Docker/OCI image reference"
-        })
-      }).strict()
-    ]);
-    ENVIRONMENT_APPROVALS_MODES = ["bypass", "prompt"];
-    EnvironmentApprovalsSchema = external_exports.enum(ENVIRONMENT_APPROVALS_MODES);
-    EnvironmentSetupSchema = environmentSetupSchema(
-      StoredEnvironmentSetupCachePathSchema
-    );
-    EnvironmentApplySetupSchema = environmentSetupSchema(
-      EnvironmentSetupCachePathSchema
-    );
-    EnvironmentSetupCacheSchema = external_exports.object({
-      ttl: external_exports.string().trim().refine(isSetupCacheTtl, {
-        message: "Expected a positive setup cache TTL such as 30m, 24h, or 7d"
-      })
-    }).strict();
-    EnvironmentResourcesSchema = external_exports.object({
-      cpuCount: external_exports.number().int().min(1).optional(),
-      memoryMB: external_exports.number().int().min(128).optional()
-    }).strict().refine(
-      (resources) => resources.cpuCount !== void 0 || resources.memoryMB !== void 0,
-      {
-        message: "Expected at least one runtime resource setting"
-      }
-    );
-    EnvironmentSpecSchema = environmentSpecSchema({
-      imageSchema: StoredEnvironmentImageSchema,
-      setupSchema: EnvironmentSetupSchema
-    });
-    EnvironmentApplySpecSchema = environmentSpecSchema({
-      imageSchema: EnvironmentImageSchema,
-      setupSchema: EnvironmentApplySetupSchema
-    });
-    EnvironmentResourceSchema = resourceEnvelopeSchema(
-      EnvironmentSpecSchema
-    );
-    EnvironmentApplyRequestSchema = resourceApplySchema(
-      EnvironmentApplySpecSchema
-    );
-  }
-});
-
 // ../../packages/schemas/src/environment-setup-failures.ts
 var EnvironmentSetupStepFailureDiagnosticSchema, PersistedEnvironmentSetupStepFailureDiagnosticSchema;
 var init_environment_setup_failures = __esm({
@@ -90213,6 +90351,7 @@ var init_src = __esm({
     init_github_sync();
     init_github_credentials();
     init_github_mcp_catalog();
+    init_hosted_runtimes();
     init_identities();
     init_ids();
     init_environments();
@@ -93030,7 +93169,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@autohq/cli",
-      version: "0.1.609",
+      version: "0.1.611",
       license: "SEE LICENSE IN README.md",
       publishConfig: {
         access: "public"
@@ -106463,9 +106602,170 @@ import { readUIMessageStream } from "ai";
 
 // src/commands/agent-bridge/harness/envelope-bounds.ts
 import { Buffer as Buffer2 } from "buffer";
+
+// src/commands/agent-bridge/harness/mcp-result-canonicalization.ts
+function canonicalizeEnvelopeMcpResults(envelope) {
+  switch (envelope.type) {
+    case "conversation.entry": {
+      const content = canonicalizeMcpResultValue(envelope.content);
+      return toCanonicalizedEnvelope(
+        envelope,
+        { ...envelope, content: content.value },
+        content.deduplicatedBranches
+      );
+    }
+    case "conversation.delta": {
+      const delta = canonicalizeMcpResultValue(envelope.delta);
+      return toCanonicalizedEnvelope(
+        envelope,
+        { ...envelope, delta: delta.value },
+        delta.deduplicatedBranches
+      );
+    }
+    case "ui.message.chunk": {
+      const chunk = canonicalizeMcpResultValue(envelope.chunk);
+      return toCanonicalizedEnvelope(
+        envelope,
+        { ...envelope, chunk: chunk.value },
+        chunk.deduplicatedBranches
+      );
+    }
+    case "ui.message.part": {
+      const part = canonicalizeMcpResultValue(envelope.part);
+      const metadata = canonicalizeMcpResultValue(envelope.messageMetadata);
+      const deduplicatedBranches = part.deduplicatedBranches + metadata.deduplicatedBranches;
+      return toCanonicalizedEnvelope(
+        envelope,
+        {
+          ...envelope,
+          part: part.value,
+          ...envelope.messageMetadata === void 0 ? {} : { messageMetadata: metadata.value }
+        },
+        deduplicatedBranches
+      );
+    }
+    case "ui.message.completed": {
+      const message = canonicalizeMcpResultValue(envelope.message);
+      return toCanonicalizedEnvelope(
+        envelope,
+        { ...envelope, message: message.value },
+        message.deduplicatedBranches
+      );
+    }
+    case "runtime.liveness":
+    case "runtime.usage_turn":
+      return { value: envelope, deduplicatedBranches: 0 };
+  }
+}
+function toCanonicalizedEnvelope(original, candidate, deduplicatedBranches) {
+  return {
+    value: deduplicatedBranches > 0 ? RuntimeBridgeOutputEnvelopeSchema.parse(candidate) : original,
+    deduplicatedBranches
+  };
+}
+function canonicalizeMcpResultValue(value) {
+  if (Array.isArray(value)) {
+    let deduplicatedBranches2 = 0;
+    let changed2 = false;
+    const items = value.map((item) => {
+      const canonical2 = canonicalizeMcpResultValue(item);
+      deduplicatedBranches2 += canonical2.deduplicatedBranches;
+      changed2 ||= canonical2.value !== item;
+      return canonical2.value;
+    });
+    return {
+      value: changed2 ? items : value,
+      deduplicatedBranches: deduplicatedBranches2
+    };
+  }
+  if (typeof value !== "object" || value === null) {
+    return { value, deduplicatedBranches: 0 };
+  }
+  const record2 = value;
+  const duplicateContentIndexes = equivalentMcpTextContentIndexes(record2);
+  let deduplicatedBranches = duplicateContentIndexes.size;
+  let changed = duplicateContentIndexes.size > 0;
+  const canonical = /* @__PURE__ */ Object.create(null);
+  for (const [key, item] of Object.entries(record2)) {
+    if (key === "content" && Array.isArray(item)) {
+      const retainedContent = duplicateContentIndexes.size > 0 ? item.filter(
+        (_contentItem, index) => !duplicateContentIndexes.has(index)
+      ) : item;
+      if (retainedContent.length === 0 && duplicateContentIndexes.size > 0) {
+        continue;
+      }
+      const content = canonicalizeMcpResultValue(retainedContent);
+      canonical[key] = content.value;
+      deduplicatedBranches += content.deduplicatedBranches;
+      changed ||= content.value !== item;
+      continue;
+    }
+    const child = canonicalizeMcpResultValue(item);
+    canonical[key] = child.value;
+    deduplicatedBranches += child.deduplicatedBranches;
+    changed ||= child.value !== item;
+  }
+  return {
+    value: changed ? canonical : value,
+    deduplicatedBranches
+  };
+}
+function equivalentMcpTextContentIndexes(value) {
+  if (!Array.isArray(value.content) || !Object.hasOwn(value, "structuredContent") || value.structuredContent === void 0) {
+    return /* @__PURE__ */ new Set();
+  }
+  const indexes = /* @__PURE__ */ new Set();
+  for (const [index, item] of value.content.entries()) {
+    if (!isPlainMcpTextBlock(item)) {
+      continue;
+    }
+    const parsed = parseJson(item.text);
+    if (parsed.parsed && jsonValuesEqual(parsed.value, value.structuredContent)) {
+      indexes.add(index);
+    }
+  }
+  return indexes;
+}
+function isPlainMcpTextBlock(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const record2 = value;
+  const keys = Object.keys(record2);
+  return keys.length === 2 && record2.type === "text" && typeof record2.text === "string";
+}
+function parseJson(value) {
+  try {
+    return { parsed: true, value: JSON.parse(value) };
+  } catch {
+    return { parsed: false, value: null };
+  }
+}
+function jsonValuesEqual(left, right) {
+  if (Object.is(left, right)) {
+    return true;
+  }
+  if (Array.isArray(left) || Array.isArray(right)) {
+    if (!Array.isArray(left) || !Array.isArray(right)) {
+      return false;
+    }
+    return left.length === right.length && left.every((item, index) => jsonValuesEqual(item, right[index]));
+  }
+  if (typeof left !== "object" || left === null || typeof right !== "object" || right === null) {
+    return false;
+  }
+  const leftRecord = left;
+  const rightRecord = right;
+  const leftKeys = Object.keys(leftRecord);
+  const rightKeys = Object.keys(rightRecord);
+  return leftKeys.length === rightKeys.length && leftKeys.every(
+    (key) => Object.hasOwn(rightRecord, key) && jsonValuesEqual(leftRecord[key], rightRecord[key])
+  );
+}
+
+// src/commands/agent-bridge/harness/envelope-bounds.ts
 var AGENT_BRIDGE_OUTPUT_MAX_ENVELOPE_BYTES = 512 * 1024;
 var AGENT_BRIDGE_OUTPUT_QUARANTINE_MAX_ENVELOPE_BYTES = 8 * 1024;
-var MAX_TARGETED_PAYLOAD_NOTICES = 4;
 var PAYLOAD_FIELD_RULES = {
   output: { label: "tool output", priority: 0 },
   errorText: { label: "tool error", priority: 0 },
@@ -106500,48 +106800,97 @@ var STRUCTURAL_STRING_FIELDS = /* @__PURE__ */ new Set([
   "completedAt"
 ]);
 function boundOutputEnvelope(envelope, maxBytes = AGENT_BRIDGE_OUTPUT_MAX_ENVELOPE_BYTES) {
-  const originalBytes = serializedByteLength(envelope);
+  const original = envelopeSerializationInfo(envelope);
+  const originalBytes = original.bytes;
   if (originalBytes <= maxBytes) {
-    return { envelope, originalBytes, truncated: false };
+    return {
+      envelope,
+      originalBytes,
+      boundedBytes: originalBytes,
+      kind: "none",
+      deduplicatedMcpResultBranches: 0,
+      truncated: false
+    };
+  }
+  const canonicalized = original.hasStructuredContent ? canonicalizeEnvelopeMcpResults(envelope) : { value: envelope, deduplicatedBranches: 0 };
+  const canonicalEnvelope = canonicalized.value;
+  const canonicalBytes = serializedByteLength(canonicalEnvelope);
+  if (canonicalBytes <= maxBytes) {
+    return {
+      envelope: canonicalEnvelope,
+      originalBytes,
+      boundedBytes: canonicalBytes,
+      kind: "mcp-result-deduplicated",
+      deduplicatedMcpResultBranches: canonicalized.deduplicatedBranches,
+      truncated: true
+    };
   }
-  const targeted = truncatePayloads(envelope, maxBytes);
+  const targeted = truncatePayloads(canonicalEnvelope, maxBytes);
   if (targeted) {
+    const boundedEnvelope = RuntimeBridgeOutputEnvelopeSchema.parse(targeted);
     return {
-      envelope: RuntimeBridgeOutputEnvelopeSchema.parse(targeted),
+      envelope: boundedEnvelope,
       originalBytes,
+      boundedBytes: serializedByteLength(boundedEnvelope),
+      kind: canonicalized.deduplicatedBranches > 0 ? "mcp-result-deduplicated+targeted-truncation" : "targeted-truncation",
+      deduplicatedMcpResultBranches: canonicalized.deduplicatedBranches,
       truncated: true
     };
   }
+  const fallbackEnvelope = RuntimeBridgeOutputEnvelopeSchema.parse(
+    replacePayloadWithMarker(canonicalEnvelope)
+  );
   return {
-    envelope: RuntimeBridgeOutputEnvelopeSchema.parse(
-      replacePayloadWithMarker(envelope)
-    ),
+    envelope: fallbackEnvelope,
     originalBytes,
+    boundedBytes: serializedByteLength(fallbackEnvelope),
+    kind: canonicalized.deduplicatedBranches > 0 ? "mcp-result-deduplicated+payload-fallback" : "payload-fallback",
+    deduplicatedMcpResultBranches: canonicalized.deduplicatedBranches,
     truncated: true
   };
 }
 function truncatePayloads(envelope, maxBytes) {
   const candidateEnvelope = structuredClone(envelope);
   const candidates = collectPayloadCandidates(envelope);
-  for (let noticeCount = 0; noticeCount < MAX_TARGETED_PAYLOAD_NOTICES; noticeCount += 1) {
+  const truncatedCandidates = [];
+  while (true) {
     const currentBytes = serializedByteLength(candidateEnvelope);
     if (currentBytes <= maxBytes) {
       return candidateEnvelope;
     }
     const candidate = takePayloadCandidate(candidates, currentBytes - maxBytes);
     if (!candidate) {
-      return null;
+      break;
     }
     setValueAtPath(
       candidateEnvelope,
       candidate.path,
       truncationNotice(candidate, "")
     );
-    if (serializedByteLength(candidateEnvelope) <= maxBytes) {
+    const truncatedBytes = serializedByteLength(candidateEnvelope);
+    if (truncatedBytes >= currentBytes) {
+      setValueAtPath(candidateEnvelope, candidate.path, candidate.value);
+      continue;
+    }
+    truncatedCandidates.push(candidate);
+    if (truncatedBytes <= maxBytes) {
       maximizePreview(candidateEnvelope, candidate, maxBytes);
       return candidateEnvelope;
     }
   }
+  for (const candidate of truncatedCandidates) {
+    setValueAtPath(
+      candidateEnvelope,
+      candidate.path,
+      compactTruncationNotice(candidate)
+    );
+  }
+  if (serializedByteLength(candidateEnvelope) <= maxBytes) {
+    return candidateEnvelope;
+  }
+  for (const candidate of truncatedCandidates) {
+    setValueAtPath(candidateEnvelope, candidate.path, "");
+  }
   return serializedByteLength(candidateEnvelope) <= maxBytes ? candidateEnvelope : null;
 }
 function collectPayloadCandidates(envelope) {
@@ -106706,10 +107055,20 @@ function truncationNotice(candidate, preview2) {
   const separator = preview2.length > 0 ? "\n" : "";
   return `${preview2}${separator}[agent-bridge ${candidate.label} truncated: original ${candidate.originalBytes} UTF-8 bytes; kept ${keptBytes}; omitted ${omittedBytes}. Omitted content was not persisted in this transcript.]`;
 }
+function compactTruncationNotice(candidate) {
+  return `[agent-bridge ${candidate.label} truncated: original ${candidate.originalBytes} UTF-8 bytes.]`;
+}
 function serializedByteLength(value) {
   const serialized = JSON.stringify(value);
   return serialized === void 0 ? 0 : Buffer2.byteLength(serialized, "utf8");
 }
+function envelopeSerializationInfo(envelope) {
+  const serialized = JSON.stringify(envelope);
+  return {
+    bytes: Buffer2.byteLength(serialized, "utf8"),
+    hasStructuredContent: serialized.includes('"structuredContent":')
+  };
+}
 function replacePayloadWithMarker(envelope) {
   switch (envelope.type) {
     case "conversation.entry": {
@@ -107671,6 +108030,9 @@ var AgentBridgeOutputBuffer = class {
         "agent_bridge_output_envelope_truncated",
         this.outputLogContext(bounded.envelope, {
           original_bytes: bounded.originalBytes,
+          bounded_bytes: bounded.boundedBytes,
+          bound_kind: bounded.kind,
+          deduplicated_mcp_result_branches: bounded.deduplicatedMcpResultBranches,
           pending_count: this.pendingOutputs.size
         })
       );
@@ -107704,6 +108066,9 @@ var AgentBridgeOutputBuffer = class {
       this.outputLogContext(bounded.envelope, {
         exhausts,
         original_bytes: bounded.originalBytes,
+        bounded_bytes: bounded.boundedBytes,
+        bound_kind: bounded.kind,
+        deduplicated_mcp_result_branches: bounded.deduplicatedMcpResultBranches,
         truncated: bounded.truncated,
         pending_count: this.pendingOutputs.size
       })