@gajae-code/coding-agent 0.12.11 → 0.12.13

package/src/cli/notify-cli.ts

@@ -7,6 +7,7 @@ import { createInterface } from "node:readline/promises";
 import { APP_NAME } from "@gajae-code/utils/dirs";
 import chalk from "chalk";
 import { Settings, type SettingsAtomicPatch } from "../config/settings";
+import { SessionIndex } from "../sdk/broker/session-index";
 import {
 	ChatDaemonController,
 	type EnsureChatDaemonResult,
@@ -14,6 +15,7 @@ import {
 	ensureSlackDaemon,
 } from "../sdk/bus/chat-daemon-control";
 import { getNotificationConfig, maskToken, tokenFingerprint } from "../sdk/bus/config";
+import { type ActivatedPreparedSession, activatePreparedSession } from "../sdk/bus/existing-thread-readiness";
 import {
 	clearTelegramActivationMarker,
 	createTelegramActivationMarker,
@@ -36,6 +38,12 @@ import {
 	sanitizeDiagnostic,
 	sendNotificationTest,
 } from "../sdk/bus/notification-service";
+import {
+	type BoundSlackThread,
+	bindConfiguredSlackThread,
+	isBoundedSlackRootTs,
+	SlackThreadBindingError,
+} from "../sdk/bus/slack-thread-binding";
 import {
 	type EnsureTelegramDaemonDetailedResult,
 	ensureTelegramDaemonRunningDetailed,
@@ -49,7 +57,15 @@ import {
 	type TelegramSetupTimers,
 } from "../sdk/bus/telegram-setup";
 
-export type NotifyAction = "setup" | "status" | "health" | "test" | "recovery" | "daemon-internal";
+export type NotifyAction =
+	| "setup"
+	| "status"
+	| "health"
+	| "test"
+	| "recovery"
+	| "bind-thread"
+	| "activate-thread"
+	| "daemon-internal";
 export type NotifySetupProvider = "telegram" | "discord" | "slack";
 
 export interface NotifyCommandArgs {
@@ -72,6 +88,8 @@ export interface NotifyCommandArgs {
 	forceDaemonLock?: boolean;
 	probe?: boolean;
 	message?: string;
+	sessionId?: string;
+	threadTs?: string;
 }
 
 export interface NotifyCommandDeps {
@@ -99,6 +117,8 @@ export interface NotifyCommandDeps {
 	setupPidIncarnation?: (pid: number) => string | undefined;
 	ensureProviderDaemon?: (provider: "discord" | "slack", settings: Settings) => Promise<EnsureChatDaemonResult>;
 	ensureTelegramDaemon?: (settings: Settings) => Promise<EnsureTelegramDaemonDetailedResult>;
+	bindSlackThread?: (input: { settings: Settings; sessionId: string; threadTs: string }) => Promise<BoundSlackThread>;
+	activatePreparedSession?: (input: { settings: Settings; sessionId: string }) => Promise<ActivatedPreparedSession>;
 }
 
 export function parseNotifyArgs(args: string[]): NotifyCommandArgs | undefined {
@@ -200,6 +220,23 @@ export function parseNotifyArgs(args: string[]): NotifyCommandArgs | undefined {
 			? { action, rawArgs: args.slice(2), forceDaemonLock: flags.get("--force-daemon-lock") === true }
 			: undefined;
 	}
+	if (action === "bind-thread") {
+		const rest = args.slice(2);
+		const flags = parseFlags(rest, new Set(["--session-id", "--thread-ts"]), new Set());
+		if (!flags) return undefined;
+		const sessionId = flags.get("--session-id");
+		const threadTs = flags.get("--thread-ts");
+		if (typeof sessionId !== "string" || typeof threadTs !== "string") return undefined;
+		return { action, rawArgs: rest, sessionId, threadTs };
+	}
+	if (action === "activate-thread") {
+		const rest = args.slice(2);
+		const flags = parseFlags(rest, new Set(["--session-id"]), new Set());
+		if (!flags) return undefined;
+		const sessionId = flags.get("--session-id");
+		if (typeof sessionId !== "string") return undefined;
+		return { action, rawArgs: rest, sessionId };
+	}
 	if (action === "daemon-internal") {
 		return {
 			action,
@@ -232,6 +269,12 @@ export async function runNotifyCommand(cmd: NotifyCommandArgs, deps: NotifyComma
 		case "recovery":
 			await runRecovery(deps, cmd.forceDaemonLock);
 			return;
+		case "bind-thread":
+			await runBindThread(cmd, deps);
+			return;
+		case "activate-thread":
+			await runActivateThread(cmd, deps);
+			return;
 		case "daemon-internal":
 			if (cmd.smoke) {
 				await runDaemonInternal(["--smoke"]);
@@ -457,6 +500,7 @@ async function runTelegramSetup(cmd: NotifyCommandArgs, deps: NotifyCommandDeps)
 		process.stdout.write(`Using provided chat id ${result.chatId} (non-interactive).\n`);
 	}
 	let settingsCommitted = false;
+	let commitAttempted = false;
 	try {
 		const proposedIdentity = deps.setupPreflight
 			? proposedIdentityFromSetupPreflight(deps.setupPreflight, token.trim(), result.chatId)
@@ -480,6 +524,7 @@ async function runTelegramSetup(cmd: NotifyCommandArgs, deps: NotifyCommandDeps)
 			{ path: "notifications.telegram.enabled", op: "set", value: true },
 		];
 		if (deps.setupRedact ?? cmd.redact) patches.push({ path: "notifications.redact", op: "set", value: true });
+		commitAttempted = true;
 		const receipt = await settings.commitAtomicBatch(patches);
 		settingsCommitted = true;
 		const activationMarker = createTelegramActivationMarker({
@@ -534,8 +579,24 @@ async function runTelegramSetup(cmd: NotifyCommandArgs, deps: NotifyCommandDeps)
 		receipt.discard();
 	} catch (error) {
 		const detail = sanitizeDiagnostic(error instanceof Error ? error.message : "unknown persistence failure", token);
+		// The wording must describe what a follow-up `notify status` will show. A failure
+		// raised after the durable write landed — including one raised from inside the
+		// commit itself — must not claim the settings were not persisted, or the operator
+		// walks away believing Telegram is off while the daemon is armed for that token.
+		// Observed state wins; the code-path flag is only the fallback for an unreadable read.
+		const observed = telegramIntentIsPersisted(settings, token.trim(), result.chatId);
+		const persisted = observed ?? settingsCommitted;
+		// A commit that was entered and then failed, whose durable state is also unreadable,
+		// is genuinely undecided: `commitAtomicBatch` can persist and still throw. Claiming
+		// either outcome would be a guess, so say so and point at the authoritative check.
+		if (!persisted && observed === undefined && commitAttempted) {
+			throw new Error(
+				"Telegram notification settings may or may not have been saved, and the stored configuration could not be read; " +
+					`run \`gjc notify status\` before retrying: ${detail}`,
+			);
+		}
 		throw new Error(
-			settingsCommitted
+			persisted
 				? `Telegram notification settings were saved, but activation or recovery failed: ${detail}`
 				: `Unable to persist and activate Telegram notification settings: ${detail}`,
 		);
@@ -545,6 +606,26 @@ async function runTelegramSetup(cmd: NotifyCommandArgs, deps: NotifyCommandDeps)
 	);
 }
 
+/**
+ * Whether the durable settings already carry the Telegram intent this setup run attempted to
+ * write: the same identity *and* the enabled state it would have produced. Matching the token
+ * and chat id alone is not enough — a previously disabled configuration can already hold both,
+ * and a commit that fails before enabling Telegram has persisted nothing new.
+ *
+ * Returns `undefined` when the durable state cannot be observed, so the caller can fall back
+ * instead of reporting a state nobody read.
+ */
+function telegramIntentIsPersisted(settings: Settings, botToken: string, chatId: string): boolean | undefined {
+	try {
+		const cfg = getNotificationConfig(settings);
+		return (
+			cfg.enabled === true && cfg.telegram?.enabled === true && cfg.botToken === botToken && cfg.chatId === chatId
+		);
+	} catch {
+		return undefined;
+	}
+}
+
 function proposedIdentityFromSetupPreflight(
 	preflight: TelegramSetupPreflight,
 	botToken: string,
@@ -728,6 +809,143 @@ async function runRecovery(deps: NotifyCommandDeps, forceDaemonLock = false): Pr
 	process.stdout.write(`${formatNotificationRecoveryReport(report)}\n`);
 }
 
+/** Target and credential inputs stay owned by `notify setup`; binding never re-routes a session elsewhere. */
+const BIND_THREAD_REJECTED_INPUTS: readonly (keyof NotifyCommandArgs)[] = [
+	"provider",
+	"token",
+	"chatId",
+	"discordBotToken",
+	"discordApplicationId",
+	"discordGuildId",
+	"discordParentChannelId",
+	"slackBotToken",
+	"slackAppToken",
+	"slackWorkspaceId",
+	"slackChannelId",
+	"slackAuthorizedUserId",
+	"message",
+	"probe",
+	"redact",
+	"forceDaemonLock",
+	"smoke",
+];
+
+export interface BindThreadInvocation {
+	sessionId: string;
+	threadTs: string;
+}
+
+/**
+ * Enforce the exact `bind-thread` grammar at every entrypoint.
+ *
+ * The command accepts only a session and a root; a positional argument, an
+ * unrelated notify flag, or a target/credential input is a rejection rather than
+ * something silently ignored, so no other invocation shape can reach the
+ * binding authority.
+ */
+export function assertStrictBindThreadInvocation(cmd: NotifyCommandArgs): BindThreadInvocation {
+	const rejected = BIND_THREAD_REJECTED_INPUTS.filter(key => {
+		const value = cmd[key];
+		return value !== undefined && value !== false && value !== "";
+	});
+	if (rejected.length > 0)
+		throw new Error(
+			`notify bind-thread accepts only --session-id and --thread-ts (rejected: ${rejected.join(", ")}).`,
+		);
+	const { sessionId, threadTs } = cmd;
+	if (!sessionId || !threadTs) throw new Error("notify bind-thread requires --session-id and --thread-ts.");
+	const allowed = new Set(["--session-id", sessionId, "--thread-ts", threadTs]);
+	const stray = cmd.rawArgs.filter(token => !allowed.has(token));
+	if (stray.length > 0)
+		throw new Error(`notify bind-thread does not accept additional arguments (rejected: ${stray.join(", ")}).`);
+	if (!isBoundedSlackRootTs(threadTs))
+		throw new SlackThreadBindingError(
+			"invalid_root",
+			"Slack root timestamp must be a bounded <seconds>.<fraction> message timestamp.",
+		);
+	return { sessionId, threadTs };
+}
+
+/** Adopt an existing Slack thread for a live session; the operator supplies only session and root identity. */
+async function runBindThread(cmd: NotifyCommandArgs, deps: NotifyCommandDeps): Promise<void> {
+	const { sessionId, threadTs } = assertStrictBindThreadInvocation(cmd);
+	const bind = deps.bindSlackThread ?? (input => bindConfiguredSlackThread(input));
+	const bound = await bind({ settings: await getSettings(deps), sessionId, threadTs });
+	process.stdout.write(`${formatBoundSlackThread(bound)}\n`);
+}
+
+/** Confirmation carries identifiers only: no tokens, message bodies, or control secrets. */
+export function formatBoundSlackThread(bound: BoundSlackThread): string {
+	return [
+		`${chalk.green("Bound")} Slack thread for session ${bound.sessionId}`,
+		`  session generation: ${bound.endpointGeneration}`,
+		`  workspace/channel:  ${bound.teamId}/${bound.channelId}`,
+		`  thread root:        ${bound.rootTs}`,
+		`  daemon owner:       ${bound.ownerId} (generation ${bound.daemonGeneration})`,
+	].join("\n");
+}
+
+/** Activation carries only a session; a root or target here is a rejection, not an override. */
+const ACTIVATE_THREAD_REJECTED_INPUTS: readonly (keyof NotifyCommandArgs)[] = [
+	...BIND_THREAD_REJECTED_INPUTS,
+	"threadTs",
+];
+
+export interface ActivateThreadInvocation {
+	sessionId: string;
+}
+
+/**
+ * Enforce the exact `activate-thread` grammar at every entrypoint.
+ *
+ * Activation names one prepared session and nothing else: the root it adopts is
+ * already the applied binding, so a supplied root, target, or credential is a
+ * rejection rather than something silently ignored.
+ */
+export function assertStrictActivateThreadInvocation(cmd: NotifyCommandArgs): ActivateThreadInvocation {
+	const rejected = ACTIVATE_THREAD_REJECTED_INPUTS.filter(key => {
+		const value = cmd[key];
+		return value !== undefined && value !== false && value !== "";
+	});
+	if (rejected.length > 0)
+		throw new Error(`notify activate-thread accepts only --session-id (rejected: ${rejected.join(", ")}).`);
+	const { sessionId } = cmd;
+	if (!sessionId) throw new Error("notify activate-thread requires --session-id.");
+	const allowed = new Set(["--session-id", sessionId]);
+	const stray = cmd.rawArgs.filter(token => !allowed.has(token));
+	if (stray.length > 0)
+		throw new Error(`notify activate-thread does not accept additional arguments (rejected: ${stray.join(", ")}).`);
+	return { sessionId };
+}
+
+/**
+ * Publish the readiness a prepared session withheld.
+ *
+ * The session's own host owns the decision: this command only proves discovery
+ * authority and asks it to activate, so activation before a binding exists is
+ * refused by the session rather than forced by the operator.
+ */
+async function runActivateThread(cmd: NotifyCommandArgs, deps: NotifyCommandDeps): Promise<void> {
+	const { sessionId } = assertStrictActivateThreadInvocation(cmd);
+	const activate =
+		deps.activatePreparedSession ??
+		(async (input: { settings: Settings; sessionId: string }) =>
+			await activatePreparedSession({
+				sessionIndex: await new SessionIndex(input.settings.getAgentDir()).open(),
+				sessionId: input.sessionId,
+			}));
+	const activated = await activate({ settings: await getSettings(deps), sessionId });
+	process.stdout.write(`${formatActivatedSession(activated)}\n`);
+}
+
+/** Confirmation carries identifiers only: no endpoints, tokens, or thread content. */
+export function formatActivatedSession(activated: ActivatedPreparedSession): string {
+	return [
+		`${chalk.green("Activated")} session ${activated.sessionId} (${activated.status})`,
+		`  session generation: ${activated.endpointGeneration}`,
+	].join("\n");
+}
+
 export function printNotifyHelp(): void {
 	process.stdout.write(`${chalk.bold(`${APP_NAME} notify`)} - Configure Telegram, Discord, or Slack notifications
 
@@ -744,6 +962,8 @@ ${chalk.bold("Usage:")}
   ${APP_NAME} notify health [--provider telegram|discord|slack] [--probe]
   ${APP_NAME} notify test [--provider telegram|discord|slack] [--message <text>]
   ${APP_NAME} notify recovery [--force-daemon-lock]
+  ${APP_NAME} notify bind-thread --session-id <sessionId> --thread-ts <rootTs>
+  ${APP_NAME} notify activate-thread --session-id <sessionId>
 
 ${chalk.bold("Subcommands:")}
   setup     Pair Telegram or atomically save and activate complete Discord/Slack settings
@@ -751,6 +971,8 @@ ${chalk.bold("Subcommands:")}
   health    Report selected provider state; --probe uses REST only and never opens Gateway/Socket Mode
   test      Send a one-off test through one selected or uniquely effective provider
   recovery  Clear dead-owner daemon locks and stale per-session endpoint files (never touches a live owner); --force-daemon-lock retries only with the same fail-closed dead-owner proof
+  bind-thread      Adopt an existing Slack thread as a live session's root; target and credentials come from setup only
+  activate-thread  Publish the readiness a prepared session withheld once its thread binding is applied
 
 ${chalk.bold("Examples:")}
   ${APP_NAME} notify setup
@@ -761,6 +983,8 @@ ${chalk.bold("Examples:")}
   ${APP_NAME} notify health --provider discord --probe
   ${APP_NAME} notify test --provider slack --message "hello from gjc"
   ${APP_NAME} notify recovery
+  ${APP_NAME} notify bind-thread --session-id 01J... --thread-ts 1785573662.132329
+  ${APP_NAME} notify activate-thread --session-id 01J...
 
 ${chalk.bold("Threaded Mode:")}
   GJC uses Telegram private-chat topics for per-session threads. Setup verifies the bot

package/src/cli/plugin-cli.ts

@@ -155,6 +155,7 @@ export function parsePluginArgs(args: string[]): PluginCommandArgs | undefined {
 }
 
 import { classifyInstallTarget } from "./classify-install-target";
+import { findMarketplacesOffering, isBareInstallName } from "./marketplace-hint";
 
 export { classifyInstallTarget } from "./classify-install-target";
 
@@ -609,6 +610,15 @@ async function handleInstall(
 			// The spec can carry credentials, a query string, or an absolute home
 			// path, so report the failure without echoing it or the raw cause.
 			console.error(chalk.red(`${theme.status.error} Failed to install plugin (${describeInstallFailure(err)})`));
+			// A bare name (no `@scope`, no version, no path separator) is safe to
+			// echo, and it is exactly the shape a user copies out of
+			// `plugin discover`. Point at the qualified spec that would work.
+			if (isBareInstallName(spec)) {
+				const offering = await findMarketplacesOffering(mktMgr, spec).catch(() => []);
+				for (const marketplace of offering) {
+					console.error(chalk.dim(`  Try: ${APP_NAME} plugin install ${spec}@${marketplace}`));
+				}
+			}
 			process.exit(1);
 		}
 	}

package/src/cli/update-cli.ts

@@ -12,6 +12,12 @@ import { $ } from "bun";
 import chalk from "chalk";
 import { installDefaultGjcDefinitions } from "../defaults/gjc-defaults";
 import { theme } from "../modes/theme/theme";
+import {
+	DEFAULT_NPM_REGISTRY,
+	fetchLatestPackageVersion,
+	type Installer,
+	type NpmRegistryLookupOptions,
+} from "../utils/npm-registry";
 
 const RELEASE_REPO = "Yeachan-Heo/gajae-code";
 const PACKAGE = "@gajae-code/coding-agent";
@@ -21,6 +27,10 @@ const NPM_MANAGED_PACKAGES = [NPM_WRAPPER_PACKAGE, PACKAGE] as const;
 interface ReleaseInfo {
 	tag: string;
 	version: string;
+	/** Registry the version came from. Release binaries still come from GitHub. */
+	registry: string;
+	/** Config problems that did not stop the lookup but changed its outcome. */
+	warnings: string[];
 }
 
 /** Result from running the installed binary and parsing its reported version. */
@@ -205,23 +215,31 @@ async function resolveUpdateTarget(): Promise<UpdateTarget> {
 /**
  * Get the latest release info from the npm registry.
  * Uses npm instead of GitHub API to avoid unauthenticated rate limiting.
+ *
+ * The registry comes from npm config (`npm_config_registry`, `.npmrc`,
+ * `BUN_CONFIG_REGISTRY`) so the check reaches the same place the install does.
+ * Hardcoding the public registry broke every mirrored or firewalled network.
  */
-async function getLatestRelease(): Promise<ReleaseInfo> {
-	const response = await fetch(`https://registry.npmjs.org/${PACKAGE}/latest`);
-	if (!response.ok) {
-		throw new Error(`Failed to fetch release info: ${response.statusText}`);
-	}
-
-	const data = (await response.json()) as { version: string };
-	const version = data.version;
-	const tag = `v${version}`;
+async function getLatestRelease(options?: Installer | NpmRegistryLookupOptions): Promise<ReleaseInfo> {
+	const overrides: NpmRegistryLookupOptions = typeof options === "string" ? { installer: options } : (options ?? {});
+	// The user is deliberately waiting on this command, unlike the startup check.
+	const { version, registry, warnings } = await fetchLatestPackageVersion(PACKAGE, {
+		timeoutMs: 20_000,
+		...overrides,
+	});
 
 	return {
-		tag,
+		tag: `v${version}`,
 		version,
+		registry,
+		warnings,
 	};
 }
 
+export function getLatestReleaseForTest(options: NpmRegistryLookupOptions): Promise<ReleaseInfo> {
+	return getLatestRelease(options);
+}
+
 /**
  * Compare semver versions. Returns:
  * - negative if a < b
@@ -376,8 +394,10 @@ function formatBinaryDownloadFailureMessage(
 	url: string,
 	status: string | number,
 	platform: NodeJS.Platform = process.platform,
+	registryNote?: string,
 ): string {
-	return `Download failed for ${binaryName} from ${url}: ${status}.\n${formatManualUpdateInstructions(platform)}`;
+	const note = registryNote ? `\n${registryNote}` : "";
+	return `Download failed for ${binaryName} from ${url}: ${status}.${note}\n${formatManualUpdateInstructions(platform)}`;
 }
 
 export function formatBinaryDownloadFailureMessageForTest(
@@ -385,8 +405,9 @@ export function formatBinaryDownloadFailureMessageForTest(
 	url: string,
 	status: string | number,
 	platform: NodeJS.Platform = process.platform,
+	registryNote?: string,
 ): string {
-	return formatBinaryDownloadFailureMessage(binaryName, url, status, platform);
+	return formatBinaryDownloadFailureMessage(binaryName, url, status, platform, registryNote);
 }
 
 export function buildReleaseBinaryUrlForTest(
@@ -582,10 +603,23 @@ export async function fsyncFileForTest(filePath: string): Promise<void> {
  * Download a release binary to a temp path, throwing a friendly error when the
  * release asset cannot be fetched.
  */
-async function downloadBinaryTo(url: string, tempPath: string, binaryName: string): Promise<void> {
+async function downloadBinaryTo(
+	url: string,
+	tempPath: string,
+	binaryName: string,
+	registryNote?: string,
+): Promise<void> {
 	const response = await fetch(url, { redirect: "follow" });
 	if (!response.ok || !response.body) {
-		throw new Error(formatBinaryDownloadFailureMessage(binaryName, url, response.statusText || response.status));
+		throw new Error(
+			formatBinaryDownloadFailureMessage(
+				binaryName,
+				url,
+				response.statusText || response.status,
+				process.platform,
+				registryNote,
+			),
+		);
 	}
 	const fileStream = fs.createWriteStream(tempPath, { mode: 0o755 });
 	await pipeline(response.body, fileStream);
@@ -639,16 +673,29 @@ export async function runBinaryUpdateFlow(
 	});
 }
 
+/**
+ * Describe the registry a version came from, when it is not the public one.
+ *
+ * The binary update path downloads from GitHub release tags, so a version that
+ * only exists on a private mirror produces a bare 404 with nothing linking it
+ * back to the registry that named it.
+ */
+function formatRegistryProvenance(version: string, registry: string | undefined): string | undefined {
+	if (!registry || registry === DEFAULT_NPM_REGISTRY) return undefined;
+	return `Version ${version} was resolved from ${registry}, not ${DEFAULT_NPM_REGISTRY}; a version published only to that registry has no matching GitHub release asset.`;
+}
+
 /**
  * Download a release binary to a target path, replacing an existing file.
  */
-async function updateViaBinaryAt(targetPath: string, expectedVersion: string): Promise<void> {
+async function updateViaBinaryAt(targetPath: string, expectedVersion: string, registry?: string): Promise<void> {
 	const binaryName = getBinaryName();
 	const url = buildReleaseBinaryUrl(expectedVersion);
+	const registryNote = formatRegistryProvenance(expectedVersion, registry);
 	console.log(chalk.dim(`Downloading ${binaryName}…`));
 
 	const verification = await runBinaryUpdateFlow(targetPath, url, expectedVersion, {
-		download: (downloadUrl, tempPath) => downloadBinaryTo(downloadUrl, tempPath, binaryName),
+		download: (downloadUrl, tempPath) => downloadBinaryTo(downloadUrl, tempPath, binaryName, registryNote),
 		fsync: fsyncFile,
 		replace: replaceBinaryForUpdate,
 		verifyInstalledVersion: verifyInstalledRuntime,
@@ -665,20 +712,20 @@ async function updateViaBinaryAt(targetPath: string, expectedVersion: string): P
  * Run the update command.
  */
 export interface UpdateCommandDependencies {
-	getLatestRelease?: () => Promise<ReleaseInfo>;
+	getLatestRelease?: (installer?: Installer) => Promise<ReleaseInfo>;
 	resolveUpdateTarget?: () => Promise<UpdateTarget>;
-	performUpdate?: (target: UpdateTarget, expectedVersion: string) => Promise<void>;
+	performUpdate?: (target: UpdateTarget, expectedVersion: string, registry?: string) => Promise<void>;
 	refreshInstalledDefaultSkills?: () => Promise<void>;
 	exit?: (code: number) => never;
 }
 
-async function performUpdate(target: UpdateTarget, expectedVersion: string): Promise<void> {
+async function performUpdate(target: UpdateTarget, expectedVersion: string, registry?: string): Promise<void> {
 	if (target.method === "bun") {
 		await updateViaBun(expectedVersion);
 	} else if (target.method === "npm") {
 		await updateViaNpm(target.packageName, expectedVersion);
 	} else {
-		await updateViaBinaryAt(target.path, expectedVersion);
+		await updateViaBinaryAt(target.path, expectedVersion, registry);
 	}
 }
 
@@ -694,14 +741,34 @@ export async function runUpdateCommand(
 
 	console.log(chalk.dim(`Current version: ${VERSION}`));
 
+	// Resolve the install target first so the registry lookup can match the
+	// manager that will actually run: the npm-managed path ignores
+	// BUN_CONFIG_REGISTRY, so preferring it there would make the version check
+	// disagree with the install this command is gating. Failure is not fatal
+	// here — the later resolveTarget() call reports it.
+	let installer: Installer | undefined;
+	let target: UpdateTarget | undefined;
+	try {
+		target = await resolveTarget();
+		installer = target.method === "bun" ? "bun" : target.method === "npm" ? "npm" : undefined;
+	} catch {
+		installer = undefined;
+	}
+
 	let release: ReleaseInfo;
 	try {
-		release = await lookupRelease();
+		release = await lookupRelease(installer);
 	} catch (err) {
 		console.error(chalk.red(`Failed to check for updates: ${err}`));
 		return exit(1);
 	}
 
+	// A config file that exists but could not be read changes which registry
+	// answered; saying so beats a version that quietly came from somewhere else.
+	// `?? []` because UpdateCommandDependencies is a public seam an untyped
+	// consumer can satisfy without the field.
+	for (const warning of release.warnings ?? []) console.warn(chalk.yellow(`Warning: ${warning}`));
+
 	const comparison = compareVersions(release.version, VERSION);
 
 	if (comparison <= 0 && !opts.force) {
@@ -718,8 +785,8 @@ export async function runUpdateCommand(
 	if (opts.check) return;
 
 	try {
-		const target = await resolveTarget();
-		await update(target, release.version);
+		const resolved = target ?? (await resolveTarget());
+		await update(resolved, release.version, release.registry);
 	} catch (err) {
 		console.error(chalk.red(`Update failed: ${err}`));
 		return exit(1);

package/src/cli.ts

@@ -389,11 +389,34 @@ function routeLegacyRootArgv(argv: readonly string[]): string[] | undefined {
 	return ["team", size, ...remaining];
 }
 
+/**
+ * Map the common mistaken `models` subcommand spelling to non-agent listing.
+ *
+ * Agents frequently run `gjc models` from the bash tool expecting a catalog.
+ * Without this route, `models` was a positional launch prompt and nested agents
+ * re-invoked `gjc models`, spawning an unbounded process chain (#3857).
+ * Always rewrite to `launch --list-models` so the invocation exits after a
+ * bounded listing and never starts an interactive agent session.
+ */
+export function routeModelsAlias(argv: readonly string[]): string[] | undefined {
+	if (argv[0] !== "models") return undefined;
+	const rest = argv.slice(1);
+	if (rest.length === 0) return ["launch", "--list-models"];
+	// Pure search tokens become a single fuzzy pattern (matches --list-models).
+	if (rest.every(token => !token.startsWith("-") && !token.startsWith("@"))) {
+		return ["launch", "--list-models", rest.join(" ")];
+	}
+	// Mixed flags still go through list-models first so "models" is never a prompt.
+	return ["launch", "--list-models", ...rest];
+}
+
 /** Apply the same default-launch routing used by runCli after root fast paths. */
 export function routeRootArgv(argv: readonly string[]): string[] {
 	const normalizedArgv = normalizeResumeAlias(argv);
 	const legacyArgv = routeLegacyRootArgv(normalizedArgv);
 	if (legacyArgv) return legacyArgv;
+	const modelsArgv = routeModelsAlias(normalizedArgv);
+	if (modelsArgv) return modelsArgv;
 	const first = normalizedArgv[0];
 	return first === "--help" || first === "-h" || first === "--version" || first === "-v" || first === "help"
 		? normalizedArgv

package/src/commands/notify.ts

@@ -2,17 +2,32 @@
  * Configure Telegram, Discord, or Slack notifications.
  */
 import { Args, Command, Flags } from "@gajae-code/utils/cli";
-import { type NotifyAction, type NotifyCommandArgs, runNotifyCliCommand } from "../cli/notify-cli";
+import {
+	assertStrictActivateThreadInvocation,
+	assertStrictBindThreadInvocation,
+	type NotifyAction,
+	type NotifyCommandArgs,
+	runNotifyCliCommand,
+} from "../cli/notify-cli";
 import { initTheme } from "../modes/theme/theme";
 
-const ACTIONS: NotifyAction[] = ["setup", "status", "health", "test", "recovery", "daemon-internal"];
+const ACTIONS: NotifyAction[] = [
+	"setup",
+	"status",
+	"health",
+	"test",
+	"recovery",
+	"bind-thread",
+	"activate-thread",
+	"daemon-internal",
+];
 
 export default class Notify extends Command {
 	static description = "Configure Telegram, Discord, or Slack notifications";
 
 	static args = {
 		action: Args.string({
-			description: "Notify action (setup|status|health|test|recovery|daemon-internal)",
+			description: "Notify action (setup|status|health|test|recovery|bind-thread|activate-thread|daemon-internal)",
 			required: false,
 		}),
 		extra: Args.string({
@@ -46,6 +61,8 @@ export default class Notify extends Command {
 		}),
 		probe: Flags.boolean({ description: "notify health: run the selected provider's REST diagnostic" }),
 		message: Flags.string({ description: "notify test: custom message body" }),
+		"session-id": Flags.string({ description: "Live GJC session to bind to an existing Slack thread" }),
+		"thread-ts": Flags.string({ description: "Existing Slack root thread timestamp" }),
 		"owner-id": Flags.string({ description: "Internal: daemon owner id" }),
 		"agent-dir": Flags.string({ description: "Internal: agent dir for the daemon" }),
 	};
@@ -105,8 +122,15 @@ export default class Notify extends Command {
 			redact: Boolean(flags.redact),
 			probe: Boolean(flags.probe),
 			message: flags.message as string | undefined,
+			sessionId: flagRec["session-id"] as string | undefined,
+			threadTs: flagRec["thread-ts"] as string | undefined,
 		};
 
+		// `bind-thread` and `activate-thread` have no positional or internal form:
+		// any extra argument or unrelated notify flag is rejected here rather than
+		// silently ignored.
+		if (action === "bind-thread") assertStrictBindThreadInvocation(cmd);
+		if (action === "activate-thread") assertStrictActivateThreadInvocation(cmd);
 		if (action !== "daemon-internal") await initTheme();
 		await runNotifyCliCommand(cmd);
 	}

package/src/commands/sdk.ts

@@ -423,6 +423,7 @@ export async function runSessionHost(
 				sessionManager: opened.sessionManager,
 				...(mcpConfigPath ? { mcpConfigPath } : {}),
 				...(mcpStartupTimeoutMs !== undefined ? { mcpStartupTimeoutMs } : {}),
+				...(request.readiness ? { readiness: request.readiness } : {}),
 			});
 		} catch (error) {
 			throw await registrationFailure(error);