abtars 0.1.0-alpha.1

package/bundle/chunk-6UCRKRWR.js

@@ -0,0 +1,644 @@
+import { createRequire as __bundleCreateRequire } from 'node:module'; import { fileURLToPath as __bundleFileURLToPath } from 'node:url'; import { dirname as __bundleDirname } from 'node:path'; const require = __bundleCreateRequire(import.meta.url); const __chunk_filename = __bundleFileURLToPath(import.meta.url); const __chunk_dirname = __bundleDirname(__chunk_filename);
+import {
+  createAgentTransport
+} from "./chunk-BSSBCSCL.js";
+import {
+  loadUsers
+} from "./chunk-GST5T3WZ.js";
+import {
+  init_log_and_swallow,
+  logAndSwallow
+} from "./chunk-FMWKEPM7.js";
+import {
+  getEnv,
+  init_env_schema
+} from "./chunk-JCJS4ZIB.js";
+import {
+  init_logger,
+  isLogLevel,
+  logDebug,
+  logError,
+  logInfo,
+  logWarn
+} from "./chunk-BUUVFUPO.js";
+import {
+  abtarsHome,
+  init_paths
+} from "./chunk-X76UX47U.js";
+
+// src/boot/phase-transport.ts
+init_log_and_swallow();
+init_env_schema();
+import { execSync as execSync2 } from "node:child_process";
+
+// src/components/transport/tmux-client.ts
+init_logger();
+init_log_and_swallow();
+init_paths();
+import { execSync } from "node:child_process";
+import { writeFileSync, unlinkSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+var TAG = "tmux";
+var KIRO_PROMPT_RE = /^\d+%\s*!?>/;
+var SHELL_PROMPT_RE = /[$❯%#]\s*$/;
+var TmuxClient = class {
+  sessionName;
+  captureDelaySec;
+  maxWaitSec;
+  ready = false;
+  /** Optional callback for streaming intermediate responses before final prompt. */
+  onIntermediateResponse;
+  /** Tracks the cumulative text delivered via intermediate chunks (for tail detection). */
+  lastIntermediateDelivered = "";
+  constructor(sessionName, captureDelaySec, maxWaitSec) {
+    this.sessionName = sessionName;
+    this.captureDelaySec = captureDelaySec;
+    this.maxWaitSec = maxWaitSec;
+  }
+  async initialize() {
+    if (!this.sessionExists()) {
+      throw new Error(
+        `tmux session "${this.sessionName}" not found. Run: scripts/tmux-session.sh to start it.`
+      );
+    }
+    this.ready = true;
+    logInfo("tmux", `Session "${this.sessionName}" found`);
+  }
+  get isReady() {
+    return this.ready && this.sessionExists();
+  }
+  transportCommands = [];
+  async sendPrompt(_sessionKey, message) {
+    if (!this.isReady) {
+      throw new Error("tmux session not available");
+    }
+    this.lastIntermediateDelivered = "";
+    const maxAttempts = 2;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      const before = this.capturePaneRaw();
+      if (attempt === 1) {
+        logDebug("tmux", `Sending: "${message.slice(0, 80)}"`);
+      } else {
+        logInfo("tmux", `Retry #${attempt}: resending prompt`);
+      }
+      try {
+        if (message.length > 4e3) {
+          const tmpDir = join(abtarsHome(), "tmp");
+          mkdirSync(tmpDir, { recursive: true });
+          const tmpFile = join(tmpDir, `prompt-${Date.now()}.txt`);
+          writeFileSync(tmpFile, message);
+          const readCmd = `My full message is in ${tmpFile} \u2014 please read it and respond.`;
+          const escaped = readCmd.replace(/'/g, "'\\''");
+          this.exec(`tmux send-keys -t ${this.sessionName} '${escaped}' Enter`);
+          setTimeout(() => {
+            try {
+              unlinkSync(tmpFile);
+            } catch (err) {
+              logAndSwallow(TAG, "unlink tmpFile", err);
+            }
+          }, 12e4);
+        } else {
+          const escaped = message.replace(/'/g, "'\\''");
+          this.exec(`tmux send-keys -t ${this.sessionName} '${escaped}' Enter`);
+        }
+      } catch (err) {
+        logWarn("tmux", `send-keys failed: ${err instanceof Error ? err.message : String(err)}`);
+        return "\u26A0\uFE0F Failed to send message to Kiro session. The tmux session may be in copy mode or unresponsive. Try /reset.";
+      }
+      await sleep(this.captureDelaySec * 1e3);
+      const response = await this.pollForResponse(before);
+      if (response.startsWith("Kiro is having trouble") && attempt < maxAttempts) {
+        logInfo("tmux", `Kiro trouble detected, will retry in 5s...`);
+        await sleep(5e3);
+        continue;
+      }
+      logDebug("tmux", `Got response (${response.length} chars)`);
+      return response;
+    }
+    return "\u26A0\uFE0F Kiro is having trouble responding. Try again or /reset.";
+  }
+  async resetSession(_sessionKey) {
+    if (!this.sessionExists()) return;
+    this.exec(`tmux send-keys -t ${this.sessionName} C-c`);
+    await sleep(1e3);
+    this.exec(`tmux send-keys -t ${this.sessionName} '/clear' Enter`);
+    await sleep(2e3);
+    this.exec(`tmux send-keys -t ${this.sessionName} 'y' Enter`);
+    await sleep(1e3);
+  }
+  async restartSession(workingDir, kiroModel) {
+    if (this.sessionExists()) {
+      this.exec(`tmux kill-session -t ${this.sessionName}`);
+      await sleep(1e3);
+    }
+    let cmd = `kiro-cli chat --trust-all-tools`;
+    if (kiroModel) cmd += ` --model ${kiroModel}`;
+    this.exec(`tmux new-session -d -s ${this.sessionName} -c '${workingDir}' '${cmd}'`);
+    this.exec(`tmux set-option -t ${this.sessionName} history-limit 5000`);
+    await sleep(3e3);
+    this.exec(`tmux send-keys -t ${this.sessionName} '/settings chat.enableThinking true' Enter`);
+    await sleep(2e3);
+    this.ready = this.sessionExists();
+    logInfo("tmux", `Session restarted (ready=${this.ready})`);
+  }
+  async sendInterrupt() {
+    if (!this.sessionExists()) return;
+    logInfo("tmux", "Sending Ctrl+C interrupt");
+    this.exec(`tmux send-keys -t ${this.sessionName} C-c`);
+  }
+  destroy() {
+    this.ready = false;
+  }
+  /**
+   * Poll capture-pane until Kiro's prompt reappears (N% >).
+   * Delivers intermediate purple-line responses via onIntermediateResponse callback
+   * so the user sees partial answers while Kiro continues with tools.
+   * Only returns when the actual Kiro prompt appears or timeout.
+   */
+  async pollForResponse(beforeSnapshot) {
+    const startTime = Date.now();
+    const maxWaitMs = this.maxWaitSec * 1e3;
+    let lastCapture = "";
+    let stableCount = 0;
+    let lastDeliveredAnswer = "";
+    while (Date.now() - startTime < maxWaitMs) {
+      const capture = this.capturePaneRaw();
+      const newContent = this.diffOutput(beforeSnapshot, capture);
+      if (newContent.length === 0) {
+        await sleep(2e3);
+        continue;
+      }
+      const lines = capture.split("\n");
+      const lastNonEmpty = this.getLastNonEmptyLine(lines);
+      const lastClean = this.stripAnsi(lastNonEmpty);
+      if (KIRO_PROMPT_RE.test(lastClean)) {
+        const pctMatch = lastClean.match(/^(\d+)%/);
+        if (pctMatch) {
+          this.lastContextPercent = parseInt(pctMatch[1], 10);
+          logDebug("tmux", `Context window: ${this.lastContextPercent}%`);
+        }
+        logDebug("tmux", `Detected Kiro prompt: "${lastClean}"`);
+        return this.extractResponse(newContent);
+      }
+      if (SHELL_PROMPT_RE.test(lastClean) && newContent.length > 10) {
+        logDebug("tmux", `Detected shell prompt: "${lastClean}"`);
+        return this.extractResponse(newContent);
+      }
+      if (this.onIntermediateResponse && capture !== lastCapture) {
+        const intermediateAnswer = this.extractAnswerOnly(newContent);
+        if (intermediateAnswer && intermediateAnswer !== lastDeliveredAnswer) {
+          const newPart = intermediateAnswer.startsWith(lastDeliveredAnswer) ? intermediateAnswer.slice(lastDeliveredAnswer.length).trim() : intermediateAnswer;
+          if (newPart) {
+            logDebug("tmux", `Delivering intermediate chunk (${newPart.length} chars)`);
+            this.onIntermediateResponse(newPart);
+            lastDeliveredAnswer = intermediateAnswer;
+            this.lastIntermediateDelivered = intermediateAnswer;
+          }
+        }
+      }
+      if (capture === lastCapture) {
+        stableCount++;
+      } else {
+        stableCount = 0;
+        lastCapture = capture;
+      }
+      await sleep(2e3);
+    }
+    const finalCapture = this.capturePaneRaw();
+    const finalNew = this.diffOutput(beforeSnapshot, finalCapture);
+    if (finalNew.length > 0) {
+      return this.extractResponse(finalNew) + "\n\n\u23F1\uFE0F (response may be incomplete \u2014 timed out)";
+    }
+    return "\u23F1\uFE0F Kiro is still processing. Check the tmux session directly.";
+  }
+  /**
+   * Extract the meaningful response from the diff.
+   * Removes the echoed user input line and Kiro's prompt lines.
+   * Stores the "answer only" portion (lines that were "> " prefixed)
+   * separately for TTS use.
+   *
+   * Kiro output format:
+   *   N% > <echoed user input>
+   *   > <response line 1>
+   *   > <response line 2>
+   *   ▸ Time: Ns
+   *   M% >
+   */
+  lastAnswerOnly = "";
+  lastContextPercent = -1;
+  /** Get just the Kiro answer lines ("> " prefixed) from the last response — for TTS. */
+  get answerOnly() {
+    return this.lastAnswerOnly;
+  }
+  get toolCallsSucceeded() {
+    return 0;
+  }
+  /** Get the context window usage percentage from the last Kiro prompt (e.g. 10 for "10% >"). Returns -1 if unknown. */
+  get contextPercent() {
+    return this.lastContextPercent;
+  }
+  /** Get the cumulative text that was delivered via intermediate streaming. */
+  get intermediateDeliveredText() {
+    return this.lastIntermediateDelivered;
+  }
+  /** Extract just the purple "> " answer lines from raw tmux output (no side effects). */
+  extractAnswerOnly(raw) {
+    const PURPLE_PREFIX = /\x1b\[38;5;141m>\s/;
+    const lines = raw.split("\n");
+    let blockStart = -1;
+    for (let i = lines.length - 1; i >= 0; i--) {
+      if (PURPLE_PREFIX.test(lines[i])) {
+        blockStart = i;
+        while (blockStart > 0 && PURPLE_PREFIX.test(lines[blockStart - 1])) blockStart--;
+        break;
+      }
+    }
+    if (blockStart < 0) return "";
+    const answerLines = [];
+    for (let i = blockStart; i < lines.length; i++) {
+      const clean = this.stripAnsi(lines[i]).trim();
+      if (KIRO_PROMPT_RE.test(clean)) break;
+      if (clean.startsWith("\u25B8 Time:")) break;
+      if (clean.startsWith("> ")) answerLines.push(clean.slice(2));
+      else if (clean === ">") answerLines.push("");
+      else if (clean === "") answerLines.push("");
+      else answerLines.push(clean);
+    }
+    return answerLines.join("\n").trim();
+  }
+  extractResponse(raw) {
+    const PURPLE_PREFIX = /\x1b\[38;5;141m>\s/;
+    const lines = raw.split("\n");
+    const answerLines = [];
+    let lastPurpleBlockStart = -1;
+    for (let i = 0; i < lines.length; i++) {
+      if (PURPLE_PREFIX.test(lines[i])) {
+        if (lastPurpleBlockStart === -1) lastPurpleBlockStart = i;
+      }
+    }
+    let blockStart = -1;
+    for (let i = lines.length - 1; i >= 0; i--) {
+      if (PURPLE_PREFIX.test(lines[i])) {
+        blockStart = i;
+        while (blockStart > 0) {
+          const prev = lines[blockStart - 1];
+          if (PURPLE_PREFIX.test(prev) || !KIRO_PROMPT_RE.test(this.stripAnsi(prev).trim()) && !prev.includes("\u25B8 Time:") && this.stripAnsi(prev).trim() !== "" && !PURPLE_PREFIX.test(prev) && blockStart === i) {
+            if (PURPLE_PREFIX.test(prev)) {
+              blockStart--;
+            } else {
+              break;
+            }
+          } else {
+            break;
+          }
+        }
+        break;
+      }
+    }
+    if (blockStart >= 0) {
+      for (let i = blockStart; i < lines.length; i++) {
+        const line = lines[i];
+        const clean = this.stripAnsi(line).trim();
+        if (KIRO_PROMPT_RE.test(clean)) break;
+        if (clean.startsWith("\u25B8 Time:") || clean.startsWith("\u25B8 Time:")) break;
+        if (clean === "") {
+          answerLines.push("");
+          continue;
+        }
+        if (clean.startsWith("> ")) {
+          answerLines.push(clean.slice(2));
+        } else if (clean === ">") {
+          answerLines.push("");
+        } else {
+          answerLines.push(clean);
+        }
+      }
+      this.lastAnswerOnly = answerLines.join("\n").trim();
+    } else {
+      this.lastAnswerOnly = "";
+    }
+    const cleaned = this.stripAnsi(raw);
+    const allLines = cleaned.split("\n");
+    const result = [];
+    for (const line of allLines) {
+      const trimmed = line.trim();
+      if (result.length === 0 && trimmed === "") continue;
+      if (KIRO_PROMPT_RE.test(trimmed)) continue;
+      if (trimmed.startsWith("\u25B8 Time:") || trimmed.startsWith("\u25B8 Time:")) continue;
+      if (/^-{4,}$/.test(trimmed)) continue;
+      result.push(line);
+    }
+    const stripped = result.map((line) => {
+      const trimmed = line.trimStart();
+      if (trimmed.startsWith("> ")) return trimmed.slice(2);
+      if (trimmed === ">") return "";
+      return line;
+    });
+    const final = stripped.join("\n").trim();
+    logDebug("tmux", `extractResponse: ${result.length} lines \u2192 "${final.slice(0, 120)}"`);
+    if (this.lastAnswerOnly) {
+      logDebug("tmux", `answerOnly (${this.lastAnswerOnly.length} chars): "${this.lastAnswerOnly.slice(0, 120)}"`);
+    }
+    return final;
+  }
+  /** Get new content by diffing before/after snapshots. */
+  diffOutput(before, after) {
+    const beforeLines = before.split("\n");
+    const afterLines = after.split("\n");
+    let commonPrefix = 0;
+    while (commonPrefix < beforeLines.length && commonPrefix < afterLines.length && beforeLines[commonPrefix] === afterLines[commonPrefix]) {
+      commonPrefix++;
+    }
+    return afterLines.slice(commonPrefix).join("\n").trim();
+  }
+  /** Get the last non-empty line from an array. */
+  getLastNonEmptyLine(lines) {
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const trimmed = lines[i].trim();
+      if (trimmed.length > 0) return trimmed;
+    }
+    return "";
+  }
+  /** Strip ANSI escape codes. */
+  stripAnsi(text) {
+    return text.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "").replace(/\x1B\][^\x07]*\x07/g, "");
+  }
+  capturePaneRaw() {
+    try {
+      return this.exec(`tmux capture-pane -t ${this.sessionName} -p -e -S -2000`);
+    } catch (err) {
+      logAndSwallow(TAG, "capturePaneRaw", err);
+      return "";
+    }
+  }
+  sessionExists() {
+    try {
+      this.exec(`tmux has-session -t ${this.sessionName}`);
+      return true;
+    } catch (err) {
+      logAndSwallow(TAG, "sessionExists check", err);
+      return false;
+    }
+  }
+  exec(command) {
+    return execSync(command, {
+      encoding: "utf-8",
+      timeout: 15e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/boot/phase-transport.ts
+init_logger();
+
+// src/boot/ctx-start.ts
+init_log_and_swallow();
+import { readFileSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+function updateCtxStart(memoryDir, userId, ts = Date.now()) {
+  const p = join2(memoryDir, "context-window-start.json");
+  let data = {};
+  try {
+    data = JSON.parse(readFileSync(p, "utf-8"));
+  } catch (err) {
+    logAndSwallow("ctx_start", "op", err);
+  }
+  data[userId] = ts;
+  writeFileSync2(p, JSON.stringify(data), "utf-8");
+}
+function resetAllCtxStarts(memoryDir) {
+  const p = join2(memoryDir, "context-window-start.json");
+  let data = {};
+  try {
+    data = JSON.parse(readFileSync(p, "utf-8"));
+  } catch (err) {
+    logAndSwallow("ctx_start", "read ctx-start json", err);
+    return;
+  }
+  const now = Date.now();
+  for (const key of Object.keys(data)) data[key] = now;
+  writeFileSync2(p, JSON.stringify(data), "utf-8");
+}
+
+// src/boot/phase-transport.ts
+var TAG2 = "transport";
+async function phaseTransport(ctx) {
+  const { memoryConfig } = ctx;
+  await buildTransport(ctx);
+  if (memoryConfig.memoryEnabled) {
+    const reg = loadUsers();
+    for (const user of reg.users) updateCtxStart(memoryConfig.memoryDir, user.userId, ctx.startedAt);
+  }
+  return "ran";
+}
+async function buildTransport(ctx) {
+  const { config, memoryConfig } = ctx;
+  let transport;
+  const { resolveAgent, getEnvFallback, loadTransport, resolveHailMary, clearTransportCache, validateProviderReady } = await import("./transport-config-YLXU33RO.js");
+  clearTransportCache();
+  const tc = loadTransport();
+  const prof = tc ? resolveAgent("professor", tc) : null;
+  const hm = resolveHailMary(tc);
+  if (hm) {
+    ctx.hailMary = {
+      model: hm.model,
+      endpoint: hm.endpoint,
+      apiKey: hm.apiKeyEnv ? getEnv().getApiKey(hm.apiKeyEnv) : void 0
+    };
+    logInfo("main", `\u{1F6A8} hailMary configured: ${hm.model} (manual /model emergency only)`);
+  } else {
+    ctx.hailMary = null;
+  }
+  let resolved = prof ?? (() => {
+    const fb = getEnvFallback();
+    logWarn("main", `\u26A0\uFE0F Using .env fallback: ${fb.model} via ${fb.providerName}`);
+    return { model: fb.model, provider: fb.provider, providerName: fb.providerName, contextWindow: fb.contextWindow, maxOutput: fb.maxOutput, fallbacks: [] };
+  })();
+  const validation = validateProviderReady(resolved.providerName, resolved.provider, getEnv());
+  if (!validation.ok) {
+    const errMsg = `transport.json configures '${resolved.providerName}' but ${validation.reason}. Fix: ${validation.fix}`;
+    if (ctx.transport) {
+      logError("main", `${errMsg} \u2014 keeping existing transport up (skipping rebuild)`);
+      return "ran";
+    }
+    if (prof) {
+      const fb = getEnvFallback();
+      logError("main", `${errMsg} \u2014 falling back to .env config (${fb.model} via ${fb.providerName})`);
+      resolved = { model: fb.model, provider: fb.provider, providerName: fb.providerName, contextWindow: fb.contextWindow, maxOutput: fb.maxOutput, fallbacks: [] };
+      const fbValidation = validateProviderReady(resolved.providerName, resolved.provider, getEnv());
+      if (!fbValidation.ok) {
+        logError("main", `.env fallback '${resolved.providerName}' also invalid: ${fbValidation.reason}`);
+        throw new Error(`${errMsg} (and .env fallback is also invalid: ${fbValidation.reason})`);
+      }
+    } else {
+      throw new Error(errMsg);
+    }
+  }
+  if (ctx.transport) {
+    try {
+      await ctx.transport.destroy();
+    } catch (err) {
+      logWarn("main", `Old transport destroy failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    ctx.transport = null;
+  }
+  if (resolved.provider.transport === "tmux") {
+    const defaults = tc?.transportDefaults?.tmux;
+    logInfo("main", `\u{1F5A5}\uFE0F  tmux transport (${resolved.providerName})`);
+    transport = new TmuxClient(
+      defaults?.session ?? config.transport.tmuxSession,
+      defaults?.captureDelaySec ?? config.transport.tmuxCaptureDelaySec,
+      defaults?.maxWaitSec ?? config.transport.tmuxMaxWaitSec
+    );
+  } else if (resolved.provider.transport === "api") {
+    const { DirectApiTransport } = await import("./direct-api-transport-YR7SXXNN.js");
+    const { ModelHealthRegistry } = await import("./model-health-registry-35LQNVQR.js");
+    const { FallbackPolicy } = await import("./fallback-policy-L4QV2PEJ.js");
+    const apiKey = getEnv().getApiKey(resolved.provider.apiKeyEnv ?? "API_KEY");
+    const candidates = [
+      { endpoint: resolved.provider.endpoint ?? "http://localhost:11434/v1", apiKey, model: resolved.model, maxContext: resolved.contextWindow }
+    ];
+    for (const fb of resolved.fallbacks) {
+      const fbResolved = tc ? resolveAgent("_fallback", { ...tc, agents: { ...tc.agents, _fallback: { model: fb.model, provider: fb.provider } } }) : null;
+      candidates.push({
+        endpoint: fbResolved?.provider.endpoint ?? resolved.provider.endpoint,
+        apiKey: fbResolved?.provider.apiKeyEnv ? getEnv().getApiKey(fbResolved.provider.apiKeyEnv) : apiKey,
+        model: fb.model,
+        maxContext: fbResolved?.contextWindow ?? resolved.contextWindow
+      });
+    }
+    if (!ctx.modelHealthRegistry) {
+      ctx.modelHealthRegistry = new ModelHealthRegistry(tc?.healthPolicy);
+    }
+    if (!ctx.modelHealthRegistry.onDemote) {
+      ctx.modelHealthRegistry.onDemote = (model, _endpoint, reason) => {
+        import("./transport-config-YLXU33RO.js").then(({ demoteModel }) => demoteModel(model, reason));
+        import("./notification-Y5S5MMLV.js").then(({ sendNotification }) => sendNotification(ctx, `\u26A0\uFE0F ${model} demoted (${reason}). Next healthy model promoted.`)).catch((err) => logAndSwallow(TAG2, "sendNotification model-demote", err));
+      };
+    }
+    const policy = new FallbackPolicy(candidates, ctx.modelHealthRegistry);
+    transport = new DirectApiTransport({
+      endpoint: resolved.provider.endpoint ?? "http://localhost:11434/v1",
+      apiKey,
+      model: resolved.model,
+      maxContext: resolved.contextWindow,
+      maxOutput: resolved.maxOutput,
+      maxTurns: tc?.maxTurns ?? 50,
+      apiFormat: resolved.provider.apiFormat,
+      thinking: resolved.provider.thinking
+    }, policy);
+    logInfo("main", `\u{1F50C} Direct API transport (${resolved.providerName}, model=${resolved.model}, ${candidates.length} candidates)`);
+  } else {
+    try {
+      execSync2("pkill -f 'kiro-cli.*acp.*professor' 2>/dev/null || true", { timeout: 3e3 });
+    } catch (err) {
+      logAndSwallow("phase_transport", "op", err);
+    }
+    logInfo("main", `\u{1F50C} ACP transport (${resolved.provider.cli ?? "kiro-cli"}, model=${resolved.model})`);
+    transport = createAgentTransport("professor", {
+      cliPath: resolved.provider.cli ?? config.transport.agentCliPath,
+      workingDir: config.transport.workingDir,
+      agentCli: resolved.provider.cli ?? "kiro-cli",
+      model: resolved.model
+    });
+  }
+  await transport.initialize();
+  if ("setSystemPrompt" in transport && typeof transport.setSystemPrompt === "function") {
+    const { loadSoulBundle } = await import("./soul-loader-54WCVNLJ.js");
+    const soul = loadSoulBundle();
+    if (soul) transport.setSystemPrompt(soul);
+  }
+  if (resolved.fallbacks.length > 0 && resolved.provider.transport !== "api") {
+    logWarn("main", `\u26A0\uFE0F Fallbacks configured for ${resolved.provider.transport} transport \u2014 only API transport supports model fallback`);
+  }
+  ctx.transport = transport;
+  ctx.modelName = resolved.model;
+  ctx.modelProvider = resolved.providerName;
+  ctx.fallbackChain = resolved.fallbacks.map((f) => f.model);
+  if (ctx.modelHealthRegistry) {
+    ctx.runtime.setRegistry(ctx.modelHealthRegistry);
+  }
+  ctx.runtime.setMainTransport(transport);
+  ctx.runtime.setSessionManager(ctx.sessionManager);
+  if (getEnv().enableAsyncDelegation) {
+    const { setDelegationDeps } = await import("./delegation-tools-GYTS2D6A.js");
+    setDelegationDeps(ctx.runtime, ctx.sessionManager);
+  }
+  logInfo("main", "\u2705 Transport ready");
+  if (resolved.provider.transport === "api" && ctx.memory) {
+    const { setMemoryBackend } = await import("./tool-registry-MU3OX4UI.js");
+    const { SqliteBackend } = await import("abmind");
+    const backend = new SqliteBackend(memoryConfig);
+    await backend.initialize();
+    setMemoryBackend(backend);
+    logInfo("main", "\u{1F9E0} In-process memory wired to tool registry");
+    const db = ctx.memory.getDb?.() ?? ctx.memory.getDatabase?.();
+    if (db && resolved.contextWindow >= 128e3) {
+      const { ContextEngine } = await import("abmind");
+      const { createContextOrchestrator } = await import("./context-HCEGZNDC.js");
+      const contextEngine = new ContextEngine(db);
+      const orchestrator = createContextOrchestrator(
+        contextEngine,
+        async (systemPrompt, userPrompt) => {
+          const { streamSingleCompletion } = await import("./stream-single-WSG4D53C.js");
+          return streamSingleCompletion({
+            endpoint: resolved.provider.endpoint ?? "http://localhost:11434/v1",
+            apiKey: getEnv().getApiKey(resolved.provider.apiKeyEnv ?? "API_KEY") ?? void 0,
+            model: resolved.model,
+            systemPrompt,
+            userPrompt,
+            maxTokens: 4096
+          });
+        },
+        (_chatId) => {
+          try {
+            return ctx.memory?.getLastMessageTimestamp(true) ?? null;
+          } catch (err) {
+            logAndSwallow(TAG2, "getLastMessageTimestamp", err);
+            return null;
+          }
+        }
+      );
+      transport.contextOrchestrator = orchestrator;
+      logInfo("main", "\u{1F4E6} Context engine wired (auto-compaction active)");
+    }
+  }
+  if ("onFallback" in transport) {
+    let lastNotifiedModel = null;
+    transport.onFallback = (model, ctxPct, reason) => {
+      const reasonTag = reason ? ` (${reason})` : "";
+      const msg = `\u26A1 Fallback${reasonTag}: ${model}${ctxPct >= 0 ? ` (ctx: ~${ctxPct}%)` : ""}`;
+      logInfo("main", msg);
+      if (model !== lastNotifiedModel || isLogLevel("debug")) {
+        lastNotifiedModel = model;
+        import("./notification-Y5S5MMLV.js").then(({ sendNotification }) => sendNotification(ctx, msg)).catch((err) => logAndSwallow(TAG2, "sendNotification fallback", err));
+      }
+    };
+  }
+  return "ran";
+}
+async function rebuildTransport(ctx) {
+  logInfo("main", "\u{1F504} Rebuilding transport...");
+  await buildTransport(ctx);
+  if (ctx.pipelineDeps && ctx.transport) {
+    ctx.pipelineDeps.transport = ctx.transport;
+  }
+  if (ctx.idleSave && ctx.transport) {
+    ctx.idleSave.transport = ctx.transport;
+  }
+  logInfo("main", "\u2705 Transport rebuilt");
+  return "ran";
+}
+
+export {
+  updateCtxStart,
+  resetAllCtxStarts,
+  phaseTransport,
+  buildTransport,
+  rebuildTransport
+};
+//# sourceMappingURL=chunk-6UCRKRWR.js.map