@indigoai-us/hq-cli 5.312.2-beta.0 → 5.314.0

package/dist/lib/bot/local-name.d.ts

@@ -1,54 +0,0 @@
-/**
- * Which folder under ~/.hq/bots/ a cloud bot belongs to.
- *
- * HQ gives a bot's cloud record a slug carrying the owner's suffix: a bot
- * created here as `qa-x` is `qa-x-rg13gzm4` in the cloud. Deriving the local
- * name from the slug alone meant re-adopting that bot built a SECOND directory
- * next to the first — `~/.hq/bots/qa-x-rg13gzm4/` beside `~/.hq/bots/qa-x/` —
- * with a second LaunchAgent label and a second memory folder, while the
- * original kept live machine credentials that nothing would ever clean up and
- * `hq bot rm qa-x` could no longer reach.
- *
- * One bot, one directory. So:
- *
- *   1. If any directory here already carries this bot's agent uid — in its
- *      bot.json, or (when a wipe took the config but left the credentials) in
- *      its machine-creds.json — that IS the bot's directory. Reuse it and
- *      repair in place.
- *   2. Otherwise strip the owner's suffix off the slug, so a bot created here
- *      comes back under the name it was created with.
- *   3. Unless that name is already taken by a DIFFERENT bot, in which case the
- *      full slug keeps the two apart.
- */
-import type { MyLocalBot } from "./api.js";
-export interface LocalBotDirectory {
-    name: string;
-    dir: string;
-    /** The identity the directory holds, from bot.json or its credentials; null when it holds neither. */
-    agentUid: string | null;
-}
-/** A cloud name as a folder name here, or null when it cannot be one. */
-export declare function botNameFromSlug(value: string | undefined | null): string | null;
-/** Every bot directory on this computer, with the identity it holds. */
-export declare function localBotDirectories(root?: string): LocalBotDirectory[];
-/** The directory this identity already has here, however it is named. */
-export declare function findLocalBotByAgentUid(agentUid: string, root?: string): LocalBotDirectory | null;
-/**
- * `qa-x-rg13gzm4` → `qa-x`, when `rg13gzm4` is this owner's suffix. The suffix
- * is whatever tail of the owner's uid HQ appended, so it is recognised by
- * matching the tail against the uid rather than by assuming its length.
- * Anything unrecognised is left exactly as it is.
- */
-export declare function stripOwnerSuffix(slug: string, ownerUid: string | null | undefined): string;
-/**
- * The folder name this cloud bot has (or should have) on this computer, or
- * null when its name cannot be a folder name here at all.
- *
- * `ownerUid` is the signed-in account, used when the listing did not say who
- * owns the bot; the listing's own `ownerUid` wins when it is there.
- */
-export declare function localNameForRemoteBot(bot: MyLocalBot, opts?: {
-    ownerUid?: string | null;
-    root?: string;
-}): string | null;
-//# sourceMappingURL=local-name.d.ts.map

package/dist/lib/bot/local-name.js

