@indigoai-us/hq-cli 5.25.1 → 5.28.0

package/dist/commands/dm.d.ts

@@ -0,0 +1,41 @@
+import { Command } from "commander";
+export interface DmRecipient {
+    toEmail?: string;
+    toPersonUid?: string;
+}
+/**
+ * Classify a recipient arg as an email or a personUid. Mirrors the
+ * email/prs_ heuristic used by `hq members`. Returns null for neither.
+ */
+export declare function detectRecipient(recipient: string): DmRecipient | null;
+/**
+ * Parse a relative duration like `30s`, `10m`, `2h`, `1d` into milliseconds.
+ * Returns null on anything that doesn't match. Pure → unit-testable.
+ */
+export declare function parseDuration(input: string): number | null;
+export interface DmSendBody {
+    toEmail?: string;
+    toPersonUid?: string;
+    body: string;
+    prompt?: string;
+    details?: string;
+    deliverAt?: string;
+}
+/**
+ * Build the POST /v1/notify/dm request body from CLI inputs. Pure (no I/O,
+ * no clock) so the option-resolution logic is unit-testable; the caller
+ * supplies `now` for the `--in` relative-delay computation.
+ *
+ * Throws Error with a user-facing message on invalid input.
+ */
+export declare function buildDmBody(args: {
+    recipient: string;
+    message: string;
+    prompt?: string;
+    details?: string;
+    at?: string;
+    inDelay?: string;
+    now: number;
+}): DmSendBody;
+export declare function registerDmCommand(program: Command): void;
+//# sourceMappingURL=dm.d.ts.map

package/dist/commands/dm.js

