@indigoai-us/hq-cli 5.322.0 → 5.324.0

package/dist/lib/cli-invite-nudge.js

@@ -0,0 +1,152 @@
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { createInterface } from "node:readline/promises";
+import { isExpiring, isMachineIdentity, loadCachedTokens, } from "../utils/cognito-session.js";
+import { queueCliInviteNudgeEvent } from "../utils/cli-telemetry.js";
+import { resolveCompanyFlagGate } from "./flag-registry.js";
+import { isHumanInteractiveCliSession } from "./first-sync-next-step.js";
+import { vaultApiFetch } from "../utils/vault-api.js";
+export const CLI_INVITE_NUDGE_FLAG = "cli.first-sync-invite-teammate-v1";
+function reportFailure(operation, error) {
+    const name = error instanceof Error ? error.name : "unknown";
+    const code = /^[A-Za-z][A-Za-z0-9]{0,39}$/.test(name) ? name : "unknown";
+    console.error(`hq: Could not ${operation} (${code}); invite prompt stays hidden.`);
+}
+/** One eligible, successful work-bearing company sync can show one prompt per company. */
+export async function runCliInviteNudge(input) {
+    if (!input.interactive || !input.canPrompt || input.alreadyShown || !/^cmp_[A-Za-z0-9_-]{1,128}$/.test(input.companyUid)) {
+        return false;
+    }
+    let enabled;
+    try {
+        enabled = await input.flagEnabled();
+    }
+    catch (error) {
+        (input.reportFailure ?? reportFailure)("resolve the invite flag", error);
+        return false;
+    }
+    if (!enabled)
+        return false;
+    let humanMemberCount;
+    try {
+        humanMemberCount = await input.readHumanMemberCount();
+    }
+    catch (error) {
+        (input.reportFailure ?? reportFailure)("check company membership", error);
+        return false;
+    }
+    if (humanMemberCount !== 1 || !input.claimShown())
+        return false;
+    input.write("Your company has one member. Invite a teammate to share the workspace.");
+    input.record(input.companyUid, "shown");
+    let clicked;
+    try {
+        clicked = await input.ask("Show the existing invite command? [y/N] ");
+    }
+    catch (error) {
+        (input.reportFailure ?? reportFailure)("read the invite choice", error);
+        return true;
+    }
+    input.record(input.companyUid, clicked ? "clicked" : "dismissed");
+    if (clicked) {
+        input.write(`Run: hq members invite <email> --company ${input.companyRef} --role member`);
+    }
+    return true;
+}
+function inviteNudgeMarkerPath(companyUid, home = process.env.HOME?.trim() || os.homedir()) {
+    const digest = createHash("sha256").update(companyUid).digest("hex");
+    return path.join(home, ".hq", "cli-invite-nudge", `${digest}.shown`);
+}
+function markerExists(companyUid) {
+    try {
+        return fs.existsSync(inviteNudgeMarkerPath(companyUid));
+    }
+    catch (error) {
+        reportFailure("read invite prompt state", error);
+        return true;
+    }
+}
+function claimMarker(companyUid) {
+    const marker = inviteNudgeMarkerPath(companyUid);
+    const homeHq = path.join(process.env.HOME?.trim() || os.homedir(), ".hq");
+    try {
+        // Do not create ~/.hq for a machine without a signed-in person profile.
+        if (!fs.existsSync(homeHq))
+            return false;
+        fs.mkdirSync(path.dirname(marker), { recursive: true, mode: 0o700 });
+        fs.writeFileSync(marker, `${new Date().toISOString()}\n`, { flag: "wx", mode: 0o600 });
+        return true;
+    }
+    catch (error) {
+        if (typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST") {
+            return false;
+        }
+        reportFailure("write invite prompt state", error);
+        return false;
+    }
+}
+async function readActiveHumanMemberCount(accessToken, companyUid) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 1_200);
+    try {
+        const response = await vaultApiFetch({
+            token: accessToken,
+            path: `/membership/company/${encodeURIComponent(companyUid)}`,
+            signal: controller.signal,
+        });
+        if (!response.ok)
+            throw new Error(`http_${response.status}`);
+        const body = await response.json();
+        if (!Array.isArray(body.members))
+            throw new Error("invalid_roster_shape");
+        return body.members.filter((member) => typeof member === "object" && member !== null &&
+            member.status === "active" &&
+            typeof member.personUid === "string" &&
+            member.personUid.startsWith("prs_")).length;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function askInviteChoice(prompt) {
+    const terminal = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = await terminal.question(prompt);
+        return answer.trim().toLowerCase() === "y";
+    }
+    finally {
+        terminal.close();
+    }
+}
+/** Called after a successful work-bearing company sync; every dependency remains fail-closed. */
+export async function maybeShowCliInviteNudge(input) {
+    const companyUid = input.companyUid?.trim() ?? "";
+    const companyRef = input.companyRef?.trim() ?? "";
+    if (!companyUid || !companyRef)
+        return false;
+    const cached = loadCachedTokens();
+    if (!cached || isExpiring(cached, 120) ||
+        !isHumanInteractiveCliSession({
+            stdoutIsTTY: Boolean(process.stdout.isTTY),
+            argv: process.argv,
+            env: process.env,
+            machineIdentity: isMachineIdentity(),
+        }))
+        return false;
+    return runCliInviteNudge({
+        companyUid,
+        companyRef,
+        interactive: true,
+        canPrompt: process.stdin.isTTY === true,
+        alreadyShown: markerExists(companyUid),
+        flagEnabled: () => resolveCompanyFlagGate(companyUid, cached.idToken ?? "", CLI_INVITE_NUDGE_FLAG, { fallback: false }, () => false),
+        readHumanMemberCount: () => readActiveHumanMemberCount(input.accessToken, companyUid),
+        claimShown: () => claimMarker(companyUid),
+        ask: askInviteChoice,
+        write: (line) => console.log(line),
+        record: queueCliInviteNudgeEvent,
+    });
+}
+//# sourceMappingURL=cli-invite-nudge.js.map

