@lawaty/lacode 0.2.2 → 0.4.0

package/README.md

@@ -284,6 +284,7 @@ option is optional:
 | `modelsFile` | — | An explicit slot file; short-circuits the chain below. |
 | `reapMs` | `30000` | Hang-reaper interval. |
 | `selfUpdate` | `true` | Check for a newer release at most once per ~6h and install it in the background; it applies on the next opencode start. `false` — or `LACODE_NO_SELFUPDATE=1` — turns the check off. |
+| `sound` | `true` | Play a short tone with each notification, one per outcome, so you can tell a finished session from a question or a permission prompt without reading the popup. It is opt-out: `false` — or `LACODE_SOUND=0` (`false`, `off`, `no` work too, and beat the option) — turns the sound off, and anything else, a typo included, leaves it on. |
 | `omniroute` | — | Optional [OmniRoute](#configuring-omniroute) gateway integration. Absent or `{ enabled: false }` changes nothing. |
 
 ### Staying up to date
@@ -336,6 +337,9 @@ as an opencode provider for you. It is **off by default**: if you do not set
    disabled for that run, and the integration is per-run.
 2. Add the plugin block to your opencode config:
    `["@lawaty/lacode", { "omniroute": { "enabled": true, "apiKey": "<your omniroute key>", "combo": "auto", "models": [] } }]`
+   `auto` is the zero-config default, but on a free tier it often resolves to a
+   slow chain. [A tested fast combo](#a-tested-fast-combo-free-mix) below is
+   ordered for latency and is worth applying on a new client.
 3. Optionally, to route pooled work through it, make `omniroute/auto 3` the
    **first** line of `~/.config/lacode/pool.txt`. `pool.txt` is optional user
    config; the bundled default preset does **not** include OmniRoute.
@@ -425,6 +429,98 @@ the only thing that changes when the gateway is down is that `omniroute/<id>`
 fails; every other slot keeps working. See
 [docs/USER-STORIES.md](docs/USER-STORIES.md) US-28.
 
+### A tested fast combo: `free-mix`
+
+`combo: "auto"` is the zero-configuration default, but `auto` inherits whatever
+the gateway chooses, and on a busy free tier that is frequently the slowest
+chain available. The combo below was **measured** against a live free-tier
+gateway and is ordered for latency rather than for breadth. Apply it during the
+"Setting it up on a client machine" steps above and pooled work is usable
+straight away, instead of starting from a gateway that queues for half a minute
+per call.
+
+```jsonc
+{
+  "name": "free-mix",
+  // Order decides. Do NOT use "weighted" here — weights let the gateway
+  // re-shuffle a model that is returning 429 into first position again.
+  "strategy": "priority",
+  "models": [
+    { "model": "gemini/gemini-3.1-flash-lite",                      "providerId": "gemini" },
+    { "model": "gemini/gemini-3.8-flash",                           "providerId": "gemini" },
+    { "model": "gemini/gemini-3.7-flash",                           "providerId": "gemini" },
+    { "model": "gemini/gemini-3-flash-preview",                     "providerId": "gemini" },
+    { "model": "openrouter/nvidia/nemotron-3-super-120b-a12b:free",  "providerId": "openrouter" },
+    { "model": "openrouter/nvidia/nemotron-3-ultra-550b-a55b:free",  "providerId": "openrouter" },
+    { "model": "openrouter/nvidia/nemotron-3.5-lightning:free",     "providerId": "openrouter" },
+    { "model": "openrouter/cohere/north-mini-code:free",            "providerId": "openrouter" },
+    { "model": "openrouter/poolside/laguna-s-2.1:free",             "providerId": "openrouter" },
+    { "model": "openrouter/dots-studio/dots-3-note-preview:free",   "providerId": "openrouter" }
+  ]
+}
+```
+
+Why this order, from 859 calls over a single day against that gateway:
+
+| Model | Observed behaviour | Position |
+| --- | --- | --- |
+| `gemini/gemini-3.1-flash-lite` | **165/172 succeeded (96%)**, ~4.5s median | **first** |
+| `gemini-3.8-flash` / `3.7-flash` / `3-flash-preview` | succeed intermittently, but **burn exactly 30.0s** on a `503` queue-budget timeout when they do not | next |
+| `openrouter/*:free` | **~90% `429`**, but fails *fast* (~1.8s) and occasionally succeeds | last, as a cheap final fallback |
+| `gemini-2.5-flash`, `gemini-2.5-flash-lite` | **`404` on every attempt** — dead ids | **omitted entirely** |
+
+The ordering matters because a combo pays for *every* step it walks past. Put the
+96%-success model first and the common case is a single hop; the 30s models sit
+behind it where they cost nothing, and the 429s sit last where they give up in
+under two seconds.
+
+Measured on the same gateway, same day, `max_tokens: 10`:
+
+| | Before | After |
+| --- | --- | --- |
+| `free-mix` response | 42.7s / 41.8s / 34.7s | 4.1s / 3.1s / 3.2s / 4.0s / 3.2s |
+| Median | **~41.8s** | **~3.2s** |
+| Provider time burned on calls >25s | **56.9 of 102.4 min (56%)** | — |
+
+Before the change, the real call sequence was a `429` after 2.7s, then a `503`
+after 30.0s, then the actual work in 5.7s — roughly **33 seconds of dead time in
+front of every successful request**, and a p90 of 100s when three 30s steps
+chained.
+
+These free-tier endpoints change availability constantly, so treat the ordering
+as a **starting point to re-measure, not a permanent truth**. Re-check it with
+OmniRoute's own call logs before assuming it still holds:
+
+```bash
+# one timed request through the gateway
+curl -o /dev/null -w '%{http_code} %{time_starttransfer}s\n' \
+  -X POST http://localhost:20128/v1/chat/completions \
+  -H "Authorization: Bearer $OMNIROUTE_API_KEY" -H 'Content-Type: application/json' \
+  -d '{"model":"free-mix","messages":[{"role":"user","content":"Say OK"}],"max_tokens":10}'
+
+# per-model status + duration, straight from OmniRoute's logs
+python3 - <<'PY'
+import json, glob, collections
+d = "/home/<user>/.omniroute/call_logs/<YYYY-MM-DD>"
+g = collections.defaultdict(collections.Counter)
+for f in glob.glob(d + "/*.json"):
+    try: s = json.load(open(f))["summary"]
+    except Exception: continue
+    g[s.get("comboStepId")][s.get("status")] += 1
+for k, v in sorted(g.items(), key=lambda x: str(x[0])):
+    print(f"{str(k)[:44]:44} {dict(v)}")
+PY
+```
+
+Apply it with the bundled CLI (`PUT /api/combos/<id>` updates in place, so the
+combo is never briefly missing):
+
+```bash
+omniroute api combos get-api-combos-id- --id <combo-id> --json > free-mix.json
+# edit name/strategy/models in free-mix.json, then:
+omniroute api combos put-api-combos-id- --id <combo-id> --body @free-mix.json
+```
+
 **A note on mid-session switching.** opencode 1.18.34 exposes no hook to change
 an agent's main model mid-request, so LaCode cannot swap models inside a running
 session; use an OmniRoute `combo` (or `auto`) if you want per-request fallback.
@@ -569,6 +665,28 @@ published, because none has been independently measured. The mechanism, the
 permission rule that makes one writer possible, and what the log lines mean are
 in [docs/CONTEXT.md](docs/CONTEXT.md).
 
+## Managerial directions
+
+You can optionally add `manager.md` to `.opencode/context/`. This file is owned
+by you alone and is never written, edited, pruned, or promoted by any agent. It
+outranks the five generated files on focus and settled decisions, but it is
+secondary to the source code: if the code disagrees, the code wins and the
+conflict is reported back to you.
+
+The file is per-clone, not committed, and entirely optional: if it is missing,
+agents behave exactly as before. When present, it should contain these three
+sections:
+
+- `## Stage`: A snapshot of your current work-in-progress. Rewrite this section
+  rather than appending to it to keep it concise. If this file passes roughly 150
+  lines, run `/context-review`.
+- `## Confirmed`: Facts and decisions you have personally ratified. Treat these
+  as settled, but not as permission to skip reading the code.
+- `## Instructions`: Standing managerial directions for all agents.
+
+No agent may write this file at all: the context agent's edit permission denies
+`manager.md` explicitly, so ratification can only ever come from your hand.
+
 ## Cost
 
 The mechanism is specific and small: bulk exploration, implementation and
@@ -645,7 +763,7 @@ open are in [docs/TUNNEL.md](docs/TUNNEL.md).
 
 ## User stories
 
-Twenty-three stories across seven epics, each written as a behavioural contract
+Twenty-nine stories across seven epics, each written as a behavioural contract
 with acceptance criteria a test can assert mechanically — the pains behind them,
 the Given/When/Then criteria, and the story-to-test mapping are in
 [docs/USER-STORIES.md](docs/USER-STORIES.md).

package/dist/agents.js

@@ -43,6 +43,7 @@ var DEFAULT_PRESET = join2(PRESETS_DIR, "free-tier.json");
 var USER_CONFIG_DIR = join2(homedir(), ".config", "lacode");
 var USER_MODELS_PATH = join2(USER_CONFIG_DIR, "pool.json");
 var USER_MODELS_TXT = join2(USER_CONFIG_DIR, "pool.txt");
+var CHILD_MEMORY_MS = 30 * 6e4;
 
 // src/agents.ts
 var POOLED_BASES = ["explore", "implement", "context"];

package/dist/index.js

@@ -243,6 +243,7 @@ function state(opts = {}) {
       cooling: /* @__PURE__ */ new Map(),
       strikes: /* @__PURE__ */ new Map(),
       activity: /* @__PURE__ */ new Map(),
+      children: /* @__PURE__ */ new Map(),
       reaped: 0,
       reaping: false,
       lastSweep: 0,
@@ -284,7 +285,7 @@ function init(s, onWarn) {
 }
 function pruneOwn(s) {
   const now = Date.now();
-  for (const [key, claim] of s.own) if (now - claim.t > CLAIM_TTL_MS) s.own.delete(key);
+  for (const [key, claim] of s.own) if (now - (claim.hb ?? claim.t) > CLAIM_TTL_MS) s.own.delete(key);
 }
 function publish(s) {
   if (!s.dirReady) return;
@@ -349,7 +350,7 @@ function readSiblings(s) {
     try {
       const parsed = JSON.parse(readFileSync2(path4, "utf8"));
       const claims = Object.values(parsed).filter(
-        (c) => c && typeof c.v === "string" && typeof c.m === "string" && now - c.t <= CLAIM_TTL_MS
+        (c) => c && typeof c.v === "string" && typeof c.m === "string" && now - (c.hb ?? c.t) <= CLAIM_TTL_MS
       );
       siblings.push({ id: match[1], claims });
     } catch {
@@ -463,26 +464,72 @@ function snapshot(s) {
 }
 var loadOf = (counts, model) => counts.get(model) ?? 0;
 var underCeiling = (slot, counts) => loadOf(counts, slot.model) < slot.weight;
-function pickSlot(s, snap) {
+function roundRobinSequence(slots) {
+  const seq = [];
+  for (const slot of slots) for (let turn = 0; turn < slot.weight; turn++) seq.push(slot.index);
+  return seq;
+}
+var CURSOR_FILE = "cursor.json";
+function readCursor(s) {
+  try {
+    const parsed = JSON.parse(readFileSync2(join2(s.dir, CURSOR_FILE), "utf8"));
+    if (typeof parsed.seq === "number" && Number.isInteger(parsed.seq) && parsed.seq >= 0) return parsed.seq;
+  } catch {
+  }
+  return 0;
+}
+function writeCursor(s, seq) {
+  if (!s.dirReady) return;
+  const path4 = join2(s.dir, CURSOR_FILE);
+  try {
+    writeFileSync(`${path4}.tmp`, JSON.stringify({ seq }));
+    renameSync(`${path4}.tmp`, path4);
+  } catch {
+  }
+}
+function pickSlot(s, snap, options) {
+  const advance = options?.advance !== false;
   const slots = s.slots.length > 0 ? s.slots : FALLBACK_SLOTS;
+  const seq = roundRobinSequence(slots);
+  if (seq.length > 0) {
+    const byIndex = new Map(slots.map((slot) => [slot.index, slot]));
+    const start = readCursor(s) % seq.length;
+    for (let step = 0; step < seq.length; step++) {
+      const at = (start + step) % seq.length;
+      const slot = byIndex.get(seq[at]);
+      if (slot && isAvailable(s, slot.model, snap.cooling) && underCeiling(slot, snap.counts)) {
+        if (advance) writeCursor(s, at + 1);
+        return slot;
+      }
+    }
+  }
   const usable = slots.filter((slot) => isAvailable(s, slot.model, snap.cooling));
   const pool = usable.length > 0 ? usable : slots;
-  const open = pool.filter((slot) => underCeiling(slot, snap.counts));
-  if (open.length > 0) return open.reduce((best, slot) => slot.weight > best.weight ? slot : best, open[0]);
   return pool.reduce((best, slot) => loadOf(snap.counts, slot.model) < loadOf(snap.counts, best.model) ? slot : best, pool[0]);
 }
 function agentFor(base, slot) {
   return `${base}-${slot}`;
 }
 function acquire(s, base, slot, ownerSession, key, target) {
-  s.own.set(key, { v: base, k: slot.index, m: slot.model, t: Date.now(), s: ownerSession, g: target });
-  if (target) s.activity.set(target, Date.now());
+  const now = Date.now();
+  s.own.set(key, { v: base, k: slot.index, m: slot.model, t: now, hb: now, s: ownerSession, g: target });
+  if (target) s.activity.set(target, now);
   publish(s);
 }
 function release(s, key) {
   if (s.own.delete(key)) publish(s);
 }
+var CHILD_RING = 8;
+var CHILD_MEMORY_MS = 30 * 6e4;
+var CHILD_SLACK_MS = 1e3;
+function noteChild(s, parentID, childID) {
+  const ring = s.children.get(parentID) ?? [];
+  ring.push({ id: childID, t: Date.now() });
+  while (ring.length > CHILD_RING) ring.shift();
+  s.children.set(parentID, ring);
+}
 function bindChild(s, parentID, childID) {
+  noteChild(s, parentID, childID);
   const candidates = [...s.own.entries()].filter(([, c]) => c.s === parentID && !c.g).sort((a, b) => a[1].t - b[1].t);
   if (candidates.length === 0) return false;
   candidates[0][1].g = childID;
@@ -490,8 +537,29 @@ function bindChild(s, parentID, childID) {
   publish(s);
   return true;
 }
+function backfillChild(s, claim) {
+  if (claim.g || !claim.s) return false;
+  const now = Date.now();
+  const taken = new Set([...s.own.values()].map((c) => c.g).filter((g) => typeof g === "string"));
+  const ring = s.children.get(claim.s) ?? [];
+  for (let i = ring.length - 1; i >= 0; i--) {
+    const child = ring[i];
+    if (now - child.t > CHILD_MEMORY_MS) break;
+    if (child.t < claim.t - CHILD_SLACK_MS) continue;
+    if (taken.has(child.id)) continue;
+    claim.g = child.id;
+    s.activity.set(child.id, now);
+    publish(s);
+    return true;
+  }
+  return false;
+}
 function noteActivity(s, sessionID) {
-  s.activity.set(sessionID, Date.now());
+  const now = Date.now();
+  s.activity.set(sessionID, now);
+  let touched = false;
+  for (const claim of s.own.values()) if (claim.g === sessionID) claim.hb = now, touched = true;
+  if (touched) publish(s);
 }
 function idleFor(s, claim, now) {
   const target = claim.g;
@@ -1342,6 +1410,7 @@ import { tool } from "@opencode-ai/plugin";
 var SERVICE = "agent-pool";
 var REAP_INTERVAL_MS = 3e4;
 var HANG_FALLBACK_MS = 10 * 60 * 1e3;
+var ABORT_TIMEOUT_MS = 1e4;
 var agentPoolHooks = (async ({ client, serverUrl }, options) => {
   const opts = options ?? {};
   const s = state(opts);
@@ -1355,14 +1424,28 @@ var agentPoolHooks = (async ({ client, serverUrl }, options) => {
   };
   init(s, (m) => void warnOnce(m));
   const abortSession = async (sessionID) => {
-    if (!serverUrl) return false;
+    if (!serverUrl) return { ok: false, why: "no serverUrl: this process has no HTTP server to abort through" };
     try {
-      await fetch(new URL(`/session/${sessionID}/abort`, serverUrl).toString(), { method: "POST" });
-      return true;
-    } catch {
-      return false;
+      const res = await fetch(new URL(`/session/${sessionID}/abort`, serverUrl).toString(), {
+        method: "POST",
+        signal: AbortSignal.timeout(ABORT_TIMEOUT_MS)
+      });
+      if (!res.ok) return { ok: false, why: `gateway answered HTTP ${res.status}` };
+      const body = (await res.text()).trim();
+      if (body === "false") return { ok: false, why: "server reported the session was not aborted" };
+      return { ok: true, why: "" };
+    } catch (error) {
+      return { ok: false, why: String(error) };
     }
   };
+  const MAX_ABORT_ATTEMPTS = 3;
+  const coolForHang = async (claim, log2) => {
+    const now = Date.now();
+    const prior = s.cooling.get(claim.m);
+    if (prior && prior.until > now) return;
+    const strike = recordStrike(s, claim.m, "hang", HANG_FALLBACK_MS);
+    if (strike) await log2("warn", `cooling ${claim.m} for ${Math.round((strike.until - now) / 1e3)}s (hang)`);
+  };
   const reapStuck = async () => {
     if (s.reaping) return;
     s.reaping = true;
@@ -1370,21 +1453,53 @@ var agentPoolHooks = (async ({ client, serverUrl }, options) => {
     try {
       const stuck = findStuck(s);
       if (stuck.length === 0) return;
-      releaseStuck(s, stuck.map((x) => x.key));
-      for (const { claim } of stuck) {
-        const killed = claim.g ? await abortSession(claim.g) : false;
+      const released = [];
+      for (const { key, claim } of stuck) {
+        if (!claim.g) backfillChild(s, claim);
+        const idle = idleFor(s, claim, Date.now());
+        const since = Number.isFinite(idle) ? `${Math.round(idle / 1e3)}s of silence` : "no child session ever bound";
+        const age = Math.round((Date.now() - claim.t) / 1e3);
+        if (claim.g) {
+          const kill = await abortSession(claim.g);
+          if (kill.ok) {
+            released.push(key);
+            s.reaped++;
+            await log(
+              "warn",
+              `hung ${claim.v} on ${claim.m} after ${age}s with ${since}; aborted session ${claim.g}`,
+              { base: claim.v, model: claim.m, slot: claim.k, session: claim.g, aborted: true }
+            );
+            await coolForHang(claim, log);
+            continue;
+          }
+          claim.n = (claim.n ?? 0) + 1;
+          if (claim.n < MAX_ABORT_ATTEMPTS) {
+            await log(
+              "warn",
+              `could not abort hung ${claim.v} session ${claim.g} on ${claim.m} (${kill.why}); claim held, retry ${claim.n}/${MAX_ABORT_ATTEMPTS}`,
+              { base: claim.v, model: claim.m, slot: claim.k, session: claim.g, aborted: false }
+            );
+            continue;
+          }
+          released.push(key);
+          s.reaped++;
+          await log(
+            "error",
+            `GIVING UP on hung ${claim.v} session ${claim.g} on ${claim.m}: ${kill.why} after ${claim.n} attempts. The claim is released but the session is still running and must be killed by hand.`,
+            { base: claim.v, model: claim.m, slot: claim.k, session: claim.g, aborted: false }
+          );
+          continue;
+        }
+        released.push(key);
         s.reaped++;
-        await log(
-          "warn",
-          `hung ${claim.v} on ${claim.m} after ${Math.round((Date.now() - claim.t) / 1e3)}s with ${Math.round(idleFor(s, claim, Date.now()) / 1e3)}s of silence; ${killed ? `aborted session ${claim.g}` : "no session to abort"}`,
-          { base: claim.v, model: claim.m, slot: claim.k, session: claim.g, aborted: killed }
-        );
-        const now = Date.now();
-        const prior = s.cooling.get(claim.m);
-        if (prior && prior.until > now) continue;
-        const strike = recordStrike(s, claim.m, "hang", HANG_FALLBACK_MS);
-        if (strike) await log("warn", `cooling ${claim.m} for ${Math.round((strike.until - now) / 1e3)}s (hang)`);
+        await log("warn", `released unbound ${claim.v} claim on ${claim.m} after ${age}s (${since}); model not cooled`, {
+          base: claim.v,
+          model: claim.m,
+          slot: claim.k,
+          aborted: false
+        });
       }
+      if (released.length > 0) releaseStuck(s, released);
     } catch (error) {
       await log("error", `reaper failed: ${String(error)}`);
     } finally {
@@ -1549,7 +1664,7 @@ var agentPoolHooks = (async ({ client, serverUrl }, options) => {
           };
           for (const claim of snap.own.values()) add(claim.m, claim.v);
           for (const sibling of snap.siblings) for (const claim of sibling.claims) add(claim.m, claim.v);
-          const next = pickSlot(s, snap);
+          const next = pickSlot(s, snap, { advance: false });
           const line = (slot) => {
             const entry = byModel.get(slot.model);
             const users = entry && entry.bases.size > 0 ? [...entry.bases].map(([b, n]) => `${b}x${n}`).join(" ") : "idle";
@@ -1571,7 +1686,7 @@ var agentPoolHooks = (async ({ client, serverUrl }, options) => {
             title: `agent-pool: ${total} task(s) in flight, ${coolingNow.length} model(s) cooling`,
             output: [
               `shared pool over ${slots.length} model(s) from ${s.origin}; bases: ${BASES.join(", ")}
-priority is weight: the heaviest slot under its ceiling takes the next spawn (FULL = at ceiling, used only when every slot is)`,
+round robin in slot order, each slot taking as many turns as its weight says, so no slot is starved while another drains (FULL = at ceiling, used only when every slot is)`,
               ...slots.map(line),
               "",
               "by process:",
@@ -1905,15 +2020,16 @@ var INTERNAL_TITLE_PREFIXES = [
   // it would announce the cartographer's own bookkeeping as a finished task.
   "context (auto"
 ];
+var NOTIFY_OUTCOMES = ["done", "question", "permission", "error"];
 var notifyMessage = (outcome, detail) => {
   if (outcome === "error") return detail ? `Failed \u2014 ${detail}` : "Failed";
   if (outcome === "question") return detail ? `Awaiting your response \u2014 ${detail}` : "Awaiting your response";
   if (outcome === "permission") return detail ? `Awaiting your permission \u2014 ${detail}` : "Awaiting your permission";
   return "Task finished, waiting for your review";
 };
-var helperArgv = (helper, title, message, urgency, icon) => {
+var helperArgv = (helper, title, message, urgency, icon, sound) => {
   const name = helper.split(/[\\/]/).pop() ?? "";
-  return name === "lacode" || name === "lacode.js" ? ["notify", title, message, urgency, icon] : [title, message, urgency, icon];
+  return name === "lacode" || name === "lacode.js" ? ["notify", title, message, urgency, icon, sound] : [title, message, urgency, icon, sound];
 };
 var safeStringify = (value) => {
   try {
@@ -2068,6 +2184,8 @@ var Notifier = class {
 // src/plugins/notify.ts
 var SERVICE3 = "notify";
 var COOLDOWN_MS2 = 5e3;
+var SOUND_ENV = "LACODE_SOUND";
+var SOUND_OFF_VALUES = ["0", "false", "off", "no"];
 var findHelper = () => {
   const home = process.env.HOME ?? "";
   const candidates = [
@@ -2081,7 +2199,10 @@ var findHelper = () => {
   for (const candidate of candidates) if (existsSync3(candidate)) return candidate;
   return void 0;
 };
-var notifyHooks = (async ({ client, directory }, _options, deps = {}) => {
+var notifyHooks = (async ({ client, directory }, options, deps = {}) => {
+  const opts = options ?? {};
+  const soundEnv = (process.env[SOUND_ENV] ?? "").trim().toLowerCase();
+  const soundOn = !SOUND_OFF_VALUES.includes(soundEnv) && opts.sound !== false;
   const notifier = new Notifier(COOLDOWN_MS2);
   const active = /* @__PURE__ */ new Set();
   const titles = /* @__PURE__ */ new Map();
@@ -2094,7 +2215,7 @@ var notifyHooks = (async ({ client, directory }, _options, deps = {}) => {
     const info = await client.session.get({ path: { id: sessionID }, query: { directory } }).then((result) => result.data).catch(() => void 0);
     return info;
   };
-  const deliverViaHelper = (title, message, urgency) => new Promise((resolve3) => {
+  const deliverViaHelper = (title, message, urgency, sound) => new Promise((resolve3) => {
     const helper = findHelper();
     if (!helper) {
       if (!warnedHelper) {
@@ -2104,7 +2225,7 @@ var notifyHooks = (async ({ client, directory }, _options, deps = {}) => {
       resolve3({ ok: false, detail: "no oc-notify helper found" });
       return;
     }
-    const child = spawn(helper, helperArgv(helper, title, message, urgency, "utilities-terminal"), {
+    const child = spawn(helper, helperArgv(helper, title, message, urgency, "utilities-terminal", sound), {
       stdio: ["ignore", "ignore", "pipe"],
       detached: true
     });
@@ -2163,7 +2284,8 @@ var notifyHooks = (async ({ client, directory }, _options, deps = {}) => {
         return;
       }
       const message = isRemote ? `${decision.message} (remote)` : decision.message;
-      const sent = await deliver(decision.title, message, decision.urgency);
+      const sound = soundOn && NOTIFY_OUTCOMES.includes(outcome) ? outcome : "none";
+      const sent = await deliver(decision.title, message, decision.urgency, sound);
       void log(sent.ok ? "info" : "error", sent.ok ? "notified" : "notification failed", {
         sessionID,
         outcome,