ai-spend-agent 0.9.0 → 0.9.2

package/dist/projectAccountabilityState.d.ts

@@ -1,4 +1,4 @@
-import { type AcceptedOutcomeV0, type AcceptedOutcomeV0DraftInput, type ApprovalEventV0, type ApprovalEventV0DraftInput, type ConfirmedOwnershipV0 } from "@agent-finops/core";
+import { isCredentialLike, isPathLike, type AcceptedOutcomeV0, type AcceptedOutcomeV0DraftInput, type ApprovalEventV0, type ApprovalEventV0DraftInput, type ConfirmedOwnershipV0 } from "@agent-finops/core";
 export declare const PROJECT_ACCOUNTABILITY_STATE_FILE = "project-accountability.json";
 export declare const PROJECT_ACCOUNTABILITY_STATE_KIND: "aibill.project_accountability_store";
 export declare const PROJECT_ACCOUNTABILITY_STATE_VERSION: 1;
@@ -85,11 +85,10 @@ export declare function appendProjectApprovalEvent(rootPath: string, input: Omit
  */
 export declare function appendAcceptedProjectOutcome(rootPath: string, value: AcceptedOutcomeV0 | AcceptedOutcomeV0DraftInput): Promise<ProjectAccountabilityStateV1>;
 /**
- * Exported as the classification FLOOR for the guided-prompt engine: the
- * per-prompt classifier must reject at least everything these predicates
- * reject, so `parseDisplayLabel` can never abort on an answer the prompt
- * already accepted (the Aug 17 incident class).
+ * The classification FLOOR predicates for the guided-prompt engine live in
+ * core (`guidedAnswer.ts`) so the CLI classifier, the MCP draft preview,
+ * and this accountability backstop can never drift apart. Re-exported here
+ * for existing CLI imports.
  */
-export declare function isPathLike(value: string): boolean;
-export declare function isCredentialLike(value: string): boolean;
+export { isCredentialLike, isPathLike };
 //# sourceMappingURL=projectAccountabilityState.d.ts.map

package/dist/projectAccountabilityState.js

@@ -5,7 +5,7 @@ import { lstat, mkdir, open, readdir, realpath, rmdir, unlink } from "node:fs/pr
 import { homedir } from "node:os";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { promisify } from "node:util";
-import { CONFIRMED_OWNERSHIP_V0_KIND, MAX_APPROVAL_EVENTS_V0, PROJECT_ECONOMICS_V0_VERSION, appendApprovalEventV0, createAcceptedOutcomeV0, createConfirmedOwnershipV0, createProjectEconomicsReference, parseAcceptedOutcomeV0, parseApprovalEventV0, parseConfirmedOwnershipV0, readSafeStateText, resolveSafeScanRoot, UnsafeStateFileError, writeSafeStateText } from "@agent-finops/core";
+import { CONFIRMED_OWNERSHIP_V0_KIND, isCredentialLike, isPathLike, MAX_APPROVAL_EVENTS_V0, PROJECT_ECONOMICS_V0_VERSION, appendApprovalEventV0, createAcceptedOutcomeV0, createConfirmedOwnershipV0, createProjectEconomicsReference, parseAcceptedOutcomeV0, parseApprovalEventV0, parseConfirmedOwnershipV0, readSafeStateText, resolveSafeScanRoot, UnsafeStateFileError, writeSafeStateText } from "@agent-finops/core";
 export const PROJECT_ACCOUNTABILITY_STATE_FILE = "project-accountability.json";
 export const PROJECT_ACCOUNTABILITY_STATE_KIND = "aibill.project_accountability_store";
 export const PROJECT_ACCOUNTABILITY_STATE_VERSION = 1;
@@ -794,21 +794,12 @@ function noFollowFlag() {
     return typeof constants.O_NOFOLLOW === "number" ? constants.O_NOFOLLOW : 0;
 }
 /**
- * Exported as the classification FLOOR for the guided-prompt engine: the
- * per-prompt classifier must reject at least everything these predicates
- * reject, so `parseDisplayLabel` can never abort on an answer the prompt
- * already accepted (the Aug 17 incident class).
+ * The classification FLOOR predicates for the guided-prompt engine live in
+ * core (`guidedAnswer.ts`) so the CLI classifier, the MCP draft preview,
+ * and this accountability backstop can never drift apart. Re-exported here
+ * for existing CLI imports.
  */
-export function isPathLike(value) {
-    return /^(?:~?[\\/]|\.{1,2}(?:[\\/]|$)|[A-Za-z]:[\\/]|\\\\)/u.test(value) ||
-        /(?:^|[\\/])\.\.(?:[\\/]|$)/u.test(value) || value.includes("\\");
-}
-export function isCredentialLike(value) {
-    return /(?:sk-(?:ant-|proj-)?|sk_|gh[pousr]_|github_pat_|npm_|AIza|xox[baprs]-|glpat-|AKIA)[A-Za-z0-9_-]{8,}/i
-        .test(value) ||
-        /(?:api[_ -]?key|access[_ -]?token|auth[_ -]?token|secret|password)\s*[:=]\s*\S+/i
-            .test(value);
-}
+export { isCredentialLike, isPathLike };
 function hasUnpairedSurrogate(value) {
     for (let index = 0; index < value.length; index += 1) {
         const code = value.charCodeAt(index);

package/dist/signup.d.ts

@@ -0,0 +1,272 @@
+/**
+ * CLI email capture — the launch-list signup lane (v0.9.2).
+ *
+ * Design: docs/qa-handoff/CLI_CAPTURE_DESIGN.md (see its dated placement
+ * addendum). QA verdict (its B/M fixes are mandatory):
+ * docs/qa-handoff/CLI_CAPTURE_QA_VERDICT.md.
+ *
+ * Placement (founder decision 2026-08-24): the ONE ask runs PRE-RECEIPT,
+ * DURING the first evidence scan — it fills the first-run wait instead of
+ * adding one. The receipt renders when both the human's answer (or skip /
+ * timeout / Ctrl-C) and the pipeline resolve; consent, when an email was
+ * typed, renders strictly AFTER the receipt.
+ *
+ * Hard rules encoded here:
+ * - The payload is EXACTLY {email, ref} — the deployed asktilden.com route
+ *   reads `ref` (not `sourceRef`) and normalizes anything failing
+ *   /^[a-z0-9][a-z0-9_-]{0,63}$/ (dots included) to "direct" (verdict B1).
+ * - Consent shows the literal payload JSON; the sent line claims only the
+ *   payload layer, never "nothing else left this machine" (verdict B2).
+ * - One POST attempt, 3s timeout, no retry, no queue, and the typed email is
+ *   never persisted on failure.
+ * - Every read is timeout-guarded and can never eat a skip: a timeout or
+ *   Ctrl-C records NO lifetime skip (verdict M3).
+ * - Skip = two empty Enters with one declarative nudge between them; the
+ *   completed pair counts as ONE lifetime skip. This is the founder-approved
+ *   ceiling: no further skip friction may be added, and removal of skip is
+ *   refused by design.
+ * - Never-ask state lives in ~/.aibill/signup.json (the existing home dir —
+ *   verdict M5) and fails CLOSED to never-ask on corrupt/readonly state.
+ */
+export declare const waitlistUrl = "https://asktilden.com/api/waitlist";
+/** Closed payload type — adding a field here must fail the creep-guard test. */
+export type WaitlistPayload = {
+    email: string;
+    ref: string;
+};
+export type WaitlistRefSurface = "receipt" | "signup";
+export declare const deployedRefPattern: RegExp;
+export declare function normalizeWaitlistEmail(raw: string): string | undefined;
+/** `--ref` allowlist: lowercase alphanumerics and dashes, 1–24 chars. */
+export declare function sanitizeSignupRefTag(raw: string): string | undefined;
+export declare function buildWaitlistRef(surface: WaitlistRefSurface, tag?: string): string;
+/**
+ * The exact bytes sent — key order pinned. Payload creep (adding os/plan/
+ * version data, or stuffing values into ref) fails the CI creep-guard test;
+ * see docs/qa-handoff/CLI_CAPTURE_DESIGN.md §3c before touching this.
+ */
+export declare function serializeWaitlistPayload(payload: WaitlistPayload): string;
+export type WaitlistPostOutcome = "sent" | "invalid_email" | "rate_limited" | "unreachable";
+/**
+ * Single POST, 3s timeout, one attempt, no retry, no queue. The response
+ * body is never printed (it could be an HTML error page); only the status
+ * code is mapped. Headers are the full explicit set this request adds —
+ * pinned by test so header creep fails CI too.
+ */
+export declare function postWaitlistSignup(payload: WaitlistPayload, options?: {
+    fetchImpl?: typeof fetch;
+    timeoutMs?: number;
+}): Promise<WaitlistPostOutcome>;
+export type EmailDeliverability = "ok" | "no_mx" | "disposable";
+/** Small static blocklist of throwaway-inbox domains (exact match only). */
+export declare const disposableEmailDomains: ReadonlySet<string>;
+/** Exact or subdomain match against the blocklist (QA m5). */
+export declare function isDisposableEmailDomain(domain: string): boolean;
+export type SignupDnsResolver = {
+    resolveMx: (domain: string) => Promise<Array<{
+        exchange: string;
+        priority: number;
+    }>>;
+    resolve4: (domain: string) => Promise<string[]>;
+};
+export declare function assessEmailDeliverability(email: string, options?: {
+    resolver?: SignupDnsResolver;
+    timeoutMs?: number;
+}): Promise<EmailDeliverability>;
+export declare const signupCopy: {
+    /**
+     * Launch-week headline — TRUE only through launch day (Fri Aug 28); the
+     * date gate in signupAskBlockLines swaps in the evergreen fallback after
+     * signupLaunchWindowEndsAt so this copy can never go stale.
+     */
+    readonly askHeadlineLaunch: readonly ["aibill launches Friday with Star.fun.", "Get the launch email + what ships next:"];
+    readonly askHeadlineFallback: readonly ["Get product updates:"];
+    readonly askFooter: "type your email, or press Enter to skip";
+    readonly askPrompt: "  > ";
+    readonly waitLine: "reading your local AI evidence…";
+    /** Printed once if the scan finishes while the ask is still open. */
+    readonly receiptReadyLine: "your receipt is ready — type your email, or press Enter to see it";
+    /** Printed after the FIRST empty Enter; the second empty Enter skips. */
+    readonly skipNudgeLine: "one launch email · Enter again to skip, or type your email";
+    readonly scopeLine: "used only for updates · never shared";
+    /** Printed on the first Ctrl-C at the ask (the scan continues; M2). */
+    readonly interruptLine: "ok — skipped the ask · your receipt is still being read (Ctrl-C again to quit)";
+    /** Printed when ^C lands after the ask settled but before the receipt. */
+    readonly interruptAfterAnswerLine: "still reading your evidence · Ctrl-C again to quit";
+    /** Printed when the re-prompt budget closes the ask (no skip consumed). */
+    readonly budgetClosedLine: "moving on · npx aibill signup <email> anytime";
+    readonly consentQuestion: (payloadJson: string) => string;
+    readonly sentLine: "sent: exactly that JSON · nothing else in the payload";
+    readonly neverLine: "ok — never asking again · npx aibill signup <email> if you change your mind";
+    readonly invalidEmailLine: "that email did not validate — check it and retry";
+    readonly noMxLine: "that domain can't receive email — check the spelling";
+    readonly disposableLine: "use an address you actually check";
+    readonly rateLimitedLine: "busy — try again in a minute, or join at https://asktilden.com";
+    readonly unreachableLine: "could not reach asktilden.com — join at https://asktilden.com";
+    readonly alreadyLine: "already on the list · nothing sent twice";
+    readonly nothingSentLine: "nothing sent";
+    readonly nonInteractiveLine: "signup needs an interactive terminal — or join at https://asktilden.com";
+    readonly forgetLine: "local signup state cleared · to leave the list, reply to any email or write hello@asktilden.com";
+    readonly receiptPointer: "npx aibill signup <email>         launch updates · optional · email only";
+    readonly samplePointer: "launch updates: npx aibill signup <email> · optional · email only";
+    readonly initPointer: "launch updates (optional): npx aibill signup <email>";
+    readonly statuslinePointer: "launch updates: npx aibill signup <email> · optional";
+};
+/**
+ * End of the launch-week headline window (the Friday line is true only
+ * through launch day, Fri 2026-08-28). After this instant the ask block
+ * automatically uses the evergreen fallback headline.
+ */
+export declare const signupLaunchWindowEndsAt = "2026-08-29T00:00:00Z";
+/**
+ * The standout ask block: full-width rule (the receipt's own rule
+ * convention), then the headline for the current window, then the skip
+ * footer. Text lines carry the receipt's two-space indent.
+ */
+export declare function signupAskBlockLines(now: Date, width: number): string[];
+/** Same clamp the receipt renderer applies (COLUMNS → tty → 72, 40..120). */
+export declare function signupTerminalWidth(): number;
+export type SignupStatus = "subscribed" | "never" | "deferred";
+export type SignupState = {
+    version: 1;
+    status: SignupStatus;
+    /** Lifetime count of completed explicit skips (double-Enter / declined consent). */
+    askCount: number;
+    /**
+     * Lifetime count of ask OPENINGS (stamped even when the human never
+     * answers). Timeouts consume no skip, so this cap is what ends the asks
+     * for perpetual walk-away users (QA m10).
+     */
+    stampCount?: number;
+    lastAskedAt?: string;
+    /** Stored only after a successful subscribe, only locally. */
+    email?: string;
+};
+export type SignupStateRead = {
+    kind: "fresh";
+} | {
+    kind: "ok";
+    state: SignupState;
+} | {
+    kind: "unreadable";
+};
+export declare function signupStateFilePath(homeDirectory?: string): string;
+export declare function readSignupState(filePath: string): Promise<SignupStateRead>;
+/** Atomic-ish write; returns false instead of throwing so callers fail closed. */
+export declare function writeSignupState(filePath: string, state: SignupState): Promise<boolean>;
+export declare function clearSignupState(filePath: string): Promise<boolean>;
+/** Hard lifetime ceiling on ask openings, decided answer or not (QA m10). */
+export declare const maximumLifetimeAskStamps = 6;
+/**
+ * Whether the ONE ask may run. Fails closed on unreadable state; a
+ * future-dated lastAskedAt (clock moved back) counts as recently asked,
+ * never as a reason to re-ask.
+ */
+export declare function signupAskAllowed(read: SignupStateRead, now: Date): boolean;
+export type SignupAskIo = {
+    /** Resolves the typed line, or undefined when the read timed out / aborted. */
+    question: (query: string, timeoutMs: number) => Promise<string | undefined>;
+    write: (line: string) => void;
+    /** Raw prompt redraw after a nudge line (no newline appended). */
+    writeRaw?: (text: string) => void;
+};
+export declare const signupAskTimeoutMs = 30000;
+export type PreReceiptAskOutcome = {
+    kind: "no_ask";
+} | {
+    kind: "skipped";
+} | {
+    kind: "email";
+    payload: WaitlistPayload;
+    stamped: SignupState;
+};
+export type PreReceiptAskSession = {
+    /** Resolves when the human answered, skipped, timed out, or interrupted. */
+    outcome: Promise<PreReceiptAskOutcome>;
+    /**
+     * Ready-nudge: the pipeline finished while the ask is still open. Prints
+     * one line and re-draws the prompt; the open read's timer is NOT reset.
+     */
+    notifyReceiptReady: () => void;
+};
+/**
+ * Opens the ONE ask, or returns undefined (with zero output) when state
+ * disallows it — subsequent runs stay byte-identical to the fast path.
+ *
+ * Decision ledger (unchanged semantics, earlier placement):
+ * - timeout / Ctrl-C        → no decision: lastAskedAt stamped, NO skip
+ * - Enter, then Enter again → ONE lifetime skip (nudge line between)
+ * - n / never               → never ask again
+ * - typed input             → email path (format + deliverability checks
+ *                             re-prompt without consuming skips)
+ * The consent step (literal payload JSON → y/N → single POST) runs strictly
+ * AFTER the receipt via runSignupConsentAfterReceipt.
+ */
+export declare function openPreReceiptSignupAsk(options: {
+    io: SignupAskIo;
+    stateFilePath: string;
+    now?: () => Date;
+    width?: number;
+    /** Lines printed before the ask block (the terminal wait line). */
+    preambleLines?: readonly string[];
+    dnsResolver?: SignupDnsResolver;
+}): Promise<PreReceiptAskSession | undefined>;
+/**
+ * The consent step, strictly AFTER the receipt has printed: scope line, the
+ * literal payload JSON, a typed y — then ONE POST. Failures never persist,
+ * retry, or queue the typed email.
+ */
+export declare function runSignupConsentAfterReceipt(options: {
+    io: SignupAskIo;
+    stateFilePath: string;
+    payload: WaitlistPayload;
+    stamped: SignupState;
+    fetchImpl?: typeof fetch;
+}): Promise<void>;
+/**
+ * Which argv shapes qualify for the during-scan ask: the real receipt path
+ * only — the default/quickstart command (flag-form included) — and never
+ * sample, drill-downs, JSON, help/version, or any named command (improve,
+ * report, init, …).
+ */
+export declare function qualifiesForPreReceiptSignupAsk(argv: readonly string[]): boolean;
+/**
+ * Concurrency shell: run the evidence pipeline and the open ask together.
+ * The receipt renders only after BOTH resolve; a pipeline error is captured
+ * (never an unhandled rejection) and still waits for the bounded ask, so a
+ * prompt can never hang over a dead pipeline longer than its own timeout.
+ * If the pipeline settles first, the session gets the one ready-nudge.
+ */
+export declare function orchestratePreReceiptAsk<T>(input: {
+    session: PreReceiptAskSession | undefined;
+    runPipeline: () => Promise<T>;
+}): Promise<{
+    pipeline: {
+        ok: true;
+        value: T;
+    } | {
+        ok: false;
+        error: unknown;
+    };
+    outcome: PreReceiptAskOutcome;
+}>;
+export type TerminalPreReceiptAsk = {
+    session: PreReceiptAskSession;
+    /** True when the last read ended without the user pressing Enter. */
+    needsFreshLine: () => boolean;
+    runConsent: (outcome: Extract<PreReceiptAskOutcome, {
+        kind: "email";
+    }>) => Promise<void>;
+    close: () => void;
+};
+/**
+ * Opens the during-scan ask on the real terminal: its own readline with
+ * per-read AbortSignal timeouts. The timeout race can never eat a typed
+ * skip — either the line resolved first (the skip is recorded) or the abort
+ * won and NOTHING is recorded; the wrong decision is unrepresentable.
+ * Ctrl-C cancels only the ask (no skip consumed, state already stamped);
+ * the receipt still renders. Returns undefined — with zero output — when
+ * signup state disallows the ask.
+ */
+export declare function openPreReceiptSignupAskInTerminal(): Promise<TerminalPreReceiptAsk | undefined>;
+//# sourceMappingURL=signup.d.ts.map