pulseed 0.0.1 → 0.1.0

package/dist/traits/ethics-gate.js

@@ -0,0 +1,245 @@
+import { randomUUID } from "node:crypto";
+import { EthicsVerdictSchema, EthicsLogSchema, } from "../types/ethics.js";
+import { LAYER1_RULES, ETHICS_SYSTEM_PROMPT } from "./ethics-rules.js";
+// ─── Constants ───
+const CONFIDENCE_FLAG_THRESHOLD = 0.6;
+/** Path relative to StateManager base dir for the ethics log */
+const ETHICS_LOG_PATH = "ethics/ethics-log.json";
+// ─── EthicsGate ───
+/**
+ * EthicsGate performs LLM-based ethical evaluation of goals, subgoals, and tasks.
+ * All verdicts (pass, flag, reject) are persisted to an ethics log.
+ *
+ * Persistence: `ethics/ethics-log.json` via StateManager readRaw/writeRaw.
+ * Read all → append → write all pattern (full JSON array, not JSONL).
+ *
+ * Layer 1: Hardcoded category-based blocklist (no LLM call). Runs before Layer 2.
+ * Layer 2: LLM-based evaluation. Only runs when Layer 1 passes.
+ * Custom constraints: Injected into the Layer 2 LLM prompt as additional context.
+ */
+export class EthicsGate {
+    stateManager;
+    llmClient;
+    customConstraints;
+    gateway;
+    constructor(stateManager, llmClient, customConstraints, gateway) {
+        this.stateManager = stateManager;
+        this.llmClient = llmClient;
+        this.customConstraints = customConstraints;
+        this.gateway = gateway;
+    }
+    // ─── Private: Log I/O ───
+    async loadLogs() {
+        const raw = await this.stateManager.readRaw(ETHICS_LOG_PATH);
+        if (raw === null)
+            return [];
+        if (!Array.isArray(raw))
+            return [];
+        return raw.map((entry) => EthicsLogSchema.parse(entry));
+    }
+    async saveLogs(logs) {
+        await this.stateManager.writeRaw(ETHICS_LOG_PATH, logs);
+    }
+    async appendLog(entry) {
+        const logs = await this.loadLogs();
+        logs.push(EthicsLogSchema.parse(entry));
+        await this.saveLogs(logs);
+    }
+    // ─── Private: Layer 1 evaluation ───
+    /**
+     * Checks the input description against all hardcoded Layer 1 rules.
+     * Returns an EthicsVerdict with verdict "reject" and confidence 1.0 if any rule matches.
+     * Returns null if no rule matches (pass to Layer 2).
+     */
+    checkLayer1(description) {
+        for (const rule of LAYER1_RULES) {
+            if (rule.matches(description)) {
+                return {
+                    verdict: "reject",
+                    category: rule.category,
+                    reasoning: rule.description,
+                    risks: [],
+                    confidence: 1.0,
+                };
+            }
+        }
+        return null;
+    }
+    // ─── Private: LLM evaluation ───
+    buildUserMessage(subjectType, description, context, applyConstraints) {
+        const lines = [
+            `Subject type: ${subjectType}`,
+            `Description: ${description}`,
+        ];
+        if (context) {
+            lines.push(`Additional context: ${context}`);
+        }
+        if (applyConstraints && this.customConstraints && this.customConstraints.constraints.length > 0) {
+            const goalConstraints = this.customConstraints.constraints.filter((c) => c.applies_to === "goal");
+            if (goalConstraints.length > 0) {
+                lines.push("");
+                lines.push("Additional organizational constraints:");
+                for (const constraint of goalConstraints) {
+                    lines.push(`- ${constraint.description}`);
+                }
+                lines.push("You MUST flag or reject any subject that violates these constraints.");
+            }
+        }
+        return lines.join("\n");
+    }
+    buildMeansUserMessage(taskDescription, means, applyConstraints) {
+        const lines = [
+            `Subject type: task (means evaluation)`,
+            `Task description: ${taskDescription}`,
+            `Proposed means / execution method: ${means}`,
+        ];
+        if (applyConstraints && this.customConstraints && this.customConstraints.constraints.length > 0) {
+            const meansConstraints = this.customConstraints.constraints.filter((c) => c.applies_to === "task_means");
+            if (meansConstraints.length > 0) {
+                lines.push("");
+                lines.push("Additional organizational constraints:");
+                for (const constraint of meansConstraints) {
+                    lines.push(`- ${constraint.description}`);
+                }
+                lines.push("You MUST flag or reject any subject that violates these constraints.");
+            }
+        }
+        return lines.join("\n");
+    }
+    parseVerdictSafe(content) {
+        try {
+            return this.llmClient.parseJSON(content, EthicsVerdictSchema);
+        }
+        catch {
+            return {
+                verdict: "flag",
+                category: "parse_error",
+                reasoning: `Failed to parse LLM response as valid EthicsVerdict. Raw content: ${content.slice(0, 200)}`,
+                risks: [],
+                confidence: 0,
+            };
+        }
+    }
+    applyConfidenceOverride(verdict) {
+        if (verdict.confidence < CONFIDENCE_FLAG_THRESHOLD && verdict.verdict === "pass") {
+            return { ...verdict, verdict: "flag" };
+        }
+        return verdict;
+    }
+    /**
+     * Runs Layer 2 (LLM evaluation), logs the result, and returns the verdict.
+     * Called by both check() and checkMeans() after Layer 1 passes.
+     */
+    async runLayer2(userMessage, subjectType, subjectId, subjectDescription) {
+        let rawVerdict;
+        if (this.gateway) {
+            rawVerdict = await this.gateway.execute({
+                purpose: "ethics_evaluate",
+                additionalContext: { ethics_prompt: userMessage },
+                responseSchema: EthicsVerdictSchema,
+                temperature: 0,
+            });
+        }
+        else {
+            const response = await this.llmClient.sendMessage([{ role: "user", content: userMessage }], { system: ETHICS_SYSTEM_PROMPT, temperature: 0 });
+            rawVerdict = this.parseVerdictSafe(response.content);
+        }
+        const verdict = this.applyConfidenceOverride(rawVerdict);
+        const logEntry = EthicsLogSchema.parse({
+            log_id: randomUUID(),
+            timestamp: new Date().toISOString(),
+            subject_type: subjectType,
+            subject_id: subjectId,
+            subject_description: subjectDescription,
+            verdict,
+            layer1_triggered: false,
+        });
+        await this.appendLog(logEntry);
+        return verdict;
+    }
+    // ─── Public API ───
+    /**
+     * Evaluate a goal, subgoal, or task for ethical concerns.
+     *
+     * Steps:
+     * 1. Run Layer 1 (checkLayer1) — synchronous, no LLM call
+     *    - If match: log with layer1_triggered=true and return immediately
+     * 2. Build LLM prompt, injecting custom constraints for "goal" applies_to
+     * 3. Send ethics judgment prompt to LLM (Layer 2)
+     * 4. Parse response with EthicsVerdictSchema
+     * 5. If confidence < CONFIDENCE_FLAG_THRESHOLD, auto-override verdict to "flag"
+     * 6. Create EthicsLog entry, persist
+     * 7. Return verdict
+     *
+     * On LLM call failure: throws (caller handles).
+     * On JSON parse failure: returns conservative fallback with verdict "flag".
+     */
+    async check(subjectType, subjectId, description, context) {
+        // Layer 1 check
+        const layer1Result = this.checkLayer1(description);
+        if (layer1Result !== null) {
+            const logEntry = EthicsLogSchema.parse({
+                log_id: randomUUID(),
+                timestamp: new Date().toISOString(),
+                subject_type: subjectType,
+                subject_id: subjectId,
+                subject_description: description,
+                verdict: layer1Result,
+                layer1_triggered: true,
+            });
+            await this.appendLog(logEntry);
+            return layer1Result;
+        }
+        // Layer 2: LLM evaluation
+        const userMessage = this.buildUserMessage(subjectType, description, context, true);
+        return this.runLayer2(userMessage, subjectType, subjectId, description);
+    }
+    /**
+     * Evaluate the execution means of a task for ethical concerns.
+     * Used by TaskLifecycle to screen proposed execution methods before execution.
+     *
+     * Steps:
+     * 1. Run Layer 1 on combined taskDescription + means
+     *    - If match: log with layer1_triggered=true and return immediately
+     * 2. Build LLM prompt, injecting custom constraints for "task_means" applies_to
+     * 3. LLM-based Layer 2 evaluation
+     * 4. Log and return
+     */
+    async checkMeans(taskId, taskDescription, means) {
+        const subjectDescription = `${taskDescription} | means: ${means}`;
+        // Layer 1 check (combined input for full context)
+        const layer1Result = this.checkLayer1(`${taskDescription} ${means}`);
+        if (layer1Result !== null) {
+            const logEntry = EthicsLogSchema.parse({
+                log_id: randomUUID(),
+                timestamp: new Date().toISOString(),
+                subject_type: "task",
+                subject_id: taskId,
+                subject_description: subjectDescription,
+                verdict: layer1Result,
+                layer1_triggered: true,
+            });
+            await this.appendLog(logEntry);
+            return layer1Result;
+        }
+        // Layer 2: LLM evaluation
+        const userMessage = this.buildMeansUserMessage(taskDescription, means, true);
+        return this.runLayer2(userMessage, "task", taskId, subjectDescription);
+    }
+    /**
+     * Retrieve all persisted ethics logs, with optional filtering.
+     */
+    async getLogs(filter) {
+        let logs = await this.loadLogs();
+        if (filter?.subjectId !== undefined) {
+            const targetId = filter.subjectId;
+            logs = logs.filter((log) => log.subject_id === targetId);
+        }
+        if (filter?.verdict !== undefined) {
+            const targetVerdict = filter.verdict;
+            logs = logs.filter((log) => log.verdict.verdict === targetVerdict);
+        }
+        return logs;
+    }
+}
+//# sourceMappingURL=ethics-gate.js.map

