@byok-sdk/client 0.15.0 → 0.17.0

package/dist/index.js

@@ -1,11 +1,11 @@
 import { randomUUID, createHash, randomBytes, createPrivateKey, generateKeyPairSync, sign, timingSafeEqual, createHmac } from 'crypto';
-import { promises, mkdirSync, constants, existsSync, linkSync, fstatSync, lstatSync, unlinkSync, renameSync, writeFileSync, chmodSync, statSync, readdirSync, readFileSync, opendirSync, realpathSync, openSync, readSync, closeSync } from 'fs';
+import { promises, mkdirSync, constants, existsSync, linkSync, fstatSync, lstatSync, unlinkSync, renameSync, writeFileSync, chmodSync, statSync, readdirSync, readFileSync, readSync, openSync, fchmodSync, fsyncSync, closeSync, opendirSync, realpathSync } from 'fs';
 import * as path3 from 'path';
 import path3__default, { join, isAbsolute } from 'path';
-import { AGENT_CONTENT_ARTIFACT_READ_CAPABILITY, AGENT_CONTENT_TRANSCRIPT_READ_CAPABILITY, AGENT_CONTENT_WORKSPACE_READ_CAPABILITY, AgentRefSchema, AgentHomeProjectionPayloadSchema, byokBlobUrlPath, BYOK_BLOBS_PATH, byokBlobFinalizePath, isTaskOfferType, partitionAgentEvents, BYOK_SKILL_PACKS_PATH, byokSkillPackFilePath, BYOK_RECORDS_PATH, byokRecordPath, TASK_TRANSITIONS, AgentEgressPolicySchema, BYOK_PAIR_PATH, PairResponseSchema, BYOK_CHALLENGE_PATH, BYOK_TOKEN_PATH, CONFIGURED_TOOLSETS_MAX_ITEMS, ToolsetIdSchema, AgentContentReceiptPayloadSchema, decodeEnvelope, createEnvelope, encodeEnvelope, PROTOCOL_VERSION, AGENT_EGRESS_RELIABLE_ACK_CAPABILITY, RuntimeIdSchema, HarnessIdSchema, TERMINAL_PROJECTION_SELECTION_CAPABILITY, PROVIDER_PROFILE_BINDING_CAPABILITY, STRICT_AGENT_ONLY_CAPABILITY, AGENT_HOME_PROJECTION_CAPABILITY, AGENT_EGRESS_POLICY_CAPABILITY, AGENT_EGRESS_FRESH_SESSION_CAPABILITY, AGENT_MESSAGE_EGRESS_CAPABILITY, AgentHomeProjectionCompletionRequestSchema, byokAgentHomeProjectionCompletionPath, AgentHomeProjectionReadbackSchema, parseMessage, checkResultDocument, MAX_MESSAGES_PER_BATCH, isServerToDaemonType, BYOK_CAPABILITIES_PATH, BYOK_PRESENCE_PATH, AgentMessagePublishPayloadSchema, AgentMessageDispositionPayloadSchema, AGENT_MEMORY_PROJECTION_CAPABILITY, TERMINAL_INFERENCE_USAGE_MAX_DURATION_MS, TERMINAL_INFERENCE_USAGE_MAX_TOKENS, RESULT_DOCUMENT_MAX_BYTES, BYOK_EVENTS_PATH, BYOK_MESSAGES_PATH, MessagesSendResponseSchema, MAILBOX_READ_AHEAD_MAX_SEQS, MAILBOX_READ_AHEAD_CAPABILITY, MESSAGE_TYPES, AGENT_MEMORY_PROJECTION_MAX_ORDERING_VALUE, AgentMemoryProjectionMutationSchema, AGENT_MEMORY_PROJECTION_MAX_REDACTED_BYTES } from '@byok-sdk/protocol';
+import { AGENT_CONTENT_ARTIFACT_READ_CAPABILITY, AGENT_CONTENT_TRANSCRIPT_READ_CAPABILITY, AGENT_CONTENT_WORKSPACE_READ_CAPABILITY, AgentRefSchema, AgentHomeProjectionPayloadSchema, byokBlobUrlPath, BYOK_BLOBS_PATH, byokBlobFinalizePath, isTaskOfferType, partitionAgentEvents, BYOK_SKILL_PACKS_PATH, byokSkillPackFilePath, BYOK_RECORDS_PATH, byokRecordPath, TASK_TRANSITIONS, AgentEgressPolicySchema, AgentMessagePublishPayloadSchema, AgentMessageDispositionPayloadSchema, BYOK_PAIR_PATH, PairResponseSchema, BYOK_CHALLENGE_PATH, BYOK_TOKEN_PATH, CONFIGURED_TOOLSETS_MAX_ITEMS, ToolsetIdSchema, AgentContentReceiptPayloadSchema, decodeEnvelope, createEnvelope, encodeEnvelope, PROTOCOL_VERSION, AGENT_EGRESS_RELIABLE_ACK_CAPABILITY, RuntimeIdSchema, HarnessIdSchema, TERMINAL_PROJECTION_SELECTION_CAPABILITY, PROVIDER_PROFILE_BINDING_CAPABILITY, STRICT_AGENT_ONLY_CAPABILITY, AGENT_HOME_PROJECTION_CAPABILITY, AGENT_EGRESS_POLICY_CAPABILITY, AGENT_EGRESS_FRESH_SESSION_CAPABILITY, AGENT_MESSAGE_EGRESS_CAPABILITY, AgentHomeProjectionCompletionRequestSchema, byokAgentHomeProjectionCompletionPath, AgentHomeProjectionReadbackSchema, parseMessage, checkResultDocument, MAX_MESSAGES_PER_BATCH, isServerToDaemonType, BYOK_CAPABILITIES_PATH, BYOK_PRESENCE_PATH, AGENT_MEMORY_PROJECTION_CAPABILITY, TERMINAL_INFERENCE_USAGE_MAX_DURATION_MS, TERMINAL_INFERENCE_USAGE_MAX_TOKENS, RESULT_DOCUMENT_MAX_BYTES, BYOK_EVENTS_PATH, BYOK_MESSAGES_PATH, MessagesSendResponseSchema, MAILBOX_READ_AHEAD_MAX_SEQS, MAILBOX_READ_AHEAD_CAPABILITY, MESSAGE_TYPES, AGENT_MEMORY_PROJECTION_MAX_ORDERING_VALUE, AgentMemoryProjectionMutationSchema, AGENT_MEMORY_PROJECTION_MAX_REDACTED_BYTES } from '@byok-sdk/protocol';
 import net2, { createServer, createConnection } from 'net';
-import * as os4 from 'os';
-import os4__default from 'os';
+import * as os from 'os';
+import os__default from 'os';
 import { execFile, spawn, spawnSync } from 'child_process';
 import { fileURLToPath } from 'url';
 import { createInterface } from 'readline';
@@ -246,6 +246,18 @@ var ADMINISTRATORS_SID = "*S-1-5-32-544";
 function buildIcaclsArgs(dir, username) {
   return [dir, "/inheritance:r", "/grant:r", `${username}:(OI)(CI)F`, "/grant", `${SYSTEM_SID}:(OI)(CI)F`, "/grant", `${ADMINISTRATORS_SID}:(OI)(CI)F`];
 }
