@cabane/companion 0.6.5 → 0.6.7

package/dist/cli.js

@@ -2827,7 +2827,17 @@ import {
 } from "@anthropic-ai/claude-agent-sdk";
 
 // packages/agent-runtime/src/claude-code/addendum.ts
-var CLAUDE_CODE_ADDENDUM = "";
+var CLAUDE_CODE_ADDENDUM = [
+  "On this harness the Cabane tools register under MCP prefixes. The workspace tool is",
+  "`mcp__cabane__sdk`; the ancillary tools are `mcp__cabane__list_workspaces`,",
+  "`mcp__cabane__read_binary`, `mcp__cabane__upload`, `mcp__cabane__begin_upload`,",
+  "`mcp__cabane__finalize_upload`, and `mcp__cabane__mint_render_token`; the turn tools are",
+  "`mcp__cabane_companion__ask`, `mcp__cabane_companion__wake_me`,",
+  "`mcp__cabane_companion__summon_agent`, `mcp__cabane_companion__sub_agent`, and",
+  "`mcp__cabane_companion__skip_turn`. Where this prompt names a tool by its bare verb, call",
+  "the prefixed form from your tool list. Your harness's own tools (shell, local file",
+  "read/edit) keep their ordinary names and act on the local machine only."
+].join(" ");
 
 // packages/agent-runtime/src/claude-code/policy.ts
 import { z as z9 } from "zod";
