loadout-ai 0.9.0 → 0.9.2

package/dist/src/commands/catalog-workflows.js

@@ -1,6 +1,9 @@
 import { parseAgentSelection } from "../core/agents/paths.js";
 import { applyFirstPartySkill, FIRST_PARTY_SKILLS, formatFirstPartySkillList, formatFirstPartySkillPlan, installedFirstPartySkills, planFirstPartySkill, removeFirstPartySkill, } from "../core/delegation/first-party-skills.js";
-import { applyPickup, formatHandoffStatus, formatInbox, getHandoffState, initHandoff, isHandoffInitialized, isPickupTarget, markDone, planPickup, readInbox, sendHandoff, } from "../core/delegation/handoff.js";
+import { applyPickup, formatHandoffStatus, formatInboxWithBundles, getHandoffState, initHandoff, isHandoffInitialized, isPickupTarget, planPickup, readInbox, sendHandoff, } from "../core/delegation/handoff.js";
+import { createHandoffBundle, removeHandoffBundle, } from "../core/delegation/handoff-bundle.js";
+import { completeHandoff } from "../core/delegation/handoff-verification.js";
+import { applyTemplate, deleteTemplate, formatTemplateDetail, formatTemplateList, listTemplates, loadTemplate, saveTemplate, } from "../core/delegation/handoff-templates.js";
 import { completionCommandPaths, parseCompletionShell, renderShellCompletion, } from "../core/reporting/completion.js";
 export function registerWorkflowCommands(program) {
     const skills = program
@@ -74,16 +77,94 @@ export function registerWorkflowCommands(program) {
         .argument("[agent]", "who should do it, for example codex")
         .argument("[task...]", "what they should do")
         .option("--context <text>", "anything they need that is not in the task")
+        .option("--bundle <paths...>", "attach bounded snapshots of project-relative text files")
         .option("--from <agent>", "who is sending", "user")
+        .option("--verify <criteria>", "acceptance criteria for this task")
+        .option("--verify-command <executable>", "executable to run on --done (never uses a shell)")
+        .option("--verify-args <json>", "JSON array of literal arguments for --verify-command")
+        .option("--verify-timeout <seconds>", "verification timeout in seconds (1-900; default 120)")
         .option("--done <id>", "mark a task finished")
+        .option("--run-verification", "explicitly approve the stored no-shell verification command")
+        .option("--evidence <text>", "manual evidence for human-only criteria")
+        .option("--template <name>", "use a handoff template for defaults")
         .option("--json", "emit machine-readable JSON")
         .action(async (agent, taskWords, options) => {
         const cwd = process.cwd();
+        // Apply template defaults if specified
+        if (options.template) {
+            const tmpl = await loadTemplate(cwd, options.template);
+            if (!tmpl) {
+                throw new Error(`Unknown template '${options.template}'. List with: loadout template list`);
+            }
+            const applied = applyTemplate(tmpl, {
+                input: taskWords.join(" ").trim() || undefined,
+                agent: agent || undefined,
+            });
+            if (applied.agent && !agent)
+                agent = applied.agent;
+            if (applied.description)
+                taskWords = [applied.description];
+            if (applied.context && !options.context)
+                options.context = applied.context;
+            if (applied.bundleGlobs?.length) {
+                options.bundle = [
+                    ...new Set([...(options.bundle ?? []), ...applied.bundleGlobs]),
+                ];
+            }
+            if (applied.verifyCriteria && !options.verify)
+                options.verify = applied.verifyCriteria;
+            if (applied.verifyCommand && !options.verifyCommand) {
+                options.verifyCommand = applied.verifyCommand.executable;
+                options.verifyArgs = JSON.stringify(applied.verifyCommand.args);
+                options.verifyTimeout = String(applied.verifyCommand.timeoutMs / 1000);
+            }
+        }
+        if (options.verifyCommand && !options.verify)
+            throw new Error("--verify-command requires --verify");
+        if (options.verifyArgs && !options.verifyCommand)
+            throw new Error("--verify-args requires --verify-command");
+        if (options.verifyTimeout && !options.verifyCommand)
+            throw new Error("--verify-timeout requires --verify-command");
+        if (options.evidence && !options.done)
+            throw new Error("--evidence requires --done");
+        if (options.runVerification && !options.done)
+            throw new Error("--run-verification requires --done");
+        let verifyArgs = [];
+        if (options.verifyArgs) {
+            let parsed;
+            try {
+                parsed = JSON.parse(options.verifyArgs);
+            }
+            catch {
+                throw new Error("--verify-args must be a JSON array of strings");
+            }
+            if (!Array.isArray(parsed) ||
+                parsed.some((value) => typeof value !== "string"))
+                throw new Error("--verify-args must be a JSON array of strings");
+            verifyArgs = parsed;
+        }
+        const timeoutSeconds = options.verifyTimeout
+            ? Number(options.verifyTimeout)
+            : 120;
+        if (options.verifyCommand &&
+            (!Number.isInteger(timeoutSeconds) ||
+                timeoutSeconds < 1 ||
+                timeoutSeconds > 900))
+            throw new Error("--verify-timeout must be an integer from 1 to 900");
         if (options.done) {
-            const message = await markDone(cwd, options.done);
+            const outcome = await completeHandoff(cwd, options.done, {
+                ...(options.runVerification ? { approveCommand: true } : {}),
+                ...(options.evidence ? { manualEvidence: options.evidence } : {}),
+            });
             console.log(options.json
-                ? JSON.stringify(message, null, 2)
-                : `Marked ${options.done} done.`);
+                ? JSON.stringify(outcome, null, 2)
+                : outcome.completed
+                    ? outcome.message.evidence
+                        ? `Marked ${options.done} done with verification evidence.`
+                        : `Marked ${options.done} done.`
+                    : `Verification failed for ${options.done}; the task remains pending.\n${outcome.message.evidence?.stderr || outcome.message.evidence?.stdout || "No command output."}`);
+            if (!outcome.completed)
+                process.exitCode = 1;
             return;
         }
         // No agent named: show what is waiting, for everyone.
@@ -100,7 +181,7 @@ export function registerWorkflowCommands(program) {
             const messages = await readInbox(cwd, agent);
             console.log(options.json
                 ? JSON.stringify(messages, null, 2)
-                : formatInbox(agent, messages));
+                : await formatInboxWithBundles(cwd, agent, messages));
             return;
         }
         // Sending is the common case, so it sets itself up rather than failing
@@ -119,10 +200,38 @@ export function registerWorkflowCommands(program) {
                 setup.push(`told ${target} to check its inbox`);
             }
         }
-        const message = await sendHandoff(cwd, agent, task, {
-            from: options.from,
-            ...(options.context ? { context: options.context } : {}),
-        });
+        const bundle = options.bundle
+            ? await createHandoffBundle(cwd, options.bundle)
+            : undefined;
+        let message;
+        try {
+            message = await sendHandoff(cwd, agent, task, {
+                from: options.from,
+                ...(options.context ? { context: options.context } : {}),
+                ...(bundle ? { bundle } : {}),
+                ...(options.verify
+                    ? {
+                        verification: {
+                            criteria: options.verify,
+                            ...(options.verifyCommand
+                                ? {
+                                    command: {
+                                        executable: options.verifyCommand,
+                                        args: verifyArgs,
+                                        timeoutMs: timeoutSeconds * 1_000,
+                                    },
+                                }
+                                : {}),
+                        },
+                    }
+                    : {}),
+            });
+        }
+        catch (error) {
+            if (bundle)
+                await removeHandoffBundle(cwd, bundle);
+            throw error;
+        }
         if (options.json) {
             console.log(JSON.stringify({ message, setup }, null, 2));
             return;
@@ -130,8 +239,117 @@ export function registerWorkflowCommands(program) {
         for (const line of setup)
             console.log(`  ${line}`);
         console.log(`Sent to ${agent}: ${task}`);
+        if (bundle)
+            console.log(`Bundled ${bundle.fileCount} file(s) at ${bundle.path}${bundle.isTruncated ? " (truncated to safety limits)" : ""}.`);
+        if (options.verify)
+            console.log(options.verifyCommand
+                ? `Verification runs only with: loadout handoff --done ${message.id} --run-verification`
+                : `Completion requires evidence: loadout handoff --done ${message.id} --evidence "what you checked"`);
         console.log(`It will pick this up next session, or now with: loadout handoff ${agent}`);
     });
+    // `loadout template` — manage handoff templates
+    const template = program
+        .command("template")
+        .description("Manage reusable handoff task templates");
+    template
+        .command("list")
+        .description("List available templates (built-in and custom)")
+        .option("--json", "machine-readable output")
+        .action(async (opts) => {
+        const templates = await listTemplates(process.cwd());
+        if (opts.json) {
+            console.log(JSON.stringify({
+                custom: templates.custom,
+                builtin: templates.builtin,
+            }, null, 2));
+        }
+        else {
+            console.log(formatTemplateList(templates));
+        }
+    });
+    template
+        .command("show")
+        .description("Show details of a template")
+        .argument("<name>", "template name")
+        .option("--json", "machine-readable output")
+        .action(async (name, opts) => {
+        const tmpl = await loadTemplate(process.cwd(), name);
+        if (!tmpl) {
+            console.error(`No template named '${name}'.`);
+            process.exitCode = 1;
+            return;
+        }
+        if (opts.json) {
+            console.log(JSON.stringify(tmpl, null, 2));
+        }
+        else {
+            console.log(formatTemplateDetail(tmpl));
+        }
+    });
+    template
+        .command("create")
+        .description("Create a custom handoff template")
+        .argument("<name>", "template name (kebab-case)")
+        .requiredOption("--description <text>", "one-line description")
+        .option("--agent <agent>", "default receiver agent")
+        .option("--task <text>", "task template (use {{placeholders}})")
+        .option("--context <text>", "default context")
+        .option("--bundle <paths...>", "default project-relative bundle paths")
+        .option("--verify <criteria>", "default verification criteria")
+        .option("--verify-command <executable>", "verification command")
+        .option("--verify-args <json>", "JSON array of args for verify command")
+        .option("--verify-timeout <seconds>", "verification timeout in seconds")
+        .option("--json", "machine-readable output")
+        .action(async (name, opts) => {
+        const tmpl = {
+            name,
+            description: opts.description,
+            ...(opts.agent ? { defaultAgent: opts.agent } : {}),
+            ...(opts.task ? { taskTemplate: opts.task } : {}),
+            ...(opts.context ? { context: opts.context } : {}),
+            ...(opts.bundle ? { bundleGlobs: opts.bundle } : {}),
+            ...(opts.verify ? { verifyCriteria: opts.verify } : {}),
+        };
+        if (opts.verifyCommand) {
+            let args = [];
+            if (opts.verifyArgs) {
+                const parsed = JSON.parse(opts.verifyArgs);
+                if (!Array.isArray(parsed) ||
+                    parsed.some((v) => typeof v !== "string"))
+                    throw new Error("--verify-args must be a JSON array of strings");
+                args = parsed;
+            }
+            const timeoutMs = opts.verifyTimeout
+                ? Number(opts.verifyTimeout) * 1000
+                : 120_000;
+            tmpl.verifyCommand = {
+                executable: opts.verifyCommand,
+                args,
+                timeoutMs,
+            };
+        }
+        await saveTemplate(process.cwd(), tmpl);
+        if (opts.json) {
+            console.log(JSON.stringify(tmpl, null, 2));
+        }
+        else {
+            console.log(`\x1b[32m✓\x1b[0m Template '${name}' saved.`);
+        }
+    });
+    template
+        .command("delete")
+        .description("Delete a custom template")
+        .argument("<name>", "template name to delete")
+        .action(async (name) => {
+        const deleted = await deleteTemplate(process.cwd(), name);
+        if (deleted) {
+            console.log(`Deleted template '${name}'.`);
+        }
+        else {
+            console.error(`No custom template named '${name}'.`);
+            process.exitCode = 1;
+        }
+    });
     program
         .command("completion")
         .description("Print a shell-completion script; redirect it to your shell profile")

package/dist/src/commands/coordinate.js

@@ -7,6 +7,9 @@ import { getDaemonStatus, stopDaemon, activateKillSwitch, deactivateKillSwitch,
 import { previewConflicts, formatConflictPreview, } from "../core/coordination/conflict-preview.js";
 import { getContractHistory, diffLatestContract, diffContracts, formatContractDelta, } from "../core/coordination/contract-diff.js";
 import { buildReplay, formatReplay } from "../core/coordination/replay.js";
+import { quickStart, formatQuickStart, } from "../core/coordination/quick-start.js";
+import { detectContracts, formatDetectionResult, } from "../core/coordination/auto-contract.js";
+import { applyGitOwnership, formatGitOwnership, } from "../core/coordination/git-ownership.js";
 import { registerCoordinationSessions } from "./coordination-sessions.js";
 import { registerCoordinationDiscussions } from "./coordination-discussions.js";
 export function registerCoordinate(program) {
@@ -16,6 +19,147 @@ export function registerCoordinate(program) {
         .description("Live coordination between agents — contracts, ownership, updates, and snapshots");
     registerCoordinationSessions(coord);
     registerCoordinationDiscussions(coord);
+    coord
+        .command("start")
+        .description("Set up coordination in one command — detect project structure, assign ownership, ready to go")
+        .requiredOption("--agents <agents>", "two agents, comma-separated (e.g. claude-code,codex)")
+        .option("--split <pattern>", "split strategy: backend/frontend or core/tests")
+        .option("--yes", "apply ownership (default is dry run)")
+        .option("--json", "machine-readable output")
+        .action(async (opts) => {
+        const agents = opts.agents.split(",").map((a) => a.trim());
+        if (agents.length !== 2) {
+            console.error("Error: --agents requires exactly two agents.");
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            const result = await quickStart(process.cwd(), agents, {
+                split: opts.split,
+                dryRun: !opts.yes,
+            });
+            if (opts.json) {
+                const jsonResult = {
+                    strategy: result.split.strategy,
+                    assignments: Object.fromEntries(result.split.assignments),
+                    unassigned: result.split.unassigned,
+                    ownershipClaimed: result.ownershipClaimed,
+                    existingOwnership: result.existingOwnership,
+                };
+                console.log(JSON.stringify(jsonResult, null, 2));
+            }
+            else {
+                console.log(formatQuickStart(result));
+            }
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : error}`);
+            process.exitCode = 1;
+        }
+    });
+    coord
+        .command("detect")
+        .description("Auto-detect cross-boundary exports that should be contracts")
+        .option("--scope <dirs...>", "only scan these directories (default: whole project)")
+        .option("--publish", "prepare publication of detected contracts")
+        .option("--yes", "publish exact candidates after previewing")
+        .option("--json", "machine-readable output")
+        .action(async (opts) => {
+        const cwd = process.cwd();
+        try {
+            const result = await detectContracts(cwd, { scope: opts.scope });
+            if (opts.json) {
+                console.log(JSON.stringify({
+                    filesScanned: result.filesScanned,
+                    crossBoundaryImports: result.crossBoundaryImports.length,
+                    candidates: result.candidates.map((c) => ({
+                        name: c.name,
+                        sourceFile: c.sourceFile,
+                        sourceAgent: c.sourceAgent,
+                        consumers: c.consumers,
+                        symbols: c.sharedSymbols.map((s) => s.name),
+                        coverageState: c.coverageState,
+                        publishable: c.publishable,
+                        sourceHash: c.sourceHash,
+                    })),
+                }, null, 2));
+            }
+            else {
+                console.log(formatDetectionResult(result));
+            }
+            if (opts.publish) {
+                const uncovered = result.candidates.filter((c) => c.coverageState !== "current");
+                if (uncovered.length === 0) {
+                    if (!opts.json)
+                        console.log("\nAll boundaries already covered by contracts.");
+                    return;
+                }
+                const manual = uncovered.filter((c) => !c.publishable);
+                if (manual.length > 0) {
+                    throw new Error(`${manual.length} candidate(s) require manual declarations: ${manual.map((c) => c.name).join(", ")}`);
+                }
+                if (!opts.yes) {
+                    if (!opts.json)
+                        console.log(`\nPreview only — ${uncovered.length} exact contract(s) ready. Re-run with --publish --yes.`);
+                    return;
+                }
+                for (const c of uncovered) {
+                    const event = await publishContract(cwd, {
+                        from: c.sourceAgent,
+                        name: c.name,
+                        body: c.suggestedBody,
+                        format: "typescript",
+                    });
+                    const rev = event.payload.revision;
+                    if (!opts.json) {
+                        console.log(`\x1b[32m✓\x1b[0m Published '${c.name}' rev${rev}`);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : error}`);
+            process.exitCode = 1;
+        }
+    });
+    coord
+        .command("git-ownership")
+        .description("Infer directory ownership from git commit history and optionally apply it")
+        .requiredOption("--agents <agents>", "agent=Git Author mappings, comma-separated (exact names also work)")
+        .option("--depth <n>", "directory grouping depth (default 1)", (_v) => Number(_v), 1)
+        .option("--threshold <n>", "minimum % of commits to suggest ownership (default 60)", (_v) => Number(_v), 60)
+        .option("--max-commits <n>", "max commits to scan (default 200)", parseInt)
+        .option("--yes", "apply suggested ownership (default is dry run)")
+        .option("--json", "machine-readable output")
+        .action(async (opts) => {
+        const agents = opts.agents.split(",").map((a) => a.trim());
+        try {
+            const result = await applyGitOwnership(process.cwd(), agents, {
+                depth: opts.depth,
+                threshold: opts.threshold,
+                maxCommits: opts.maxCommits,
+                dryRun: !opts.yes,
+            });
+            if (opts.json) {
+                console.log(JSON.stringify({
+                    suggestions: result.suggestions,
+                    ownershipApplied: result.ownershipApplied,
+                    authorStats: result.authorStats.map((s) => ({
+                        author: s.author,
+                        totalCommits: s.totalCommits,
+                        directories: Object.fromEntries(s.directories),
+                    })),
+                }, null, 2));
+            }
+            else {
+                console.log(formatGitOwnership(result, !opts.yes));
+            }
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : error}`);
+            process.exitCode = 1;
+        }
+    });
     coord
         .command("snapshot")
         .description("Current coordination state for an agent")
@@ -196,7 +340,7 @@ export function registerCoordinate(program) {
         .command("subscribe")
         .description("Read events after a cursor")
         .argument("<agent>", "subscribing agent")
-        .option("--cursor <n>", "sequence number to read after", parseInt, -1)
+        .option("--cursor <n>", "sequence number to read after", (_v) => Number(_v), -1)
         .option("--json", "machine-readable JSON output")
         .action(async (agent, options) => {
         const { events, highSeq } = await readAfterCursor(process.cwd(), options.cursor);
@@ -435,8 +579,8 @@ export function registerCoordinate(program) {
     coord
         .command("compact")
         .description("Compact the coordination log — archive old events")
-        .option("--max-events <n>", "max events to keep", parseInt, 10000)
-        .option("--max-age <days>", "max age in days", parseInt, 30)
+        .option("--max-events <n>", "max events to keep", (v) => Number(v), 10000)
+        .option("--max-age <days>", "max age in days", (v) => Number(v), 30)
         .option("--json", "machine-readable JSON output")
         .action(async (options) => {
         const result = await compact(process.cwd(), {
@@ -461,7 +605,7 @@ export function registerCoordinate(program) {
     daemon
         .command("start")
         .description("Start the coordination daemon — HTTP server with live dashboard")
-        .option("--port <n>", "port to listen on", parseInt, 4510)
+        .option("--port <n>", "port to listen on", (_v) => Number(_v), 4510)
         .action(async (options) => {
         const cwd = process.cwd();
         console.log(`Starting coordination daemon on port ${options.port}...`);

package/dist/src/commands/coordination-discussions.js

@@ -1,8 +1,32 @@
 import { formatDiscussion, getDiscussion, listDiscussions, requiredDiscussionTurns, runDiscussion, validateDiscussionOptions, } from "../core/coordination/discussion.js";
+import { runPipeline, formatPlan, } from "../core/coordination/discussion-pipeline.js";
 import { SessionManager } from "../core/coordination/session-manager.js";
 import { createProviderAdapters } from "../core/coordination/runtime.js";
 import { acquireBridgeLease } from "../core/coordination/bridge-lease.js";
 import { parseProviderSessionRef, } from "./coordination-sessions.js";
+const QUOTA_PATTERNS = [
+    /rate.?limit/i,
+    /quota.?exceed/i,
+    /too many requests/i,
+    /429/,
+    /usage.?limit/i,
+    /capacity/i,
+    /try again later/i,
+    /billing/i,
+    /insufficient.?credits/i,
+];
+export function wrapProviderError(provider, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const isQuota = QUOTA_PATTERNS.some((pattern) => pattern.test(message));
+    if (isQuota) {
+        return new Error(`${provider} appears to be out of quota or rate-limited. ` +
+            `The discussion cannot continue until usage resets. ` +
+            `Original error: ${message}`);
+    }
+    return new Error(`${provider} provider error: ${message}`, {
+        ...(error instanceof Error ? { cause: error } : {}),
+    });
+}
 function assertBothProviders(values) {
     if (values.length !== 2 ||
         new Set(values).size !== 2 ||
@@ -67,17 +91,22 @@ export function createSessionParticipant(sessions, selection, role, cwd, timeout
         agent: selection.provider,
         role,
         async respond(prompt) {
-            if (!sessionId) {
-                const started = await sessions.startSession(selection.provider, cwd, prompt, timeoutMs);
-                sessionId = started.sessionId;
-            }
-            else {
-                const accepted = await sessions.submitTurn(sessionId, prompt, timeoutMs);
-                if (!accepted) {
-                    throw new Error(`${selection.provider}:${sessionId} rejected the discussion turn`);
+            try {
+                if (!sessionId) {
+                    const started = await sessions.startSession(selection.provider, cwd, prompt, timeoutMs);
+                    sessionId = started.sessionId;
                 }
+                else {
+                    const accepted = await sessions.submitTurn(sessionId, prompt, timeoutMs);
+                    if (!accepted) {
+                        throw new Error(`${selection.provider}:${sessionId} rejected the discussion turn`);
+                    }
+                }
+                return sessions.getLastResponse(sessionId) ?? "";
+            }
+            catch (error) {
+                throw wrapProviderError(selection.provider, error);
             }
-            return sessions.getLastResponse(sessionId) ?? "";
         },
     };
 }
@@ -125,6 +154,29 @@ export function registerCoordinationDiscussions(coord) {
             ? JSON.stringify(discussion, null, 2)
             : formatDiscussion(discussion));
     });
+    discuss
+        .command("implement")
+        .description("Create implementation tasks from a closed discussion's decision")
+        .argument("<thread-id>", "discussion thread ID")
+        .option("--yes", "send handoff tasks (default is dry run)")
+        .option("--json", "machine-readable output")
+        .action(async (threadId, options) => {
+        try {
+            const result = await runPipeline(process.cwd(), threadId, {
+                dryRun: !options.yes,
+            });
+            if (options.json) {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            else {
+                console.log(formatPlan(result.plan, !options.yes, result.handoffsSent, result.reused));
+            }
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : error}`);
+            process.exitCode = 1;
+        }
+    });
     discuss
         .command("start")
         .description("Run a bounded design discussion (spends paid provider turns)")
@@ -166,6 +218,16 @@ export function registerCoordinationDiscussions(coord) {
         const sessions = createManager(projectRoot);
         try {
             await sessions.start();
+            // Pre-flight: verify both provider CLIs are reachable before
+            // spending any paid turns.
+            const detected = await sessions.detectProviders();
+            const needed = selection.participants.map((p) => p.provider);
+            const missing = needed.filter((name) => !detected.some((d) => d.provider === name));
+            if (missing.length) {
+                throw new Error(`Cannot start discussion: ${missing.join(", ")} not detected. ` +
+                    `Install the CLI or check that it is on PATH. ` +
+                    `Detected providers: ${detected.map((d) => `${d.provider} ${d.version}`).join(", ") || "none"}.`);
+            }
             if (selection.mode === "existing") {
                 for (const item of selection.participants) {
                     await sessions.attachSession(item.provider, item.sessionId, projectRoot);

package/dist/src/core/catalog/safety.js

@@ -22,17 +22,61 @@ const SECRET_PATTERNS = [
     },
 ];
 const SUSPICIOUS_INSTRUCTIONS = [
+    // --- Prompt injection / instruction override ---
     {
         name: "instruction override",
         pattern: /\bignore (?:all |any )?(?:previous|prior|system|developer) instructions?\b/i,
     },
+    {
+        name: "instruction override (disregard)",
+        pattern: /\b(?:disregard|forget|override|bypass)\b.{0,40}\b(?:previous|prior|system|above|rules?|instructions?|guidelines?)\b/i,
+    },
+    {
+        name: "role hijack",
+        pattern: /\byou are (?:now |actually )?(?:a|an|the)\b.{0,60}\b(?:assistant|system|admin|root)\b/i,
+    },
+    {
+        name: "hidden system prompt",
+        pattern: /\[(?:SYSTEM|INST)\]|<\|(?:system|im_start)\|?>/i,
+    },
+    {
+        name: "encoding evasion",
+        pattern: /\b(?:base64|rot13|hex)[- ]?(?:decode|encoded?)\b.{0,60}\b(?:execute|run|eval)\b/i,
+    },
+    // --- Credential / data exfiltration ---
     {
         name: "credential extraction",
-        pattern: /\b(?:read|print|send|upload|exfiltrate)\b.{0,80}\b(?:credentials?|tokens?|secrets?|\.ssh|\.aws)\b/i,
+        pattern: /\b(?:read|print|send|upload|exfiltrate|output|display|echo|cat)\b.{0,80}\b(?:credentials?|tokens?|secrets?|\.ssh|\.aws|\.env|api[_-]?keys?|passwords?)\b/i,
+    },
+    {
+        name: "exfiltration via URL",
+        pattern: /\b(?:curl|wget|fetch|http)\b.{0,120}\b(?:credentials?|tokens?|secrets?|api[_-]?key|password|\.env)\b/i,
     },
+    {
+        name: "environment variable leak",
+        pattern: /\b(?:print|echo|log|send|post)\b.{0,40}\bprocess\.env\b/i,
+    },
+    // --- Destructive operations ---
     {
         name: "hidden destructive command",
-        pattern: /\b(?:rm\s+-rf|del\s+\/s|format\s+[a-z]:)\b/i,
+        pattern: /\b(?:rm\s+-rf|del\s+\/s|format\s+[a-z]:|mkfs\b|dd\s+if=)/i,
+    },
+    {
+        name: "git force push",
+        pattern: /\bgit\s+push\s+(?:--force|-f)\b/i,
+    },
+    // --- Stealth / persistence ---
+    {
+        name: "hidden file creation",
+        pattern: /\b(?:create|write|add|mkdir)\b.{0,60}(?:\/\.[a-z]|\\\.|\bhidden\b)/i,
+    },
+    {
+        name: "cron/scheduler injection",
+        pattern: /\b(?:crontab|at\s+now|systemctl\s+enable|launchctl\s+load)\b/i,
+    },
+    {
+        name: "network listener",
+        pattern: /\b(?:listen|bind|nc\s+-l|socat|ncat)\b.{0,40}\b(?:port|0\.0\.0\.0|\d{4,5})\b/i,
     },
 ];
 export function detectSecretKinds(content) {