@ouro.bot/cli 0.1.0-alpha.92 → 0.1.0-alpha.920

package/dist/repertoire/tools-flow.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restTool = exports.speakTool = exports.settleTool = exports.observeTool = exports.ponderTool = void 0;
+exports.ponderTool = {
+    type: "function",
+    function: {
+        name: "ponder",
+        description: "create or revise a typed ponder packet so i don't lose the plot while i keep working. use this for harness friction, research, or reflection that should survive the current turn. if the user asked me to think privately and return later from an outward session, preserve literal return tokens and constraints in payload_json fields or success_criteria; the runtime records the latest user request as sourceRequest. then do not settle with the final private answer in the same outward turn; only acknowledge that the private pass is queued. in private runtime, ponder only preserves state; it does not create a new self-return obligation, so surface any existing held item instead of pondering a replacement. ponder does not end the turn by itself and may be followed by more tools before i settle or rest. Don't ponder trivial questions.",
+        parameters: {
+            type: "object",
+            properties: {
+                action: {
+                    type: "string",
+                    enum: ["create", "revise"],
+                    description: "create a new packet or revise an existing drafting packet.",
+                },
+                kind: {
+                    type: "string",
+                    enum: ["harness_friction", "research", "reflection"],
+                    description: "the packet kind. determines the SOP the private-runtime turn should follow.",
+                },
+                packet_id: {
+                    type: "string",
+                    description: "required for action=revise. the packet to revise in place.",
+                },
+                follows_packet_id: {
+                    type: "string",
+                    description: "optional follow-up linkage when a new packet grows out of an earlier one.",
+                },
+                objective: {
+                    type: "string",
+                    description: "the durable objective for this packet.",
+                },
+                summary: {
+                    type: "string",
+                    description: "brief factual summary of the work object or friction being preserved.",
+                },
+                success_criteria: {
+                    type: "string",
+                    description: "newline-delimited success criteria bullets.",
+                },
+                payload_json: {
+                    type: "string",
+                    description: "JSON object string with packet-specific structured details. include exact markers, return wording fragments, or constraints the private-runtime pass must preserve; sourceRequest is owned by the runtime from the latest user request. use {} only when there are no such details.",
+                },
+                thought: {
+                    type: "string",
+                    description: "deprecated compatibility field. legacy thought text is normalized into a reflection packet.",
+                },
+                say: {
+                    type: "string",
+                    description: "deprecated compatibility field. retained for migration only; it no longer controls deferral or silence.",
+                },
+            },
+        },
+    },
+};
+exports.observeTool = {
+    type: "function",
+    function: {
+        name: "observe",
+        description: "absorb what happened without responding — the moment doesn't call for words. must be the only tool call in the turn.",
+        parameters: {
+            type: "object",
+            properties: {
+                reason: { type: "string", description: "brief reason for staying silent (for logging)" },
+            },
+        },
+    },
+};
+exports.settleTool = {
+    type: "function",
+    function: {
+        name: "settle",
+        description: "deliver your response and end your turn — this hands control back to the user. only settle when your work is complete, you're genuinely blocked, the user asked a direct question that needs an answer now, or a required confirmation/stop/pause boundary is reached. process feedback during active work is loop input, not a settle reason. do not settle with status updates mid-task. if you're settling with 'I'll look into that,' you probably should be using a tool instead.",
+        parameters: {
+            type: "object",
+            properties: {
+                answer: { type: "string" },
+                intent: { type: "string", enum: ["complete", "blocked", "direct_reply"] },
+            },
+            required: ["answer"],
+        },
+    },
+};
+exports.speakTool = {
+    type: "function",
+    function: {
+        name: "speak",
+        description: "i speak to send words to my friend mid-turn without ending it. for progress, acknowledgment, or phase-boundary updates during heavy work. after speaking, continue with tools unless the next step needs a reply. i settle when my work is done or i need a reply.",
+        parameters: {
+            type: "object",
+            properties: {
+                message: { type: "string", description: "the words i'm sending to my friend right now" },
+            },
+            required: ["message"],
+        },
+    },
+};
+exports.restTool = {
+    type: "function",
+    function: {
+        name: "rest",
+        description: "end a private-runtime turn when private work is complete. rest remains the explicit terminal move for the private-runtime turn and must be the only tool call in the turn. on idle heartbeat turns, use status=HEARTBEAT_OK.",
+        parameters: {
+            type: "object",
+            properties: {
+                status: {
+                    type: "string",
+                    description: "optional rest status. use HEARTBEAT_OK when the heartbeat fires and there is nothing to do.",
+                },
+                note: {
+                    type: "string",
+                    description: "optional brief note about why i'm resting.",
+                },
+            },
+        },
+    },
+};

