diff --git a/.env.example b/.env.example
index cc1280d..9f37759 100644
--- a/.env.example
+++ b/.env.example
@@ -55,3 +55,12 @@ CRAWL_MAX_DAYS=30
 # Loyalty: "spent cents:percent off" pairs. The more an agent has paid, the less a day costs.
 CRAWL_LOYALTY=1000:20,5000:40,10000:60
 CRAWL_FLOOR_CENTS=10
+
+# The agent question loop. CHOVY_SIGNING_SECRET signs both directions
+# (X-Chovy-Signature: t=<unix>,v1=<hmac-sha256 of "t.body">). Unset means the
+# internal routes answer 503 rather than accepting unsigned work, because a
+# question creates a scored contribution and moves somebody's revenue share.
+CHOVY_SIGNING_SECRET=
+# Optional: where an answered question is delivered back. Without it the loop
+# still records and scores; the agent has to come and read instead.
+CHOVY_WEBHOOK_URL=
diff --git a/README.md b/README.md
index e699248..164237d 100644
--- a/README.md
+++ b/README.md
@@ -93,6 +93,13 @@ public page (plus `skill.md` and `manifest.json` for agents), `/@<handle>` is an
 operator's profile, `/dashboard/niches` is their own view, and
 `/admin/knowledge` is where claims and contributions are verified.
 
+When an agent gets stuck on something only a person who has done the job can
+settle, it asks: the question lands on the operator's dashboard, the answer
+becomes niche knowledge and a scored contribution, and Chovy is told. Saying
+"not enough context" is a first-class answer that costs nothing, because a
+guess that gets verified is worse for the niche than an open question. See
+[docs/agent-questions.md](docs/agent-questions.md).
+
 Score comes only from contributions somebody verified, and volume does not buy
 it: repeated submissions of a type pay less each time, anything claiming a
 customer or a payment needs an outside reference, and a duplicate books once.
diff --git a/apps/web/public/styles.css b/apps/web/public/styles.css
index 172d71f..a4f0ae3 100644
--- a/apps/web/public/styles.css
+++ b/apps/web/public/styles.css
@@ -934,3 +934,37 @@ td.evidence {
   max-width: 22rem;
   overflow-wrap: anywhere;
 }
+
+/* the agent question loop */
+.card.question {
+  gap: 0.5rem;
+}
+.badge.urgent {
+  display: inline-block;
+  font-size: 0.7rem;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  padding: 0.1rem 0.4rem;
+  border-radius: var(--radius-lg);
+  border: 1px solid var(--destructive);
+  color: var(--destructive);
+}
+/* What the agent scraped on its way to being stuck. Quoted so a reader can see
+   it is reported text and not the site talking, and collapsed so it does not
+   bury the question it is context for. */
+.agent-summary {
+  cursor: pointer;
+  font-size: 0.8rem;
+  color: var(--muted);
+}
+.agent-quote {
+  margin: 0.4rem 0 0;
+  padding: 0.5rem 0.75rem;
+  border-left: 2px solid var(--border);
+  color: var(--muted);
+  font-size: 0.85rem;
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+  max-height: 18rem;
+  overflow-y: auto;
+}
diff --git a/apps/web/src/app.js b/apps/web/src/app.js
index 2e390a5..41bf72f 100644
--- a/apps/web/src/app.js
+++ b/apps/web/src/app.js
@@ -6,6 +6,7 @@ import { modulesFor, withModules } from './lib/modules.js';
 import { partners } from './lib/partners.js';
 import { gateway, gatewayFor } from './lib/pricing.js';
 import { Denied } from './lib/service.js';
+import { registerAgents } from './routes/agents.js';
 import { registerApi } from './routes/api.js';
 import { registerAuth } from './routes/auth.js';
 import { registerAutomotive } from './routes/automotive.js';
@@ -100,6 +101,12 @@ registerApi(app);
 registerAutomotive(app);
 registerMcp(app);
 
