@sigrun/warden 0.0.0-stage → 0.1.0

package/dist/settings.js

@@ -0,0 +1,167 @@
+/**
+ * Warden settings: parsed from the extension's settings document
+ * (the extension's own scoped settings document, `settings/sigrun-warden.json`).
+ * Every invalid value falls back
+ * to its default with ONE `console.warn` naming the key, at most once
+ * per key per process — `parseSettings` runs per factory, so the dedup
+ * set is module-scoped; tests that need a fresh warn pass new keys or
+ * call `resetWarnedKeys()` (test hook).
+ */
+export function defaultSettings() {
+    return {
+        judge: { enabled: true },
+        thresholds: { clearAsk: 0.7, card: 0.7, irreversible: 0.9 },
+        clearances: [],
+        rules: [],
+        steerBudget: 3,
+        retentionDays: { calls: 90, holds: 365 },
+    };
+}
+/** Warned-key dedup, module-scoped ("once per key per process"). */
+const warnedKeys = new Set();
+/** Test hook: clear the once-per-process warn dedup. */
+export function resetWarnedKeys() {
+    warnedKeys.clear();
+}
+function warnOnce(warn, key) {
+    if (warnedKeys.has(key))
+        return;
+    warnedKeys.add(key);
+    warn(`warden settings: invalid "${key}", using default`);
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNumber(value) {
+    return typeof value === "number" && Number.isFinite(value);
+}
+function booleanAt(warn, key, value, fallback) {
+    if (value === undefined)
+        return fallback;
+    if (typeof value === "boolean")
+        return value;
+    warnOnce(warn, key);
+    return fallback;
+}
+function numberAt(warn, key, value, fallback) {
+    if (value === undefined)
+        return fallback;
+    if (isNumber(value) && value >= 0)
+        return value;
+    warnOnce(warn, key);
+    return fallback;
+}
+function thresholdAt(warn, key, value, fallback) {
+    if (value === undefined)
+        return fallback;
+    if (isNumber(value) && value >= 0 && value <= 1)
+        return value;
+    warnOnce(warn, key);
+    return fallback;
+}
+function stringAt(warn, key, value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value === "string" && value.length > 0)
+        return value;
+    warnOnce(warn, key);
+    return undefined;
+}
+const RULE_MATCHES = ["command", "path", "tool"];
+const RULE_LEVELS = ["warn", "hold", "deny"];
+/**
+ * Parse the raw settings document. `raw` is the settings-store value; an
+ * absent or non-object raw value yields all defaults. Each invalid key
+ * warns once per process and falls back independently.
+ */
+export function parseSettings(raw, warn) {
+    const defaults = defaultSettings();
+    if (!isPlainObject(raw))
+        return defaults;
+    const rawJudge = raw.judge;
+    const judgeEnabled = rawJudge === undefined
+        ? defaults.judge.enabled
+        : !isPlainObject(rawJudge)
+            ? (warnOnce(warn, "judge"), defaults.judge.enabled)
+            : booleanAt(warn, "judge.enabled", rawJudge.enabled, defaults.judge.enabled);
+    const rawThresholds = raw.thresholds;
+    const thresholds = { ...defaults.thresholds };
+    if (raw.thresholds !== undefined && !isPlainObject(rawThresholds)) {
+        warnOnce(warn, "thresholds");
+    }
+    else if (isPlainObject(rawThresholds)) {
+        thresholds.clearAsk = thresholdAt(warn, "thresholds.clearAsk", rawThresholds.clearAsk, defaults.thresholds.clearAsk);
+        thresholds.card = thresholdAt(warn, "thresholds.card", rawThresholds.card, defaults.thresholds.card);
+        thresholds.irreversible = thresholdAt(warn, "thresholds.irreversible", rawThresholds.irreversible, defaults.thresholds.irreversible);
+    }
+    let clearances = defaults.clearances;
+    if (raw.clearances !== undefined) {
+        if (Array.isArray(raw.clearances)) {
+            const parsed = [];
+            for (const entry of raw.clearances) {
+                if (isPlainObject(entry) &&
+                    typeof entry.job === "string" &&
+                    Array.isArray(entry.tools) &&
+                    entry.tools.every((tool) => typeof tool === "string")) {
+                    parsed.push({ job: entry.job, tools: entry.tools });
+                }
+                else {
+                    warnOnce(warn, "clearances");
+                }
+            }
+            clearances = parsed;
+        }
+        else {
+            warnOnce(warn, "clearances");
+        }
+    }
+    let rules = defaults.rules;
+    if (raw.rules !== undefined) {
+        if (Array.isArray(raw.rules)) {
+            const parsed = [];
+            for (const entry of raw.rules) {
+                if (isPlainObject(entry) &&
+                    RULE_MATCHES.includes(entry.match) &&
+                    typeof entry.pattern === "string" &&
+                    RULE_LEVELS.includes(entry.level)) {
+                    parsed.push({
+                        match: entry.match,
+                        pattern: entry.pattern,
+                        level: entry.level,
+                    });
+                }
+                else {
+                    warnOnce(warn, "rules");
+                }
+            }
+            rules = parsed;
+        }
+        else {
+            warnOnce(warn, "rules");
+        }
+    }
+    const rawRetention = raw.retentionDays;
+    const retentionDays = { ...defaults.retentionDays };
+    if (rawRetention !== undefined && !isPlainObject(rawRetention)) {
+        warnOnce(warn, "retentionDays");
+    }
+    else if (isPlainObject(rawRetention)) {
+        retentionDays.calls = numberAt(warn, "retentionDays.calls", rawRetention.calls, defaults.retentionDays.calls);
+        retentionDays.holds = numberAt(warn, "retentionDays.holds", rawRetention.holds, defaults.retentionDays.holds);
+    }
+    const settings = {
+        judge: { enabled: judgeEnabled },
+        thresholds,
+        clearances,
+        rules,
+        steerBudget: numberAt(warn, "steerBudget", raw.steerBudget, defaults.steerBudget),
+        retentionDays,
+    };
+    const decisionModel = stringAt(warn, "decisionModel", raw.decisionModel);
+    if (decisionModel !== undefined)
+        settings.decisionModel = decisionModel;
+    const cardModel = stringAt(warn, "cardModel", raw.cardModel);
+    if (cardModel !== undefined)
+        settings.cardModel = cardModel;
+    return settings;
+}

