@nebulacomponents/citable 1.13.1 → 1.15.0

package/skill/agents/citable-auditor.md

@@ -0,0 +1,64 @@
+---
+name: citable-auditor
+description: Run a Citable audit or evidence collection when the user needs a plan, immutable or sealed run, observation, capability diagnosis, or evidence-bounded summary. Not for semantic approval, source remediation, content rewriting, or claims that an outcome is guaranteed.
+tools:
+  - Read
+  - Glob
+  - Grep
+  - Bash
+model: inherit
+maxTurns: 20
+skills:
+  - citable
+---
+
+You are Citable's evidence-collection specialist. Establish what the target
+makes observable, what the selected method could not collect, and where the
+resulting immutable evidence package lives.
+
+## Authority boundary
+
+- You may run the Citable CLI and read its artifacts.
+- Never edit the audited property, its source, its registries, or an existing
+  run package.
+- Do not use `curl`, `wget`, raw browser automation, or ad hoc HTTP clients.
+  Network collection must go through the applicable guarded Citable command.
+- Do not run `citable apply`, use `--write`, or create implementation facts.
+- Do not infer crawling, indexing, ranking, citation, recommendation,
+  inclusion, sentiment, or conversion outcomes.
+
+## Workflow
+
+1. Read repository instructions and identify the target and requested evidence
+   question.
+2. Run `citable doctor` when optional browser, API, OCR, or lab capability is
+   relevant. Treat `ready` as prerequisite presence only.
+3. Run `citable plan-audit --target <target>` when the appropriate scopes or
+   collectors are not already explicit. The plan is not evidence.
+4. Run `citable audit [scope] --target <target>` for deterministic and
+   heuristic site findings. Preserve the full audit unless the user explicitly
+   requested a scope.
+5. Run only the relevant `citable observe <mode>` commands for external or
+   rendered observations. Preserve provider, method, authority, authenticity,
+   collection, and representativeness boundaries.
+6. Read the run manifest, findings, summary, warnings, incomplete state, and
+   checksums before reporting.
+
+If prerequisites, authorization, source facts, or required inputs are absent,
+preserve `blocked`, `incomplete`, `not_established`, or `not_evidenced`.
+Never translate one of those states into zero, pass, absence, or failure of the
+external system.
+
+## Return contract
+
+Report:
+
+1. target, command, scope, and collection method;
+2. run ID and artifact directory;
+3. deterministic observations;
+4. evidence-backed semantic findings and probabilistic inferences, separately;
+5. skipped checks, collection failures, limitations, and residual unknowns;
+6. exact next evidence or owner input required;
+7. whether semantic review or a governed action plan is the next bounded step.
+
+A human-readable report without its run package is not a deliverable.

package/skill/agents/citable-semantic-reviewer.md

@@ -0,0 +1,66 @@
+---
+name: citable-semantic-reviewer
+description: Review semantic questions in an existing Citable run, finding, action, or artifact, including claim support, answer extractability, entity clarity, comparison fairness, and narrative accuracy. Not for collecting new evidence, running audits, editing source, or approving publication.
+tools:
+  - Read
+  - Glob
+  - Grep
+model: inherit
+maxTurns: 15
+skills:
+  - citable
+---
+
+You are Citable's read-only semantic reviewer. Evaluate meaning against the
+exact source evidence and review policy without changing technical findings,
+registries, source files, or sealed artifacts.
+
+## Preconditions
+
+Require an existing source run, finding, review item, or action artifact. Bind
+the review to the available run ID, finding ID and finding hash, review-item
+hash, policy, subject, captured evidence, and declared limitations. If the
+binding or source material is unavailable, return `review_required` with the
+missing input instead of reconstructing it.
+
+## Review dimensions
+
+Apply only dimensions relevant to the requested item:
+
+- intent alignment and answer extractability;
+- claim boundedness and evidence strength;
+- entity clarity and source identity;
+- information gain and comparison fairness;
+- recommendation eligibility and narrative accuracy;
+- factual accuracy, accessibility, conversion function, legal defensibility,
+  and maintainability.
+
+Separate deterministic fact from evidence-backed semantic finding,
+probabilistic inference, strategic hypothesis, experiment result, and
+untestable condition. Never present inference as fact.
+
+## Authority boundary
+
+- Never edit source files, registries, findings, review items, action plans, or
+  sealed run artifacts.
+- Do not collect new external evidence or treat general knowledge as source-run
+  evidence.
+- Do not change a technical failure to pass or accepted risk.
+- Do not mark a claim `verified`, complete a required review, approve
+  publication, or satisfy an owner-controlled gate. Automation cannot upgrade
+  evidence authority.
+- Preserve `review_required` when evidence or accountable authority is missing.
+- Preserve `adjudication_required` when current authorized reviewers disagree.
+
+## Return contract
+
+For each reviewed item, report:
+
+1. artifact binding and review dimensions applied;
+2. supporting and contradicting evidence;
+3. semantic assessment with confidence and false-positive conditions;
+4. missing evidence, ambiguity, residual risk, and required owner input;
+5. proposed disposition: `review_required`, `adjudication_required`, or a
+   recommendation for an authorized human reviewer to record.
+
+Your output is review context, not an approval or a mutation instruction.

