fullstackgtm 0.49.0 → 0.50.1

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> | 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
@@ -204,7 +204,11 @@ Profiles (multi-organization use):
 Plan lifecycle:
   audit --save persists the dry-run plan to ~/.fullstackgtm/plans. Approve
   specific operations (optionally with --value <opId>=<v> for placeholders),
-  then apply by id — the store enforces approval and records every run.
+  then apply by id — the store enforces approval and records every run. When
+  paired, local and hosted are replicas of the same immutable plan: either
+  capable surface may approve or apply, and each CLI check-in imports missing
+  approvals and exact operation receipts. Use \`plans sync\` for an explicit
+  check-in; offline changes reconcile later without blocking local work.
 
 Authentication (checked in order):
   1. --token-env <name>        explicit env var for this invocation (hubspot)
@@ -543,27 +547,28 @@ export const HELP: Record<string, HelpEntry> = {
     seeAlso: ["audit", "plans", "apply"],
   },
   plans: {
-    summary: "plan lifecycle: list / show / approve / reject saved plans",
+    summary: "replicated plan lifecycle: list / show / sync / approve / reject",
     phase: "Govern",
     synopsis: [
-      "fullstackgtm plans list [--status <s>] | show <id> | 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",
     ],
-    detail: "Approval is explicit and per-operation; placeholders need a concrete --value or a suggestion to be approvable.",
+    detail:
+      "Approval is explicit and per-operation; placeholders need a concrete --value or a suggestion to be approvable. When paired, hosted and CLI are eventually consistent replicas of one immutable plan. `plans sync` explicitly exchanges approval revisions, execution state, and exact per-operation receipts; ordinary plan commands also check in best-effort. Either surface may apply when its CRM connector supports the selected operations.",
     seeAlso: ["audit", "suggest", "apply"],
   },
   apply: {
     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 only verb that mutates a CRM. Writes only operations approved via `plans approve` or `--approve`, with compare-and-set and readback. 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": {
@@ -653,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,
@@ -662,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"],
@@ -676,28 +681,28 @@ 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", "--stale-days", "--assign-owner", "--objects", "--max", "--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", "--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", "--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", "--scopes", "--seed", "--set", "--signals-from", "--since", "--snapshot", "--source", "--staged-run", "--stale-days", "--status", "--task-account", "--task-deal", "--title", "--to", "--today", "--token", "--token-env", "--touch", "--transcript", "--trigger", "--usd-per-credit", "--value", "--values-from", "--vendor", "--via", "--watchlist", "--where",
+  "--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",
 ]);
 
 // Lifecycle-grouped front door. One line per verb, organized by the

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,15 +11,16 @@ 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";
+import { claimHostedPlanApply, reconcileHostedPatchPlan, releaseHostedPlanApply, reportHostedPlanLifecycle, uploadHostedPatchPlan } from "../hostedPatchPlan.ts";
 import { APPLY_STAGES, composeListeners, createProgressEmitter } from "../progress.ts";
 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";
 
 
@@ -33,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);
@@ -141,8 +251,18 @@ export async function apply(args: string[]) {
   const store = planId ? createFilePlanStore() : null;
 
   if (planId && store) {
-    const stored = await store.get(planId);
+    let stored = await store.get(planId);
     if (!stored) throw new Error(`No stored plan with id ${planId}.`);
+    const reconciliation = await reconcileHostedPatchPlan(store, stored);
+    if (reconciliation.status === "conflict") throw new Error(`Refusing to apply plan ${planId}: ${reconciliation.reason}.`);
+    if (reconciliation.status === "updated") {
+      stored = reconciliation.stored;
+      console.error(`Synced hosted ${reconciliation.remoteStatus} state for ${planId}.`);
+    }
+    if (stored.status === "applied") {
+      console.log(`Plan ${planId} was already applied by another replica; imported its execution receipt. No provider writes were attempted.`);
+      return;
+    }
     if (stored.status !== "approved") {
       throw new Error(
         `Plan ${planId} is ${stored.status}; approve operations first with \`fullstackgtm plans approve ${planId} --operations <ids|all>\`.`,
