@indigoai-us/hq-cli 5.345.103 → 5.345.105

package/dist/lib/bot/pack-link.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Recognize a content pack in what a person wrote to the setup bot (US-004,
+ * contract section 4), so the bot's skill text (assets/bot-workers/setup/
+ * skills/add-a-pack.md) and the code agree on what counts as a pack reference:
+ *
+ *   https://www.hqforwork.com/packs/{slug}      a pack page
+ *   hqforwork.com/packs/{slug}                   the same without scheme or www
+ *   hq-pack-{slug}                               the package name
+ *   {slug}                                       a bare slug the catalog knows
+ *   "add the {Display Name}"                     a display name from the catalog
+ *   ./packs/hq-pack-{slug}, ~/Downloads/hq-pack-{slug}   a local pack folder
+ *
+ * The catalog is the curated list `hq packages list` prints (core.yaml
+ * `recommended_packages`, see readRecommendedPackages). A slug or display name
+ * that matches none of its entries is `unknown`, with the three closest
+ * catalog names to offer. Nothing here knows any particular pack.
+ */
+import type { CatalogEntry } from "../../utils/hq-core-yaml.js";
+/** The package-name prefix every HQ content pack carries. */
+export declare const HQ_PACK_PREFIX = "hq-pack-";
+/** Same shape the deep link and the pack page accept. */
+export declare const PACK_SLUG_PATTERN: RegExp;
+export interface PackCatalogEntry {
+    /** `design-styles` */
+    slug: string;
+    /** `Design Styles` */
+    displayName: string;
+    description?: string;
+    /** The install source as the curated catalog spells it, when it has one. */
+    source?: string;
+}
+export type PackReferenceKind = "url" | "package-name" | "slug" | "display-name" | "path";
+export type PackReference = {
+    kind: PackReferenceKind;
+    slug: string;
+    displayName: string;
+    /** What to hand `hq packages install`: the slug, or the local path when the message carried one. */
+    installSource: string;
+    entry?: PackCatalogEntry;
+} | {
+    kind: "unknown";
+    /** The slug or name the person seems to mean. */
+    query: string;
+    /** Up to three catalog display names closest to the query. */
+    suggestions: string[];
+};
+/** `github:indigoai-us/hq-packages#packages/hq-pack-design-styles` -> `design-styles`. */
+export declare function packSlugFromSource(source: string): string | null;
+/** `design-styles` -> `Design Styles`. */
+export declare function displayNameFromSlug(slug: string): string;
+/** The curated catalog (`recommended_packages`) as pack entries; a repeated slug keeps its first entry. */
+export declare function packCatalogFromRecommended(entries: readonly CatalogEntry[]): PackCatalogEntry[];
+/** The `n` catalog display names closest to `query` (slug or name), best first. */
+export declare function closestPackNames(query: string, catalog: readonly PackCatalogEntry[], n?: number): string[];
+/**
+ * The pack a message refers to, or null when it mentions no pack. A URL,
+ * package name or path always resolves (the slug is explicit); a bare slug or
+ * a display name must be in the catalog, otherwise the result is `unknown`
+ * with the closest catalog names.
+ */
+export declare function recognizePackReference(message: string, catalog: readonly PackCatalogEntry[]): PackReference | null;
+/** The suggestions the confirmation message carries: `["Add the {displayName}","Not now"]`. */
+export declare function packConfirmSuggestions(displayName: string): [string, string];
+/** The exact command the setup bot runs after "Add the ...". */
+export declare function packInstallCommand(installSource: string): string;
+//# sourceMappingURL=pack-link.d.ts.map

package/dist/lib/bot/pack-link.js

