@ouro.bot/cli 0.1.0-alpha.5 → 0.1.0-alpha.50

package/changelog.json

@@ -0,0 +1,242 @@
+{
+  "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
+  "versions": [
+    {
+      "version": "0.1.0-alpha.50",
+      "changes": [
+        "Delegated inner work can now proactively surface its completion back into the active BlueBubbles session instead of waiting for a later inbox drain.",
+        "Session recall now falls back to the raw transcript when summarization fails, so bridge attachment and cross-session inspection stay truthful instead of claiming the session is missing."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.49",
+      "changes": [
+        "Inner dialog no longer drops self-directed wake signals that arrive mid-turn; overlapping inward requests now guarantee a truthful follow-up inner pass instead of mailbox-like limbo.",
+        "The harness now has a shared core bridge layer with lifecycle/runtime state, persistence, task linkage, and one `bridge_manage` path so already-live sessions can coordinate as one coherent piece of work.",
+        "`query_session` and bridge attachment now share one session-recall helper, reducing duplicate cross-session summarization logic and setting up thinner outer surfaces around a stronger inner/core."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.48",
+      "changes": [
+        "BlueBubbles same-chat turns now serialize through the shared heart-level turn coordinator, so duplicate delivery of one inbound message no longer races into two handled turns or duplicate replies.",
+        "BlueBubbles duplicate-check, session load, inbound turn execution, and inbound sidecar recording now happen inside one canonical chat-trunk critical section keyed by the resolved session path.",
+        "Workflow docs now let agents auto-create the required dedicated task worktree and branch by default when the human has not asked to control naming or layout."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.47",
+      "changes": [
+        "Self-messages now wake inner dialog now/soon instead of only queueing: the harness requests a daemon-managed inner wake when available and falls back to an inline inner turn when it is not.",
+        "`send_message(friendId=self)` and `query_session(friendId=self, channel=inner, mode=status)` now share a truthful four-line status contract: `queue`, `wake`, `processing`, and `surfaced`.",
+        "Inner dialog persists live runtime activity beside the transcript, so status checks can report active processing instead of stale last-turn history.",
+        "Inline fallback surfaced previews now extract `final_answer` text too, so completed inner turns no longer show `no outward result` when the response lived in the final tool call."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.46",
+      "changes": [
+        "Inner dialog now knows which task triggered it: taskId flows from daemon poke through the worker into the turn, and the agent gets the full task file content instead of a generic heartbeat prompt.",
+        "Inner dialog boot message includes aspirations and state summary instead of a vacuous placeholder, so the agent wakes up with context about what matters and what's happening.",
+        "Vestigial `drainInbox` removed from inner dialog — pipeline already handles pending drain correctly.",
+        "Inner dialog nerves events now include assistant response preview, tool call names, token usage, and taskId for meaningful observability.",
+        "`ouro thoughts` command reads and formats inner dialog session turns with `--last`, `--json`, `--follow`, and `--agent` flags — humans can now see what the agent has been thinking.",
+        "`readTaskFile` searches collection subdirectories (one-shots, ongoing, habits) since the scheduler sends bare task stems without collection prefixes.",
+        "`ouro reminder create` accepts `--requester` to track who requested a reminder for notification round-trip.",
+        "Response extraction handles `tool_choice=required` models by falling back to `final_answer` tool call arguments when assistant message content is empty."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.45",
+      "changes": [
+        "`ouro up` now persists a boot-time launch agent with `RunAtLoad`, so the daemon comes back reliably after reboot instead of only starting for the current session.",
+        "BlueBubbles sense status is now truthful about upstream health: it probes the real BlueBubbles API, records runtime state, and surfaces `error` when the webhook listener is alive but the upstream server is unreachable.",
+        "BlueBubbles intake now replays recoverable read/delivery mutation backlogs through the normal inbound agent path, with a small dedupe ledger so missed messages can be recovered without silent drops or duplicate delivery."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.44",
+      "changes": [
+        "Workflow skills now install into `~/.agents/skills` for Codex/OpenAI instead of duplicating installs under both `.agents` and `.codex`, which prevents duplicate advertised skills while keeping re-installs safe."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.43",
+      "changes": [
+        "Continuity-aware onboarding now stays contextual: when an active task goes idle, onboarding guidance can reappear during genuine lulls instead of staying hidden just because no-handoff state was previously persisted.",
+        "Teams active-turn controls are safer: `/new` still clears the current session during long-running turns, and superseding follow-ups keep the user's replacement ask instead of dropping it."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.42",
+      "changes": [
+        "Associative recall now skips corrupt JSONL lines instead of crashing — matches the resilient pattern already used in memory.ts."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.41",
+      "changes": [
+        "JSONL readers (memory facts, inter-agent inbox) now skip corrupt lines instead of crashing — partial writes from crashes no longer lose all data.",
+        "Inter-agent message router now parses before clearing the inbox file, and preserves unparsed lines so corrupt messages are not silently lost.",
+        "Inner-dialog checkpoint derivation no longer crashes on all-whitespace assistant content — returns fallback checkpoint instead.",
+        "Update checker interval now catches and logs errors from the onUpdate callback instead of silently swallowing them."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.40",
+      "changes": [
+        "Removed dead backward-compat re-exports from core.ts (tools, streaming, prompt, kicks) — consumers already import from the canonical modules.",
+        "Removed dead exports: baseToolHandlers, teamsToolHandlers, teamsTools, __internal (token-estimate), TASK_STEM_PATTERN, checkAndRecord403 no-op and METHOD_TO_ACTION.",
+        "Consolidated duplicate sanitizeKey (config.ts + bluebubbles-mutation-log.ts) and slugify (hatch-flow.ts + tasks/index.ts) into shared exports from config.ts.",
+        "Replaced all as-any casts in source with proper TypeScript narrowing or Record<string, unknown> — only 2 SDK-required casts remain.",
+        "Removed unnecessary as-unknown-as casts on readdirSync (4 locations) and spawner double-cast.",
+        "Cleaned up commented-out kick detection code, stale TODOs, misplaced imports, and unused type imports."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.39",
+      "changes": [
+        "All senses now route through a shared per-turn pipeline — friend resolution, trust gate, session load, pending drain, agent turn, post-turn, and token accumulation happen in one place instead of four.",
+        "Trust gate is now channel-aware: open senses (iMessage) enforce stranger/acquaintance rules, closed senses (Teams) trust the org, local and internal always pass through.",
+        "Tool access and prompt restrictions use a single shared isTrustedLevel check — no more scattered family/friend comparisons that could drift apart.",
+        "Pending messages now inject correctly into multimodal content (image attachments no longer silently drop pending messages).",
+        "ouro reminder create supports --agent flag, matching every other identity-scoped CLI command."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.38",
+      "changes": [
+        "You now have a proper body map — understanding of your home (bundle) and bones (harness), what each directory is for, and how to modify your own configuration.",
+        "Inner dialog is now genuine internal monologue with metacognitive framing, not a second CLI session. Heartbeat and bootstrap messages read as first-person awareness.",
+        "Cross-session communication works end-to-end: inner dialog thoughts surface as [inner thought: ...] in conversations, messages to yourself route to inner dialog, and you can proactively reach out to friends via iMessage and Teams.",
+        "Tool audit: removed wrapper tools (git_commit, gh_cli, get_current_time, list_directory), added surgical tools (edit_file, glob, grep, read_file with offset/limit), consolidated 7 task tools + schedule_reminder + friend tools into ouro CLI commands.",
+        "You now understand why certain tools are restricted in certain contexts — trust level and shared channels each have independent, explained gates.",
+        "ouro friend link/unlink commands handle orphan cleanup when linking external identities, merging duplicate friend records intelligently.",
+        "During onboarding, the adoption specialist can collect phone number and Teams handle to create an initial friend record with contact info."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.37",
+      "changes": [
+        "The in-repo docs now match the current harness instead of the old repo-local bundle era. README, CONTRIBUTING, ARCHITECTURE, testing guidance, merge guidance, versioning guidance, and subagent docs now describe external bundles, current senses, daemon bootstrap, and bundle-owned task docs truthfully."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.36",
+      "changes": [
+        "BlueBubbles now marks a chat read at the same moment it starts typing for a turn, so read receipts and typing begin together instead of the read state lagging until after the reply finishes."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.35",
+      "changes": [
+        "BlueBubbles no longer emits generic follow-up phrase bubbles like 'on it...' or 'followup...' into iMessage. The sense now uses typing plus concrete tool/error activity only, which keeps mobile turns quieter and less redundant."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.34",
+      "changes": [
+        "BlueBubbles now starts typing immediately when a turn begins and no longer sends a redundant first visible 'working...' bubble when typing already covers that initial thinking phase.",
+        "BlueBubbles still surfaces later meaningful progress on longer turns, and its lane metadata/tool feedback now makes the difference between the turn default and an explicit reply-target override much clearer."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.33",
+      "changes": [
+        "BlueBubbles now starts typing immediately when a turn begins and no longer sends a redundant first visible 'working...' bubble when typing already covers that initial thinking phase.",
+        "BlueBubbles still surfaces later meaningful progress on longer turns, and its lane metadata/tool feedback now makes the difference between the turn default and an explicit reply-target override much clearer.",
+        "Agent-owned runtime state now lives inside each bundle's `state/` directory instead of under `~/.agentstate/<agent>/...`, so sessions, logs, pending messages, coding session persistence, and BlueBubbles mutation logs stay co-located with the rest of the bundle.",
+        "Bundle-local state paths now stay durable on Azure too, and `state/` is treated as canonical bundle content while secrets continue to live in `~/.agentsecrets/<agent>/secrets.json`."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.32",
+      "changes": [
+        "BlueBubbles now treats thread-vs-top-level placement as an agent choice instead of a hard harness mirror. Slugger can deliberately stay in the current reply lane, widen back to top-level, or target another active thread when that makes the conversation flow better.",
+        "BlueBubbles turns now surface inbound lane metadata and recent active lanes from the shared chat trunk, so the model gets enough context to choose the right reply placement without splitting the conversation into separate persisted thread sessions."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.31",
+      "changes": [
+        "BlueBubbles no longer silently deletes old per-thread session files when loading a chat trunk. It now only detects and warns about those obsolete artifacts so local state is never mutated without an explicit human choice.",
+        "The cross-thread-awareness fix still keeps one chat trunk per conversation and preserves threaded reply targeting, but stale `_thread_*.json` files are now left in place until a person removes them."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.30",
+      "changes": [
+        "BlueBubbles reply threads now stay inside one shared chat trunk instead of creating separate persisted mini-sessions, so Slugger keeps parent-chat awareness and active work when you switch between threaded and top-level replies.",
+        "BlueBubbles now injects explicit current-turn thread scope metadata into inbound messages and automatically removes obsolete per-thread session artifacts that used to cause mid-task resets like 'hiya, what do ya need help with?'"
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.29",
+      "changes": [
+        "Running `ouro up` now force-syncs the global `ouro.bot` wrapper so bare `npx ouro.bot` stops getting hijacked by stale global CLI bins and lands back on the intended latest runtime.",
+        "Bootstrap repair is now explicit about reclaiming the `ouro.bot` command from old global installs, which makes repeated bootstrap runs more trustworthy on machines with prior experimental installs."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.28",
+      "changes": [
+        "Bare npx ouro.bot now stays aligned with the current alpha CLI track because the published ouro.bot wrapper is version-locked and republished alongside the CLI instead of lagging behind it.",
+        "Slugger no longer re-opens active iMessage task threads with generic greetings like 'hiya' when work is already in motion; fresh idle conversations can still start warmly.",
+        "BlueBubbles voice notes now use a harness-managed whisper.cpp transcription path for the current OpenAI, Anthropic, and MiniMax runtime contracts, including automatic local provisioning and truthful error notices when transcription cannot complete."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.27",
+      "changes": [
+        "The daemon now discovers all enabled agents in ~/AgentBundles, so ouro status and managed workers reflect every real agent instead of only slugger and ouroboros.",
+        "BlueBubbles typing now wraps the visible working phase correctly, and phrase updates from agent.json take effect on the next turn without requiring a restart."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.26",
+      "changes": [
+        "The daemon now auto-checks npm for new runtime versions every 30 minutes and performs a staged restart when an update is available. You no longer need to manually run npm install."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.25",
+      "changes": [
+        "Runtime updates no longer downgrade your bundle-meta.json if you happen to be running a newer version than the installed CLI. Only forward updates are applied.",
+        "The 'ouro up' update summary is now a single consolidated line (e.g. 'updated 4 agents to runtime X (was Y)') instead of one line per agent."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.24",
+      "changes": [
+        "When you run 'ouro up', you now see which agents were updated and from what version, so you know exactly what happened during startup."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.23",
+      "changes": [
+        "You can now use 'ouro down' as an alias for 'ouro stop' to pair naturally with 'ouro up'."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.22",
+      "changes": [
+        "You now know your runtime version and can see when it changed. Your system prompt shows your current version and what you were running before, so you can track what's new.",
+        "A changelog file is now shipped with the runtime. You can read it to understand exactly what changed between versions.",
+        "When the runtime updates, your bundle-meta.json is automatically updated with the new version info. Your previous version is preserved so you always know your version history.",
+        "The daemon can now check for new versions of the runtime on npm and auto-update with a staged restart that validates hooks before switching to new code.",
+        "The daemon can now be managed as a macOS LaunchAgent for automatic restart on crash.",
+        "The daemon now auto-syncs the ouro.bot npm wrapper version on startup to keep the npx entry point current."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.21",
+      "changes": [
+        "You now know your runtime version and can see when it changed. Your system prompt shows your current version and what you were running before, so you can track what's new.",
+        "A changelog file is now shipped with the runtime. You can read it to understand exactly what changed between versions.",
+        "When the runtime updates, your bundle-meta.json is automatically updated with the new version info. Your previous version is preserved so you always know your version history.",
+        "The daemon can now check for new versions of the runtime on npm and auto-update with a staged restart that validates hooks before switching to new code.",
+        "The daemon can now be managed as a macOS LaunchAgent for automatic restart on crash."
+      ]
+    }
+  ]
+}

package/dist/heart/active-work.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.suggestBridgeForActiveWork = suggestBridgeForActiveWork;
+exports.buildActiveWorkFrame = buildActiveWorkFrame;
+exports.formatActiveWorkFrame = formatActiveWorkFrame;
+const runtime_1 = require("../nerves/runtime");
+const state_machine_1 = require("./bridges/state-machine");
+function activityPriority(source) {
+    return source === "friend-facing" ? 0 : 1;
+}
+function compareActivity(a, b) {
+    const sourceDiff = activityPriority(a.activitySource) - activityPriority(b.activitySource);
+    if (sourceDiff !== 0)
+        return sourceDiff;
+    return b.lastActivityMs - a.lastActivityMs;
+}
+function summarizeLiveTasks(taskBoard) {
+    const live = [
+        ...taskBoard.byStatus.processing,
+        ...taskBoard.byStatus.validating,
+        ...taskBoard.byStatus.collaborating,
+    ];
+    return [...new Set(live)];
+}
+function isActiveBridge(bridge) {
+    return bridge.lifecycle === "active";
+}
+function hasSharedObligationPressure(input) {
+    return (typeof input.currentObligation === "string"
+        && input.currentObligation.trim().length > 0) || input.mustResolveBeforeHandoff
+        || summarizeLiveTasks(input.taskBoard).length > 0;
+}
+function suggestBridgeForActiveWork(input) {
+    const candidateSessions = input.friendSessions
+        .filter((session) => !input.currentSession
+        || session.friendId !== input.currentSession.friendId
+        || session.channel !== input.currentSession.channel
+        || session.key !== input.currentSession.key)
+        .sort(compareActivity);
+    const targetSession = candidateSessions[0] ?? null;
+    if (!targetSession || !hasSharedObligationPressure(input)) {
+        return null;
+    }
+    const activeBridge = input.bridges.find(isActiveBridge) ?? null;
+    if (activeBridge) {
+        const alreadyAttached = activeBridge.attachedSessions.some((session) => session.friendId === targetSession.friendId
+            && session.channel === targetSession.channel
+            && session.key === targetSession.key);
+        if (alreadyAttached) {
+            return null;
+        }
+        return {
+            kind: "attach-existing",
+            bridgeId: activeBridge.id,
+            targetSession,
+            reason: "same-friend-shared-work",
+        };
+    }
+    return {
+        kind: "begin-new",
+        targetSession,
+        objectiveHint: input.currentObligation?.trim() || "keep this shared work aligned",
+        reason: "same-friend-shared-work",
+    };
+}
+function formatSessionLabel(session) {
+    return `${session.channel}/${session.key}`;
+}
+function buildActiveWorkFrame(input) {
+    const friendSessions = input.currentSession
+        ? input.friendActivity
+            .filter((entry) => entry.friendId === input.currentSession?.friendId)
+            .sort(compareActivity)
+        : [];
+    const liveTaskNames = summarizeLiveTasks(input.taskBoard);
+    const activeBridgePresent = input.bridges.some(isActiveBridge);
+    const centerOfGravity = activeBridgePresent
+        ? "shared-work"
+        : (input.inner.status === "running" || input.inner.hasPending || input.mustResolveBeforeHandoff)
+            ? "inward-work"
+            : "local-turn";
+    const frame = {
+        currentSession: input.currentSession ?? null,
+        currentObligation: input.currentObligation?.trim() || null,
+        mustResolveBeforeHandoff: input.mustResolveBeforeHandoff,
+        centerOfGravity,
+        inner: input.inner,
+        bridges: input.bridges,
+        taskPressure: {
+            compactBoard: input.taskBoard.compact,
+            liveTaskNames,
+            activeBridges: input.taskBoard.activeBridges,
+        },
+        friendActivity: {
+            freshestForCurrentFriend: friendSessions[0] ?? null,
+            otherLiveSessionsForCurrentFriend: friendSessions,
+        },
+        bridgeSuggestion: suggestBridgeForActiveWork({
+            currentSession: input.currentSession,
+            currentObligation: input.currentObligation,
+            mustResolveBeforeHandoff: input.mustResolveBeforeHandoff,
+            bridges: input.bridges,
+            taskBoard: input.taskBoard,
+            friendSessions,
+        }),
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.active_work_build",
+        message: "built shared active-work frame",
+        meta: {
+            centerOfGravity: frame.centerOfGravity,
+            friendId: frame.currentSession?.friendId ?? null,
+            bridges: frame.bridges.length,
+            liveTasks: frame.taskPressure.liveTaskNames.length,
+            liveSessions: frame.friendActivity.otherLiveSessionsForCurrentFriend.length,
+            hasBridgeSuggestion: frame.bridgeSuggestion !== null,
+        },
+    });
+    return frame;
+}
+function formatActiveWorkFrame(frame) {
+    const lines = ["## active work"];
+    if (frame.currentSession) {
+        lines.push(`current session: ${formatSessionLabel(frame.currentSession)}`);
+    }
+    lines.push(`center: ${frame.centerOfGravity}`);
+    if (typeof frame.currentObligation === "string" && frame.currentObligation.trim().length > 0) {
+        lines.push(`obligation: ${frame.currentObligation.trim()}`);
+    }
+    if (frame.mustResolveBeforeHandoff) {
+        lines.push("handoff pressure: must resolve before handoff");
+    }
+    const innerStatus = frame.inner?.status ?? "idle";
+    const innerHasPending = frame.inner?.hasPending === true;
+    lines.push(`inner status: ${innerStatus}${innerHasPending ? " (pending queued)" : ""}`);
+    if ((frame.taskPressure?.liveTaskNames ?? []).length > 0) {
+        lines.push(`live tasks: ${frame.taskPressure.liveTaskNames.join(", ")}`);
+    }
+    if ((frame.bridges ?? []).length > 0) {
+        const bridgeLabels = frame.bridges.map((bridge) => `${bridge.id} [${(0, state_machine_1.bridgeStateLabel)(bridge)}]`);
+        lines.push(`bridges: ${bridgeLabels.join(", ")}`);
+    }
+    if (frame.friendActivity?.freshestForCurrentFriend) {
+        lines.push(`freshest friend-facing session: ${formatSessionLabel(frame.friendActivity.freshestForCurrentFriend)}`);
+    }
+    if (frame.bridgeSuggestion) {
+        if (frame.bridgeSuggestion.kind === "attach-existing") {
+            lines.push(`suggested bridge: attach ${frame.bridgeSuggestion.bridgeId} -> ${formatSessionLabel(frame.bridgeSuggestion.targetSession)}`);
+        }
+        else {
+            lines.push(`suggested bridge: begin -> ${formatSessionLabel(frame.bridgeSuggestion.targetSession)}`);
+            lines.push(`bridge objective hint: ${frame.bridgeSuggestion.objectiveHint}`);
+        }
+    }
+    return lines.join("\n");
+}