fullstackgtm 0.50.0 → 0.51.0

package/dist/cli/help.js

@@ -16,13 +16,16 @@ Usage:
   fullstackgtm login salesforce --instance-url <url> [--no-validate]  advanced: paste access token
   fullstackgtm login stripe [--no-validate]
   fullstackgtm login anthropic | openai        store an LLM API key for call parse/score
-  fullstackgtm login apollo                    store an Apollo API key for enrich pulls\n  fullstackgtm login pipe0 | explorium | theirstack  store a discovery-provider key (theirstack = technographic TAM)\n  fullstackgtm login heyreach                  store a HeyReach key for enrich acquire --source linkedin\n  fullstackgtm logout <hubspot|salesforce|stripe|anthropic|openai|apollo|pipe0|explorium|heyreach|broker>
+  fullstackgtm login apollo | clay             store a data-provider Public API key
+  fullstackgtm login pipe0 | explorium | theirstack  store a discovery-provider key (theirstack = technographic TAM)
+  fullstackgtm login heyreach                  store a HeyReach key for enrich acquire --source linkedin
+  fullstackgtm logout <hubspot|salesforce|stripe|anthropic|openai|apollo|clay|pipe0|explorium|heyreach|broker>
 
   Secrets (tokens, client secrets) are NEVER passed as flags — they leak via
   the process list and shell history. Pipe them on stdin or enter them at the
   interactive prompt:
     echo "$HUBSPOT_TOKEN" | fullstackgtm login hubspot --private-token
-  fullstackgtm init [--source pipe0|explorium|linkedin] [--provider hubspot|salesforce] [--out <dir>] [--force]
+  fullstackgtm init [--source pipe0|explorium|clay|linkedin] [--provider hubspot|salesforce] [--out <dir>] [--force]
                                                cold start: scaffold icp.json + enrich.config.json + a
                                                PLAYBOOK wired for this workspace (the CLI ships primitives,
                                                your agent is the orchestrator — see docs/recipes.md)
@@ -72,7 +75,7 @@ Usage:
   fullstackgtm tam estimate [--name <n>] [--icp <path>] (--accounts <n> | --source theirstack|explorium) (--acv <annual-usd> | --acv-from-crm --deal-period monthly|quarterly|annual) [--acv-basis account|buyer] [--buyers-per-account <n>] [--cross-checks <file.json>] [source options] [--json]
   fullstackgtm tam status [--name <n>] <source options> [--save] [--json]
   fullstackgtm tam report [--name <n>] [--out <path>]
