@huynle/hub 0.9.2 → 0.10.0

package/packages/cli/dist/hub-cli.js

@@ -7,7 +7,7 @@ import { createInterface } from "readline";
 // packages/cli/package.json
 var package_default = {
   name: "@huynle/hub-cli",
-  version: "0.9.2",
+  version: "0.10.0",
   private: true,
   description: "The hub CLI (`hub` / `hubctl`) for agents and scripts (internal; bundled into @huynle/hub, not published on its own).",
   license: "MIT",
@@ -419,138 +419,6 @@ function parseAddress(addr) {
   const scope = project ? { project } : {};
   return role ? { kind: "role", role: match[1], ...scope } : { kind: "name", name: match[1], ...scope };
 }
-// packages/sdk/src/artifact-jobs.ts
-var PATH = "/api/agent/artifacts";
-var seg = (value) => encodeURIComponent(value);
-var sig = (options = {}) => options.signal ? { signal: options.signal } : {};
-function artifactJobsApi(hub) {
-  const jobs = (id) => `${PATH}/${seg(id)}/jobs`;
-  const job = (id, jobID, tail = "") => `${jobs(id)}/${seg(jobID)}${tail}`;
-  return {
-    create: async (artifactID, input, options = {}) => {
-      const response = await hub.request("POST", jobs(artifactID), { body: input, ...options.idempotencyKey ? { headers: { "idempotency-key": options.idempotencyKey } } : {}, ...sig(options) });
-      const answer = await response.json();
-      return { job: answer.job, created: response.status === 201 };
-    },
-    list: (artifactID, options = {}) => hub.call("GET", jobs(artifactID), { query: { limit: options.limit, cursor: options.cursor }, ...sig(options) }),
-    get: (artifactID, jobID, options) => hub.call("GET", job(artifactID, jobID), sig(options)),
-    context: (artifactID, jobID, options) => hub.call("GET", job(artifactID, jobID, "/context"), sig(options)),
-    proposal: (artifactID, jobID, options) => hub.call("GET", job(artifactID, jobID, "/proposal"), sig(options)),
-    submit: (artifactID, jobID, result, options) => hub.call("POST", job(artifactID, jobID, "/result"), { body: result, ...sig(options) }),
-    apply: (artifactID, jobID, expectedRevision, options) => hub.call("POST", job(artifactID, jobID, "/apply"), { body: { expectedRevision }, ...sig(options) }),
-    cancel: (artifactID, jobID, expectedRevision, options) => hub.call("POST", job(artifactID, jobID, "/cancel"), { body: { expectedRevision }, ...sig(options) })
-  };
-}
-
-// packages/sdk/src/artifacts.ts
-var PATH2 = "/api/agent/artifacts";
-var seg2 = (value) => encodeURIComponent(value);
-var sig2 = (options = {}) => options.signal ? { signal: options.signal } : {};
-function artifactsApi(hub) {
-  const publish = async (pathname, body, options = {}) => {
-    const response = await hub.request("POST", pathname, { body, ...options.idempotencyKey ? { headers: { "idempotency-key": options.idempotencyKey } } : {}, ...sig2(options) });
-    const answer = await response.json();
-    return { artifact: answer.artifact, revision: answer.revision, created: response.status === 201 };
-  };
-  return {
-    list: (filter = {}) => hub.call("GET", PATH2, { query: { limit: filter.limit, cursor: filter.cursor, state: filter.state, workspace: filter.workspace }, ...sig2(filter) }),
-    get: (id, options) => hub.call("GET", `${PATH2}/${seg2(id)}`, sig2(options)),
-    create: (input, options) => publish(PATH2, input, options),
-    revise: (id, input, options) => publish(`${PATH2}/${seg2(id)}/revisions`, input, options),
-    revisions: (id, options = {}) => hub.call("GET", `${PATH2}/${seg2(id)}/revisions`, { query: { limit: options.limit, cursor: options.cursor }, ...sig2(options) }),
-    revision: (id, revisionID, options) => hub.call("GET", `${PATH2}/${seg2(id)}/revisions/${seg2(revisionID)}`, sig2(options)),
-    uploadBlob: async (body, mediaType, options = {}) => {
-      const response = await hub.request("POST", `${PATH2}/blobs`, { raw: { body, contentType: mediaType }, ...options.hash ? { headers: { "x-blob-hash": options.hash } } : {}, ...sig2(options) });
-      return await response.json();
-    },
-    download: (id, revisionID, hash, options) => hub.request("GET", `${PATH2}/${seg2(id)}/revisions/${seg2(revisionID)}/blobs/${seg2(hash)}`, sig2(options)),
-    update: (id, input, options) => hub.call("PATCH", `${PATH2}/${seg2(id)}`, { body: input, ...sig2(options) }),
-    setVisibility: (id, input, options) => hub.call("PUT", `${PATH2}/${seg2(id)}/visibility`, { body: input, ...sig2(options) }),
-    archive: (id, expectedRevision, options) => hub.call("POST", `${PATH2}/${seg2(id)}/archive`, { body: { expectedRevision }, ...sig2(options) }),
-    unarchive: (id, expectedRevision, options) => hub.call("POST", `${PATH2}/${seg2(id)}/unarchive`, { body: { expectedRevision }, ...sig2(options) }),
-    delete: async (id, expectedRevision, options) => {
-      await hub.call("DELETE", `${PATH2}/${seg2(id)}`, { body: { expectedRevision }, ...sig2(options) });
-    },
-    jobs: artifactJobsApi(hub)
-  };
-}
-// packages/sdk/src/team-intake.ts
-var seg3 = (value) => encodeURIComponent(value);
-var sig3 = (options = {}) => options.signal ? { signal: options.signal } : {};
-var path3 = (team) => `/api/agent/teams/${seg3(team)}/intake`;
-function teamIntakeApi(hub) {
-  return {
-    submit: async (team, input, options = {}) => {
-      const response = await hub.request("POST", path3(team), { body: input, ...options.idempotencyKey ? { headers: { "idempotency-key": options.idempotencyKey } } : {}, ...sig3(options) });
-      const answer = await response.json();
-      return { intake: answer.intake, created: response.status === 201 };
-    },
-    intake: (team, intakeID, options) => hub.call("GET", `${path3(team)}/${seg3(intakeID)}`, sig3(options)),
-    intakes: (team, filter = {}) => hub.call("GET", path3(team), { query: { status: filter.status, limit: filter.limit, cursor: filter.cursor }, ...sig3(filter) }),
-    setIntakeStatus: (team, intakeID, input, options) => hub.call("POST", `${path3(team)}/${seg3(intakeID)}/status`, { body: input, ...sig3(options) })
-  };
-}
-var TEAM_INTAKE_STATUS_INPUTS = ["open", "in_progress", "blocked", "done", "failed", "cancelled"];
-async function reportIntakeStatus(api, team, intakeID, input, options = {}) {
-  const expectedRevision = input.expectedRevision ?? (await api.intake(team, intakeID, options)).intake.revision;
-  return api.setIntakeStatus(team, intakeID, { status: input.status, expectedRevision, ...input.reason !== undefined ? { reason: input.reason } : {} }, options);
-}
-// packages/sdk/src/teams.ts
-var seg4 = (value) => encodeURIComponent(value);
-var sig4 = (options = {}) => options.signal ? { signal: options.signal } : {};
-var key = (options = {}) => options.idempotencyKey ? { headers: { "idempotency-key": options.idempotencyKey } } : {};
-var base = (team) => `/api/agent/teams/${seg4(team)}`;
-function teamsApi(hub) {
-  const created = async (method, pathname, body, options = {}) => {
-    const response = await hub.request(method, pathname, { body, ...key(options), ...sig4(options) });
-    return { ...await response.json(), created: response.status === 201 };
-  };
-  const revised = (verb) => (team, expectedRevision, options) => hub.call("POST", `${base(team)}/${verb}`, { body: { expectedRevision }, ...sig4(options) });
-  return {
-    ...teamIntakeApi(hub),
-    create: (spec, options) => created("POST", "/api/agent/teams", spec, options),
-    list: (filter = {}) => hub.call("GET", "/api/agent/teams", {
-      query: {
-        state: filter.state,
-        tag: filter.tags,
-        project: filter.project,
-        metadata: filter.metadata ? Object.entries(filter.metadata).map(([k, v]) => `${k}=${v}`) : undefined,
-        paused: filter.paused === undefined ? undefined : String(filter.paused),
-        limit: filter.limit,
-        cursor: filter.cursor
-      },
-      ...sig4(filter)
-    }),
-    get: (team, options) => hub.call("GET", base(team), sig4(options)),
-    update: (team, patch, expectedRevision, options = {}) => hub.call("PATCH", base(team), { body: { ...patch, expectedRevision, ...options.publish ? { publish: true } : {} }, ...sig4(options) }),
-    draft: (team, options) => hub.call("GET", `${base(team)}/draft`, sig4(options)),
-    discardDraft: (team, expectedRevision, options) => hub.call("DELETE", `${base(team)}/draft`, { query: { expectedRevision }, ...sig4(options) }),
-    setRole: (team, role, expectedRevision, options) => {
-      const { name, ...fields } = role;
-      return hub.call("PUT", `${base(team)}/draft/roles/${seg4(name)}`, { body: { ...fields, expectedRevision }, ...sig4(options) });
-    },
-    removeRole: (team, role, expectedRevision, options) => hub.call("DELETE", `${base(team)}/draft/roles/${seg4(role)}`, { query: { expectedRevision }, ...sig4(options) }),
-    setEdge: (team, edge, expectedRevision, options) => hub.call("PUT", `${base(team)}/draft/edges`, { body: { ...edge, expectedRevision }, ...sig4(options) }),
-    removeEdge: (team, from, to, expectedRevision, options) => hub.call("DELETE", `${base(team)}/draft/edges`, { query: { from, to, expectedRevision }, ...sig4(options) }),
-    publish: (team, expectedRevision, options) => hub.call("POST", `${base(team)}/publish`, { body: { expectedRevision }, ...sig4(options) }),
-    pause: revised("pause"),
-    resume: revised("resume"),
-    archive: revised("archive"),
-    restore: revised("restore"),
-    versions: (team, options = {}) => hub.call("GET", `${base(team)}/versions`, { query: { limit: options.limit, cursor: options.cursor }, ...sig4(options) }),
-    version: (team, version, options) => hub.call("GET", `${base(team)}/versions/${version}`, sig4(options)),
-    diff: (team, options = {}) => hub.call("GET", `${base(team)}/diff`, { query: { from: options.from, to: options.to }, ...sig4(options) }),
-    staffing: (team, options = {}) => hub.call("GET", `${base(team)}/staffing`, { query: { ended: options.ended ? 1 : undefined }, ...sig4(options) }),
-    staff: (team, input, options) => created("PUT", `${base(team)}/staffing`, input, options),
-    launchMember: (team, input, options) => created("POST", `${base(team)}/staffing/launch`, input, options),
-    replace: (team, staffingID, input, options) => hub.call("POST", `${base(team)}/staffing/${seg4(staffingID)}/replace`, { body: input, ...sig4(options) }),
-    unstaff: (team, staffingID, expectedRevision, options) => hub.call("DELETE", `${base(team)}/staffing/${seg4(staffingID)}`, { query: { expectedRevision }, ...sig4(options) }),
-    roster: (team, options) => hub.call("GET", `${base(team)}/roster`, sig4(options)),
-    status: (team, options) => hub.call("GET", `${base(team)}/status`, sig4(options)),
-    settings: (options) => hub.call("GET", "/api/agent/team-settings", sig4(options)),
-    setSettings: (input, expectedRevision, options) => hub.call("PUT", "/api/agent/team-settings", { body: { teamIsolation: input.teamIsolation, expectedRevision }, ...sig4(options) })
-  };
-}
 // packages/sdk/src/errors.ts
 class HubError extends Error {
   status;
@@ -667,15 +535,288 @@ async function* sseEvents(response, signal) {
   }
 }
 
+// packages/sdk/src/app-front.ts
+var AGENT = "/api/agent";
+var sig = (options = {}) => options.signal ? { signal: options.signal } : {};
+var seg = (value) => encodeURIComponent(value).replace(/%40/g, "@");
+var RESUMABLE = new Set(["slow", "token_expired"]);
+function speechApi(hub) {
+  return {
+    async transcribe(audio, options = {}) {
+      const type = options.type ?? (audio instanceof Blob && audio.type ? audio.type : "audio/webm");
+      const response = await hub.request("POST", `${AGENT}/speech/transcribe`, { raw: { body: audio, contentType: type }, ...sig(options) });
+      return await response.json();
+    },
+    async speak(text, options = {}) {
+      const response = await hub.request("POST", `${AGENT}/speech/speak`, { body: { text }, ...sig(options) });
+      if (!response.body)
+        throw new HubTransportError("bad_response", "the hub sent no audio");
+      return response.body;
+    }
+  };
+}
+function conversationApi(hub) {
+  const at = (addr, verb) => `${AGENT}/sessions/${seg(addr)}/${verb}`;
+  return {
+    set: (addr, on, options = {}) => hub.call("POST", at(addr, "conversation"), { body: options.front === undefined ? { on } : { on, front: options.front }, ...sig(options) }),
+    utterance: (addr, text, options = {}) => hub.call("POST", at(addr, "utterance"), { body: { text }, ...sig(options) }),
+    interrupt: async (addr, options = {}) => {
+      await hub.request("POST", at(addr, "interrupt"), sig(options));
+    },
+    stream: (addr, options = {}) => streamFrames(hub, at(addr, "stream"), options)
+  };
+}
+function appDecisionsApi(hub) {
+  return {
+    list: (options = {}) => hub.call("GET", `${AGENT}/decisions`, { query: { answerable: 1, state: options.state }, ...sig(options) }),
+    answer: (id, answer) => {
+      const { signal: _signal, ...body } = answer;
+      return hub.call("POST", `${AGENT}/decisions/${seg(id)}/answer`, { body, ...sig(answer) });
+    }
+  };
+}
+function retryable(cause) {
+  if (cause instanceof HubError)
+    return cause.status === 429 || cause.status >= 500;
+  if (cause instanceof HubTransportError)
+    return cause.kind === "unreachable" || cause.kind === "stream" || cause.kind === "http" && (cause.status === undefined || cause.status === 429 || cause.status >= 500);
+  return false;
+}
+var wait = (ms, signal) => new Promise((resolve) => {
+  if (signal?.aborted)
+    return resolve();
+  const done = () => {
+    clearTimeout(timer);
+    signal?.removeEventListener("abort", done);
+    resolve();
+  };
+  const timer = setTimeout(done, ms);
+  signal?.addEventListener("abort", done, { once: true });
+});
+async function* streamFrames(hub, pathname, options) {
+  const resume = options.resume ?? true;
+  const maxReconnects = options.maxReconnects ?? 5;
+  const base = options.reconnectDelayMs ?? 1000;
+  const cap = options.maxReconnectDelayMs ?? 30000;
+  let cursor = options.cursor;
+  let misses = 0;
+  let lastFailure;
+  let retryAfterMs = 0;
+  for (let attempt = 0;; attempt++) {
+    if (options.signal?.aborted)
+      return;
+    let response;
+    try {
+      response = await hub.request("GET", pathname, { headers: { accept: "text/event-stream", ...cursor ? { "last-event-id": cursor } : {} }, ...sig(options) });
+    } catch (cause) {
+      if (attempt === 0 || options.signal?.aborted || !retryable(cause))
+        throw cause;
+      lastFailure = cause;
+      retryAfterMs = cause instanceof HubError && cause.retryAfter !== undefined ? cause.retryAfter * 1000 : 0;
+    }
+    if (response) {
+      retryAfterMs = 0;
+      if (!response.body)
+        throw new HubTransportError("bad_response", "the hub sent no stream");
+      const reader = response.body.getReader();
+      const stop = () => void reader.cancel().catch(() => {});
+      options.signal?.addEventListener("abort", stop, { once: true });
+      const parser = new SseParser;
+      const decoder = new TextDecoder;
+      lastFailure = undefined;
+      try {
+        read:
+          for (;; ) {
+            let chunk;
+            try {
+              chunk = await reader.read();
+            } catch (cause) {
+              lastFailure = cause;
+              break;
+            }
+            if (chunk.done || options.signal?.aborted)
+              break;
+            for (const event of parser.push(decoder.decode(chunk.value, { stream: true }))) {
+              if (event.id)
+                cursor = event.id;
+              if (event.event !== "message")
+                continue;
+              let frame;
+              try {
+                frame = JSON.parse(event.data);
+              } catch {
+                continue;
+              }
+              if (frame.type === "end") {
+                if (resume && RESUMABLE.has(frame.reason)) {
+                  lastFailure = new HubTransportError("stream", `the stream ended (${frame.reason})`);
+                  break read;
+                }
+                yield { frame };
+                return;
+              }
+              if (frame.type !== "ready")
+                misses = 0;
+              yield cursor ? { frame, cursor } : { frame };
+              if (options.signal?.aborted)
+                return;
+            }
+          }
+      } finally {
+        options.signal?.removeEventListener("abort", stop);
+        stop();
+      }
+      if (options.signal?.aborted || !resume)
+        return;
+    }
+    if (++misses > maxReconnects) {
+      throw new HubTransportError("stream", `the conversation stream gave up after ${maxReconnects} reconnects${lastFailure instanceof Error ? ` (${lastFailure.message})` : ""}`, { cause: lastFailure });
+    }
+    const backoff = Math.min(cap, base * 2 ** (misses - 1));
+    await wait(Math.max(retryAfterMs, backoff * (0.5 + Math.random() * 0.5)), options.signal);
+  }
+}
+// packages/sdk/src/artifact-jobs.ts
+var PATH = "/api/agent/artifacts";
+var seg2 = (value) => encodeURIComponent(value);
+var sig2 = (options = {}) => options.signal ? { signal: options.signal } : {};
+function artifactJobsApi(hub) {
+  const jobs = (id) => `${PATH}/${seg2(id)}/jobs`;
+  const job = (id, jobID, tail = "") => `${jobs(id)}/${seg2(jobID)}${tail}`;
+  return {
+    create: async (artifactID, input, options = {}) => {
+      const response = await hub.request("POST", jobs(artifactID), { body: input, ...options.idempotencyKey ? { headers: { "idempotency-key": options.idempotencyKey } } : {}, ...sig2(options) });
+      const answer = await response.json();
+      return { job: answer.job, created: response.status === 201 };
+    },
+    list: (artifactID, options = {}) => hub.call("GET", jobs(artifactID), { query: { limit: options.limit, cursor: options.cursor }, ...sig2(options) }),
+    get: (artifactID, jobID, options) => hub.call("GET", job(artifactID, jobID), sig2(options)),
+    context: (artifactID, jobID, options) => hub.call("GET", job(artifactID, jobID, "/context"), sig2(options)),
+    proposal: (artifactID, jobID, options) => hub.call("GET", job(artifactID, jobID, "/proposal"), sig2(options)),
+    submit: (artifactID, jobID, result, options) => hub.call("POST", job(artifactID, jobID, "/result"), { body: result, ...sig2(options) }),
+    apply: (artifactID, jobID, expectedRevision, options) => hub.call("POST", job(artifactID, jobID, "/apply"), { body: { expectedRevision }, ...sig2(options) }),
+    cancel: (artifactID, jobID, expectedRevision, options) => hub.call("POST", job(artifactID, jobID, "/cancel"), { body: { expectedRevision }, ...sig2(options) })
+  };
+}
+
+// packages/sdk/src/artifacts.ts
+var PATH2 = "/api/agent/artifacts";
+var seg3 = (value) => encodeURIComponent(value);
+var sig3 = (options = {}) => options.signal ? { signal: options.signal } : {};
+function artifactsApi(hub) {
+  const publish = async (pathname, body, options = {}) => {
+    const response = await hub.request("POST", pathname, { body, ...options.idempotencyKey ? { headers: { "idempotency-key": options.idempotencyKey } } : {}, ...sig3(options) });
+    const answer = await response.json();
+    return { artifact: answer.artifact, revision: answer.revision, created: response.status === 201 };
+  };
+  return {
+    list: (filter = {}) => hub.call("GET", PATH2, { query: { limit: filter.limit, cursor: filter.cursor, state: filter.state, workspace: filter.workspace }, ...sig3(filter) }),
+    get: (id, options) => hub.call("GET", `${PATH2}/${seg3(id)}`, sig3(options)),
+    create: (input, options) => publish(PATH2, input, options),
+    revise: (id, input, options) => publish(`${PATH2}/${seg3(id)}/revisions`, input, options),
+    revisions: (id, options = {}) => hub.call("GET", `${PATH2}/${seg3(id)}/revisions`, { query: { limit: options.limit, cursor: options.cursor }, ...sig3(options) }),
+    revision: (id, revisionID, options) => hub.call("GET", `${PATH2}/${seg3(id)}/revisions/${seg3(revisionID)}`, sig3(options)),
+    uploadBlob: async (body, mediaType, options = {}) => {
+      const response = await hub.request("POST", `${PATH2}/blobs`, { raw: { body, contentType: mediaType }, ...options.hash ? { headers: { "x-blob-hash": options.hash } } : {}, ...sig3(options) });
+      return await response.json();
+    },
+    download: (id, revisionID, hash, options) => hub.request("GET", `${PATH2}/${seg3(id)}/revisions/${seg3(revisionID)}/blobs/${seg3(hash)}`, sig3(options)),
+    update: (id, input, options) => hub.call("PATCH", `${PATH2}/${seg3(id)}`, { body: input, ...sig3(options) }),
+    setVisibility: (id, input, options) => hub.call("PUT", `${PATH2}/${seg3(id)}/visibility`, { body: input, ...sig3(options) }),
+    archive: (id, expectedRevision, options) => hub.call("POST", `${PATH2}/${seg3(id)}/archive`, { body: { expectedRevision }, ...sig3(options) }),
+    unarchive: (id, expectedRevision, options) => hub.call("POST", `${PATH2}/${seg3(id)}/unarchive`, { body: { expectedRevision }, ...sig3(options) }),
+    delete: async (id, expectedRevision, options) => {
+      await hub.call("DELETE", `${PATH2}/${seg3(id)}`, { body: { expectedRevision }, ...sig3(options) });
+    },
+    jobs: artifactJobsApi(hub)
+  };
+}
+// packages/sdk/src/team-intake.ts
+var seg4 = (value) => encodeURIComponent(value);
+var sig4 = (options = {}) => options.signal ? { signal: options.signal } : {};
+var path3 = (team) => `/api/agent/teams/${seg4(team)}/intake`;
+function teamIntakeApi(hub) {
+  return {
+    submit: async (team, input, options = {}) => {
+      const response = await hub.request("POST", path3(team), { body: input, ...options.idempotencyKey ? { headers: { "idempotency-key": options.idempotencyKey } } : {}, ...sig4(options) });
+      const answer = await response.json();
+      return { intake: answer.intake, created: response.status === 201 };
+    },
+    intake: (team, intakeID, options) => hub.call("GET", `${path3(team)}/${seg4(intakeID)}`, sig4(options)),
+    intakes: (team, filter = {}) => hub.call("GET", path3(team), { query: { status: filter.status, limit: filter.limit, cursor: filter.cursor }, ...sig4(filter) }),
+    setIntakeStatus: (team, intakeID, input, options) => hub.call("POST", `${path3(team)}/${seg4(intakeID)}/status`, { body: input, ...sig4(options) })
+  };
+}
+var TEAM_INTAKE_STATUS_INPUTS = ["open", "in_progress", "blocked", "done", "failed", "cancelled"];
+async function reportIntakeStatus(api, team, intakeID, input, options = {}) {
+  const expectedRevision = input.expectedRevision ?? (await api.intake(team, intakeID, options)).intake.revision;
+  return api.setIntakeStatus(team, intakeID, { status: input.status, expectedRevision, ...input.reason !== undefined ? { reason: input.reason } : {} }, options);
+}
+// packages/sdk/src/teams.ts
+var seg5 = (value) => encodeURIComponent(value);
+var sig5 = (options = {}) => options.signal ? { signal: options.signal } : {};
+var key = (options = {}) => options.idempotencyKey ? { headers: { "idempotency-key": options.idempotencyKey } } : {};
+var base = (team) => `/api/agent/teams/${seg5(team)}`;
+function teamsApi(hub) {
+  const created = async (method, pathname, body, options = {}) => {
+    const response = await hub.request(method, pathname, { body, ...key(options), ...sig5(options) });
+    return { ...await response.json(), created: response.status === 201 };
+  };
+  const revised = (verb) => (team, expectedRevision, options) => hub.call("POST", `${base(team)}/${verb}`, { body: { expectedRevision }, ...sig5(options) });
+  return {
+    ...teamIntakeApi(hub),
+    create: (spec, options) => created("POST", "/api/agent/teams", spec, options),
+    list: (filter = {}) => hub.call("GET", "/api/agent/teams", {
+      query: {
+        state: filter.state,
+        tag: filter.tags,
+        project: filter.project,
+        metadata: filter.metadata ? Object.entries(filter.metadata).map(([k, v]) => `${k}=${v}`) : undefined,
+        paused: filter.paused === undefined ? undefined : String(filter.paused),
+        limit: filter.limit,
+        cursor: filter.cursor
+      },
+      ...sig5(filter)
+    }),
+    get: (team, options) => hub.call("GET", base(team), sig5(options)),
+    update: (team, patch, expectedRevision, options = {}) => hub.call("PATCH", base(team), { body: { ...patch, expectedRevision, ...options.publish ? { publish: true } : {} }, ...sig5(options) }),
+    draft: (team, options) => hub.call("GET", `${base(team)}/draft`, sig5(options)),
+    discardDraft: (team, expectedRevision, options) => hub.call("DELETE", `${base(team)}/draft`, { query: { expectedRevision }, ...sig5(options) }),
+    setRole: (team, role, expectedRevision, options) => {
+      const { name, ...fields } = role;
+      return hub.call("PUT", `${base(team)}/draft/roles/${seg5(name)}`, { body: { ...fields, expectedRevision }, ...sig5(options) });
+    },
+    removeRole: (team, role, expectedRevision, options) => hub.call("DELETE", `${base(team)}/draft/roles/${seg5(role)}`, { query: { expectedRevision }, ...sig5(options) }),
+    setEdge: (team, edge, expectedRevision, options) => hub.call("PUT", `${base(team)}/draft/edges`, { body: { ...edge, expectedRevision }, ...sig5(options) }),
+    removeEdge: (team, from, to, expectedRevision, options) => hub.call("DELETE", `${base(team)}/draft/edges`, { query: { from, to, expectedRevision }, ...sig5(options) }),
+    publish: (team, expectedRevision, options) => hub.call("POST", `${base(team)}/publish`, { body: { expectedRevision }, ...sig5(options) }),
+    pause: revised("pause"),
+    resume: revised("resume"),
+    archive: revised("archive"),
+    restore: revised("restore"),
+    versions: (team, options = {}) => hub.call("GET", `${base(team)}/versions`, { query: { limit: options.limit, cursor: options.cursor }, ...sig5(options) }),
+    version: (team, version, options) => hub.call("GET", `${base(team)}/versions/${version}`, sig5(options)),
+    diff: (team, options = {}) => hub.call("GET", `${base(team)}/diff`, { query: { from: options.from, to: options.to }, ...sig5(options) }),
+    staffing: (team, options = {}) => hub.call("GET", `${base(team)}/staffing`, { query: { ended: options.ended ? 1 : undefined }, ...sig5(options) }),
+    staff: (team, input, options) => created("PUT", `${base(team)}/staffing`, input, options),
+    launchMember: (team, input, options) => created("POST", `${base(team)}/staffing/launch`, input, options),
+    replace: (team, staffingID, input, options) => hub.call("POST", `${base(team)}/staffing/${seg5(staffingID)}/replace`, { body: input, ...sig5(options) }),
+    unstaff: (team, staffingID, expectedRevision, options) => hub.call("DELETE", `${base(team)}/staffing/${seg5(staffingID)}`, { query: { expectedRevision }, ...sig5(options) }),
+    roster: (team, options) => hub.call("GET", `${base(team)}/roster`, sig5(options)),
+    status: (team, options) => hub.call("GET", `${base(team)}/status`, sig5(options)),
+    settings: (options) => hub.call("GET", "/api/agent/team-settings", sig5(options)),
+    setSettings: (input, expectedRevision, options) => hub.call("PUT", "/api/agent/team-settings", { body: { teamIsolation: input.teamIsolation, expectedRevision }, ...sig5(options) })
+  };
+}
 // packages/sdk/src/concierge.ts
 var WATCHLIST = "/api/agent/concierge/watchlist";
-var sig5 = (options = {}) => options.signal ? { signal: options.signal } : {};
+var sig6 = (options = {}) => options.signal ? { signal: options.signal } : {};
 function conciergeApi(hub) {
-  const verb = (name) => (addr, options) => hub.call("POST", `${WATCHLIST}/${name}`, { body: { session: addr }, ...sig5(options) });
+  const verb = (name) => (addr, options) => hub.call("POST", `${WATCHLIST}/${name}`, { body: { session: addr }, ...sig6(options) });
   return {
     watchlist: {
-      get: (options) => hub.call("GET", WATCHLIST, sig5(options)),
-      update: (patch, expectedRevision, options) => hub.call("PUT", WATCHLIST, { body: { ...patch, expectedRevision }, ...sig5(options) }),
+      get: (options) => hub.call("GET", WATCHLIST, sig6(options)),
+      update: (patch, expectedRevision, options) => hub.call("PUT", WATCHLIST, { body: { ...patch, expectedRevision }, ...sig6(options) }),
       watch: verb("watch"),
       unwatch: verb("unwatch"),
       mute: verb("mute"),
@@ -685,7 +826,7 @@ function conciergeApi(hub) {
 }
 
 // packages/sdk/src/client.ts
-var AGENT = "/api/agent";
+var AGENT2 = "/api/agent";
 var WAIT_POLL_MAX_S = 60;
 function queryString(query = {}) {
   const params = new URLSearchParams;
@@ -724,69 +865,72 @@ class HubClient {
   #fetch;
   launches = {
     create: async (spec, options = {}) => {
-      const response = await this.request("POST", `${AGENT}/launches`, { body: spec, ...signalOf(options) });
-      const body = await this.#json(response, `${AGENT}/launches`);
+      const response = await this.request("POST", `${AGENT2}/launches`, { body: spec, ...signalOf(options) });
+      const body = await this.#json(response, `${AGENT2}/launches`);
       return { launch: body.launch, created: response.status === 201 };
     },
     list: (filter = {}) => {
       const state = typeof filter.state === "string" ? filter.state : filter.state?.join(",");
-      return this.call("GET", `${AGENT}/launches`, { query: { state, label: filter.label }, ...signalOf(filter) });
+      return this.call("GET", `${AGENT2}/launches`, { query: { state, label: filter.label }, ...signalOf(filter) });
     },
-    get: (id, options = {}) => this.call("GET", `${AGENT}/launches/${segment(id)}`, signalOf(options)),
-    stop: (id, options = {}) => this.call("DELETE", `${AGENT}/launches/${segment(id)}`, signalOf(options))
+    get: (id, options = {}) => this.call("GET", `${AGENT2}/launches/${segment(id)}`, signalOf(options)),
+    stop: (id, options = {}) => this.call("DELETE", `${AGENT2}/launches/${segment(id)}`, signalOf(options))
   };
   profiles = {
-    create: (input, options = {}) => this.call("POST", `${AGENT}/profiles`, { body: input, ...idempotent(options) }),
-    import: (input, options = {}) => this.call("POST", `${AGENT}/profiles/import`, { body: input, ...idempotent(options) }),
-    list: (filter = {}) => this.call("GET", `${AGENT}/profiles`, { query: { state: filter.state, limit: filter.limit, cursor: filter.cursor, include: filter.include }, ...signalOf(filter) }),
-    get: (id, options = {}) => this.call("GET", `${AGENT}/profiles/${segment(id)}`, signalOf(options)),
-    update: (id, patch, options = {}) => this.call("PATCH", `${AGENT}/profiles/${segment(id)}`, { body: patch, ...signalOf(options) }),
-    usage: (id, options = {}) => this.call("GET", `${AGENT}/profiles/${segment(id)}/usage`, { query: { limit: options.limit, cursor: options.cursor }, ...signalOf(options) }),
-    versions: (id, options = {}) => this.call("GET", `${AGENT}/profiles/${segment(id)}/versions`, { query: { limit: options.limit, cursor: options.cursor }, ...signalOf(options) }),
-    createVersion: (id, input, options = {}) => this.call("POST", `${AGENT}/profiles/${segment(id)}/versions`, { body: input, ...idempotent(options) }),
-    version: (id, version, options = {}) => this.call("GET", `${AGENT}/profiles/${segment(id)}/versions/${version}`, signalOf(options)),
-    skill: (id, version, name, options = {}) => this.call("GET", `${AGENT}/profiles/${segment(id)}/versions/${version}/skills/${segment(name)}`, signalOf(options)),
-    render: (id, version, name, params, options = {}) => this.call("POST", `${AGENT}/profiles/${segment(id)}/versions/${version}/commands/${segment(name)}/render`, { body: { params }, ...signalOf(options) }),
-    ofSession: (addr, options = {}) => this.call("GET", `${AGENT}/sessions/${segment(addr)}/profile`, signalOf(options)),
-    assign: (addr, input, options = {}) => this.call("PUT", `${AGENT}/sessions/${segment(addr)}/profile`, { body: input, ...signalOf(options) }),
-    unassign: (addr, expectedRevision, options = {}) => this.call("DELETE", `${AGENT}/sessions/${segment(addr)}/profile`, { query: { expectedRevision }, ...signalOf(options) }),
-    sessionSkill: (addr, name, options = {}) => this.call("GET", `${AGENT}/sessions/${segment(addr)}/profile/skills/${segment(name)}`, signalOf(options)),
-    sessionRender: (addr, name, params, options = {}) => this.call("POST", `${AGENT}/sessions/${segment(addr)}/profile/commands/${segment(name)}/render`, { body: { params }, ...signalOf(options) })
+    create: (input, options = {}) => this.call("POST", `${AGENT2}/profiles`, { body: input, ...idempotent(options) }),
+    import: (input, options = {}) => this.call("POST", `${AGENT2}/profiles/import`, { body: input, ...idempotent(options) }),
+    list: (filter = {}) => this.call("GET", `${AGENT2}/profiles`, { query: { state: filter.state, limit: filter.limit, cursor: filter.cursor, include: filter.include }, ...signalOf(filter) }),
+    get: (id, options = {}) => this.call("GET", `${AGENT2}/profiles/${segment(id)}`, signalOf(options)),
+    update: (id, patch, options = {}) => this.call("PATCH", `${AGENT2}/profiles/${segment(id)}`, { body: patch, ...signalOf(options) }),
+    usage: (id, options = {}) => this.call("GET", `${AGENT2}/profiles/${segment(id)}/usage`, { query: { limit: options.limit, cursor: options.cursor }, ...signalOf(options) }),
+    versions: (id, options = {}) => this.call("GET", `${AGENT2}/profiles/${segment(id)}/versions`, { query: { limit: options.limit, cursor: options.cursor }, ...signalOf(options) }),
+    createVersion: (id, input, options = {}) => this.call("POST", `${AGENT2}/profiles/${segment(id)}/versions`, { body: input, ...idempotent(options) }),
+    version: (id, version, options = {}) => this.call("GET", `${AGENT2}/profiles/${segment(id)}/versions/${version}`, signalOf(options)),
+    skill: (id, version, name, options = {}) => this.call("GET", `${AGENT2}/profiles/${segment(id)}/versions/${version}/skills/${segment(name)}`, signalOf(options)),
+    render: (id, version, name, params, options = {}) => this.call("POST", `${AGENT2}/profiles/${segment(id)}/versions/${version}/commands/${segment(name)}/render`, { body: { params }, ...signalOf(options) }),
+    ofSession: (addr, options = {}) => this.call("GET", `${AGENT2}/sessions/${segment(addr)}/profile`, signalOf(options)),
+    assign: (addr, input, options = {}) => this.call("PUT", `${AGENT2}/sessions/${segment(addr)}/profile`, { body: input, ...signalOf(options) }),
+    unassign: (addr, expectedRevision, options = {}) => this.call("DELETE", `${AGENT2}/sessions/${segment(addr)}/profile`, { query: { expectedRevision }, ...signalOf(options) }),
+    sessionSkill: (addr, name, options = {}) => this.call("GET", `${AGENT2}/sessions/${segment(addr)}/profile/skills/${segment(name)}`, signalOf(options)),
+    sessionRender: (addr, name, params, options = {}) => this.call("POST", `${AGENT2}/sessions/${segment(addr)}/profile/commands/${segment(name)}/render`, { body: { params }, ...signalOf(options) })
   };
   workspaces = {
-    create: (input, options = {}) => this.call("POST", `${AGENT}/workspaces`, { body: input, ...idempotent(options) }),
-    list: (filter = {}) => this.call("GET", `${AGENT}/workspaces`, { query: { state: filter.state, limit: filter.limit, cursor: filter.cursor }, ...signalOf(filter) }),
-    get: (id, options = {}) => this.call("GET", `${AGENT}/workspaces/${segment(id)}`, signalOf(options)),
-    update: (id, patch, options = {}) => this.call("PATCH", `${AGENT}/workspaces/${segment(id)}`, { body: patch, ...signalOf(options) }),
-    archive: (id, expectedRevision, options = {}) => this.call("POST", `${AGENT}/workspaces/${segment(id)}/archive`, { body: { expectedRevision }, ...signalOf(options) }),
-    restore: (id, expectedRevision, options = {}) => this.call("POST", `${AGENT}/workspaces/${segment(id)}/restore`, { body: { expectedRevision }, ...signalOf(options) }),
-    bindings: (id, options = {}) => this.call("GET", `${AGENT}/workspaces/${segment(id)}/bindings`, signalOf(options)),
-    bind: (id, input, options = {}) => this.call("POST", `${AGENT}/workspaces/${segment(id)}/bindings`, { body: input, ...idempotent(options) }),
-    unbind: (id, bindingID, expectedRevision, options = {}) => this.call("DELETE", `${AGENT}/workspaces/${segment(id)}/bindings`, { query: { bindingID, expectedRevision }, ...signalOf(options) }),
-    members: (id, options = {}) => this.call("GET", `${AGENT}/workspaces/${segment(id)}/members`, { query: { includeLeft: options.includeLeft ? 1 : undefined }, ...signalOf(options) }),
-    join: (id, input, options = {}) => this.call("POST", `${AGENT}/workspaces/${segment(id)}/members`, { body: input, ...idempotent(options) }),
-    setRole: (id, memberID, role, expectedRevision, options = {}) => this.call("PATCH", `${AGENT}/workspaces/${segment(id)}/members/${segment(memberID)}`, { body: { role, expectedRevision }, ...signalOf(options) }),
-    leave: (id, memberID, expectedRevision, options = {}) => this.call("DELETE", `${AGENT}/workspaces/${segment(id)}/members/${segment(memberID)}`, { query: { expectedRevision }, ...signalOf(options) }),
-    assignments: (id, filter = {}) => this.call("GET", `${AGENT}/workspaces/${segment(id)}/assignments`, { query: { memberID: filter.memberID, status: filter.status, limit: filter.limit, cursor: filter.cursor }, ...signalOf(filter) }),
-    assignment: (id, assignmentID, options = {}) => this.call("GET", `${AGENT}/workspaces/${segment(id)}/assignments/${segment(assignmentID)}`, signalOf(options)),
-    assign: (id, input, options = {}) => this.call("POST", `${AGENT}/workspaces/${segment(id)}/assignments`, { body: input, ...idempotent(options) }),
-    setAssignmentStatus: (id, assignmentID, status, expectedRevision, options = {}) => this.call("PATCH", `${AGENT}/workspaces/${segment(id)}/assignments/${segment(assignmentID)}`, { body: { status, expectedRevision }, ...signalOf(options) }),
-    reassign: (id, assignmentID, memberID, expectedRevision, options = {}) => this.call("PATCH", `${AGENT}/workspaces/${segment(id)}/assignments/${segment(assignmentID)}`, { body: { memberID, expectedRevision }, ...signalOf(options) }),
-    supervision: (id, options = {}) => this.call("GET", `${AGENT}/workspaces/${segment(id)}/supervision`, signalOf(options)),
-    supervise: (id, input, options = {}) => this.call("PUT", `${AGENT}/workspaces/${segment(id)}/supervision`, { body: input, ...signalOf(options) }),
-    board: (id, options = {}) => this.call("GET", `${AGENT}/workspaces/${segment(id)}/board`, signalOf(options)),
-    master: (id, options = {}) => this.call("GET", `${AGENT}/workspaces/${segment(id)}/master`, signalOf(options)),
-    replaceMaster: (id, input, options = {}) => this.call("POST", `${AGENT}/workspaces/${segment(id)}/master`, { body: input, ...idempotent(options) }),
-    createSideChat: (id, input, options = {}) => this.call("POST", `${AGENT}/workspaces/${segment(id)}/side-chats`, { body: input, ...idempotent(options) }),
-    sideChats: (id, filter = {}) => this.call("GET", `${AGENT}/workspaces/${segment(id)}/side-chats`, { query: { limit: filter.limit, cursor: filter.cursor }, ...signalOf(filter) }),
-    sideChat: (id, sideChatID, options = {}) => this.call("GET", `${AGENT}/workspaces/${segment(id)}/side-chats/${segment(sideChatID)}`, signalOf(options)),
-    sideChatByID: (sideChatID, options = {}) => this.call("GET", `${AGENT}/side-chats/${segment(sideChatID)}`, signalOf(options)),
-    refreshSideChat: (id, sideChatID, expectedRevision, options = {}) => this.call("POST", `${AGENT}/workspaces/${segment(id)}/side-chats/${segment(sideChatID)}/refresh`, { body: { expectedRevision }, ...signalOf(options) }),
-    sendToMain: (id, sideChatID, text, options = {}) => this.call("POST", `${AGENT}/workspaces/${segment(id)}/side-chats/${segment(sideChatID)}/send`, { body: { text, confirmed: true }, ...signalOf(options) })
+    create: (input, options = {}) => this.call("POST", `${AGENT2}/workspaces`, { body: input, ...idempotent(options) }),
+    list: (filter = {}) => this.call("GET", `${AGENT2}/workspaces`, { query: { state: filter.state, limit: filter.limit, cursor: filter.cursor }, ...signalOf(filter) }),
+    get: (id, options = {}) => this.call("GET", `${AGENT2}/workspaces/${segment(id)}`, signalOf(options)),
+    update: (id, patch, options = {}) => this.call("PATCH", `${AGENT2}/workspaces/${segment(id)}`, { body: patch, ...signalOf(options) }),
+    archive: (id, expectedRevision, options = {}) => this.call("POST", `${AGENT2}/workspaces/${segment(id)}/archive`, { body: { expectedRevision }, ...signalOf(options) }),
+    restore: (id, expectedRevision, options = {}) => this.call("POST", `${AGENT2}/workspaces/${segment(id)}/restore`, { body: { expectedRevision }, ...signalOf(options) }),
+    bindings: (id, options = {}) => this.call("GET", `${AGENT2}/workspaces/${segment(id)}/bindings`, signalOf(options)),
+    bind: (id, input, options = {}) => this.call("POST", `${AGENT2}/workspaces/${segment(id)}/bindings`, { body: input, ...idempotent(options) }),
+    unbind: (id, bindingID, expectedRevision, options = {}) => this.call("DELETE", `${AGENT2}/workspaces/${segment(id)}/bindings`, { query: { bindingID, expectedRevision }, ...signalOf(options) }),
+    members: (id, options = {}) => this.call("GET", `${AGENT2}/workspaces/${segment(id)}/members`, { query: { includeLeft: options.includeLeft ? 1 : undefined }, ...signalOf(options) }),
+    join: (id, input, options = {}) => this.call("POST", `${AGENT2}/workspaces/${segment(id)}/members`, { body: input, ...idempotent(options) }),
+    setRole: (id, memberID, role, expectedRevision, options = {}) => this.call("PATCH", `${AGENT2}/workspaces/${segment(id)}/members/${segment(memberID)}`, { body: { role, expectedRevision }, ...signalOf(options) }),
+    leave: (id, memberID, expectedRevision, options = {}) => this.call("DELETE", `${AGENT2}/workspaces/${segment(id)}/members/${segment(memberID)}`, { query: { expectedRevision }, ...signalOf(options) }),
+    assignments: (id, filter = {}) => this.call("GET", `${AGENT2}/workspaces/${segment(id)}/assignments`, { query: { memberID: filter.memberID, status: filter.status, limit: filter.limit, cursor: filter.cursor }, ...signalOf(filter) }),
+    assignment: (id, assignmentID, options = {}) => this.call("GET", `${AGENT2}/workspaces/${segment(id)}/assignments/${segment(assignmentID)}`, signalOf(options)),
+    assign: (id, input, options = {}) => this.call("POST", `${AGENT2}/workspaces/${segment(id)}/assignments`, { body: input, ...idempotent(options) }),
+    setAssignmentStatus: (id, assignmentID, status, expectedRevision, options = {}) => this.call("PATCH", `${AGENT2}/workspaces/${segment(id)}/assignments/${segment(assignmentID)}`, { body: { status, expectedRevision }, ...signalOf(options) }),
+    reassign: (id, assignmentID, memberID, expectedRevision, options = {}) => this.call("PATCH", `${AGENT2}/workspaces/${segment(id)}/assignments/${segment(assignmentID)}`, { body: { memberID, expectedRevision }, ...signalOf(options) }),
+    supervision: (id, options = {}) => this.call("GET", `${AGENT2}/workspaces/${segment(id)}/supervision`, signalOf(options)),
+    supervise: (id, input, options = {}) => this.call("PUT", `${AGENT2}/workspaces/${segment(id)}/supervision`, { body: input, ...signalOf(options) }),
+    board: (id, options = {}) => this.call("GET", `${AGENT2}/workspaces/${segment(id)}/board`, signalOf(options)),
+    master: (id, options = {}) => this.call("GET", `${AGENT2}/workspaces/${segment(id)}/master`, signalOf(options)),
+    replaceMaster: (id, input, options = {}) => this.call("POST", `${AGENT2}/workspaces/${segment(id)}/master`, { body: input, ...idempotent(options) }),
+    createSideChat: (id, input, options = {}) => this.call("POST", `${AGENT2}/workspaces/${segment(id)}/side-chats`, { body: input, ...idempotent(options) }),
+    sideChats: (id, filter = {}) => this.call("GET", `${AGENT2}/workspaces/${segment(id)}/side-chats`, { query: { limit: filter.limit, cursor: filter.cursor }, ...signalOf(filter) }),
+    sideChat: (id, sideChatID, options = {}) => this.call("GET", `${AGENT2}/workspaces/${segment(id)}/side-chats/${segment(sideChatID)}`, signalOf(options)),
+    sideChatByID: (sideChatID, options = {}) => this.call("GET", `${AGENT2}/side-chats/${segment(sideChatID)}`, signalOf(options)),
+    refreshSideChat: (id, sideChatID, expectedRevision, options = {}) => this.call("POST", `${AGENT2}/workspaces/${segment(id)}/side-chats/${segment(sideChatID)}/refresh`, { body: { expectedRevision }, ...signalOf(options) }),
+    sendToMain: (id, sideChatID, text, options = {}) => this.call("POST", `${AGENT2}/workspaces/${segment(id)}/side-chats/${segment(sideChatID)}/send`, { body: { text, confirmed: true }, ...signalOf(options) })
   };
   artifacts = artifactsApi(this);
   teams = teamsApi(this);
   concierge = conciergeApi(this);
+  speech = speechApi(this);
+  conversation = conversationApi(this);
+  appDecisions = appDecisionsApi(this);
   constructor(options) {
     this.url = options.url;
     this.#base = options.url.replace(/\/+$/, "");
@@ -795,7 +939,8 @@ class HubClient {
   }
   async request(method, pathname, options = {}) {
     const target = `${pathname}${queryString(options.query)}`;
-    const headers = { ...options.headers, authorization: `Bearer ${this.#token}`, accept: "application/json" };
+    const token = typeof this.#token === "string" ? this.#token : await this.#token();
+    const headers = { ...options.headers, authorization: `Bearer ${token}`, accept: "application/json" };
     if (options.body !== undefined)
       headers["content-type"] = "application/json";
     if (options.raw)
@@ -842,26 +987,26 @@ class HubClient {
     }
   }
   whoami(options = {}) {
-    return this.call("GET", `${AGENT}/whoami`, signalOf(options));
+    return this.call("GET", `${AGENT2}/whoami`, signalOf(options));
   }
   status(options = {}) {
-    return this.call("GET", `${AGENT}/status`, signalOf(options));
+    return this.call("GET", `${AGENT2}/status`, signalOf(options));
   }
   sessions(filter = {}) {
     const state = typeof filter.state === "string" ? filter.state : filter.state?.join(",");
-    return this.call("GET", `${AGENT}/sessions`, {
+    return this.call("GET", `${AGENT2}/sessions`, {
       query: { project: filter.project, state, machine: filter.machine, label: filter.label, q: filter.q },
       ...signalOf(filter)
     });
   }
   show(addr, options = {}) {
-    return this.call("GET", `${AGENT}/sessions/${segment(addr)}`, signalOf(options));
+    return this.call("GET", `${AGENT2}/sessions/${segment(addr)}`, signalOf(options));
   }
   log(addr, options = {}) {
-    return this.call("GET", `${AGENT}/sessions/${segment(addr)}/log`, { query: { n: options.n }, ...signalOf(options) });
+    return this.call("GET", `${AGENT2}/sessions/${segment(addr)}/log`, { query: { n: options.n }, ...signalOf(options) });
   }
   who(options = {}) {
-    return this.call("GET", `${AGENT}/who`, { query: { project: options.project, role: options.role === undefined ? undefined : bareRole(options.role), team: options.team }, ...signalOf(options) });
+    return this.call("GET", `${AGENT2}/who`, { query: { project: options.project, role: options.role === undefined ? undefined : bareRole(options.role), team: options.team }, ...signalOf(options) });
   }
   async* watch(options = {}) {
     const { signal } = options;
@@ -869,7 +1014,7 @@ class HubClient {
       return;
     let response;
     try {
-      response = await this.request("GET", `${AGENT}/watch`, { query: { blocked: options.blocked ? "1" : undefined, session: options.session, cursor: options.cursor }, ...signalOf(options) });
+      response = await this.request("GET", `${AGENT2}/watch`, { query: { blocked: options.blocked ? "1" : undefined, session: options.session, cursor: options.cursor }, ...signalOf(options) });
     } catch (cause) {
       if (signal?.aborted)
         return;
@@ -878,49 +1023,61 @@ class HubClient {
     yield* sseEvents(response, signal);
   }
   events(options = {}) {
-    return this.call("GET", `${AGENT}/events`, { query: { cursor: options.cursor, wait: options.wait, limit: options.limit, type: options.types, session: options.sessions }, ...signalOf(options) });
+    return this.call("GET", `${AGENT2}/events`, { query: { cursor: options.cursor, wait: options.wait, limit: options.limit, type: options.types, session: options.sessions }, ...signalOf(options) });
   }
   webhookCreate(input, options = {}) {
-    return this.call("POST", `${AGENT}/webhooks`, { body: input, ...signalOf(options) });
+    return this.call("POST", `${AGENT2}/webhooks`, { body: input, ...signalOf(options) });
   }
   webhooks(options = {}) {
-    return this.call("GET", `${AGENT}/webhooks`, signalOf(options));
+    return this.call("GET", `${AGENT2}/webhooks`, signalOf(options));
   }
   webhook(id, options = {}) {
-    return this.call("GET", `${AGENT}/webhooks/${segment(id)}`, signalOf(options));
+    return this.call("GET", `${AGENT2}/webhooks/${segment(id)}`, signalOf(options));
   }
   webhookDelete(id, options = {}) {
-    return this.call("DELETE", `${AGENT}/webhooks/${segment(id)}`, signalOf(options));
+    return this.call("DELETE", `${AGENT2}/webhooks/${segment(id)}`, signalOf(options));
+  }
+  subscribe(input, options = {}) {
+    return this.call("POST", `${AGENT2}/subscriptions`, { body: input, ...signalOf(options) });
+  }
+  subscriptions(options = {}) {
+    return this.call("GET", `${AGENT2}/subscriptions`, { query: { session: options.session }, ...signalOf(options) });
+  }
+  subscription(id, options = {}) {
+    return this.call("GET", `${AGENT2}/subscriptions/${segment(id)}`, signalOf(options));
+  }
+  unsubscribe(id, options = {}) {
+    return this.call("DELETE", `${AGENT2}/subscriptions/${segment(id)}`, signalOf(options));
   }
   setArchived(addr, archived, options = {}) {
-    return this.call("PUT", `${AGENT}/sessions/${segment(addr)}/archive`, { body: { archived }, ...signalOf(options) });
+    return this.call("PUT", `${AGENT2}/sessions/${segment(addr)}/archive`, { body: { archived }, ...signalOf(options) });
   }
   setPinned(addr, pinned, options = {}) {
-    return this.call("PUT", `${AGENT}/sessions/${segment(addr)}/pin`, { body: { pinned }, ...signalOf(options) });
+    return this.call("PUT", `${AGENT2}/sessions/${segment(addr)}/pin`, { body: { pinned }, ...signalOf(options) });
   }
   intent(addr, options = {}) {
-    return this.call("GET", `${AGENT}/sessions/${segment(addr)}/intent`, signalOf(options));
+    return this.call("GET", `${AGENT2}/sessions/${segment(addr)}/intent`, signalOf(options));
   }
   setIntent(addr, text, expectedRevision, options = {}) {
-    return this.call("PUT", `${AGENT}/sessions/${segment(addr)}/intent`, { body: { text, expectedRevision }, ...signalOf(options) });
+    return this.call("PUT", `${AGENT2}/sessions/${segment(addr)}/intent`, { body: { text, expectedRevision }, ...signalOf(options) });
   }
   previewArchiveInactive(inactiveFor, limit, options = {}) {
-    return this.call("POST", `${AGENT}/sessions/archive-inactive`, { body: { preview: true, inactiveFor, limit }, ...signalOf(options) });
+    return this.call("POST", `${AGENT2}/sessions/archive-inactive`, { body: { preview: true, inactiveFor, limit }, ...signalOf(options) });
   }
   archiveInactive(previewToken, options = {}) {
-    return this.call("POST", `${AGENT}/sessions/archive-inactive`, { body: { previewToken, confirm: true }, ...signalOf(options) });
+    return this.call("POST", `${AGENT2}/sessions/archive-inactive`, { body: { previewToken, confirm: true }, ...signalOf(options) });
   }
   name(name, options = {}) {
-    return this.call("POST", `${AGENT}/name`, { body: { name, ...options.session ? { session: options.session } : {} }, ...signalOf(options) });
+    return this.call("POST", `${AGENT2}/name`, { body: { name, ...options.session ? { session: options.session } : {} }, ...signalOf(options) });
   }
   claimRole(role, options = {}) {
-    return this.call("POST", `${AGENT}/roles/claim`, { body: { role: bareRole(role), ...options.exclusive ? { exclusive: true } : {}, ...roleTarget(options) }, ...signalOf(options) });
+    return this.call("POST", `${AGENT2}/roles/claim`, { body: { role: bareRole(role), ...options.exclusive ? { exclusive: true } : {}, ...roleTarget(options) }, ...signalOf(options) });
   }
   releaseRole(role, options = {}) {
-    return this.call("POST", `${AGENT}/roles/release`, { body: { role: bareRole(role), ...roleTarget(options) }, ...signalOf(options) });
+    return this.call("POST", `${AGENT2}/roles/release`, { body: { role: bareRole(role), ...roleTarget(options) }, ...signalOf(options) });
   }
   msg(to, text, options = {}) {
-    return this.call("POST", `${AGENT}/msg`, { body: { to, text, ...sendFields(options), ...options.all ? { all: true } : {} }, ...idempotent(options) });
+    return this.call("POST", `${AGENT2}/msg`, { body: { to, text, ...sendFields(options), ...options.all ? { all: true } : {} }, ...idempotent(options) });
   }
   async ask(to, text, options = {}) {
     if (options.all && options.wait !== undefined)
@@ -937,7 +1094,7 @@ class HubClient {
       ...options.wait !== undefined ? { wait: first } : {},
       ...decisionFields(options)
     };
-    const asked = await this.call("POST", `${AGENT}/ask`, { body, ...idempotent(options) });
+    const asked = await this.call("POST", `${AGENT2}/ask`, { body, ...idempotent(options) });
     if ("sent" in asked)
       return asked;
     let current = asked;
@@ -949,28 +1106,28 @@ class HubClient {
     return current;
   }
   message(id, options = {}) {
-    return this.call("GET", `${AGENT}/messages/${segment(id)}`, { query: { wait: options.wait }, ...signalOf(options) });
+    return this.call("GET", `${AGENT2}/messages/${segment(id)}`, { query: { wait: options.wait }, ...signalOf(options) });
   }
   reply(id, text, options = {}) {
-    return this.call("POST", `${AGENT}/reply`, { body: { replyTo: id, text, ...options.wake !== undefined ? { wake: options.wake } : {} }, ...signalOf(options) });
+    return this.call("POST", `${AGENT2}/reply`, { body: { replyTo: id, text, ...options.wake !== undefined ? { wake: options.wake } : {} }, ...signalOf(options) });
   }
   decline(id, why, options = {}) {
-    return this.call("POST", `${AGENT}/decline`, { body: { replyTo: id, why }, ...signalOf(options) });
+    return this.call("POST", `${AGENT2}/decline`, { body: { replyTo: id, why }, ...signalOf(options) });
   }
   inbox(options = {}) {
-    return this.call("GET", `${AGENT}/inbox`, signalOf(options));
+    return this.call("GET", `${AGENT2}/inbox`, signalOf(options));
   }
   mute(session, options = {}) {
-    return this.call("POST", `${AGENT}/mute`, { body: { session }, ...signalOf(options) });
+    return this.call("POST", `${AGENT2}/mute`, { body: { session }, ...signalOf(options) });
   }
   unmute(session, options = {}) {
-    return this.call("POST", `${AGENT}/unmute`, { body: { session }, ...signalOf(options) });
+    return this.call("POST", `${AGENT2}/unmute`, { body: { session }, ...signalOf(options) });
   }
   decisions(options = {}) {
-    return this.call("GET", `${AGENT}/decisions`, { query: { state: options.state }, ...signalOf(options) });
+    return this.call("GET", `${AGENT2}/decisions`, { query: { state: options.state }, ...signalOf(options) });
   }
   decision(id, options = {}) {
-    return this.call("GET", `${AGENT}/decisions/${segment(id)}`, signalOf(options));
+    return this.call("GET", `${AGENT2}/decisions/${segment(id)}`, signalOf(options));
   }
   answerDecision(id, answer) {
     const { signal: _signal, ...body } = answer;
@@ -978,16 +1135,16 @@ class HubClient {
   }
   approve(addr, requestID, options = {}) {
     const body = { requestID, ...options.always ? { always: true } : {}, ...options.recommend ? { recommend: true } : {}, ...whyField(options) };
-    return this.call("POST", `${AGENT}/sessions/${segment(addr)}/approve`, { body, ...signalOf(options) });
+    return this.call("POST", `${AGENT2}/sessions/${segment(addr)}/approve`, { body, ...signalOf(options) });
   }
   deny(addr, requestID, options = {}) {
-    return this.call("POST", `${AGENT}/sessions/${segment(addr)}/deny`, { body: { requestID, ...whyField(options) }, ...signalOf(options) });
+    return this.call("POST", `${AGENT2}/sessions/${segment(addr)}/deny`, { body: { requestID, ...whyField(options) }, ...signalOf(options) });
   }
   answer(addr, formID, answer, options = {}) {
-    return this.call("POST", `${AGENT}/sessions/${segment(addr)}/answer`, { body: { formID, answer, ...whyField(options) }, ...signalOf(options) });
+    return this.call("POST", `${AGENT2}/sessions/${segment(addr)}/answer`, { body: { formID, answer, ...whyField(options) }, ...signalOf(options) });
   }
   cancelForm(addr, formID, options = {}) {
-    return this.call("POST", `${AGENT}/sessions/${segment(addr)}/answer`, { body: { formID, cancel: true, ...whyField(options) }, ...signalOf(options) });
+    return this.call("POST", `${AGENT2}/sessions/${segment(addr)}/answer`, { body: { formID, cancel: true, ...whyField(options) }, ...signalOf(options) });
   }
   prompt(addr, text, options = {}) {
     const body = {
@@ -997,38 +1154,38 @@ class HubClient {
       ...options.wake !== undefined ? { wake: options.wake } : {},
       ...whyField(options)
     };
-    return this.call("POST", `${AGENT}/sessions/${segment(addr)}/prompt`, { body, ...signalOf(options) });
+    return this.call("POST", `${AGENT2}/sessions/${segment(addr)}/prompt`, { body, ...signalOf(options) });
   }
   stop(addr, options = {}) {
-    return this.call("POST", `${AGENT}/sessions/${segment(addr)}/stop`, { body: whyField(options), ...signalOf(options) });
+    return this.call("POST", `${AGENT2}/sessions/${segment(addr)}/stop`, { body: whyField(options), ...signalOf(options) });
   }
   grants(options = {}) {
-    return this.call("GET", `${AGENT}/grants`, signalOf(options));
+    return this.call("GET", `${AGENT2}/grants`, signalOf(options));
   }
   grant(id, options = {}) {
-    return this.call("GET", `${AGENT}/grants/${segment(id)}`, signalOf(options));
+    return this.call("GET", `${AGENT2}/grants/${segment(id)}`, signalOf(options));
   }
   createGrant(spec, options = {}) {
-    return this.call("POST", `${AGENT}/grants`, { body: spec, ...signalOf(options) });
+    return this.call("POST", `${AGENT2}/grants`, { body: spec, ...signalOf(options) });
   }
   updateGrant(id, spec, options = {}) {
-    return this.call("PUT", `${AGENT}/grants/${segment(id)}`, { body: spec, ...signalOf(options) });
+    return this.call("PUT", `${AGENT2}/grants/${segment(id)}`, { body: spec, ...signalOf(options) });
   }
   revokeGrant(id, options = {}) {
-    return this.call("DELETE", `${AGENT}/grants/${segment(id)}`, signalOf(options));
+    return this.call("DELETE", `${AGENT2}/grants/${segment(id)}`, signalOf(options));
   }
   requestGrant(grant, why, options = {}) {
-    return this.call("POST", `${AGENT}/grants/requests`, { body: { grant, why }, ...signalOf(options) });
+    return this.call("POST", `${AGENT2}/grants/requests`, { body: { grant, why }, ...signalOf(options) });
   }
   createAppToken(input = {}) {
     const { signal: _signal, ...body } = input;
-    return this.call("POST", `${AGENT}/app-tokens`, { body, ...signalOf(input) });
+    return this.call("POST", `${AGENT2}/app-tokens`, { body, ...signalOf(input) });
   }
   appTokens(options = {}) {
-    return this.call("GET", `${AGENT}/app-tokens`, signalOf(options));
+    return this.call("GET", `${AGENT2}/app-tokens`, signalOf(options));
   }
   revokeAppToken(id, options = {}) {
-    return this.call("DELETE", `${AGENT}/app-tokens/${segment(id)}`, signalOf(options));
+    return this.call("DELETE", `${AGENT2}/app-tokens/${segment(id)}`, signalOf(options));
   }
 }
 // packages/sdk/src/envelope.ts
@@ -1065,13 +1222,15 @@ function escapeBody(text) {
 `).map((line) => FORGEABLE.test(line) ? `\\${line}` : line).join(`
 `);
 }
+var NOTICE_ONLY_APPS = new Set(["subscriptions"]);
+var noticeOnly = (from) => from.kind === "app" && NOTICE_ONLY_APPS.has(from.tokenID);
 function renderEnvelope(input) {
   const { id, kind } = input;
   const to = sanitizeLabel(input.to);
   const target = kind === "reply" || kind === "decline" ? `to you · re ${sanitizeLabel(input.replyTo ?? "")}` : to.startsWith("@@") ? `to ${to} → you` : "to you";
   const header = `[hub] ${kind} from ${partyLabel(input.from)} ${target} · ${stamp(input.at)} · ${id}`;
   const boundary = `----- ${id} -----`;
-  const hint = kind === "ask" ? `↩ hub reply ${id} "…" · hub decline ${id} --why "…"${input.expiresAt === undefined ? "" : ` · expires ${stamp(input.expiresAt)}`}` : `↩ hub reply ${id} "…"`;
+  const hint = noticeOnly(input.from) ? "↩ a notice: no reply needed (hub unsubscribe <sub_…> stops it)" : kind === "ask" ? `↩ hub reply ${id} "…" · hub decline ${id} --why "…"${input.expiresAt === undefined ? "" : ` · expires ${stamp(input.expiresAt)}`}` : `↩ hub reply ${id} "…"`;
   return [header, boundary, escapeBody(input.text), boundary, hint].join(`
 `);
 }
@@ -3591,7 +3750,7 @@ function profileTemplateParts(template) {
 
 // packages/protocol/src/concierge.ts
 var SESSION_CONTEXT_FEATURE = "sessionContext";
-var SESSION_CONTEXT_KEYS = ["instructions", "board", "notes"];
+var SESSION_CONTEXT_KEYS = ["instructions", "board", "notes", "frontBoard"];
 var SESSION_CONTEXT_LIMITS = { partChars: 40000, denyGlobs: 50, globChars: 100, allowTools: 50 };
 var isRecord3 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 var TOOL_GLOB = /^[A-Za-z0-9_.*-]+$/;
@@ -4166,6 +4325,19 @@ var RECORDING_LIMITS = {
   hubFlushMs: 2000,
   hubFlushEvents: 100
 };
+// packages/protocol/src/app-front.ts
+var ACCESS_TOKEN_TTL_MS = 60 * 60000;
+var REFRESH_TOKEN_IDLE_MS = 30 * 24 * 60 * 60000;
+var CONNECT_FLOW_TTL_MS = 10 * 60000;
+var APP_STREAM_LIMITS = {
+  heartbeatMs: 20000,
+  retryMs: 2000,
+  recheckMs: 30000,
+  bufferMaxBytes: 1 << 20,
+  streamsPerApp: 4,
+  streamsPerUser: 20
+};
+var LOOPBACK_HOSTS2 = new Set(["127.0.0.1", "[::1]", "localhost"]);
 // packages/protocol/src/index.ts
 var PROTOCOL_VERSION = 1;
 var FORM_ANSWER_MAX_KEYS = 50;
@@ -4249,10 +4421,12 @@ var IMPLIED_OPENCODE_FEATURES = [
   "expose",
   "create"
 ];
-var OPTIONAL_SPOKE_FEATURES = [...IMPLIED_OPENCODE_FEATURES, "autoName", "sessionTokens", "deliver", "hubPrompt", "permissionMessage", "actTokens", "launch", "fork", "revert", "dismissError", "timelineMedia", PREVIEW_BUNDLE_FEATURE, "voiceFront"];
+var OPTIONAL_SPOKE_FEATURES = [...IMPLIED_OPENCODE_FEATURES, "autoName", "sessionTokens", "deliver", "hubPrompt", "permissionMessage", "actTokens", "launch", "fork", "revert", "dismissError", "timelineMedia", PREVIEW_BUNDLE_FEATURE, "voiceFront", "conciergeFront", "inboxCarried"];
 var CORE_OPS = ["turn", "steer", "interrupt", "stop", "permission", "form"];
 var KNOWN_SPOKE_FEATURES = [...CORE_OPS, ...OPTIONAL_SPOKE_FEATURES, "turnEvents", PROFILE_APPLY_FEATURE, SESSION_CONTEXT_FEATURE];
 var SPOKE_FEATURES = [...OPTIONAL_SPOKE_FEATURES, PROFILE_APPLY_FEATURE, SESSION_CONTEXT_FEATURE];
+var RELAY_TEXT_MAX = 4000;
+var FRONT_UPDATE_MAX = 8000;
 var SESSION_TOKENS_MAX = 500;
 var SESSION_TOKEN_MAX_CHARS = 4096;
 var MESSAGE_KINDS = ["msg", "ask", "reply", "decline", "primer", "decision", "prompt"];
@@ -4269,6 +4443,8 @@ function featureForOp(op) {
       return "revert";
     case "removeFront":
       return "voiceFront";
+    case "frontUpdate":
+      return "conciergeFront";
     default:
       return op;
   }
@@ -4359,6 +4535,9 @@ function isSpokeRequest(v) {
     return nonEmpty(v.sessionID);
   if (v.op === "openLink")
     return (v.sessionID === undefined || nonEmpty(v.sessionID)) && (v.voice === undefined || typeof v.voice === "boolean");
+  if (v.op === "relayToSession") {
+    return nonEmpty(v.frontID) && v.frontID.length <= 300 && nonEmpty(v.session) && v.session.length <= 300 && str2(v.text) && v.text.trim().length > 0 && v.text.length <= RELAY_TEXT_MAX && (v.previous === undefined || typeof v.previous === "boolean") && (v.confirm === undefined || typeof v.confirm === "boolean");
+  }
   return false;
 }
 var PROMPT_IMAGE_MIMES = ["image/png", "image/jpeg", "image/webp", "image/gif"];
@@ -4483,6 +4662,8 @@ function isServerRequest(v) {
     case "dismissError":
     case "removeFront":
       return nonEmpty(v.sessionID);
+    case "frontUpdate":
+      return nonEmpty(v.sessionID) && str2(v.text) && v.text.trim().length > 0 && v.text.length <= FRONT_UPDATE_MAX && (v.finished === undefined || typeof v.finished === "boolean");
     default:
       return false;
   }
@@ -4591,8 +4772,22 @@ var JOB_STATUSES = new Set(["running", "exited", "timeout", "killed"]);
 var DEFAULT_LIST = Object.freeze({ days: 30, max: 100 });
 var LIST_LIMITS = { days: 365, max: 500 };
 var DEFAULT_SERVER = "http://127.0.0.1:4097";
-var DEFAULT_SUBAGENT = "general";
-var AGENT_ID = /^[A-Za-z0-9_.-]{1,64}$/;
+var OBSOLETE_CONFIG_KEYS = ["subagent", "workModel"];
+var OBSOLETE_WHY = {
+  subagent: "the voice agent that delegated to it is gone",
+  workModel: "the voice agent whose workers used it is gone"
+};
+var warnedKeys = new Set;
+function warnObsoleteKeys(raw, log = console.warn, seen = warnedKeys) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+    return;
+  for (const key of OBSOLETE_CONFIG_KEYS) {
+    if (!(key in raw) || seen.has(key))
+      continue;
+    seen.add(key);
+    log(`[hub] config.json: "${key}" is obsolete (${OBSOLETE_WHY[key]}: Voice mode always uses the voice front now); it is ignored and removed on the next save`);
+  }
+}
 var MODEL_REF = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.:\/-]+(?:#[A-Za-z0-9_.-]+)?$/;
 var modelRef = (v) => typeof v === "string" && v.length <= 200 && MODEL_REF.test(v) ? v : undefined;
 function configPath(env = process.env, home = homedir()) {
@@ -4609,7 +4804,7 @@ function prepareConfigPath(env = process.env, home = homedir(), log) {
   return file;
 }
 function defaults(machineName) {
-  return { server: DEFAULT_SERVER, mode: "off", sessions: [], machineName, subagent: DEFAULT_SUBAGENT, autoStartLocalHub: true, herdr: true, list: { ...DEFAULT_LIST } };
+  return { server: DEFAULT_SERVER, mode: "off", sessions: [], machineName, autoStartLocalHub: true, herdr: true, list: { ...DEFAULT_LIST } };
 }
 function normalize(raw, machineName) {
   const base = defaults(machineName);
@@ -4624,12 +4819,10 @@ function normalize(raw, machineName) {
     mode,
     sessions,
     machineName: typeof r.machineName === "string" && r.machineName ? r.machineName : machineName,
-    subagent: typeof r.subagent === "string" && AGENT_ID.test(r.subagent) ? r.subagent : base.subagent,
     autoStartLocalHub: r.autoStartLocalHub !== false,
     herdr: r.herdr !== false,
     list: listWindow(r.list),
     ...modelRef(r.voiceModel) ? { voiceModel: modelRef(r.voiceModel) } : {},
-    ...modelRef(r.workModel) ? { workModel: modelRef(r.workModel) } : {},
     ...typeof r.machineID === "string" && r.machineID ? { machineID: r.machineID } : {},
     ...typeof r.token === "string" && r.token ? { token: r.token } : {}
   };
@@ -4644,7 +4837,9 @@ function listWindow(raw) {
 }
 function readConfig(file, machineName) {
   try {
-    return normalize(JSON.parse(readFileSync3(file, "utf8")), machineName);
+    const raw = JSON.parse(readFileSync3(file, "utf8"));
+    warnObsoleteKeys(raw);
+    return normalize(raw, machineName);
   } catch {
     return defaults(machineName);
   }
@@ -5721,7 +5916,7 @@ function normalizeDirectories(raw, field, problems, options) {
   }
   return out;
 }
-var LOOPBACK_HOSTS2 = new Set(["127.0.0.1", "[::1]", "localhost"]);
+var LOOPBACK_HOSTS3 = new Set(["127.0.0.1", "[::1]", "localhost"]);
 function loopbackOrigin(raw) {
   if (typeof raw !== "string" || raw.length > 2048)
     return;
@@ -5733,7 +5928,7 @@ function loopbackOrigin(raw) {
   }
   if (url.protocol !== "http:" && url.protocol !== "https:")
     return;
-  if (url.username || url.password || !LOOPBACK_HOSTS2.has(url.hostname))
+  if (url.username || url.password || !LOOPBACK_HOSTS3.has(url.hostname))
     return;
   if (url.pathname !== "/" && url.pathname !== "" || url.search || url.hash)
     return;
@@ -9227,7 +9422,7 @@ import { arch as osArch, platform as osPlatform } from "node:os";
 // packages/node/package.json
 var package_default2 = {
   name: "@huynle/hub-node",
-  version: "0.9.2",
+  version: "0.10.0",
   private: true,
   description: "`hub node`: the per-machine daemon that prepares, collects and cleans up launch workspaces (internal; shipped inside @huynle/hub, not published on its own).",
   license: "MIT",
@@ -10682,7 +10877,7 @@ import path14 from "node:path";
 // packages/runtime-openshell/package.json
 var package_default3 = {
   name: "@huynle/hub-runtime-openshell",
-  version: "0.9.2",
+  version: "0.10.0",
   private: true,
   description: "The `openshell` runtime of `hub node`: launches in NVIDIA OpenShell sandboxes, driven through the openshell CLI (internal; shipped inside @huynle/hub, not published on its own).",
   license: "MIT",
@@ -12337,6 +12532,46 @@ function openShellCheckText(report) {
 `);
 }
 
+// packages/cli/src/subscriptions.ts
+var SUBSCRIBE_FLAGS = { type: "multi", delivery: "string", batch: "string", expires: "string", "max-per-hour": "string", subscriber: "string", note: "string" };
+var DELIVERIES2 = ["queue", "steer", "silent"];
+var safe2 = (v, max = 120) => sanitizeLabel(String(v), max);
+function subscribeInput(addrs, flags) {
+  if (!addrs.length)
+    throw new UsageError("needs at least one address (a session, @@role, #team or children)");
+  const delivery = str(flags, "delivery");
+  if (delivery !== undefined && !DELIVERIES2.includes(delivery))
+    throw new UsageError(`--delivery is one of ${DELIVERIES2.join(", ")}`);
+  const batch = str(flags, "batch");
+  const expires = str(flags, "expires");
+  const max = str(flags, "max-per-hour");
+  if (max !== undefined && !/^\d+$/.test(max))
+    throw new UsageError("--max-per-hour takes a whole number (1–120)");
+  const types = flags.type;
+  const subscriber = str(flags, "subscriber");
+  const note = str(flags, "note");
+  return {
+    to: addrs.length === 1 ? addrs[0] : [...addrs],
+    ...types?.length ? { types: types.flatMap((t) => t.split(",")).map((t) => t.trim()).filter(Boolean) } : {},
+    ...delivery !== undefined ? { delivery } : {},
+    ...batch !== undefined ? { batch: durationArg(batch, "--batch") } : {},
+    ...expires !== undefined ? { expires: durationArg(expires, "--expires") } : {},
+    ...max !== undefined ? { maxPerHour: Number(max) } : {},
+    ...subscriber !== undefined ? { subscriber } : {},
+    ...note !== undefined ? { note } : {}
+  };
+}
+var targets = (s) => s.targets.map((t) => t.kind === "children" ? "its subagents" : safe2(t.addr, 80)).join(", ");
+var iso4 = (ms) => new Date(ms).toISOString().slice(0, 16) + "Z";
+function subscriptionLine(s) {
+  const extra = [safe2(s.delivery, 10), `batch ${Math.round(s.batchMs / 1000)}s`, `≤${s.maxPerHour}/h`, `expires ${iso4(s.expiresAt)}`, `${s.stats.delivered} delivered`, ...s.pending ? [`${s.pending} pending`] : [], ...s.stats.dropped ? [`${s.stats.dropped} dropped`] : [], ...s.stats.suppressed ? [`${s.stats.suppressed} loop-suppressed`] : []];
+  return `${safe2(s.id, 40)}  ${safe2(s.subscriber, 80)} ← ${targets(s)}  [${s.types.map((t) => safe2(t, 40)).join(",")}]  ${extra.join(" · ")}${s.note ? `  "${safe2(s.note, 200)}"` : ""}`;
+}
+var subscribedText = (b) => `subscribed ${subscriptionLine(b.subscription)}
+the subscriber gets one hub message per batch window; stop with \`hub unsubscribe ${safe2(b.subscription.id, 40)}\``;
+var subscriptionsText = (b) => b.subscriptions.length ? b.subscriptions.map(subscriptionLine).join(`
+`) : "no subscriptions";
+
 // packages/claude-code/src/main.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
 import { realpathSync as realpathSync5 } from "node:fs";
@@ -13022,7 +13257,7 @@ function buildHarnessHello(options) {
 }
 // packages/spoke-sdk/src/harness-spoke.ts
 var INSPECT2 = Symbol.for("nodejs.util.inspect.custom");
-var MODIFIER_NEEDS = { permissionMessage: "permission", launch: "create", hubPrompt: "deliver", turnEvents: null };
+var MODIFIER_NEEDS = { permissionMessage: "permission", launch: "create", hubPrompt: "deliver", turnEvents: null, inboxCarried: null };
 var ALWAYS = ["sessionTokens", "actTokens"];
 var CORE2 = CORE_OPS;
 
@@ -13445,7 +13680,7 @@ var LINE_MAX = 16 * 1024 * 1024;
 var STDERR_KEEP = 2000;
 var record2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v) ? v : {};
 var sleep6 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-var AGENT2 = /^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/;
+var AGENT3 = /^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/;
 var MODEL = /^[A-Za-z0-9][A-Za-z0-9._:@/\[\]-]{0,299}$/;
 var PROVIDERS = new Set(["anthropic", "claude-code"]);
 function launchDirectory(directory, roots) {
@@ -13475,7 +13710,7 @@ function launchDirectory(directory, roots) {
 function launchAgent(agent) {
   if (agent === undefined)
     return;
-  if (!AGENT2.test(agent))
+  if (!AGENT3.test(agent))
     throw new Error(`Claude Code cannot take agent ${JSON.stringify(agent)} (letters, digits, ".", "_" and "-")`);
   return agent;
 }
@@ -14640,7 +14875,7 @@ import path23 from "node:path";
 // packages/claude-code/package.json
 var package_default4 = {
   name: "@huynle/hub-claude-code",
-  version: "0.9.2",
+  version: "0.10.0",
   private: true,
   description: "The Claude Code hooks spoke: per-user daemon, hook bridge, plugin dir, `hub claude` wrapper and daemon-backed MCP server (internal; shipped inside @huynle/hub, not published on its own).",
   license: "MIT",
@@ -14929,7 +15164,7 @@ import path26 from "node:path";
 // packages/preset/package.json
 var package_default5 = {
   name: "@huynle/hub-preset",
-  version: "0.9.2",
+  version: "0.10.0",
   private: true,
   description: "The preset spoke: drives a harness without a spoke of its own through a terminal pane (tmux), described by a data-only preset; official presets in presets/ (internal; shipped inside @huynle/hub, not published on its own).",
   license: "MIT",
@@ -15454,7 +15689,7 @@ import { openSync as openSync6, closeSync as closeSync6, readFileSync as readFil
 // packages/codex/package.json
 var package_default6 = {
   name: "@huynle/hub-codex",
-  version: "0.9.2",
+  version: "0.10.0",
   private: true,
   description: "The Codex app-server spoke: attaches to Codex's app-server (its own over stdio, and the shared daemon's socket when present), and the `hub codex` wrapper (internal; shipped inside @huynle/hub, not published on its own).",
   license: "MIT",
@@ -16026,7 +16261,7 @@ class CodexSessions {
     const thread = this.#thread(req.sessionID);
     if (thread.turnID)
       throw new Error("The Codex session is busy (a turn is running); steer it instead");
-    const turnID = await this.#startTurn(thread, input(req.text, req.images), "user");
+    const turnID = await this.#startTurn(thread, input(req.text, req.images), "carried");
     const end = await this.#waitTurn(thread, turnID);
     const reply = thread.reply?.text ?? "";
     if (!end)
@@ -16038,7 +16273,7 @@ class CodexSessions {
   async steer(req) {
     const thread = this.#thread(req.sessionID);
     const id = inboxID();
-    await this.#steerOrStart(thread, input(req.text, req.images), "user", id);
+    await this.#steerOrStart(thread, input(req.text, req.images), "carried", id);
     return { inboxID: id };
   }
   async interrupt(req) {
@@ -16224,7 +16459,9 @@ class CodexSessions {
       const origin = clientID ? thread.inputs.get(clientID) : undefined;
       if (clientID)
         thread.inputs.delete(clientID);
-      this.#emit({ type: "session.inbox.delivered", data: { sessionID: thread.hubID, inboxID: plainID3(clientID && origin ? clientID : item.id), origin: origin ?? "user" } });
+      const inboxID = plainID3(clientID && origin ? clientID : item.id);
+      const data = origin === "hub" ? { origin: "hub" } : origin === "carried" ? { origin: "user", carried: true } : { origin: "user" };
+      this.#emit({ type: "session.inbox.delivered", data: { sessionID: thread.hubID, inboxID, ...data } });
       return;
     }
     if (!TOOL_ITEMS.has(item.type))
@@ -16610,7 +16847,7 @@ function startCodexSpoke(options) {
       profileApply: profiles.handle
     },
     deliver: (req) => sessions.deliver(req),
-    features: ["hubPrompt", "launch", "turnEvents"],
+    features: ["hubPrompt", "launch", "turnEvents", "inboxCarried"],
     onState: (state, error) => log(`hub connection ${state}${error ? `: ${error}` : ""}`),
     ...options.socket ? { socket: options.socket } : {},
     ...options.backoff ? { backoff: options.backoff } : {}
@@ -23277,7 +23514,7 @@ var PROVIDER_TIMEOUT_MS = 90000;
 var MAX_OUTPUT3 = 1024 * 1024;
 var VERSION_IN = /(?:^|[^0-9.])v?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)(?![0-9A-Za-z.-])/;
 var MODEL_LINE = /^[A-Za-z0-9][A-Za-z0-9._-]*\/\S+$/;
-var safe2 = (detail) => isSecretValue(detail) ? "(details withheld: they looked like they carried a credential)" : detail.replace(/\s+/g, " ").trim().slice(0, 200);
+var safe3 = (detail) => isSecretValue(detail) ? "(details withheld: they looked like they carried a credential)" : detail.replace(/\s+/g, " ").trim().slice(0, 200);
 var errorText5 = (error) => error instanceof Error ? error.message : String(error);
 async function runOnce(options, context, argv, timeoutMs) {
   try {
@@ -23352,7 +23589,7 @@ async function verifyOpencode(context, options) {
     results = [await versionProbe2(options, context), await providerProbe(options, context), await spokeProbe2(options, context)];
   }
   const observedAt = context.now();
-  return { harness: "opencode", probes: results.map((p) => ({ ...p, observedAt, ...p.detail !== undefined ? { detail: safe2(p.detail) } : {} })) };
+  return { harness: "opencode", probes: results.map((p) => ({ ...p, observedAt, ...p.detail !== undefined ? { detail: safe3(p.detail) } : {} })) };
 }
 function locateOpencodeBinary(probe) {
   const snap = discover(probe, { now: 0 });
@@ -25999,7 +26236,7 @@ Reading
 
 Identity
   hub whoami                          who this credential is
-  hub who [--project P] [--role R] [--team T]  named and role-holding sessions (team members: their teams)
+  hub who [--project P] [--role R] [--team T]  online, named and role-holding sessions (team members: their teams)
   hub name <@name> [--session <addr>]
   hub intent <addr> [text… | --clear]  what the session is for (one line, ≤ 280 characters, untrusted);
                                       no text: show it (else its title); a session token sets only its own
@@ -26116,6 +26353,15 @@ Codex (app-server spoke)
   hub codex-spoke install|uninstall [--dry-run] | status
                                       the spoke service as a launchd agent / systemd user unit (printed, never loaded)
 
+Subscriptions (a session hears other sessions' events as batched hub messages; docs/subscriptions.md)
+  hub subscribe <addr|@@role|#team|children>... [--type T]... [--delivery queue|steer|silent] [--batch 30s]
+         [--expires 1d] [--max-per-hour N] [--subscriber <addr>] [--note "…"]
+                                      types: state, state:idle, blocker, message, launch, naming, presence,
+                                      manage, exact types or * (default state, blocker); in a session's shell it
+                                      subscribes itself, a login names --subscriber (app tokens: events:subscribe)
+  hub subscriptions [--session <addr>]   yours (or what a session subscribes to and what follows it)
+  hub unsubscribe <subID>
+
 Concierge watchlist (users; app tokens: sessions:read to show, sessions:manage to change)
   hub watchlist [show]                what the Concierge watches now, and why; its config and revision
   hub watchlist watch|unwatch <addr>  watch a session (a subagent: its root), or stop
@@ -26699,6 +26945,31 @@ ${openedText(body.decision)}` : outcome.text);
       answer(context, body, (b) => watchlistVerbText("unmute", b));
     }
   },
+  subscribe: {
+    args: ["addr..."],
+    flags: SUBSCRIBE_FLAGS,
+    async handle(context) {
+      const input = subscribeInput(context.parsed.args, context.parsed.flags);
+      const body = await context.hub((hub) => hub.subscribe(input));
+      answer(context, body, subscribedText);
+    }
+  },
+  subscriptions: {
+    flags: { session: "string" },
+    async handle(context) {
+      const session = str(context.parsed.flags, "session");
+      const body = await context.hub((hub) => hub.subscriptions(session !== undefined ? { session } : {}));
+      answer(context, body, subscriptionsText);
+    }
+  },
+  unsubscribe: {
+    args: ["<subID>"],
+    async handle(context) {
+      const id = context.parsed.args[0];
+      await context.hub((hub) => hub.unsubscribe(id));
+      answer(context, { removed: id }, () => `removed ${id}`);
+    }
+  },
   logout: {
     async handle(context) {
       const file = loginFile(context.io.env, context.io.home);