@@ -0,0 +1,148 @@
+
+!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]="69d48194-d5ae-508e-b614-68f2066db6ee")}catch(e){}}();
+import chalk from "chalk";
+import { readFileSync } from "node:fs";
+import { ensureCognitoToken } from "../utils/cognito-session.js";
+import { vaultApiFetch } from "../utils/vault-api.js";
+const EMAIL_PATTERN = /^[^\s]+@[^\s]+$/;
+const PERSON_UID_PATTERN = /^prs_[A-Za-z0-9_-]+$/;
+/**
+ * Classify a recipient arg as an email or a personUid. Mirrors the
+ * email/prs_ heuristic used by `hq members`. Returns null for neither.
+ */
+export function detectRecipient(recipient) {
+    const r = recipient.trim();
+    if (EMAIL_PATTERN.test(r))
+        return { toEmail: r.toLowerCase() };
+    if (PERSON_UID_PATTERN.test(r))
+        return { toPersonUid: r };
+    return null;
+}
+/**
+ * Parse a relative duration like `30s`, `10m`, `2h`, `1d` into milliseconds.
+ * Returns null on anything that doesn't match. Pure → unit-testable.
+ */
+export function parseDuration(input) {
+    const m = /^(\d+)\s*(s|m|h|d)$/.exec(input.trim());
+    if (!m)
+        return null;
+    const n = parseInt(m[1], 10);
+    const mult = {
+        s: 1000,
+        m: 60_000,
+        h: 3_600_000,
+        d: 86_400_000,
+    };
+    return n * mult[m[2]];
+}
+/**
+ * Build the POST /v1/notify/dm request body from CLI inputs. Pure (no I/O,
+ * no clock) so the option-resolution logic is unit-testable; the caller
+ * supplies `now` for the `--in` relative-delay computation.
+ *
+ * Throws Error with a user-facing message on invalid input.
+ */
+export function buildDmBody(args) {
+    const rcpt = detectRecipient(args.recipient);
+    if (!rcpt) {
+        throw new Error(`Invalid recipient '${args.recipient}': must be an email address or a personUid (prs_…).`);
+    }
+    const body = (args.message ?? "").trim();
+    if (!body) {
+        throw new Error("A message body is required: hq dm <recipient> <message>");
+    }
+    if (args.at && args.inDelay) {
+        throw new Error("Use only one of --at or --in, not both.");
+    }
+    let deliverAt;
+    if (args.at) {
+        const when = new Date(args.at);
+        if (isNaN(when.getTime())) {
+            throw new Error(`Invalid --at '${args.at}': must be an ISO8601 date.`);
+        }
+        deliverAt = when.toISOString();
+    }
+    else if (args.inDelay) {
+        const ms = parseDuration(args.inDelay);
+        if (ms === null) {
+            throw new Error(`Invalid --in '${args.inDelay}': use a relative delay like 30s, 10m, 2h, 1d.`);
+        }
+        deliverAt = new Date(args.now + ms).toISOString();
+    }
+    const prompt = args.prompt?.trim();
+    const details = args.details?.trim();
+    return {
+        ...rcpt,
+        body,
+        ...(prompt ? { prompt } : {}),
+        ...(details ? { details } : {}),
+        ...(deliverAt ? { deliverAt } : {}),
+    };
+}
+function friendlyDmError(status, code, fallback) {
+    if (status === 401)
+        return "Not authenticated — run `hq login` and try again.";
+    if (status === 404 || code === "RECIPIENT_NOT_FOUND") {
+        return "Recipient not found or not reachable — you can only DM someone you share an active company with.";
+    }
+    if (status >= 500)
+        return `Server error: ${fallback}`;
+    return fallback;
+}
+export function registerDmCommand(program) {
+    program
+        .command("dm <recipient> [message]")
+        .description("Send a direct message to a teammate (email or personUid). They receive it as an HQ Sync notification.")
+        .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")
+        .action(async (recipient, message, opts) => {
+        try {
+            // Resolve prompt/details from inline text or a file.
+            let prompt = opts.prompt;
+            if (opts.promptFile)
+                prompt = readFileSync(opts.promptFile, "utf8");
+            let details = opts.details;
+            if (opts.detailsFile)
+                details = readFileSync(opts.detailsFile, "utf8");
+            const reqBody = buildDmBody({
+                recipient,
+                message: message ?? "",
+                prompt,
+                details,
+                at: opts.at,
+                inDelay: opts.in,
+                now: Date.now(),
+            });
+            const token = await ensureCognitoToken();
+            const res = await vaultApiFetch({
+                token,
+                path: "/v1/notify/dm",
+                method: "POST",
+                body: reqBody,
+            });
+            if (!res.ok) {
+                const err = (await res.json().catch(() => ({})));
+                console.error(chalk.red(friendlyDmError(res.status, err.code, err.error ?? err.message ?? res.statusText)));
+                process.exit(1);
+            }
+            const data = (await res.json());
+            if (data.scheduled) {
+                console.log(chalk.green(`Scheduled DM to ${recipient} for ${data.deliverAt} (eventId ${data.eventId}).`));
+                console.log(chalk.dim("It delivers within ~60s of that time, even if you're offline."));
+            }
+            else {
+                console.log(chalk.green(`DM sent to ${recipient} (eventId ${data.eventId}).`));
+            }
+        }
+        catch (err) {
+            console.error(chalk.red("Error:"), err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+    });
+}
+//# sourceMappingURL=dm.js.map
+//# debugId=69d48194-d5ae-508e-b614-68f2066db6ee

package/dist/commands/files-browse.d.ts

@@ -205,6 +205,55 @@ export interface RunCatResult {
  * containment guard). Refuses ahead of any I/O when `--out` is unsafe.
  */
 export declare function runCat(input: RunCatInput): Promise<RunCatResult>;
+/**
+ * Subset of `VaultClient` the `shared-with-me` orchestrator uses. No vend / S3
+ * — this is a pure read of the caller's explicit-grant graph, so it never
+ * touches the credential/browse vend surface.
+ */
+export interface FilesSharedWithMeVaultClient {
+    listMyMemberships(): Promise<Array<{
+        companyUid: string;
+    }>>;
+    listMyExplicitGrants(companyUid: string): Promise<ExplicitGrant[]>;
+    entity: {
+        get(uid: string): Promise<{
+            uid: string;
+            slug: string;
+            name?: string;
+        }>;
+    };
+}
+export interface SharedWithMeRow {
+    companySlug: string;
+    /** Company-relative grant path (e.g. `knowledge/`, `reports/q3.pdf`). */
+    path: string;
+    permission: ExplicitGrant["permission"];
+    source: ExplicitGrant["source"];
+}
+export interface RunSharedWithMeInput {
+    vaultClient: FilesSharedWithMeVaultClient;
+    /**
+     * Scope to a single company by UID. When omitted, rolls up across every
+     * company the caller has a membership in (the cross-company "what's shared
+     * with me everywhere" view).
+     */
+    companyUid?: string;
+    /** Display slug for the single-company case (avoids an extra entity.get). */
+    companySlug?: string;
+}
+/**
+ * `hq files shared-with-me` orchestrator. Lists the caller's EXPLICIT
+ * file-ACL grants — the canonical "what's been shared with me" surface.
+ * Role-bypass access (owner/admin) is intentionally excluded server-side by
+ * `listMyExplicitGrants`, so this shows real grants, not role-implied reach.
+ *
+ * Pure data — no console output, no S3, no vend. The caller renders + exits.
+ */
+export declare function runSharedWithMe(input: RunSharedWithMeInput): Promise<SharedWithMeRow[]>;
+/**
+ * Render `shared-with-me` rows as a padded table. Mirrors `formatBrowseTable`.
+ */
+export declare function formatSharedWithMeTable(rows: SharedWithMeRow[]): string;
 /**
  * Wire `hq files browse` + `hq files cat` onto an existing `files`
  * Commander group. `registerFilesCommand` in files.ts builds the group

package/dist/commands/files-browse.js

@@ -29,7 +29,7 @@
  * `pnpm.overrides` until that release ships to npm.
  */
 
-!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]="55a4ece7-6b33-5809-97c0-475c423bc012")}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]="102456e4-666a-5484-b432-7f0b73275818")}catch(e){}}();
 import chalk from "chalk";
 import * as fs from "node:fs";
 import * as path from "node:path";
