@secondlayer/sentinel 0.1.0 → 0.2.0

package/README.md

@@ -31,7 +31,7 @@ Anything that spends balance or changes monitoring shows what it would do first
 claude mcp add sentinel -- npx -y -p @secondlayer/sentinel sentinel-mcp
 ```
 
-Uses your login, or add `--env SENTINEL_API_KEY=sk-sl_…` for a scoped key. Every write tool takes `confirm`; without it you get what would happen and nothing changes.
+Uses your login, or add `--env SENTINEL_API_KEY=sk-snt_…` for a scoped key. A secondlayer API key won't work here; Sentinel keys start `sk-snt_`. Every write tool takes `confirm`; without it you get what would happen and nothing changes.
 
 ## SDK
 

package/dist/cli.js

@@ -85,10 +85,14 @@ class SentinelError extends Error {
     this.name = "SentinelError";
   }
 }
-var subjectKey = (s) => s.kind === "fn" ? `fn:${s.fn}` : `asset:${s.asset}`;
+var rowsOf = (intents) => intents.flatMap((i) => i.rows);
+var subjectKey = (s) => s.kind === "fn" ? `fn:${s.fn}` : s.kind === "group" ? `group:${s.group}` : `asset:${s.asset}`;
+var CONTROL_NAME = "Control changes";
 function subjectName(s, units) {
   if (s.kind === "fn")
     return s.fn;
+  if (s.kind === "group")
+    return CONTROL_NAME;
   if (units?.symbol)
     return units.symbol;
   if (s.asset.toLowerCase() === "stx")
@@ -120,7 +124,7 @@ function resolveSubject(watches, name) {
   const hits = groups.filter((g) => {
     const s = g.watches[0].subject;
     const asset = s.kind === "asset" ? s.asset.toLowerCase() : null;
-    return g.name.toLowerCase() === q || g.key.toLowerCase() === q || asset === q || asset !== null && asset.split("::")[1] === q;
+    return g.name.toLowerCase() === q || g.key.toLowerCase() === q || s.kind === "group" && q === s.group || asset === q || asset !== null && asset.split("::")[1] === q;
   });
   if (hits.length === 1)
     return hits[0];
@@ -172,26 +176,16 @@ function ruleSummary(rule, units) {
     }
   }
 }
-function kindTag(rule) {
-  switch (rule.kind) {
-    case "signature":
-      return "finding";
-    case "outflowSingle":
-    case "outflowWindow":
-    case "valueNewActor":
-      return "outflow";
-    case "callerAllowlist":
-    case "actor":
-      return "who-acts";
-    case "audit":
-      return rule.triggerClass === "governance.proposal_submitted" ? "governance" : "upgrade";
+function intentLine(i) {
+  const t = i.threshold;
+  if (i.kind !== "money_out" || !t)
+    return i.summary;
+  const units = i.units ?? null;
+  if (t.amount === null) {
+    const sug = t.suggested ? ` (suggested ${amountText(t.suggested.amount, units)}, ${t.suggested.basis})` : "";
+    return `no threshold yet: every outflow alerts${sug}`;
   }
-}
-function subjectStatus(ws) {
-  const st = ws.map((w) => w.status);
-  if (st.includes("live"))
-    return "live";
-  return st.length > 0 && st.every((x) => x === "paused") ? "paused" : "suggested";
+  return `${amountText(t.amount, units)} or more in one tx · ${t.basis}`;
 }
 var isMutableRule = (rule) => rule.kind !== "signature" && rule.kind !== "audit";
 function mutedUntilOf(w, now = Date.now()) {
@@ -256,11 +250,13 @@ var HOUR_MS = 3600000;
 var muteEnd = (hours) => new Date(Date.now() + Math.min(hours * HOUR_MS, 7 * 24 * HOUR_MS - 60000)).toISOString();
 async function watchContext(client, planId) {
   const plan = await client.plan(planId);
+  const { intents } = await client.watches(planId);
   return {
     planId,
     contractId: plan.contractId,
     access: plan.access,
-    watches: (await client.watches(planId)).watches
+    intents,
+    watches: rowsOf(intents)
   };
 }
 async function savedMonitor(client, planId) {
@@ -279,6 +275,16 @@ async function planOfContract(client, contractId) {
 }
 
 // cli/auth.ts
+var NEEDS_TTY = 'sentinel login needs an interactive terminal. In CI: echo "$KEY" | sentinel login --with-token';
+var API_KEY_LOGIN = "Your secondlayer login is an API key Sentinel can't use. Run: sentinel login --force";
+
+class PromptClosedError extends Error {
+  constructor() {
+    super(NEEDS_TTY);
+    this.name = "PromptClosedError";
+  }
+}
+var isOtherProductKey = (message) => message.startsWith("This is a secondlayer API key");
 var sessionExpiry = () => new Date(Date.now() + 90 * 24 * 60 * 60 * 1000).toISOString();
 async function post(doFetch, path, body) {
   try {
@@ -324,9 +330,39 @@ async function login(flags, io) {
   }
   const existing = await readSession();
   if (existing && !flags.includes("--force")) {
-    io.out(`Already logged in as ${existing.email}. Run again with --force to switch accounts.`);
-    return 0;
+    const r = await check(auth.clientFor(existing.token));
+    if (!("error" in r)) {
+      io.out(`Already logged in as ${r.email ?? existing.email}. Run again with --force to switch accounts.`);
+      return 0;
+    }
+    if (r.status === 401 && (existing.token.startsWith("sk-sl_") || isOtherProductKey(r.error))) {
+      io.err(API_KEY_LOGIN);
+      return 1;
+    }
+    if (r.status === 403) {
+      io.err(r.error);
+      return 0;
+    }
+    if (r.status !== 401) {
+      io.err(r.error);
+      return 1;
+    }
+  }
+  if (!auth.interactive) {
+    io.err(NEEDS_TTY);
+    return 2;
+  }
+  try {
+    return await promptLogin(io);
+  } catch (e) {
+    if (!(e instanceof PromptClosedError))
+      throw e;
+    io.err(NEEDS_TTY);
+    return 2;
   }
+}
+async function promptLogin(io) {
+  const { auth } = io;
   const doFetch = auth.fetch ?? globalThis.fetch;
   const email = (await auth.prompt("Email: ")).trim();
   if (!/^.+@.+\..+$/.test(email)) {
@@ -383,6 +419,330 @@ async function whoami(client, io) {
   return 0;
 }
 
+// client/kind.ts
+var isGreen = (f) => f.poc === "green";
+function findingKind(f) {
+  if (f.disposition === "refuted" || f.verdict === "refuted")
+    return "refuted";
+  if (f.class === "centralization" || f.disposition === "waived")
+    return "trust";
+  if (f.class === "bug" && f.verdict === "confirmed" && f.reverified === true && isGreen(f)) {
+    return "exploitable";
+  }
+  return "worth_a_look";
+}
+var URGENT_CONSEQUENCES = new Set(["authority", "code", "value"]);
+var KIND_LABEL = {
+  exploitable: "Exploitable",
+  trust: "Trust assumption",
+  worth_a_look: "Worth a look",
+  refuted: "refuted"
+};
+
+// client/labels.ts
+var isPrelaunchKey = (id) => id.startsWith("github:") || id.startsWith("gist:");
+function contractName(id) {
+  if (isPrelaunchKey(id))
+    return id.split(":").pop()?.split("/").pop()?.replace(/\.clar$/, "") ?? id;
+  return id.split(".")[1] ?? id;
+}
+var MONITOR_LABELS = {
+  draft: "not on yet",
+  requested: "setting up",
+  live: "watching",
+  armed: "armed for launch",
+  stale: "deploy didn't match"
+};
+var monitoringLabel = (status) => status ? MONITOR_LABELS[status] ?? status : "not on yet";
+
+// client/handoff.ts
+var DEFAULT_FILE = "sentinel-poc.ts";
+var pocFileName = (f) => f.proof?.file ?? DEFAULT_FILE;
+function runCommand(opts) {
+  const lines = [`# save the PoC above as ${opts.file}, then in your own checkout:`];
+  if (opts.commit)
+    lines.push(`git checkout ${opts.commit}   # the commit Sentinel reviewed`);
+  const where = opts.substrate === "fork" ? "needs a Stacks RPC" : "airgapped, no network";
+  lines.push(`bun run ${opts.file}   # @stacks/clarinet-sdk — ${where}`);
+  return lines.join(`
+`);
+}
+function handoffBundle(f, ctx) {
+  const proof = f.proof;
+  const file = pocFileName(f);
+  const poc = proof?.script ? {
+    file,
+    substrate: proof.substrate ?? null,
+    reproduced: !!proof.reproduced,
+    exitCode: proof.exitCode ?? null,
+    source: proof.script
+  } : null;
+  return {
+    contract: ctx.contract,
+    fn: f.targetFn ?? null,
+    commit: ctx.commit ?? null,
+    poc,
+    runCommand: poc ? runCommand({ commit: ctx.commit, file, substrate: poc.substrate }) : null
+  };
+}
+function assertionsOf(output) {
+  const ratio = output.match(/(\d+)\s*\/\s*(\d+)\s*assertions?/i);
+  if (ratio)
+    return `${ratio[1]}/${ratio[2]}`;
+  const passed = output.match(/(\d+)\s*assertions?\s*passed/i);
+  return passed ? `${passed[1]} passed` : null;
+}
+var FENCE = "```";
+var FOOTER = "Sentinel's findings are a starting point for your own review, not an audit sign-off.";
+var KIND_LINE = {
+  exploitable: "Exploitable (verified, re-verified, reproduced in the sandbox)",
+  trust: "Trust assumption (watched: Sentinel alerts when it's used)",
+  worth_a_look: "Worth a look (not proven exploitable)",
+  refuted: "Refuted"
+};
+var tick = (s) => `\`${s}\``;
+var cell = (s) => s.replace(/\|/g, "\\|").replace(/\n/g, " ");
+var num = (n) => n.toLocaleString("en-US");
+function printed(output) {
+  const lines = output.replace(/\[SENTINEL-POC-TRACE\][\s\S]*?\[\/SENTINEL-POC-TRACE\]/g, "").split(`
+`).filter((l) => l.trim());
+  return lines.slice(-40).join(`
+`);
+}
+function movedMd(trace) {
+  const keys = Object.keys(trace.series ?? {}).filter((k) => trace.steps.some((s) => s.values?.[k] !== undefined));
+  const name = (k) => trace.series?.[k] ?? k;
+  const unit = trace.unit ? ` ${trace.unit}` : "";
+  const changes = (i) => {
+    const prev = trace.steps[i - 1]?.values;
+    const now = trace.steps[i].values;
+    if (!prev || !now)
+      return [];
+    return keys.filter((k) => now[k] !== undefined && prev[k] !== undefined && now[k] !== prev[k]).map((k) => `${name(k)} ${num(prev[k])} → ${num(now[k])}${unit}`);
+  };
+  const first = trace.steps.findIndex((_, i) => changes(i).length > 0);
+  const rows = trace.steps.map((s, i) => {
+    const call = [s.call && tick(s.call), s.result && `→ ${tick(s.result)}`].filter(Boolean).join(" ");
+    const start = keys.filter((k) => s.values?.[k] !== undefined).map((k) => `${name(k)} ${num(s.values?.[k])}${unit}`).join(" · ");
+    const change = i === 0 ? start || "start" : changes(i).join(" · ") || "no change";
+    return `| ${i + 1} ${cell(s.label)} | ${cell(call || "—")} | ${cell(change)} |`;
+  });
+  return [
+    "## What the PoC moved",
+    first > 0 ? `**${changes(first).join("; ")} at step ${first + 1} (${trace.steps[first].label}).**` : "No tracked value changed across the steps.",
+    "",
+    "| Step | Call | Value change |",
+    "|---|---|---|",
+    ...rows,
+    ""
+  ];
+}
+function variantOf(f) {
+  if (f.proof?.reproduced)
+    return "reproduced";
+  if (f.proof && !f.proof.unavailable && !f.proof.errored && f.proof.script)
+    return "notrepro";
+  if (f.verdict !== "confirmed")
+    return "lead";
+  return "analysis";
+}
+function where(f, ctx) {
+  const at = ctx.commit ? ` at commit ${tick(ctx.commit.slice(0, 7))}` : "";
+  return f.targetFn ? `Open ${tick(f.targetFn)} in ${tick(contractName(ctx.contract))}${at} and show the function with ~10 lines of context. Point at the lines this finding is about and explain in your own words what they do.` : `Find the code this finding describes in ${tick(contractName(ctx.contract))}${at} and show it with ~10 lines of context. Explain in your own words what it does.`;
+}
+function contextMd(f, ctx, kind) {
+  return [
+    "## Context",
+    `- Contract: ${tick(ctx.contract)}`,
+    ...ctx.commit ? [`- Commit reviewed: ${tick(ctx.commit.slice(0, 7))}`] : [],
+    ...f.targetFn ? [`- Function: ${tick(f.targetFn)}`] : [],
+    `- Kind: ${KIND_LINE[kind]}`
+  ];
+}
+function reportBackMd(ctx, extra) {
+  return [
+    "## How to report back",
+    `- Cite every claim with ${tick("file:line")}${ctx.commit ? ` at commit ${tick(ctx.commit.slice(0, 7))}` : ""}.`,
+    "- Show the code you discuss, quoted from the repo, not paraphrased.",
+    extra,
+    "- Keep two sections: **Facts** (what the code and the run show) and **Assessment** (your conclusions, each with a confidence level). Don't mix them.",
+    "- Don't change contract code until the team has chosen an approach.",
+    ""
+  ];
+}
+function tailMd(ctx, withPoc) {
+  return [
+    "",
+    "## Pull it again",
+    `${FENCE}shell`,
+    `npx @secondlayer/sentinel finding ${ctx.planId} ${ctx.index}${withPoc ? " --poc --run" : ""}`,
+    FENCE,
+    `MCP: ${tick(`get_finding { planId: "${ctx.planId}", index: ${ctx.index} }`)} returns this finding as JSON${withPoc ? ", the PoC source and the run command" : ""}.`,
+    "",
+    "---",
+    FOOTER
+  ];
+}
+function issueMd(f, withCondition) {
+  return [
+    "## The issue",
+    f.headline && f.headline !== f.title ? `${f.headline} (${f.title})` : f.title,
+    ...f.blastRadius ? ["", `**Impact:** ${f.blastRadius}`] : [],
+    ...withCondition && f.precondition ? ["", `**Exploitable when:** ${f.precondition}`] : [],
+    ""
+  ];
+}
+function prelaunchBrief(f, ctx, kind) {
+  const kindLine = kind === "exploitable" ? "Exploitable · look before launch" : kind === "trust" ? "Trust assumption" : "Worth a look before launch";
+  return [
+    "# Task: review a Sentinel finding on pre-launch code",
+    "",
+    `Sentinel found an issue${f.targetFn ? ` in ${tick(f.targetFn)}` : ""}: ${f.title}. PoCs and exploit detail open once Sentinel confirms this code isn't already live on mainnet; possible approaches are shown now, so this brief carries the finding and a direction, not the PoC. Look at the code before launch: the watch arms at launch, but it isn't a substitute for the review.`,
+    "",
+    "## Start here",
+    `1. ${where(f, ctx)}`,
+    "2. Only then discuss approaches that fit this codebase's design.",
+    "",
+    "## How to report back",
+    `- Cite every claim with ${tick("file:line")}${ctx.commit ? ` at commit ${tick(ctx.commit.slice(0, 7))}` : ""}.`,
+    "- Keep **Facts** and **Assessment** apart, with a confidence level on each conclusion.",
+    "",
+    "## Context",
+    `- Contract: ${tick(contractName(ctx.contract))} (pre-launch)${ctx.commit ? `, commit ${tick(ctx.commit.slice(0, 7))}` : ""}`,
+    `- ${f.targetFn ? `Function: ${tick(f.targetFn)} · ` : ""}Kind: ${kindLine}`,
+    "",
+    ...issueMd(f, false),
+    ...f.recommendedAction ? ["## One direction to consider (not a verified patch)", f.recommendedAction, ""] : [],
+    "---",
+    FOOTER
+  ].join(`
+`);
+}
+function trustBrief(f, ctx) {
+  return [
+    "# Task: review a trust assumption and decide whether to reduce it",
+    "",
+    `Sentinel found a power held by design${f.targetFn ? ` in ${tick(f.targetFn)}` : ""}: ${f.title}. It's a trust assumption, not a bug, so there is nothing to reproduce. Review it and decide whether the trust it asks of your users fits your design.`,
+    "",
+    "## Start here",
+    `1. ${where(f, ctx)}`,
+    `2. Find every place that reads what ${f.targetFn ? tick(f.targetFn) : "this power"} changes, and show each one, so the reach of this power is clear.`,
+    "3. Only then discuss options that fit this codebase's design.",
+    "",
+    ...reportBackMd(ctx, "- There is no PoC for a trust assumption. Don't write an exploit for it."),
+    ...contextMd(f, ctx, "trust"),
+    "- Class: trust assumption (a power held by design)",
+    "- Evidence: checked by Sentinel's adversarial verifier. No PoC; nothing to run.",
+    "",
+    "## What it is",
+    f.headline && f.headline !== f.title ? `${f.headline} (${f.title})` : f.title,
+    ...f.powers?.length ? [
+      "",
+      "**Powers:**",
+      ...f.powers.map((p) => `- ${p.holder} can ${p.can}${p.fn ? ` (${tick(p.fn)})` : ""}`)
+    ] : [],
+    ...f.blastRadius ? ["", `**Impact:** ${f.blastRadius}`] : [],
+    ...f.precondition ? ["", `**Usable when:** ${f.precondition}`] : [],
+    "",
+    ...f.recommendedAction ? ["## Options to consider (not a patch)", `- ${f.recommendedAction}`, ""] : [],
+    "## If you change it",
+    "- A test for the new behavior.",
+    "- A test that an account without the role is still refused.",
+    ...tailMd(ctx, false)
+  ].join(`
+`);
+}
+function refutedBrief(f, ctx) {
+  return [
+    "# Note: a Sentinel finding refuted on re-check",
+    "",
+    `Sentinel's verifier re-examined this${f.targetFn ? ` (${tick(f.targetFn)})` : ""} and showed it can't happen: ${f.title}. It's kept for the record and isn't watched.`,
+    "",
+    ...contextMd(f, ctx, "refuted"),
+    ...tailMd(ctx, false)
+  ].join(`
+`);
+}
+function bugBrief(f, ctx, kind) {
+  const v = variantOf(f);
+  const bundle = handoffBundle(f, { contract: ctx.contract, commit: ctx.commit });
+  const poc = bundle.poc;
+  const p = f.proof;
+  const asserted = p?.output ? assertionsOf(p.output) : null;
+  const counted = asserted?.includes("/") ? `${asserted} assertions, ` : asserted ? `${asserted.replace(" passed", "")} assertions passed, ` : "";
+  const ran = `${counted}exit ${p?.exitCode ?? "?"}`;
+  const sandbox = p?.substrate === "fork" ? "a mainnet-fork sandbox" : `an airgapped sandbox (${tick("--network none")})`;
+  const what = `Sentinel found an issue${f.targetFn ? ` in ${tick(f.targetFn)}` : ""}: ${f.title}`;
+  const open = {
+    reproduced: `${what}. It reproduced with the PoC below. Review the affected code, choose an approach that fits your design, then confirm the PoC no longer succeeds.`,
+    notrepro: `${what}. Its verifier confirmed it by analysis, but the PoC below ran and did not reproduce it. Review the affected code and the run, and decide whether it applies to your deployment.`,
+    analysis: `${what}. Its verifier confirmed it by analysis; no PoC result yet. ${poc ? "Run the PoC below in your own tooling, then review" : "Review"} the affected code and choose an approach that fits your design.`,
+    lead: `An auditor flagged an issue${f.targetFn ? ` in ${tick(f.targetFn)}` : ""}: ${f.title}. The verifier hasn't confirmed it, so treat it as a lead.`
+  }[v];
+  const evidence = {
+    reproduced: `confirmed by Sentinel's adversarial verifier${f.reverified ? ", re-verified by a second independent pass" : ""}, then reproduced in ${sandbox}: ${ran}.${f.reverified ? "" : " Not re-verified yet."}`,
+    notrepro: `confirmed by Sentinel's adversarial verifier. The PoC ran in ${sandbox} and did not reproduce it (${ran}). Verified by analysis only.`,
+    analysis: "confirmed by Sentinel's adversarial verifier. No PoC result yet.",
+    lead: "found by an auditor, not yet confirmed by the verifier. Treat it as a lead."
+  }[v];
+  const runStep = poc ? v === "notrepro" ? `2. Save the PoC below as ${tick(poc.file)} and run it. Show the output, compare it with Sentinel's run below, and say whether it reproduces in this codebase.` : v === "reproduced" ? `2. Save the PoC below as ${tick(poc.file)} and run it. Show the output and say whether it reproduces.` : `2. Save the PoC below as ${tick(poc.file)} and run it. Show the output and say whether it reproduces. If its setup doesn't match this codebase, adapt it and list what you changed.` : null;
+  const out = p?.output ? printed(p.output) : "";
+  return [
+    "# Task: investigate a Sentinel finding and decide on an approach",
+    "",
+    `${open}${poc ? " Simnet only; nothing touches mainnet." : ""}`,
+    "",
+    "## Start here",
+    `1. ${where(f, ctx)}`,
+    ...runStep ? [runStep] : [],
+    `${runStep ? 3 : 2}. Only then discuss approaches that fit this codebase's design.`,
+    "",
+    ...reportBackMd(ctx, poc ? "- Show the exact command you ran and its full output." : "- Say what you checked and how."),
+    ...contextMd(f, ctx, kind),
+    f.class === "bug" ? "- Class: bug (not a trust assumption; no privileged role needed)" : `- Class: ${f.class}`,
+    `- Evidence: ${evidence}`,
+    "",
+    ...v === "reproduced" && p?.trace ? movedMd(p.trace) : [],
+    ...issueMd(f, true),
+    ...poc ? [
+      v === "notrepro" ? `## PoC as it ran (save as ${tick(poc.file)})` : `## PoC (save as ${tick(poc.file)})`,
+      `${FENCE}typescript`,
+      poc.source,
+      FENCE,
+      "",
+      "## Run it",
+      `${FENCE}shell`,
+      bundle.runCommand ?? "",
+      FENCE,
+      ...out && (v === "reproduced" || v === "notrepro") ? [
+        v === "reproduced" ? "Sentinel's output, before any change:" : "Sentinel's run printed:",
+        FENCE,
+        out,
+        FENCE
+      ] : [],
+      ""
+    ] : [],
+    ...f.recommendedAction ? ["## One direction to consider (not a verified patch)", f.recommendedAction, ""] : [],
+    ...poc ? [
+      "## Confirm a change",
+      "- Re-run the PoC. With your change in place it should no longer succeed.",
+      "- Consider keeping the PoC as a regression test, with its assertions flipped to expect the failure."
+    ] : [],
+    ...tailMd(ctx, !!poc)
+  ].join(`
+`);
+}
+function agentBrief(f, ctx) {
+  const kind = f.kind ?? findingKind(f);
+  if (ctx.prelaunch && kind !== "refuted")
+    return prelaunchBrief(f, ctx, kind);
+  if (kind === "refuted")
+    return refutedBrief(f, ctx);
+  if (kind === "trust")
+    return trustBrief(f, ctx);
+  return bugBrief(f, ctx, kind);
+}
+
 // cli/sentinel.ts
 var USAGE = `sentinel <command>
 
@@ -396,7 +756,8 @@ var USAGE = `sentinel <command>
 
   plans                       your contracts: monitoring, worst evidence, plan id
   plan <id> [--json]          verdict and findings (--json: the raw v1 response)