@@ -0,0 +1,153 @@
+/**
+ * Recognize a content pack in what a person wrote to the setup bot (US-004,
+ * contract section 4), so the bot's skill text (assets/bot-workers/setup/
+ * skills/add-a-pack.md) and the code agree on what counts as a pack reference:
+ *
+ *   https://www.hqforwork.com/packs/{slug}      a pack page
+ *   hqforwork.com/packs/{slug}                   the same without scheme or www
+ *   hq-pack-{slug}                               the package name
+ *   {slug}                                       a bare slug the catalog knows
+ *   "add the {Display Name}"                     a display name from the catalog
+ *   ./packs/hq-pack-{slug}, ~/Downloads/hq-pack-{slug}   a local pack folder
+ *
+ * The catalog is the curated list `hq packages list` prints (core.yaml
+ * `recommended_packages`, see readRecommendedPackages). A slug or display name
+ * that matches none of its entries is `unknown`, with the three closest
+ * catalog names to offer. Nothing here knows any particular pack.
+ */
+/** The package-name prefix every HQ content pack carries. */
+export const HQ_PACK_PREFIX = "hq-pack-";
+/** Same shape the deep link and the pack page accept. */
+export const PACK_SLUG_PATTERN = /^[a-z0-9-]{2,64}$/;
+/** `github:indigoai-us/hq-packages#packages/hq-pack-design-styles` -> `design-styles`. */
+export function packSlugFromSource(source) {
+    const trimmed = source.trim().replace(/[/\\]+$/, "");
+    const last = trimmed.split(/[/\\#:]/).pop() ?? "";
+    const bare = last.replace(/@.*$/, "").replace(/\.(?:tgz|tar\.gz|zip)$/i, "");
+    const slug = bare.startsWith(HQ_PACK_PREFIX) ? bare.slice(HQ_PACK_PREFIX.length) : bare;
+    return PACK_SLUG_PATTERN.test(slug) ? slug : null;
+}
+/** `design-styles` -> `Design Styles`. */
+export function displayNameFromSlug(slug) {
+    return slug
+        .split("-")
+        .filter(Boolean)
+        .map((w) => w[0].toUpperCase() + w.slice(1))
+        .join(" ");
+}
+/** The curated catalog (`recommended_packages`) as pack entries; a repeated slug keeps its first entry. */
+export function packCatalogFromRecommended(entries) {
+    const out = new Map();
+    for (const entry of entries) {
+        const slug = packSlugFromSource(entry.source);
+        if (!slug || out.has(slug))
+            continue;
+        const named = entry.name?.trim();
+        out.set(slug, {
+            slug,
+            displayName: named || displayNameFromSlug(slug),
+            ...(entry.description ? { description: entry.description } : {}),
+            source: entry.source,
+        });
+    }
+    return [...out.values()];
+}
+const URL_PATTERN = /(?:https?:\/\/)?(?:www\.)?hqforwork\.com\/packs\/([a-z0-9-]{2,64})(?![a-z0-9-])/i;
+const PACKAGE_NAME_PATTERN = /(?<![a-z0-9-])hq-pack-([a-z0-9-]{2,64})(?![a-z0-9-])/i;
+/** A path token whose last `hq-pack-*` segment names the pack. */
+const PATH_PATTERN = /(?:^|\s)((?:~|\.{1,2})?\/[^\s"'`]*hq-pack-([a-z0-9-]{2,64})(?:\/[^\s"'`]*)?)/i;
+/** Something that looks like a slug the person typed on purpose. */
+const SLUG_TOKEN = /(?<![a-z0-9-])([a-z0-9]+(?:-[a-z0-9]+)+)(?![a-z0-9-])/gi;
+const PACK_TALK = /\bpacks?\b|\binstall\b|\badd\b/i;
+function normalize(s) {
+    return s.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+}
+function wordPhrase(message, phrase) {
+    const words = normalize(phrase).split(" ").filter(Boolean);
+    if (words.length === 0)
+        return false;
+    const re = new RegExp(`(?<![a-z0-9])${words.map((w) => w.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("[\\s-]+")}(?![a-z0-9])`, "i");
+    return re.test(message);
+}
+function found(kind, slug, catalog, installSource = slug) {
+    const entry = catalog.find((e) => e.slug === slug);
+    return { kind, slug, displayName: entry?.displayName ?? displayNameFromSlug(slug), installSource, ...(entry ? { entry } : {}) };
+}
+function levenshtein(a, b) {
+    const prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+    for (let i = 1; i <= a.length; i++) {
+        let diag = prev[0];
+        prev[0] = i;
+        for (let j = 1; j <= b.length; j++) {
+            const tmp = prev[j];
+            prev[j] = Math.min(prev[j] + 1, prev[j - 1] + 1, diag + (a[i - 1] === b[j - 1] ? 0 : 1));
+            diag = tmp;
+        }
+    }
+    return prev[b.length];
+}
+/** The `n` catalog display names closest to `query` (slug or name), best first. */
+export function closestPackNames(query, catalog, n = 3) {
+    const q = normalize(query);
+    const scored = catalog.map((entry) => {
+        const candidates = [normalize(entry.slug), normalize(entry.displayName)];
+        const score = Math.min(...candidates.map((c) => levenshtein(q, c) / Math.max(q.length, c.length, 1)));
+        return { name: entry.displayName, score };
+    });
+    scored.sort((a, b) => a.score - b.score || a.name.localeCompare(b.name));
+    return scored.slice(0, n).map((s) => s.name);
+}
+/**
+ * The pack a message refers to, or null when it mentions no pack. A URL,
+ * package name or path always resolves (the slug is explicit); a bare slug or
+ * a display name must be in the catalog, otherwise the result is `unknown`
+ * with the closest catalog names.
+ */
+export function recognizePackReference(message, catalog) {
+    const text = message.trim();
+    if (!text)
+        return null;
+    const url = URL_PATTERN.exec(text);
+    if (url)
+        return found("url", url[1].toLowerCase(), catalog);
+    const localPath = PATH_PATTERN.exec(text);
+    if (localPath)
+        return found("path", localPath[2].toLowerCase(), catalog, localPath[1]);
+    const pkg = PACKAGE_NAME_PATTERN.exec(text);
+    if (pkg)
+        return found("package-name", pkg[1].toLowerCase(), catalog);
+    // A slug typed as such (hyphens and all; a one-word slug is just its name),
+    // then a display name in plain words; the longest wins when one contains another.
+    const bySlug = [...catalog]
+        .filter((e) => e.slug.includes("-"))
+        .sort((a, b) => b.slug.length - a.slug.length)
+        .find((e) => new RegExp(`(?<![a-z0-9-])${e.slug}(?![a-z0-9-])`, "i").test(text));
+    if (bySlug)
+        return found("slug", bySlug.slug, catalog);
+    const byName = [...catalog].sort((a, b) => b.displayName.length - a.displayName.length).find((e) => wordPhrase(text, e.displayName));
+    if (byName)
+        return found("display-name", byName.slug, catalog);
+    // A slug-shaped token the catalog does not know, in a message about packs.
+    if (PACK_TALK.test(text)) {
+        const tokens = [...text.matchAll(SLUG_TOKEN)].map((m) => m[1].toLowerCase()).filter((t) => PACK_SLUG_PATTERN.test(t));
+        const query = tokens[0] ?? quotedName(text);
+        if (query)
+            return { kind: "unknown", query, suggestions: closestPackNames(query, catalog) };
+    }
+    return null;
+}
+/** `add the "Growth Kit" pack` -> `Growth Kit`. */
+function quotedName(text) {
+    const m = /["'“‘]([^"'”’]{2,64})["'”’]/.exec(text);
+    return m ? m[1].trim() : null;
+}
+/** The suggestions the confirmation message carries: `["Add the {displayName}","Not now"]`. */
+export function packConfirmSuggestions(displayName) {
+    return [`Add the ${displayName}`, "Not now"];
+}
+/** The exact command the setup bot runs after "Add the ...". */
+export function packInstallCommand(installSource) {
+    const arg = /[\s"']/.test(installSource) ? JSON.stringify(installSource) : installSource;
+    return `hq packages install ${arg} --start-bot`;
+}
+//# sourceMappingURL=pack-link.js.map

package/dist/lib/bot/pack-setup-driver.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The instant first question of a pack bot. On first start the runtime sends
+ * the pack's first `setup:` question from code, with the company's name to
+ * confirm when the question asks for it, so the person is not left waiting on
+ * a model turn that only works out which company they are in. Every answer
+ * after that goes to the model, which runs the setup as an interview.
+ *
+ * State lives in the bot folder (`pack-setup-state.json`). The next model turn
+ * in the owner DM gets a note that the first question already went out.
+ */
+import type { PackSetup, PackSetupQuestion } from "../../types.js";
+export declare const PACK_SETUP_STATE_FILE = "pack-setup-state.json";
+export interface PackSetupState {
+    v: 1;
+    pack: string;
+    /** Company slug the pack is set up in. */
+    firm: string;
+    /** The question id the app asked from code. */
+    askedFirst: string;
+    /** The next model turn in the owner DM gets a note that the first question went out. */
+    modelNotePending: boolean;
+    updatedAt: string;
+}
+export declare function statePath(botDir: string): string;
+export declare function readPackSetupState(botDir: string): PackSetupState | null;
+export declare function writePackSetupState(botDir: string, state: PackSetupState): void;
+/** The company's display name from companies/manifest.yaml, else its slug. */
+export declare function companyDisplayName(hqRoot: string, slug: string): string;
+/** The value a question proposes from `default_from`, if any. */
+export declare function questionDefault(q: PackSetupQuestion, ctx: {
+    firmName: string;
+}): string | null;
+/** One question as a message: the text and its buttons, proposing the default when there is one. */
+export declare function questionMessage(q: PackSetupQuestion, defaultValue: string | null): string;
+/** The note on the first model turn after the app asked the first question. */
+export declare function firstQuestionNote(setup: PackSetup, state: PackSetupState, firmName: string): string;
+//# sourceMappingURL=pack-setup-driver.d.ts.map

package/dist/lib/bot/pack-setup-driver.js

@@ -0,0 +1,83 @@
+/**
+ * The instant first question of a pack bot. On first start the runtime sends
+ * the pack's first `setup:` question from code, with the company's name to
+ * confirm when the question asks for it, so the person is not left waiting on
+ * a model turn that only works out which company they are in. Every answer
+ * after that goes to the model, which runs the setup as an interview.
+ *
+ * State lives in the bot folder (`pack-setup-state.json`). The next model turn
+ * in the owner DM gets a note that the first question already went out.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as yaml from "js-yaml";
+import { questionSuggestions, suggestionsEnvelope } from "../packages/setup-prompt.js";
+export const PACK_SETUP_STATE_FILE = "pack-setup-state.json";
+export function statePath(botDir) {
+    return path.join(botDir, PACK_SETUP_STATE_FILE);
+}
+export function readPackSetupState(botDir) {
+    try {
+        const raw = JSON.parse(fs.readFileSync(statePath(botDir), "utf8"));
+        if (raw?.v !== 1 || typeof raw.pack !== "string" || typeof raw.firm !== "string" || typeof raw.askedFirst !== "string")
+            return null;
+        return {
+            v: 1,
+            pack: raw.pack,
+            firm: raw.firm,
+            askedFirst: raw.askedFirst,
+            modelNotePending: raw.modelNotePending === true,
+            updatedAt: typeof raw.updatedAt === "string" ? raw.updatedAt : new Date(0).toISOString(),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function writePackSetupState(botDir, state) {
+    fs.mkdirSync(botDir, { recursive: true, mode: 0o700 });
+    const tmp = `${statePath(botDir)}.tmp`;
+    fs.writeFileSync(tmp, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
+    fs.renameSync(tmp, statePath(botDir));
+}
+/** The company's display name from companies/manifest.yaml, else its slug. */
+export function companyDisplayName(hqRoot, slug) {
+    try {
+        const doc = yaml.load(fs.readFileSync(path.join(hqRoot, "companies", "manifest.yaml"), "utf8"));
+        for (const table of [doc?.companies, doc]) {
+            const entry = table && typeof table === "object" ? table[slug] : undefined;
+            const name = entry && typeof entry === "object" ? entry.name : undefined;
+            if (typeof name === "string" && name.trim())
+                return name.trim();
+        }
+    }
+    catch {
+        // fall through to the slug
+    }
+    return slug;
+}
+/** The value a question proposes from `default_from`, if any. */
+export function questionDefault(q, ctx) {
+    if (q.default_from === "company_display_name")
+        return ctx.firmName;
+    return null;
+}
+/** One question as a message: the text and its buttons, proposing the default when there is one. */
+export function questionMessage(q, defaultValue) {
+    let text = q.text;
+    const items = questionSuggestions(q);
+    if (defaultValue) {
+        text = `${text} I have "${defaultValue}" from your company. Use that, or type a different one.`;
+        items.unshift(`Use ${defaultValue}`);
+    }
+    return items.length ? `${text}\n\n${suggestionsEnvelope(items)}` : text;
+}
+/** The note on the first model turn after the app asked the first question. */
+export function firstQuestionNote(setup, state, firmName) {
+    const q = setup.questions.find((x) => x.id === state.askedFirst);
+    return (`[Pack setup: the app already sent your hello and your first setup question (\`${state.askedFirst}\`` +
+        (q?.default_from ? `, proposing "${firmName}"` : "") +
+        `) for the company ${state.firm} (${firmName}). HQ is signed in and that company is on this computer, so skip any checks of that. ` +
+        `The message below is the person's reply to that question; carry on the setup from it.]`);
+}
+//# sourceMappingURL=pack-setup-driver.js.map

package/dist/lib/bot/pack-setup.d.ts

@@ -0,0 +1,62 @@
+/**
+ * A bot whose worker belongs to an installed pack with a `setup:` block gets
+ * an auto-generated "Pack setup" section in its system prompt, and, when the
+ * pack asks for it and HQ's own setup is unfinished, a takeover section with
+ * HQ's setup worker skills (build contract section 3).
+ *
+ * scan-packages links a pack worker at `core/workers/public/<id>` ->
+ * `core/packages/<pack>/workers/<id>`, so the pack is found by resolving the
+ * worker folder's real path and checking whether it sits under
+ * `<hqRoot>/core/packages/<pack>/`.
+ */
+import type { PackSetup } from "../../types.js";
+import { type WorkerSkillSource } from "./prompt.js";
+export interface PackSetupResolveFs {
+    realpathSync: (p: string) => string;
+    existsSync: (p: string) => boolean;
+}
+/** The installed pack (name + root) a worker folder belongs to, or null. */
+export declare function findPackForWorker(hqRoot: string, workerDir: string, io?: PackSetupResolveFs): {
+    packName: string;
+    packRoot: string;
+} | null;
+export interface PackSetupPromptSections {
+    packName: string;
+    /** Absolute installed pack root. */
+    packRoot: string;
+    /** The validated `setup:` block. */
+    setup: PackSetup;
+    /** "## Finish HQ setup first", present only when the bot takes over HQ setup. */
+    takeover?: string;
+    /** "## Pack setup (...)". */
+    packSetup: string;
+}
+export interface ResolvePackSetupPromptInput {
+    hqRoot: string;
+    /** hqRoot-relative worker folder (bot.json `workerDir`). */
+    workerDir: string;
+    /** Only worker-sourced bots can belong to a pack. */
+    workerSource?: "scaffold" | "worker";
+    /** Seams for tests. */
+    io?: PackSetupResolveFs;
+    readProgressNote?: () => {
+        path: string | null;
+        note: string | null;
+    };
+    setupWorkerSkills?: (hqRoot: string) => {
+        workerDir: string;
+        skills: WorkerSkillSource[];
+    } | null;
+    log?: (level: "info" | "warn", message: string) => void;
+}
+/** HQ's setup worker folder and skills, resolved like `hq bot create --worker setup`. */
+export declare function loadSetupWorkerSkills(hqRoot: string): {
+    workerDir: string;
+    skills: WorkerSkillSource[];
+} | null;
+/**
+ * The prompt sections for a pack bot, or null when the bot's worker is not a
+ * pack worker or its pack has no valid `setup:` block.
+ */
+export declare function resolvePackSetupPrompt(input: ResolvePackSetupPromptInput): PackSetupPromptSections | null;
+//# sourceMappingURL=pack-setup.d.ts.map

package/dist/lib/bot/pack-setup.js

@@ -0,0 +1,103 @@
+/**
+ * A bot whose worker belongs to an installed pack with a `setup:` block gets
+ * an auto-generated "Pack setup" section in its system prompt, and, when the
+ * pack asks for it and HQ's own setup is unfinished, a takeover section with
+ * HQ's setup worker skills (build contract section 3).
+ *
+ * scan-packages links a pack worker at `core/workers/public/<id>` ->
+ * `core/packages/<pack>/workers/<id>`, so the pack is found by resolving the
+ * worker folder's real path and checking whether it sits under
+ * `<hqRoot>/core/packages/<pack>/`.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { readInstalledPackSetup } from "../packages/setup-block.js";
+import { renderPackSetupSection } from "../packages/setup-prompt.js";
+import { decideTakeover, readHqSetupProgressNote, renderTakeoverSection } from "../packages/setup-takeover.js";
+import { readPackManifest } from "../../utils/pack-contributions.js";
+import { readPromptSources } from "./prompt.js";
+import { resolveBotWorker } from "./worker-source.js";
+import { SETUP_BOT_WORKER_ID } from "./config.js";
+const defaultFs = {
+    realpathSync: (p) => fs.realpathSync(p),
+    existsSync: (p) => fs.existsSync(p),
+};
+/** The installed pack (name + root) a worker folder belongs to, or null. */
+export function findPackForWorker(hqRoot, workerDir, io = defaultFs) {
+    let packagesRoot;
+    let workerReal;
+    try {
+        packagesRoot = io.realpathSync(path.join(hqRoot, "core", "packages"));
+        workerReal = io.realpathSync(path.isAbsolute(workerDir) ? workerDir : path.join(hqRoot, workerDir));
+    }
+    catch {
+        return null;
+    }
+    const rel = path.relative(packagesRoot, workerReal);
+    if (!rel || rel.startsWith("..") || path.isAbsolute(rel))
+        return null;
+    const packName = rel.split(path.sep)[0];
+    if (!packName || packName.startsWith("."))
+        return null;
+    return { packName, packRoot: path.join(packagesRoot, packName) };
+}
+/** HQ's setup worker folder and skills, resolved like `hq bot create --worker setup`. */
+export function loadSetupWorkerSkills(hqRoot) {
+    try {
+        const worker = resolveBotWorker(hqRoot, SETUP_BOT_WORKER_ID);
+        const sources = readPromptSources(hqRoot, worker.path, undefined, { workerSource: "worker" });
+        return { workerDir: worker.path, skills: sources.worker?.skills ?? [] };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The prompt sections for a pack bot, or null when the bot's worker is not a
+ * pack worker or its pack has no valid `setup:` block.
+ */
+export function resolvePackSetupPrompt(input) {
+    if (input.workerSource !== "worker")
+        return null;
+    const log = input.log ?? (() => { });
+    const found = findPackForWorker(input.hqRoot, input.workerDir, input.io);
+    if (!found)
+        return null;
+    const { manifest, error } = readPackManifest(found.packRoot);
+    if (!manifest) {
+        log("warn", `worker ${input.workerDir} belongs to pack ${found.packName} but its package.yaml is unreadable (${error ?? "unknown"}); no pack setup section`);
+        return null;
+    }
+    if (manifest.setup === undefined)
+        return null;
+    const setup = readInstalledPackSetup(manifest, found.packRoot, input.io?.existsSync);
+    if (!setup) {
+        log("warn", `pack ${found.packName} has a setup: block that does not validate; no pack setup section`);
+        return null;
+    }
+    const promptInput = { packName: found.packName, packRoot: found.packRoot, setup };
+    const sections = {
+        packName: found.packName,
+        packRoot: found.packRoot,
+        setup,
+        packSetup: renderPackSetupSection(promptInput),
+    };
+    if (setup.takeover_setup) {
+        const progress = (input.readProgressNote ?? readHqSetupProgressNote)();
+        if (decideTakeover({ takeoverSetup: true, progressNote: progress.note })) {
+            const setupWorker = (input.setupWorkerSkills ?? loadSetupWorkerSkills)(input.hqRoot);
+            sections.takeover = renderTakeoverSection({
+                packName: found.packName,
+                setupWorkerDir: setupWorker?.workerDir ?? path.join("core", "workers", SETUP_BOT_WORKER_ID),
+                skills: setupWorker?.skills ?? [],
+                progressNotePath: progress.path,
+            });
+            log("info", `pack ${found.packName}: HQ setup is not finished; this bot finishes it before the pack setup`);
+        }
+        else {
+            log("info", `pack ${found.packName}: HQ setup is finished; going straight to the pack setup`);
+        }
+    }
+    return sections;
+}
+//# sourceMappingURL=pack-setup.js.map

package/dist/lib/bot/prompt.d.ts

@@ -93,6 +93,14 @@ export interface BuildSystemPromptInput {
     kind?: BotKind;
     /** Company bots: the slugs of the companies the bot is a member of. */
     companies?: string[];
+    /**
+     * Pack bot: the auto-generated "Pack setup" section (and the HQ setup
+     * takeover section when it applies), rendered by lib/bot/pack-setup.ts.
+     */
+    packSetup?: {
+        takeover?: string;
+        packSetup: string;
+    } | null;
     /** hqRoot-relative (default `${workerDir}/memory`) or absolute. */
     memoryDir?: string;
 }

package/dist/lib/bot/prompt.js

@@ -373,6 +373,11 @@ export function buildSystemPrompt(input) {
             parts.push(`## Persona (${path.join(input.workerDir, "persona.md")})\n\n${input.sources.persona.trim()}`);
         }
     }
+    if (input.packSetup) {
+        if (input.packSetup.takeover)
+            parts.push(input.packSetup.takeover);
+        parts.push(input.packSetup.packSetup);
+    }
     if (input.sources.memory.length > 0) {
         const blocks = input.sources.memory.map((m) => `### ${m.name}\n\n${m.body.trim()}`);
         parts.push(`## Memory (${memoryDir}/)\n\n${blocks.join("\n\n")}`);

package/dist/lib/bot/run.d.ts

@@ -201,13 +201,25 @@ export declare const KICKOFF_MESSAGE_ID = "kickoff";
 export declare function turnEnv(base: NodeJS.ProcessEnv, kind: BotKind, agentUid?: string, companySlug?: string): NodeJS.ProcessEnv;
 /** The core worker HQ's setup bot runs. */
 export declare const SETUP_WORKER_ID = "setup";
+/**
+ * The executable a bot's turns will spawn, for the start-up log: an absolute
+ * path when the runtime found one (the HQ app toolchain, a system prefix, the
+ * Claude desktop app), the bare name when it relies on PATH, or "not found"
+ * when the bare name is on no PATH entry either.
+ */
+export declare function describeRuntimeBinary(runtime: BotRuntime, env: NodeJS.ProcessEnv, cwd: string): string;
 /** The one message a person gets when a turn on their message did not finish. */
 export declare function didNotFinishText(reason: string, progressPosted: boolean): string;
 export { containsNoReplySentinel };
 /** Grok emits is_error with this message when the model produces only reasoning tokens. */
 export declare function isReasoningOnlyError(excerpt: string): boolean;
-/** The one note a person gets when the bot pauses after repeated failures. */
-export declare function holdNoticeText(holdMs: number, messagePending: boolean): string;
+/**
+ * The one note a person gets when the bot pauses after repeated failures. With
+ * `reason` (the plain failure text of the last turn) it is the summary that
+ * replaces the fifth per-turn line: one message for the run of failures, with
+ * what went wrong and the one next step.
+ */
+export declare function holdNoticeText(holdMs: number, messagePending: boolean, reason?: string): string;
 /** Owner stop, `hq bot stop` or `hq bot restart`: all arrive as the same signal. */
 export declare const STOPPED_BY_OWNER_REASON = "I was stopped before I was done";
 export declare const RESTARTED_REASON = "I was restarted while I was working on it";
@@ -229,4 +241,8 @@ export interface BotHandle {
 export declare function inboxLaneKey(item: InboxItem, config: Pick<BotConfig, "ownerUid" | "agentUid" | "name">): string;
 export declare function preflightCreds(dir: string, config: BotConfig): string | null;
 export declare function runBot(deps: BotRunDeps): Promise<BotHandle>;
+/** True for a setup note the desktop app sent, not words the person typed. */
+export declare function isAppSetupNote(text: string): boolean;
+/** Put ahead of an app setup note: fold it in, and stay quiet unless it changes what to say. */
+export declare const APP_SETUP_NOTE_TURN_NOTE: string;
 //# sourceMappingURL=run.d.ts.map