package/skill/commands/README.md

@@ -21,9 +21,12 @@ intent, not executability, so statuses are strict:
 | /citable validate, validate-claims, validate-evidence, validate-schema, validate-links | implemented |
 | /citable compare-snapshots / validate-regression | implemented |
 | /citable action-plan | implemented — writes ordered, source-run-bound action artifacts outside immutable evidence packages |
-| /citable observe | implemented — render, index, citation, crawler-log, passage, consensus, performance, and corroboration evidence |
+| /citable observe | implemented — render, index, citation, crawler-log, passage, consensus, performance, corroboration, and stance evidence |
 | /citable apply | implemented — reviewed, hash-locked source replacements; dry run by default |
+| /citable connect status / configure / discover / validate / sync / read / apply / disconnect | implemented — GA4, GSC, WordPress, and Webflow adapters with hash-locked CMS remediation |
 | /citable monitor | implemented — compares immutable observation runs and emits evidence-linked alerts |
+| /citable report dashboard | implemented — folds each run's recorded summary into a cross-run Markdown/HTML trend; derives no new findings and no combined score |
+| /citable report share-of-voice | implemented — joins competitor registry against recorded citation observations to compute verified share-of-citation |
 | /citable metrics import | implemented — validates declared CSV/JSON metrics and writes immutable observations |
 | /citable objectives init / validate | implemented — user-owned metric selection, cohorts, windows, and guardrails |
 | /citable evaluate | implemented — independent baseline/evaluation comparisons with inconclusive handling |

package/skill/commands/action-findings.md

@@ -15,6 +15,11 @@ failure_behaviour: missing or invalid source run -> fail; review-required action
 3. Assign owners. Resolve each blocked action's exact required input. Missing
    facts, evidence, legal review, or semantic review are blockers, not drafting
    opportunities.
+   Treat `decision_owner` independently from implementation responsibility when
+   the generated plan names different roles. Empty `depends_on_action_ids`,
+   `leading_indicators`, or `monitoring_window` fields mean those relationships
+   are not established by the source evidence; do not fill them with generic
+   SEO assumptions.
 4. Capture a before state for each subject. Use the finding's evidence,
    preferred remediation, unsafe shortcuts, and detector lineage as the change
    boundary.
@@ -24,7 +29,10 @@ failure_behaviour: missing or invalid source run -> fail; review-required action
    writes use the loader/saver and retain history. Content claims remain equal
    to or narrower than their registered scope.
 7. Build and test the target repository. Run the generated verification
-   command, then compare the new audit to the source run.
+   command, evaluate the explicit `failure_condition`, then compare the new
+   audit to the source run. Monitor only the listed leading indicators over the
+   declared window; an empty list or null window does not authorize an inferred
+   outcome measure.
 8. Close only with evidence: resolved detector/subject pair, before/after run
    IDs, diff, reviewer, and residual risk. Mark blocked, accepted risk, and
    false positive explicitly; do not silently drop findings.

package/skill/commands/observe-and-act.md

@@ -19,22 +19,69 @@ failure_behaviour: unavailable dependency, credential, source run, reviewer, exa
   browser version, device, JavaScript, locale, consent, authentication state,
   and ordered interaction steps. Fill/select values are referenced by
   environment-variable name and are never written to the plan or artifacts.
+  Targets, subresources, and navigation steps must remain on public network
+  destinations; unsupported schemes and configured non-public address ranges
+  are blocked. DNS validation does not pin the later browser connection, so
+  isolated execution with egress controls remains required for untrusted URLs.
+  Plans may include a strict semantic-impact policy covering text retention,
+  heading, link, and structured-data parity. Deterministic violations name a
+  review owner and always remain `review_required`; passing configured checks
+  does not establish semantic or retrieval equivalence.
 - `observe index --input <JSON>` imports owner exports. With `--target`,
   `--site-url`, and `GSC_ACCESS_TOKEN`, it calls Google URL Inspection, which
   reports the indexed version rather than performing a live indexability test.
 - `observe citations --input <JSON>` imports complete controlled observations.
   With `--endpoint`, the input is a versioned prompt corpus and each prompt runs
   1-20 times (default 3) through the disclosed adapter protocol. An API is not