-  finding <id> <n> [--json]   one finding
+  finding <id> <n> [--poc] [--run] [--brief] [--json]   one finding; --poc adds the PoC source, --run the command
+                              to re-run it, --brief the agent brief (the finding page's "Copy agent brief")
   runs <id>                   follow-up runs on a plan
   watch <id>                  follow running runs until none are left
   reverify <id> [--yes]       check a plan's leads again (stronger second pass, $3); only starts with --yes
@@ -430,9 +791,9 @@ credential: SENTINEL_API_KEY, then --token <key>, then sentinel login. env: SENT
 `;
 var POLL_MS = 5000;
 var VALUE_FLAGS = new Set(["--email", "--webhook", "--slack", "--contract"]);
-var cell = (v, empty = "—") => v === null || v === undefined || v === "" ? empty : String(v);
+var cell2 = (v, empty = "—") => v === null || v === undefined || v === "" ? empty : String(v);
 var table = (rows) => {
-  const text = rows.map((r) => r.map((c) => cell(c)));
+  const text = rows.map((r) => r.map((c) => cell2(c)));
   const w = text[0]?.map((_, i) => Math.max(...text.map((r) => r[i].length))) ?? [];
   return text.map((r) => r.map((c, i) => c.padEnd(w[i])).join("  ").trimEnd());
 };
@@ -443,7 +804,7 @@ var phaseOf = (r) => {
 var verdictLine = (p) => {
   const r = p.report;
   const head = `${p.contractId}  ${p.status}`;
-  return r ? `${head}  ${cell(r.severity)}/${cell(r.class)}  alert=${cell(r.alertLevel)}` : head;
+  return r ? `${head}  ${cell2(r.severity)}/${cell2(r.class)}  alert=${cell2(r.alertLevel)}` : head;
 };
 async function run(argv, io) {
   const flags = [];
@@ -468,7 +829,17 @@ ${USAGE}` : USAGE);
   }
   const [cmd, id, n] = args;
   const json = flags.includes("--json");