package/dist/lib/core-utils/timeout-guard-native-flags.d.ts

@@ -0,0 +1,6 @@
+/** Flag snapshot reader loaded only when the timeout guard would block. */
+import type { FlagReader } from "../flag-registry.js";
+import { type PersistedFlagSnapshot } from "../flag-snapshot-file.js";
+export declare function createNativeSnapshotFlagReader(persistedSnapshot: PersistedFlagSnapshot | null, companyIdentifiers: readonly string[], env: NodeJS.ProcessEnv): FlagReader;
+export declare function snapshotFlagReader(env: NodeJS.ProcessEnv): FlagReader;
+//# sourceMappingURL=timeout-guard-native-flags.d.ts.map

package/dist/lib/core-utils/timeout-guard-native-flags.js

@@ -0,0 +1,30 @@
+/** Flag snapshot reader loaded only when the timeout guard would block. */
+import { readLocalOverride, resolveFlag, } from "@indigoai-us/hq-flags-client";
+import { resolveProcessFlagCompanyContext } from "../process-flag-company-context.js";
+import { readFlagSnapshotFile, } from "../flag-snapshot-file.js";
+export function createNativeSnapshotFlagReader(persistedSnapshot, companyIdentifiers, env) {
+    const snapshot = persistedSnapshot
+        ? { version: 0, flags: persistedSnapshot.flags }
+        : null;
+    return {
+        isEnabled(flagKey, lookup = {}) {
+            if (snapshot) {
+                return resolveFlag({
+                    flagKey,
+                    env,
+                    snapshot,
+                    companyIdentifiers,
+                    lookup,
+                }).value;
+            }
+            return readLocalOverride(flagKey, env) ?? (lookup.fallback ?? false);
+        },
+    };
+}
+export function snapshotFlagReader(env) {
+    const company = resolveProcessFlagCompanyContext(env);
+    const persistedSnapshot = company.companyUid ? readFlagSnapshotFile(company.companyUid, { env }) : null;
+    const companyIdentifiers = [company.companyUid, company.companySlug].filter((value) => Boolean(value));
+    return createNativeSnapshotFlagReader(persistedSnapshot, companyIdentifiers, env);
+}
+//# sourceMappingURL=timeout-guard-native-flags.js.map

package/dist/lib/core-utils/timeout-guard-native.d.ts

@@ -1,7 +1,4 @@
 /** Native fast-route adapter for the shared timeout-guard command. */