-  fullstackgtm tam populate [--name <n>] --cron "<expr>" [--source pipe0|explorium|linkedin] [--provider hubspot|salesforce] [--label <l>]
+  fullstackgtm tam populate [--name <n>] --cron "<expr>" [--source pipe0|explorium|clay|linkedin] [--provider hubspot|salesforce] [--label <l>]
                                                size the reachable market FROM the ICP (a real account count ×
                                                ACV; buyers/account = the contact population target), then fill
                                                it: populate schedules plan-only enrich acquire --save (apply
@@ -176,11 +179,11 @@ Usage:
   fullstackgtm suggest --plan-id <id> | --plan <path>  [source options] [--json] [--out <path>]
                                                derive values for requires_human_* placeholders
                                                from snapshot evidence, with confidence + reasons
-  fullstackgtm plans list [--status <s>] | show <id> | sync | reject <id>
+  fullstackgtm plans list [--status <s>] | show <id> [--verbose] | sync | reject <id>
   fullstackgtm plans approve <id> --operations <ids|all> [--value <opId>=<v>]
   fullstackgtm plans approve <id> --values-from <suggestions.json> [--min-confidence high|low] [--include-creates]
   fullstackgtm plans recover <id> --acknowledge-uncertain-writes
-  fullstackgtm apply --plan-id <id> --provider <name>
+  fullstackgtm apply --plan-id <id> --provider <name> [--verbose|--json]
   fullstackgtm apply --plan-id <id> --channel outbox          (render approved openers; transmits nothing)
   fullstackgtm apply --plan <path> --provider <name> --approve <ids|all> [options]
   fullstackgtm audit-log export [--out <path>] | verify --in <path>   tamper-evident apply-run record
@@ -276,7 +279,7 @@ export const HELP = {
         summary: "scaffold a workspace (icp.json + enrich.config.json + PLAYBOOK)",
         phase: "Setup",
         synopsis: [
-            "fullstackgtm init [--source pipe0|explorium|linkedin] [--provider hubspot|salesforce] [--out <dir>] [--force]",
+            "fullstackgtm init [--source pipe0|explorium|clay|linkedin] [--provider hubspot|salesforce] [--out <dir>] [--force]",
         ],
         detail: "Cold start: writes a starter ICP, an acquire-ready enrich.config.json (with a visible assign seam so leads are never ownerless), and a PLAYBOOK wired with the cold-start + outbound-loop recipes for this workspace. Pure file-writer — no network, keeps existing files unless --force. The CLI ships governed primitives; your coding agent is the orchestrator (see docs/recipes.md).",
         seeAlso: ["icp", "enrich", "signals"],
@@ -289,7 +292,7 @@ export const HELP = {
             "fullstackgtm login hubspot | salesforce          hosted browser OAuth (default)",
             "fullstackgtm login --via <hosted url>            pair with a team deployment",
             "fullstackgtm login stripe",
-            "fullstackgtm login anthropic | openai | apollo",
+            "fullstackgtm login anthropic | openai | apollo | clay",
         ],
         detail: "HubSpot/Salesforce use hosted browser OAuth by default; BYO app/token paths are advanced. Secrets are NEVER passed as flags — pipe on stdin or enter at the prompt: `echo \"$TOKEN\" | fullstackgtm login hubspot --private-token`.",
         seeAlso: ["doctor", "logout", "profiles"],
@@ -297,7 +300,7 @@ export const HELP = {
     logout: {
         summary: "remove stored credentials for a provider",
         phase: "Setup",
-        synopsis: ["fullstackgtm logout <hubspot|salesforce|stripe|anthropic|openai|apollo|pipe0|explorium|broker>"],
+        synopsis: ["fullstackgtm logout <hubspot|salesforce|stripe|anthropic|openai|apollo|clay|pipe0|explorium|broker>"],
         seeAlso: ["login", "doctor"],
     },
     doctor: {
@@ -502,7 +505,7 @@ export const HELP = {
         summary: "replicated plan lifecycle: list / show / sync / approve / reject",
         phase: "Govern",
         synopsis: [
-            "fullstackgtm plans list [--status <s>] | show <id> | sync | reject <id>",
+            "fullstackgtm plans list [--status <s>] | show <id> [--verbose] | sync | reject <id>",
             "fullstackgtm plans approve <id> --operations <ids|all> [--value <opId>=<v>]",
             "fullstackgtm plans approve <id> --values-from <suggestions.json> [--min-confidence high|low]",
             "fullstackgtm plans recover <id> --acknowledge-uncertain-writes",
@@ -514,11 +517,11 @@ export const HELP = {
         summary: "write ONLY explicitly approved operations to a provider",
         phase: "Govern / Verify",
         synopsis: [
-            "fullstackgtm apply --plan-id <id> --provider <name>",
+            "fullstackgtm apply --plan-id <id> --provider <name> [--verbose|--json]",
             "fullstackgtm apply --plan-id <id> --channel outbox   (render approved drafted openers to the outbox; transmits nothing)",
             "fullstackgtm apply --plan <path> --provider <name> --approve <ids|all> [--value <opId>=<v>]",
         ],
-        detail: "The CLI CRM-write verb. Writes only operations approved locally or imported from the shared hosted replica, with an online execution claim when available, stable operation ids, compare-and-set, resolve-before-create, and readback. Hosted may execute the same synchronized plan when it has a compatible CRM connection; its exact operation receipts are imported on the next CLI check-in. Never writes requires_human_* placeholders without a --value override.",
+        detail: "The CLI CRM-write verb. Writes only operations approved locally or imported from the shared hosted replica, with an online execution claim when available, stable operation ids, compare-and-set, resolve-before-create, and readback. Default output is a compact outcome card; --verbose prints the full run document and --json preserves structured output. Hosted may execute the same synchronized plan when it has a compatible CRM connection; its exact operation receipts are imported on the next CLI check-in. Never writes requires_human_* placeholders without a --value override.",
         seeAlso: ["plans", "suggest", "audit-log"],
     },
     "audit-log": {
@@ -597,7 +600,7 @@ export const BESPOKE_HELP = ["init", "call", "market", "tam", "enrich", "schedul
 export const GLOBAL_FLAGS = ["--help", "--full"];
 export const GLOBAL_SHORT_FLAGS = ["-h"];
 export const SOURCE_FLAGS = ["--provider", "--token-env", "--input", "--demo", "--sample", "--seed", "--today"];
-export const AUDIT_FLAGS = ["--config", "--allow-plugins", "--no-plugins", "--rules", "--stale-days", "--fail-on", "--save", "--dry-run", "--json", "--out", "--full"];
+export const AUDIT_FLAGS = ["--config", "--allow-plugins", "--no-plugins", "--rules", "--stale-days", "--fail-on", "--save", "--dry-run", "--json", "--out", "--full", "--verbose"];
 // Complete per-command flag registry used by runCli's fail-closed flag
 // validation. Keep this next to HELP so focused help, machine capabilities,
 // and the parser safety gate have one command inventory to reconcile against.
@@ -605,7 +608,7 @@ export const COMMAND_FLAGS = {
     init: ["--source", "--provider", "--out", "--force"],
     login: ["--via", "--hosted", "--private-token", "--token", "--key", "--api-key", "--client-id", "--client-secret", "--scopes", "--port", "--oauth", "--device", "--instance-url", "--login-url", "--no-validate"],
     logout: [],
-    doctor: ["--json"],
+    doctor: ["--verbose", "--json"],
     capabilities: ["--json"],
     "robot-docs": [],
     profiles: ["--json"],
@@ -619,24 +622,24 @@ export const COMMAND_FLAGS = {
     hierarchy: [...SOURCE_FLAGS, "--json", "--out"],
     relationships: [...SOURCE_FLAGS, "--account-id", "--domain", "--json", "--out"],
     route: [...SOURCE_FLAGS, "--match", "--no-inherit-owner", "--reassign-owned", "--policy", "--reason", "--max-operations", "--save", "--dry-run", "--json", "--out"],
-    fix: [...SOURCE_FLAGS, "--config", "--allow-plugins", "--no-plugins", "--rule", "--provider", "--min-confidence", "--include-creates", "--yes", "--confirm", "--dry-run"],
-    "bulk-update": [...SOURCE_FLAGS, "--where", "--set", "--guard", "--require", "--create-task", "--archive", "--force-archive-duplicates", "--reason", "--max-operations", "--save", "--dry-run", "--json", "--out"],
-    dedupe: [...SOURCE_FLAGS, "--key", "--keep", "--reason", "--max-operations", "--save", "--dry-run", "--json", "--out"],
-    reassign: [...SOURCE_FLAGS, "--from", "--assign-unowned", "--to", "--objects", "--where", "--except-deal-stage", "--include-closed-deals", "--reason", "--max-operations", "--save", "--dry-run", "--json", "--out"],
-    backfill: [...SOURCE_FLAGS, "--since", "--pipeline", "--match-property", "--skip-unmatched", "--save", "--dry-run", "--json"],
-    enrich: [...SOURCE_FLAGS, "--config", "--source", "--icp", "--input", "--provider", "--list", "--stale-days", "--assign-owner", "--objects", "--max", "--scan-limit", "--staged-run", "--run-label", "--label", "--runs", "--save", "--dry-run", "--json", "--out"],
-    call: [...SOURCE_FLAGS, "--transcript", "--title", "--source", "--model", "--deterministic", "--heuristics", "--llm", "--json", "--ndjson", "--out", "--call", "--call-type", "--rubric", "--list", "--list-rubrics", "--attendees", "--domain", "--deal", "--save", "--dry-run"],
+    fix: [...SOURCE_FLAGS, "--config", "--allow-plugins", "--no-plugins", "--rule", "--provider", "--min-confidence", "--include-creates", "--yes", "--confirm", "--dry-run", "--verbose"],
+    "bulk-update": [...SOURCE_FLAGS, "--where", "--set", "--guard", "--require", "--create-task", "--archive", "--force-archive-duplicates", "--reason", "--max-operations", "--save", "--dry-run", "--verbose", "--json", "--out"],
+    dedupe: [...SOURCE_FLAGS, "--key", "--keep", "--reason", "--max-operations", "--save", "--dry-run", "--verbose", "--json", "--out"],
+    reassign: [...SOURCE_FLAGS, "--from", "--assign-unowned", "--to", "--objects", "--where", "--except-deal-stage", "--include-closed-deals", "--reason", "--max-operations", "--save", "--dry-run", "--verbose", "--json", "--out"],
+    backfill: [...SOURCE_FLAGS, "--since", "--pipeline", "--match-property", "--skip-unmatched", "--save", "--dry-run", "--verbose", "--json"],
+    enrich: [...SOURCE_FLAGS, "--config", "--source", "--icp", "--input", "--provider", "--list", "--stale-days", "--assign-owner", "--objects", "--max", "--scan-limit", "--staged-run", "--run-label", "--label", "--runs", "--save", "--dry-run", "--verbose", "--json", "--out"],
+    call: [...SOURCE_FLAGS, "--transcript", "--title", "--source", "--model", "--deterministic", "--heuristics", "--llm", "--verbose", "--json", "--ndjson", "--out", "--call", "--call-type", "--rubric", "--list", "--list-rubrics", "--attendees", "--domain", "--deal", "--save", "--dry-run"],
     suggest: [...SOURCE_FLAGS, "--plan-id", "--plan", "--json", "--out"],
-    plans: ["--status", "--operations", "--value", "--values-from", "--min-confidence", "--include-creates", "--acknowledge-uncertain-writes", "--json"],
-    apply: ["--plan", "--plan-id", "--provider", "--channel", "--token-env", "--approve", "--value", "--json", "--config"],
+    plans: ["--status", "--operations", "--value", "--values-from", "--min-confidence", "--include-creates", "--acknowledge-uncertain-writes", "--verbose", "--json"],
+    apply: ["--plan", "--plan-id", "--provider", "--channel", "--token-env", "--approve", "--value", "--verbose", "--json", "--config"],
     "audit-log": ["--in", "--out", "--json"],
     merge: ["--input", "--out", "--json"],
-    market: ["--category", "--config", "--vendor", "--snapshot", "--task-account", "--task-deal", "--capture-run", "--run", "--prior-run", "--diff", "--from", "--calls", "--anchor", "--min-mentions", "--max-claims", "--promote-lift", "--model", "--format", "--auto", "--unverified", "--save", "--dry-run", "--json", "--out"],
-    tam: [...SOURCE_FLAGS, "--source", "--name", "--icp", "--accounts", "--acv", "--acv-basis", "--acv-from-crm", "--deal-period", "--buyers-per-account", "--cross-checks", "--max", "--max-credits", "--usd-per-credit", "--dry-run", "--confirm", "--cron", "--label", "--save", "--json", "--out"],
-    icp: [...SOURCE_FLAGS, "--name", "--signals-from", "--with-history", "--prompt", "--min-score", "--from-judge", "--golden", "--against-outcomes", "--min-accuracy", "--model", "--label", "--save", "--json", "--out"],
-    signals: ["--bucket", "--source", "--connector", "--connector-opt", "--watchlist", "--keywords", "--from", "--label", "--since", "--account", "--contact", "--unjudged", "--touch", "--result", "--save", "--json", "--explain"],
-    draft: ["--from-judge", "--min-score", "--prompt", "--model", "--channel", "--save", "--dry-run", "--json", "--out"],
-    schedule: ["--cron", "--label", "--provider", "--trigger", "--timer", "--runs", "--json"],
+    market: ["--category", "--config", "--vendor", "--snapshot", "--task-account", "--task-deal", "--capture-run", "--run", "--prior-run", "--diff", "--from", "--calls", "--anchor", "--min-mentions", "--max-claims", "--promote-lift", "--model", "--format", "--auto", "--unverified", "--save", "--dry-run", "--verbose", "--json", "--out"],
+    tam: [...SOURCE_FLAGS, "--source", "--name", "--icp", "--accounts", "--acv", "--acv-basis", "--acv-from-crm", "--deal-period", "--buyers-per-account", "--cross-checks", "--max", "--max-credits", "--usd-per-credit", "--dry-run", "--confirm", "--cron", "--label", "--save", "--verbose", "--json", "--out"],
+    icp: [...SOURCE_FLAGS, "--name", "--signals-from", "--with-history", "--prompt", "--min-score", "--from-judge", "--golden", "--against-outcomes", "--min-accuracy", "--model", "--label", "--save", "--verbose", "--json", "--out"],
+    signals: ["--bucket", "--source", "--connector", "--connector-opt", "--watchlist", "--keywords", "--from", "--label", "--since", "--account", "--contact", "--unjudged", "--touch", "--result", "--save", "--verbose", "--json", "--explain"],
+    draft: ["--from-judge", "--min-score", "--prompt", "--model", "--channel", "--save", "--dry-run", "--verbose", "--json", "--out"],
+    schedule: ["--cron", "--label", "--provider", "--trigger", "--timer", "--runs", "--verbose", "--json"],
 };
 export const FLAGS_WITH_VALUES = new Set([
     "--account", "--account-id", "--accounts", "--acv", "--acv-basis", "--after", "--anchor", "--api-key", "--approve", "--archive", "--assign-owner", "--attendees", "--before", "--bucket", "--buyers-per-account", "--call", "--call-type", "--calls", "--capture-run", "--category", "--channel", "--client", "--client-id", "--client-secret", "--config", "--connector", "--connector-opt", "--contact", "--cron", "--cross-checks", "--deal", "--deal-period", "--diff", "--domain", "--email", "--except-deal-stage", "--format", "--from", "--from-judge", "--golden", "--guard", "--icp", "--in", "--input", "--instance-url", "--keep", "--key", "--keywords", "--label", "--list", "--login-url", "--match", "--match-property", "--max", "--max-claims", "--max-credits", "--max-examples", "--max-operations", "--min-accuracy", "--min-confidence", "--min-mentions", "--min-score", "--model", "--name", "--objects", "--operations", "--out", "--pipeline", "--plan", "--plan-id", "--policy", "--port", "--prepared-by", "--prior-run", "--profile", "--promote-lift", "--prompt", "--provider", "--reason", "--require", "--result", "--rubric", "--rule", "--rules", "--run", "--run-label", "--runs", "--scan-limit", "--scopes", "--seed", "--set", "--signals-from", "--since", "--snapshot", "--source", "--staged-run", "--stale-days", "--status", "--task-account", "--task-deal", "--timer", "--title", "--to", "--today", "--token", "--token-env", "--touch", "--transcript", "--trigger", "--usd-per-credit", "--value", "--values-from", "--vendor", "--via", "--watchlist", "--where",

package/dist/cli/icp.js

@@ -9,6 +9,20 @@ import { DEFAULT_GOLDEN_NOW_ISO, DEFAULT_GOLDEN_SET, DEFAULT_MIN_ACCURACY, defau
 import { loadIcp, numericOption, option, readSnapshot, resolveLlmBaseUrls, saveRequested } from "./shared.js";
 import { createStatusLine } from "./ui.js";
 import { unknownSubcommandError } from "./suggest.js";
+function renderJudgeDecisions(decisions) {
+    if (decisions.length === 0)
+        return "No accounts cleared the score threshold.";
+    const lines = [`ICP decisions (${decisions.length})`, ""];
+    for (const decision of decisions) {
+        const target = decision.contact?.email || decision.contact?.title;
+        lines.push(`${decision.decision.toUpperCase().padEnd(7)} ${String(decision.score).padStart(3)}  ${decision.accountDomain}${target ? ` · ${target}` : ""}`);
+        if (decision.whyNow)
+            lines.push(`            ${decision.whyNow.replace(/\s+/g, " ").trim()}`);
+        if (decision.play)
+            lines.push(`            Next: ${decision.play.replace(/\s+/g, " ").trim()}`);
+    }
+    return lines.join("\n");
+}
 /**
  * `icp` — develop and inspect the Ideal Customer Profile that targets acquire.
  * The CLI can't run AskUserQuestion itself; `icp interview` emits the question
@@ -133,7 +147,7 @@ ops. Develop one by interview, then \`enrich acquire\` picks up ./icp.json.
         }
         decisions = decisions.filter((d) => d.score >= minScore);
         // 5) Ranked decisions to stdout (JSON), guidance to stderr.
-        console.log(JSON.stringify(decisions, null, 2));
+        console.log(rest.includes("--json") || rest.includes("--verbose") ? JSON.stringify(decisions, null, 2) : renderJudgeDecisions(decisions));
         console.error(`Judged ${unjudged.length} signal(s) across ${new Set(decisions.map((d) => d.accountDomain)).size} account(s): ` +
             `${decisions.filter((d) => d.decision === "send").length} send, ` +
             `${decisions.filter((d) => d.decision === "nurture").length} nurture, ` +

package/dist/cli/init.js

@@ -13,7 +13,7 @@ import { option } from "./shared.js";
 export function initCommand(args) {
     if (args.includes("--help") || args.includes("-h")) {
         console.log(`Usage:
-  fullstackgtm init [--source pipe0|explorium|linkedin] [--provider hubspot|salesforce] [--out <dir>] [--force]
+  fullstackgtm init [--source pipe0|explorium|clay|linkedin] [--provider hubspot|salesforce] [--out <dir>] [--force]
 
 Scaffolds a workspace so the first acquire/signals/judge/draft commands work:
   icp.json            starter ICP (edit, or rebuild with \`icp interview\`)
@@ -25,8 +25,8 @@ docs/recipes.md for the full play set. Existing files are kept unless --force.`)
         return;
     }
     const source = (option(args, "--source") ?? "pipe0");
-    if (!["pipe0", "explorium", "linkedin"].includes(source)) {
-        throw new Error(`init: --source must be pipe0|explorium|linkedin (got "${source}")`);
+    if (!["pipe0", "explorium", "clay", "linkedin"].includes(source)) {
+        throw new Error(`init: --source must be pipe0|explorium|clay|linkedin (got "${source}")`);
     }
     const provider = (option(args, "--provider") ?? "hubspot");
     if (!["hubspot", "salesforce"].includes(provider)) {

package/dist/cli/market.js

@@ -481,9 +481,22 @@ Rules:
             writeFileSync(resolve(process.cwd(), outPath), output);
             console.log(`Wrote ${outPath}`);
         }
-        else {
+        else if (rest.includes("--verbose") || option(rest, "--format")) {
             console.log(output);
         }
+        else {
+            const fronts = computeFrontStates(config, set);
+            const counts = new Map();
+            for (const front of fronts)
+                counts.set(front.state, (counts.get(front.state) ?? 0) + 1);
+            console.log(`${config.category} market · ${set.runLabel}`);
+            console.log(`${fronts.length} claim fronts · ${["open", "contested", "owned", "saturated", "vacant"].filter((state) => counts.has(state)).map((state) => `${counts.get(state)} ${state}`).join(" · ")}`);
+            for (const front of fronts) {
+                const owner = front.loudVendorIds.length ? ` · ${front.loudVendorIds.join(", ")}` : "";
+                console.log(`\n${front.state.toUpperCase()}  ${front.claimId}${owner}`);
+            }
+            console.log("\nUse --verbose for the full evidence report, or --out <path> to write it.");
+        }
         return;
     }
     if (subcommand === "axes") {

package/dist/cli/planOutput.d.ts

@@ -0,0 +1,5 @@
+import type { PatchPlan } from "../types.ts";
+export declare function compactPlan(plan: PatchPlan, options?: {
+    saved?: boolean;
+}): string;
+export declare function verbosePlanRequested(args: readonly string[]): boolean;

package/dist/cli/planOutput.js

@@ -0,0 +1,27 @@
+import { box, colorEnabled, paint, truncateToWidth } from "./ui.js";
+export function compactPlan(plan, options = {}) {
+    const counts = new Map();
+    for (const operation of plan.operations) {
+        const action = operation.operation || operation.field || "change";
+        counts.set(action, (counts.get(action) ?? 0) + 1);
+    }
+    const mix = [...counts]
+        .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+        .slice(0, 4)
+        .map(([action, count]) => `${count} ${action}`)
+        .join(" · ");
+    const lines = [
+        truncateToWidth(plan.title, 100),
+        `Status   ${options.saved ? "SAVED · NEEDS APPROVAL" : "DRY RUN · NOTHING WRITTEN"}`,
+        truncateToWidth(`Scope    ${plan.operations.length} operation${plan.operations.length === 1 ? "" : "s"}${mix ? ` · ${mix}` : ""}`, 100),
+        truncateToWidth(`Effect   ${plan.summary}`, 100),
+        options.saved ? `Next     fullstackgtm plans show ${plan.id}` : "Next     re-run with --save to stage this plan for approval",
+    ];
+    return [
+        ...box(lines, paint(colorEnabled(process.stdout)), "Plan preview"),
+        `Details: re-run with --verbose${options.saved ? `; JSON: fullstackgtm plans show ${plan.id} --json` : "; machine output: --json"}`,
+    ].join("\n");
+}
+export function verbosePlanRequested(args) {
+    return args.includes("--verbose") || args.includes("--full");
+}

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)