@ouro.bot/cli 0.1.0-alpha.65 → 0.1.0-alpha.651

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 inner dialog, 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 inner session 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 inner 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 an inner-session turn when i'm done thinking. rest remains the explicit terminal move for the inner session 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;
-}