viber-channel 0.8.16 → 0.8.19

package/lib/agent_tools.ts

@@ -17,7 +17,7 @@
  * MCP tool-result shape. It does NOT hold state.
  */
 import { postMessage, parseArtifact, type Artifact } from "./messages.js";
-import { listPeersAuto, openDm, type OpenDmResult } from "./peers.js";
+import { listPeersAuto, openDm, type OpenDmResult, type PeerFilters } from "./peers.js";
 import { ConversationTokenExpiredError } from "./messages.js";
 import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 
@@ -98,12 +98,27 @@ function errorText(s: string): AgentToolResult {
  * entry then carries a `project` field); a regular instance transparently
  * falls back to its own project (unchanged behaviour, no `project` field).
  */
-export async function listAgents(ctx: AgentToolsContext): Promise<AgentToolResult> {
+export async function listAgents(
+  ctx: AgentToolsContext,
+  args: Record<string, unknown> = {},
+): Promise<AgentToolResult> {
   if (!ctx.instanceToken()) {
     return errorText("Channel not ready: no instance identity yet.");
   }
+  // #501 step-05 — optional filters, applied SERVER-side. Without them a
+  // dev-lead looking for its two reviewers pulls every agent the project ever
+  // created (30 rows for 5 live ones, measured), in a loop.
+  const filters: PeerFilters = {};
+  if (args.online === true) filters.online = true;
+  if (typeof args.label_prefix === "string" && args.label_prefix !== "") {
+    filters.labelPrefix = args.label_prefix;
+  }
   try {
-    const { peers, scope } = await listPeersAuto(ctx.baseUrl(), ctx.instanceToken());
+    const { peers, scope, presenceStatus } = await listPeersAuto(
+      ctx.baseUrl(),
+      ctx.instanceToken(),
+      filters,
+    );
     // Project only what the model needs to pick a peer (drop last_seen /
     // active_conversation_id — available over the wire if a future tool needs them).
     const summary = peers.map((p) => ({
@@ -114,13 +129,22 @@ export async function listAgents(ctx: AgentToolsContext): Promise<AgentToolResul
       // Present only in the user-scoped (orchestrator) listing.
       ...(p.project_name !== undefined ? { project: p.project_name } : {}),
     }));
+    // An `online` filter under an unreadable presence source would come back
+    // empty and read as "nobody is alive" — the false green in listing form.
+    // The server drops the filter in that case; say so rather than let the
+    // caller believe it was applied.
+    const presenceWarning =
+      filters.online === true && presenceStatus === "unavailable"
+        ? "WARNING: the presence source is unavailable, so the `online` filter was NOT applied — " +
+          "`online` values below are unknown, not observed.\n\n"
+        : "";
     const body =
       summary.length === 0
         ? scope === "user"
           ? "No other agents are currently registered in any of your projects."
           : "No other agents are currently registered in this project."
         : JSON.stringify(summary, null, 2);
-    return text(body);
+    return text(`${presenceWarning}${body}`);
   } catch (err) {
     return errorText(`list_agents failed: ${String(err)}`);
   }

package/lib/auth.ts

@@ -1,5 +1,5 @@
 import { chmodSync, readFileSync, writeFileSync } from "node:fs";
-import { isAbsolute, join } from "node:path";
+import { basename, isAbsolute, join } from "node:path";
 
 export interface AuthJson {
   schema_version: number;
@@ -63,15 +63,81 @@ export function isDevBackend(
  * silently authenticated against the dev backend with STAGING creds (`-32000`)
  * because only `VIBER_BASE_URL` was set and the auth file defaulted to staging.
  */
-export function authFilePath(cwd: string = process.cwd()): string {
+export function authFilePath(
+  cwd: string = process.cwd(),
+  baseUrl: string = process.env.VIBER_BASE_URL ?? "",
+): string {
+  const qa = isQaBackend(baseUrl);
   const override = process.env.VIBER_AUTH_FILE;
   if (override !== undefined && override.trim() !== "") {
+    assertAuthFileMatchesBackend(basename(override), qa);
     return isAbsolute(override) ? override : join(cwd, override);
   }
-  const file = isDevBackend() ? "dev.auth.json" : "auth.json";
+  const file = isDevBackend(baseUrl) ? "dev.auth.json" : qa ? QA_AUTH_FILE : "auth.json";
   return join(cwd, ".viber", file);
 }
 
+/**
+ * #613: the auth file `connect` must write for a claim URL. The CLAIM decides
+ * for qa: `connect https://viber-qa.dgypx.dev/connect/<id>` run with no
+ * VIBER_BASE_URL would otherwise derive the file from the (empty) env and write
+ * qa credentials into `auth.json`, overwriting STAGING's. A set env that
+ * contradicts the claim (qa vs not qa) is refused. Non-qa claims keep the
+ * pre-#613 behavior (file derived from the env) unchanged.
+ */
+export function connectAuthPath(
+  claimBaseUrl: string,
+  cwd: string = process.cwd(),
+  envBaseUrl: string = process.env.VIBER_BASE_URL ?? "",
+): string {
+  const claimQa = isQaBackend(claimBaseUrl);
+  if (envBaseUrl.trim() !== "" && claimQa !== isQaBackend(envBaseUrl)) {
+    throw new Error(
+      `claim URL ${claimBaseUrl} and VIBER_BASE_URL=${envBaseUrl} disagree on the qa backend; refusing to write credentials`,
+    );
+  }
+  return authFilePath(cwd, claimQa ? claimBaseUrl : envBaseUrl);
+}
+
+/** #613: the qa web host. Matched EXACTLY (hostname), never by substring. */
+export const QA_WEB_HOST = "viber-qa.dgypx.dev";
+export const QA_AUTH_FILE = "qa.auth.json";
+
+/**
+ * #613: true only when `VIBER_BASE_URL` is the qa web host. Same raw-env
+ * classification rule as {@link isDevBackend} (never the API transport host),
+ * but an exact hostname match: a substring test would let any host containing
+ * "qa" read qa credentials, or a qa host fall through to STAGING's auth.json.
+ */
+export function isQaBackend(
+  baseUrl: string = process.env.VIBER_BASE_URL ?? "",
+): boolean {
+  try {
+    return new URL(baseUrl).hostname === QA_WEB_HOST;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * #613: a `VIBER_AUTH_FILE` override still wins, but a CONTRADICTORY one is
+ * refused instead of resolved in silence: qa credentials against another
+ * backend, or another env's well-known file against the qa backend. Custom
+ * file names stay allowed on both sides.
+ */
+function assertAuthFileMatchesBackend(file: string, qa: boolean): void {
+  if (!qa && file === QA_AUTH_FILE) {
+    throw new Error(
+      `VIBER_AUTH_FILE points at ${QA_AUTH_FILE} but VIBER_BASE_URL is not https://${QA_WEB_HOST}`,
+    );
+  }
+  if (qa && (file === "auth.json" || file === "dev.auth.json")) {
+    throw new Error(
+      `VIBER_BASE_URL is the qa backend but VIBER_AUTH_FILE points at ${file} (another env's credentials)`,
+    );
+  }
+}
+
 export function loadAuth(cwd: string = process.cwd()): AuthJson {
   const path = authFilePath(cwd);
   let raw: string;

package/lib/bridge_core.ts

@@ -306,11 +306,13 @@ export async function postBridgeReply(opts: {
 	ownPostedIds: Set<string>;
 	signal?: AbortSignal;
 	logPrefix: string;
+	/** Fetch seam (#606) — see postMessage. Defaults to the global fetch. */
+	fetchImpl?: typeof fetch;
 }): Promise<void> {
 	const { baseUrl, runtime, text, ownPostedIds, signal, logPrefix } = opts;
 	let result;
 	try {
-		result = await postMessage(baseUrl, runtime.id, runtime.token, text, undefined, signal);
+		result = await postMessage(baseUrl, runtime.id, runtime.token, text, undefined, signal, opts.fetchImpl ?? fetch);
 	} catch (err) {
 		if (err instanceof ConversationTokenExpiredError) {
 			throw new BridgeShutdownError("conversation token expired", 3);
@@ -345,6 +347,93 @@ export function decideTurnPostAction(opts: {
 	return "auto-post";
 }
 
+/** Max length of the runtime cause quoted verbatim in a channel failure notice. */
+const FAILURE_CAUSE_MAX = 400;
+
+/** Transport degradation observed during a turn (#606 step-02, codex only). */
+export type TurnDegradation = { events: number; lastStatus?: number };
+
+/**
+ * #606 — the text a bridge posts on the CHANNEL when a turn fails.
+ *
+ * The whole point of the issue is that a failed turn was written to stderr only,
+ * so the model filled the silence with an INVENTED cause. This text therefore
+ * quotes what the runtime said, VERBATIM and truncated, and adds nothing of its
+ * own: no classification, no advice, no guess. Pure (no clock, no network) so it
+ * is testable without a harness.
+ */
+export function failureNoticeText(err: unknown, degradation?: TurnDegradation): string {
+	const raw = safeErrorMessage(err).replace(/\s+/g, " ").trim();
+	const cause = raw.length > FAILURE_CAUSE_MAX ? `${raw.slice(0, FAILURE_CAUSE_MAX)}...` : raw || "(aucun detail)";
+	let text = `Tour echoue, aucune reponse produite. Cause rapportee par le runtime: ${cause}`;
+	if (degradation && degradation.events > 0) {
+		const status = degradation.lastStatus ? `, dernier statut HTTP ${degradation.lastStatus}` : "";
+		text += ` (transport degrade: ${degradation.events} evenement(s) avant l'echec${status})`;
+	}
+	return text;
+}
+
+/**
+ * #606 — the dedup signature of a failure cause.
+ *
+ * A blown quota fails EVERY subsequent turn: without dedup the fix that makes a
+ * failure speak would flood the channel. Two failures of the same cause must
+ * therefore yield the SAME key, so the volatile identifiers a runtime stamps on
+ * each attempt (turnId, threadId, cf-ray, timestamps, long hex ids) are stripped.
+ *
+ * The degradation COUNT is deliberately reduced to its presence, never its value:
+ * keying on the number would make every different N a "new cause" and re-open the
+ * flood the dedup exists to close.
+ */
+export function failureCauseKey(err: unknown, degradation?: TurnDegradation): string {
+	const normalized = safeErrorMessage(err)
+		.replace(/"(?:turnId|threadId|conversationId|requestId)"\s*:\s*"[^"]*"/g, "")
+		// STOPS at a JSON delimiter (review codex P2a). `\S+` here crossed the
+		// closing quote and ate everything up to the next SPACE — measured: two
+		// errors differing only by httpStatusCode 503 vs 429 collapsed onto
+		// `Codex turn failed: {"message":"Request failed,` because the status sat
+		// AFTER the cf-ray. A normalisation that eats the discriminator gags the
+		// second outage: the exact defect this key exists to avoid.
+		.replace(/cf-ray:\s*[^\s",}\]]+/gi, "")
+		.replace(/\d{4}-\d{2}-\d{2}T[\d:.]+Z?/g, "")
+		// The RESET INSTANT of a quota, in the two shapes our own log carries for
+		// the same outage (review codex, .raw l.95 vs l.111): with the date and
+		// without. Stripping only the clock left them on different keys, so the
+		// same cause announced twice.
+		.replace(
+			/\b(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)[a-z]*\s+\d{1,2}(?:st|nd|rd|th)?,?\s*\d{4}\b/gi,
+			"",
+		)
+		.replace(/\b\d{1,2}:\d{2}(:\d{2})?\s*(AM|PM)?\b/gi, "")
+		.replace(/\b[0-9a-f]{12,}\b/gi, "")
+		.replace(/\s+/g, " ")
+		.trim();
+	const degraded = degradation && degradation.events > 0 ? "|degraded" : "";
+	// WHOLE, neither truncated nor hashed (review codex, both passes). Slicing to a
+	// display bound made the key lose identity past that bound — two errors sharing
+	// a long prefix became one cause and the second was silenced. A digest fixed
+	// that but kept a residual collision, which costs a SUPPRESSED notice: the
+	// defect this key exists to prevent, made rare instead of impossible.
+	// There is no size constraint to trade against: the key is one closure variable
+	// holding one cause at a time. Keeping the normalised string entire removes the
+	// class rather than shrinking it — a display concern must not decide identity,
+	// which is the whole lesson of P2b.
+	return `${normalized}${degraded}`;
+}
+
+/**
+ * #606 step-02 — read the transport degradation a runtime attached to the error
+ * it threw. The failing turn never returns a TurnResult, so the count cannot ride
+ * on one; the codex bridge stamps it on the Error itself. Any runtime that stamps
+ * nothing (gemma: a single fetch, no intermediate transport events to observe)
+ * simply yields undefined, and the notice omits the clause.
+ */
+export function readTurnDegradation(err: unknown): TurnDegradation | undefined {
+	const d = (err as { degradation?: unknown })?.degradation as TurnDegradation | undefined;
+	if (!d || typeof d.events !== "number" || d.events <= 0) return undefined;
+	return { events: d.events, lastStatus: typeof d.lastStatus === "number" ? d.lastStatus : undefined };
+}
+
 /**
  * #429 cross-run dedup, mirror of dm_stream's `forwardMessage` guard (L146-147).
  * True when this id was already DELIVERED in a prior run and must be skipped on a
@@ -570,6 +659,34 @@ export async function sseLoop(opts: {
 	const sseUrl = buildSseUrl(minted.ws_url, minted.conversation_id);
 	const ownPostedIds = new Set<string>();
 
+	// #606 anti-flood state: the cause key of the LAST failure actually announced
+	// on the channel. A blown quota fails every subsequent turn, so announcing each
+	// one would replace a silence bug with a spam bug. Closure state, owned by this
+	// loop — no module singleton (.claude/rules/architecture.md §7).
+	// Cross-RUN note. This comment CLAIMED the key survives a re-join; it does not,
+	// and N.11 measures the opposite (review codex, prose-has-no-test: the code was
+	// right, the sentence was false). What actually happens: the watermark
+	// deliberately does NOT advance on a failed reply (at-least-once retry, see
+	// below), so a re-join replays the message and fails again — and since each
+	// sseLoop call owns a FRESH closure, that re-join announces once more. Same for
+	// a process restart. Deliberate: a bridge that comes back and hits the same wall
+	// is information. Within one join, the key is what stops the flood.
+	let lastAnnouncedCause: string | undefined;
+
+	/**
+	 * #606 — a DELIVERED turn means the previous cause is over: rearm the notice.
+	 *
+	 * Lives HERE, on the turn outcome, and not at a caller. Review F2 measured why:
+	 * written at the text caller only, the VOICE path never rearmed, so
+	 * text-fails → voice-recovers → text-fails-again left the third failure GAGGED
+	 * — the issue's own defect, reproduced by the issue's fix. Placing it on the
+	 * outcome removes the class instead of patching the two paths that exist today.
+	 * An ABORTED turn never gets here: teardown says nothing about runtime health.
+	 */
+	function rearmFailureNotice(): void {
+		lastAnnouncedCause = undefined;
+	}
+
 	// Run one turn for `content` via the injected runtime, then auto-post its
 	// reply UNLESS an outbound tool already posted this turn (anti-double-post).
 	// Returns true when the reply was dropped because the stream was aborted
@@ -598,12 +715,15 @@ export async function sseLoop(opts: {
 				return true;
 			case "suppress-outbound":
 				process.stderr.write(`${logPrefix} outbound tool posted this turn on ${runtime.id}; suppressing final auto-post\n`);
+				rearmFailureNotice();
 				return false;
 			case "skip-empty":
 				process.stderr.write(`${logPrefix} turn on ${runtime.id} produced no text and used no outbound tool; nothing to deliver\n`);
+				rearmFailureNotice();
 				return false;
 			case "auto-post":
-				await postBridgeReply({ baseUrl: baseUrl(), runtime, text: reply, ownPostedIds, signal, logPrefix });
+				await postBridgeReply({ baseUrl: baseUrl(), runtime, text: reply, ownPostedIds, signal, logPrefix, fetchImpl });
+				rearmFailureNotice();
 				return false;
 		}
 	}
@@ -652,6 +772,49 @@ export async function sseLoop(opts: {
 			.finally(() => ackInFlightIds.delete(idStr));
 	}
 
+
+	/**
+	 * #606 — say a failed turn on the CHANNEL, best-effort.
+	 *
+	 * Deliberately unable to make things worse:
+	 *  - the transport may be the very thing that broke (the measured case was a
+	 *    503 storm), so a failing notice is swallowed to stderr, NEVER retried and
+	 *    never rethrown — one failure must not become two;
+	 *  - it posts through postBridgeReply, so the notice id lands in ownPostedIds
+	 *    like any other reply and cannot feed itself back through handleInboundMessage;
+	 *  - the cause key is recorded only AFTER a post that actually succeeded, so a
+	 *    lost notice does not silence the next one.
+	 */
+	async function announceTurnFailure(err: unknown): Promise<void> {
+		const degradation = readTurnDegradation(err);
+		const key = failureCauseKey(err, degradation);
+		if (key === lastAnnouncedCause) {
+			process.stderr.write(`${logPrefix} failure notice suppressed (same cause as the previous one)\n`);
+			return;
+		}
+		try {
+			await postBridgeReply({
+				baseUrl: baseUrl(),
+				runtime,
+				text: failureNoticeText(err, degradation),
+				ownPostedIds,
+				signal,
+				logPrefix,
+				fetchImpl,
+			});
+			lastAnnouncedCause = key;
+		} catch (notifyErr) {
+			// Includes BridgeShutdownError from an expired token: swallowed here on
+			// purpose. CONSEQUENCE, named because it is not obvious (review F3): a
+			// token expiry first met BY THE NOTICE is discovered later, on the next
+			// turn, instead of shutting the bridge down now. Accepted — this path
+			// runs while ALREADY handling a failure; escalating a
+			// shutdown from the notice would turn "the agent could not answer" into
+			// "the agent died", which is a worse report than the one we came to give.
+			process.stderr.write(`${logPrefix} failure notice could not be posted: ${safeErrorMessage(notifyErr)}\n`);
+		}
+	}
+
 	async function handleInboundMessage(msg: ConversationMessage): Promise<boolean> {
 		const idStr = msg.id !== undefined && msg.id !== null ? String(msg.id) : undefined;
 		// TRUTHY check (not `!== undefined`): idStr === "" must yield NaN, not
@@ -688,6 +851,7 @@ export async function sseLoop(opts: {
 		} catch (err) {
 			if (err instanceof BridgeShutdownError) throw err;
 			process.stderr.write(`${logPrefix} failed to handle message: ${safeErrorMessage(err)}\n`);
+			await announceTurnFailure(err);
 		}
 		return options.once === true;
 	}
@@ -810,6 +974,12 @@ export async function sseLoop(opts: {
 							} catch (err) {
 								if (err instanceof BridgeShutdownError) throw err;
 								process.stderr.write(`${logPrefix} failed to handle transcription: ${safeErrorMessage(err)}\n`);
+								// #606: a VOICE turn that fails was the second silent swallow in this
+								// same chain — found while building the tests, not by the grep on
+								// "failed to handle message", which only ever proved the uniqueness of
+								// the TEXT path. A user speaking to a dead runtime deserves the same
+								// notice as one typing to it.
+								await announceTurnFailure(err);
 							}
 							if (options.once) return;
 						}

package/lib/bridge_tool_host.ts

@@ -92,8 +92,19 @@ export const TOOL_DEFS = [
       "List the OTHER agents (instances) you can DM. Returns each agent's id, " +
       "label, runtime kind, and whether it is online. Use it to find an id before message_agent. " +
       "Normally project-scoped; an ORCHESTRATOR instance (#307) sees all the owner's projects, " +
-      "each entry tagged with a `project` field.",
-    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+      "each entry tagged with a `project` field. " +
+      "FILTER instead of listing everything (#501): `online: true` for live agents only, " +
+      "`label_prefix` for one team (e.g. \"501-\"). Both are applied server-side. " +
+      "If the presence source is unreachable the `online` filter is DROPPED and the answer " +
+      "says so — an empty list would wrongly read as \"no agent is alive\".",
+    inputSchema: {
+      type: "object",
+      properties: {
+        online: { type: "boolean", description: "Only agents currently seen online." },
+        label_prefix: { type: "string", description: 'Only labels starting with this, e.g. "501-".' },
+      },
+      additionalProperties: false,
+    },
   },
   {
     name: "message_agent",
@@ -146,7 +157,7 @@ export async function dispatchBridgeTool(
 ): Promise<AgentToolResult> {
   let result: AgentToolResult;
   if (name === "list_agents") {
-    result = await listAgents(opts.ctx);
+    result = await listAgents(opts.ctx, args);
   } else if (name === "message_agent") {
     result = await messageAgent(opts.ctx, args);
   } else if (name === "send_message") {

package/lib/claude_tool_defs.ts

@@ -71,10 +71,24 @@ export const CLAUDE_TOOL_DEFS = [
       "Use this to find the id of an agent (e.g. 'Codex Review') before calling message_agent. " +
       "Normally scoped to this project; if the owner designated this instance an ORCHESTRATOR " +
       "(#307), the list covers ALL the owner's projects and each entry carries a `project` field. " +
-      "You are never in the list.",
+      "You are never in the list. " +
+      "FILTER instead of listing everything (#501): `online: true` returns only agents the server " +
+      'currently sees online, `label_prefix` only those whose label starts with it (e.g. "501-" ' +
+      "for one team). Both are applied server-side, so an unfiltered call in a loop is the " +
+      "expensive path. If the presence source is unreachable the `online` filter is DROPPED and " +
+      'the answer says so — an empty list would wrongly read as "no agent is alive".',
     inputSchema: {
       type: "object" as const,
-      properties: {},
+      properties: {
+        online: {
+          type: "boolean",
+          description: "Only agents the server currently sees online.",
+        },
+        label_prefix: {
+          type: "string",
+          description: 'Only agents whose label starts with this prefix, e.g. "501-".',
+        },
+      },
       required: [],
       additionalProperties: false,
     },

package/lib/connect.ts

@@ -19,7 +19,7 @@ import {
   writeFileSync,
 } from "node:fs";
 import { dirname, isAbsolute, join, relative } from "node:path";
-import { authFilePath } from "./auth.js";
+import { connectAuthPath, isQaBackend } from "./auth.js";
 import { clientFingerprint } from "./fingerprint.js";
 import { cfAccessHeaders } from "./cfAccess.js";
 
@@ -50,6 +50,21 @@ interface TerminalResponse {
 
 type PollResponse = ConsumedResponse | PendingResponse | TerminalResponse;
 
+const DEFAULT_NEXT_STEPS =
+  `Next steps:\n` +
+  `  1. Register the channel MCP server (one-time per machine):\n` +
+  `       claude mcp add viber-channel --scope user -- bunx viber-channel@latest\n` +
+  `  2. Restart Claude Code in this directory.\n\n`;
+
+// #613: qa never runs the published channel — the default advice would be wrong
+// at the exact moment of the qa gesture.
+export const QA_NEXT_STEPS =
+  `Next steps (qa):\n` +
+  `  1. Run the channel FROM SOURCE in the Gateway worktree: register viber-qa-channel\n` +
+  `     in its local .mcp.json (bun ./viber-channel/viber-channel.ts,\n` +
+  `     VIBER_BASE_URL=https://viber-qa.dgypx.dev). NEVER bunx viber-channel@latest.\n` +
+  `  2. See plans/613-env-qa (mount procedure).\n\n`;
+
 const POLL_INTERVAL_MS = 2000;
 const MAX_POLL_DURATION_MS = 10 * 60 * 1000;
 
@@ -77,6 +92,7 @@ function writeAuthJson(
   cwd: string,
   data: ConsumedResponse,
   fingerprint: string,
+  authPath: string,
 ): void {
   const viberDir = join(cwd, ".viber");
   mkdirSync(viberDir, { recursive: true });
@@ -85,7 +101,7 @@ function writeAuthJson(
   // credentials to the same file the channel will read (e.g. dev.auth.json),
   // instead of silently writing auth.json while the channel reads elsewhere.
   // readme.md + .gitignore stay in <cwd>/.viber regardless.
-  const authPath = authFilePath(cwd);
+  // #613: `authPath` comes from connectAuthPath (the claim decides for qa).
   mkdirSync(dirname(authPath), { recursive: true });
 
   const auth: Record<string, unknown> = {
@@ -159,6 +175,8 @@ export async function runConnect(
   cwd: string = process.cwd(),
 ): Promise<void> {
   const { baseUrl, claimId } = parseClaimUrl(claimUrl);
+  // #613: resolved BEFORE any network call, so a contradiction fails early.
+  const authPath = connectAuthPath(baseUrl, cwd);
 
   const fingerprint = clientFingerprint(cwd);
   process.stderr.write(
@@ -191,14 +209,11 @@ export async function runConnect(
     }
     const data = (await pollResp.json()) as PollResponse;
     if (data.status === "consumed") {
-      writeAuthJson(cwd, data, fingerprint);
+      writeAuthJson(cwd, data, fingerprint, authPath);
       process.stdout.write(
         `\n✓ Connected as ${data.user_email} to project '${data.project_name}'.\n` +
-          `  Wrote ${authFilePath(cwd)}\n\n` +
-          `Next steps:\n` +
-          `  1. Register the channel MCP server (one-time per machine):\n` +
-          `       claude mcp add viber-channel --scope user -- bunx viber-channel@latest\n` +
-          `  2. Restart Claude Code in this directory.\n\n`,
+          `  Wrote ${authPath}\n\n` +
+          (isQaBackend(baseUrl) ? QA_NEXT_STEPS : DEFAULT_NEXT_STEPS),
       );
       return;
     }