-import type { FlagReader } from "../flag-registry.js";
-import { type PersistedFlagSnapshot } from "../flag-snapshot-file.js";
 import { type TimeoutGuardDeps } from "./timeout-guard.js";
-export declare function createNativeSnapshotFlagReader(persistedSnapshot: PersistedFlagSnapshot | null, companyIdentifiers: readonly string[], env: NodeJS.ProcessEnv): FlagReader;
 export declare function runTimeoutGuardFast(_argv: readonly string[], stdin: string, _cwd: string, _hqRoot: string | undefined, dependencies?: TimeoutGuardDeps): Promise<number>;
 //# sourceMappingURL=timeout-guard-native.d.ts.map

package/dist/lib/core-utils/timeout-guard-native.js

@@ -1,40 +1,14 @@
 /** Native fast-route adapter for the shared timeout-guard command. */
-import { readLocalOverride, resolveFlag, } from "@indigoai-us/hq-flags-client";
-import { resolveProcessFlagCompanyContext } from "../process-flag-company-context.js";
-import { readFlagSnapshotFile, } from "../flag-snapshot-file.js";
 import { timeoutGuardCommand } from "./timeout-guard.js";
-export function createNativeSnapshotFlagReader(persistedSnapshot, companyIdentifiers, env) {
-    const snapshot = persistedSnapshot
-        ? { version: 0, flags: persistedSnapshot.flags }
-        : null;
-    return {
-        isEnabled(flagKey, lookup = {}) {
-            if (snapshot) {
-                return resolveFlag({
-                    flagKey,
-                    env,
-                    snapshot,
-                    companyIdentifiers,
-                    lookup,
-                }).value;
-            }
-            return readLocalOverride(flagKey, env) ?? (lookup.fallback ?? false);
-        },
-    };
-}
-function snapshotFlagReader(companyUid, companySlug, env) {
-    const persistedSnapshot = companyUid ? readFlagSnapshotFile(companyUid, { env }) : null;
-    const companyIdentifiers = [companyUid, companySlug].filter((value) => Boolean(value));
-    return createNativeSnapshotFlagReader(persistedSnapshot, companyIdentifiers, env);
-}
 export async function runTimeoutGuardFast(_argv, stdin, _cwd, _hqRoot, dependencies = {}) {
     const env = dependencies.env ?? process.env;
-    const company = resolveProcessFlagCompanyContext(env);
-    const flagReader = dependencies.flagReader ?? snapshotFlagReader(company.companyUid, company.companySlug, env);
     return timeoutGuardCommand(stdin, {
         ...dependencies,
         env,
-        flagReader,
+        getFlagReader: dependencies.getFlagReader ?? (async () => {
+            const { snapshotFlagReader } = await import("./timeout-guard-native-flags.js");
+            return snapshotFlagReader(env);
+        }),
     });
 }
 //# sourceMappingURL=timeout-guard-native.js.map

package/dist/lib/core-utils/timeout-guard.d.ts

