@secondlayer/sentinel 0.1.0 → 0.2.0

package/dist/sentinel-client.d.ts

@@ -2,6 +2,7 @@
  * Client for the Sentinel v1 API (docs/api.md). Shared by the MCP server and the CLI. No dependencies:
  * global fetch. Auth is one function, `authHeader`, so another credential can be swapped in later.
  */
+import type { AlertLevel, FindingKind } from "./kind";
 export declare const DEFAULT_BASE_URL = "https://api.runsentinel.app";
 export declare class SentinelError extends Error {
     readonly status: number;
@@ -47,8 +48,25 @@ export type Finding = {
     verdict: string;
     disposition: string;
     poc?: string;
+    /** What the finding is for the people watching (client/kind.ts), stamped by the API. */
+    kind?: FindingKind;
+    /** How the finding's watch pages; absent on a refuted finding. */
+    alertLevel?: AlertLevel;
+    reverified?: boolean;
+    /** "fn" when `targetFn` names the function; "contract" when no single function carries it. */
+    scope?: "fn" | "contract";
+    /** Trust findings: the powers held by design, one entry each. */
+    powers?: Power[];
+    /** The watch row's subject, a short fn-level phrase (verified owners only). */
+    watchSubject?: string;
     [field: string]: unknown;
 };
+/** One power a trust finding describes (monitoring/adjudication.ts `Power`, copied: no deps). */
+export type Power = {
+    holder: string;
+    can: string;
+    fn?: string;
+};
 /** A plan at the caller's access level: `access` is absent on the teaser. */
 export type PlanView = {
     view: string;
@@ -114,6 +132,11 @@ export type WatchSubject = {
 } | {
     kind: "asset";
     asset: string;
+}
+/** Control changes: one group over every fn that changes who controls the contract. */
+ | {
+    kind: "group";
+    group: "control";
 };
 export type WatchStatus = "suggested" | "live" | "paused";
 export type Units = {
@@ -146,8 +169,57 @@ export type StoredWatch = {
     updatedAt: string;
     units: Units | null;
 };
+export type IntentKind = "money_out" | "control" | "finding" | "owner_fn";
+/**
+ * One intent watch: what a team sees (Money out per asset, Control changes, one per finding, a fn the team
+ * added). `rows` are the stored watches behind it: what a rule edit, a switch or a mute acts on.
+ */
+export type IntentWatch<R = StoredWatch & {
+    on: boolean;
+}> = {
+    id: string;
+    kind: IntentKind;
+    title: string;
+    tag: string;
+    summary: string;
+    on: boolean;
+    alertLevel: "urgent" | "normal";
+    watchIds: string[];
+    rows: R[];
+    members: {
+        group: string;
+        fns: string[];
+    }[];
+    /** Money out: the asset, its token units and its threshold (null amount: every outflow alerts). */
+    asset?: string;
+    units?: Units | null;
+    threshold?: {
+        amount: string | null;
+        basis: string;
+        confirmed: boolean;
+        suggested: {
+            amount: string;
+            basis: string;
+        } | null;
+    };
+    findingRef?: {
+        title: string;
+        index: number | null;
+    };
+};
+/** The stored rows behind a list of intent watches, in order. */
+export declare const rowsOf: <R>(intents: {
+    rows: R[];
+}[]) => R[];
 export type WatchesView = {
-    watches: StoredWatch[];
+    intents: IntentWatch[];
+    /** "N of M on", over intent watches. */
+    counts: {
+        on: number;
+        total: number;
+    };
+    /** Finding-based watches hidden until the account verifies control (a count only). */
+    locked: number;
     events: {
         id: string;
         watchId: string;
@@ -167,13 +239,13 @@ export type StartedMonitoring = {
     contractId: string;
     planId: string;
     status: "draft" | "requested" | "live";
-    watches: StoredWatchView[];
+    intents: IntentWatch<StoredWatchView>[];
     webhookUrl: string | null;
     slackUrl: string | null;
     emailAlerts: boolean;
     hasSigningSecret: boolean;
 };
-type StoredWatchView = Pick<StoredWatch, "id" | "subject" | "rule" | "status" | "title">;
+type StoredWatchView = Pick<StoredWatch, "id" | "subject" | "rule" | "suggestedRule" | "delivery" | "provenance" | "status" | "title" | "reason" | "units">;
 export type WatchChoice = {
     watchId?: string;
     fn: string;
@@ -200,7 +272,8 @@ export type DeliveryResult = {
     detail: string;
 };
 export declare const subjectKey: (s: WatchSubject) => string;
-/** The subject's display name: the fn name, or the token's symbol (never the raw token id). */
+export declare const CONTROL_NAME = "Control changes";
+/** The subject's display name: the fn name, the token's symbol (never the raw token id), or the group's. */
 export declare function subjectName(s: WatchSubject, units: Units | null): string;
 type HasSubject = {
     subject: WatchSubject;
@@ -220,7 +293,8 @@ export declare class SubjectError extends Error {
 export declare function groupSubjects<W extends HasSubject>(watches: W[]): SubjectMatch<W>[];
 /**
  * The watches on the subject `name` points at: its display name (fn name, token symbol, or the part
- * after `::`), its subjectKey (`fn:…` / `asset:…`) or a full asset id, case-insensitive. A name that
+ * after `::`, or "Control changes" / "control"), its subjectKey (`fn:…` / `asset:…` / `group:control`) or a
+ * full asset id, case-insensitive. A name that
  * matches nothing, or more than one subject, throws a SubjectError listing the candidates.
  */
 export declare function resolveSubject<W extends HasSubject>(watches: W[], name: string): SubjectMatch<W>;
@@ -231,6 +305,8 @@ export declare function ruleSummary(rule: WatchRule, units: Units | null): strin
 export type WatchKindTag = "finding" | "outflow" | "who-acts" | "governance" | "upgrade";
 /** The plain tag a rule is listed under. */
 export declare function kindTag(rule: WatchRule): WatchKindTag;
+/** An intent watch's one line: a Money out threshold in token units (or its fail-safe), else its summary. */
+export declare function intentLine(i: Pick<IntentWatch<unknown>, "kind" | "summary" | "threshold" | "units">): string;
 /** A subject's status from its rules: live if any is, else paused if all are, else suggested. */
 export declare function subjectStatus(ws: {
     status: WatchStatus;
@@ -355,7 +431,11 @@ export type WatchContext = {
     contractId: string;
     /** The plan's access level for this caller; a claimed one hides exploit detail. */
     access: PlanView["access"];
-    watches: StoredWatch[];
+    intents: IntentWatch[];
+    /** The stored rows behind the intents: what subjects resolve over. */
+    watches: (StoredWatch & {
+        on: boolean;
+    })[];
 };
 /** The caller's watches for a plan. */
 export declare function watchContext(client: SentinelClient, planId: string): Promise<WatchContext>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@secondlayer/sentinel",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Sentinel from a terminal or an agent: the CLI, an MCP server and a client for your Stacks contract monitoring.",
   "license": "MIT",
   "repository": "https://runsentinel.app/docs",