@@ -283,6 +283,79 @@ export async function runCat(input) {
     await pipeline(body, input.stdout ?? process.stdout);
     return { bytesWritten, destination: { kind: "stdout" }, vend };
 }
+/**
+ * `hq files shared-with-me` orchestrator. Lists the caller's EXPLICIT
+ * file-ACL grants — the canonical "what's been shared with me" surface.
+ * Role-bypass access (owner/admin) is intentionally excluded server-side by
+ * `listMyExplicitGrants`, so this shows real grants, not role-implied reach.
+ *
+ * Pure data — no console output, no S3, no vend. The caller renders + exits.
+ */
+export async function runSharedWithMe(input) {
+    const { vaultClient } = input;
+    // Resolve the (companyUid, slug) pairs to query. Single-company when a UID
+    // was supplied; otherwise fan out across every membership.
+    let targets;
+    if (input.companyUid) {
+        targets = [{ uid: input.companyUid, slug: input.companySlug ?? input.companyUid }];
+    }
+    else {
+        const memberships = await vaultClient.listMyMemberships();
+        targets = await Promise.all(memberships.map(async (m) => {
+            try {
+                const ent = await vaultClient.entity.get(m.companyUid);
+                return { uid: m.companyUid, slug: ent.slug || m.companyUid };
+            }
+            catch {
+                // Entity not visible — fall back to the UID as the display label
+                // rather than dropping the company's grants entirely.
+                return { uid: m.companyUid, slug: m.companyUid };
+            }
+        }));
+    }
+    const rows = [];
+    for (const t of targets) {
+        let grants;
+        try {
+            grants = await vaultClient.listMyExplicitGrants(t.uid);
+        }
+        catch {
+            // A single company's grant fetch failing shouldn't sink the whole
+            // roll-up — skip it and continue (best-effort discovery view).
+            continue;
+        }
+        for (const g of grants) {
+            rows.push({
+                companySlug: t.slug,
+                path: g.path,
+                permission: g.permission,
+                source: g.source,
+            });
+        }
+    }
+    // Stable sort: company, then path — deterministic output for humans + tests.
+    rows.sort((a, b) => a.companySlug === b.companySlug
+        ? a.path.localeCompare(b.path)
+        : a.companySlug.localeCompare(b.companySlug));
+    return rows;
+}
+/**
+ * Render `shared-with-me` rows as a padded table. Mirrors `formatBrowseTable`.
+ */
+export function formatSharedWithMeTable(rows) {
+    if (rows.length === 0) {
+        return "Nothing is explicitly shared with you. (Owner/admin role-bypass access is not listed here — only explicit grants.)";
+    }
+    const cols = ["COMPANY", "PATH", "PERMISSION", "SOURCE"];
+    const data = rows.map((r) => [r.companySlug, r.path, r.permission, r.source]);
+    const widths = cols.map((c, i) => Math.max(c.length, ...data.map((row) => row[i].length)));
+    const renderRow = (row) => row.map((cell, i) => cell.padEnd(widths[i])).join("  ");
+    return [
+        chalk.bold(renderRow(cols)),
+        chalk.dim(renderRow(widths.map((w) => "─".repeat(w)))),
+        ...data.map(renderRow),
+    ].join("\n");
+}
 // ── CLI registration ────────────────────────────────────────────────────────
 const defaultS3Factory = ({ region, credentials }) => new S3Client({ region, credentials });
 /**
@@ -447,6 +520,33 @@ export function registerFilesBrowseCommands(filesCmd) {
             process.exit(1);
         }
     });
+    filesCmd
+        .command("shared-with-me")
+        .description("List the files/prefixes explicitly shared with you. Omit --company to roll up across every company you're a member of. Pure read — no download, no credentials vended. Owner/admin role-bypass access is NOT listed (only explicit grants).")
+        .option("--company <slug>", "Scope to a single company (defaults to a cross-company roll-up).")
+        .action(async (options) => {
+        try {
+            const accessToken = await ensureCognitoToken();
+            const vaultConfig = buildVaultConfig(accessToken);
+            const client = new VaultClient(vaultConfig);
+            let companyUid;
+            if (options.company) {
+                // Confirm membership + resolve UID, same early-failure pattern as
+                // browse/cat. Roll-up mode skips this and fans out internally.
+                companyUid = await getCompanyUid(accessToken, options.company);
+            }
+            const rows = await runSharedWithMe({
+                vaultClient: client,
+                companyUid,
+                companySlug: options.company,
+            });
+            console.log(formatSharedWithMeTable(rows));
+        }
+        catch (err) {
+            console.error(chalk.red("Error:"), err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+    });
 }
 //# sourceMappingURL=files-browse.js.map
-//# debugId=55a4ece7-6b33-5809-97c0-475c423bc012
+//# debugId=102456e4-666a-5484-b432-7f0b73275818

package/dist/commands/sync-narrow.js

@@ -37,11 +37,11 @@
  * `file:../hq-cloud` via `pnpm.overrides`.
  */
 