package/dist/skills.d.ts

@@ -0,0 +1,33 @@
+import type { EntryRecord } from "@earendil-works/pi-durable";
+export interface SkillSeen {
+    name: string;
+    location?: string;
+    body: string;
+    /** sha256 hex of the body. */
+    hash: string;
+}
+export interface SkillTag {
+    name: string;
+    location?: string;
+}
+/** Extract `<skill name="…" location="…">` tags from expanded text. */
+export declare function skillTagsInText(text: string): SkillTag[];
+/**
+ * Collect the skills the run saw, newest first, deduped by body hash.
+ * Input `entries` may be in either order; the newest copy of a body
+ * wins and the result sorts by first-seen recency (the entry id of
+ * each body's newest sighting, descending).
+ */
+export declare function skillsInRun(entries: readonly EntryRecord[]): SkillSeen[];
+export interface SkillBlock {
+    name: string;
+    location?: string;
+    body: string;
+}
+/**
+ * Every `<skill name="…">…</skill>` block in the text, in order. The
+ * body is trimmed of one surrounding newline pair and of core's
+ * `References are relative to …` preamble, so it equals the SKILL.md
+ * text the other channels capture.
+ */
+export declare function skillBlocksInText(text: string): SkillBlock[];

package/dist/skills.js

@@ -0,0 +1,203 @@
+/**
+ * Skills in the run (warden spec §3.4 card sources): a skill reaches a
+ * run three ways — a `<skill name="…" location="…">` block expanded
+ * into a user/job prompt, a `load_skill` result (its call's args name
+ * the skill), or a `read` of a path ending SKILL.md. `skillsInRun`
+ * collects them from the run's entries, deduped by the sha256 of the
+ * body, newest first (the most recent copy governs).
+ */
+import { createHash } from "node:crypto";
+const SKILL_TAG_RE = /<skill\s+name="([^"]+)"(?:\s+location="([^"]*)")?\s*>/g;
+/** Extract `<skill name="…" location="…">` tags from expanded text. */
+export function skillTagsInText(text) {
+    const tags = [];
+    SKILL_TAG_RE.lastIndex = 0;
+    for (;;) {
+        const match = SKILL_TAG_RE.exec(text);
+        if (match === null)
+            break;
+        const name = match[1];
+        const location = match[2];
+        tags.push(location === undefined ? { name } : { name, location });
+    }
+    return tags;
+}
+/** The text blocks of one entry's model messages, joined. */
+function entryText(entry) {
+    const messages = entry.model;
+    if (messages === undefined || messages.length === 0)
+        return "";
+    const parts = [];
+    for (const message of messages) {
+        const content = message.content;
+        if (typeof content === "string") {
+            parts.push(content);
+        }
+        else if (Array.isArray(content)) {
+            for (const block of content) {
+                if (typeof block === "object" &&
+                    block !== null &&
+                    block.type === "text" &&
+                    typeof block.text === "string") {
+                    parts.push(block.text);
+                }
+            }
+        }
+    }
+    return parts.join("\n");
+}
+/** Tool calls one entry carries (assistant messages' toolCalls). */
+function entryToolCalls(entry) {
+    const calls = [];
+    for (const message of entry.model ?? []) {
+        const list = message.toolCalls;
+        if (!Array.isArray(list))
+            continue;
+        for (const raw of list) {
+            if (typeof raw !== "object" || raw === null)
+                continue;
+            const call = raw;
+            if (typeof call.id !== "string" || typeof call.name !== "string")
+                continue;
+            calls.push({
+                id: call.id,
+                name: call.name,
+                args: typeof call.arguments === "object" && call.arguments !== null
+                    ? call.arguments
+                    : {},
+            });
+        }
+    }
+    return calls;
+}
+/** Tool results one entry carries (toolResult messages). */
+function entryToolResults(entry) {
+    const results = [];
+    for (const message of entry.model ?? []) {
+        if (message.role !== "toolResult")
+            continue;
+        const m = message;
+        if (typeof m.toolCallId !== "string" || typeof m.toolName !== "string")
+            continue;
+        const parts = [];
+        if (typeof m.content === "string") {
+            parts.push(m.content);
+        }
+        else if (Array.isArray(m.content)) {
+            for (const block of m.content) {
+                if (typeof block === "object" &&
+                    block !== null &&
+                    block.type === "text" &&
+                    typeof block.text === "string") {
+                    parts.push(block.text);
+                }
+            }
+        }
+        results.push({
+            callId: m.toolCallId,
+            toolName: m.toolName,
+            text: parts.join("\n"),
+        });
+    }
+    return results;
+}
+function bodyHash(body) {
+    return createHash("sha256").update(body, "utf8").digest("hex");
+}
+/**
+ * Collect the skills the run saw, newest first, deduped by body hash.
+ * Input `entries` may be in either order; the newest copy of a body
+ * wins and the result sorts by first-seen recency (the entry id of
+ * each body's newest sighting, descending).
+ */
+export function skillsInRun(entries) {
+    // Pair tool calls with results by callId (results reference calls).
+    const calls = new Map();
+    for (const entry of entries) {
+        for (const call of entryToolCalls(entry)) {
+            calls.set(call.id, call);
+        }
+    }
+    // body hash → { skill, newest entry id } — dedup keeps the newest.
+    const byHash = new Map();
+    const collect = (seen, at) => {
+        const existing = byHash.get(seen.hash);
+        if (existing === undefined || at > existing.seenAt) {
+            byHash.set(seen.hash, { skill: seen, seenAt: at });
+        }
+    };
+    for (const entry of entries) {
+        const id = BigInt(entry.id);
+        // Channel 1: <skill> blocks in expanded user/job prompts. One
+        // scan consumes every block, so two same-named blocks each hash
+        // their own body.
+        if (entry.kind === "pi.user" || entry.kind === "sigrun.user.expanded") {
+            const text = entryText(entry);
+            for (const block of skillBlocksInText(text)) {
+                collect({
+                    name: block.name,
+                    ...(block.location === undefined ? {} : { location: block.location }),
+                    body: block.body,
+                    hash: bodyHash(block.body),
+                }, id);
+            }
+        }
+        // Channels 2/3: tool results paired with their calls.
+        for (const result of entryToolResults(entry)) {
+            const call = calls.get(result.callId);
+            if (result.toolName === "load_skill") {
+                const name = typeof call?.args.skill === "string"
+                    ? call.args.skill
+                    : typeof call?.args.name === "string"
+                        ? call.args.name
+                        : undefined;
+                if (name === undefined || result.text.length === 0)
+                    continue;
+                collect({ name, body: result.text, hash: bodyHash(result.text) }, id);
+            }
+            else if (result.toolName === "read") {
+                const path = typeof call?.args.path === "string" ? call.args.path : undefined;
+                if (path === undefined || !path.endsWith("SKILL.md"))
+                    continue;
+                if (result.text.length === 0)
+                    continue;
+                // The skill name is the parent directory's leaf.
+                const segments = path.split("/").filter((part) => part.length > 0);
+                const name = segments.length >= 2 ? segments[segments.length - 2] : segments[0];
+                collect({ name, location: path, body: result.text, hash: bodyHash(result.text) }, id);
+            }
+        }
+    }
+    return [...byHash.values()]
+        .sort((a, b) => (a.seenAt > b.seenAt ? -1 : a.seenAt < b.seenAt ? 1 : 0))
+        .map((entry) => entry.skill);
+}
+const SKILL_BLOCK_RE = /<skill\s+name="([^"]+)"(?:\s+location="([^"]*)")?\s*>([\s\S]*?)<\/skill>/g;
+// Core's expansion (dist/commands/expand.js) prefixes the body with a
+// `References are relative to <dir>.` preamble line and a blank line —
+// neither is part of the skill body (and the absolute dir must never
+// reach a card prompt).
+const CORE_PREAMBLE_RE = /^References are relative to \S+\.\n\n/;
+/**
+ * Every `<skill name="…">…</skill>` block in the text, in order. The
+ * body is trimmed of one surrounding newline pair and of core's
+ * `References are relative to …` preamble, so it equals the SKILL.md
+ * text the other channels capture.
+ */
+export function skillBlocksInText(text) {
+    const blocks = [];
+    SKILL_BLOCK_RE.lastIndex = 0;
+    for (;;) {
+        const match = SKILL_BLOCK_RE.exec(text);
+        if (match === null)
+            break;
+        const body = match[3]
+            .replace(/^\n/, "")
+            .replace(/\n$/, "")
+            .replace(CORE_PREAMBLE_RE, "");
+        const name = match[1];
+        const location = match[2];
+        blocks.push(location === undefined ? { name, body } : { name, location, body });
+    }
+    return blocks;
+}

package/dist/state.d.ts

@@ -0,0 +1,59 @@
+import type { EntryId } from "@earendil-works/pi-durable";
+/**
+ * The escalation key / call fingerprint: `warden:` + the first 16 hex of
+ * sha256(tool + "\n" + canonical JSON of the arguments, keys sorted).
+ * Canonicalization is recursive so argument order never splits a grant.
+ */
+export declare function grantKey(tool: string, args: Record<string, unknown>): string;
+export interface ConversationState {
+    /** The newest user-input entry of the current run (run boundary). Serialized as a number. */
+    runStart?: EntryId;
+    /** Set when a deny/destructive call was blocked this run (Task 14/15). */
+    tainted?: boolean;
+    steers: number;
+    /**
+     * Held calls, kept across runs for 24 h, consumed on release.
+     * `afterEntry` carries the hold NONCE (the interaction callId suffix:
+     * `warden-<fingerprint>-<nonce>`); `status` tracks the hold lifecycle:
+     * pending → answered (consumed) → released (one call released).
+     */
+    blocked: {
+        fingerprint: string;
+        at: string;
+        /** The hold NONCE (the interaction callId suffix) for the Task 11 hold path. */
+        afterEntry?: string;
+        /** The newest entry id the block sits after (Task 12: the reply anchor). */
+        atEntry?: string;
+        status?: "pending" | "answered" | "released";
+    }[];
+    /** Answered allows consumed once; a reply releases one call. */
+    released: {
+        fingerprint: string;
+        replyEntry: string;
+    }[];
+    /** One in-flight execution per grant (job presence). */
+    reservations: {
+        grantKey: string;
+        callId: string;
+        escalationId: string;
+    }[];
+}
+/** The fingerprint of one call: the grant key WITHOUT the `warden:` prefix. */
+export declare function callFingerprint(call: {
+    name: string;
+    arguments: Record<string, unknown>;
+}): string;
+export declare function emptyState(): ConversationState;
+/**
+ * The on-disk store. `update` runs `fn` under a per-conversation
+ * in-process lock and persists the result atomically. A change of
+ * `runStart` (a new run) resets the run-scoped fields — `steers` and
+ * `taint` — while 24 h `blocked` records and `reservations` persist;
+ * `released` entries prune with their blocked record.
+ */
+export declare class StateStore {
+    #private;
+    constructor(stateDir: string, now?: () => Date);
+    load(id: number): Promise<ConversationState>;
+    update<T>(id: number, fn: (s: ConversationState) => T | Promise<T>): Promise<T>;
+}

package/dist/state.js

@@ -0,0 +1,110 @@
+/**
+ * Per-conversation warden state (`paths.state/conv/<id>.json`): blocked
+ * records (24 h), live-question releases, and job grant reservations.
+ * Writes are serialized in-process then atomic (temp + rename).
+ */
+import { createHash } from "node:crypto";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+/**
+ * The escalation key / call fingerprint: `warden:` + the first 16 hex of
+ * sha256(tool + "\n" + canonical JSON of the arguments, keys sorted).
+ * Canonicalization is recursive so argument order never splits a grant.
+ */
+export function grantKey(tool, args) {
+    const canonical = canonicalize(args);
+    const digest = createHash("sha256")
+        .update(tool)
+        .update("\n")
+        .update(canonical)
+        .digest("hex");
+    return `warden:${digest.slice(0, 16)}`;
+}
+function canonicalize(value) {
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value) ?? "undefined";
+    if (Array.isArray(value))
+        return `[${value.map(canonicalize).join(",")}]`;
+    const record = value;
+    const keys = Object.keys(record).sort();
+    const body = keys
+        .map((key) => `${JSON.stringify(key)}:${canonicalize(record[key])}`)
+        .join(",");
+    return `{${body}}`;
+}
+/** The fingerprint of one call: the grant key WITHOUT the `warden:` prefix. */
+export function callFingerprint(call) {
+    return grantKey(call.name, call.arguments).slice("warden:".length);
+}
+export function emptyState() {
+    return { steers: 0, blocked: [], released: [], reservations: [] };
+}
+const BLOCKED_TTL_MS = 24 * 60 * 60 * 1000;
+/**
+ * The on-disk store. `update` runs `fn` under a per-conversation
+ * in-process lock and persists the result atomically. A change of
+ * `runStart` (a new run) resets the run-scoped fields — `steers` and
+ * `taint` — while 24 h `blocked` records and `reservations` persist;
+ * `released` entries prune with their blocked record.
+ */
+export class StateStore {
+    #dir;
+    #now;
+    #locks = new Map();
+    constructor(stateDir, now = () => new Date()) {
+        this.#dir = join(stateDir, "conv");
+        this.#now = now;
+    }
+    async load(id) {
+        let text;
+        try {
+            text = await readFile(this.#path(id), "utf8");
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return emptyState();
+            throw error;
+        }
+        try {
+            return { ...emptyState(), ...JSON.parse(text) };
+        }
+        catch {
+            // A torn write must never brick the warden (fail closed on state).
+            return emptyState();
+        }
+    }
+    async update(id, fn) {
+        const prior = this.#locks.get(id) ?? Promise.resolve();
+        const run = prior.then(() => this.#updateInner(id, fn));
+        this.#locks.set(id, run.catch(() => {
+            // A failed update must not poison the chain for the next caller.
+        }));
+        return run;
+    }
+    async #updateInner(id, fn) {
+        const state = await this.load(id);
+        this.#prune(state);
+        const result = await fn(state);
+        await mkdir(this.#dir, { recursive: true });
+        const tmp = `${this.#path(id)}.tmp`;
+        await writeFile(tmp, `${JSON.stringify(state)}\n`, "utf8");
+        await rename(tmp, this.#path(id));
+        return result;
+    }
+    /** Drop expired 24 h blocked records (and their releases). */
+    #prune(state) {
+        const cutoff = this.#now().getTime() - BLOCKED_TTL_MS;
+        const kept = state.blocked.filter((record) => {
+            const at = Date.parse(record.at);
+            return !Number.isFinite(at) || at >= cutoff;
+        });
+        if (kept.length === state.blocked.length)
+            return;
+        const keptFingerprints = new Set(kept.map((record) => record.fingerprint));
+        state.blocked = kept;
+        state.released = state.released.filter((release) => keptFingerprints.has(release.fingerprint));
+    }
+    #path(id) {
+        return join(this.#dir, `${id}.json`);
+    }
+}