+/**
+ * The agent question loop. Before the niche routes, because its dashboard and
+ * API paths are literal and must be matched before `/:slug` is asked.
+ */
+registerAgents(app);
+
 /**
  * Last, because a niche's page is served from the site root: every other
  * route is registered before `/:slug` can be asked. A niche may not take a
diff --git a/apps/web/src/lib/chovy.js b/apps/web/src/lib/chovy.js
new file mode 100644
index 0000000..e1e05d9
--- /dev/null
+++ b/apps/web/src/lib/chovy.js
@@ -0,0 +1,73 @@
+import { config } from '@nichedb/config';
+import { domainEvent } from '@nichedb/knowledge';
+import { SIGNATURE_HEADER, signPayload, verifySignature } from '@nichedb/knowledge/signing';
+
+/**
+ * The wire between NicheDB and Chovy.
+ *
+ * Both directions are signed with the same secret and the same scheme, so the
+ * side that signs a question verifies the answer with the code it already has.
+ * Neither side reads the other's tables; everything crosses as an event with a
+ * globally unique id, which is what makes a redelivery cheap to ignore.
+ */
+
+export const chovyConfigured = () => Boolean(config.chovy.signingSecret);
+
+/**
+ * Check the signature on an internal request.
+ *
+ * Returns the reason on failure so an integrator debugging a 401 can tell a
+ * wrong secret from a wrong clock. The reason is safe to return: it says
+ * nothing a caller holding the body does not already know.
+ */
+export async function verifyInternalRequest(c) {
+  if (!chovyConfigured())
+    return { ok: false, status: 503, reason: 'this deployment has no CHOVY_SIGNING_SECRET' };
+
+  // The raw text, not a re-serialised object: an HMAC is over bytes, and
+  // JSON.stringify(JSON.parse(x)) is not always x.
+  const rawBody = await c.req.text();
+  const result = verifySignature({
+    rawBody,
+    header: c.req.header(SIGNATURE_HEADER),
+    secret: config.chovy.signingSecret,
+  });
+  if (!result.ok) return { ok: false, status: 401, reason: result.reason };
+
+  try {
+    return { ok: true, body: rawBody ? JSON.parse(rawBody) : {}, rawBody };
+  } catch {
+    return { ok: false, status: 400, reason: 'body is not JSON' };
+  }
+}
+
+/**
+ * Tell Chovy something happened.
+ *
+ * Never throws and never blocks the thing that triggered it. An operator's
+ * answer is recorded and scored whether or not the agent is reachable; a
+ * delivery that failed is a log line, not a lost contribution. Without a
+ * configured URL this is a no-op, which is the normal state until a Chovy
+ * deployment exists to point at.
+ */
+export async function notifyChovy(type, { payload, nicheId = null, userId = null } = {}) {
+  if (!chovyConfigured() || !config.chovy.webhookUrl) return { sent: false, reason: 'not wired' };
+  const event = domainEvent({ type, producer: 'nichedb', payload, nicheId, userId });
+  const rawBody = JSON.stringify(event);
+  try {
+    const res = await fetch(config.chovy.webhookUrl, {
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        [SIGNATURE_HEADER]: signPayload({ rawBody, secret: config.chovy.signingSecret }),
+      },
+      body: rawBody,
+      signal: AbortSignal.timeout(5000),
+    });
+    if (!res.ok) console.error('[chovy] delivery refused', type, res.status);
+    return { sent: res.ok, status: res.status, eventId: event.id };
+  } catch (err) {
+    console.error('[chovy] could not deliver', type, err?.message ?? err);
+    return { sent: false, reason: String(err?.message ?? err) };
+  }
+}
diff --git a/apps/web/src/routes/agents.js b/apps/web/src/routes/agents.js
new file mode 100644
index 0000000..f121f65
--- /dev/null
+++ b/apps/web/src/routes/agents.js
@@ -0,0 +1,208 @@
+import * as a from '@nichedb/db/agents';
+import * as k from '@nichedb/db/knowledge';
+import { chovyConfigured, notifyChovy, verifyInternalRequest } from '../lib/chovy.js';
+import { render, requireUser, respond } from '../lib/http.js';
+import { isAdmin } from '../lib/service.js';
+import { NicheQuestions } from '../views/knowledge.jsx';
+
+/**
+ * The agent question loop.
+ *
+ * An agent gets stuck on something only a person who has done the job can
+ * settle, and asks. The operator answers in about two minutes, the answer
+ * becomes scored knowledge, and Chovy is told.
+ *
+ * The internal route is signed. Everything else here is an ordinary
+ * authenticated page or endpoint, because answering is a thing a person does.
+ */
+export function registerAgents(app) {
+  /* -------------------------------------------------------------- internal -- */
+
+  /**
+   * An agent asking for judgement.
+   *
+   * Signed with CHOVY_SIGNING_SECRET, because this creates work that pays: an
+   * unsigned endpoint here is a way to mint scored contributions.
+   */
+  app.post('/api/v1/internal/expert-questions', async (c) => {
+    const auth = await verifyInternalRequest(c);
+    if (!auth.ok) return c.json({ error: auth.reason }, auth.status);
+
+    const payload = auth.body?.payload ?? auth.body ?? {};
+    const slug = payload.nicheSlug ?? payload.niche ?? null;
+    const niche = slug ? await k.getNiche(slug) : await k.getNicheById(payload.nicheId);
+    if (!niche) return c.json({ error: 'no such niche' }, 404);
+    if (!payload.title || !payload.question)
+      return c.json({ error: 'a question needs a title and a question' }, 400);
+
+    const { question, duplicate } = await a.createQuestion({
+      // Chovy's own id if it sent one, else the envelope's, so a redelivery of
+      // either shape books once.
+      externalId: payload.externalId ?? auth.body?.id ?? null,
+      nicheId: niche.id,
+      agentId: payload.agentId ?? niche.primary_agent_id ?? null,
+      title: payload.title,
+      question: payload.question,
+      context: payload.context ?? null,
+      options: payload.options ?? [],
+      urgency: payload.urgency ?? 'normal',
+      relatedResourceIds: payload.relatedResourceIds ?? [],
+    });
+
+    return c.json(
+      {
+        stored: Boolean(question),
+        duplicate,
+        question: question ? { id: String(question.id), status: question.status } : null,
+      },
+      duplicate ? 200 : 201,
+    );
+  });
+
+  /* ------------------------------------------------------------- operators -- */
+
+  app.get('/api/v1/niches/:slug/questions', async (c) => {
+    const niche = await k.getNiche(c.req.param('slug'));
+    if (!niche) return c.json({ error: 'not found' }, 404);
+    const user = requireUser(c);
+    const member = await k.memberOf({ nicheId: niche.id, userId: user.id });
+    // A question carries the agent's raw research, which is not public.
+    if (member?.status !== 'active' && !isAdmin(user))
+      return c.json({ error: 'you do not operate this niche' }, 403);
+    return c.json({
+      questions: await a.listQuestions({
+        nicheId: niche.id,
+        status: c.req.query('status') ?? 'waiting',
+      }),
+    });
+  });
+
+  app.post('/api/v1/niches/:slug/questions/:id/answer', async (c) => {
+    const user = requireUser(c);
+    const niche = await k.getNiche(c.req.param('slug'));
+    if (!niche) return c.json({ error: 'not found' }, 404);
+    const body = await c.req.json().catch(() => ({}));
+    return answer(c, {
+      user,
+      questionId: c.req.param('id'),
+      kind: body.kind,
+      optionId: body.optionId,
+      body: body.answer ?? body.body,
+    });
+  });
+
+  /* ------------------------------------------------------------- dashboard -- */
+
+  app.get('/dashboard/niches/:slug/questions', async (c) => {
+    const user = requireUser(c);
+    const niche = await k.getNiche(c.req.param('slug'));
+    if (!niche) return c.notFound();
+    const member = await k.memberOf({ nicheId: niche.id, userId: user.id });
+    if (member?.status !== 'active' && !isAdmin(user)) return c.notFound();
+
+    const [open, settled] = await Promise.all([
+      a.listQuestions({ nicheId: niche.id, status: 'waiting' }),
+      a.listQuestions({ nicheId: niche.id, status: 'answered', limit: 20 }),
+    ]);
+    return c.html(
+      await render(
+        <NicheQuestions
+          user={user}
+          niche={niche}
+          questions={open}
+          settled={settled}
+          configured={chovyConfigured()}
+          notice={c.req.query('notice')}
+          error={c.req.query('error')}
+        />,
+      ),
+    );
+  });
+
+  /** The form on the dashboard posts here. */
+  app.post('/dashboard/questions/:id/answer', async (c) => {
+    const user = requireUser(c);
+    const form = await c.req.parseBody();
+    return answer(c, {
+      user,
+      questionId: c.req.param('id'),
+      kind: form.kind,
+      optionId: form.optionId || null,
+      body: form.answer || null,
+      redirectTo: form.next ? String(form.next) : '/dashboard/niches',
+    });
+  });
+
+  app.post('/dashboard/questions/:id/dismiss', async (c) => {
+    const user = requireUser(c);
+    const done = await a.dismissQuestion({ questionId: c.req.param('id'), influencerId: user.id });
+    return respond(c, {
+      json: { dismissed: Boolean(done) },
+      redirectTo: '/dashboard/niches',
+      notice: done ? 'Dismissed.' : null,
+      error: done ? null : 'That question is not yours to dismiss.',
+    });
+  });
+
+  /**
+   * One place where an answer is recorded, whichever surface it came from.
+   *
+   * Chovy is told after the write, never before, and a delivery that fails
+   * does not fail the answer: the contribution is already banked.
+   */
+  async function answer(c, { user, questionId, kind, optionId, body, redirectTo }) {
+    const out = await a.answerQuestion({
+      questionId,
+      influencerId: user.id,
+      kind: kind ? String(kind) : 'answered',
+      optionId: optionId ? String(optionId) : null,
+      body: body ?? null,
+    });
+    if (!out.ok)
+      return respond(c, {
+        json: { error: out.reason },
+        status: 400,
+        redirectTo,
+        error: out.reason,
+      });
+
+    if (out.answer.kind === 'answered') {
+      await notifyChovy('expert_answer.created', {
+        nicheId: out.question.niche_id,
+        userId: user.id,
+        payload: {
+          questionId: String(out.question.id),
+          externalId: out.question.external_id,
+          answer: out.answer.body,
+          optionId: out.answer.option_id,
+          answeredBy: user.handle ?? null,
+        },
+      });
+    } else if (out.answer.kind === 'needs_research') {
+      await notifyChovy('agent.research_requested', {
+        nicheId: out.question.niche_id,
+        userId: user.id,
+        payload: {
+          questionId: String(out.question.id),
+          externalId: out.question.external_id,
+          note: out.answer.body,
+        },
+      });
+    }
+
+    const said =
+      out.answer.kind === 'answered'
+        ? out.contributionStatus === 'verified'
+          ? `Thanks. That is ${out.points} points.`
+          : 'Thanks. It goes to review before it counts.'
+        : out.answer.kind === 'needs_research'
+          ? 'Sent back to the agent for more research.'
+          : 'Noted. It stays open for someone else.';
+
+    return respond(c, {
+      json: { ok: true, points: out.points, status: out.contributionStatus },
+      redirectTo,
+      notice: said,
+    });
+  }
+}
diff --git a/apps/web/src/routes/knowledge.js b/apps/web/src/routes/knowledge.js
index 10cd442..cd05ee5 100644
--- a/apps/web/src/routes/knowledge.js
+++ b/apps/web/src/routes/knowledge.js
@@ -1,4 +1,5 @@
 import { config } from '@nichedb/config';
