fullstackgtm 0.50.0 → 0.50.1

package/dist/cli/plans.js

@@ -17,7 +17,7 @@ import { progressReporter, reportCounts } from "../runReport.js";
 import { claimHostedPlanApply, reconcileHostedPatchPlan, releaseHostedPlanApply, reportHostedPlanLifecycle, uploadHostedPatchPlan } from "../hostedPatchPlan.js";
 import { APPLY_STAGES, composeListeners, createProgressEmitter } from "../progress.js";
 import { connectorFor, isOptionValue, numericOption, option, repeatedOption, selectedRules } from "./shared.js";
-import { colorEnabled, createProgressRenderer, paint, planStatusWord, stylizePlanMarkdown, table, truncateToWidth } from "./ui.js";
+import { box, colorEnabled, createProgressRenderer, createStatusLine, formatDuration, paint, planStatusWord, stylizePlanMarkdown, table, truncateToWidth } from "./ui.js";
 import { unknownSubcommandError } from "./suggest.js";
 function parseValueOverrides(args) {
     const valueOverrides = {};
@@ -29,6 +29,119 @@ function parseValueOverrides(args) {
     }
     return valueOverrides;
 }
+function recordHeadline(operation) {
+    const after = operation.afterValue && typeof operation.afterValue === "object" && !Array.isArray(operation.afterValue)
+        ? operation.afterValue : {};
+    const properties = after.properties && typeof after.properties === "object" && !Array.isArray(after.properties)
+        ? after.properties : {};
+    const first = typeof properties.firstname === "string" ? properties.firstname : "";
+    const last = typeof properties.lastname === "string" ? properties.lastname : "";
+    const company = typeof properties.company === "string" ? properties.company
+        : typeof after.associateCompanyName === "string" ? after.associateCompanyName : undefined;
+    const title = [first, last].filter(Boolean).join(" ") || company || operation.objectId || operation.id;
+    const role = typeof properties.jobtitle === "string" ? properties.jobtitle : undefined;
+    return { title, ...(role ? { subtitle: role } : {}), ...(company ? { company } : {}) };
+}
+function planEffect(stored) {
+    const total = stored.plan.operations.length;
+    const approved = stored.approvedOperationIds.length;
+    if (stored.status === "applied") {
+        const results = stored.runs.at(-1)?.results ?? [];
+        const applied = results.filter((result) => result.status === "applied").length;
+        const skipped = results.filter((result) => result.status === "skipped").length;
+        return `Completed ${applied} operation${applied === 1 ? "" : "s"}${skipped ? `; ${skipped} skipped` : ""}. No further writes will run.`;
+    }
+    if (stored.status === "approved")
+        return `Apply will execute ${approved} selected operation${approved === 1 ? "" : "s"}; ${total - approved} will not run.`;
+    if (stored.status === "rejected")
+        return "Rejected. No provider writes can run.";
+    return `No provider writes can run until operations are approved (0 of ${total} selected).`;
+}
+function printPlanCards(stored, hostedUrl) {
+    const p = paint(colorEnabled(process.stdout));
+    const total = stored.plan.operations.length;
+    const approved = new Set(stored.approvedOperationIds);
+    const width = Math.max(56, Math.min(100, (process.stdout.columns ?? 100) - 4));
+    const fit = (value) => truncateToWidth(value, width);
+    const summary = [
+        fit(stored.plan.title),
+        `Status     ${stored.status.toUpperCase().replaceAll("_", " ")}`,
+        `Selection  ${approved.size} of ${total} operation${total === 1 ? "" : "s"} approved`,
+        `Runs       ${stored.runs.length}`,
+        fit(`Effect     ${planEffect(stored)}`),
+    ];
+    console.log(box(summary, p, "Plan").join("\n"));
+    if (hostedUrl)
+        console.log(`Hosted: ${hostedUrl}`);
+    console.log("\nOperations");
+    let operationIndex = 0;
+    const latestResults = new Map((stored.runs.at(-1)?.results ?? []).map((result) => [result.operationId, result.status]));
+    for (const operation of stored.plan.operations) {
+        const selected = approved.has(operation.id);
+        const resultStatus = latestResults.get(operation.id);
+        const headline = recordHeadline(operation);
+        const action = operation.operation === "create_record"
+            ? `Create ${operation.objectType}${headline.company ? ` and resolve/link ${headline.company}` : ""}`
+            : `${operation.operation.replaceAll("_", " ")} ${operation.objectType}`;
+        const lines = [
+            fit(headline.title),
+            ...(headline.subtitle || headline.company
+                ? [fit([headline.subtitle, headline.company].filter(Boolean).join(" · "))]
+                : []),
+            fit(`Action     ${action}`),
+            `Operation  ${operation.id}`,
+        ];
+        if (operationIndex++ > 0)
+            console.log("");
+        const state = resultStatus === "applied" ? "✓ APPLIED"
+            : resultStatus && selected ? `! ${resultStatus.toUpperCase()}`
+                : selected ? "✓ APPROVED" : stored.status === "applied" ? "○ EXCLUDED" : "○ NOT APPROVED";
+        console.log(box(lines, p, state).join("\n"));
+    }
+    if (stored.status === "approved") {
+        console.log(`\nNext: fullstackgtm apply --plan-id ${stored.plan.id} --provider <hubspot|salesforce>`);
+    }
+    console.log(`Details: fullstackgtm plans show ${stored.plan.id} --verbose`);
+}
+function printApplyCards(run, plan, approvedOperationIds, planIdStored) {
+    const p = paint(colorEnabled(process.stdout));
+    const approved = new Set(approvedOperationIds);
+    const operations = new Map(plan.operations.map((operation) => [operation.id, operation]));
+    const counts = { applied: 0, skipped: 0, failed: 0, conflict: 0 };
+    for (const result of run.results)
+        counts[result.status] += 1;
+    const elapsed = Math.max(0, Date.parse(run.finishedAt) - Date.parse(run.startedAt));
+    const summary = [
+        `Status    ${run.status.toUpperCase()}`,
+        `Provider  ${run.provider}`,
+        `Outcome   ${counts.applied} applied · ${run.results.length - approved.size} excluded · ${counts.failed + counts.conflict} failed/conflicted`,
+        `Duration  ${formatDuration(elapsed)}`,
+        ...(planIdStored ? ["Receipt   recorded locally; hosted reconciliation requested"] : []),
+    ];
+    console.log(box(summary, p, "Apply result").join("\n"));
+    console.log("\nOperations");
+    let index = 0;
+    for (const result of run.results) {
+        const operation = operations.get(result.operationId);
+        if (!operation)
+            continue;
+        const selected = approved.has(result.operationId);
+        const headline = recordHeadline(operation);
+        const state = !selected ? "○ EXCLUDED" : result.status === "applied" ? "✓ APPLIED" : `! ${result.status.toUpperCase()}`;
+        const lines = [
+            headline.title,
+            ...(headline.subtitle || headline.company ? [[headline.subtitle, headline.company].filter(Boolean).join(" · ")] : []),
+            `Operation  ${result.operationId}`,
+            ...(result.detail ? [truncateToWidth(`Result     ${result.detail}`, 100)] : []),
+        ];
+        if (index++ > 0)
+            console.log("");
+        console.log(box(lines, p, state).join("\n"));
+    }
+    if (planIdStored)
+        console.log(`\nInspect: fullstackgtm plans show ${run.planId}`);
+    console.log("Details: rerun with --verbose; machine output: --json");
+}
 function tryLoadAcquireConfig(args) {
     try {
         const path = resolve(process.cwd(), option(args, "--config") ?? ENRICH_CONFIG_FILE_NAME);
@@ -322,9 +435,12 @@ export async function apply(args) {
     if (args.includes("--json")) {
         console.log(JSON.stringify(run, null, 2));
     }
-    else {
+    else if (args.includes("--verbose")) {
         console.log(formatPatchPlanRun(run));
     }
+    else {
+        printApplyCards(run, plan, approvedOperationIds, Boolean(planId && store));
+    }
     if (run.status === "failed")
         process.exitCode = 1;
 }
@@ -422,31 +538,48 @@ export async function plansCommand(args) {
         }
         const p = paint(colorEnabled(process.stdout));
         if (p.enabled) {
-            // Interactive terminals get an aligned table with status color-banding;
-            // the plain per-line format below is unchanged for pipes.
+            const statusCounts = new Map();
+            for (const stored of plans)
+                statusCounts.set(stored.status, (statusCounts.get(stored.status) ?? 0) + 1);
+            const awaiting = plans.filter((stored) => stored.status === "needs_approval").length;
+            const approved = plans.filter((stored) => stored.status === "approved").length;
+            console.log(box([
+                `${plans.length} plan${plans.length === 1 ? "" : "s"} · ${awaiting} awaiting approval · ${approved} ready to apply`,
+                [...statusCounts.entries()].map(([name, count]) => `${name.replaceAll("_", " ")}: ${count}`).join("  ·  "),
+            ], p, "Change queue").join("\n"));
+            console.log("");
+            // Interactive terminals get an aligned decision table; the plain
+            // per-line format below remains stable for pipes and scripts.
             const rows = plans.map((stored) => [
-                stored.plan.id,
                 stored.status,
-                `${stored.approvedOperationIds.length} approved`,
+                stored.plan.title,
+                `${stored.approvedOperationIds.length}/${stored.plan.operations.length} selected`,
                 `${stored.runs.length} run${stored.runs.length === 1 ? "" : "s"}`,
-                stored.plan.summary,
+                stored.plan.id,
             ]);
             // Long summaries would wrap and break the table's alignment. The summary
             // is the LAST column: cap it to what's left of the terminal width after
             // the fixed columns and their two-space gutters (floor of 24 so narrow
             // terminals still show something useful).
             const columns = process.stdout.columns ?? 80;
-            const fixedWidth = [0, 1, 2, 3].reduce((sum, index) => sum + Math.max(...rows.map((row) => row[index].length)), 0) + 2 * 4;
-            const summaryWidth = Math.max(24, columns - fixedWidth);
+            const fixedWidth = [0, 2, 3, 4].reduce((sum, index) => sum + Math.max(...rows.map((row) => row[index].length)), 0) + 2 * 4;
+            const titleWidth = Math.max(24, columns - fixedWidth);
             for (const row of rows)
-                row[4] = truncateToWidth(row[4], summaryWidth);
+                row[1] = truncateToWidth(row[1], titleWidth);
             const statusPainter = (cell) => {
                 const painted = planStatusWord(cell.trimEnd(), p);
                 return painted + cell.slice(cell.trimEnd().length);
             };
-            for (const line of table(rows, [null, statusPainter, p.dim, p.dim, null])) {
+            for (const line of table(rows, [statusPainter, null, p.dim, p.dim, p.dim])) {
                 console.log(line);
             }
+            const next = plans.find((stored) => stored.status === "approved") ?? plans.find((stored) => stored.status === "needs_approval");
+            if (next) {
+                const command = next.status === "approved"
+                    ? `fullstackgtm apply --plan-id ${next.plan.id} --provider <name>`
+                    : `fullstackgtm plans show ${next.plan.id}`;
+                console.log(`\nNext: ${command}`);
+            }
             return;
         }
         for (const stored of plans) {
@@ -473,16 +606,11 @@ export async function plansCommand(args) {
             console.log(JSON.stringify(stored, null, 2));
             return;
         }
-        const showPaint = paint(colorEnabled(process.stdout));
-        console.log(`Status: ${planStatusWord(stored.status, showPaint)}`);
-        console.log(`Approved operations: ${stored.approvedOperationIds.join(", ") || "none"}`);
-        console.log(`Runs: ${stored.runs.length}`);
         const mirror = await uploadHostedPatchPlan(stored);
-        if (mirror.status === "saved")
-            console.log(`Hosted review: ${mirror.state.url}`);
-        else if (mirror.status === "unavailable" || mirror.status === "conflict")
-            console.log(`Hosted review: sync pending (${mirror.reason})`);
-        if (stored.applyAttempts?.length) {
+        printPlanCards(stored, mirror.status === "saved" ? mirror.state.url : undefined);
+        if (mirror.status === "unavailable" || mirror.status === "conflict")
+            console.log(`Hosted sync pending: ${mirror.reason}`);
+        if (rest.includes("--verbose") && stored.applyAttempts?.length) {
             console.log("Apply attempts:");
             for (const attempt of stored.applyAttempts) {
                 console.log(`  ${attempt.id}  ${attempt.status}  ${attempt.provider} via ${attempt.source}  ${attempt.claimedAt}`);
@@ -490,8 +618,11 @@ export async function plansCommand(args) {
                     console.log(`    ${attempt.note}`);
             }
         }
-        console.log("");
-        console.log(stylizePlanMarkdown(patchPlanToMarkdown(stored.plan), showPaint));
+        if (rest.includes("--verbose")) {
+            const showPaint = paint(colorEnabled(process.stdout));
+            console.log("\nFull plan document\n");
+            console.log(stylizePlanMarkdown(patchPlanToMarkdown(stored.plan), showPaint));
+        }
         return;
     }
     if (subcommand === "approve") {
@@ -578,19 +709,39 @@ export async function plansCommand(args) {
     if (subcommand === "sync") {
         const plans = await store.list();
         let updated = 0;
+        let completed = 0;
         const warnings = [];
-        for (const stored of plans) {
-            const result = await reconcileHostedPatchPlan(store, stored);
-            if (result.status === "updated")
-                updated += 1;
-            else if (result.status === "conflict" || result.status === "unavailable")
-                warnings.push(`${stored.plan.id}: ${result.reason}`);
-            if (stored.status === "applied") {
-                const hostedClaimId = [...(stored.applyAttempts ?? [])].reverse().find((attempt) => attempt.hostedClaimId)?.hostedClaimId;
-                const pushed = await reportHostedPlanLifecycle(stored, { claimId: hostedClaimId });
-                if (pushed.status === "conflict" || pushed.status === "unavailable")
-                    warnings.push(`${stored.plan.id} receipt: ${pushed.reason}`);
+        const status = createStatusLine();
+        status.set(`Synchronizing plan replicas 0/${plans.length}`);
+        // A workspace can accumulate hundreds of local plans. Reconcile with a
+        // small worker pool so one network round-trip per plan does not turn into
+        // a minutes-long silent serial wait, without stampeding the hosted API.
+        let next = 0;
+        const worker = async () => {
+            while (next < plans.length) {
+                const stored = plans[next++];
+                const result = await reconcileHostedPatchPlan(store, stored);
+                if (result.status === "updated")
+                    updated += 1;
+                else if (result.status === "conflict" || result.status === "unavailable")
+                    warnings.push(`${stored.plan.id}: ${result.reason}`);
+                // Historical local-only plans have no remote row to receive a receipt.
+                // `backfill runs` is the explicit import path for that old history.
+                if (stored.status === "applied" && result.status !== "missing" && (stored.applyAttempts?.length ?? 0) > 0) {
+                    const hostedClaimId = [...(stored.applyAttempts ?? [])].reverse().find((attempt) => attempt.hostedClaimId)?.hostedClaimId;
+                    const pushed = await reportHostedPlanLifecycle(stored, { claimId: hostedClaimId });
+                    if (pushed.status === "conflict" || pushed.status === "unavailable")
+                        warnings.push(`${stored.plan.id} receipt: ${pushed.reason}`);
+                }
+                completed += 1;
+                status.set(`Synchronizing plan replicas ${completed}/${plans.length}`);
             }
+        };
+        try {
+            await Promise.all(Array.from({ length: Math.min(6, plans.length) }, () => worker()));
+        }
+        finally {
+            status.done();
         }
         console.log(`Plan replicas synchronized: ${updated} updated, ${plans.length - updated} unchanged.`);
         for (const warning of warnings)

package/dist/cli/schedule.js

@@ -8,6 +8,7 @@ import { computeMissedFirings, createFileScheduleRunStore, createFileScheduleSto
 import { runCli } from "../cli.js";
 import { isOptionValue, numericOption, option } from "./shared.js";
 import { unknownSubcommandError } from "./suggest.js";
+import { colorEnabled, paint, table } from "./ui.js";
 /**
  * The schedule layer: declarative cadences for read/plan-side commands,
  * materialized through a provider (MVP: the user crontab), with an
@@ -113,10 +114,19 @@ trigger: manual. status shows next firing and surfaces missed firings
             console.log('No schedules. Add one with `fullstackgtm schedule add "<command>" --cron "<expr>"`.');
             return;
         }
-        for (const entry of withNext) {
-            console.log(`${entry.id}  ${entry.enabled ? "on " : "off"}  ${entry.cron.padEnd(14)} next ${entry.nextFiring ?? "—"}  ${entry.label}: ${entry.argv.join(" ")}`);
-        }
-        console.log("\nEntries are declarative — `schedule install` materializes enabled ones into the crontab.");
+        const p = paint(colorEnabled(process.stdout));
+        const verbose = rest.includes("--verbose");
+        const rows = [
+            ["STATE", "SCHEDULE", "NEXT", ...(verbose ? ["CRON", "COMMAND"] : [])],
+            ...withNext.map((entry) => [
+                entry.enabled ? "on" : "off",
+                `${entry.label} · ${entry.id}`,
+                entry.nextFiring ?? "—",
+                ...(verbose ? [entry.cron, entry.argv.join(" ")] : []),
+            ]),
+        ];
+        console.log(table(rows, [p.dim, null, null]).join("\n"));
+        console.log("\nDeclarative only · run `fullstackgtm schedule install` after changes.");
         return;
     }
     if (subcommand === "remove") {
@@ -251,20 +261,21 @@ trigger: manual. status shows next firing and surfaces missed firings
             const last = entry.lastRun;
             const streak = entry.streak;
             const missed = entry.missedFirings;
-            console.log(`${entry.id}  ${entry.enabled ? "on " : "off"}  ${entry.cron}  ${entry.label}: ${entry.argv.join(" ")}`);
-            console.log(`  next: ${entry.nextFiring ?? "— (disabled)"}`);
+            const verbose = rest.includes("--verbose");
+            const outcome = !last ? "never run" : last.exitCode === 0 ? (last.noopReason ? `no-op · ${last.noopReason}` : "healthy") : `failed · exit ${last.exitCode}`;
+            console.log(`${entry.enabled ? "●" : "○"} ${entry.label} · ${outcome}`);
+            console.log(`  ${entry.id} · next ${entry.nextFiring ?? "— (disabled)"}`);
+            if (verbose)
+                console.log(`  ${entry.argv.join(" ")} · cron ${entry.cron}`);
             if (last) {
                 const artifacts = [
                     ...last.artifacts.planIds.map((planId) => `plan ${planId}`),
                     ...last.artifacts.runLabels.map((runLabel) => `run ${runLabel}`),
                 ];
-                console.log(`  last: ${last.firedAt} (${last.trigger}) exit ${last.exitCode}` +
-                    (last.noopReason ? ` — no-op: ${last.noopReason}` : "") +
-                    (artifacts.length ? ` — ${artifacts.join(", ")}` : ""));
-                console.log(`  streak: ${streak.length} ${streak.outcome}(s)`);
+                console.log(`  last ${last.firedAt} · ${last.trigger} · ${streak.length} ${streak.outcome}${streak.length === 1 ? "" : "s"}${artifacts.length ? ` · ${artifacts.join(", ")}` : ""}`);
             }
             else {
-                console.log("  last: never fired");
+                console.log("  last never fired");
             }
             if (missed.length > 0) {
                 console.log(`  missed: ${missed.length}${entry.missedFiringsCapped ? "+" : ""} expected firing(s) with no run record ` +

package/dist/cli/signals.js

@@ -22,6 +22,20 @@ function resolveSignalsConfig(args) {
         return loadSignalsConfig(local);
     return DEFAULT_SIGNALS_CONFIG;
 }
+function concise(value, max = 72) {
+    const oneLine = value.replace(/\s+/g, " ").trim();
+    return oneLine.length <= max ? oneLine : `${oneLine.slice(0, max - 1)}…`;
+}
+function renderSignals(signals) {
+    if (signals.length === 0)
+        return "No signals matched.";
+    const lines = [`Fresh signals (${signals.length})`, ""];
+    for (const signal of signals) {
+        lines.push(`${signal.weight.toFixed(2).padStart(5)}  ${signal.accountDomain}  · ${signal.bucket}`);
+        lines.push(`       ${concise(signal.trigger)}`);
+    }
+    return lines.join("\n");
+}
 /**
  * Resolve the watchlist of accounts to scan. Sources, in precedence order:
  *  - a --watchlist file (JSON array of {domain, boards?} or bare domain strings),
@@ -211,7 +225,7 @@ from the credential ladder, never argv; --connector-opt carries non-secret knobs
         const { fresh, deduped } = dedupeSignals(candidates, priorSignals, config.dedupWindowDays, now);
         const ranked = [...fresh].sort((a, b) => b.weight - a.weight || a.accountDomain.localeCompare(b.accountDomain));
         // Ranked fresh signals to stdout; guidance to stderr.
-        console.log(JSON.stringify(ranked, null, 2));
+        console.log(rest.includes("--json") || rest.includes("--verbose") ? JSON.stringify(ranked, null, 2) : renderSignals(ranked));
         console.error(`Fetched ${fetched} candidate signal(s); ${fresh.length} fresh, ${deduped.length} deduped ` +
             `(window ${config.dedupWindowDays}d). NO plan emitted — signals are read-only re: CRM.`);
         const save = saveRequested(rest);
@@ -259,7 +273,7 @@ from the credential ladder, never argv; --connector-opt carries non-secret knobs
             return true;
         });
         const ranked = filtered.sort((a, b) => b.weight - a.weight || a.accountDomain.localeCompare(b.accountDomain));
-        console.log(JSON.stringify(ranked, null, 2));
+        console.log(rest.includes("--json") || rest.includes("--verbose") ? JSON.stringify(ranked, null, 2) : renderSignals(ranked));
         console.error(`${ranked.length} signal(s)${unjudgedOnly ? " (unjudged)" : ""}.`);
         return;
     }
@@ -286,7 +300,12 @@ from the credential ladder, never argv; --connector-opt carries non-secret knobs
         const outcomes = await store.listOutcomes();
         const signalsById = new Map((await store.allSignals()).map((s) => [s.id, s]));
         const weights = computeWeights(config, outcomes, signalsById);
-        console.log(JSON.stringify(weights, null, 2));
+        if (rest.includes("--json") || rest.includes("--verbose")) {
+            console.log(JSON.stringify(weights, null, 2));
+        }
+        else {
+            console.log(["Learned signal weights", "", ...SIGNAL_BUCKETS.map((bucket) => `${bucket.padEnd(10)} ${weights[bucket].toFixed(4)}`)].join("\n"));
+        }
         if (rest.includes("--explain")) {
             // Per-bucket config default vs learned + booked/total over credited signals.
             const booked = new Map();

package/dist/cli/tam.js

@@ -253,9 +253,18 @@ RevOps universe, with real names. --source explorium is a firmographic count onl
             writeFileSync(resolve(process.cwd(), out), md);
             console.log(`Wrote ${out}.`);
         }
-        else {
+        else if (rest.includes("--verbose")) {
             console.log(md);
         }
+        else if (timeline.length > 0) {
+            console.log(coverageToText(model, timeline.at(-1), eta));
+            console.log("\nUse --verbose for assumptions, cross-checks, and the full coverage history.");
+        }
+        else {
+            console.log(`TAM "${model.name}" · ${model.universe.accounts.toLocaleString()} accounts · ${model.universe.contacts.toLocaleString()} buyers · $${Math.round(model.tamUsd).toLocaleString()}`);
+            console.log(`ICP ${model.icpName} · ${model.acv.basis}-basis ACV $${Math.round(model.acv.valueUsd).toLocaleString()} (${model.acv.source})`);
+            console.log("No coverage readings yet. Run `fullstackgtm tam status --save` to establish one; use --verbose for the full assumptions report.");
+        }
         return;
     }
     if (sub === "populate") {

package/dist/cli/ui.js

@@ -262,8 +262,12 @@ export function createChecklist(items, stream = process.stderr, env = process.en
             const label = entry.state === "pending" ? p.dim(item.label.padEnd(labelWidth)) : item.label.padEnd(labelWidth);
             return `  ${glyph} ${label}${note}`;
         });
-        const up = painted > 0 ? `\u001b[${painted}A` : "";
-        stream.write(`${up}${lines.map((line) => `\u001b[2K${line}`).join("\n")}\n`);
+        // Keep the cursor on the board's last row while it is live. A trailing
+        // newline on every repaint can scroll the old top row into permanent
+        // history when the board sits at the bottom of the terminal, producing
+        // apparent duplicate/errored frames in terminal captures.
+        const up = painted > 1 ? `\u001b[${painted - 1}A` : "";
+        stream.write(`${up}${lines.map((line) => `\u001b[2K${line}`).join("\n")}`);
         painted = lines.length;
     };
     const start = () => {
@@ -292,14 +296,18 @@ export function createChecklist(items, stream = process.stderr, env = process.en
             timer = null;
             if (options.persist) {
                 // The caller's final state update already painted the completed board.
-                // Freeze that frame in scrollback; repainting here can leave both the
-                // last live frame and the final frame visible in some terminals.
+                // Advance exactly once so subsequent output begins below it.
+                if (painted > 0)
+                    stream.write("\n");
                 painted = 0;
                 return;
             }
             if (painted > 0) {
-                // Erase the board: cursor up over every painted line, clear each.
-                stream.write(`\u001b[${painted}A${"\u001b[2K\n".repeat(painted)}\u001b[${painted}A`);
+                // Erase in place without linefeeds, which could themselves scroll.
+                const up = painted > 1 ? `\u001b[${painted - 1}A` : "";
+                const clear = Array.from({ length: painted }, (_, index) => `\u001b[2K${index < painted - 1 ? "\u001b[1B" : ""}`).join("");
+                const restore = painted > 1 ? `\u001b[${painted - 1}A` : "";
+                stream.write(`${up}${clear}${restore}`);
                 painted = 0;
             }
         },

package/dist/connectors/hubspot.d.ts

@@ -18,6 +18,10 @@ export type HubspotConnectorOptions = {
      * alongside the legacy `onProgress` callback; both are presentation-only.
      */
     progress?: ProgressEmitter;
+    /** Maximum retries for HubSpot 429/5xx responses (default 5). */
+    maxRetries?: number;
+    /** Injectable delay for deterministic retry tests. */
+    sleep?: (milliseconds: number) => Promise<void>;
 };
 /**
  * Reference connector for HubSpot.

package/dist/connectors/hubspot.js

@@ -30,6 +30,8 @@ const PULL_STAGE_BY_TYPE = {
 export function createHubspotConnector(options) {
     const baseUrl = (options.apiBaseUrl ?? DEFAULT_API_BASE_URL).replace(/\/$/, "");
     const fetchImpl = options.fetchImpl ?? fetch;
+    const maxRetries = options.maxRetries ?? 5;
+    const sleep = options.sleep ?? ((milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)));
     const mappings = options.fieldMappings;
     // create:<Name> dedup within one connector lifetime (one apply run): the
     // search API is eventually consistent, so a just-created company is
@@ -66,28 +68,44 @@ export function createHubspotConnector(options) {
         emitter.items(fetched);
     };
     async function request(path, init = {}) {
-        const token = await options.getAccessToken();
         let response;
-        try {
-            response = await fetchImpl(`${baseUrl}${path}`, {
-                ...init,
-                headers: {
-                    Authorization: `Bearer ${token}`,
-                    "Content-Type": "application/json",
-                    ...(init.headers ?? {}),
-                },
-            });
-        }
-        catch (error) {
-            const cause = error instanceof Error && error.cause instanceof Error ? `: ${error.cause.message}` : "";
-            throw new Error(`Cannot reach HubSpot at ${baseUrl}${cause}. Check network access.`);
-        }
-        if (!response.ok) {
+        for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
+            const token = await options.getAccessToken();
+            try {
+                response = await fetchImpl(`${baseUrl}${path}`, {
+                    ...init,
+                    headers: {
+                        Authorization: `Bearer ${token}`,
+                        "Content-Type": "application/json",
+                        ...(init.headers ?? {}),
+                    },
+                });
+            }
+            catch (error) {
+                const cause = error instanceof Error && error.cause instanceof Error ? `: ${error.cause.message}` : "";
+                throw new Error(`Cannot reach HubSpot at ${baseUrl}${cause}. Check network access.`);
+            }
+            const retryable = response.status === 429 || response.status >= 500;
+            if (!retryable || attempt === maxRetries)
+                break;
+            await response.text().catch(() => undefined);
+            const retryAfter = response.headers.get("Retry-After");
+            const seconds = retryAfter === null ? NaN : Number(retryAfter);
+            const dateDelay = retryAfter && !Number.isFinite(seconds) ? Date.parse(retryAfter) - Date.now() : NaN;
+            const delayMs = Math.min(30_000, Math.max(0, Number.isFinite(seconds) ? seconds * 1_000 : Number.isFinite(dateDelay) ? dateDelay : 1_000 * 2 ** attempt));
+            const reason = response.status === 429 ? "rate limited" : `temporarily unavailable (${response.status})`;
+            options.progress?.note(`HubSpot ${reason}; retrying in ${Math.ceil(delayMs / 1_000)}s (${attempt + 1}/${maxRetries})`);
+            await sleep(delayMs);
+        }
+        if (!response || !response.ok) {
             // Status line only — HubSpot 4xx bodies echo submitted property values
             // (contact emails, company domains) and the request payload, and these
             // errors are persisted into scheduled-run records. Never interpolate it.
-            await response.text().catch(() => undefined);
-            throw new Error(`HubSpot API error ${response.status}. Check the token scopes and request.`);
+            await response?.text().catch(() => undefined);
+            if (response?.status === 429) {
+                throw new Error(`HubSpot rate limit (429) persisted after ${maxRetries} retries. Wait for the portal limit to reset, then retry; no CRM writes were made.`);
+            }
+            throw new Error(`HubSpot API error ${response?.status ?? "unknown"}. Check the token scopes and request.`);
         }
         // DELETE and some association writes return 204 with an empty body.
         const text = await response.text();

package/dist/hostedPatchPlan.js

@@ -191,7 +191,12 @@ export async function reportHostedPlanLifecycle(stored, options = {}) {
         return { status: "unpaired" };
     const status = stored.status === "applied" ? "applied" : stored.status === "rejected" ? "rejected" : "approved";
     const runRecord = status === "applied" ? stored.runs.at(-1) : undefined;
-    const operationReceipts = runRecord?.results.map((result) => ({
+    // The hosted terminal transition is authority-bound to the exact approved
+    // subset. Local runs also record excluded operations as `skipped` for a
+    // complete human audit trail; those are not execution receipts and must not
+    // be echoed as though they were authorized provider work.
+    const approved = new Set(stored.approvedOperationIds);
+    const operationReceipts = runRecord?.results.filter((result) => approved.has(result.operationId)).map((result) => ({
         packageOpId: result.operationId,
         status: result.status,
         ...(result.detail ? { error: result.detail.slice(0, 1000) } : {}),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fullstackgtm",
-  "version": "0.50.0",
+  "version": "0.50.1",
   "description": "Open-source agentic GTM ops framework: canonical GTM data model, pluggable deterministic audits, reviewable dry-run patch plans, approval-gated write-back with conflict detection, and cross-system entity resolution. HubSpot, Salesforce, and Stripe connectors included.",
   "license": "Apache-2.0",
   "author": "Full Stack GTM LLC <ryan@fullstackgtm.com> (https://fullstackgtm.com)",

package/src/cli/audit.ts

@@ -13,6 +13,7 @@ import { reportCounts, reportCrm, reportFindings } from "../runReport.ts";
 import type { AuditFindingSeverity, CanonicalGtmSnapshot, PatchPlan } from "../types.ts";
 import { connectorFor, numericOption, option, readSnapshot, saveRequested, selectedRules } from "./shared.ts";
 import { colorEnabled, createChecklist, formatCount, paint, scoreColor, sparkline, stylizePlanMarkdown, table, type Paint } from "./ui.ts";
+import { compactPlan, verbosePlanRequested } from "./planOutput.ts";
 
 
 const SEVERITY_RANK: Record<AuditFindingSeverity, number> = {
@@ -258,13 +259,16 @@ export async function audit(args: string[]) {
   }
   if (args.includes("--json")) {
     console.log(JSON.stringify(plan, null, 2));
+  } else if (!verbosePlanRequested(args)) {
+    console.log(compactPlan(plan, { saved: saveRequested(args) }));
+    console.error(`\n${auditNextStep(args, plan)}`);
   } else {
     // Default to the summary view (rule table + counts); the full per-operation
     // dump is opt-in via --full or, for a deliverable, `report`. (dx-punch-list #3)
     // Interactive terminals get the styled rendering; piped output is unchanged.
     console.log(
       stylizePlanMarkdown(
-        patchPlanToMarkdown(plan, { summary: !args.includes("--full") }),
+        patchPlanToMarkdown(plan, { summary: false }),
         paint(colorEnabled(process.stdout)),
       ),
     );

package/src/cli/auth.ts

@@ -638,6 +638,30 @@ export async function doctorCommand(args: string[]) {
     workspace.auditCount === 0
       ? p.dim("no saved audits yet (fullstackgtm audit --provider <name> --save starts the timeline)")
       : `${scoreColor(workspace.healthScore ?? 0, p)}/100${delta} — ${workspace.auditCount} audit(s) saved, last ${workspace.lastAuditAt}${healthSparkline(workspace.profile, p.enabled)}`;
+  const connectedProviders = Object.entries(report.providers).filter(([, provider]) => provider.source !== "none");
+  const blockers = [
+    ...(!report.node.ok ? [`Node v${report.node.version} is unsupported; install ${report.node.required}.`] : []),
+    ...(connectedProviders.length === 0 ? ["No CRM connected."] : []),
+    ...(workspace.pendingPlans.length > 0 ? [`${workspace.pendingPlans.length} plan${workspace.pendingPlans.length === 1 ? "" : "s"} awaiting approval.`] : []),
+  ];
+  if (!args.includes("--verbose")) {
+    const ready = report.node.ok && connectedProviders.length > 0;
+    const compact = [
+      `${ready ? p.green("Ready") : p.yellow("Setup needed")} · ${report.package.name} ${report.package.version} · profile ${report.profile}`,
+      `CRM       ${connectedProviders.length > 0 ? connectedProviders.map(([name]) => name).join(", ") : "not connected"}`,
+      `Health    ${healthLine}`,
+      `Plans     ${workspace.pendingPlans.length === 0 ? "none awaiting approval" : `${workspace.pendingPlans.length} awaiting approval · ${workspace.pendingPlans[0].id}`}`,
+      ...(blockers.length > 0 ? ["", "Attention", ...blockers.map((blocker) => `  ${blocker}`)] : []),
+      "",
+      "Next",
+      ...nextSteps.map((step) => `  ${step}`),
+      "",
+      "Run `fullstackgtm doctor --verbose` for credential paths and optional tooling checks.",
+    ];
+    console.log(p.enabled ? box(compact, p, "Workspace readiness").join("\n") : compact.join("\n"));
+    if (!report.node.ok) process.exitCode = 1;
+    return;
+  }
   const lines = [
     `Package:    ${p.bold(`${report.package.name} ${report.package.version}`)}`,
     `Node:       v${report.node.version} (${report.node.required} required) ${mark(report.node.ok)}`,