-  presumed equivalent to a provider's consumer search experience.
+  presumed equivalent to a provider's consumer search experience. Adapter
+  endpoints require HTTPS, must resolve only to public destinations, and may
+  not redirect.
+  Citation objects may include a strict `source_profile` containing declared
+  format, word and heading counts, freshness date, and evidence features.
+  Competitive summaries group these profiles by cited domain. Imported profile
+  values are comparative metadata, not independently fetched or verified
+  qualities.
 - `observe logs --input <JSON>` imports server/CDN records. User-agent matches
   without IP verification remain low confidence.
+- `observe probes --target <URL> [--region <label>]` sends one bounded synthetic
+  request for every active identity in `crawlers.yaml`, preserving response
+  bodies, safe diagnostic headers, redirects, and coarse edge/challenge
+  classification. The request merely spoofs each declared user agent: it does
+  not establish crawler identity, production access, regional
+  representativeness, or alignment between declared policy and actual crawler
+  treatment.
+- `observe network --input <JSON>` accepts a strict regional runner export with
+  region, network, user agent, DNS answers, TLS authorization/fingerprint,
+  status, latency, and cache state for every probe. Citable validates and seals
+  these observations but does not operate the runner or infer global coverage.
 - `observe passages|consensus --target <dir|URL>` performs static extraction.
+  Passage observations include raw/extracted byte and visible-token ratios plus
+  exact repeated header, navigation, aside, and footer regions across the
+  audited page cohort. These classifications are descriptive and do not imply
+  content harm, retrieval effects, or ranking effects.
+  Versioned passage records also join declared page prompts, questions, and
+  expected answer components. This only creates review context:
+  question-to-passage suitability remains `review_required`.
+  Consensus normalizes parseable HTTP, sitemap, and visible/meta freshness
+  dates, preserves conflicts and invalid values, and compares the current
+  content hash with the latest immutable page snapshot. A detected hash change
+  establishes only an interval after the prior capture—not an exact change
+  time, cause, quality improvement, or ranking effect. Lifecycle review dates
+  remain a separate governance signal.
+  `observe consensus --input <canonical-index-import.json>` additionally joins
+  schema-validated engine-selected canonical observations while preserving
+  their collection authority and authenticity. Missing engine observations
+  remain `null`; they are never inferred from static declarations.
 - `observe performance` imports evidence or calls CrUX with `CRUX_API_KEY`.
   `--lighthouse` instead performs 1-5 local lab runs (default 3) using optional
   `lighthouse` and `chrome-launcher` peers, preserving each result and a median
   summary. Lab evidence remains separate from CrUX field evidence.
-- `observe corroboration --input <JSON>` records observable external mentions;
-  controlled or unverified sources do not become authority claims.
+- `observe corroboration --input <JSON>` accepts only the versioned
+  `corroboration-import` contract. Each mention must disclose source control,
+  relationship, collection authority, authenticity, and dataset coverage.
+  Legacy independence booleans and undisclosed control fail closed. An
+  observable mention does not establish source authority, claim support,
+  ranking impact, citation eligibility, or representative coverage.
 
 ## Guarded remediation
 
@@ -44,9 +91,16 @@ reviewer, matches the exact file hash, and identifies exactly one source string.
 `--write` applies only after all operations validate. Build, tests, semantic
 review, re-audit, and snapshot comparison remain mandatory afterward.
 
-## Monitoring
+## Monitoring and alert delivery
 
-`monitor [runA runB]` reports state changes, missing observations, index loss,
-canonical disagreement, and citation-presence changes. Alerts are evidence
-changes, not causal explanations or ranking conclusions. Schedule it in CI at
-the cadence defined by lifecycle and experiment records.
+`monitor [runA runB] [--webhook <url>] [--min-severity <level>]` reports state
+changes, missing observations, index loss, canonical disagreement, and
+citation-presence changes. With `--webhook`, detected regressions matching or
+exceeding `--min-severity` (default `medium`) are dispatched as sealed JSON
+alert payloads and logged under `.citable/monitoring/deliveries/`. Destination
+URLs must be public network destinations (private/loopback addresses are blocked).
+Alerts are evidence changes, not causal explanations or ranking conclusions.
+
+Scheduled monitoring (`schedules run <id> --monitor [--webhook <url>]`) automatically
+compares the scheduled audit against the preceding baseline run and dispatches
+regression alerts when configured in `schedules.yaml`.

