@mnemom/mnemom 0.11.0 → 0.12.0

package/README.md

@@ -26,23 +26,23 @@ That's it. `mnemom init` detects your configured AI provider API keys (Anthropic
 
 ## Supported Providers
 
-| Provider | Models | Thinking/AIP | Auth |
-|----------|--------|-------------|------|
-| Anthropic | Claude Opus 4.6, Opus 4.5, Sonnet 4.5 | Full (thinking blocks) | `x-api-key` |
-| OpenAI | GPT-5.2, GPT-5.2 Pro, GPT-5 | Via reasoning summaries | `Authorization: Bearer` |
-| Gemini | Gemini 2.5 Pro, Gemini 3 Pro | Full (thought parts) | `x-goog-api-key` |
+| Provider  | Models                                | Thinking/AIP            | Auth                    |
+| --------- | ------------------------------------- | ----------------------- | ----------------------- |
+| Anthropic | Claude Opus 4.6, Opus 4.5, Sonnet 4.5 | Full (thinking blocks)  | `x-api-key`             |
+| OpenAI    | GPT-5.2, GPT-5.2 Pro, GPT-5           | Via reasoning summaries | `Authorization: Bearer` |
+| Gemini    | Gemini 2.5 Pro, Gemini 3 Pro          | Full (thought parts)    | `x-goog-api-key`        |
 
 ## CLI Commands
 
-| Command | Description |
-|---------|-------------|
-| `mnemom init` | Configure tracing for your AI agent (multi-provider) |
-| `mnemom status` | Show agent status, providers, and connection info |
-| `mnemom integrity` | Display integrity score and verification stats |
-| `mnemom logs [-l N]` | Show recent traces and actions |
-| `mnemom card show` | Display active alignment card |
-| `mnemom card publish <file>` | Publish alignment card from JSON file |
-| `mnemom card validate <file>` | Validate card JSON locally |
+| Command                       | Description                                          |
+| ----------------------------- | ---------------------------------------------------- |
+| `mnemom init`                 | Configure tracing for your AI agent (multi-provider) |
+| `mnemom status`               | Show agent status, providers, and connection info    |
+| `mnemom integrity`            | Display integrity score and verification stats       |
+| `mnemom logs [-l N]`          | Show recent traces and actions                       |
+| `mnemom card show`            | Display active alignment card                        |
+| `mnemom card publish <file>`  | Publish alignment card from JSON file                |
+| `mnemom card validate <file>` | Validate card JSON locally                           |
 
 ## How It Works
 
@@ -84,20 +84,20 @@ What is **not** stored: your prompts, responses, or API key.
 
 ### AIP Compatibility Matrix
 
-| Provider/Model | AIP Support | Method |
-|----------------|-------------|--------|
-| Anthropic reasoning models (Opus, Sonnet) | Full | Thinking blocks analyzed directly |
-| OpenAI GPT-5 Thinking series | Partial | Reasoning summaries (reduced confidence) |
-| Gemini 2.5/3 with thinking | Full | Thought parts analyzed directly |
-| Non-reasoning models | Tracing only | Synthetic clear verdict |
+| Provider/Model                            | AIP Support  | Method                                   |
+| ----------------------------------------- | ------------ | ---------------------------------------- |
+| Anthropic reasoning models (Opus, Sonnet) | Full         | Thinking blocks analyzed directly        |
+| OpenAI GPT-5 Thinking series              | Partial      | Reasoning summaries (reduced confidence) |
+| Gemini 2.5/3 with thinking                | Full         | Thought parts analyzed directly          |
+| Non-reasoning models                      | Tracing only | Synthetic clear verdict                  |
 
 ## Enforcement Modes
 