@@ -1,114 +0,0 @@
-/**
- * Which folder under ~/.hq/bots/ a cloud bot belongs to.
- *
- * HQ gives a bot's cloud record a slug carrying the owner's suffix: a bot
- * created here as `qa-x` is `qa-x-rg13gzm4` in the cloud. Deriving the local
- * name from the slug alone meant re-adopting that bot built a SECOND directory
- * next to the first — `~/.hq/bots/qa-x-rg13gzm4/` beside `~/.hq/bots/qa-x/` —
- * with a second LaunchAgent label and a second memory folder, while the
- * original kept live machine credentials that nothing would ever clean up and
- * `hq bot rm qa-x` could no longer reach.
- *
- * One bot, one directory. So:
- *
- *   1. If any directory here already carries this bot's agent uid — in its
- *      bot.json, or (when a wipe took the config but left the credentials) in
- *      its machine-creds.json — that IS the bot's directory. Reuse it and
- *      repair in place.
- *   2. Otherwise strip the owner's suffix off the slug, so a bot created here
- *      comes back under the name it was created with.
- *   3. Unless that name is already taken by a DIFFERENT bot, in which case the
- *      full slug keeps the two apart.
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { readBotConfig } from "./config.js";
-import { readBotCredsIdentity } from "./creds.js";
-import { botDir, botsRoot, isValidBotName } from "./paths.js";
-/** The shortest tail that can be an owner suffix; below this, stripping is guesswork. */
-const MIN_OWNER_SUFFIX = 4;
-/** A cloud name as a folder name here, or null when it cannot be one. */
-export function botNameFromSlug(value) {
-    const slug = (value ?? "")
-        .trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-+|-+$/g, "")
-        .slice(0, 40)
-        .replace(/-+$/g, "");
-    return slug && isValidBotName(slug) ? slug : null;
-}
-/** Every bot directory on this computer, with the identity it holds. */
-export function localBotDirectories(root) {
-    const base = root ?? botsRoot();
-    let entries;
-    try {
-        entries = fs.readdirSync(base, { withFileTypes: true });
-    }
-    catch {
-        return [];
-    }
-    const out = [];
-    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-        if (!entry.isDirectory())
-            continue;
-        const dir = path.join(base, entry.name);
-        const agentUid = readBotConfig(dir)?.agentUid ?? readBotCredsIdentity(dir)?.entityUid ?? null;
-        out.push({ name: entry.name, dir, agentUid });
-    }
-    return out;
-}
-/** The directory this identity already has here, however it is named. */
-export function findLocalBotByAgentUid(agentUid, root) {
-    const wanted = (agentUid ?? "").trim();
-    if (!wanted)
-        return null;
-    return localBotDirectories(root).find((d) => d.agentUid === wanted) ?? null;
-}
-/**
- * `qa-x-rg13gzm4` → `qa-x`, when `rg13gzm4` is this owner's suffix. The suffix
- * is whatever tail of the owner's uid HQ appended, so it is recognised by
- * matching the tail against the uid rather than by assuming its length.
- * Anything unrecognised is left exactly as it is.
- */
-export function stripOwnerSuffix(slug, ownerUid) {
-    const owner = (ownerUid ?? "").trim().toLowerCase();
-    if (!owner)
-        return slug;
-    const cut = slug.lastIndexOf("-");
-    if (cut <= 0)
-        return slug;
-    const tail = slug.slice(cut + 1);
-    if (tail.length < MIN_OWNER_SUFFIX || !owner.endsWith(tail))
-        return slug;
-    const base = slug.slice(0, cut);
-    return isValidBotName(base) ? base : slug;
-}
-/**
- * The folder name this cloud bot has (or should have) on this computer, or
- * null when its name cannot be a folder name here at all.
- *
- * `ownerUid` is the signed-in account, used when the listing did not say who
- * owns the bot; the listing's own `ownerUid` wins when it is there.
- */
-export function localNameForRemoteBot(bot, opts = {}) {
-    const root = opts.root;
-    const existing = bot.agentUid ? findLocalBotByAgentUid(bot.agentUid, root) : null;
-    if (existing)
-        return existing.name;
-    const slug = botNameFromSlug(bot.slug) ?? botNameFromSlug(bot.name);
-    if (!slug)
-        return null;
-    const stripped = stripOwnerSuffix(slug, bot.ownerUid ?? opts.ownerUid ?? null);
-    if (stripped === slug)
-        return slug;
-    // Two different bots may want the same short name. The one that is here
-    // already keeps it; the newcomer keeps its full slug, so neither is lost.
-    const taken = localBotDirectories(root).find((d) => d.name === stripped);
-    if (taken && taken.agentUid !== bot.agentUid)
-        return slug;
-    if (!taken && fs.existsSync(botDir(stripped, root)))
-        return slug;
-    return stripped;
-}
-//# sourceMappingURL=local-name.js.map

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

@@ -1,13 +0,0 @@
-/**
- * ~/.hq/bots/<name>/logs/bot.log with rotation at 5MB. Never writes prompts,
- * tokens, credentials, or DM bodies — only metadata and bounded error text.
- */
-export declare function ensureBotLog(dir: string): string;
-export declare function rotateBotLogIfNeeded(dir: string, maxBytes?: number): void;
-/** Strip anything that looks like a bearer token, secret, or op:// ref. */
-export declare function redactForLog(message: string): string;
-export declare function botLogLine(level: "info" | "warn" | "error", message: string, now?: () => Date): string;
-export declare function appendBotLog(dir: string, line: string): void;
-export type BotLogger = (level: "info" | "warn" | "error", message: string) => void;
-export declare function createBotLogger(dir: string, now?: () => Date): BotLogger;
-//# sourceMappingURL=log.d.ts.map

package/dist/lib/bot/log.js

