privateer-agent 0.15.4 → 0.15.6

package/dist-boot/c-I3C6LBW4.mjs

@@ -0,0 +1,765 @@
+import{createRequire as __pvCR}from"node:module";import{fileURLToPath as __pvF}from"node:url";import{dirname as __pvD}from"node:path";const require=__pvCR(import.meta.url);const __pvUrl=(r)=>new URL(r,import.meta.url).href;const __pvFile=(r)=>__pvF(new URL(r,import.meta.url));
+import {
+  DEFAULT_MAX_BYTES
+} from "./c-7UOG7POX.mjs";
+import {
+  __name
+} from "./c-CN77DCGF.mjs";
+
+// node_modules/pi-background-tasks/src/core/common.ts?ext=pi-background-tasks
+import { accessSync, constants, statSync } from "node:fs";
+import { open } from "node:fs/promises";
+import { basename, delimiter, extname, isAbsolute, join, resolve, win32 } from "node:path";
+var ReloadSurvivalError = class extends Error {
+  constructor(code, message) {
+    super(`${code}: ${message}`);
+    this.code = code;
+    this.name = "ReloadSurvivalError";
+  }
+  code;
+  static {
+    __name(this, "ReloadSurvivalError");
+  }
+};
+function rejectSurvivalForTaskKind(value, kind) {
+  if (!Object.prototype.hasOwnProperty.call(value, "surviveReload")) return;
+  throw new ReloadSurvivalError(
+    "pi_bg_survive_reload_unsupported_task_kind",
+    `${kind} does not support surviveReload; only ordinary isAgent:false shell tasks may survive reload`
+  );
+}
+__name(rejectSurvivalForTaskKind, "rejectSurvivalForTaskKind");
+function deriveCompletionDeliveryGuidance(notifyOnCompletion, triggerOnCompletion) {
+  if (notifyOnCompletion && triggerOnCompletion) {
+    return {
+      mode: "notification-and-wake",
+      notificationEnabled: true,
+      automaticWakeEnabled: true,
+      text: [
+        "Terminal notification: enabled.",
+        "Automatic follow-up turn: enabled.",
+        "Next action: do not poll or sleep merely to wait; continue only independent useful work, otherwise end this turn and wait for <background-task-notification>."
+      ].join("\n")
+    };
+  }
+  if (notifyOnCompletion) {
+    return {
+      mode: "notification-only",
+      notificationEnabled: true,
+      automaticWakeEnabled: false,
+      text: [
+        "Terminal notification: enabled.",
+        "Automatic follow-up turn: disabled. The terminal notification will be delivered, but it will not start an agent turn.",
+        "Next action: automatic wake-up was explicitly disabled; use bg_status/bg_logs only when deliberate monitoring is required, without tight polling."
+      ].join("\n")
+    };
+  }
+  return {
+    mode: "manual-monitoring",
+    notificationEnabled: false,
+    automaticWakeEnabled: false,
+    text: [
+      "Terminal notification: disabled.",
+      triggerOnCompletion ? "Automatic follow-up turn: disabled because terminal notifications are disabled. triggerOnCompletion has no effect while notifyOnCompletion is false." : "Automatic follow-up turn: disabled.",
+      "Next action: completion delivery was explicitly disabled; use bg_status/bg_logs only for deliberate manual monitoring, without tight polling."
+    ].join("\n")
+  };
+}
+__name(deriveCompletionDeliveryGuidance, "deriveCompletionDeliveryGuidance");
+var DEFAULT_LOG_BYTES = Math.min(DEFAULT_MAX_BYTES, 50 * 1024);
+var MAX_LOG_BYTES = Math.min(DEFAULT_MAX_BYTES, 50 * 1024);
+var COMMAND_PREVIEW_CHARS = 90;
+var parseJsonValue = globalThis.JSON.parse;
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null;
+}
+__name(isJsonObject, "isJsonObject");
+function parseJsonText(text) {
+  return parseJsonValue(text);
+}
+__name(parseJsonText, "parseJsonText");
+function sanitizePathSegment(value) {
+  const sanitized = value.replace(/[^a-zA-Z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "");
+  return sanitized || "session";
+}
+__name(sanitizePathSegment, "sanitizePathSegment");
+function stripMatchingQuotes(value) {
+  const trimmed = value.trim();
+  if (trimmed.length >= 2) {
+    const first = trimmed[0];
+    const last = trimmed[trimmed.length - 1];
+    if (first === '"' && last === '"' || first === "'" && last === "'") {
+      return trimmed.slice(1, -1);
+    }
+  }
+  return trimmed;
+}
+__name(stripMatchingQuotes, "stripMatchingQuotes");
+function compactWhitespace(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+__name(compactWhitespace, "compactWhitespace");
+function truncateChars(value, maxChars) {
+  if (value.length <= maxChars) return value;
+  return `${value.slice(0, Math.max(0, maxChars - 1))}\u2026`;
+}
+__name(truncateChars, "truncateChars");
+function normalizeTaskName(value) {
+  if (typeof value !== "string") return void 0;
+  const normalized = compactWhitespace(stripMatchingQuotes(value));
+  if (!normalized) return void 0;
+  return truncateChars(normalized, 80);
+}
+__name(normalizeTaskName, "normalizeTaskName");
+function deriveTaskNameFromCommand(command) {
+  const normalized = compactWhitespace(stripMatchingQuotes(command));
+  if (!normalized) return "Background task";
+  const packageScript = /^(npm|pnpm|yarn|bun)\s+(?:(run)\s+)?([^\s;&|]+)/.exec(normalized);
+  if (packageScript) {
+    const runner = packageScript[1] ?? "npm";
+    const run = packageScript[2] !== void 0 ? " run" : "";
+    const script = packageScript[3] ?? "";
+    return truncateChars(`${runner}${run} ${script}`, 48);
+  }
+  const words = normalized.split(/\s+/).slice(0, 5).join(" ");
+  return truncateChars(words.length > 0 ? words : normalized, 48);
+}
+__name(deriveTaskNameFromCommand, "deriveTaskNameFromCommand");
+function taskDisplayName(task) {
+  const commandName = task.command && task.command.length > 0 ? deriveTaskNameFromCommand(task.command) : void 0;
+  return normalizeTaskName(task.name) ?? normalizeTaskName(task.description) ?? commandName ?? task.id ?? "Background task";
+}
+__name(taskDisplayName, "taskDisplayName");
+function parseNameValueAndRest(valueAndRest) {
+  const input = valueAndRest.trimStart();
+  if (!input) return void 0;
+  const quote = input[0];
+  if (quote === '"' || quote === "'") {
+    let escaped = false;
+    let value = "";
+    for (let i = 1; i < input.length; i++) {
+      const char = input.charAt(i);
+      if (escaped) {
+        value += char;
+        escaped = false;
+        continue;
+      }
+      if (char === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (char === quote) {
+        return { value, rest: input.slice(i + 1).trimStart() };
+      }
+      value += char;
+    }
+    return void 0;
+  }
+  const match = /^(\S+)(?:\s+([\s\S]*))?$/.exec(input);
+  if (!match) return void 0;
+  const parsedValue = match[1];
+  if (parsedValue === void 0) return void 0;
+  return { value: parsedValue, rest: match[2]?.trimStart() ?? "" };
+}
+__name(parseNameValueAndRest, "parseNameValueAndRest");
+function parseBgCommandArgs(args) {
+  let input = args.trim();
+  let name;
+  let isAgent = false;
+  let surviveReload = false;
+  while (input) {
+    let consumed = false;
+    for (const prefix of ["--name=", "-n="]) {
+      if (input.startsWith(prefix)) {
+        const parsed = parseNameValueAndRest(input.slice(prefix.length));
+        if (!parsed) throw new Error(`${prefix.slice(0, -1)} requires a task name`);
+        name = normalizeTaskName(parsed.value);
+        input = parsed.rest;
+        consumed = true;
+        break;
+      }
+    }
+    if (consumed) continue;
+    for (const prefix of ["--name", "-n"]) {
+      if (input === prefix || input.startsWith(`${prefix} `) || input.startsWith(`${prefix}	`)) {
+        const parsed = parseNameValueAndRest(input.slice(prefix.length));
+        if (!parsed) throw new Error(`${prefix} requires a task name`);
+        name = normalizeTaskName(parsed.value);
+        input = parsed.rest;
+        consumed = true;
+        break;
+      }
+    }
+    if (consumed) continue;
+    for (const flag of ["--agent", "--llm-agent"]) {
+      if (input === flag || input.startsWith(`${flag} `) || input.startsWith(`${flag}	`)) {
+        isAgent = true;
+        input = input.slice(flag.length).trimStart();
+        consumed = true;
+        break;
+      }
+    }
+    if (consumed) continue;
+    for (const flag of ["--script", "--no-agent"]) {
+      if (input === flag || input.startsWith(`${flag} `) || input.startsWith(`${flag}	`)) {
+        isAgent = false;
+        input = input.slice(flag.length).trimStart();
+        consumed = true;
+        break;
+      }
+    }
+    if (consumed) continue;
+    if (input === "--survive-reload" || input.startsWith("--survive-reload ") || input.startsWith("--survive-reload	")) {
+      if (surviveReload) {
+        throw new ReloadSurvivalError(
+          "pi_bg_survive_reload_invalid",
+          "/bg accepts --survive-reload at most once"
+        );
+      }
+      surviveReload = true;
+      input = input.slice("--survive-reload".length).trimStart();
+      continue;
+    }
+    if (input.startsWith("--survive-reload=")) {
+      throw new ReloadSurvivalError(
+        "pi_bg_survive_reload_invalid",
+        "/bg accepts only the bare --survive-reload flag"
+      );
+    }
+    if (input === "--") {
+      input = "";
+      break;
+    }
+    if (input.startsWith("-- ")) {
+      input = input.slice(3).trimStart();
+      break;
+    }
+    break;
+  }
+  if (surviveReload && isAgent) {
+    throw new ReloadSurvivalError(
+      "pi_bg_survive_reload_requires_non_agent",
+      "surviveReload requires isAgent:false"
+    );
+  }
+  return name ? { name, command: input, isAgent, surviveReload } : { command: input, isAgent, surviveReload };
+}
+__name(parseBgCommandArgs, "parseBgCommandArgs");
+function formatDuration(ms) {
+  if (ms < 1e3) return `${String(ms)}ms`;
+  const seconds = Math.floor(ms / 1e3);
+  if (seconds < 60) return `${String(seconds)}s`;
+  const minutes = Math.floor(seconds / 60);
+  const remSeconds = seconds % 60;
+  if (minutes < 60) return `${String(minutes)}m${remSeconds > 0 ? `${String(remSeconds)}s` : ""}`;
+  const hours = Math.floor(minutes / 60);
+  const remMinutes = minutes % 60;
+  return `${String(hours)}h${remMinutes > 0 ? `${String(remMinutes)}m` : ""}`;
+}
+__name(formatDuration, "formatDuration");
+function formatCompactNumber(count) {
+  const normalized = Math.max(0, Math.floor(count));
+  if (normalized < 1e3) return normalized.toString();
+  if (normalized < 1e4) return `${(normalized / 1e3).toFixed(1)}k`;
+  if (normalized < 1e6) return `${String(Math.round(normalized / 1e3))}k`;
+  if (normalized < 1e7) return `${(normalized / 1e6).toFixed(1)}M`;
+  return `${String(Math.round(normalized / 1e6))}M`;
+}
+__name(formatCompactNumber, "formatCompactNumber");
+function formatContextUsageSummary(usage) {
+  if (usage?.contextWindow === void 0 || usage.contextWindow <= 0) return void 0;
+  const window = formatCompactNumber(usage.contextWindow);
+  if (usage.percent === null || usage.tokens === null) return `ctx=?/${window}`;
+  return `ctx=${usage.percent.toFixed(1)}%/${window}`;
+}
+__name(formatContextUsageSummary, "formatContextUsageSummary");
+function formatTokenUsageSummary(usage) {
+  if (!usage || usage.totalTokens <= 0) return void 0;
+  return `tokens=${formatCompactNumber(usage.totalTokens)}`;
+}
+__name(formatTokenUsageSummary, "formatTokenUsageSummary");
+function formatToolUsageSummary(usage) {
+  if (!usage || usage.total <= 0 && usage.failed <= 0) return void 0;
+  const failed = usage.failed > 0 ? ` failed=${String(usage.failed)}` : "";
+  return `tools=${String(usage.total)}${failed}`;
+}
+__name(formatToolUsageSummary, "formatToolUsageSummary");
+function formatModelSummary(model) {
+  if (!model) return void 0;
+  return `model=${model}`;
+}
+__name(formatModelSummary, "formatModelSummary");
+var AGENT_ACTIVITY_TYPE = "background-task-activity";
+var AGENT_ACTIVITY_DETAIL_MAX = 80;
+function readActivityString(record, key) {
+  const value = record[key];
+  return typeof value === "string" ? value : void 0;
+}
+__name(readActivityString, "readActivityString");
+function parseAgentActivity(payload) {
+  if (!isJsonObject(payload)) return void 0;
+  const record = payload;
+  if (record.type !== AGENT_ACTIVITY_TYPE) return void 0;
+  const kind = record.kind;
+  if (kind === "assistant_text" || kind === "reasoning") {
+    const text = readActivityString(record, "text");
+    if (text === void 0) return void 0;
+    return { kind, text };
+  }
+  if (kind === "tool_start") {
+    const tool = readActivityString(record, "tool");
+    if (!tool) return void 0;
+    return { kind, tool, argsSummary: readActivityString(record, "argsSummary") ?? "" };
+  }
+  if (kind === "tool_end") {
+    const tool = readActivityString(record, "tool");
+    if (!tool) return void 0;
+    const activity = { kind, tool, isError: record.isError === true };
+    const error = readActivityString(record, "error");
+    if (error !== void 0 && error.trim().length > 0) activity.error = error;
+    return activity;
+  }
+  return void 0;
+}
+__name(parseAgentActivity, "parseAgentActivity");
+function formatAgentActivityLine(activity) {
+  if (activity.kind === "assistant_text") {
+    const text = activity.text.replace(/\s+$/u, "");
+    return text.trim().length > 0 ? text : void 0;
+  }
+  if (activity.kind === "reasoning") {
+    const text = activity.text.replace(/\s+$/u, "");
+    return text.trim().length > 0 ? `\u2026 ${text}` : void 0;
+  }
+  if (activity.kind === "tool_start") {
+    const summary = compactWhitespace(activity.argsSummary);
+    const suffix = summary.length > 0 ? ` ${truncateChars(summary, AGENT_ACTIVITY_DETAIL_MAX)}` : "";
+    return `\u2192 ${activity.tool}${suffix}`;
+  }
+  if (!activity.isError) return void 0;
+  const detail = activity.error ? `: ${truncateChars(compactWhitespace(activity.error), AGENT_ACTIVITY_DETAIL_MAX)}` : "";
+  return `\u2717 ${activity.tool} failed${detail}`;
+}
+__name(formatAgentActivityLine, "formatAgentActivityLine");
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+__name(shellQuote, "shellQuote");
+var ShellInvocationError = class extends Error {
+  static {
+    __name(this, "ShellInvocationError");
+  }
+  code = "pi_bg_shell_invalid";
+  constructor(message) {
+    super(`pi_bg_shell_invalid: ${message}`);
+    this.name = "ShellInvocationError";
+  }
+};
+var POSIX_FUNCTION_SHELLS = /* @__PURE__ */ new Set([
+  "sh",
+  "dash",
+  "ash",
+  "ksh",
+  "ksh93",
+  "mksh",
+  "pdksh",
+  "zsh",
+  "yash",
+  "posh"
+]);
+function failShellInvocation(message) {
+  throw new ShellInvocationError(message);
+}
+__name(failShellInvocation, "failShellInvocation");
+function shellErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+__name(shellErrorMessage, "shellErrorMessage");
+function freezeShellPolicy(policy) {
+  return Object.freeze({
+    ...policy,
+    argvPrefix: Object.freeze([...policy.argvPrefix])
+  });
+}
+__name(freezeShellPolicy, "freezeShellPolicy");
+function shellPolicySnapshot(policy) {
+  return Object.freeze({
+    policy: policy.policy,
+    executable: policy.executable,
+    argvPrefix: Object.freeze([...policy.argvPrefix]),
+    dialect: policy.dialect
+  });
+}
+__name(shellPolicySnapshot, "shellPolicySnapshot");
+function isWindowsExecutablePath(path) {
+  const extension = extname(path).toLowerCase();
+  return extension === ".exe" || extension === ".com";
+}
+__name(isWindowsExecutablePath, "isWindowsExecutablePath");
+function validateWindowsShellPath(path, label) {
+  if (path.length === 0) failShellInvocation(`${label} is empty`);
+  if (!isAbsolute(path) && !win32.isAbsolute(path)) {
+    failShellInvocation(`${label} must be an absolute path`);
+  }
+  if (!isWindowsExecutablePath(path)) {
+    failShellInvocation(`${label} must point to a .exe or .com file`);
+  }
+  let stats;
+  try {
+    stats = statSync(path);
+  } catch (error) {
+    failShellInvocation(`${label} stat failed: ${shellErrorMessage(error)}`);
+  }
+  if (!stats.isFile()) failShellInvocation(`${label} must point to a regular file`);
+  return path;
+}
+__name(validateWindowsShellPath, "validateWindowsShellPath");
+function inspectWindowsShellCandidate(path) {
+  if (!isWindowsExecutablePath(path)) {
+    return { found: false, diagnostic: `${path} is not a .exe or .com path` };
+  }
+  try {
+    const stats = statSync(path);
+    if (stats.isFile()) return { found: true };
+    return { found: false, diagnostic: `${path} is not a regular file` };
+  } catch (error) {
+    return { found: false, diagnostic: `${path}: ${shellErrorMessage(error)}` };
+  }
+}
+__name(inspectWindowsShellCandidate, "inspectWindowsShellCandidate");
+function windowsPathValue(env) {
+  return env["PATH"] ?? env["Path"] ?? env["path"] ?? "";
+}
+__name(windowsPathValue, "windowsPathValue");
+function resolveWindowsBash(env) {
+  const pathValue = windowsPathValue(env);
+  const diagnostics = [];
+  for (const dir of pathValue.split(";").filter((entry) => entry.length > 0)) {
+    for (const name of ["bash.exe", "bash.com"]) {
+      const candidate = join(dir, name);
+      const result = inspectWindowsShellCandidate(candidate);
+      if (result.found) return candidate;
+      diagnostics.push(result.diagnostic);
+    }
+  }
+  const suffix = diagnostics.length > 0 ? `: ${diagnostics.join("; ")}` : "";
+  failShellInvocation(`PI_BG_SHELL=bash could not resolve bash.exe or bash.com on PATH${suffix}`);
+}
+__name(resolveWindowsBash, "resolveWindowsBash");
+function validatePosixShellPath(path, label) {
+  if (path.length === 0) failShellInvocation(`${label} is empty`);
+  if (!isAbsolute(path)) failShellInvocation(`${label} must be an absolute path`);
+  let stats;
+  try {
+    stats = statSync(path);
+  } catch (error) {
+    failShellInvocation(`${label} stat failed: ${shellErrorMessage(error)}`);
+  }
+  if (!stats.isFile()) failShellInvocation(`${label} must point to a regular file`);
+  try {
+    accessSync(path, constants.X_OK);
+  } catch (error) {
+    failShellInvocation(`${label} must be executable: ${shellErrorMessage(error)}`);
+  }
+  return path;
+}
+__name(validatePosixShellPath, "validatePosixShellPath");
+function inspectPosixShellCandidate(path) {
+  try {
+    const stats = statSync(path);
+    if (!stats.isFile()) return false;
+    accessSync(path, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(inspectPosixShellCandidate, "inspectPosixShellCandidate");
+function resolvePosixExecutable(name, env, activationCwd) {
+  const binCandidate = `/bin/${name}`;
+  if (inspectPosixShellCandidate(binCandidate)) return binCandidate;
+  const pathValue = env["PATH"] ?? "";
+  for (const entry of pathValue.split(delimiter)) {
+    if (entry.length === 0) continue;
+    const directory = isAbsolute(entry) ? entry : resolve(activationCwd, entry);
+    const candidate = join(directory, name);
+    if (inspectPosixShellCandidate(candidate)) return candidate;
+  }
+  failShellInvocation(
+    `PI_BG_POSIX_SHELL=${name} could not resolve executable ${binCandidate} or ${name} on PATH`
+  );
+}
+__name(resolvePosixExecutable, "resolvePosixExecutable");
+function inheritedPosixDialect(executable) {
+  const name = basename(executable).toLowerCase();
+  if (name === "bash") return "bash";
+  return POSIX_FUNCTION_SHELLS.has(name) ? "posix" : "user-non-posix";
+}
+__name(inheritedPosixDialect, "inheritedPosixDialect");
+function resolveShellPolicy(platform = process.platform, env = process.env, activationCwd = process.cwd()) {
+  if (platform === "win32") {
+    const requestedShell = env["PI_BG_SHELL"];
+    const requestedPath = env["PI_BG_SHELL_PATH"];
+    if (requestedShell === void 0) {
+      if (requestedPath !== void 0)
+        failShellInvocation("PI_BG_SHELL_PATH requires PI_BG_SHELL");
+      const comSpec = env["ComSpec"];
+      return freezeShellPolicy({
+        policy: "cmd",
+        executable: comSpec && comSpec.length > 0 ? comSpec : "cmd.exe",
+        argvPrefix: ["/d", "/s", "/c"],
+        dialect: "cmd",
+        supportsPosixFunctionWrapper: false,
+        windowsVerbatimArguments: true
+      });
+    }
+    if (requestedShell !== "cmd" && requestedShell !== "bash") {
+      failShellInvocation("PI_BG_SHELL must be exactly cmd or bash");
+    }
+    const explicitPath = requestedPath !== void 0 ? validateWindowsShellPath(requestedPath, "PI_BG_SHELL_PATH") : void 0;
+    if (requestedShell === "cmd") {
+      const comSpec = env["ComSpec"];
+      return freezeShellPolicy({
+        policy: "cmd",
+        executable: explicitPath ?? (comSpec && comSpec.length > 0 ? comSpec : "cmd.exe"),
+        argvPrefix: ["/d", "/s", "/c"],
+        dialect: "cmd",
+        supportsPosixFunctionWrapper: false,
+        windowsVerbatimArguments: true
+      });
+    }
+    return freezeShellPolicy({
+      policy: "bash",
+      executable: explicitPath ?? resolveWindowsBash(env),
+      argvPrefix: ["-c"],
+      dialect: "bash",
+      supportsPosixFunctionWrapper: true,
+      windowsVerbatimArguments: false
+    });
+  }
+  const configuredPolicy = env["PI_BG_POSIX_SHELL"];
+  if (configuredPolicy !== void 0 && configuredPolicy !== "inherit" && configuredPolicy !== "bash" && configuredPolicy !== "sh") {
+    failShellInvocation("PI_BG_POSIX_SHELL must be exactly inherit, bash, or sh");
+  }
+  const policy = configuredPolicy ?? "inherit";
+  const configuredPath = env["PI_BG_POSIX_SHELL_PATH"];
+  if (policy === "inherit") {
+    if (configuredPath !== void 0) {
+      failShellInvocation(
+        "PI_BG_POSIX_SHELL_PATH requires PI_BG_POSIX_SHELL=bash or PI_BG_POSIX_SHELL=sh"
+      );
+    }
+    const inherited = env["SHELL"];
+    const executable2 = inherited && inherited.length > 0 ? inherited : "/bin/sh";
+    const dialect = inheritedPosixDialect(executable2);
+    return freezeShellPolicy({
+      policy,
+      executable: executable2,
+      argvPrefix: ["-c"],
+      dialect,
+      supportsPosixFunctionWrapper: dialect === "bash" || dialect === "posix",
+      windowsVerbatimArguments: false
+    });
+  }
+  const executable = configuredPath !== void 0 ? validatePosixShellPath(configuredPath, "PI_BG_POSIX_SHELL_PATH") : resolvePosixExecutable(policy, env, activationCwd);
+  return freezeShellPolicy({
+    policy,
+    executable,
+    argvPrefix: ["-c"],
+    dialect: policy === "bash" ? "bash" : "posix",
+    supportsPosixFunctionWrapper: true,
+    windowsVerbatimArguments: false
+  });
+}
+__name(resolveShellPolicy, "resolveShellPolicy");
+function shellInvocationForPolicy(command, policy) {
+  const dialect = policy.dialect === "bash" ? "posix" : policy.dialect;
+  return {
+    shell: policy.executable,
+    args: policy.dialect === "cmd" ? [...policy.argvPrefix, `"${command}"`] : [...policy.argvPrefix, command],
+    dialect,
+    windowsVerbatimArguments: policy.windowsVerbatimArguments
+  };
+}
+__name(shellInvocationForPolicy, "shellInvocationForPolicy");
+function normalizeMaxBytes(value, fallback = DEFAULT_LOG_BYTES) {
+  const raw = typeof value === "number" && Number.isFinite(value) ? Math.floor(value) : fallback;
+  return Math.max(1, Math.min(MAX_LOG_BYTES, raw));
+}
+__name(normalizeMaxBytes, "normalizeMaxBytes");
+function snapshot(task) {
+  return {
+    id: task.id,
+    name: taskDisplayName(task),
+    command: task.command,
+    description: task.description,
+    status: task.status,
+    outputPath: task.outputPath,
+    cwd: task.cwd,
+    startTime: task.startTime,
+    endTime: task.endTime,
+    exitCode: task.exitCode,
+    signal: task.signal,
+    pid: task.pid,
+    bytesWritten: task.bytesWritten,
+    isAgent: task.isAgent,
+    surviveReload: task.surviveReload === true,
+    reloadSurvival: task.reloadSurvival,
+    error: task.error,
+    notified: task.notified,
+    notifyOnCompletion: task.notifyOnCompletion,
+    triggerOnCompletion: task.triggerOnCompletion,
+    timeoutSeconds: task.timeoutSeconds,
+    contextUsage: task.contextUsage,
+    tokenUsage: task.tokenUsage,
+    toolUsage: task.toolUsage,
+    model: task.model,
+    telemetryUnavailableReason: task.telemetryUnavailableReason,
+    shellPolicy: task.shellPolicy,
+    attestationPath: task.attestationPath,
+    delegate: task.delegate,
+    fusion: task.fusion
+  };
+}
+__name(snapshot, "snapshot");
+function formatSnapshotList(tasks, now = Date.now()) {
+  if (tasks.length === 0) return "No background tasks in this Pi extension runtime.";
+  return tasks.map((task) => {
+    const statusIcon = task.status === "running" ? "\u25B6" : task.status === "completed" ? "\u2713" : task.status === "killed" ? "\u25A0" : "\u2717";
+    const age = formatDuration((task.endTime ?? now) - task.startTime);
+    const code = task.exitCode !== void 0 ? ` exit=${String(task.exitCode)}` : "";
+    const pid = task.pid !== void 0 ? ` pid=${String(task.pid)}` : "";
+    const error = task.error ? ` error=${truncateChars(task.error, 80)}` : "";
+    const telemetry = [
+      formatContextUsageSummary(task.contextUsage),
+      formatModelSummary(task.model),
+      formatTokenUsageSummary(task.tokenUsage),
+      formatToolUsageSummary(task.toolUsage)
+    ].filter(Boolean).join(" ");
+    const telemetryText = telemetry ? ` ${telemetry}` : "";
+    return `${statusIcon} ${task.id} ${task.status} ${age}${code}${pid}${telemetryText} \u2014 ${truncateChars(taskDisplayName(task), COMMAND_PREVIEW_CHARS)}${error}
+    output: ${task.outputPath}`;
+  }).join("\n");
+}
+__name(formatSnapshotList, "formatSnapshotList");
+async function boundedRead(filePath, maxBytes, tail) {
+  const stats = statSync(filePath);
+  const totalBytes = stats.size;
+  const bytesToRead = Math.min(totalBytes, maxBytes);
+  if (bytesToRead === 0) return { content: "", truncated: false, bytesRead: 0, totalBytes };
+  const file = await open(filePath, "r");
+  try {
+    const buffer = Buffer.alloc(bytesToRead);
+    const position = tail ? Math.max(0, totalBytes - bytesToRead) : 0;
+    const { bytesRead } = await file.read(buffer, 0, bytesToRead, position);
+    return {
+      content: buffer.subarray(0, bytesRead).toString("utf8"),
+      truncated: totalBytes > bytesRead,
+      bytesRead,
+      totalBytes
+    };
+  } finally {
+    await file.close();
+  }
+}
+__name(boundedRead, "boundedRead");
+function escapeXml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+__name(escapeXml, "escapeXml");
+var UPDATE_COMMAND = "/bg-update";
+var SEMVER_PATTERN = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+function parseSemver(value) {
+  if (typeof value !== "string") return void 0;
+  const match = SEMVER_PATTERN.exec(value.trim());
+  if (!match) return void 0;
+  const majorRaw = match[1];
+  const minorRaw = match[2];
+  const patchRaw = match[3];
+  if (majorRaw === void 0 || minorRaw === void 0 || patchRaw === void 0) return void 0;
+  const major = Number(majorRaw);
+  const minor = Number(minorRaw);
+  const patch = Number(patchRaw);
+  if (!Number.isInteger(major) || !Number.isInteger(minor) || !Number.isInteger(patch))
+    return void 0;
+  const prerelease = match[4] !== void 0 ? match[4].split(".") : [];
+  return { major, minor, patch, prerelease };
+}
+__name(parseSemver, "parseSemver");
+function comparePrerelease(a, b) {
+  if (a.length === 0 && b.length === 0) return 0;
+  if (a.length === 0) return 1;
+  if (b.length === 0) return -1;
+  const shared = Math.min(a.length, b.length);
+  for (let i = 0; i < shared; i++) {
+    const idA = a[i];
+    const idB = b[i];
+    if (idA === void 0 || idB === void 0) break;
+    if (idA === idB) continue;
+    const numericA = /^\d+$/.test(idA);
+    const numericB = /^\d+$/.test(idB);
+    if (numericA && numericB) {
+      const diff = Number(idA) - Number(idB);
+      if (diff !== 0) return diff < 0 ? -1 : 1;
+      continue;
+    }
+    if (numericA) return -1;
+    if (numericB) return 1;
+    return idA < idB ? -1 : 1;
+  }
+  if (a.length === b.length) return 0;
+  return a.length < b.length ? -1 : 1;
+}
+__name(comparePrerelease, "comparePrerelease");
+function compareSemver(a, b) {
+  const left = parseSemver(a);
+  const right = parseSemver(b);
+  if (!left || !right) return void 0;
+  if (left.major !== right.major) return left.major < right.major ? -1 : 1;
+  if (left.minor !== right.minor) return left.minor < right.minor ? -1 : 1;
+  if (left.patch !== right.patch) return left.patch < right.patch ? -1 : 1;
+  return comparePrerelease(left.prerelease, right.prerelease);
+}
+__name(compareSemver, "compareSemver");
+function isNewerVersion(latest, current) {
+  return compareSemver(latest, current) === 1;
+}
+__name(isNewerVersion, "isNewerVersion");
+function formatUpdateSegment(latest, current) {
+  if (!latest) return void 0;
+  if (!isNewerVersion(latest, current)) return void 0;
+  return `\u2B06 v${latest} ${UPDATE_COMMAND}`;
+}
+__name(formatUpdateSegment, "formatUpdateSegment");
+
+export {
+  ReloadSurvivalError,
+  rejectSurvivalForTaskKind,
+  deriveCompletionDeliveryGuidance,
+  DEFAULT_LOG_BYTES,
+  MAX_LOG_BYTES,
+  isJsonObject,
+  parseJsonText,
+  sanitizePathSegment,
+  compactWhitespace,
+  truncateChars,
+  normalizeTaskName,
+  deriveTaskNameFromCommand,
+  taskDisplayName,
+  parseBgCommandArgs,
+  formatDuration,
+  formatCompactNumber,
+  parseAgentActivity,
+  formatAgentActivityLine,
+  shellQuote,
+  shellPolicySnapshot,
+  resolveShellPolicy,
+  shellInvocationForPolicy,
+  normalizeMaxBytes,
+  snapshot,
+  formatSnapshotList,
+  boundedRead,
+  escapeXml,
+  isNewerVersion,
+  formatUpdateSegment
+};