-!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]="a6c1e2b9-5d9a-57b2-a80b-adfdbce88206")}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]="8cdf980e-e3cf-585c-b2e5-1615765675a1")}catch(e){}}();
 import chalk from "chalk";
 import * as readline from "node:readline";
 import * as fs from "node:fs";
-import { VaultClient, coalescePrefixes, readJournal, writeJournal, tombstoneEntry, } from "@indigoai-us/hq-cloud";
+import { VaultClient, coalescePrefixes, grantPathToPrefix, readJournal, writeJournal, tombstoneEntry, } from "@indigoai-us/hq-cloud";
 import { DEFAULT_HQ_ROOT, ensureCognitoToken, buildVaultConfig, } from "../utils/cognito-session.js";
 import { readActiveCompanySlug } from "./sync-mode.js";
 import { buildNarrowPlan, formatBytes, formatNarrowPlanSummary, } from "../lib/local-tree-diff.js";
@@ -115,7 +115,18 @@ export async function computeNarrowPlan(input) {
     const { hqRoot, companySlug, companyUid, vaultClient } = input;
     const io = input.journalIO ?? realJournalIO;
     const grants = await vaultClient.listMyExplicitGrants(companyUid);
-    const prospectivePrefixSet = coalescePrefixes(grants.map((g) => g.path));
+    // Normalize each grant into a company-relative, startsWith-friendly prefix
+    // (grantPathToPrefix, hq-cloud ≥5.42.0): real grants are anchored
+    // (`companies/<slug>/x/*`, `<slug>/x/*`) and glob-style (`x/*`, bare `*`),
+    // none of which startsWith-match the company-relative local-tree keys
+    // buildNarrowPlan emits. A wildcard grant normalizes to "" (everything);
+    // coalescePrefixes drops empties, so guard it explicitly to `[""]` (which
+    // isCoveredByAny treats as covering everything → nothing orphaned) rather
+    // than letting it collapse to "nothing" and propose deleting the tree.
+    const normalizedPrefixes = grants.map((g) => grantPathToPrefix(g.path, companySlug));
+    const prospectivePrefixSet = normalizedPrefixes.some((p) => p === "")
+        ? [""]
+        : coalescePrefixes(normalizedPrefixes);
     const journal = io.read(companySlug);
     const plan = buildNarrowPlan({
         hqRoot,
@@ -324,4 +335,4 @@ export function registerSyncNarrowCommand(syncCmd) {
     });
 }
 //# sourceMappingURL=sync-narrow.js.map
-//# debugId=a6c1e2b9-5d9a-57b2-a80b-adfdbce88206
+//# debugId=8cdf980e-e3cf-585c-b2e5-1615765675a1

package/dist/index.js

@@ -3,7 +3,7 @@
  * HQ CLI - Module management, package management, and cloud sync for HQ
  */
 
-!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]="0ed956d3-5fde-54aa-96cb-1859a15f7723")}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]="d7693093-4011-58fa-b5be-805b5f9f5421")}catch(e){}}();
 import { Command } from "commander";
 import { initSentry, Sentry } from "./sentry.js";
 import { registerAddCommand } from "./commands/add.js";
