@indigoai-us/hq-cli 5.58.0 → 5.59.0

package/dist/commands/channels.d.ts

@@ -0,0 +1,16 @@
+import { Command } from "commander";
+import { type ChannelSummary } from "./dm.js";
+/**
+ * Human label for a channel row. Named channels (personal/company) show their
+ * name + a `hq dm <slug>` hint; unnamed group DMs are identified by their
+ * members (caller excluded), matching how HQ Sync renders them. Pure →
+ * unit-testable.
+ */
+export declare function describeChannel(c: ChannelSummary): string;
+/**
+ * Render the caller's channels for `hq channels`. Pure (takes the already
+ * fetched list) so the formatting is unit-testable without network/auth.
+ */
+export declare function formatChannelsList(channels: ChannelSummary[]): string;
+export declare function registerChannelsCommand(program: Command): void;
+//# sourceMappingURL=channels.d.ts.map

package/dist/commands/channels.js

@@ -0,0 +1,78 @@
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="891a3265-c9ff-53d8-8a3c-2a964f5a74b6")}catch(e){}}();
+import chalk from "chalk";
+import { ensureCognitoToken } from "../utils/cognito-session.js";
+import { vaultApiFetch } from "../utils/vault-api.js";
+import { channelSlug } from "./dm.js";
+/**
+ * Human label for a channel row. Named channels (personal/company) show their
+ * name + a `hq dm <slug>` hint; unnamed group DMs are identified by their
+ * members (caller excluded), matching how HQ Sync renders them. Pure →
+ * unit-testable.
+ */
+export function describeChannel(c) {
+    if (c.scope === "group") {
+        const names = (c.members ?? [])
+            .map((m) => m.displayName)
+            .filter((n) => !!n);
+        const who = names.length > 0
+            ? names.join(", ")
+            : `${c.memberCount ?? "?"}-person group`;
+        return `${who}  ${chalk.dim("(group DM)")}`;
+    }
+    const slug = c.slug ?? (c.name ? channelSlug(c.name) : "");
+    const scopeTag = c.scope ? chalk.dim(`(${c.scope})`) : "";
+    const hint = slug ? chalk.dim(`— hq dm ${slug} "…"`) : "";
+    return `${chalk.bold(c.name ?? slug ?? c.channelId)} ${scopeTag} ${hint}`.trim();
+}
+/**
+ * Render the caller's channels for `hq channels`. Pure (takes the already
+ * fetched list) so the formatting is unit-testable without network/auth.
+ */
+export function formatChannelsList(channels) {
+    if (channels.length === 0) {
+        return chalk.dim("No channels yet. Group DMs and named channels you're in will appear here.");
+    }
+    const lines = [
+        chalk.green(`${channels.length} channel${channels.length === 1 ? "" : "s"}:`),
+    ];
+    for (const c of channels) {
+        lines.push(`  ${describeChannel(c)}`);
+    }
+    return lines.join("\n");
+}
+async function runChannelsList() {
+    try {
+        const token = await ensureCognitoToken();
+        const res = await vaultApiFetch({ token, path: "/v1/notify/channels" });
+        if (!res.ok) {
+            if (res.status === 401) {
+                console.error(chalk.red("Not authenticated — run `hq login` and try again."));
+            }
+            else {
+                const err = (await res.json().catch(() => ({})));
+                console.error(chalk.red(`Could not list channels: ${err.error ?? err.message ?? res.statusText}`));
+            }
+            process.exit(1);
+        }
+        const data = (await res.json());
+        console.log(formatChannelsList(data.channels ?? []));
+    }
+    catch (err) {
+        console.error(chalk.red("Error:"), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+}
+export function registerChannelsCommand(program) {
+    const channels = program
+        .command("channels")
+        .description("List the DM channels you're in (name them with `hq dm <name> \"…\"`).");
+    channels
+        .command("list", { isDefault: true })
+        .description("List your DM channels — named channels and group DMs.")
+        .action(async () => {
+        await runChannelsList();
+    });
+}
+//# sourceMappingURL=channels.js.map
+//# debugId=891a3265-c9ff-53d8-8a3c-2a964f5a74b6

package/dist/commands/dm.d.ts

@@ -16,6 +16,47 @@ export declare function detectRecipient(recipient: string): DmRecipient | null;
  * (the normal 1:1 path). Pure → unit-testable.
  */
 export declare function parseGroupRecipients(recipient: string): string[] | null;
+/**
+ * Normalize a channel name into a stable slug for name matching. MIRRORS the
+ * server's `channelSlug` (hq-pro src/vault-service/lib/channels.ts): lowercase,
+ * collapse runs of non-alphanumerics to single hyphens, trim leading/trailing
+ * hyphens. Keep in lockstep with the server so `hq dm vyg-dev` matches the
+ * channel the server stored as slug `vyg-dev`. Pure → unit-testable.
+ */
+export declare function channelSlug(name: string): string;
+/**
+ * Decide whether a positional recipient token addresses a DM CHANNEL by name
+ * (rather than a person/agent or a group). Returns the bare channel name to
+ * resolve, or null when the token is a person path (email / prs_ / agt_ uid) or
+ * a comma group. Pure → unit-testable.
+ *
+ *   "#vyg-dev" → "vyg-dev"   (explicit hash form)
+ *   "vyg-dev"  → "vyg-dev"   (bare name — not an email/uid/group)
+ *   "a@b.com"  → null        (person)
+ *   "prs_…"    → null        (person)   "agt_…" → null (agent)
+ *   "a@x,b@y"  → null        (group DM)
+ */
+export declare function parseChannelName(recipient: string): string | null;
+/** Minimal channel shape the CLI reads back from GET /v1/notify/channels. */
+export interface ChannelSummary {
+    channelId: string;
+    name?: string;
+    slug?: string;
+    scope?: string;
+    memberCount?: number;
+    members?: {
+        personUid: string;
+        displayName?: string;
+    }[];
+}
+/**
+ * Find the caller's channel(s) whose name matches `name`, by slug or
+ * case-insensitive display name. Group DMs are unnamed (participant-keyed), so
+ * they never match a name. Returns ALL matches so the caller can detect an
+ * ambiguous name (same slug across personal + company scope). Pure →
+ * unit-testable.
+ */
+export declare function matchChannelsByName(channels: ChannelSummary[], name: string): ChannelSummary[];
 /**
  * Parse a relative duration like `30s`, `10m`, `2h`, `1d` into milliseconds.
  * Returns null on anything that doesn't match. Pure → unit-testable.

package/dist/commands/dm.js

@@ -1,5 +1,5 @@
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="f4bc9146-4033-5a73-a246-6f80a5e0f7ef")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="e95f345b-0e15-52b3-a851-fc97da935a99")}catch(e){}}();
 import chalk from "chalk";
 import { readFileSync } from "node:fs";
 import { ensureCognitoToken } from "../utils/cognito-session.js";
@@ -37,6 +37,72 @@ export function parseGroupRecipients(recipient) {
         .filter(Boolean);
     return [...new Set(parts)];
 }
+/**
+ * Normalize a channel name into a stable slug for name matching. MIRRORS the
+ * server's `channelSlug` (hq-pro src/vault-service/lib/channels.ts): lowercase,
+ * collapse runs of non-alphanumerics to single hyphens, trim leading/trailing
+ * hyphens. Keep in lockstep with the server so `hq dm vyg-dev` matches the
+ * channel the server stored as slug `vyg-dev`. Pure → unit-testable.
+ */
+export function channelSlug(name) {
+    return name
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+/**
+ * Decide whether a positional recipient token addresses a DM CHANNEL by name
+ * (rather than a person/agent or a group). Returns the bare channel name to
+ * resolve, or null when the token is a person path (email / prs_ / agt_ uid) or
+ * a comma group. Pure → unit-testable.
+ *
+ *   "#vyg-dev" → "vyg-dev"   (explicit hash form)
+ *   "vyg-dev"  → "vyg-dev"   (bare name — not an email/uid/group)
+ *   "a@b.com"  → null        (person)
+ *   "prs_…"    → null        (person)   "agt_…" → null (agent)
+ *   "a@x,b@y"  → null        (group DM)
+ */
+export function parseChannelName(recipient) {
+    const r = recipient.trim();
+    if (!r)
+        return null;
+    if (r.startsWith("#")) {
+        const name = r.slice(1).trim();
+        return name || null;
+    }
+    // A comma is the group-DM signal; emails and prs_/agt_ uids are person paths.
+    if (r.includes(","))
+        return null;
+    if (EMAIL_PATTERN.test(r))
+        return null;
+    if (RECIPIENT_UID_PATTERN.test(r))
+        return null;
+    return r;
+}
+/**
+ * Find the caller's channel(s) whose name matches `name`, by slug or
+ * case-insensitive display name. Group DMs are unnamed (participant-keyed), so
+ * they never match a name. Returns ALL matches so the caller can detect an
+ * ambiguous name (same slug across personal + company scope). Pure →
+ * unit-testable.
+ */
+export function matchChannelsByName(channels, name) {
+    const targetSlug = channelSlug(name);
+    const targetName = name.trim().toLowerCase();
+    if (!targetSlug && !targetName)
+        return [];
+    return channels.filter((c) => {
+        if (c.scope === "group")
+            return false;
+        const slug = c.slug ?? (c.name ? channelSlug(c.name) : "");
+        if (slug && slug === targetSlug)
+            return true;
+        if (c.name && c.name.trim().toLowerCase() === targetName)
+            return true;
+        return false;
+    });
+}
 /**
  * Parse a relative duration like `30s`, `10m`, `2h`, `1d` into milliseconds.
  * Returns null on anything that doesn't match. Pure → unit-testable.
@@ -266,13 +332,95 @@ async function runGroupSend(recipients, message) {
         process.exit(1);
     }
 }
+/** Fetch the caller's channels (GET /v1/notify/channels). */
+async function fetchChannels(token) {
+    const res = await vaultApiFetch({ token, path: "/v1/notify/channels" });
+    if (!res.ok) {
+        const err = (await res.json().catch(() => ({})));
+        throw new Error(friendlyDmError(res.status, err.code, err.error ?? err.message ?? res.statusText));
+    }
+    const data = (await res.json());
+    return data.channels ?? [];
+}
+/**
+ * Channel DM path: `hq dm vyg-dev "msg"`, `hq dm '#vyg-dev' "msg"`, or
+ * `hq dm --channel vyg-dev "msg"`. Resolves the caller's channel by name via
+ * GET /v1/notify/channels, then posts the message into it. Scheduling /
+ * prompt / details are 1:1-DM features and are rejected here rather than
+ * silently dropped.
+ */
+async function runChannelSend(channelName, message, opts) {
+    try {
+        const body = (message ?? "").trim();
+        if (!body) {
+            console.error(chalk.red(`A message body is required: hq dm ${channelName} "<message>" (or hq dm --channel ${channelName} "<message>").`));
+            process.exit(1);
+        }
+        const unsupported = [
+            opts.prompt || opts.promptFile ? "--prompt/--prompt-file" : null,
+            opts.details || opts.detailsFile ? "--details/--details-file" : null,
+            opts.at ? "--at" : null,
+            opts.in ? "--in" : null,
+        ].filter(Boolean);
+        if (unsupported.length > 0) {
+            console.error(chalk.red(`${unsupported.join(", ")} ${unsupported.length === 1 ? "is" : "are"} only supported for 1:1 DMs, not channel messages.`));
+            process.exit(1);
+        }
+        const token = await ensureCognitoToken();
+        const channels = await fetchChannels(token);
+        const matches = matchChannelsByName(channels, channelName);
+        if (matches.length === 0) {
+            console.error(chalk.red(`No channel named '${channelName}' — run \`hq channels\` to see your channels.`));
+            process.exit(1);
+        }
+        if (matches.length > 1) {
+            const scopes = matches.map((m) => m.scope ?? "?").join(", ");
+            console.error(chalk.red(`'${channelName}' matches ${matches.length} channels (${scopes}) — this is ambiguous. Open the channel in HQ Sync to post, or rename one.`));
+            process.exit(1);
+        }
+        const channel = matches[0];
+        const sendRes = await vaultApiFetch({
+            token,
+            path: `/v1/notify/channels/${encodeURIComponent(channel.channelId)}/messages`,
+            method: "POST",
+            body: { body },
+        });
+        if (!sendRes.ok) {
+            const err = (await sendRes.json().catch(() => ({})));
+            console.error(chalk.red(friendlyDmError(sendRes.status, err.code, err.error ?? err.message ?? sendRes.statusText)));
+            process.exit(1);
+        }
+        console.log(chalk.green(`Message posted to #${channel.name ?? channelName}.`));
+    }
+    catch (err) {
+        console.error(chalk.red("Error:"), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+}
 async function runDmSend(recipient, message, opts) {
+    // --channel <name> is an explicit channel target; the positional carries the
+    // message (recipient slot), e.g. `hq dm --channel vyg-dev "hello"`.
+    if (opts.channel !== undefined) {
+        await runChannelSend(opts.channel, message ?? recipient, opts);
+        return;
+    }
+    if (recipient === undefined) {
+        console.error(chalk.red('A recipient is required: hq dm <email|personUid|#channel> "<message>" (or --channel <name>).'));
+        process.exit(1);
+        return;
+    }
     // A comma in the recipient means a group DM — fan into the channel path.
     const group = parseGroupRecipients(recipient);
     if (group) {
         await runGroupSend(group, message);
         return;
     }
+    // A bare name or #hash addresses a named DM channel.
+    const channelName = parseChannelName(recipient);
+    if (channelName !== null) {
+        await runChannelSend(channelName, message, opts);
+        return;
+    }
     try {
         // Resolve prompt/details from inline text or a file.
         let prompt = opts.prompt;
@@ -354,14 +502,15 @@ export function registerDmCommand(program) {
         .command("dm")
         .description("Send a direct message and manage connection requests.");
     dm
-        .command("send <recipient> [message]", { isDefault: true, hidden: true })
-        .description('Send a direct message to someone (email, personUid, or agentUid). A person receives it as an HQ Sync notification; an agent receives it in its durable box inbox and replies by DM. If you aren\'t connected yet, it sends a connection request that holds your message. For a GROUP DM, pass a comma-separated recipient: hq dm send "a@x.com,b@y.com" "hi".')
-        .option("--prompt <text>", "Agent-context prompt the recipient can one-click copy into their agent")
-        .option("--prompt-file <path>", "Read the agent prompt from a file")
-        .option("--details <text>", "Longer detail shown in the recipient's DM detail window")
-        .option("--details-file <path>", "Read the details from a file")
-        .option("--at <iso>", "Schedule delivery at an ISO8601 time (store-and-forward; delivered within ~60s of the time)")
-        .option("--in <duration>", "Schedule delivery after a relative delay: 30s, 10m, 2h, 1d")
+        .command("send [recipient] [message]", { isDefault: true, hidden: true })
+        .description('Send a direct message. RECIPIENT can be a person (email, personUid, or agentUid), a GROUP DM (comma-separated: "a@x.com,b@y.com"), or one of your DM CHANNELS by name — bare (hq dm vyg-dev "hi"), hash form (hq dm "#vyg-dev" "hi"), or via --channel (hq dm --channel vyg-dev "hi"). A person receives a DM as an HQ Sync notification; an agent receives it in its durable box inbox. If you aren\'t connected yet, it sends a connection request that holds your message. See your channels with `hq channels`.')
+        .option("--channel <name>", "Post the message to one of your DM channels by name (e.g. --channel vyg-dev)")
+        .option("--prompt <text>", "Agent-context prompt the recipient can one-click copy into their agent (1:1 DMs only)")
+        .option("--prompt-file <path>", "Read the agent prompt from a file (1:1 DMs only)")
+        .option("--details <text>", "Longer detail shown in the recipient's DM detail window (1:1 DMs only)")
+        .option("--details-file <path>", "Read the details from a file (1:1 DMs only)")
+        .option("--at <iso>", "Schedule delivery at an ISO8601 time (store-and-forward; delivered within ~60s of the time; 1:1 DMs only)")
+        .option("--in <duration>", "Schedule delivery after a relative delay: 30s, 10m, 2h, 1d (1:1 DMs only)")
         .action(async (recipient, message, opts) => {
         await runDmSend(recipient, message, opts);
     });
@@ -391,4 +540,4 @@ export function registerDmCommand(program) {
     });
 }
 //# sourceMappingURL=dm.js.map
-//# debugId=f4bc9146-4033-5a73-a246-6f80a5e0f7ef
+//# debugId=e95f345b-0e15-52b3-a851-fc97da935a99

package/dist/commands/people.d.ts

@@ -6,21 +6,25 @@
  *   hq people search <keyword> [--company <slug>] [--json]
  *   hq people resolve <name>   [--company <slug>] [--json]
  *
- * Source of truth is `companies/<company>/people/<person>/meta.yaml`. Every
- * subcommand operates on exactly ONE company (the active company, or the one
- * named by `--company`); nothing reads across company boundaries.
+ * Local records from `companies/<company>/people/<person>/meta.yaml` are the
+ * curated primary source. On misses, commands may fall back to the membership
+ * roster for exactly ONE company (the active company, or the one named by
+ * `--company`); nothing reads across company boundaries.
  */
 import { Command } from "commander";
+import { type ActiveMember } from "./members.js";
 import { resolveNameToEmail, type PersonRecord } from "../utils/people.js";
-export type RefreshPeopleRoster = (hqRoot: string, companySlug: string) => Promise<void>;
+export type FetchPeopleRoster = (hqRoot: string, companySlug: string) => Promise<PersonRecord[]>;
 interface PeopleCommandDeps {
-    refreshRoster?: RefreshPeopleRoster;
+    fetchRoster?: FetchPeopleRoster;
 }
 interface PeopleLookupOpts {
     localOnly?: boolean;
     json?: boolean;
 }
-export declare function refreshPeopleRosterFromCloud(hqRoot: string, companySlug: string): Promise<void>;
+export declare function activeMemberToPersonRecord(m: ActiveMember): PersonRecord | null;
+export declare function fetchMembershipRoster(hqRoot: string, companySlug: string): Promise<PersonRecord[]>;
+export declare function mergePeople(primary: PersonRecord[], extra: PersonRecord[]): PersonRecord[];
 /**
  * Resolve the single company to operate on. Explicit `--company` always wins
  * (after a path-safety check). Otherwise the active company is inferred from
@@ -33,14 +37,14 @@ export declare function resolvePersonWithRosterFallback(input: {
     slug: string;
     name: string;
     opts?: PeopleLookupOpts;
-    refreshRoster?: RefreshPeopleRoster;
+    fetchRoster?: FetchPeopleRoster;
 }): Promise<ReturnType<typeof resolveNameToEmail>>;
 export declare function searchPeopleWithRosterFallback(input: {
     hqRoot: string;
     slug: string;
     keyword: string;
     opts?: PeopleLookupOpts;
-    refreshRoster?: RefreshPeopleRoster;
+    fetchRoster?: FetchPeopleRoster;
 }): Promise<PersonRecord[]>;
 export declare function registerPeopleCommand(program: Command, deps?: PeopleCommandDeps): void;
 export {};

package/dist/commands/people.js

@@ -6,35 +6,73 @@
  *   hq people search <keyword> [--company <slug>] [--json]
  *   hq people resolve <name>   [--company <slug>] [--json]
  *
- * Source of truth is `companies/<company>/people/<person>/meta.yaml`. Every
- * subcommand operates on exactly ONE company (the active company, or the one
- * named by `--company`); nothing reads across company boundaries.
+ * Local records from `companies/<company>/people/<person>/meta.yaml` are the
+ * curated primary source. On misses, commands may fall back to the membership
+ * roster for exactly ONE company (the active company, or the one named by
+ * `--company`); nothing reads across company boundaries.
  */
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="79abc1f5-4f5a-5c95-b29b-10f04417355f")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="555055d9-98e2-5fcd-b736-4b1df12daf4d")}catch(e){}}();
 import * as fs from "fs";
 import { Option } from "commander";
 import chalk from "chalk";
-import { VaultClient } from "@indigoai-us/hq-cloud";
 import * as yaml from "js-yaml";
 import { findHqRoot } from "../utils/manifest.js";
 import { manifestPath } from "./cloud-provision.js";
-import { DEFAULT_COGNITO, buildVaultConfig, ensureCognitoToken, } from "../utils/cognito-session.js";
+import { ensureCognitoToken } from "../utils/cognito-session.js";
 import { getCompanyUid } from "../utils/vault-api.js";
-import { createCompanyPresignClient, runGet } from "./files-browse.js";
+import { listActiveMembers } from "./members.js";
 import { assertSafeCompanySlug, listCompanyPeople, searchPeople, resolveNameToEmail, companyPeopleDir, } from "../utils/people.js";
-export async function refreshPeopleRosterFromCloud(hqRoot, companySlug) {
-    const accessToken = await ensureCognitoToken();
-    const client = new VaultClient(buildVaultConfig(accessToken));
-    await getCompanyUid(accessToken, companySlug);
-    await runGet({
-        path: `companies/${companySlug}/people/`,
-        hqRoot,
-        companySlug,
-        vaultClient: client,
-        companyClient: ({ companyUid }) => createCompanyPresignClient({ token: accessToken, companyUid }),
-        region: DEFAULT_COGNITO.region,
-    });
+function slugify(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-|-$/g, "");
+}
+export function activeMemberToPersonRecord(m) {
+    const name = m.personName?.trim() ||
+        m.personEmail?.trim() ||
+        m.personSlug?.trim() ||
+        "";
+    if (!name)
+        return null;
+    const email = m.personEmail?.trim() || undefined;
+    const slug = m.personSlug?.trim() || slugify(name) || m.personUid;
+    return {
+        slug,
+        name,
+        email,
+        role: m.role || undefined,
+        type: "internal",
+        source: `hq-pro membership: /membership/company/${m.companyUid}`,
+    };
+}
+export async function fetchMembershipRoster(hqRoot, companySlug) {
+    void hqRoot;
+    const token = await ensureCognitoToken();
+    const companyUid = await getCompanyUid(token, companySlug);
+    const members = await listActiveMembers(token, companyUid);
+    return members
+        .map(activeMemberToPersonRecord)
+        .filter((r) => r !== null);
+}
+function personIdentityKey(person) {
+    return (person.email?.toLowerCase() ||
+        person.slug?.toLowerCase() ||
+        person.name.toLowerCase());
+}
+export function mergePeople(primary, extra) {
+    const seen = new Set(primary.map(personIdentityKey));
+    const merged = [...primary];
+    for (const person of extra) {
+        const key = personIdentityKey(person);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        merged.push(person);
+    }
+    return merged;
 }
 /** Companies that still exist (anything not explicitly `status: archived`). */
 function activeCompanySlugs(manifest) {
@@ -103,37 +141,38 @@ function fail(message) {
     console.error(chalk.red(message));
     process.exit(1);
 }
-function logRefreshFailure(companySlug, err) {
+function logRosterFetchFailure(companySlug, err) {
     const message = err instanceof Error ? err.message : String(err);
-    console.error(chalk.dim(`  Could not refresh people roster for '${companySlug}': ${message}`));
+    console.error(chalk.dim(`  Could not fetch people roster for '${companySlug}': ${message}`));
 }
-async function tryRefreshRoster(refreshRoster, hqRoot, slug) {
+async function tryFetchRoster(fetchRoster, hqRoot, slug) {
     try {
-        await refreshRoster(hqRoot, slug);
-        return true;
+        return await fetchRoster(hqRoot, slug);
     }
     catch (err) {
-        logRefreshFailure(slug, err);
-        return false;
+        logRosterFetchFailure(slug, err);
+        return null;
     }
 }
 export async function resolvePersonWithRosterFallback(input) {
-    const local = resolveNameToEmail(listCompanyPeople(input.hqRoot, input.slug), input.name);
+    const localPeople = listCompanyPeople(input.hqRoot, input.slug);
+    const local = resolveNameToEmail(localPeople, input.name);
     if (local.status !== "not_found" || input.opts?.localOnly)
         return local;
-    const refreshed = await tryRefreshRoster(input.refreshRoster ?? refreshPeopleRosterFromCloud, input.hqRoot, input.slug);
-    if (!refreshed)
+    const roster = await tryFetchRoster(input.fetchRoster ?? fetchMembershipRoster, input.hqRoot, input.slug);
+    if (!roster)
         return local;
-    return resolveNameToEmail(listCompanyPeople(input.hqRoot, input.slug), input.name);
+    return resolveNameToEmail(mergePeople(localPeople, roster), input.name);
 }
 export async function searchPeopleWithRosterFallback(input) {
-    const local = searchPeople(listCompanyPeople(input.hqRoot, input.slug), input.keyword);
+    const localPeople = listCompanyPeople(input.hqRoot, input.slug);
+    const local = searchPeople(localPeople, input.keyword);
     if (local.length > 0 || input.opts?.localOnly)
         return local;
-    const refreshed = await tryRefreshRoster(input.refreshRoster ?? refreshPeopleRosterFromCloud, input.hqRoot, input.slug);
-    if (!refreshed)
+    const roster = await tryFetchRoster(input.fetchRoster ?? fetchMembershipRoster, input.hqRoot, input.slug);
+    if (!roster)
         return local;
-    return searchPeople(listCompanyPeople(input.hqRoot, input.slug), input.keyword);
+    return searchPeople(mergePeople(localPeople, roster), input.keyword);
 }
 export function registerPeopleCommand(program, deps = {}) {
     const people = program
@@ -147,12 +186,19 @@ export function registerPeopleCommand(program, deps = {}) {
         .command("list")
         .description("List all people recorded for the company")
         .option("--json", "Output JSON instead of a table")
-        .action((opts) => {
+        .option("--local-only", "Skip network fallback; list only the local people roster")
+        .action(async (opts) => {
         try {
             const scope = people.opts();
             const hqRoot = resolveHqRoot(scope);
             const slug = resolveCompanySlug(hqRoot, scope.company);
-            const records = listCompanyPeople(hqRoot, slug);
+            let records = listCompanyPeople(hqRoot, slug);
+            if (!opts.localOnly) {
+                const roster = await tryFetchRoster(deps.fetchRoster ?? fetchMembershipRoster, hqRoot, slug);
+                if (roster)
+                    records = mergePeople(records, roster);
+            }
+            records = records.sort((a, b) => a.name.localeCompare(b.name));
             if (opts.json) {
                 console.log(JSON.stringify(records, null, 2));
                 return;
@@ -171,7 +217,7 @@ export function registerPeopleCommand(program, deps = {}) {
         .command("search <keyword>")
         .description("Keyword search over people names and emails")
         .option("--json", "Output JSON instead of a table")
-        .option("--local-only", "Skip cloud fallback; search only the local people roster")
+        .option("--local-only", "Skip network fallback; search only the local people roster")
         .action(async (keyword, opts) => {
         try {
             const scope = people.opts();
@@ -182,7 +228,7 @@ export function registerPeopleCommand(program, deps = {}) {
                 slug,
                 keyword,
                 opts,
-                refreshRoster: deps.refreshRoster,
+                fetchRoster: deps.fetchRoster,
             });
             if (opts.json) {
                 console.log(JSON.stringify(matches, null, 2));
@@ -202,7 +248,7 @@ export function registerPeopleCommand(program, deps = {}) {
         .command("resolve <name>")
         .description("Resolve a person name to their email address")
         .option("--json", "Output JSON instead of plain text")
-        .option("--local-only", "Skip cloud fallback; resolve only from the local people roster")
+        .option("--local-only", "Skip network fallback; resolve only from the local people roster")
         .action(async (name, opts) => {
         try {
             const scope = people.opts();
@@ -213,7 +259,7 @@ export function registerPeopleCommand(program, deps = {}) {
                 slug,
                 name,
                 opts,
-                refreshRoster: deps.refreshRoster,
+                fetchRoster: deps.fetchRoster,
             });
             if (opts.json) {
                 console.log(JSON.stringify(result, null, 2));
@@ -247,4 +293,4 @@ export function registerPeopleCommand(program, deps = {}) {
     });
 }
 //# sourceMappingURL=people.js.map
-//# debugId=79abc1f5-4f5a-5c95-b29b-10f04417355f
+//# debugId=555055d9-98e2-5fcd-b736-4b1df12daf4d

package/dist/index.js

@@ -5,7 +5,7 @@
 // MUST be first: guard the Node version before any dependency that needs a
 // Node 20+ API (e.g. util.styleText) or a newer native ABI is evaluated.
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="6ad01242-c165-5be2-bb31-e929c0b38f5e")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="8839ee7d-9f6d-54fe-8f90-99ad858e349e")}catch(e){}}();
 import "./node-preflight.js";
 import { Command } from "commander";
 import { initSentry, Sentry } from "./sentry.js";
@@ -41,6 +41,7 @@ import { registerFilesBrowseCommands } from "./commands/files-browse.js";
 import { registerMembersCommand } from "./commands/members.js";
 import { registerPeopleCommand } from "./commands/people.js";
 import { registerDmCommand } from "./commands/dm.js";
+import { registerChannelsCommand } from "./commands/channels.js";
 import { registerFeedbackCommand } from "./commands/feedback.js";
 import { registerMeetingsCommand } from "./commands/meetings.js";
 import { registerSourcesCommand } from "./commands/sources.js";
@@ -152,6 +153,7 @@ registerMembersCommand(program);
 // the local companies/<co>/people store scoped to one company.
 registerPeopleCommand(program);
 registerDmCommand(program);
+registerChannelsCommand(program);
 // Onboarding (top-level — Cognito + vault-service provisioning)
 registerOnboardCommand(program);
 // Feedback (subcommand group — hq feedback bug|feature)
@@ -242,4 +244,4 @@ registerCompanyCommand(program);
     }
 })();
 //# sourceMappingURL=index.js.map
-//# debugId=6ad01242-c165-5be2-bb31-e929c0b38f5e
+//# debugId=8839ee7d-9f6d-54fe-8f90-99ad858e349e

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.58.0",
+  "version": "5.59.0",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {