@ouro.bot/cli 0.1.0-alpha.935 → 0.1.0-alpha.937

package/dist/senses/shepherd/cmux.js

@@ -132,31 +132,46 @@ function createCmuxHost(client, options = {}) {
             (0, runtime_1.emitNervesEvent)({ level: "warn", component: "senses", event: "senses.shepherd_cmux_status_error", message: "could not clear a Shepherd status", meta: { error: error.message } });
         });
     };
-    async function surfaceEntries() {
+    async function surfaceEntries(strict = false) {
         const tree = await client.call("system.tree", { all_windows: true });
-        return list(tree.windows).flatMap((window) => list(window.workspaces).map((workspace) => ({ window, workspace }))).flatMap(({ window, workspace }) => list(workspace.panes).flatMap((pane) => list(pane.surfaces)).map((surface) => ({
-            id: str(surface.id) ?? "",
-            ref: str(surface.ref) ?? "",
-            workspace: str(workspace.ref),
-            workspaceTitle: str(workspace.title),
-            workspaceId: str(workspace.id) ?? "",
-            title: str(surface.title) ?? "",
-            tty: str(surface.tty),
-            type: str(surface.type) ?? "",
-            agent: hooked.get(str(surface.id) ?? "")?.agent ?? null,
-            cwd: hooked.get(str(surface.id) ?? "")?.cwd ?? null,
-            // The human's terminal: the focused surface of the selected workspace in a visible window.
-            focused: surface.focused === true && workspace.selected === true && window.visible !== false,
-            ...(surface.focused === true && workspace.selected === true && window.visible !== false && window.key === true
-                ? { selected: true } : {}),
-        })));
+        const records = (value) => {
+            if (strict && (!Array.isArray(value) || !value.every(isRecord)))
+                throw new Error("invalid cmux terminal inventory");
+            return list(value);
+        };
+        const seen = new Set();
+        return records(tree.windows).flatMap((window) => records(window.workspaces).map((workspace) => ({ window, workspace }))).flatMap(({ window, workspace }) => records(workspace.panes).flatMap((pane) => records(pane.surfaces)).map((surface) => {
+            if (strict && (typeof surface.id !== "string" || !surface.id.trim() || typeof surface.type !== "string"
+                || !["terminal", "browser"].includes(surface.type) || seen.has(surface.id)))
+                throw new Error("invalid cmux terminal inventory identity");
+            seen.add(str(surface.id) ?? "");
+            return {
+                id: str(surface.id) ?? "",
+                ref: str(surface.ref) ?? "",
+                workspace: str(workspace.ref),
+                workspaceTitle: str(workspace.title),
+                workspaceId: str(workspace.id) ?? "",
+                title: str(surface.title) ?? "",
+                tty: str(surface.tty),
+                type: str(surface.type) ?? "",
+                agent: hooked.get(str(surface.id) ?? "")?.agent ?? null,
+                cwd: hooked.get(str(surface.id) ?? "")?.cwd ?? null,
+                // The human's terminal: the focused surface of the selected workspace in a visible window.
+                focused: surface.focused === true && workspace.selected === true && window.visible !== false,
+                ...(surface.focused === true && workspace.selected === true && window.visible !== false && window.key === true
+                    ? { selected: true } : {}),
+            };
+        }));
+    }
+    async function retirementInventory() {
+        return (await surfaceEntries(true)).filter(surface => surface.type === "terminal").map(surface => surface.id);
     }
-    async function surfaces(freshFocus = false) {
-        const entries = await surfaceEntries();
+    async function surfaces(freshFocus = false, strictInventory = false) {
+        const entries = await surfaceEntries(strictInventory);
         const identities = await (options.identifyTerminals ?? terminal_process_1.identifyTerminalProcesses)(entries.filter((entry) => entry.type === "terminal" && entry.tty).map((entry) => entry.tty));
         // Process lookup is awaited. On inspection paths, do not return focus from
         // the tree sampled before that await. A moved/rebound TTY loses authority.
-        const current = freshFocus ? await surfaceEntries() : entries;
+        const current = freshFocus ? await surfaceEntries(strictInventory) : entries;
         return current.map((entry) => {
             const bound = entries.some(before => before.id === entry.id && before.tty === entry.tty && before.workspaceId === entry.workspaceId && before.type === entry.type);
             const identity = entry.tty && bound ? identities.get(entry.tty.replace(/^\/dev\//, "")) : undefined;
@@ -216,6 +231,7 @@ function createCmuxHost(client, options = {}) {
         async list() {
             return (await surfaces()).filter((surface) => surface.type === "terminal").map(({ workspaceId: _workspaceId, type: _type, ...session }) => session);
         },
+        retirementInventory,
         read,
         inspect,
         async promptIfUnchanged(sessionId, line, expected, canSend) {
@@ -390,16 +406,40 @@ function createCmuxHost(client, options = {}) {
                     },
                 });
             };
-            /** Terminals whose agent is not idle: output that changed and then held still for the quiet window is a return. */
+            let lastObserved = [];
+            /** Inventory reads stay outside the judge queue; idle-hook terminals are observed but never rejudged here. */
             const poll = async () => {
                 try {
-                    const terminals = (await surfaces()).filter((surface) => surface.type === "terminal" && hooked.get(surface.id)?.idle !== true);
+                    const terminals = (await surfaces(false, !!handlers.observed)).filter((surface) => surface.type === "terminal");
+                    if (closed)
+                        return;
                     const seen = new Set(terminals.map((surface) => surface.id));
                     for (const id of screens.keys())
                         if (!seen.has(id))
                             screens.delete(id);
+                    const rows = [];
                     for (const surface of terminals) {
-                        const hash = (0, node_crypto_1.createHash)("sha256").update(await read(surface.id, POLL_LINES)).digest("hex");
+                        const idle = hooked.get(surface.id)?.idle === true;
+                        if (idle)
+                            screens.delete(surface.id);
+                        if (idle && !handlers.observed)
+                            continue;
+                        let text;
+                        try {
+                            text = await read(surface.id, POLL_LINES);
+                        }
+                        catch (error) {
+                            rows.push({ session: surface, activity: "unknown", observedAt: null, error: "read_failed" });
+                            (0, runtime_1.emitNervesEvent)({ level: "warn", component: "senses", event: "senses.shepherd_cmux_poll_error",
+                                message: "could not read one cmux terminal; other terminals remain observable", meta: { error: (0, redact_1.redactSecrets)(String(error)) } });
+                            continue;
+                        }
+                        if (closed)
+                            return;
+                        rows.push({ session: surface, activity: surface.agent ? (0, prompt_state_1.inspectCodingPrompt)(surface.agent, text).activity : "unknown", observedAt: now() });
+                        if (idle)
+                            continue;
+                        const hash = (0, node_crypto_1.createHash)("sha256").update(text).digest("hex");
                         const last = screens.get(surface.id);
                         const at = now();
                         if (!last)
@@ -413,9 +453,15 @@ function createCmuxHost(client, options = {}) {
                             handlers.returned({ sessionId: surface.id, transitionId: `cmux:quiet:${surface.id}:${last.changedAt}`, agent: surface.agent, cwd: surface.cwd ?? null, title: surface.title, workspaceTitle: surface.workspaceTitle, lastBody: null, backgroundWork: null });
                         }
                     }
+                    if (closed)
+                        return;
+                    lastObserved = rows;
+                    handlers.observed?.({ at: now(), sessions: rows });
                 }
                 catch (error) {
                     (0, runtime_1.emitNervesEvent)({ level: "warn", component: "senses", event: "senses.shepherd_cmux_poll_error", message: "could not poll cmux terminals; the next poll retries", meta: { error: error.message } });
+                    if (!closed)
+                        handlers.observed?.({ at: now(), sessions: lastObserved, error: "host_unavailable" });
                 }
                 if (!closed)
                     cancelPoll = schedule(() => void poll(), exports.POLL_MS);

package/dist/senses/shepherd/guidance.js

@@ -145,8 +145,8 @@ function bounded(value, name, max) {
 function knownTarget(root, target, live, record) {
     if (!validTarget(target))
         throw new Error("invalid Shepherd session target");
-    const known = record ?? [...(0, returns_1.readReturns)(root).filter(validReturn)].reverse().find(r => r.host === target.host && r.session === target.session)
-        ?? live.find(t => t.host === target.host && t.session === target.session);
+    const known = record ?? live.find(t => t.host === target.host && t.session === target.session)
+        ?? [...(0, returns_1.readReturns)(root).filter(validReturn)].reverse().find(r => r.host === target.host && r.session === target.session);
     if (!known)
         throw new Error("unknown session; no recorded or verified live Shepherd target");
     if (known.host !== target.host || known.session !== target.session || known.cwd !== target.cwd || known.task !== target.task)
@@ -191,6 +191,9 @@ async function mutate(root, op, input, apply) {
                 throw new Error("request ID was already used with a different body");
             return prior.receipt;
         }
+        if (input.expectedRevision !== undefined && (!Number.isSafeInteger(input.expectedRevision) || input.expectedRevision < 0 || input.expectedRevision !== state.revision)) {
+            throw new Error("Shepherd guidance revision conflict");
+        }
         const clean = { actorId: input.actorId, requestId: input.requestId, at: new Date().toISOString(), kind: "operator instruction", returnId: null };
         const result = apply(state, clean);
         state.revision++;

package/dist/senses/shepherd/herdr.js

@@ -114,12 +114,26 @@ function herdrRequest(socketPath, method, params, timeoutMs = TIMEOUT_MS) {
 function createHerdrHost(connection, options = {}) {
     const schedule = options.schedule ?? cmux_1.realSchedule;
     const call = (method, params) => herdrRequest(connection.socketPath, method, params);
-    async function panes() {
+    async function panes(strict = false) {
         const result = await call("pane.list", {});
+        if (strict) {
+            if (!Array.isArray(result.panes))
+                throw new Error("invalid Herdr terminal inventory");
+            const seen = new Set();
+            for (const pane of result.panes) {
+                if (!isRecord(pane) || typeof pane.pane_id !== "string" || !pane.pane_id.trim() || seen.has(pane.pane_id)) {
+                    throw new Error("invalid Herdr terminal inventory identity");
+                }
+                seen.add(pane.pane_id);
+            }
+        }
         return Array.isArray(result.panes) ? result.panes.filter(isRecord) : [];
     }
     return {
         name: "herdr",
+        async retirementInventory() {
+            return (await panes(true)).map(pane => pane.pane_id);
+        },
         async list() {
             return (await panes()).map((pane) => ({
                 id: str(pane.pane_id) ?? "",
@@ -187,6 +201,50 @@ function createHerdrHost(connection, options = {}) {
             let refresh = false;
             const status = new Map();
             const pending = new Map();
+            const inventory = new Map();
+            let cancelObservation = null;
+            let inventoryGeneration = 0;
+            const publishObservation = (error) => {
+                handlers.observed?.({ at: Date.now(), sessions: [...inventory.values()], ...(error ? { error } : {}) });
+            };
+            const inventoryRow = (pane) => {
+                const id = str(pane.pane_id);
+                if (!id)
+                    return;
+                const state = str(pane.agent_status);
+                inventory.set(id, {
+                    session: { id, ref: id, workspace: str(pane.workspace_id),
+                        title: str(pane.title) ?? str(pane.terminal_title_stripped) ?? str(pane.label) ?? "",
+                        agent: str(pane.agent), cwd: str(pane.foreground_cwd) ?? str(pane.cwd), focused: pane.focused === true },
+                    activity: state === "working" ? "working" : RETURN_STATES.has(state ?? "") ? "idle" : "unknown",
+                    observedAt: Date.now(),
+                });
+            };
+            const replaceInventory = (current) => {
+                const ids = new Set(current.flatMap(pane => str(pane.pane_id) ?? []));
+                for (const id of inventory.keys())
+                    if (!ids.has(id))
+                        inventory.delete(id);
+                for (const pane of current)
+                    inventoryRow(pane);
+                publishObservation();
+            };
+            // Read-only refresh belongs to this host watcher, never to the judge or the browser.
+            const refreshObservation = async () => {
+                cancelObservation = null;
+                const generation = ++inventoryGeneration;
+                try {
+                    const current = await panes(true);
+                    if (!closed && generation === inventoryGeneration)
+                        replaceInventory(current);
+                }
+                catch {
+                    if (!closed && generation === inventoryGeneration)
+                        publishObservation("host_unavailable");
+                }
+                if (!closed && generation === inventoryGeneration && !cancelObservation)
+                    cancelObservation = schedule(() => void refreshObservation(), 5_000);
+            };
             const cancelPending = (paneId) => {
                 pending.get(paneId)?.();
                 pending.delete(paneId);
@@ -263,12 +321,22 @@ function createHerdrHost(connection, options = {}) {
                 if (name === "pane_closed") {
                     cancelPending(paneId);
                     status.delete(paneId);
+                    inventory.delete(paneId);
                     refresh = true;
                     stream?.close();
                     return;
                 }
                 if (name !== "pane_agent_status_changed")
                     return;
+                const row = inventory.get(paneId);
+                if (row) {
+                    const next = str(data.agent_status);
+                    row.activity = next === "working" ? "working" : RETURN_STATES.has(next ?? "") ? "idle" : "unknown";
+                    row.observedAt = Date.now();
+                    publishObservation();
+                    if (closed)
+                        return;
+                }
                 observed(paneId, str(data.agent_status) ?? "unknown");
             };
             const reconnect = (error) => {
@@ -282,13 +350,17 @@ function createHerdrHost(connection, options = {}) {
                 const delay = RECONNECT_DELAYS_MS[Math.min(attempt, RECONNECT_DELAYS_MS.length - 1)];
                 attempt += 1;
                 (0, runtime_1.emitNervesEvent)({ level: "warn", component: "senses", event: "senses.shepherd_herdr_closed", message: "Herdr event subscription closed; resubscribing", meta: { delay, error: error?.message ?? null } });
+                publishObservation("host_unavailable");
+                if (closed)
+                    return;
                 cancelReconnect = schedule(() => void subscribe(), delay);
             };
             const subscribe = async () => {
                 cancelReconnect = null;
                 let current;
+                const generation = ++inventoryGeneration;
                 try {
-                    current = await panes();
+                    current = await panes(!!handlers.observed);
                 }
                 catch (error) {
                     return reconnect(error);
@@ -314,11 +386,19 @@ function createHerdrHost(connection, options = {}) {
                     else if (next !== "unknown")
                         status.set(id, next);
                 }
+                if (generation === inventoryGeneration)
+                    replaceInventory(current);
+                if (closed)
+                    return;
+                if (handlers.observed && !cancelObservation)
+                    cancelObservation = schedule(() => void refreshObservation(), 5_000);
                 const subscriptions = [
                     { type: "pane.created" }, { type: "pane.closed" }, { type: "pane.focused" }, { type: "pane.moved" },
                     ...current.flatMap((pane) => str(pane.pane_id) ? [{ type: "pane.agent_status_changed", pane_id: pane.pane_id }] : []),
                 ];
                 stream = connectLines(connection.socketPath, (line) => {
+                    if (closed)
+                        return;
                     if (isRecord(line.result) && line.result.type === "subscription_started") {
                         attempt = 0;
                         (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.shepherd_herdr_connected", message: "Herdr event subscription started", meta: { panes: subscriptions.length - 4 } });
@@ -334,6 +414,8 @@ function createHerdrHost(connection, options = {}) {
             return {
                 close() {
                     closed = true;
+                    inventoryGeneration += 1;
+                    cancelObservation?.();
                     cancelReconnect?.();
                     for (const cancel of pending.values())
                         cancel();

package/dist/senses/shepherd/judge-evaluation-command.js

@@ -0,0 +1,180 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openShepherdJudgeEvaluationOutput = openShepherdJudgeEvaluationOutput;
+exports.loadConfiguredShepherdEvaluationJudge = loadConfiguredShepherdEvaluationJudge;
+exports.runShepherdJudgeEvaluationCommand = runShepherdJudgeEvaluationCommand;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const runtime_1 = require("../../nerves/runtime");
+const judge_1 = require("./judge");
+const judge_evaluation_1 = require("./judge-evaluation");
+const redact_1 = require("./redact");
+const shepherd_judge_corpus_v1_json_1 = __importDefault(require("./shepherd-judge-corpus-v1.json"));
+function openShepherdJudgeEvaluationOutput(file) {
+    const fd = fs.openSync(file, "wx", 0o600);
+    return {
+        write: report => {
+            const bytes = Buffer.from(JSON.stringify(report, null, 2) + "\n", "utf8");
+            let offset = 0;
+            while (offset < bytes.length) {
+                const written = fs.writeSync(fd, bytes, offset, bytes.length - offset, offset);
+                if (written === 0)
+                    throw new Error("Evaluation output write made no progress");
+                offset += written;
+            }
+            fs.ftruncateSync(fd, bytes.length);
+            fs.fsyncSync(fd);
+        },
+        close: () => fs.closeSync(fd),
+    };
+}
+async function loadConfiguredShepherdEvaluationJudge(agent) {
+    const { getAgentRoot } = await Promise.resolve().then(() => __importStar(require("../../heart/identity")));
+    const root = getAgentRoot(agent);
+    if (!fs.statSync(path.join(root, "agent.json")).isFile())
+        throw new Error("The selected agent needs an existing agent.json");
+    const { getProviderRuntime } = await Promise.resolve().then(() => __importStar(require("../../heart/core")));
+    const runtime = await getProviderRuntime("agent", { agentName: agent, agentRoot: root });
+    const metadata = JSON.parse(fs.readFileSync(path.resolve(__dirname, "../../../package.json"), "utf8"));
+    if (!metadata || typeof metadata !== "object" || !("version" in metadata) || typeof metadata.version !== "string") {
+        throw new Error("Could not identify the evaluation runtime package version");
+    }
+    const digest = (name) => (0, node_crypto_1.createHash)("sha256")
+        .update(fs.readFileSync(path.join(__dirname, `${name}${path.extname(__filename)}`))).digest("hex");
+    const observed = {
+        resetTurnState: messages => runtime.resetTurnState?.(messages),
+        streamTurn: async (request) => {
+            const response = await runtime.streamTurn(request);
+            if (!(0, judge_1.isShepherdJudgeAnswerValid)(response.content ?? ""))
+                throw new Error("Judge returned malformed or nonconforming JSON; no classification credit");
+            return response;
+        },
+    };
+    return {
+        judge: (0, judge_1.createShepherdJudge)(async () => observed, 20_000),
+        provenance: {
+            provider: runtime.id, model: runtime.model, runtimeVersion: metadata.version,
+            judgeSha256: digest("judge"), evaluatorSha256: digest("judge-evaluation"),
+        },
+    };
+}
+function parseArgs(argv) {
+    const values = new Map();
+    for (let i = 0; i < argv.length; i += 2) {
+        const name = argv[i], value = argv[i + 1];
+        if (!["--agent", "--output"].includes(name) || values.has(name) || !value?.trim() || value.startsWith("--")) {
+            throw new Error("Usage: shepherd:judge-eval -- --agent NAME --output NEW_PRIVATE_REPORT.json");
+        }
+        values.set(name, value);
+    }
+    const agent = values.get("--agent"), output = values.get("--output");
+    if (!agent || !/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,99}$/.test(agent) || !output) {
+        throw new Error("Explicit --agent NAME and --output NEW_PRIVATE_REPORT.json are required");
+    }
+    return { agent, output };
+}
+async function runShepherdJudgeEvaluationCommand(argv, dependencies = {
+    loadJudge: loadConfiguredShepherdEvaluationJudge, openOutput: openShepherdJudgeEvaluationOutput,
+    // eslint-disable-next-line no-console -- explicit evaluation command terminal output
+    print: message => console.log(message),
+}) {
+    let output = null;
+    let exitCode = 1;
+    let summary = null;
+    let outputClosed = false;
+    (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.shepherd_judge_evaluation_command_start",
+        message: "starting explicit tool-free classification command", meta: {} });
+    try {
+        const args = parseArgs(argv);
+        (0, judge_evaluation_1.validateShepherdJudgeCorpus)(shepherd_judge_corpus_v1_json_1.default);
+        output = dependencies.openOutput(args.output);
+        const { judge, provenance } = await dependencies.loadJudge(args.agent);
+        const destination = output;
+        const report = await (0, judge_evaluation_1.runShepherdJudgeEvaluation)(shepherd_judge_corpus_v1_json_1.default, judge, provenance, results => {
+            if (results.length % 20 !== 0)
+                return;
+            destination.write({ schemaVersion: 1, phase: "judge-classification-only", state: "running",
+                ...provenance, completedCalls: results.length, results, admissionExercised: false, nativeHostQualified: false, v1Qualified: false });
+            dependencies.print(JSON.stringify({ phase: "judge-classification-only", completedCalls: results.length, v1Qualified: false }));
+        });
+        output.write(report);
+        summary = {
+            phase: report.phase, classificationPassed: report.classificationPassed, v1Qualified: false,
+            uniqueCases: report.uniqueCases, calls: report.results.length,
+            unsafeProposedActions: report.unsafeProposedActions, unattendedKeys: report.unattendedKeys, errors: report.errors,
+            report: args.output, boundary: "Classification evidence only; not v1 qualification.",
+        };
+        exitCode = report.classificationPassed ? 0 : 1;
+    }
+    catch (error) {
+        const detail = (0, redact_1.redactSecrets)(String(error)).slice(0, 2000);
+        dependencies.print(JSON.stringify({ error: detail, v1Qualified: false }));
+        if (output) {
+            try {
+                output.write({ schemaVersion: 1, phase: "judge-classification-only", state: "error", error: detail, v1Qualified: false });
+            }
+            catch (writeError) {
+                dependencies.print(JSON.stringify({ error: `Could not persist evaluation error: ${(0, redact_1.redactSecrets)(String(writeError)).slice(0, 2000)}` }));
+            }
+        }
+        (0, runtime_1.emitNervesEvent)({ component: "senses", level: "error", event: "senses.shepherd_judge_evaluation_command_error",
+            message: "classification command failed; no v1 qualification",
+            meta: { phase: "judge-classification-only", outputReserved: output !== null, error: detail } });
+    }
+    finally {
+        try {
+            output?.close();
+            outputClosed = output !== null;
+        }
+        catch (error) {
+            exitCode = 1;
+            const detail = (0, redact_1.redactSecrets)(String(error)).slice(0, 2000);
+            dependencies.print(JSON.stringify({ error: `Could not close evaluation output: ${detail}`, v1Qualified: false }));
+            (0, runtime_1.emitNervesEvent)({ component: "senses", level: "error", event: "senses.shepherd_judge_evaluation_output_close_error",
+                message: "evaluation output close failed", meta: { phase: "judge-classification-only", error: detail } });
+        }
+    }
+    if (summary && outputClosed) {
+        dependencies.print(JSON.stringify(summary));
+        (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.shepherd_judge_evaluation_command_end",
+            message: "classification report persisted and closed", meta: { classificationPassed: summary.classificationPassed, v1Qualified: false } });
+    }
+    return exitCode;
+}

package/dist/senses/shepherd/judge-evaluation-entry.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const judge_evaluation_command_1 = require("./judge-evaluation-command");
+const runtime_1 = require("../../nerves/runtime");
+const redact_1 = require("./redact");
+void (0, judge_evaluation_command_1.runShepherdJudgeEvaluationCommand)(process.argv.slice(2)).then(code => { process.exitCode = code; }).catch(error => {
+    const detail = (0, redact_1.redactSecrets)(String(error)).slice(0, 2000);
+    (0, runtime_1.emitNervesEvent)({ component: "senses", level: "error", event: "senses.shepherd_judge_evaluation_entry_error",
+        message: "classification command rejected unexpectedly", meta: { phase: "judge-classification-only", error: detail } });
+    // eslint-disable-next-line no-console -- terminal UX: last-resort nonzero evaluation failure
+    console.error(JSON.stringify({ error: detail, v1Qualified: false }));
+    process.exitCode = 1;
+});