+function buildIcaclsFileArgs(filePath, username) {
+  return [
+    filePath,
+    "/inheritance:r",
+    "/grant:r",
+    `${username}:F`,
+    "/grant",
+    `${SYSTEM_SID}:F`,
+    "/grant",
+    `${ADMINISTRATORS_SID}:F`
+  ];
+}
 var SecureDirHardeningError = class extends Error {
   constructor(dir, reason) {
     super(
@@ -256,6 +268,14 @@ var SecureDirHardeningError = class extends Error {
   }
   dir;
 };
+var SecureFileHardeningError = class extends Error {
+  constructor(filePath, reason) {
+    super(`failed to apply a restrictive Windows ACL to "${filePath}": ${reason}`);
+    this.filePath = filePath;
+    this.name = "SecureFileHardeningError";
+  }
+  filePath;
+};
 async function ensureSecureDir(dir, opts = {}) {
   const platform = opts.platform ?? process.platform;
   const run = opts.run ?? defaultRunner;
@@ -263,7 +283,7 @@ async function ensureSecureDir(dir, opts = {}) {
   await promises.chmod(dir, 448).catch(() => {
   });
   if (platform !== "win32") return;
-  const { username } = os4__default.userInfo();
+  const { username } = os__default.userInfo();
   let result;
   try {
     result = await run("icacls", buildIcaclsArgs(dir, username));
@@ -274,6 +294,22 @@ async function ensureSecureDir(dir, opts = {}) {
     throw new SecureDirHardeningError(dir, `icacls exited ${result.code}: ${(result.stderr || result.stdout).trim()}`);
   }
 }
+async function ensureSecureFile(filePath, opts = {}) {
+  const platform = opts.platform ?? process.platform;
+  const run = opts.run ?? defaultRunner;
+  await promises.chmod(filePath, 384);
+  if (platform !== "win32") return;
+  const { username } = os__default.userInfo();
+  let result;
+  try {
+    result = await run("icacls", buildIcaclsFileArgs(filePath, username));
+  } catch (err) {
+    throw new SecureFileHardeningError(filePath, `could not run icacls: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  if (result.code !== 0) {
+    throw new SecureFileHardeningError(filePath, `icacls exited ${result.code}: ${(result.stderr || result.stdout).trim()}`);
+  }
+}
 
 // src/daemon/path-mutation-gate.ts
 var PathMutationGateBusyError = class extends Error {
@@ -3365,6 +3401,19 @@ var RuntimeStartupDisposalFailure = class extends Error {
 function isRuntimeStartupDisposalFailure(value) {
   return typeof value === "object" && value !== null && value[/* @__PURE__ */ Symbol.for("@byok-sdk/client/RuntimeStartupDisposalFailure/v1")] === true && typeof value.retryDisposal === "function";
 }
+var GIT_ERROR_CATEGORIES = [
+  "git-unavailable",
+  "git-timeout",
+  "git-output-limit",
+  "git-command-failed",
+  "workspace-root-invalid",
+  "workspace-root-conflict",
+  "workspace-not-owned",
+  "repository-root-mismatch",
+  "repository-invalid",
+  "lease-busy",
+  "ledger-invalid"
+];
 var GitWorkspaceError = class extends Error {
   constructor(category, message = category) {
     super(message);
@@ -5125,7 +5174,7 @@ var PiAdapter = class {
           const taskMcpServers = startInput.mcpServers ?? {};
           let mcpConfigPath;
           try {
-            mcpConfigDir = await promises.mkdtemp(path3__default.join(os4__default.tmpdir(), "byok-pi-mcp-"));
+            mcpConfigDir = await promises.mkdtemp(path3__default.join(os__default.tmpdir(), "byok-pi-mcp-"));
             await promises.chmod(mcpConfigDir, 448).catch(() => {
             });
             mcpConfigPath = path3__default.join(mcpConfigDir, "mcp-config.json");
@@ -6237,7 +6286,7 @@ var ClaudeAdapter = class {
       });
     }
     if (needsMcpConfig) {
-      mcpConfigDir = await promises.mkdtemp(path3__default.join(os4__default.tmpdir(), "byok-mcp-"));
+      mcpConfigDir = await promises.mkdtemp(path3__default.join(os__default.tmpdir(), "byok-mcp-"));
       await promises.chmod(mcpConfigDir, 448).catch(() => {
       });
       const mcpConfigPath = path3__default.join(mcpConfigDir, "mcp-config.json");
@@ -7824,7 +7873,7 @@ function isNodeError(error, code) {
   return error instanceof Error && "code" in error && error.code === code;
 }
 async function scavengeStaleWindowsBridges() {
-  const temporaryRoot = os4.tmpdir();
+  const temporaryRoot = os.tmpdir();
   let entries;
   try {
     entries = await fs14.readdir(temporaryRoot, { withFileTypes: true });
@@ -8043,7 +8092,7 @@ var DeviceCredentialStore = class {
   }
   async #windows(operation, encoded) {
     await scavengeStaleWindowsBridges();
-    const directory = await fs14.mkdtemp(path3.join(os4.tmpdir(), WINDOWS_BRIDGE_DIRECTORY_PREFIX));
+    const directory = await fs14.mkdtemp(path3.join(os.tmpdir(), WINDOWS_BRIDGE_DIRECTORY_PREFIX));
     const executable = path3.join(directory, "credential-bridge.exe");
     const request = [
       operation,
@@ -8230,7 +8279,7 @@ var DeviceStore = class _DeviceStore {
   /** Internal test seam. Product construction always supplies productId and gets an OS store. */
   credentials;
   static defaultDir(productId) {
-    return path3__default.join(os4__default.homedir(), ".byok", productId);
+    return path3__default.join(os__default.homedir(), ".byok", productId);
   }
   /**
    * Resolve the one store pathname every daemon/CLI component must share.
@@ -8502,7 +8551,7 @@ var AuthManager = class {
             if (!(error instanceof DeviceRecordRePairRequiredError)) throw error;
           }
         }
-        const observedDeviceName = this.opts.deviceName ?? os4__default.hostname();
+        const observedDeviceName = this.opts.deviceName ?? os__default.hostname();
         const observedMachineId = await this.opts.machineId?.();
         let keyPair;
         let pairingDeviceName = observedDeviceName;
@@ -9008,9 +9057,9 @@ async function probeDarwin(run) {
   return DARWIN_UUID_RE.exec(result.stdout)?.[1];
 }
 async function probeLinux(readFile3) {
-  for (const path40 of LINUX_MACHINE_ID_PATHS) {
+  for (const path43 of LINUX_MACHINE_ID_PATHS) {
     try {
-      const contents = (await readFile3(path40)).trim();
+      const contents = (await readFile3(path43)).trim();
       if (contents.length > 0) return contents;
     } catch {
     }
@@ -9042,7 +9091,7 @@ async function withTimeout2(probe, timeoutMs) {
 async function resolveMachineId(options) {
   const platform = options.platform ?? process.platform;
   const run = options.run ?? runDeviceCommand;
-  const readFile3 = options.readFile ?? ((path40) => fs14.readFile(path40, "utf8"));
+  const readFile3 = options.readFile ?? ((path43) => fs14.readFile(path43, "utf8"));
   let probe;
   if (platform === "darwin") probe = probeDarwin(run);
   else if (platform === "linux") probe = probeLinux(readFile3);
@@ -12188,9 +12237,9 @@ function isSqliteAvailable() {
   }
 }
 var SECURE_FILE_MODE = 384;
-function openJournalDatabase(path40, busyTimeoutMs, faults) {
+function openJournalDatabase(path43, busyTimeoutMs, faults) {
   const { DatabaseSync } = loadSqliteModule();
-  const db = new DatabaseSync(path40, { timeout: busyTimeoutMs });
+  const db = new DatabaseSync(path43, { timeout: busyTimeoutMs });
   try {
     faults?.onStep?.("after-open");
     db.exec("PRAGMA auto_vacuum = INCREMENTAL;");
@@ -12334,9 +12383,9 @@ var RECEIVED_STATE = "received";
 function byteLength2(value) {
   return Buffer.byteLength(value, "utf8");
 }
-function fileBytes(path40) {
+function fileBytes(path43) {
   try {
-    return statSync(path40).size;
+    return statSync(path43).size;
   } catch {
     return 0;
   }
@@ -14203,6 +14252,10 @@ var AgentMessageOutbox = class _AgentMessageOutbox {
       this.revokedTasks.add(taskId);
     });
   }
+  /** The same terminal classification used by operator receipts and archival. */
+  terminalRecords() {
+    return Object.freeze(this.records().filter((record3) => this.isTerminalEvidence(record3.taskId)));
+  }
   isTerminalEvidence(taskId) {
     return this.revokedTasks.has(taskId) || this.dispositionByTask.get(taskId)?.outcome === "refused";
   }
@@ -14294,7 +14347,7 @@ var AgentMessageOutbox = class _AgentMessageOutbox {
   async archiveTerminalRecords(archiveDirectory) {
     return this.exclusive(async () => {
       if (!path3__default.isAbsolute(archiveDirectory)) throw new AgentMessageOutboxError("message archive directory must be absolute");
-      const terminal = this.records().filter((record3) => this.isTerminalEvidence(record3.taskId));
+      const terminal = this.terminalRecords();
       if (terminal.length === 0) return void 0;
       await ensureSecureDir(archiveDirectory);
       const archivePath = path3__default.join(archiveDirectory, `message-terminal-${randomUUID()}.jsonl`);
@@ -22052,8 +22105,8 @@ var TruthMemoryClient = class {
   #requestId;
   #allowedObjectDownloadOrigins;
   async listManifest(query = {}) {
-    const path40 = manifestPath(query);
-    const response = await this.#proofFetch(path40, {
+    const path43 = manifestPath(query);
+    const response = await this.#proofFetch(path43, {
       method: "GET",
       operation: "truth.list",
       resource: "records",
@@ -22160,9 +22213,9 @@ var TruthMemoryClient = class {
   }
   async #write(kind, recordKey, requestId, payload, expectedPrimary, expectedSnapshots) {
     assertDistinctExpectedWrites([expectedPrimary, ...expectedSnapshots]);
-    const path40 = recordPath(kind, recordKey);
+    const path43 = recordPath(kind, recordKey);
     const body = new TextEncoder().encode(JSON.stringify(payload));
-    const response = await this.#proofFetch(path40, {
+    const response = await this.#proofFetch(path43, {
       method: "PUT",
       operation: "truth.write",
       resource: `${kind}/${recordKey}`,
@@ -22188,8 +22241,8 @@ var TruthMemoryClient = class {
     };
   }
   async #readVerified(listed) {
-    const path40 = recordPath(listed.kind, listed.recordKey);
-    const response = await this.#proofFetch(path40, {
+    const path43 = recordPath(listed.kind, listed.recordKey);
+    const response = await this.#proofFetch(path43, {
       method: "GET",
       operation: "truth.read",
       resource: `${listed.kind}/${listed.recordKey}`,
@@ -22250,16 +22303,16 @@ var TruthMemoryClient = class {
     }
     return { ...listed, bytes };
   }
-  async #proofFetch(path40, request) {
+  async #proofFetch(path43, request) {
     const proof = await this.options.signer.sign({
       method: request.method,
-      path: path40,
+      path: path43,
       operation: request.operation,
       resource: request.resource,
       requestId: request.requestId,
       body: request.body
     });
-    const response = await this.#fetch(new URL(path40, this.#base), {
+    const response = await this.#fetch(new URL(path43, this.#base), {
       method: request.method,
       headers: {
         ...request.headers,
@@ -22270,7 +22323,7 @@ var TruthMemoryClient = class {
     if (!response.ok) {
       throw new TruthMemoryClientError(
         "truth_http_failed",
-        `truth request ${request.method} ${path40} failed with HTTP ${response.status}`,
+        `truth request ${request.method} ${path43} failed with HTTP ${response.status}`,
         response.status
       );
     }
@@ -22528,7 +22581,7 @@ function plistString(value) {
 function generateLaunchdPlist(def) {
   const { label, program, logDir } = def;
   const args = [program.command, ...program.args];
-  const cwd = program.cwd ?? os4__default.homedir();
+  const cwd = program.cwd ?? os__default.homedir();
   const outLog = path3__default.join(logDir, `${label}.out.log`);
   const errLog = path3__default.join(logDir, `${label}.err.log`);
   return `<?xml version="1.0" encoding="UTF-8"?>
@@ -22562,8 +22615,8 @@ ${args.map((a) => `    ${plistString(a)}`).join("\n")}
 }
 function createLaunchdLifecycle(def, deps = {}) {
   const run = deps.run ?? defaultRunner;
-  const fs33 = deps.fs ?? promises;
-  const homedir = deps.homedir ?? (() => os4__default.homedir());
+  const fs36 = deps.fs ?? promises;
+  const homedir = deps.homedir ?? (() => os__default.homedir());
   const getuid = deps.getuid ?? (() => {
     if (typeof process.getuid !== "function") {
       throw new Error("launchd lifecycle requires a POSIX uid (process.getuid unavailable) \u2014 this module only runs on macOS");
@@ -22576,7 +22629,7 @@ function createLaunchdLifecycle(def, deps = {}) {
   const serviceTarget = () => `${domainTarget()}/${label}`;
   async function fileExists(p) {
     try {
-      await fs33.stat(p);
+      await fs36.stat(p);
       return true;
     } catch {
       return false;
@@ -22584,9 +22637,9 @@ function createLaunchdLifecycle(def, deps = {}) {
   }
   async function writePlist(program) {
     const xml = generateLaunchdPlist({ label, program, logDir: def.logDir });
-    await fs33.mkdir(path3__default.dirname(plistPath()), { recursive: true });
-    await fs33.mkdir(def.logDir, { recursive: true });
-    await fs33.writeFile(plistPath(), xml, "utf8");
+    await fs36.mkdir(path3__default.dirname(plistPath()), { recursive: true });
+    await fs36.mkdir(def.logDir, { recursive: true });
+    await fs36.writeFile(plistPath(), xml, "utf8");
   }
   async function install(opts = {}) {
     await writePlist(opts.program ?? def.program);
@@ -22597,7 +22650,7 @@ function createLaunchdLifecycle(def, deps = {}) {
   }
   async function uninstall() {
     await runIdempotent(run, "launchctl", ["bootout", serviceTarget()], "launchctl bootout", LAUNCHD_NOT_LOADED);
-    await fs33.rm(plistPath(), { force: true });
+    await fs36.rm(plistPath(), { force: true });
   }
   async function start() {
     if (!await fileExists(plistPath())) {
@@ -22656,7 +22709,7 @@ function generateSystemdUnit(def) {
   const { name, displayName, program, logDir } = def;
   assertNoControlChars(name, "name");
   assertNoControlChars(displayName, "displayName");
-  const cwd = program.cwd ?? os4__default.homedir();
+  const cwd = program.cwd ?? os__default.homedir();
   assertNoControlChars(cwd, "program.cwd");
   const outLog = path3__default.join(logDir, `${name}.out.log`);
   const errLog = path3__default.join(logDir, `${name}.err.log`);
@@ -22681,14 +22734,14 @@ WantedBy=default.target
 }
 function createSystemdLifecycle(def, deps = {}) {
   const run = deps.run ?? defaultRunner;
-  const fs33 = deps.fs ?? promises;
-  const homedir = deps.homedir ?? (() => os4__default.homedir());
+  const fs36 = deps.fs ?? promises;
+  const homedir = deps.homedir ?? (() => os__default.homedir());
   const name = sanitizeServiceName(def.name);
   const unitName = `${name}.service`;
   const unitPath = () => path3__default.join(homedir(), ".config", "systemd", "user", unitName);
   async function fileExists(p) {
     try {
-      await fs33.stat(p);
+      await fs36.stat(p);
       return true;
     } catch {
       return false;
@@ -22696,9 +22749,9 @@ function createSystemdLifecycle(def, deps = {}) {
   }
   async function writeUnit(program) {
     const unit = generateSystemdUnit({ name, displayName: def.displayName ?? def.name, program, logDir: def.logDir });
-    await fs33.mkdir(path3__default.dirname(unitPath()), { recursive: true });
-    await fs33.mkdir(def.logDir, { recursive: true });
-    await fs33.writeFile(unitPath(), unit, "utf8");
+    await fs36.mkdir(path3__default.dirname(unitPath()), { recursive: true });
+    await fs36.mkdir(def.logDir, { recursive: true });
+    await fs36.writeFile(unitPath(), unit, "utf8");
   }
   async function install(opts = {}) {
     await writeUnit(opts.program ?? def.program);
@@ -22707,7 +22760,7 @@ function createSystemdLifecycle(def, deps = {}) {
   }
   async function uninstall() {
     await runIdempotent(run, "systemctl", ["--user", "disable", "--now", unitName], "systemctl disable --now", SYSTEMD_NOT_LOADED);
-    await fs33.rm(unitPath(), { force: true });
+    await fs36.rm(unitPath(), { force: true });
     await run("systemctl", ["--user", "daemon-reload"]);
   }
   async function start() {
@@ -22770,7 +22823,7 @@ ${argXml}${cwdXml}
 }
 function createWinswLifecycle(def, deps = {}) {
   const run = deps.run ?? defaultRunner;
-  const fs33 = deps.fs ?? promises;
+  const fs36 = deps.fs ?? promises;
   const windows = def.windows;
   if (!windows) {
     throw new Error("WinSW service lifecycle requires `ServiceDefinition.windows.winswBin` (the product-bundled WinSW executable path)");
@@ -22782,7 +22835,7 @@ function createWinswLifecycle(def, deps = {}) {
   const xmlPath = path3__default.join(installDir, `${id}.xml`);
   async function fileExists(p) {
     try {
-      await fs33.stat(p);
+      await fs36.stat(p);
       return true;
     } catch {
       return false;
@@ -22790,10 +22843,10 @@ function createWinswLifecycle(def, deps = {}) {
   }
   async function writeFiles(program) {
     const xml = generateWinswXml({ id, displayName: def.displayName ?? def.name, program, logDir: def.logDir });
-    await fs33.mkdir(installDir, { recursive: true });
-    await fs33.mkdir(def.logDir, { recursive: true });
-    await fs33.copyFile(winswBin, exePath);
-    await fs33.writeFile(xmlPath, xml, "utf8");
+    await fs36.mkdir(installDir, { recursive: true });
+    await fs36.mkdir(def.logDir, { recursive: true });
+    await fs36.copyFile(winswBin, exePath);
+    await fs36.writeFile(xmlPath, xml, "utf8");
   }
   async function install(opts = {}) {
     await writeFiles(opts.program ?? def.program);
@@ -22803,8 +22856,8 @@ function createWinswLifecycle(def, deps = {}) {
   async function uninstall() {
     await runIdempotent(run, exePath, ["stop"], "winsw stop", WINSW_NOT_INSTALLED);
     await runIdempotent(run, exePath, ["uninstall"], "winsw uninstall", WINSW_NOT_INSTALLED);
-    await fs33.rm(exePath, { force: true });
-    await fs33.rm(xmlPath, { force: true });
+    await fs36.rm(exePath, { force: true });
+    await fs36.rm(xmlPath, { force: true });
   }
   async function start() {
     if (!await fileExists(xmlPath)) {
@@ -23068,7 +23121,7 @@ async function inspectJournal(storeDir) {
           reason: "journal exceeds the bounded diagnostics copy limit"
         };
       }
-      const tempDir = await promises.mkdtemp(path3__default.join(os4__default.tmpdir(), "byok-journal-inspect-"));
+      const tempDir = await promises.mkdtemp(path3__default.join(os__default.tmpdir(), "byok-journal-inspect-"));
       const { DatabaseSync } = loadSqliteModule();
       let db;
       try {
@@ -23425,6 +23478,204 @@ function sameInode2(left, right) {
 function sameFileState5(left, right) {
   return sameInode2(left, right) && left.size === right.size && left.mtimeNs === right.mtimeNs && left.ctimeNs === right.ctimeNs;
 }
+function publishQuarantineEvidencePinned(quarantineDir, expectedDirectory, sourcePath, sourceFd, sourceStat, evidenceName, manifestName, quarantinedAt, reason) {
+  const previousCwd = process.cwd();
+  let entered = false;
+  let evidenceCreated = false;
+  let manifestCreated = false;
+  let sourceRemoved = false;
+  let evidenceTemp;
+  let manifestTemp;
+  try {
+    process.chdir(quarantineDir);
+    entered = true;
+    const pinned = lstatSync(".", { bigint: true });
+    if (!pinned.isDirectory() || !sameInode2(pinned, expectedDirectory)) {
+      throw new Error("quarantine path changed before publication; refusing quarantine");
+    }
+    const openSource = fstatSync(sourceFd, { bigint: true });
+    const namedSource = lstatSync(sourcePath, { bigint: true });
+    if (!sameFileState5(openSource, sourceStat) || !sameFileState5(namedSource, sourceStat)) {
+      throw new Error("operational health source identity changed before quarantine");
+    }
+    const sizeBytes = Number(sourceStat.size);
+    if (sizeBytes > MAX_OPERATIONAL_HEALTH_FILE_BYTES) {
+      throw new Error("operational health state exceeds the bounded quarantine read limit");
+    }
+    const bytes = Buffer.alloc(sizeBytes);
+    let position = 0;
+    while (position < sizeBytes) {
+      const bytesRead = readSync(sourceFd, bytes, position, sizeBytes - position, position);
+      if (bytesRead === 0) throw new Error("operational health state ended during bounded copy");
+      position += bytesRead;
+    }
+    const afterRead = fstatSync(sourceFd, { bigint: true });
+    if (!sameFileState5(afterRead, sourceStat)) {
+      throw new Error("operational health state changed during bounded copy");
+    }
+    const sha2562 = createHash("sha256").update(bytes).digest("hex");
+    evidenceTemp = `.${evidenceName}.${randomUUID()}.tmp`;
+    const evidenceFd = openSync(evidenceTemp, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, 384);
+    try {
+      writeFileSync(evidenceFd, bytes);
+      fchmodSync(evidenceFd, 384);
+      fsyncSync(evidenceFd);
+    } finally {
+      closeSync(evidenceFd);
+    }
+    linkSync(evidenceTemp, evidenceName);
+    evidenceCreated = true;
+    const evidence = lstatSync(evidenceName, { bigint: true });
+    const tempEvidence = lstatSync(evidenceTemp, { bigint: true });
+    if (!evidence.isFile() || !sameInode2(evidence, tempEvidence) || evidence.size !== sourceStat.size) {
+      throw new Error("quarantined operational health evidence does not match the bounded copy");
+    }
+    unlinkSync(evidenceTemp);
+    evidenceTemp = void 0;
+    const finalOpenSource = fstatSync(sourceFd, { bigint: true });
+    const finalNamedSource = lstatSync(sourcePath, { bigint: true });
+    if (!sameFileState5(finalOpenSource, sourceStat) || !sameFileState5(finalNamedSource, sourceStat)) {
+      throw new Error("operational health source changed before removal");
+    }
+    const manifestBody = `${JSON.stringify(
+      {
+        version: 1,
+        quarantinedAt,
+        reason,
+        sourcePath,
+        evidenceFile: evidenceName,
+        sha256: sha2562,
+        sizeBytes
+      },
+      null,
+      2
+    )}
+`;
+    manifestTemp = `.${manifestName}.${randomUUID()}.tmp`;
+    const manifestFd = openSync(manifestTemp, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, 384);
+    try {
+      writeFileSync(manifestFd, manifestBody, "utf8");
+      fchmodSync(manifestFd, 384);
+      fsyncSync(manifestFd);
+    } finally {
+      closeSync(manifestFd);
+    }
+    linkSync(manifestTemp, manifestName);
+    manifestCreated = true;
+    unlinkSync(manifestTemp);
+    manifestTemp = void 0;
+    if (process.platform !== "win32") {
+      const quarantineDirectoryFd = openSync(".", constants.O_RDONLY);
+      try {
+        fsyncSync(quarantineDirectoryFd);
+      } finally {
+        closeSync(quarantineDirectoryFd);
+      }
+    }
+    const removalOpenSource = fstatSync(sourceFd, { bigint: true });
+    const removalNamedSource = lstatSync(sourcePath, { bigint: true });
+    if (!sameFileState5(removalOpenSource, sourceStat) || !sameFileState5(removalNamedSource, sourceStat)) {
+      throw new Error("operational health source changed before removal");
+    }
+    unlinkSync(sourcePath);
+    sourceRemoved = true;
+    if (process.platform !== "win32") {
+      const directoryFd = openSync(path3__default.dirname(sourcePath), constants.O_RDONLY);
+      try {
+        fsyncSync(directoryFd);
+      } finally {
+        closeSync(directoryFd);
+      }
+    }
+    return { sha256: sha2562, sizeBytes };
+  } catch (err) {
+    if (evidenceTemp) {
+      try {
+        unlinkSync(evidenceTemp);
+      } catch {
+      }
+    }
+    if (manifestTemp) {
+      try {
+        unlinkSync(manifestTemp);
+      } catch {
+      }
+    }
+    if (manifestCreated && !sourceRemoved) {
+      try {
+        unlinkSync(manifestName);
+      } catch {
+      }
+    }
+    if (evidenceCreated && !sourceRemoved) {
+      try {
+        unlinkSync(evidenceName);
+      } catch {
+      }
+    }
+    throw err;
+  } finally {
+    if (entered) process.chdir(previousCwd);
+  }
+}
+async function quarantineCorruptOperationalHealth(storeDir, options = {}) {
+  const resolvedStoreDir = path3__default.resolve(storeDir);
+  const owner = await acquireDaemonOwner(resolvedStoreDir, "doctor", options.clock);
+  try {
+    const sourcePath = path3__default.join(resolvedStoreDir, OPERATIONAL_HEALTH_FILENAME);
+    let opened;
+    try {
+      opened = await openOperationalHealthFile(resolvedStoreDir);
+    } catch (err) {
+      throw new Error("operational health state could not be opened safely; refusing quarantine", { cause: err });
+    }
+    if (!opened) return { status: "not-needed", reason: "missing" };
+    const source = opened.handle;
+    try {
+      const inspection = await inspectOperationalHealthHandle(source, opened.stat);
+      if (inspection.status === "valid") return { status: "not-needed", reason: "valid" };
+      if (inspection.status === "unavailable") {
+        throw new Error(`${inspection.reason}; refusing to quarantine unconfirmed corruption`);
+      }
+      const sourceStat = await source.stat({ bigint: true });
+      if (!sourceStat.isFile()) throw new Error("operational health state is not a regular file; refusing quarantine");
+      const quarantineDir = path3__default.join(resolvedStoreDir, JOURNAL_QUARANTINE_DIRNAME);
+      try {
+        const existing = await promises.lstat(quarantineDir);
+        if (!existing.isDirectory() || existing.isSymbolicLink()) {
+          throw new Error("quarantine path is not a real directory; refusing quarantine");
+        }
+      } catch (err) {
+        if (err.code !== "ENOENT") throw err;
+        await promises.mkdir(quarantineDir, { mode: 448 });
+      }
+      await ensureSecureDir(quarantineDir);
+      const securedQuarantine = await promises.lstat(quarantineDir, { bigint: true });
+      if (!securedQuarantine.isDirectory() || securedQuarantine.isSymbolicLink()) {
+        throw new Error("quarantine path changed during validation; refusing quarantine");
+      }
+      const stamp = (options.clock ?? (() => /* @__PURE__ */ new Date()))().toISOString().replace(/[:.]/g, "-");
+      const evidenceName = `${stamp}-${randomUUID()}-${OPERATIONAL_HEALTH_FILENAME}`;
+      const manifestName = `${evidenceName}.manifest.json`;
+      const hashed = publishQuarantineEvidencePinned(
+        quarantineDir,
+        securedQuarantine,
+        sourcePath,
+        source.fd,
+        sourceStat,
+        evidenceName,
+        manifestName,
+        (options.clock ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
+        inspection.reason
+      );
+      return { status: "quarantined", evidenceName, manifestName, sha256: hashed.sha256, sizeBytes: hashed.sizeBytes };
+    } finally {
+      await source.close();
+    }
+  } finally {
+    await owner.release();
+  }
+}
 
 // src/diagnostics/device-doctor.ts
 function diagnoseDevice(config, options = {}) {
@@ -23498,7 +23749,342 @@ async function repairDeviceEnrollmentMetadata(config, input) {
     throw new DeviceMetadataRepairError(failureCode);
   }
 }
+function auditLogPath(storeDir) {
+  return path3__default.join(storeDir, "audit.jsonl");
+}
+new Set(GIT_ERROR_CATEGORIES);
+
+// src/diagnostics/support-bundle.ts
+var MAX_SUPPORT_AUDIT_TAIL_BYTES = 256 * 1024;
+var MAX_SUPPORT_AUDIT_FACTS = 200;
+var AUDIT_KINDS = /* @__PURE__ */ new Set([
+  "artifact",
+  "awaiting-approval",
+  "cancelled",
+  "claimed",
+  "completed",
+  "connection",
+  "failed",
+  "git-workspace",
+  "offered",
+  "paired",
+  "progress",
+  "runtimes-detected",
+  "shutdown-complete",
+  "shutdown-requested",
+  "stale-approval-decision",
+  "started",
+  "unpaired"
+]);
+function isAuditKind(value) {
+  return typeof value === "string" && AUDIT_KINDS.has(value);
+}
+function sameFileState6(left, right) {
+  return left.dev === right.dev && left.ino === right.ino && left.size === right.size && left.mtimeNs === right.mtimeNs && left.ctimeNs === right.ctimeNs;
+}
+async function recentAuditFacts(storeDir) {
+  const filePath = auditLogPath(storeDir);
+  let pathStat;
+  try {
+    pathStat = await promises.lstat(filePath, { bigint: true });
+    if (!pathStat.isFile() || pathStat.isSymbolicLink()) {
+      return { status: "unavailable", included: 0, sourceBytesRead: 0, sourceTruncated: false, facts: [] };
+    }
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return { status: "missing", included: 0, sourceBytesRead: 0, sourceTruncated: false, facts: [] };
+    }
+    return { status: "unavailable", included: 0, sourceBytesRead: 0, sourceTruncated: false, facts: [] };
+  }
+  let handle;
+  try {
+    handle = await promises.open(
+      filePath,
+      constants.O_RDONLY | constants.O_NONBLOCK | (constants.O_NOFOLLOW ?? 0)
+    );
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return { status: "missing", included: 0, sourceBytesRead: 0, sourceTruncated: false, facts: [] };
+    }
+    return { status: "unavailable", included: 0, sourceBytesRead: 0, sourceTruncated: false, facts: [] };
+  }
+  try {
+    const stat = await handle.stat({ bigint: true });
+    const namedAfterOpen = await promises.lstat(filePath, { bigint: true });
+    if (!stat.isFile() || !namedAfterOpen.isFile() || namedAfterOpen.isSymbolicLink() || !sameFileState6(pathStat, stat) || !sameFileState6(stat, namedAfterOpen)) {
+      return { status: "unavailable", included: 0, sourceBytesRead: 0, sourceTruncated: false, facts: [] };
+    }
+    const sourceSize = Number(stat.size);
+    const length = Math.min(sourceSize, MAX_SUPPORT_AUDIT_TAIL_BYTES);
+    const start = Math.max(0, sourceSize - length);
+    const buffer = Buffer.alloc(length);
+    const { bytesRead } = await handle.read(buffer, 0, length, start);
+    const afterRead = await handle.stat({ bigint: true });
+    const namedAfterRead = await promises.lstat(filePath, { bigint: true });
+    if (bytesRead !== length || namedAfterRead.isSymbolicLink() || !sameFileState6(stat, afterRead) || !sameFileState6(afterRead, namedAfterRead)) {
+      return { status: "unavailable", included: 0, sourceBytesRead: 0, sourceTruncated: false, facts: [] };
+    }
+    let text = buffer.subarray(0, bytesRead).toString("utf8");
+    if (start > 0) text = text.slice(Math.max(0, text.indexOf("\n") + 1));
+    const lines = text.split("\n").filter(Boolean).slice(-MAX_SUPPORT_AUDIT_FACTS);
+    const facts = [];
+    for (const line of lines) {
+      try {
+        const value = JSON.parse(line);
+        if (isAuditKind(value.kind) && typeof value.ts === "string" && Number.isFinite(Date.parse(value.ts))) {
+          facts.push({ kind: value.kind, ts: new Date(Date.parse(value.ts)).toISOString() });
+        }
+      } catch {
+      }
+    }
+    return { status: "available", included: facts.length, sourceBytesRead: bytesRead, sourceTruncated: sourceSize > bytesRead, facts };
+  } catch {
+    return { status: "unavailable", included: 0, sourceBytesRead: 0, sourceTruncated: false, facts: [] };
+  } finally {
+    await handle.close();
+  }
+}
+function projectControl(control) {
+  if (control.status === "offline") return { status: "offline" };
+  const transport = ["connecting", "open", "closed", "revoked"].includes(control.transport) ? control.transport : "unavailable";
+  const operationalHealth = control.operationalHealth.availability === "available" ? {
+    availability: "available",
+    state: control.operationalHealth.state,
+    failureCount: control.operationalHealth.failureCount,
+    windowMs: control.operationalHealth.windowMs,
+    failureThreshold: control.operationalHealth.failureThreshold,
+    crashCount: control.operationalHealth.crashCount
+  } : { availability: "unavailable" };
+  return {
+    status: "online",
+    pid: control.pid,
+    uptimeMs: control.uptimeMs,
+    transport,
+    activeTaskCount: control.activeTaskCount,
+    pendingApprovalCount: control.pendingApprovalCount,
+    operationalHealth,
+    storagePresent: control.storage !== void 0
+  };
+}
+async function createSupportBundle(config, storeDir, options = {}) {
+  const [snapshot, recentEvents] = await Promise.all([collectDiagnostics(config, storeDir, options), recentAuditFacts(storeDir)]);
+  return {
+    version: 1,
+    generatedAt: snapshot.generatedAt,
+    product: snapshot.product,
+    system: snapshot.system,
+    config: {
+      serverProtocol: snapshot.config.serverProtocol,
+      customStoreDir: snapshot.config.customStoreDir,
+      hostedJournal: snapshot.config.hostedJournal,
+      ...snapshot.config.runtimeAllowlistCount === void 0 ? {} : { runtimeAllowlistCount: snapshot.config.runtimeAllowlistCount }
+    },
+    device: {
+      status: snapshot.device.status,
+      ...snapshot.device.deviceIdHash ? { deviceIdHash: snapshot.device.deviceIdHash } : {}
+    },
+    runtimes: snapshot.runtimes,
+    control: projectControl(snapshot.control),
+    health: snapshot.health,
+    journal: snapshot.journal,
+    workspace: snapshot.workspace,
+    quarantine: {
+      status: snapshot.quarantine.status,
+      count: snapshot.quarantine.count,
+      scannedCount: snapshot.quarantine.scannedCount,
+      truncated: snapshot.quarantine.truncated,
+      entries: snapshot.quarantine.entries
+    },
+    checks: snapshot.checks.map(({ id, status }) => ({ id, status })),
+    recentEvents,
+    redaction: {
+      policy: "allowlist-v1",
+      omitted: [
+        "server URL host/path/query",
+        "store/workspace/config paths",
+        "control token and provider credentials",
+        "task, prompt, tool input/output and approval text",
+        "raw audit and quarantine contents"
+      ],
+      transformed: ["productName/productId/deviceId/runtimeId/quarantine filenames -> SHA-256", "audit events -> closed kind/timestamp only"]
+    }
+  };
+}
+async function writeSupportBundle(outputPath, bundle, secureFileOptions = {}) {
+  const dir = path3__default.dirname(outputPath);
+  const parentStat = await promises.stat(dir);
+  if (!parentStat.isDirectory()) throw new Error("support bundle output parent is not a directory");
+  const privateDir = path3__default.join(dir, `.${path3__default.basename(outputPath)}.${process.pid}.${randomUUID()}.private`);
+  const tempPath = path3__default.join(privateDir, "bundle.tmp");
+  try {
+    await promises.mkdir(privateDir, { mode: 448 });
+    await ensureSecureDir(privateDir, secureFileOptions);
+    await atomicWriteFile(tempPath, `${JSON.stringify(bundle, null, 2)}
+`, { mode: 384, fsync: true });
+    await ensureSecureFile(tempPath, secureFileOptions);
+    await promises.link(tempPath, outputPath);
+    const published = await promises.open(outputPath, "r+");
+    try {
+      await published.sync();
+    } finally {
+      await published.close();
+    }
+    if (process.platform !== "win32") {
+      const parent = await promises.open(dir, "r");
+      try {
+        await parent.sync();
+      } finally {
+        await parent.close();
+      }
+    }
+  } finally {
+    await promises.rm(privateDir, { recursive: true, force: true }).catch(() => void 0);
+  }
+}
+
+// src/diagnostics/operator-actions.ts
+var MESSAGES2 = {
+  "confirmation-required": "Explicit confirmation is required for this local maintenance action.",
+  "invalid-input": "The maintenance action requires valid explicit inputs.",
+  "daemon-running": "Stop the host daemon before local maintenance.",
+  "store-busy": "Another operation owns the device store.",
+  "agent-busy": "Another operation owns the Agent home.",
+  "target-mismatch": "The stored device or Agent records do not match the authorized target.",
+  "source-unavailable": "The local source cannot be accessed safely; preserve it for inspection.",
+  "output-exists": "The selected output already exists; it will not be overwritten.",
+  "operation-failed": "The maintenance operation did not complete; preserve evidence before retrying."
+};
+var DeviceOperatorError = class extends Error {
+  constructor(code) {
+    super(MESSAGES2[code]);
+    this.code = code;
+    this.name = "DeviceOperatorError";
+  }
+  code;
+};
+function requireConfirmation(input) {
+  if (input?.confirmed !== true) throw new DeviceOperatorError("confirmation-required");
+}
+function closedError(error) {
+  if (error instanceof DeviceOperatorError) return error;
+  if (error instanceof DaemonOwnerActiveError) return new DeviceOperatorError("store-busy");
+  if (error instanceof AgentHomeBusyError) return new DeviceOperatorError("agent-busy");
+  return new DeviceOperatorError("operation-failed");
+}
+async function requireOffline(config, storeDir) {
+  const control = await connectControlClient({ productId: config.productId, storeDir });
+  if (control.ok) {
+    control.client.close();
+    throw new DeviceOperatorError("daemon-running");
+  }
+}
+async function quarantineDeviceOperationalHealth(config, input) {
+  requireConfirmation(input);
+  try {
+    const storeDir = DeviceStore.resolveDir(config.productId, config.storeDir);
+    await requireOffline(config, storeDir);
+    const result = await quarantineCorruptOperationalHealth(storeDir);
+    return { action: "quarantine-operational-health", scope: "device", ...result };
+  } catch (error) {
+    throw closedError(error);
+  }
+}
+async function exportDeviceSupportBundle(config, input) {
+  if (typeof input?.outputPath !== "string" || !path3__default.isAbsolute(input.outputPath)) {
+    throw new DeviceOperatorError("invalid-input");
+  }
+  try {
+    const storeDir = DeviceStore.resolveDir(config.productId, config.storeDir);
+    const bundle = await createSupportBundle(config, storeDir, {
+      adapters: input.adapters,
+      runtimeProbeTimeoutMs: input.runtimeProbeTimeoutMs
+    });
+    await writeSupportBundle(input.outputPath, bundle);
+    return { action: "export-support-bundle", scope: "device", status: "written", bundleVersion: bundle.version };
+  } catch (error) {
+    if (error?.code === "EEXIST") throw new DeviceOperatorError("output-exists");
+    throw closedError(error);
+  }
+}
+async function existingOutbox(home) {
+  const components = [
+    home,
+    path3__default.join(home, AGENT_HOME_INTERNAL_DIRECTORY),
+    path3__default.join(home, AGENT_MESSAGE_DIRECTORY),
+    path3__default.join(home, AGENT_MESSAGE_DIRECTORY, AGENT_MESSAGE_OUTBOX_FILENAME)
+  ];
+  for (let index = 0; index < components.length; index += 1) {
+    let stat;
+    try {
+      stat = await promises.lstat(components[index]);
+    } catch (error) {
+      if (error.code === "ENOENT") return false;
+      throw new DeviceOperatorError("source-unavailable");
+    }
+    if (stat.isSymbolicLink() || (index === components.length - 1 ? !stat.isFile() : !stat.isDirectory())) {
+      throw new DeviceOperatorError("source-unavailable");
+    }
+  }
+  return true;
+}
+async function archiveAgentTerminalMessages(config, input) {
+  requireConfirmation(input);
+  const parsedRef = AgentRefSchema.safeParse(input.agentRef);
+  if (!parsedRef.success || !isTenantId(input.expectedTenantId) || typeof input.expectedDeviceId !== "string" || !input.expectedDeviceId.trim() || typeof input.archiveDirectory !== "string" || !path3__default.isAbsolute(input.archiveDirectory) || !config.agentHome) {
+    throw new DeviceOperatorError("invalid-input");
+  }
+  const notNeeded = { action: "archive-terminal-messages", scope: "agent", status: "not-needed" };
+  try {
+    const storeDir = DeviceStore.resolveDir(config.productId, config.storeDir);
+    await requireOffline(config, storeDir);
+    const owner = await acquireDaemonOwner(storeDir, "doctor");
+    try {
+      const metadata = await new DeviceStore(storeDir, void 0, config.productId).load();
+      if (!metadata || metadata.deviceId !== input.expectedDeviceId || metadata.tenantId !== input.expectedTenantId) {
+        throw new DeviceOperatorError("target-mismatch");
+      }
+      const manager = new AgentHomeManager({
+        hostStorageRoot: config.agentHome.hostStorageRoot,
+        leaseManager: new AgentHomeLeaseManager({ ownerId: stableAgentHomeOwnerId(storeDir, config.productId) })
+      });
+      const home = await manager.layout.canonicalHomePath(parsedRef.data);
+      if (!await existingOutbox(home)) return notNeeded;
+      const binding = await manager.acquire(parsedRef.data);
+      try {
+        if (!await existingOutbox(binding.lease.cwd)) throw new DeviceOperatorError("source-unavailable");
+        const outbox = await AgentMessageOutbox.open(binding.lease.cwd);
+        const records = outbox.records();
+        if (records.some((record3) => record3.tenantId !== input.expectedTenantId || record3.agentRef.agentId !== parsedRef.data.agentId)) {
+          throw new DeviceOperatorError("target-mismatch");
+        }
+        const archivedRecords = outbox.terminalRecords().length;
+        if (archivedRecords === 0) return notNeeded;
+        try {
+          await promises.mkdir(input.archiveDirectory, { mode: 448 });
+        } catch (error) {
+          if (error.code === "EEXIST") throw new DeviceOperatorError("output-exists");
+          throw error;
+        }
+        const archivePath = await outbox.archiveTerminalRecords(input.archiveDirectory);
+        if (!archivePath) throw new DeviceOperatorError("operation-failed");
+        return {
+          action: "archive-terminal-messages",
+          scope: "agent",
+          status: "archived",
+          archivedRecords,
+          archiveFileName: path3__default.basename(archivePath)
+        };
+      } finally {
+        await binding.lease.release();
+      }
+    } finally {
+      await owner.release();
+    }
+  } catch (error) {
+    throw closedError(error);
+  }
+}
 
-export { AGENT_CONTENT_READ_CAPABILITIES, AGENT_CONTENT_READ_CAPABILITY_ARTIFACT, AGENT_CONTENT_READ_CAPABILITY_TRANSCRIPT, AGENT_CONTENT_READ_CAPABILITY_WORKSPACE, AGENT_HOME_PROJECTION_STATE_FILE, AGENT_MEMORY_AUDIT_FILENAME, AGENT_MEMORY_OUTBOX_FILENAME, AgentHomeBusyError, AgentHomeCollisionError, AgentHomeError, AgentHomeLayout, AgentHomeLeaseCorruptError, AgentHomeLeaseManager, AgentHomeManager, AgentHomeResolutionError, AgentMemoryError, AgentMemoryRevisionConflictError, AgentRefValidationError, AgentSessionHandoffCorruptError, AgentSessionHandoffMismatchError, AgentSessionHandoffStore, AgentSessionHandoffStoreError, BYOK_SDK_HELPER_SUBCOMMAND, BlobClient, BlobRequestAbortedError, ClaudeAdapter, CodexAdapter, DEFAULT_ACK_CRITICAL_RESERVE_BYTES, DEFAULT_CLEANUP_BATCH_LIMIT, DEFAULT_HARD_BUDGET_RATIO, DEFAULT_INCREMENTAL_VACUUM_PAGES, DEFAULT_LOG_ROTATION, DEFAULT_NORMAL_COMPACTION_INTERVAL_MS, DEFAULT_PRESSURE_COMPACTION_INTERVAL_MS, DEFAULT_RETENTION_MS, DEFAULT_SOFT_BUDGET_RATIO, DaemonObserver, DeviceMetadataRepairError, GitWorkspaceError, GitWorkspaceManager, GitWorkspaceStore, JOURNAL_DB_FILENAME, JOURNAL_QUARANTINE_DIRNAME, JOURNAL_TASK_REF_PREFIX, JournalClosedError, JournalCorruptError, JournalRecordTooLargeError, JournalUnavailableError, JournalUnknownTaskError, LocalStateRelocationBusyError, LocalStateRelocationError, LocalStateRelocationIntegrityError, LocalStorageEmergencyError, LocalStoragePolicyError, LocalStoragePressureEngine, LocalTeamWorkspace, LocalTeamWorkspace as LocalTeamWorkspaceService, McpToolsetDefinitionRevisionConflictError, McpToolsetRevisionConflictError, PI_PACKAGE_NAME, PiAdapter, PolicyUnsupportedError, RUNTIME_ADAPTER_CONTRACT_VIOLATION_REASON, ReplayCursorTooOldError, RuntimeDisposalFailure, RuntimeExecutionFailure, RuntimeStartupDisposalFailure, SKILL_PACKS_CAPABILITY, SKILL_PACKS_DIRNAME, SKILL_PACK_AUDIT_FILENAME, SKILL_PACK_INSTALL_ERROR_CODES, SKILL_PACK_LOCK_FILENAME, SKILL_PACK_LOCK_SCHEMA, SKILL_PACK_RESPONSE_MAX_BYTES, SecureDirHardeningError, SkillPackInstallError, SqliteLocalTaskJournal, SteerUnsupportedError, TeamTmuxViewError, TeamWorkspaceConflictError, TeamWorkspaceCorruptError, TeamWorkspaceError, TeamWorkspaceLeaseError, TeamWorkspaceNotFoundError, TeamWorkspaceQuotaError, TeamWorkspaceReceiptError, TeamWorkspaceValidationError, TruthMemoryClient, TruthMemoryClientError, UnsupportedServicePlatformError, buildIcaclsArgs, cleanupEligibleAt, cleanupOrderFor, computePressureState, createAgentHomeProjection, createAgentHomeProjectionConsumer, createDaemon, createDaemonWithAdapters, createFilesystemCleanupExecutor, createServiceLifecycle, createStatfsFreeBytesProvider, decodeTeamMemberContext, diagnoseDevice, encodeTeamMemberContext, ensureSecureDir, freezeRuntimeAdapterDescriptor, generateLaunchdPlist, generateSystemdUnit, generateWinswXml, installSkillPacks, isAgentMemorySecureFilesystemAvailable, isGitWorkspaceConfig, isRuntimeDisposalFailure, isRuntimeExecutionFailure, isRuntimeStartupDisposalFailure, journalHash, listInstalledSkillPacks, localStateRelocation, nodeAgentProgram, openTeamTmuxView, prependGitWorkspaceGuidance, projectRuntimeBoundaryFailure, projectRuntimeExecutionFailure, projectSkillPack, readDeviceEnrollmentStatus, repairDeviceEnrollmentMetadata, requestDeviceAssertion, resolveLocalAgentReleaseIdentity, resolveLocalStoragePolicy, resolveSdkReservedHelperBin, runSdkReservedHelperCommand, sanitizeServiceName, sealRuntimeOperationManifest, skillPacksRoot, stableAgentHomeOwnerId, validateAgentRef };
+export { AGENT_CONTENT_READ_CAPABILITIES, AGENT_CONTENT_READ_CAPABILITY_ARTIFACT, AGENT_CONTENT_READ_CAPABILITY_TRANSCRIPT, AGENT_CONTENT_READ_CAPABILITY_WORKSPACE, AGENT_HOME_PROJECTION_STATE_FILE, AGENT_MEMORY_AUDIT_FILENAME, AGENT_MEMORY_OUTBOX_FILENAME, AgentHomeBusyError, AgentHomeCollisionError, AgentHomeError, AgentHomeLayout, AgentHomeLeaseCorruptError, AgentHomeLeaseManager, AgentHomeManager, AgentHomeResolutionError, AgentMemoryError, AgentMemoryRevisionConflictError, AgentRefValidationError, AgentSessionHandoffCorruptError, AgentSessionHandoffMismatchError, AgentSessionHandoffStore, AgentSessionHandoffStoreError, BYOK_SDK_HELPER_SUBCOMMAND, BlobClient, BlobRequestAbortedError, ClaudeAdapter, CodexAdapter, DEFAULT_ACK_CRITICAL_RESERVE_BYTES, DEFAULT_CLEANUP_BATCH_LIMIT, DEFAULT_HARD_BUDGET_RATIO, DEFAULT_INCREMENTAL_VACUUM_PAGES, DEFAULT_LOG_ROTATION, DEFAULT_NORMAL_COMPACTION_INTERVAL_MS, DEFAULT_PRESSURE_COMPACTION_INTERVAL_MS, DEFAULT_RETENTION_MS, DEFAULT_SOFT_BUDGET_RATIO, DaemonObserver, DeviceMetadataRepairError, DeviceOperatorError, GitWorkspaceError, GitWorkspaceManager, GitWorkspaceStore, JOURNAL_DB_FILENAME, JOURNAL_QUARANTINE_DIRNAME, JOURNAL_TASK_REF_PREFIX, JournalClosedError, JournalCorruptError, JournalRecordTooLargeError, JournalUnavailableError, JournalUnknownTaskError, LocalStateRelocationBusyError, LocalStateRelocationError, LocalStateRelocationIntegrityError, LocalStorageEmergencyError, LocalStoragePolicyError, LocalStoragePressureEngine, LocalTeamWorkspace, LocalTeamWorkspace as LocalTeamWorkspaceService, McpToolsetDefinitionRevisionConflictError, McpToolsetRevisionConflictError, PI_PACKAGE_NAME, PiAdapter, PolicyUnsupportedError, RUNTIME_ADAPTER_CONTRACT_VIOLATION_REASON, ReplayCursorTooOldError, RuntimeDisposalFailure, RuntimeExecutionFailure, RuntimeStartupDisposalFailure, SKILL_PACKS_CAPABILITY, SKILL_PACKS_DIRNAME, SKILL_PACK_AUDIT_FILENAME, SKILL_PACK_INSTALL_ERROR_CODES, SKILL_PACK_LOCK_FILENAME, SKILL_PACK_LOCK_SCHEMA, SKILL_PACK_RESPONSE_MAX_BYTES, SecureDirHardeningError, SkillPackInstallError, SqliteLocalTaskJournal, SteerUnsupportedError, TeamTmuxViewError, TeamWorkspaceConflictError, TeamWorkspaceCorruptError, TeamWorkspaceError, TeamWorkspaceLeaseError, TeamWorkspaceNotFoundError, TeamWorkspaceQuotaError, TeamWorkspaceReceiptError, TeamWorkspaceValidationError, TruthMemoryClient, TruthMemoryClientError, UnsupportedServicePlatformError, archiveAgentTerminalMessages, buildIcaclsArgs, cleanupEligibleAt, cleanupOrderFor, computePressureState, createAgentHomeProjection, createAgentHomeProjectionConsumer, createDaemon, createDaemonWithAdapters, createFilesystemCleanupExecutor, createServiceLifecycle, createStatfsFreeBytesProvider, decodeTeamMemberContext, diagnoseDevice, encodeTeamMemberContext, ensureSecureDir, exportDeviceSupportBundle, freezeRuntimeAdapterDescriptor, generateLaunchdPlist, generateSystemdUnit, generateWinswXml, installSkillPacks, isAgentMemorySecureFilesystemAvailable, isGitWorkspaceConfig, isRuntimeDisposalFailure, isRuntimeExecutionFailure, isRuntimeStartupDisposalFailure, journalHash, listInstalledSkillPacks, localStateRelocation, nodeAgentProgram, openTeamTmuxView, prependGitWorkspaceGuidance, projectRuntimeBoundaryFailure, projectRuntimeExecutionFailure, projectSkillPack, quarantineDeviceOperationalHealth, readDeviceEnrollmentStatus, repairDeviceEnrollmentMetadata, requestDeviceAssertion, resolveLocalAgentReleaseIdentity, resolveLocalStoragePolicy, resolveSdkReservedHelperBin, runSdkReservedHelperCommand, sanitizeServiceName, sealRuntimeOperationManifest, skillPacksRoot, stableAgentHomeOwnerId, validateAgentRef };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map