@indigoai-us/hq-cli 5.314.0 → 5.316.0

package/dist/commands/onboard-bot-membership.d.ts

@@ -0,0 +1,32 @@
+/**
+ * A company created from a local bot's conversation is owned by the person
+ * (the turn runs with the owner's sign-in), so the bot that helped create it
+ * is not in it. The bot passes its own id along (HQ_BOT_AGENT_UID — an id,
+ * never a credential), and `hq onboard create-company` adds that bot as a
+ * member right after, so it can keep helping inside the new company.
+ *
+ * Best effort: a failure here never fails the company that was just created.
+ */
+import { inviteMember } from "./members.js";
+export declare const HQ_BOT_AGENT_UID_ENV = "HQ_BOT_AGENT_UID";
+/** The bot to add to `companyUid`, or null when this is not a bot's turn. */
+export declare function botToAddAfterCreateCompany(env: NodeJS.ProcessEnv, companyUid: string | undefined): {
+    agentUid: string;
+    companyUid: string;
+} | null;
+export interface AddBotDeps {
+    invite: typeof inviteMember;
+    callerUid: (token: string) => Promise<string>;
+}
+/** Add the bot as a member. Returns a one-line outcome for the log; never throws. */
+export declare function addBotToNewCompany(input: {
+    agentUid: string;
+    companyUid: string;
+    token: string;
+}, deps?: AddBotDeps): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+}>;
+//# sourceMappingURL=onboard-bot-membership.d.ts.map

package/dist/commands/onboard-bot-membership.js

@@ -0,0 +1,40 @@
+/**
+ * A company created from a local bot's conversation is owned by the person
+ * (the turn runs with the owner's sign-in), so the bot that helped create it
+ * is not in it. The bot passes its own id along (HQ_BOT_AGENT_UID — an id,
+ * never a credential), and `hq onboard create-company` adds that bot as a
+ * member right after, so it can keep helping inside the new company.
+ *
+ * Best effort: a failure here never fails the company that was just created.
+ */
+import { getCallerPersonUid, inviteMember } from "./members.js";
+export const HQ_BOT_AGENT_UID_ENV = "HQ_BOT_AGENT_UID";
+const AGENT_UID_RE = /^agt_[A-Za-z0-9]{1,64}$/;
+/** The bot to add to `companyUid`, or null when this is not a bot's turn. */
+export function botToAddAfterCreateCompany(env, companyUid) {
+    const agentUid = env[HQ_BOT_AGENT_UID_ENV]?.trim() ?? "";
+    const company = companyUid?.trim() ?? "";
+    if (!AGENT_UID_RE.test(agentUid) || !company.startsWith("cmp_"))
+        return null;
+    return { agentUid, companyUid: company };
+}
+const defaultDeps = { invite: inviteMember, callerUid: getCallerPersonUid };
+/** Add the bot as a member. Returns a one-line outcome for the log; never throws. */
+export async function addBotToNewCompany(input, deps = defaultDeps) {
+    try {
+        const callerUid = await deps.callerUid(input.token);
+        await deps.invite({
+            target: input.agentUid,
+            role: "member",
+            sendEmail: false,
+            companyUid: input.companyUid,
+            callerUid,
+            token: input.token,
+        });
+        return { ok: true };
+    }
+    catch (err) {
+        return { ok: false, reason: err instanceof Error ? err.message : String(err) };
+    }
+}
+//# sourceMappingURL=onboard-bot-membership.js.map

package/dist/commands/onboard-create-identity.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Who a new company is created for, when `hq onboard create-company` is run
+ * without `--email` / `--person-name`.
+ *
+ * The signed-in account already carries both on its ID token. Asking the
+ * person to type their own name again — which is what the setup bot had to do,
+ * because `hq whoami` shows only the email — is a question HQ can answer
+ * itself. Explicit flags still win.
+ */
+export interface CreateCompanyIdentity {
+    email: string;
+    personName: string;
+}
+export type CreateCompanyIdentityResult = {
+    ok: true;
+    identity: CreateCompanyIdentity;
+} | {
+    ok: false;
+    message: string;
+};
+/** Pure: flags first, then the ID token's claims. */
+export declare function resolveCreateCompanyIdentity(flags: {
+    email?: string;
+    personName?: string;
+}, claims: Record<string, unknown>): CreateCompanyIdentityResult;
+//# sourceMappingURL=onboard-create-identity.d.ts.map