package/dist/targets.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The card-check targets of one call (warden spec §3.2): the elements
+ * of the FIRST array-of-scalars argument, as strings — the ids the call
+ * acts on. With no array-of-scalars argument, the whole call is ONE
+ * target: the canonical JSON of its arguments.
+ */
+/** One call's card-check targets. */
+export declare function targetsOf(args: Record<string, unknown>): readonly string[];

package/dist/targets.js

@@ -0,0 +1,32 @@
+/**
+ * The card-check targets of one call (warden spec §3.2): the elements
+ * of the FIRST array-of-scalars argument, as strings — the ids the call
+ * acts on. With no array-of-scalars argument, the whole call is ONE
+ * target: the canonical JSON of its arguments.
+ */
+/** One call's card-check targets. */
+export function targetsOf(args) {
+    for (const value of Object.values(args)) {
+        if (Array.isArray(value) &&
+            value.every((item) => typeof item === "string" ||
+                typeof item === "number" ||
+                typeof item === "boolean")) {
+            return value.map(String);
+        }
+    }
+    // state.ts's canonicalize is private; grantKey's digest is not the
+    // target TEXT, so re-derive the canonical JSON here (keys sorted,
+    // matching state.ts's shape).
+    return [canonicalize(args)];
+}
+function canonicalize(value) {
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value) ?? "undefined";
+    if (Array.isArray(value))
+        return `[${value.map(canonicalize).join(",")}]`;
+    const record = value;
+    const keys = Object.keys(record).sort();
+    return `{${keys
+        .map((key) => `${JSON.stringify(key)}:${canonicalize(record[key])}`)
+        .join(",")}}`;
+}