package/dist/repertoire/tools-friend-link.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.friendLinkToolDefinition = void 0;
+const identity_1 = require("../heart/identity");
+const friend_link_codes_1 = require("../mind/friend-link-codes");
+const runtime_1 = require("../nerves/runtime");
+const LINKABLE_CHANNELS = ["teams", "bluebubbles", "telegram", "mail", "voice", "mcp", "cli"];
+exports.friendLinkToolDefinition = {
+    tool: {
+        type: "function",
+        function: {
+            name: "friend_link_code",
+            description: "Issue a one-time code that links another account of the person you are talking to (for example their Teams account) to them. " +
+                "Give them the code; when they send exactly that code to you from the other account in a 1:1 chat, that account is treated as them. " +
+                "Only for family, only for themselves, and never in a group chat. The code expires in 10 minutes and works once.",
+            parameters: {
+                type: "object",
+                properties: {
+                    channel: {
+                        type: "string",
+                        enum: [...LINKABLE_CHANNELS],
+                        description: "The channel the other account will message from. Omit to accept any channel.",
+                    },
+                },
+            },
+        },
+    },
+    handler: async (args, ctx) => {
+        (0, runtime_1.emitNervesEvent)({
+            component: "repertoire",
+            event: "repertoire.tool_friend_link_code",
+            message: "friend_link_code invoked",
+            meta: { channel: args.channel ?? "any" },
+        });
+        const context = ctx?.context;
+        if (!context?.friend)
+            return "no friend context: I can only issue a link code to the person I'm talking to.";
+        const friend = context.friend;
+        if (friend.trustLevel !== "family")
+            return "link codes are only for family.";
+        if (context.isGroupChat)
+            return "link codes can't be issued in a group chat. Ask me in a 1:1 chat.";
+        const channel = args.channel;
+        if (channel && !LINKABLE_CHANNELS.includes(channel))
+            return `unknown channel '${channel}'. Use one of: ${LINKABLE_CHANNELS.join(", ")}.`;
+        const issued = (0, friend_link_codes_1.issueLinkCode)({
+            agentRoot: ctx?.agentRoot ?? (0, identity_1.getAgentRoot)(),
+            friend,
+            ...(channel ? { channel: channel } : {}),
+            issuedBy: `tool:${context.channel.channel}`,
+        });
+        const where = issued.channel ? `from their ${issued.channel} account` : "from the account they want to link";
+        return `link code for ${friend.name}: ${issued.code}\nTell them to send exactly this code to me ${where}, in a 1:1 chat, before ${issued.expiresAt}. It works once.`;
+    },
+    summaryKeys: ["channel"],
+    riskProfile: { mutates: "durable_state_write", risk: "high", reason: "issues a code that links a new account to a family friend" },
+};