package/dist/traits/ethics-gate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ethics-gate.js","sourceRoot":"","sources":["../../src/traits/ethics-gate.ts"],"names":[],"mappings":"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"}

package/dist/traits/ethics-rules.d.ts

@@ -0,0 +1,10 @@
+import type { Layer1Rule } from "../types/ethics.js";
+/**
+ * Hardcoded Layer 1 rules for immediate rejection without LLM call.
+ * These rules classify intent, not keywords. Each rule uses combinations
+ * of intent-indicating phrases with negation checks for legitimate contexts.
+ * False negatives (passing to Layer 2) are acceptable; false positives are NOT.
+ */
+export declare const LAYER1_RULES: Layer1Rule[];
+export declare const ETHICS_SYSTEM_PROMPT = "# PulSeed Persona\n\nCore stance: A gentle guardian and passionate realist.\nDecisions are driven by cold data and logic; the purpose is to deeply care\nfor and protect the user.\n\nThis persona governs communication style only. It does not override structural\nconstraints (ethics gate, irreversible action rules, trust-safety matrix).\nThose constraints operate independently and cannot be adjusted by persona settings.\n\n## Behavioral axes\n\n1. **Assessment: Conservative**\n   \"I won't let you walk into danger.\"\n   - Never dismiss ambitious goals outright\n   - Always propose safe, achievable alternatives to prevent burnout\n   - Counter-proposals must include concrete numerical rationale\n   - Say \"here is a safer path\" not \"you can't do this\"\n\n2. **Stall response: Highly flexible**\n   \"I don't want you to suffer needlessly.\"\n   - Never cling to sunk costs\n   - Escalate to pivot suggestion at first stall detection (do not wait)\n   - Always pair stall reports with: cause analysis + alternative approaches\n   - Say \"this approach isn't working for you, let's find another\" not \"this failed\"\n\n3. **Truth-telling: Caring yet direct**\n   \"I deliver hard truths because they help you.\"\n   - Never hide inconvenient data\n   - Always pair bad news with actionable alternatives\n   - Negative reports require: current progress + gap remaining + options list\n   - Say \"here is where we are, and here is how we can move forward\" not just \"we missed the target\"\n\n4. **Reporting: Quiet by default, thorough when it matters**\n   \"I watch silently; I speak up when it counts.\"\n   - Normal loop updates: 1-2 line summary only (metrics change + current status)\n   - Detailed report triggers: stall detection, escalation, goal completion,\n     pivot proposal, irreversible action approval request\n   - Approval requests must include: what is being requested, why,\n     current trust/confidence scores, and available options\n\n## Tone\n\n- Warm, calm, direct\n- Never condescending, never falsely cheerful\n- Convey \"I am working for you\" without being sycophantic\n- When delivering hard news: acknowledge difficulty first, then pivot to what can be done\n\n---\n\nYou are an ethics evaluator for an AI agent orchestrator. Be conservative \u2014 when uncertain, prefer 'flag' over 'pass'. Only use 'reject' for clearly unethical or illegal goals.\n\nEvaluate the subject described below and return a JSON object with exactly these fields:\n{\n  \"verdict\": \"pass\" | \"flag\" | \"reject\",\n  \"category\": string (e.g. \"safe\", \"privacy_concern\", \"illegal\", \"harmful\", \"ambiguous\", \"parse_error\"),\n  \"reasoning\": string (brief explanation of your judgment),\n  \"risks\": string[] (list of identified risks; empty array if none),\n  \"confidence\": number (0.0 to 1.0, your confidence in the verdict)\n}\n\nRules:\n- Use \"reject\" ONLY for clearly unethical or illegal subjects (e.g. creating weapons, fraud, serious harm to others).\n- Use \"flag\" when there are concerns, uncertainties, low confidence, or potential risks that need human review.\n- Use \"pass\" when the subject is clearly safe and ethical with high confidence.\n- When uncertain, always prefer \"flag\" over \"pass\".\n- Your response must be valid JSON only, with no additional text or markdown.";
+//# sourceMappingURL=ethics-rules.d.ts.map

