fullstackgtm 0.48.0 → 0.49.0

package/src/cli/fix.ts

@@ -3,10 +3,11 @@
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { auditSnapshot, defaultPolicy } from "../audit.ts";
-import { loadConfig, mergePolicy, resolveConfiguredRules } from "../config.ts";
+import { loadConfig, mergePolicy, resolveConfiguredRules, rulePackageTrustFromCli } from "../config.ts";
 import { applyPatchPlan } from "../connector.ts";
 import { patchPlanToMarkdown } from "../format.ts";
 import { createFilePlanStore } from "../planStore.ts";
+import { verifyApprovalDigests } from "../integrity.ts";
 import { resolveRecord, type ResolveCandidate } from "../resolve.ts";
 import { parseAssignmentPolicy } from "../assign.ts";
 import { buildLeadRoutePlan } from "../route.ts";
@@ -213,8 +214,9 @@ export async function fixCommand(args: string[]) {
   }
   const includeCreates = args.includes("--include-creates");
 
-  const loaded = loadConfig(option(args, "--config") ?? undefined);
-  const configured = await resolveConfiguredRules(loaded);
+  const explicitConfig = option(args, "--config") ?? undefined;
+  const loaded = loadConfig(explicitConfig);
+  const configured = await resolveConfiguredRules(loaded, undefined, rulePackageTrustFromCli(args, explicitConfig));
   const rule = configured.find((candidate) => candidate.id === ruleId);
   if (!rule) {
     throw new Error(`Unknown rule: ${ruleId}. Available rules: ${configured.map((r) => r.id).join(", ")}`);
@@ -287,6 +289,22 @@ export async function fixCommand(args: string[]) {
     return;
   }
   const connector = await connectorFor(provider, args);
+  const claimed = await store.claimApply(plan.id, { provider, source: "fix" });
+  const { claimId } = claimed;
+  const claimedVerification = verifyApprovalDigests(
+    claimed.stored.plan.operations,
+    claimed.stored.approvedOperationIds,
+    claimed.stored.valueOverrides,
+    claimed.stored.approvalDigests,
+  );
+  if (!claimedVerification.ok) {
+    await store.abortApplyPreflight(
+      plan.id,
+      claimId,
+      "Approval integrity verification failed after the claim and before provider I/O.",
+    );
+    throw new Error(`Refusing to apply plan ${plan.id}: approval changed while acquiring the apply claim.`);
+  }
   // Live apply board on interactive terminals (stderr; inert otherwise); the
   // same emitter streams heartbeats to the paired hosted app on long runs.
   const renderer = createProgressRenderer(APPLY_STAGES);
@@ -295,15 +313,18 @@ export async function fixCommand(args: string[]) {
   );
   let run: PatchPlanRun;
   try {
-    run = await applyPatchPlan(connector, plan, {
-      approvedOperationIds: approvedIds,
-      valueOverrides: overrides,
+    run = await applyPatchPlan(connector, claimed.stored.plan, {
+      approvedOperationIds: claimed.stored.approvedOperationIds,
+      valueOverrides: claimed.stored.valueOverrides,
       progress,
     });
+  } catch (error) {
+    await store.markApplyUncertain(plan.id, claimId);
+    throw error;
   } finally {
     renderer.done();
   }
-  await store.recordRun(plan.id, run);
+  await store.recordRun(plan.id, run, claimId);
   const counts: Record<string, number> = { applied: 0, conflict: 0, skipped: 0, failed: 0 };
   for (const result of run.results) counts[result.status] = (counts[result.status] ?? 0) + 1;
   lines.push(

package/src/cli/help.ts

@@ -183,6 +183,7 @@ Usage:
   fullstackgtm plans list [--status <s>] | show <id> | 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> --channel outbox          (render approved openers; transmits nothing)
   fullstackgtm apply --plan <path> --provider <name> --approve <ids|all> [options]
@@ -230,6 +231,8 @@ Audit options:
   --config <path>        Config file (default: ./fullstackgtm.config.json if present)
                          { "policy": {...}, "rules": {"enabled":[],"disabled":[]},
                            "rulePackages": ["./team-rules.mjs"] }
+  --allow-plugins        Execute rulePackages from an explicit --config path after review
+  --no-plugins           Ignore rulePackages; use declarative config and built-in rules only
   --rules <ids>          Comma-separated rule ids to run (default: all; see \`rules\`)
   --json                 Print the JSON patch plan instead of markdown
   --out <path>           Also write the JSON patch plan to a file
@@ -546,6 +549,7 @@ export const HELP: Record<string, HelpEntry> = {
       "fullstackgtm plans list [--status <s>] | show <id> | 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.",
     seeAlso: ["audit", "suggest", "apply"],
@@ -644,12 +648,12 @@ export const HELP: Record<string, HelpEntry> = {
 
 // Verbs that print their own richer multi-subcommand help; runCli routes their
 // `--help` to themselves, so commandHelp() only renders these via `help <verb>`.
-export const BESPOKE_HELP = ["init", "call", "market", "tam", "enrich", "bulk-update", "schedule", "signals", "icp", "draft"];
+export const BESPOKE_HELP = ["init", "call", "market", "tam", "enrich", "schedule", "signals", "icp", "draft"];
 
 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", "--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"];
 
 // Complete per-command flag registry used by runCli's fail-closed flag
 // validation. Keep this next to HELP so focused help, machine capabilities,
@@ -666,13 +670,13 @@ export const COMMAND_FLAGS: Record<string, string[]> = {
   snapshot: [...SOURCE_FLAGS, "--since", "--out", "--archive"],
   audit: [...SOURCE_FLAGS, ...AUDIT_FLAGS],
   report: [...SOURCE_FLAGS, ...AUDIT_FLAGS, "--plan", "--client", "--title", "--prepared-by", "--format", "--max-examples"],
-  diff: ["--before", "--after", "--config", "--stale-days", "--today", "--json", "--fail-on-new-findings"],
-  rules: ["--config", "--json"],
+  diff: ["--before", "--after", "--config", "--allow-plugins", "--no-plugins", "--stale-days", "--today", "--json", "--fail-on-new-findings"],
+  rules: ["--config", "--allow-plugins", "--no-plugins", "--json"],
   resolve: [...SOURCE_FLAGS, "--name", "--domain", "--email", "--account-id", "--json"],
   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", "--rule", "--provider", "--min-confidence", "--include-creates", "--yes", "--confirm", "--dry-run"],
+  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"],
@@ -680,7 +684,7 @@ export const COMMAND_FLAGS: Record<string, string[]> = {
   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"],
   suggest: [...SOURCE_FLAGS, "--plan-id", "--plan", "--json", "--out"],
-  plans: ["--status", "--operations", "--value", "--values-from", "--min-confidence", "--include-creates", "--json"],
+  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"],
   "audit-log": ["--in", "--out", "--json"],
   merge: ["--input", "--out", "--json"],

package/src/cli/market.ts

@@ -4,7 +4,7 @@ import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { createFilePlanStore } from "../planStore.ts";
 import type { ParsedCall } from "../calls.ts";
-import { captureMarket, computeFrontStates, createFileObservationStore, diffFrontStates, loadCaptureTexts, loadMarketConfig, starterMarketConfig, validateObservationSet, verifyEvidenceSpans, type ObservationSet } from "../market.ts";
+import { captureMarket, computeFrontStates, createFileObservationStore, diffFrontStates, loadCaptureTexts, loadMarketConfig, observationId, starterMarketConfig, validateObservationSet, verifyEvidenceSpans, type ObservationSet } from "../market.ts";
 import { assessAxes, axesReportToText } from "../marketAxes.ts";
 import { computeDirectives, computeOverlayStats, directivesToPlan, overlayToMarkdown, type CallDocument } from "../marketOverlay.ts";
 import { computeScaleIndex, scaleReportToText } from "../marketScale.ts";
@@ -29,6 +29,7 @@ import { unknownSubcommandError } from "./suggest.ts";
  */
 const MARKET_SUBCOMMANDS = [
   "init", "capture", "classify", "worksheet", "observe", "fronts", "axes", "overlay", "scale", "report", "refresh",
+  "schema", "hints", "observe-template", "review",
 ];
 
 export async function marketCommand(args: string[]) {
@@ -42,9 +43,13 @@ export async function marketCommand(args: string[]) {
 market init --category <name> [--out <path>]   write a starter market.config.json
 market init --category <name> --auto --vendor <url> [--vendor <url>...] [--anchor <url>] [--max-claims n]
                                                LLM-propose vendors + claim taxonomy from seed pages (needs an API key)
+market schema                                  print exact MarketConfig + ObservationSet shapes and a tiny example
 market capture [--config <path>] [--run <label>]
 market classify [--run <label>] [--capture-run <label>] [--vendor <id>] [--model m] [--out <path>]
 market worksheet --vendor <id> [--capture-run <label>] [--out <path>]
+market hints [--vendor <id>] [--capture-run <label>] [--json]
+market observe-template [--run <label>] [--out <path>]
+market review --from <observations.json> [--json]
 market observe --from <observations.json|sets.jsonl|spool-dir> [--unverified]
 market fronts [--config <path>] [--run <label>] [--diff <prior-run>] [--json]
 market axes [--config <path>] [--run <label>] [--json]
@@ -86,6 +91,64 @@ recomputed deterministically on every invocation — never stored.`);
     return;
   }
 
+  if (subcommand === "schema") {
+    console.log(`MarketConfig shape:
+{
+  "category": "string",
+  "anchorVendor": "optional vendor id",
+  "vendors": [{
+    "id": "stable-vendor-id",
+    "name": "Vendor Name",
+    "urls": { "home": "https://...", "pricing": null, "product": ["https://..."] },
+    "aliases": ["optional alternate names"]
+  }],
+  "claims": [{
+    "id": "stable-claim-id",
+    "capability": "Specific differentiating capability",
+    "icp": "buyer/segment this claim matters to",
+    "pricingStructure": "pricing motion implied by the claim, or unknown",
+    "definition": "How to judge LOUD vs QUIET vs ABSENT from page text",
+    "terms": ["buyer/search terms for deterministic mention matching"]
+  }],
+  "surfaceRule": "LOUD = hero/primary positioning; QUIET = supported but secondary; ABSENT = no support; UNOBSERVABLE = no usable capture."
+}
+
+ObservationSet shape:
+{
+  "id": "set_run1",
+  "category": "same category as config",
+  "runLabel": "run-1",
+  "runAt": "2026-06-11T00:00:00.000Z",
+  "extractor": "manual|agent:<model>|llm:<provider>:<model>",
+  "observations": [{
+    "id": "stable observation id (any unique string is accepted)",
+    "vendorId": "vendor id from config",
+    "claimId": "claim id from config",
+    "observedAt": "2026-06-11",
+    "intensity": "loud|quiet|absent|unobservable",
+    "confidence": "high|medium|low",
+    "reason": "one reviewer-facing sentence",
+    "evidence": [{
+      "id": "ev1",
+      "sourceSystem": "web",
+      "sourceObjectType": "page",
+      "sourceObjectId": "source URL",
+      "text": "VERBATIM quote from captured page text",
+      "metadata": { "url": "source URL", "captureHash": "hash from worksheet" }
+    }]
+  }]
+}
+
+Rules:
+- exactly one observation per vendor × claim cell
+- loud/quiet require ≥1 verbatim evidence quote
+- absent/unobservable use [] evidence
+- unobservable means no usable captured page exists for the vendor; if pages were captured but the claim is unsupported, use absent
+- submit with: fullstackgtm market observe --from observations.json
+- derive outputs with: fullstackgtm market fronts --json; fullstackgtm market report --format md --out market-report.md`);
+    return;
+  }
+
   if (subcommand === "init") {
     const category = option(rest, "--category");
     if (!category) throw new Error("market init requires --category <name>");
@@ -162,7 +225,22 @@ recomputed deterministically on every invocation — never stored.`);
         return;
       }
       if (!rest.includes("--unverified")) {
-        const { textByHash } = loadCaptureTexts(config.category);
+        const { entries, textByHash } = loadCaptureTexts(config.category);
+        const usableVendorIds = new Set(
+          entries
+            .filter((entry) => entry.runLabel === set.runLabel && entry.captureHash && textByHash.has(entry.captureHash))
+            .map((entry) => entry.vendorId),
+        );
+        const unsupportedUnobservable = set.observations.filter((obs) => obs.intensity === "unobservable" && usableVendorIds.has(obs.vendorId));
+        if (unsupportedUnobservable.length > 0) {
+          console.error(`Rejected: ${unsupportedUnobservable.length} unobservable reading(s) for vendors with usable captures`);
+          for (const obs of unsupportedUnobservable.slice(0, 20)) {
+            console.error(`  - ${obs.vendorId} × ${obs.claimId}: vendor has captured page text; unsupported claims should be absent, not unobservable`);
+          }
+          console.error("Use unobservable only when no usable captured page exists for that vendor/run. (--unverified skips this gate when captures genuinely live elsewhere.)");
+          process.exitCode = 1;
+          return;
+        }
         const failures = verifyEvidenceSpans(set.observations, textByHash);
         if (failures.length > 0) {
           console.error(`Rejected: ${failures.length} evidence span(s) failed verification against the stored captures`);
@@ -195,6 +273,107 @@ recomputed deterministically on every invocation — never stored.`);
     return;
   }
 
+  if (subcommand === "hints") {
+    const vendorFilter = option(rest, "--vendor");
+    const vendorIds = vendorFilter ? [vendorFilter] : config.vendors.map((vendor) => vendor.id);
+    const worksheets = vendorIds.map((vendorId) => buildWorksheet(config, vendorId, { captureRun: option(rest, "--capture-run") ?? undefined }));
+    if (rest.includes("--json")) {
+      console.log(JSON.stringify({
+        category: config.category,
+        captureRun: worksheets[0]?.captureRun ?? null,
+        vendors: worksheets.map((worksheet) => ({ vendor: worksheet.vendor, claimHints: worksheet.claimHints })),
+      }, null, 2));
+      return;
+    }
+    for (const worksheet of worksheets) {
+      console.log(`\n## ${worksheet.vendor.id} — ${worksheet.vendor.name}`);
+      if (worksheet.pages.length === 0) {
+        console.log("No usable captures: classify every claim as unobservable.");
+        continue;
+      }
+      for (const hint of worksheet.claimHints) {
+        console.log(`\n${hint.claimId}`);
+        if (hint.matches.length === 0) {
+          console.log("  no lexical matches in captured text (usually absent; still inspect pages for synonyms)");
+          continue;
+        }
+        for (const match of hint.matches) console.log(`  - ${match.term} @ ${match.url}: ${match.quote}`);
+      }
+    }
+    return;
+  }
+
+  if (subcommand === "observe-template") {
+    const runLabel = option(rest, "--run") ?? "run-1";
+    const now = new Date().toISOString();
+    const observations = config.vendors.flatMap((vendor) => {
+      const worksheet = buildWorksheet(config, vendor.id, { captureRun: runLabel });
+      const noPages = worksheet.pages.length === 0;
+      return config.claims.map((claim) => ({
+        id: observationId(config.category, runLabel, vendor.id, claim.id),
+        vendorId: vendor.id,
+        claimId: claim.id,
+        observedAt: now.slice(0, 10),
+        intensity: noPages ? "unobservable" : "absent",
+        confidence: "low",
+        reason: noPages ? `No usable captures for ${vendor.name}; cannot judge.` : "TODO: inspect worksheet/hints and classify this cell.",
+        evidence: [],
+        _claimHints: worksheet.claimHints.find((hint) => hint.claimId === claim.id)?.matches ?? [],
+      }));
+    });
+    const set = { id: `set_${runLabel}`, category: config.category, runLabel, runAt: now, extractor: "manual-template", observations };
+    const payload = `${JSON.stringify(set, null, 2)}\n`;
+    const outPath = option(rest, "--out");
+    if (outPath) {
+      writeFileSync(resolve(process.cwd(), outPath), payload);
+      console.log(`Wrote ${outPath}: ${observations.length} template observations. Fill TODO cells, then run market review --from ${outPath}`);
+    } else {
+      console.log(payload);
+    }
+    return;
+  }
+
+  if (subcommand === "review") {
+    const fromPath = option(rest, "--from");
+    if (!fromPath) throw new Error("market review requires --from <observations.json>");
+    const set = JSON.parse(readFileSync(resolve(process.cwd(), fromPath), "utf8")) as ObservationSet;
+    const errors = validateObservationSet(config, set).map((detail) => ({ code: "invalid_observation_set", detail }));
+    const warnings: Array<{ code: string; detail: string }> = [];
+    const { entries, textByHash } = loadCaptureTexts(config.category);
+    const usableVendorIds = new Set(
+      entries
+        .filter((entry) => entry.runLabel === set.runLabel && entry.captureHash && textByHash.has(entry.captureHash))
+        .map((entry) => entry.vendorId),
+    );
+    for (const obs of set.observations) {
+      if (obs.intensity === "unobservable" && usableVendorIds.has(obs.vendorId)) {
+        errors.push({ code: "unobservable_with_captures", detail: `${obs.vendorId} × ${obs.claimId}: vendor has captured page text; use absent when unsupported.` });
+      }
+      if ((obs.intensity === "absent" || obs.intensity === "unobservable") && usableVendorIds.has(obs.vendorId)) {
+        const hints = buildWorksheet(config, obs.vendorId, { captureRun: set.runLabel }).claimHints.find((hint) => hint.claimId === obs.claimId)?.matches ?? [];
+        if (hints.length > 0) {
+          warnings.push({
+            code: "support_candidate_marked_absent",
+            detail: `${obs.vendorId} × ${obs.claimId}: ${hints.length} candidate snippet(s) matched terms but cell is ${obs.intensity}; verify absent vs quiet. Example: ${hints[0].quote}`,
+          });
+        }
+      }
+    }
+    for (const failure of verifyEvidenceSpans(set.observations, textByHash)) {
+      errors.push({ code: "bad_evidence", detail: `${failure.vendorId} × ${failure.claimId}: ${failure.problem}` });
+    }
+    const summary = { ok: errors.length === 0, errors, warnings };
+    if (rest.includes("--json")) {
+      console.log(JSON.stringify(summary, null, 2));
+    } else {
+      console.log(`${summary.ok ? "OK" : "FAILED"}: ${errors.length} error(s), ${warnings.length} warning(s)`);
+      for (const err of errors.slice(0, 20)) console.log(`ERROR ${err.code}: ${err.detail}`);
+      for (const warn of warnings.slice(0, 20)) console.log(`WARN  ${warn.code}: ${warn.detail}`);
+    }
+    if (errors.length > 0) process.exitCode = 1;
+    return;
+  }
+
   if (subcommand === "classify") {
     const credential = await requireLlmCredential("market classify");
     const vendorFilter = option(rest, "--vendor");

package/src/cli/plans.ts

@@ -3,7 +3,7 @@
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { auditSnapshot, defaultPolicy } from "../audit.ts";
-import { loadConfig, mergePolicy, resolveConfiguredRules } from "../config.ts";
+import { loadConfig, mergePolicy, resolveConfiguredRules, rulePackageTrustFromCli } from "../config.ts";
 import { applyPatchPlan } from "../connector.ts";
 import { diffFindings, diffSnapshots, diffToMarkdown } from "../diff.ts";
 import { createChannelConnector } from "../connectors/outboxChannel.ts";
@@ -234,6 +234,28 @@ export async function apply(args: string[]) {
   // A channel (e.g. outbox) renders approved ops to a local artifact and
   // transmits nothing; a CRM provider writes records. Same governed apply path.
   const connector = channel ? createChannelConnector(channel) : await connectorFor(provider!, args);
+  let applyClaimId: string | undefined;
+  if (planId && store) {
+    const claimed = await store.claimApply(planId, { provider: provider ?? `channel:${channel}`, source: "cli" });
+    applyClaimId = claimed.claimId;
+    const claimedVerification = verifyApprovalDigests(
+      claimed.stored.plan.operations,
+      claimed.stored.approvedOperationIds,
+      claimed.stored.valueOverrides,
+      claimed.stored.approvalDigests,
+    );
+    if (!claimedVerification.ok) {
+      await store.abortApplyPreflight(
+        planId,
+        claimed.claimId,
+        "Approval integrity verification failed after the claim and before provider I/O.",
+      );
+      throw new Error(`Refusing to apply plan ${planId}: approval changed while acquiring the apply claim.`);
+    }
+    plan = claimed.stored.plan;
+    approvedOperationIds = claimed.stored.approvedOperationIds;
+    valueOverrides = claimed.stored.valueOverrides;
+  }
   // Interactive terminals get a live apply board on stderr while the run
   // executes (preflight → operations → results, with a per-op safety ticker);
   // piped runs render nothing. Either way the emitter streams heartbeats to
@@ -249,11 +271,16 @@ export async function apply(args: string[]) {
       valueOverrides,
       progress,
     });
+  } catch (error) {
+    // Once applyPatchPlan starts, an exception cannot prove that the provider
+    // performed no write. Keep the claim fail-closed for operator reconciliation.
+    if (planId && store && applyClaimId) await store.markApplyUncertain(planId, applyClaimId);
+    throw error;
   } finally {
     renderer.done();
   }
   if (planId && store) {
-    await store.recordRun(planId, run);
+    await store.recordRun(planId, run, applyClaimId!);
   }
 
   // Charge the acquire meter for the creates that actually landed.
@@ -307,8 +334,9 @@ export async function diffCommand(args: string[]) {
     readFileSync(resolve(process.cwd(), afterPath), "utf8"),
   ) as CanonicalGtmSnapshot;
 
-  const loaded = loadConfig(option(args, "--config") ?? undefined);
-  const rules = selectedRules(args, await resolveConfiguredRules(loaded));
+  const explicitConfig = option(args, "--config") ?? undefined;
+  const loaded = loadConfig(explicitConfig);
+  const rules = selectedRules(args, await resolveConfiguredRules(loaded, undefined, rulePackageTrustFromCli(args, explicitConfig)));
   const policy = mergePolicy(defaultPolicy(), loaded?.config);
   const today = option(args, "--today");
   if (today) policy.today = today;
@@ -455,6 +483,13 @@ export async function plansCommand(args: string[]) {
     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) {
+      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));
     return;
@@ -520,5 +555,31 @@ export async function plansCommand(args: string[]) {
     return;
   }
 
-  throw unknownSubcommandError("plans", subcommand, ["list", "show", "approve", "reject"]);
+  if (subcommand === "recover") {
+    const planId = rest.find((arg) => !arg.startsWith("--"));
+    if (!planId) {
+      throw new Error("Usage: fullstackgtm plans recover <planId> --acknowledge-uncertain-writes");
+    }
+    const stored = await store.get(planId);
+    if (!stored) throw new Error(`No stored plan with id ${planId}.`);
+    if (stored.status !== "applying" || !stored.applyClaim) {
+      throw new Error(`Plan ${planId} has no unresolved apply attempt.`);
+    }
+    const attempt = stored.applyAttempts?.find((entry) => entry.id === stored.applyClaim?.id);
+    if (!rest.includes("--acknowledge-uncertain-writes")) {
+      throw new Error(
+        `Plan ${planId} has an unresolved ${attempt?.provider ?? "provider"} apply attempt (${stored.applyClaim.id}). ` +
+          "Inspect the affected records in the provider; do not replay automatically. If you accept that some writes may already have landed, " +
+          `run \`fullstackgtm plans recover ${planId} --acknowledge-uncertain-writes\`. This clears every approval and requires a fresh review and approval before retrying.`,
+      );
+    }
+    await store.recoverApply(planId);
+    console.log(
+      `Released ${planId} to needs_approval after acknowledging uncertain provider state. ` +
+        `No writes were replayed. Re-audit provider state, review the plan, then approve operations again before any apply.`,
+    );
+    return;
+  }
+
+  throw unknownSubcommandError("plans", subcommand, ["list", "show", "approve", "reject", "recover"]);
 }