-  const known = new Set(["--json", "--yes", "--help", "--force", "--with-token", "--from-repo"]);
+  const known = new Set([
+    "--json",
+    "--yes",
+    "--help",
+    "--force",
+    "--with-token",
+    "--from-repo",
+    "--poc",
+    "--run",
+    "--brief"
+  ]);
   if (flags.some((f) => !known.has(f)))
     return usage(`Unknown flag ${flags.find((f) => !known.has(f))}`);
   if (flags.includes("--help") || !cmd || cmd === "help") {
@@ -484,8 +855,8 @@ ${USAGE}` : USAGE);
           io.out(JSON.stringify(plans, null, 2));
         else {
           const rows = plans.map((p) => [
-            p.contractId,
-            cell(p.monitoring, "none"),
+            contractName(p.contractId),
+            monitoringLabel(p.monitoring),
             p.evidence?.worst ? `${p.evidence.worst.severity} ${p.evidence.worst.evidence}` : null,
             p.planId
           ]);
@@ -508,8 +879,7 @@ ${USAGE}` : USAGE);
           io.out("Exploit detail is hidden until you verify control in the web app.");
         const rows = (p.report?.findings ?? []).map((f, i) => [
           i,
-          f.severity,
-          f.class,
+          f.kind ? KIND_LABEL[f.kind] : f.class,
           f.verdict,
           f.disposition,
           f.title
@@ -525,14 +895,50 @@ ${USAGE}` : USAGE);
         if (n === undefined || !/^\d+$/.test(n))
           return usage("sentinel finding needs a plan id and a finding number");
         const f = await io.client.finding(id, Number(n));
+        const wantPoc = flags.includes("--poc");
+        const wantRun = flags.includes("--run");
+        const wantBrief = flags.includes("--brief");
+        const p = wantPoc || wantRun || wantBrief ? await io.client.plan(id) : null;
+        const commit = p?.report?.target?.commit ?? null;
+        const bundle = p && (wantPoc || wantRun) ? handoffBundle(f, { contract: p.contractId, commit }) : null;
+        if (p && wantBrief) {
+          io.out(agentBrief(f, {
+            contract: p.contractId,
+            commit,
+            planId: id,
+            index: Number(n),
+            prelaunch: p.access === "prelaunch"
+          }));
+          return 0;
+        }
         if (json) {
-          io.out(JSON.stringify(f, null, 2));
+          io.out(JSON.stringify(bundle ? { finding: f, poc: bundle.poc, runCommand: bundle.runCommand } : f, null, 2));
           return 0;
         }
+        const kind = f.kind ? KIND_LABEL[f.kind] : f.class;
+        const alerts = f.alertLevel ? `alerts: ${f.alertLevel}` : null;
         io.out(`${f.title}
-${[f.severity, f.class, f.verdict, f.disposition].map((v) => cell(v)).join(" ")}`);
+${[kind, f.verdict, f.disposition, alerts].filter(Boolean).map((v) => cell2(v)).join(" · ")}`);
         if (f.headline)
           io.out(f.headline);
+        if (wantPoc) {
+          if (bundle?.poc) {
+            io.out(`
+# PoC · ${bundle.poc.file}`);
+            io.out(bundle.poc.source);
+          } else
+            io.out(`
+No PoC is stored for this finding.`);
+        }
+        if (wantRun) {
+          if (bundle?.runCommand) {
+            io.out(`
+# Run it yourself`);
+            io.out(bundle.runCommand);
+          } else
+            io.out(`
+No run command: no PoC is stored for this finding.`);
+        }
         return 0;
       }
       case "runs": {
@@ -752,7 +1158,7 @@ async function monitoring(cmd, pos, on, flags, values, io, usage) {
       return 0;
     }
     const r = await io.client.watchContract(first);
-    io.out("watches" in r ? `Monitoring ${r.contractId}. Manage it with plan ${r.planId}.` : `Sentinel is still making the plan (${r.planId}). Run this again in a few minutes.`);
+    io.out("intents" in r ? `Monitoring ${r.contractId}. Manage it with plan ${r.planId}.` : `Sentinel is still making the plan (${r.planId}). Run this again in a few minutes.`);
     return 0;
   }
   if (!first)
