fullstackgtm 0.50.0 → 0.50.1

package/src/cli/backfill.ts

@@ -15,6 +15,7 @@ import { progressReporter } from "../runReport.ts";
 import { unknownSubcommandError } from "./suggest.ts";
 import { option, readSnapshot, saveRequested } from "./shared.ts";
 import { colorEnabled, createProgressRenderer, paint, stylizePlanMarkdown, table } from "./ui.ts";
+import { compactPlan, verbosePlanRequested } from "./planOutput.ts";
 
 /** STRIPE_SECRET_KEY env ∨ stored `login stripe` credential (same ladder as `--provider stripe`). */
 function resolveStripeKey(): string {
@@ -93,6 +94,8 @@ export async function backfillCommand(args: string[]) {
         2,
       ),
     );
+  } else if (!verbosePlanRequested(rest)) {
+    console.log(compactPlan(result.plan, { saved: save && result.plan.operations.length > 0 }));
   } else {
     // TTY-only styling; piped output stays byte-identical plain text.
     console.log(

package/src/cli/call.ts

@@ -177,11 +177,11 @@ score always needs a key (scoring is LLM work).`);
       if (!outPath) console.log(JSON.stringify(parsed, null, 2));
       return;
     }
-    console.log(`Call ${parsed.id}${parsed.title ? ` — ${parsed.title}` : ""} (${parsed.sourceSystem})`);
-    console.log(`${parsed.segments.length} segments · ${parsed.insights.length} insights (${parsed.summary.highImportance} high-importance)\n`);
-    for (const insight of parsed.insights) {
-      console.log(`[${insight.type}] (importance ${insight.importance}) ${insight.text}`);
-    }
+    console.log(`Call ${parsed.id}${parsed.title ? ` — ${parsed.title}` : ""}`);
+    console.log(`${parsed.segments.length} segments · ${parsed.insights.length} insights · ${parsed.summary.highImportance} high priority`);
+    const visible = rest.includes("--verbose") ? parsed.insights : parsed.insights.filter((insight) => insight.importance >= 3);
+    for (const insight of visible) console.log(`\n${insight.type.replaceAll("_", " ")} · priority ${insight.importance}\n  ${insight.text.replace(/\s+/g, " ").trim()}`);
+    if (!rest.includes("--verbose") && visible.length < parsed.insights.length) console.log(`\n${parsed.insights.length - visible.length} lower-priority insight(s) hidden; use --verbose to show all.`);
     return;
   }
 
@@ -301,13 +301,32 @@ score always needs a key (scoring is LLM work).`);
       console.log(JSON.stringify(scorecard, null, 2));
       return;
     }
-    console.log(renderScorecard(scorecard, title));
+    console.log(rest.includes("--verbose") ? renderScorecard(scorecard, title) : renderCompactScorecard(scorecard, title));
     return;
   }
 
   throw new Error(`call supports: parse, classify, link, plan, score (got ${subcommand ?? "nothing"})`);
 }
 