package/src/cli/ui.ts

@@ -449,6 +449,7 @@ export function severityWord(word: string, p: Paint): string {
 export function planStatusWord(status: string, p: Paint): string {
   if (status === "needs_approval") return p.yellow(status);
   if (status === "approved" || status === "applied") return p.green(status);
+  if (status === "applying") return p.yellow(status);
   if (status === "rejected") return p.red(status);
   return status;
 }

package/src/cli.ts

@@ -91,7 +91,7 @@ export async function runCli(argv: string[]) {
   }
   // Commands without bespoke help get focused per-command help on --help
   // instead of executing (audit used to silently run the sample audit) or
-  // dumping the whole surface. call/market/enrich/bulk-update/schedule print
+  // dumping the whole surface. call/market/enrich/schedule print
   // their own richer help. `--full` always escapes to the complete reference.
   if (!BESPOKE_HELP.includes(command) && (args.includes("--help") || args.includes("-h"))) {
     console.log(args.includes("--full") ? usage() : commandHelp(command));

package/src/config.ts

@@ -35,6 +35,35 @@ export type LoadedConfig = {
   path: string;
 };
 
+export type RulePackageTrust = {
+  /** Execute rule-package modules. Only set after an explicit trust decision. */
+  allowRulePackages?: boolean;
+  /** Deliberately ignore rule packages while still applying declarative config. */
+  disableRulePackages?: boolean;
+};
+
+/**
+ * Translate the CLI's explicit trust flags into the library trust contract.
+ * Plugin execution requires both an explicit config path and --allow-plugins;
+ * discovering a config in the current directory is never a trust decision.
+ */
+export function rulePackageTrustFromCli(
+  args: string[],
+  explicitConfigPath?: string,
+): RulePackageTrust {
+  const allow = args.includes("--allow-plugins");
+  const disable = args.includes("--no-plugins");
+  if (allow && disable) {
+    throw new Error("--allow-plugins and --no-plugins cannot be used together.");
+  }
+  if (allow && !explicitConfigPath) {
+    throw new Error(
+      "--allow-plugins requires --config <path>. Plugin code is never trusted from an implicitly discovered config.",
+    );
+  }
+  return { allowRulePackages: allow, disableRulePackages: disable };
+}
+
 export function loadConfig(
   explicitPath?: string,
   cwd = process.cwd(),
@@ -73,10 +102,19 @@ export function mergePolicy(base: GtmPolicy, config?: FullstackgtmConfig): GtmPo
 export async function resolveConfiguredRules(
   loaded?: LoadedConfig | null,
   baseRules: GtmAuditRule[] = builtinAuditRules,
+  trust: RulePackageTrust = {},
 ): Promise<GtmAuditRule[]> {
   let rules = [...baseRules];
 
-  for (const specifier of loaded?.config.rulePackages ?? []) {
+  const packages = loaded?.config.rulePackages ?? [];
+  if (packages.length && !trust.allowRulePackages && !trust.disableRulePackages) {
+    throw new Error(
+      `Config ${loaded!.path} declares executable rulePackages. Refusing to load plugin code without explicit trust. ` +
+        "For the CLI, pass --config <path> --allow-plugins after reviewing the modules, or pass --no-plugins to use only declarative policy and built-in rules.",
+    );
+  }
+
+  for (const specifier of trust.disableRulePackages ? [] : packages) {
     const resolvedSpecifier =
       specifier.startsWith(".") || isAbsolute(specifier)
         ? pathToFileURL(resolve(dirname(loaded!.path), specifier)).href

package/src/connectors/prospectSources.ts

@@ -14,6 +14,7 @@
  * env/credential store, never argv.
  */
 import type { CanonicalGtmSnapshot } from "../types.ts";
+import { ProviderHttpError } from "../providerError.ts";
 
 export type Prospect = {
   firstName?: string;
@@ -79,7 +80,7 @@ export async function fetchExploriumProspects(opts: {
     body: JSON.stringify({ mode: "full", size, page_size: size, page: 1, filters: opts.filters }),
   });
   if (!response.ok) {
-    throw new Error(`Explorium /v1/prospects failed: HTTP ${response.status} ${await safeText(response)}`);
+    throw new ProviderHttpError("Explorium", "prospect search", response.status);
   }
   const data = (await response.json()) as { data?: ExploriumRow[] };
   return (data.data ?? []).map((row) => ({
@@ -132,7 +133,7 @@ export async function fetchPipe0CrustdataProspects(opts: {
     }),
   });
   if (!response.ok) {
-    throw new Error(`pipe0 /v1/searches/run/sync failed: HTTP ${response.status} ${await safeText(response)}`);
+    throw new ProviderHttpError("pipe0", "prospect search", response.status);
   }
   const body = (await response.json()) as {
     results?: Array<Record<string, { value?: unknown }>>;
@@ -214,7 +215,7 @@ export async function probeExploriumBusinessCount(opts: {
     body: JSON.stringify({ mode: "full", page_size: 1, page: 1, filters: opts.filters }),
   });
   if (!response.ok) {
-    throw new Error(`Explorium /v1/businesses count failed: HTTP ${response.status} ${await safeText(response)}`);
+    throw new ProviderHttpError("Explorium", "business count", response.status);
   }
   const body = (await response.json()) as { total_results?: unknown };
   const total = body.total_results;
@@ -427,14 +428,6 @@ function fieldValue(field: Pipe0Field | undefined): string | undefined {
   return typeof v === "string" && v.trim() ? v : undefined;
 }
 
-async function safeText(response: Response): Promise<string> {
-  try {
-    return (await response.text()).slice(0, 300);
-  } catch {
-    return "";
-  }
-}
-
 // ---------------------------------------------------------------------------
 // Pre-email dedup: identity keys shared between prospects and CRM contacts, so
 // we can drop already-in-CRM / already-seen people BEFORE paying for emails.