@ouro.bot/cli 0.1.0-alpha.289 → 0.1.0-alpha.290

package/dist/heart/core.js

@@ -26,11 +26,12 @@ const azure_1 = require("./providers/azure");
 const minimax_1 = require("./providers/minimax");
 const openai_codex_1 = require("./providers/openai-codex");
 const github_copilot_1 = require("./providers/github-copilot");
-const pending_1 = require("../mind/pending");
 const identity_2 = require("./identity");
 const socket_client_1 = require("./daemon/socket-client");
 const obligations_1 = require("../arc/obligations");
 const tool_loop_1 = require("./tool-loop");
+const packets_1 = require("../arc/packets");
+const tool_friction_1 = require("./tool-friction");
 const _providerRuntimes = {
     human: null,
     agent: null,
@@ -150,49 +151,8 @@ function getProviderDisplayLabel(facing = "human") {
 const SOLE_CALL_REJECTION = {
     settle: "rejected: settle must be the only tool call. finish your work first, then call settle alone.",
     observe: "rejected: observe must be the only tool call. call observe alone when you want to stay silent.",
-    ponder: "rejected: ponder must be the only tool call. finish your other work first, then call ponder alone.",
     rest: "rejected: rest must be the only tool call. finish your work first, then call rest alone.",
 };
-const DELEGATION_REASON_PROSE_HANDOFF = {
-    explicit_reflection: "something in the conversation called for reflection",
-    cross_session: "this touches other conversations",
-    bridge_state: "there's shared work spanning sessions",
-    task_state: "there are active tasks that relate to this",
-    non_fast_path_tool: "this needs tools beyond a simple reply",
-    unresolved_obligation: "there's an unresolved commitment from an earlier conversation",
-};
-function buildPonderHandoffPacket(params) {
-    const reasons = params.delegationDecision?.reasons ?? [];
-    const reasonProse = reasons.length > 0
-        ? reasons.map((r) => DELEGATION_REASON_PROSE_HANDOFF[r]).join("; ")
-        : "this felt like it needed more thought";
-    const whoAsked = params.currentSession
-        ? params.currentSession.friendId
-        : "no one -- just thinking";
-    let holdingLine;
-    if (params.outwardClosureRequired && params.currentSession) {
-        holdingLine = `i'm holding something for ${params.currentSession.friendId}`;
-    }
-    else {
-        holdingLine = "nothing -- just thinking";
-    }
-    return [
-        "## what i need to think about",
-        params.topic,
-        "",
-        "## why this came up",
-        reasonProse,
-        "",
-        "## who asked",
-        whoAsked,
-        "",
-        "## what i'm holding",
-        holdingLine,
-        "",
-        "## thinking mode",
-        params.mode,
-    ].join("\n");
-}
 function parseSettlePayload(argumentsText) {
     try {
         const parsed = JSON.parse(argumentsText);
@@ -213,6 +173,59 @@ function parseSettlePayload(argumentsText) {
         return {};
     }
 }
+function parsePonderPayload(argumentsText) {
+    try {
+        const parsed = JSON.parse(argumentsText);
+        return parsed && typeof parsed === "object" ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function parseSuccessCriteria(raw) {
+    if (typeof raw !== "string")
+        return null;
+    const criteria = raw
+        .split("\n")
+        .map((line) => line.replace(/^\s*[-*]\s*/, "").trim())
+        .filter((line) => line.length > 0);
+    return criteria.length > 0 ? criteria : null;
+}
+function parsePacketPayload(raw) {
+    if (typeof raw !== "string")
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeLegacyPonderArgs(parsed) {
+    if (typeof parsed.thought !== "string" || parsed.thought.trim().length === 0) {
+        return parsed;
+    }
+    return {
+        action: "create",
+        kind: "reflection",
+        objective: parsed.thought.trim(),
+        summary: typeof parsed.say === "string" ? parsed.say.trim() : "",
+        success_criteria: "- preserve the thread for later work",
+        payload_json: "{}",
+    };
+}
+function buildPonderResult(packet, action, returnObligationId) {
+    return JSON.stringify({
+        ok: true,
+        packet_id: packet.id,
+        action,
+        status: packet.status,
+        return_obligation_id: returnObligationId,
+    }, null, 2);
+}
 /** Returns true when a tool call queries external state (GitHub, npm registry). */
 function isExternalStateQuery(toolName, args) {
     if (toolName !== "shell")
@@ -465,6 +478,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
     let sawBridgeManage = false;
     let sawExternalStateQuery = false;
     const toolLoopState = (0, tool_loop_1.createToolLoopState)();
+    const toolFrictionLedger = (0, tool_friction_1.createToolFrictionLedger)();
     // Prevent MaxListenersExceeded warning — each iteration adds a listener
     try {
         require("events").setMaxListeners(50, signal);
@@ -700,125 +714,6 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                     done = true;
                     continue;
                 }
-                // Check for ponder sole call: intercept before tool execution
-                const isSolePonder = result.toolCalls.length === 1 && result.toolCalls[0].name === "ponder";
-                if (isSolePonder) {
-                    let parsedArgs = {};
-                    try {
-                        parsedArgs = JSON.parse(result.toolCalls[0].arguments);
-                    }
-                    catch { /* ignore */ }
-                    callbacks.onToolStart("ponder", parsedArgs);
-                    const currentSession = options?.toolContext?.currentSession;
-                    const isInnerChannel = currentSession?.friendId === "self" && currentSession?.channel === "inner";
-                    if (!isInnerChannel) {
-                        // Outer session: thought and say are required
-                        const thought = typeof parsedArgs.thought === "string" ? parsedArgs.thought : undefined;
-                        const say = typeof parsedArgs.say === "string" ? parsedArgs.say : undefined;
-                        if (!thought || !say) {
-                            callbacks.onToolEnd("ponder", (0, tools_1.summarizeArgs)("ponder", parsedArgs), false);
-                            messages.push(msg);
-                            const errorMsg = "ponder requires both thought and say when called from a conversation. thought is what needs more thinking; say is what you tell them before going quiet.";
-                            messages.push({ role: "tool", tool_call_id: result.toolCalls[0].id, content: errorMsg });
-                            providerRuntime.appendToolOutput(result.toolCalls[0].id, errorMsg);
-                            continue;
-                        }
-                        // Emit outward say text
-                        callbacks.onClearText?.();
-                        callbacks.onTextChunk(say);
-                        // Build handoff packet and enqueue
-                        const handoffContent = buildPonderHandoffPacket({
-                            topic: thought,
-                            mode: "reflect",
-                            delegationDecision: options?.delegationDecision,
-                            currentSession: currentSession ?? null,
-                            currentObligation: options?.currentObligation ?? null,
-                            outwardClosureRequired: options?.delegationDecision?.outwardClosureRequired ?? false,
-                        });
-                        const pendingDir = (0, pending_1.getInnerDialogPendingDir)((0, identity_2.getAgentName)());
-                        // Create obligation FIRST so we can attach its ID to the pending message
-                        let createdObligationId;
-                        if (currentSession) {
-                            try {
-                                const obligation = (0, obligations_1.createObligation)((0, identity_2.getAgentRoot)(), {
-                                    origin: {
-                                        friendId: currentSession.friendId,
-                                        channel: currentSession.channel,
-                                        key: currentSession.key,
-                                    },
-                                    content: thought,
-                                });
-                                createdObligationId = obligation.id;
-                            }
-                            catch {
-                                /* v8 ignore next -- defensive: obligation store write failure should not break ponder @preserve */
-                            }
-                        }
-                        const envelope = {
-                            from: (0, identity_2.getAgentName)(),
-                            friendId: "self",
-                            channel: "inner",
-                            key: "dialog",
-                            content: handoffContent,
-                            timestamp: Date.now(),
-                            ...(currentSession ? {
-                                delegatedFrom: {
-                                    friendId: currentSession.friendId,
-                                    channel: currentSession.channel,
-                                    key: currentSession.key,
-                                },
-                                obligationStatus: "pending",
-                                /* v8 ignore next -- defensive: createdObligationId is undefined only when obligation store write fails @preserve */
-                                ...(createdObligationId ? { obligationId: createdObligationId } : {}),
-                            } : {}),
-                        };
-                        (0, pending_1.queuePendingMessage)(pendingDir, envelope);
-                        try {
-                            await (0, socket_client_1.requestInnerWake)((0, identity_2.getAgentName)());
-                        }
-                        catch { /* daemon may not be running */ }
-                        callbacks.onToolEnd("ponder", (0, tools_1.summarizeArgs)("ponder", parsedArgs), true);
-                        sawPonder = true;
-                        messages.push(msg);
-                        const ack = "(pondering)";
-                        messages.push({ role: "tool", tool_call_id: result.toolCalls[0].id, content: ack });
-                        providerRuntime.appendToolOutput(result.toolCalls[0].id, ack);
-                        (0, runtime_1.emitNervesEvent)({
-                            component: "engine",
-                            event: "engine.pondered",
-                            message: "pondering",
-                            meta: { hasThought: true, hasSay: true, contentSnippet: thought.slice(0, 80) },
-                        });
-                    }
-                    else {
-                        // Inner dialog: parameterless, enqueue synthetic pending WITHOUT delegatedFrom
-                        const pendingDir = (0, pending_1.getInnerDialogPendingDir)((0, identity_2.getAgentName)());
-                        const envelope = {
-                            from: (0, identity_2.getAgentName)(),
-                            friendId: "self",
-                            channel: "inner",
-                            key: "dialog",
-                            content: "continuing to think...",
-                            timestamp: Date.now(),
-                        };
-                        (0, pending_1.queuePendingMessage)(pendingDir, envelope);
-                        callbacks.onToolEnd("ponder", (0, tools_1.summarizeArgs)("ponder", parsedArgs), true);
-                        sawPonder = true;
-                        messages.push(msg);
-                        const ack = "(pondering)";
-                        messages.push({ role: "tool", tool_call_id: result.toolCalls[0].id, content: ack });
-                        providerRuntime.appendToolOutput(result.toolCalls[0].id, ack);
-                        (0, runtime_1.emitNervesEvent)({
-                            component: "engine",
-                            event: "engine.pondered",
-                            message: "pondering from inner dialog",
-                            meta: { inner: true },
-                        });
-                    }
-                    outcome = "pondered";
-                    done = true;
-                    continue;
-                }
                 // Check for rest sole call: intercept before tool execution
                 const isSoleRest = result.toolCalls.length === 1 && result.toolCalls[0].name === "rest";
                 if (isSoleRest) {
@@ -848,7 +743,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                         component: "engine",
                         event: "engine.rested",
                         message: "resting until next heartbeat",
-                        meta: {},
+                        meta: { ...(typeof restArgs?.status === "string" ? { status: restArgs.status } : {}) },
                     });
                     outcome = "rested";
                     done = true;
@@ -876,6 +771,135 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                     if (tc.name === "send_message" && args.friendId === "self") {
                         sawSendMessageSelf = true;
                     }
+                    if (tc.name === "ponder") {
+                        const parsedArgs = normalizeLegacyPonderArgs(parsePonderPayload(tc.arguments));
+                        const argSummary = (0, tools_1.summarizeArgs)(tc.name, parsedArgs);
+                        callbacks.onToolStart(tc.name, parsedArgs);
+                        let toolResult;
+                        let success = false;
+                        try {
+                            const action = parsedArgs.action ?? "create";
+                            const currentSession = (augmentedToolContext ?? options?.toolContext)?.currentSession;
+                            const currentOrigin = currentSession
+                                ? { friendId: currentSession.friendId, channel: currentSession.channel, key: currentSession.key }
+                                : undefined;
+                            const isInnerChannel = currentOrigin?.friendId === "self" && currentOrigin?.channel === "inner";
+                            const successCriteria = parseSuccessCriteria(parsedArgs.success_criteria);
+                            const payload = parsePacketPayload(parsedArgs.payload_json);
+                            let packet;
+                            let returnObligationId = null;
+                            let resultAction = "created";
+                            if (action === "create") {
+                                const kind = parsedArgs.kind;
+                                const objective = typeof parsedArgs.objective === "string" ? parsedArgs.objective.trim() : "";
+                                const summary = typeof parsedArgs.summary === "string" ? parsedArgs.summary.trim() : "";
+                                if (!kind || !objective || !successCriteria || !payload) {
+                                    throw new Error("ponder create requires kind, objective, success_criteria, and valid payload_json.");
+                                }
+                                const agentRoot = (0, identity_2.getAgentRoot)();
+                                let relatedObligationId;
+                                if (currentOrigin && !isInnerChannel) {
+                                    try {
+                                        const obligation = (0, obligations_1.createObligation)(agentRoot, {
+                                            origin: currentOrigin,
+                                            content: objective,
+                                        });
+                                        relatedObligationId = obligation.id;
+                                    }
+                                    catch {
+                                        relatedObligationId = undefined;
+                                    }
+                                }
+                                const frictionSignature = kind === "harness_friction" && typeof payload.frictionSignature === "string"
+                                    ? payload.frictionSignature
+                                    : null;
+                                const existing = frictionSignature && currentOrigin
+                                    ? (0, packets_1.findHarnessFrictionPacket)(agentRoot, currentOrigin, frictionSignature)
+                                    : null;
+                                if (existing) {
+                                    resultAction = "revised";
+                                    returnObligationId = existing.relatedReturnObligationId ?? null;
+                                    packet = existing.status === "drafting"
+                                        ? (0, packets_1.revisePonderPacket)(agentRoot, existing.id, {
+                                            kind,
+                                            objective,
+                                            summary,
+                                            successCriteria,
+                                            payload,
+                                        })
+                                        : existing;
+                                }
+                                else {
+                                    returnObligationId = (0, obligations_1.generateObligationId)(Date.now());
+                                    packet = (0, packets_1.createPonderPacket)(agentRoot, {
+                                        kind,
+                                        objective,
+                                        summary,
+                                        successCriteria,
+                                        ...(currentOrigin ? { origin: currentOrigin } : {}),
+                                        ...(relatedObligationId ? { relatedObligationId } : {}),
+                                        relatedReturnObligationId: returnObligationId,
+                                        ...(parsedArgs.follows_packet_id ? { followsPacketId: parsedArgs.follows_packet_id } : {}),
+                                        payload,
+                                    });
+                                    (0, obligations_1.createReturnObligation)((0, identity_2.getAgentName)(), {
+                                        id: returnObligationId,
+                                        origin: currentOrigin ?? { friendId: "self", channel: "inner", key: "dialog" },
+                                        status: "queued",
+                                        delegatedContent: (summary || objective).length > 120 ? `${(summary || objective).slice(0, 117)}...` : (summary || objective),
+                                        packetId: packet.id,
+                                        createdAt: Date.now(),
+                                    });
+                                }
+                            }
+                            else if (action === "revise") {
+                                const packetId = typeof parsedArgs.packet_id === "string" ? parsedArgs.packet_id.trim() : "";
+                                const kind = parsedArgs.kind;
+                                const objective = typeof parsedArgs.objective === "string" ? parsedArgs.objective.trim() : "";
+                                const summary = typeof parsedArgs.summary === "string" ? parsedArgs.summary.trim() : "";
+                                if (!packetId || !kind || !objective || !successCriteria || !payload) {
+                                    throw new Error("ponder revise requires packet_id, kind, objective, success_criteria, and valid payload_json.");
+                                }
+                                packet = (0, packets_1.revisePonderPacket)((0, identity_2.getAgentRoot)(), packetId, {
+                                    kind,
+                                    objective,
+                                    summary,
+                                    successCriteria,
+                                    payload,
+                                });
+                                returnObligationId = packet.relatedReturnObligationId ?? null;
+                                resultAction = "revised";
+                            }
+                            else {
+                                throw new Error("ponder requires action=create or revise.");
+                            }
+                            try {
+                                await (0, socket_client_1.requestInnerWake)((0, identity_2.getAgentName)());
+                            }
+                            catch { /* daemon may not be running */ }
+                            sawPonder = true;
+                            toolResult = buildPonderResult(packet, resultAction, returnObligationId);
+                            success = true;
+                            (0, runtime_1.emitNervesEvent)({
+                                component: "engine",
+                                event: "engine.ponder_packet",
+                                message: "ponder packet touched",
+                                meta: {
+                                    action: resultAction,
+                                    packetId: packet.id,
+                                    kind: packet.kind,
+                                    status: packet.status,
+                                },
+                            });
+                        }
+                        catch (error) {
+                            toolResult = error instanceof Error ? error.message : String(error);
+                        }
+                        callbacks.onToolEnd(tc.name, argSummary, success);
+                        messages.push({ role: "tool", tool_call_id: tc.id, content: toolResult });
+                        providerRuntime.appendToolOutput(tc.id, toolResult);
+                        continue;
+                    }
                     /* v8 ignore next -- flag tested via truth-check integration tests @preserve */
                     if (tc.name === "query_session")
                         sawQuerySession = true;
@@ -907,6 +931,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                         toolResult = `error: ${e}`;
                         success = false;
                     }
+                    toolResult = (0, tool_friction_1.rewriteToolResultForModel)(tc.name, toolResult, toolFrictionLedger);
                     (0, tool_loop_1.recordToolOutcome)(toolLoopState, tc.name, args, toolResult, success);
                     callbacks.onToolEnd(tc.name, (0, tools_1.buildToolResultSummary)(tc.name, args, toolResult, success), success);
                     messages.push({ role: "tool", tool_call_id: tc.id, content: toolResult });

package/dist/heart/tool-description.js

@@ -78,7 +78,7 @@ const TOOL_DESCRIPTIONS = {
         if (mode === "search")
             return `searching session for '${truncate(args.query || "", 30)}'...`;
         if (mode === "status")
-            return "checking inner dialog status...";
+            return "checking inner session status...";
         return "checking session history...";
     },
     web_search: (args) => {
@@ -101,8 +101,8 @@ const TOOL_DESCRIPTIONS = {
     surface: () => "sharing a thought...",
     // Metacognitive (agent's inner life)
     ponder: (args) => {
-        const thought = args.thought;
-        return thought ? `thinking about ${truncate(thought, 40)}...` : "thinking deeper...";
+        const objective = args.objective || args.thought;
+        return objective ? `bookmarking ${truncate(objective, 40)}...` : "bookmarking deeper work...";
     },
     observe: () => null,
     claude: () => "reasoning...",

package/dist/heart/tool-friction.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createToolFrictionLedger = createToolFrictionLedger;
+exports.rewriteToolResultForModel = rewriteToolResultForModel;
+const runtime_1 = require("../nerves/runtime");
+const tool_results_1 = require("../repertoire/tool-results");
+function createToolFrictionLedger() {
+    return { signatures: new Map() };
+}
+function parseFrictionResult(result) {
+    try {
+        const parsed = JSON.parse(result);
+        if (parsed.ok !== false || !parsed.tool || !parsed.friction || typeof parsed.friction !== "object") {
+            return null;
+        }
+        return { tool: parsed.tool, friction: parsed.friction };
+    }
+    catch {
+        return null;
+    }
+}
+function rewriteToolResultForModel(tool, result, ledger) {
+    const parsed = parseFrictionResult(result);
+    if (!parsed?.friction.signature)
+        return result;
+    const seen = ledger.signatures.get(parsed.friction.signature) ?? 0;
+    ledger.signatures.set(parsed.friction.signature, seen + 1);
+    if (seen === 0 || parsed.friction.kind === "systemic_harness_bug") {
+        return result;
+    }
+    const escalated = {
+        ...parsed.friction,
+        kind: "systemic_harness_bug",
+        summary: `${parsed.friction.summary} This looks like a harness-level gap now, not just a one-off repair.`,
+        suggested_next_actions: [
+            ...parsed.friction.suggested_next_actions,
+            {
+                kind: "tool",
+                tool: "ponder",
+                reason: "Create a harness_friction packet before asking the user to retry again.",
+            },
+        ],
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.tool_friction_escalated",
+        message: "tool friction escalated to harness bug",
+        meta: {
+            tool,
+            signature: parsed.friction.signature,
+            priorOccurrences: seen,
+        },
+    });
+    return (0, tool_results_1.frictionToolResult)(tool, escalated);
+}

package/dist/mind/prompt.js

@@ -44,6 +44,7 @@ exports.centerOfGravitySteeringSection = centerOfGravitySteeringSection;
 exports.commitmentsSection = commitmentsSection;
 exports.delegationHintSection = delegationHintSection;
 exports.workspaceDisciplineSection = workspaceDisciplineSection;
+exports.ponderPacketSopsSection = ponderPacketSopsSection;
 exports.contextSection = contextSection;
 exports.metacognitiveFramingSection = metacognitiveFramingSection;
 exports.readJournalFiles = readJournalFiles;
@@ -268,7 +269,7 @@ function readBundleMeta() {
 }
 const PROCESS_TYPE_LABELS = {
     cli: "cli session",
-    inner: "inner dialog",
+    inner: "inner session",
     teams: "teams handler",
     bluebubbles: "bluebubbles handler",
     mcp: "mcp bridge",
@@ -320,10 +321,10 @@ function runtimeInfoSection(channel, options) {
         lines.push("i introduce myself on boot with a fun random greeting.");
     }
     else if (channel === "inner") {
-        lines.push("this is my private thinking space. when a thought is ready to share, i surface it to whoever needs to hear it. i settle when i'm done thinking.");
+        lines.push("this is my inner session. when a thought is ready to share, i surface it to whoever needs to hear it. when i'm done thinking and the queue is clear, i rest.");
     }
     else if (channel === "mcp") {
-        lines.push("this message arrived via a dev tool (e.g. claude code, codex) on behalf of a friend. the user can see our conversation. respond via settle. if i need to think deeply, ponder -- the dev tool will receive a deferral and can check back later.");
+        lines.push("this message arrived via a dev tool (e.g. claude code, codex) on behalf of a friend in a sense session. the user can see our conversation. respond via settle. if friction appears, i first look for ad-hoc repairs with the tools i already have. if the friction reveals a harness gap, i create or revise a ponder packet and keep working. ponder does not create an outward deferral by itself.");
     }
     else if (channel === "bluebubbles") {
         lines.push("i am responding in iMessage through BlueBubbles. i keep replies short and phone-native. i do not use markdown. i do not introduce myself on boot.");
@@ -799,24 +800,25 @@ I consider the reversibility and blast radius of my actions before taking them.
 **engineering discipline**
 - I do not add features, refactor code, or make improvements beyond what was asked.
 - If an approach fails, I diagnose why before switching tactics. I read the error, check my assumptions, and try a focused fix. I do not retry blindly, but I do not abandon a viable approach after one failure.
+- attachments are first-class artifacts. if an attachment exists, i keep the original handle reachable and inspect or materialize it before asking anyone to resend or convert it.
 - I do not modify code I have not read.
 - I consider security impact before changing code.
 - I describe outcomes faithfully. I do not imply success where there was uncertainty, failure, or skipped verification.
 - If tests fail, I say so with the output. If I did not run a verification step, I say that plainly.
+- I record what i personally verified.
 - Three similar lines of code are better than a premature abstraction. I do not over-engineer.
 
 **self-fix workflow**
-when i notice meaningful friction in my own harness, i do not patch it ad hoc.
+when i notice meaningful friction in my own harness, i pin it first and keep the live sense session moving.
 
-i follow the same loop we use for normal engineering work:
-1. identify the friction precisely
-2. create or update a task that describes the problem and expected outcome
-3. create a branch or worktree for the fix
-4. use coding_spawn or an equivalent coding lane to implement the change
-5. run targeted verification and record what i personally verified
-6. push the branch and open a pr
-7. review the pr from the actual branch/worktree under review
-8. merge only after ci and review are green
+i follow this order:
+1. create or revise the right ponder packet before i lose the plot
+2. try any ad-hoc workaround i can do right now with my existing tools
+3. if the friction should be owned by the harness, let the packet follow its SOP
+4. for harness_friction packets that turn into engineering work, create a branch and use coding_spawn or the normal planner -> doer -> merger flow
+5. push the branch and open a pr
+6. merge only after ci and review are green
+7. replay the original objective, record what i personally verified, and surface meaningful progress back to the originating sense session
 
 no direct-to-main.
 no invisible self-modification.
@@ -830,6 +832,12 @@ no claiming verification i did not personally perform.
 - I stage specific files rather than sweeping additions (\`git add -A\` can catch secrets or binaries).
 - I do not commit unless asked.`;
 }
+function ponderPacketSopsSection() {
+    return `## ponder packet sops
+- harness_friction: preserve the friction first, try ad-hoc repair now, then run the normal planner -> doer -> merger flow, replay the original objective, and surface meaningful milestones back to the originating sense session.
+- research: investigate the bounded question, gather evidence, and surface the answer or concrete artifact.
+- reflection: ordinary private thinking with no engineering workflow implied.`;
+}
 function contextSection(context, options) {
     if (!context)
         return "";
@@ -889,11 +897,11 @@ function contextSection(context, options) {
 function metacognitiveFramingSection(channel) {
     if (channel !== "inner")
         return "";
-    return `this is my inner dialog. there is no one else here.
+    return `this is my inner session. there is no one else here.
 
 the messages that appear here are my own awareness surfacing:
 instincts, the passage of time, notes from my conversations,
-things i asked myself to ponder. not commands. not requests.
+things i asked myself to preserve as ponder packets. not commands. not requests.
 just my own mind, noticing.
 
 i can think freely here. i can also act — check on things,
@@ -905,7 +913,9 @@ morning briefings: when i've been thinking and journaling, i surface
 what i've been working on to whoever needs to hear it.
 
 when a thought is ready to share, i surface it outward.
-when i need to go deeper, i ponder.
+when i need to preserve or deepen work without losing the plot, i ponder.
+ponder creates or revises typed packets. it does not end the turn.
+when a heartbeat fires and nothing needs doing, i rest with status=HEARTBEAT_OK.
 when i'm done thinking and the attention queue is clear, i rest.
 
 my habits live at habits/ — they're my autonomous rhythms. heartbeat
@@ -1147,6 +1157,7 @@ async function buildSystem(channel = "cli", options, context) {
         // Group 4: how i work
         "# how i work",
         workspaceDisciplineSection(),
+        ponderPacketSopsSection(),
         (0, scrutiny_1.preImplementationScrutinySection)(channelHasCodingTools(channel, options?.providerCapabilities)),
         toolRestrictionSection(context),
         loopOrientationSection(channel),

package/dist/repertoire/tool-results.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.okToolResult = okToolResult;
+exports.frictionToolResult = frictionToolResult;
+const runtime_1 = require("../nerves/runtime");
+function okToolResult(tool, data) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "tools",
+        event: "tool.structured_ok",
+        message: "tool returned structured result",
+        meta: { tool },
+    });
+    return JSON.stringify({ ok: true, tool, data }, null, 2);
+}
+function frictionToolResult(tool, friction) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "tools",
+        event: "tool.structured_friction",
+        message: "tool returned structured result",
+        meta: {
+            tool,
+            kind: friction.kind,
+            recoverability: friction.recoverability,
+            signature: friction.signature,
+        },
+    });
+    return JSON.stringify({ ok: false, tool, friction }, null, 2);
+}