+function renderCompactScorecard(scorecard: CallScorecard, title?: string): string {
+  const lines = [
+    `${title ?? "Call"} · ${scorecard.overallScore}/${scorecard.scale}${scorecard.band ? ` · ${scorecard.band.label}` : ""}`,
+    scorecard.rubricName ? `${scorecard.rubricName}${scorecard.callType ? ` (${scorecard.callType})` : ""}` : "",
+    "",
+  ].filter((line, index) => line || index === 2);
+  for (const dimension of scorecard.dimensions) {
+    lines.push(`${dimension.score}/${dimension.maxScore}  ${dimension.name}`);
+    lines.push(`     ${dimension.coachingNote.replace(/\s+/g, " ").trim()}`);
+  }
+  if (scorecard.missedItems.length) {
+    lines.push("", "Focus next");
+    for (const item of scorecard.missedItems) lines.push(`  ${item}`);
+  }
+  if (scorecard.highlights.length) lines.push("", `Strengths: ${scorecard.highlights.join(" · ")}`);
+  lines.push("", "Use --verbose for the full coaching scorecard.");
+  return lines.join("\n");
+}
+
 function renderScorecard(scorecard: CallScorecard, title?: string): string {
   const bandText = scorecard.band ? ` — ${scorecard.band.label}` : "";
   const rubricLine = scorecard.rubricName ? `Rubric: ${scorecard.rubricName}${scorecard.callType ? ` (${scorecard.callType})` : ""}` : "";

package/src/cli/draft.ts

@@ -9,6 +9,7 @@ import { createFileJudgeStore } from "../judge.ts";
 import { authorOpeners, DEFAULT_DRAFT_PROMPT, DRAFT_CHANNELS, draft, type DraftChannel } from "../draft.ts";
 import type { LlmCallOptions } from "../llm.ts";
 import { numericOption, option, resolveLlmBaseUrls, saveRequested } from "./shared.ts";
+import { compactPlan, verbosePlanRequested } from "./planOutput.ts";
 
 
 /**
@@ -78,7 +79,14 @@ LLM key it emits a clearly-labeled stub rather than fake authored copy.`);
     openers,
   });
 
-  console.log(JSON.stringify({ drafts, rejected }, null, 2));
+  if (args.includes("--json")) {
+    console.log(JSON.stringify({ drafts, rejected }, null, 2));
+  } else if (verbosePlanRequested(args)) {
+    console.log(JSON.stringify({ drafts, rejected }, null, 2));
+    console.log(compactPlan(plan, { saved: save }));
+  } else {
+    console.log(compactPlan(plan, { saved: save }));
+  }
   const stale = drafts.filter((d) => d.staleTrigger);
   console.error(
     `${drafts.length} opener(s) staged as create_task proposals (channel ${channel}, min score ${minScore})` +

package/src/cli/enrich.ts

@@ -24,6 +24,7 @@ import { isOptionValue, loadIcp, numericOption, option, readSnapshot, saveReques
 import { providerKey } from "./tam.ts";
 import { unknownSubcommandError } from "./suggest.ts";
 import { colorEnabled, createProgressRenderer, createStatusLine, formatBar, formatDuration, paint, type Paint } from "./ui.ts";
+import { compactPlan, verbosePlanRequested } from "./planOutput.ts";
 import type { AcquireBudget } from "../acquireMeter.ts";
 
 
@@ -309,7 +310,7 @@ are phase 2. Recurring execution is the scheduler's job; enrich has no cron.`);
           ),
         );
       } else {
-        console.log(patchPlanToMarkdown(result.plan));
+        console.log(verbosePlanRequested(rest) ? patchPlanToMarkdown(result.plan) : compactPlan(result.plan));
         console.log(meterLine);
         if (gaugeLine) console.log(gaugeLine);
         console.log("\nDry run — nothing written. Re-run with --save to persist the plan, then approve + apply.");
@@ -514,7 +515,7 @@ are phase 2. Recurring execution is the scheduler's job; enrich has no cron.`);
     if (rest.includes("--json")) {
       console.log(JSON.stringify(result.plan, null, 2));
     } else {
-      console.log(patchPlanToMarkdown(result.plan));
+      console.log(verbosePlanRequested(rest) ? patchPlanToMarkdown(result.plan) : compactPlan(result.plan));
       console.log(formatEnrichCounts(result.counts, result.ambiguities.length));
       console.log("\nDry run — nothing written. Re-run with --save to persist the plan and the run record.");
     }

package/src/cli/fix.ts

@@ -22,6 +22,7 @@ import { progressReporter } from "../runReport.ts";
 import type { PatchPlan, PatchPlanRun } from "../types.ts";
 import { confirmRequested, connectorFor, isOptionValue, numericOption, option, readSnapshot, repeatedOption, saveRequested } from "./shared.ts";
 import { box, colorEnabled, createProgressRenderer, paint } from "./ui.ts";
+import { compactPlan, verbosePlanRequested } from "./planOutput.ts";
 
 
 /**
@@ -107,8 +108,10 @@ async function emitPlan(plan: PatchPlan, args: string[]) {
   }
   if (args.includes("--json")) {
     console.log(JSON.stringify(plan, null, 2));
-  } else {
+  } else if (verbosePlanRequested(args)) {
     console.log(patchPlanToMarkdown(plan));
+  } else {
+    console.log(compactPlan(plan, { saved: saveRequested(args) }));
   }
 }
 
@@ -181,8 +184,7 @@ export async function reassignCommand(args: string[]) {
   const store = saveRequested(args) ? createFilePlanStore() : null;
   for (const plan of plans) {
     if (store) await store.save(plan);
-    console.log(`${plan.id}  ${String(plan.operations.length).padStart(3)} operation(s)  ${plan.title}`);
-    console.log(`    ${plan.summary}`);
+    console.log(verbosePlanRequested(args) ? patchPlanToMarkdown(plan) : compactPlan(plan, { saved: Boolean(store) }));
   }
   if (store) {
     console.log(

package/src/cli/help.ts

@@ -180,11 +180,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
@@ -550,7 +550,7 @@ export const HELP: Record<string, HelpEntry> = {
     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",
@@ -563,12 +563,12 @@ export const HELP: Record<string, HelpEntry> = {
     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.",
+      "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": {
@@ -658,7 +658,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,
@@ -667,7 +667,7 @@ export const COMMAND_FLAGS: Record<string, string[]> = {
   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"],
@@ -681,24 +681,24 @@ export const COMMAND_FLAGS: Record<string, string[]> = {
   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([

package/src/cli/icp.ts

@@ -12,6 +12,18 @@ import { loadIcp, numericOption, option, readSnapshot, resolveLlmBaseUrls, saveR
 import { createStatusLine } from "./ui.ts";
 import { unknownSubcommandError } from "./suggest.ts";
 
+function renderJudgeDecisions(decisions: Awaited<ReturnType<typeof judgeSignals>>): string {
+  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.
@@ -158,7 +170,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, ` +

package/src/cli/market.ts

@@ -499,8 +499,19 @@ Rules:
     if (outPath) {
       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<string, number>();
+      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;
   }

package/src/cli/planOutput.ts

@@ -0,0 +1,30 @@
+import type { PatchPlan } from "../types.ts";
+import { box, colorEnabled, paint, truncateToWidth } from "./ui.ts";
+
+export function compactPlan(plan: PatchPlan, options: { saved?: boolean } = {}): string {
+  const counts = new Map<string, number>();
+  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: readonly string[]) {
+  return args.includes("--verbose") || args.includes("--full");
+}

package/src/cli/plans.ts

@@ -11,7 +11,7 @@ import { formatPatchPlanRun, patchPlanToMarkdown } from "../format.ts";
 import { mergeSnapshots } from "../merge.ts";
 import { verifyApprovalDigests } from "../integrity.ts";
 import { buildAuditLog, verifyAuditLog } from "../auditLog.ts";
-import { createFilePlanStore } from "../planStore.ts";
+import { createFilePlanStore, type StoredPlan } from "../planStore.ts";
 import { ENRICH_CONFIG_FILE_NAME, loadEnrichConfig, type EnrichConfig } from "../enrich.ts";
 import { loadMeter, recordConsumption, remaining } from "../acquireMeter.ts";
 import { progressReporter, reportCounts } from "../runReport.ts";
@@ -20,7 +20,7 @@ import { APPLY_STAGES, composeListeners, createProgressEmitter } from "../progre
 import type { ValueSuggestion } from "../suggest.ts";
 import type { CanonicalGtmSnapshot, CreateRecordPayload, PatchOperation, PatchPlan, PatchPlanRun } from "../types.ts";
 import { connectorFor, isOptionValue, numericOption, option, repeatedOption, selectedRules } from "./shared.ts";
-import { colorEnabled, createProgressRenderer, paint, planStatusWord, stylizePlanMarkdown, table, truncateToWidth } from "./ui.ts";
+import { box, colorEnabled, createProgressRenderer, createStatusLine, formatDuration, paint, planStatusWord, stylizePlanMarkdown, table, truncateToWidth } from "./ui.ts";
 import { unknownSubcommandError } from "./suggest.ts";
 
 
@@ -34,6 +34,115 @@ function parseValueOverrides(args: string[]) {
   return valueOverrides;
 }
 
+function recordHeadline(operation: PatchOperation): { title: string; subtitle?: string; company?: string } {
+  const after = operation.afterValue && typeof operation.afterValue === "object" && !Array.isArray(operation.afterValue)
+    ? operation.afterValue as Record<string, unknown> : {};
+  const properties = after.properties && typeof after.properties === "object" && !Array.isArray(after.properties)
+    ? after.properties as Record<string, unknown> : {};
+  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: StoredPlan): string {
+  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: StoredPlan, hostedUrl?: string) {
+  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: string) => 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: PatchPlanRun, plan: PatchPlan, approvedOperationIds: string[], planIdStored: boolean) {
+  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: string[]): EnrichConfig | undefined {
   try {
     const path = resolve(process.cwd(), option(args, "--config") ?? ENRICH_CONFIG_FILE_NAME);
@@ -361,8 +470,10 @@ export async function apply(args: string[]) {
 
   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;
 }
@@ -484,14 +595,23 @@ export async function plansCommand(args: string[]) {
     }
     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<string, number>();
+      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
@@ -499,19 +619,26 @@ export async function plansCommand(args: string[]) {
       // terminals still show something useful).
       const columns = process.stdout.columns ?? 80;
       const fixedWidth =
-        [0, 1, 2, 3].reduce(
+        [0, 2, 3, 4].reduce(
           (sum, index) => sum + Math.max(...rows.map((row) => row[index].length)),
           0,
         ) + 2 * 4;
-      const summaryWidth = Math.max(24, columns - fixedWidth);
-      for (const row of rows) row[4] = truncateToWidth(row[4], summaryWidth);
+      const titleWidth = Math.max(24, columns - fixedWidth);
+      for (const row of rows) row[1] = truncateToWidth(row[1], titleWidth);
       const statusPainter = (cell: string) => {
         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) {
@@ -538,22 +665,21 @@ export async function plansCommand(args: string[]) {
       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}`);
         if (attempt.note) 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;
   }
 
@@ -654,16 +780,35 @@ export async function plansCommand(args: string[]) {
   if (subcommand === "sync") {
     const plans = await store.list();
     let updated = 0;
+    let completed = 0;
     const warnings: string[] = [];
-    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) console.error(`  ${warning}`);