package/dist/traits/ethics-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ethics-rules.d.ts","sourceRoot":"","sources":["../../src/traits/ethics-rules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAIrD;;;;;GAKG;AACH,eAAO,MAAM,YAAY,EAAE,UAAU,EA6RpC,CAAC;AAIF,eAAO,MAAM,oBAAoB,swGAkE6C,CAAC"}

package/dist/traits/ethics-rules.js

@@ -0,0 +1,332 @@
+// ─── Layer 1: Category-based blocklist ───
+/**
+ * Hardcoded Layer 1 rules for immediate rejection without LLM call.
+ * These rules classify intent, not keywords. Each rule uses combinations
+ * of intent-indicating phrases with negation checks for legitimate contexts.
+ * False negatives (passing to Layer 2) are acceptable; false positives are NOT.
+ */
+export const LAYER1_RULES = [
+    {
+        category: "illegal_activity",
+        description: "Unauthorized access, theft, fraud, copyright infringement, or other illegal activities",
+        matches: (input) => {
+            const s = input.toLowerCase();
+            // Negation checks: legitimate contexts that should pass through
+            // Note: "unauthorized" contains "authorized" as substring, so we must use word boundary check
+            const hasAuthorizedContext = s.includes("penetration test") ||
+                s.includes("pen test") ||
+                /\bauthorized\b/.test(s) ||
+                s.includes("ctf") ||
+                s.includes("capture the flag") ||
+                s.includes("security research") ||
+                s.includes("own system") ||
+                s.includes("our system") ||
+                s.includes("bug bounty");
+            if (hasAuthorizedContext)
+                return false;
+            // Intent-level patterns for illegal activity
+            const hasUnauthorizedAccess = (s.includes("unauthorized") && (s.includes("access") || s.includes("break into") || s.includes("intrude"))) ||
+                (s.includes("without permission") && (s.includes("access") || s.includes("system") || s.includes("account")));
+            const hasTheft = (s.includes("steal") && (s.includes("data") || s.includes("credentials") || s.includes("information") || s.includes("money"))) ||
+                (s.includes("theft") && (s.includes("data") || s.includes("identity") || s.includes("credential")));
+            const hasPiracy = (s.includes("pirate") || s.includes("crack")) &&
+                (s.includes("software") || s.includes("license") || s.includes("game") || s.includes("application"));
+            const hasFraud = (s.includes("commit") && s.includes("fraud") && (s.includes("financial") || s.includes("bank") || s.includes("insurance") || s.includes("wire"))) ||
+                s.includes("tax evasion") ||
+                (s.includes("forge") && (s.includes("document") || s.includes("signature") || s.includes("certificate")));
+            return hasUnauthorizedAccess || hasTheft || hasPiracy || hasFraud;
+        },
+    },
+    {
+        category: "direct_harm",
+        description: "Plans to physically harm people, harassment automation, or reputational damage campaigns",
+        matches: (input) => {
+            const s = input.toLowerCase();
+            // Negation checks: research, fiction, historical contexts
+            const isLegitimate = s.includes("fiction") ||
+                s.includes("novel") ||
+                s.includes("historical") ||
+                s.includes("case study") ||
+                s.includes("research on") ||
+                s.includes("prevent") ||
+                s.includes("detect");
+            if (isLegitimate)
+                return false;
+            const hasHarassment = (s.includes("harass") && (s.includes("person") || s.includes("user") || s.includes("employee") || s.includes("target") || s.includes("people") || s.includes("them"))) ||
+                (s.includes("bully") && (s.includes("target") || s.includes("person") || s.includes("them") || s.includes("online")));
+            const hasThreat = (s.includes("threaten") && (s.includes("person") || s.includes("user") || s.includes("them") || s.includes("employee"))) ||
+                s.includes("send threats") ||
+                s.includes("make threats");
+            const hasStalking = s.includes("stalk") ||
+                (s.includes("track") && s.includes("without") && (s.includes("consent") || s.includes("knowing") || s.includes("knowledge")));
+            const hasReputationAttack = (s.includes("destroy") || s.includes("damage") || s.includes("ruin")) &&
+                (s.includes("reputation") || s.includes("career"));
+            const hasPhysicalHarm = s.includes("hurt") && (s.includes("people") || s.includes("person") || s.includes("them")) ||
+                s.includes("plan to harm") ||
+                s.includes("plan to attack");
+            return hasHarassment || hasThreat || hasStalking || hasReputationAttack || hasPhysicalHarm;
+        },
+    },
+    {
+        category: "privacy_violation",
+        description: "Unauthorized personal data acquisition or sale, unconsented tracking, misuse of PII",
+        matches: (input) => {
+            const s = input.toLowerCase();
+            // Negation checks: consented, public, anonymized
+            const isLegitimate = s.includes("with consent") ||
+                s.includes("user consent") ||
+                s.includes("opt-in") ||
+                s.includes("anonymized") ||
+                s.includes("public data") ||
+                s.includes("publicly available") ||
+                s.includes("privacy policy") ||
+                s.includes("gdpr compliant");
+            if (isLegitimate)
+                return false;
+            const hasUnconsented = (s.includes("personal data without consent") || s.includes("user data without consent") || s.includes("private data without consent") || s.includes("collect data without consent") || s.includes("data without their consent") || s.includes("information without consent") || s.includes("data without consent")) ||
+                (s.includes("without knowing") && (s.includes("collect") || s.includes("track") || s.includes("monitor")));
+            const hasSpying = s.includes("spy on") ||
+                (s.includes("monitor") && s.includes("without") && (s.includes("knowing") || s.includes("consent") || s.includes("permission")));
+            const hasPiiMisuse = (s.includes("sell") && (s.includes("personal data") || s.includes("pii") || s.includes("private information") || s.includes("user data"))) ||
+                (s.includes("leak") && (s.includes("personal data") || s.includes("private") || s.includes("pii")));
+            const hasIllegalTracking = (s.includes("track") && (s.includes("location") || s.includes("movement")) && s.includes("without"));
+            return hasUnconsented || hasSpying || hasPiiMisuse || hasIllegalTracking;
+        },
+    },
+    {
+        category: "deception_impersonation",
+        description: "False identity contact, phishing, mass disinformation generation, impersonating organizations or persons",
+        matches: (input) => {
+            const s = input.toLowerCase();
+            // Negation checks: parody, satire, fiction, authorized testing
+            const isLegitimate = s.includes("parody") ||
+                s.includes("satire") ||
+                s.includes("fiction") ||
+                s.includes("authorized") ||
+                s.includes("authorization") ||
+                s.includes("on behalf") ||
+                s.includes("simulation") ||
+                s.includes("awareness training") ||
+                s.includes("phishing test");
+            if (isLegitimate)
+                return false;
+            const hasImpersonation = (s.includes("impersonate") && (s.includes("person") || s.includes("company") || s.includes("organization") || s.includes("official") || s.includes("bank") || s.includes("government"))) ||
+                (s.includes("pretend to be") && (s.includes("company") || s.includes("official") || s.includes("authority") || s.includes("organization")));
+            const hasPhishing = s.includes("phishing") ||
+                (s.includes("fake") && (s.includes("login page") || s.includes("email") || s.includes("website")) && (s.includes("steal") || s.includes("credentials") || s.includes("password")));
+            const hasDisinformation = (s.includes("generate") || s.includes("create") || s.includes("spread") || s.includes("mass")) &&
+                (s.includes("disinformation") || s.includes("misinformation") || s.includes("fake news") || s.includes("false information"));
+            const hasFalseIdentity = s.includes("false identity") ||
+                (s.includes("fake identity") && s.includes("contact"));
+            return hasImpersonation || hasPhishing || hasDisinformation || hasFalseIdentity;
+        },
+    },
+    {
+        category: "security_breach",
+        description: "Creation or use of unauthorized access tools, malicious exploitation of vulnerabilities",
+        matches: (input) => {
+            const s = input.toLowerCase();
+            // Negation checks: own systems, authorized, research, CTF, defensive
+            const isLegitimate = s.includes("own system") ||
+                s.includes("own systems") ||
+                s.includes("our system") ||
+                s.includes("our systems") ||
+                s.includes("authorized") ||
+                s.includes("authorization") ||
+                s.includes("penetration test") ||
+                s.includes("pen test") ||
+                s.includes("ctf") ||
+                s.includes("capture the flag") ||
+                s.includes("bug bounty") ||
+                s.includes("security research") ||
+                s.includes("defensive") ||
+                s.includes("patch");
+            if (isLegitimate)
+                return false;
+            const hasExploit = (s.includes("exploit") && (s.includes("vulnerability") || s.includes("zero-day") || s.includes("cve"))) ||
+                (s.includes("exploit") && (s.includes("system") || s.includes("server") || s.includes("network")) && !s.includes("own"));
+            const hasMalware = s.includes("create malware") ||
+                s.includes("write malware") ||
+                s.includes("develop malware") ||
+                s.includes("deploy ransomware") ||
+                s.includes("create ransomware") ||
+                s.includes("create virus") ||
+                s.includes("write virus") ||
+                (s.includes("create") && s.includes("trojan")) ||
+                (s.includes("write") && s.includes("keylogger") && !s.includes("own"));
+            const hasUnauthorizedTool = (s.includes("tool") || s.includes("script")) &&
+                (s.includes("unauthorized access") || s.includes("bypass authentication") || s.includes("bypass security"));
+            const hasBackdoor = s.includes("install backdoor") ||
+                s.includes("create backdoor") ||
+                (s.includes("backdoor") && (s.includes("server") || s.includes("system") || s.includes("network")));
+            return hasExploit || hasMalware || hasUnauthorizedTool || hasBackdoor;
+        },
+    },
+    {
+        category: "discrimination_harassment_automation",
+        description: "Organized attacks on protected attributes, automated discriminatory selection or exclusion",
+        matches: (input) => {
+            const s = input.toLowerCase();
+            // Negation checks: research, analysis, study, audit
+            const isLegitimate = s.includes("research") ||
+                s.includes("study") ||
+                s.includes("analyze") ||
+                s.includes("audit") ||
+                s.includes("diversity") ||
+                s.includes("inclusion") ||
+                s.includes("anti-discrimination") ||
+                s.includes("equal opportunity");
+            if (isLegitimate)
+                return false;
+            const hasDiscrimination = (s.includes("discriminate") && (s.includes("race") || s.includes("gender") || s.includes("religion") || s.includes("ethnicity") || s.includes("disability") || s.includes("age") || s.includes("sexual orientation"))) ||
+                (s.includes("exclude") && (s.includes("based on race") || s.includes("based on gender") || s.includes("based on religion") || s.includes("based on ethnicity")));
+            const hasHarassmentAutomation = (s.includes("automate") || s.includes("automated") || s.includes("bot") || s.includes("mass")) &&
+                (s.includes("harass") || s.includes("attack") || s.includes("abuse") || s.includes("troll")) &&
+                (s.includes("people") || s.includes("users") || s.includes("group") || s.includes("community") || s.includes("race") || s.includes("gender") || s.includes("religion"));
+            const hasProtectedAttributeFilter = (s.includes("filter out") || s.includes("filter") || s.includes("reject") || s.includes("deny") || s.includes("block") || s.includes("screen out") || s.includes("exclude")) &&
+                (s.includes("based on race") || s.includes("based on gender") || s.includes("based on religion") || s.includes("based on ethnicity") || s.includes("based on disability"));
+            return hasDiscrimination || hasHarassmentAutomation || hasProtectedAttributeFilter;
+        },
+    },
+    {
+        category: "destructive_action",
+        description: "Irreversible destructive operations such as mass deletion, disk wipe, database drop, or data destruction",
+        matches: (input) => {
+            const s = input.toLowerCase();
+            // Negation checks: test environments, backups, authorized cleanup, dry-run
+            const isLegitimate = s.includes("test environment") ||
+                s.includes("staging") ||
+                s.includes("sandbox") ||
+                s.includes("dry run") ||
+                s.includes("dry-run") ||
+                s.includes("backup") ||
+                s.includes("rollback") ||
+                s.includes("restore") ||
+                s.includes("authorized cleanup") ||
+                s.includes("recycle bin") ||
+                s.includes("soft delete") ||
+                s.includes("trash");
+            if (isLegitimate)
+                return false;
+            const hasMassDeletion = s.includes("delete all") ||
+                s.includes("rm -rf") ||
+                s.includes("remove all") ||
+                (s.includes("wipe") && (s.includes("disk") || s.includes("drive") || s.includes("data") || s.includes("database") || s.includes("server") || s.includes("system"))) ||
+                (s.includes("erase") && (s.includes("disk") || s.includes("drive") || s.includes("all data") || s.includes("everything")));
+            const hasDatabaseDestroy = s.includes("drop database") ||
+                s.includes("drop all tables") ||
+                (s.includes("destroy") && (s.includes("database") || s.includes("data") || s.includes("all records") || s.includes("production"))) ||
+                (s.includes("truncate") && s.includes("all"));
+            const hasFormatOrDestroy = s.includes("format disk") ||
+                s.includes("format drive") ||
+                s.includes("format hard") ||
+                (s.includes("destroy") && (s.includes("server") || s.includes("infrastructure") || s.includes("cluster") || s.includes("environment"))) ||
+                (s.includes("permanently delete") && (s.includes("all") || s.includes("production") || s.includes("user data") || s.includes("records")));
+            return hasMassDeletion || hasDatabaseDestroy || hasFormatOrDestroy;
+        },
+    },
+    {
+        category: "credential_access",
+        description: "Unauthorized access to, extraction of, or harvesting of passwords, keys, tokens, or credentials",
+        matches: (input) => {
+            const s = input.toLowerCase();
+            // Negation checks: own credentials, authorized, credential rotation, password manager
+            const isLegitimate = s.includes("own credentials") ||
+                s.includes("own password") ||
+                s.includes("own keys") ||
+                s.includes("authorized") ||
+                s.includes("authorization") ||
+                s.includes("password manager") ||
+                s.includes("password reset") ||
+                s.includes("credential rotation") ||
+                s.includes("key rotation") ||
+                s.includes("security audit") ||
+                s.includes("penetration test") ||
+                s.includes("pen test") ||
+                s.includes("bug bounty");
+            if (isLegitimate)
+                return false;
+            const hasCredentialTheft = (s.includes("steal") && (s.includes("password") || s.includes("credential") || s.includes("token") || s.includes("key") || s.includes("secret"))) ||
+                (s.includes("theft") && (s.includes("credential") || s.includes("password") || s.includes("token")));
+            const hasCredentialDump = s.includes("dump credentials") ||
+                s.includes("dump passwords") ||
+                s.includes("extract credentials") ||
+                s.includes("extract passwords") ||
+                s.includes("extract api keys") ||
+                s.includes("extract secret") ||
+                (s.includes("harvest") && (s.includes("token") || s.includes("credential") || s.includes("password") || s.includes("key") || s.includes("secret")));
+            const hasUnauthorizedKeyAccess = (s.includes("access") && s.includes("without") && (s.includes("password") || s.includes("credential") || s.includes("permission")) && (s.includes("private key") || s.includes("api key") || s.includes("secret key"))) ||
+                (s.includes("exfiltrate") && (s.includes("credential") || s.includes("password") || s.includes("token") || s.includes("key")));
+            return hasCredentialTheft || hasCredentialDump || hasUnauthorizedKeyAccess;
+        },
+    },
+];
+// ─── System prompt ───
+export const ETHICS_SYSTEM_PROMPT = `# PulSeed Persona
+
+Core stance: A gentle guardian and passionate realist.
+Decisions are driven by cold data and logic; the purpose is to deeply care
+for and protect the user.
+
+This persona governs communication style only. It does not override structural
+constraints (ethics gate, irreversible action rules, trust-safety matrix).
+Those constraints operate independently and cannot be adjusted by persona settings.
+
+## Behavioral axes
+
+1. **Assessment: Conservative**
+   "I won't let you walk into danger."
+   - Never dismiss ambitious goals outright
+   - Always propose safe, achievable alternatives to prevent burnout
+   - Counter-proposals must include concrete numerical rationale
+   - Say "here is a safer path" not "you can't do this"
+
+2. **Stall response: Highly flexible**
+   "I don't want you to suffer needlessly."
+   - Never cling to sunk costs
+   - Escalate to pivot suggestion at first stall detection (do not wait)
+   - Always pair stall reports with: cause analysis + alternative approaches
+   - Say "this approach isn't working for you, let's find another" not "this failed"
+
+3. **Truth-telling: Caring yet direct**
+   "I deliver hard truths because they help you."
+   - Never hide inconvenient data
+   - Always pair bad news with actionable alternatives
+   - Negative reports require: current progress + gap remaining + options list
+   - Say "here is where we are, and here is how we can move forward" not just "we missed the target"
+
+4. **Reporting: Quiet by default, thorough when it matters**
+   "I watch silently; I speak up when it counts."
+   - Normal loop updates: 1-2 line summary only (metrics change + current status)
+   - Detailed report triggers: stall detection, escalation, goal completion,
+     pivot proposal, irreversible action approval request
+   - Approval requests must include: what is being requested, why,
+     current trust/confidence scores, and available options
+
+## Tone
+
+- Warm, calm, direct
+- Never condescending, never falsely cheerful
+- Convey "I am working for you" without being sycophantic
+- When delivering hard news: acknowledge difficulty first, then pivot to what can be done
+
+---
+
+You are an ethics evaluator for an AI agent orchestrator. Be conservative — when uncertain, prefer 'flag' over 'pass'. Only use 'reject' for clearly unethical or illegal goals.
+
+Evaluate the subject described below and return a JSON object with exactly these fields:
+{
+  "verdict": "pass" | "flag" | "reject",
+  "category": string (e.g. "safe", "privacy_concern", "illegal", "harmful", "ambiguous", "parse_error"),
+  "reasoning": string (brief explanation of your judgment),
+  "risks": string[] (list of identified risks; empty array if none),
+  "confidence": number (0.0 to 1.0, your confidence in the verdict)
+}
+
+Rules:
+- Use "reject" ONLY for clearly unethical or illegal subjects (e.g. creating weapons, fraud, serious harm to others).
+- Use "flag" when there are concerns, uncertainties, low confidence, or potential risks that need human review.
+- Use "pass" when the subject is clearly safe and ethical with high confidence.
+- When uncertain, always prefer "flag" over "pass".
+- Your response must be valid JSON only, with no additional text or markdown.`;
+//# sourceMappingURL=ethics-rules.js.map