@indigoai-us/hq-cli 5.345.179 → 5.345.181

package/dist/commands/channels.js

@@ -2,7 +2,7 @@ import chalk from "chalk";
 import { ensureCognitoToken } from "../utils/cognito-session.js";
 import { vaultApiFetch } from "../utils/vault-api.js";
 import { suggestChannels, withChannelSuggestions } from "./channel-suggest.js";
-import { callerFromToken, channelSlug, fetchChannelMembers, fetchChannels, matchChannelsByName, } from "./dm.js";
+import { callerFromToken, channelSlug, fetchChannelMembers, fetchChannels, matchChannelsByName, matchContactByName, } 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
@@ -294,6 +294,176 @@ async function runChannelsDelete(channelName, opts) {
         process.exit(1);
     }
 }
+// ─── Channel membership: add / remove ────────────────────────────────────────
+/**
+ * Resolve the `<member>` argument of `hq channels add|remove` to a person or
+ * agent uid. Accepts a uid (`prs_…`, `agt_…`), an email, or a display name /
+ * @handle matched against the caller's DM contacts (which include the bots the
+ * caller owns). Pure → unit-testable. Returns an error sentence on no or
+ * ambiguous match so the caller never guesses. Feedback e165b286.
+ */
+export function resolveMemberTarget(contacts, raw) {
+    const target = raw.trim().replace(/^@/, "");
+    if (!target)
+        return { ok: false, error: "Name a member: a @handle, an email, or a prs_/agt_ uid." };
+    if (/^(prs|agt)_[A-Za-z0-9_-]+$/.test(target)) {
+        const known = contacts.find((c) => c.personUid === target);
+        return { ok: true, personUid: target, displayName: known?.displayName?.trim() || target };
+    }
+    if (target.includes("@")) {
+        const email = target.toLowerCase();
+        const hits = contacts.filter((c) => c.personUid && c.email?.trim().toLowerCase() === email);
+        const unique = [...new Map(hits.map((c) => [c.personUid, c])).values()];
+        if (unique.length === 1) {
+            return { ok: true, personUid: unique[0].personUid, displayName: unique[0].displayName?.trim() || email };
+        }
+        return {
+            ok: false,
+            error: unique.length === 0
+                ? `No contact with the email '${target}'. They must share a company with you; pass their prs_/agt_ uid to add them anyway.`
+                : `'${target}' matches ${unique.length} contacts. Pass the prs_/agt_ uid instead.`,
+        };
+    }
+    const match = matchContactByName(contacts, target);
+    if (match?.personUid) {
+        return { ok: true, personUid: match.personUid, displayName: match.displayName?.trim() || target };
+    }
+    const names = contacts
+        .map((c) => c.displayName?.trim())
+        .filter((n) => Boolean(n))
+        .sort((a, b) => a.localeCompare(b));
+    return {
+        ok: false,
+        error: `No contact matches '${raw.trim()}'. Contacts: ${names.slice(0, 12).join(", ") || "(none)"}` +
+            `${names.length > 12 ? ", …" : ""}. Use the exact name, an email, or a prs_/agt_ uid.`,
+    };
+}
+async function fetchDmContacts(token) {
+    const res = await vaultApiFetch({ token, path: "/v1/notify/contacts" });
+    if (!res.ok)
+        return [];
+    const data = (await res.json().catch(() => ({})));
+    return Array.isArray(data.contacts) ? data.contacts : [];
+}
+async function resolveOneChannel(token, channelName) {
+    const channels = await fetchChannels(token);
+    const matches = matchChannelsByName(channels, channelName);
+    if (matches.length === 0) {
+        const message = `No channel named '${channelName}'. Run \`hq channels\` to see your channels.`;
+        throw new Error(withChannelSuggestions(message, suggestChannels(channels, channelName)));
+    }
+    if (matches.length > 1) {
+        const scopes = matches.map((match) => match.scope ?? "?").join(", ");
+        throw new Error(`'${channelName}' matches ${matches.length} channels (${scopes}). Name one of them.`);
+    }
+    return matches[0];
+}
+/** The server's refusal, as one plain sentence. */
+export async function channelMembershipError(res, verb, fallback) {
+    const err = (await res.json().catch(() => ({})));
+    switch (err.code) {
+        case "CHANNEL_NOT_MEMBER":
+            return "Join the channel before adding members (so far you only browse it). Post once with `hq dm <channel> \"…\"`, or add yourself first with your own uid.";
+        case "INVITEE_NOT_FOUND":
+            return "That person or bot is not reachable from this company.";
+        case "CHANNEL_NOT_OWNER":
+            return verb === "add"
+                ? "Only the channel owner or a company admin can add members."
+                : "Only the channel owner or a company admin can remove other members, and the channel owner cannot be removed.";
+        default: {
+            const detail = err.error ?? err.message;
+            return detail ? `${fallback} (HTTP ${res.status}): ${detail}` : `${fallback} (HTTP ${res.status})`;
+        }
+    }
+}
+/**
+ * `hq channels add <channel> <member…>`: POST /v1/notify/channels/{id}/members
+ * once per member. Agents (`agt_…`) are allowed; this is how an owner adds a
+ * personal bot to a channel so everyone there can @mention it. The server
+ * reports `alreadyMember` on a repeat, which is printed, not treated as an error.
+ */
+async function runChannelsAdd(channelName, members, opts) {
+    let failed;
+    try {
+        const token = await ensureCognitoToken();
+        const channel = await resolveOneChannel(token, channelName);
+        const contacts = await fetchDmContacts(token);
+        const results = [];
+        for (const raw of members) {
+            const target = resolveMemberTarget(contacts, raw);
+            if (!target.ok) {
+                results.push({ member: raw, ok: false, error: target.error });
+                continue;
+            }
+            const res = await vaultApiFetch({
+                token,
+                path: `/v1/notify/channels/${encodeURIComponent(channel.channelId)}/members`,
+                method: "POST",
+                body: { toPersonUid: target.personUid },
+            });
+            if (!res.ok) {
+                results.push({ member: raw, personUid: target.personUid, ok: false, error: await channelMembershipError(res, "add", "Could not add the member") });
+                continue;
+            }
+            const data = (await res.json().catch(() => ({})));
+            results.push({ member: target.displayName, personUid: target.personUid, ok: true, alreadyMember: data.alreadyMember === true });
+        }
+        const label = channel.name ?? channelName;
+        if (opts.json) {
+            console.log(JSON.stringify({ channelId: channel.channelId, name: label, results }, null, 2));
+        }
+        else {
+            for (const r of results) {
+                if (r.ok) {
+                    console.log(r.alreadyMember ? chalk.dim(`${r.member} is already in #${label}.`) : chalk.green(`Added ${r.member} to #${label}.`));
+                }
+                else {
+                    console.error(chalk.red(`${r.member}: ${r.error}`));
+                }
+            }
+        }
+        failed = results.some((r) => !r.ok);
+    }
+    catch (err) {
+        console.error(chalk.red("Error:"), err instanceof Error ? err.message : String(err));
+        failed = true;
+    }
+    if (failed)
+        process.exit(1);
+}
+/** `hq channels remove <channel> <member>`: DELETE /v1/notify/channels/{id}/members/{uid}. */
+async function runChannelsRemove(channelName, member, opts) {
+    try {
+        const token = await ensureCognitoToken();
+        const channel = await resolveOneChannel(token, channelName);
+        // The member is in the channel, so resolve against the roster first, then contacts.
+        const roster = await fetchChannelMembers(token, channel.channelId);
+        const rosterContacts = roster.map((m) => ({ personUid: m.personUid, email: m.email, displayName: m.displayName }));
+        let target = resolveMemberTarget(rosterContacts, member);
+        if (!target.ok)
+            target = resolveMemberTarget(await fetchDmContacts(token), member);
+        if (!target.ok)
+            throw new Error(target.error);
+        const res = await vaultApiFetch({
+            token,
+            path: `/v1/notify/channels/${encodeURIComponent(channel.channelId)}/members/${encodeURIComponent(target.personUid)}`,
+            method: "DELETE",
+        });
+        if (!res.ok)
+            throw new Error(await channelMembershipError(res, "remove", "Could not remove the member"));
+        const label = channel.name ?? channelName;
+        if (opts.json) {
+            console.log(JSON.stringify({ channelId: channel.channelId, personUid: target.personUid, removed: true }, null, 2));
+        }
+        else {
+            console.log(chalk.green(`Removed ${target.displayName} from #${label}.`));
+        }
+    }
+    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")
@@ -329,5 +499,19 @@ export function registerChannelsCommand(program) {
         .action(async (channelName, opts) => {
         await runChannelsDelete(channelName, opts);
     });
+    channels
+        .command("add <channel> <member...>")
+        .description("Add people or your own bots to a channel, by @handle, email, or prs_/agt_ uid.")
+        .option("--json", "Output the per-member results as JSON.")
+        .action(async (channelName, members, opts) => {
+        await runChannelsAdd(channelName, members, opts);
+    });
+    channels
+        .command("remove <channel> <member>")
+        .description("Remove a member or bot from a channel (owner or company admin), or leave it yourself.")
+        .option("--json", "Output the result as JSON.")
+        .action(async (channelName, member, opts) => {
+        await runChannelsRemove(channelName, member, opts);
+    });
 }
 //# sourceMappingURL=channels.js.map

package/dist/commands/lanes.d.ts

@@ -147,7 +147,7 @@ export declare function checkpointInstruction(worker: Pick<ResolvedLaneWorker, "
 export declare function composeWorkerBrief(worker: ResolvedLaneWorker, taskBrief: string, hqRoot: string): string;
 /**
  * A lane with no worker still carries the standing authorization paragraph,
- * the foreground-only rule and the temp-home rule.
+ * the foreground-only rule, the temp-home rule and the self-review rule.
  */
 export declare function composeGeneralBrief(taskBrief: string, hqRoot: string): string;
 export declare const DISPATCH_TERMINAL_REASON: "outpost_dispatch_failed";

package/dist/commands/lanes.js

@@ -108,7 +108,7 @@ import { resolveKrFreshnessForShow } from "../lib/lanes/kr-freshness.js";
 import { ensureSessionHome } from "../lib/lanes/session-relink.js";
 import { defaultProbe, validateProfileLaneModel, validateLaneModel, } from "../lib/lanes/models.js";
 import { readLaneClaudeCredential } from "../lib/lanes/claude-credential.js";
-import { parseCliModel, refuseOutpostSelfTarget, resolveLaneModel, FOREGROUND_ONLY_RULE, STANDING_AUTHORIZATION, tempHomeRule, spawnLaneWorker, spawnEnvelopeRepairRequest, laneRunDir, readSpawnManifest, stopLaneProcesses, } from "../lib/lanes/spawn.js";
+import { parseCliModel, refuseOutpostSelfTarget, resolveLaneModel, FOREGROUND_ONLY_RULE, STANDING_AUTHORIZATION, selfReviewRule, tempHomeRule, spawnLaneWorker, spawnEnvelopeRepairRequest, laneRunDir, readSpawnManifest, stopLaneProcesses, } from "../lib/lanes/spawn.js";
 import { handOffInstallHere } from "../lib/daemon/handoff.js";
 export { spawnLaneWorker };
 export function openPullRequestsForProject(hqRoot, metadata) {
@@ -3041,11 +3041,13 @@ export function composeWorkerBrief(worker, taskBrief, hqRoot) {
         "",
         tempHomeRule(hqRoot),
         "",
+        selfReviewRule(hqRoot),
+        "",
     ].join("\n");
 }
 /**
  * A lane with no worker still carries the standing authorization paragraph,
- * the foreground-only rule and the temp-home rule.
+ * the foreground-only rule, the temp-home rule and the self-review rule.
  */
 export function composeGeneralBrief(taskBrief, hqRoot) {
     return [
@@ -3058,6 +3060,8 @@ export function composeGeneralBrief(taskBrief, hqRoot) {
         "",
         tempHomeRule(hqRoot),
         "",
+        selfReviewRule(hqRoot),
+        "",
     ].join("\n");
 }
 function parseMaxRuntimeSeconds(raw, workerId) {

package/dist/commands/mesh.js

@@ -3071,6 +3071,25 @@ export function registerMeshCommand(program, deps = {}) {
         .description("Report daemon running/MQTT/spool/held/dead-letter/outbox/flush health")
         .option("--json", "Print machine-readable JSON")
         .action((opts) => wrap(() => runDaemonDoctorCmd(opts))());
+    mesh
+        .command("push-status")
+        .description("Report whether the owner DM push signal is live or stale, with the last event time")
+        .option("--json", "Print machine-readable JSON")
+        .action((opts) => wrap(() => runMeshPushStatus(opts))());
+}
+async function runMeshPushStatus(opts) {
+    const { ownerPushStatusForAccount, readOwnerInboxPushState, formatOwnerPushStatus } = await import("../lib/mesh/live/daemon/owner-inbox-push.js");
+    const { describeCognitoTokenSource } = await import("../utils/cognito-session.js");
+    const { actorKind } = describeCognitoTokenSource({ home: os.homedir(), env: process.env });
+    const status = ownerPushStatusForAccount(readOwnerInboxPushState(workMeshRoot(undefined, process.env)), Date.now(), actorKind);
+    if (opts.json) {
+        console.log(JSON.stringify(status, null, 2));
+    }
+    else {
+        console.log(formatOwnerPushStatus(status));
+    }
+    if (status.status === "stale")
+        process.exitCode = 1;
 }
 async function runDaemonRun(opts = {}) {
     const { runMeshDaemon } = await import("../lib/mesh/live/daemon/run.js");