+import * as agents from '@nichedb/db/agents';
 import * as k from '@nichedb/db/knowledge';
 import {
   CONTRIBUTION_EVENT_TYPES,
@@ -118,10 +119,12 @@ export function registerKnowledge(app) {
 
   app.get('/dashboard/niches', async (c) => {
     const user = requireUser(c);
-    const [niches, contributions, tiers] = await Promise.all([
+    const [niches, contributions, tiers, questions, questionCounts] = await Promise.all([
       k.nichesForUser(user.id),
       k.listContributions({ influencerId: user.id, limit: 50 }),
       k.listTiers(),
+      agents.questionsAwaiting(user.id),
+      agents.openQuestionCounts(user.id),
     ]);
     return c.html(
       await render(
@@ -130,6 +133,8 @@ export function registerKnowledge(app) {
           niches={niches}
           contributions={contributions}
           tiers={tiers}
+          questions={questions}
+          questionCounts={questionCounts}
           notice={c.req.query('notice')}
           error={c.req.query('error')}
         />,
diff --git a/apps/web/src/views/knowledge.jsx b/apps/web/src/views/knowledge.jsx
index 2c09d84..4fb9749 100644
--- a/apps/web/src/views/knowledge.jsx
+++ b/apps/web/src/views/knowledge.jsx
@@ -1,4 +1,4 @@
-import { formatBps, nextTierFor } from '@nichedb/knowledge';
+import { asJson, asJsonArray, formatBps, nextTierFor } from '@nichedb/knowledge';
 import { Notice, Num, Relative } from './components.jsx';
 import { Layout } from './Layout.jsx';
 
@@ -232,11 +232,11 @@ export const OpportunityPage = ({ user, opportunity, tiers, claim, notice, error
       </section>
     ) : null}
 
-    {Object.keys(opportunity.dimensions ?? {}).length ? (
+    {Object.keys(asJson(opportunity.dimensions)).length ? (
       <section>
         <h2>How that score is made</h2>
         <ul class="dimensions">
-          {Object.entries(opportunity.dimensions).map(([k, v]) => (
+          {Object.entries(asJson(opportunity.dimensions)).map(([k, v]) => (
             <li key={k}>
               <span class="dim-name">{k.replace(/_/g, ' ')}</span> <span class="num">{v}</span>
             </li>
@@ -330,10 +330,23 @@ export const InfluencerPage = ({ user, influencer }) => (
 );
 
 /** The operator's own view: what needs them, and where they stand. */
-export const InfluencerDashboard = ({ user, niches, contributions, tiers, notice, error }) => (
+export const InfluencerDashboard = ({
+  user,
+  niches,
+  contributions,
+  tiers,
+  questions = [],
+  questionCounts = {},
+  notice,
+  error,
+}) => (
   <Layout user={user} title="Your niches">
     <Notice notice={notice} error={error} />
 
+    {/* First on the page, because this is the thing that actually wants a
+        human today. Everything below it is a record of what already happened. */}
+    <QuestionsPanel questions={questions} next="/dashboard/niches" />
+
     <h1>Your niches</h1>
     {niches.length === 0 ? (
       <p class="muted empty">
@@ -364,6 +377,12 @@ export const InfluencerDashboard = ({ user, niches, contributions, tiers, notice
                   <>At the top of the ladder.</>
                 )}
               </p>
+              <p class="card-links small">
+                <a href={`/dashboard/niches/${n.slug}/questions`}>
+                  Questions
+                  {questionCounts[String(n.id)] ? ` (${questionCounts[String(n.id)]})` : ''}
+                </a>
+              </p>
             </li>
           );
         })}
@@ -556,3 +575,138 @@ export const KnowledgeAdmin = ({ user, claims, pending, audit, notice, error })
     </section>
   </Layout>
 );
+
+/**
+ * One question, with the three things a person can say about it.
+ *
+ * Everything from the agent is rendered as text. `context` in particular is
+ * whatever it scraped on the way to being stuck, so it is untrusted input on
+ * its way to a human and then back to a model: it goes in a quoted block that
+ * says where it came from, and nothing on either side of the loop treats it as
+ * an instruction.
+ */
+export const QuestionCard = ({ question, next }) => (
+  <li class="card question" key={question.id}>
+    <p class="card-title">
+      {question.urgency === 'high' ? <span class="badge urgent">urgent</span> : null}{' '}
+      {question.title}
+    </p>
+    {question.niche_slug ? (
+      <p class="card-desc muted small">
+        <a href={`/${question.niche_slug}`}>{question.niche_name}</a>
+        {question.status === 'researching' ? ' · sent back for research' : ''}
+      </p>
+    ) : null}
+
+    <p>{question.question}</p>
+
+    {question.context ? (
+      <details class="agent-context">
+        <summary class="agent-summary">What the agent found</summary>
+        {/* Quoted, not obeyed. This is crawled text. */}
+        <blockquote class="agent-quote">{question.context}</blockquote>
+      </details>
+    ) : null}
+
+    <form method="post" action={`/dashboard/questions/${question.id}/answer`} class="stack">
+      <input type="hidden" name="next" value={next ?? '/dashboard/niches'} />
+      {asJsonArray(question.options).length ? (
+        <fieldset class="field">
+          <legend class="label">Which is it?</legend>
+          {asJsonArray(question.options).map((o) => (
+            <label class="check" key={o.id}>
+              <input type="radio" name="optionId" value={o.id} />
+              <span>{o.label}</span>
+            </label>
+          ))}
+        </fieldset>
+      ) : null}
+
+      <label class="field">
+        <span class="label">Your answer</span>
+        <textarea name="answer" rows="3" maxlength="8000" placeholder="How it actually works." />
+        <span class="help">
+          What you know, in your own words. This becomes niche knowledge and a scored contribution.
+        </span>
+      </label>
+
+      <p class="row">
+        <button type="submit" name="kind" value="answered" class="btn-primary">
+          Answer
+        </button>
+        <button type="submit" name="kind" value="insufficient_context" class="btn-ghost">
+          Not enough context
+        </button>
+        <button type="submit" name="kind" value="needs_research" class="btn-ghost">
+          Ask the agent to research more
+        </button>
+      </p>
+      <p class="help muted small">
+        Saying you cannot answer costs you nothing. A guess that gets verified becomes wrong
+        knowledge, which is worse for the niche than an unanswered question.
+      </p>
+    </form>
+  </li>
+);
+
+/** The dashboard panel: what is waiting on this person, across every niche. */
+export const QuestionsPanel = ({ questions, next }) => (
+  <section>
+    <h2>Your agent needs you</h2>
+    {questions.length === 0 ? (
+      <p class="muted empty">Nothing waiting. The agents will ask when they get stuck.</p>
+    ) : (
+      <>
+        <p class="muted small">
+          {questions.length} {questions.length === 1 ? 'question needs' : 'questions need'} expert
+          judgement. Each should take a minute or two.
+        </p>
+        <ul class="cards">
+          {questions.map((q) => (
+            <QuestionCard key={q.id} question={q} next={next} />
+          ))}
+        </ul>
+      </>
+    )}
+  </section>
+);
+
+/** One niche's queue, open and recently settled. */
+export const NicheQuestions = ({ user, niche, questions, settled, configured, notice, error }) => (
+  <Layout user={user} title={`${niche.name} questions`}>
+    <Notice notice={notice} error={error} />
+    <h1>{niche.name}: agent questions</h1>
+    <p class="muted">
+      <a href={`/${niche.slug}`}>The niche</a> · <a href="/dashboard/niches">Your niches</a>
+    </p>
+
+    {configured ? null : (
+      <p class="alert info">
+        No agent is wired to this deployment yet (<code>CHOVY_SIGNING_SECRET</code> is unset), so
+        nothing can ask a question.
+      </p>
+    )}
+
+    <QuestionsPanel questions={questions} next={`/dashboard/niches/${niche.slug}/questions`} />
+
+    <section>
+      <h2>Settled</h2>
+      {settled.length === 0 ? (
+        <p class="muted empty">Nothing answered yet.</p>
+      ) : (
+        <ul class="items">
+          {settled.map((q) => (
+            <li class="item" key={q.id}>
+              <div class="item-body">
+                <p class="item-title">{q.title}</p>
+                <p class="item-meta">
+                  answered <Relative at={q.answered_at ?? q.created_at} />
+                </p>
+              </div>
+            </li>
+          ))}
+        </ul>
+      )}
+    </section>
+  </Layout>
+);
diff --git a/docs/agent-questions.md b/docs/agent-questions.md
new file mode 100644
index 0000000..fd32eee
--- /dev/null
+++ b/docs/agent-questions.md
@@ -0,0 +1,152 @@
+# The agent question loop
+
+**Where the AI admits it does not know something, and the person who does gets paid for the answer.**
+
+An agent is building or researching for a niche and hits something only
+somebody who has done the job can settle. Two sources disagree about roofing
+waste percentages. Steam lists an early-access date and a 1.0 date and only one
+of them is the release. It cannot read its way out of that, so it asks.
+
+```
+YOUR AGENT NEEDS YOUR EXPERTISE
+
+Do early-access dates count as releases?
+Steam lists an early access date and a 1.0 date.
+
+  ( ) Early access date
+  ( ) 1.0 date
+
+[Answer]  [Not enough context]  [Ask the agent to research more]
+```
+
+The answer becomes niche knowledge and a scored contribution in the same
+request. That is the flywheel: the agent's ignorance is what generates the
+human's income, so a niche with an active agent gives its operator a steady,
+bounded reason to show up.
+
+## The round trip
+
+```
+Chovy agent
+    |  POST /api/v1/internal/expert-questions   (signed)
+    v
+agent_questions ──> the operator's dashboard
+                          |
+                          |  answers, declines, or sends it back
+                          v
+                    agent_answers
+                          |
+             +------------+------------+
+             |                         |
+             v                         v
+     contribution_events        expert_answer.created
+     (agent_answer, 3pts)       delivered back to Chovy
+             |
+             v
+       score -> tier -> revenue share
+```
+
+## What a person can say
+
+Three answers, and two of them are not answers. That is deliberate.
+
+| | What happens | Points |
+| --- | --- | ---: |
+| **Answer** | Question closes, Chovy is told, a contribution is recorded | 3 |
+| **Not enough context** | Recorded, question stays open for someone else | 0 |
+| **Ask the agent to research more** | Question goes to `researching`, Chovy is told | 0 |
+
+Declining has to be free, and it is worth being explicit about why. If the only
+paid action is answering, an operator who half-knows will guess. A guess that
+gets verified becomes wrong knowledge in a dataset other people pay to read,
+and nothing downstream can tell it apart from the real thing. A question left
+open costs a day. A confident wrong answer costs the niche its credibility.
+
+## Signing
+
+The internal route creates work that pays, so it is signed rather than merely
+internal. An unsigned endpoint here is a way to mint scored contributions.
+
+```
+X-Chovy-Signature: t=<unix seconds>,v1=<hex hmac-sha256>
+signed payload:    `${t}.${rawBody}`
+secret:            CHOVY_SIGNING_SECRET
+tolerance:         300 seconds
+```
+
+The same scheme this deployment already verifies for CoinPay webhooks, and the
+same in both directions, so Chovy verifies our answers with the code it uses to
+sign its questions. `packages/knowledge/src/signing.js` is the shared
+implementation; it takes strings, not request objects, so both sides can use it.
+
+Unset the secret and the route answers 503. That is deliberate: no default, no
+fallback, and no quiet acceptance of unsigned work.
+
+The HMAC is over the raw request text, never a re-serialised object.
+`JSON.stringify(JSON.parse(x))` is not always `x`.
+
+## Untrusted context
+
+A question carries `context`: whatever the agent scraped on the way to being
+stuck. It is the highest-risk field in this system, because it is attacker-
+influenced text travelling to a human and then back into a model's context.
+
+Three rules, all enforced in code rather than by intention:
+
+1. It renders as escaped text inside a `<blockquote>` labelled "What the agent
+   found", so a reader can see it is reported material and not the site
+   talking. A `<script>` tag in it is displayed, not run.
+2. Nothing on either side interpolates it into instructions. The migration says
+   so at the column and the answer path never concatenates it.
+3. It is length-capped on the way in, so a question cannot be a denial of
+   service against the page that shows it.
+
+## Idempotency
+
+A question carries the agent's own `externalId`. A redelivered webhook returns
+`{"duplicate": true}` and the original question, so nothing appears twice in
+front of a person.
+
+An answer is guarded twice over. The `unique (question_id, influencer_id)`
+constraint settles a race, and only the request that wins it goes on to score.
+Under that, the contribution's own dedupe key is derived from the question id,
+so even a double-scored path books once.
+
+## Trying it
+
+```sh
+export CHOVY_SIGNING_SECRET=dev-secret
+BODY='{"payload":{"nicheSlug":"games","externalId":"q-1","title":"Which date?",
+       "question":"Early access or 1.0?","urgency":"high",
+       "options":[{"id":"ea","label":"Early access"},{"id":"full","label":"1.0"}]}}'
+T=$(date +%s)
+MAC=$(printf '%s.%s' "$T" "$BODY" | openssl dgst -sha256 -hmac "$CHOVY_SIGNING_SECRET" -hex | sed 's/.*= *//')
+
+curl -X POST localhost:3000/api/v1/internal/expert-questions \
+  -H 'content-type: application/json' \
+  -H "x-chovy-signature: t=$T,v1=$MAC" -d "$BODY"
+```
+
+It then appears on `/dashboard/niches` for every active operator of that niche.
+
+## Endpoints
+
+```
+POST /api/v1/internal/expert-questions          signed; an agent asking
+GET  /api/v1/niches/:slug/questions             members and admins only
+POST /api/v1/niches/:slug/questions/:id/answer  members only
+
+GET  /dashboard/niches/:slug/questions          the queue, as a page
+POST /dashboard/questions/:id/answer            what the form posts
+POST /dashboard/questions/:id/dismiss           not worth anybody's time
+```
+
+Questions are not public. They carry the agent's raw research, and a niche's
+open problems are not something to publish while they are open.
+
+## Tests
+
+```sh
+bun test test/signing.test.js   # tamper, replay, wrong secret, clock skew
+bun test test/schema.test.js    # redelivery, one answer per person, declines score nothing
+```
diff --git a/docs/architecture.md b/docs/architecture.md
index d460daa..997a914 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -75,5 +75,6 @@ index, and the Knowledge Influencer tables for people who operate a niche. See
 ## Reading further
 
 - [knowledge-influencers.md](./knowledge-influencers.md)
+- [agent-questions.md](./agent-questions.md)
 - [revenue-share.md](./revenue-share.md)
 - [x402-attribution.md](./x402-attribution.md)
diff --git a/docs/knowledge-influencers.md b/docs/knowledge-influencers.md
index b0e396a..7e3ef9c 100644
--- a/docs/knowledge-influencers.md
+++ b/docs/knowledge-influencers.md
@@ -35,7 +35,8 @@ arrive through are already defined in `packages/knowledge/src/events.js`.
 | `/<slug>/skill.md` | The same, for an agent. |
 | `/<slug>/manifest.json` | Feeds, APIs, datasets and the x402 terms, machine-readable. |
 | `/@<handle>` | A Knowledge Influencer's public profile. |
-| `/dashboard/niches` | The operator's own view: score, tier, distance to the next rung. |
+| `/dashboard/niches` | The operator's own view: what the agent is asking, score, tier, distance to the next rung. |
+| `/dashboard/niches/<slug>/questions` | One niche's question queue. |
 | `/admin/knowledge` | Claims and contributions awaiting a human, and the audit log. |
 
 A niche page is served from the site root because that is where somebody
@@ -113,11 +114,17 @@ bun test test/schema.test.js        # the tables, against an in-process Postgres
 
 Neither needs a server.
 
+## The agent question loop
+
+This is the part that makes a day's work a few minutes long instead of an
+open-ended obligation to go and find something to contribute. See
+[agent-questions.md](./agent-questions.md).
+
 ## Not yet built
 
-- The Chovy agent loop (`agent_questions`, `agent_answers`). The event names
-  and envelope are in `packages/knowledge/src/events.js`.
 - The revenue ledger and payouts. The arithmetic is written and tested
   (`allocate`, `attributableNetMinor`); only the tables and the wiring are
   missing.
 - Promotion attribution, and the opportunity score's own inputs.
+- Notifications. A question arriving should reach the operator by email or
+  push; today it waits on the dashboard until they look.
diff --git a/packages/config/src/index.js b/packages/config/src/index.js
index c48b2fd..0372cfd 100644
--- a/packages/config/src/index.js
+++ b/packages/config/src/index.js
@@ -260,6 +260,18 @@ export const config = {
   // be paid for their work, and a weak fallback is how that ships by accident.
   partnerSecret: opt('PARTNER_VERIFY_SECRET', ''),
 
+  // The agent question loop. The internal routes create scored work and move
+  // somebody's revenue share, so they are signed rather than merely internal.
+  // No default and no fallback: unset means the routes answer 503 and the
+  // dashboard simply has no questions on it, which is a visible nothing rather
+  // than an endpoint anyone who can reach the port may post to.
+  chovy: {
+    signingSecret: opt('CHOVY_SIGNING_SECRET', ''),
+    // Where an answer is delivered back. Optional: the loop still records and
+    // scores without it, the agent just has to come and read.
+    webhookUrl: opt('CHOVY_WEBHOOK_URL', ''),
+  },
+
   session: {
     cookie: 'ndb_session',
     ttlDays: num('SESSION_TTL_DAYS', 90),
diff --git a/packages/db/migrations/0009_agent_questions.sql b/packages/db/migrations/0009_agent_questions.sql
new file mode 100644
index 0000000..dcc6294
--- /dev/null
+++ b/packages/db/migrations/0009_agent_questions.sql
@@ -0,0 +1,84 @@
+-- The agent question loop: where the AI admits it does not know something and
+-- the human who does gets paid for the answer.
+--
+-- This is the part that makes a Knowledge Influencer's day a few minutes long
+-- instead of an open-ended obligation to go and find something to contribute.
+-- The agent is building for a niche, hits a question that only somebody who
+-- has done the job can settle, and asks. The answer becomes niche knowledge
+-- and a scored contribution in the same transaction.
+
+create table agent_questions (
+  id          bigserial primary key,
+  -- Chovy's own id for the question. Idempotency lives on this: a webhook
+  -- delivered twice must not put the same question in front of a person twice.
+  external_id text,
+  niche_id    bigint not null references niches(id) on delete cascade,
+  -- Which agent asked. A logical name (`chovy-niche-commercial-roofing`),
+  -- matching niches.primary_agent_id; there is no agents table to join.
+  agent_id    text,
+  title       text not null,
+  question    text not null,
+  -- UNTRUSTED. This is whatever the agent gathered while getting stuck: pages
+  -- it crawled, snippets it found, its own reasoning. It is rendered as text
+  -- and it is never instructions. Nothing reads this column and does what it
+  -- says, on either side of the loop.
+  context     text,
+  -- [{ id, label }]. When present the operator picks rather than types, which
+  -- is what makes a two-minute answer possible.
+  options     jsonb not null default '[]',
+  urgency     text not null default 'normal',
+  constraint agent_questions_urgency check (urgency in ('low', 'normal', 'high')),
+  related_resource_ids jsonb not null default '[]',
+  -- open: waiting on a human. answered: somebody settled it. dismissed: an
+  -- operator or admin said it is not worth answering.
+  -- researching: a human asked the agent to go back and find out more.
+  status      text not null default 'open',
+  constraint agent_questions_status
+    check (status in ('open', 'researching', 'answered', 'dismissed')),
+  created_at  timestamptz not null default now(),
+  answered_at timestamptz
+);
+create index agent_questions_queue_idx
+  on agent_questions (niche_id, status, created_at desc);
+-- The dashboard's only hot query: what is still waiting, worst first.
+create index agent_questions_open_idx
+  on agent_questions (niche_id, urgency, created_at) where status in ('open', 'researching');
+-- A redelivery books once. Partial, because a question raised by hand has no
+-- external id and two of those must not collide.
+create unique index agent_questions_external
+  on agent_questions (niche_id, external_id) where external_id is not null;
+
+-- What a human said back.
+--
+-- Kept as its own table rather than columns on the question because "I do not
+-- have enough context" is a real answer that has to be recorded without
+-- closing the question, and because a niche with several operators can have
+-- more than one of them weigh in.
+create table agent_answers (
+  id            bigserial primary key,
+  question_id   bigint not null references agent_questions(id) on delete cascade,
+  influencer_id uuid not null references users(id) on delete cascade,
+  -- answered:            a real answer, which scores.
+  -- insufficient_context: the question cannot be answered as asked.
+  -- needs_research:      go and find out more, then ask again.
+  --
+  -- The last two score nothing and cost nothing. An operator who feels pressed
+  -- to answer because answering is what pays will guess, and a guess that gets
+  -- verified becomes wrong knowledge that the data quality never recovers
+  -- from. Declining has to be free.
+  kind          text not null default 'answered',
+  constraint agent_answers_kind
+    check (kind in ('answered', 'insufficient_context', 'needs_research')),
+  -- The option chosen, when the question offered any.
+  option_id     text,
+  body          text,
+  -- The scored contribution this answer created, when it created one. Null for
+  -- a decline, which is the whole point of the column being nullable.
+  contribution_event_id bigint references contribution_events(id) on delete set null,
+  created_at    timestamptz not null default now(),
+  -- One answer per person per question. Changing your mind is a new question,
+  -- not a second payment for the same one.
+  unique (question_id, influencer_id)
+);
+create index agent_answers_question_idx on agent_answers (question_id);
+create index agent_answers_influencer_idx on agent_answers (influencer_id, created_at desc);
diff --git a/packages/db/migrations/0010_repair_jsonb_strings.sql b/packages/db/migrations/0010_repair_jsonb_strings.sql
new file mode 100644
index 0000000..823bc18
--- /dev/null
+++ b/packages/db/migrations/0010_repair_jsonb_strings.sql
@@ -0,0 +1,38 @@
+-- Repair jsonb columns that hold a STRING instead of the thing it spells.
+--
+-- Bun's driver passes a string parameter cast to `jsonb` straight through
+-- rather than parsing it, so a value written as a stringified object landed as
+-- a jsonb string: `"{}"` rather than `{}`. The writes now cast through `text`,
+-- which stores the real structure, and this repairs what the old ones left.
+--
+-- It shipped visibly. Every opportunity page rendered a "How that score is
+-- made" list with two entries, `0` and `1`, holding a brace each, because
+-- Object.keys of a string is its character indices.
+--
+-- `#>> '{}'` takes the text a jsonb string contains, and casting that back to
+-- jsonb parses it. Guarded by jsonb_typeof so a row that is already correct is
+-- left alone, and so re-running costs nothing.
+
+update opportunities
+set dimensions = (dimensions #>> '{}')::jsonb
+where jsonb_typeof(dimensions) = 'string';
+
+update niche_claims
+set answers = (answers #>> '{}')::jsonb
+where jsonb_typeof(answers) = 'string';
+
+update contribution_events
+set evidence = (evidence #>> '{}')::jsonb
+where jsonb_typeof(evidence) = 'string';
+
+update knowledge_audit_logs
+set detail = (detail #>> '{}')::jsonb
+where jsonb_typeof(detail) = 'string';
+
+update agent_questions
+set options = (options #>> '{}')::jsonb
+where jsonb_typeof(options) = 'string';
+
+update agent_questions
+set related_resource_ids = (related_resource_ids #>> '{}')::jsonb
+where jsonb_typeof(related_resource_ids) = 'string';
diff --git a/packages/db/package.json b/packages/db/package.json
index 3e11940..bcf15b8 100644
--- a/packages/db/package.json
+++ b/packages/db/package.json
@@ -8,7 +8,8 @@
     "./queries": "./src/queries.js",
     "./migrate": "./src/migrate.js",
     "./knowledge": "./src/knowledge.js",
-    "./automotive": "./src/automotive.js"
+    "./automotive": "./src/automotive.js",
+    "./agents": "./src/agents.js"
   },
   "dependencies": {
     "@nichedb/config": "workspace:*",
diff --git a/packages/db/src/agents.js b/packages/db/src/agents.js
new file mode 100644
index 0000000..b256025
--- /dev/null
+++ b/packages/db/src/agents.js
@@ -0,0 +1,270 @@
+import { sql } from './index.js';
+import { memberOf, recordContribution } from './knowledge.js';
+
+/**
+ * The agent question loop.
+ *
+ * An agent asks, an operator answers, the answer becomes scored knowledge.
+ * Everything here is the storage half; what an answer is worth is decided by
+ * `@nichedb/knowledge` through `recordContribution`, the same as every other
+ * contribution, so there is no second scoring path to keep in step.
+ */
+
+/* -------------------------------------------------------------- questions -- */
+
+/**
+ * Record a question from an agent.
+ *
+ * Idempotent on the agent's own id: a webhook delivered twice puts one
+ * question in front of a person. The existing row comes back so the caller
+ * can tell the difference between "stored" and "already had it".
+ */
+export async function createQuestion({
+  externalId = null,
+  nicheId,
+  agentId = null,
+  title,
+  question,
+  context = null,
+  options = [],
+  urgency = 'normal',
+  relatedResourceIds = [],
+}) {
+  const clean = String(urgency ?? 'normal');
+  const [row] = await sql`
+    insert into agent_questions
+      (external_id, niche_id, agent_id, title, question, context, options, urgency, related_resource_ids)
+    values (${externalId}, ${Number(nicheId)}, ${agentId},
+            ${String(title ?? '').slice(0, 300)},
+            ${String(question ?? '').slice(0, 8000)},
+            ${context === null ? null : String(context).slice(0, 20_000)},
+            ${JSON.stringify(Array.isArray(options) ? options.slice(0, 12) : [])}::text::jsonb,
+            ${['low', 'normal', 'high'].includes(clean) ? clean : 'normal'},
+            ${JSON.stringify(Array.isArray(relatedResourceIds) ? relatedResourceIds : [])}::text::jsonb)
+    on conflict (niche_id, external_id) where external_id is not null do nothing
+    returning id, external_id, niche_id, agent_id, title, question, context,
+              options, urgency, related_resource_ids, status, created_at, answered_at
+  `;
+  if (row) return { question: row, duplicate: false };
+  if (!externalId) return { question: null, duplicate: false };
+  const existing = await questionByExternalId({ nicheId, externalId });
+  return { question: existing, duplicate: true };
+}
+
+export async function questionByExternalId({ nicheId, externalId }) {
+  const [row] = await sql`
+    select id, external_id, niche_id, agent_id, title, question, context,
+           options, urgency, related_resource_ids, status, created_at, answered_at
+    from agent_questions
+    where niche_id = ${Number(nicheId)} and external_id = ${externalId}
+  `;
+  return row ?? null;
+}
+
+export async function getQuestion(id) {
+  const [row] = await sql`
+    select q.id, q.external_id, q.niche_id, q.agent_id, q.title, q.question, q.context,
+           q.options, q.urgency, q.related_resource_ids, q.status, q.created_at, q.answered_at,
+           n.slug as niche_slug, n.name as niche_name
+    from agent_questions q
+    join niches n on n.id = q.niche_id
+    where q.id = ${Number(id)}
+  `;
+  return row ?? null;
+}
+
+/**
+ * A niche's questions. Most urgent first, then oldest.
+ *
+ * `status` takes 'waiting' to mean everything still on a human: open, and
+ * anything sent back for research. Those are one queue to the person looking
+ * at it, and filtering on 'open' alone made a question they had just handed
+ * back disappear from the page while still counting on their dashboard.
+ */
+export async function listQuestions({ nicheId, status = 'waiting', limit = 50 } = {}) {
+  const waiting = status === 'waiting';
+  return sql`
+    select q.id, q.external_id, q.niche_id, q.agent_id, q.title, q.question, q.context,
+           q.options, q.urgency, q.related_resource_ids, q.status, q.created_at, q.answered_at,
+           n.slug as niche_slug, n.name as niche_name,
+           (select count(*)::int from agent_answers a where a.question_id = q.id) as answer_count
+    from agent_questions q
+    join niches n on n.id = q.niche_id
+    where q.niche_id = ${Number(nicheId)}
+      and (${waiting} or ${status}::text is null or q.status = ${status})
+      and (not ${waiting} or q.status in ('open', 'researching'))
+    order by
+      case q.urgency when 'high' then 0 when 'normal' then 1 else 2 end,
+      q.created_at
+    limit ${Math.min(Number(limit) || 50, 200)}
+  `;
+}
+
+/**
+ * Everything waiting on one person, across every niche they operate.
+ *
+ * This is the dashboard's "your agent needs you" list. A question this person
+ * has already answered is not waiting on them, which is what the `not exists`
+ * is for: in a niche with two operators, each sees only what they have not
+ * dealt with.
+ */
+export async function questionsAwaiting(userId, { limit = 25 } = {}) {
+  return sql`
+    select q.id, q.external_id, q.niche_id, q.agent_id, q.title, q.question, q.context,
+           q.options, q.urgency, q.related_resource_ids, q.status, q.created_at, q.answered_at,
+           n.slug as niche_slug, n.name as niche_name
+    from agent_questions q
+    join niches n on n.id = q.niche_id
+    join niche_members m on m.niche_id = q.niche_id and m.user_id = ${userId}::uuid
+    where q.status in ('open', 'researching')
+      and m.status = 'active'
+      and m.role in ('operator', 'specialist')
+      and not exists (
+        select 1 from agent_answers a
+        where a.question_id = q.id and a.influencer_id = ${userId}::uuid
+      )
+    order by
+      case q.urgency when 'high' then 0 when 'normal' then 1 else 2 end,
+      q.created_at
+    limit ${Math.min(Number(limit) || 25, 100)}
+  `;
+}
+
+/** How many questions each of a person's niches is waiting on. */
+export async function openQuestionCounts(userId) {
+  const rows = await sql`
+    select q.niche_id, count(*)::int as n
+    from agent_questions q
+    join niche_members m on m.niche_id = q.niche_id and m.user_id = ${userId}::uuid
+    where q.status in ('open', 'researching') and m.status = 'active'
+      and not exists (
+        select 1 from agent_answers a
+        where a.question_id = q.id and a.influencer_id = ${userId}::uuid
+      )
+    group by q.niche_id
+  `;
+  return Object.fromEntries(rows.map((r) => [String(r.niche_id), Number(r.n)]));
+}
+
+/* ---------------------------------------------------------------- answers -- */
+
+/**
+ * Answer a question.
+ *
+ * A real answer becomes an `agent_answer` contribution, scored by the same
+ * engine as everything else, and closes the question. A decline records that
+ * the person looked and could not help: no points, no penalty, and the
+ * question stays open for somebody who can.
+ *
+ * The answer row is written first, and its unique constraint is what settles a
+ * race: two operators submitting at the same instant, or one double-clicking,
+ * and exactly one row is created. Only the request that created it goes on to
+ * score, so nobody is paid twice for one question. The contribution's own
+ * dedupe key is the second guard under that, keyed on the question id.
+ */
+export async function answerQuestion({
+  questionId,
+  influencerId,
+  kind = 'answered',
+  optionId = null,
+  body = null,
+}) {
+  const question = await getQuestion(questionId);
+  if (!question) return { ok: false, reason: 'no such question' };
+  if (question.status === 'answered' || question.status === 'dismissed')
+    return { ok: false, reason: 'that question is already settled' };
+
+  const member = await memberOf({ nicheId: question.niche_id, userId: influencerId });
+  if (member?.status !== 'active' || member.role === 'observer')
+    return { ok: false, reason: 'you do not operate this niche' };
+
+  const shape = ['answered', 'insufficient_context', 'needs_research'].includes(kind)
+    ? kind
+    : 'answered';
+  const text = body === null ? null : String(body).slice(0, 8000);
+  if (shape === 'answered' && !text && !optionId)
+    return { ok: false, reason: 'an answer needs either a choice or some words' };
+
+  // The row goes in first and the unique constraint decides the race. A second
+  // submission finds nothing to insert and stops here, before it can score.
+  const [answer] = await sql`
+    insert into agent_answers (question_id, influencer_id, kind, option_id, body)
+    values (${Number(questionId)}, ${influencerId}::uuid, ${shape}, ${optionId}, ${text})
+    on conflict (question_id, influencer_id) do nothing
+    returning *
+  `;
+  if (!answer) return { ok: false, reason: 'you have already answered this one' };
+
+  let scored = null;
+  if (shape === 'answered') {
+    // The evidence names the question it settles, which is what makes the
+    // dedupe key stable: answering question 41 twice is one contribution.
+    scored = await recordContribution({
+      nicheId: question.niche_id,
+      influencerId,
+      type: 'agent_answer',
+      evidence: {
+        questionId: `agent-question:${question.id}`,
+        title: question.title,
+        answer: text ?? `option:${optionId}`,
+        agentId: question.agent_id,
+      },
+      sourceType: 'agent_question',
+      sourceId: String(question.id),
+    });
+    if (scored?.event?.id) {
+      await sql`
+        update agent_answers set contribution_event_id = ${scored.event.id}
+        where id = ${answer.id}
+      `;
+      answer.contribution_event_id = scored.event.id;
+    }
+  }
+
+  // A real answer settles the question. A request for more research hands it
+  // back to the agent. "Not enough context" leaves it open for someone else.
+  const status =
+    shape === 'answered'
+      ? 'answered'
+      : shape === 'needs_research'
+        ? 'researching'
+        : question.status;
+  await sql`
+    update agent_questions
+    set status = ${status},
+        answered_at = ${shape === 'answered' ? new Date() : null}
+    where id = ${Number(questionId)}
+  `;
+
+  return {
+    ok: true,
+    answer,
+    question: await getQuestion(questionId),
+    points: scored?.points ?? 0,
+    contributionStatus: scored?.status ?? null,
+  };
+}
+
+export async function listAnswers(questionId) {
+  return sql`
+    select a.*, u.handle::text as handle, u.display_name
+    from agent_answers a
+    join users u on u.id = a.influencer_id
+    where a.question_id = ${Number(questionId)}
+    order by a.created_at
+  `;
+}
+
+/** An operator or admin saying a question is not worth anybody's time. */
+export async function dismissQuestion({ questionId, influencerId }) {
+  const question = await getQuestion(questionId);
+  if (!question) return null;
+  const member = await memberOf({ nicheId: question.niche_id, userId: influencerId });
+  if (member?.status !== 'active' || member.role === 'observer') return null;
+  const [row] = await sql`
+    update agent_questions set status = 'dismissed'
+    where id = ${Number(questionId)} and status in ('open', 'researching')
+    returning id
+  `;
+  return row ?? null;
+}
diff --git a/packages/db/src/knowledge.js b/packages/db/src/knowledge.js
index d072956..9aadd7a 100644
--- a/packages/db/src/knowledge.js
+++ b/packages/db/src/knowledge.js
@@ -223,7 +223,7 @@ export async function getOpportunity(slug) {
 export async function upsertOpportunity({ nicheId, score, dimensions = {}, rationale = null }) {
   const [row] = await sql`
     insert into opportunities (niche_id, score, dimensions, rationale)
-    values (${Number(nicheId)}, ${score ?? null}, ${JSON.stringify(dimensions)}::jsonb, ${rationale})
+    values (${Number(nicheId)}, ${score ?? null}, ${JSON.stringify(dimensions)}::text::jsonb, ${rationale})
     on conflict (niche_id) do update
       set score = excluded.score, dimensions = excluded.dimensions,
           rationale = excluded.rationale, updated_at = now()
@@ -241,7 +241,7 @@ export async function upsertOpportunity({ nicheId, score, dimensions = {}, ratio
 export async function createClaim({ nicheId, userId, answers = {} }) {
   const [row] = await sql`
     insert into niche_claims (niche_id, user_id, answers)
-    values (${Number(nicheId)}, ${userId}::uuid, ${JSON.stringify(answers)}::jsonb)
+    values (${Number(nicheId)}, ${userId}::uuid, ${JSON.stringify(answers)}::text::jsonb)
     on conflict (niche_id, user_id) where status = 'pending' do nothing
     returning *
   `;
@@ -386,14 +386,17 @@ export async function recordContribution({
     insert into contribution_events
       (niche_id, influencer_id, event_type, points, status, source_type, source_id, evidence, dedupe_key, verified_at)
     values (${Number(nicheId)}, ${influencerId}::uuid, ${type}, ${scored.points}, ${scored.status},
-            ${sourceType}, ${sourceId}, ${JSON.stringify(evidence)}::jsonb, ${scored.dedupeKey},
+            ${sourceType}, ${sourceId}, ${JSON.stringify(evidence)}::text::jsonb, ${scored.dedupeKey},
             ${scored.status === 'verified' ? new Date() : null})
     on conflict (niche_id, influencer_id, dedupe_key) where dedupe_key is not null do nothing
     returning *
   `;
   if (!row) return { event: null, duplicate: true, points: 0, status: 'rejected', ...scored };
 
-  if (row.status === 'verified') await refreshScore({ nicheId, influencerId });
+  // Recomputed whichever way it landed. A pending contribution moves no score
+  // but it does move the count the dashboard shows, and "0 awaiting review"
+  // while something waits is how a person concludes the form is broken.
+  await refreshScore({ nicheId, influencerId });
   return { event: row, ...scored, duplicate: false };
 }
 
@@ -611,7 +614,7 @@ export async function audit({
   await sql`
     insert into knowledge_audit_logs (actor_id, action, subject_type, subject_id, niche_id, detail)
     values (${actorId}::uuid, ${action}, ${subjectType}, ${subjectId}, ${nicheId},
-            ${JSON.stringify(detail)}::jsonb)
+            ${JSON.stringify(detail)}::text::jsonb)
   `;
 }
 
diff --git a/packages/knowledge/package.json b/packages/knowledge/package.json
index a620cbc..c521a18 100644
--- a/packages/knowledge/package.json
+++ b/packages/knowledge/package.json
@@ -8,6 +8,7 @@
     "./tiers": "./src/tiers.js",
     "./weights": "./src/weights.js",
     "./score": "./src/score.js",
-    "./events": "./src/events.js"
+    "./events": "./src/events.js",
+    "./signing": "./src/signing.js"
   }
 }
diff --git a/packages/knowledge/src/events.js b/packages/knowledge/src/events.js
index b7a4615..d838978 100644
--- a/packages/knowledge/src/events.js
+++ b/packages/knowledge/src/events.js
@@ -41,6 +41,9 @@ export const NICHEDB_EVENTS = [
   'influencer.joined',
   'influencer.tier_changed',
   'expert_answer.created',
+  // A human read the question and sent it back: the agent has to find out more
+  // before a person can settle it. Not a failure, and not scored.
+  'agent.research_requested',
   'source.approved',
   'source.rejected',
   'product_idea.created',
diff --git a/packages/knowledge/src/index.js b/packages/knowledge/src/index.js
index 5730386..7bdca0d 100644
--- a/packages/knowledge/src/index.js
+++ b/packages/knowledge/src/index.js
@@ -86,3 +86,36 @@ export const RESERVED_NICHE_SLUGS = new Set([
 /** Is this slug safe to serve from the root? */
 export const isReservedNicheSlug = (slug) =>
   RESERVED_NICHE_SLUGS.has(String(slug ?? '').toLowerCase());
+
+/**
+ * A jsonb column, as an object.
+ *
+ * Bun's driver passes a string parameter cast to `jsonb` straight through, so
+ * a value written that way is stored as a jsonb STRING and read back as one.
+ * The writes now cast through `text` and store the real structure, but rows
+ * written before that fix are still strings, and a string reaching
+ * `Object.keys` renders its characters as though they were fields. That is
+ * exactly what shipped: two dimensions called `0` and `1`, holding a brace
+ * each, on every opportunity page.
+ *
+ * So every read of one of these columns goes through here. It is the same
+ * defence the ingest side already applies to a source's config.
+ */
+export function asJson(value, fallback = {}) {
+  if (value === null || value === undefined) return fallback;
+  if (typeof value === 'string') {
+    try {
+      const parsed = JSON.parse(value);
+      return parsed === null || typeof parsed !== 'object' ? fallback : parsed;
+    } catch {
+      return fallback;
+    }
+  }
+  return typeof value === 'object' ? value : fallback;
+}
+
+/** The same, for a column that should hold a list. */
+export function asJsonArray(value) {
+  const out = asJson(value, []);
+  return Array.isArray(out) ? out : [];
+}
diff --git a/packages/knowledge/src/signing.js b/packages/knowledge/src/signing.js
new file mode 100644
index 0000000..b0e0873
--- /dev/null
+++ b/packages/knowledge/src/signing.js
@@ -0,0 +1,85 @@
+/**
+ * Signed service requests between Chovy and NicheDB.
+ *
+ * The internal routes create scored work and move somebody's revenue share, so
+ * they are not open to whoever can reach the port. Every one carries an HMAC
+ * over the body and a timestamp, in the same shape this deployment already
+ * verifies for CoinPay webhooks:
+ *
+ *   X-Chovy-Signature: t=<unix seconds>,v1=<hex hmac-sha256>
+ *   signed payload:    `${t}.${rawBody}`
+ *
+ * The same scheme in both directions, so Chovy verifies what we send back with
+ * the code it already uses to sign what it sends.
+ *
+ * It lives here, with the rest of the contract, because a signature scheme one
+ * side invents privately is a scheme the other side gets subtly wrong. Pure
+ * strings in and out: no request object, no framework.
+ */
+
+import { createHmac, timingSafeEqual } from 'node:crypto';
+
+export const SIGNATURE_HEADER = 'x-chovy-signature';
+
+/** Seconds either side of now that a signature is still good for. */
+export const DEFAULT_TOLERANCE_SECONDS = 300;
+
+/** The header value for a body. `timestamp` is injectable so a test can pin it. */
+export function signPayload({ rawBody, secret, timestamp = Math.floor(Date.now() / 1000) }) {
+  if (!secret) throw new TypeError('signPayload needs a secret');
+  const t = Math.floor(Number(timestamp));
+  const mac = createHmac('sha256', secret)
+    .update(`${t}.${rawBody ?? ''}`)
+    .digest('hex');
+  return `t=${t},v1=${mac}`;
+}
+
+/** `t=1,v1=abc` → { t: '1', v1: 'abc' }. Splits on the first `=` only. */
+function parseHeader(header) {
+  const out = {};
+  for (const part of String(header ?? '').split(',')) {
+    const at = part.indexOf('=');
+    if (at === -1) continue;
+    out[part.slice(0, at).trim()] = part.slice(at + 1).trim();
+  }
+  return out;
+}
+
+/**
+ * Is this body signed by someone holding the secret, recently?
+ *
+ * Returns a reason rather than a bare false, because "your clock is wrong" and
+ * "your secret is wrong" are different problems and an integrator debugging a
+ * 401 cannot tell them apart otherwise.
+ */
+export function verifySignature({
+  rawBody,
+  header,
+  secret,
+  toleranceSeconds = DEFAULT_TOLERANCE_SECONDS,
+  now = Math.floor(Date.now() / 1000),
+}) {
+  if (!secret) return { ok: false, reason: 'no signing secret is configured' };
+  if (!header) return { ok: false, reason: 'no signature' };
+
+  const parts = parseHeader(header);
+  const t = Number(parts.t);
+  const given = parts.v1;
+  if (!Number.isFinite(t) || !given) return { ok: false, reason: 'malformed signature' };
+
+  // Checked before the compare, so a captured request cannot be replayed for
+  // ever. A future timestamp is refused on the same window: a clock running
+  // ahead is still a clock nobody should trust to be unique.
+  if (Math.abs(now - t) > toleranceSeconds) return { ok: false, reason: 'signature expired' };
+
+  const expected = createHmac('sha256', secret)
+    .update(`${t}.${rawBody ?? ''}`)
+    .digest('hex');
+  const a = Buffer.from(expected, 'utf8');
+  const b = Buffer.from(given, 'utf8');
+  // Length has to match before timingSafeEqual, which throws on a mismatch.
+  // Comparing lengths first leaks only the length, which the header already shows.
+  if (a.length !== b.length) return { ok: false, reason: 'bad signature' };
+  if (!timingSafeEqual(a, b)) return { ok: false, reason: 'bad signature' };
+  return { ok: true, timestamp: t };
+}
diff --git a/test/knowledge.test.js b/test/knowledge.test.js
index 6098489..c139d66 100644
--- a/test/knowledge.test.js
+++ b/test/knowledge.test.js
@@ -1,6 +1,8 @@
 import { describe, expect, test } from 'bun:test';
 import {
   allocate,
+  asJson,
+  asJsonArray,
   attributableNetMinor,
   CONTRIBUTION_TIERS,
   dedupeKeyFor,
@@ -315,3 +317,36 @@ describe('reserved slugs', () => {
     expect(isReservedNicheSlug('commercial-roofing')).toBe(false);
   });
 });
+
+describe('reading a jsonb column', () => {
+  test('an object comes back as itself', () => {
+    expect(asJson({ software_gap: 80 })).toEqual({ software_gap: 80 });
+    expect(asJsonArray([{ id: 'a' }])).toEqual([{ id: 'a' }]);
+  });
+
+  test('a column that stored a string is parsed rather than iterated', () => {
+    // This is the shape that shipped: Object.keys('{}') is ['0','1'], which is
+    // how two dimensions called 0 and 1 appeared on every opportunity page.
+    expect(Object.keys('{}')).toEqual(['0', '1']);
+    expect(asJson('{}')).toEqual({});
+    expect(Object.keys(asJson('{}'))).toEqual([]);
+    expect(asJson('{"software_gap":80}')).toEqual({ software_gap: 80 });
+    expect(asJsonArray('[{"id":"ea"}]')).toEqual([{ id: 'ea' }]);
+  });
+
+  test('null, nonsense and scalars fall back rather than throwing', () => {
+    expect(asJson(null)).toEqual({});
+    expect(asJson(undefined)).toEqual({});
+    expect(asJson('not json at all')).toEqual({});
+    expect(asJson('"just a string"')).toEqual({});
+    expect(asJson('42')).toEqual({});
+    expect(asJson(42)).toEqual({});
+    expect(asJson(null, { a: 1 })).toEqual({ a: 1 });
+  });
+
+  test('asJsonArray refuses an object, so a map() cannot be reached with one', () => {
+    expect(asJsonArray('{"a":1}')).toEqual([]);
+    expect(asJsonArray({ a: 1 })).toEqual([]);
+    expect(asJsonArray(null)).toEqual([]);
+  });
+});
diff --git a/test/schema.test.js b/test/schema.test.js
index 6e9b270..9208bba 100644
--- a/test/schema.test.js
+++ b/test/schema.test.js
@@ -62,6 +62,8 @@ describe('migrations', () => {
       'contribution_scores',
       'tier_history',
       'knowledge_audit_logs',
+      'agent_questions',
+      'agent_answers',
     ]) {
       expect(names).toContain(t);
     }
@@ -380,3 +382,238 @@ describe('knowledge influencers', () => {
     expect(audit[0].niche_id).toBeNull();
   });
 });
+
+/**
+ * The agent question loop's tables. What is checked here is what the
+ * application trusts the database for: a redelivered question appears once, a
+ * person answers once, and declining leaves no scored trace.
+ */
+describe('agent questions', () => {
+  const niche = async () =>
+    one(`insert into niches (slug, name) values ($1, 'N') returning id`, [
+      `q${Math.random()}`.replace('.', ''),
+    ]);
+  const person = async () =>
+    one(`insert into users (email) values ($1) returning id`, [`a${Math.random()}@e.com`]);
+  const ask = (nicheId, externalId = null, urgency = 'normal') =>
+    rows(
+      `insert into agent_questions (niche_id, external_id, title, question, urgency)
+       values ($1, $2, 'T', 'Q', $3)
+       on conflict (niche_id, external_id) where external_id is not null do nothing
+       returning id`,
+      [nicheId, externalId, urgency],
+    );
+
+  test('a question delivered twice is stored once', async () => {
+    const n = await niche();
+    expect((await ask(n.id, 'chovy-q-1')).length).toBe(1);
+    expect((await ask(n.id, 'chovy-q-1')).length).toBe(0);
+    // A different agent id is a different question.
+    expect((await ask(n.id, 'chovy-q-2')).length).toBe(1);
+  });
+
+  test('the same external id in another niche is another question', async () => {
+    const a = await niche();
+    const b = await niche();
+    expect((await ask(a.id, 'shared')).length).toBe(1);
+    expect((await ask(b.id, 'shared')).length).toBe(1);
+  });
+
+  test('questions raised by hand have no id and never collide', async () => {
+    const n = await niche();
+    expect((await ask(n.id, null)).length).toBe(1);
+    expect((await ask(n.id, null)).length).toBe(1);
+  });
+
+  test('urgency and status are constrained, so a typo cannot hide a question', async () => {
+    const n = await niche();
+    let threw = null;
+    try {
+      await db.query(
+        `insert into agent_questions (niche_id, title, question, urgency) values ($1,'T','Q','asap')`,
+        [n.id],
+      );
+    } catch (e) {
+      threw = e.message;
+    }
+    expect(threw).toMatch(/agent_questions_urgency/);
+
+    threw = null;
+    try {
+      await db.query(
+        `insert into agent_questions (niche_id, title, question, status) values ($1,'T','Q','done')`,
+        [n.id],
+      );
+    } catch (e) {
+      threw = e.message;
+    }
+    expect(threw).toMatch(/agent_questions_status/);
+  });
+
+  test('one answer per person per question', async () => {
+    const n = await niche();
+    const [q] = await ask(n.id, 'once');
+    const u = await person();
+    const answer = () =>
+      rows(
+        `insert into agent_answers (question_id, influencer_id, kind, body)
+         values ($1, $2, 'answered', 'ten percent')
+         on conflict (question_id, influencer_id) do nothing returning id`,
+        [q.id, u.id],
+      );
+    expect((await answer()).length).toBe(1);
+    expect((await answer()).length).toBe(0);
+  });
+
+  test('two operators can each answer the same question', async () => {
+    const n = await niche();
+    const [q] = await ask(n.id, 'two');
+    const a = await person();
+    const b = await person();
+    for (const u of [a, b]) {
+      const out = await rows(
+        `insert into agent_answers (question_id, influencer_id, kind) values ($1, $2, 'answered')
+         on conflict (question_id, influencer_id) do nothing returning id`,
+        [q.id, u.id],
+      );
+      expect(out.length).toBe(1);
+    }
+  });
+
+  test('declining is recorded and carries no contribution', async () => {
+    const n = await niche();
+    const [q] = await ask(n.id, 'decline');
+    const u = await person();
+    await db.query(
+      `insert into agent_answers (question_id, influencer_id, kind) values ($1, $2, 'insufficient_context')`,
+      [q.id, u.id],
+    );
+    const row = await one(
+      `select kind, contribution_event_id from agent_answers where question_id = $1`,
+      [q.id],
+    );
+    expect(row.kind).toBe('insufficient_context');
+    // No points, and nothing to reverse later. Declining has to be free.
+    expect(row.contribution_event_id).toBeNull();
+  });
+
+  test('an answer kind nobody defined is refused', async () => {
+    const n = await niche();
+    const [q] = await ask(n.id, 'kind');
+    const u = await person();
+    let threw = null;
+    try {
+      await db.query(
+        `insert into agent_answers (question_id, influencer_id, kind) values ($1, $2, 'maybe')`,
+        [q.id, u.id],
+      );
+    } catch (e) {
+      threw = e.message;
+    }
+    expect(threw).toMatch(/agent_answers_kind/);
+  });
+
+  test('the open queue is urgent first, then oldest first', async () => {
+    const n = await niche();
+    await ask(n.id, 'low-1', 'low');
+    await ask(n.id, 'high-1', 'high');
+    await ask(n.id, 'normal-1', 'normal');
+    const queue = await rows(
+      `select external_id from agent_questions
+       where niche_id = $1 and status in ('open','researching')
+       order by case urgency when 'high' then 0 when 'normal' then 1 else 2 end, created_at`,
+      [n.id],
+    );
+    expect(queue.map((r) => r.external_id)).toEqual(['high-1', 'normal-1', 'low-1']);
+  });
+
+  test('deleting a question takes its answers, and the contribution outlives it', async () => {
+    const n = await niche();
+    const [q] = await ask(n.id, 'cascade');
+    const u = await person();
+    const ev = await one(
+      `insert into contribution_events (niche_id, influencer_id, event_type, points, status)
+       values ($1, $2, 'agent_answer', 3, 'verified') returning id`,
+      [n.id, u.id],
+    );
+    await db.query(
+      `insert into agent_answers (question_id, influencer_id, kind, contribution_event_id)
+       values ($1, $2, 'answered', $3)`,
+      [q.id, u.id, ev.id],
+    );
+    await db.query(`delete from agent_questions where id = $1`, [q.id]);
+    expect((await rows(`select id from agent_answers where question_id = $1`, [q.id])).length).toBe(
+      0,
+    );
+    // The score does not move because a question was tidied away.
+    expect(await one(`select id from contribution_events where id = $1`, [ev.id])).toBeDefined();
+  });
+});
+
+/**
+ * The jsonb repair. What went wrong is worth pinning down: a stringified
+ * object cast straight to jsonb is stored as a jsonb *string*, and every read
+ * of it then sees characters instead of fields.
+ */
+describe('jsonb columns hold structure, not a string of one', () => {
+  test('casting through text is what parses it', async () => {
+    const direct = await one(`select jsonb_typeof($1::jsonb) as shape`, ['{"software_gap":80}']);
+    const viaText = await one(`select jsonb_typeof($1::text::jsonb) as shape`, [
+      '{"software_gap":80}',
+    ]);
+    // PGlite parses a text parameter on the way in, so both look right here.
+    // The distinction this pins is the SQL, which is what production runs.
+    expect(['string', 'object']).toContain(direct.shape);
+    expect(viaText.shape).toBe('object');
+  });
+
+  test('the repair turns a jsonb string back into the object it spells', async () => {
+    const n = await one(`insert into niches (slug, name) values ($1,'N') returning id`, [
+      `r${Math.random()}`.replace('.', ''),
+    ]);
+    // Store the broken shape on purpose: a jsonb string containing JSON.
+    await db.query(
+      `insert into opportunities (niche_id, dimensions) values ($1, to_jsonb($2::text))`,
+      [n.id, '{"software_gap":80}'],
+    );
+    const before = await one(
+      `select jsonb_typeof(dimensions) as shape from opportunities where niche_id = $1`,
+      [n.id],
+    );
+    expect(before.shape).toBe('string');
+
+    await db.query(
+      `update opportunities set dimensions = (dimensions #>> '{}')::jsonb
+       where jsonb_typeof(dimensions) = 'string'`,
+    );
+
+    const after = await one(
+      `select jsonb_typeof(dimensions) as shape, dimensions->>'software_gap' as gap
+       from opportunities where niche_id = $1`,
+      [n.id],
+    );
+    expect(after.shape).toBe('object');
+    // And it is queryable as jsonb, which a string never was.
+    expect(after.gap).toBe('80');
+  });
+
+  test('the repair leaves a correct row alone and can be run twice', async () => {
+    const n = await one(`insert into niches (slug, name) values ($1,'N') returning id`, [
+      `r${Math.random()}`.replace('.', ''),
+    ]);
+    await db.query(`insert into opportunities (niche_id, dimensions) values ($1, $2::jsonb)`, [
+      n.id,
+      '{"lead_value":70}',
+    ]);
+    const repair = () =>
+      db.query(`update opportunities set dimensions = (dimensions #>> '{}')::jsonb
+                where jsonb_typeof(dimensions) = 'string'`);
+    await repair();
+    await repair();
+    const after = await one(
+      `select dimensions->>'lead_value' as v from opportunities where niche_id = $1`,
+      [n.id],
+    );
+    expect(after.v).toBe('70');
+  });
+});
diff --git a/test/signing.test.js b/test/signing.test.js
new file mode 100644
index 0000000..4449549
--- /dev/null
+++ b/test/signing.test.js
@@ -0,0 +1,98 @@
+import { describe, expect, test } from 'bun:test';
+import {
+  DEFAULT_TOLERANCE_SECONDS,
+  SIGNATURE_HEADER,
+  signPayload,
+  verifySignature,
+} from '../packages/knowledge/src/signing.js';
+
+/**
+ * The internal routes create scored work and move somebody's revenue share, so
+ * what this file is really testing is that nobody without the secret can.
+ */
+const secret = 'a-test-signing-secret';
+const body = JSON.stringify({ type: 'agent.question_created', payload: { title: 'TPO waste' } });
+
+describe('signing', () => {
+  test('a body signed with the secret verifies', () => {
+    const header = signPayload({ rawBody: body, secret });
+    expect(verifySignature({ rawBody: body, header, secret })).toMatchObject({ ok: true });
+  });
+
+  test('the header is the house shape: t=<unix>,v1=<hex>', () => {
+    const header = signPayload({ rawBody: body, secret, timestamp: 1_700_000_000 });
+    expect(header).toMatch(/^t=1700000000,v1=[0-9a-f]{64}$/);
+    expect(SIGNATURE_HEADER).toBe('x-chovy-signature');
+  });
+
+  test('a changed body does not verify against the old signature', () => {
+    const header = signPayload({ rawBody: body, secret });
+    const tampered = body.replace('TPO waste', 'TPO waste (edited)');
+    expect(verifySignature({ rawBody: tampered, header, secret })).toMatchObject({
+      ok: false,
+      reason: 'bad signature',
+    });
+  });
+
+  test('the wrong secret does not verify', () => {
+    const header = signPayload({ rawBody: body, secret: 'someone elses secret' });
+    expect(verifySignature({ rawBody: body, header, secret }).ok).toBe(false);
+  });
+
+  test('a captured request cannot be replayed once the window has passed', () => {
+    const t = 1_700_000_000;
+    const header = signPayload({ rawBody: body, secret, timestamp: t });
+    // Inside the window it is still good.
+    expect(verifySignature({ rawBody: body, header, secret, now: t + 60 }).ok).toBe(true);
+    // Outside it, the same bytes are refused.
+    expect(
+      verifySignature({ rawBody: body, header, secret, now: t + DEFAULT_TOLERANCE_SECONDS + 1 }),
+    ).toMatchObject({ ok: false, reason: 'signature expired' });
+  });
+
+  test('a timestamp in the future is refused on the same window', () => {
+    const t = 1_700_000_000;
+    const header = signPayload({ rawBody: body, secret, timestamp: t });
+    expect(
+      verifySignature({ rawBody: body, header, secret, now: t - DEFAULT_TOLERANCE_SECONDS - 1 }).ok,
+    ).toBe(false);
+  });
+
+  test('moving the timestamp invalidates the signature, so the window cannot be re-dated', () => {
+    const t = 1_700_000_000;
+    const header = signPayload({ rawBody: body, secret, timestamp: t });
+    const mac = header.split('v1=')[1];
+    const restamped = `t=${t + 10_000},v1=${mac}`;
+    expect(
+      verifySignature({ rawBody: body, header: restamped, secret, now: t + 10_000 }),
+    ).toMatchObject({ ok: false, reason: 'bad signature' });
+  });
+
+  test('nonsense headers are refused rather than throwing', () => {
+    for (const header of ['', 'garbage', 't=abc,v1=x', 'v1=onlythis', 't=1700000000']) {
+      expect(verifySignature({ rawBody: body, header, secret }).ok).toBe(false);
+    }
+  });
+
+  test('a signature of a different length is refused without throwing', () => {
+    // timingSafeEqual throws on unequal lengths, so this path must not reach it.
+    const header = 't=1700000000,v1=abc';
+    expect(verifySignature({ rawBody: body, header, secret, now: 1_700_000_000 })).toMatchObject({
+      ok: false,
+      reason: 'bad signature',
+    });
+  });
+
+  test('with no secret configured nothing verifies, and signing refuses', () => {
+    const header = signPayload({ rawBody: body, secret });
+    expect(verifySignature({ rawBody: body, header, secret: '' }).ok).toBe(false);
+    expect(() => signPayload({ rawBody: body, secret: '' })).toThrow();
+  });
+
+  test('an empty body still signs and verifies', () => {
+    const header = signPayload({ rawBody: '', secret });
+    expect(verifySignature({ rawBody: '', header, secret }).ok).toBe(true);
+    // And an empty body is not interchangeable with a full one.
+    expect(verifySignature({ rawBody: body, header, secret }).ok).toBe(false);
+  });
+});