-| Mode | Behavior |
-|------|----------|
-| `observe` | Detect violations, record them, take no action (default) |
-| `nudge` | Detect violations, inject feedback into the agent's next request via system prompt — the agent sees it and can self-correct |
-| `enforce` | Hard block with 403 for non-streaming; falls back to nudge for streaming |
+| Mode      | Behavior                                                                                                                    |
+| --------- | --------------------------------------------------------------------------------------------------------------------------- |
+| `observe` | Detect violations, record them, take no action (default)                                                                    |
+| `nudge`   | Detect violations, inject feedback into the agent's next request via system prompt — the agent sees it and can self-correct |
+| `enforce` | Hard block with 403 for non-streaming; falls back to nudge for streaming                                                    |
 
 Enforcement works across all providers where AIP is supported.
 

package/dist/commands/agents.js

@@ -23,18 +23,13 @@ export async function agentsListCommand() {
     const idW = 40;
     const seenW = 14;
     const statusW = 14;
-    const header = "Name".padEnd(nameW) +
-        "ID".padEnd(idW) +
-        "Last Seen".padEnd(seenW) +
-        "Containment";
+    const header = "Name".padEnd(nameW) + "ID".padEnd(idW) + "Last Seen".padEnd(seenW) + "Containment";
     console.log(`  ${header}`);
     console.log(`  ${"─".repeat(nameW + idW + seenW + statusW)}`);
     for (const agent of agents) {
         const name = (agent.name ?? "-").slice(0, nameW - 2).padEnd(nameW);
         const id = agent.id.padEnd(idW);
-        const lastSeen = agent.last_seen
-            ? new Date(agent.last_seen).toLocaleDateString()
-            : "-";
+        const lastSeen = agent.last_seen ? new Date(agent.last_seen).toLocaleDateString() : "-";
         const seen = lastSeen.padEnd(seenW);
         const containment = agent.containment_status ?? "-";
         console.log(`  ${name}${id}${seen}${containment}`);

package/dist/commands/api-key.js

@@ -54,9 +54,7 @@ function renderScopeBadge(scope) {
     return `[${scope}]`;
 }
 function formatRow(key) {
-    const created = key.created_at
-        ? new Date(key.created_at).toISOString().slice(0, 10)
-        : "?";
+    const created = key.created_at ? new Date(key.created_at).toISOString().slice(0, 10) : "?";
     const lastUsed = key.last_used_at
         ? new Date(key.last_used_at).toISOString().slice(0, 10)
         : "never";

package/dist/commands/auth.js

@@ -1,5 +1,4 @@
-import { getAuthInfo, clearAuthTokens } from "../lib/auth.js";
-import { loginWithBrowser, loginWithPassword } from "../lib/auth.js";
+import { getAuthInfo, clearAuthTokens, loginWithBrowser, loginWithPassword } from "../lib/auth.js";
 import { fmt } from "../lib/format.js";
 import { askInput } from "../lib/prompt.js";
 export async function loginCommand(options = {}) {

package/dist/commands/card.js

@@ -7,7 +7,7 @@ import { ALIGNMENT_CARD_MAX_BYTES, getAlignmentCard, putAlignmentCard, resolveAg
 import { requireAuth } from "../lib/auth.js";
 import { fmt } from "../lib/format.js";
 import { askYesNo, isInteractive } from "../lib/prompt.js";
-import { evaluatePolicy, } from "@mnemom/policy-engine";
+import { evaluatePolicy } from "@mnemom/policy-engine";
 function detectFormat(filePath) {
     const ext = path.extname(filePath).toLowerCase();
     if (ext === ".yaml" || ext === ".yml")
@@ -201,7 +201,7 @@ export function validateUnifiedCard(card) {
                 message: "Must contain at least one value.",
             });
         }
-        else if (!decl.every(s => typeof s === "string")) {
+        else if (!decl.every((s) => typeof s === "string")) {
             checks.push({
                 name: "values.declared",
                 passed: false,
@@ -238,7 +238,8 @@ export function validateUnifiedCard(card) {
             }
         }
         // hierarchy enum
-        if (v.hierarchy !== undefined && !VALUE_HIERARCHIES.includes(String(v.hierarchy))) {
+        if (v.hierarchy !== undefined &&
+            !VALUE_HIERARCHIES.includes(String(v.hierarchy))) {
             checks.push({
                 name: "values.hierarchy",
                 passed: false,
@@ -247,7 +248,8 @@ export function validateUnifiedCard(card) {
         }
     }
     // ── autonomy.bounded_actions (required, non-empty; disjoint from forbidden_actions) ──
-    if (!isObj(card.autonomy) || !Array.isArray(card.autonomy.bounded_actions)) {
+    if (!isObj(card.autonomy) ||
+        !Array.isArray(card.autonomy.bounded_actions)) {
         checks.push({
             name: "autonomy.bounded_actions",
             passed: false,
@@ -428,7 +430,8 @@ export function validateUnifiedCard(card) {
                             message: "Required (non-empty string).",
                         });
                     }
-                    if (cv.severity !== undefined && !CONSCIENCE_SEVERITIES.includes(String(cv.severity))) {
+                    if (cv.severity !== undefined &&
+                        !CONSCIENCE_SEVERITIES.includes(String(cv.severity))) {
                         checks.push({
                             name: `conscience.values[${i}].severity`,
                             passed: false,
@@ -676,20 +679,21 @@ export async function cardEditCommand(agentName, options = {}) {
     if (!original) {
         console.log(fmt.warn("No alignment card found. Creating a template..."));
     }
-    const cardYaml = original || yaml.dump({
-        card_version: "unified/2026-04-26",
-        agent_id: agentId,
-        autonomy_mode: "observe",
-        integrity_mode: "observe",
-        principal: { type: "agent", identifier: agentId, relationship: "delegated_authority" },
-        values: { declared: ["transparency", "safety", "honesty"] },
-        autonomy: {
-            bounded_actions: ["respond_to_prompts"],
-            forbidden_actions: [],
-            escalation_triggers: [],
-        },
-        audit: { retention_days: 30, queryable: false, trace_format: "otel" },
-    }, { lineWidth: 120, noRefs: true });
+    const cardYaml = original ||
+        yaml.dump({
+            card_version: "unified/2026-04-26",
+            agent_id: agentId,
+            autonomy_mode: "observe",
+            integrity_mode: "observe",
+            principal: { type: "agent", identifier: agentId, relationship: "delegated_authority" },
+            values: { declared: ["transparency", "safety", "honesty"] },
+            autonomy: {
+                bounded_actions: ["respond_to_prompts"],
+                forbidden_actions: [],
+                escalation_triggers: [],
+            },
+            audit: { retention_days: 30, queryable: false, trace_format: "otel" },
+        }, { lineWidth: 120, noRefs: true });
     // Write to temp file
     const tmpDir = os.tmpdir();
     const tmpFile = path.join(tmpDir, `mnemom-card-${agentId}.yaml`);
@@ -703,7 +707,9 @@ export async function cardEditCommand(agentName, options = {}) {
         try {
             fs.unlinkSync(tmpFile);
         }
-        catch { /* ignore */ }
+        catch {
+            /* ignore */
+        }
         process.exit(1);
     }
     // Read back and compare
@@ -711,7 +717,9 @@ export async function cardEditCommand(agentName, options = {}) {
     try {
         fs.unlinkSync(tmpFile);
     }
-    catch { /* ignore */ }
+    catch {
+        /* ignore */
+    }
     if (edited === cardYaml) {
         console.log("\nNo changes made.\n");
         return;
@@ -808,7 +816,10 @@ export async function cardEvaluateCommand(file, options) {
     // 2. Parse tool list from --tools or --tool-manifest
     let tools = [];
     if (options.tools) {
-        tools = options.tools.split(",").map((t) => ({ name: t.trim() })).filter((t) => t.name);
+        tools = options.tools
+            .split(",")
+            .map((t) => ({ name: t.trim() }))
+            .filter((t) => t.name);
     }
     else if (options.toolManifest) {
         const manifestPath = path.resolve(options.toolManifest);

package/dist/commands/governance.js

@@ -211,12 +211,7 @@ export async function governanceDestinationsListCommand(opts) {
 }
 export async function governanceDestinationsAddCommand(opts) {
     await requireAuth();
-    const validChannels = [
-        "webhook",
-        "slack",
-        "email",
-        "pagerduty",
-    ];
+    const validChannels = ["webhook", "slack", "email", "pagerduty"];
     if (!validChannels.includes(opts.channel)) {
         throw new Error(`--channel must be one of: ${validChannels.join(", ")}`);
     }
@@ -305,7 +300,10 @@ export async function governanceRulesAddCommand(opts) {
     catch {
         throw new Error("--predicate must be valid JSON");
     }
-    const destinationIds = opts.destinations.split(",").map((s) => s.trim()).filter(Boolean);
+    const destinationIds = opts.destinations
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean);
     if (destinationIds.length === 0) {
         throw new Error("--destinations must list at least one destination ID (comma-separated)");
     }

package/dist/commands/integrity.js

@@ -1,5 +1,4 @@
-import { resolveAgentId } from "../lib/api.js";
-import { getIntegrity } from "../lib/api.js";
+import { resolveAgentId, getIntegrity } from "../lib/api.js";
 import { fmt } from "../lib/format.js";
 export async function integrityCommand(agentName) {
     const agentId = await resolveAgentId(agentName);

package/dist/commands/license.js

@@ -72,10 +72,15 @@ export async function licenseActivateCommand(jwt) {
     saveLicenseJwt(jwt);
     // Display info
     const expiresAt = claims.exp ? new Date(claims.exp * 1000) : null;
-    const daysRemaining = expiresAt ? Math.floor((expiresAt.getTime() - Date.now()) / 86400000) : "unknown";
+    const daysRemaining = expiresAt
+        ? Math.floor((expiresAt.getTime() - Date.now()) / 86400000)
+        : "unknown";
     console.log("  License ID:      " + (claims.license_id || "unknown"));
     console.log("  Plan:            " + (claims.plan_id || "unknown"));
-    console.log("  Features:        " + Object.keys(claims.feature_flags || {}).filter((k) => claims.feature_flags[k]).join(", ") || "none");
+    console.log("  Features:        " +
+        Object.keys(claims.feature_flags || {})
+            .filter((k) => claims.feature_flags[k])
+            .join(", ") || "none");
     console.log("  Expires:         " + (expiresAt ? expiresAt.toISOString() : "unknown"));
     console.log("  Days remaining:  " + daysRemaining);
     console.log("  Max activations: " + (claims.max_activations || "unknown"));
@@ -95,14 +100,18 @@ export async function licenseStatusCommand() {
         process.exit(1);
     }
     const expiresAt = claims.exp ? new Date(claims.exp * 1000) : null;
-    const daysRemaining = expiresAt ? Math.floor((expiresAt.getTime() - Date.now()) / 86400000) : null;
+    const daysRemaining = expiresAt
+        ? Math.floor((expiresAt.getTime() - Date.now()) / 86400000)
+        : null;
     const isExpired = daysRemaining !== null && daysRemaining <= 0;
     console.log(fmt.header("Enterprise License Status"));
     console.log();
     console.log(`  ${fmt.label("License ID:     ", String(claims.license_id || "unknown"))}`);
     console.log(`  ${fmt.label("Account:        ", String(claims.account_id || "unknown"))}`);
     console.log(`  ${fmt.label("Plan:           ", String(claims.plan_id || "unknown"))}`);
-    console.log(`  ${fmt.label("Features:       ", Object.keys(claims.feature_flags || {}).filter((k) => claims.feature_flags[k]).join(", ") || "none")}`);
+    console.log(`  ${fmt.label("Features:       ", Object.keys(claims.feature_flags || {})
+        .filter((k) => claims.feature_flags[k])
+        .join(", ") || "none")}`);
     console.log(`  ${fmt.label("Expires:        ", expiresAt ? expiresAt.toISOString() : "unknown")}`);
     console.log(`  ${fmt.label("Days remaining: ", String(daysRemaining ?? "unknown"))}`);
     console.log(`  ${fmt.label("Status:         ", isExpired ? "EXPIRED" : "Active")}`);

package/dist/commands/listen.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `mnemom listen <org_id>` — Stripe-style live webhook event stream
+ * (Track 2 W3.4b).
+ *
+ *   mnemom listen <org_id>
+ *     [--forward-to <url>]    # POST each event to this local URL
+ *     [--secret <hex>]        # local signing secret for re-signed HMAC
+ *     [--filter <a,b,c>]      # only forward/print these event types
+ *     [--since <event_id>]    # resume from this cursor on first connect
+ *     [--json]                # emit raw JSON lines instead of formatted summary
+ *
+ * Connects to `${API_BASE}/v1/orgs/${orgId}/webhooks/listen` (SSE)
+ * and reconnects with `Last-Event-ID` on stream close. Each event is
+ * printed (formatted summary or raw JSON) and, if `--forward-to` is
+ * set, re-signed with the local secret and POST'd to the receiver
+ * URL — letting customers write/test webhook receivers locally
+ * against real production events.
+ */
+interface ListenOptions {
+    forwardTo?: string;
+    secret?: string;
+    filter?: string;
+    since?: string;
+    json?: boolean;
+    /** Test-mode hook: forces a single iteration (no reconnect loop). */
+    __once?: boolean;
+}
+export declare function listenCommand(orgId: string, opts?: ListenOptions): Promise<void>;
+export {};

package/dist/commands/listen.js

@@ -0,0 +1,201 @@
+/**
+ * `mnemom listen <org_id>` — Stripe-style live webhook event stream
+ * (Track 2 W3.4b).
+ *
+ *   mnemom listen <org_id>
+ *     [--forward-to <url>]    # POST each event to this local URL
+ *     [--secret <hex>]        # local signing secret for re-signed HMAC
+ *     [--filter <a,b,c>]      # only forward/print these event types
+ *     [--since <event_id>]    # resume from this cursor on first connect
+ *     [--json]                # emit raw JSON lines instead of formatted summary
+ *
+ * Connects to `${API_BASE}/v1/orgs/${orgId}/webhooks/listen` (SSE)
+ * and reconnects with `Last-Event-ID` on stream close. Each event is
+ * printed (formatted summary or raw JSON) and, if `--forward-to` is
+ * set, re-signed with the local secret and POST'd to the receiver
+ * URL — letting customers write/test webhook receivers locally
+ * against real production events.
+ */
+import { getApiUrl } from "../lib/config.js";
+import { resolveAuth, forceRefreshAccessToken, requireAuth } from "../lib/auth.js";
+import { fmt } from "../lib/format.js";
+import { parseSseStream, reSignDelivery } from "../lib/listen-stream.js";
+const API_BASE = getApiUrl();
+async function authHeaders() {
+    const cred = await resolveAuth();
+    switch (cred.type) {
+        case "jwt":
+            return { Authorization: `Bearer ${cred.token}` };
+        case "api-key":
+            return { "X-Mnemom-Api-Key": cred.key };
+        case "none":
+            return {};
+    }
+}
+function parseFilter(value) {
+    if (!value)
+        return null;
+    const set = new Set(value
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean));
+    return set.size > 0 ? set : null;
+}
+async function forwardEvent(url, rawBody, signingSecret, eventId) {
+    const start = Date.now();
+    const { timestamp, signature } = reSignDelivery(rawBody, signingSecret);
+    try {
+        const res = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "X-Webhook-Id": eventId,
+                "X-Webhook-Timestamp": timestamp,
+                "X-Webhook-Signature": signature,
+            },
+            body: rawBody,
+        });
+        return { status: res.status, latencyMs: Date.now() - start };
+    }
+    catch (err) {
+        return {
+            status: null,
+            error: err instanceof Error ? err.message : String(err),
+            latencyMs: Date.now() - start,
+        };
+    }
+}
+function summarizeEvent(eventId, eventType, fwd) {
+    const ts = new Date().toISOString().slice(11, 19);
+    if (!fwd)
+        return `[${ts}] ${eventType.padEnd(30)} ${eventId}`;
+    const statusStr = fwd.status !== null ? String(fwd.status) : "ERR";
+    const okSign = fwd.status !== null && fwd.status >= 200 && fwd.status < 300 ? "✓" : "✗";
+    return (`[${ts}] ${eventType.padEnd(30)} ${eventId.padEnd(24)} → ${okSign} ${statusStr} (${fwd.latencyMs}ms)` +
+        (fwd.error ? ` ${fwd.error}` : ""));
+}
+/**
+ * One connect → consume cycle. Returns the cursor after the cycle ends
+ * (either from the `close` event or from the last received event_id),
+ * so callers can reconnect with it.
+ */
+async function consumeOnce(orgId, cursor, opts, filter, log) {
+    const url = new URL(`${API_BASE}/v1/orgs/${orgId}/webhooks/listen`);
+    if (cursor)
+        url.searchParams.set("since", cursor);
+    const headers = {
+        ...(await authHeaders()),
+        Accept: "text/event-stream",
+    };
+    if (cursor)
+        headers["Last-Event-ID"] = cursor;
+    let res = await fetch(url.toString(), { headers });
+    if (res.status === 401) {
+        const refreshed = await forceRefreshAccessToken();
+        if (refreshed) {
+            const retryHeaders = {
+                ...(await authHeaders()),
+                Accept: "text/event-stream",
+                ...(cursor ? { "Last-Event-ID": cursor } : {}),
+            };
+            res = await fetch(url.toString(), { headers: retryHeaders });
+        }
+    }
+    if (!res.ok) {
+        const msg = await res.text().catch(() => "");
+        throw new Error(`${res.status} ${msg.slice(0, 200)}`);
+    }
+    if (!res.body)
+        throw new Error("response body missing");
+    let latestCursor = cursor;
+    for await (const frame of parseSseStream(res.body)) {
+        if (frame.event === "ready") {
+            // Connection healthy; nothing to print.
+            continue;
+        }
+        if (frame.event === "close") {
+            // Server-initiated graceful close; cursor in the data.
+            try {
+                const parsed = JSON.parse(frame.data);
+                if (parsed.cursor)
+                    latestCursor = parsed.cursor;
+            }
+            catch {
+                /* fall through */
+            }
+            return latestCursor;
+        }
+        if (frame.event === "error") {
+            log(fmt.error(`server error frame: ${frame.data}`));
+            continue;
+        }
+        if (frame.event !== "webhook.event")
+            continue;
+        let payload;
+        try {
+            payload = JSON.parse(frame.data);
+        }
+        catch {
+            log(fmt.warn(`skipped unparseable data: ${frame.data.slice(0, 80)}`));
+            continue;
+        }
+        if (filter && payload.event_type && !filter.has(payload.event_type))
+            continue;
+        if (frame.id)
+            latestCursor = frame.id;
+        if (opts.json) {
+            log(frame.data);
+        }
+        let fwdResult = null;
+        if (opts.forwardTo) {
+            if (!opts.secret) {
+                log(fmt.error("--forward-to requires --secret to re-sign the local delivery"));
+            }
+            else {
+                fwdResult = await forwardEvent(opts.forwardTo, frame.data, opts.secret, payload.event_id ?? "unknown");
+            }
+        }
+        if (!opts.json) {
+            log(summarizeEvent(payload.event_id ?? "unknown", payload.event_type ?? "?", fwdResult));
+        }
+    }
+    return latestCursor;
+}
+const RECONNECT_BACKOFF_MS = [1000, 2000, 5000, 10000];
+export async function listenCommand(orgId, opts = {}) {
+    await requireAuth();
+    if (!orgId) {
+        console.log(fmt.error("Usage: mnemom listen <org_id>") + "\n");
+        process.exit(1);
+    }
+    const filter = parseFilter(opts.filter);
+    let cursor = opts.since ?? null;
+    if (!opts.json) {
+        const filterStr = filter ? ` (filter: ${[...filter].join(", ")})` : "";
+        const forwardStr = opts.forwardTo ? `\n  Forward → ${opts.forwardTo}` : "";
+        console.log(fmt.header(`Listening for webhook events — org ${orgId}${filterStr}`) +
+            forwardStr +
+            "\n  Press Ctrl-C to stop." +
+            "\n");
+    }
+    let consecutiveFailures = 0;
+    while (true) {
+        try {
+            const next = await consumeOnce(orgId, cursor, opts, filter, (msg) => console.log(msg));
+            cursor = next;
+            consecutiveFailures = 0;
+            if (opts.__once)
+                return;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.log(fmt.warn(`Stream closed: ${msg}`));
+            if (opts.__once)
+                return;
+            const delay = RECONNECT_BACKOFF_MS[Math.min(consecutiveFailures, RECONNECT_BACKOFF_MS.length - 1)];
+            console.log(fmt.warn(`Reconnecting in ${delay}ms…`));
+            await new Promise((r) => setTimeout(r, delay));
+            consecutiveFailures += 1;
+        }
+    }
+}

package/dist/commands/logs.js

@@ -36,9 +36,7 @@ export async function logsCommand(options = {}) {
 }
 function displayTrace(trace) {
     const timestamp = formatTimestamp(trace.timestamp);
-    const statusMsg = trace.verified
-        ? fmt.success(timestamp)
-        : fmt.error(`${timestamp} [VIOLATION]`);
+    const statusMsg = trace.verified ? fmt.success(timestamp) : fmt.error(`${timestamp} [VIOLATION]`);
     console.log(`\n  ${statusMsg}`);
     console.log(`  ${fmt.label("Action:", ` ${trace.action}`)}`);
     if (trace.tool_name) {

package/dist/commands/org.js

@@ -34,10 +34,7 @@ export async function orgListCommand(opts) {
     const idW = 24;
     const roleW = 10;
     const ownerW = 8;
-    const header = "Name".padEnd(nameW) +
-        "ID".padEnd(idW) +
-        "Role".padEnd(roleW) +
-        "Owner".padEnd(ownerW);
+    const header = "Name".padEnd(nameW) + "ID".padEnd(idW) + "Role".padEnd(roleW) + "Owner".padEnd(ownerW);
     console.log(`  ${header}`);
     console.log(`  ${"─".repeat(nameW + idW + roleW + ownerW)}`);
     for (const org of orgs) {
@@ -60,7 +57,7 @@ export async function orgListCommand(opts) {
  */
 export async function orgShowCommand(orgIdArg, opts) {
     await requireAuth();
-    let target = null;
+    let target;
     try {
         if (opts.personal) {
             const ref = await getMyPersonalOrg();
@@ -81,7 +78,8 @@ export async function orgShowCommand(orgIdArg, opts) {
                 target = orgs[0];
             }
             else {
-                console.log(fmt.warn(`You have ${orgs.length} memberships. Specify an org_id or pass --personal.`) + "\n");
+                console.log(fmt.warn(`You have ${orgs.length} memberships. Specify an org_id or pass --personal.`) +
+                    "\n");
                 process.exit(1);
                 return;
             }