@secondlayer/sentinel 0.4.0 → 0.6.0

package/dist/mcp.js

@@ -12659,6 +12659,13 @@ class SentinelError extends Error {
     this.name = "SentinelError";
   }
 }
+var runInProgress = (status) => status === "queued" || status === "running";
+function runPhase(run) {
+  if (run.status === "queued")
+    return "queued";
+  const last = run.events.at(-1);
+  return last ? [last.name ?? last.kind, last.state].filter(Boolean).join(" ") : "starting";
+}
 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";
@@ -12774,7 +12781,10 @@ function mutedUntilOf(w, now = Date.now()) {
 function createClient(opts) {
   const baseUrl = (opts.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
   const doFetch = opts.fetch ?? globalThis.fetch;
-  const authHeader = () => ({ authorization: `Bearer ${opts.token}` });
+  const authHeader = () => ({
+    authorization: `Bearer ${opts.token}`,
+    ...opts.client ? { "x-sentinel-client": opts.client } : {}
+  });
   async function call(method, path, body) {
     const res = await doFetch(`${baseUrl}${path}`, {
       method,
@@ -12791,6 +12801,7 @@ function createClient(opts) {
   }
   const plan = (id) => `/v1/plans/${encodeURIComponent(id)}`;
   const appPlan = (id) => `/plan/${encodeURIComponent(id)}`;
+  const appProject = (id) => `/projects/${encodeURIComponent(id)}`;
   return {
     me: () => call("GET", "/v1/me"),
     plans: async () => (await call("GET", "/v1/plans")).plans,
@@ -12806,6 +12817,8 @@ function createClient(opts) {
     testsFromRepo: (id) => call("POST", `${appPlan(id)}/tests`, { fromRepo: true }),
     previewPlan: (contractId) => call("POST", "/plan/preview", { contractId }),
     createPlan: (contractId) => call("POST", "/plan", { contractId }),
+    previewImport: (url) => call("POST", "/projects/import/preview", { url }),
+    importRepo: (input) => call("POST", "/projects/import", input),
     billing: () => call("GET", "/billing"),
     watches: (planId) => call("GET", `${appPlan(planId)}/watches`),
     setRule: (planId, watchId, rule) => call("POST", `${appPlan(planId)}/watches/${encodeURIComponent(watchId)}/rule`, { rule }),
@@ -12822,9 +12835,70 @@ function createClient(opts) {
     watchContract: (contractId) => call("POST", "/contracts/watch", {
       contractId
     }),
-    stopMonitoring: (planId) => call("DELETE", `${appPlan(planId)}/monitor`)
+    stopMonitoring: (planId) => call("DELETE", `${appPlan(planId)}/monitor`),
+    watchActivity: (planId, intentId, opts = {}) => call("GET", `${appPlan(planId)}/watches/${encodeURIComponent(intentId)}/activity${query(opts)}`),
+    functions: async (planId) => (await call("GET", `${appPlan(planId)}/functions`)).functions,
+    functionActivity: (planId, fn) => call("GET", `${appPlan(planId)}/functions/${encodeURIComponent(fn)}/activity`),
+    alertPreview: (planId, example) => call("GET", `${appPlan(planId)}/alert-preview${query({ example })}`),
+    threshold: (planId, asset) => call("GET", `${appPlan(planId)}/watches/asset/${encodeURIComponent(asset)}/threshold`),
+    setThreshold: (planId, asset, amount) => call("POST", `${appPlan(planId)}/watches/asset/${encodeURIComponent(asset)}/threshold`, { amount }),
+    retryHistory: (planId) => call("POST", `${appPlan(planId)}/history/retry`, {}),
+    readAlert: (alertId) => call("POST", `/alerts/${encodeURIComponent(alertId)}/read`),
+    readAllAlerts: () => call("POST", "/alerts/read-all"),
+    ask: (q) => call("POST", "/ask", { q }),
+    acknowledge: (planId, finding, title, reason, note = null) => call("POST", `${appPlan(planId)}/acknowledge`, {
+      finding,
+      title,
+      reason,
+      note
+    }),
+    reopen: (planId, finding, title) => call("POST", `${appPlan(planId)}/reopen`, { finding, title }),
+    ackHistory: async (planId) => (await call("GET", `${appPlan(planId)}/acks`)).events,
+    notes: async (planId, finding) => (await call("GET", `${appPlan(planId)}/findings/${finding}/notes`)).notes,
+    addNote: (planId, finding, title, body) => call("POST", `${appPlan(planId)}/findings/${finding}/notes`, {
+      title,
+      body
+    }),
+    tests: (planId, files) => call("POST", `${appPlan(planId)}/tests`, { files }),
+    fuzzCheck: (planId, harness) => call("POST", `${appPlan(planId)}/fuzzcheck`, { harness }),
+    fuzz: (planId, invariants) => call("POST", `${appPlan(planId)}/fuzz`, { invariants }),
+    latestCommit: (planId) => call("GET", `${appPlan(planId)}/latest`),
+    updatePlan: (planId, commit) => call("POST", `${appPlan(planId)}/update`, commit ? { commit } : {}),
+    setAutoPlan: (planId, auto) => call("POST", `${appPlan(planId)}/wait`, { auto }),
+    setLink: (planId, dependency, url) => call("POST", `${appPlan(planId)}/link`, { id: dependency, url }),
+    planLinked: (planId) => call("POST", `${appPlan(planId)}/plan-linked`, {}),
+    renameContract: (planId, name) => call("POST", `${appPlan(planId)}/settings`, { name }),
+    removeContract: (planId, confirm) => call("POST", `${appPlan(planId)}/remove`, {
+      confirm
+    }),
+    projects: () => call("GET", "/projects"),
+    project: (projectId) => call("GET", appProject(projectId)),
+    projectOverview: (projectId, opts = {}) => call("GET", `${appProject(projectId)}/overview${opts.watches ? "?watches=1" : ""}`),
+    renameProject: (projectId, name) => call("POST", `${appProject(projectId)}/rename`, { name }),
+    removeProject: (projectId, confirm) => call("POST", `${appProject(projectId)}/remove`, {
+      confirm
+    }),
+    answerMergeSuggestion: (from, into, accept) => call("POST", "/projects/merge", { from, into, accept }),
+    mergeProject: (projectId, into) => call("POST", `${appProject(projectId)}/merge-into`, { into }),
+    moveProjectContract: (projectId, contractId, into) => call("POST", `${appProject(projectId)}/contracts/${encodeURIComponent(contractId)}/move`, { into }),
+    removeProjectContract: (projectId, contractId, confirm) => call("POST", `${appProject(projectId)}/contracts/${encodeURIComponent(contractId)}/remove`, { confirm }),
+    previewProjectContract: (projectId, contractId) => call("POST", `${appProject(projectId)}/contracts/preview`, { contractId }),
+    addProjectContract: (projectId, contractId, opts = {}) => call("POST", `${appProject(projectId)}/contracts`, { contractId, ...opts }),
+    setProjectDestinations: (projectId, dest) => call("POST", `${appProject(projectId)}/destinations`, dest),
+    setProjectMonitoring: (projectId, on) => call("POST", `${appProject(projectId)}/monitoring`, { on }),
+    projectWatches: (projectId) => call("GET", `${appProject(projectId)}/watches`),
+    projectActivity: (projectId, intentId, opts = {}) => call("GET", `${appProject(projectId)}/watches/${encodeURIComponent(intentId)}/activity${query(opts)}`),
+    projectChanges: (projectId, opts = {}) => call("GET", `${appProject(projectId)}/changes${query(opts)}`)
   };
 }
+function query(params) {
+  const q = new URLSearchParams;
+  for (const [k, v] of Object.entries(params))
+    if (v !== undefined && v !== null)
+      q.set(k, String(v));
+  const s = q.toString();
+  return s ? `?${s}` : "";
+}
 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) {
@@ -20342,9 +20416,9 @@ function assertionsOf(output) {
 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)",
+  exploitable: "Reproducible (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)",
+  worth_a_look: "Worth a look (not reproduced)",
   refuted: "Refuted"
 };
 var tick = (s) => `\`${s}\``;
@@ -20435,16 +20509,16 @@ function issueMd(f, withCondition) {
     "## 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}`] : [],
+    ...withCondition && f.precondition ? ["", `**Reproduces 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";
+  const kindLine = kind === "exploitable" ? "Reproducible · 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.`,
+    `Sentinel found an issue${f.targetFn ? ` in ${tick(f.targetFn)}` : ""}: ${f.title}. PoCs and reproduction 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)}`,
@@ -20476,7 +20550,7 @@ function trustBrief(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."),
+    ...reportBackMd(ctx, "- There is no PoC for a trust assumption. Don't write a PoC 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.",
@@ -20594,10 +20668,6 @@ function agentBrief(f, ctx) {
 var CLAIMED_NOTE = "Exploit detail is hidden until you verify control of this contract in the web app.";
 var REVERIFY_ESTIMATE = "about 10 min";
 var PAID_RUN_NOTE = "A paid run from your balance, charged only if it finishes (or a free daily run when billing isn't linked).";
-function phaseOf(run) {
-  const last = run.events.at(-1);
-  return last ? [last.name ?? last.kind, last.state].filter(Boolean).join(" ") : "starting";
-}
 var noteFor = (p) => p.access === "claimed" ? { note: CLAIMED_NOTE } : {};
 var ruleInput = discriminatedUnion("kind", [
   object({
@@ -20640,6 +20710,7 @@ var paidRun = (willDo) => ({
 function intentView(i) {
   const lead = i.rows[0];
   return {
+    id: i.id,
     watch: i.title,
     subject: lead ? subjectName(lead.subject, lead.units) : i.title,
     kind: i.kind,
@@ -20685,6 +20756,14 @@ function buildTools(client) {
   const planId = string2().describe("Plan id, from list_contracts");
   const subject = string2().describe("A watched subject: a function name or a token symbol, from list_watches");
   const confirm = boolean2().optional().describe("Set true to actually do it. Without it you only get what it would do.");
+  const projectId = string2().describe("Project id, from list_projects");
+  const projectNamed = async (id) => {
+    const { projects } = await client.projects();
+    const p = projects.find((x) => x.id === id);
+    if (!p)
+      throw new SentinelError(404, `No project ${id}. Yours: ${projects.map((x) => `${x.name} (${x.id})`).join(", ") || "none"}`);
+    return p;
+  };
   return {
     list_contracts: {
       description: "Your claimed contracts: plan id, monitoring status, worst evidence.",
@@ -20750,13 +20829,19 @@ function buildTools(client) {
       }
     },
     get_run_status: {
-      description: "Running and finished follow-up runs on a plan, with the phase of each running one.",
+      description: "Unfinished and finished follow-up runs on a plan, with the phase of each unfinished one (`queued` while it waits its turn).",
       input: { planId },
       run: async (a) => {
         const runs = await client.runs(a.planId);
         return {
-          running: runs.filter((r) => r.status === "running").map((r) => ({ id: r.id, kind: r.kind, startedAt: r.startedAt, phase: phaseOf(r) })),
-          finished: runs.filter((r) => r.status !== "running").map((r) => ({ id: r.id, kind: r.kind, status: r.status, finishedAt: r.finishedAt }))
+          running: runs.filter((r) => runInProgress(r.status)).map((r) => ({
+            id: r.id,
+            kind: r.kind,
+            status: r.status,
+            startedAt: r.startedAt,
+            phase: runPhase(r)
+          })),
+          finished: runs.filter((r) => !runInProgress(r.status)).map((r) => ({ id: r.id, kind: r.kind, status: r.status, finishedAt: r.finishedAt }))
         };
       }
     },
@@ -20831,6 +20916,45 @@ function buildTools(client) {
         });
       }
     },
+    preview_repo_import: {
+      description: "Read a public GitHub Clarinet repo (github.com/<owner>/<repo>, or /tree/<branch>/<folder> for one project of a monorepo): its contracts in deploy order, which are worth monitoring, which already have a plan, and what importing the suggested ones costs. Writes and charges nothing. Pass its commit to import_repo.",
+      input: {
+        url: string2().describe("A public GitHub repo link")
+      },
+      run: async (a) => {
+        const p = await client.previewImport(a.url);
+        return {
+          ...p,
+          next: `To import, call import_repo with url, commit "${p.commit}" and the contract names (the suggested ones: ${p.contracts.filter((c) => c.suggested).map((c) => c.name).join(", ") || "none"}).`
+        };
+      }
+    },
+    import_repo: {
+      description: "Plan contracts of a repo from preview_repo_import into one project: one paid plan per new contract (a recent plan is reused free), at the preview's commit only. Without confirm it only says what it would do; confirm: true imports and spends balance.",
+      input: {
+        url: string2().describe("The repo link given to preview_repo_import"),
+        commit: string2().regex(/^[0-9a-f]{40}$/).describe("The commit preview_repo_import returned: only that code is imported"),
+        contracts: array(string2()).min(1).describe("Contract names from the preview"),
+        project: string2().optional().describe('One of your project ids, or "new" (the default: a project named after the repo)'),
+        confirm
+      },
+      run: async (a) => {
+        const names = a.contracts;
+        const target = a.project ?? "new";
+        const willDo = `Import ${names.length} contract${names.length === 1 ? "" : "s"} (${names.join(", ")}) at ${a.commit.slice(0, 7)} into ${target === "new" ? "a new project" : target}.`;
+        if (a.confirm !== true) {
+          const b = await client.billing();
+          return preview(willDo, b.prices ? `Each new plan costs $${b.prices.run.toFixed(2)}, charged only if it finishes; one planned recently is reused free.` : "Billing isn't linked: the free daily plan limit applies.");
+        }
+        const r = await client.importRepo({
+          url: a.url,
+          commit: a.commit,
+          contracts: names,
+          project: a.project
+        });
+        return done(willDo, r.notStarted ? "Some plans didn't start." : "Started.", r);
+      }
+    },
     challenge: {
       description: "Re-verify one finding against your argument. Owners only. Without confirm it only describes what it will do.",
       input: {
@@ -20860,9 +20984,18 @@ function buildTools(client) {
       run: async (a) => a.confirm === true ? client.directed(a.planId, a.prompt) : paidRun("Re-plan this contract around what you asked to have watched.")
     },
     run_tests: {
-      description: "Run the Clarinet suite from a pre-launch plan's repo in the sandbox. Owners only. Without confirm it only describes what it will do.",
-      input: { planId, confirm },
-      run: async (a) => a.confirm === true ? client.testsFromRepo(a.planId) : paidRun("Run the Clarinet suite from this pre-launch plan's repo in the airgapped sandbox.")
+      description: "Run Clarinet tests against a plan's contract in the sandbox: your own test files (`files`), or without them the suite from a pre-launch plan's repo. Owners only. Without confirm it only describes what it will do.",
+      input: {
+        planId,
+        files: array(object({ path: string2(), content: string2() })).optional().describe("Your test files (path and TypeScript source); leave out to run the repo's suite"),
+        confirm
+      },
+      run: async (a) => {
+        const files = a.files;
+        if (a.confirm !== true)
+          return paidRun(files?.length ? `Run ${files.length} test file(s) against this plan's contract in the airgapped sandbox.` : "Run the Clarinet suite from this pre-launch plan's repo in the airgapped sandbox.");
+        return files?.length ? client.tests(a.planId, files) : client.testsFromRepo(a.planId);
+      }
     },
     list_watches: {
       description: "What a plan watches, as intent watches (Money out once per contract with a limit per token, Control changes, Admin operations, Settings, one per finding, the fns you added): on or off, the threshold or summary, the fns covered, what it can see (coverage: direct-calls means a call made from another contract isn't visible yet), each rule in token units, any mute, and the subject name the other watch tools take.",
@@ -21035,6 +21168,466 @@ function buildTools(client) {
         await client.stopMonitoring(await planOfContract(client, a.contractId));
         return done(willDo, "Stopped.");
       }
+    },
+    get_watch_activity: {
+      description: "What one watch saw and what crossed its rules: counts and the latest events (time, function, amount, caller, result). `watchId` is a watch's id from list_watches.",
+      input: {
+        planId,
+        watchId: string2().describe("An intent watch id, from list_watches"),
+        window: union([literal(7), literal(90)]).optional().describe("Days, 7 (default) or 90"),
+        filter: _enum(["over", "all"]).optional().describe("over: only what crossed a rule's line"),
+        cursor: string2().optional().describe("nextCursor from a previous page"),
+        asset: string2().optional().describe("Money out: which asset (an id from list_watches)")
+      },
+      run: async (a) => client.watchActivity(a.planId, a.watchId, {
+        window: a.window,
+        filter: a.filter,
+        cursor: a.cursor,
+        asset: a.asset
+      })
+    },
+    list_functions: {
+      description: "Every public function of a plan's contract: what it does (its consequence), a one-line description, and the watch covering it (null: nothing watches it).",
+      input: { planId },
+      run: async (a) => ({ functions: await client.functions(a.planId) })
+    },
+    get_function_activity: {
+      description: "What a watch on a function nobody watches yet would have seen. `collected: false` until its history is read (try again in a few minutes).",
+      input: { planId, fn: string2().describe("A public function name, from list_functions") },
+      run: async (a) => client.functionActivity(a.planId, a.fn)
+    },
+    preview_alert: {
+      description: "A sample alert for a plan, as email and Slack render it, plus the webhook body. `example` picks a Money out or a finding alert; without it, the loudest watch.",
+      input: { planId, example: _enum(["money_out", "finding"]).optional() },
+      run: async (a) => client.alertPreview(a.planId, a.example)
+    },
+    set_threshold: {
+      description: "Read or set one asset's Money out limit (an asset subject from list_watches: its symbol). Without amount it only reads the limit. With amount (base units, a digit string) and no confirm it describes the change; confirm: true sets it, live at once.",
+      input: {
+        planId,
+        subject: string2().describe("A Money out asset: its token symbol, from list_watches"),
+        amount: string2().regex(/^\d{1,30}$/).optional().describe("The new limit in the token's base units"),
+        confirm
+      },
+      run: async (a) => {
+        const ctx = await watchContext(client, a.planId);
+        const g = resolveSubject(ctx.watches.filter((w) => w.subject.kind === "asset"), a.subject);
+        const s = g.watches[0].subject;
+        if (s.kind !== "asset")
+          throw new SentinelError(400, `${a.subject} isn't an asset.`);
+        const current = await client.threshold(ctx.planId, s.asset);
+        const limit = (amount) => assetClause({
+          asset: s.asset,
+          units: g.watches[0].units,
+          threshold: { ...current.threshold, amount }
+        });
+        if (a.amount === undefined)
+          return { subject: g.name, limit: limit(current.threshold.amount), ...current };
+        const willDo = `Change ${g.name}'s Money out limit: ${limit(current.threshold.amount)} becomes ${limit(a.amount)}.`;
+        if (a.confirm !== true)
+          return preview(willDo, "Live now.");
+        const r = await client.setThreshold(ctx.planId, s.asset, a.amount);
+        return done(willDo, "Live now.", { threshold: r.threshold });
+      }
+    },
+    retry_history: {
+      description: "Read a plan's watch history again after a failed read (activity says history: failed). Without confirm it only describes.",
+      input: { planId, confirm },
+      run: async (a) => {
+        const willDo = "Read the history of this plan's watches again, in the background.";
+        if (a.confirm !== true)
+          return preview(willDo, "Starts now.");
+        await client.retryHistory(a.planId);
+        return done(willDo, "Started; activity fills in over the next few minutes.");
+      }
+    },
+    mark_alert_read: {
+      description: "Mark one alert read. Without confirm it only describes.",
+      input: { alertId: string2().describe("Alert id, from list_alerts"), confirm },
+      run: async (a) => {
+        const willDo = `Mark alert ${a.alertId} read.`;
+        if (a.confirm !== true)
+          return preview(willDo, "Takes effect now.");
+        await client.readAlert(a.alertId);
+        return done(willDo, "Done.");
+      }
+    },
+    mark_all_alerts_read: {
+      description: "Mark every alert read. Without confirm it only describes.",
+      input: { confirm },
+      run: async (a) => {
+        if (a.confirm !== true)
+          return preview("Mark every alert read.", "Takes effect now.");
+        const r = await client.readAllAlerts();
+        return done("Mark every alert read.", `${r.count} marked read.`);
+      }
+    },
+    ask_sentinel: {
+      description: "Ask a question about Sentinel itself (how monitoring, plans or billing work), answered from its docs.",
+      input: { question: string2().min(3).max(200) },
+      run: async (a) => client.ask(a.question)
+    },
+    acknowledge_finding: {
+      description: "Label a finding for your team: accepted (a risk you accept), fixed (awaiting deploy) or disagree. Changes no verdict; accepting a trust finding keeps a suggested watch on its function. Verified owners. Without confirm it only describes.",
+      input: {
+        planId,
+        index: number2().int().min(0).describe("Finding index from get_plan"),
+        reason: _enum(["accepted", "fixed", "disagree"]),
+        note: string2().max(500).optional(),
+        confirm
+      },
+      run: async (a) => {
+        const f = await client.finding(a.planId, a.index);
+        const reason = a.reason;
+        const willDo = `Label "${f.title}" ${reason}. It changes no verdict.`;
+        if (a.confirm !== true)
+          return preview(willDo, "Your team sees it now.");
+        const r = await client.acknowledge(a.planId, a.index, f.title, reason, a.note ?? null);
+        return done(willDo, "Labelled.", r.watchId ? { suggestedWatchId: r.watchId } : {});
+      }
+    },
+    reopen_finding: {
+      description: "Put an acknowledged finding back on the list. Verified owners. Without confirm it only describes.",
+      input: {
+        planId,
+        index: number2().int().min(0).describe("Finding index from get_plan"),
+        confirm
+      },
+      run: async (a) => {
+        const f = await client.finding(a.planId, a.index);
+        const willDo = `Put "${f.title}" back on the list.`;
+        if (a.confirm !== true)
+          return preview(willDo, "Takes effect now.");
+        await client.reopen(a.planId, a.index, f.title);
+        return done(willDo, "Reopened.");
+      }
+    },
+    get_ack_history: {
+      description: "Every acknowledgement change on a plan's contract, oldest first. Verified owners.",
+      input: { planId },
+      run: async (a) => ({ events: await client.ackHistory(a.planId) })
+    },
+    list_notes: {
+      description: "Your team's notes on one finding (and Sentinel's, when a later check reopened it). Verified owners.",
+      input: { planId, index: number2().int().min(0).describe("Finding index from get_plan") },
+      run: async (a) => ({ notes: await client.notes(a.planId, a.index) })
+    },
+    add_note: {
+      description: "Add a note to one finding. Verified owners. Without confirm it only describes.",
+      input: {
+        planId,
+        index: number2().int().min(0).describe("Finding index from get_plan"),
+        body: string2().min(1).max(2000),
+        confirm
+      },
+      run: async (a) => {
+        const f = await client.finding(a.planId, a.index);
+        const willDo = `Add a note to "${f.title}".`;
+        if (a.confirm !== true)
+          return preview(willDo, "Your team sees it now.");
+        const r = await client.addNote(a.planId, a.index, f.title, a.body);
+        return done(willDo, "Noted.", { note: r.note });
+      }
+    },
+    run_fuzz: {
+      description: "Fuzz a plan's contract against your Clarity invariant or property functions in the sandbox. Without confirm it only compile-checks them (free) and describes the run. Owners only.",
+      input: {
+        planId,
+        invariants: string2().min(10).describe("Clarity define-… invariant or property functions"),
+        confirm
+      },
+      run: async (a) => {
+        const check = await client.fuzzCheck(a.planId, a.invariants);
+        if (!check.ok)
+          return { started: false, compiles: false, message: check.message ?? null };
+        if (a.confirm !== true)
+          return {
+            ...paidRun("Fuzz the contract against these invariants in the airgapped sandbox."),
+            compiles: true
+          };
+        return client.fuzz(a.planId, a.invariants);
+      }
+    },
+    get_latest_commit: {
+      description: "Whether a pre-launch plan's branch moved on: how far behind it is, what an update would review (carried, focused or full), and whether it's free (monitoring on).",
+      input: { planId },
+      run: async (a) => client.latestCommit(a.planId)
+    },
+    update_plan: {
+      description: "Plan the branch's latest commit (or `commit`, a full sha); the new plan replaces this one when it finishes. Free while monitoring is on, else priced as a new plan. Owners only. Without confirm it only describes.",
+      input: {
+        planId,
+        commit: string2().regex(/^[0-9a-f]{40}$/).optional(),
+        confirm
+      },
+      run: async (a) => {
+        const latest = await client.latestCommit(a.planId);
+        const willDo = `Plan ${a.commit ? `commit ${a.commit.slice(0, 7)}` : "the branch's latest commit"}.`;
+        if (a.confirm !== true)
+          return {
+            ...preview(willDo, "free" in latest && latest.free ? "Free: monitoring is on." : PAID_RUN_NOTE),
+            latest
+          };
+        return client.updatePlan(a.planId, a.commit);
+      }
+    },
+    set_auto_plan: {
+      description: "For a plan waiting on contracts that aren't deployed yet: plan it on its own once they deploy (a paid plan), or not. Owners only. Without confirm it only describes.",
+      input: { planId, auto: boolean2(), confirm },
+      run: async (a) => {
+        const willDo = a.auto ? "Plan this on its own once every contract it waits on is deployed." : "Don't plan this on its own.";
+        if (a.confirm !== true)
+          return preview(willDo, "Takes effect now.");
+        return done(willDo, "Saved.", await client.setAutoPlan(a.planId, a.auto === true));
+      }
+    },
+    link_dependency: {
+      description: "Link code for one contract a waiting plan depends on (a .clar file or repo link; a repo link also fills the others it holds), or clear it with url: null. Owners only. Without confirm it only describes.",
+      input: {
+        planId,
+        contract: string2().describe("The contract the plan waits on (from get_plan)"),
+        url: string2().nullable(),
+        confirm
+      },
+      run: async (a) => {
+        const willDo = a.url === null ? `Clear the code linked for ${a.contract}.` : `Link ${a.url} as the code of ${a.contract}.`;
+        if (a.confirm !== true)
+          return preview(willDo, "Takes effect now.");
+        return done(willDo, "Saved.", await client.setLink(a.planId, a.contract, a.url));
+      }
+    },
+    plan_with_links: {
+      description: "Plan a waiting contract now, with the linked code loaded at its real principals. A paid plan. Owners only. Without confirm it only describes.",
+      input: { planId, confirm },
+      run: async (a) => a.confirm === true ? client.planLinked(a.planId) : paidRun("Plan this contract now with the linked code.")
+    },
+    rename_contract: {
+      description: "Your own name for a plan's contract; an empty name clears it. Owners only. Without confirm it only describes.",
+      input: { planId, name: string2().max(60), confirm },
+      run: async (a) => {
+        const name = a.name.trim();
+        const willDo = name ? `Call this contract "${name}".` : "Clear your name for this contract.";
+        if (a.confirm !== true)
+          return preview(willDo, "Takes effect now.");
+        return done(willDo, "Saved.", await client.renameContract(a.planId, name));
+      }
+    },
+    remove_contract: {
+      description: "Take a contract off your account: its monitoring, alerts and claim go. `name` is the contract's name, typed, as the app asks (the preview says which). Can't be undone. Without confirm it only describes.",
+      input: {
+        planId,
+        name: string2().optional().describe("The contract's name, typed to confirm"),
+        confirm
+      },
+      run: async (a) => {
+        const p = await client.plan(a.planId);
+        const willDo = `Take ${p.contractId} off your account: its monitoring, alerts and claim go.`;
+        if (a.confirm !== true || a.name === undefined)
+          return {
+            ...preview(willDo, "Can't be undone."),
+            confirmWith: `name: "${contractName(p.contractId)}"`
+          };
+        return done(willDo, "Removed.", await client.removeContract(a.planId, a.name));
+      }
+    },
+    list_projects: {
+      description: "Your projects (the contracts of one protocol, grouped): id, name, contracts, monitoring, open findings, alerts in 7 days; and the merges Sentinel suggests (answer them with answer_merge_suggestion).",
+      input: {},
+      run: async () => client.projects()
+    },
+    get_project: {
+      description: "One project: each contract (added: you claimed it, with its plan; found: one Sentinel found in your code), its role and monitoring.",
+      input: { projectId },
+      run: async (a) => client.project(a.projectId)
+    },
+    get_project_overview: {
+      description: "One project with each claimed contract's plan (as get_plan) and, with watches: true, its watches (as list_watches), in one read.",
+      input: { projectId, watches: boolean2().optional() },
+      run: async (a) => client.projectOverview(a.projectId, { watches: a.watches === true })
+    },
+    rename_project: {
+      description: "Rename a project. Without confirm it only describes.",
+      input: { projectId, name: string2().min(1).max(60), confirm },
+      run: async (a) => {
+        const willDo = `Rename project ${a.projectId} to "${a.name.trim()}".`;
+        if (a.confirm !== true)
+          return preview(willDo, "Takes effect now.");
+        return done(willDo, "Renamed.", await client.renameProject(a.projectId, a.name));
+      }
+    },
+    merge_project: {
+      description: "Merge one of your projects into another: every contract moves; monitoring, watches and verification stay as they are. Both ids come from list_projects. Without confirm it only describes.",
+      input: {
+        projectId,
+        into: string2().describe("The project to merge into, an id from list_projects"),
+        confirm
+      },
+      run: async (a) => {
+        const from = await projectNamed(a.projectId);
+        const to = await projectNamed(a.into);
+        const willDo = `Move every contract of ${from.name} (${from.contracts.length}) into ${to.name}; ${from.name} goes.`;
+        if (a.confirm !== true)
+          return preview(willDo, "Takes effect now.");
+        return done(willDo, "Merged.", await client.mergeProject(from.id, to.id));
+      }
+    },
+    answer_merge_suggestion: {
+      description: "Accept (merge `from` into `into`) or dismiss a merge Sentinel suggested, from list_projects' suggestions. Without confirm it only describes.",
+      input: {
+        from: string2().describe("The suggestion's from project id"),
+        into: string2().describe("The suggestion's into project id"),
+        accept: boolean2(),
+        confirm
+      },
+      run: async (a) => {
+        const r = await client.projects();
+        if (!r.suggestions.some((s) => s.from === a.from && s.into === a.into))
+          throw new SentinelError(404, `No open suggestion to merge ${a.from} into ${a.into}.`);
+        const nameOf = (id) => r.projects.find((p) => p.id === id)?.name ?? String(id);
+        const willDo = a.accept ? `Merge ${nameOf(a.from)} into ${nameOf(a.into)}: every contract moves.` : `Dismiss the suggestion to merge ${nameOf(a.from)} into ${nameOf(a.into)}.`;
+        if (a.confirm !== true)
+          return preview(willDo, "Takes effect now.");
+        return done(willDo, "Done.", await client.answerMergeSuggestion(a.from, a.into, a.accept === true));
+      }
+    },
+    move_project_contract: {
+      description: 'Move one contract to another of your projects (an id from list_projects), or to a new project named after it ("new", a contract you added). Without confirm it only describes.',
+      input: { projectId, contractId: string2(), into: string2(), confirm },
+      run: async (a) => {
+        const to = a.into === "new" ? "a new project named after it" : (await projectNamed(a.into)).name;
+        const willDo = `Move ${a.contractId} to ${to}.`;
+        if (a.confirm !== true)
+          return preview(willDo, "Takes effect now.");
+        return done(willDo, "Moved.", await client.moveProjectContract(a.projectId, a.contractId, a.into));
+      }
+    },
+    remove_project_contract: {
+      description: "Remove a contract from a project. One you added goes the way remove_contract takes it (monitoring, alerts and claim; `name`: its name, typed, as the preview says); one Sentinel found just leaves the project. Without confirm it only describes.",
+      input: {
+        projectId,
+        contractId: string2(),
+        name: string2().optional().describe("A contract you added: its name, typed to confirm"),
+        confirm
+      },
+      run: async (a) => {
+        const member = (await client.project(a.projectId)).contracts.find((c) => c.contractId === a.contractId);
+        if (!member)
+          throw new SentinelError(404, `${a.contractId} isn't in project ${a.projectId}.`);
+        const added = member.origin === "added";
+        const willDo = added ? `Remove ${a.contractId}: its monitoring, alerts and claim go.` : `Take ${a.contractId} out of the project (Sentinel found it; you never claimed it).`;
+        if (a.confirm !== true || added && a.name === undefined)
+          return {
+            ...preview(willDo, added ? "Can't be undone." : "Takes effect now."),
+            ...added ? { confirmWith: `name: "${contractName(member.contractId)}"` } : {}
+          };
+        return done(willDo, "Removed.", await client.removeProjectContract(a.projectId, a.contractId, added ? a.name : undefined));
+      }
+    },
+    remove_project: {
+      description: "Remove a project and every contract you added in it (their monitoring, alerts and claims). `name` is the project's name, typed, as the app asks. Can't be undone. Without confirm it only describes.",
+      input: {
+        projectId,
+        name: string2().optional().describe("The project's name, typed to confirm"),
+        confirm
+      },
+      run: async (a) => {
+        const p = await client.project(a.projectId);
+        const added = p.contracts.filter((c) => c.origin === "added").length;
+        const willDo = `Remove ${p.name} and the ${added} contract(s) you added in it.`;
+        if (a.confirm !== true || a.name === undefined)
+          return { ...preview(willDo, "Can't be undone."), confirmWith: `name: "${p.name}"` };
+        return done(willDo, "Removed.", await client.removeProject(p.id, a.name));
+      }
+    },
+    add_project_contract: {
+      description: 'Add a contract (SP….name, or a GitHub/Gist .clar link) to a project and start its plan. Without confirm it only shows where it fits (the project Sentinel suggests and why) and what it costs; confirm: true plans it into `into` (a project id, or "new"; default this project) and spends balance.',
+      input: {
+        projectId,
+        contractId: string2(),
+        into: string2().optional().describe('A project id from list_projects, or "new"'),
+        confirm
+      },
+      run: async (a) => {
+        const into = a.into ?? a.projectId;
+        if (a.confirm !== true) {
+          const [p, b] = await Promise.all([
+            client.previewProjectContract(a.projectId, a.contractId),
+            client.billing()
+          ]);
+          return {
+            ...preview(`Plan ${p.contractId} into ${into === "new" ? "a new project" : into}.`, b.prices ? `Costs $${b.prices.run.toFixed(2)}, charged only if it finishes.` : "Billing isn't linked: the free daily plan limit applies."),
+            suggestion: p.suggestion
+          };
+        }
+        const r = await client.addProjectContract(a.projectId, a.contractId, into === a.projectId ? {} : { project: into });
+        return done(`Plan ${a.contractId}.`, r.cached ? "Already planned." : "Started.", r);
+      }
+    },
+    list_project_watches: {
+      description: "A project's watches as one list across its contracts: each watch's id, title, on or off, summary, and the member plan to change it through (the plan watch tools).",
+      input: { projectId },
+      run: async (a) => client.projectWatches(a.projectId)
+    },
+    get_project_watch_activity: {
+      description: "One project watch's activity on one member (`contract`, default the first that holds it): counts and the latest events.",
+      input: {
+        projectId,
+        watchId: string2().describe("A watch id from list_project_watches"),
+        contract: string2().optional(),
+        window: union([literal(7), literal(90)]).optional()
+      },
+      run: async (a) => client.projectActivity(a.projectId, a.watchId, {
+        contract: a.contract,
+        window: a.window
+      })
+    },
+    list_project_changes: {
+      description: 'The account\'s changes to what Sentinel watches across a project, newest first: each watch turned on or off, rule edits (rule and prevRule, the one it replaced), mutes and cooldowns, with how each was made (source) and when. `watch` keeps one watch (an id from list_project_watches); filter "mutes" keeps mutes and cooldowns; pass `next` back as cursor for older ones.',
+      input: {
+        projectId,
+        watch: string2().optional(),
+        filter: literal("mutes").optional(),
+        limit: number2().int().min(1).max(200).optional(),
+        cursor: string2().optional()
+      },
+      run: async (a) => client.projectChanges(a.projectId, {
+        watch: a.watch,
+        filter: a.filter,
+        limit: a.limit,
+        cursor: a.cursor
+      })
+    },
+    set_project_destinations: {
+      description: "Where a project's alerts go, set on each contract you added in it: email on or off, a webhook URL, a Slack URL. A URL left out is cleared. Without confirm it only describes.",
+      input: {
+        projectId,
+        email: boolean2().optional(),
+        webhookUrl: string2().optional(),
+        slackUrl: string2().optional(),
+        confirm
+      },
+      run: async (a) => {
+        const dest = {
+          ...a.email === undefined ? {} : { email: a.email },
+          ...a.webhookUrl ? { webhookUrl: a.webhookUrl } : {},
+          ...a.slackUrl ? { slackUrl: a.slackUrl } : {}
+        };
+        const willDo = `Send this project's alerts to: ${[dest.email ? "email" : null, dest.webhookUrl ? "webhook" : null, dest.slackUrl ? "Slack" : null].filter(Boolean).join(", ") || "no new place"}; a URL left out is cleared.`;
+        if (a.confirm !== true)
+          return preview(willDo, "Takes effect now.");
+        const r = await client.setProjectDestinations(a.projectId, dest);
+        return done(willDo, "Saved on each contract; a new webhook secret is shown once.", r);
+      }
+    },
+    set_project_monitoring: {
+      description: "Turn monitoring on or off for every contract you added in a project. Monitored events are billed. Without confirm it only describes.",
+      input: { projectId, on: boolean2(), confirm },
+      run: async (a) => {
+        const willDo = `Turn monitoring ${a.on ? "on" : "off"} for every contract you added in this project.`;
+        if (a.confirm !== true)
+          return preview(willDo, a.on ? "Live now; events are billed." : "Off now.");
+        return done(willDo, "Done.", await client.setProjectMonitoring(a.projectId, a.on === true));
+      }
     }
   };
 }
@@ -21049,7 +21642,7 @@ async function runTool(tool, args) {
   }
 }
 function buildServer(client) {
-  const server = new McpServer({ name: "sentinel", version: "0.4.0" });
+  const server = new McpServer({ name: "sentinel", version: "0.6.0" });
   for (const [name, tool] of Object.entries(buildTools(client))) {
     server.registerTool(name, { description: tool.description, inputSchema: tool.input }, (args) => runTool(tool, args));
   }
@@ -21064,6 +21657,7 @@ if (!credential) {
 }
 var client = createClient({
   token: credential.token,
-  baseUrl: process.env.SENTINEL_API_URL
+  baseUrl: process.env.SENTINEL_API_URL,
+  client: "mcp"
 });
 await buildServer(client).connect(new StdioServerTransport);