@@ -49,6 +49,8 @@ export declare function evaluateTimeoutGuard(input: TimeoutGuardInput): GuardVer
 export interface TimeoutGuardDeps {
     /** Resolve the current HQ user email for the rollout gate. Default: cached id token. */
     getEmail?: () => string | undefined;
+    /** Resolve the flag reader only after an input would otherwise be blocked. */
+    getFlagReader?: () => Promise<FlagReader>;
     env?: NodeJS.ProcessEnv;
     stderr?: NodeJS.WritableStream;
     /** Test seam: held registry snapshot reader. */

package/dist/lib/core-utils/timeout-guard.js

@@ -222,8 +222,9 @@ export async function timeoutGuardCommand(stdin, deps = {}) {
     if (!verdict.block)
         return 0;
     // Rollout gate: only act for @getindigo.ai identities.
+    const flagReader = deps.flagReader ?? await deps.getFlagReader?.();
     const getEmail = deps.getEmail ?? defaultEmail;
-    if (!await isGatedUser(await getEmail(), deps.flagReader))
+    if (!await isGatedUser(await getEmail(), flagReader))
         return 0;
     err.write(`${BLOCK_MESSAGE(verdict.reason ?? "declared timeout exceeds the harness ceiling")}\n`);
     return 2;

package/dist/lib/daemon/convergence.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Daemon version convergence (hq-anywhere US-012).
+ *
+ * After `hq update` (or /update-hq) installs a new hq-cli, the resident
+ * daemon still runs the old code until it restarts. This module asks the
+ * running hqd for its version and compares it with the version now installed
+ * on disk. Policy hq-self-updater-must-verify-convergence-after-install: the
+ * caller reports a mismatch as a failure; it is never swallowed.
+ */
+export declare const CONVERGENCE_TIMEOUT_MS = 10000;
+export declare const CONVERGENCE_POLL_MS = 500;
+export interface ConvergenceResult {
+    converged: boolean;
+    expected: string;
+    /** The version hqd reported last, or null when it never answered. */
+    running: string | null;
+    /** The last ping error when hqd never answered. */
+    error?: string;
+}
+export interface ConvergenceDeps {
+    /** Ask hqd for its version; rejects when hqd is unreachable. */
+    ping?: () => Promise<string>;
+    timeoutMs?: number;
+    pollMs?: number;
+    sleep?: (ms: number) => Promise<void>;
+    now?: () => number;
+}
+/** Ping hqd over its socket and return the version it reports. */
+export declare function pingHqdVersion(socketPath?: string, timeoutMs?: number): Promise<string>;
+/**
+ * The hq-cli version installed on PATH. The process running `hq update` is
+ * the old CLI, so its own CLI_VERSION is not the installed version.
+ */
+export declare function installedCliVersion(run?: (cmd: string, args: string[]) => {
+    status: number | null;
+    stdout: string;
+}): string | null;
+/** Poll hqd until it reports `expected` or the budget runs out. */
+export declare function verifyDaemonConvergence(expected: string, deps?: ConvergenceDeps): Promise<ConvergenceResult>;
+/** One-line description of a non-converged result, with the remediation. */
+export declare function describeNonConvergence(result: ConvergenceResult): string;
+//# sourceMappingURL=convergence.d.ts.map

package/dist/lib/daemon/convergence.js

@@ -0,0 +1,66 @@
+/**
+ * Daemon version convergence (hq-anywhere US-012).
+ *
+ * After `hq update` (or /update-hq) installs a new hq-cli, the resident
+ * daemon still runs the old code until it restarts. This module asks the
+ * running hqd for its version and compares it with the version now installed
+ * on disk. Policy hq-self-updater-must-verify-convergence-after-install: the
+ * caller reports a mismatch as a failure; it is never swallowed.
+ */
+import { spawnSync } from "node:child_process";
+import { hqdRequest } from "./protocol.js";
+export const CONVERGENCE_TIMEOUT_MS = 10_000;
+export const CONVERGENCE_POLL_MS = 500;
+/** Ping hqd over its socket and return the version it reports. */
+export async function pingHqdVersion(socketPath, timeoutMs = 2_000) {
+    const result = (await hqdRequest("ping", {}, { socketPath, timeoutMs }));
+    if (typeof result?.version !== "string")
+        throw new Error("hqd ping did not return a version");
+    return result.version;
+}
+/**
+ * The hq-cli version installed on PATH. The process running `hq update` is
+ * the old CLI, so its own CLI_VERSION is not the installed version.
+ */
+export function installedCliVersion(run = defaultRun) {
+    const out = run("hq", ["--version"]);
+    if (out.status !== 0)
+        return null;
+    const match = /\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?/.exec(out.stdout);
+    return match ? match[0] : null;
+}
+function defaultRun(cmd, args) {
+    const result = spawnSync(cmd, args, { encoding: "utf8", timeout: 10_000 });
+    return { status: result.status, stdout: typeof result.stdout === "string" ? result.stdout : "" };
+}
+/** Poll hqd until it reports `expected` or the budget runs out. */
+export async function verifyDaemonConvergence(expected, deps = {}) {
+    const ping = deps.ping ?? (() => pingHqdVersion());
+    const timeoutMs = deps.timeoutMs ?? CONVERGENCE_TIMEOUT_MS;
+    const pollMs = deps.pollMs ?? CONVERGENCE_POLL_MS;
+    const sleep = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    const now = deps.now ?? Date.now;
+    const deadline = now() + timeoutMs;
+    let running = null;
+    let error;
+    for (;;) {
+        try {
+            running = await ping();
+            error = undefined;
+            if (running === expected)
+                return { converged: true, expected, running };
+        }
+        catch (err) {
+            error = err instanceof Error ? err.message : String(err);
+        }
+        if (now() >= deadline)
+            return { converged: false, expected, running, ...(error ? { error } : {}) };
+        await sleep(pollMs);
+    }
+}
+/** One-line description of a non-converged result, with the remediation. */
+export function describeNonConvergence(result) {
+    const seen = result.running ? `hqd is still running ${result.running}` : `hqd did not answer (${result.error ?? "no response"})`;
+    return `Daemon did not converge on hq-cli ${result.expected}: ${seen}. Run: hq daemon restart && hq doctor --only anywhere`;
+}
+//# sourceMappingURL=convergence.js.map

package/dist/lib/daemon/heartbeat.d.ts

@@ -0,0 +1,43 @@
+/**
+ * hqd heartbeat (hq-anywhere US-012).
+ *
+ * Every 60s the daemon records a host-local beat in ~/.hq/hqd-heartbeat.json so `hq doctor` can tell a live daemon
+ * from a stale one offline. A device with no beat for 5 minutes is
+ * "daemon stale".
+ */
+export declare const HEARTBEAT_INTERVAL_MS = 60000;
+export declare const HEARTBEAT_STALE_MS: number;
+export declare const HEARTBEAT_FILE = "hqd-heartbeat.json";
+export declare const DAEMON_STALE_LABEL = "daemon stale";
+export interface HeartbeatState {
+    at: string;
+    version: string;
+    sessions: number;
+    device: string;
+}
+export declare function heartbeatFile(home?: string, env?: NodeJS.ProcessEnv): string;
+/** Mesh session id for this device's daemon; only characters the spool accepts. */
+export declare function heartbeatSessionId(hostname?: string): string;
+export declare function readHeartbeat(file: string): HeartbeatState | null;
+/** Presence label for a device given its last beat: "daemon stale" after 5 minutes of silence. */
+export declare function daemonPresenceLabel(state: HeartbeatState | null, now?: Date): "daemon live" | typeof DAEMON_STALE_LABEL;
+export interface HeartbeatOptions {
+    version: string;
+    sessionCount: () => number;
+    file?: string;
+    hostname?: string;
+    now?: () => Date;
+    intervalMs?: number;
+    /** Optional host event publisher. The daemon does not publish to Work Mesh without an explicit company-bound session. */
+    publish?: (state: HeartbeatState, sessionId: string) => void;
+    log?: (level: "info" | "warn" | "error", message: string) => void;
+}
+/** Publish one heartbeat. Errors are logged and returned, never thrown into the daemon loop. */
+export declare function beatOnce(opts: HeartbeatOptions): {
+    ok: boolean;
+    state: HeartbeatState;
+    error?: string;
+};
+/** Beat now and every interval until stopped. The timer does not hold the process open. */
+export declare function startHeartbeat(opts: HeartbeatOptions): () => void;
+//# sourceMappingURL=heartbeat.d.ts.map

package/dist/lib/daemon/heartbeat.js

@@ -0,0 +1,70 @@
+/**
+ * hqd heartbeat (hq-anywhere US-012).
+ *
+ * Every 60s the daemon records a host-local beat in ~/.hq/hqd-heartbeat.json so `hq doctor` can tell a live daemon
+ * from a stale one offline. A device with no beat for 5 minutes is
+ * "daemon stale".
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+export const HEARTBEAT_INTERVAL_MS = 60_000;
+export const HEARTBEAT_STALE_MS = 5 * 60_000;
+export const HEARTBEAT_FILE = "hqd-heartbeat.json";
+export const DAEMON_STALE_LABEL = "daemon stale";
+export function heartbeatFile(home = os.homedir(), env = process.env) {
+    const dir = env.HQ_REGISTRY_DIR?.trim() ? path.resolve(env.HQ_REGISTRY_DIR.trim()) : path.join(home, ".hq");
+    return path.join(dir, HEARTBEAT_FILE);
+}
+/** Mesh session id for this device's daemon; only characters the spool accepts. */
+export function heartbeatSessionId(hostname = os.hostname()) {
+    return `hqd-${hostname.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").slice(0, 48) || "device"}`;
+}
+export function readHeartbeat(file) {
+    let raw;
+    try {
+        raw = fs.readFileSync(file, "utf8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return null;
+        throw err;
+    }
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.at !== "string" || typeof parsed.version !== "string")
+        throw new Error(`${file} is not a heartbeat record`);
+    return { at: parsed.at, version: parsed.version, sessions: Number(parsed.sessions ?? 0), device: String(parsed.device ?? "") };
+}
+/** Presence label for a device given its last beat: "daemon stale" after 5 minutes of silence. */
+export function daemonPresenceLabel(state, now = new Date()) {
+    if (!state)
+        return DAEMON_STALE_LABEL;
+    const age = now.getTime() - Date.parse(state.at);
+    return Number.isFinite(age) && age <= HEARTBEAT_STALE_MS ? "daemon live" : DAEMON_STALE_LABEL;
+}
+/** Publish one heartbeat. Errors are logged and returned, never thrown into the daemon loop. */
+export function beatOnce(opts) {
+    const now = (opts.now ?? (() => new Date()))();
+    const sessionId = heartbeatSessionId(opts.hostname);
+    const state = { at: now.toISOString(), version: opts.version, sessions: opts.sessionCount(), device: sessionId };
+    try {
+        const file = opts.file ?? heartbeatFile();
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.writeFileSync(file, `${JSON.stringify(state)}\n`, { mode: 0o600 });
+        opts.publish?.(state, sessionId);
+        return { ok: true, state };
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        opts.log?.("warn", `hqd heartbeat failed: ${error}`);
+        return { ok: false, state, error };
+    }
+}
+/** Beat now and every interval until stopped. The timer does not hold the process open. */
+export function startHeartbeat(opts) {
+    beatOnce(opts);
+    const timer = setInterval(() => beatOnce(opts), opts.intervalMs ?? HEARTBEAT_INTERVAL_MS);
+    timer.unref();
+    return () => clearInterval(timer);
+}
+//# sourceMappingURL=heartbeat.js.map

package/dist/lib/daemon/ops/journal.d.ts

@@ -0,0 +1,29 @@
+/**
+ * journal.append op (hq-anywhere US-009).
+ *
+ * Follows `.claude/skills/_shared/journal.sh append` semantics: the entry goes
+ * into the project's active journal (frontmatter `status: active`, `project:`
+ * = the project folder) as "- <ISO8601> <text>" on the line after the section
+ * header, or under a new header at EOF when the header is missing. A daemon
+ * has no per-session pointer, so the newest active journal in
+ * <project>/journal/ is used, and one is opened (same template as
+ * `journal.sh open`) when none exists.
+ */
+export declare const JOURNAL_SECTIONS: Record<string, string>;
+export declare class JournalOpError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export interface JournalAppendArgs {
+    company: string;
+    project: string;
+    section: string;
+    text: string;
+}
+export interface JournalAppendResult {
+    path: string;
+    line: string;
+    opened: boolean;
+}
+export declare function journalAppend(args: JournalAppendArgs, hqRoot: string, now?: Date): JournalAppendResult;
+//# sourceMappingURL=journal.d.ts.map

package/dist/lib/daemon/ops/journal.js

@@ -0,0 +1,141 @@
+/**
+ * journal.append op (hq-anywhere US-009).
+ *
+ * Follows `.claude/skills/_shared/journal.sh append` semantics: the entry goes
+ * into the project's active journal (frontmatter `status: active`, `project:`
+ * = the project folder) as "- <ISO8601> <text>" on the line after the section
+ * header, or under a new header at EOF when the header is missing. A daemon
+ * has no per-session pointer, so the newest active journal in
+ * <project>/journal/ is used, and one is opened (same template as
+ * `journal.sh open`) when none exists.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+const SLUG_RE = /^[A-Za-z0-9_][A-Za-z0-9._-]*$/;
+export const JOURNAL_SECTIONS = {
+    decisions: "## Decisions",
+    open: "## Open threads",
+    findings: "## Findings",
+    rejected: "## Rejected",
+};
+export class JournalOpError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "JournalOpError";
+    }
+}
+function isoSeconds(d) {
+    return `${d.toISOString().slice(0, 19)}Z`;
+}
+function frontmatterValue(text, key) {
+    const m = new RegExp(`^${key}: (.*)$`, "m").exec(text);
+    return m ? m[1] : null;
+}
+function findActiveJournal(projectDir) {
+    const dir = path.join(projectDir, "journal");
+    let names;
+    try {
+        names = fs.readdirSync(dir);
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return null;
+        throw err;
+    }
+    for (const name of names.filter((n) => n.endsWith(".md")).sort().reverse()) {
+        const file = path.join(dir, name);
+        const text = fs.readFileSync(file, "utf8");
+        if (frontmatterValue(text, "status") !== "active")
+            continue;
+        const project = frontmatterValue(text, "project");
+        if (!project)
+            continue;
+        let real;
+        try {
+            real = fs.realpathSync(project);
+        }
+        catch {
+            continue;
+        }
+        if (real === projectDir)
+            return file;
+    }
+    return null;
+}
+function openJournal(projectDir, now) {
+    const dir = path.join(projectDir, "journal");
+    fs.mkdirSync(dir, { recursive: true });
+    const iso = now.toISOString();
+    const stamp = `${iso.slice(0, 10)}-${iso.slice(11, 13)}${iso.slice(14, 16)}`;
+    const base = `${stamp}-hqd-adhoc`;
+    let file = path.join(dir, `${base}.md`);
+    let suffix = 2;
+    while (fs.existsSync(file))
+        file = path.join(dir, `${base}-${suffix++}.md`);
+    fs.writeFileSync(file, [
+        "---",
+        "skill: hqd",
+        `started_at: ${isoSeconds(now)}`,
+        "thread_id: adhoc",
+        `project: ${projectDir}`,
+        "status: active",
+        "auto_capture: true",
+        'summary: ""',
+        "---",
+        "",
+        "## Decisions",
+        "## Open threads",
+        "## Findings",
+        "## Rejected",
+        "## Auto-capture",
+        "",
+    ].join("\n"));
+    return file;
+}
+export function journalAppend(args, hqRoot, now = new Date()) {
+    if (!SLUG_RE.test(args.company))
+        throw new JournalOpError("bad_args", "company must be a company slug");
+    if (!SLUG_RE.test(args.project))
+        throw new JournalOpError("bad_args", "project must be a project folder name");
+    const header = JOURNAL_SECTIONS[args.section];
+    if (!header)
+        throw new JournalOpError("bad_args", `section must be one of ${Object.keys(JOURNAL_SECTIONS).join(", ")}`);
+    const text = args.text.replace(/\s*[\r\n]+\s*/g, " ").trim();
+    if (!text)
+        throw new JournalOpError("bad_args", "text must be non-empty");
+    const rawDir = path.join(hqRoot, "companies", args.company, "projects", args.project);
+    let projectDir;
+    try {
+        projectDir = fs.realpathSync(rawDir);
+    }
+    catch {
+        throw new JournalOpError("unknown_project", `no project folder at companies/${args.company}/projects/${args.project}`);
+    }
+    const companyRoot = fs.realpathSync(path.join(hqRoot, "companies", args.company));
+    if (!projectDir.startsWith(companyRoot + path.sep)) {
+        throw new JournalOpError("bad_args", "project folder resolves outside its company");
+    }
+    let file = findActiveJournal(projectDir);
+    const opened = file === null;
+    if (!file)
+        file = openJournal(projectDir, now);
+    const line = `- ${isoSeconds(now)} ${text}`;
+    const body = fs.readFileSync(file, "utf8");
+    const lines = body.split("\n");
+    const at = lines.indexOf(header);
+    let next;
+    if (at !== -1) {
+        lines.splice(at + 1, 0, line);
+        next = lines.join("\n");
+    }
+    else {
+        next = `${body}${body.endsWith("\n") || body === "" ? "" : "\n"}\n${header}\n${line}\n`;
+    }
+    const tmp = `${file}.tmp`;
+    fs.writeFileSync(tmp, next);
+    fs.renameSync(tmp, file);
+    return { path: file, line, opened };
+}
+//# sourceMappingURL=journal.js.map