@botiverse/raft-daemon 0.58.0 → 0.58.2

package/dist/{chunk-MG6RP2NS.js → chunk-XA4ZPIWE.js}

@@ -1518,50 +1518,50 @@ import { mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
 import { createRequire } from "module";
 import path2 from "path";
 
-// src/drivers/slockCliGuide.ts
+// src/drivers/raftCliGuide.ts
 var MESSAGE_HEREDOC_DELIMITER = "SLOCKMSG";
 function describeSlockInstallation(audience) {
   if (audience === "managed-runner") {
-    return "The daemon injects a local `slock` wrapper into PATH for you.";
+    return "The daemon injects a local `raft` wrapper (with `slock` kept as a legacy alias) into PATH for you.";
   }
   return "Install the published agent CLI: `npm i -g @botiverse/raft@latest` (exposes the `raft` command; `slock` remains a compatible alias). Discover/select a valid external-CLI agent identity first, for example with `raft agent list --server <serverUrl>` or a Raft setup card; then run `raft agent login --server <serverUrl> --agent <id> --profile-slug <slug>` for the selected agent. After login succeeds, invoke commands as `raft --profile <slug> ...` (or set `RAFT_PROFILE=<slug>`).";
 }
 function buildCommunicationSection(audience) {
   const installation = describeSlockInstallation(audience);
-  return `## Communication \u2014 slock CLI ONLY
-
-Use the \`slock\` CLI for chat / task / attachment operations. ${installation} Use ONLY these commands for communication:
-
-1. **\`slock message check\`** \u2014 Non-blocking check for new messages. Use freely during work \u2014 at natural breakpoints or after notifications.
-2. **\`slock message send\`** \u2014 Send a message to a channel or DM.
-3. **\`slock server info\`** \u2014 List channels in this server, which ones you have joined, plus all agents and humans.
-4. **\`slock channel members\`** \u2014 List the members (agents and humans) of a specific channel, DM, or thread target.
-5. **\`slock channel join\`** \u2014 Join a visible public channel. This only affects your own agent membership.
-6. **\`slock channel leave\`** \u2014 Leave a regular channel you have joined. This only affects your own agent membership.
-7. **\`slock thread unfollow\`** \u2014 Stop receiving ordinary delivery for a thread you no longer need to follow. This only affects your own agent attention state.
-8. **\`slock message read\`** \u2014 Read past messages from a channel, DM, or thread. Supports \`before\` / \`after\` anchors and \`around\` for centered context.
-9. **\`slock message search\`** \u2014 Search messages visible to you, then inspect a hit with \`slock message read\`.
-10. **\`slock message resolve\`** \u2014 Verify that a cited message id exists exactly and print its canonical message row. Use this when checking whether a referenced id is real; \`read --around\` is for context, not proof.
-11. **\`slock message react\`** \u2014 Add or remove your reaction on a message. Use sparingly: prefer acknowledgement/follow-up signals like \u{1F440}, and do not auto-react to every merge, deploy, or task completion with celebratory emoji.
-12. **\`slock task list\`** \u2014 View a channel's task board.
-13. **\`slock task create\`** \u2014 Create new task-messages in a channel (supports batch titles; equivalent to sending a new message and publishing it as a task-message, not claiming it for yourself).
-14. **\`slock task claim\`** \u2014 Claim tasks by number or message ID (supports batch, handles conflicts).
-15. **\`slock task unclaim\`** \u2014 Release your claim on a task.
-16. **\`slock task update\`** \u2014 Change a task's status (e.g. to in_review or done).
-17. **\`slock attachment upload\`** \u2014 Upload a file to attach to a message. Uses content sniffing for image previews; pass \`--mime-type\` only when you know the exact type. Returns an attachment ID to pass to \`slock message send\`.
-18. **\`slock attachment view\`** \u2014 Download an attached file by its attachment ID so you can inspect it locally.
-19. **\`slock profile show\`** \u2014 Show your own profile, or another visible profile via \`@handle\`. Mirrors the canonical Slock profile view.
-20. **\`slock profile update\`** \u2014 Update your own profile. Supports \`--avatar-file <path>\`, \`--avatar-url pixel:random:<seed>\`, \`--display-name <name>\`, and \`--description <text>\`. Use \`--avatar-url pixel:random:<seed>\` when you want a new pixel avatar but do not have a local image file. Values must be non-empty. Provide at least one flag per call; multiple flags can be combined.
-21. **\`slock integration list\`** \u2014 List built-in Slock apps, registered third-party services, and this agent's active Slock Agent Logins.
-22. **\`slock integration login\`** \u2014 Provision or reuse this agent's login for a built-in Slock app or registered third-party service.
-23. **\`slock integration env\`** \u2014 Print per-agent local CLI environment for a manifest-backed service that requires isolated HOME/XDG state.
-24. **\`slock reminder schedule\`** \u2014 Schedule a reminder for yourself later, at a specific time, or on a recurring cadence.
-25. **\`slock reminder list\`** \u2014 List your reminders, including lifecycle history for each reminder.
-26. **\`slock reminder snooze\`** \u2014 Push a reminder later without replacing it.
-27. **\`slock reminder update\`** \u2014 Change a reminder's title, schedule, or recurrence without creating a new reminder.
-28. **\`slock reminder cancel\`** \u2014 Cancel one of your reminders by ID.
-29. **\`slock reminder log\`** \u2014 Show the event log for a reminder, including fires, dismissals, and reschedules.
-30. **\`slock action prepare\`** \u2014 Prepare an action card for a human to commit (B-mode quick-commit shortcut). Posts a card the human can click to execute the action under their own identity. Pass \`--target <ch>\` and pipe the action JSON on stdin (variants: \`channel:create\`, \`agent:create\`).
+  return `## Communication \u2014 raft CLI ONLY
+
+Use the \`raft\` CLI for chat / task / attachment operations (\`slock\` remains a legacy alias). ${installation} Use ONLY these commands for communication:
+
+1. **\`raft message check\`** \u2014 Non-blocking check for new messages. Use freely during work \u2014 at natural breakpoints or after notifications.
+2. **\`raft message send\`** \u2014 Send a message to a channel or DM.
+3. **\`raft server info\`** \u2014 List channels in this server, which ones you have joined, plus all agents and humans.
+4. **\`raft channel members\`** \u2014 List the members (agents and humans) of a specific channel, DM, or thread target.
+5. **\`raft channel join\`** \u2014 Join a visible public channel. This only affects your own agent membership.
+6. **\`raft channel leave\`** \u2014 Leave a regular channel you have joined. This only affects your own agent membership.
+7. **\`raft thread unfollow\`** \u2014 Stop receiving ordinary delivery for a thread you no longer need to follow. This only affects your own agent attention state.
+8. **\`raft message read\`** \u2014 Read past messages from a channel, DM, or thread. Supports \`before\` / \`after\` anchors and \`around\` for centered context.
+9. **\`raft message search\`** \u2014 Search messages visible to you, then inspect a hit with \`raft message read\`.
+10. **\`raft message resolve\`** \u2014 Verify that a cited message id exists exactly and print its canonical message row. Use this when checking whether a referenced id is real; \`read --around\` is for context, not proof.
+11. **\`raft message react\`** \u2014 Add or remove your reaction on a message. Use sparingly: prefer acknowledgement/follow-up signals like \u{1F440}, and do not auto-react to every merge, deploy, or task completion with celebratory emoji.
+12. **\`raft task list\`** \u2014 View a channel's task board.
+13. **\`raft task create\`** \u2014 Create new task-messages in a channel (supports batch titles; equivalent to sending a new message and publishing it as a task-message, not claiming it for yourself).
+14. **\`raft task claim\`** \u2014 Claim tasks by number or message ID (supports batch, handles conflicts).
+15. **\`raft task unclaim\`** \u2014 Release your claim on a task.
+16. **\`raft task update\`** \u2014 Change a task's status (e.g. to in_review or done).
+17. **\`raft attachment upload\`** \u2014 Upload a file to attach to a message. Uses content sniffing for image previews; pass \`--mime-type\` only when you know the exact type. Returns an attachment ID to pass to \`raft message send\`.
+18. **\`raft attachment view\`** \u2014 Download an attached file by its attachment ID so you can inspect it locally.
+19. **\`raft profile show\`** \u2014 Show your own profile, or another visible profile via \`@handle\`. Mirrors the canonical Slock profile view.
+20. **\`raft profile update\`** \u2014 Update your own profile. Supports \`--avatar-file <path>\`, \`--avatar-url pixel:random:<seed>\`, \`--display-name <name>\`, and \`--description <text>\`. Use \`--avatar-url pixel:random:<seed>\` when you want a new pixel avatar but do not have a local image file. Values must be non-empty. Provide at least one flag per call; multiple flags can be combined.
+21. **\`raft integration list\`** \u2014 List built-in Slock apps, registered third-party services, and this agent's active Slock Agent Logins.
+22. **\`raft integration login\`** \u2014 Provision or reuse this agent's login for a built-in Slock app or registered third-party service.
+23. **\`raft integration env\`** \u2014 Print per-agent local CLI environment for a manifest-backed service that requires isolated HOME/XDG state.
+24. **\`raft reminder schedule\`** \u2014 Schedule a reminder for yourself later, at a specific time, or on a recurring cadence.
+25. **\`raft reminder list\`** \u2014 List your reminders, including lifecycle history for each reminder.
+26. **\`raft reminder snooze\`** \u2014 Push a reminder later without replacing it.
+27. **\`raft reminder update\`** \u2014 Change a reminder's title, schedule, or recurrence without creating a new reminder.
+28. **\`raft reminder cancel\`** \u2014 Cancel one of your reminders by ID.
+29. **\`raft reminder log\`** \u2014 Show the event log for a reminder, including fires, dismissals, and reschedules.
+30. **\`raft action prepare\`** \u2014 Prepare an action card for a human to commit (B-mode quick-commit shortcut). Posts a card the human can click to execute the action under their own identity. Pass \`--target <ch>\` and pipe the action JSON on stdin (variants: \`channel:create\`, \`agent:create\`).
 
 The CLI prints human-readable canonical text on success (matching the format you see in received messages and history). On failure it prints canonical labeled text to stderr:
 - \`Error:\` human-readable error summary
@@ -1586,14 +1586,14 @@ function buildSendingMessagesSection() {
   const D = MESSAGE_HEREDOC_DELIMITER;
   return `### Sending messages
 
-- **Reply to a channel**: \`slock message send --target "#channel-name" <<'${D}'\` followed by the message body and \`${D}\`
-- **Reply to a DM**: \`slock message send --target dm:@peer-name <<'${D}'\` followed by the message body and \`${D}\`
-- **Reply in a thread**: \`slock message send --target "#channel:shortid" <<'${D}'\` followed by the message body and \`${D}\`
-- **Start a NEW DM**: \`slock message send --target dm:@person-name <<'${D}'\` followed by the message body and \`${D}\`
+- **Reply to a channel**: \`raft message send --target "#channel-name" <<'${D}'\` followed by the message body and \`${D}\`
+- **Reply to a DM**: \`raft message send --target dm:@peer-name <<'${D}'\` followed by the message body and \`${D}\`
+- **Reply in a thread**: \`raft message send --target "#channel:shortid" <<'${D}'\` followed by the message body and \`${D}\`
+- **Start a NEW DM**: \`raft message send --target dm:@person-name <<'${D}'\` followed by the message body and \`${D}\`
 
 Message content is always read from stdin. Use a heredoc so quotes, backticks, code blocks, and newlines are not interpreted by the shell:
 \`\`\`bash
-slock message send --target "#channel-name" <<'${D}'
+raft message send --target "#channel-name" <<'${D}'
 Long message with "quotes", $vars, \`backticks\`, and code blocks.
 ${D}
 \`\`\`
@@ -1601,8 +1601,8 @@ ${D}
 Use a delimiter that is unlikely to appear in the message body; the examples use \`${D}\` instead of \`EOF\` so shell snippets and recovery drafts are less likely to leak delimiter text into sent messages.
 
 If Slock says a message was not sent and was saved as a draft, choose one path:
-- To update the draft, use a normal \`slock message send --target <target>\` with the revised content.
-- To send the current draft unchanged, use \`slock message send --send-draft --target <target>\` with no stdin. Do not use \`--send-draft\` when changing content.
+- To update the draft, use a normal \`raft message send --target <target>\` with the revised content.
+- To send the current draft unchanged, use \`raft message send --send-draft --target <target>\` with no stdin. Do not use \`--send-draft\` when changing content.
 
 **IMPORTANT**: To reply to any message, always reuse the exact \`target\` from the received message. This ensures your reply goes to the right place \u2014 whether it's a channel, DM, or thread.`;
 }
@@ -1610,8 +1610,8 @@ function buildRemindersSection() {
   return `### Reminders
 
 Use reminders for follow-up that depends on future state you cannot resolve now, whether user-requested or self-driven. A reminder is an author-owned, persistent, observable, snoozable, updatable, and cancelable wake-up signal anchored to a Slock message or thread; when it fires, it wakes the author who scheduled it, not other people. If anchored to a message or thread, the receipt/fire system message is visible in that surface, but wake ownership does not transfer. To notify another human or agent later, schedule your own reminder and then @mention them when it fires. Use reminders instead of keeping the current turn alive with a long sleep or relying on MEMORY to wake you. If you expect the wait to finish within about 1 minute, you may briefly poll, but say so in the relevant thread first.
-When a reminder already exists, prefer \`slock reminder snooze\` to push it later, \`slock reminder update\` to change its meaning or schedule, and \`slock reminder cancel\` only when it is truly no longer needed.
-Use \`slock reminder schedule\` rather than runtime-native wake or cron tools such as ScheduleWakeup or CronCreate for user-visible reminders, so reminders stay author-owned, persistent, observable, snoozable, updatable, and cancelable in Slock.
+When a reminder already exists, prefer \`raft reminder snooze\` to push it later, \`raft reminder update\` to change its meaning or schedule, and \`raft reminder cancel\` only when it is truly no longer needed.
+Use \`raft reminder schedule\` rather than runtime-native wake or cron tools such as ScheduleWakeup or CronCreate for user-visible reminders, so reminders stay author-owned, persistent, observable, snoozable, updatable, and cancelable in Slock.
 Create agent reminders only after resolving the anchor message from the current conversation and passing its msgId explicitly; if no anchor can be resolved, consider posting a status update in the relevant thread so the intent is visible, then revisit when context is available.`;
 }
 function buildThreadsSection() {
@@ -1622,38 +1622,38 @@ Threads are sub-conversations attached to a specific message. They let you discu
 
 - **Thread targets** have a colon and short ID suffix: \`#general:00000000\` (thread in #general) or \`dm:@richard:11111111\` (thread in a DM).
 - When you receive a message from a thread (the target has a \`:shortid\` suffix), **always reply using that same target** to keep the conversation in the thread.
-- **Start a new thread**: Use the \`msg=\` field from the header as the thread suffix. For example, if you see \`[target=#general msg=00000000 ...]\`, reply with \`slock message send --target "#general:00000000" <<'${D}'\` followed by the message body and \`${D}\`. The thread will be auto-created if it doesn't exist yet. Example IDs like \`00000000\` are placeholders; real message IDs come from received messages.
+- **Start a new thread**: Use the \`msg=\` field from the header as the thread suffix. For example, if you see \`[target=#general msg=00000000 ...]\`, reply with \`raft message send --target "#general:00000000" <<'${D}'\` followed by the message body and \`${D}\`. The thread will be auto-created if it doesn't exist yet. Example IDs like \`00000000\` are placeholders; real message IDs come from received messages.
 - When you send a message, the response includes the message ID. You can use it to start a thread on your own message.
-- You can read thread history: \`slock message read --channel "#general:00000000"\`
-- You can stop receiving ordinary delivery for a thread with \`slock thread unfollow --target "#general:00000000"\`. Only do this when your work in that thread is clearly complete or no longer relevant.
+- You can read thread history: \`raft message read --channel "#general:00000000"\`
+- You can stop receiving ordinary delivery for a thread with \`raft thread unfollow --target "#general:00000000"\`. Only do this when your work in that thread is clearly complete or no longer relevant.
 - Threads cannot be nested \u2014 you cannot start a thread inside a thread.`;
 }
 function buildDiscoverySection() {
   return `### Discovering people and channels
 
-Call \`slock server info\` to see all channels in this server, which ones you have joined, other agents, and humans.
-Visible public channels may appear even when \`joined=false\`. In that state you can still inspect them with \`slock message read\` and \`slock channel members\`, but you cannot send messages there or receive ordinary channel delivery until you join with \`slock channel join --target "#channel-name"\`. Private channels require a human with access to add you. To leave a regular channel you have joined, use \`slock channel leave --target "#channel-name"\`. To stop following a thread without leaving its parent channel, use \`slock thread unfollow --target "#channel-name:shortid"\`.
-Private channels are membership-gated. If \`slock server info\` shows a channel as private, treat its name, members, and content as private to that channel; do not disclose that information in other channels, DMs, summaries, or task reports unless a human explicitly asks within an authorized context. In \`slock channel members\`, human role labels such as owner/admin show server-level authority; no role label means ordinary member.`;
+Call \`raft server info\` to see all channels in this server, which ones you have joined, other agents, and humans.
+Visible public channels may appear even when \`joined=false\`. In that state you can still inspect them with \`raft message read\` and \`raft channel members\`, but you cannot send messages there or receive ordinary channel delivery until you join with \`raft channel join --target "#channel-name"\`. Private channels require a human with access to add you. To leave a regular channel you have joined, use \`raft channel leave --target "#channel-name"\`. To stop following a thread without leaving its parent channel, use \`raft thread unfollow --target "#channel-name:shortid"\`.
+Private channels are membership-gated. If \`raft server info\` shows a channel as private, treat its name, members, and content as private to that channel; do not disclose that information in other channels, DMs, summaries, or task reports unless a human explicitly asks within an authorized context. In \`raft channel members\`, human role labels such as owner/admin show server-level authority; no role label means ordinary member.`;
 }
 function buildChannelAwarenessSection() {
   return `### Channel awareness
 
-Each channel has a **name** and optionally a **description** that define its purpose (visible via \`slock server info\`). Respect them:
+Each channel has a **name** and optionally a **description** that define its purpose (visible via \`raft server info\`). Respect them:
 - **Reply in context** \u2014 always respond in the channel/thread the message came from.
 - **Stay on topic** \u2014 when proactively sharing results or updates, post in the channel most relevant to the work. Don't scatter messages across unrelated channels.
-- If unsure where something belongs, call \`slock server info\` to review channel descriptions.`;
+- If unsure where something belongs, call \`raft server info\` to review channel descriptions.`;
 }
 function buildReadingHistorySection() {
   return `### Reading history
 
-\`slock message read --channel "#channel-name"\` or \`slock message read --channel dm:@peer-name\` or \`slock message read --channel "#channel:shortid"\`
+\`raft message read --channel "#channel-name"\` or \`raft message read --channel dm:@peer-name\` or \`raft message read --channel "#channel:shortid"\`
 
-To jump directly to a specific hit with nearby context, use \`slock message read --channel "..." --around "messageId"\` or \`slock message read --channel "..." --around 12345\`.`;
+To jump directly to a specific hit with nearby context, use \`raft message read --channel "..." --around "messageId"\` or \`raft message read --channel "..." --around 12345\`.`;
 }
 function buildHistoricalReferencesSection() {
   return `### Historical references
 
-When a user refers to prior Slock discussion and the relevant context is not already available, first use \`slock message search\` and \`slock message read\` to find the original thread, decision, or owner before answering. If you find it, summarize the original conclusion with the source thread/message; if you cannot find it, say that explicitly.`;
+When a user refers to prior Slock discussion and the relevant context is not already available, first use \`raft message search\` and \`raft message read\` to find the original thread, decision, or owner before answering. If you find it, summarize the original conclusion with the source thread/message; if you cannot find it, say that explicitly.`;
 }
 function buildTasksSection() {
   const D = MESSAGE_HEREDOC_DELIMITER;
@@ -1670,7 +1670,7 @@ When someone sends a message that asks you to do something \u2014 fix a bug, wri
 
 Only top-level channel / DM messages can become tasks. Messages inside threads are discussion context \u2014 reply there, but keep claims and conversions to top-level messages.
 
-\`slock message read\` shows messages in their current state. If a message was later converted to a task, it will show the \`[task #N ...]\` suffix.
+\`raft message read\` shows messages in their current state. If a message was later converted to a task, it will show the \`[task #N ...]\` suffix.
 
 **Status flow:** \`todo\` \u2192 \`in_progress\` \u2192 \`in_review\` \u2192 \`done\`
 
@@ -1679,24 +1679,24 @@ Only top-level channel / DM messages can become tasks. Messages inside threads a
 **Workflow:**
 1. Receive a message that requires action \u2192 claim it first (by task number if already a task, or by message ID if it's a regular message)
 2. If the claim fails, someone else is working on it \u2014 move on to another task
-3. Post updates in the task's thread: \`slock message send --target "#channel:msgShortId" <<'${D}'\` followed by the message body and \`${D}\`
-4. When done, set status to \`in_review\` so a human can validate via \`slock task update\`
+3. Post updates in the task's thread: \`raft message send --target "#channel:msgShortId" <<'${D}'\` followed by the message body and \`${D}\`
+4. When done, set status to \`in_review\` so a human can validate via \`raft task update\`
 5. After approval (e.g. "looks good", "merge it"), set status to \`done\`
 
-**What \`slock task create\` really means:**
+**What \`raft task create\` really means:**
 - Tasks live in the same chat flow as messages. A task is just a message with task metadata, not a separate source of truth.
-- \`slock task create\` is a convenience helper for a specific sequence: create a brand-new message, then publish that new message as a task-message.
-- \`slock task create\` only creates the task \u2014 to own it, call \`slock task claim\` afterward.
-- Typical uses for \`slock task create\` are breaking down a larger task into parallel subtasks, or batch-creating genuinely new work for others to claim.
+- \`raft task create\` is a convenience helper for a specific sequence: create a brand-new message, then publish that new message as a task-message.
+- \`raft task create\` only creates the task \u2014 to own it, call \`raft task claim\` afterward.
+- Typical uses for \`raft task create\` are breaking down a larger task into parallel subtasks, or batch-creating genuinely new work for others to claim.
 - If someone already sent the work item as a message, just claim that existing message/task instead of creating a new one.
-- If the work already exists as a message, reuse it via \`slock task claim --message-id ...\`.
+- If the work already exists as a message, reuse it via \`raft task claim --message-id ...\`.
 
 **Creating new tasks:**
 - The task system exists to prevent duplicate work. If you see an existing task for the work, either claim that task or leave it alone.
 - If a message already shows a \`[task #N ...]\` suffix, claim \`#N\` if it is yours to take; otherwise move on.
-- Before calling \`slock task create\`, first check whether the work already exists on the task board or is already being handled.
+- Before calling \`raft task create\`, first check whether the work already exists on the task board or is already being handled.
 - Reuse existing tasks and threads instead of creating duplicates.
-- Use \`slock task create\` only for genuinely new subtasks or follow-up work that does not already have a canonical task.`;
+- Use \`raft task create\` only for genuinely new subtasks or follow-up work that does not already have a canonical task.`;
 }
 function buildSplittingTasksSection() {
   return `### Splitting tasks for parallel execution
@@ -1727,7 +1727,7 @@ Keep the user informed. They cannot see your internal reasoning, so:
 - When done, summarize the result.
 - Keep updates concise \u2014 one or two sentences. Don't flood the chat.`;
 }
-function buildConversationEtiquetteSection(taskClaimCmd = "`slock task claim`") {
+function buildConversationEtiquetteSection(taskClaimCmd = "`raft task claim`") {
   return `### Conversation etiquette
 
 - **Respect ongoing conversations.** If a human is having a back-and-forth with another person (human or agent) on a topic, their follow-up messages are directed at that person \u2014 only join if you are explicitly @mentioned or clearly addressed.
@@ -1864,7 +1864,7 @@ function runtimeContextLines(config) {
   return lines.length > 4 ? lines : [];
 }
 function buildPrompt(config, opts) {
-  const taskClaimCmd = "`slock task claim`";
+  const taskClaimCmd = "`raft task claim`";
   const cliGuideSections = buildSlockCliGuideSections({
     // The daemon prompt audience is always managed-runner regardless of
     // CLI vs MCP variant — both are daemon-spawned. The self-hosted-runner
@@ -1876,16 +1876,16 @@ function buildPrompt(config, opts) {
     },
     taskClaimCmd
   });
-  const checkCmd = "`slock message check`";
-  const inboxCheckCmd = "`slock inbox check`";
+  const checkCmd = "`raft message check`";
+  const inboxCheckCmd = "`raft inbox check`";
   const messageDeliveryText = opts.includeStdinNotificationSection ? "New messages may be delivered to you automatically while your process stays alive." : "The daemon will automatically restart you when new messages arrive.";
   const noConcreteMessageStartupStep = opts.includeStdinNotificationSection ? `3. If there is no concrete incoming message to handle but this turn includes a Slock inbox notice: the notice means messages exist that you have not seen \u2014 their bodies are withheld to avoid flooding you, not absent (unobserved is not the same as nonexistent). Whether and when to read them is your judgment, now or later; ${checkCmd} reads them and the notice metadata (who, where, how many) helps you triage. Never derive "no work" from a content-free notice alone \u2014 if you choose not to read, that is a deferral to report honestly, not a conclusion that nothing is pending. If there is neither a concrete message nor an inbox notice, stop and wait. ${messageDeliveryText}` : `3. If there is no concrete incoming message to handle, stop and wait. ${messageDeliveryText}`;
   const criticalRules = [
-    "- Always communicate through `slock` CLI commands. This is your only output channel: text you produce outside a `slock` command is not delivered to anyone.",
+    "- Always communicate through `raft` CLI commands. This is your only output channel: text you produce outside a `raft` command is not delivered to anyone.",
     ...opts.extraCriticalRules,
-    "- Use only the provided `slock` CLI commands for messaging.",
-    "- Do not combine multiple `slock` CLI commands in one shell command. Run one `slock` command per tool call, read its output, then decide the next command.",
-    "- Always claim a task via `slock task claim` before starting work on it. If the claim fails, move on to a different task."
+    "- Use only the provided `raft` CLI commands for messaging.",
+    "- Do not combine multiple `raft` CLI commands in one shell command. Run one `raft` command per tool call, read its output, then decide the next command.",
+    "- Always claim a task via `raft task claim` before starting work on it. If the claim fails, move on to a different task."
   ];
   const runtimeProfileControl = config.runtimeProfileControl?.kind === "daemon_release_notice" ? config.runtimeProfileControl : null;
   const runtimeProfileControlStartupStep = runtimeProfileControl ? [
@@ -1893,10 +1893,10 @@ function buildPrompt(config, opts) {
   ] : [];
   const startupSteps = [
     ...runtimeProfileControlStartupStep,
-    "1. If this turn already includes a concrete incoming message, first decide whether that message needs a visible acknowledgment, blocker question, or ownership signal. If it does, send it early with `slock message send` before deep context gathering.",
+    "1. If this turn already includes a concrete incoming message, first decide whether that message needs a visible acknowledgment, blocker question, or ownership signal. If it does, send it early with `raft message send` before deep context gathering.",
     "2. Read MEMORY.md (in your cwd) and then only the additional memory/files you need to handle the current turn well.",
     noConcreteMessageStartupStep,
-    "4. When you receive a message, process it and reply with `slock message send`.",
+    "4. When you receive a message, process it and reply with `raft message send`.",
     "5. **Complete ALL your work before stopping.** If a task requires multi-step work (research, code changes, testing), finish everything, report results, then stop. New messages arrive automatically \u2014 you do not need to poll or wait for them."
   ];
   const communicationSection = cliGuideSections.communication;
@@ -1908,11 +1908,11 @@ function buildPrompt(config, opts) {
   const channelAwarenessSection = cliGuideSections.channelAwareness;
   const thirdPartyIntegrationsSection = `### Third-party integrations
 
-If a built-in Slock app or registered third-party service requires login, use Slock Agent Login through the CLI instead of asking the human to copy tokens or complete human OAuth for you. If a human asks you to sign into, open, use, or fetch identity from a third-party app or built-in Slock app, first run \`slock integration list\` and match the app to a listed service before browsing the app. Use \`slock integration login --service <service>\` to provision or reuse your agent login for that service. If the service exposes an agent behavior manifest and you need to run its local CLI, run \`slock integration env --service <service>\` before invoking that CLI; if it prints exports, apply them first so service credentials stay under a per-agent profile HOME/XDG tree instead of the host user's global HOME. If it reports that no local env is required, do not invent HOME/XDG overrides. If it fails, do not run that local CLI with the host user's HOME; report that the service manifest is unsupported. Slock does not execute commands from remote manifests automatically. If the CLI reports that the \`integration\` command is unknown, the local daemon/CLI is too old for Slock Agent Login; report that the machine must be upgraded/restarted instead of calling internal HTTP endpoints yourself. When the command returns \`Agent login ready\` or \`Already logged in\`, the agent-side login is ready. If the output includes an app URL, open that URL as the service-provided app surface; it should look like the service's normal Login with Slock callback and not require you to understand Slock's internal grant/request protocol. Do not crawl third-party routes looking for a session before trying the registered-service login path. Do not open the human \`Login with Slock\` browser flow, use internal request IDs as OAuth callback codes, call internal Slock integration endpoints directly, or call third-party exchange endpoints unless a human explicitly asks you to debug that server-to-server protocol. If the service or human asks for your Slock Agent identity card, use \`slock profile show\`. Third-party pages may show \`Login with Slock\`; for agent-facing access, prefer the listed service / Slock Agent Login path.`;
+If a built-in Slock app or registered third-party service requires login, use Slock Agent Login through the CLI instead of asking the human to copy tokens or complete human OAuth for you. If a human asks you to sign into, open, use, or fetch identity from a third-party app or built-in Slock app, first run \`raft integration list\` and match the app to a listed service before browsing the app. Use \`raft integration login --service <service>\` to provision or reuse your agent login for that service. If the service exposes an agent behavior manifest and you need to run its local CLI, run \`raft integration env --service <service>\` before invoking that CLI; if it prints exports, apply them first so service credentials stay under a per-agent profile HOME/XDG tree instead of the host user's global HOME. If it reports that no local env is required, do not invent HOME/XDG overrides. If it fails, do not run that local CLI with the host user's HOME; report that the service manifest is unsupported. Slock does not execute commands from remote manifests automatically. If the CLI reports that the \`integration\` command is unknown, the local daemon/CLI is too old for Slock Agent Login; report that the machine must be upgraded/restarted instead of calling internal HTTP endpoints yourself. When the command returns \`Agent login ready\` or \`Already logged in\`, the agent-side login is ready. If the output includes an app URL, open that URL as the service-provided app surface; it should look like the service's normal Login with Slock callback and not require you to understand Slock's internal grant/request protocol. Do not crawl third-party routes looking for a session before trying the registered-service login path. Do not open the human \`Login with Slock\` browser flow, use internal request IDs as OAuth callback codes, call internal Slock integration endpoints directly, or call third-party exchange endpoints unless a human explicitly asks you to debug that server-to-server protocol. If the service or human asks for your Slock Agent identity card, use \`raft profile show\`. Third-party pages may show \`Login with Slock\`; for agent-facing access, prefer the listed service / Slock Agent Login path.`;
   const readingHistorySection = cliGuideSections.readingHistory;
   const historicalReferenceSection = cliGuideSections.historicalReferences;
   const tasksSection = cliGuideSections.tasks;
-  let prompt = `You are "${config.displayName || config.name}", an AI agent in Slock \u2014 a collaborative platform for human-AI collaboration, serving as a shared message service for humans and agents who may be running on different computers.
+  let prompt = `You are "${config.displayName || config.name}", an AI agent in Raft (former Slock) \u2014 a collaborative platform for human-AI collaboration, serving as a shared message service for humans and agents who may be running on different computers.
 
 ## Who you are
 
@@ -2026,7 +2026,7 @@ While you are working, the daemon may write a batched, content-free inbox update
 How to handle these:
 - Treat the notification as a non-urgent signal that new Slock messages are waiting; it does not include the message content and does not require an immediate interruption.
 - A content-free notice means messages exist that you have not seen \u2014 not that there is no content or no action. Whether and when to read them is your judgment, now or later; ${checkCmd} is one cheap command and the notice metadata helps you triage. If you defer, report the deferral honestly; never derive "no work" from a content-free notice alone.
-- Keep working until a natural breakpoint. If you then choose to inspect pending targets, call ${inboxCheckCmd}; use ${checkCmd} / \`slock message read\` when you choose to inspect message content.
+- Keep working until a natural breakpoint. If you then choose to inspect pending targets, call ${inboxCheckCmd}; use ${checkCmd} / \`raft message read\` when you choose to inspect message content.
 - If a message you explicitly read is higher priority, pivot to it. If not, continue your current work.`;
     } else {
       const notifyExample = `\`[Slock inbox notice:\\nInbox update: N unread messages total; M changed targets\\n#channel  pending: K messages ...]\``;
@@ -2041,7 +2041,7 @@ ${notifyExample}
 How to handle these:
 - The notice is target-scoped and content-free. Its header may show total unread/pending count, while detail rows list the targets changed by this update; it never includes message bodies.
 - A content-free notice means messages exist that you have not seen \u2014 not that there is no content or no action. Whether and when to read them is your judgment, now or later; ${checkCmd} is one cheap command and the notice metadata helps you triage. If you defer, report the deferral honestly; never derive "no work" from a content-free notice alone.
-- Do not interrupt the current step just because a notice arrived. At a natural breakpoint, call ${inboxCheckCmd} if you choose to inspect pending targets, or use ${checkCmd} / \`slock message read\` when you choose to inspect message content.
+- Do not interrupt the current step just because a notice arrived. At a natural breakpoint, call ${inboxCheckCmd} if you choose to inspect pending targets, or use ${checkCmd} / \`raft message read\` when you choose to inspect message content.
 - If a message you explicitly read is higher priority, you may pivot to it. If not, continue your current work.`;
     }
   }
@@ -3702,14 +3702,17 @@ async function prepareCliTransport(ctx, extraEnv = {}, platform = process.platfo
     writeFileSync(tokenFile, ctx.config.authToken || ctx.daemonApiKey, { mode: 384 });
   }
   const posixWrapper = path2.join(slockDir, "slock");
+  const posixRaftWrapper = path2.join(slockDir, "raft");
   const posixCredentialPrefix = agentCredentialProxy ? `SLOCK_AGENT_PROXY_URL=${shellSingleQuote(agentCredentialProxy.proxyUrl)} SLOCK_AGENT_PROXY_TOKEN_FILE=${shellSingleQuote(agentCredentialProxyTokenFile)} SLOCK_AGENT_ACTIVE_CAPABILITIES=${shellSingleQuote(DEFAULT_ACTIVE_CAPABILITIES)} ` : "";
   const posixBody = `#!/usr/bin/env bash
 ${posixLoopbackNoProxyPrelude()}
 ${posixCredentialPrefix}exec ${shellSingleQuote(process.execPath)} ${shellSingleQuote(ctx.slockCliPath)} "$@"
 `;
   writeFileSync(posixWrapper, posixBody, { mode: 493 });
+  writeFileSync(posixRaftWrapper, posixBody, { mode: 493 });
   if (platform === "win32") {
     const cmdWrapper = path2.join(slockDir, "slock.cmd");
+    const cmdRaftWrapper = path2.join(slockDir, "raft.cmd");
     const cmdCredentialLine = agentCredentialProxy ? `set "SLOCK_AGENT_PROXY_URL=${agentCredentialProxy.proxyUrl}"\r
 set "SLOCK_AGENT_PROXY_TOKEN_FILE=${agentCredentialProxyTokenFile}"\r
 set "SLOCK_AGENT_ACTIVE_CAPABILITIES=${DEFAULT_ACTIVE_CAPABILITIES}"\r
@@ -3727,7 +3730,9 @@ set "SLOCK_AGENT_ACTIVE_CAPABILITIES=${DEFAULT_ACTIVE_CAPABILITIES}"\r
       ""
     ].filter((line) => line.length > 0).join("\r\n") + "\r\n";
     writeFileSync(cmdWrapper, cmdBody);
+    writeFileSync(cmdRaftWrapper, cmdBody);
     const psWrapper = path2.join(slockDir, "slock.ps1");
+    const psRaftWrapper = path2.join(slockDir, "raft.ps1");
     const psCredentialLines = agentCredentialProxy ? [
       `$env:SLOCK_AGENT_PROXY_URL=${powershellSingleQuote(agentCredentialProxy.proxyUrl)}`,
       `$env:SLOCK_AGENT_PROXY_TOKEN_FILE=${powershellSingleQuote(agentCredentialProxyTokenFile)}`,
@@ -3755,6 +3760,7 @@ set "SLOCK_AGENT_ACTIVE_CAPABILITIES=${DEFAULT_ACTIVE_CAPABILITIES}"\r
       ""
     ].join("\r\n");
     writeFileSync(psWrapper, psBody);
+    writeFileSync(psRaftWrapper, psBody);
   }
   const opencliBinPath = resolveOpencliBinPath();
   if (opencliBinPath) {
@@ -4477,7 +4483,7 @@ var ClaudeDriver = class {
     return buildCliTransportSystemPrompt(config, {
       extraCriticalRules: [],
       postStartupNotes: [
-        "**Claude runtime note:** While you are busy, Slock batches inbox-count notifications instead of injecting message content. Use `slock message check` at natural breakpoints to pull the pending messages before side-effect actions that depend on current context."
+        "**Claude runtime note:** While you are busy, Slock batches inbox-count notifications instead of injecting message content. Use `raft message check` at natural breakpoints to pull the pending messages before side-effect actions that depend on current context."
       ],
       includeStdinNotificationSection: true,
       messageNotificationStyle: "direct"
@@ -5147,7 +5153,7 @@ var CodexDriver = class {
     return buildCliTransportSystemPrompt(config, {
       extraCriticalRules: [],
       postStartupNotes: [
-        "**IMPORTANT**: Your process stays alive across turns. While you are working, Slock may write batched inbox-count notifications into the current turn; call `slock message check` at natural breakpoints to read the pending messages."
+        "**IMPORTANT**: Your process stays alive across turns. While you are working, Slock may write batched inbox-count notifications into the current turn; call `raft message check` at natural breakpoints to read the pending messages."
       ],
       includeStdinNotificationSection: true,
       messageNotificationStyle: "direct"
@@ -7022,7 +7028,7 @@ var PiDriver = class {
     return buildCliTransportSystemPrompt(config, {
       extraCriticalRules: [],
       postStartupNotes: [
-        "**Pi runtime note:** Slock keeps Pi running as a persistent SDK session. While you are working, Slock may send inbox-count notifications into the current turn; call `slock message check` at natural breakpoints."
+        "**Pi runtime note:** Slock keeps Pi running as a persistent SDK session. While you are working, Slock may send inbox-count notifications into the current turn; call `raft message check` at natural breakpoints."
       ],
       includeStdinNotificationSection: true,
       messageNotificationStyle: "direct"
@@ -7945,29 +7951,29 @@ function formatThreadContextMessage(message) {
 function communicationCommand(name) {
   switch (name) {
     case "send_message":
-      return "slock message send";
+      return "raft message send";
     case "read_history":
-      return "slock message read";
+      return "raft message read";
     case "check_messages":
-      return "slock message check";
+      return "raft message check";
     case "claim_tasks":
-      return "slock task claim";
+      return "raft task claim";
     default:
-      return `slock ${name.replace(/_/g, " ")}`;
+      return `raft ${name.replace(/_/g, " ")}`;
   }
 }
 function dynamicReplyInstruction() {
-  return "reply using `slock message send --target <exact target>`";
+  return "reply using `raft message send --target <exact target>`";
 }
 function dynamicClaimInstruction() {
-  return "claim the relevant task with `slock task claim`";
+  return "claim the relevant task with `raft task claim`";
 }
 function formatIncomingMessage(message) {
   const threadJoinPrefix = message.thread_join_context ? [
     `[Slock thread context: you were added to a new thread via @mention.]`,
     `parent: ${message.thread_join_context.parent_target}`,
     `thread: ${message.thread_join_context.thread_target}`,
-    `suggested next step: slock message read --channel "${message.thread_join_context.suggested_read_history_target}"`,
+    `suggested next step: raft message read --channel "${message.thread_join_context.suggested_read_history_target}"`,
     "",
     "Parent message:",
     formatThreadContextMessage(message.thread_join_context.parent_message),
@@ -8089,7 +8095,7 @@ After confirming language preference, do not give a generic product introduction
 A starter plan should make the next action executable, not just descriptive.
 For new channels, new agents, and adding members to an existing channel, post an **action card** rather than a copyable spec:
 
-- Use \`slock action prepare --target <onboarding-channel>\` and pipe an \`ActionCardAction\` JSON. Identity references are handles (\`@alice\` / \`@scout\` / \`#general\` \u2014 bare names work too), never UUIDs. Server resolves at prepare time.
+- Use \`raft action prepare --target <onboarding-channel>\` and pipe an \`ActionCardAction\` JSON. Identity references are handles (\`@alice\` / \`@scout\` / \`#general\` \u2014 bare names work too), never UUIDs. Server resolves at prepare time.
   - \`{type: "channel:create", name, visibility: "public" | "private", description?, initialHumans?: ["@alice"], initialAgents?: ["@scout"], draftHint?}\`
   - \`{type: "agent:create", name, description?, suggestedComputer?, requiredComputer?, draftHint?}\`
   - \`{type: "channel:add_member", channel: "#existing-channel", humans?: ["@alice"], agents?: ["@scout"], draftHint?}\` \u2014 at least one of humans / agents must be non-empty
@@ -8344,8 +8350,8 @@ Do not copy these answers verbatim.
 
 ## FAQ 15: How do I create agents or channels?
 ### Answer idea
-- When the owner agrees to a new agent or channel, **post an action card** with \`slock action prepare\`. The card lives inline in chat; the owner clicks the action button, the matching create dialog opens prefilled with your values (editable), and the resource is created under their identity when they submit.
-- v1 supports three action types via \`slock action prepare --target '<channel>' <<'SLOCKACTION' { ... } SLOCKACTION\`:
+- When the owner agrees to a new agent or channel, **post an action card** with \`raft action prepare\`. The card lives inline in chat; the owner clicks the action button, the matching create dialog opens prefilled with your values (editable), and the resource is created under their identity when they submit.
+- v1 supports three action types via \`raft action prepare --target '<channel>' <<'SLOCKACTION' { ... } SLOCKACTION\`:
   - \`{type: "channel:create", name, visibility: "public" | "private", description?, initialHumans?: ["@alice"], initialAgents?: ["@scout"], draftHint?}\`
   - \`{type: "agent:create", name, description?, suggestedComputer?, requiredComputer?, draftHint?}\` \u2014 runtime / model / reasoning effort are the owner's call. Use \`requiredComputer\` only when the owner explicitly says the new agent must run on that computer; use \`suggestedComputer\` for a soft preference.
   - \`{type: "channel:add_member", channel: "#existing-channel", humans?: ["@alice"], agents?: ["@scout"], draftHint?}\` \u2014 at least one of humans / agents must be non-empty. The owner clicks "Add Members" on the card; an AddMembers dialog opens with your suggested list (each row toggleable) and the owner submits to actually add them.
@@ -14160,7 +14166,7 @@ function resolveSlockCliPathOrEmpty(moduleUrl = import.meta.url) {
 }
 async function runBundledSlockCli(argv) {
   process.argv = [process.execPath, "slock", ...argv];
-  await import("./dist-VQDBFGLG.js");
+  await import("./dist-ADWW7UHH.js");
 }
 function detectRuntimes(tracer = noopTracer) {
   const ids = [];
@@ -14290,7 +14296,7 @@ var DaemonCore = class {
   options;
   daemonVersion;
   // When this runner is launched by a managed Computer service, the
-  // service exports SLOCK_COMPUTER_VERSION (the `@slock-ai/computer`
+  // service exports SLOCK_COMPUTER_VERSION (the `@botiverse/raft-computer`
   // bundle version). Reported in `ready` so the server can surface the
   // Computer's own version (distinct from the underlying daemonVersion).
   computerVersion;

package/dist/cli/index.js

@@ -1289,8 +1289,8 @@ async function mintAndPersist(ctx, options, accessToken, paths) {
   ctx.io.stdout.write(
     `state: authorized
 Logged in as '${minted.agentName}' on ${options.server}. Credential saved to ${paths.credentialPath}.
-Next (if you are the human operator): start your agent with RAFT_PROFILE=${paths.profileSlug} in its environment, and let the agent run \`raft manual get slock-cli-overview\` to learn the Slock CLI.
-Next (if you are the agent): run \`raft manual get slock-cli-overview\`, then use \`raft --profile ${paths.profileSlug} \u2026\` for all commands.
+Next (if you are the human operator): start your agent with RAFT_PROFILE=${paths.profileSlug} in its environment, and let the agent run \`raft manual get raft-cli-overview\` to learn the Raft CLI.
+Next (if you are the agent): run \`raft manual get raft-cli-overview\`, then use \`raft --profile ${paths.profileSlug} \u2026\` for all commands.
 `
   );
 }

package/dist/core.js

@@ -11,7 +11,7 @@ import {
   runBundledSlockCli,
   scanWorkspaceDirectories,
   subscribeDaemonLogs
-} from "./chunk-MG6RP2NS.js";
+} from "./chunk-XA4ZPIWE.js";
 export {
   DAEMON_CLI_USAGE,
   DaemonCore,

package/dist/{dist-VQDBFGLG.js → dist-ADWW7UHH.js}

@@ -1276,8 +1276,8 @@ async function mintAndPersist(ctx, options, accessToken, paths) {
   ctx.io.stdout.write(
     `state: authorized
 Logged in as '${minted.agentName}' on ${options.server}. Credential saved to ${paths.credentialPath}.
-Next (if you are the human operator): start your agent with RAFT_PROFILE=${paths.profileSlug} in its environment, and let the agent run \`raft manual get slock-cli-overview\` to learn the Slock CLI.
-Next (if you are the agent): run \`raft manual get slock-cli-overview\`, then use \`raft --profile ${paths.profileSlug} \u2026\` for all commands.
+Next (if you are the human operator): start your agent with RAFT_PROFILE=${paths.profileSlug} in its environment, and let the agent run \`raft manual get raft-cli-overview\` to learn the Raft CLI.
+Next (if you are the agent): run \`raft manual get raft-cli-overview\`, then use \`raft --profile ${paths.profileSlug} \u2026\` for all commands.
 `
   );
 }

package/dist/index.js

@@ -3,7 +3,7 @@ import {
   DAEMON_CLI_USAGE,
   DaemonCore,
   parseDaemonCliArgs
-} from "./chunk-MG6RP2NS.js";
+} from "./chunk-XA4ZPIWE.js";
 
 // src/index.ts
 var parsedArgs = parseDaemonCliArgs(process.argv.slice(2));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botiverse/raft-daemon",
-  "version": "0.58.0",
+  "version": "0.58.2",
   "type": "module",
   "bin": {
     "raft-daemon": "dist/raft-daemon.js",
@@ -36,7 +36,7 @@
     "typecheck": "tsc --noEmit",
     "lint:publish-package": "node scripts/check-publish-package.mjs",
     "generate:slock-cli-guide": "tsx scripts/generate-slock-cli-guide.ts",
-    "check:slock-cli-guide-fresh": "pnpm generate:slock-cli-guide && git diff --exit-code ../../manual/agent-knowledge/slock-cli-overview.md",
+    "check:slock-cli-guide-fresh": "pnpm generate:slock-cli-guide && git diff --exit-code ../../manual/agent-knowledge/raft-cli-overview.md",
     "release:patch": "npm version patch --no-git-tag-version && cd ../.. && pnpm install --lockfile-only && git add packages/daemon/package.json pnpm-lock.yaml && git commit -m \"chore: bump @botiverse/raft-daemon to v$(node -p \"require('./packages/daemon/package.json').version\")\" && git tag daemon-v$(node -p \"require('./packages/daemon/package.json').version\") && git push && git push --tags",
     "release:minor": "npm version minor --no-git-tag-version && cd ../.. && pnpm install --lockfile-only && git add packages/daemon/package.json pnpm-lock.yaml && git commit -m \"chore: bump @botiverse/raft-daemon to v$(node -p \"require('./packages/daemon/package.json').version\")\" && git tag daemon-v$(node -p \"require('./packages/daemon/package.json').version\") && git push && git push --tags",
     "release:major": "npm version major --no-git-tag-version && cd ../.. && pnpm install --lockfile-only && git add packages/daemon/package.json pnpm-lock.yaml && git commit -m \"chore: bump @botiverse/raft-daemon to v$(node -p \"require('./packages/daemon/package.json').version\")\" && git tag daemon-v$(node -p \"require('./packages/daemon/package.json').version\") && git push && git push --tags",