@codexhost/cli-win32-arm64 0.8.0 → 0.9.1

package/app/plugins/codebuddy/plugin.mjs

@@ -5,9 +5,6 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// dist/codebuddy-adapter.js
-import { stat as stat2 } from "node:fs/promises";
-
 // ../../../node_modules/zod/v4/classic/external.js
 var external_exports = {};
 __export(external_exports, {
@@ -774,10 +771,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path7) {
-  if (!path7)
+function getElementAtPath(obj, path8) {
+  if (!path8)
     return obj;
-  return path7.reduce((acc, key) => acc?.[key], obj);
+  return path8.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1186,11 +1183,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path7, issues) {
+function prefixIssues(path8, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path7);
+    iss.path.unshift(path8);
     return iss;
   });
 }
@@ -1337,16 +1334,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path7 = []) => {
+  const processError = (error52, path8 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path7, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path8, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
       } else {
-        const fullpath = [...path7, ...issue2.path];
+        const fullpath = [...path8, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -1373,17 +1370,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path7 = []) => {
+  const processError = (error52, path8 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path7, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path8, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
       } else {
-        const fullpath = [...path7, ...issue2.path];
+        const fullpath = [...path8, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -1415,8 +1412,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path7 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path7) {
+  const path8 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path8) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -14108,13 +14105,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path7 = ref.slice(1).split("/").filter(Boolean);
-  if (path7.length === 0) {
+  const path8 = ref.slice(1).split("/").filter(Boolean);
+  if (path8.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path7[0] === defsKey) {
-    const key = path7[1];
+  if (path8[0] === defsKey) {
+    const key = path8[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -14525,6 +14522,46 @@ config(en_default());
 // ../../shared-contracts/dist/version.js
 var WORKSPACE_CONTRACT_VERSION = 1;
 
+// ../../shared-contracts/dist/idle-release.js
+var IDLE_RELEASE_TIMEOUT_MINUTES_MIN = 5;
+var IDLE_RELEASE_TIMEOUT_MINUTES_MAX = 1440;
+var idleReleaseSettingsSchema = external_exports.strictObject({
+  enabled: external_exports.boolean(),
+  timeoutMinutes: external_exports.number().int().min(IDLE_RELEASE_TIMEOUT_MINUTES_MIN).max(IDLE_RELEASE_TIMEOUT_MINUTES_MAX)
+});
+var DEFAULT_IDLE_RELEASE_SETTINGS = Object.freeze({
+  enabled: false,
+  timeoutMinutes: 30
+});
+
+// ../../shared-contracts/dist/loaded-sessions.js
+var loadedSessionStateSchema = external_exports.enum([
+  "idle",
+  "running",
+  "busy",
+  "closing",
+  "failed",
+  "blocked"
+]);
+var loadedSessionReasonSchema = external_exports.enum([
+  "none",
+  "disabled",
+  "timeout",
+  "operation",
+  "background",
+  "identity",
+  "persistence",
+  "closeFailed"
+]);
+var loadedSessionsSchema = external_exports.array(external_exports.strictObject({
+  threadId: external_exports.string(),
+  title: external_exports.string(),
+  harnessId: external_exports.string(),
+  state: loadedSessionStateSchema,
+  reason: loadedSessionReasonSchema,
+  inactiveMs: external_exports.number().nonnegative()
+}));
+
 // ../../shared-contracts/dist/ids.js
 var opaqueIdSchema = external_exports.string().refine((value) => value.trim().length > 0, {
   message: "Identifier must not be empty or whitespace"
@@ -15010,6 +15047,8 @@ var pluginPresentationShape = {
   id: harnessPluginIdSchema,
   name: external_exports.string().trim().min(1).max(128),
   version: external_exports.string().min(1).max(128),
+  /** The factory accepts a persisted local entrypoint through its construction context. */
+  launchCommand: external_exports.literal(true).optional(),
   links: external_exports.object({
     documentation: documentationUrlSchema.optional(),
     installation: documentationUrlSchema.optional()
@@ -15047,6 +15086,19 @@ var harnessPluginRouteSchema = external_exports.object({
   permissionModeId: harnessPermissionModeIdSchema.optional()
 }).strict();
 
+// ../../shared-contracts/dist/harness-launch-settings.js
+var harnessLaunchPathSchema = external_exports.string().trim().min(1).max(4096).refine((value) => !/[\u0000\r\n]/u.test(value), "Invalid entrypoint path");
+var harnessLaunchSettingsGetSchema = external_exports.object({
+  harnessId: harnessPluginIdSchema
+}).strict();
+var harnessLaunchSettingsSetSchema = harnessLaunchSettingsGetSchema.extend({
+  path: harnessLaunchPathSchema.nullable()
+});
+var harnessLaunchSettingsSchema = external_exports.object({
+  path: harnessLaunchPathSchema.nullable(),
+  restartRequired: external_exports.boolean()
+}).strict();
+
 // ../../shared-contracts/dist/codex-accounts.js
 var accountIdSchema = external_exports.string().min(1).max(256).regex(/^[A-Za-z0-9._~-]+$/u);
 var nonBlankTextSchema3 = external_exports.string().trim().min(1);
@@ -15075,75 +15127,15 @@ var codexAccountSchema = external_exports.object({
   email: external_exports.string().email().max(320).optional(),
   planType: codexAccountPlanTypeSchema.optional()
 }).strict();
-var codexAccountPhaseSchema = external_exports.enum(["ready", "changing", "unavailable"]);
-var codexAccountPendingOperationSchema = external_exports.object({
-  operationId: nonBlankTextSchema3.max(1024),
-  kind: external_exports.enum(["login", "switch", "logout", "recovery"])
-}).strict();
-var codexAccountCapabilitiesSchema = external_exports.object({
-  manage: external_exports.boolean(),
-  switch: external_exports.boolean(),
-  login: external_exports.boolean(),
-  delete: external_exports.boolean(),
-  recover: external_exports.boolean().optional(),
-  logout: external_exports.boolean().optional(),
-  reason: external_exports.enum([
-    "ssh-single-account",
-    "unsupported-storage",
-    "unsupported-version",
-    "recovery-required",
-    "keyring-unavailable",
-    "migration-required"
-  ]).optional()
-}).strict();
+var codexAccountPhaseSchema = external_exports.enum(["ready", "unavailable"]);
 var codexAccountListResultSchema = external_exports.object({
   version: external_exports.literal(2),
   currentAccountId: accountIdSchema.nullable(),
   phase: codexAccountPhaseSchema,
   revision: external_exports.number().int().nonnegative(),
   instanceId: nonBlankTextSchema3.max(1024).optional(),
-  cleanupRequired: external_exports.boolean().optional(),
-  /** Credentials were adopted; other native homes/history remain unmerged. */
-  legacyHistoryPreserved: external_exports.boolean().optional(),
-  pendingOperation: codexAccountPendingOperationSchema.optional(),
-  capabilities: codexAccountCapabilitiesSchema,
-  accounts: external_exports.array(codexAccountSchema).max(128)
+  accounts: external_exports.array(codexAccountSchema).max(1)
 }).strict();
-var codexAccountActivateParamsSchema = external_exports.object({ accountId: accountIdSchema }).strict();
-var codexAccountSwitchParamsSchema = external_exports.object({ accountId: accountIdSchema }).strict();
-var codexAccountReadyMutationResultShape = {
-  phase: external_exports.literal("ready"),
-  revision: external_exports.number().int().nonnegative()
-};
-var codexAccountSwitchResultSchema = external_exports.object({
-  currentAccountId: accountIdSchema,
-  ...codexAccountReadyMutationResultShape
-}).strict();
-var codexAccountDeleteParamsSchema = external_exports.object({ accountId: accountIdSchema }).strict();
-var codexAccountDeleteResultSchema = external_exports.object({ deletedAccountId: accountIdSchema }).strict();
-var codexAccountLoginStartParamsSchema = external_exports.object({ accountId: accountIdSchema.optional() }).strict();
-var codexAccountLoginStartResultSchema = external_exports.object({
-  accountId: accountIdSchema,
-  loginId: nonBlankTextSchema3.max(1024),
-  verificationUrl: external_exports.string().url().max(16384),
-  userCode: nonBlankTextSchema3.max(1024)
-}).strict();
-var codexAccountLoginCancelParamsSchema = external_exports.object({ loginId: nonBlankTextSchema3.max(1024) }).strict();
-var codexAccountLoginCancelResultSchema = external_exports.object({ cancelled: external_exports.boolean() }).strict();
-var codexAccountLoginCompletedSchema = external_exports.object({
-  accountId: accountIdSchema,
-  loginId: nonBlankTextSchema3.max(1024),
-  success: external_exports.boolean(),
-  error: external_exports.string().max(4096).nullable(),
-  saved: external_exports.boolean().optional(),
-  cleanupRequired: external_exports.boolean().optional()
-}).strict();
-var codexAccountLogoutParamsSchema = external_exports.object({}).strict();
-var codexAccountLogoutResultSchema = external_exports.object({
-  currentAccountId: external_exports.null(),
-  ...codexAccountReadyMutationResultShape
-}).strict();
-var codexAccountRecoverParamsSchema = external_exports.object({}).strict();
 var codexAccountUsageParamsSchema = external_exports.object({ accountId: accountIdSchema, refresh: external_exports.boolean().optional() }).strict();
 var codexAccountUsageResultSchema = external_exports.object({
   accountId: accountIdSchema,
@@ -15152,21 +15144,6 @@ var codexAccountUsageResultSchema = external_exports.object({
   freshness: external_exports.enum(["live", "cached"]),
   observedAt: external_exports.string().datetime().nullable()
 }).strict();
-var codexAccountResetCreditConsumeParamsSchema = external_exports.object({
-  accountId: accountIdSchema,
-  idempotencyKey: external_exports.string().uuid().optional()
-}).strict();
-var codexAccountResetCreditConsumeOutcomeSchema = external_exports.enum([
-  "reset",
-  "nothingToReset",
-  "noCredit",
-  "alreadyRedeemed"
-]);
-var codexAccountResetCreditConsumeResultSchema = external_exports.object({
-  accountId: accountIdSchema,
-  outcome: codexAccountResetCreditConsumeOutcomeSchema,
-  accountCredits: accountCreditsSnapshotSchema.optional()
-}).strict();
 
 // ../../shared-contracts/dist/harness-session-import.js
 var HARNESS_SESSION_IMPORT_ID_MAX_LENGTH = 1024;
@@ -15409,193 +15386,534 @@ var updateStatusResultSchema = external_exports.strictObject({
 // ../../shared-contracts/dist/index.js
 var workspaceContractVersionSchema = external_exports.literal(WORKSPACE_CONTRACT_VERSION);
 
-// dist/acp-client.js
-import { execFile, spawn } from "node:child_process";
-import { Readable, Writable } from "node:stream";
-
-// ../../../node_modules/@agentclientprotocol/sdk/dist/schema/index.js
-var AGENT_METHODS = {
-  initialize: "initialize",
-  authenticate: "authenticate",
-  providers_list: "providers/list",
-  providers_set: "providers/set",
-  providers_disable: "providers/disable",
-  session_new: "session/new",
-  session_load: "session/load",
-  session_set_mode: "session/set_mode",
-  session_set_config_option: "session/set_config_option",
-  session_prompt: "session/prompt",
-  session_cancel: "session/cancel",
-  mcp_message: "mcp/message",
-  session_list: "session/list",
-  session_delete: "session/delete",
-  session_fork: "session/fork",
-  session_resume: "session/resume",
-  session_close: "session/close",
-  logout: "logout",
-  nes_start: "nes/start",
-  nes_suggest: "nes/suggest",
-  nes_accept: "nes/accept",
-  nes_reject: "nes/reject",
-  nes_close: "nes/close",
-  document_did_open: "document/didOpen",
-  document_did_change: "document/didChange",
-  document_did_close: "document/didClose",
-  document_did_save: "document/didSave",
-  document_did_focus: "document/didFocus"
-};
-var CLIENT_METHODS = {
-  session_request_permission: "session/request_permission",
-  session_update: "session/update",
-  fs_write_text_file: "fs/write_text_file",
-  fs_read_text_file: "fs/read_text_file",
-  terminal_create: "terminal/create",
-  terminal_output: "terminal/output",
-  terminal_release: "terminal/release",
-  terminal_wait_for_exit: "terminal/wait_for_exit",
-  terminal_kill: "terminal/kill",
-  mcp_connect: "mcp/connect",
-  mcp_message: "mcp/message",
-  mcp_disconnect: "mcp/disconnect",
-  elicitation_create: "elicitation/create",
-  elicitation_complete: "elicitation/complete"
-};
-var PROTOCOL_METHODS = {
-  cancel_request: "$/cancel_request"
-};
-
-// ../../../node_modules/@agentclientprotocol/sdk/dist/schema-deserialize.js
-var skippedItem = /* @__PURE__ */ Symbol("skippedItem");
-function defaultOnError(schema, fallback) {
-  return schema.catch(fallback);
+// ../../harness-adapter/dist/approval.js
+function invalidRequest(message) {
+  return { code: "invalidRequest", message, retryable: false };
 }
-function requiredDefaultOnError(schema, fallback) {
-  const schemaWithCatch = schema.catch(fallback);
-  return external_exports.unknown().transform((value, context) => {
-    if (value !== void 0)
-      return schemaWithCatch.parse(value);
-    context.addIssue({
-      code: "custom",
-      message: "Required value is missing"
-    });
-    return external_exports.NEVER;
-  });
+function validateHostApprovalResponse(interaction, response) {
+  return interaction.actions.some(({ id }) => id === response.actionId) ? null : invalidRequest("Approval Response contains an undeclared action ID");
 }
-function stringTag(value, key) {
-  if (value === null || typeof value !== "object" || Array.isArray(value)) {
-    return void 0;
-  }
-  const tag = value[key];
-  return typeof tag === "string" ? tag : void 0;
+
+// ../../harness-adapter/dist/question.js
+function invalidRequest2(message) {
+  return { code: "invalidRequest", message, retryable: false };
 }
-function excludeKnownTags(schema, key, knownTags) {
-  return schema.superRefine((value, context) => {
-    const tag = stringTag(value, key);
-    if (tag !== void 0 && knownTags.includes(tag)) {
-      context.addIssue({
-        code: "custom",
-        path: [key],
-        message: `${key} ${JSON.stringify(tag)} is reserved by a known variant, but the value does not match that variant's schema`
-      });
+function validateHostQuestionResponse(interaction, response) {
+  const questionIds = new Set(interaction.questions.map(({ id }) => id));
+  if (response.cancelled) {
+    return Object.keys(response.answers).length === 0 ? null : invalidRequest2("Cancelled Question Response must not contain answers");
+  }
+  for (const answerId of Object.keys(response.answers)) {
+    if (!questionIds.has(answerId)) {
+      return invalidRequest2("Question Response contains an unknown Question ID");
     }
-  });
-}
-function preserveCustomPayload(schema, key, knownTags) {
-  return external_exports.unknown().transform((value, context) => {
-    const result = schema.safeParse(value);
-    if (!result.success) {
-      for (const issue2 of result.error.issues) {
-        context.addIssue({ ...issue2, input: value });
-      }
-      return external_exports.NEVER;
+  }
+  for (const question of interaction.questions) {
+    const answers = response.answers[question.id] ?? [];
+    if (!question.optional && answers.length === 0) {
+      return invalidRequest2("Question Response omits a required answer");
     }
-    const output = result.data;
-    const tag = stringTag(value, key);
-    if (tag !== void 0 && !knownTags.includes(tag)) {
-      const raw = value;
-      for (const [property, rawValue] of Object.entries(raw)) {
-        if (property === "__proto__")
-          continue;
-        if (!Object.hasOwn(output, property))
-          output[property] = rawValue;
+    if (question.type === "text") {
+      if (answers.length > 1) {
+        return invalidRequest2("Text Question accepts at most one answer");
       }
+      continue;
     }
-    return output;
-  });
+    if (!question.multiple && answers.length > 1) {
+      return invalidRequest2("Single-choice Question accepts at most one answer");
+    }
+    const declared = new Set(question.options.map(({ value }) => value));
+    if (!question.allowOther && answers.some((answer) => !declared.has(answer))) {
+      return invalidRequest2("Question Response contains an undeclared choice");
+    }
+  }
+  return null;
 }
-function vecSkipError(itemSchema) {
-  return external_exports.array(itemSchema.catch(skippedItem)).transform((items) => items.filter((item) => item !== skippedItem));
+
+// ../../harness-adapter/dist/interaction.js
+function invalidRequest3(message) {
+  return { code: "invalidRequest", message, retryable: false };
+}
+function invalidState(message) {
+  return { code: "invalidState", message, retryable: false };
+}
+function validateHostInteractionResponse(interaction, response) {
+  if (!interaction) {
+    return invalidState("Interaction Response must reference a pending Interaction");
+  }
+  if (interaction.type === "question") {
+    return response.type === "question" ? validateHostQuestionResponse(interaction, response) : invalidRequest3("Interaction Response type does not match the pending Interaction");
+  }
+  return response.type === "approval" ? validateHostApprovalResponse(interaction, response) : invalidRequest3("Interaction Response type does not match the pending Interaction");
 }
 
-// ../../../node_modules/@agentclientprotocol/sdk/dist/schema/zod.gen.js
-var zRequestId = union([number2(), string2()]).nullable();
-var zSessionId = string2();
-var zWriteTextFileRequest = object({
-  sessionId: zSessionId,
-  path: string2(),
-  content: string2(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => void 0)
-});
-var zReadTextFileRequest = object({
-  sessionId: zSessionId,
-  path: string2(),
-  line: defaultOnError(int().gte(0).max(4294967295, {
-    error: "Invalid value: Expected uint32 to be <= 4294967295"
-  }).nullish(), () => void 0),
-  limit: defaultOnError(int().gte(0).max(4294967295, {
-    error: "Invalid value: Expected uint32 to be <= 4294967295"
-  }).nullish(), () => void 0),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => void 0)
-});
-var zToolCallId = string2();
-var zToolKind = union([
-  literal("read"),
-  literal("edit"),
-  literal("delete"),
-  literal("move"),
-  literal("search"),
-  literal("execute"),
-  literal("think"),
-  literal("fetch"),
-  literal("switch_mode"),
-  literal("other")
-]);
-var zToolCallStatus = union([
-  literal("pending"),
-  literal("in_progress"),
-  literal("completed"),
-  literal("failed")
-]);
-var zRole = union([literal("assistant"), literal("user")]);
-var zAnnotations = object({
-  audience: defaultOnError(vecSkipError(zRole).nullish(), () => void 0),
-  lastModified: defaultOnError(string2().nullish(), () => void 0),
-  priority: defaultOnError(number2().nullish(), () => void 0),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => void 0)
-});
-var zTextContent = object({
-  annotations: defaultOnError(zAnnotations.nullish(), () => void 0),
-  text: string2(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => void 0)
-});
-var zImageContent = object({
-  annotations: defaultOnError(zAnnotations.nullish(), () => void 0),
-  data: string2(),
-  mimeType: string2(),
-  uri: defaultOnError(string2().nullish(), () => void 0),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => void 0)
-});
-var zAudioContent = object({
-  annotations: defaultOnError(zAnnotations.nullish(), () => void 0),
-  data: string2(),
-  mimeType: string2(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => void 0)
-});
-var zResourceLink = object({
-  annotations: defaultOnError(zAnnotations.nullish(), () => void 0),
-  description: defaultOnError(string2().nullish(), () => void 0),
-  mimeType: defaultOnError(string2().nullish(), () => void 0),
-  name: string2(),
+// ../../harness-adapter/dist/output-channel.js
+var HarnessOutputChannel = class {
+  outputs;
+  #consumerCreated = false;
+  #ended = false;
+  #pending = [];
+  #values = [];
+  constructor() {
+    this.outputs = {
+      [Symbol.asyncIterator]: () => {
+        if (this.#consumerCreated) {
+          throw new Error("Harness outputs allow only one consumer");
+        }
+        this.#consumerCreated = true;
+        return {
+          next: () => this.#next()
+        };
+      }
+    };
+  }
+  emit(value) {
+    if (this.#ended)
+      return false;
+    const resolve = this.#pending.shift();
+    if (resolve)
+      resolve({ done: false, value });
+    else
+      this.#values.push(value);
+    return true;
+  }
+  end() {
+    if (this.#ended)
+      return;
+    this.#ended = true;
+    if (this.#values.length !== 0)
+      return;
+    for (const resolve of this.#pending.splice(0))
+      resolve({ done: true, value: void 0 });
+  }
+  #next() {
+    const value = this.#values.shift();
+    if (value !== void 0)
+      return Promise.resolve({ done: false, value });
+    if (this.#ended)
+      return Promise.resolve({ done: true, value: void 0 });
+    return new Promise((resolve) => this.#pending.push(resolve));
+  }
+};
+
+// ../../harness-adapter/dist/diagnostics.js
+var DIAGNOSTIC_TAIL_MAX_LENGTH = 8e3;
+var SENSITIVE_VALUE_PATTERN = /(api[_-]?key|access[_-]?token|auth(?:orization)?|password|secret)(\s*[:=]\s*)([^\s,;]+)/giu;
+var BEARER_PATTERN = /\bBearer\s+[A-Za-z0-9._~+/=-]+/giu;
+function sanitizeDiagnosticTail(value) {
+  const redacted = value.replace(BEARER_PATTERN, "Bearer [redacted]").replace(SENSITIVE_VALUE_PATTERN, "$1$2[redacted]");
+  return redacted.length <= DIAGNOSTIC_TAIL_MAX_LENGTH ? redacted : redacted.slice(-DIAGNOSTIC_TAIL_MAX_LENGTH);
+}
+
+// ../../harness-adapter/dist/usage.js
+var tokenFields = [
+  "inputTokens",
+  "cachedInputTokens",
+  "cacheWriteInputTokens",
+  "outputTokens",
+  "outputTokensPerSecond",
+  "reasoningOutputTokens",
+  "totalTokens",
+  "contextWindowTokens",
+  "contextUsedTokens"
+];
+var safeIntegerFields = [
+  "planFiveHourResetsAtUnix",
+  "planSevenDayResetsAtUnix"
+];
+var percentFields = [
+  "cacheHitRatePercent",
+  "planFiveHourUsedPercent",
+  "planSevenDayUsedPercent"
+];
+var usageFields = /* @__PURE__ */ new Set([
+  ...tokenFields,
+  ...safeIntegerFields,
+  ...percentFields,
+  "totalCostUsd",
+  "totalCredits",
+  "contextUsagePercent"
+]);
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseHostUsage(value) {
+  if (!isRecord(value))
+    throw new Error("Harness Usage must be an object");
+  const keys = Object.keys(value);
+  if (keys.length === 0)
+    throw new Error("Harness Usage must contain a reliable field");
+  for (const key of keys) {
+    if (!usageFields.has(key)) {
+      throw new Error(`Harness Usage contains unknown field '${key}'`);
+    }
+  }
+  for (const field of ["totalCredits", "contextUsagePercent"]) {
+    const candidate = value[field];
+    if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isFinite(candidate) || candidate < 0)) {
+      throw new Error(`Harness Usage '${field}' must be a finite non-negative number`);
+    }
+  }
+  for (const field of tokenFields) {
+    const candidate = value[field];
+    if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isSafeInteger(candidate) || candidate < 0)) {
+      throw new Error(`Harness Usage '${field}' must be a non-negative safe integer`);
+    }
+  }
+  for (const field of safeIntegerFields) {
+    const candidate = value[field];
+    if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isSafeInteger(candidate) || candidate < 0)) {
+      throw new Error(`Harness Usage '${field}' must be a non-negative safe integer`);
+    }
+  }
+  if (value.outputTokensPerSecond !== void 0 && (typeof value.outputTokensPerSecond !== "number" || !Number.isFinite(value.outputTokensPerSecond) || value.outputTokensPerSecond < 0)) {
+    throw new Error("Harness Usage 'outputTokensPerSecond' must be a finite non-negative number");
+  }
+  if (value.totalCostUsd !== void 0 && (typeof value.totalCostUsd !== "number" || !Number.isFinite(value.totalCostUsd) || value.totalCostUsd < 0)) {
+    throw new Error("Harness Usage 'totalCostUsd' must be a finite non-negative number");
+  }
+  for (const field of percentFields) {
+    const candidate = value[field];
+    if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isFinite(candidate) || candidate < 0 || candidate > 100)) {
+      throw new Error(`Harness Usage '${field}' must be between 0 and 100`);
+    }
+  }
+  const hasContextUsed = value.contextUsedTokens !== void 0;
+  const hasContextWindow = value.contextWindowTokens !== void 0;
+  if (hasContextUsed !== hasContextWindow) {
+    throw new Error("Harness Usage context fields must be provided together");
+  }
+  if (hasContextWindow && value.contextWindowTokens === 0) {
+    throw new Error("Harness Usage 'contextWindowTokens' must be greater than zero");
+  }
+  if (value.planFiveHourResetsAtUnix !== void 0 && value.planFiveHourUsedPercent === void 0) {
+    throw new Error("Harness Usage 'planFiveHourResetsAtUnix' must be provided with 'planFiveHourUsedPercent'");
+  }
+  if (value.planSevenDayResetsAtUnix !== void 0 && value.planSevenDayUsedPercent === void 0) {
+    throw new Error("Harness Usage 'planSevenDayResetsAtUnix' must be provided with 'planSevenDayUsedPercent'");
+  }
+  return { ...value };
+}
+
+// dist/common.js
+var CODEBUDDY_ID = harnessIdSchema.parse("codebuddy");
+var CODEBUDDY_RUNTIME_PROFILE = {
+  harnessId: CODEBUDDY_ID,
+  displayName: "CodeBuddy",
+  interactionIdPrefix: "codebuddy",
+  configDirectoryEnvironmentVariables: ["CODEBUDDY_CONFIG_DIR"],
+  defaultConfigDirectoryName: ".codebuddy"
+};
+var OUTPUT_LIMIT = 64e3;
+var record2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+var rows = (value) => Array.isArray(value) ? value.map(record2) : [];
+var text = (value) => typeof value === "string" ? value : "";
+var CodeBuddyError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+};
+function nativeError(error51, profile = CODEBUDDY_RUNTIME_PROFILE) {
+  const diagnostic = sanitizeDiagnosticTail(error51 instanceof Error ? error51.message : String(error51));
+  const nativeCode = record2(error51).code;
+  const code = error51 instanceof CodeBuddyError ? error51.code : nativeCode === -32e3 || /authentication required|not logged in|unauthenticated/iu.test(diagnostic) ? "authenticationRequired" : nativeCode === "ENOENT" ? "notInstalled" : /session.*not found/iu.test(diagnostic) ? "sessionNotFound" : "nativeFailure";
+  return {
+    code,
+    message: `${profile.displayName}: ${diagnostic || "native operation failed"}`,
+    retryable: ["sessionBusy", "unavailable"].includes(code)
+  };
+}
+function failure(code, message, profile = CODEBUDDY_RUNTIME_PROFILE) {
+  return { ok: false, error: nativeError(new CodeBuddyError(code, message), profile) };
+}
+async function bounded(operation, milliseconds, label, onTimeout) {
+  let timer;
+  try {
+    return await Promise.race([
+      operation,
+      new Promise((_, reject) => {
+        timer = setTimeout(() => {
+          const error51 = new CodeBuddyError("unavailable", `${label} timed out`);
+          try {
+            onTimeout?.(error51);
+          } finally {
+            reject(error51);
+          }
+        }, milliseconds);
+      })
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// dist/slash-commands.js
+var excluded = /* @__PURE__ */ new Set([
+  "background",
+  "bg",
+  "branch",
+  "fork",
+  "fork-bg",
+  "clear",
+  "resume",
+  "exit",
+  "rewind",
+  "multitask",
+  "agent-mode",
+  "btw",
+  "loop",
+  "goal",
+  "login",
+  "logout",
+  "feedback",
+  "keybindings",
+  "copy",
+  "statusline",
+  "gateway",
+  "remote-control",
+  "_compact"
+]);
+function isExcludedInvocation(invocation) {
+  return invocation?.startsWith("/") === true && excluded.has(invocation.slice(1));
+}
+function nativeCommandsEnabled(profile = CODEBUDDY_RUNTIME_PROFILE) {
+  return profile.nativeCommands ?? profile.harnessId === CODEBUDDY_RUNTIME_PROFILE.harnessId;
+}
+function commandCatalog(value, profile = CODEBUDDY_RUNTIME_PROFILE) {
+  const seen = /* @__PURE__ */ new Set();
+  return {
+    commands: rows(value).flatMap((entry) => {
+      const name = text(entry.name).replace(/^\//u, "");
+      if (excluded.has(name) || seen.has(name))
+        return [];
+      const parsed = harnessCommandCatalogSchema.safeParse({
+        commands: [
+          {
+            id: `${profile.harnessId}.${name}`,
+            invocation: `/${name}`,
+            label: name,
+            ...text(entry.description).trim() ? { description: text(entry.description).trim().slice(0, 512) } : {},
+            argumentMode: name === "compact" || record2(entry.input).hint || record2(entry._meta).type === "skill" ? "text" : "none"
+          }
+        ]
+      });
+      if (!parsed.success)
+        return [];
+      seen.add(name);
+      return parsed.data.commands;
+    })
+  };
+}
+var CODEBUDDY_COMMAND_CATALOG = commandCatalog([
+  {
+    name: "compact",
+    description: "Summarize conversation context with optional focus instructions"
+  },
+  { name: "cost", description: "Show current Session usage and cost" }
+]);
+function commandPrompt(command, catalog, profile = CODEBUDDY_RUNTIME_PROFILE) {
+  const descriptor = catalog.commands.find((entry) => entry.id === command.commandId);
+  if (!descriptor)
+    return failure("unsupported", "Command is not available in this Session", profile);
+  const args = command.arguments;
+  if (args && (Object.keys(args).some((key) => key !== "text") || args.text !== void 0 && typeof args.text !== "string" || descriptor.argumentMode === "none" && Object.keys(args).length > 0))
+    return failure("invalidRequest", "Command arguments must match the native command", profile);
+  const argument = typeof args?.text === "string" ? args.text.trim() : "";
+  return { ok: true, value: `${descriptor.invocation}${argument ? ` ${argument}` : ""}` };
+}
+
+// dist/codebuddy-adapter.js
+import { stat as stat2 } from "node:fs/promises";
+
+// dist/acp-client.js
+import { execFile, spawn } from "node:child_process";
+import { Readable as Readable2, Writable } from "node:stream";
+
+// ../../../node_modules/@agentclientprotocol/sdk/dist/schema/index.js
+var AGENT_METHODS = {
+  initialize: "initialize",
+  authenticate: "authenticate",
+  providers_list: "providers/list",
+  providers_set: "providers/set",
+  providers_disable: "providers/disable",
+  session_new: "session/new",
+  session_load: "session/load",
+  session_set_mode: "session/set_mode",
+  session_set_config_option: "session/set_config_option",
+  session_prompt: "session/prompt",
+  session_cancel: "session/cancel",
+  mcp_message: "mcp/message",
+  session_list: "session/list",
+  session_delete: "session/delete",
+  session_fork: "session/fork",
+  session_resume: "session/resume",
+  session_close: "session/close",
+  logout: "logout",
+  nes_start: "nes/start",
+  nes_suggest: "nes/suggest",
+  nes_accept: "nes/accept",
+  nes_reject: "nes/reject",
+  nes_close: "nes/close",
+  document_did_open: "document/didOpen",
+  document_did_change: "document/didChange",
+  document_did_close: "document/didClose",
+  document_did_save: "document/didSave",
+  document_did_focus: "document/didFocus"
+};
+var CLIENT_METHODS = {
+  session_request_permission: "session/request_permission",
+  session_update: "session/update",
+  fs_write_text_file: "fs/write_text_file",
+  fs_read_text_file: "fs/read_text_file",
+  terminal_create: "terminal/create",
+  terminal_output: "terminal/output",
+  terminal_release: "terminal/release",
+  terminal_wait_for_exit: "terminal/wait_for_exit",
+  terminal_kill: "terminal/kill",
+  mcp_connect: "mcp/connect",
+  mcp_message: "mcp/message",
+  mcp_disconnect: "mcp/disconnect",
+  elicitation_create: "elicitation/create",
+  elicitation_complete: "elicitation/complete"
+};
+var PROTOCOL_METHODS = {
+  cancel_request: "$/cancel_request"
+};
+
+// ../../../node_modules/@agentclientprotocol/sdk/dist/schema-deserialize.js
+var skippedItem = /* @__PURE__ */ Symbol("skippedItem");
+function defaultOnError(schema, fallback) {
+  return schema.catch(fallback);
+}
+function requiredDefaultOnError(schema, fallback) {
+  const schemaWithCatch = schema.catch(fallback);
+  return external_exports.unknown().transform((value, context) => {
+    if (value !== void 0)
+      return schemaWithCatch.parse(value);
+    context.addIssue({
+      code: "custom",
+      message: "Required value is missing"
+    });
+    return external_exports.NEVER;
+  });
+}
+function stringTag(value, key) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const tag = value[key];
+  return typeof tag === "string" ? tag : void 0;
+}
+function excludeKnownTags(schema, key, knownTags) {
+  return schema.superRefine((value, context) => {
+    const tag = stringTag(value, key);
+    if (tag !== void 0 && knownTags.includes(tag)) {
+      context.addIssue({
+        code: "custom",
+        path: [key],
+        message: `${key} ${JSON.stringify(tag)} is reserved by a known variant, but the value does not match that variant's schema`
+      });
+    }
+  });
+}
+function preserveCustomPayload(schema, key, knownTags) {
+  return external_exports.unknown().transform((value, context) => {
+    const result = schema.safeParse(value);
+    if (!result.success) {
+      for (const issue2 of result.error.issues) {
+        context.addIssue({ ...issue2, input: value });
+      }
+      return external_exports.NEVER;
+    }
+    const output = result.data;
+    const tag = stringTag(value, key);
+    if (tag !== void 0 && !knownTags.includes(tag)) {
+      const raw = value;
+      for (const [property, rawValue] of Object.entries(raw)) {
+        if (property === "__proto__")
+          continue;
+        if (!Object.hasOwn(output, property))
+          output[property] = rawValue;
+      }
+    }
+    return output;
+  });
+}
+function vecSkipError(itemSchema) {
+  return external_exports.array(itemSchema.catch(skippedItem)).transform((items) => items.filter((item) => item !== skippedItem));
+}
+
+// ../../../node_modules/@agentclientprotocol/sdk/dist/schema/zod.gen.js
+var zRequestId = union([number2(), string2()]).nullable();
+var zSessionId = string2();
+var zWriteTextFileRequest = object({
+  sessionId: zSessionId,
+  path: string2(),
+  content: string2(),
+  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => void 0)
+});
+var zReadTextFileRequest = object({
+  sessionId: zSessionId,
+  path: string2(),
+  line: defaultOnError(int().gte(0).max(4294967295, {
+    error: "Invalid value: Expected uint32 to be <= 4294967295"
+  }).nullish(), () => void 0),
+  limit: defaultOnError(int().gte(0).max(4294967295, {
+    error: "Invalid value: Expected uint32 to be <= 4294967295"
+  }).nullish(), () => void 0),
+  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => void 0)
+});
+var zToolCallId = string2();
+var zToolKind = union([
+  literal("read"),
+  literal("edit"),
+  literal("delete"),
+  literal("move"),
+  literal("search"),
+  literal("execute"),
+  literal("think"),
+  literal("fetch"),
+  literal("switch_mode"),
+  literal("other")
+]);
+var zToolCallStatus = union([
+  literal("pending"),
+  literal("in_progress"),
+  literal("completed"),
+  literal("failed")
+]);
+var zRole = union([literal("assistant"), literal("user")]);
+var zAnnotations = object({
+  audience: defaultOnError(vecSkipError(zRole).nullish(), () => void 0),
+  lastModified: defaultOnError(string2().nullish(), () => void 0),
+  priority: defaultOnError(number2().nullish(), () => void 0),
+  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => void 0)
+});
+var zTextContent = object({
+  annotations: defaultOnError(zAnnotations.nullish(), () => void 0),
+  text: string2(),
+  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => void 0)
+});
+var zImageContent = object({
+  annotations: defaultOnError(zAnnotations.nullish(), () => void 0),
+  data: string2(),
+  mimeType: string2(),
+  uri: defaultOnError(string2().nullish(), () => void 0),
+  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => void 0)
+});
+var zAudioContent = object({
+  annotations: defaultOnError(zAnnotations.nullish(), () => void 0),
+  data: string2(),
+  mimeType: string2(),
+  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => void 0)
+});
+var zResourceLink = object({
+  annotations: defaultOnError(zAnnotations.nullish(), () => void 0),
+  description: defaultOnError(string2().nullish(), () => void 0),
+  mimeType: defaultOnError(string2().nullish(), () => void 0),
+  name: string2(),
   size: defaultOnError(number2().nullish(), () => void 0),
   title: defaultOnError(string2().nullish(), () => void 0),
   uri: string2(),
@@ -17147,17 +17465,17 @@ function isResponseMessage(value) {
 function isNotificationMessage(value) {
   return isJsonRpcEnvelope(value) && !("id" in value) && typeof value["method"] === "string";
 }
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null;
 }
 function isJsonRpcEnvelope(value) {
-  return isRecord(value) && value["jsonrpc"] === "2.0";
+  return isRecord2(value) && value["jsonrpc"] === "2.0";
 }
 function isJsonRpcId(value) {
   return value === null || typeof value === "string" || typeof value === "number" && Number.isFinite(value);
 }
 function isResponseShapedMessage(value) {
-  return isRecord(value) && !("method" in value) && ("id" in value || "result" in value || "error" in value);
+  return isRecord2(value) && !("method" in value) && ("id" in value || "result" in value || "error" in value);
 }
 function isResponseBatch(batch) {
   let hasValidCall = false;
@@ -17167,7 +17485,7 @@ function isResponseBatch(batch) {
   for (const entry of batch) {
     hasValidCall ||= isRequestMessage(entry) || isNotificationMessage(entry);
     hasValidResponse ||= isResponseMessage(entry);
-    if (!isRecord(entry)) {
+    if (!isRecord2(entry)) {
       continue;
     }
     hasCallShape ||= "method" in entry;
@@ -17182,13 +17500,13 @@ function isResponseBatch(batch) {
   return hasResponseShape && !hasCallShape;
 }
 function cancelRequestId(params) {
-  if (!isRecord(params) || !isJsonRpcId(params["requestId"])) {
+  if (!isRecord2(params) || !isJsonRpcId(params["requestId"])) {
     return void 0;
   }
   return params["requestId"];
 }
 function isErrorResponse(value) {
-  return isRecord(value) && typeof value["code"] === "number" && Number.isInteger(value["code"]) && typeof value["message"] === "string";
+  return isRecord2(value) && typeof value["code"] === "number" && Number.isInteger(value["code"]) && typeof value["message"] === "string";
 }
 var Handled = {
   /**
@@ -17679,7 +17997,7 @@ var Connection = class {
       this.receiveBatch(message);
       return;
     }
-    if (!isRecord(message)) {
+    if (!isRecord2(message)) {
       console.error("Invalid message", { message });
       return;
     }
@@ -17742,7 +18060,7 @@ var Connection = class {
     if (this.abortController.signal.aborted) {
       return Promise.resolve();
     }
-    if (!isRecord(message)) {
+    if (!isRecord2(message)) {
       console.error("Invalid message", { message });
       return Promise.resolve();
     }
@@ -18112,7 +18430,7 @@ function ndJsonStream(output, input) {
         if (trimmedLine) {
           try {
             const message = JSON.parse(trimmedLine);
-            if (isRecord(message) || Array.isArray(message)) {
+            if (isRecord2(message) || Array.isArray(message)) {
               controller.enqueue(message);
             } else {
               console.warn("Skipping JSON line that is not an object:", trimmedLine);
@@ -19573,6 +19891,69 @@ var ClientSideConnection = class {
   }
 };
 
+// dist/copy-cleanup.js
+import { randomBytes } from "node:crypto";
+import { createInterface } from "node:readline";
+import { stripVTControlCharacters } from "node:util";
+import { Readable } from "node:stream";
+var CodeBuddyCopyCleanup = class {
+  copyId;
+  cwd;
+  password = randomBytes(32).toString("base64url");
+  arguments = [
+    "--acp",
+    "--serve",
+    "--host",
+    "127.0.0.1",
+    "--port",
+    "0",
+    "--auth",
+    "password"
+  ];
+  #endpoint;
+  constructor(copyId, cwd) {
+    this.copyId = copyId;
+    this.cwd = cwd;
+  }
+  environment(environment) {
+    return {
+      ...environment,
+      CODEBUDDY_GATEWAY_AUTH: "password",
+      CODEBUDDY_GATEWAY_PASSWORD: this.password,
+      CODEBUDDY_GATEWAY_BASE_PATH: ""
+    };
+  }
+  /** Native --serve banners include its password; never pass them to the ACP parser/logs. */
+  protocolOutput(stdout) {
+    return Readable.from(this.#protocolLines(stdout));
+  }
+  async *#protocolLines(stdout) {
+    for await (const line of createInterface({ input: stdout })) {
+      const endpoint = /^\s*Endpoint\s+(http:\/\/127\.0\.0\.1:\d+)\s*$/u.exec(stripVTControlCharacters(line));
+      if (endpoint)
+        this.#endpoint = endpoint[1];
+      if (line.trimStart().startsWith("{"))
+        yield Buffer.from(`${line}
+`);
+    }
+  }
+  async remove() {
+    if (!this.#endpoint)
+      throw new CodeBuddyError("nativeFailure", `Native cleanup endpoint was not reported; temporary Session ${this.copyId} remains`);
+    const response = await fetch(`${this.#endpoint}/api/v1/sessions/${encodeURIComponent(this.copyId)}?cwd=${encodeURIComponent(this.cwd)}`, {
+      method: "DELETE",
+      headers: { Authorization: `Bearer ${this.password}`, "x-codebuddy-request": "true" },
+      signal: AbortSignal.timeout(5e3),
+      redirect: "error"
+    }).catch(() => {
+      throw new CodeBuddyError("nativeFailure", `Native cleanup request failed; temporary Session ${this.copyId} remains`);
+    });
+    await response.body?.cancel();
+    if (response.status !== 204)
+      throw new CodeBuddyError("nativeFailure", `Native cleanup failed (${response.status}); temporary Session ${this.copyId} remains`);
+  }
+};
+
 // ../../harness-discovery/dist/environment.js
 import fs from "node:fs";
 import path from "node:path";
@@ -19644,7 +20025,7 @@ function withNodeRuntimeOnPath(environment, runtimeExecutable = process.execPath
   const directories = (environment[pathKey] ?? "").split(delimiter).filter(Boolean);
   const equal = platform === "win32" ? (value) => value.toLowerCase() : (value) => value;
   if (!directories.some((directory) => equal(directory) === equal(runtimeDirectory))) {
-    directories.unshift(runtimeDirectory);
+    directories.push(runtimeDirectory);
   }
   return { ...environment, [pathKey]: directories.join(delimiter) };
 }
@@ -19706,366 +20087,110 @@ function versionManagerBinaryDirectories(context) {
     for (const formula of newestFirst(list(prefix).filter((name) => name.startsWith("node@")))) {
       directories.push(pathFlavor.join(prefix, formula, "bin"));
     }
-  }
-  return directories;
-}
-
-// ../../harness-discovery/dist/resolve.js
-var VERSION_MANAGER_ROOTS = "<version-managers>";
-function installRootExtensions(platform) {
-  return platform === "win32" ? [".exe", ".cmd"] : [""];
-}
-function resolveHomeDirectory(input) {
-  return input.homeDirectory ?? environmentValue(input.environment, "HOME") ?? environmentValue(input.environment, "USERPROFILE") ?? os.homedir();
-}
-function templateVariables(environment, platform, home) {
-  const pathFlavor = targetPath(platform);
-  return {
-    HOME: home,
-    USERPROFILE: home,
-    APPDATA: environmentValue(environment, "APPDATA") ?? pathFlavor.join(home, "AppData", "Roaming"),
-    LOCALAPPDATA: environmentValue(environment, "LOCALAPPDATA") ?? pathFlavor.join(home, "AppData", "Local")
-  };
-}
-function joinTemplate(platform, value) {
-  const pathFlavor = targetPath(platform);
-  const segments = value.split("/");
-  const head = segments[0] ?? "";
-  const tail = segments.slice(1);
-  if (head === "")
-    return pathFlavor.join(pathFlavor.sep, ...tail);
-  return tail.length === 0 ? head : pathFlavor.join(head, ...tail);
-}
-function expandInstallRoot(template, environment, platform, home) {
-  const variables = templateVariables(environment, platform, home);
-  let unresolved = false;
-  const substituted = template.replace(/^~(?=\/|$)/u, home).replace(/\$\{(\w+)\}/gu, (_match, name) => {
-    const value = variables[name] ?? environmentValue(environment, name);
-    if (value === void 0 || value === "") {
-      unresolved = true;
-      return "";
-    }
-    return value;
-  });
-  return unresolved ? void 0 : joinTemplate(platform, substituted);
-}
-function installRootDirectories(spec, input, dependencies, platform, home) {
-  const templates = (platform === "win32" ? spec.installRoots?.windows : spec.installRoots?.posix) ?? [];
-  const directories = [];
-  for (const template of templates) {
-    if (template === VERSION_MANAGER_ROOTS) {
-      directories.push(...versionManagerBinaryDirectories({
-        platform,
-        environment: input.environment,
-        home,
-        ...dependencies.subdirectories ? { subdirectories: dependencies.subdirectories } : {}
-      }));
-      continue;
-    }
-    const directory = expandInstallRoot(template, input.environment, platform, home);
-    if (directory !== void 0)
-      directories.push(directory);
-  }
-  return directories;
-}
-function harnessCandidates(spec, input, dependencies = {}) {
-  const platform = input.platform ?? process.platform;
-  const pathFlavor = targetPath(platform);
-  const configured = input.command ?? (spec.commandEnvironmentVariable ? environmentValue(input.environment, spec.commandEnvironmentVariable) : void 0);
-  const command = configured ?? spec.command;
-  if (pathFlavor.isAbsolute(command) || command.includes("/") || command.includes("\\")) {
-    return [{ candidate: command, source: "configured" }];
-  }
-  const candidates = [];
-  const extensions = executableExtensions(command, platform, input.environment);
-  for (const directory of pathDirectories(input.environment, platform)) {
-    for (const extension of extensions) {
-      candidates.push({
-        candidate: pathFlavor.join(directory, command + extension),
-        source: "path"
-      });
-    }
-  }
-  if (configured !== void 0)
-    return candidates;
-  const home = resolveHomeDirectory(input);
-  for (const directory of installRootDirectories(spec, input, dependencies, platform, home)) {
-    for (const extension of installRootExtensions(platform)) {
-      candidates.push({
-        candidate: pathFlavor.join(directory, spec.command + extension),
-        source: "install-root"
-      });
-    }
-  }
-  return candidates;
-}
-function resolveHarnessExecutable(spec, input, dependencies = {}) {
-  const platform = input.platform ?? process.platform;
-  const isExecutable = dependencies.isExecutable ?? ((candidate) => isExecutableFile(candidate, platform));
-  const runnable = spec.runnableCandidate ?? ((candidate) => candidate);
-  const context = { platform, isExecutable };
-  for (const { candidate, source } of harnessCandidates(spec, input, dependencies)) {
-    const executable = runnable(candidate, context);
-    if (executable !== void 0 && isExecutable(executable))
-      return { executable, source };
-  }
-  return void 0;
-}
-
-// ../../harness-adapter/dist/approval.js
-function invalidRequest(message) {
-  return { code: "invalidRequest", message, retryable: false };
-}
-function validateHostApprovalResponse(interaction, response) {
-  return interaction.actions.some(({ id }) => id === response.actionId) ? null : invalidRequest("Approval Response contains an undeclared action ID");
-}
-
-// ../../harness-adapter/dist/question.js
-function invalidRequest2(message) {
-  return { code: "invalidRequest", message, retryable: false };
-}
-function validateHostQuestionResponse(interaction, response) {
-  const questionIds = new Set(interaction.questions.map(({ id }) => id));
-  if (response.cancelled) {
-    return Object.keys(response.answers).length === 0 ? null : invalidRequest2("Cancelled Question Response must not contain answers");
-  }
-  for (const answerId of Object.keys(response.answers)) {
-    if (!questionIds.has(answerId)) {
-      return invalidRequest2("Question Response contains an unknown Question ID");
-    }
-  }
-  for (const question of interaction.questions) {
-    const answers = response.answers[question.id] ?? [];
-    if (!question.optional && answers.length === 0) {
-      return invalidRequest2("Question Response omits a required answer");
-    }
-    if (question.type === "text") {
-      if (answers.length > 1) {
-        return invalidRequest2("Text Question accepts at most one answer");
-      }
-      continue;
-    }
-    if (!question.multiple && answers.length > 1) {
-      return invalidRequest2("Single-choice Question accepts at most one answer");
-    }
-    const declared = new Set(question.options.map(({ value }) => value));
-    if (!question.allowOther && answers.some((answer) => !declared.has(answer))) {
-      return invalidRequest2("Question Response contains an undeclared choice");
-    }
-  }
-  return null;
-}
-
-// ../../harness-adapter/dist/interaction.js
-function invalidRequest3(message) {
-  return { code: "invalidRequest", message, retryable: false };
-}
-function invalidState(message) {
-  return { code: "invalidState", message, retryable: false };
-}
-function validateHostInteractionResponse(interaction, response) {
-  if (!interaction) {
-    return invalidState("Interaction Response must reference a pending Interaction");
-  }
-  if (interaction.type === "question") {
-    return response.type === "question" ? validateHostQuestionResponse(interaction, response) : invalidRequest3("Interaction Response type does not match the pending Interaction");
-  }
-  return response.type === "approval" ? validateHostApprovalResponse(interaction, response) : invalidRequest3("Interaction Response type does not match the pending Interaction");
-}
-
-// ../../harness-adapter/dist/output-channel.js
-var HarnessOutputChannel = class {
-  outputs;
-  #consumerCreated = false;
-  #ended = false;
-  #pending = [];
-  #values = [];
-  constructor() {
-    this.outputs = {
-      [Symbol.asyncIterator]: () => {
-        if (this.#consumerCreated) {
-          throw new Error("Harness outputs allow only one consumer");
-        }
-        this.#consumerCreated = true;
-        return {
-          next: () => this.#next()
-        };
-      }
-    };
-  }
-  emit(value) {
-    if (this.#ended)
-      return false;
-    const resolve = this.#pending.shift();
-    if (resolve)
-      resolve({ done: false, value });
-    else
-      this.#values.push(value);
-    return true;
-  }
-  end() {
-    if (this.#ended)
-      return;
-    this.#ended = true;
-    if (this.#values.length !== 0)
-      return;
-    for (const resolve of this.#pending.splice(0))
-      resolve({ done: true, value: void 0 });
-  }
-  #next() {
-    const value = this.#values.shift();
-    if (value !== void 0)
-      return Promise.resolve({ done: false, value });
-    if (this.#ended)
-      return Promise.resolve({ done: true, value: void 0 });
-    return new Promise((resolve) => this.#pending.push(resolve));
-  }
-};
-
-// ../../harness-adapter/dist/diagnostics.js
-var DIAGNOSTIC_TAIL_MAX_LENGTH = 8e3;
-var SENSITIVE_VALUE_PATTERN = /(api[_-]?key|access[_-]?token|auth(?:orization)?|password|secret)(\s*[:=]\s*)([^\s,;]+)/giu;
-var BEARER_PATTERN = /\bBearer\s+[A-Za-z0-9._~+/=-]+/giu;
-function sanitizeDiagnosticTail(value) {
-  const redacted = value.replace(BEARER_PATTERN, "Bearer [redacted]").replace(SENSITIVE_VALUE_PATTERN, "$1$2[redacted]");
-  return redacted.length <= DIAGNOSTIC_TAIL_MAX_LENGTH ? redacted : redacted.slice(-DIAGNOSTIC_TAIL_MAX_LENGTH);
+  }
+  return directories;
 }
 
-// ../../harness-adapter/dist/usage.js
-var tokenFields = [
-  "inputTokens",
-  "cachedInputTokens",
-  "cacheWriteInputTokens",
-  "outputTokens",
-  "outputTokensPerSecond",
-  "reasoningOutputTokens",
-  "totalTokens",
-  "contextWindowTokens",
-  "contextUsedTokens"
-];
-var safeIntegerFields = [
-  "planFiveHourResetsAtUnix",
-  "planSevenDayResetsAtUnix"
-];
-var percentFields = [
-  "cacheHitRatePercent",
-  "planFiveHourUsedPercent",
-  "planSevenDayUsedPercent"
-];
-var usageFields = /* @__PURE__ */ new Set([
-  ...tokenFields,
-  ...safeIntegerFields,
-  ...percentFields,
-  "totalCostUsd",
-  "totalCredits",
-  "contextUsagePercent"
-]);
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+// ../../harness-discovery/dist/resolve.js
+var VERSION_MANAGER_ROOTS = "<version-managers>";
+function installRootExtensions(platform) {
+  return platform === "win32" ? [".exe", ".cmd"] : [""];
 }
-function parseHostUsage(value) {
-  if (!isRecord2(value))
-    throw new Error("Harness Usage must be an object");
-  const keys = Object.keys(value);
-  if (keys.length === 0)
-    throw new Error("Harness Usage must contain a reliable field");
-  for (const key of keys) {
-    if (!usageFields.has(key)) {
-      throw new Error(`Harness Usage contains unknown field '${key}'`);
+function resolveHomeDirectory(input) {
+  return input.homeDirectory ?? environmentValue(input.environment, "HOME") ?? environmentValue(input.environment, "USERPROFILE") ?? os.homedir();
+}
+function templateVariables(environment, platform, home) {
+  const pathFlavor = targetPath(platform);
+  return {
+    HOME: home,
+    USERPROFILE: home,
+    APPDATA: environmentValue(environment, "APPDATA") ?? pathFlavor.join(home, "AppData", "Roaming"),
+    LOCALAPPDATA: environmentValue(environment, "LOCALAPPDATA") ?? pathFlavor.join(home, "AppData", "Local")
+  };
+}
+function joinTemplate(platform, value) {
+  const pathFlavor = targetPath(platform);
+  const segments = value.split("/");
+  const head = segments[0] ?? "";
+  const tail = segments.slice(1);
+  if (head === "")
+    return pathFlavor.join(pathFlavor.sep, ...tail);
+  return tail.length === 0 ? head : pathFlavor.join(head, ...tail);
+}
+function expandInstallRoot(template, environment, platform, home) {
+  const variables = templateVariables(environment, platform, home);
+  let unresolved = false;
+  const substituted = template.replace(/^~(?=\/|$)/u, home).replace(/\$\{(\w+)\}/gu, (_match, name) => {
+    const value = variables[name] ?? environmentValue(environment, name);
+    if (value === void 0 || value === "") {
+      unresolved = true;
+      return "";
     }
-  }
-  for (const field of ["totalCredits", "contextUsagePercent"]) {
-    const candidate = value[field];
-    if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isFinite(candidate) || candidate < 0)) {
-      throw new Error(`Harness Usage '${field}' must be a finite non-negative number`);
+    return value;
+  });
+  return unresolved ? void 0 : joinTemplate(platform, substituted);
+}
+function installRootDirectories(spec, input, dependencies, platform, home) {
+  const templates = (platform === "win32" ? spec.installRoots?.windows : spec.installRoots?.posix) ?? [];
+  const directories = [];
+  for (const template of templates) {
+    if (template === VERSION_MANAGER_ROOTS) {
+      directories.push(...versionManagerBinaryDirectories({
+        platform,
+        environment: input.environment,
+        home,
+        ...dependencies.subdirectories ? { subdirectories: dependencies.subdirectories } : {}
+      }));
+      continue;
     }
+    const directory = expandInstallRoot(template, input.environment, platform, home);
+    if (directory !== void 0)
+      directories.push(directory);
   }
-  for (const field of tokenFields) {
-    const candidate = value[field];
-    if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isSafeInteger(candidate) || candidate < 0)) {
-      throw new Error(`Harness Usage '${field}' must be a non-negative safe integer`);
-    }
+  return directories;
+}
+function harnessCandidates(spec, input, dependencies = {}) {
+  const platform = input.platform ?? process.platform;
+  const pathFlavor = targetPath(platform);
+  const configured = input.command ?? (spec.commandEnvironmentVariable ? environmentValue(input.environment, spec.commandEnvironmentVariable) : void 0);
+  const command = configured ?? spec.command;
+  if (pathFlavor.isAbsolute(command) || command.includes("/") || command.includes("\\")) {
+    return [{ candidate: command, source: "configured" }];
   }
-  for (const field of safeIntegerFields) {
-    const candidate = value[field];
-    if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isSafeInteger(candidate) || candidate < 0)) {
-      throw new Error(`Harness Usage '${field}' must be a non-negative safe integer`);
+  const candidates = [];
+  const extensions = executableExtensions(command, platform, input.environment);
+  for (const directory of pathDirectories(input.environment, platform)) {
+    for (const extension of extensions) {
+      candidates.push({
+        candidate: pathFlavor.join(directory, command + extension),
+        source: "path"
+      });
     }
   }
-  if (value.outputTokensPerSecond !== void 0 && (typeof value.outputTokensPerSecond !== "number" || !Number.isFinite(value.outputTokensPerSecond) || value.outputTokensPerSecond < 0)) {
-    throw new Error("Harness Usage 'outputTokensPerSecond' must be a finite non-negative number");
-  }
-  if (value.totalCostUsd !== void 0 && (typeof value.totalCostUsd !== "number" || !Number.isFinite(value.totalCostUsd) || value.totalCostUsd < 0)) {
-    throw new Error("Harness Usage 'totalCostUsd' must be a finite non-negative number");
-  }
-  for (const field of percentFields) {
-    const candidate = value[field];
-    if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isFinite(candidate) || candidate < 0 || candidate > 100)) {
-      throw new Error(`Harness Usage '${field}' must be between 0 and 100`);
+  if (configured !== void 0)
+    return candidates;
+  const home = resolveHomeDirectory(input);
+  for (const directory of installRootDirectories(spec, input, dependencies, platform, home)) {
+    for (const extension of installRootExtensions(platform)) {
+      candidates.push({
+        candidate: pathFlavor.join(directory, spec.command + extension),
+        source: "install-root"
+      });
     }
   }
-  const hasContextUsed = value.contextUsedTokens !== void 0;
-  const hasContextWindow = value.contextWindowTokens !== void 0;
-  if (hasContextUsed !== hasContextWindow) {
-    throw new Error("Harness Usage context fields must be provided together");
-  }
-  if (hasContextWindow && value.contextWindowTokens === 0) {
-    throw new Error("Harness Usage 'contextWindowTokens' must be greater than zero");
-  }
-  if (value.planFiveHourResetsAtUnix !== void 0 && value.planFiveHourUsedPercent === void 0) {
-    throw new Error("Harness Usage 'planFiveHourResetsAtUnix' must be provided with 'planFiveHourUsedPercent'");
-  }
-  if (value.planSevenDayResetsAtUnix !== void 0 && value.planSevenDayUsedPercent === void 0) {
-    throw new Error("Harness Usage 'planSevenDayResetsAtUnix' must be provided with 'planSevenDayUsedPercent'");
-  }
-  return { ...value };
-}
-
-// dist/common.js
-var CODEBUDDY_ID = harnessIdSchema.parse("codebuddy");
-var OUTPUT_LIMIT = 64e3;
-var record2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
-var rows = (value) => Array.isArray(value) ? value.map(record2) : [];
-var text = (value) => typeof value === "string" ? value : "";
-var CodeBuddyError = class extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-  }
-};
-function nativeError(error51) {
-  const diagnostic = sanitizeDiagnosticTail(error51 instanceof Error ? error51.message : String(error51));
-  const nativeCode = record2(error51).code;
-  const code = error51 instanceof CodeBuddyError ? error51.code : nativeCode === -32e3 || /authentication required|not logged in|unauthenticated/iu.test(diagnostic) ? "authenticationRequired" : nativeCode === "ENOENT" ? "notInstalled" : /session.*not found/iu.test(diagnostic) ? "sessionNotFound" : "nativeFailure";
-  return {
-    code,
-    message: `CodeBuddy: ${diagnostic || "native operation failed"}`,
-    retryable: ["sessionBusy", "unavailable"].includes(code)
-  };
-}
-function failure(code, message) {
-  return { ok: false, error: nativeError(new CodeBuddyError(code, message)) };
+  return candidates;
 }
-async function bounded(operation, milliseconds, label, onTimeout) {
-  let timer;
-  try {
-    return await Promise.race([
-      operation,
-      new Promise((_, reject) => {
-        timer = setTimeout(() => {
-          const error51 = new CodeBuddyError("unavailable", `${label} timed out`);
-          try {
-            onTimeout?.(error51);
-          } finally {
-            reject(error51);
-          }
-        }, milliseconds);
-      })
-    ]);
-  } finally {
-    clearTimeout(timer);
+function resolveHarnessExecutable(spec, input, dependencies = {}) {
+  const platform = input.platform ?? process.platform;
+  const isExecutable = dependencies.isExecutable ?? ((candidate) => isExecutableFile(candidate, platform));
+  const runnable = spec.runnableCandidate ?? ((candidate) => candidate);
+  const context = { platform, isExecutable };
+  for (const { candidate, source } of harnessCandidates(spec, input, dependencies)) {
+    const executable = runnable(candidate, context);
+    if (executable !== void 0 && isExecutable(executable))
+      return { executable, source };
   }
+  return void 0;
 }
 
 // dist/command.js
@@ -20084,21 +20209,34 @@ var codeBuddyDiscoverySpec = {
     ]
   }
 };
-function codeBuddyInvocation(environment, ephemeral) {
+function codeBuddyInvocation(environment, ephemeral, argumentsOverride) {
   const resolved = resolveHarnessExecutable(codeBuddyDiscoverySpec, { environment });
   if (!resolved)
     throw new CodeBuddyError("notInstalled", "CLI is not installed; run codebuddy and sign in first");
   const env = withNodeRuntimeOnPath(environment);
   return {
-    ...commandInvocation(resolved.executable, ["--acp", ...ephemeral ? ["--no-session-persistence"] : []], env),
+    ...commandInvocation(resolved.executable, argumentsOverride ?? [
+      "--acp",
+      ...ephemeral ? ["--no-session-persistence"] : [],
+      ...!ephemeral && [
+        "CODEXHOST_CLI_PATH",
+        "CODEXHOST_RUNTIME_ENDPOINT",
+        "CODEXHOST_RUNTIME_TOKEN",
+        "CODEXHOST_THREAD_ID"
+      ].every((key) => environment[key]) ? ["--append-system-prompt", CODEBUDDY_DELEGATION_INSTRUCTIONS] : []
+    ], env),
     environment: env
   };
 }
+var CODEBUDDY_DELEGATION_INSTRUCTIONS = `This Session runs inside codexhost.
+When the user requests cross-Harness agent delegation, use the executable at the CODEXHOST_CLI_PATH environment variable through your native shell tool. Start with its --help and harness list commands, then use delegate start and thread send/read/wait/cancel as documented by the CLI. Pass --format compact when reporting results. Keep the inherited CODEXHOST_RUNTIME_ENDPOINT, CODEXHOST_RUNTIME_TOKEN and CODEXHOST_THREAD_ID environment variables for all such calls; they identify this Runtime and parent Thread. Do not print or expose their values, replace the configured executable, or start delegation unless the user's request authorizes it. Native CodeBuddy Agent subagents remain available for CodeBuddy-only work.`;
 
 // dist/acp-client.js
 var CodeBuddyAcpClient = class {
   options;
   operationTimeoutMs;
+  invocationFactory;
+  #copyCleanup;
   #child;
   #connection;
   #exited;
@@ -20110,12 +20248,14 @@ var CodeBuddyAcpClient = class {
   #failed = new Promise((_, reject) => {
     this.#rejectFailure = reject;
   });
-  constructor(options, operationTimeoutMs = 15e3) {
+  constructor(options, operationTimeoutMs = 15e3, invocationFactory = codeBuddyInvocation) {
     this.options = options;
     this.operationTimeoutMs = operationTimeoutMs;
+    this.invocationFactory = invocationFactory;
     void this.#failed.catch(() => {
     });
-    const invocation = codeBuddyInvocation(options.environment, options.ephemeral);
+    this.#copyCleanup = options.temporarySessionId ? new CodeBuddyCopyCleanup(options.temporarySessionId, options.cwd) : void 0;
+    const invocation = invocationFactory(this.#copyCleanup?.environment(options.environment) ?? options.environment, options.ephemeral, this.#copyCleanup?.arguments);
     this.#child = spawn(invocation.command, invocation.arguments, {
       cwd: options.cwd,
       env: invocation.environment,
@@ -20152,7 +20292,7 @@ var CodeBuddyAcpClient = class {
           return { outcome: "cancelled" };
         return options.handlers.question(params);
       }
-    }), ndJsonStream2(Writable.toWeb(this.#child.stdin), Readable.toWeb(this.#child.stdout)));
+    }), ndJsonStream2(Writable.toWeb(this.#child.stdin), Readable2.toWeb(this.#copyCleanup?.protocolOutput(this.#child.stdout) ?? this.#child.stdout)));
     void this.#connection.closed.then(() => {
       this.#fault(new CodeBuddyError("processExited", "ACP connection closed"));
     }).catch((error51) => {
@@ -20202,13 +20342,27 @@ var CodeBuddyAcpClient = class {
   async cancel(sessionId) {
     await this.#request(() => this.#connection.cancel({ sessionId }), "ACP cancel");
   }
+  async removeCopy() {
+    const cleanup = this.#copyCleanup;
+    if (!cleanup)
+      throw new CodeBuddyError("invalidState", "No temporary copy is owned by this process");
+    await this.#request(() => cleanup.remove(), "Native temporary Session cleanup");
+  }
+  async rollback(sessionId, forkPointId) {
+    return record2(await this.#request(() => this.#connection.extMethod("_codebuddy.ai/session/rollback", {
+      sessionId,
+      forkPointId,
+      reason: "resend_edit",
+      files: false
+    }), "ACP history rewind"));
+  }
   async answer(sessionId, toolCallId, answers) {
     const response = await this.#request(() => this.#connection.extMethod("_codebuddy.ai/resolveInterruption", {
       sessionId,
       toolCallId,
       decision: answers === null ? "deny" : "allow",
       ...answers ? { answers } : {}
-    }), "CodeBuddy question response");
+    }), "ACP question response");
     if (record2(response).resolved !== true)
       throw new CodeBuddyError("protocolError", "Native question is no longer pending");
   }
@@ -20250,19 +20404,25 @@ var CODEBUDDY_CAPABILITIES = {
     selectPermissionMode: true,
     permissionModeScope: "live"
   },
-  history: { fork: false, forkAcrossCwd: false, rollbackLastTurn: false },
+  history: { fork: true, forkAcrossCwd: false, rollbackLastTurn: true },
   subagents: { observe: true, readTranscript: true }
 };
+function capabilitiesForProfile(profile = CODEBUDDY_RUNTIME_PROFILE) {
+  return {
+    ...CODEBUDDY_CAPABILITIES,
+    history: profile.historyCapabilities ?? CODEBUDDY_CAPABILITIES.history
+  };
+}
 function modelRef(modelId) {
   return harnessModelRefSchema.parse({ id: `cb.${Buffer.from(modelId).toString("base64url")}` });
 }
 function nativeModel(ref) {
   const value = Buffer.from(ref.id.slice(3), "base64url").toString("utf8");
   if (!value || !ref.id.startsWith("cb.") || modelRef(value).id !== ref.id)
-    throw new CodeBuddyError("invalidRequest", "Invalid CodeBuddy Model Ref");
+    throw new CodeBuddyError("invalidRequest", "Invalid native Model Ref");
   return value;
 }
-function configuration(value) {
+function configuration(value, profile = CODEBUDDY_RUNTIME_PROFILE) {
   const options = rows(value);
   const get = (id) => options.find((option) => option.id === id) ?? {};
   const model = get("model"), mode = get("mode"), thought = get("thought_level");
@@ -20272,7 +20432,12 @@ function configuration(value) {
     ref: modelRef(text(option.value)),
     label: text(option.name)
   }));
-  const currentModel = models.find((item) => item.ref.id === modelRef(text(model.currentValue)).id);
+  const currentModelRef = modelRef(text(model.currentValue));
+  let currentModel = models.find((item) => item.ref.id === currentModelRef.id);
+  if (!currentModel && profile.allowUnlistedModelSelection) {
+    currentModel = { ref: currentModelRef, label: text(model.currentValue) };
+    models.push(currentModel);
+  }
   if (!currentModel)
     throw new CodeBuddyError("protocolError", "ACP did not report a valid current Model");
   const catalog = harnessModelCatalogSchema.parse({
@@ -20302,18 +20467,28 @@ function configuration(value) {
   };
   return { catalog, permissionModes, state, options };
 }
-function confirmedConfiguration(response, id, value) {
-  const result = configuration(record2(response).configOptions);
+function confirmedConfiguration(response, id, value, profile = CODEBUDDY_RUNTIME_PROFILE) {
+  const result = configuration(record2(response).configOptions, profile);
   if (result.options.find((option) => option.id === id)?.currentValue !== value) {
     throw new CodeBuddyError("protocolError", `ACP did not confirm ${id}`);
   }
   return result;
 }
 
+// dist/derivation.js
+import { randomUUID } from "node:crypto";
+import { execFile as execFile2, spawn as spawn2 } from "node:child_process";
+import { lstat, mkdir, readFile as readFile2, realpath as realpath4, unlink, writeFile } from "node:fs/promises";
+import path5 from "node:path";
+import { isDeepStrictEqual as isDeepStrictEqual3 } from "node:util";
+
 // dist/history.js
+import { createHash } from "node:crypto";
+import { realpathSync } from "node:fs";
 import { access, readdir, realpath as realpath2 } from "node:fs/promises";
 import { homedir } from "node:os";
 import path4 from "node:path";
+import { isDeepStrictEqual } from "node:util";
 
 // ../../../node_modules/diff/libesm/diff/base.js
 var Diff = class {
@@ -20415,16 +20590,16 @@ var Diff = class {
       }
     }
   }
-  addToPath(path7, added, removed, oldPosInc, options) {
-    const last = path7.lastComponent;
+  addToPath(path8, added, removed, oldPosInc, options) {
+    const last = path8.lastComponent;
     if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
       return {
-        oldPos: path7.oldPos + oldPosInc,
+        oldPos: path8.oldPos + oldPosInc,
         lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
       };
     } else {
       return {
-        oldPos: path7.oldPos + oldPosInc,
+        oldPos: path8.oldPos + oldPosInc,
         lastComponent: { count: 1, added, removed, previousComponent: last }
       };
     }
@@ -20762,28 +20937,31 @@ function toolOutput(value) {
     ...output.length > OUTPUT_LIMIT ? { truncated: true } : {}
   };
 }
-function toolOutcome(status) {
+function toolOutcome(status, profile = CODEBUDDY_RUNTIME_PROFILE) {
   if (status === "completed")
     return { status: "succeeded" };
   if (status === "cancelled" || status === "interrupted")
     return { status: "cancelled" };
   return {
     status: "failed",
-    error: nativeError(new CodeBuddyError("nativeFailure", status === "failed" ? "Tool execution failed" : "Tool completion was not recorded"))
+    error: nativeError(new CodeBuddyError("nativeFailure", status === "failed" ? "Tool execution failed" : "Tool completion was not recorded"), profile)
   };
 }
 var CodeBuddyTurnOutput = class {
   turnId;
   cwd;
   emit;
+  profile;
   #items = /* @__PURE__ */ new Map();
   #finished = /* @__PURE__ */ new Set();
   #tools = /* @__PURE__ */ new Map();
   #diffs = /* @__PURE__ */ new Set();
-  constructor(turnId, cwd, emit) {
+  #compactionOutcome;
+  constructor(turnId, cwd, emit, profile = CODEBUDDY_RUNTIME_PROFILE) {
     this.turnId = turnId;
     this.cwd = cwd;
     this.emit = emit;
+    this.profile = profile;
   }
   #start(item) {
     this.#items.set(item.itemId, { item, outcome: { status: "succeeded" } });
@@ -20800,11 +20978,33 @@ var CodeBuddyTurnOutput = class {
       snapshot: structuredClone({ item, outcome })
     });
   }
+  replayCommandResult(items) {
+    if (this.#items.size)
+      return;
+    for (const snapshot of items) {
+      const item = structuredClone(snapshot.item);
+      this.#start(item);
+      this.#finish(item, snapshot.outcome);
+    }
+  }
+  confirmCompaction(items) {
+    const persisted = items.find((snapshot) => snapshot.item.type === "contextCompaction");
+    this.#compactionOutcome = persisted ? structuredClone(persisted.outcome) : void 0;
+  }
+  compact() {
+    const itemId = hostItemIdSchema.parse(`compact-${this.turnId}`);
+    if (!this.#items.has(itemId))
+      this.#start({ type: "contextCompaction", itemId });
+  }
   update(value) {
     const update = record2(value), meta3 = record2(update._meta);
     if (meta3["codebuddy.ai/memberEvent"])
       return;
     const kind = update.sessionUpdate;
+    if (nativeCommandsEnabled(this.profile) && meta3["codebuddy.ai/isCompactInternal"] === true) {
+      this.compact();
+      return;
+    }
     if (kind === "agent_message_chunk" || kind === "agent_thought_chunk") {
       const delta = contentText(update.content);
       if (!delta)
@@ -20844,7 +21044,7 @@ var CodeBuddyTurnOutput = class {
     const terminal = update.status === "completed" || update.status === "failed";
     if (!terminal && !record2(merged._meta)["codebuddy.ai/toolArgumentsComplete"])
       return;
-    const name = text(record2(merged._meta)["codebuddy.ai/toolName"]) || text(merged.title) || "CodeBuddy tool";
+    const name = text(record2(merged._meta)["codebuddy.ai/toolName"]) || text(merged.title) || `${this.profile.displayName} tool`;
     const id = `tool-${callId}`;
     let item = this.#items.get(id)?.item;
     if (!item) {
@@ -20875,7 +21075,7 @@ var CodeBuddyTurnOutput = class {
         update: { type: "output.replace", output }
       });
     }
-    this.#finish(item, toolOutcome(update.status));
+    this.#finish(item, toolOutcome(update.status, this.profile));
     if (update.status === "completed" && !this.#diffs.has(callId)) {
       const changes = [];
       for (const diff of rows(merged.content)) {
@@ -20904,9 +21104,13 @@ var CodeBuddyTurnOutput = class {
   }
   finish(status, error51) {
     for (const { item } of this.#items.values()) {
-      const outcome = status === "failed" ? {
-        status,
-        error: error51 ?? nativeError(new CodeBuddyError("nativeFailure", "Turn failed"))
+      if (item.type === "contextCompaction" && this.#compactionOutcome) {
+        this.#finish(item, this.#compactionOutcome);
+        continue;
+      }
+      const outcome = status === "failed" || item.type === "contextCompaction" && status === "succeeded" && !this.#compactionOutcome ? {
+        status: "failed",
+        error: error51 ?? nativeError(new CodeBuddyError("nativeFailure", item.type === "contextCompaction" ? "Native compaction completion was not confirmed" : "Turn failed"), this.profile)
       } : { status };
       this.#finish(item, outcome);
     }
@@ -20923,7 +21127,7 @@ function codeBuddyChildId(value) {
   const id = structured || /\[Agent ID: (agent-[a-zA-Z0-9_-]+)\]\s*$/u.exec(body)?.[1];
   return id && validCodeBuddyChildId(id) ? id : void 0;
 }
-function codeBuddyDelegation(callId, input, status, childId) {
+function codeBuddyDelegation(callId, input, status, childId, displayName = "CodeBuddy") {
   const args = record2(input);
   const resumed = text(args.resume);
   const nativeId = childId ?? (validCodeBuddyChildId(resumed) ? resumed : void 0);
@@ -20936,7 +21140,7 @@ function codeBuddyDelegation(callId, input, status, childId) {
       {
         subagentId: nativeId ?? callId,
         ...nativeId ? { nativeSubagentId: nativeId } : {},
-        description: text(args.description) || "CodeBuddy Subagent",
+        description: text(args.description) || `${displayName} Subagent`,
         ...text(args.subagent_type) ? { role: text(args.subagent_type) } : {},
         ...text(args.model) ? { model: text(args.model) } : {},
         background: args.run_in_background === true,
@@ -20970,9 +21174,55 @@ async function readCodeBuddyVersionedText(file2, maximumBytes, tooLargeMessage,
 }
 
 // dist/history.js
-function validateNativeRef(ref) {
-  if (ref.harnessId !== CODEBUDDY_ID || ref.formatVersion !== 1 || !/^[A-Za-z0-9][A-Za-z0-9_-]{0,199}$/u.test(ref.nativeSessionId)) {
-    throw new CodeBuddyError("invalidRequest", "Invalid CodeBuddy Native Session identity");
+function codeBuddyProjectSlug(cwd, profile = CODEBUDDY_RUNTIME_PROFILE) {
+  const canonical = codeBuddyCanonicalCwd(cwd);
+  if (profile.projectDirectoryName)
+    return profile.projectDirectoryName(canonical);
+  return canonical.replace(/[^a-z0-9]/giu, "-").replace(/-+/gu, "-").replace(/^-|-$/gu, "").toLowerCase();
+}
+function codeBuddyCanonicalCwd(cwd) {
+  try {
+    return realpathSync.native(cwd);
+  } catch {
+    return path4.resolve(cwd);
+  }
+}
+function codeBuddyConfigRoot(environment, profile) {
+  const configuredRoot = profile.configDirectoryEnvironmentVariables.map((name) => environment[name]).find((value) => typeof value === "string" && value.trim().length > 0);
+  return configuredRoot || path4.join(environment.HOME || environment.USERPROFILE || homedir(), profile.defaultConfigDirectoryName);
+}
+function codeBuddyPrimaryHistoryPath(cwd, ref, environment, profile = CODEBUDDY_RUNTIME_PROFILE) {
+  return path4.join(codeBuddyConfigRoot(environment, profile), "projects", codeBuddyProjectSlug(cwd, profile), `${ref.nativeSessionId}.jsonl`);
+}
+function derivedLocator(ref) {
+  const locator = record2(ref.locator);
+  if (locator.codebuddyDerived !== 1)
+    return void 0;
+  const fields = [
+    locator.boundCwd,
+    locator.targetProjectSlug,
+    locator.inheritedPrefixRows,
+    locator.inheritedPrefixSha256,
+    locator.bindingMarkerId
+  ];
+  if (fields.every((value) => value === void 0))
+    return void 0;
+  if (typeof locator.boundCwd !== "string" || !locator.boundCwd || typeof locator.targetProjectSlug !== "string" || !locator.targetProjectSlug || !Number.isSafeInteger(locator.inheritedPrefixRows) || Number(locator.inheritedPrefixRows) < 0 || typeof locator.inheritedPrefixSha256 !== "string" || !/^[a-f0-9]{64}$/u.test(locator.inheritedPrefixSha256) || typeof locator.bindingMarkerId !== "string" || !locator.bindingMarkerId)
+    throw new CodeBuddyError("protocolError", "Derived Native Session locator is incomplete");
+  return {
+    boundCwd: locator.boundCwd,
+    targetProjectSlug: locator.targetProjectSlug,
+    inheritedPrefixRows: Number(locator.inheritedPrefixRows),
+    inheritedPrefixSha256: locator.inheritedPrefixSha256,
+    bindingMarkerId: locator.bindingMarkerId
+  };
+}
+function nativeRowsDigest(rows2) {
+  return createHash("sha256").update(JSON.stringify(rows2)).digest("hex");
+}
+function validateNativeRef(ref, profile = CODEBUDDY_RUNTIME_PROFILE) {
+  if (ref.harnessId !== profile.harnessId || ref.formatVersion !== 1 || !/^[A-Za-z0-9][A-Za-z0-9_-]{0,199}$/u.test(ref.nativeSessionId)) {
+    throw new CodeBuddyError("invalidRequest", `Invalid ${profile.displayName} Native Session identity`);
   }
 }
 async function sameCwd(left, right) {
@@ -20984,18 +21234,37 @@ async function sameCwd(left, right) {
   });
   return process.platform === "win32" ? a.toLowerCase() === b.toLowerCase() : a === b;
 }
-async function codeBuddyNativeHistory(cwd, ref, environment) {
-  return codeBuddyHistory(cwd, ref, environment, false);
+async function matchesAnyHistoricalCwd(value, candidates) {
+  const resolved = path4.resolve(value);
+  for (const candidate of candidates) {
+    const other = path4.resolve(candidate);
+    if (process.platform === "win32" ? resolved.toLowerCase() === other.toLowerCase() : resolved === other)
+      return true;
+    try {
+      if (await sameCwd(value, candidate))
+        return true;
+    } catch (error51) {
+      if (!(error51 instanceof CodeBuddyError) && !["ENOENT", "ENOTDIR"].includes(text(record2(error51).code)))
+        throw error51;
+    }
+  }
+  return false;
+}
+async function codeBuddyNativeHistory(cwd, ref, environment, profileOrVerifiedSource = CODEBUDDY_RUNTIME_PROFILE, transaction) {
+  const profile = typeof profileOrVerifiedSource === "string" ? CODEBUDDY_RUNTIME_PROFILE : profileOrVerifiedSource;
+  const effectiveTransaction = typeof profileOrVerifiedSource === "string" ? { inheritedContents: profileOrVerifiedSource } : transaction;
+  return codeBuddyHistory(cwd, ref, environment, false, profile, effectiveTransaction);
 }
-async function codeBuddyLiveNativeHistory(cwd, ref, environment) {
-  return codeBuddyHistory(cwd, ref, environment, true);
+async function codeBuddyLiveNativeHistory(cwd, ref, environment, profile = CODEBUDDY_RUNTIME_PROFILE) {
+  return codeBuddyHistory(cwd, ref, environment, true, profile);
 }
-async function codeBuddyHistory(cwd, ref, environment, tolerateIncompleteTail) {
-  validateNativeRef(ref);
-  const configRoot = environment.CODEBUDDY_CONFIG_DIR || path4.join(environment.HOME || environment.USERPROFILE || homedir(), ".codebuddy");
+async function codeBuddyHistory(cwd, ref, environment, tolerateIncompleteTail, profile, transaction) {
+  validateNativeRef(ref, profile);
+  const configRoot = codeBuddyConfigRoot(environment, profile);
   const root = path4.join(configRoot, "projects");
-  const slug = path4.resolve(cwd).replace(/[^a-z0-9]/giu, "-").replace(/-+/gu, "-").replace(/^-|-$/gu, "").toLowerCase();
+  const slug = codeBuddyProjectSlug(cwd, profile);
   const primary = path4.join(root, slug, `${ref.nativeSessionId}.jsonl`);
+  const provenance = derivedLocator(ref);
   let candidates = [];
   try {
     await access(primary);
@@ -21003,6 +21272,8 @@ async function codeBuddyHistory(cwd, ref, environment, tolerateIncompleteTail) {
   } catch (error51) {
     if (record2(error51).code !== "ENOENT")
       throw error51;
+    if (transaction?.requirePrimary || provenance)
+      throw new CodeBuddyError("sessionNotFound", "Native Session history was not found");
     const directories = await readdir(root, { withFileTypes: true }).catch((error52) => {
       if (record2(error52).code === "ENOENT")
         return [];
@@ -21026,15 +21297,63 @@ async function codeBuddyHistory(cwd, ref, environment, tolerateIncompleteTail) {
   const file2 = candidates[0];
   if (!file2)
     throw new CodeBuddyError("sessionNotFound", "Native Session history was not found");
+  if (profile.historyCapabilities?.fork && !transaction && path4.resolve(file2) !== path4.resolve(primary))
+    throw new CodeBuddyError("invalidRequest", "Native Session is not stored in the requested working directory");
   const source = await readCodeBuddyVersionedText(file2, 64e6, "Native history exceeds the supported 64 MB snapshot size"), parsed = parseJsonl(source.contents, tolerateIncompleteTail);
   const checkedDirectories = /* @__PURE__ */ new Set();
-  for (const row of parsed.rows) {
-    if (row.sessionId && row.sessionId !== ref.nativeSessionId)
-      throw new CodeBuddyError("protocolError", "Native history has a different Session identity");
-    if (typeof row.cwd === "string" && !checkedDirectories.has(row.cwd)) {
-      if (!await sameCwd(row.cwd, cwd))
-        throw new CodeBuddyError("invalidRequest", "Native Session belongs to a different working directory");
-      checkedDirectories.add(row.cwd);
+  const inheritedRows = /* @__PURE__ */ new Map();
+  for (const row of transaction?.inheritedContents ? parseRows(transaction.inheritedContents) : []) {
+    const id = text(row.id);
+    const candidates2 = inheritedRows.get(id) ?? [];
+    candidates2.push(row);
+    inheritedRows.set(id, candidates2);
+  }
+  const inherited = (row) => inheritedRows.get(text(row.id))?.some((candidate) => isDeepStrictEqual(candidate, row)) === true;
+  if (transaction) {
+    for (const row of parsed.rows) {
+      if (inherited(row)) {
+        if (typeof row.cwd === "string")
+          checkedDirectories.add(row.cwd);
+        continue;
+      }
+      if (row.sessionId && row.sessionId !== ref.nativeSessionId)
+        throw new CodeBuddyError("protocolError", "Native history has a different Session identity");
+      if (typeof row.cwd === "string" && !checkedDirectories.has(row.cwd)) {
+        const allowed = [cwd, ...transaction.allowedHistoricalCwds ?? []];
+        if (!await matchesAnyHistoricalCwd(row.cwd, allowed))
+          throw new CodeBuddyError("invalidRequest", "Native Session belongs to a different working directory");
+        checkedDirectories.add(row.cwd);
+      }
+    }
+  } else if (provenance) {
+    if (!await sameCwd(provenance.boundCwd, cwd) || provenance.targetProjectSlug !== slug || path4.resolve(file2) !== path4.resolve(primary))
+      throw new CodeBuddyError("invalidRequest", "Derived Native Session target binding changed");
+    const active = nativeHistoryRows(parsed.contents);
+    if (provenance.inheritedPrefixRows > active.length || nativeRowsDigest(active.slice(0, provenance.inheritedPrefixRows)) !== provenance.inheritedPrefixSha256)
+      throw new CodeBuddyError("protocolError", "Derived Native Session prefix verification failed");
+    const marker = parsed.rows.find((row) => text(row.id) === provenance.bindingMarkerId);
+    if (!marker || marker.sessionId !== ref.nativeSessionId || typeof marker.cwd !== "string" || !await sameCwd(marker.cwd, cwd))
+      throw new CodeBuddyError("protocolError", "Derived Native Session target marker is missing");
+    checkedDirectories.add(cwd);
+    const verifiedSuffixCwds = /* @__PURE__ */ new Set();
+    for (const row of active.slice(provenance.inheritedPrefixRows)) {
+      if (row.sessionId && row.sessionId !== ref.nativeSessionId)
+        throw new CodeBuddyError("protocolError", "Derived Native Session appended foreign history");
+      if (typeof row.cwd === "string" && !verifiedSuffixCwds.has(row.cwd)) {
+        if (!await sameCwd(row.cwd, cwd))
+          throw new CodeBuddyError("invalidRequest", "Derived Native Session left its target directory");
+        verifiedSuffixCwds.add(row.cwd);
+      }
+    }
+  } else {
+    for (const row of parsed.rows) {
+      if (row.sessionId && row.sessionId !== ref.nativeSessionId)
+        throw new CodeBuddyError("protocolError", "Native history has a different Session identity");
+      if (typeof row.cwd === "string" && !checkedDirectories.has(row.cwd)) {
+        if (!await sameCwd(row.cwd, cwd))
+          throw new CodeBuddyError("invalidRequest", "Native Session belongs to a different working directory");
+        checkedDirectories.add(row.cwd);
+      }
     }
   }
   return {
@@ -21044,12 +21363,15 @@ async function codeBuddyHistory(cwd, ref, environment, tolerateIncompleteTail) {
     reusableVersion: source.reusableVersion
   };
 }
-async function readNativeHistory(cwd, ref, environment) {
-  return (await codeBuddyNativeHistory(cwd, ref, environment)).contents;
+async function readNativeHistory(cwd, ref, environment, profile = CODEBUDDY_RUNTIME_PROFILE) {
+  return (await codeBuddyNativeHistory(cwd, ref, environment, profile)).contents;
 }
 function parseRows(contents, tolerateIncompleteTail = false) {
   return parseJsonl(contents, tolerateIncompleteTail).rows;
 }
+function nativeRawHistoryRows(contents) {
+  return parseRows(contents);
+}
 function parseJsonl(contents, tolerateIncompleteTail) {
   const lines = contents.split(/\r?\n/u);
   const completeLines = [], rows2 = [];
@@ -21070,11 +21392,25 @@ function parseJsonl(contents, tolerateIncompleteTail) {
     contents: tolerateIncompleteTail ? completeLines.join("\n") : contents
   };
 }
+var NATIVE_MESSAGE_TYPES = /* @__PURE__ */ new Set([
+  "message",
+  "reasoning",
+  "function_call",
+  "function_call_result"
+]);
+function pendingNativeHistoryRewind(contents) {
+  const last = parseRows(contents).findLast((row) => row.type === "resend-fork-notice" || NATIVE_MESSAGE_TYPES.has(text(row.type)));
+  return last?.type === "resend-fork-notice" ? { forkPointId: text(last.parentId) || null } : void 0;
+}
 function nativeHistoryRows(contents) {
   const entries = /* @__PURE__ */ new Map();
   let leaf = "";
   for (const row of parseRows(contents)) {
-    if (!["message", "reasoning", "function_call", "function_call_result"].includes(text(row.type)))
+    if (row.type === "resend-fork-notice") {
+      leaf = text(row.parentId);
+      continue;
+    }
+    if (!NATIVE_MESSAGE_TYPES.has(text(row.type)))
       continue;
     if (!text(row.id))
       throw new CodeBuddyError("protocolError", "Native message is missing its stable ID");
@@ -21094,39 +21430,118 @@ function nativeHistoryRows(contents) {
   }
   return chain.reverse();
 }
-function snapshotFromHistory(contents, ref, cwd) {
+function snapshotFromHistory(contents, ref, cwd, profile = CODEBUDDY_RUNTIME_PROFILE) {
+  const supportsNativeCommands = nativeCommandsEnabled(profile);
+  const supportsFork = capabilitiesForProfile(profile).history.fork;
   const turns = [];
   let current;
   const tools = /* @__PURE__ */ new Map();
-  for (const row of nativeHistoryRows(contents)) {
+  const earlyResults = /* @__PURE__ */ new Map();
+  const applyResult = (snapshot, row) => {
+    snapshot.outcome = toolOutcome(row.status, profile);
+    if (snapshot.item.type === "subagentDelegation") {
+      const childId = codeBuddyChildId(row);
+      snapshot.item.subagents = snapshot.item.subagents.map((child) => ({
+        ...child,
+        ...childId ? { subagentId: childId, nativeSubagentId: childId } : {},
+        status: snapshot.outcome.status === "failed" ? "failed" : child.background ? "interrupted" : "completed",
+        resultSummary: child.background ? "Live background observation is unavailable after reload" : contentText(row.output).slice(0, 2e3)
+      }));
+    }
+    if (snapshot.item.type === "toolExecution")
+      snapshot.item.output = toolOutput(row.output);
+    if (snapshot.item.type === "commandExecution") {
+      const output = toolOutput(row.output);
+      snapshot.item.output = contentText(output.content);
+      snapshot.item.outputTruncated = Boolean(output.truncated);
+    }
+  };
+  const history = nativeHistoryRows(contents);
+  const manualCompactions = /* @__PURE__ */ new Set();
+  let compactUser;
+  if (supportsNativeCommands)
+    for (const row of history) {
+      const data = record2(row.providerData);
+      if (row.type === "message" && row.role === "user")
+        compactUser = data.agent === "compact" ? text(row.id) : void 0;
+      if (compactUser && row.role === "assistant" && data.compactType === "user-command")
+        manualCompactions.add(compactUser);
+    }
+  for (const row of history) {
+    const data = record2(row.providerData);
+    const body = contentText(row.content);
+    const localCommand = supportsNativeCommands && data.skipRun === true ? /^<command-name>([^<]+)<\/command-name>(?:\s*<command-args>([\s\S]*)<\/command-args>)?$/u.exec(body) : null;
+    const localOutput = supportsNativeCommands && data.skipRun === true ? /^<local-command-stdout>([\s\S]*)<\/local-command-stdout>$/u.exec(body) : null;
+    if (localOutput) {
+      if (current) {
+        current.items.push({
+          item: {
+            type: "agentMessage",
+            itemId: hostItemIdSchema.parse(`agentMessage-${text(row.id)}`),
+            text: localOutput[1] ?? ""
+          },
+          outcome: { status: "succeeded" }
+        });
+        current.outcome = { status: "succeeded" };
+      }
+      continue;
+    }
+    if (supportsNativeCommands && data.skipRun === true && body.startsWith('<system-reminder data-role="command-caveat">'))
+      continue;
+    if (supportsNativeCommands && row.type === "message" && row.role === "user" && data.agent === "compact" && !manualCompactions.has(text(row.id)))
+      continue;
     if (row.type === "message" && row.role === "user") {
       current = {
         nativeTurnRef: nativeTurnRefSchema.parse({
-          harnessId: CODEBUDDY_ID,
+          harnessId: profile.harnessId,
           nativeSessionId: ref.nativeSessionId,
           nativeTurnKey: row.id,
           formatVersion: 1
         }),
-        input: [{ type: "text", text: contentText(row.content) }],
+        input: [
+          {
+            type: "text",
+            text: supportsNativeCommands && data.agent === "compact" ? "/compact" : localCommand ? `${localCommand[1]}${localCommand[2] ? ` ${localCommand[2]}` : ""}` : body
+          }
+        ],
         items: [],
         outcome: { status: "unknown", reason: "Native terminal outcome was not recorded" },
         ...typeof row.timestamp === "number" ? { startedAtMs: row.timestamp } : {}
       };
       turns.push(current);
       tools.clear();
+      earlyResults.clear();
       continue;
     }
     if (!current)
       continue;
+    if (supportsNativeCommands && (data.agent === "compact" || data.isCompactInternal === true)) {
+      if (row.role === "assistant") {
+        const outcome = row.status === "completed" && data.isCompacted === true ? { status: "succeeded" } : row.status === "cancelled" || row.status === "interrupted" ? { status: "cancelled" } : {
+          status: "failed",
+          error: nativeError(new CodeBuddyError("nativeFailure", "Native compaction did not complete"), profile)
+        };
+        current.items.push({
+          item: {
+            type: "contextCompaction",
+            itemId: hostItemIdSchema.parse(`compact-${text(row.id)}`)
+          },
+          outcome
+        });
+        if (data.compactType === "user-command")
+          current.outcome = outcome;
+      }
+      continue;
+    }
     const model = text(record2(row.providerData).model);
     if (model)
       current.model = modelRef(model);
     if (row.type === "message" && row.role === "assistant" || row.type === "reasoning") {
       const type = row.type === "reasoning" ? "reasoning" : "agentMessage";
-      const body = contentText(row.content) || contentText(row.rawContent);
-      if (body)
+      const body2 = contentText(row.content) || contentText(row.rawContent);
+      if (body2)
         current.items.push({
-          item: { type, itemId: hostItemIdSchema.parse(`${type}-${text(row.id)}`), text: body },
+          item: { type, itemId: hostItemIdSchema.parse(`${type}-${text(row.id)}`), text: body2 },
           outcome: { status: "succeeded" }
         });
       if (row.role === "assistant" && row.status === "completed") {
@@ -21143,36 +21558,36 @@ function snapshotFromHistory(contents, ref, cwd) {
           throw new CodeBuddyError("protocolError", "Invalid native Tool arguments");
         }
       }
+      const callId = text(row.callId);
       const snapshot = {
-        item: row.name === "Agent" ? codeBuddyDelegation(text(row.callId), input, "running") : toolItem(text(row.callId), text(row.name), input, cwd),
-        outcome: toolOutcome("unknown")
+        item: row.name === "Agent" ? codeBuddyDelegation(callId, input, "running", void 0, profile.displayName) : toolItem(callId, text(row.name), input, typeof row.cwd === "string" ? row.cwd : cwd),
+        outcome: toolOutcome("unknown", profile)
       };
-      tools.set(text(row.callId), snapshot);
+      tools.set(callId, snapshot);
       current.items.push(snapshot);
       current.outcome = { status: "unknown", reason: "Native Tool has not completed" };
-    } else if (row.type === "function_call_result") {
-      const snapshot = tools.get(text(row.callId));
-      if (!snapshot)
-        throw new CodeBuddyError("protocolError", "Native Tool result has no call");
-      snapshot.outcome = toolOutcome(row.status);
-      if (snapshot.item.type === "subagentDelegation") {
-        const childId = codeBuddyChildId(row);
-        snapshot.item.subagents = snapshot.item.subagents.map((child) => ({
-          ...child,
-          ...childId ? { subagentId: childId, nativeSubagentId: childId } : {},
-          status: snapshot.outcome.status === "failed" ? "failed" : child.background ? "interrupted" : "completed",
-          resultSummary: child.background ? "Live background observation is unavailable after reload" : contentText(row.output).slice(0, 2e3)
-        }));
-      }
-      if (snapshot.item.type === "toolExecution")
-        snapshot.item.output = toolOutput(row.output);
-      if (snapshot.item.type === "commandExecution") {
-        const output = toolOutput(row.output);
-        snapshot.item.output = contentText(output.content);
-        snapshot.item.outputTruncated = Boolean(output.truncated);
+      const early = earlyResults.get(callId);
+      if (early) {
+        earlyResults.delete(callId);
+        applyResult(snapshot, early);
       }
+    } else if (row.type === "function_call_result") {
+      const callId = text(row.callId);
+      const snapshot = tools.get(callId);
+      if (snapshot)
+        applyResult(snapshot, row);
+      else
+        earlyResults.set(callId, row);
     }
   }
+  if (supportsFork)
+    for (const turn of turns)
+      turn.checkpoint = nativeCheckpointRefSchema.parse({
+        harnessId: profile.harnessId,
+        nativeSessionId: ref.nativeSessionId,
+        checkpointId: turn.nativeTurnRef.nativeTurnKey,
+        formatVersion: 1
+      });
   return { turns };
 }
 function historyUsage(contents) {
@@ -21203,25 +21618,814 @@ function historyUsage(contents) {
   return Object.keys(result).length ? result : null;
 }
 
+// dist/child-provenance.js
+import { createHash as createHash2 } from "node:crypto";
+import { realpath as realpath3 } from "node:fs/promises";
+import { isDeepStrictEqual as isDeepStrictEqual2 } from "node:util";
+var CODEBUDDY_CHILD_MAX_BYTES = 8e6;
+var equalPath = (left, right) => process.platform === "win32" ? left.toLowerCase() === right.toLowerCase() : left === right;
+function codeBuddyChildDigest(contents) {
+  return createHash2("sha256").update(contents).digest("hex");
+}
+function parseCodeBuddyChild(contents, tolerateIncompleteTail) {
+  const lines = contents.split(/\r?\n/u);
+  if (tolerateIncompleteTail && lines.at(-1)?.trim()) {
+    try {
+      JSON.parse(lines.at(-1) ?? "");
+    } catch {
+      lines.pop();
+    }
+  }
+  const entries = lines.filter((line) => line.trim()).map((line) => record2(JSON.parse(line)));
+  return { contents: lines.join("\n"), entries };
+}
+function inheritedChildren(parent) {
+  const value = record2(parent.locator).codebuddyInheritedChildren;
+  if (value === void 0)
+    return [];
+  if (!Array.isArray(value) || value.length > 256)
+    throw new CodeBuddyError("protocolError", "Inherited Subagent provenance is invalid");
+  const seen = /* @__PURE__ */ new Set();
+  return value.map((candidate) => {
+    const child = record2(candidate);
+    const historicalCwds = child.historicalCwds;
+    const recordedCwds = child.recordedCwds;
+    const workspaceBindings = child.workspaceBindings;
+    if (!validCodeBuddyChildId(text(child.childId)) || !/^[A-Za-z0-9][A-Za-z0-9_-]{0,199}$/u.test(text(child.nativeSessionId)) || !Number.isSafeInteger(child.inheritedBytes) || Number(child.inheritedBytes) < 0 || Number(child.inheritedBytes) > CODEBUDDY_CHILD_MAX_BYTES || !Number.isSafeInteger(child.inheritedRows) || Number(child.inheritedRows) < 0 || typeof child.inheritedSha256 !== "string" || !/^[a-f0-9]{64}$/u.test(child.inheritedSha256) || !Array.isArray(historicalCwds) || historicalCwds.length > 256 || historicalCwds.some((cwd) => typeof cwd !== "string" || !cwd) || !Array.isArray(recordedCwds) || recordedCwds.length > 256 || recordedCwds.some((cwd) => typeof cwd !== "string" || !cwd) || !Array.isArray(workspaceBindings) || workspaceBindings.length > 256)
+      throw new CodeBuddyError("protocolError", "Inherited Subagent provenance is invalid");
+    const bindings = workspaceBindings.map((candidate2) => {
+      const binding = record2(candidate2);
+      if (typeof binding.recordedCwd !== "string" || !binding.recordedCwd || typeof binding.canonicalCwd !== "string" || !binding.canonicalCwd)
+        throw new CodeBuddyError("protocolError", "Inherited Subagent provenance is invalid");
+      return {
+        recordedCwd: binding.recordedCwd,
+        canonicalCwd: binding.canonicalCwd
+      };
+    });
+    const boundRecorded = new Set(bindings.map((binding) => binding.recordedCwd));
+    const boundCanonical = new Set(bindings.map((binding) => binding.canonicalCwd));
+    if (boundRecorded.size !== bindings.length || new Set(recordedCwds).size !== recordedCwds.length || boundRecorded.size !== new Set(recordedCwds).size || recordedCwds.some((cwd) => !boundRecorded.has(cwd)) || new Set(historicalCwds).size !== historicalCwds.length || boundCanonical.size !== new Set(historicalCwds).size || historicalCwds.some((cwd) => !boundCanonical.has(cwd)))
+      throw new CodeBuddyError("protocolError", "Inherited Subagent provenance is inconsistent");
+    const childId = text(child.childId);
+    if (seen.has(childId))
+      throw new CodeBuddyError("protocolError", "Inherited Subagent provenance is ambiguous");
+    seen.add(childId);
+    return {
+      childId,
+      nativeSessionId: text(child.nativeSessionId),
+      inheritedBytes: Number(child.inheritedBytes),
+      inheritedRows: Number(child.inheritedRows),
+      inheritedSha256: child.inheritedSha256,
+      recordedCwds: [...recordedCwds],
+      historicalCwds: [...historicalCwds],
+      workspaceBindings: bindings
+    };
+  });
+}
+function codeBuddyInheritedChild(parent, childId) {
+  return inheritedChildren(parent).find((child) => child.childId === childId);
+}
+async function canonicalCwds(cwds) {
+  const result = /* @__PURE__ */ new Map();
+  for (const cwd of new Set(cwds)) {
+    const canonical = await realpath3(cwd).catch((error51) => {
+      if (["ENOENT", "ENOTDIR"].includes(String(record2(error51).code)))
+        throw new CodeBuddyError("invalidRequest", "Subagent historical working directory is unavailable; ownership cannot be verified");
+      throw error51;
+    });
+    result.set(cwd, canonical);
+  }
+  return result;
+}
+async function validateCodeBuddyChildContents(contents, parent, childId, cwd, tolerateIncompleteTail) {
+  if (!validCodeBuddyChildId(childId))
+    throw new CodeBuddyError("invalidRequest", "Invalid native Subagent ID");
+  const parsed = parseCodeBuddyChild(contents, tolerateIncompleteTail);
+  const sessions = new Set(parsed.entries.map((row) => text(row.sessionId)).filter(Boolean));
+  if (sessions.size !== 1)
+    throw new CodeBuddyError("protocolError", "Subagent transcript identity is missing or mixed");
+  const nativeSessionId = [...sessions][0];
+  if (!nativeSessionId || !/^[A-Za-z0-9][A-Za-z0-9_-]{0,199}$/u.test(nativeSessionId))
+    throw new CodeBuddyError("protocolError", "Missing or invalid native child Session");
+  const inherited = codeBuddyInheritedChild(parent, childId);
+  let inheritedEntries = [];
+  if (inherited) {
+    const bytes = Buffer.from(contents, "utf8");
+    if (inherited.inheritedBytes > bytes.length)
+      throw new CodeBuddyError("protocolError", "Inherited Subagent prefix is incomplete");
+    const prefix = bytes.subarray(0, inherited.inheritedBytes);
+    const prefixText = prefix.toString("utf8");
+    if (!isDeepStrictEqual2(Buffer.from(prefixText, "utf8"), prefix) || codeBuddyChildDigest(prefix) !== inherited.inheritedSha256)
+      throw new CodeBuddyError("protocolError", "Inherited Subagent prefix verification failed");
+    let prefixParsed;
+    try {
+      prefixParsed = parseCodeBuddyChild(prefixText, false);
+    } catch {
+      throw new CodeBuddyError("protocolError", "Inherited Subagent prefix is malformed");
+    }
+    if (prefixParsed.entries.length !== inherited.inheritedRows || parsed.entries.length < inherited.inheritedRows || !isDeepStrictEqual2(prefixParsed.entries, parsed.entries.slice(0, inherited.inheritedRows)) || nativeSessionId !== inherited.nativeSessionId)
+      throw new CodeBuddyError("protocolError", "Inherited Subagent identity changed");
+    inheritedEntries = prefixParsed.entries;
+  }
+  const target = await realpath3(cwd);
+  const inheritedCwds = inheritedEntries.flatMap((row) => typeof row.cwd === "string" ? [row.cwd] : []);
+  const suffixCwds = parsed.entries.slice(inheritedEntries.length).flatMap((row) => typeof row.cwd === "string" ? [row.cwd] : []);
+  const canonical = await canonicalCwds(suffixCwds);
+  if (inherited) {
+    const allowed = new Set(inherited.recordedCwds);
+    const observed = new Set(inheritedCwds);
+    if (allowed.size !== observed.size || [...allowed].some((value) => !observed.has(value)) || inheritedCwds.some((value) => !allowed.has(value)))
+      throw new CodeBuddyError("invalidRequest", "Inherited Subagent workspace changed");
+  }
+  for (const value of suffixCwds) {
+    const actual = canonical.get(value);
+    if (!actual || !equalPath(actual, target))
+      throw new CodeBuddyError("invalidRequest", "Subagent workspace differs from parent");
+  }
+  const bindings = new Map((inherited?.workspaceBindings ?? []).map((binding) => [
+    binding.recordedCwd,
+    binding.canonicalCwd
+  ]));
+  for (const value of new Set(suffixCwds)) {
+    const resolved = canonical.get(value);
+    if (!resolved)
+      throw new CodeBuddyError("invalidRequest", "Subagent workspace is unavailable");
+    const existing = bindings.get(value);
+    if (existing && !equalPath(existing, resolved))
+      throw new CodeBuddyError("invalidRequest", "Subagent workspace binding changed");
+    bindings.set(value, resolved);
+  }
+  return {
+    ...parsed,
+    nativeSessionId,
+    recordedCwds: [...bindings.keys()],
+    historicalCwds: [...new Set(bindings.values())],
+    workspaceBindings: [...bindings].map(([recordedCwd, canonicalCwd]) => ({
+      recordedCwd,
+      canonicalCwd
+    }))
+  };
+}
+function codeBuddyInheritedChildDescriptor(childId, contents, child) {
+  if (child.recordedCwds.length > 256 || child.historicalCwds.length > 256)
+    throw new CodeBuddyError("unsupported", "Too many Subagent historical workspaces");
+  return {
+    childId,
+    nativeSessionId: child.nativeSessionId,
+    inheritedBytes: Buffer.byteLength(contents, "utf8"),
+    inheritedRows: child.entries.length,
+    inheritedSha256: codeBuddyChildDigest(contents),
+    recordedCwds: child.recordedCwds,
+    historicalCwds: child.historicalCwds,
+    workspaceBindings: child.workspaceBindings
+  };
+}
+async function codeBuddyChildPrefixThrough(contents, lastId, child) {
+  let cursor = 0;
+  let rowIndex = 0;
+  let match = -1;
+  let end = -1;
+  while (cursor < contents.length) {
+    const newline2 = contents.indexOf("\n", cursor);
+    const next = newline2 < 0 ? contents.length : newline2 + 1;
+    const physicalLine = contents.slice(cursor, next);
+    const line = physicalLine.replace(/\r?\n$/u, "");
+    if (line.trim()) {
+      const row = child.entries[rowIndex++];
+      if (!row)
+        throw new CodeBuddyError("protocolError", "Subagent transcript rows changed");
+      if (text(row.id) === lastId) {
+        if (match >= 0)
+          throw new CodeBuddyError("protocolError", "Agent result has an ambiguous child range");
+        match = rowIndex - 1;
+        end = next;
+      }
+    }
+    cursor = next;
+  }
+  if (rowIndex !== child.entries.length || match < 0 || end < 0)
+    throw new CodeBuddyError("protocolError", "Agent result child range was not found");
+  const entries = child.entries.slice(0, match + 1);
+  const cwdValues = entries.flatMap((row) => typeof row.cwd === "string" ? [row.cwd] : []);
+  const inheritedBindings = new Map(child.workspaceBindings.map((binding) => [binding.recordedCwd, binding.canonicalCwd]));
+  const bindings = [...new Set(cwdValues)].map((recordedCwd) => {
+    const canonicalCwd = inheritedBindings.get(recordedCwd);
+    if (!canonicalCwd)
+      throw new CodeBuddyError("protocolError", "Subagent workspace binding is missing");
+    return { recordedCwd, canonicalCwd };
+  });
+  return {
+    contents: contents.slice(0, end),
+    child: {
+      contents: contents.slice(0, end),
+      entries,
+      nativeSessionId: child.nativeSessionId,
+      recordedCwds: bindings.map((binding) => binding.recordedCwd),
+      historicalCwds: [...new Set(bindings.map((binding) => binding.canonicalCwd))],
+      workspaceBindings: bindings
+    }
+  };
+}
+
+// dist/derivation.js
+async function copyCodeBuddySession(cwd, sourceId, targetId, environment, signal, invocationFactory = codeBuddyInvocation) {
+  if (signal.aborted)
+    throw new CodeBuddyError("invalidState", "Adapter closed before history copy");
+  const invocation = invocationFactory(environment, false, [
+    "--resume",
+    sourceId,
+    "--fork-session",
+    "--session-id",
+    targetId,
+    "--print",
+    "--input-format",
+    "stream-json",
+    "--output-format",
+    "stream-json"
+  ]);
+  await new Promise((resolve, reject) => {
+    const child = spawn2(invocation.command, invocation.arguments, {
+      cwd,
+      env: invocation.environment,
+      stdio: "pipe",
+      windowsHide: true,
+      windowsVerbatimArguments: invocation.windowsVerbatimArguments,
+      detached: process.platform !== "win32"
+    });
+    let output = "", bytes = 0, failed = false;
+    let termination = Promise.resolve();
+    const stop = () => {
+      if (failed)
+        return;
+      failed = true;
+      if (child.exitCode !== null || child.signalCode !== null) {
+        child.stdout.destroy();
+        child.stderr.destroy();
+      } else if (process.platform === "win32" && child.pid) {
+        termination = new Promise((done) => {
+          execFile2("taskkill", ["/PID", String(child.pid), "/T", "/F"], { windowsHide: true, timeout: 3e3 }, () => {
+            child.kill();
+            done();
+          });
+        });
+      } else if (child.pid) {
+        try {
+          process.kill(-child.pid, "SIGKILL");
+        } catch {
+          child.kill("SIGKILL");
+        }
+      } else
+        child.kill("SIGKILL");
+    };
+    const timer = setTimeout(stop, 3e4);
+    signal.addEventListener("abort", stop, { once: true });
+    child.stdout.on("data", (data) => {
+      bytes += data.length;
+      if (bytes > 64e6) {
+        stop();
+        return;
+      }
+      output += data.toString();
+    });
+    child.stderr.resume();
+    child.stdin.on("error", () => {
+    });
+    child.once("error", reject);
+    child.once("close", async (code) => {
+      await termination;
+      clearTimeout(timer);
+      signal.removeEventListener("abort", stop);
+      if (failed || signal.aborted || code !== 0) {
+        reject(new CodeBuddyError("nativeFailure", "Native history copy failed or was interrupted"));
+        return;
+      }
+      try {
+        const rows2 = output.trim().split(/\r?\n/u).filter(Boolean).map((line) => record2(JSON.parse(line)));
+        const init = rows2.find((row) => row.type === "system" && row.subtype === "init");
+        const result = rows2.findLast((row) => row.type === "result");
+        if (init?.session_id !== targetId || result?.session_id !== targetId || result?.is_error !== false || result?.duration_api_ms !== 0)
+          throw new CodeBuddyError("unsupported", "Native CLI did not confirm a model-free history copy");
+        resolve();
+      } catch (error51) {
+        reject(error51);
+      }
+    });
+    if (signal.aborted)
+      stop();
+    child.stdin.end();
+  });
+}
+function withoutIdentity(row) {
+  const result = { ...row };
+  delete result.id;
+  delete result.parentId;
+  delete result.logicalParentId;
+  delete result.sessionId;
+  return result;
+}
+function assertCopiedPrefix(source, copied) {
+  if (copied.length < source.length)
+    throw new CodeBuddyError("unsupported", "Native Fork omitted history");
+  const ids = new Map(source.map((row, index) => [text(row.id), text(copied[index]?.id)]));
+  for (const [index, row] of source.entries()) {
+    const clone2 = copied[index];
+    if (!clone2)
+      throw new CodeBuddyError("unsupported", "Native Fork omitted history");
+    if (!isDeepStrictEqual3(withoutIdentity(row), withoutIdentity(clone2)) || ["parentId", "logicalParentId"].some((key) => text(clone2[key]) !== (ids.get(text(row[key])) ?? "")))
+      throw new CodeBuddyError("unsupported", "Native Fork did not preserve the exact history prefix");
+  }
+}
+function commandCaveat(row) {
+  return record2(row?.providerData).skipRun === true && JSON.stringify(row?.content).includes('data-role=\\"command-caveat\\"');
+}
+function retainedRowCount(input, contents, sourceCwd = input.cwd, profile = CODEBUDDY_RUNTIME_PROFILE) {
+  const rows2 = nativeHistoryRows(contents);
+  const turns = snapshotFromHistory(contents, input.sourceRef, sourceCwd, profile).turns;
+  let excluded2;
+  if (input.kind === "rollbackLastTurn") {
+    if (!turns.length)
+      throw new CodeBuddyError("invalidState", "Native Session has no Turn to revise");
+    excluded2 = turns.at(-1)?.nativeTurnRef.nativeTurnKey;
+  } else {
+    const checkpoint = input.checkpoint;
+    const index = turns.findIndex((turn) => turn.nativeTurnRef.nativeTurnKey === checkpoint.checkpointId);
+    if (checkpoint.harnessId !== profile.harnessId || checkpoint.nativeSessionId !== input.sourceRef.nativeSessionId || checkpoint.formatVersion !== 1 || index < 0)
+      throw new CodeBuddyError("checkpointNotFound", "Native Fork checkpoint was not found");
+    excluded2 = turns[index + 1]?.nativeTurnRef.nativeTurnKey;
+  }
+  let count = excluded2 ? rows2.findIndex((row) => row.id === excluded2) : rows2.length;
+  if (count < 0)
+    throw new CodeBuddyError("protocolError", "Native Turn boundary is missing");
+  if (excluded2)
+    while (count > 0 && commandCaveat(rows2[count - 1]))
+      count--;
+  return count;
+}
+function sameResolvedPath(left, right) {
+  const a = codeBuddyCanonicalCwd(left), b = codeBuddyCanonicalCwd(right);
+  return process.platform === "win32" ? a.toLowerCase() === b.toLowerCase() : a === b;
+}
+async function bridgeCopyToTarget(sourceCwd, targetCwd, ref, contents, environment, profile) {
+  const sourceFile = codeBuddyPrimaryHistoryPath(sourceCwd, ref, environment, profile);
+  const targetFile = codeBuddyPrimaryHistoryPath(targetCwd, ref, environment, profile);
+  if (sameResolvedPath(sourceFile, targetFile))
+    return void 0;
+  const targetDirectory = path5.dirname(targetFile);
+  const projectsDirectory = path5.dirname(targetDirectory);
+  await mkdir(targetDirectory, { recursive: true });
+  const [realProjects, realTargetDirectory] = await Promise.all([
+    realpath4(projectsDirectory),
+    realpath4(targetDirectory)
+  ]);
+  if (!sameResolvedPath(realTargetDirectory, path5.join(realProjects, codeBuddyProjectSlug(targetCwd, profile))))
+    throw new CodeBuddyError("invalidRequest", "Cross-directory history bridge target escaped the native projects root");
+  const expected = Buffer.from(contents, "utf8");
+  await writeFile(targetFile, expected, { flag: "wx", mode: 384 });
+  const bridge = { file: targetFile, expected };
+  try {
+    const persisted = await readFile2(targetFile);
+    if (!isDeepStrictEqual3(persisted, expected))
+      throw new CodeBuddyError("nativeFailure", "Cross-directory history bridge changed native bytes");
+    return bridge;
+  } catch (error51) {
+    return failAfterBridgeCleanup(error51, bridge);
+  }
+}
+async function cleanupBridge(bridge) {
+  if (!bridge)
+    return;
+  try {
+    const info = await lstat(bridge.file);
+    if (!info.isFile() || process.platform !== "win32" && (info.mode & 63) !== 0)
+      return;
+    if (!isDeepStrictEqual3(await readFile2(bridge.file), bridge.expected))
+      return;
+    await unlink(bridge.file);
+  } catch (error51) {
+    if (record2(error51).code !== "ENOENT")
+      throw error51;
+  }
+}
+async function failAfterBridgeCleanup(failure2, bridge) {
+  try {
+    await cleanupBridge(bridge);
+  } catch (cleanupFailure) {
+    throw new AggregateError([failure2, cleanupFailure], "Native derivation and bridge cleanup both failed");
+  }
+  throw failure2;
+}
+function argumentsRecord(value) {
+  if (typeof value !== "string")
+    return record2(value);
+  try {
+    return record2(JSON.parse(value));
+  } catch {
+    return {};
+  }
+}
+function referencedChildren(rows2) {
+  const calls = /* @__PURE__ */ new Map();
+  const children = /* @__PURE__ */ new Map();
+  for (const row of rows2) {
+    if (row.type === "function_call" && row.name === "Agent") {
+      const callId2 = text(row.callId);
+      if (!callId2 || calls.has(callId2))
+        throw new CodeBuddyError("protocolError", "Agent delegation identity is ambiguous");
+      const resumed2 = text(argumentsRecord(row.arguments).resume);
+      if (resumed2 && !validCodeBuddyChildId(resumed2))
+        throw new CodeBuddyError("protocolError", "Agent delegation has an invalid child identity");
+      calls.set(callId2, resumed2 || void 0);
+      continue;
+    }
+    if (row.type !== "function_call_result")
+      continue;
+    const callId = text(row.callId);
+    if (!calls.has(callId))
+      continue;
+    const subagent = record2(record2(record2(row.providerData).toolResult).subAgent);
+    const childId = text(subagent.sessionId);
+    if (!validCodeBuddyChildId(childId))
+      throw new CodeBuddyError("unsupported", "Retained Agent result has no verified native child identity");
+    const resumed = calls.get(callId);
+    if (resumed && resumed !== childId)
+      throw new CodeBuddyError("protocolError", "Agent result changed its child identity");
+    const lastId = text(subagent.lastId);
+    const afterId = text(subagent.afterId);
+    if (!lastId)
+      throw new CodeBuddyError("unsupported", "Retained Agent result has no bounded child transcript range");
+    const child = children.get(childId) ?? { childId, ranges: [] };
+    child.ranges.push({ ...afterId ? { afterId } : {}, lastId });
+    children.set(childId, child);
+    if (children.size > 256)
+      throw new CodeBuddyError("unsupported", "Too many retained Subagent transcripts");
+    calls.delete(callId);
+  }
+  if (calls.size)
+    throw new CodeBuddyError("unsupported", "Retained Agent delegation is incomplete");
+  return [...children.values()];
+}
+function assertChildRanges(rows2, child) {
+  const positions = /* @__PURE__ */ new Map();
+  for (const [index, row] of rows2.entries()) {
+    const id = text(row.id);
+    if (!id)
+      continue;
+    const matches = positions.get(id) ?? [];
+    matches.push(index);
+    positions.set(id, matches);
+  }
+  let previous = -1;
+  for (const range of child.ranges) {
+    const last = positions.get(range.lastId);
+    const after = range.afterId ? positions.get(range.afterId) : void 0;
+    if (last?.length !== 1 || after && after.length !== 1 || range.afterId && !after || after && (after[0] ?? -1) >= (last[0] ?? -1) || (last[0] ?? -1) < previous)
+      throw new CodeBuddyError("protocolError", "Agent result child range is inconsistent");
+    previous = last[0] ?? -1;
+  }
+}
+async function plainDirectory(parent, name) {
+  const directory = path5.join(parent, name);
+  await mkdir(directory, { mode: 448 }).catch((error51) => {
+    if (record2(error51).code !== "EEXIST")
+      throw error51;
+  });
+  const info = await lstat(directory);
+  if (!info.isDirectory() || info.isSymbolicLink() || process.platform !== "win32" && (info.mode & 18) !== 0)
+    throw new CodeBuddyError("invalidRequest", "Redirected native Subagent directory");
+  const actual = await realpath4(directory);
+  if (!sameResolvedPath(actual, directory))
+    throw new CodeBuddyError("invalidRequest", "Redirected native Subagent directory");
+  return directory;
+}
+async function verifiedChildFile(file2, expected) {
+  const info = await lstat(file2);
+  if (!info.isFile() || info.isSymbolicLink() || process.platform !== "win32" && (info.mode & 63) !== 0)
+    throw new CodeBuddyError("invalidRequest", "Unsafe derived Subagent transcript");
+  if (!sameResolvedPath(await realpath4(file2), file2))
+    throw new CodeBuddyError("invalidRequest", "Redirected derived Subagent transcript");
+  const before = await codeBuddyFileVersion(file2);
+  const actual = await readCodeBuddyVersionedText(file2, CODEBUDDY_CHILD_MAX_BYTES, "Subagent transcript exceeds 8 MB", before);
+  if (!actual.reusableVersion || !sameCodeBuddyFileVersion(before, actual.reusableVersion) || !isDeepStrictEqual3(Buffer.from(actual.contents, "utf8"), expected))
+    throw new CodeBuddyError("nativeFailure", "Native Fork produced a different Subagent transcript");
+}
+async function persistChildCopy(file2, expected) {
+  try {
+    await writeFile(file2, expected, { flag: "wx", mode: 384 });
+  } catch (error51) {
+    if (record2(error51).code !== "EEXIST")
+      throw error51;
+    await verifiedChildFile(file2, expected);
+    return void 0;
+  }
+  const copy = { file: file2, expected };
+  try {
+    await verifiedChildFile(file2, expected);
+    return copy;
+  } catch (error51) {
+    return failAfterBridgeCleanup(error51, copy);
+  }
+}
+async function copyInheritedChildren(options) {
+  const { references } = options;
+  if (!references.length)
+    return { descriptors: [], created: [] };
+  const sourceHistoryFile = await realpath4(options.sourceHistoryFile);
+  const sourceProject = path5.dirname(sourceHistoryFile);
+  if (!sameResolvedPath(sourceHistoryFile, path5.join(sourceProject, `${options.sourceRef.nativeSessionId}.jsonl`)))
+    throw new CodeBuddyError("invalidRequest", "Unexpected source history location");
+  const sourceDirectory = path5.join(sourceProject, options.sourceRef.nativeSessionId, "subagents");
+  const sourceDirectoryInfo = await lstat(sourceDirectory);
+  if (!sourceDirectoryInfo.isDirectory() || sourceDirectoryInfo.isSymbolicLink())
+    throw new CodeBuddyError("invalidRequest", "Redirected source Subagent directory");
+  if (!sameResolvedPath(await realpath4(sourceDirectory), sourceDirectory))
+    throw new CodeBuddyError("invalidRequest", "Redirected source Subagent directory");
+  const targetHistoryFile = await realpath4(options.targetHistoryFile);
+  const targetProject = path5.dirname(targetHistoryFile);
+  if (!sameResolvedPath(targetHistoryFile, path5.join(targetProject, `${options.targetRef.nativeSessionId}.jsonl`)))
+    throw new CodeBuddyError("invalidRequest", "Unexpected target history location");
+  const targetSessionDirectory = await plainDirectory(targetProject, options.targetRef.nativeSessionId);
+  const targetDirectory = await plainDirectory(targetSessionDirectory, "subagents");
+  const descriptors = [];
+  const created = [];
+  try {
+    for (const reference of references) {
+      const sourceFile = path5.join(sourceDirectory, `${reference.childId}.jsonl`);
+      const sourceInfo = await lstat(sourceFile);
+      if (!sourceInfo.isFile() || sourceInfo.isSymbolicLink())
+        throw new CodeBuddyError("invalidRequest", "Redirected source Subagent transcript");
+      const before = await codeBuddyFileVersion(sourceFile);
+      if (!sameResolvedPath(before.realFile, sourceFile))
+        throw new CodeBuddyError("invalidRequest", "Redirected source Subagent transcript");
+      if (before.size > CODEBUDDY_CHILD_MAX_BYTES)
+        throw new CodeBuddyError("unsupported", "Subagent transcript exceeds 8 MB");
+      const source = await readCodeBuddyVersionedText(sourceFile, CODEBUDDY_CHILD_MAX_BYTES, "Subagent transcript exceeds 8 MB", before);
+      if (!source.reusableVersion)
+        throw new CodeBuddyError("sessionBusy", "Source Subagent changed during Fork");
+      const validated = await validateCodeBuddyChildContents(source.contents, options.sourceRef, reference.childId, options.sourceCwd, false);
+      assertChildRanges(validated.entries, reference);
+      const last = reference.ranges.at(-1)?.lastId;
+      if (!last)
+        throw new CodeBuddyError("protocolError", "Missing Agent result child range");
+      const prefix = await codeBuddyChildPrefixThrough(source.contents, last, validated);
+      const expected = Buffer.from(prefix.contents, "utf8");
+      const targetFile = path5.join(targetDirectory, `${reference.childId}.jsonl`);
+      const copy = await persistChildCopy(targetFile, expected);
+      if (copy)
+        created.push(copy);
+      const after = await readCodeBuddyVersionedText(sourceFile, CODEBUDDY_CHILD_MAX_BYTES, "Subagent transcript exceeds 8 MB", before);
+      if (!after.reusableVersion || !sameCodeBuddyFileVersion(before, after.reusableVersion) || after.contents !== source.contents)
+        throw new CodeBuddyError("sessionBusy", "Source Subagent changed during Fork");
+      descriptors.push(codeBuddyInheritedChildDescriptor(reference.childId, prefix.contents, prefix.child));
+    }
+    return { descriptors, created };
+  } catch (failure2) {
+    const cleanupFailures = [];
+    for (const copy of created.toReversed()) {
+      try {
+        await cleanupBridge(copy);
+      } catch (error51) {
+        cleanupFailures.push(error51);
+      }
+    }
+    if (cleanupFailures.length)
+      throw new AggregateError([failure2, ...cleanupFailures], "Subagent copy and cleanup both failed");
+    throw failure2;
+  }
+}
+async function deriveCodeBuddySession(options) {
+  const { input, environment, factory, signal } = options;
+  const sourceCwd = options.sourceCwd ?? input.cwd;
+  const profile = options.profile ?? CODEBUDDY_RUNTIME_PROFILE;
+  const strictHistoryBinding = profile.historyCapabilities?.forkAcrossCwd === true;
+  validateNativeRef(input.sourceRef, profile);
+  const source = await codeBuddyNativeHistory(sourceCwd, input.sourceRef, environment, profile);
+  const retained = retainedRowCount(input, source.contents, sourceCwd, profile);
+  const sourceRows = nativeHistoryRows(source.contents);
+  const childReferences = referencedChildren(sourceRows.slice(0, retained));
+  const temporary = nativeSessionRefSchema.parse({
+    harnessId: profile.harnessId,
+    nativeSessionId: randomUUID(),
+    formatVersion: 1
+  });
+  await (options.copy ?? copyCodeBuddySession)(sourceCwd, input.sourceRef.nativeSessionId, temporary.nativeSessionId, environment, signal, options.invocationFactory ?? codeBuddyInvocation);
+  const nativeCopy = await codeBuddyNativeHistory(sourceCwd, temporary, environment, profile, {
+    ...strictHistoryBinding ? { requirePrimary: true } : {},
+    inheritedContents: source.contents
+  });
+  if (!isDeepStrictEqual3(nativeHistoryRows(nativeCopy.contents), sourceRows))
+    throw new CodeBuddyError("unsupported", "Native history copy changed the source prefix");
+  const bridge = strictHistoryBinding ? await bridgeCopyToTarget(sourceCwd, input.cwd, temporary, nativeCopy.contents, environment, profile) : void 0;
+  if (strictHistoryBinding) {
+    let targetCopy;
+    try {
+      targetCopy = await codeBuddyNativeHistory(input.cwd, temporary, environment, profile, {
+        requirePrimary: true,
+        inheritedContents: nativeCopy.contents
+      });
+    } catch (error51) {
+      return failAfterBridgeCleanup(error51, bridge);
+    }
+    if (targetCopy.contents !== nativeCopy.contents) {
+      return failAfterBridgeCleanup(new CodeBuddyError("nativeFailure", "Cross-directory history bridge changed native bytes"), bridge);
+    }
+  }
+  let derivedId;
+  let failure2;
+  let inheritedChildCopies = [];
+  let derivationSucceeded = false;
+  let receiveCommands;
+  const commands = new Promise((resolve) => {
+    receiveCommands = resolve;
+  });
+  let client2;
+  try {
+    client2 = factory({
+      cwd: input.cwd,
+      environment,
+      ephemeral: false,
+      temporarySessionId: temporary.nativeSessionId,
+      handlers: {
+        permission: async () => ({ outcome: { outcome: "cancelled" } }),
+        question: async () => ({ outcome: "cancelled" }),
+        fault: (error51) => {
+          failure2 = error51;
+        },
+        update: ({ sessionId, update }) => {
+          if (record2(update).sessionUpdate === "available_commands_update")
+            receiveCommands(record2(update).availableCommands);
+          const meta3 = record2(record2(update)._meta);
+          if (meta3["codebuddy.ai/sessionReset"] === true && meta3["codebuddy.ai/newSessionId"] === sessionId)
+            derivedId = sessionId;
+        }
+      }
+    });
+  } catch (error51) {
+    return failAfterBridgeCleanup(error51, bridge);
+  }
+  const abort = () => {
+    void client2.close();
+  };
+  signal.addEventListener("abort", abort, { once: true });
+  let primaryFailure;
+  try {
+    if (!client2.removeCopy)
+      throw new CodeBuddyError("unsupported", "Native temporary Session cleanup is unavailable");
+    if (signal.aborted)
+      throw new CodeBuddyError("invalidState", "Adapter closed during Fork");
+    await client2.initialize();
+    const opened = await client2.open(input.cwd, temporary.nativeSessionId);
+    if (opened.sessionId && opened.sessionId !== temporary.nativeSessionId)
+      throw new CodeBuddyError("protocolError", "ACP loaded a different temporary Session");
+    const nativeState = configuration(opened.configOptions, profile).state;
+    const available = await bounded(commands, 5e3, "Native command discovery", abort);
+    if (!Array.isArray(available) || !available.some((entry) => record2(entry).name === "fork"))
+      throw new CodeBuddyError("unsupported", "Native Session does not advertise /fork");
+    const result = await bounded(client2.prompt(temporary.nativeSessionId, "/fork"), 2e4, "Native Fork", abort);
+    if (failure2)
+      throw failure2;
+    if (result.stopReason !== "end_turn" || !derivedId || [input.sourceRef.nativeSessionId, temporary.nativeSessionId].includes(derivedId))
+      throw new CodeBuddyError("unsupported", "Native Fork did not report a separate Session");
+    const preliminaryRef = nativeSessionRefSchema.parse({
+      harnessId: profile.harnessId,
+      nativeSessionId: derivedId,
+      formatVersion: 1
+    });
+    const historicalCwds = [
+      .../* @__PURE__ */ new Set([
+        ...sourceRows.flatMap((row) => typeof row.cwd === "string" ? [row.cwd] : []),
+        ...source.historicalCwds,
+        sourceCwd,
+        input.cwd
+      ])
+    ];
+    const historyTransaction = strictHistoryBinding ? { requirePrimary: true, allowedHistoricalCwds: historicalCwds } : void 0;
+    const forked = await codeBuddyNativeHistory(input.cwd, preliminaryRef, environment, profile, historyTransaction);
+    const forkRows = nativeHistoryRows(forked.contents);
+    assertCopiedPrefix(sourceRows, forkRows);
+    const marker = strictHistoryBinding ? nativeRawHistoryRows(forked.contents).findLast((row) => Boolean(text(row.id)) && row.sessionId === derivedId && typeof row.cwd === "string" && sameResolvedPath(row.cwd, input.cwd)) : void 0;
+    if (strictHistoryBinding && !marker)
+      throw new CodeBuddyError("unsupported", "Native Fork did not persist a target binding marker");
+    if (!client2.rollback)
+      throw new CodeBuddyError("unsupported", "Native history rewind is unavailable");
+    const point = retained ? text(forkRows[retained - 1]?.id) : null;
+    const rewound = await client2.rollback(derivedId, point);
+    if (rewound.applied !== true || (rewound.actualForkPointId ?? null) !== point)
+      throw new CodeBuddyError("nativeFailure", "Native history rewind was not confirmed");
+    const verified = await codeBuddyNativeHistory(input.cwd, preliminaryRef, environment, profile, historyTransaction);
+    const finalRows = nativeHistoryRows(verified.contents);
+    if (!isDeepStrictEqual3(finalRows, forkRows.slice(0, retained)))
+      throw new CodeBuddyError("nativeFailure", "Native history rewind did not persist the exact prefix");
+    const inheritedChildren2 = await copyInheritedChildren({
+      references: childReferences,
+      sourceRef: input.sourceRef,
+      sourceCwd,
+      sourceHistoryFile: source.file,
+      targetRef: preliminaryRef,
+      targetHistoryFile: verified.file
+    });
+    inheritedChildCopies = inheritedChildren2.created;
+    const inheritedChildLocator = inheritedChildren2.descriptors.length ? { codebuddyInheritedChildren: inheritedChildren2.descriptors } : {};
+    const ref = nativeSessionRefSchema.parse({
+      ...preliminaryRef,
+      locator: strictHistoryBinding ? {
+        codebuddyDerived: 1,
+        boundCwd: codeBuddyCanonicalCwd(input.cwd),
+        targetProjectSlug: codeBuddyProjectSlug(input.cwd, profile),
+        inheritedPrefixRows: finalRows.length,
+        inheritedPrefixSha256: nativeRowsDigest(finalRows),
+        bindingMarkerId: text(marker?.id),
+        ...inheritedChildLocator
+      } : { codebuddyDerived: 1, ...inheritedChildLocator }
+    });
+    await codeBuddyNativeHistory(input.cwd, ref, environment, profile);
+    const after = await codeBuddyNativeHistory(sourceCwd, input.sourceRef, environment, profile);
+    if (after.contents !== source.contents)
+      throw new CodeBuddyError("sessionBusy", "Source history changed during Fork");
+    if (signal.aborted)
+      throw new CodeBuddyError("invalidState", "Adapter closed during Fork");
+    const saved = record2(record2(input.sourceRef.locator).configuration);
+    const state = options.state ?? {
+      ...nativeState,
+      ...text(saved.model) ? { effectiveModel: modelRef(text(saved.model)) } : {}
+    };
+    const model = input.kind === "rollbackLastTurn" && input.model ? input.model : state.effectiveModel;
+    const thinking = input.kind === "rollbackLastTurn" && input.thinkingOptionId ? input.thinkingOptionId : options.state?.effectiveThinkingOptionId ?? (text(saved.thinking) ? harnessThinkingOptionIdSchema.parse(saved.thinking) : state.effectiveThinkingOptionId);
+    const mode = input.kind === "rollbackLastTurn" && input.permissionModeId ? input.permissionModeId : options.state?.effectivePermissionModeId ?? (text(saved.mode) ? harnessPermissionModeIdSchema.parse(saved.mode) : state.effectivePermissionModeId);
+    const resume = {
+      kind: "resume",
+      nativeRef: ref,
+      cwd: input.cwd,
+      ...input.environment ? { environment: input.environment } : {},
+      ...model ? { model } : {},
+      ...thinking ? { thinkingOptionId: thinking } : {},
+      ...mode ? { permissionModeId: mode } : {}
+    };
+    derivationSucceeded = true;
+    return resume;
+  } catch (error51) {
+    primaryFailure = error51;
+    throw error51;
+  } finally {
+    signal.removeEventListener("abort", abort);
+    const cleanupFailures = [];
+    let temporaryCleanupFailed = false;
+    try {
+      if (client2.removeCopy)
+        await client2.removeCopy();
+    } catch (error51) {
+      temporaryCleanupFailed = true;
+      cleanupFailures.push(error51);
+    }
+    try {
+      await client2.close();
+    } catch (error51) {
+      cleanupFailures.push(error51);
+    }
+    try {
+      await cleanupBridge(bridge);
+    } catch (error51) {
+      cleanupFailures.push(error51);
+    }
+    if (!derivationSucceeded || cleanupFailures.length) {
+      for (const copy of inheritedChildCopies.toReversed()) {
+        try {
+          await cleanupBridge(copy);
+        } catch (error51) {
+          cleanupFailures.push(error51);
+        }
+      }
+    }
+    if (cleanupFailures.length) {
+      if (primaryFailure)
+        throw new AggregateError([primaryFailure, ...cleanupFailures], `${primaryFailure instanceof Error ? primaryFailure.message : "Native derivation failed"}; ${temporaryCleanupFailed ? `temporary Session ${temporary.nativeSessionId} could not be removed` : "native derivation cleanup also failed"}`);
+      if (cleanupFailures.length === 1)
+        throw cleanupFailures[0];
+      throw new AggregateError(cleanupFailures, "Native derivation cleanup failed");
+    }
+  }
+}
+
 // dist/interactions.js
 var CodeBuddyInteractions = class {
   emit;
   client;
+  profile;
   #pending = /* @__PURE__ */ new Map();
   #sequence = 0;
-  constructor(emit, client2) {
+  constructor(emit, client2, profile = CODEBUDDY_RUNTIME_PROFILE) {
     this.emit = emit;
     this.client = client2;
+    this.profile = profile;
   }
   #question(turnId, input) {
     const questions = rows(record2(input).questions);
     if (!questions.length || questions.length > 4)
-      throw new CodeBuddyError("protocolError", "Invalid CodeBuddy question count");
+      throw new CodeBuddyError("protocolError", `Invalid ${this.profile.displayName} question count`);
     return {
       type: "question",
-      interactionId: hostInteractionIdSchema.parse(`codebuddy-question-${++this.#sequence}`),
+      interactionId: hostInteractionIdSchema.parse(`${this.profile.interactionIdPrefix}-question-${++this.#sequence}`),
       turnId,
-      title: "CodeBuddy",
+      title: this.profile.displayName,
       questions: questions.map((question, index) => {
         const options = rows(question.options).map((option) => ({
           value: text(option.label),
@@ -21229,7 +22433,7 @@ var CodeBuddyInteractions = class {
           ...option.description ? { description: text(option.description) } : {}
         }));
         if (!text(question.question) || !options.length || options.some((option) => !option.value))
-          throw new CodeBuddyError("protocolError", "Malformed CodeBuddy question");
+          throw new CodeBuddyError("protocolError", `Malformed ${this.profile.displayName} question`);
         return {
           id: text(question.id) || `q_${index}`,
           type: "choice",
@@ -21269,9 +22473,9 @@ var CodeBuddyInteractions = class {
       throw new CodeBuddyError("unsupported", "ACP approval does not provide a reject action");
     const interaction = {
       type: "approval",
-      interactionId: hostInteractionIdSchema.parse(`codebuddy-approval-${++this.#sequence}`),
+      interactionId: hostInteractionIdSchema.parse(`${this.profile.interactionIdPrefix}-approval-${++this.#sequence}`),
       turnId,
-      title: name || request.toolCall.title || "CodeBuddy tool approval",
+      title: name || request.toolCall.title || `${this.profile.displayName} tool approval`,
       subject: { type: "nativeAction" },
       actions,
       description: JSON.stringify(request.toolCall.rawInput ?? {}).slice(0, 16e3)
@@ -21307,7 +22511,7 @@ var CodeBuddyInteractions = class {
   async respond(command) {
     const pending = this.#pending.get(command.interactionId);
     if (!pending || pending.responding)
-      return failure("invalidRequest", "Interaction is not awaiting a response");
+      return failure("invalidRequest", "Interaction is not awaiting a response", this.profile);
     const validation = validateHostInteractionResponse(pending.interaction, command.response);
     if (validation)
       return { ok: false, error: validation };
@@ -21318,7 +22522,7 @@ var CodeBuddyInteractions = class {
       return { ok: true, value: { accepted: true } };
     } catch (error51) {
       pending.responding = false;
-      return { ok: false, error: nativeError(error51) };
+      return { ok: false, error: nativeError(error51, this.profile) };
     }
   }
   #finish(pending, reason) {
@@ -21343,33 +22547,23 @@ var CodeBuddyInteractions = class {
 };
 
 // dist/subagent-history.js
-import { readdir as readdir2, realpath as realpath3 } from "node:fs/promises";
-import path5 from "node:path";
-var equalPath = (a, b) => process.platform === "win32" ? a.toLowerCase() === b.toLowerCase() : a === b;
+import { readdir as readdir2, realpath as realpath5 } from "node:fs/promises";
+import path6 from "node:path";
+var equalPath2 = (a, b) => process.platform === "win32" ? a.toLowerCase() === b.toLowerCase() : a === b;
 var MAX_CACHED_CHILDREN = 16;
-function childContents(contents) {
-  const lines = contents.split(/\r?\n/u);
-  if (lines.at(-1)?.trim()) {
-    try {
-      JSON.parse(lines.at(-1) ?? "");
-    } catch {
-      lines.pop();
-    }
-  }
-  const entries = lines.filter((line) => line.trim()).map((line) => record2(JSON.parse(line)));
-  return { contents: lines.join("\n"), entries };
-}
 var CodeBuddyChildObserver = class {
   parent;
   cwd;
   environment;
+  profile;
   #children = /* @__PURE__ */ new Map();
   #parent;
   #closed = false;
-  constructor(parent, cwd, environment) {
+  constructor(parent, cwd, environment, profile = CODEBUDDY_RUNTIME_PROFILE) {
     this.parent = parent;
     this.cwd = cwd;
     this.environment = environment;
+    this.profile = profile;
   }
   close() {
     this.#closed = true;
@@ -21380,16 +22574,16 @@ var CodeBuddyChildObserver = class {
     if (this.#closed)
       throw new CodeBuddyError("invalidRequest", "Subagent observer is closed");
   }
-  async #validateWorkspaces(cwds, child = false) {
-    const expected = await realpath3(this.cwd);
+  async #validateWorkspaces(cwds) {
+    const expected = await realpath5(this.cwd);
     for (const cwd of new Set(cwds)) {
-      const actual = await realpath3(cwd).catch((error51) => {
-        if (!child && ["ENOENT", "ENOTDIR"].includes(String(record2(error51).code)))
+      const actual = await realpath5(cwd).catch((error51) => {
+        if (["ENOENT", "ENOTDIR"].includes(String(record2(error51).code)))
           throw new CodeBuddyError("invalidRequest", "Native Session historical working directory is unavailable; ownership cannot be verified");
         throw error51;
       });
-      if (!equalPath(actual, expected))
-        throw new CodeBuddyError("invalidRequest", child ? "Subagent workspace differs from parent" : "Native Session belongs to a different working directory");
+      if (!equalPath2(actual, expected))
+        throw new CodeBuddyError("invalidRequest", "Native Session belongs to a different working directory");
     }
   }
   async #parentHistory() {
@@ -21406,7 +22600,7 @@ var CodeBuddyChildObserver = class {
         return this.#parent;
       }
     }
-    const history = await codeBuddyLiveNativeHistory(this.cwd, this.parent, this.environment);
+    const history = await codeBuddyLiveNativeHistory(this.cwd, this.parent, this.environment, this.profile);
     this.#assertOpen();
     this.#parent = {
       file: history.file,
@@ -21418,31 +22612,34 @@ var CodeBuddyChildObserver = class {
   }
   async #directory() {
     const history = await this.#parentHistory();
-    const project = path5.dirname(await realpath3(history.file));
-    const expected = path5.join(project, this.parent.nativeSessionId, "subagents");
-    const actual = await realpath3(expected);
+    const project = path6.dirname(await realpath5(history.file));
+    const expected = path6.join(project, this.parent.nativeSessionId, "subagents");
+    const actual = await realpath5(expected);
     this.#assertOpen();
-    if (!equalPath(actual, expected))
-      throw new CodeBuddyError("invalidRequest", "Redirected CodeBuddy Subagent directory");
+    if (!equalPath2(actual, expected))
+      throw new CodeBuddyError("invalidRequest", `Redirected ${this.profile.displayName} Subagent directory`);
     return actual;
   }
   async #child(directory, childId) {
     if (!validCodeBuddyChildId(childId))
       throw new CodeBuddyError("invalidRequest", "Invalid native Subagent ID");
-    const file2 = path5.join(directory, `${childId}.jsonl`);
+    const file2 = path6.join(directory, `${childId}.jsonl`);
     const before = await codeBuddyFileVersion(file2);
-    if (!equalPath(before.realFile, file2))
+    if (!equalPath2(before.realFile, file2))
       throw new CodeBuddyError("invalidRequest", "Redirected Subagent transcript");
     this.#assertOpen();
-    if (before.size > 8e6)
+    if (before.size > CODEBUDDY_CHILD_MAX_BYTES)
       throw new CodeBuddyError("unsupported", "Subagent transcript exceeds 8 MB");
     const cached2 = this.#children.get(childId);
-    if (cached2 && sameCodeBuddyFileVersion(cached2.version, before))
+    if (cached2 && sameCodeBuddyFileVersion(cached2.version, before)) {
+      await validateCodeBuddyChildContents(cached2.rawContents, this.parent, childId, this.cwd, true);
       return cached2;
-    const source = await readCodeBuddyVersionedText(file2, 8e6, "Subagent transcript exceeds 8 MB", before), data = childContents(source.contents);
+    }
+    const source = await readCodeBuddyVersionedText(file2, CODEBUDDY_CHILD_MAX_BYTES, "Subagent transcript exceeds 8 MB", before), data = await validateCodeBuddyChildContents(source.contents, this.parent, childId, this.cwd, true);
     this.#assertOpen();
     const next = {
       ...data,
+      rawContents: source.contents,
       version: source.reusableVersion
     };
     this.#children.delete(childId);
@@ -21478,26 +22675,19 @@ var CodeBuddyChildObserver = class {
   async read(childId, status) {
     if (!status) {
       const source = await this.#parentHistory();
-      const states = snapshotFromHistory(source.contents, this.parent, this.cwd).turns.flatMap((turn) => turn.items.flatMap(({ item }) => item.type === "subagentDelegation" ? item.subagents : []));
+      const states = snapshotFromHistory(source.contents, this.parent, this.cwd, this.profile).turns.flatMap((turn) => turn.items.flatMap(({ item }) => item.type === "subagentDelegation" ? item.subagents : []));
       status = states.findLast((child) => child.nativeSubagentId === childId)?.status;
     }
     const data = await this.#child(await this.#directory(), childId);
-    const sessions = new Set(data.entries.map((row) => text(row.sessionId)).filter(Boolean));
-    if (sessions.size !== 1)
-      throw new CodeBuddyError("protocolError", "Subagent transcript identity is missing or mixed");
-    await this.#validateWorkspaces(data.entries.flatMap((row) => typeof row.cwd === "string" ? [row.cwd] : []), true);
     this.#assertOpen();
-    const childSessionId = [...sessions][0];
-    if (!childSessionId)
-      throw new CodeBuddyError("protocolError", "Missing native child Session");
-    data.snapshot ??= snapshotFromHistory(data.contents, { ...this.parent, nativeSessionId: childSessionId }, this.cwd);
+    data.snapshot ??= snapshotFromHistory(data.contents, { ...this.parent, nativeSessionId: data.nativeSessionId }, this.cwd, this.profile);
     const snapshot = structuredClone(data.snapshot);
     projectChildSnapshot(snapshot, this.parent, childId, status);
     return snapshot;
   }
 };
-async function readCodeBuddyChild(parent, childId, cwd, environment, status) {
-  const observer = new CodeBuddyChildObserver(parent, cwd, environment);
+async function readCodeBuddyChild(parent, childId, cwd, environment, status, profile = CODEBUDDY_RUNTIME_PROFILE) {
+  const observer = new CodeBuddyChildObserver(parent, cwd, environment, profile);
   try {
     return await observer.read(childId, status);
   } finally {
@@ -21511,6 +22701,7 @@ function projectChildSnapshot(snapshot, parent, childId, status) {
       nativeSessionId: parent.nativeSessionId,
       nativeTurnKey: `${childId}:${turn.nativeTurnRef.nativeTurnKey}`
     };
+    delete turn.checkpoint;
     turn.items = turn.items.filter(({ outcome }) => !(outcome.status === "failed" && outcome.error.message.includes("Tool completion was not recorded")));
     if (!status || status === "running" || status === "pending")
       turn.outcome = { status: "unknown", reason: "Subagent completion has not been confirmed" };
@@ -21536,6 +22727,9 @@ var CodeBuddySubagents = class {
   constructor(options) {
     this.options = options;
   }
+  get profile() {
+    return this.options.profile ?? CODEBUDDY_RUNTIME_PROFILE;
+  }
   begin(turnId) {
     this.#turnId = turnId;
   }
@@ -21576,7 +22770,7 @@ var CodeBuddySubagents = class {
         return true;
       call = {
         turnId: this.#turnId,
-        item: codeBuddyDelegation(callId, update.rawInput, "running"),
+        item: codeBuddyDelegation(callId, update.rawInput, "running", void 0, this.profile.displayName),
         itemCompleted: false,
         observationDone: false
       };
@@ -21607,7 +22801,7 @@ var CodeBuddySubagents = class {
               status: "failed",
               error: {
                 code: "nativeFailure",
-                message: "CodeBuddy Subagent invocation failed",
+                message: `${this.profile.displayName} Subagent invocation failed`,
                 retryable: false
               }
             } : { status: "succeeded" }
@@ -21658,19 +22852,19 @@ var CodeBuddySubagents = class {
     const parent = this.options.parent();
     if (!parent)
       return;
-    this.#observer ??= new CodeBuddyChildObserver(parent, this.options.cwd, this.options.environment);
+    this.#observer ??= new CodeBuddyChildObserver(parent, this.options.cwd, this.options.environment, this.profile);
     this.#refreshing = true;
     try {
       for (const call of this.#calls.values()) {
         if (call.observationDone)
           continue;
         try {
-          const id = call.item.subagents[0]?.nativeSubagentId ?? (call.requestId ? await (this.options.locate ? this.options.locate(parent, this.options.cwd, this.options.environment, call.requestId) : this.#observer.locate(call.requestId)) : void 0);
+          const id = call.item.subagents[0]?.nativeSubagentId ?? (call.requestId ? await (this.options.locate ? this.options.locate(parent, this.options.cwd, this.options.environment, call.requestId, this.profile) : this.#observer.locate(call.requestId)) : void 0);
           if (!id || this.#closed || call.observationDone)
             continue;
           if (!call.item.subagents[0]?.nativeSubagentId)
             this.#update(call, { nativeSubagentId: id, subagentId: id });
-          const snapshot = await (this.options.read ? this.options.read(parent, id, this.options.cwd, this.options.environment, "running") : this.#observer.read(id, "running"));
+          const snapshot = await (this.options.read ? this.options.read(parent, id, this.options.cwd, this.options.environment, "running", this.profile) : this.#observer.read(id, "running"));
           if (this.#closed || call.observationDone)
             continue;
           const observedModel = snapshot.turns.at(-1)?.model;
@@ -21726,8 +22920,11 @@ var CodeBuddySession = class {
   factory;
   readHistory;
   onClose;
-  harnessId = CODEBUDDY_ID;
-  capabilities = CODEBUDDY_CAPABILITIES;
+  profile;
+  harnessId;
+  #commands = { commands: [] };
+  commands;
+  capabilities;
   initialState = {};
   initialUsage = null;
   #channel = new HarnessOutputChannel();
@@ -21749,19 +22946,29 @@ var CodeBuddySession = class {
   #usage = null;
   #context = {};
   constructor(input, environment, factory, readHistory = readNativeHistory, onClose = () => {
-  }) {
+  }, profile = CODEBUDDY_RUNTIME_PROFILE) {
     this.input = input;
     this.environment = environment;
     this.factory = factory;
     this.readHistory = readHistory;
     this.onClose = onClose;
+    this.profile = profile;
+    this.harnessId = profile.harnessId;
+    this.capabilities = capabilitiesForProfile(profile);
+    this.#commands = structuredClone(profile.staticCommandCatalog ?? { commands: [] });
+    if (nativeCommandsEnabled(profile))
+      this.commands = {
+        list: async () => this.#closed || this.#fault ? failure("invalidState", "Session is closed or faulted", this.profile) : { ok: true, value: structuredClone(this.#commands) },
+        execute: (command) => this.#executeCommand(command)
+      };
     this.subagents = new CodeBuddySubagents({
       parent: () => this.#ref,
       cwd: input.cwd,
       environment,
-      emit: (event) => this.#emit(event)
+      emit: (event) => this.#emit(event),
+      profile
     });
-    this.#interactions = new CodeBuddyInteractions((output) => this.#channel.emit(output), () => this.#client);
+    this.#interactions = new CodeBuddyInteractions((output) => this.#channel.emit(output), () => this.#client, profile);
     this.#client = this.#createClient();
   }
   #createClient() {
@@ -21776,16 +22983,23 @@ var CodeBuddySession = class {
             this.#onFault(error51);
         },
         update: (notification) => {
-          if (generation !== this.#generation || this.#replaying || this.#closed)
+          if (generation !== this.#generation || this.#closed)
             return;
           if (this.#ref && notification.sessionId !== this.#ref.nativeSessionId)
             return;
           try {
             const update = record2(notification.update);
+            if (nativeCommandsEnabled(this.profile) && update.sessionUpdate === "available_commands_update") {
+              if (!this.profile.staticCommandCatalog)
+                this.#commands = commandCatalog(update.availableCommands, this.profile);
+              return;
+            }
+            if (this.#replaying)
+              return;
             if (this.subagents.update(update))
               return;
             if (update.sessionUpdate === "config_option_update" && this.#config)
-              this.#apply(configuration(update.configOptions));
+              this.#apply(configuration(update.configOptions, this.profile));
             if (update.sessionUpdate === "usage_update" && typeof update.used === "number" && typeof update.size === "number" && update.size > 0) {
               this.#context = {
                 contextUsedTokens: update.used,
@@ -21807,32 +23021,54 @@ var CodeBuddySession = class {
       }
     });
   }
-  async initialize() {
-    if (this.input.kind === "resume") {
-      this.#ref = this.input.nativeRef;
-      const history = await this.readHistory(this.input.cwd, this.#ref, this.environment);
-      this.#hasTurn = snapshotFromHistory(history, this.#ref, this.input.cwd).turns.length > 0;
+  /** Every fresh process must restore an unanchored rewind before it can accept prompts. */
+  async #openClient() {
+    let rewind;
+    if (this.#ref) {
+      const history = await this.readHistory(this.input.cwd, this.#ref, this.environment, this.profile);
+      this.#hasTurn = snapshotFromHistory(history, this.#ref, this.input.cwd, this.profile).turns.length > 0;
       this.#usage = historyUsage(history);
+      rewind = pendingNativeHistoryRewind(history);
     }
     await this.#client.initialize();
     const opened = await this.#client.open(this.input.cwd, this.#ref?.nativeSessionId);
     const sessionId = this.#ref?.nativeSessionId ?? text(opened.sessionId);
     if (!sessionId || opened.sessionId && opened.sessionId !== sessionId)
       throw new CodeBuddyError("protocolError", "ACP returned a different Native Session identity");
+    if (rewind) {
+      if (!this.#client.rollback)
+        throw new CodeBuddyError("unsupported", "Native history rewind is unavailable");
+      const result = await this.#client.rollback(sessionId, rewind.forkPointId);
+      if (result.applied !== true || (result.actualForkPointId ?? null) !== rewind.forkPointId)
+        throw new CodeBuddyError("nativeFailure", "Native history rewind was not confirmed");
+    }
+    return { ...opened, sessionId };
+  }
+  async initialize() {
+    const saved = this.input.kind === "resume" && record2(this.input.nativeRef.locator).codebuddyDerived === 1 ? record2(record2(this.input.nativeRef.locator).configuration) : {};
+    if (this.input.kind === "resume")
+      this.#ref = this.input.nativeRef;
+    const opened = await this.#openClient();
     this.#ref = nativeSessionRefSchema.parse({
-      harnessId: CODEBUDDY_ID,
-      nativeSessionId: sessionId,
-      formatVersion: 1
+      harnessId: this.profile.harnessId,
+      nativeSessionId: opened.sessionId,
+      formatVersion: 1,
+      ...this.#ref?.locator || this.capabilities.history.fork ? {
+        locator: {
+          ...record2(this.#ref?.locator),
+          ...this.capabilities.history.fork ? { boundCwd: codeBuddyCanonicalCwd(this.input.cwd) } : {}
+        }
+      } : {}
     });
-    this.#apply(configuration(opened.configOptions), false);
+    this.#apply(configuration(opened.configOptions, this.profile), false);
     if (this.input.kind === "create" && this.input.executionPolicy === "unattended-full-access") {
       await this.#configure("mode", "fullAccess");
-    } else if (this.input.permissionModeId)
-      await this.#configure("mode", this.input.permissionModeId);
-    if (this.input.model)
-      await this.#configure("model", nativeModel(this.input.model));
-    if (this.input.thinkingOptionId)
-      await this.#configure("thought_level", this.input.thinkingOptionId);
+    } else if (this.input.permissionModeId || text(saved.mode))
+      await this.#configure("mode", this.input.permissionModeId ?? text(saved.mode));
+    if (this.input.model || text(saved.model))
+      await this.#configure("model", this.input.model ? nativeModel(this.input.model) : text(saved.model));
+    if (this.input.thinkingOptionId || text(saved.thinking))
+      await this.#configure("thought_level", this.input.thinkingOptionId ?? text(saved.thinking));
     if (this.#fault || this.#closed)
       throw new CodeBuddyError("invalidState", "Native Session failed while opening");
     this.initialState = { ...this.#state };
@@ -21843,29 +23079,43 @@ var CodeBuddySession = class {
   }
   #apply(config2, emit = true) {
     this.#config = config2;
+    if (this.#ref && record2(this.#ref.locator).codebuddyDerived === 1)
+      this.#ref = nativeSessionRefSchema.parse({
+        ...this.#ref,
+        locator: {
+          ...record2(this.#ref.locator),
+          configuration: {
+            model: config2.state.effectiveModel ? nativeModel(config2.state.effectiveModel) : "",
+            mode: config2.state.effectivePermissionModeId ?? "",
+            thinking: config2.state.effectiveThinkingOptionId ?? ""
+          }
+        }
+      });
     this.#state = { ...config2.state, ...this.#ref ? { nativeRef: this.#ref } : {} };
     if (emit)
       this.#emit({ type: "session.state.changed", state: this.#state });
   }
   async #configure(id, value) {
     const option = this.#config?.options.find((option2) => option2.id === id);
-    if (!Array.isArray(option?.options) || !option.options.some((option2) => record2(option2).value === value))
-      throw new CodeBuddyError("invalidRequest", `Unavailable CodeBuddy ${id} selection`);
+    const listed = Array.isArray(option?.options) && option.options.some((option2) => record2(option2).value === value);
+    const allowedProductModel = id === "model" && this.profile.allowUnlistedModelSelection;
+    if (!listed && !allowedProductModel)
+      throw new CodeBuddyError("invalidRequest", `Unavailable ${this.profile.displayName} ${id} selection`);
     if (!this.#ref)
       throw new CodeBuddyError("invalidState", "Session is not open");
     const result = await this.#client.configure(this.#ref.nativeSessionId, id, value);
     if (this.#closed || this.#fault)
       throw new CodeBuddyError("invalidState", "Session closed during configuration");
-    this.#apply(confirmedConfiguration(result, id, value));
+    this.#apply(confirmedConfiguration(result, id, value, this.profile));
   }
   async #snapshot() {
     if (!this.#ref)
       throw new CodeBuddyError("invalidState", "Session is not open");
     try {
-      const history = await this.readHistory(this.input.cwd, this.#ref, this.environment);
+      const history = await this.readHistory(this.input.cwd, this.#ref, this.environment, this.profile);
       this.#usage = historyUsage(history);
       return {
-        ...this.subagents.project(snapshotFromHistory(history, this.#ref, this.input.cwd)),
+        ...this.subagents.project(snapshotFromHistory(history, this.#ref, this.input.cwd, this.profile)),
         state: this.#state
       };
     } catch (error51) {
@@ -21876,61 +23126,79 @@ var CodeBuddySession = class {
   }
   async readSnapshot() {
     if (this.#closed || this.#fault)
-      return failure("invalidState", "Session is closed or faulted");
+      return failure("invalidState", "Session is closed or faulted", this.profile);
     if (this.#busy || this.#active)
-      return failure("sessionBusy", "Session is executing an operation");
+      return failure("sessionBusy", "Session is executing an operation", this.profile);
     this.#busy = true;
     try {
       return { ok: true, value: await this.#snapshot() };
     } catch (error51) {
-      return { ok: false, error: nativeError(error51) };
+      return { ok: false, error: nativeError(error51, this.profile) };
     } finally {
       this.#busy = false;
     }
   }
+  async #executeCommand(command) {
+    const parsed = commandPrompt(command, this.#commands, this.profile);
+    if (!parsed.ok)
+      return parsed;
+    const result = await this.#execute({ type: "turn.start", turnId: command.turnId, input: [{ type: "text", text: parsed.value }] }, true);
+    return result.ok ? { ok: true, value: { turnId: command.turnId } } : result;
+  }
   async execute(command) {
+    const invocation = command.type === "turn.start" ? command.input.map((item) => item.text).join("\n").trim().split(/\s/u)[0] : void 0;
+    if (nativeCommandsEnabled(this.profile) && isExcludedInvocation(invocation))
+      return failure("unsupported", "Command is not available in this Session", this.profile);
+    return this.#execute(command, nativeCommandsEnabled(this.profile) && this.#commands.commands.some((entry) => entry.invocation === invocation));
+  }
+  async #execute(command, nativeCommand = false) {
     if (this.#closed || this.#fault)
-      return failure("invalidState", "Session is closed or faulted");
+      return failure("invalidState", "Session is closed or faulted", this.profile);
     if (command.type === "interaction.respond")
       return this.#interactions.respond(command);
     if (command.type === "turn.cancel") {
       const active = this.#active;
       if (!active || active.command.turnId !== command.turnId || !this.#ref)
-        return failure("invalidRequest", "Turn is not active");
+        return failure("invalidRequest", "Turn is not active", this.profile);
       if (!active.cancelled) {
         active.cancelled = true;
         try {
           await this.#client.cancel(this.#ref.nativeSessionId);
         } catch (error51) {
           this.#onFault(error51);
-          return { ok: false, error: nativeError(error51) };
+          return { ok: false, error: nativeError(error51, this.profile) };
         }
         this.#interactions.close();
         void bounded(active.completion, 3e4, "ACP cancel acknowledgement").catch((error51) => this.#onFault(error51));
       }
       return { ok: true, value: { cancellationRequested: true } };
     }
-    if (this.#busy || this.#active)
-      return failure("sessionBusy", "Session is executing an operation");
+    if (this.#busy || this.#active && command.type !== "model.select" && command.type !== "thinking.select")
+      return failure("sessionBusy", "Session is executing an operation", this.profile);
     this.#busy = true;
     try {
       if (command.type === "turn.start") {
         if (!command.turnId.trim() || !command.input.length || command.input.some((item) => item.type !== "text") || !command.input.map((item) => item.text).join("").trim())
-          return failure("invalidRequest", "A nonempty text prompt is required");
-        const before = new Set((await this.#snapshot()).turns.map((turn) => turn.nativeTurnRef.nativeTurnKey));
+          return failure("invalidRequest", "A nonempty text prompt is required", this.profile);
+        const snapshot = await this.#snapshot();
+        const before = new Set(snapshot.turns.map((turn) => turn.nativeTurnRef.nativeTurnKey));
+        const beforeItems = new Set(snapshot.turns.flatMap((turn) => turn.items.map((snapshot2) => snapshot2.item.itemId)));
         if (this.#closed || this.#fault)
-          return failure("invalidState", "Session closed before Turn start");
+          return failure("invalidState", "Session closed before Turn start", this.profile);
         const active = {
           command,
           before,
-          output: new CodeBuddyTurnOutput(command.turnId, this.input.cwd, (event) => this.#emit(event)),
+          beforeItems,
+          output: new CodeBuddyTurnOutput(command.turnId, this.input.cwd, (event) => this.#emit(event), this.profile),
+          nativeCommand,
           cancelled: false,
           done: false,
           completion: Promise.resolve()
         };
         this.#active = active;
         this.subagents.begin(command.turnId);
-        this.#hasTurn = true;
+        if (!nativeCommand)
+          this.#hasTurn = true;
         this.#emit({ type: "turn.started", turnId: command.turnId });
         active.completion = this.#run(active);
         return { ok: true, value: { turnId: command.turnId } };
@@ -21938,7 +23206,7 @@ var CodeBuddySession = class {
       await this.#configure(command.type === "model.select" ? "model" : command.type === "thinking.select" ? "thought_level" : "mode", command.type === "model.select" ? nativeModel(command.model) : command.type === "thinking.select" ? command.thinkingOptionId : command.permissionModeId);
       return { ok: true, value: { completed: true } };
     } catch (error51) {
-      return { ok: false, error: nativeError(error51) };
+      return { ok: false, error: nativeError(error51, this.profile) };
     } finally {
       this.#busy = false;
     }
@@ -21955,23 +23223,36 @@ var CodeBuddySession = class {
       // Those remain visible on individual Items; they do not fail the completed Turn.
       (!meta3["codebuddy.ai/outcome"] || meta3["codebuddy.ai/outcome"] === "SUCCESS" || meta3["codebuddy.ai/outcome"] === "PARTIAL_SUCCESS") ? { status: "succeeded" } : {
         status: "failed",
-        error: nativeError(new CodeBuddyError("nativeFailure", `Native Turn stopped: ${text(stop) || "unknown"} (${text(meta3["codebuddy.ai/outcome"]) || "no native outcome"})`))
+        error: nativeError(new CodeBuddyError("nativeFailure", `Native Turn stopped: ${text(stop) || "unknown"} (${text(meta3["codebuddy.ai/outcome"]) || "no native outcome"})`), this.profile)
       };
       const snapshot = await this.#snapshot();
       const added = snapshot.turns.filter((turn) => !active.before.has(turn.nativeTurnRef.nativeTurnKey));
-      if (added.length > 1 || outcome.status === "succeeded" && added.length !== 1)
+      if (added.length > 1 || !active.nativeCommand && outcome.status === "succeeded" && added.length !== 1)
         throw new CodeBuddyError("protocolError", "Could not identify exactly one persisted Native Turn");
+      active.output.confirmCompaction(snapshot.turns.flatMap((turn) => turn.items).filter((snapshot2) => !active.beforeItems.has(snapshot2.item.itemId)));
+      if (active.nativeCommand)
+        active.output.replayCommandResult(added[0]?.items ?? []);
       const nativeTurnRef = added[0]?.nativeTurnRef;
+      if (nativeTurnRef)
+        this.#hasTurn = true;
       if (response.userMessageId && nativeTurnRef?.nativeTurnKey !== response.userMessageId)
         throw new CodeBuddyError("protocolError", "ACP terminal and native history disagree on Turn identity");
       if (outcome.status === "cancelled")
         await this.#resumeAfterCancel();
-      this.#finish(active, outcome, nativeTurnRef);
+      const compactCommand = active.nativeCommand && /^\/compact(?:\s|$)/u.test(active.command.input.map((item) => item.text).join("\n").trim());
+      const persisted = compactCommand ? added[0]?.outcome : void 0;
+      if (compactCommand && (!persisted || persisted.status === "unknown"))
+        throw new CodeBuddyError("protocolError", "Native compaction terminal outcome was not persisted");
+      const terminalOutcome = persisted && persisted.status !== "unknown" ? persisted : outcome;
+      this.#finish(active, {
+        ...terminalOutcome,
+        ...added[0]?.checkpoint ? { checkpoint: added[0].checkpoint } : {}
+      }, nativeTurnRef);
       if (this.#usage)
         this.#emit({ type: "session.usage.changed", usage: { ...this.#usage, ...this.#context } });
     } catch (error51) {
       if (!active.done)
-        this.#finish(active, { status: "failed", error: nativeError(error51) });
+        this.#finish(active, { status: "failed", error: nativeError(error51, this.profile) });
     }
   }
   async #resumeAfterCancel() {
@@ -21986,11 +23267,8 @@ var CodeBuddySession = class {
       if (this.#closed)
         return;
       this.#client = this.#createClient();
-      await this.#client.initialize();
-      const loaded = await this.#client.open(this.input.cwd, this.#ref.nativeSessionId);
-      if (loaded.sessionId && loaded.sessionId !== this.#ref.nativeSessionId)
-        throw new CodeBuddyError("protocolError", "Cancellation recovery changed Native Session identity");
-      this.#apply(configuration(loaded.configOptions));
+      const loaded = await this.#openClient();
+      this.#apply(configuration(loaded.configOptions, this.profile));
       if (saved.effectiveModel)
         await this.#configure("model", nativeModel(saved.effectiveModel));
       if (saved.effectiveThinkingOptionId)
@@ -22023,7 +23301,7 @@ var CodeBuddySession = class {
   #onFault(error51) {
     if (this.#fault || this.#closed)
       return;
-    this.#fault = nativeError(error51);
+    this.#fault = nativeError(error51, this.profile);
     if (this.#active)
       this.#finish(this.#active, { status: "failed", error: this.#fault });
     this.#interactions.close();
@@ -22054,30 +23332,43 @@ var CodeBuddySession = class {
 // dist/codebuddy-adapter.js
 var CodeBuddyAdapter = class {
   options;
-  harnessId = CODEBUDDY_ID;
+  harnessId;
+  commandCatalog;
   subagents = {
     readSnapshot: async ({ parent, nativeSubagentId, cwd }) => {
       try {
         if (this.#closed)
-          return failure("invalidState", "Adapter is closed");
+          return failure("invalidState", "Adapter is closed", this.#profile);
         const session = [...this.#sessions].find((s) => s.initialState.nativeRef?.nativeSessionId === parent.nativeSessionId);
-        const snapshot = await readCodeBuddyChild(parent, nativeSubagentId, cwd, session?.environment ?? this.#environment, session?.subagents.state(nativeSubagentId)?.status);
+        const snapshot = await readCodeBuddyChild(parent, nativeSubagentId, cwd, session?.environment ?? this.#environment, session?.subagents.state(nativeSubagentId)?.status, this.#profile);
         return { ok: true, value: snapshot };
       } catch (error51) {
-        return { ok: false, error: nativeError(error51) };
+        return { ok: false, error: nativeError(error51, this.#profile) };
       }
     }
   };
   #environment;
+  #profile;
   #factory;
+  #invocation;
   #sessions = /* @__PURE__ */ new Set();
   #inspections = /* @__PURE__ */ new Set();
   #cache = /* @__PURE__ */ new Map();
   #closed = false;
+  #abort = new AbortController();
+  #derivations = /* @__PURE__ */ new Set();
   constructor(options = {}) {
     this.options = options;
+    this.#profile = options.profile ?? CODEBUDDY_RUNTIME_PROFILE;
+    this.harnessId = this.#profile.harnessId;
+    if (nativeCommandsEnabled(this.#profile)) {
+      const commandCatalog2 = this.#profile.staticCommandCatalog ?? (this.#profile.harnessId === CODEBUDDY_RUNTIME_PROFILE.harnessId ? CODEBUDDY_COMMAND_CATALOG : void 0);
+      if (commandCatalog2)
+        this.commandCatalog = commandCatalog2;
+    }
     this.#environment = { ...options.environment ?? process.env };
-    this.#factory = options.clientFactory ?? ((options2) => new CodeBuddyAcpClient(options2));
+    this.#invocation = options.invocationFactory ?? codeBuddyInvocation;
+    this.#factory = options.clientFactory ?? ((clientOptions) => new CodeBuddyAcpClient(clientOptions, void 0, this.#invocation));
   }
   inspect(input = {}) {
     const cwd = input.cwd ?? process.cwd();
@@ -22113,15 +23404,15 @@ var CodeBuddyAdapter = class {
       this.#inspections.add(client2);
       await client2.initialize();
       const opened = await client2.open(cwd);
-      const config2 = configuration(opened.configOptions);
+      const config2 = configuration(opened.configOptions, this.#profile);
       return harnessInspectionSchema.parse({
         status: "ready",
         catalog: config2.catalog,
         permissionModes: config2.permissionModes,
-        capabilities: CODEBUDDY_CAPABILITIES
+        capabilities: capabilitiesForProfile(this.#profile)
       });
     } catch (error51) {
-      const issue2 = nativeError(error51);
+      const issue2 = nativeError(error51, this.#profile);
       return {
         status: issue2.code === "notInstalled" ? "notInstalled" : "unavailable",
         error: issue2
@@ -22136,19 +23427,56 @@ var CodeBuddyAdapter = class {
   }
   async open(input) {
     if (this.#closed)
-      return failure("invalidState", "Adapter is closed");
-    if (input.kind === "fork" || input.kind === "rollbackLastTurn")
-      return failure("unsupported", "CodeBuddy ACP does not expose a verified precise history boundary operation");
+      return failure("invalidState", "Adapter is closed", this.#profile);
+    if (input.kind === "create" && input.executionPolicy === "unattended-full-access" && input.permissionModeId && input.permissionModeId !== "fullAccess")
+      return failure("invalidRequest", "Unattended execution requires native fullAccess permissions", this.#profile);
     let session;
     try {
       if (!(await stat2(input.cwd)).isDirectory())
         throw new CodeBuddyError("invalidRequest", "Working directory is not a directory");
+      if (this.#closed)
+        throw new CodeBuddyError("invalidState", "Adapter closed while opening Session");
       if (input.kind === "resume")
-        validateNativeRef(input.nativeRef);
+        validateNativeRef(input.nativeRef, this.#profile);
+      if (input.kind === "fork" || input.kind === "rollbackLastTurn") {
+        const capabilities = capabilitiesForProfile(this.#profile).history;
+        if (input.kind === "fork" && !capabilities.fork || input.kind === "rollbackLastTurn" && !capabilities.rollbackLastTurn)
+          throw new CodeBuddyError("unsupported", `${this.#profile.displayName} does not expose this verified history operation`);
+        const sourceRef = input.sourceRef;
+        validateNativeRef(sourceRef, this.#profile);
+        const source = [...this.#sessions].find((candidate) => candidate.initialState.nativeRef?.nativeSessionId === sourceRef.nativeSessionId);
+        const snapshot = await source?.readSnapshot();
+        if (this.#closed)
+          throw new CodeBuddyError("invalidState", "Adapter closed while reading source Session");
+        if (snapshot && !snapshot.ok)
+          return snapshot;
+        const boundCwd = text(record2(sourceRef.locator).boundCwd);
+        const sourceCwd = (source?.input.cwd ?? boundCwd) || input.cwd;
+        if (input.kind === "fork" && !capabilities.forkAcrossCwd && codeBuddyCanonicalCwd(sourceCwd) !== codeBuddyCanonicalCwd(input.cwd))
+          throw new CodeBuddyError("unsupported", `${this.#profile.displayName} does not support cross-directory Fork`);
+        const derivation = deriveCodeBuddySession({
+          input,
+          sourceCwd,
+          environment: { ...this.#environment, ...input.environment },
+          factory: this.#factory,
+          invocationFactory: this.#invocation,
+          profile: this.#profile,
+          signal: this.#abort.signal,
+          ...snapshot?.ok && snapshot.value.state ? { state: snapshot.value.state } : {}
+        });
+        this.#derivations.add(derivation);
+        try {
+          input = await derivation;
+        } finally {
+          this.#derivations.delete(derivation);
+        }
+      }
+      if (this.#closed)
+        throw new CodeBuddyError("invalidState", "Adapter closed while opening Session");
       session = new CodeBuddySession(input, { ...this.#environment, ...input.environment }, this.#factory, this.options.readHistory, () => {
         if (session)
           this.#sessions.delete(session);
-      });
+      }, this.#profile);
       this.#sessions.add(session);
       await session.initialize();
       if (this.#closed)
@@ -22161,24 +23489,26 @@ var CodeBuddyAdapter = class {
         this.#sessions.delete(session);
       }
       const issue2 = record2(error51).code === "ENOENT" ? new CodeBuddyError("invalidRequest", "Working directory does not exist") : error51;
-      return { ok: false, error: nativeError(issue2) };
+      return { ok: false, error: nativeError(issue2, this.#profile) };
     }
   }
   async close() {
     this.#closed = true;
+    this.#abort.abort();
+    await Promise.allSettled([...this.#derivations]);
     const results = await Promise.allSettled([...this.#sessions, ...this.#inspections].map((resource) => resource.close()));
     this.#sessions.clear();
     this.#inspections.clear();
     this.#cache.clear();
     const errors = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
     if (errors.length)
-      throw new AggregateError(errors, "CodeBuddy process cleanup failed");
+      throw new AggregateError(errors, `${this.#profile.displayName} process cleanup failed`);
   }
 };
 
 // ../../harness-broker/dist/client.js
-import { randomUUID } from "node:crypto";
-import { lstat, readFile as readFile2 } from "node:fs/promises";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { lstat as lstat2, readFile as readFile3 } from "node:fs/promises";
 import net, {} from "node:net";
 
 // ../../harness-broker/dist/protocol.js
@@ -22293,18 +23623,18 @@ function consumeBrokerFrames(socket, onFrame, onError) {
 
 // ../../harness-broker/dist/paths.js
 import os2 from "node:os";
-import path6 from "node:path";
+import path7 from "node:path";
 var HARNESS_BROKER_DESCRIPTOR_ENV = "CODEXHOST_CLAUDE_BROKER_DESCRIPTOR";
 var HARNESS_BROKER_DESCRIPTOR_FILE = "claude-code-broker-v1.json";
 function defaultHarnessBrokerDirectory(environment = process.env) {
   const home = environment.HOME || os2.homedir();
-  return path6.join(home, ".codexhost", "harness-broker");
+  return path7.join(home, ".codexhost", "harness-broker");
 }
 function defaultHarnessBrokerDescriptorPath(environment = process.env, harnessId = "claude-code") {
   harnessPluginIdSchema.parse(harnessId);
   if (harnessId !== "claude-code")
-    return path6.join(defaultHarnessBrokerDirectory(environment), `${harnessId}-broker-v1.json`);
-  return environment[HARNESS_BROKER_DESCRIPTOR_ENV] ?? path6.join(defaultHarnessBrokerDirectory(environment), HARNESS_BROKER_DESCRIPTOR_FILE);
+    return path7.join(defaultHarnessBrokerDirectory(environment), `${harnessId}-broker-v1.json`);
+  return environment[HARNESS_BROKER_DESCRIPTOR_ENV] ?? path7.join(defaultHarnessBrokerDirectory(environment), HARNESS_BROKER_DESCRIPTOR_FILE);
 }
 
 // ../../harness-broker/dist/validation.js
@@ -22581,7 +23911,7 @@ function parseSessionMetadata(value) {
   };
 }
 async function readDescriptor(descriptorPath) {
-  const metadata = await lstat(descriptorPath);
+  const metadata = await lstat2(descriptorPath);
   if (metadata.isSymbolicLink())
     throw new Error("Aqua Harness broker descriptor must not be a symlink");
   if (!metadata.isFile())
@@ -22593,12 +23923,12 @@ async function readDescriptor(descriptorPath) {
       throw new Error("Aqua Harness broker descriptor belongs to another user");
     }
   }
-  const descriptor = harnessBrokerDescriptorSchema.parse(JSON.parse(await readFile2(descriptorPath, "utf8")));
+  const descriptor = harnessBrokerDescriptorSchema.parse(JSON.parse(await readFile3(descriptorPath, "utf8")));
   if (process.platform === "darwin" && Buffer.byteLength(descriptor.socketPath) > 103) {
     throw new Error("Aqua Harness broker socket path is too long for macOS");
   }
   if (process.platform !== "win32") {
-    const socket = await lstat(descriptor.socketPath);
+    const socket = await lstat2(descriptor.socketPath);
     if (socket.isSymbolicLink() || !socket.isSocket()) {
       throw new Error("Aqua Harness broker endpoint is not a Unix socket");
     }
@@ -22695,7 +24025,7 @@ var BrokerConnection = class _BrokerConnection {
       throw new Error("Aqua Harness broker request limit exceeded");
     }
     this.#inputSequence += 1;
-    const id = randomUUID();
+    const id = randomUUID2();
     const response = new Promise((resolve, reject) => {
       const timeout = setTimeout(() => {
         this.#pending.delete(id);
@@ -23091,6 +24421,7 @@ function createHarnessAdapter(context) {
     return new BrokeredHarnessAdapter({
       harnessId: "codebuddy",
       forwardDelegationEnvironment: true,
+      commandCatalog: CODEBUDDY_COMMAND_CATALOG,
       environment: { ...context.environment }
     });
   return new CodeBuddyAdapter({ environment: { ...context.environment } });