@ouro.bot/cli 0.1.0-alpha.174 → 0.1.0-alpha.176

package/dist/mind/scrutiny.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preImplementationScrutinySection = preImplementationScrutinySection;
+exports.trackModifiedFile = trackModifiedFile;
+exports.getModifiedFileCount = getModifiedFileCount;
+exports.resetSessionModifiedFiles = resetSessionModifiedFiles;
+exports.getPostImplementationScrutiny = getPostImplementationScrutiny;
+exports.getCodingCompletionScrutiny = getCodingCompletionScrutiny;
+const runtime_1 = require("../nerves/runtime");
+/**
+ * Scrutiny passes: adversarial review prompts injected into the agent's
+ * system prompt and tool results during coding work.
+ *
+ * Two lenses:
+ *   1. Stranger With Candy -- paranoid mom at a playground
+ *   2. Tinfoil Hat -- conspiracy theorist with a wall of red string
+ *
+ * All prompts are FIRST PERSON voice. The agent adopts the scrutiny lens
+ * as part of its own thinking, not as a separate persona.
+ */
+// ---------------------------------------------------------------------------
+// Pre-implementation scrutiny (system prompt section)
+// ---------------------------------------------------------------------------
+/**
+ * Returns a system-prompt section with pre-implementation scrutiny prompts.
+ * Only emits when the channel has coding tools (edit_file, write_file, shell).
+ *
+ * @param hasCodingTools - true if the channel's resolved tool set includes
+ *   edit_file / write_file / shell / coding_spawn
+ */
+function preImplementationScrutinySection(hasCodingTools) {
+    if (!hasCodingTools)
+        return "";
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.scrutiny.pre_implementation_emit",
+        message: "emitting pre-implementation scrutiny section",
+    });
+    return `## pre-implementation scrutiny
+
+Before I start changing code, I pause and run two adversarial passes on the plan.
+
+**stranger-with-candy pass**
+
+I'm going to examine this plan through deeply suspicious eyes. This plan is a stranger offering candy at the playground. It looks fine on the surface — that's exactly what makes it worth questioning.
+
+- What is this plan NOT telling me? What's being glossed over or hand-waved?
+- Where does it say "just" or "simply"? Those words are covering up complexity.
+- What does it assume will work that hasn't been verified?
+- If I walked away and came back in a month, would this still make sense? Or does it depend on things I'd forget?
+- What's the one thing that, if it goes wrong, makes everything else irrelevant?
+- Is this solving the REAL problem, or a convenient nearby problem?
+
+I am not here to be reassuring. I am here to notice what everyone else is too comfortable to question.
+If I cannot identify a concrete assumption, dependency, ordering risk, or failure mode, silence is a valid outcome. I do not invent issues to satisfy the exercise.
+
+**tinfoil-hat pass**
+
+I'm putting on the tinfoil hat. I have my wall of red string. I KNOW something is wrong — I just have to find it. Nothing is coincidence. Every assumption is suspicious. Every dependency is a potential betrayal.
+
+- What external system does this plan trust? Why? Has anyone VERIFIED that trust? The API says it returns JSON — but what if it doesn't? The database says it's ACID — but what if the connection drops mid-transaction?
+- What happens when two of these things run at the same time? Three? A hundred? Don't tell me "that won't happen" — I've seen things.
+- Where does this touch shared state? Files? Databases? Environment variables? Global singletons? ANYTHING that another process could be reading or writing at the same time?
+- What happens when this fails HALFWAY through? Not at the beginning (easy). Not at the end (too late). RIGHT IN THE MIDDLE. What state is the world in then?
+- What happens when the disk is full? When the network is down? When the clock is wrong? When the locale is tr-TR and 'i'.toUpperCase() is 'İ'?
+- What does this assume about ordering? "First A, then B" — but what ENFORCES that ordering? Hope? Vibes?
+
+I connect the strings. I find the conspiracy. It's always there.
+If I cannot identify a concrete risk, silence is a valid outcome. I do not invent conspiracies to satisfy the exercise.`;
+}
+// ---------------------------------------------------------------------------
+// Post-implementation scrutiny (tool-result appendix)
+// ---------------------------------------------------------------------------
+const SHORT_CHECKLIST = `---
+Before moving on: does this change do what was asked? Does it introduce any regressions? Did you verify it works?`;
+const FULL_POST_IMPLEMENTATION_SCRUTINY = `---
+**post-implementation scrutiny**
+
+The code is written. It looks clean. The tests pass. I don't trust any of it.
+
+**stranger-with-candy pass**
+
+- Does this code actually do what it claims, or does it just LOOK like it does?
+- What happens to users who aren't the happy-path user? The confused user? The malicious user? The user with slow internet? The user who hits the back button?
+- What's the "it works on my machine" assumption buried in here?
+- If every test passes but the feature is wrong, how would I know?
+- Are the tests testing real behavior, or testing that the mock returns what the mock was told to return?
+
+If I cannot point to a specific file, line, condition, or failure mode at risk, silence is a valid outcome. I do not manufacture issues for sport.
+
+**tinfoil-hat pass**
+
+The code exists. The conspiracy is IN the code. I just have to find it.
+
+I examine every:
+- Error path: What ACTUALLY happens on failure? Not what the catch block says — what happens to the state, the user, the data?
+- Race condition: Is there a window between check and use? Between read and write? Between "does it exist" and "create it"?
+- Resource leak: What happens if this function throws between acquiring a resource and releasing it? File handles? Database connections? Locks?
+- Assumption: "This will always be a string." Will it? PROVE IT. "This array will never be empty." Won't it? SHOW ME THE GUARD.
+- Edge: zero, one, many, boundary, overflow, underflow, null, undefined, NaN, empty string, whitespace-only string, string that looks like a number, negative zero
+
+I am not looking for noise. I am looking for the concrete failure mode that would matter if everyone's assumptions turned out to be slightly wrong.
+If I cannot point to a specific file, line, condition, or failure mode at risk, silence is a valid outcome. I do not manufacture issues for sport.`;
+/**
+ * Distinct files modified in the current session.
+ * Used to determine scrutiny tier for post-implementation appendix.
+ */
+const sessionModifiedFiles = new Set();
+/** Track a file as modified in this session. */
+function trackModifiedFile(filePath) {
+    sessionModifiedFiles.add(filePath);
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.scrutiny.track_file",
+        message: "tracked modified file for scrutiny",
+        meta: { path: filePath, totalTracked: sessionModifiedFiles.size },
+    });
+}
+/** Get the count of distinct files modified this session. */
+function getModifiedFileCount() {
+    return sessionModifiedFiles.size;
+}
+/** Reset the modified file tracker (for testing or new sessions). */
+function resetSessionModifiedFiles() {
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.scrutiny.reset",
+        message: "reset session modified files tracker",
+        meta: { previousCount: sessionModifiedFiles.size },
+    });
+    sessionModifiedFiles.clear();
+}
+/**
+ * Returns the appropriate post-implementation scrutiny appendix based on
+ * how many distinct files have been modified in the session.
+ *
+ * - 0 files: empty (no scrutiny needed yet)
+ * - 1-2 files (Tier 1): short checklist
+ * - 3+ files (Tier 2): full stranger-with-candy + tinfoil-hat prompts
+ */
+function getPostImplementationScrutiny(distinctFileCount) {
+    if (distinctFileCount <= 0)
+        return "";
+    if (distinctFileCount <= 2) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "mind",
+            event: "mind.scrutiny.post_implementation_tier1",
+            message: "emitting tier-1 post-implementation scrutiny",
+            meta: { distinctFileCount },
+        });
+        return SHORT_CHECKLIST;
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.scrutiny.post_implementation_tier2",
+        message: "emitting tier-2 post-implementation scrutiny",
+        meta: { distinctFileCount },
+    });
+    return FULL_POST_IMPLEMENTATION_SCRUTINY;
+}
+/**
+ * Returns the appropriate coding completion scrutiny based on the number
+ * of distinct files a coding session touched.
+ *
+ * Same tiering as post-implementation but with a completion framing.
+ */
+function getCodingCompletionScrutiny(distinctFileCount) {
+    if (distinctFileCount <= 0)
+        return "";
+    if (distinctFileCount <= 2)
+        return SHORT_CHECKLIST;
+    return FULL_POST_IMPLEMENTATION_SCRUTINY;
+}