package/package.json

@@ -1,6 +1,61 @@
 {
-  "name": "@sigrun/warden",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+	"name": "@sigrun/warden",
+	"version": "0.1.0",
+	"description": "Guardrail extension for sigrun: action classification, holds, and judge-backed confirmations (pi-warden port)",
+	"type": "module",
+	"engines": {
+		"node": ">=22.19.0"
+	},
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"default": "./dist/index.js"
+		}
+	},
+	"files": [
+		"dist",
+		"CHANGELOG.md"
+	],
+	"scripts": {
+		"test": "node scripts/check-manifest.mjs --expect-name @sigrun/warden && vitest run",
+		"typecheck": "tsc --noEmit",
+		"build": "tsc -p tsconfig.build.json",
+		"prepare": "npm run build"
+	},
+	"peerDependencies": {
+		"@earendil-works/chord": "1.4.0",
+		"@earendil-works/pi-ai": "1.4.0",
+		"@earendil-works/pi-durable": "1.4.0",
+		"@sigrun/shared": "0.8.0 || 0.9.0"
+	},
+	"dependencies": {
+		"pi-warden": "^2.6.1",
+		"pi-typesafe": "^0.14.0"
+	},
+	"devDependencies": {
+		"@earendil-works/chord": "1.4.0",
+		"@earendil-works/pi-ai": "1.4.0",
+		"@earendil-works/pi-durable": "1.4.0",
+		"@sigrun/shared": "file:../sigrun/shared",
+		"@sigrun/sigrun": "file:../sigrun",
+		"@types/node": "^26.6.4",
+		"tsx": "^4.23.15",
+		"typescript": "^7.0.2",
+		"vitest": "^5.0.3"
+	},
+	"license": "MIT",
+	"repository": {
+		"type": "github",
+		"url": "git+https://github.com/sigrun-ai/sigrun-warden.git"
+	},
+	"bugs": {
+		"url": "https://github.com/sigrun-ai/sigrun-warden/issues"
+	},
+	"homepage": "https://github.com/sigrun-ai/sigrun-warden#readme",
+	"publishConfig": {
+		"access": "public",
+		"provenance": true
+	}
+}