@@ -31,6 +31,7 @@ import { registerGroupsCommand } from "./commands/groups.js";
 import { registerFilesCommand } from "./commands/files.js";
 import { registerFilesBrowseCommands } from "./commands/files-browse.js";
 import { registerMembersCommand } from "./commands/members.js";
+import { registerDmCommand } from "./commands/dm.js";
 import { registerFeedbackCommand } from "./commands/feedback.js";
 import { registerMeetingsCommand } from "./commands/meetings.js";
 import { registerSourcesCommand } from "./commands/sources.js";
@@ -110,6 +111,7 @@ const filesCmd = registerFilesCommand(program);
 registerFilesBrowseCommands(filesCmd);
 // Membership management (subcommand group — hq members invite|list|revoke)
 registerMembersCommand(program);
+registerDmCommand(program);
 // Onboarding (top-level — Cognito + vault-service provisioning)
 registerOnboardCommand(program);
 // Feedback (subcommand group — hq feedback bug|feature)
@@ -146,4 +148,4 @@ registerSignalsCommand(program);
     }
 })();
 //# sourceMappingURL=index.js.map
-//# debugId=0ed956d3-5fde-54aa-96cb-1859a15f7723
+//# debugId=d7693093-4011-58fa-b5be-805b5f9f5421

package/dist/lib/local-tree-diff.d.ts