package/dist/repertoire/tools-github.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.githubToolDefinitions = void 0;
-exports.summarizeGithubArgs = summarizeGithubArgs;
 const github_client_1 = require("./github-client");
 const runtime_1 = require("../nerves/runtime");
 exports.githubToolDefinitions = [
@@ -32,7 +31,7 @@ exports.githubToolDefinitions = [
             if (!ctx?.githubToken) {
                 return "AUTH_REQUIRED:github -- I need access to GitHub. Please sign in when prompted.";
             }
-            const owner = "ouroborosbot";
+            const owner = "ourostack";
             const repo = "ouroboros";
             const payload = { title: args.title };
             if (args.body)
@@ -43,11 +42,7 @@ exports.githubToolDefinitions = [
             return (0, github_client_1.githubRequest)(ctx.githubToken, "POST", `/repos/${owner}/${repo}/issues`, JSON.stringify(payload));
         },
         integration: "github",
-        confirmationRequired: true,
+        summaryKeys: ["title"],
+        riskProfile: { mutates: "external_side_effect", risk: "high", reason: "files a GitHub issue" },
     },
 ];
-function summarizeGithubArgs(name, args) {
-    if (name === "file_ouroboros_bug")
-        return args.title || "";
-    return undefined;
-}

package/dist/repertoire/tools-habits.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.habitToolDefinitions = void 0;
+const friends_1 = require("@ouro.bot/friends");
+const runtime_1 = require("../nerves/runtime");
+const habit_cancel_1 = require("../heart/habits/habit-cancel");
+const semantic_receipts_1 = require("../senses/bluebubbles/semantic-receipts");
+const CAPTURE_LOCATOR_PATTERN = /^capture:([a-f0-9]{64})$/;
+const ACTOR_AUTHORITY_ERROR = "habit_cancel requires trusted current-ingress actor authority";
+async function requireTrustedCurrentIngressActor(agentRoot, captureKeyHash, context) {
+    const capture = (0, semantic_receipts_1.readBlueBubblesSemanticCaptureAtRoot)(agentRoot, captureKeyHash);
+    const actor = capture?.event.actor;
+    if (!actor || !context?.friendStore)
+        throw new Error(ACTOR_AUTHORITY_ERROR);
+    try {
+        const friend = await context.friendStore.findByExternalId(actor.provider, actor.externalId);
+        if (!friends_1.TRUSTED_LEVELS.has(friend?.trustLevel ?? "stranger")) {
+            throw new Error(ACTOR_AUTHORITY_ERROR);
+        }
+    }
+    catch {
+        throw new Error(ACTOR_AUTHORITY_ERROR);
+    }
+}
+exports.habitToolDefinitions = [
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "habit_cancel",
+                description: "Cancel a named habit from the immutable evidence capture that triggered the current turn.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        habit: {
+                            type: "string",
+                            description: "Exact habit identifier to cancel.",
+                        },
+                        evidence: {
+                            type: "string",
+                            description: "Current ingress evidence locator in capture:<sha256> form.",
+                        },
+                    },
+                    required: ["habit", "evidence"],
+                    additionalProperties: false,
+                },
+            },
+        },
+        riskProfile: {
+            mutates: "durable_state_write",
+            risk: "high",
+            reason: "Permanently transitions a durable habit definition to cancelled.",
+        },
+        terminalProjection: {
+            mode: "verbatim",
+            requiresSoleCall: true,
+            clearBufferedText: true,
+        },
+        summaryKeys: ["habit", "evidence"],
+        handler: async (args, context) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "tools",
+                event: "tools.habit_cancel_invoked",
+                message: "habit cancellation tool invoked",
+                meta: { habit: typeof args.habit === "string" ? args.habit : null },
+            });
+            const keys = Object.keys(args);
+            const unexpected = keys.find((key) => key !== "habit" && key !== "evidence");
+            if (unexpected)
+                throw new Error(`unexpected habit_cancel argument: ${unexpected}`);
+            if (keys.length !== 2 || typeof args.habit !== "string" || args.habit.trim().length === 0) {
+                throw new Error("habit_cancel requires exactly habit and evidence");
+            }
+            const match = CAPTURE_LOCATOR_PATTERN.exec(args.evidence);
+            if (!match)
+                throw new Error("habit_cancel evidence must use capture:<sha256>");
+            const currentIngressEvidence = context?.currentIngressEvidence;
+            if (!currentIngressEvidence
+                || Object.keys(currentIngressEvidence).length !== 3
+                || Object.keys(currentIngressEvidence).some((key) => (key !== "schemaVersion" && key !== "provider" && key !== "captureKeyHash"))
+                || currentIngressEvidence.schemaVersion !== 1
+                || currentIngressEvidence.provider !== "bluebubbles"
+                || !/^[a-f0-9]{64}$/.test(currentIngressEvidence.captureKeyHash))
+                throw new Error("habit_cancel requires authoritative current ingress evidence");
+            if (currentIngressEvidence.captureKeyHash !== match[1]) {
+                throw new Error("habit_cancel evidence mismatch with current ingress evidence");
+            }
+            if (!context?.agentRoot)
+                throw new Error("habit_cancel requires an agent root");
+            await requireTrustedCurrentIngressActor(context.agentRoot, currentIngressEvidence.captureKeyHash, context);
+            const receipt = await (0, habit_cancel_1.cancelHabit)({
+                agentRoot: context.agentRoot,
+                habitId: args.habit,
+                evidenceLocator: args.evidence,
+                authority: {
+                    kind: "current_ingress",
+                    currentIngressEvidence,
+                },
+            });
+            return receipt.acknowledgement;
+        },
+    },
+];