@@ -235,9 +355,29 @@ export async function apply(args: string[]) {
   // transmits nothing; a CRM provider writes records. Same governed apply path.
   const connector = channel ? createChannelConnector(channel) : await connectorFor(provider!, args);
   let applyClaimId: string | undefined;
+  let hostedApplyClaimId: string | undefined;
   if (planId && store) {
     const claimed = await store.claimApply(planId, { provider: provider ?? `channel:${channel}`, source: "cli" });
     applyClaimId = claimed.claimId;
+    const hostedClaim = await claimHostedPlanApply(claimed.stored);
+    if (hostedClaim.status === "applied") {
+      await store.abortApplyPreflight(planId, claimed.claimId, "Another replica completed apply before provider I/O.");
+      const refreshed = await store.get(planId);
+      if (refreshed) await reconcileHostedPatchPlan(store, refreshed);
+      console.log(`Plan ${planId} was already applied by another replica. No provider writes were attempted.`);
+      return;
+    }
+    if (hostedClaim.status === "conflict") {
+      await store.abortApplyPreflight(planId, claimed.claimId, `Hosted execution claim failed: ${hostedClaim.reason}`);
+      throw new Error(`Refusing to apply plan ${planId}: could not coordinate with its hosted replica (${hostedClaim.reason}).`);
+    }
+    if (hostedClaim.status === "unavailable") {
+      console.error(`Hosted replica is unavailable (${hostedClaim.reason}); continuing local-first. Resolve-before-create and provider conflict guards remain active, and the execution receipt will sync on a later check-in.`);
+    }
+    if (hostedClaim.status === "claimed") {
+      hostedApplyClaimId = hostedClaim.claimId;
+      await store.recordHostedClaim(planId, claimed.claimId, hostedClaim.claimId);
+    }
     const claimedVerification = verifyApprovalDigests(
       claimed.stored.plan.operations,
       claimed.stored.approvedOperationIds,
@@ -245,6 +385,16 @@ export async function apply(args: string[]) {
       claimed.stored.approvalDigests,
     );
     if (!claimedVerification.ok) {
+      if (hostedApplyClaimId) {
+        const released = await releaseHostedPlanApply(
+          claimed.stored,
+          hostedApplyClaimId,
+          "Approval integrity verification failed after claim and before provider I/O.",
+        );
+        if (released.status === "conflict" || released.status === "unavailable") {
+          console.error(`Hosted apply claim may require recovery: ${released.reason}.`);
+        }
+      }
       await store.abortApplyPreflight(
         planId,
         claimed.claimId,
@@ -280,7 +430,12 @@ export async function apply(args: string[]) {
     renderer.done();
   }
   if (planId && store) {
-    await store.recordRun(planId, run, applyClaimId!);
+    const recorded = await store.recordRun(planId, run, applyClaimId!);
+    const durableHostedClaimId = recorded.applyAttempts?.find((attempt) => attempt.id === applyClaimId)?.hostedClaimId;
+    const mirrored = await reportHostedPlanLifecycle(recorded, { claimId: durableHostedClaimId ?? hostedApplyClaimId });
+    if (mirrored.status === "unavailable" || mirrored.status === "conflict") {
+      console.error(`Hosted plan status is stale: ${mirrored.reason}. Local apply history remains authoritative.`);
+    }
   }
 
   // Charge the acquire meter for the creates that actually landed.
@@ -315,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;
 }
@@ -408,7 +565,13 @@ export async function plansCommand(args: string[]) {
     const status = option(rest, "--status") as
       | "draft" | "needs_approval" | "approved" | "rejected" | "applied"
       | null;
-    const plans = await store.list(status ?? undefined);
+    let plans = await store.list(status ?? undefined);
+    const synced = await Promise.all(plans.map(async (stored) => {
+      const result = await reconcileHostedPatchPlan(store, stored);
+      if (result.status === "updated") return result.stored;
+      return stored;
+    }));
+    plans = status ? synced.filter((stored) => stored.status === status) : synced;
     if (rest.includes("--json") || args.includes("--json")) {
       console.log(
         JSON.stringify(
@@ -432,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
@@ -447,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) {
@@ -473,25 +652,34 @@ export async function plansCommand(args: string[]) {
   if (subcommand === "show") {
     const planId = rest.find((arg) => !arg.startsWith("--"));
     if (!planId) throw new Error("Usage: fullstackgtm plans show <planId>");
-    const stored = await store.get(planId);
+    let stored = await store.get(planId);
     if (!stored) throw new Error(`No stored plan with id ${planId}.`);
+    const reconciliation = await reconcileHostedPatchPlan(store, stored);
+    if (reconciliation.status === "updated") {
+      stored = reconciliation.stored;
+      console.error(`Synced hosted ${reconciliation.remoteStatus} state for ${planId}.`);
+    } else if (reconciliation.status === "conflict") {
+      console.error(`Hosted sync conflict: ${reconciliation.reason}.`);
+    }
     if (rest.includes("--json")) {
       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}`);
-    if (stored.applyAttempts?.length) {
+    const mirror = await uploadHostedPatchPlan(stored);
+    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;
   }
 
@@ -541,6 +729,10 @@ export async function plansCommand(args: string[]) {
       ...fileOverrides,
       ...explicitOverrides,
     });
+    const mirror = await reportHostedPlanLifecycle(updated);
+    if (mirror.status === "unavailable" || mirror.status === "conflict") {
+      console.error(`Hosted plan status is stale: ${mirror.reason}. Local approval remains authoritative.`);
+    }
     console.log(
       `Approved ${updated.approvedOperationIds.length} operation(s) on ${planId}. Apply with \`fullstackgtm apply --plan-id ${planId} --provider <name>\`.`,
     );
@@ -550,7 +742,11 @@ export async function plansCommand(args: string[]) {
   if (subcommand === "reject") {
     const planId = rest.find((arg) => !arg.startsWith("--"));
     if (!planId) throw new Error("Usage: fullstackgtm plans reject <planId>");
-    await store.reject(planId);
+    const rejected = await store.reject(planId);
+    const mirror = await reportHostedPlanLifecycle(rejected);
+    if (mirror.status === "unavailable" || mirror.status === "conflict") {
+      console.error(`Hosted plan status is stale: ${mirror.reason}. Local rejection remains authoritative.`);
+    }
     console.log(`Rejected ${planId}.`);
     return;
   }
@@ -581,5 +777,43 @@ export async function plansCommand(args: string[]) {
     return;
   }
 
-  throw unknownSubcommandError("plans", subcommand, ["list", "show", "approve", "reject", "recover"]);
+  if (subcommand === "sync") {
+    const plans = await store.list();
+    let updated = 0;
+    let completed = 0;
+    const warnings: string[] = [];
+    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}`);
+    return;
+  }
+
+  throw unknownSubcommandError("plans", subcommand, ["list", "show", "sync", "approve", "reject", "recover"]);
 }