fullstackgtm 0.49.0 → 0.50.1

package/src/acquireCheckpoint.ts

@@ -0,0 +1,186 @@
+import { createHash } from "node:crypto";
+import { chmodSync, mkdirSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { credentialsDir, ensureSecureHomeDir } from "./credentials.ts";
+import {
+  assertNoSymlinkComponents,
+  readSecureRegularFile,
+  writeSecureFileAtomic,
+} from "./secureFile.ts";
+
+/** The complete identity of one independently traversable provider audience. */
+export type AcquireCheckpointKey = {
+  provider: string;
+  source: string;
+  listId: string | null;
+  queryFingerprint: string;
+};
+
+export type AcquireContinuation = {
+  cursor?: string | null;
+  offset?: number | null;
+  exhausted: boolean;
+};
+
+/** Versioned wire format shared by local persistence and hosted sync. */
+export type AcquireCheckpoint = {
+  version: 1;
+  id: string;
+  key: AcquireCheckpointKey;
+  continuation: AcquireContinuation;
+  updatedAt: string;
+};
+
+const COMPONENT_MAX = 512;
+
+function requireComponent(value: unknown, name: string): string {
+  if (typeof value !== "string" || value.length === 0 || value.length > COMPONENT_MAX || /[\u0000-\u001f]/.test(value)) {
+    throw new Error(`Invalid acquisition checkpoint ${name}`);
+  }
+  return value;
+}
+
+export function validateAcquireCheckpointKey(value: unknown): AcquireCheckpointKey {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Invalid acquisition checkpoint key");
+  }
+  const candidate = value as Partial<AcquireCheckpointKey>;
+  const listId = candidate.listId;
+  if (listId !== null && listId !== undefined) requireComponent(listId, "listId");
+  return {
+    provider: requireComponent(candidate.provider, "provider"),
+    source: requireComponent(candidate.source, "source"),
+    listId: listId ?? null,
+    queryFingerprint: requireComponent(candidate.queryFingerprint, "queryFingerprint"),
+  };
+}
+
+/** Stable, non-secret filename/key suitable for both filesystem and hosted records. */
+export function acquireCheckpointId(key: AcquireCheckpointKey): string {
+  const valid = validateAcquireCheckpointKey(key);
+  const canonical = JSON.stringify([valid.provider, valid.source, valid.listId, valid.queryFingerprint]);
+  return `acqcp_${createHash("sha256").update(canonical).digest("hex")}`;
+}
+
+function validateContinuation(value: unknown): AcquireContinuation {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Invalid acquisition checkpoint continuation");
+  }
+  const candidate = value as Partial<AcquireContinuation>;
+  if (typeof candidate.exhausted !== "boolean") throw new Error("Invalid acquisition checkpoint exhausted flag");
+  if (candidate.cursor !== undefined && candidate.cursor !== null) requireComponent(candidate.cursor, "cursor");
+  if (
+    candidate.offset !== undefined && candidate.offset !== null &&
+    (!Number.isSafeInteger(candidate.offset) || candidate.offset < 0)
+  ) {
+    throw new Error("Invalid acquisition checkpoint offset");
+  }
+  return {
+    ...(candidate.cursor !== undefined ? { cursor: candidate.cursor } : {}),
+    ...(candidate.offset !== undefined ? { offset: candidate.offset } : {}),
+    exhausted: candidate.exhausted,
+  };
+}
+
+export function validateAcquireCheckpoint(value: unknown): AcquireCheckpoint {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Invalid acquisition checkpoint");
+  }
+  const candidate = value as Partial<AcquireCheckpoint>;
+  if (candidate.version !== 1) throw new Error(`Unsupported acquisition checkpoint version: ${String(candidate.version)}`);
+  const key = validateAcquireCheckpointKey(candidate.key);
+  const id = acquireCheckpointId(key);
+  if (candidate.id !== id) throw new Error("Acquisition checkpoint id does not match its key");
+  if (typeof candidate.updatedAt !== "string" || !Number.isFinite(Date.parse(candidate.updatedAt))) {
+    throw new Error("Invalid acquisition checkpoint updatedAt");
+  }
+  return {
+    version: 1,
+    id,
+    key,
+    continuation: validateContinuation(candidate.continuation),
+    updatedAt: candidate.updatedAt,
+  };
+}
+
+export function acquireCheckpointsDir(baseDir?: string): string {
+  return join(baseDir ?? credentialsDir(), "acquire", "checkpoints");
+}
+
+export interface AcquireCheckpointStore {
+  get(key: AcquireCheckpointKey): Promise<AcquireCheckpoint | null>;
+  put(key: AcquireCheckpointKey, continuation: AcquireContinuation, updatedAt?: Date): Promise<AcquireCheckpoint>;
+  /** Import a validated local/hosted record without changing its timestamp. */
+  putRecord(record: AcquireCheckpoint): Promise<AcquireCheckpoint>;
+  list(): Promise<AcquireCheckpoint[]>;
+}
+
+export function createFileAcquireCheckpointStore(baseDir?: string): AcquireCheckpointStore {
+  const directory = acquireCheckpointsDir(baseDir);
+
+  function fileForId(id: string): string {
+    return join(directory, `${id}.json`);
+  }
+
+  function readId(id: string): AcquireCheckpoint | null {
+    try {
+      return validateAcquireCheckpoint(JSON.parse(readSecureRegularFile(fileForId(id), { tightenMode: 0o600 })));
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") return null;
+      throw error;
+    }
+  }
+
+  function ensureDirectory(): void {
+    if (baseDir === undefined) ensureSecureHomeDir();
+    // Tighten both managed levels. mkdir's mode does not affect a directory
+    // restored or pre-created with broader permissions.
+    const levels = [join(baseDir ?? credentialsDir(), "acquire"), directory];
+    for (const level of levels) {
+      assertNoSymlinkComponents(level);
+      mkdirSync(level, { recursive: true, mode: 0o700 });
+      assertNoSymlinkComponents(level);
+      try { chmodSync(level, 0o700); } catch { /* chmod is unavailable on some filesystems. */ }
+    }
+  }
+
+  function writeRecord(value: AcquireCheckpoint): AcquireCheckpoint {
+    const record = validateAcquireCheckpoint(value);
+    ensureDirectory();
+    writeSecureFileAtomic(fileForId(record.id), `${JSON.stringify(record, null, 2)}\n`);
+    return record;
+  }
+
+  return {
+    async get(key) {
+      return readId(acquireCheckpointId(key));
+    },
+    async put(key, continuation, updatedAt = new Date()) {
+      const validKey = validateAcquireCheckpointKey(key);
+      return writeRecord({
+        version: 1,
+        id: acquireCheckpointId(validKey),
+        key: validKey,
+        continuation: validateContinuation(continuation),
+        updatedAt: updatedAt.toISOString(),
+      });
+    },
+    async putRecord(record) {
+      return writeRecord(record);
+    },
+    async list() {
+      let names: string[];
+      try {
+        assertNoSymlinkComponents(directory);
+        names = readdirSync(directory).filter((name) => /^acqcp_[a-f0-9]{64}\.json$/.test(name));
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException).code === "ENOENT") return [];
+        throw error;
+      }
+      return names
+        .map((name) => readId(name.slice(0, -5)))
+        .filter((record): record is AcquireCheckpoint => record !== null)
+        .sort((a, b) => a.updatedAt.localeCompare(b.updatedAt));
+    },
+  };
+}

package/src/acquireLinkedIn.ts

@@ -49,6 +49,8 @@ export type DiscoverLinkedInOptions = {
   sourceId?: string;
   /** Hard cap on prospects pulled. */
   max?: number;
+  /** Opaque provider continuation cursor. */
+  cursor?: string;
 };
 
 /**
@@ -60,7 +62,7 @@ export async function discoverLinkedInProspects(
   provider: LinkedInProvider,
   options: DiscoverLinkedInOptions = {},
 ): Promise<Prospect[]> {
-  const raw = await provider.fetchProspects({ sourceId: options.sourceId, max: options.max });
+  const raw = await provider.fetchProspects({ sourceId: options.sourceId, max: options.max, cursor: options.cursor });
   return raw.map(linkedInProspectToProspect);
 }
 

package/src/cli/audit.ts

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

package/src/cli/auth.ts

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

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})` +