@@ -3612,19 +3622,15 @@ function selectAdapter(registry, runtime) {
 
 // packages/agent-runtime/src/opencode/addendum.ts
 var OPENCODE_ADDENDUM = [
-  "Your one Cabane workspace tool has a plain name \u2014 `sdk` (you act on the",
-  "workspace by writing a TypeScript program and calling `sdk` with it); the",
-  "turn-control verbs (`ask`, `wake_me`, `summon_agent`, `skip_turn`) are",
-  "plain-named too, as are the few ancillary cabane tools (`list_workspaces`,",
-  "`read_binary`, `upload`, `begin_upload`, `finalize_upload`,",
-  "`mint_render_token`), and the host tools are plain verbs (`bash`, `read`,",
-  "`edit`). There is no `write`/`search`/`edit` CABANE tool here \u2014 those are",
-  "`cabane` SDK calls inside your program, not tools (a bare `read`/`edit` is the",
-  "HOST tool). If a tool appears in this prompt with an `mcp__\u2026__` prefix, that",
-  "prefix is not part of its name \u2014 call the tool by its plain verb. Write your",
-  "closing reply as the last thing you say in the turn: you can interleave",
-  "narration with tool calls, but only your final message is recorded as the",
-  "turn\u2019s reply."
+  "Every tool here goes by its plain name: the workspace tool is `sdk`; the turn tools are",
+  "`ask`, `wake_me`, `summon_agent`, `sub_agent`, `skip_turn`; the ancillary tools are",
+  "`list_workspaces`, `read_binary`, `upload`, `begin_upload`, `finalize_upload`,",
+  "`mint_render_token`; and the host tools are plain verbs too (`bash`, `read`, `edit`). Mind",
+  "the collision: a bare `read` or `edit` is the HOST tool, acting on the local machine \u2014 a",
+  "workspace read is `cabane.files.read` inside an `sdk` program. If a tool ever appears with",
+  "an `mcp__\u2026__` prefix, that prefix is not part of its name here. One more harness fact: you",
+  "can interleave narration with tool calls, but only your final message is recorded as the",
+  "turn's reply \u2014 write your closing answer last."
 ].join(" ");
 
 // packages/agent-runtime/src/opencode/events.ts
@@ -4577,22 +4583,17 @@ var OPENCODE_CONFORMANCE_FIXTURES = [
 
 // packages/agent-runtime/src/codex/addendum.ts
 var CODEX_ADDENDUM = [
-  "Your Cabane workspace tool is exposed to Codex as the qualified MCP tool",
-  "`mcp__cabane__sdk`. On Codex versions that defer MCP tools, locate it in the",
-  "`functions.exec` deferred-tool inventory and invoke that exact qualified tool",
-  "from the exec program; do not look for or call a bare top-level `sdk` tool.",
-  "If discovery or an invocation fails, report the recorded tool error; never",
-  "declare the SDK absent without attempting discovery and invocation. The SDK",
-  "call runs a TypeScript program against the ambient `cabane` object. The",
-  "turn-control verbs (`ask`, `wake_me`, `summon_agent`, `skip_turn`) are",
-  "qualified `mcp__cabane_companion__\u2026` tools (and may be deferred too), as are",
-  "the few ancillary cabane tools (`mcp__cabane__list_workspaces`,",
-  "`mcp__cabane__read_binary`, the upload tools, `mcp__cabane__mint_render_token`).",
-  "There is no Cabane `read`/`write`/`search`/`edit` tool here \u2014 those are `cabane`",
-  "SDK calls inside your program, not tools. If a tool appears in this prompt with",
-  "an `mcp__\u2026__` prefix, preserve that qualified name. Write your closing reply as",
-  "the last thing you say in the turn: you can interleave narration with tool",
-  "calls, but only your final message is recorded as the turn\u2019s reply."
+  "Codex surfaces MCP tools under qualified names, and on some versions defers them. The",
+  "workspace tool is `mcp__cabane__sdk` \u2014 if it isn't in your visible tool list, locate it in",
+  "the deferred-tool inventory and invoke that exact qualified name; never conclude the SDK is",
+  "absent without attempting discovery and invocation, and if a call fails, report the recorded",
+  "error. The turn tools are `mcp__cabane_companion__ask` / `wake_me` / `summon_agent` /",
+  "`sub_agent` / `skip_turn`, and the ancillary tools `mcp__cabane__list_workspaces` /",
+  "`read_binary` / `upload` / `begin_upload` / `finalize_upload` / `mint_render_token` \u2014 all",
+  "possibly deferred too. There is no Cabane `read`/`write`/`search` tool \u2014 those are",
+  "`cabane.*` calls inside your program. One more harness fact: you can interleave narration",
+  "with tool calls, but only your final message is recorded as the turn's reply \u2014 write your",
+  "closing answer last."
 ].join(" ");
 
 // packages/agent-runtime/src/codex/events.ts
@@ -6289,7 +6290,7 @@ function createSummonMcpServer(summonState, skipState, askState, subAgentCreate,
       ...askState ? [
         tool(
           ASK_TOOL,
-          "Ask a HUMAN a structured question (or a short LIST of them) you need answered to continue, then END your turn \u2014 don't wait for the reply. Use it when you genuinely can't proceed without a person's input (a decision only they can make, a missing fact, a go/no-go). Pass `targetUserId` (a workspace member's user id \u2014 get it from `mcp__cabane__list_members`). Two forms: a SINGLE question \u2014 a `headline` (the actual question as one clear, capitalized sentence ending in `?`, \"Do we go to prod?\") plus a short `question` body for the framing the headline can't hold \u2014 OR, when a plan ends with SEVERAL bounded decisions at once (\"three calls before I build: A? B? C?\"), a `questions` array of 1\u20135 items, each `{ headline, body?, options? }`. **Prefer the list over cramming the extra decisions into prose or dropping them** \u2014 end the turn with one ask carrying every question, never pick one and bury the rest. Each question keeps the same form rules: a one-sentence `headline`, a short `body` frame (NOT a report \u2014 your status, links, and detail go in your REPLY, and the body renders inline markdown only: links/emphasis/inline code, no bulleted lists or headings), and 2\u20134 `options` when the answer is a bounded choice \u2014 for a yes/no go-ahead always pass them, so it's one click, not a typed reply. An option can be a short button label OR a sentence that carries its own context; short/binary sets render as inline buttons, long ones stack full-width. Provide EITHER `question` (single) or `questions` (array), never both. The ask is recorded as a first-class attention item aimed at that person; your final reply carries the surrounding CONTEXT (what you found, why you're stuck), the ask carries the QUESTION(S). An open ask marks you as blocked until EVERY question is answered, so raise one only when you truly can't proceed \u2014 never ceremonially. One ask per turn (last call wins). After asking, stop \u2014 when the person replies addressed to you, the ask resolves and you resume; other people's or agents' messages may wake you but leave it open. Targets a human only; to hand work to another AGENT use summon/dispatch instead.",
+          "Ask a HUMAN a structured question (or a short LIST of them) you need answered to continue, then END your turn \u2014 don't wait for the reply. Use it when you genuinely can't proceed without a person's input (a decision only they can make, a missing fact). Pass `targetUserId` (a workspace member's user id \u2014 get it from `mcp__cabane__list_members`). Two forms: a SINGLE question \u2014 a `headline` (the actual question as one clear, capitalized sentence ending in `?`, \"Do we go to prod?\") plus a short `question` body for the framing the headline can't hold \u2014 OR, when a plan ends with SEVERAL bounded decisions at once, a `questions` array of 1\u20135 items, each `{ headline, body?, options? }`. **Prefer the list over cramming the extra decisions into prose or dropping them** \u2014 end the turn with one ask carrying every question, never pick one and bury the rest. Each question keeps the same form rules: a one-sentence `headline`, a short `body` frame (NOT a report \u2014 your status, links, and detail go in your REPLY, and the body renders inline markdown only: links/emphasis/inline code, no bulleted lists or headings), and 2\u20134 `options` when the answer is a bounded choice \u2014 for a yes/no go-ahead always pass them, so it's one click, not a typed reply. An option can be a short button label or a whole sentence. Provide EITHER `question` (single) or `questions` (array), never both. The ask is a first-class attention item aimed at that person; your final reply carries the surrounding CONTEXT (what you found, why you're stuck), the ask carries the QUESTION(S). An open ask marks you as blocked until EVERY question is answered, so raise one only when you truly can't proceed \u2014 never ceremonially. One ask per turn (last call wins). After asking, stop \u2014 when the person replies addressed to you, the ask resolves and you resume; other people's or agents' messages may wake you but leave it open. Targets a human only; to hand work to another AGENT use summon/dispatch instead.",
           {
             targetUserId: z12.string().uuid().describe("The workspace member (human) to ask \u2014 a user id from `list_members`."),
             question: z12.string().min(1).max(400).optional().describe(
@@ -6396,7 +6397,7 @@ function createSummonMcpServer(summonState, skipState, askState, subAgentCreate,
       ...wakeState ? [
         tool(
           WAKE_ME_TOOL,
-          'Wake yourself later \u2014 end this turn now and be re-dispatched at a time you pick, with a note you write to yourself. Use it for "wait until X": when the thing you need hasn\'t happened yet (a conversation isn\'t done, a PR isn\'t merged, a human hasn\'t answered), arm a wake, end your turn, and you\'re woken later to CHECK \u2014 read the workspace, and either act or re-arm. This is the loop behind "check back in five minutes", "keep checking until {condition}", and a scheduled re-try ("re-send once that agent\'s limit resets"). Ground the delay before you arm it. Almost every wake is short \u2014 seconds to a couple of hours \u2014 waiting on a condition you can name: a session limit resetting, a PR merging, a deploy landing, a throttled dispatch to re-send. Reach past a few hours only when (a) a human asked for that timing, or (b) the wait is pinned to a real external event you can name \u2014 a report that only runs Mondays, a scheduled appointment, a known reset time. A speculative far-future check-in you invented yourself \u2014 "in two weeks I\'ll see whether this feature is used" \u2014 is the one thing not to arm: if no one asked and you can\'t name both what clears the wait and why it takes that long, don\'t arm it \u2014 finish now, or raise an `ask`. Pass EXACTLY ONE of `afterSeconds` (a relative delay \u2014 `300` for five minutes) or `at` (an absolute ISO-8601 timestamp WITH a zone, e.g. `2026-07-16T09:00:00-07:00` \u2014 YOU compute it from a phrase like "tomorrow morning"; the system never parses natural-language time). `note` is a message to your future self \u2014 it becomes the body of the wake message that re-dispatches you, so write the condition to re-check ("check whether CT441 merged yet"). The wake is armed when your turn SETTLES, not now, so the delay counts from the turn ending; one wake per turn (last call wins). This is the sanctioned way to schedule your own continuation \u2014 the ONLY one; never reach for a host cron/scheduler. Guardrails: at least 60s out, at most 14 days; widen the interval as a loop ages (5m \u2192 15m \u2192 1h\u2026) rather than hammering; after many consecutive re-arms with no other activity you\'ll be steered to raise an `ask` to the human instead. If a wake can\'t be armed you\'re re-dispatched with a note explaining why \u2014 never a silent drop.',
+          "Wake yourself later \u2014 end this turn now and be re-dispatched at a time you pick, with a note you write to yourself. Use it for \"wait until X\": when the thing you need hasn't happened yet (a PR isn't merged, a human hasn't answered), arm a wake, end your turn, and you're woken later to CHECK \u2014 read the workspace, and either act or re-arm. Ground the delay before you arm it. Almost every wake is short \u2014 seconds to a couple of hours \u2014 waiting on a condition you can name: a session limit resetting, a PR merging. Reach past a few hours only when (a) a human asked for that timing, or (b) the wait is pinned to a real external event you can name \u2014 a report that only runs Mondays, a known reset time. A speculative far-future check-in you invented yourself is the one thing not to arm: if no one asked and you can't name both what clears the wait and why it takes that long, don't arm it \u2014 finish now, or raise an `ask`. Pass EXACTLY ONE of `afterSeconds` (a relative delay \u2014 `300` for five minutes) or `at` (an absolute ISO-8601 timestamp WITH a zone, e.g. `2026-07-16T09:00:00-07:00` \u2014 YOU compute it from a phrase like \"tomorrow morning\"; the system never parses natural-language time). `note` is a message to your future self \u2014 it becomes the body of the wake message that re-dispatches you, so write the condition to re-check (\"check whether CT441 merged yet\"). The wake is armed when your turn SETTLES, not now, so the delay counts from the turn ending; one wake per turn (last call wins). This is the sanctioned way to schedule your own continuation \u2014 the ONLY one; never reach for a host cron/scheduler. Guardrails: at least 60s out, at most 14 days; widen the interval as a loop ages (5m \u2192 15m \u2192 1h\u2026) rather than hammering; after many consecutive re-arms with no other activity you'll be steered to raise an `ask` to the human instead. If a wake can't be armed you're re-dispatched with a note explaining why \u2014 never a silent drop.",
           {
             afterSeconds: z12.number().int().positive().optional().describe(
               "Relative delay in seconds from when this turn ends (e.g. 300 = five minutes). Provide EITHER this or `at`, not both. Floor 60s, horizon 14 days \u2014 enforced server-side."
@@ -7286,13 +7287,13 @@ ${reason}`,
     const wakeState = createWakeState();
     const subAgentCreate = async (args) => {
       const dispatchTarget = args.agentId ?? payload.agentId;
-      const channelId = turnContext.conversation.channelId;
+      const projectId = turnContext.conversation.projectId;
       const { status: status2, body } = await this.opts.api.createSubAgentConversation(
         workspaceId,
         payload.conversationId,
         turnContext.turnToken ?? this.opts.credential,
         {
-          ...channelId ? { channelId } : {},
+          ...projectId ? { projectId } : {},
           ...args.title ? { title: args.title } : {},
           body: args.prompt,
           dispatch: dispatchTarget,

package/dist/runtime.js

@@ -2480,7 +2480,17 @@ import {
 } from "@anthropic-ai/claude-agent-sdk";
 
 // packages/agent-runtime/src/claude-code/addendum.ts
-var CLAUDE_CODE_ADDENDUM = "";
+var CLAUDE_CODE_ADDENDUM = [
+  "On this harness the Cabane tools register under MCP prefixes. The workspace tool is",
+  "`mcp__cabane__sdk`; the ancillary tools are `mcp__cabane__list_workspaces`,",
+  "`mcp__cabane__read_binary`, `mcp__cabane__upload`, `mcp__cabane__begin_upload`,",
+  "`mcp__cabane__finalize_upload`, and `mcp__cabane__mint_render_token`; the turn tools are",
+  "`mcp__cabane_companion__ask`, `mcp__cabane_companion__wake_me`,",
+  "`mcp__cabane_companion__summon_agent`, `mcp__cabane_companion__sub_agent`, and",
+  "`mcp__cabane_companion__skip_turn`. Where this prompt names a tool by its bare verb, call",
+  "the prefixed form from your tool list. Your harness's own tools (shell, local file",
+  "read/edit) keep their ordinary names and act on the local machine only."
+].join(" ");
 
 // packages/agent-runtime/src/claude-code/policy.ts
 import { z as z9 } from "zod";
@@ -3265,19 +3275,15 @@ function selectAdapter(registry, runtime) {
 
 // packages/agent-runtime/src/opencode/addendum.ts
 var OPENCODE_ADDENDUM = [
-  "Your one Cabane workspace tool has a plain name \u2014 `sdk` (you act on the",
-  "workspace by writing a TypeScript program and calling `sdk` with it); the",
-  "turn-control verbs (`ask`, `wake_me`, `summon_agent`, `skip_turn`) are",
-  "plain-named too, as are the few ancillary cabane tools (`list_workspaces`,",
-  "`read_binary`, `upload`, `begin_upload`, `finalize_upload`,",
-  "`mint_render_token`), and the host tools are plain verbs (`bash`, `read`,",
-  "`edit`). There is no `write`/`search`/`edit` CABANE tool here \u2014 those are",
-  "`cabane` SDK calls inside your program, not tools (a bare `read`/`edit` is the",
-  "HOST tool). If a tool appears in this prompt with an `mcp__\u2026__` prefix, that",
-  "prefix is not part of its name \u2014 call the tool by its plain verb. Write your",
-  "closing reply as the last thing you say in the turn: you can interleave",
-  "narration with tool calls, but only your final message is recorded as the",
-  "turn\u2019s reply."
+  "Every tool here goes by its plain name: the workspace tool is `sdk`; the turn tools are",
+  "`ask`, `wake_me`, `summon_agent`, `sub_agent`, `skip_turn`; the ancillary tools are",
+  "`list_workspaces`, `read_binary`, `upload`, `begin_upload`, `finalize_upload`,",
+  "`mint_render_token`; and the host tools are plain verbs too (`bash`, `read`, `edit`). Mind",
+  "the collision: a bare `read` or `edit` is the HOST tool, acting on the local machine \u2014 a",
+  "workspace read is `cabane.files.read` inside an `sdk` program. If a tool ever appears with",
+  "an `mcp__\u2026__` prefix, that prefix is not part of its name here. One more harness fact: you",
+  "can interleave narration with tool calls, but only your final message is recorded as the",
+  "turn's reply \u2014 write your closing answer last."
 ].join(" ");
 
 // packages/agent-runtime/src/opencode/events.ts
@@ -4230,22 +4236,17 @@ var OPENCODE_CONFORMANCE_FIXTURES = [
 
 // packages/agent-runtime/src/codex/addendum.ts
 var CODEX_ADDENDUM = [
-  "Your Cabane workspace tool is exposed to Codex as the qualified MCP tool",
-  "`mcp__cabane__sdk`. On Codex versions that defer MCP tools, locate it in the",
-  "`functions.exec` deferred-tool inventory and invoke that exact qualified tool",
-  "from the exec program; do not look for or call a bare top-level `sdk` tool.",
-  "If discovery or an invocation fails, report the recorded tool error; never",
-  "declare the SDK absent without attempting discovery and invocation. The SDK",
-  "call runs a TypeScript program against the ambient `cabane` object. The",
-  "turn-control verbs (`ask`, `wake_me`, `summon_agent`, `skip_turn`) are",
-  "qualified `mcp__cabane_companion__\u2026` tools (and may be deferred too), as are",
-  "the few ancillary cabane tools (`mcp__cabane__list_workspaces`,",
-  "`mcp__cabane__read_binary`, the upload tools, `mcp__cabane__mint_render_token`).",
-  "There is no Cabane `read`/`write`/`search`/`edit` tool here \u2014 those are `cabane`",
-  "SDK calls inside your program, not tools. If a tool appears in this prompt with",
-  "an `mcp__\u2026__` prefix, preserve that qualified name. Write your closing reply as",
-  "the last thing you say in the turn: you can interleave narration with tool",
-  "calls, but only your final message is recorded as the turn\u2019s reply."
+  "Codex surfaces MCP tools under qualified names, and on some versions defers them. The",
+  "workspace tool is `mcp__cabane__sdk` \u2014 if it isn't in your visible tool list, locate it in",
+  "the deferred-tool inventory and invoke that exact qualified name; never conclude the SDK is",
+  "absent without attempting discovery and invocation, and if a call fails, report the recorded",
+  "error. The turn tools are `mcp__cabane_companion__ask` / `wake_me` / `summon_agent` /",
+  "`sub_agent` / `skip_turn`, and the ancillary tools `mcp__cabane__list_workspaces` /",
+  "`read_binary` / `upload` / `begin_upload` / `finalize_upload` / `mint_render_token` \u2014 all",
+  "possibly deferred too. There is no Cabane `read`/`write`/`search` tool \u2014 those are",
+  "`cabane.*` calls inside your program. One more harness fact: you can interleave narration",
+  "with tool calls, but only your final message is recorded as the turn's reply \u2014 write your",
+  "closing answer last."
 ].join(" ");
 
 // packages/agent-runtime/src/codex/events.ts
@@ -5942,7 +5943,7 @@ function createSummonMcpServer(summonState, skipState, askState, subAgentCreate,
       ...askState ? [
         tool(
           ASK_TOOL,
-          "Ask a HUMAN a structured question (or a short LIST of them) you need answered to continue, then END your turn \u2014 don't wait for the reply. Use it when you genuinely can't proceed without a person's input (a decision only they can make, a missing fact, a go/no-go). Pass `targetUserId` (a workspace member's user id \u2014 get it from `mcp__cabane__list_members`). Two forms: a SINGLE question \u2014 a `headline` (the actual question as one clear, capitalized sentence ending in `?`, \"Do we go to prod?\") plus a short `question` body for the framing the headline can't hold \u2014 OR, when a plan ends with SEVERAL bounded decisions at once (\"three calls before I build: A? B? C?\"), a `questions` array of 1\u20135 items, each `{ headline, body?, options? }`. **Prefer the list over cramming the extra decisions into prose or dropping them** \u2014 end the turn with one ask carrying every question, never pick one and bury the rest. Each question keeps the same form rules: a one-sentence `headline`, a short `body` frame (NOT a report \u2014 your status, links, and detail go in your REPLY, and the body renders inline markdown only: links/emphasis/inline code, no bulleted lists or headings), and 2\u20134 `options` when the answer is a bounded choice \u2014 for a yes/no go-ahead always pass them, so it's one click, not a typed reply. An option can be a short button label OR a sentence that carries its own context; short/binary sets render as inline buttons, long ones stack full-width. Provide EITHER `question` (single) or `questions` (array), never both. The ask is recorded as a first-class attention item aimed at that person; your final reply carries the surrounding CONTEXT (what you found, why you're stuck), the ask carries the QUESTION(S). An open ask marks you as blocked until EVERY question is answered, so raise one only when you truly can't proceed \u2014 never ceremonially. One ask per turn (last call wins). After asking, stop \u2014 when the person replies addressed to you, the ask resolves and you resume; other people's or agents' messages may wake you but leave it open. Targets a human only; to hand work to another AGENT use summon/dispatch instead.",
+          "Ask a HUMAN a structured question (or a short LIST of them) you need answered to continue, then END your turn \u2014 don't wait for the reply. Use it when you genuinely can't proceed without a person's input (a decision only they can make, a missing fact). Pass `targetUserId` (a workspace member's user id \u2014 get it from `mcp__cabane__list_members`). Two forms: a SINGLE question \u2014 a `headline` (the actual question as one clear, capitalized sentence ending in `?`, \"Do we go to prod?\") plus a short `question` body for the framing the headline can't hold \u2014 OR, when a plan ends with SEVERAL bounded decisions at once, a `questions` array of 1\u20135 items, each `{ headline, body?, options? }`. **Prefer the list over cramming the extra decisions into prose or dropping them** \u2014 end the turn with one ask carrying every question, never pick one and bury the rest. Each question keeps the same form rules: a one-sentence `headline`, a short `body` frame (NOT a report \u2014 your status, links, and detail go in your REPLY, and the body renders inline markdown only: links/emphasis/inline code, no bulleted lists or headings), and 2\u20134 `options` when the answer is a bounded choice \u2014 for a yes/no go-ahead always pass them, so it's one click, not a typed reply. An option can be a short button label or a whole sentence. Provide EITHER `question` (single) or `questions` (array), never both. The ask is a first-class attention item aimed at that person; your final reply carries the surrounding CONTEXT (what you found, why you're stuck), the ask carries the QUESTION(S). An open ask marks you as blocked until EVERY question is answered, so raise one only when you truly can't proceed \u2014 never ceremonially. One ask per turn (last call wins). After asking, stop \u2014 when the person replies addressed to you, the ask resolves and you resume; other people's or agents' messages may wake you but leave it open. Targets a human only; to hand work to another AGENT use summon/dispatch instead.",
           {
             targetUserId: z12.string().uuid().describe("The workspace member (human) to ask \u2014 a user id from `list_members`."),
             question: z12.string().min(1).max(400).optional().describe(
@@ -6049,7 +6050,7 @@ function createSummonMcpServer(summonState, skipState, askState, subAgentCreate,
       ...wakeState ? [
         tool(
           WAKE_ME_TOOL,
-          'Wake yourself later \u2014 end this turn now and be re-dispatched at a time you pick, with a note you write to yourself. Use it for "wait until X": when the thing you need hasn\'t happened yet (a conversation isn\'t done, a PR isn\'t merged, a human hasn\'t answered), arm a wake, end your turn, and you\'re woken later to CHECK \u2014 read the workspace, and either act or re-arm. This is the loop behind "check back in five minutes", "keep checking until {condition}", and a scheduled re-try ("re-send once that agent\'s limit resets"). Ground the delay before you arm it. Almost every wake is short \u2014 seconds to a couple of hours \u2014 waiting on a condition you can name: a session limit resetting, a PR merging, a deploy landing, a throttled dispatch to re-send. Reach past a few hours only when (a) a human asked for that timing, or (b) the wait is pinned to a real external event you can name \u2014 a report that only runs Mondays, a scheduled appointment, a known reset time. A speculative far-future check-in you invented yourself \u2014 "in two weeks I\'ll see whether this feature is used" \u2014 is the one thing not to arm: if no one asked and you can\'t name both what clears the wait and why it takes that long, don\'t arm it \u2014 finish now, or raise an `ask`. Pass EXACTLY ONE of `afterSeconds` (a relative delay \u2014 `300` for five minutes) or `at` (an absolute ISO-8601 timestamp WITH a zone, e.g. `2026-07-16T09:00:00-07:00` \u2014 YOU compute it from a phrase like "tomorrow morning"; the system never parses natural-language time). `note` is a message to your future self \u2014 it becomes the body of the wake message that re-dispatches you, so write the condition to re-check ("check whether CT441 merged yet"). The wake is armed when your turn SETTLES, not now, so the delay counts from the turn ending; one wake per turn (last call wins). This is the sanctioned way to schedule your own continuation \u2014 the ONLY one; never reach for a host cron/scheduler. Guardrails: at least 60s out, at most 14 days; widen the interval as a loop ages (5m \u2192 15m \u2192 1h\u2026) rather than hammering; after many consecutive re-arms with no other activity you\'ll be steered to raise an `ask` to the human instead. If a wake can\'t be armed you\'re re-dispatched with a note explaining why \u2014 never a silent drop.',
+          "Wake yourself later \u2014 end this turn now and be re-dispatched at a time you pick, with a note you write to yourself. Use it for \"wait until X\": when the thing you need hasn't happened yet (a PR isn't merged, a human hasn't answered), arm a wake, end your turn, and you're woken later to CHECK \u2014 read the workspace, and either act or re-arm. Ground the delay before you arm it. Almost every wake is short \u2014 seconds to a couple of hours \u2014 waiting on a condition you can name: a session limit resetting, a PR merging. Reach past a few hours only when (a) a human asked for that timing, or (b) the wait is pinned to a real external event you can name \u2014 a report that only runs Mondays, a known reset time. A speculative far-future check-in you invented yourself is the one thing not to arm: if no one asked and you can't name both what clears the wait and why it takes that long, don't arm it \u2014 finish now, or raise an `ask`. Pass EXACTLY ONE of `afterSeconds` (a relative delay \u2014 `300` for five minutes) or `at` (an absolute ISO-8601 timestamp WITH a zone, e.g. `2026-07-16T09:00:00-07:00` \u2014 YOU compute it from a phrase like \"tomorrow morning\"; the system never parses natural-language time). `note` is a message to your future self \u2014 it becomes the body of the wake message that re-dispatches you, so write the condition to re-check (\"check whether CT441 merged yet\"). The wake is armed when your turn SETTLES, not now, so the delay counts from the turn ending; one wake per turn (last call wins). This is the sanctioned way to schedule your own continuation \u2014 the ONLY one; never reach for a host cron/scheduler. Guardrails: at least 60s out, at most 14 days; widen the interval as a loop ages (5m \u2192 15m \u2192 1h\u2026) rather than hammering; after many consecutive re-arms with no other activity you'll be steered to raise an `ask` to the human instead. If a wake can't be armed you're re-dispatched with a note explaining why \u2014 never a silent drop.",
           {
             afterSeconds: z12.number().int().positive().optional().describe(
               "Relative delay in seconds from when this turn ends (e.g. 300 = five minutes). Provide EITHER this or `at`, not both. Floor 60s, horizon 14 days \u2014 enforced server-side."
@@ -6939,13 +6940,13 @@ ${reason}`,
     const wakeState = createWakeState();
     const subAgentCreate = async (args) => {
       const dispatchTarget = args.agentId ?? payload.agentId;
-      const channelId = turnContext.conversation.channelId;
+      const projectId = turnContext.conversation.projectId;
       const { status, body } = await this.opts.api.createSubAgentConversation(
         workspaceId,
         payload.conversationId,
         turnContext.turnToken ?? this.opts.credential,
         {
-          ...channelId ? { channelId } : {},
+          ...projectId ? { projectId } : {},
           ...args.title ? { title: args.title } : {},
           body: args.prompt,
           dispatch: dispatchTarget,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cabane/companion",
-  "version": "0.6.5",
+  "version": "0.6.7",
   "type": "module",
   "description": "The Cabane Companion (headless): connect a coding agent on your machine to your Cabane workspace as a responder — drive work against your own codebase, files, and MCP servers without putting any of it in Cabane.",
   "license": "UNLICENSED",