@@ -1,59 +0,0 @@
-/**
- * ~/.hq/bots/<name>/logs/bot.log with rotation at 5MB. Never writes prompts,
- * tokens, credentials, or DM bodies — only metadata and bounded error text.
- */
-import * as fs from "node:fs";
-import { BOT_LOG_MAX_BYTES, botLogPath, botLogsDir } from "./paths.js";
-export function ensureBotLog(dir) {
-    fs.mkdirSync(botLogsDir(dir), { recursive: true, mode: 0o700 });
-    const logPath = botLogPath(dir);
-    if (!fs.existsSync(logPath))
-        fs.writeFileSync(logPath, "", { mode: 0o600 });
-    return logPath;
-}
-export function rotateBotLogIfNeeded(dir, maxBytes = BOT_LOG_MAX_BYTES) {
-    const logPath = botLogPath(dir);
-    try {
-        if (!fs.existsSync(logPath))
-            return;
-        if (fs.statSync(logPath).size <= maxBytes)
-            return;
-        const rotated = `${logPath}.1`;
-        try {
-            fs.unlinkSync(rotated);
-        }
-        catch {
-            /* ignore */
-        }
-        fs.renameSync(logPath, rotated);
-        fs.writeFileSync(logPath, "", { mode: 0o600 });
-    }
-    catch {
-        /* best-effort */
-    }
-}
-/** Strip anything that looks like a bearer token, secret, or op:// ref. */
-export function redactForLog(message) {
-    return message
-        .replace(/Bearer\s+[A-Za-z0-9._-]+/gi, "Bearer [REDACTED]")
-        .replace(/op:\/\/[^\s"]+/g, "op://[REDACTED]")
-        .replace(/"secret"\s*:\s*"[^"]*"/g, '"secret":"[REDACTED]"')
-        .replace(/eyJ[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{10,}/g, "[REDACTED_JWT]");
-}
-export function botLogLine(level, message, now = () => new Date()) {
-    return `${now().toISOString()} ${level} ${redactForLog(message).slice(0, 600)}`;
-}
-export function appendBotLog(dir, line) {
-    rotateBotLogIfNeeded(dir);
-    const logPath = ensureBotLog(dir);
-    try {
-        fs.appendFileSync(logPath, line.endsWith("\n") ? line : `${line}\n`);
-    }
-    catch {
-        /* best-effort */
-    }
-}
-export function createBotLogger(dir, now = () => new Date()) {
-    return (level, message) => appendBotLog(dir, botLogLine(level, message, now));
-}
-//# sourceMappingURL=log.js.map

package/dist/lib/bot/owner-context.d.ts

@@ -1,79 +0,0 @@
-/**
- * Owner context: who the bot's owner is and which companies they belong to.
- *
- * A local bot runs under its OWN HQ identity (per-bot machine credentials set
- * for the whole resident process, and inherited by the model subprocess). So
- * any membership lookup the model makes with `hq` describes the bot, and a bot
- * usually belongs to no company. Bots were reading that empty answer as "your
- * owner has no company".
- *
- * The resident process (trusted code, not the model) looks the owner up with
- * the owner's own cached HQ session, strictly non-interactively, and verifies
- * the session really is the owner before trusting it. Only the result (company
- * slugs, uids, roles) reaches the model; the owner's token never does. A failed
- * lookup is reported as "could not check", never as "no companies".
- */
-interface OwnerCompany {
-    companyUid: string;
-    /** Present when the server enriched it. */
-    companySlug?: string;
-    role: string;
-}
-export type OwnerContext = {
-    status: "ok";
-    ownerUid: string;
-    companies: OwnerCompany[];
-    checkedAt: string;
-} | {
-    status: "unavailable";
-    ownerUid: string;
-    reason: string;
-    checkedAt: string;
-    /** True when the owner's sign-in exists and only reading their account failed. */
-    signedIn?: boolean;
-    /** Technical cause, for logs only; never shown to the model. */
-    detail?: string;
-} | {
-    status: "mismatch";
-    ownerUid: string;
-    signedInAs: string;
-    checkedAt: string;
-};
-export interface OwnerLookupIo {
-    /** The owner's own session token; must never prompt or open a browser. */
-    personToken: () => Promise<string>;
-    /** `prs_*` uid the token belongs to. */
-    callerPersonUid: (token: string) => Promise<string>;
-    /** Raw memberships for the token's subject. */
-    memberships: (token: string) => Promise<Array<{
-        companyUid: string;
-        companySlug?: string;
-        role: string;
-        status: string;
-    }>>;
-    now?: () => Date;
-    /** Test seam for the retry pause. */
-    sleep?: (ms: number) => Promise<void>;
-}
-export declare function lookupOwnerContext(ownerUid: string, io?: OwnerLookupIo): Promise<OwnerContext>;
-/** Successful lookups are reused for 5 minutes, failures retried after 1 minute. */
-export declare const OWNER_CONTEXT_TTL_MS: number;
-export declare const OWNER_CONTEXT_RETRY_MS = 60000;
-export declare class OwnerContextCache {
-    private readonly lookup;
-    private readonly nowMs;
-    private readonly waitMs;
-    private readonly ownerUid;
-    private value;
-    private at;
-    private pending;
-    constructor(lookup: () => Promise<OwnerContext>, nowMs?: () => number, waitMs?: number, ownerUid?: string);
-    get(): Promise<OwnerContext>;
-}
-/**
- * The block prepended to every owner DM turn. It names its subject explicitly so the
- * model cannot confuse the owner's memberships with its own.
- */
-export declare function ownerContextBlock(ctx: OwnerContext, agentUid: string): string;
-export {};
-//# sourceMappingURL=owner-context.d.ts.map

package/dist/lib/bot/owner-context.js

@@ -1,175 +0,0 @@
-/**
- * Owner context: who the bot's owner is and which companies they belong to.
- *
- * A local bot runs under its OWN HQ identity (per-bot machine credentials set
- * for the whole resident process, and inherited by the model subprocess). So
- * any membership lookup the model makes with `hq` describes the bot, and a bot
- * usually belongs to no company. Bots were reading that empty answer as "your
- * owner has no company".
- *
- * The resident process (trusted code, not the model) looks the owner up with
- * the owner's own cached HQ session, strictly non-interactively, and verifies
- * the session really is the owner before trusting it. Only the result (company
- * slugs, uids, roles) reaches the model; the owner's token never does. A failed
- * lookup is reported as "could not check", never as "no companies".
- */
-import { ensureCognitoToken } from "../../utils/cognito-session.js";
-import { resolveCallerPersonUid, vaultApiFetch } from "../../utils/vault-api.js";
-function message(err) {
-    return err instanceof Error ? err.message : String(err);
-}
-const defaultOwnerLookupIo = {
-    // tokenSource "person" never uses the bot's machine creds, even though
-    // HQ_MACHINE_CREDS_FILE is set for this process.
-    personToken: () => ensureCognitoToken({ tokenSource: "person", interactive: false }),
-    callerPersonUid: (token) => resolveCallerPersonUid(token),
-    memberships: async (token) => {
-        const res = await vaultApiFetch({ token, path: "/membership/me", signal: AbortSignal.timeout(15_000) });
-        if (!res.ok)
-            throw new Error(`membership lookup returned ${res.status}`);
-        const data = (await res.json());
-        if (!Array.isArray(data.memberships))
-            throw new Error("membership lookup returned no list");
-        return data.memberships;
-    },
-};
-/** A read right after sign-in or bot start can fail once; try again before reporting it. */
-const OWNER_LOOKUP_RETRY_DELAYS_MS = [1_000, 2_000];
-async function withRetry(fn, io) {
-    const sleep = io.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
-    let lastErr;
-    for (const delay of [0, ...OWNER_LOOKUP_RETRY_DELAYS_MS]) {
-        if (delay)
-            await sleep(delay);
-        try {
-            return await fn();
-        }
-        catch (err) {
-            lastErr = err;
-        }
-    }
-    throw lastErr;
-}
-export async function lookupOwnerContext(ownerUid, io = defaultOwnerLookupIo) {
-    const checkedAt = (io.now ?? (() => new Date()))().toISOString();
-    let token;
-    try {
-        token = await io.personToken();
-    }
-    catch (err) {
-        return { status: "unavailable", ownerUid, reason: `your owner's HQ sign-in on this computer is not usable (${message(err)})`, checkedAt };
-    }
-    let signedInAs;
-    try {
-        signedInAs = await withRetry(() => io.callerPersonUid(token), io);
-    }
-    catch (err) {
-        // The raw error ("…Sign in to HQ once…") would read to the model as "not signed in".
-        return { status: "unavailable", ownerUid, reason: "their HQ account could not be read just now", detail: message(err), checkedAt, signedIn: true };
-    }
-    if (signedInAs !== ownerUid)
-        return { status: "mismatch", ownerUid, signedInAs, checkedAt };
-    try {
-        const rows = await withRetry(() => io.memberships(token), io);
-        const companies = rows
-            .filter((m) => m.status === "active")
-            .map((m) => ({ companyUid: m.companyUid, ...(m.companySlug ? { companySlug: m.companySlug } : {}), role: m.role }));
-        return { status: "ok", ownerUid, companies, checkedAt };
-    }
-    catch (err) {
-        return { status: "unavailable", ownerUid, reason: `could not read your owner's companies (${message(err)})`, checkedAt, signedIn: true };
-    }
-}
-/** Successful lookups are reused for 5 minutes, failures retried after 1 minute. */
-export const OWNER_CONTEXT_TTL_MS = 5 * 60_000;
-export const OWNER_CONTEXT_RETRY_MS = 60_000;
-/** A turn never waits longer than this for a refresh; the lookup keeps going in the background. */
-const OWNER_CONTEXT_WAIT_MS = 8_000;
-export class OwnerContextCache {
-    lookup;
-    nowMs;
-    waitMs;
-    ownerUid;
-    value = null;
-    at = 0;
-    pending = null;
-    constructor(lookup, nowMs = Date.now, waitMs = OWNER_CONTEXT_WAIT_MS, ownerUid = "") {
-        this.lookup = lookup;
-        this.nowMs = nowMs;
-        this.waitMs = waitMs;
-        this.ownerUid = ownerUid;
-    }
-    async get() {
-        const age = this.nowMs() - this.at;
-        if (this.value && age < (this.value.status === "ok" ? OWNER_CONTEXT_TTL_MS : OWNER_CONTEXT_RETRY_MS))
-            return this.value;
-        if (!this.pending) {
-            this.pending = this.lookup()
-                .then((v) => {
-                this.value = v;
-                this.at = this.nowMs();
-                return v;
-            })
-                .finally(() => {
-                this.pending = null;
-            });
-            this.pending.catch(() => undefined);
-        }
-        let timer;
-        const slow = new Promise((resolve) => {
-            timer = setTimeout(() => resolve(null), this.waitMs);
-        });
-        try {
-            const got = await Promise.race([this.pending, slow]);
-            if (got)
-                return got;
-        }
-        finally {
-            if (timer)
-                clearTimeout(timer);
-        }
-        // Slow refresh: the last answer (it carries its own checkedAt) beats none.
-        if (this.value)
-            return this.value;
-        return {
-            status: "unavailable",
-            ownerUid: this.ownerUid,
-            reason: "the check is taking too long",
-            checkedAt: new Date(this.nowMs()).toISOString(),
-        };
-    }
-}
-/**
- * The block prepended to every owner DM turn. It names its subject explicitly so the
- * model cannot confuse the owner's memberships with its own.
- */
-export function ownerContextBlock(ctx, agentUid) {
-    const head = `[Owner context, checked ${ctx.checkedAt} by this bot's runtime with your owner's own HQ sign-in. It describes your OWNER (${ctx.ownerUid}), not you (${agentUid}).]`;
-    let body;
-    if (ctx.status === "ok") {
-        body =
-            ctx.companies.length === 0
-                ? "Your owner has no active company memberships. They work in a personal HQ."
-                : `Your owner's active companies:\n${ctx.companies
-                    .map((c) => `- ${c.companySlug ?? c.companyUid} (${c.companyUid}), role: ${c.role}`)
-                    .join("\n")}`;
-    }
-    else if (ctx.status === "mismatch") {
-        body =
-            `The HQ sign-in on this computer belongs to ${ctx.signedInAs}, not your owner, so your owner's companies could not be checked. ` +
-                "Do not say which companies your owner belongs to; tell them you could not check and why.";
-    }
-    else if (ctx.signedIn) {
-        body =
-            `Your owner IS signed in to HQ on this computer, but their companies could not be checked: ${ctx.reason}. ` +
-                "Do not guess and do not say they have no company. Do not ask them to sign in or to run any command: " +
-                "say you could not read their account just now and that you will check again on their next message.";
-    }
-    else {
-        body =
-            `Your owner's companies could not be checked: ${ctx.reason}. ` +
-                "Do not guess and do not say they have no company; tell them you could not check right now.";
-    }
-    return `${head}\n${body}\n[End owner context]`;
-}
-//# sourceMappingURL=owner-context.js.map

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

@@ -1,76 +0,0 @@
-/**
- * Local bot on-disk layout (local-bots US-003/US-005).
- *
- *   ~/.hq/bots/<name>/
- *     bot.json            config (name, agt_ uid, owner, runtime, hqRoot)
- *     memory/             the bot's memory when created with --memory local
- *     machine-creds.json  0600 Cognito machine creds (never printed)
- *     token-state/        per-bot machine token cache (HQ_MACHINE_TOKEN_STATE_DIR)
- *     status.json         pid, state, restarts, last heartbeat
- *     inbox-state.json    processed messageIds (idempotency across restarts)
- *     session.json        model-CLI session id for the owner DM
- *     session-dm-<hexPeerUid>.json  one session per other DM correspondent
- *     session-room-<channelId>.json  one session per room the bot answers in
- *     session-job-<jobId>.json       one session per scheduled job the bot runs
- *     job-completions.json  run completions the cloud has not accepted yet
- *     pid                 single-file pid lock
- *     logs/bot.log        rotated at 5MB
- *
- * Injectable root (HQ_BOTS_ROOT) so tests never touch the real HOME.
- */
-export declare const BOTS_DIRNAME = "bots";
-export declare const BOT_CONFIG_NAME = "bot.json";
-export declare const BOT_CREDS_NAME = "machine-creds.json";
-export declare const BOT_STATUS_NAME = "status.json";
-export declare const BOT_INBOX_STATE_NAME = "inbox-state.json";
-export declare const BOT_SESSION_NAME = "session.json";
-export declare const BOT_TOKEN_STATE_DIRNAME = "token-state";
-export declare const BOT_LOGS_DIRNAME = "logs";
-export declare const BOT_LOG_NAME = "bot.log";
-export declare const BOT_LOG_MAX_BYTES: number;
-export declare const LAUNCHD_LABEL_PREFIX = "ai.getindigo.hq-bot";
-export declare function isValidBotName(name: string): boolean;
-export declare function validateBotName(name: string): string;
-export declare function botsRoot(home?: string, env?: NodeJS.ProcessEnv): string;
-export declare function botDir(name: string, root?: string): string;
-export declare function botConfigPath(dir: string): string;
-export declare function botCredsPath(dir: string): string;
-export declare function botStatusPath(dir: string): string;
-export declare function botInboxStatePath(dir: string): string;
-/**
- * Model conversations are scoped to a DM correspondent or room. The owner's
- * legacy "dm" scope remains stable; other senders use "dm:<peerUid>".
- */
-export type BotSessionScope = "dm" | `dm:${string}` | `room:${string}` | `job:${string}`;
-/** Preserve the owner session; keep every other correspondent separate. */
-export declare function dmSessionScope(peerUid: string, ownerUid: string): BotSessionScope;
-export declare function roomSessionScope(channelId: string): BotSessionScope;
-/**
- * One session per scheduled job. A job turn must never resume the owner's DM
- * conversation (a scheduled run is not a reply), and two different jobs must
- * not share a session either — each recurring routine keeps its own history.
- */
-export declare function jobSessionScope(jobId: string): BotSessionScope;
-export declare function botSessionPath(dir: string, scope?: BotSessionScope): string;
-export declare function botTokenStateDir(dir: string): string;
-/**
- * Scratch working directory for model turns. Deliberately OUTSIDE the HQ git
- * tree: Claude/Grok/Codex scan the working tree on every turn, and HQ's tree
- * (tens of thousands of entries, a huge `git status`) cost ~20 s per reply on
- * 2026-09-11. The system prompt tells the bot where HQ is; it `cd`s there when
- * a request needs the files or `hq` commands.
- */
-export declare function botTurnCwd(dir: string): string;
-/** ~/.hq/bots/<name>/memory — "local" memory, outside the synced HQ tree. */
-export declare function botLocalMemoryDir(dir: string): string;
-/**
- * ~/.hq/bots/<name>/attachments — chat attachments the runner downloads for a
- * turn (dir 0700, files 0600), one subfolder per vault scope.
- */
-export declare function botAttachmentsDir(dir: string): string;
-export declare function botLogsDir(dir: string): string;
-export declare function botLogPath(dir: string): string;
-export declare function launchdLabel(name: string): string;
-/** personal/workers/<name>/ relative to the HQ root. */
-export declare function botWorkerRelDir(name: string): string;
-//# sourceMappingURL=paths.d.ts.map