@@ -26,7 +26,11 @@
 import { type SyncJournal } from "@indigoai-us/hq-cloud";
 export type DirtyReason = "modified-after-sync" | "hash-mismatch" | "not-in-journal" | "stat-error";
 export interface NarrowFile {
-    /** Path relative to `hqRoot` (matches journal key + S3 key naming). */
+    /**
+     * COMPANY-RELATIVE path (e.g. `meetings/a.md`) — the canonical namespace
+     * shared by the per-company journal keys, the vault S3 keys, and the
+     * server's explicit-grant paths. NOT hq-root-relative.
+     */
     relPath: string;
     /** Absolute path on disk (convenience for the CLI delete loop). */
     absPath: string;
@@ -57,7 +61,8 @@ export interface BuildNarrowPlanInput {
     /**
      * Coalesced prospective `shared`-mode prefix set (the result of running
      * the caller's explicit grants through `coalescePrefixes`). Prefixes are
-     * hq-root-relative (e.g. `companies/indigo/meetings/`).
+     * COMPANY-RELATIVE (e.g. `meetings/`) — the namespace the grants endpoint
+     * returns and the namespace `relPath` is now computed in.
      */
     prospectivePrefixSet: readonly string[];
     /**

package/dist/lib/local-tree-diff.js

@@ -24,7 +24,7 @@
  * for the destructive side effects (delete, tombstone, PUT sync-config).
  */
 
-!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]="77563dec-63f2-52df-9138-c88bfd1600b9")}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]="20a280f3-0fed-5868-9ad4-fcc562253486")}catch(e){}}();
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { hashFile, isCoveredByAny, } from "@indigoai-us/hq-cloud";
@@ -55,7 +55,16 @@ export function buildNarrowPlan(input) {
     if (!fs.existsSync(walkRoot)) {
         return emptyPlan();
     }
-    walkLocal(walkRoot, hqRoot, (file) => {
+    // Walk with `walkRoot` as the rel-root so each file's `relPath` is
+    // COMPANY-RELATIVE (e.g. `meetings/a.md`) — the same namespace as the
+    // server's explicit-grant paths, the per-company journal keys, and the
+    // hq-cloud sync engine's `RemoteFile.key`. Computing it relative to `hqRoot`
+    // (the old behavior) produced `companies/<slug>/meetings/a.md`, which
+    // matched neither the company-relative grants nor the journal keys — so
+    // every file fell out of `prospectivePrefixSet` AND missed its journal
+    // entry, making narrow flag the entire tree as dirty orphans. See the
+    // namespace contract in hq-cloud `scope-shrink.ts` / `prefix-coalesce.ts`.
+    walkLocal(walkRoot, walkRoot, (file) => {
         if (isCoveredByAny(file.relPath, prospectivePrefixSet)) {
             staying.push(file);
             return;
@@ -100,7 +109,10 @@ function emptyPlan() {
  * Uses `lstat` rather than `stat` so a symlink's size doesn't follow the
  * target chain (matches the share-engine convention).
  */
-function walkLocal(dir, hqRoot, emit) {
+function walkLocal(dir, 
+// Rel-root for `relPath` — the company walk root (`<hqRoot>/companies/<slug>`),
+// so emitted `relPath`s are company-relative. Fixed across recursion.
+relRoot, emit) {
     let entries;
     try {
         entries = fs.readdirSync(dir, { withFileTypes: true });
@@ -115,7 +127,7 @@ function walkLocal(dir, hqRoot, emit) {
     }
     for (const entry of entries) {
         const absPath = path.join(dir, entry.name);
-        const relPath = path.relative(hqRoot, absPath);
+        const relPath = path.relative(relRoot, absPath);
         if (entry.isSymbolicLink()) {
             // Record the link as a file-like entry. Don't descend — narrow is
             // about pruning files that the LOCAL tree has materialized here; a
@@ -132,7 +144,7 @@ function walkLocal(dir, hqRoot, emit) {
             continue;
         }
         if (entry.isDirectory()) {
-            walkLocal(absPath, hqRoot, emit);
+            walkLocal(absPath, relRoot, emit);
             continue;
         }
         if (entry.isFile()) {
@@ -241,4 +253,4 @@ export function formatBytes(n) {
     return `${v.toFixed(2)} ${units[i]}`;
 }
 //# sourceMappingURL=local-tree-diff.js.map
-//# debugId=77563dec-63f2-52df-9138-c88bfd1600b9
+//# debugId=20a280f3-0fed-5868-9ad4-fcc562253486

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.25.1",
+  "version": "5.28.0",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {
@@ -15,7 +15,7 @@
     "clean": "rm -rf dist"
   },
   "dependencies": {
-    "@indigoai-us/hq-cloud": "~5.39.0",
+    "@indigoai-us/hq-cloud": "~5.42.0",
     "@indigoai-us/hq-onboarding": "^0.1.0",
     "@sentry/node": "^10.49.0",
     "chalk": "^5.3.0",

package/src/commands/dm.test.ts

@@ -0,0 +1,88 @@
+import { describe, it, expect } from "vitest";
+import { detectRecipient, parseDuration, buildDmBody } from "./dm.js";
+
+describe("detectRecipient", () => {
+  it("classifies an email", () => {
+    expect(detectRecipient("Stefan@Getindigo.ai")).toEqual({
+      toEmail: "stefan@getindigo.ai",
+    });
+  });
+  it("classifies a personUid", () => {
+    expect(detectRecipient("prs_01ABC")).toEqual({ toPersonUid: "prs_01ABC" });
+  });
+  it("rejects anything else", () => {
+    expect(detectRecipient("not-an-email")).toBeNull();
+    expect(detectRecipient("")).toBeNull();
+  });
+});
+
+describe("parseDuration", () => {
+  it("parses units", () => {
+    expect(parseDuration("30s")).toBe(30_000);
+    expect(parseDuration("10m")).toBe(600_000);
+    expect(parseDuration("2h")).toBe(7_200_000);
+    expect(parseDuration("1d")).toBe(86_400_000);
+    expect(parseDuration(" 5m ")).toBe(300_000);
+  });
+  it("returns null on garbage", () => {
+    expect(parseDuration("soon")).toBeNull();
+    expect(parseDuration("10")).toBeNull();
+    expect(parseDuration("10x")).toBeNull();
+  });
+});
+
+describe("buildDmBody", () => {
+  const now = Date.parse("2026-05-29T00:00:00.000Z");
+
+  it("builds an email DM with body", () => {
+    expect(
+      buildDmBody({ recipient: "a@b.com", message: "  hi  ", now }),
+    ).toEqual({ toEmail: "a@b.com", body: "hi" });
+  });
+
+  it("includes prompt + details when present, omits when blank", () => {
+    expect(
+      buildDmBody({
+        recipient: "prs_x",
+        message: "m",
+        prompt: "do the thing",
+        details: "  ",
+        now,
+      }),
+    ).toEqual({ toPersonUid: "prs_x", body: "m", prompt: "do the thing" });
+  });
+
+  it("resolves --in to a future deliverAt", () => {
+    const out = buildDmBody({ recipient: "a@b.com", message: "m", inDelay: "10m", now });
+    expect(out.deliverAt).toBe("2026-05-29T00:10:00.000Z");
+  });
+
+  it("resolves --at to a normalized ISO deliverAt", () => {
+    const out = buildDmBody({
+      recipient: "a@b.com",
+      message: "m",
+      at: "2026-06-01T12:00:00Z",
+      now,
+    });
+    expect(out.deliverAt).toBe("2026-06-01T12:00:00.000Z");
+  });
+
+  it("rejects an invalid recipient", () => {
+    expect(() => buildDmBody({ recipient: "nope", message: "m", now })).toThrow(/Invalid recipient/);
+  });
+
+  it("requires a body", () => {
+    expect(() => buildDmBody({ recipient: "a@b.com", message: "   ", now })).toThrow(/body is required/);
+  });
+
+  it("rejects both --at and --in", () => {
+    expect(() =>
+      buildDmBody({ recipient: "a@b.com", message: "m", at: "2026-06-01T12:00:00Z", inDelay: "10m", now }),
+    ).toThrow(/only one of --at or --in/);
+  });
+
+  it("rejects an invalid --at and --in", () => {
+    expect(() => buildDmBody({ recipient: "a@b.com", message: "m", at: "nope", now })).toThrow(/Invalid --at/);
+    expect(() => buildDmBody({ recipient: "a@b.com", message: "m", inDelay: "soon", now })).toThrow(/Invalid --in/);
+  });
+});