package/dist/repertoire/tools-house-care.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.houseCareToolDefinitions = exports.houseDigestToolDefinition = exports.houseSweepToolDefinition = exports.DIGEST_MAX_LINES = exports.LEAD_IN_MAX_CHARS = void 0;
+exports.setHouseCareToolDeps = setHouseCareToolDeps;
+exports.digestLines = digestLines;
+const node_crypto_1 = require("node:crypto");
+const replay_harness_1 = require("../a2a/replay-harness");
+const a2a_await_delivery_1 = require("../heart/awaiting/a2a-await-delivery");
+const runtime_1 = require("../nerves/runtime");
+const house_sweep_1 = require("./house-sweep");
+const tools_base_1 = require("./tools-base");
+/**
+ * The Butler's two house-care tools. `house_sweep` is one read-only call that gathers everything the daily sweep
+ * covers. `house_digest_send` is the only way the sweep reaches the owner: it refuses an empty digest, sends one short
+ * owner notice through the existing owner-notice path (the replay sink when a replay window is open for the asker),
+ * and only then records the findings as told, so the same finding is not repeated unless it changed.
+ */
+exports.LEAD_IN_MAX_CHARS = 140;
+const DAY_MS = 86_400_000;
+const HOUSE_CARE_AWAIT = "house-care-sweep";
+const PEER_NAME_MAX = 40;
+/** Addresses a lead-in must not carry: a bare domain (word.tld), an @mention, mailto:, or any bidi, zero-width or invisible character. */
+const LEAD_IN_FORBIDDEN = /\b[a-z0-9-]+\.[a-z]{2,}\b|@\w|mailto:|[\u200b-\u200f\u202a-\u202e\u2060-\u206f\ufeff]/iu;
+let injected = {};
+function setHouseCareToolDeps(deps) { injected = deps; }
+/** The friend whose request this turn serves; absent on the Butler's own scheduled turns. */
+function askerFriendId(ctx) {
+    return ctx?.context?.friend?.id ?? ctx?.relationshipAuthorization?.actor?.friendId;
+}
+/** The package-managed daily await's own tick: not a peer's or friend's request, and not the owner asking. */
+function isManagedSweepTick(ctx) {
+    return ctx?.autonomousTurnKind === "await" && ctx.autonomousAwaitName === HOUSE_CARE_AWAIT;
+}
+/** The replay gate is running: the managed tick must stay out of its way (it shares the await runner and the owner-notice path). */
+function sweepYieldsToReplay(ctx, now) {
+    return isManagedSweepTick(ctx) && Boolean(ctx?.agentRoot) && (0, replay_harness_1.isAnyReplayWindowOpen)(ctx.agentRoot, now);
+}
+const REPLAY_YIELD = JSON.stringify({ skipped: true, reason: "a replay-gate window is open, so the daily house-care sweep does nothing now. Finish with resolve_await verdict 'no' and the word quiet; do not send anything to the owner." });
+/** Digest lines: identical summaries collapse into one line with a count, at most DIGEST_MAX_LINES lines, then one pointer to the rest. `shownSummaries` are the summaries whose lines are in the digest. */
+exports.DIGEST_MAX_LINES = 8;
+function digestLines(summaries) {
+    const counts = new Map();
+    for (const summary of summaries)
+        counts.set(summary, (counts.get(summary) ?? 0) + 1);
+    const groups = [...counts].slice(0, exports.DIGEST_MAX_LINES);
+    const lines = groups.map(([summary, count]) => `- ${summary}${count > 1 ? ` (x${count})` : ""}`);
+    const hidden = summaries.length - groups.reduce((sum, [, count]) => sum + count, 0);
+    if (hidden > 0)
+        lines.push(`and ${hidden} more (ask me for the full list)`);
+    return { lines, shownSummaries: new Set(groups.map(([summary]) => summary)) };
+}
+function replayAsker(ctx) {
+    const friendId = askerFriendId(ctx);
+    return Boolean(friendId && ctx?.agentRoot && (0, replay_harness_1.isReplayIdentity)(ctx.agentRoot, friendId));
+}
+exports.houseSweepToolDefinition = {
+    tool: {
+        type: "function",
+        function: {
+            name: "house_sweep",
+            description: "The daily house-care sweep in one read-only call. It checks stalled or failed downloads, monitored-but-missing episodes and movies, and failed imports in Sonarr and Radarr; disk, array capacity and parity; container state against the steward policy; and delegation, escalation and standing-permission grants that expire or no longer work. It returns a compact report: the queue state, the findings (each says whether a tool may fix it and which), the ids that are new since the owner was last told (fresh), and whether a digest is due. It changes nothing in the house. Run it when the owner asks about the house or for a sweep, and on the daily house-care await.",
+            parameters: { type: "object", properties: {}, additionalProperties: false },
+        },
+    },
+    handler: async (_args, ctx) => {
+        if (!ctx?.agentRoot)
+            return JSON.stringify({ error: "house sweep runtime is unavailable" });
+        if (sweepYieldsToReplay(ctx, (injected.now ?? Date.now)()))
+            return REPLAY_YIELD;
+        const report = await (0, house_sweep_1.runHouseSweep)({ agentRoot: ctx.agentRoot, sanctuary: ctx.sanctuary, replay: replayAsker(ctx), now: injected.now, ...injected.sweepDeps });
+        return JSON.stringify(report);
+    },
+    summaryKeys: [],
+    riskProfile: { mutates: "none", risk: "low" },
+};
+exports.houseDigestToolDefinition = {
+    tool: {
+        type: "function",
+        function: {
+            name: "house_digest_send",
+            description: "Send the owner ONE short house-care digest, only when the latest house_sweep left findings that need their choice. Give finding_ids from that sweep (never a finding the owner was already told about unchanged). The digest body is always the findings' own summaries; you cannot change them. lead_in is an optional single line of at most 140 characters placed above them. It is refused when no valid finding id is given, when a finding was already told unchanged within 7 days, and when a digest already went out today. Delivery goes through the owner-notice path; for a replay request it goes to the replay sink, never to the owner.",
+            parameters: {
+                type: "object",
+                properties: {
+                    finding_ids: { type: "array", items: { type: "string" }, description: "Ids from the latest house_sweep." },
+                    lead_in: { type: "string", description: `Optional one-line lead-in, at most ${exports.LEAD_IN_MAX_CHARS} characters.` },
+                },
+                required: ["finding_ids"],
+                additionalProperties: false,
+            },
+        },
+    },
+    handler: async (args, ctx) => {
+        const agentRoot = ctx?.agentRoot;
+        if (!agentRoot)
+            return JSON.stringify({ error: "house sweep runtime is unavailable" });
+        const rawIds = args.finding_ids;
+        const ids = Array.isArray(rawIds) ? [...new Set(rawIds.filter((id) => typeof id === "string" && id.length > 0))] : [];
+        if (ids.length === 0)
+            return JSON.stringify({ sent: false, error: "no digest: name at least one finding id from the latest house_sweep. When nothing needs the owner, say nothing." });
+        const replay = replayAsker(ctx);
+        const scope = replay ? "replay" : "live";
+        // The digest comes only from the sweep THIS process ran. Files under state/house-sweep/ are writable by the resident's uid: untrusted bookkeeping, never a source of owner-facing text.
+        const last = (0, house_sweep_1.recallSweep)(agentRoot, scope);
+        if (!last)
+            return JSON.stringify({ sent: false, error: "no sweep has run in this session: run house_sweep first and use its finding ids." });
+        const known = new Map(last.map((finding) => [finding.id, finding]));
+        const unknown = ids.filter((id) => !known.has(id));
+        if (unknown.length > 0)
+            return JSON.stringify({ sent: false, error: `unknown finding ids: ${unknown.join(", ")}. Run house_sweep first and use its ids.` });
+        const chosen = ids.map((id) => known.get(id));
+        const rawLead = args.lead_in;
+        const leadIn = typeof rawLead === "string" ? rawLead.trim() : "";
+        if (leadIn.length > exports.LEAD_IN_MAX_CHARS || (0, house_sweep_1.safe)(leadIn) !== leadIn || LEAD_IN_FORBIDDEN.test(leadIn))
+            return JSON.stringify({ sent: false, error: `lead_in must be one plain line of at most ${exports.LEAD_IN_MAX_CHARS} characters, with no links, addresses, mentions or hidden characters` });
+        const now = (injected.now ?? Date.now)();
+        if (sweepYieldsToReplay(ctx, now))
+            return REPLAY_YIELD;
+        const digest = (0, node_crypto_1.createHash)("sha256").update(chosen.map((finding) => finding.fingerprint).sort().join(",")).digest("hex").slice(0, 12);
+        const friendId = askerFriendId(ctx);
+        const agentName = ctx.agentName ?? "sanctuary";
+        // A peer's digest says whose it is; the body is only ever the stored finding summaries.
+        const peer = ctx.relationshipAuthorization?.profileId === "sanctuary-agent-peer" ? `From ${(0, house_sweep_1.clip)((0, house_sweep_1.safe)(ctx.context?.friend?.name ?? friendId ?? "a peer"), PEER_NAME_MAX) || "a peer"}:\n` : "";
+        const clipped = chosen.map((finding) => (0, house_sweep_1.clip)((0, house_sweep_1.safe)(finding.summary), 220));
+        const rendered = digestLines(clipped);
+        // Only the findings whose lines are in the digest count as told; the ones behind "and N more" stay fresh for the next digest.
+        const shown = chosen.filter((_, i) => rendered.shownSummaries.has(clipped[i]));
+        const body = `${peer}${leadIn ? `${leadIn}\n` : ""}${rendered.lines.join("\n")}`;
+        if (replay) {
+            // A replay identity's digest never reaches the owner: it goes to the sink while the window is open, and is refused when it is not.
+            if (!friendId || !(0, replay_harness_1.isReplayWindowOpen)(agentRoot, friendId, now))
+                return JSON.stringify({ sent: false, error: "this is a replay request and no replay window is open for it, so nothing was sent to the owner" });
+            (0, replay_harness_1.appendReplayNotice)(agentRoot, { noticeId: `house-sweep:replay:${now}:${digest}`, text: body, friendId }, now);
+            (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.house_digest_sent", message: "house digest written to the replay sink", meta: { findings: ids.length, destination: "replay-sink" } });
+            return JSON.stringify({ sent: true, destination: "replay sink", findings: ids.length });
+        }
+        // Enforced here, not only in the sweep: the ledger is reloaded at send time.
+        const ledger = (0, house_sweep_1.readLedger)(agentRoot);
+        const priorStamp = (0, house_sweep_1.readLastDigestAt)(agentRoot);
+        const stamp = new Date(now).toISOString();
+        const told = chosen.filter((finding) => {
+            const entry = ledger[finding.id];
+            return entry !== undefined && entry.fingerprint === finding.fingerprint && now - Date.parse(entry.reportedAt) < house_sweep_1.REMIND_DAYS * DAY_MS;
+        });
+        if (told.length > 0)
+            return JSON.stringify({ sent: false, error: `the owner was already told about ${told.map((finding) => finding.id).join(", ")} unchanged in the last ${house_sweep_1.REMIND_DAYS} days; leave ${told.length === 1 ? "it" : "them"} out` });
+        // Only the daily house-care await's own tick is "scheduled" and takes the one-per-day slot; on-demand digests are limited by the per-finding dedupe above.
+        // The package-managed await may run under the owner's own relationship authorization (the live runtime binds it that way), which does not downgrade it;
+        // The system await has no relationship coordinates, so the pipeline binds the self friend: no authorization with no friend or the self friend is the managed tick itself.
+        // Any other relationship (a peer, a friend) or a real friend with no authorization behind the tick downgrades.
+        const ownerBound = ctx.relationshipAuthorization?.profileId === "sanctuary-owner";
+        const kind = isManagedSweepTick(ctx) && (ownerBound || (!ctx.relationshipAuthorization && (!friendId || friendId === tools_base_1.SELF_FRIEND_ID))) ? "scheduled" : "ondemand";
+        if (kind === "scheduled" && (0, house_sweep_1.sameUtcDay)(priorStamp, stamp))
+            return JSON.stringify({ sent: false, error: "the daily house digest already went out today; at most one scheduled digest is sent per day" });
+        const day = stamp.slice(0, 10);
+        // Reserve before sending so a crash or a concurrent turn cannot send twice; a failed send rolls the reservation back.
+        const reserved = { ...ledger };
+        for (const finding of shown)
+            reserved[finding.id] = { fingerprint: finding.fingerprint, reportedAt: stamp };
+        (0, house_sweep_1.writeLedger)(agentRoot, reserved, kind === "scheduled" ? stamp : priorStamp);
+        try {
+            await (injected.notifyOwner ? injected.notifyOwner(agentName) : (0, a2a_await_delivery_1.defaultNotifyOwner)(agentName))({ noticeId: `house-sweep:${kind}:${day}:${digest}`, text: body });
+        }
+        catch (error) {
+            (0, house_sweep_1.writeLedger)(agentRoot, ledger, priorStamp);
+            return JSON.stringify({ sent: false, error: `the owner notice could not be sent: ${error instanceof Error ? error.message : String(error)}. Nothing was recorded as told, so the next sweep will try again.` });
+        }
+        (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.house_digest_sent", message: "house digest sent to the owner", meta: { findings: ids.length, destination: "owner", kind } });
+        return JSON.stringify({ sent: true, destination: "owner", findings: ids.length });
+    },
+    summaryKeys: ["finding_ids"],
+    riskProfile: { mutates: "external_side_effect", risk: "high", reason: "sends the owner a Telegram notice" },
+};
+exports.houseCareToolDefinitions = [exports.houseSweepToolDefinition, exports.houseDigestToolDefinition];