@integrity-labs/agt-cli 0.28.621 → 0.28.622

package/dist/bin/agt.js

@@ -40,10 +40,10 @@ import {
   success,
   table,
   warn
-} from "../chunk-MSQXSVA5.js";
+} from "../chunk-6TLALALT.js";
 import {
   readDirectChatSessionState
-} from "../chunk-QSPSXG4K.js";
+} from "../chunk-UIB2SMFE.js";
 import {
   AnchorSessionClient,
   CHANNEL_REGISTRY,
@@ -4909,7 +4909,7 @@ import { execFileSync, execSync } from "child_process";
 import { existsSync as existsSync10, realpathSync as realpathSync2 } from "fs";
 import chalk18 from "chalk";
 import ora16 from "ora";
-var cliVersion = true ? "0.28.621" : "dev";
+var cliVersion = true ? "0.28.622" : "dev";
 async function fetchLatestVersion() {
   const host2 = getHost();
   if (!host2) return null;
@@ -6089,7 +6089,7 @@ function handleError(err) {
 }
 
 // src/bin/agt.ts
-var cliVersion2 = true ? "0.28.621" : "dev";
+var cliVersion2 = true ? "0.28.622" : "dev";
 var program = new Command();
 program.name("agt").description("Augmented CLI \u2014 agent provisioning and management").version(cliVersion2).option("--json", "Emit machine-readable JSON output (suppress spinners and colors)").option("--skip-update-check", "Skip the automatic update check on startup");
 program.hook("preAction", async (thisCommand, actionCommand) => {

package/dist/{chunk-MSQXSVA5.js → chunk-6TLALALT.js}

@@ -7,7 +7,7 @@ import {
   expandTemplateVars,
   isolationMode,
   parseEnvIntegrations
-} from "./chunk-QSPSXG4K.js";
+} from "./chunk-UIB2SMFE.js";
 import {
   BIND_FAILURE_QUARANTINE_THRESHOLD,
   INTEGRATIONS_SECTION_END,
@@ -6065,7 +6065,7 @@ function exchangeFailureKind(err) {
 }
 
 // src/lib/api-client.ts
-var agtCliVersion = true ? "0.28.621" : "dev";
+var agtCliVersion = true ? "0.28.622" : "dev";
 var lastConfigHash = null;
 function setConfigHash(hash) {
   lastConfigHash = hash && hash.length > 0 ? hash : null;
@@ -9558,4 +9558,4 @@ export {
   managerInstallSystemUnitCommand,
   managerUninstallSystemUnitCommand
 };
-//# sourceMappingURL=chunk-MSQXSVA5.js.map
+//# sourceMappingURL=chunk-6TLALALT.js.map

package/dist/{chunk-QSPSXG4K.js → chunk-UIB2SMFE.js}

@@ -848,7 +848,6 @@ function buildOpencodeIntegrationServers(integrations, ctx) {
 }
 
 // ../../packages/core/dist/provisioning/frameworks/opencode/opencode-client.js
-var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 var HttpOpencodeClient = class _HttpOpencodeClient {
   base;
   headers;
@@ -895,68 +894,44 @@ var HttpOpencodeClient = class _HttpOpencodeClient {
     }
   }
   async createSession(params) {
-    const out = await this.call("POST", "/api/session", params ?? {});
-    const id = out.data?.id;
+    const out = await this.call("POST", "/session", params ?? {});
+    const id = out.id;
     if (!id)
       throw new Error("opencode createSession returned no session id");
     return { sessionID: id };
   }
-  async prompt(params) {
-    const out = await this.call("POST", `/api/session/${params.sessionID}/prompt`, {
-      prompt: { text: params.text },
-      // ENG-7931: pass the model on the prompt so the serve runs the intended
-      // provider/model instead of defaulting the session to a free Zen model.
-      ...params.model ? { model: params.model } : {},
-      delivery: params.delivery ?? "queue"
+  async sendMessage(params) {
+    const out = await this.call("POST", `/session/${params.sessionID}/message`, {
+      parts: [{ type: "text", text: params.text }],
+      ...params.model ? { model: { providerID: params.model.providerID, modelID: params.model.id } } : {}
     });
-    return { admittedSeq: out.data?.admittedSeq ?? 0, messageID: out.data?.id };
-  }
-  async waitIdle(sessionID, opts = {}) {
-    const timeoutMs = opts.timeoutMs ?? 12e4;
-    const pollIntervalMs = opts.pollIntervalMs ?? 300;
-    const deadline = Date.now() + timeoutMs;
-    for (; ; ) {
-      const newest = _HttpOpencodeClient.newestByCreated(await this.fetchMessages(sessionID));
-      if (newest?.type === "assistant" && newest.time?.completed != null)
-        return;
-      if (Date.now() >= deadline) {
-        throw new Error(`opencode waitIdle: session ${sessionID} did not go idle within ${timeoutMs}ms`);
-      }
-      await delay(pollIntervalMs);
-    }
+    const reply = _HttpOpencodeClient.textOf(out.parts ?? []);
+    return { reply, messageID: out.info?.id, parentID: out.info?.parentID };
   }
-  async latestAssistantText(sessionID) {
-    const assistants = (await this.fetchMessages(sessionID)).filter((m) => m.type === "assistant");
-    const newest = _HttpOpencodeClient.newestByCreated(assistants);
-    if (!newest)
-      return null;
-    const text = (newest.content ?? []).filter((p) => p.type === "text" && typeof p.text === "string").map((p) => p.text).join("");
+  /** Concatenated text of the `text` parts of one message, or null if none. */
+  static textOf(parts) {
+    const text = parts.filter((p) => p.type === "text" && typeof p.text === "string").map((p) => p.text).join("");
     return text || null;
   }
   async fetchMessages(sessionID) {
-    const out = await this.call("GET", `/api/session/${sessionID}/message`);
-    return out.data ?? [];
+    const out = await this.call("GET", `/session/${sessionID}/message`);
+    if (!Array.isArray(out))
+      return [];
+    return out.map((m) => ({
+      id: m.info?.id,
+      type: m.info?.role,
+      time: m.info?.time,
+      finish: m.info?.finish,
+      content: m.parts ?? []
+    }));
   }
   async listSessions() {
-    const out = await this.call("GET", "/api/session");
-    return (out.data ?? []).filter((s) => typeof s.id === "string").map((s) => ({ id: s.id, title: s.title, updated: s.time?.updated, created: s.time?.created }));
+    const out = await this.call("GET", "/session");
+    return (Array.isArray(out) ? out : []).filter((s) => typeof s.id === "string").map((s) => ({ id: s.id, title: s.title, updated: s.time?.updated, created: s.time?.created }));
   }
   async getStructuredMessages(sessionID) {
     return this.fetchMessages(sessionID);
   }
-  /** The message with the greatest `time.created` (opencode returns newest-first, but don't rely on order). */
-  static newestByCreated(messages) {
-    let newest;
-    let newestT = Number.NEGATIVE_INFINITY;
-    for (const m of messages) {
-      const t = m.time?.created ?? 0;
-      if (t >= newestT) {
-        newestT = t;
-        newest = m;
-      }
-    }
-    return newest;
-  }
 };
 
 // ../../packages/core/dist/provisioning/frameworks/opencode/opencode-transcript.js
@@ -1025,123 +1000,13 @@ function buildPart(p, redact, maxPartChars) {
   return { kind: "other" };
 }
 
-// ../../packages/core/dist/provisioning/frameworks/opencode/opencode-run.js
-var OpencodeRunError = class extends Error {
-  admitted;
-  constructor(message, admitted, options) {
-    super(message, options);
-    this.name = "OpencodeRunError";
-    this.admitted = admitted;
-  }
-};
-function runCrossedAdmission(stdout) {
-  for (const line2 of stdout.split("\n")) {
-    const trimmed = line2.trim();
-    if (!trimmed)
-      continue;
-    try {
-      JSON.parse(trimmed);
-      return true;
-    } catch {
-    }
-  }
-  return false;
-}
-function buildOpencodeRunArgs(params, opts = {}) {
-  const args = [
-    "run",
-    "--attach",
-    params.serveUrl,
-    "--dir",
-    params.projectDir,
-    "--session",
-    params.sessionID,
-    "--format",
-    "json"
-  ];
-  if (opts.includePasswordArg && params.password) {
-    args.push("-p", params.password);
-  }
-  if (params.model) {
-    args.push("--model", `${params.model.providerID}/${params.model.id}`);
-  }
-  if (params.agent) {
-    args.push("--agent", params.agent);
-  }
-  args.push(params.text);
-  return args;
-}
-function parseOpencodeRunReply(stdout) {
-  const parts = [];
-  for (const line2 of stdout.split("\n")) {
-    const trimmed = line2.trim();
-    if (!trimmed)
-      continue;
-    let evt;
-    try {
-      evt = JSON.parse(trimmed);
-    } catch {
-      continue;
-    }
-    const e = evt;
-    if (e?.type === "text" && e.part && e.part.type === "text" && typeof e.part.text === "string") {
-      parts.push(e.part.text);
-    }
-  }
-  const reply = parts.join("").trim();
-  return reply.length > 0 ? reply : null;
-}
-function parseOpencodeRunError(stdout) {
-  for (const line2 of stdout.split("\n")) {
-    const trimmed = line2.trim();
-    if (!trimmed)
-      continue;
-    let evt;
-    try {
-      evt = JSON.parse(trimmed);
-    } catch {
-      continue;
-    }
-    const e = evt;
-    if (e?.type === "error") {
-      const msg = e.error?.data?.message;
-      if (typeof msg === "string" && msg.length > 0)
-        return msg;
-      const name = e.error?.name;
-      if (typeof name === "string" && name.length > 0)
-        return name;
-      return "opencode run reported an error event";
-    }
-  }
-  return null;
-}
-function parseRunToolCalls(stdout) {
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  for (const line2 of stdout.split("\n")) {
-    const trimmed = line2.trim();
-    if (!trimmed)
-      continue;
-    let evt;
-    try {
-      evt = JSON.parse(trimmed);
-    } catch {
-      continue;
-    }
-    const e = evt;
-    if (e.part && e.part.type === "tool" && typeof e.part.tool === "string") {
-      if (!seen.has(e.part.tool)) {
-        seen.add(e.part.tool);
-        out.push(e.part.tool);
-      }
-    }
-  }
-  return out;
-}
-
 // ../../packages/core/dist/provisioning/frameworks/opencode/inbound-bridge.js
 var InboundError = class extends Error {
-  /** True once `prompt()` has durably admitted the turn. Retry is unsafe. */
+  /**
+   * False ONLY when the turn provably never reached the agent (createSession
+   * failed). A failure once the message is in flight is reported as `true`: the
+   * turn probably ran, so retrying it would duplicate it.
+   */
   admitted;
   sessionID;
   cause;
@@ -1171,24 +1036,64 @@ var OpencodeInboundBridge = class {
   client;
   gate;
   sessionDefaults;
-  delivery;
   awaitReply;
-  runTurn;
   /** conversationKey → sessionID (one session per thread/DM). */
   sessions = /* @__PURE__ */ new Map();
   /** conversationKey → in-flight createSession, so concurrent inbound for the
    *  same conversation share one session instead of racing to create two. */
   inFlight = /* @__PURE__ */ new Map();
+  /**
+   * conversationKey → tail of the turn chain for that conversation. Turns on one
+   * conversation run STRICTLY ONE AT A TIME.
+   *
+   * This is load-bearing for correctness, not a politeness measure (ENG-9096).
+   * opencode queues overlapping turns correctly - the transcript comes out in
+   * order and nothing is lost - but every concurrent `POST /session/{id}/message`
+   * returns the SAME assistant message: the newest one, not the caller's own.
+   * Measured: two overlapping turns, and the POST that submitted the FIRST
+   * message received the reply to the SECOND, while the first turn's reply was
+   * returned to nobody. On a channel that means one person being handed the
+   * answer to someone else's question in the same thread.
+   *
+   * The response gives no way to detect this after the fact: it carries
+   * `info.parentID` (the user message it answers) but the caller is never told
+   * its own user-message id, so there is nothing to compare against. Serialising
+   * is therefore the fix, not a mitigation - the alternative is undetectable.
+   *
+   * `opencode run --attach` did not need this: each spawn streamed only its own
+   * turn, so correlation came free. This is the one property the subprocess had
+   * that the HTTP path does not.
+   */
+  turnChains = /* @__PURE__ */ new Map();
   constructor(opts) {
     this.client = opts.client;
     this.gate = opts.gate ?? (() => ({ admit: true }));
     this.sessionDefaults = opts.sessionDefaults;
-    this.delivery = opts.delivery ?? "queue";
     this.awaitReply = opts.awaitReply ?? true;
-    this.runTurn = opts.runTurn;
-    if (this.runTurn && this.delivery === "steer") {
-      console.warn("[opencode-bridge] delivery:'steer' is ignored when runTurn is set - opencode run cannot steer an in-flight turn; falling back to queue semantics.");
-    }
+  }
+  /**
+   * Run `fn` only once every previously-queued turn for `conversationKey` has
+   * settled.
+   *
+   * `then(fn, fn)` — the SAME handler on both arms — is what keeps the chain
+   * alive: a predecessor that rejected still lets the next turn run, so one
+   * failed turn cannot strand every later message in that conversation. The
+   * promise returned to the caller is that same one, so the caller still sees
+   * the real failure.
+   *
+   * There was a second, redundant guard here (storing a tail wrapped to always
+   * resolve). It was removed deliberately. With both present, sabotaging EITHER
+   * one alone still passed every test, because the other silently covered it —
+   * so neither was actually protected by anything. One mechanism, one test that
+   * fails when it goes. Storing the rejecting promise raises no unhandled
+   * rejection, because it is the same object the caller already handled; that
+   * was measured, not assumed.
+   */
+  serialize(conversationKey, fn) {
+    const prior = this.turnChains.get(conversationKey) ?? Promise.resolve();
+    const next = prior.then(fn, fn);
+    this.turnChains.set(conversationKey, next);
+    return next;
   }
   /** Resolve (creating on first use) the opencode session for a conversation. */
   async ensureSession(conversationKey) {
@@ -1238,55 +1143,19 @@ var OpencodeInboundBridge = class {
         cause: err
       });
     }
-    if (this.runTurn) {
-      const runner = this.runTurn;
-      const framed = frameInboundPrompt(msg);
-      const model = this.sessionDefaults?.model ?? null;
-      if (!awaitReply) {
-        void runner({ sessionID, text: framed, model }).catch((err) => {
-          console.error(`[opencode-bridge] fire-and-forget run turn failed for session ${sessionID}:`, err instanceof Error ? err.name : typeof err);
-        });
-        return { status: "admitted", sessionID, admittedSeq: 0 };
-      }
-      try {
-        const { admittedSeq: seq, reply } = await runner({ sessionID, text: framed, model });
-        return { status: "replied", sessionID, admittedSeq: seq, reply };
-      } catch (err) {
-        const admitted = err instanceof OpencodeRunError ? err.admitted : false;
-        throw new InboundError(admitted ? "opencode run turn failed after admission (not retried; avoids duplicate)" : "opencode run turn failed before admission (treated as retryable)", { admitted, sessionID, cause: err });
-      }
-    }
-    let admittedSeq;
-    try {
-      ({ admittedSeq } = await this.client.prompt({
-        sessionID,
-        text: frameInboundPrompt(msg),
-        delivery: this.delivery,
-        // ENG-7931: the serve does not apply the config default model to
-        // API-created sessions, so run each turn on the explicitly-resolved
-        // model (same one used for session-create).
-        model: this.sessionDefaults?.model
-      }));
-    } catch (err) {
-      throw new InboundError("opencode prompt failed (admit ambiguous, treated as retryable)", {
-        admitted: false,
-        sessionID,
-        cause: err
-      });
-    }
+    const framed = frameInboundPrompt(msg);
+    const model = this.sessionDefaults?.model;
     if (!awaitReply) {
-      return { status: "admitted", sessionID, admittedSeq };
+      void this.serialize(msg.conversationKey, () => this.client.sendMessage({ sessionID, text: framed, model })).catch((err) => {
+        console.error(`[opencode-bridge] fire-and-forget turn failed for session ${sessionID}:`, err instanceof Error ? err.name : typeof err);
+      });
+      return { status: "admitted", sessionID };
     }
     try {
-      await this.client.waitIdle(sessionID);
-      const reply = await this.client.latestAssistantText(sessionID);
-      return { status: "replied", sessionID, admittedSeq, reply };
+      const { reply } = await this.serialize(msg.conversationKey, () => this.client.sendMessage({ sessionID, text: framed, model }));
+      return { status: "replied", sessionID, reply };
     } catch (err) {
-      throw new InboundError("opencode reply read failed AFTER a durable admit (do not retry)", {
-        admitted: true,
-        sessionID,
-        cause: err
-      });
+      throw new InboundError("opencode turn failed; the turn may have run to completion regardless, so it is not redelivered", { admitted: true, sessionID, cause: err });
     }
   }
 };
@@ -2385,76 +2254,22 @@ function noteOpencodeTurnOutcome(codeName, outcome, startedOn) {
 function getBridge(codeName, port, password) {
   const cached = bridges.get(codeName);
   if (cached && cached.port === port && cached.password === password) return cached.bridge;
-  const client = new HttpOpencodeClient({ baseUrl: baseUrlFor(port), password });
+  const client = new HttpOpencodeClient({
+    baseUrl: baseUrlFor(port),
+    password,
+    // A turn now runs inside one request, so the request timeout IS the turn
+    // budget (see OPENCODE_RUN_TIMEOUT_MS). Leaving the client's 120s default
+    // would quietly shorten it.
+    requestTimeoutMs: OPENCODE_RUN_TIMEOUT_MS
+  });
   const model = sessions.get(codeName)?.model ?? null;
-  const projectDir = sessions.get(codeName)?.projectDir ?? null;
   const bridge = new OpencodeInboundBridge({
     client,
-    sessionDefaults: model ? { model } : void 0,
-    runTurn: projectDir ? makeRunTurn(codeName, port, password, projectDir) : void 0
+    sessionDefaults: model ? { model } : void 0
   });
   bridges.set(codeName, { port, password, bridge });
   return bridge;
 }
-function makeRunTurn(codeName, port, password, projectDir) {
-  return ({ sessionID, text, model }) => new Promise((resolve, reject) => {
-    const args = buildOpencodeRunArgs({
-      bin: OPENCODE_BIN,
-      serveUrl: baseUrlFor(port),
-      projectDir,
-      password,
-      sessionID,
-      text,
-      model: model ?? null
-    });
-    const child = spawn(OPENCODE_BIN, args, {
-      cwd: projectDir,
-      // Password off argv (would show in `ps`); it rides the env instead.
-      env: { ...process.env, OPENCODE_SERVER_PASSWORD: password },
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    let stdout = "";
-    let stderr = "";
-    let settled = false;
-    const finish = (fn) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      fn();
-    };
-    const fail = (message, cause) => reject(new OpencodeRunError(message, runCrossedAdmission(stdout), { cause }));
-    const timer = setTimeout(() => {
-      finish(() => {
-        try {
-          child.kill("SIGKILL");
-        } catch {
-        }
-        fail(`opencode run timed out after ${OPENCODE_RUN_TIMEOUT_MS}ms`);
-      });
-    }, OPENCODE_RUN_TIMEOUT_MS);
-    child.stdout.on("data", (d) => {
-      stdout += d.toString();
-    });
-    child.stderr.on("data", (d) => {
-      stderr += d.toString();
-    });
-    child.on("error", (err) => finish(() => fail(`opencode run spawn failed: ${err instanceof Error ? err.message : err}`, err)));
-    child.on("close", (code) => finish(() => {
-      const runError = parseOpencodeRunError(stdout);
-      if (code !== 0 || runError) {
-        const tail = runError ?? (stderr.trim() || stdout.trim()).slice(-500);
-        fail(`opencode run failed (exit ${code ?? "null"}): ${tail}`);
-        return;
-      }
-      const reply = parseOpencodeRunReply(stdout);
-      const tools = parseRunToolCalls(stdout);
-      if (tools.length > 0) {
-        console.error(`[opencode-run] ${codeName} tools: ${tools.join(", ")}`);
-      }
-      resolve({ admittedSeq: 0, reply });
-    }));
-  });
-}
 function stopOpencodeSession(codeName, log2) {
   const tmuxSession = opencodeTmuxSession(codeName);
   try {
@@ -4352,4 +4167,4 @@ export {
   stopAllSessionsAndWait,
   getProjectDir
 };
-//# sourceMappingURL=chunk-QSPSXG4K.js.map
+//# sourceMappingURL=chunk-UIB2SMFE.js.map