package/skill/commands/plan-audit.md

@@ -0,0 +1,35 @@
+---
+command: /citable plan-audit --target <dir|url>
+purpose: Inspect observable target signals and propose an evidence-bounded audit and collector plan without creating a run or treating inferred business profiles as facts.
+preconditions: [readable built output directory or permitted public URL]
+artifacts_created: []
+failure_behaviour: missing or unreadable target -> fail; fewer than two supporting signals -> no profile established; unavailable optional prerequisite -> collector blocked
+---
+
+# Profile-aware audit planning
+
+1. Run `citable plan-audit --target <dir|url>` before choosing optional
+   collectors. The command builds the same bounded site model used by audit but
+   does not create an audit, observation, snapshot, or remediation artifact.
+2. Treat every returned profile as `probabilistic_inference`. Preserve its
+   confidence and evidence list. A profile changes semantic emphasis only; it
+   does not suppress detectors or establish the target's business model.
+3. Use the proposed full audit as the deterministic baseline. Do not translate
+   an inferred profile into a reduced audit that could hide cross-discipline
+   findings.
+4. Read collector states independently. `available` means the prerequisite is
+   present, not that browser launch, authorization, property access, quota, or
+   collection will succeed. `blocked` lists the missing input and remains
+   unresolved until the relevant collector produces evidence.
+5. Keep profile-specific emphasis bounded:
+   SaaS focuses review on pricing, capability claims, and product identity;
+   e-commerce on product/offer support; local on identity/NAP and review
+   evidence; publisher on authorship/freshness; multilingual on hreflang and
+   parity; API/docs on machine interfaces and authentication claims.
+
+# Refusal boundary
+
+Do not invent an industry, customer segment, locale strategy, product catalog,
+local presence, or API capability to complete the plan. If no profile reaches
+the two-signal threshold, report that none is established and run the full
+audit without profile-specific emphasis.

package/skill/commands/reporting.md

@@ -0,0 +1,57 @@
+---
+command: /citable report dashboard [--last N] [--since <run-id>]
+purpose: Fold the summary each audit run already recorded into a cross-run Markdown table and self-contained HTML page without deriving new findings, scores, or causal explanations.
+preconditions: [at least one finalized audit run under .citable/runs/ with a summary.json]
+failure_behaviour: fewer than two audit runs -> explicit insufficient-history state, not a trend; unreadable summary or manifest -> run reported under skipped runs; non-integer --last -> fail
+artifacts_created: [.citable/reports/dashboard.md, .citable/reports/dashboard.html]
+---
+
+# Cross-run evidence reporting
+
+1. Run `citable report dashboard` to read severity counts, retrieval
+   eligibility, source extraction and support, and observed citation presence
+   rate across run history. Every value is copied from a run's own
+   `summary.json`. The command runs no detector, opens no network connection,
+   and never edits an immutable run package.
+2. Treat the output as derived, not canonical. It is written to
+   `.citable/reports/`, alongside `monitor` and `action-plan` derived
+   artifacts. The evidence of record remains `.citable/runs/<run-id>/`.
+3. Window the history with `--since <run-id>` (keeps that run and everything
+   after it) and `--last N` (keeps the final N runs). Run IDs sort
+   chronologically, so both filters are deterministic.
+4. Read fewer than two runs as no trend. With zero or one run the dashboard
+   states insufficient history explicitly instead of drawing a line through a
+   single point. Direction, rate of change, and improvement are not established
+   by one observation.
+5. Read skipped runs as a gap in the series, not as absence of a problem. A run
+   whose `summary.json` or `manifest.json` cannot be parsed, and an observation
+   run whose summary records no severity or posture, is listed with its reason
+   rather than counted as zero findings.
+6. Read a falling count as an observed difference between runs, not as proof
+   that a condition was fixed. Use `citable compare-snapshots` to establish
+   whether two runs are comparable at all — detector set, configuration,
+   observation method, and tool version all change what a count means.
+
+# Refusal boundary
+
+Do not present the dashboard as an AI visibility score, a ranking forecast, or
+a measure of citation likelihood. The three posture dimensions are reported
+separately and are never combined into a single number. Do not interpolate,
+estimate, or carry forward a missing value: a run with no evidenced citation
+presence rate is omitted from that trend line, not filled in. Do not attribute
+any observed change to a specific intervention.
+
+# Share of voice and competitor reporting
+
+1. Run `citable report share-of-voice [--last N] [--since <run-id>]` to evaluate
+   first-party and competitor citation presence and share across recorded
+   `observe citation` runs.
+2. Contested competitor domains are loaded from `.citable/competitors.yaml`.
+   Citations whose canonical URL matches declared competitor domains are joined
+   into per-prompt and aggregate shares.
+3. Competitor share is calculated strictly from evidenced observations; missing
+   observations or unevaluated prompts are never filled with fabricated zeros or
+   interpolated estimates.
+4. Outputs are written to `.citable/reports/share-of-voice.md` and
+   `.citable/reports/share-of-voice.html`.
+

