@ouro.bot/cli 0.1.0-alpha.81 → 0.1.0-alpha.811

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-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;
+        },
+    },
+];