package/dist/commands/onboard-create-identity.js

@@ -0,0 +1,23 @@
+function text(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+/** Pure: flags first, then the ID token's claims. */
+export function resolveCreateCompanyIdentity(flags, claims) {
+    const email = text(flags.email) || text(claims.email);
+    const personName = text(flags.personName) ||
+        text(claims.name) ||
+        [text(claims.given_name), text(claims.family_name)].filter(Boolean).join(" ");
+    const missing = [];
+    if (!email)
+        missing.push("--email");
+    if (!personName)
+        missing.push("--person-name");
+    if (missing.length > 0) {
+        return {
+            ok: false,
+            message: `Your HQ sign-in does not say ${missing.length === 2 ? "your email or name" : missing[0] === "--email" ? "your email" : "your name"}. Pass ${missing.join(" and ")}.`,
+        };
+    }
+    return { ok: true, identity: { email, personName } };
+}
+//# sourceMappingURL=onboard-create-identity.js.map

package/dist/commands/onboard-identity-guard.d.ts

@@ -24,7 +24,7 @@
  * the checkpoint adopted a person the caller no longer owns. The resume command
  * uses it to surface a recoverable, actionable error instead of looping.
  */
-import type { OnboardingCheckpoint } from "@indigoai-us/hq-onboarding";
+import type { OnboardingCheckpoint } from "../lib/onboarding/index.js";
 export type OnboardingIdentityCheck = {
     kind: "ok";
 } | {

package/dist/commands/onboard.js

@@ -19,12 +19,15 @@
  * browser-OAuth flow opens automatically.
  */
 import chalk from "chalk";
-import { runOnboardCli, readCheckpoint } from "@indigoai-us/hq-onboarding";
-import { DEFAULT_HQ_ROOT, DEFAULT_VAULT_API_URL, ensureCognitoToken, buildVaultConfig, } from "../utils/cognito-session.js";
+import { runOnboardCli, readCheckpoint } from "../lib/onboarding/index.js";
+import { DEFAULT_HQ_ROOT, DEFAULT_VAULT_API_URL, ensureCognitoIdToken, ensureCognitoToken, buildVaultConfig, } from "../utils/cognito-session.js";
 import { createDefaultVaultClient } from "./cloud-provision.js";
 import { detectOnboardingIdentityMismatch } from "./onboard-identity-guard.js";
 import { planOnboardJoin } from "./onboard-join.js";
 import { buildCreateCompanyWarning } from "./onboard-warning.js";
+import { resolveCreateCompanyIdentity } from "./onboard-create-identity.js";
+import { peekIdToken } from "../utils/id-token.js";
+import { addBotToNewCompany, botToAddAfterCreateCompany } from "./onboard-bot-membership.js";
 // ---------------------------------------------------------------------------
 // Command registration
 // ---------------------------------------------------------------------------
@@ -39,11 +42,18 @@ export function registerOnboardCommand(program) {
         "a same-named company makes a separate one you'd be alone in.")
         .requiredOption("--slug <slug>", "Company slug (used as bucket name suffix)")
         .requiredOption("--name <name>", "Company display name")
-        .requiredOption("--email <email>", "Your email (must match Cognito sign-in)")
-        .requiredOption("--person-name <name>", "Your display name")
+        .option("--email <email>", "Your email (default: your HQ sign-in's email; must match it)")
+        .option("--person-name <name>", "Your display name (default: the name on your HQ sign-in)")
         .option("--hq-root <path>", `Local HQ tree root (default: ${DEFAULT_HQ_ROOT})`, DEFAULT_HQ_ROOT)
-        .action(async (options) => {
+        .action(async (flags) => {
         try {
+            const idToken = await ensureCognitoIdToken();
+            const resolved = resolveCreateCompanyIdentity(flags, peekIdToken(idToken));
+            if (!resolved.ok) {
+                console.error(chalk.red(`\n✗ ${resolved.message}`));
+                process.exit(1);
+            }
+            const options = { ...flags, ...resolved.identity };
             console.log(chalk.bold(`\nHQ Onboard — Create Company`));
             console.log(`  Company:  ${options.name} (${options.slug})`);
             console.log(`  Person:   ${options.personName} <${options.email}>`);
@@ -63,6 +73,15 @@ export function registerOnboardCommand(program) {
                 console.error(chalk.red(`\n✗ Onboarding failed: ${result.error}`));
                 process.exit(1);
             }
+            // Created from a local bot's conversation: keep that bot in the company.
+            const bot = botToAddAfterCreateCompany(process.env, result.result?.companyUid);
+            if (bot) {
+                const added = await addBotToNewCompany({ ...bot, token: accessToken });
+                if (added.ok)
+                    console.log(chalk.green(`✓ Added your bot (${bot.agentUid}) to ${options.name} as a member`));
+                else
+                    console.log(chalk.yellow(`! Could not add your bot (${bot.agentUid}) to ${options.name}: ${added.reason}. Invite it later with: hq members invite ${bot.agentUid} --company ${options.slug} --role member`));
+            }
         }
         catch (err) {
             console.error(chalk.red("\n✗ Error:"), err instanceof Error ? err.message : String(err));

package/dist/commands/outpost-pruner.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function registerOutpostPrunerCommand(lanes: Command): void;
+//# sourceMappingURL=outpost-pruner.d.ts.map

package/dist/commands/outpost-pruner.js

@@ -0,0 +1,125 @@
+import { spawnSync } from "node:child_process";
+import * as os from "node:os";
+import * as path from "node:path";
+import { outpostWorktreePrunerEnabled, OUTPOST_WORKTREE_PRUNER_FLAG } from "../lib/lanes/outpost-worktree-pruner-flag.js";
+import { OUTPOST_WORKTREE_PRUNER_DEFAULT_MIN_AGE_DAYS, runOutpostWorktreePruner, } from "../lib/lanes/outpost-worktree-pruner.js";
+import { defaultOutpostPrunerSystemdDir, installOutpostPrunerTimers, uninstallOutpostPrunerTimers, } from "../lib/lanes/outpost-pruner-install.js";
+import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
+function errorType(error) {
+    return error instanceof Error ? error.name : "UnknownError";
+}
+function printJson(value) {
+    process.stdout.write(`${JSON.stringify(value)}\n`);
+}
+function printErrorJson(event, error, fields = {}) {
+    printJson({ event, ...fields, error: errorType(error) });
+}
+function runSystemctl(binary, args) {
+    const result = spawnSync(binary, args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+    return {
+        status: result.status ?? 1,
+        stdout: result.stdout ?? "",
+        stderr: result.stderr ?? "",
+    };
+}
+function systemdRoot(option) {
+    return path.resolve(option ?? defaultOutpostPrunerSystemdDir(os.homedir()));
+}
+function skippedResult(trigger, minAgeDays, reason) {
+    return {
+        event: "outpost.worktree_pruner.run",
+        trigger,
+        dry_run: false,
+        feature_enabled: false,
+        skipped: reason,
+        flag: OUTPOST_WORKTREE_PRUNER_FLAG,
+        min_age_days: minAgeDays,
+        candidates: [],
+        removed: [],
+        kept: [],
+        bytes_freed: 0,
+        bytes_freed_basis: "statfs_available_byte_delta",
+        package_store: { attempted: false, reason: "not_run" },
+    };
+}
+export function registerOutpostPrunerCommand(lanes) {
+    const pruner = lanes
+        .command("outpost-pruner")
+        .description("Inspect, install, and run safe outpost worktree pruning");
+    pruner
+        .command("run")
+        .description("Run the guarded outpost worktree and user-cache cleanup")
+        .option("--trigger <kind>", "pressure | daily | manual", "manual")
+        .option("--min-age-days <days>", "Minimum age before cleanup (1–365 days)", (value) => Number(value), OUTPOST_WORKTREE_PRUNER_DEFAULT_MIN_AGE_DAYS)
+        .option("--dry-run", "List eligible worktrees without deleting files")
+        .action(async (options) => {
+        const trigger = options.trigger ?? "manual";
+        const minAgeDays = options.minAgeDays ?? OUTPOST_WORKTREE_PRUNER_DEFAULT_MIN_AGE_DAYS;
+        try {
+            if (!["pressure", "daily", "manual"].includes(trigger)) {
+                throw new TypeError("invalid trigger");
+            }
+            const featureEnabled = options.dryRun ? false : await outpostWorktreePrunerEnabled();
+            if (!options.dryRun && !featureEnabled) {
+                printJson(skippedResult(trigger, minAgeDays, "feature_flag_off"));
+                return;
+            }
+            const result = runOutpostWorktreePruner({
+                hqRoot: resolveLanesHqRoot(),
+                trigger,
+                dryRun: Boolean(options.dryRun),
+                featureEnabled,
+                minAgeDays,
+            });
+            printJson({ ...result, flag: OUTPOST_WORKTREE_PRUNER_FLAG });
+        }
+        catch (error) {
+            printErrorJson("outpost.worktree_pruner.run", error, {
+                trigger,
+                dry_run: Boolean(options.dryRun),
+            });
+            process.exitCode = 1;
+        }
+    });
+    pruner
+        .command("install")
+        .description("Write the pressure and daily systemd user timers")
+        .option("--systemd-root <path>", "Systemd user unit directory")
+        .option("--enable", "Enable both timers after writing the units")
+        .action((options) => {
+        try {
+            const result = installOutpostPrunerTimers({
+                systemdRoot: systemdRoot(options.systemdRoot),
+                hqRoot: resolveLanesHqRoot(),
+                home: os.homedir(),
+                enable: Boolean(options.enable),
+                runCommand: options.enable ? runSystemctl : undefined,
+            });
+            printJson(result);
+        }
+        catch (error) {
+            printErrorJson("outpost.worktree_pruner.install", error);
+            process.exitCode = 1;
+        }
+    });
+    pruner
+        .command("uninstall")
+        .description("Disable and remove the pressure and daily systemd user timers")
+        .option("--systemd-root <path>", "Systemd user unit directory")
+        .option("--disable", "Disable both timers before removing their units")
+        .action((options) => {
+        try {
+            const result = uninstallOutpostPrunerTimers({
+                systemdRoot: systemdRoot(options.systemdRoot),
+                disable: Boolean(options.disable),
+                runCommand: options.disable ? runSystemctl : undefined,
+            });
+            printJson(result);
+        }
+        catch (error) {
+            printErrorJson("outpost.worktree_pruner.uninstall", error);
+            process.exitCode = 1;
+        }
+    });
+}
+//# sourceMappingURL=outpost-pruner.js.map

package/dist/commands/pack-install.js

@@ -1421,7 +1421,9 @@ export async function makeInstallSecretResolver(secretNames, company) {
                 return () => null;
             [scopeUid] = scopes;
         }
-        const authorized = await loadRevealedSecrets(token, scopeUid, names);
+        const authorized = await loadRevealedSecrets(token, scopeUid, names, undefined, {
+            allowOfflineFallback: false,
+        });
         return (name) => authorized.get(name) ?? null;
     }
     catch {

package/dist/commands/packs.js

@@ -23,11 +23,21 @@ import { spawnSync } from 'child_process';
 import chalk from 'chalk';
 import semverSatisfies from 'semver/functions/satisfies.js';
 import { findHqRoot } from '../utils/manifest.js';
+import { resolveHqRoot as resolveDetectedHqRoot } from './doctor.js';
 import { classify, resolveLatest, resolveLatestMarketplace, runScanPackages, installPack, } from './pack-install.js';
 import { contributionLinks, linkStatus, listInstalledPacks, findDependentPacks, readPackManifest, unwirePack, unwirePackMcp, readHqVersion, readRecommendedPackages, packagesDir, } from '../utils/pack-contributions.js';
 function resolveRoot(opts) {
     return opts.hqRoot ? path.resolve(opts.hqRoot) : findHqRoot();
 }
+function resolvePackListRoot(opts) {
+    if (opts.hqRoot)
+        return path.resolve(opts.hqRoot);
+    const hqRoot = resolveDetectedHqRoot(process.cwd());
+    if (!hqRoot) {
+        throw new Error('hq packages: not inside an HQ tree. Run this command from inside your HQ root or pass --hq-root <path>.');
+    }
+    return hqRoot;
+}
 /** JSON when --json or when piped (non-TTY); human-readable on a terminal. */
 function wantsJson(opts) {
     return opts.json === true || !process.stdout.isTTY;
@@ -377,7 +387,7 @@ export function registerPacksListCommand(parent) {
         .option('--eval-conditionals', 'Evaluate catalog conditional predicates (runs bash)')
         .action(async (opts) => {
         try {
-            const view = await buildListView(resolveRoot(opts), !!opts.checkUpdates, !!opts.evalConditionals, !!opts.refresh);
+            const view = await buildListView(resolvePackListRoot(opts), !!opts.checkUpdates, !!opts.evalConditionals, !!opts.refresh);
             if (wantsJson(opts))
                 emitJson(view);
             else

package/dist/commands/people.d.ts

@@ -17,9 +17,13 @@ import { resolveNameToEmail, type PersonRecord } from "../utils/people.js";
 export type FetchPeopleRoster = (hqRoot: string, companySlug: string) => Promise<PersonRecord[]>;
 interface PeopleCommandDeps {
     fetchRoster?: FetchPeopleRoster;
+    /** Test seam for the shared active-membership ambiguity resolver. */
+    resolveMissingManifestMemberships?: () => Promise<void>;
+    companySelectionGuidanceEnabled?: () => boolean;
 }
 interface PeopleLookupOpts {
     localOnly?: boolean;
+    membershipOnly?: boolean;
     json?: boolean;
 }
 export declare function activeMemberToPersonRecord(m: ActiveMember): PersonRecord | null;

package/dist/commands/people.js

@@ -19,6 +19,7 @@ import { findHqRoot } from "../utils/manifest.js";
 import { manifestPath } from "./cloud-provision.js";
 import { ensureCognitoToken } from "../utils/cognito-session.js";
 import { getCompanyUid } from "../utils/vault-api.js";
+import { companyErrorsSdkWarningEnabled } from "../lib/company-errors-sdk-warning-flag.js";
 import { listActiveMembers } from "./members.js";
 import { assertSafeCompanySlug, listCompanyPeople, searchPeople, resolveNameToEmail, companyPeopleDir, } from "../utils/people.js";
 function slugify(value) {
@@ -41,6 +42,8 @@ export function activeMemberToPersonRecord(m) {
         slug,
         name,
         email,
+        personUid: m.personUid,
+        companyUid: m.companyUid,
         role: m.role || undefined,
         type: "internal",
         source: `hq-pro membership: /membership/company/${m.companyUid}`,
@@ -106,6 +109,29 @@ export function resolveCompanySlug(hqRoot, explicit) {
     throw new Error("Multiple companies found — re-run with --company <slug> to pick one:\n" +
         slugs.map((s) => `  --company ${s}`).join("\n"));
 }
+async function resolvePeopleCompanySlug(hqRoot, explicit, localOnly, deps) {
+    try {
+        return resolveCompanySlug(hqRoot, explicit);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const ambiguous = message.includes("companies/manifest.yaml not found") ||
+            message.startsWith("Multiple companies found");
+        const enabled = (deps.companySelectionGuidanceEnabled ?? companyErrorsSdkWarningEnabled)();
+        if (!explicit && !localOnly && enabled && ambiguous) {
+            const resolveMemberships = deps.resolveMissingManifestMemberships ??
+                (async () => {
+                    const token = await ensureCognitoToken();
+                    await getCompanyUid(token, undefined);
+                });
+            // The shared resolver throws members-style guidance for multiple active
+            // companies. A single membership cannot provide a local slug without a
+            // manifest, so preserve the existing missing-manifest error in that case.
+            await resolveMemberships();
+        }
+        throw error;
+    }
+}
 /** Resolve the HQ root: explicit override (tests) → cwd walk-up. */
 function resolveHqRoot(opts) {
     return opts.hqRoot ?? findHqRoot();
@@ -147,6 +173,13 @@ async function tryFetchRoster(fetchRoster, hqRoot, slug) {
     }
 }
 export async function resolvePersonWithRosterFallback(input) {
+    if (input.opts?.membershipOnly) {
+        if (input.opts.localOnly)
+            throw new Error('--membership-only cannot be combined with --local-only');
+        // No local fallback: callers need authoritative IDs and must see transport errors.
+        const roster = await (input.fetchRoster ?? fetchMembershipRoster)(input.hqRoot, input.slug);
+        return resolveNameToEmail(roster, input.name);
+    }
     const localPeople = listCompanyPeople(input.hqRoot, input.slug);
     const local = resolveNameToEmail(localPeople, input.name);
     if (local.status !== "not_found" || input.opts?.localOnly)
@@ -183,7 +216,7 @@ export function registerPeopleCommand(program, deps = {}) {
         try {
             const scope = people.opts();
             const hqRoot = resolveHqRoot(scope);
-            const slug = resolveCompanySlug(hqRoot, scope.company);
+            const slug = await resolvePeopleCompanySlug(hqRoot, scope.company, opts.localOnly, deps);
             let records = listCompanyPeople(hqRoot, slug);
             if (!opts.localOnly) {
                 const roster = await tryFetchRoster(deps.fetchRoster ?? fetchMembershipRoster, hqRoot, slug);
@@ -214,7 +247,7 @@ export function registerPeopleCommand(program, deps = {}) {
         try {
             const scope = people.opts();
             const hqRoot = resolveHqRoot(scope);
-            const slug = resolveCompanySlug(hqRoot, scope.company);
+            const slug = await resolvePeopleCompanySlug(hqRoot, scope.company, opts.localOnly, deps);
             const matches = await searchPeopleWithRosterFallback({
                 hqRoot,
                 slug,
@@ -239,13 +272,14 @@ export function registerPeopleCommand(program, deps = {}) {
     people
         .command("resolve <name>")
         .description("Resolve a person name to their email address")
+        .option("--membership-only", "Resolve from authoritative company membership, ignoring local records")
         .option("--json", "Output JSON instead of plain text")
         .option("--local-only", "Skip network fallback; resolve only from the local people roster")
         .action(async (name, opts) => {
         try {
             const scope = people.opts();
             const hqRoot = resolveHqRoot(scope);
-            const slug = resolveCompanySlug(hqRoot, scope.company);
+            const slug = await resolvePeopleCompanySlug(hqRoot, scope.company, opts.localOnly, deps);
             const result = await resolvePersonWithRosterFallback({
                 hqRoot,
                 slug,

package/dist/commands/personal-connector-settings-flag.d.ts

@@ -0,0 +1,4 @@
+export declare const CLI_PERSONAL_CONNECTOR_SETTINGS_FLAG = "cli.personal-connector-settings";
+/** Keep company-shared connector storage unchanged until the flag is explicitly enabled. */
+export declare function personalConnectorSettingsEnabled(): boolean;
+//# sourceMappingURL=personal-connector-settings-flag.d.ts.map

package/dist/commands/personal-connector-settings-flag.js

@@ -0,0 +1,7 @@
+import { resolveProcessFlagGate } from "../lib/flag-registry.js";
+export const CLI_PERSONAL_CONNECTOR_SETTINGS_FLAG = "cli.personal-connector-settings";
+/** Keep company-shared connector storage unchanged until the flag is explicitly enabled. */
+export function personalConnectorSettingsEnabled() {
+    return resolveProcessFlagGate(CLI_PERSONAL_CONNECTOR_SETTINGS_FLAG, { fallback: false }, () => false);
+}
+//# sourceMappingURL=personal-connector-settings-flag.js.map

package/dist/commands/personal-targeted-push-flag.d.ts

@@ -0,0 +1,4 @@
+export declare const CLI_PERSONAL_TARGETED_PUSH_PATHS_FLAG = "cli.personal-targeted-push-paths";
+/** The established full-scope behavior remains in force until an explicit hq-flags enablement. */
+export declare function personalTargetedPushPathsEnabled(): boolean;
+//# sourceMappingURL=personal-targeted-push-flag.d.ts.map

package/dist/commands/personal-targeted-push-flag.js

@@ -0,0 +1,7 @@
+import { resolveProcessFlagGate } from "../lib/flag-registry.js";
+export const CLI_PERSONAL_TARGETED_PUSH_PATHS_FLAG = "cli.personal-targeted-push-paths";
+/** The established full-scope behavior remains in force until an explicit hq-flags enablement. */
+export function personalTargetedPushPathsEnabled() {
+    return resolveProcessFlagGate(CLI_PERSONAL_TARGETED_PUSH_PATHS_FLAG, { fallback: false }, () => false);
+}
+//# sourceMappingURL=personal-targeted-push-flag.js.map

package/dist/commands/personal-targeted-push-paths.d.ts

@@ -0,0 +1,3 @@
+/** Resolve explicit --personal paths against the same roots as a full personal push. */
+export declare function resolveExplicitPersonalPushPaths(hqRoot: string, requestedPaths: readonly string[], cwd?: string): string[];
+//# sourceMappingURL=personal-targeted-push-paths.d.ts.map

package/dist/commands/personal-targeted-push-paths.js

@@ -0,0 +1,67 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { computePersonalVaultPaths, matchPersonalVaultExclusion, } from "@indigoai-us/hq-cloud";
+function isWithin(parent, candidate) {
+    const relative = path.relative(parent, candidate);
+    return relative === "" ||
+        (relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative));
+}
+function rejectPath(input, reason) {
+    throw new Error(`--personal cannot push path "${input}": ${reason}`);
+}
+/** Resolve explicit --personal paths against the same roots as a full personal push. */
+export function resolveExplicitPersonalPushPaths(hqRoot, requestedPaths, cwd = process.cwd()) {
+    let realRoot;
+    try {
+        realRoot = fs.realpathSync.native(hqRoot);
+    }
+    catch (error) {
+        const code = error instanceof Error && "code" in error ? String(error.code) : "unavailable";
+        throw new Error(`--personal cannot resolve HQ root "${hqRoot}" (${code})`);
+    }
+    const allowedRoots = computePersonalVaultPaths(realRoot)
+        .map((allowedPath) => {
+        try {
+            return fs.realpathSync.native(allowedPath);
+        }
+        catch (error) {
+            const code = error instanceof Error && "code" in error ? String(error.code) : "unavailable";
+            throw new Error(`--personal personal-vault scope changed at "${allowedPath}" (${code})`);
+        }
+    })
+        .filter((allowedPath) => isWithin(realRoot, allowedPath));
+    const resolved = [];
+    for (const input of requestedPaths) {
+        const normalizedInput = path.resolve(cwd, input);
+        let realPath;
+        try {
+            realPath = fs.realpathSync.native(normalizedInput);
+        }
+        catch (error) {
+            const code = error instanceof Error && "code" in error ? String(error.code) : "unavailable";
+            rejectPath(input, `path cannot be resolved (${code})`);
+        }
+        if (!isWithin(realRoot, realPath)) {
+            rejectPath(input, "resolved path escapes the HQ root");
+        }
+        let isDirectory;
+        try {
+            isDirectory = fs.statSync(realPath).isDirectory();
+        }
+        catch (error) {
+            const code = error instanceof Error && "code" in error ? String(error.code) : "unavailable";
+            rejectPath(input, `path cannot be inspected (${code})`);
+        }
+        const relativePath = path.relative(realRoot, realPath).split(path.sep).join("/");
+        const exclusion = matchPersonalVaultExclusion(relativePath, isDirectory);
+        if (exclusion) {
+            rejectPath(input, `excluded by personal-vault rule ${exclusion.id}`);
+        }
+        if (!allowedRoots.some((allowedRoot) => isWithin(allowedRoot, realPath))) {
+            rejectPath(input, "resolved path is outside the personal-vault paths");
+        }
+        resolved.push(realPath);
+    }
+    return resolved;
+}
+//# sourceMappingURL=personal-targeted-push-paths.js.map

package/dist/commands/publish.d.ts

@@ -130,7 +130,7 @@ export declare function unwrapListing(body: Record<string, unknown>): ListingRes
  * locally-resolved author handle — falling back gracefully when the server
  * omits either field.
  */
-export declare function buildListingNotice(status: number, body: Record<string, unknown>, packName: string, packVersion: string): string;
+export declare function buildListingNotice(status: number, body: Record<string, unknown>, packName: string, packVersion: string, selectedHandle?: string): string;
 /**
  * The exact JSON body the deployed `POST /v1/listings` handler expects. Field
  * shapes mirror the server contract: `type` ∈ {skill,worker}, `contributes` is
@@ -151,6 +151,12 @@ export interface ListingRequest {
      * caller is staff (`@getindigo.ai`) and the server has the capability enabled.
      */
     publishAsHandle?: string;
+    /**
+     * OPTIONAL explicit choice among the caller's OWN claimed creator handles
+     * (`hq publish --handle <h>`). The server refuses a handle the caller does
+     * not own (403 CREATOR_HANDLE_NOT_OWNED) instead of falling back.
+     */
+    ownedCreatorHandle?: string;
     /** Base64-encoded gzip pack tarball (pack.tar.gz bytes). */
     tarball: string;
 }
@@ -196,6 +202,7 @@ export interface PublishResult {
  */
 export declare function runPublish(targetPath: string, deps: PublishDeps, opts?: {
     publishAsHandle?: string;
+    creatorHandle?: string;
 }): Promise<PublishResult>;
 export declare function registerPublishCommand(program: Command): void;
 //# sourceMappingURL=publish.d.ts.map