package/src/cli/index.js

@@ -3,6 +3,8 @@ import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { init } from '../commands/init.js';
 import { audit } from '../commands/audit.js';
+import { planAudit } from '../commands/planAudit.js';
+import { demo } from '../commands/demo.js';
 import { validate } from '../commands/validate.js';
 import { mapClaims } from '../commands/mapClaims.js';
 import { substantiate } from '../commands/substantiate.js';
@@ -14,9 +16,11 @@ import { projectGithub, runSchedule } from '../commands/delivery.js';
 import { actionPlan } from '../commands/actionPlan.js';
 import { observe } from '../commands/observe.js';
 import { applyRemediation } from '../commands/applyRemediation.js';
-import { monitor } from '../commands/monitor.js';
+import { monitor, monitorAndAlert } from '../commands/monitor.js';
+import { reportDashboard } from '../commands/reportDashboard.js';
+import { reportShareOfVoice } from '../commands/reportShareOfVoice.js';
 import { evaluateObjective, importMetrics, initializeObjective, validateObjectives } from '../commands/measurement.js';
-import { configureConnection, connectionStatus, discoverConnections, disconnectConnection, syncConnection, validateConnection } from '../commands/connect.js';
+import { configureConnection, connectionStatus, discoverConnections, disconnectConnection, syncConnection, validateConnection, readCmsContent, applyCmsRemediation } from '../commands/connect.js';
 import { evaluateDispositions, validateGovernance } from '../commands/governance.js';
 import { evaluateReviews, initializeSamplingPlan, prioritizeReviews, queueReviews, selectSample } from '../commands/reviews.js';
 import { selfUpgradeCommand, selfUpgradeExitCode } from '../commands/selfUpgrade.js';
@@ -49,9 +53,11 @@ Commands
   uninstall                 Remove managed Citable skill files
   list                      List detected providers and installation state
   doctor                    Diagnose installer, provider, and integrity problems
-  init                      Initialize .citable/ context and registries (non-destructive)
+  init [--seed <name>]      Initialize .citable/ context and registries (non-destructive)
+  demo                      Run the detector engine against a bundled offline example (no setup, no network)
   audit [scope]             Run detectors; scopes: technical seo aeo geo architecture entity
                             claims evidence schema lifecycle corroboration
+  plan-audit                Inspect target signals and propose an evidence-bounded audit plan
   inspect <page>            Profile one page (URL path or source file)
   map-claims                Extract material claim candidates from pages (--write to save)
   substantiate              Assess claim/evidence status (--write to apply downgrades)
@@ -60,15 +66,20 @@ Commands
   compare-snapshots [a b]   Regression diff between two audit runs
   action-plan [run]         Turn audit findings into ordered remediation work
   observe <mode>            Collect render, index, citation, log, Bing, passage,
-                            consensus, performance, corroboration, media evidence, or representation evidence
+                            consensus, performance, corroboration, crawler or regional probes,
+                            media evidence, or representation evidence
   apply                     Apply a reviewed, hash-locked remediation spec
-  monitor [runA runB]       Compare observation runs and emit regression alerts
+  monitor [runA runB]       Compare observation runs and emit regression alerts [--webhook <url>]
+  report dashboard [--last N] [--since <run-id>]   Render a cross-run evidence trend as Markdown + HTML
+  report share-of-voice [--last N]                 Compute first-party and competitor citation share
   metrics import            Import declared metric observations from CSV/JSON
   connect status            List optional connectors and configured connections
   connect configure         Configure non-secret connection state (--write to save)
   connect discover          Discover provider properties using environment auth
   connect validate          Verify configured property access
   connect sync              Collect declared metrics into immutable observations
+  connect read              Read CMS content and hash for remediation targeting
+  connect apply             Apply reviewed, hash-locked CMS remediation (--write to apply)
   connect disconnect        Remove optional connection state (--write to confirm)
   objectives init           Validate/add one objective from --input (--write to save)
   objectives validate       Validate objective contracts and metric references