@@ -769,21 +1175,16 @@ async function monitoring(cmd, pos, on, flags, values, io, usage) {
   const ctx = await watchContext(io.client, planId);
   if (cmd === "watches") {
     if (flags.includes("--json")) {
-      io.out(JSON.stringify({ watches: ctx.watches }, null, 2));
+      io.out(JSON.stringify({ intents: ctx.intents }, null, 2));
       return 0;
     }
     if (ctx.access === "claimed") {
       io.out("Exploit detail is hidden until you verify control in the web app.");
     }
-    for (const g of groupSubjects(ctx.watches)) {
-      const muted = g.watches.map((w) => mutedUntilOf(w)).find(Boolean);
-      io.out([
-        g.name,
-        [...new Set(g.watches.map((w) => kindTag(w.rule)))].join("+"),
-        subjectStatus(g.watches),
-        muted ? `muted until ${muted}` : ""
-      ].filter(Boolean).join("  "));
-      for (const w of g.watches)
+    for (const i of ctx.intents) {
+      const muted = i.rows.map((w) => mutedUntilOf(w)).find(Boolean);
+      io.out([i.title, i.tag, i.on ? "on" : "off", intentLine(i), muted ? `muted until ${muted}` : ""].filter(Boolean).join("  "));
+      for (const w of i.rows)
         io.out(`  ${w.status.padEnd(14)}${ruleSummary(w.rule, w.units)}`);
     }
     return 0;
@@ -893,7 +1294,10 @@ async function readStdin() {
 async function prompt(question) {
   const rl = createInterface({ input: process.stdin, output: process.stderr });
   try {
-    return await rl.question(question);
+    return await new Promise((resolve, reject) => {
+      rl.once("close", () => reject(new PromptClosedError));
+      rl.question(question).then(resolve, reject);
+    });
   } finally {
     rl.close();
   }
@@ -913,7 +1317,13 @@ async function main() {
     client: clientFor(credential?.token ?? ""),
     out: console.log,
     err: console.error,
-    auth: { source: credential?.source ?? null, clientFor, prompt, readStdin }
+    auth: {
+      source: credential?.source ?? null,
+      interactive: Boolean(process.stdin.isTTY),
+      clientFor,
+      prompt,
+      readStdin
+    }
   });
 }
 process.exit(await main());