@ouro.bot/cli 0.1.0-alpha.934 → 0.1.0-alpha.936

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/observation-publisher.js

@@ -0,0 +1,320 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createShepherdObservationPublisher = createShepherdObservationPublisher;
+const node_crypto_1 = require("node:crypto");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const mandates_1 = require("../../heart/shepherd/mandates");
+const supervision_1 = require("../../heart/shepherd/supervision");
+const runtime_1 = require("../../nerves/runtime");
+const guidance_1 = require("./guidance");
+const notice_outbox_1 = require("./notice-outbox");
+const recovery_1 = require("./recovery");
+const checkin_store_1 = require("./checkin-store");
+const returns_1 = require("./returns");
+const redact_1 = require("./redact");
+const object = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const kinds = new Set(["premature", "gate", "done", "working", "waiting", "unclear", "error", "loop_guard"]);
+const safe = (value) => (0, redact_1.redactSecrets)(value).replace(/[\x00-\x1f\x7f-\x9f\u2028\u2029]+/g, " ").trim().slice(0, 2000) || "(unnamed)";
+const idFor = (value) => (0, node_crypto_1.createHash)("sha256").update(JSON.stringify(value)).digest("hex");
+const iso = (at) => {
+    if (!Number.isFinite(Date.parse(at)))
+        throw new Error("Invalid observation source timestamp");
+    return new Date(at).toISOString();
+};
+const emptyPage = () => ({ totalCount: 0, truncated: false, items: [] });
+const unknownCustody = () => ({
+    revision: null, bytes: null, capacity: "unknown", claims: { totalCount: null, truncated: true, items: [] },
+});
+function page(events, totalCount) {
+    const unique = [...new Map(events.map(event => [event.id, event])).values()];
+    const count = totalCount === undefined ? unique.length : totalCount;
+    const items = unique.sort((a, b) => b.at.localeCompare(a.at) || a.id.localeCompare(b.id)).slice(0, supervision_1.SHEPHERD_SUPERVISION_LIMIT);
+    return { items, totalCount: count, truncated: count === null || count > items.length };
+}
+/** Unlike the legacy convenience reader, a malformed row never becomes a healthy empty history. */
+function readReturnSummaries(root) {
+    const file = (0, returns_1.returnsLogPath)(root);
+    const metadata = fs.lstatSync(file, { throwIfNoEntry: false });
+    if (!metadata)
+        return null;
+    if (!metadata.isFile() || metadata.nlink !== 1 || metadata.size > supervision_1.SHEPHERD_OBSERVATION_MAX_BYTES)
+        throw new Error("Invalid returns source");
+    const fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+    let raw;
+    try {
+        const opened = fs.fstatSync(fd);
+        if (opened.ino !== metadata.ino || opened.dev !== metadata.dev)
+            throw new Error("Returns source changed");
+        const bytes = Buffer.alloc(supervision_1.SHEPHERD_OBSERVATION_MAX_BYTES + 1);
+        let size = 0;
+        while (size < bytes.length) {
+            const received = fs.readSync(fd, bytes, size, bytes.length - size, null);
+            if (!received)
+                break;
+            size += received;
+        }
+        if (size > supervision_1.SHEPHERD_OBSERVATION_MAX_BYTES)
+            throw new Error("Returns source exceeds limit");
+        raw = bytes.toString("utf8", 0, size);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    return raw.split("\n").filter(line => line.trim()).map(line => {
+        const value = JSON.parse(line);
+        if (!object(value) || typeof value.at !== "string" || typeof value.host !== "string" || typeof value.session !== "string"
+            || typeof value.transition !== "string" || typeof value.kind !== "string" || !kinds.has(value.kind)
+            || !value.host || !value.session || !value.transition || (value.action !== "respond" && value.action !== "let_through")
+            || typeof value.reason !== "string")
+            throw new Error("Invalid returns source schema");
+        return { at: iso(value.at), host: safe(value.host), session: safe(value.session), transition: value.transition, kind: value.kind,
+            action: value.action, reason: safe(value.reason) };
+    });
+}
+function createShepherdObservationPublisher(options) {
+    const now = options.now ?? Date.now;
+    let stopped = false;
+    let observed = null;
+    let returns = [];
+    let custody = unknownCustody();
+    const events = { returns: emptyPage(), custody: emptyPage(), notices: emptyPage() };
+    let observations = emptyPage();
+    function projectAndPublish() {
+        const at = now();
+        const health = {
+            host: observed && !observed.error ? "ok" : "missing", guidance: "ok", mandates: "ok", returns: "ok", custody: "ok", notices: "ok",
+        };
+        const errors = [];
+        const fail = (source) => {
+            health[source] = "error";
+            errors.push({ source, code: "read_failed", detail: `The ${source} source could not be read. Any retained history is not current.` });
+        };
+        const read = (source, fn) => {
+            try {
+                return fn();
+            }
+            catch {
+                fail(source);
+                return null;
+            }
+        };
+        const guidance = read("guidance", () => (0, guidance_1.readGuidance)(options.agentRoot));
+        const mandates = read("mandates", () => (0, mandates_1.readShepherdMandates)(options.agentRoot));
+        try {
+            const current = readReturnSummaries(options.agentRoot);
+            if (current === null)
+                health.returns = "missing";
+            else {
+                returns = current;
+                events.returns = page(current.map(record => ({
+                    id: `return:${idFor([record.host, record.session, record.transition, record.at])}`,
+                    host: record.host, session: record.session, instance: null, at: record.at, kind: "judgment", summary: record.kind,
+                })));
+            }
+        }
+        catch {
+            fail("returns");
+        }
+        try {
+            const current = (0, recovery_1.readCheckInSnapshot)((0, checkin_store_1.checkInStorePath)(options.agentRoot), { limit: supervision_1.SHEPHERD_SUPERVISION_LIMIT });
+            if (current.state === "missing")
+                health.custody = "missing";
+            else {
+                custody = {
+                    revision: current.revision, bytes: current.bytes, capacity: current.capacity,
+                    claims: { totalCount: current.totalCount, truncated: current.nextCursor !== null, items: current.entries.map(entry => ({
+                            id: entry.id, host: safe(entry.host), session: safe(entry.session), instance: entry.instance === null ? null : safe(entry.instance),
+                            state: entry.state, claimedAt: iso(entry.claimedAt), reason: entry.reason === null ? null : safe(entry.reason), retired: entry.retired,
+                        })) },
+                };
+                events.custody = page(current.entries.flatMap(entry => {
+                    const base = { host: safe(entry.host), session: safe(entry.session), instance: entry.instance === null ? null : safe(entry.instance) };
+                    const boundAdmission = entry.receipt?.requestId === entry.id && entry.receipt.surfaceId === entry.session
+                        && entry.receipt.processInstance === entry.instance && entry.receipt.pasteAdmitted && entry.receipt.submitAdmitted;
+                    return [{
+                            ...base, id: `input:${entry.id}`, at: iso(entry.claimedAt),
+                            kind: entry.state === "sent" ? boundAdmission ? "input_admitted" : "legacy_input_reported"
+                                : entry.state === "not_sent" ? "observation" : "input_unknown",
+                            summary: entry.state === "sent" ? boundAdmission ? "Bound host receipt reports paste and submit admission; not proof of task completion"
+                                : "Legacy dispatcher reported sent; no qualified bound paste-and-submit receipt. Not proof of input admission or task completion."
+                                : entry.state === "not_sent" ? "Input refused; no terminal input"
+                                    : "Claim held; input outcome is unknown. Reconcile evidence, do not retry blindly.",
+                        }, ...entry.reconciliations.map(receipt => ({
+                            ...base, id: `recovery:${entry.id}:${receipt.revision}`, at: iso(receipt.at),
+                            kind: "recovery", summary: `Owner acknowledged recovery: ${receipt.resolution}; original state ${receipt.originalState}`,
+                        }))];
+                }), current.nextCursor === null ? undefined : null);
+            }
+        }
+        catch {
+            fail("custody");
+        }
+        try {
+            events.notices = page((0, notice_outbox_1.readNoticeOutbox)(options.agentRoot).flatMap(entry => {
+                const base = { host: safe(entry.record.host), session: safe(entry.record.session), instance: null };
+                return [{
+                        ...base, id: `notice:${entry.id}`, at: iso(entry.record.at), kind: "notification_queued", summary: "Owner notification queued",
+                    }, ...Object.entries(entry.deliveries).map(([recipient, delivery]) => ({
+                        ...base, id: `notice:${entry.id}:${idFor(recipient)}`, at: iso(delivery.at),
+                        kind: delivery.state === "sent" ? "notification_delivered"
+                            : delivery.state === "unknown" ? "notification_unknown" : "notification_queued",
+                        summary: delivery.state === "sent" ? "Owner notification accepted by transport; not proof the owner read it"
+                            : delivery.state === "unknown" ? "Owner notification delivery is unknown" : "Owner notification pending transport",
+                    }))];
+            }));
+        }
+        catch {
+            fail("notices");
+        }
+        if (observed?.error)
+            errors.push({ source: "host", code: observed.error, detail: observed.error === "sense_stopped"
+                    ? "The Shepherd sense is stopped. Retained observations are historical."
+                    : "The terminal host is unavailable. Retained observations are historical." });
+        const sessions = (observed?.sessions ?? []).slice(0, supervision_1.SHEPHERD_SUPERVISION_LIMIT).map(row => {
+            const session = row.session;
+            let authority = "unknown";
+            let withheldReason = row.error ? "Terminal could not be read; no current policy assessment" : "Guarded automatic input is not qualified for this host";
+            if (row.error && errors.length < 50)
+                errors.push({ source: "host", code: "row_read_failed", detail: `Terminal ${safe(session.id)} could not be read` });
+            if (guidance && mandates) {
+                if ((0, guidance_1.applicableGuidance)(guidance, { host: options.host, session: session.id, cwd: session.cwd ?? null, task: null }).paused)
+                    authority = "paused";
+                else if (session.cwd) {
+                    const resolution = (0, mandates_1.resolveShepherdMandate)(mandates, {
+                        project: session.cwd, host: options.host, session: session.id, ...(session.instance ? { instance: session.instance } : {}),
+                    }, at);
+                    authority = resolution.state === "authorized" ? "active" : resolution.reason === "ambiguous_mandates" ? "ambiguous" : "absent";
+                }
+                else
+                    authority = "absent";
+                if (authority === "paused")
+                    withheldReason = "Stored terminal pause is set";
+                else if (authority === "absent")
+                    withheldReason = "No applicable stored mandate; legacy automatic paths are not uniformly mandate-enforced";
+                else if (authority === "ambiguous")
+                    withheldReason = "Multiple stored mandates apply; policy scope is ambiguous";
+            }
+            const last = returns.filter(record => record.host === options.host && record.session === safe(session.id)).sort((a, b) => b.at.localeCompare(a.at))[0];
+            return {
+                host: safe(options.host), session: safe(session.id), instance: session.instance ? safe(session.instance) : null,
+                label: safe(session.title || session.ref || session.id), harness: session.agent ? safe(session.agent) : null,
+                project: session.cwd ? safe(session.cwd) : null, activity: row.activity,
+                observedAt: row.observedAt === null ? null : new Date(row.observedAt).toISOString(),
+                lastDecision: last?.kind ?? null, lastAction: last?.action ?? null, lastReason: last?.reason ?? null,
+                lastActionAt: last?.at ?? null, withheldReason, authority, capability: "unsupported",
+            };
+        });
+        const allEvents = [...Object.values(events), observations];
+        const total = allEvents.some(value => value.totalCount === null) ? null : allEvents.reduce((sum, value) => sum + value.totalCount, 0);
+        const snapshot = {
+            schemaVersion: 1, agentName: options.agentName, observedAt: new Date(observed?.at ?? at).toISOString(),
+            sourceHealth: health, sourceErrors: errors,
+            sessions: { totalCount: observed ? observed.sessions.length : null,
+                truncated: !observed || observed.sessions.length > sessions.length, items: sessions },
+            timeline: page(allEvents.flatMap(value => value.items), total), custody,
+        };
+        try {
+            if (!(0, supervision_1.isShepherdSupervisionSnapshot)(snapshot))
+                throw new Error("Invalid bounded observation projection");
+            const encoded = JSON.stringify(snapshot);
+            if (Buffer.byteLength(encoded) > supervision_1.SHEPHERD_OBSERVATION_MAX_BYTES)
+                throw new Error("Observation exceeds publication limit");
+            const dir = (0, returns_1.shepherdStateDir)(options.agentRoot);
+            (0, checkin_store_1.validateCustodyDirectory)(dir, true);
+            const temporary = path.join(dir, `${supervision_1.SHEPHERD_OBSERVATION_FILE}.${(0, node_crypto_1.randomUUID)()}.tmp`);
+            const fd = fs.openSync(temporary, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_NOFOLLOW, 0o600);
+            try {
+                fs.writeFileSync(fd, encoded);
+                fs.fsyncSync(fd);
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+            fs.renameSync(temporary, path.join(dir, supervision_1.SHEPHERD_OBSERVATION_FILE));
+            const directory = fs.openSync(dir, fs.constants.O_RDONLY | fs.constants.O_DIRECTORY | fs.constants.O_NOFOLLOW);
+            try {
+                fs.fsyncSync(directory);
+            }
+            finally {
+                fs.closeSync(directory);
+            }
+            return true;
+        }
+        catch {
+            (0, runtime_1.emitNervesEvent)({ level: "warn", component: "senses", event: "senses.shepherd_observation_failed",
+                message: "Could not publish a safe Shepherd observation; the previous replica must age out", meta: { agent: options.agentName } });
+            return false;
+        }
+    }
+    function publish() {
+        try {
+            return projectAndPublish();
+        }
+        catch {
+            (0, runtime_1.emitNervesEvent)({ level: "warn", component: "senses", event: "senses.shepherd_observation_failed",
+                message: "Could not assemble a Shepherd observation; the previous replica must age out", meta: { agent: options.agentName } });
+            return false;
+        }
+    }
+    return {
+        observe(observation) {
+            if (stopped)
+                return false;
+            observed = structuredClone(observation);
+            if (!observation.error) {
+                const current = observation.sessions.slice(0, supervision_1.SHEPHERD_SUPERVISION_LIMIT).map(row => ({
+                    id: `observation:${idFor([options.host, row.session.id, row.session.instance ?? null, observation.at])}`,
+                    host: safe(options.host), session: safe(row.session.id), instance: row.session.instance ? safe(row.session.instance) : null,
+                    at: new Date(observation.at).toISOString(), kind: "observation",
+                    summary: row.error ? "Terminal observation failed" : `Observed terminal activity: ${row.activity}`,
+                }));
+                const unique = new Map([...current, ...observations.items].map(event => [event.id, event]));
+                observations = page([...unique.values()], observations.totalCount
+                    + current.filter(event => !observations.items.some(previous => previous.id === event.id)).length);
+            }
+            return publish();
+        },
+        refresh() { return !stopped && publish(); },
+        stop() {
+            if (stopped)
+                return;
+            observed = { ...(observed ?? { at: 0, sessions: [] }), error: "sense_stopped" };
+            publish();
+            stopped = true;
+        },
+    };
+}

package/dist/senses/shepherd/operations-defaults.js

@@ -0,0 +1,86 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDefaultShepherdOperationDeps = createDefaultShepherdOperationDeps;
+const path = __importStar(require("node:path"));
+const fs = __importStar(require("node:fs"));
+const identity_1 = require("../../heart/identity");
+const runtime_credentials_1 = require("../../heart/runtime-credentials");
+const shepherd_config_1 = require("../../heart/shepherd-config");
+const host_1 = require("./host");
+const surface_1 = require("./surface");
+const runtime_1 = require("../../nerves/runtime");
+function createDefaultShepherdOperationDeps(lifecycle) {
+    return {
+        agentRoot: agent => path.join((0, identity_1.getAgentBundlesRoot)(), `${agent}.ouro`),
+        resolveOwner: async (agent) => {
+            if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(agent))
+                throw new Error("existing local owner requires a safe agent name");
+            const root = path.join((0, identity_1.getAgentBundlesRoot)(), `${agent}.ouro`);
+            if (!fs.lstatSync(root, { throwIfNoEntry: false })?.isDirectory()
+                || !fs.lstatSync(path.join(root, "friends"), { throwIfNoEntry: false })?.isDirectory()) {
+                throw new Error("existing local owner linking is required; no bundle or friends directory was created");
+            }
+            return { actorId: await (0, surface_1.resolveExistingLocalOwner)((0, surface_1.localShepherdFriendStore)(agent)) };
+        },
+        host: async (agent) => {
+            const machine = (0, runtime_credentials_1.readMachineRuntimeCredentialConfig)(agent);
+            if (!machine.ok)
+                throw new Error("machine Shepherd connection configuration is unavailable");
+            const connection = (0, shepherd_config_1.resolveShepherdConnection)(agent, machine.config);
+            if (!connection.ok)
+                throw new Error(connection.error);
+            return (0, host_1.createShepherdHost)(connection.connection, { agentName: agent });
+        },
+        senseStopped: async (agent) => {
+            const response = await lifecycle(agent);
+            if (!response.ok)
+                throw new Error(response.error ?? "daemon lifecycle unavailable");
+            const value = response.data;
+            if (value === null || typeof value !== "object" || !("kind" in value) || value.kind !== "daemon_lifecycle"
+                || !("enabled" in value) || value.enabled !== false || !("processState" in value) || value.processState !== "stopped"
+                || !("checkedAt" in value) || typeof value.checkedAt !== "string" || !Number.isFinite(Date.parse(value.checkedAt))
+                || Date.parse(value.checkedAt) > Date.now() || Date.now() - Date.parse(value.checkedAt) > 30_000) {
+                throw new Error("fresh disabled and stopped daemon lifecycle proof is unavailable");
+            }
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses", event: "senses.shepherd_maintenance_quiescence_confirmed",
+                message: "validated fresh daemon proof that Shepherd is disabled and stopped",
+                meta: { agent, processState: "stopped" },
+            });
+            return { kind: "daemon_lifecycle", enabled: false, processState: "stopped", checkedAt: value.checkedAt };
+        },
+    };
+}