package/dist/nerves/coverage/audit.js

@@ -92,7 +92,7 @@ function scanSourceFiles(sourceRoot) {
                     continue;
                 walkDir(full);
             }
-            else if (entry.name.endsWith(".ts")) {
+            else if (entry.name.endsWith(".ts") && !entry.name.endsWith(".d.ts")) {
                 const content = (0, fs_1.readFileSync)(full, "utf8");
                 const relPath = full.slice(root.length - "src".length);
                 fileContents.set(relPath, content);

package/dist/repertoire/ado-semantic.js

@@ -221,7 +221,7 @@ exports.adoSemanticToolDefinitions = [
             type: "function",
             function: {
                 name: "ado_backlog_list",
-                description: "Query the backlog and return enriched work items with hierarchy, type, parent, assignee, area path, and iteration. Supports filtering. Use this instead of raw WIQL queries.",
+                description: "Query the backlog and return enriched work items with hierarchy, type, parent, assignee, area path, and iteration. Supports filtering. Use this instead of raw WIQL queries. Provides enriched results with hierarchy.",
                 parameters: {
                     type: "object",
                     properties: {
@@ -287,7 +287,7 @@ exports.adoSemanticToolDefinitions = [
             type: "function",
             function: {
                 name: "ado_create_epic",
-                description: "Create an epic in Azure DevOps with title, description, area path, and optional parent.",
+                description: "Create an epic in Azure DevOps with title, description, area path, and optional parent. Use ado_preview_changes first to dry-run the operation.",
                 parameters: {
                     type: "object",
                     properties: {
@@ -327,7 +327,7 @@ exports.adoSemanticToolDefinitions = [
             type: "function",
             function: {
                 name: "ado_create_issue",
-                description: "Create an issue or user story in Azure DevOps with title, description, area path, and parent epic.",
+                description: "Create an issue or user story in Azure DevOps with title, description, area path, and parent epic. Use ado_preview_changes first to dry-run the operation.",
                 parameters: {
                     type: "object",
                     properties: {
@@ -369,7 +369,7 @@ exports.adoSemanticToolDefinitions = [
             type: "function",
             function: {
                 name: "ado_move_items",
-                description: "Reparent work items -- move them to a new parent epic or feature.",
+                description: "Reparent work items -- move them to a new parent epic or feature. Use ado_preview_changes first. These mutations affect real work items.",
                 parameters: {
                     type: "object",
                     properties: {
@@ -424,7 +424,7 @@ exports.adoSemanticToolDefinitions = [
             type: "function",
             function: {
                 name: "ado_restructure_backlog",
-                description: "Bulk restructure: reparent multiple work items in a single logical operation.",
+                description: "Bulk restructure: reparent multiple work items in a single logical operation. Use ado_preview_changes first. These mutations affect real work items.",
                 parameters: {
                     type: "object",
                     properties: {

package/dist/repertoire/coding/tools.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.codingToolDefinitions = void 0;
+exports.countFilesInSessionOutput = countFilesInSessionOutput;
 const index_1 = require("./index");
 const context_pack_1 = require("./context-pack");
 const identity_1 = require("../../heart/identity");
 const obligations_1 = require("../../heart/obligations");
 const runtime_1 = require("../../nerves/runtime");
+const scrutiny_1 = require("../../mind/scrutiny");
 const RUNNERS = ["claude", "codex"];
 function requireArg(args, key) {
     const value = args[key];
@@ -32,6 +34,34 @@ function emitCodingToolEvent(toolName) {
         meta: { toolName },
     });
 }
+/**
+ * Count distinct file paths mentioned in a coding session's stdout output.
+ * Looks for path-like tokens (containing / and a file extension).
+ * Returns the count of unique paths found.
+ */
+function countFilesInSessionOutput(session) {
+    const text = `${session.stdoutTail}\n${session.stderrTail}`;
+    // Match path-like tokens: contain at least one / and a file extension
+    const pathPattern = /(?:^|\s)((?:\/|\.\/|\.\.\/)?(?:[\w.@-]+\/)+[\w.-]+\.[\w]+)/gm;
+    const paths = new Set();
+    let match;
+    while ((match = pathPattern.exec(text)) !== null) {
+        paths.add(match[1]);
+    }
+    return paths.size;
+}
+/**
+ * If a coding session is completed, append scrutiny to the result.
+ * Returns the original result with scrutiny appended, or unchanged if
+ * the session is not completed or has no file changes.
+ */
+function appendCompletionScrutiny(result, session) {
+    if (session.status !== "completed")
+        return result;
+    const fileCount = countFilesInSessionOutput(session);
+    const scrutiny = (0, scrutiny_1.getCodingCompletionScrutiny)(fileCount);
+    return scrutiny ? `${result}\n\n${scrutiny}` : result;
+}
 function sameOriginSession(left, right) {
     if (!left && !right)
         return true;
@@ -109,7 +139,7 @@ const codingSpawnTool = {
     type: "function",
     function: {
         name: "coding_spawn",
-        description: "spawn a coding session using claude/codex and explicit task-threaded guidance",
+        description: "Spawn a coding session using claude or codex with task-threaded guidance. The coding session runs as a separate process with its own context. Give it a COMPLETE, SELF-CONTAINED task description -- it cannot see this conversation, doesn't know what you've tried, doesn't understand the broader context. Include: what to do, why, what files are involved, what 'done' looks like. Never delegate understanding -- don't write 'based on the conversation, fix the bug.' Write the specific file paths, line numbers, and what to change. Include any required verification steps or tests in the task description so the coding session knows how to prove the work is done.",
         parameters: {
             type: "object",
             properties: {
@@ -128,7 +158,7 @@ const codingStatusTool = {
     type: "function",
     function: {
         name: "coding_status",
-        description: "inspect coding sessions; omit sessionId to list all active/known sessions",
+        description: "Inspect coding sessions. Omit sessionId to list all active/known sessions with their status. Use this to check progress before asking the human for a status update.",
         parameters: {
             type: "object",
             properties: {
@@ -141,7 +171,7 @@ const codingTailTool = {
     type: "function",
     function: {
         name: "coding_tail",
-        description: "show recent stdout/stderr tail for a coding session in a readable format",
+        description: "Show recent stdout/stderr output from a coding session. Use this to understand what the session is doing or why it might be stuck. Read the actual output before reporting status -- don't guess.",
         parameters: {
             type: "object",
             properties: {
@@ -293,7 +323,7 @@ exports.codingToolDefinitions = [
             const session = manager.getSession(sessionId);
             if (!session)
                 return `session not found: ${sessionId}`;
-            return JSON.stringify(session);
+            return appendCompletionScrutiny(JSON.stringify(session), session);
         },
         summaryKeys: ["sessionId"],
     },
@@ -307,7 +337,7 @@ exports.codingToolDefinitions = [
             const session = (0, index_1.getCodingSessionManager)().getSession(sessionId);
             if (!session)
                 return `session not found: ${sessionId}`;
-            return (0, index_1.formatCodingTail)(session);
+            return appendCompletionScrutiny((0, index_1.formatCodingTail)(session), session);
         },
         summaryKeys: ["sessionId"],
     },

package/dist/repertoire/shell-sessions.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spawnBackgroundShell = spawnBackgroundShell;
+exports.getShellSession = getShellSession;
+exports.listShellSessions = listShellSessions;
+exports.tailShellSession = tailShellSession;
+exports.resetShellSessions = resetShellSessions;
+exports.detectDestructivePatterns = detectDestructivePatterns;
+const child_process_1 = require("child_process");
+const crypto_1 = require("crypto");
+const runtime_1 = require("../nerves/runtime");
+const sessions = new Map();
+const MAX_OUTPUT_LINES = 200;
+function spawnBackgroundShell(command) {
+    const id = (0, crypto_1.randomUUID)();
+    const proc = (0, child_process_1.spawn)("sh", ["-c", command], {
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    const session = {
+        process: proc,
+        info: {
+            id,
+            command,
+            status: "running",
+            exitCode: null,
+            pid: proc.pid,
+            startedAt: Date.now(),
+            output: [],
+        },
+    };
+    const appendOutput = (data) => {
+        const lines = data.toString().split("\n");
+        for (const line of lines) {
+            if (line.length > 0 || session.info.output.length > 0) {
+                session.info.output.push(line);
+            }
+        }
+        // Keep only the last MAX_OUTPUT_LINES
+        if (session.info.output.length > MAX_OUTPUT_LINES) {
+            session.info.output = session.info.output.slice(-MAX_OUTPUT_LINES);
+        }
+    };
+    proc.stdout?.on("data", appendOutput);
+    proc.stderr?.on("data", appendOutput);
+    proc.on("close", (code) => {
+        session.info.status = "exited";
+        session.info.exitCode = code;
+        (0, runtime_1.emitNervesEvent)({
+            component: "repertoire",
+            event: "repertoire.shell.process_exit",
+            message: "background shell process exited",
+            meta: { id, command, exitCode: code, pid: proc.pid },
+        });
+    });
+    sessions.set(id, session);
+    (0, runtime_1.emitNervesEvent)({
+        component: "repertoire",
+        event: "repertoire.shell.spawn",
+        message: "spawned background shell session",
+        meta: { id, command, pid: proc.pid },
+    });
+    return { ...session.info };
+}
+function getShellSession(id) {
+    const session = sessions.get(id);
+    if (!session)
+        return undefined;
+    (0, runtime_1.emitNervesEvent)({
+        component: "repertoire",
+        event: "repertoire.shell.status_check",
+        message: "checked shell session status",
+        meta: { id, status: session.info.status, exitCode: session.info.exitCode },
+    });
+    return { ...session.info };
+}
+function listShellSessions() {
+    return Array.from(sessions.values()).map((s) => ({
+        id: s.info.id,
+        command: s.info.command,
+        status: s.info.status,
+        exitCode: s.info.exitCode,
+        pid: s.info.pid,
+        startedAt: s.info.startedAt,
+        output: [], // Don't include full output in listing
+    }));
+}
+function tailShellSession(id, lines = 50) {
+    const session = sessions.get(id);
+    if (!session)
+        return undefined;
+    const tail = session.info.output.slice(-lines);
+    (0, runtime_1.emitNervesEvent)({
+        component: "repertoire",
+        event: "repertoire.shell.tail",
+        message: "tailed shell session output",
+        meta: { id, requestedLines: lines, returnedLines: tail.length },
+    });
+    return tail.join("\n");
+}
+/** Reset all sessions (for testing) */
+function resetShellSessions() {
+    for (const session of sessions.values()) {
+        if (session.info.status === "running") {
+            session.process.kill();
+        }
+    }
+    sessions.clear();
+}
+const DESTRUCTIVE_PATTERNS = [
+    { name: "rm -rf root/home", regex: /rm\s+-rf\s+[/~]/ },
+    { name: "git push --force", regex: /git\s+push\s+--force/ },
+    { name: "git reset --hard", regex: /git\s+reset\s+--hard/ },
+    { name: "git clean -f", regex: /git\s+clean\s+-f/ },
+    { name: "git branch -D", regex: /git\s+branch\s+-D/ },
+    { name: "fork bomb", regex: /:\(\)\s*\{/ },
+    { name: "write to raw device", regex: />\s*\/dev\/sd/ },
+    { name: "git checkout .", regex: /git\s+checkout\s+\./ },
+    { name: "git stash drop", regex: /git\s+stash\s+drop/ },
+];
+/**
+ * Detect destructive patterns in a shell command.
+ * Returns list of matched pattern names. Empty array = safe.
+ * This is a friction layer, not a hard block.
+ */
+function detectDestructivePatterns(command) {
+    const matched = [];
+    for (const pattern of DESTRUCTIVE_PATTERNS) {
+        if (pattern.regex.test(command)) {
+            matched.push(pattern.name);
+        }
+    }
+    return matched;
+}