@desplega.ai/agent-swarm 1.145.0 → 1.147.0

package/dist/cli-m9sxbkhm.js

@@ -0,0 +1,779 @@
+import {
+  init_task_attachment_links,
+  taskAttachmentDisplayUrl
+} from "./cli-9d8ntetj.js";
+import {
+  IDENTITY_FIELD_BUDGETS,
+  init_identity_field_budget,
+  init_templates
+} from "./cli-y6b6fb76.js";
+import {
+  init_resolver,
+  init_steering_enabled,
+  isSteeringEnabled,
+  resolveTemplateAsync
+} from "./cli-kpv03zhj.js";
+import {
+  MAX_PROFILE_FILE_LENGTH,
+  init_constants
+} from "./cli-e29gmdmw.js";
+import {
+  init_secret_scrubber,
+  scrubSecrets
+} from "./cli-xqcq9y5e.js";
+import {
+  __esm
+} from "./cli-bc05qbss.js";
+
+// src/utils/file-lock.ts
+import { dlopen, FFIType } from "bun:ffi";
+import { mkdir, open } from "node:fs/promises";
+import { dirname } from "node:path";
+function loadFlock() {
+  if (flockImpl !== undefined)
+    return flockImpl;
+  flockImpl = null;
+  for (const name of LIBC_CANDIDATES) {
+    try {
+      const { symbols } = dlopen(name, {
+        flock: { args: [FFIType.i32, FFIType.i32], returns: FFIType.i32 }
+      });
+      flockImpl = (fd, operation) => symbols.flock(fd, operation);
+      break;
+    } catch {}
+  }
+  return flockImpl;
+}
+async function withFileLock(lockPath, fn, options = {}) {
+  const flock = loadFlock();
+  if (!flock)
+    return { acquired: false, reason: "unsupported" };
+  const waitMs = options.waitMs ?? DEFAULTS.waitMs;
+  const pollMs = options.pollMs ?? DEFAULTS.pollMs;
+  let handle;
+  try {
+    await mkdir(dirname(lockPath), { recursive: true });
+    handle = await open(lockPath, "a");
+  } catch (error) {
+    return { acquired: false, reason: "error", error };
+  }
+  try {
+    const deadline = Date.now() + waitMs;
+    while (flock(handle.fd, LOCK_EX | LOCK_NB) !== 0) {
+      if (Date.now() >= deadline)
+        return { acquired: false, reason: "busy" };
+      await Bun.sleep(pollMs);
+    }
+    return { acquired: true, value: await fn() };
+  } finally {
+    await handle.close();
+  }
+}
+var LOCK_EX = 2, LOCK_NB = 4, LIBC_CANDIDATES, flockImpl, DEFAULTS;
+var init_file_lock = __esm(() => {
+  LIBC_CANDIDATES = process.platform === "darwin" ? ["libc.dylib", "/usr/lib/libSystem.B.dylib"] : ["libc.so.6", "libc.so", "libc.musl-x86_64.so.1", "libc.musl-aarch64.so.1"];
+  DEFAULTS = { waitMs: 15000, pollMs: 25 };
+});
+
+// src/commands/context-preamble.ts
+function prependContextPreamble(prompt, preamble) {
+  if (!preamble)
+    return prompt;
+  const newline = prompt.indexOf(`
+`);
+  const firstLine = newline === -1 ? prompt : prompt.slice(0, newline);
+  if (!/^\/[a-z0-9:_-]+(?:[ \t].*)?$/.test(firstLine.trim())) {
+    return preamble + prompt;
+  }
+  const rest = newline === -1 ? "" : prompt.slice(newline + 1);
+  return `${firstLine}
+${preamble}${rest}`;
+}
+async function fetchTaskContextForPreamble(apiUrl, apiKey, taskId) {
+  const headers = {};
+  if (apiKey)
+    headers.Authorization = `Bearer ${apiKey}`;
+  try {
+    const response = await fetch(`${apiUrl}/api/tasks/${taskId}`, { headers });
+    if (!response.ok)
+      return null;
+    const data = await response.json();
+    return {
+      id: data.id,
+      task: data.task,
+      output: data.output,
+      progress: data.progress,
+      status: data.status,
+      taskType: data.taskType,
+      parentTaskId: data.parentTaskId,
+      attachments: data.attachments
+    };
+  } catch {
+    return null;
+  }
+}
+function formatAttachmentPointer(att) {
+  const pointer = taskAttachmentDisplayUrl(att);
+  return pointer || "(no pointer)";
+}
+async function buildContextPreamble(apiUrl, apiKey, parentTaskId) {
+  const ancestors = [];
+  let currentId = parentTaskId;
+  while (currentId && ancestors.length < CONTEXT_PREAMBLE_MAX_ANCESTORS) {
+    const ctx = await fetchTaskContextForPreamble(apiUrl, apiKey, currentId);
+    if (!ctx)
+      break;
+    ancestors.push(ctx);
+    currentId = ctx.parentTaskId;
+  }
+  if (ancestors.length === 0)
+    return null;
+  const parent = ancestors[0];
+  if (!parent)
+    return null;
+  const lines = [
+    `
+---`,
+    "## Prior Conversation Context",
+    "",
+    "This task is a follow-up in an ongoing thread. Here is a summary of prior work to maintain continuity.",
+    ""
+  ];
+  const subjectPreview = parent.task.slice(0, 600).replace(/\n/g, " ");
+  lines.push(`### Immediate Prior Task (ID: \`${parent.id}\`)`);
+  lines.push(`**Task:** ${subjectPreview}`);
+  lines.push("");
+  const rawResult = parent.output || parent.progress;
+  if (rawResult) {
+    const outputBudget = Math.floor(CONTEXT_PREAMBLE_MAX_CHARS * 0.55);
+    const truncated = rawResult.length > outputBudget ? `${rawResult.slice(0, outputBudget)}
+
+[output truncated — full history via \`get-task-details\` with taskId \`${parent.id}\`]` : rawResult;
+    lines.push("**Outcome:**");
+    lines.push(truncated);
+    lines.push("");
+  } else {
+    lines.push("**Outcome:** (no output recorded yet — task may still be in progress)");
+    lines.push("");
+  }
+  const atts = parent.attachments?.filter((a) => a.name && (a.url || a.path || a.pageId));
+  if (atts && atts.length > 0) {
+    lines.push("**Artifacts from prior task:**");
+    for (const att of atts.slice(0, 10)) {
+      const pointer = formatAttachmentPointer(att);
+      const note = att.description || att.intent || "";
+      lines.push(`  - **${att.name}**: \`${pointer}\`${note ? ` — ${note}` : ""}`);
+    }
+    lines.push("");
+  }
+  lines.push(`To review the full prior conversation call \`get-task-details\` with taskId \`${parent.id}\`.`);
+  if (ancestors.length > 1) {
+    lines.push("");
+    lines.push("### Older Ancestor Tasks (pointers only — call `get-task-details` for full details)");
+    for (const ancestor of ancestors.slice(1)) {
+      const brief = ancestor.task.slice(0, 200).replace(/\n/g, " ");
+      lines.push(`- \`${ancestor.id}\` — ${brief}`);
+    }
+  }
+  lines.push("", "---", "");
+  let preamble = lines.join(`
+`);
+  if (preamble.length > CONTEXT_PREAMBLE_MAX_CHARS) {
+    preamble = `${preamble.slice(0, CONTEXT_PREAMBLE_MAX_CHARS)}
+
+[context preamble truncated to ${CONTEXT_PREAMBLE_MAX_TOKENS}-token budget]
+
+---
+`;
+  }
+  return preamble;
+}
+async function fetchSessionLogsForResume(apiUrl, apiKey, taskId) {
+  const headers = {};
+  if (apiKey)
+    headers.Authorization = `Bearer ${apiKey}`;
+  try {
+    const url = `${apiUrl}/api/tasks/${taskId}/session-logs?limit=${CONTEXT_PREAMBLE_RESUME_SESSION_LOG_LIMIT}`;
+    const response = await fetch(url, { headers });
+    if (!response.ok)
+      return [];
+    const data = await response.json();
+    return Array.isArray(data.logs) ? data.logs : [];
+  } catch {
+    return [];
+  }
+}
+async function fetchSteeringMessagesForResume(apiUrl, apiKey, taskId) {
+  const headers = {};
+  if (apiKey)
+    headers.Authorization = `Bearer ${apiKey}`;
+  try {
+    const response = await fetch(`${apiUrl}/api/tasks/${taskId}/steering-messages?status=pending,promoted`, { headers });
+    if (!response.ok)
+      return [];
+    const data = await response.json();
+    return Array.isArray(data.messages) ? data.messages.filter((message) => (message.status === "pending" || message.status === "promoted") && typeof message.body === "string" && typeof message.createdAt === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function summarizeSessionLogLine(line) {
+  const ts = line.createdAt.slice(11, 19);
+  let parsed;
+  try {
+    parsed = JSON.parse(line.content);
+  } catch {
+    const snippet2 = line.content.replace(/\s+/g, " ").slice(0, 120);
+    return snippet2 ? `[${ts}] ${snippet2}` : null;
+  }
+  if (!parsed || typeof parsed !== "object")
+    return null;
+  const obj = parsed;
+  const message = obj.message;
+  const content = message?.content;
+  if (Array.isArray(content)) {
+    for (const block of content) {
+      if (!block || typeof block !== "object")
+        continue;
+      const b = block;
+      if (b.type === "tool_use" && typeof b.name === "string") {
+        const input = b.input;
+        const file = input?.file_path ?? input?.path ?? input?.command;
+        const fileStr = typeof file === "string" ? ` ${file}` : "";
+        return `[${ts}] ${b.name}${fileStr}`;
+      }
+    }
+  }
+  if (obj.type === "tool_use" && typeof obj.name === "string") {
+    const input = obj.input;
+    const file = input?.file_path ?? input?.path ?? input?.command;
+    const fileStr = typeof file === "string" ? ` ${file}` : "";
+    return `[${ts}] ${obj.name}${fileStr}`;
+  }
+  const snippet = JSON.stringify(parsed).replace(/\s+/g, " ").slice(0, 120);
+  return snippet ? `[${ts}] ${snippet}` : null;
+}
+async function walkResumeChain(apiUrl, apiKey, immediateParentId) {
+  const chain = [];
+  let currentId = immediateParentId;
+  for (let depth = 0;depth < MAX_RESUME_CHAIN_DEPTH && currentId; depth++) {
+    const ctx = await fetchTaskContextForPreamble(apiUrl, apiKey, currentId);
+    if (!ctx)
+      break;
+    chain.push(ctx);
+    if (ctx.taskType !== "resume")
+      break;
+    currentId = ctx.parentTaskId;
+  }
+  return chain;
+}
+async function buildResumeContextPreamble(apiUrl, apiKey, parentTaskId) {
+  const chain = await walkResumeChain(apiUrl, apiKey, parentTaskId);
+  if (chain.length === 0)
+    return null;
+  const original = chain[chain.length - 1] ?? chain[0];
+  if (!original)
+    return null;
+  const parent = chain[0] ?? original;
+  const steeringEnabled = isSteeringEnabled();
+  const [logsBatches, steeringBatches] = await Promise.all([
+    Promise.all(chain.map((c) => fetchSessionLogsForResume(apiUrl, apiKey, c.id))),
+    steeringEnabled ? Promise.all(chain.map((c) => fetchSteeringMessagesForResume(apiUrl, apiKey, c.id))) : Promise.resolve([])
+  ]);
+  const merged = logsBatches.flat();
+  merged.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  const recentLogs = merged.slice(-CONTEXT_PREAMBLE_RESUME_SESSION_LOG_LIMIT);
+  const steeringMessages = steeringBatches.flat();
+  steeringMessages.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  const descBudget = Math.floor(CONTEXT_PREAMBLE_RESUME_MAX_CHARS * 0.4);
+  let logsBudget = Math.floor(CONTEXT_PREAMBLE_RESUME_MAX_CHARS * 0.3);
+  let artBudget = Math.floor(CONTEXT_PREAMBLE_RESUME_MAX_CHARS * 0.1);
+  const steeringBudget = Math.floor(CONTEXT_PREAMBLE_RESUME_MAX_CHARS * 0.1);
+  const header = [
+    `
+---`,
+    "## Resuming Interrupted Task",
+    "",
+    "This task is a fresh-session continuation of an interrupted task (graceful",
+    "shutdown / context-limit / operator action). The block below summarizes the",
+    "original task, what was done so far, and the artifacts in flight.",
+    "",
+    "**Do not redo work already completed below — extend it.**",
+    "",
+    `Original task ID: \`${original.id}\``,
+    chain.length > 1 ? `Resume chain depth: ${chain.length} (this is at least the ${chain.length === 2 ? "2nd" : chain.length === 3 ? "3rd" : `${chain.length}th`} resume attempt).` : "",
+    "",
+    "---",
+    "",
+    "### Original Task Description",
+    ""
+  ].filter((s) => s !== "").join(`
+`);
+  const descSection = original.task;
+  const summaryLines = [];
+  for (const line of recentLogs) {
+    const summary = summarizeSessionLogLine(line);
+    if (!summary)
+      continue;
+    summaryLines.push(summary);
+  }
+  const scrubbedSummary = summaryLines.map((s) => scrubSecrets(s));
+  let logsSection = scrubbedSummary.join(`
+`);
+  if (descSection.length > descBudget) {
+    const overflow = descSection.length - descBudget;
+    logsBudget = Math.max(0, logsBudget - Math.ceil(overflow / 2));
+    artBudget = Math.max(0, artBudget - Math.floor(overflow / 2));
+  }
+  while (logsSection.length > logsBudget && scrubbedSummary.length > 0) {
+    scrubbedSummary.shift();
+    logsSection = scrubbedSummary.join(`
+`);
+  }
+  const steeringLines = steeringEnabled ? steeringMessages.map((message) => {
+    const ts = message.createdAt.slice(11, 19);
+    return `[${ts}] ${scrubSecrets(message.body)}`;
+  }) : [];
+  let steeringSection = steeringLines.join(`
+`);
+  while (steeringSection.length > steeringBudget && steeringLines.length > 0) {
+    steeringLines.shift();
+    steeringSection = steeringLines.join(`
+`);
+  }
+  const atts = parent.attachments?.filter((a) => a.name && (a.url || a.path || a.pageId)) ?? [];
+  const artLines = [];
+  for (const att of atts) {
+    const pointer = formatAttachmentPointer(att);
+    artLines.push(`  - **${att.name}**: \`${pointer}\``);
+  }
+  let artSection = artLines.join(`
+`);
+  while (artSection.length > artBudget && artLines.length > 0) {
+    artLines.pop();
+    artSection = artLines.join(`
+`);
+  }
+  const sections = [header, descSection, ""];
+  if (logsSection) {
+    sections.push("### Recent Tool Calls", "", logsSection, "");
+  }
+  if (artSection) {
+    sections.push("### Artifacts In Flight", "", artSection, "");
+  }
+  if (steeringEnabled && steeringSection) {
+    sections.push("### Undelivered Steering Messages", "", steeringSection, "");
+  }
+  sections.push("---", "", `To review the full prior session call \`get-task-details\` with taskId \`${original.id}\`.`, "", "---", "");
+  let preamble = sections.join(`
+`);
+  if (preamble.length > CONTEXT_PREAMBLE_RESUME_MAX_CHARS) {
+    preamble = `${preamble.slice(0, CONTEXT_PREAMBLE_RESUME_MAX_CHARS)}
+
+[resume preamble truncated to ${CONTEXT_PREAMBLE_RESUME_MAX_TOKENS}-token budget]
+
+---
+`;
+  }
+  return preamble;
+}
+var CONTEXT_PREAMBLE_MAX_TOKENS, CONTEXT_PREAMBLE_MAX_CHARS, CONTEXT_PREAMBLE_MAX_ANCESTORS = 5, CONTEXT_PREAMBLE_RESUME_MAX_TOKENS, CONTEXT_PREAMBLE_RESUME_MAX_CHARS, CONTEXT_PREAMBLE_RESUME_SESSION_LOG_LIMIT = 50, MAX_RESUME_CHAIN_DEPTH = 10;
+var init_context_preamble = __esm(() => {
+  init_secret_scrubber();
+  init_steering_enabled();
+  init_task_attachment_links();
+  CONTEXT_PREAMBLE_MAX_TOKENS = Number(process.env.CONTEXT_PREAMBLE_MAX_TOKENS || "2000");
+  CONTEXT_PREAMBLE_MAX_CHARS = CONTEXT_PREAMBLE_MAX_TOKENS * 4;
+  CONTEXT_PREAMBLE_RESUME_MAX_TOKENS = Number(process.env.CONTEXT_PREAMBLE_RESUME_MAX_TOKENS || "4000");
+  CONTEXT_PREAMBLE_RESUME_MAX_CHARS = CONTEXT_PREAMBLE_RESUME_MAX_TOKENS * 4;
+});
+
+// src/commands/profile-sync.ts
+function contentSha256(content) {
+  return new Bun.CryptoHasher("sha256").update(content).digest("hex");
+}
+async function renderProfileSyncRejectionBanner(event) {
+  const data = event.data;
+  const field = data?.field;
+  const diskSize = data?.diskSize;
+  const dbSize = data?.dbSize;
+  const budget = data?.budget;
+  const delta = data?.delta;
+  if (typeof field !== "string" || !(field in PROFILE_FIELD_DETAILS) || typeof diskSize !== "number" || typeof dbSize !== "number" || typeof budget !== "number" || typeof delta !== "number") {
+    return null;
+  }
+  const details = PROFILE_FIELD_DETAILS[field];
+  const result = await resolveTemplateAsync("task.profile_sync_rejection", {
+    timestamp: event.createdAt,
+    field_label: details.label,
+    disk_size: diskSize,
+    db_size: dbSize,
+    budget,
+    delta: delta >= 0 ? `+${delta}` : String(delta),
+    event_id: event.id,
+    recovery_guidance: details.recoveryGuidance
+  });
+  return result.skipped ? null : result.text;
+}
+async function fetchProfileSyncRejectionBanner(config, fetchImpl = fetch, readFile = readFileIfExists) {
+  try {
+    const responses = await Promise.all(Object.keys(IDENTITY_FIELD_BUDGETS).map(async (field) => {
+      const fetchLatestEvent = async (event) => {
+        const query = new URLSearchParams({
+          event,
+          agentId: config.agentId,
+          dataField: field,
+          limit: "1"
+        });
+        const response = await fetchImpl(`${config.apiUrl}/api/events?${query}`, {
+          headers: {
+            Authorization: `Bearer ${config.apiKey}`,
+            "X-Agent-ID": config.agentId
+          }
+        });
+        if (!response.ok)
+          return null;
+        const payload = await response.json();
+        return payload.events?.[0] ?? null;
+      };
+      const [rejection, reconciliation] = await Promise.all([
+        fetchLatestEvent("system.profile_sync_rejected"),
+        fetchLatestEvent("system.profile_sync_reconciled")
+      ]);
+      return { rejection, reconciliation };
+    }));
+    const latestEvents = responses.flatMap(({ rejection, reconciliation }) => rejection ? [{ rejection, reconciliation }] : []);
+    if (latestEvents.length === 0)
+      return "";
+    let profile = null;
+    const profileResponse = await fetchImpl(`${config.apiUrl}/me`, {
+      headers: {
+        Authorization: `Bearer ${config.apiKey}`,
+        "X-Agent-ID": config.agentId
+      }
+    });
+    if (profileResponse.ok) {
+      profile = await profileResponse.json();
+    }
+    let disk = null;
+    if (config.claudeMdPath) {
+      disk = {
+        soulMd: await readFile(SOUL_MD_PATH),
+        identityMd: await readFile(IDENTITY_MD_PATH),
+        claudeMd: await readFile(config.claudeMdPath),
+        toolsMd: await readFile(TOOLS_MD_PATH)
+      };
+    }
+    const unresolved = latestEvents.flatMap(({ rejection, reconciliation }) => {
+      if (reconciliation && reconciliation.createdAt > rejection.createdAt)
+        return [];
+      const event = rejection;
+      const field = event.data?.field;
+      const rejectedDbHash = event.data?.dbHash;
+      const currentValue = typeof field === "string" ? profile?.[field] : undefined;
+      const diskValue = typeof field === "string" ? disk?.[field] : undefined;
+      if (typeof currentValue === "string" && diskValue === currentValue)
+        return [];
+      return !(typeof rejectedDbHash === "string" && typeof currentValue === "string" && contentSha256(currentValue) !== rejectedDbHash) ? [event] : [];
+    });
+    const banners = await Promise.all(unresolved.map(renderProfileSyncRejectionBanner));
+    return banners.filter((banner) => banner !== null).join("");
+  } catch {
+    return "";
+  }
+}
+async function prependProfileSyncRejectionBanner(prompt, config, fetchImpl = fetch, readFile = readFileIfExists) {
+  const banner = await fetchProfileSyncRejectionBanner(config, fetchImpl, readFile);
+  return banner ? { prompt: prependContextPreamble(prompt, banner), injected: true } : { prompt, injected: false };
+}
+async function writeIdentityBaselines(baselines) {
+  await Bun.write(IDENTITY_BASELINES_PATH, JSON.stringify(baselines));
+}
+async function readIdentityBaselines(readFile = readFileIfExists) {
+  try {
+    const raw = await readFile(IDENTITY_BASELINES_PATH);
+    if (!raw)
+      return null;
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function fetchWithSyncTimeout(fetchImpl = fetch) {
+  return (input, init) => fetchImpl(input, {
+    ...init,
+    signal: AbortSignal.timeout(CLAUDE_MD_SYNC_TIMEOUT_MS)
+  });
+}
+function syncsHookOwnedClaudeMd(claudeMdPath, changeSource) {
+  return claudeMdPath === CLAUDE_MD_PATH && changeSource === "session_sync";
+}
+function parseClaudeMdLineage(raw) {
+  if (!raw)
+    return null;
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return null;
+  const { written, base } = value;
+  const hashOrNull = (v) => v === null || typeof v === "string" && SHA256_HEX.test(v);
+  if (!("written" in value) || !("base" in value) || !hashOrNull(written) || !hashOrNull(base)) {
+    return null;
+  }
+  return { written, base };
+}
+function claudeMdPendingRecord(written) {
+  return JSON.stringify({ pending: true, written });
+}
+function parseClaudeMdPendingRecord(raw) {
+  if (!raw)
+    return null;
+  try {
+    const value = JSON.parse(raw);
+    const written = value?.pending === true ? value.written : undefined;
+    return typeof written === "string" && SHA256_HEX.test(written) ? written : null;
+  } catch {
+    return null;
+  }
+}
+function hookWrittenLineage(content) {
+  return { written: contentSha256(content), base: null };
+}
+function effectiveClaudeMdLineage(raw, content) {
+  if (raw === undefined)
+    return null;
+  return parseClaudeMdLineage(raw) ?? hookWrittenLineage(content);
+}
+function claudeMdLineageOf(content, record) {
+  if (record && record.written === contentSha256(content))
+    return record;
+  return { written: null, base: record?.base ?? null };
+}
+function planClaudeMdSync(state) {
+  const { content, record } = state;
+  if (!content.trim())
+    return null;
+  if (record === null)
+    return { claudeMd: content, changeSource: "session_sync" };
+  const { written, base } = claudeMdLineageOf(content, record);
+  if (written !== null || contentSha256(content) === base)
+    return null;
+  if (base === null)
+    return { claudeMd: content, changeSource: "session_sync" };
+  return { claudeMd: content, changeSource: "session_sync", expectedHashes: { claudeMd: base } };
+}
+function warnProfileFileTooLarge(agentId, field, actualLength, source = "profile-sync") {
+  console.warn(`[${source}] Skipping profile sync for agent ${agentId}, field ${field}: ${actualLength} characters exceeds the ${MAX_PROFILE_FILE_LENGTH}-character cap.`);
+}
+async function writeProfileFileFromDb(filePath, dbContent, now = () => new Date) {
+  const file = Bun.file(filePath);
+  let backupPath = null;
+  if (await file.exists()) {
+    const localContent = await file.text();
+    if (localContent !== dbContent) {
+      backupPath = `${filePath}.pre-boot-${now().toISOString()}.bak`;
+      await Bun.write(backupPath, localContent);
+    }
+  }
+  await Bun.write(filePath, dbContent);
+  return backupPath;
+}
+function resolveClaudeMdPath(completedProviders) {
+  const anyNonClaude = completedProviders.some((p) => p !== "claude");
+  return anyNonClaude ? WORKSPACE_CLAUDE_MD_PATH : CLAUDE_MD_PATH;
+}
+function buildIndependentIdentityPayloads(updates, changeSource) {
+  return Object.entries(updates).map(([field, value]) => ({
+    label: `identity.${field}`,
+    body: { [field]: value, changeSource }
+  }));
+}
+function extractSetupScriptContent(raw, agentId = "unknown") {
+  if (!raw.trim())
+    return null;
+  const startIdx = raw.indexOf(SETUP_MARKER_START);
+  const endIdx = raw.indexOf(SETUP_MARKER_END);
+  let content;
+  if (startIdx !== -1 && endIdx !== -1) {
+    content = raw.substring(startIdx + SETUP_MARKER_START.length, endIdx).trim();
+  } else {
+    content = raw.replace(/^#!\/bin\/bash\n/, "").trim();
+  }
+  if (!content)
+    return null;
+  if (content.length > MAX_PROFILE_FILE_LENGTH) {
+    warnProfileFileTooLarge(agentId, "setupScript", content.length);
+    return null;
+  }
+  return content;
+}
+function buildIdentityPayload(files, baselines, agentId = "unknown") {
+  const updates = {};
+  if (files.soulMd !== undefined) {
+    const content = files.soulMd;
+    if (baselines?.soulMd && contentSha256(content) === baselines.soulMd) {} else if (content.trim()) {
+      if (content.length < IDENTITY_FILE_MIN_LENGTH) {
+        console.error(`[profile-sync] Skipping SOUL.md sync: content too short (${content.length} chars, minimum ${IDENTITY_FILE_MIN_LENGTH}). This prevents accidental profile corruption.`);
+      } else {
+        updates.soulMd = content;
+      }
+    }
+  }
+  if (files.identityMd !== undefined) {
+    const content = files.identityMd;
+    if (baselines?.identityMd && contentSha256(content) === baselines.identityMd) {} else if (content.trim()) {
+      if (content.length < IDENTITY_FILE_MIN_LENGTH) {
+        console.error(`[profile-sync] Skipping IDENTITY.md sync: content too short (${content.length} chars, minimum ${IDENTITY_FILE_MIN_LENGTH}). This prevents accidental profile corruption.`);
+      } else {
+        updates.identityMd = content;
+      }
+    }
+  }
+  if (files.toolsMd !== undefined) {
+    const content = files.toolsMd;
+    if (baselines?.toolsMd && contentSha256(content) === baselines.toolsMd) {} else if (content.trim()) {
+      updates.toolsMd = content;
+    }
+  }
+  if (files.heartbeatMd !== undefined) {
+    const content = files.heartbeatMd;
+    if (baselines?.heartbeatMd && contentSha256(content) === baselines.heartbeatMd) {} else if (content.length > MAX_PROFILE_FILE_LENGTH) {
+      warnProfileFileTooLarge(agentId, "heartbeatMd", content.length);
+    } else {
+      updates.heartbeatMd = content;
+    }
+  }
+  return updates;
+}
+async function readFileIfExists(path) {
+  try {
+    const file = Bun.file(path);
+    if (!await file.exists())
+      return;
+    return await file.text();
+  } catch {
+    return;
+  }
+}
+async function collectProfilePayloads(fields, changeSource, readFile = readFileIfExists, claudeMdPath = CLAUDE_MD_PATH, agentId = "unknown") {
+  const payloads = [];
+  const baselines = changeSource === "session_sync" ? await readIdentityBaselines(readFile) : null;
+  if (fields.includes("identity")) {
+    const updates = buildIdentityPayload({
+      soulMd: await readFile(SOUL_MD_PATH),
+      identityMd: await readFile(IDENTITY_MD_PATH),
+      toolsMd: await readFile(TOOLS_MD_PATH),
+      heartbeatMd: await readFile(HEARTBEAT_MD_PATH)
+    }, baselines, agentId);
+    payloads.push(...buildIndependentIdentityPayloads(updates, changeSource));
+  }
+  if (fields.includes("claude")) {
+    const raw = await readFile(claudeMdPath);
+    if (raw?.trim()) {
+      if (baselines?.claudeMd && contentSha256(raw) === baselines.claudeMd) {} else if (syncsHookOwnedClaudeMd(claudeMdPath, changeSource)) {
+        const record = effectiveClaudeMdLineage(await readFile(CLAUDE_MD_LINEAGE_PATH), raw) ?? (baselines?.claudeMd ? { written: null, base: baselines.claudeMd } : null);
+        const body = planClaudeMdSync({ content: raw, record });
+        if (body)
+          payloads.push({ label: "claude", body });
+      } else {
+        payloads.push({ label: "claude", body: { claudeMd: raw, changeSource } });
+      }
+    }
+  }
+  if (fields.includes("setup")) {
+    const raw = await readFile(SETUP_SCRIPT_PATH);
+    if (raw !== undefined) {
+      const content = extractSetupScriptContent(raw, agentId);
+      if (content !== null) {
+        payloads.push({ label: "setup", body: { setupScript: content, changeSource } });
+      }
+    }
+  }
+  return payloads;
+}
+async function postProfileUpdate(opts, payload) {
+  const doFetch = opts.fetchImpl ?? fetch;
+  try {
+    const resp = await doFetch(`${opts.apiUrl}/api/agents/${opts.agentId}/profile`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${opts.apiKey}`,
+        "X-Agent-ID": opts.agentId
+      },
+      body: JSON.stringify(payload.body)
+    });
+    if (!resp.ok) {
+      let detail = "";
+      try {
+        detail = (await resp.text()).slice(0, 500);
+      } catch {}
+      console.warn(scrubSecrets(`[profile-sync] ${payload.label} sync failed: HTTP ${resp.status}${detail ? ` — ${detail}` : ""}`));
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.warn(scrubSecrets(`[profile-sync] ${payload.label} sync errored: ${msg}`));
+  }
+}
+async function syncProfileFilesToServer(opts) {
+  const changeSource = opts.changeSource ?? "session_sync";
+  const fields = opts.fields ?? ["identity", "claude", "setup"];
+  const claudeMdPath = opts.claudeMdPath ?? CLAUDE_MD_PATH;
+  const claudeUnderLock = fields.includes("claude") && syncsHookOwnedClaudeMd(claudeMdPath, changeSource);
+  const unlockedFields = claudeUnderLock ? fields.filter((f) => f !== "claude") : fields;
+  const payloads = await collectProfilePayloads(unlockedFields, changeSource, readFileIfExists, claudeMdPath, opts.agentId);
+  for (const payload of payloads) {
+    await postProfileUpdate(opts, payload);
+  }
+  if (claudeUnderLock) {
+    const { path: lockPath = CLAUDE_MD_LOCK_PATH, waitMs = RUNNER_LOCK_WAIT_MS } = opts.claudeMdLock ?? {};
+    const bounded = { ...opts, fetchImpl: fetchWithSyncTimeout(opts.fetchImpl) };
+    const locked = await withFileLock(lockPath, async () => {
+      const claude = await collectProfilePayloads(["claude"], changeSource, readFileIfExists, claudeMdPath, opts.agentId);
+      for (const payload of claude)
+        await postProfileUpdate(bounded, payload);
+    }, { waitMs });
+    if (!locked.acquired) {
+      const detail = locked.error === undefined ? "" : `: ${String(locked.error)}`;
+      console.warn(scrubSecrets(`[profile-sync] no CLAUDE.md lock (${locked.reason})${detail} — backstop sync skipped`));
+    }
+  }
+}
+var SOUL_MD_PATH = "/workspace/SOUL.md", IDENTITY_MD_PATH = "/workspace/IDENTITY.md", TOOLS_MD_PATH = "/workspace/TOOLS.md", HEARTBEAT_MD_PATH = "/workspace/HEARTBEAT.md", SETUP_SCRIPT_PATH = "/workspace/start-up.sh", IDENTITY_BASELINES_PATH = "/tmp/identity-baselines.json", PROFILE_FIELD_DETAILS, CLAUDE_MD_PATH, CLAUDE_MD_LINEAGE_PATH, CLAUDE_MD_LOCK_PATH, CLAUDE_MD_SYNC_TIMEOUT_MS = 1e4, RUNNER_LOCK_WAIT_MS = 15000, SHA256_HEX, WORKSPACE_CLAUDE_MD_PATH = "/workspace/CLAUDE.md", IDENTITY_FILE_MIN_LENGTH = 500, SETUP_MARKER_START = "# === Agent-managed setup (from DB) ===", SETUP_MARKER_END = "# === End agent-managed setup ===";
+var init_profile_sync = __esm(() => {
+  init_resolver();
+  init_constants();
+  init_file_lock();
+  init_identity_field_budget();
+  init_secret_scrubber();
+  init_context_preamble();
+  init_templates();
+  PROFILE_FIELD_DETAILS = {
+    soulMd: {
+      label: `soulMd (${SOUL_MD_PATH})`,
+      recoveryGuidance: `Inspect and shrink the live ${SOUL_MD_PATH} first, moving durable tail content into memory. After a worker restart, use ${SOUL_MD_PATH}.pre-boot-<timestamp>.bak as the fallback copy of the rejected content.`
+    },
+    identityMd: {
+      label: `identityMd (${IDENTITY_MD_PATH})`,
+      recoveryGuidance: `Inspect and shrink the live ${IDENTITY_MD_PATH} first, moving durable tail content into memory. After a worker restart, use ${IDENTITY_MD_PATH}.pre-boot-<timestamp>.bak as the fallback copy of the rejected content.`
+    },
+    claudeMd: {
+      label: "claudeMd (/workspace/CLAUDE.md for non-Claude harnesses; ~/.claude/CLAUDE.md for Claude)",
+      recoveryGuidance: "Inspect and shrink the live CLAUDE.md source first, moving durable tail content into memory. After a worker restart, non-Claude harnesses can use /workspace/CLAUDE.md.pre-boot-<timestamp>.bak as the fallback copy; Claude's native ~/.claude/CLAUDE.md source is not archived by that boot step."
+    },
+    toolsMd: {
+      label: `toolsMd (${TOOLS_MD_PATH})`,
+      recoveryGuidance: `Inspect and shrink the live ${TOOLS_MD_PATH} first, moving durable tail content into memory. After a worker restart, use ${TOOLS_MD_PATH}.pre-boot-<timestamp>.bak as the fallback copy of the rejected content.`
+    }
+  };
+  CLAUDE_MD_PATH = `${process.env.HOME}/.claude/CLAUDE.md`;
+  CLAUDE_MD_LINEAGE_PATH = `${CLAUDE_MD_PATH}.lineage.json`;
+  CLAUDE_MD_LOCK_PATH = `${CLAUDE_MD_PATH}.lock`;
+  SHA256_HEX = /^[0-9a-f]{64}$/;
+});
+
+export { withFileLock, init_file_lock, prependContextPreamble, buildContextPreamble, buildResumeContextPreamble, init_context_preamble, contentSha256, prependProfileSyncRejectionBanner, writeIdentityBaselines, readIdentityBaselines, CLAUDE_MD_PATH, CLAUDE_MD_LINEAGE_PATH, CLAUDE_MD_LOCK_PATH, fetchWithSyncTimeout, parseClaudeMdLineage, claudeMdPendingRecord, parseClaudeMdPendingRecord, hookWrittenLineage, effectiveClaudeMdLineage, claudeMdLineageOf, planClaudeMdSync, warnProfileFileTooLarge, writeProfileFileFromDb, resolveClaudeMdPath, buildIndependentIdentityPayloads, syncProfileFilesToServer, init_profile_sync };