@@ -80,7 +91,7 @@ Commands
   reviews plan              Validate/add a sampling plan from --input
   reviews sample [plan]     Select a reproducible census or seeded random sample
   reviews evaluate          Detect stale decisions and require disagreement adjudication
-  schedules run [id]        Execute an active version-pinned audit schedule
+  schedules run [id]        Execute an active version-pinned schedule [--monitor] [--webhook <url>]
   project github [run]      Render non-authoritative GitHub annotations from a run
   corpus evaluate           Evaluate a disclosed real-property acceptance corpus
   corpus publish            Validate and project an owner-authorized public corpus
@@ -129,6 +140,7 @@ Options
   --user-agent <value>      Disclosed request identity for representation evidence
   --lighthouse              Run local, repeated Lighthouse lab observations
   --ocr                     Explicitly request optional OCR for media images
+  --seed <name>             Overlay a bundled starter registry seed (all entries default to unverified)
   --write                   Persist registry changes (map-claims, substantiate)
   --json                    Machine-readable output only
 
@@ -150,6 +162,8 @@ function parseArgs(argv) {
     else if (a === '--input') args.input = argv[++i];
     else if (a === '--output') args.output = argv[++i];
     else if (a === '--run') args.runId = argv[++i];
+    else if (a === '--since') args.since = argv[++i];
+    else if (a === '--last') args.last = argv[++i];
     else if (a === '--provider') args.provider = argv[++i];
     else if (a === '--dataset') args.dataset = argv[++i];
     else if (a === '--connection-id') args.connectionId = argv[++i];
@@ -168,6 +182,13 @@ function parseArgs(argv) {
     else if (a === '--user-agent') args.userAgent = argv[++i];
     else if (a === '--timeout') args.timeout = Number(argv[++i]);
     else if (a === '--force') args.force = true;
+    else if (a === '--seed') args.seed = argv[++i];
+     else if (a === '--webhook') args.webhook = argv[++i];
+    else if (a === '--min-severity') args.minSeverity = argv[++i];
+    else if (a === '--monitor') args.monitor = true;
+    else if (a === '--target-id') args.targetId = argv[++i];
+    else if (a === '--reviewer') args.reviewer = argv[++i];
+    else if (a === '--entity') args.entity = argv[++i];
     else args._.push(a);
   }
   return args;
@@ -191,8 +212,25 @@ export async function main(argv = process.argv.slice(2), options = {}) {
   try {
     switch (cmd) {
       case 'init': {
-        const r = init(root, { force: args.force });
-        out(args, `Initialized .citable/\n  created: ${r.created.join(', ') || 'nothing'}\n  skipped: ${r.skipped.join(', ') || 'nothing'}\n  detected framework: ${r.detected.framework ?? 'unknown'}\n  unresolved assumptions:\n${r.unresolved.map((u) => `    - ${u}`).join('\n') || '    none'}`, r);
+        const r = init(root, { force: args.force, seed: args.seed });
+        const seedLines = r.seed
+          ? `\n  seed "${r.seed.seedName}@${r.seed.seedVersion}": ` +
+            Object.entries(r.seed.registriesTouched).map(([k, v]) => `${k}(+${v.added}/skip ${v.skipped})`).join(', ') +
+            (r.seed.warnings.length ? `\n  seed warnings:\n${r.seed.warnings.map((w) => `    - ${w}`).join('\n')}` : '')
+          : '';
+        out(args, `Initialized .citable/\n  created: ${r.created.join(', ') || 'nothing'}\n  skipped: ${r.skipped.join(', ') || 'nothing'}\n  detected framework: ${r.detected.framework ?? 'unknown'}\n  unresolved assumptions:\n${r.unresolved.map((u) => `    - ${u}`).join('\n') || '    none'}${seedLines}`, r);
+        break;
+      }
+      case 'demo': {
+        const r = await demo();
+        const nsLines = Object.entries(r.summary.by_namespace)
+          .sort(([a], [b]) => a.localeCompare(b))
+          .map(([ns, n]) => `  ${ns}: ${n} finding(s)`).join('\n') || '  no findings';
+        out(args,
+          `citable demo — offline audit of a bundled synthetic example site (not live, not a real company)\n${nsLines}\n\n` +
+          `This is a fixed demonstration fixture, not your site. Run "citable init" to set up your own governed context, ` +
+          `then "citable audit --target <dir|url>" against your real site.`,
+          r);
         break;
       }
       case 'audit': {
@@ -201,6 +239,13 @@ export async function main(argv = process.argv.slice(2), options = {}) {
         out(args, `Audit ${r.runId}: ${r.summary.total} finding(s) [${Object.entries(r.summary.by_severity).map(([k, v]) => `${k}:${v}`).join(' ')}]\nEvidence package: ${r.dir}\nReport: ${path.join(r.dir, 'report.md')}\nStatus: ${r.manifest.status}${r.manifest.incomplete_checks.length ? `\nIncomplete: ${r.manifest.incomplete_checks.join('; ')}` : ''}`, { runId: r.runId, dir: r.dir, summary: r.summary, status: r.manifest.status });
         break;
       }
+      case 'plan-audit': {
+        const r = await planAudit(root, { target: args.target, baseUrl: args.baseUrl, refDate: args.refDate });
+        const profiles = r.classification.profiles.map((profile) => `${profile.id}:${profile.confidence}`).join(', ') || 'none established';
+        const collectors = r.collectors.map((collector) => `  ${collector.id}: ${collector.status}`).join('\n');
+        out(args, `plan-audit\nProfiles (inference): ${profiles}\nAudit: ${r.audit.command}\nCollectors:\n${collectors}\n\nNo audit or observation package was created.`, r);
+        break;
+      }
       case 'inspect': {
         if (!args._[0]) throw new Error('usage: citable inspect <page> --target <dir|url>');
         const r = await inspect(root, args._[0], { target: args.target, baseUrl: args.baseUrl, refDate: args.refDate });
@@ -243,7 +288,11 @@ export async function main(argv = process.argv.slice(2), options = {}) {
       case 'observe': {
         const mode = args._[0];
         const r = await observe(root, mode, args);
-        out(args, `observe ${mode}: ${r.summary.total} observation(s) [${Object.entries(r.summary.by_state).map(([k, v]) => `${k}:${v}`).join(' ')}]\nEvidence package: ${r.dir}\nStatus: ${r.manifest.status}`, r);
+        const claimDiffLine = r.summary.citation_metrics?.claim_diff
+          ? `\nClaim diff: ${Object.entries(r.summary.citation_metrics.claim_diff).map(([k, v]) => `${k}:${v}`).join(' ')}` : '';
+        const stanceLine = r.summary.stance_metrics
+          ? `\nStance summary: favorable:${r.summary.stance_metrics.favorable} neutral:${r.summary.stance_metrics.neutral} unfavorable:${r.summary.stance_metrics.unfavorable} mixed:${r.summary.stance_metrics.mixed} review_required:${r.summary.stance_metrics.review_required}` : '';
+        out(args, `observe ${mode}: ${r.summary.total} observation(s) [${Object.entries(r.summary.by_state).map(([k, v]) => `${k}:${v}`).join(' ')}]${claimDiffLine}${stanceLine}\nEvidence package: ${r.dir}\nStatus: ${r.manifest.status}`, r);
         break;
       }
       case 'apply': {
@@ -252,11 +301,35 @@ export async function main(argv = process.argv.slice(2), options = {}) {
         break;
       }
       case 'monitor': {
-        const r = monitor(root, { runA: args._[0], runB: args._[1] });
-        out(args, `monitor ${r.run_a} → ${r.run_b}: ${r.summary.alerts} alert(s), ${r.summary.critical_or_high} critical/high\nReport: ${path.join(r.dir, 'latest.json')}`, r);
+        const r = await monitorAndAlert(root, {
+          runA: args._[0],
+          runB: args._[1],
+          webhookUrl: args.webhook,
+          minSeverity: args.minSeverity,
+        });
+        let msg = `monitor ${r.run_a} → ${r.run_b}: ${r.summary.alerts} alert(s), ${r.summary.critical_or_high} critical/high\nReport: ${path.join(r.dir, 'latest.json')}`;
+        if (r.delivery) {
+          if (r.delivery.skipped) msg += `\nDelivery: skipped (${r.delivery.reason})`;
+          else if (r.delivery.success) msg += `\nDelivery: webhook dispatched to ${r.delivery.target_url} (HTTP ${r.delivery.status_code})`;
+          else msg += `\nDelivery: webhook FAILED (${r.delivery.error})`;
+        }
+        out(args, msg, r);
         if (r.summary.critical_or_high > 0) process.exitCode = 1;
         break;
       }
+      case 'report': {
+        const sub = args._[0];
+        if (sub === 'dashboard') {
+          const r = reportDashboard(root, { since: args.since, last: args.last ? Number(args.last) : undefined });
+          out(args, `report dashboard: ${r.included} audit run(s) included, ${r.skipped} skipped\nMarkdown: ${r.path_md}\nHTML: ${r.path_html}`, r);
+        } else if (sub === 'share-of-voice' || sub === 'citations' || sub === 'share') {
+          const r = reportShareOfVoice(root, { since: args.since, last: args.last ? Number(args.last) : undefined });
+          out(args, `report share-of-voice: ${r.included} citation run(s) included, ${r.competitors_evaluated} competitor(s) evaluated\nMarkdown: ${r.path_md}\nHTML: ${r.path_html}`, r);
+        } else {
+          throw new Error('usage: citable report <dashboard|share-of-voice> [--last <n>] [--since <run-id>]');
+        }
+        break;
+      }
       case 'metrics': {
         if (args._[0] !== 'import') throw new Error('usage: citable metrics import --provider <name> --input <csv|json>');
         const r = importMetrics(root, { input: args.input, provider: args.provider });
@@ -281,10 +354,16 @@ export async function main(argv = process.argv.slice(2), options = {}) {
         } else if (mode === 'sync') {
           const r = await syncConnection(root, args);
           out(args, `connect sync ${r.connection_id}: ${r.summary.total} metric observation(s)\nEvidence package: ${r.dir}`, r);
+        } else if (mode === 'read') {
+          const r = await readCmsContent(root, args);
+          out(args, `connect read ${r.connection_id} [${r.target_id}]: title="${r.content.title}" hash=${r.content.content_hash.slice(0, 12)}…\nURL: ${r.content.url || 'n/a'}`, r);
+        } else if (mode === 'apply') {
+          const r = await applyCmsRemediation(root, args);
+          out(args, `connect apply ${r.connection_id} [${r.target_id}]: ${r.status} ${r.dry_run ? '(dry run; use --write to apply)' : 'applied'}\nBefore: ${r.before_hash?.slice(0, 12)}… After: ${r.after_hash?.slice(0, 12)}…\nReviewer: ${r.reviewer}`, r);
         } else if (mode === 'disconnect') {
           const r = disconnectConnection(root, args);
           out(args, `connect disconnect ${r.connection_id}: ${r.disconnected ? 'removed' : 'dry run; use --write to remove'}`, r);
-        } else throw new Error('usage: citable connect <status|configure|discover|validate|sync> [options]');
+        } else throw new Error('usage: citable connect <status|configure|discover|validate|sync|read|apply|disconnect> [options]');
         break;
       }
       case 'objectives': {
@@ -330,9 +409,30 @@ export async function main(argv = process.argv.slice(2), options = {}) {
         break;
       }
       case 'schedules': {
-        if(args._[0]!=='run') throw new Error('usage: citable schedules run <schedule-id> [--ref-date YYYY-MM-DD]');
-        const r=await runSchedule(root,{scheduleId:args._[1],refDate:args.refDate});
-        out(args,`schedule ${r.schedule_execution.schedule_id}: audit ${r.runId}\nEvidence package: ${r.dir}\nExecution record: ${r.execution_file}`,r);
+        if (args._[0] !== 'run') throw new Error('usage: citable schedules run <schedule-id> [--ref-date YYYY-MM-DD] [--webhook <url>] [--monitor]');
+        const r = await runSchedule(root, {
+          scheduleId: args._[1],
+          refDate: args.refDate,
+          webhook: args.webhook,
+          monitor: args.monitor,
+          minSeverity: args.minSeverity,
+        });
+        let msg = `schedule ${r.schedule_execution.schedule_id}: audit ${r.runId}\nEvidence package: ${r.dir}\nExecution record: ${r.execution_file}`;
+        if (r.schedule_execution.monitor) {
+          const m = r.schedule_execution.monitor;
+          if (m.status === 'insufficient_history') {
+            msg += `\nMonitor: insufficient history (${m.message})`;
+          } else {
+            msg += `\nMonitor: compared to ${m.baseline_run} (${m.regressions_count} regression(s), ${m.summary.regression_critical_or_high} critical/high)`;
+          }
+        }
+        if (r.schedule_execution.alert_delivery) {
+          const d = r.schedule_execution.alert_delivery;
+          if (d.skipped) msg += `\nAlert delivery: skipped (${d.reason})`;
+          else if (d.success) msg += `\nAlert delivery: dispatched to ${d.target_url} (HTTP ${d.status_code})`;
+          else msg += `\nAlert delivery: FAILED (${d.error})`;
+        }
+        out(args, msg, r);
         break;
       }
       case 'project': {