borgmcp 2.4.1 → 2.6.0

package/src/log-stream.ts

@@ -120,9 +120,13 @@ function isProcessAlive(pid: number): boolean {
  * startup (from index.ts) once the opencode drone module is initialized.
  * Used by defaultDeps when no explicit injectOpenCode is supplied.
  */
-let _moduleInjectOpenCode: ((text: string) => Promise<boolean>) | undefined;
+let _moduleInjectOpenCode:
+  | ((text: string, entryId: string, allowSubmit: boolean) => Promise<boolean>)
+  | undefined;
 
-export function setModuleInjectOpenCode(fn: (text: string) => Promise<boolean>): void {
+export function setModuleInjectOpenCode(
+  fn: (text: string, entryId: string, allowSubmit: boolean) => Promise<boolean>
+): void {
   _moduleInjectOpenCode = fn;
 }
 
@@ -387,13 +391,12 @@ export interface StreamDeps {
   ownerDeps?: import('./stream-owner.js').StreamOwnerDeps;
   /** Override owner stale threshold in focused duplicate-process tests. */
   ownerStaleMs?: number;
-  /**
-   * Optional opencode entry injector for autonomous drone processing.
-   * When provided AND the injection succeeds, the inbox file write is skipped
-   * (the drone processes the entry autonomously). On failure, falls through
-   * to the inbox write for backup.
-   */
-  injectOpenCode?: (text: string) => Promise<boolean>;
+  /** Optional OpenCode wake delivery after the durable inbox append. */
+  injectOpenCode?: (
+    text: string,
+    entryId: string,
+    allowSubmit: boolean
+  ) => Promise<boolean>;
 }
 
 const defaultDeps: Required<StreamDeps> = {
@@ -408,7 +411,10 @@ const defaultDeps: Required<StreamDeps> = {
   abortSignal: new AbortController().signal,
   ownerDeps: {},
   ownerStaleMs: 70_000,
-  injectOpenCode: (text) => _moduleInjectOpenCode ? _moduleInjectOpenCode(text) : Promise.resolve(false),
+  injectOpenCode: (text, entryId, allowSubmit) =>
+    _moduleInjectOpenCode
+      ? _moduleInjectOpenCode(text, entryId, allowSubmit)
+      : Promise.resolve(false),
 };
 
 // ------------------------------------------------------------------
@@ -814,24 +820,24 @@ export async function streamOnce(
     ev: Extract<ParsedEvent, { type: 'log' }>
   ): Promise<'persisted-skip' | 'written'> => {
     const line = formatInboxLine(withSseEventId(ev.data, ev.id));
-    if (
-      isCatchingUp &&
+    const alreadyPersisted = isCatchingUp && (
       // gh#441: pass the rendered line so the dedup can also recognize LEGACY
       // (no-entry_id-prefix) on-disk lines, not just the [entry_id:] marker.
-      (await hasInboxEntryId(active.cubeId, active.droneId, ev.id, line))
-    ) {
+      await hasInboxEntryId(active.cubeId, active.droneId, ev.id, line)
+    );
+    if (alreadyPersisted) {
+      // Replay still re-enters the OpenCode delivery queue with the same entry
+      // ID. The queue confirms/deduplicates it by stable OpenCode message ID.
+      await injectOpenCode(line, ev.id, false);
       markEventPersisted(ev.id, ev.data?.created_at ?? '');
       return 'persisted-skip';
     }
-    // gh#opencode: try autonomous opencode injection first. When the drone's
-    // child session processes entries directly, skip the inbox write (the
-    // Monitor/tail-F path is unused for opencode). Falls through to inbox on
-    // failure so the entry is never lost.
-    if (await injectOpenCode(line)) {
-      return 'written';
-    }
+    // The inbox append is the durable record. OpenCode injection is only the
+    // wake attempt and may return before the agent finishes processing.
     await appendLine(active.cubeId, active.droneId, line);
-    wakeCodex(formatCodexWakePrompt(line));
+    if (!(await injectOpenCode(line, ev.id, true))) {
+      wakeCodex(formatCodexWakePrompt(line));
+    }
     return 'written';
   };
 
@@ -978,11 +984,16 @@ export async function streamOnce(
       if (event.type === 'eviction') {
         streamState.lastContentEventAt = nowIso;
         try {
+          const line = formatEvictionSentinelLine(event.reason);
           await appendLine(
             active.cubeId,
             active.droneId,
-            formatEvictionSentinelLine(event.reason)
+            line
           );
+          const entryId =
+            event.id ??
+            `control:eviction:${active.cubeId}:${active.droneId}:${event.reason ?? ''}`;
+          await injectOpenCode(line, entryId, true);
         } catch {
           // Inbox write failed — the Path-B 410 backstop still tears the drone
           // down on its next authed call. Best-effort wake only.
@@ -1178,7 +1189,7 @@ export type ParsedEvent =
   | { type: 'heartbeat'; ts: string | null; hwm: BroadcastHwm | null }
   | { type: 'bookmark'; as_of: string | null }
   // gh#877 Path-A: terminal eviction control frame (wake hint, zero authority).
-  | { type: 'eviction'; cube_id: string | null; reason: string | null }
+  | { type: 'eviction'; id: string | null; cube_id: string | null; reason: string | null }
   | { type: 'unknown'; raw: string };
 
 /**
@@ -1336,7 +1347,7 @@ function parseEventBlock(block: string): ParsedEvent | null {
     } catch {
       // fall through with nulls
     }
-    return { type: 'eviction', cube_id, reason };
+    return { type: 'eviction', id: id || null, cube_id, reason };
   }
   return { type: 'unknown', raw: block };
 }

package/src/opencode-drone.ts

@@ -19,6 +19,13 @@ interface OpenCodeDroneState {
   cubeName: string;
   connected: boolean;
   totalEntriesInjected: number;
+  totalEntriesRetried: number;
+  deliveryQueue: OpenCodeDelivery[];
+  activeDeliveries: Map<string, OpenCodeDelivery>;
+  deliveredEntries: Map<string, string>;
+  unconfirmedEntries: Map<string, string>;
+  failedEntries: Map<string, string>;
+  processingDeliveries: boolean;
 }
 
 let state: OpenCodeDroneState | null = null;
@@ -41,6 +48,7 @@ interface OCSession {
 
 interface OCMessage {
   info?: {
+    id?: string;
     role?: string;
     time?: { created?: number };
   };
@@ -50,6 +58,27 @@ interface OCMessage {
   }>;
 }
 
+export type OpenCodeDeliveryState =
+  | 'queued'
+  | 'delivered-unconfirmed'
+  | 'retried'
+  | 'failed';
+
+interface OpenCodeDelivery {
+  entryId: string;
+  text: string;
+  messageId: string;
+  allowSubmit: boolean;
+  state: Exclude<OpenCodeDeliveryState, 'failed'>;
+  resolve: (delivered: boolean) => void;
+  promise: Promise<boolean>;
+}
+
+type OpenCodeDeliveryOutcome = 'delivered' | 'delivered-unconfirmed' | 'failed';
+
+const OPEN_CODE_DELIVERY_RETRY_DELAYS_MS = [0, 250, 1_000, 3_000] as const;
+const OPEN_CODE_DELIVERY_HISTORY_LIMIT = 256;
+
 interface SessionBinding {
   version: 2;
   sessionId: string;
@@ -89,7 +118,18 @@ export function createOpenCodeLaunchKickoff(
 
 const bindingPathsForTests = new Set<string>();
 
+function abandonOpenCodeDeliveries(current: OpenCodeDroneState | null): void {
+  if (!current) return;
+  current.connected = false;
+  for (const delivery of current.activeDeliveries.values()) {
+    delivery.resolve(false);
+  }
+  current.activeDeliveries.clear();
+  current.deliveryQueue.length = 0;
+}
+
 export async function connectOpenCodeDrone(deps: ConnectDeps): Promise<void> {
+  abandonOpenCodeDeliveries(state);
   state = {
     serverUrl: deps.serverUrl,
     sessionId: null,
@@ -100,6 +140,13 @@ export async function connectOpenCodeDrone(deps: ConnectDeps): Promise<void> {
     cubeName: deps.cubeName,
     connected: true,
     totalEntriesInjected: 0,
+    totalEntriesRetried: 0,
+    deliveryQueue: [],
+    activeDeliveries: new Map(),
+    deliveredEntries: new Map(),
+    unconfirmedEntries: new Map(),
+    failedEntries: new Map(),
+    processingDeliveries: false,
   };
   log(`connected url=${deps.serverUrl} dir=${deps.directory}`);
 }
@@ -153,13 +200,10 @@ async function listSessions(): Promise<OCSession[]> {
 }
 
 async function getSession(id: string): Promise<OCSession | null> {
-  try {
-    const { status, body } = await rawGet(`/session/${id}`);
-    if (status !== 200) return null;
-    return JSON.parse(body);
-  } catch {
-    return null;
-  }
+  const { status, body } = await rawGet(`/session/${id}`);
+  if (status === 404) return null;
+  if (status !== 200) throw new Error(`OpenCode session request failed (${status})`);
+  return JSON.parse(body);
 }
 
 async function listSessionMessages(id: string): Promise<OCMessage[]> {
@@ -168,9 +212,27 @@ async function listSessionMessages(id: string): Promise<OCMessage[]> {
   return JSON.parse(body);
 }
 
-async function promptSession(id: string, bodyObj: Record<string, unknown>): Promise<boolean> {
+async function getSessionMessage(
+  sessionId: string,
+  messageId: string,
+): Promise<'found' | 'missing'> {
+  const { status, body } = await rawGet(
+    `/session/${sessionId}/message/${encodeURIComponent(messageId)}`,
+  );
+  if (status === 404) return 'missing';
+  if (status !== 200) {
+    throw new Error(`OpenCode message request failed (${status})`);
+  }
+  const message = JSON.parse(body) as OCMessage;
+  if (message.info?.id !== messageId || message.info.role !== 'user') {
+    throw new Error('OpenCode returned the wrong injected message');
+  }
+  return 'found';
+}
+
+async function promptSession(id: string, bodyObj: Record<string, unknown>): Promise<number> {
   const { status } = await rawPost(`/session/${id}/prompt_async`, bodyObj);
-  return status === 200 || status === 204;
+  return status;
 }
 
 // ---------------------------------------------------------------------------
@@ -381,11 +443,156 @@ async function resolveInjectionSession(): Promise<OCSession | null> {
   return bound;
 }
 
-async function rebindAfterFailure(knownRootSessionIds: string[]): Promise<OCSession | null> {
-  const replacement = await findUnseenTopLevelSession(knownRootSessionIds);
-  if (!replacement) return null;
-  saveBinding(replacement.session, replacement.knownRootSessionIds);
-  return replacement.session;
+function openCodeMessageId(entryId: string): string {
+  const digest = createHash('sha256').update(entryId).digest('hex');
+  return `msg_borg_${digest}`;
+}
+
+function rememberBounded(
+  entries: Map<string, string>,
+  entryId: string,
+  text: string,
+): void {
+  entries.delete(entryId);
+  entries.set(entryId, text);
+  while (entries.size > OPEN_CODE_DELIVERY_HISTORY_LIMIT) {
+    const oldest = entries.keys().next().value;
+    if (typeof oldest !== 'string') break;
+    entries.delete(oldest);
+  }
+}
+
+function waitForDeliveryRetry(attempt: number): Promise<void> {
+  const delay = OPEN_CODE_DELIVERY_RETRY_DELAYS_MS[attempt] ?? 0;
+  return delay > 0
+    ? new Promise((resolve) => setTimeout(resolve, delay))
+    : Promise.resolve();
+}
+
+async function deliverOpenCodeEntry(
+  owner: OpenCodeDroneState,
+  delivery: OpenCodeDelivery,
+): Promise<OpenCodeDeliveryOutcome> {
+  let target: OCSession | null = null;
+
+  // Before the one allowed POST, retries are safe: no submission has happened.
+  // A replayed inbox entry sets allowSubmit=false, so it can only confirm an
+  // earlier submission and can never manufacture a second prompt.
+  for (let attempt = 0; attempt < OPEN_CODE_DELIVERY_RETRY_DELAYS_MS.length; attempt++) {
+    if (state !== owner || !owner.connected) return 'failed';
+    if (attempt > 0) {
+      delivery.state = 'retried';
+      owner.totalEntriesRetried++;
+      await waitForDeliveryRetry(attempt);
+      if (state !== owner || !owner.connected) return 'failed';
+    }
+
+    if (!target) {
+      try {
+        target = await resolveInjectionSession();
+      } catch (err) {
+        log(`entry ${delivery.entryId} target unavailable: ${err}`);
+        continue;
+      }
+      if (!target) return 'failed';
+    }
+
+    try {
+      if (await getSessionMessage(target.id, delivery.messageId) === 'found') {
+        return 'delivered';
+      }
+    } catch (err) {
+      log(`entry ${delivery.entryId} confirmation unavailable: ${err}`);
+      continue;
+    }
+
+    if (!delivery.allowSubmit) {
+      continue;
+    }
+
+    // OpenCode does not deduplicate repeated prompt_async calls by messageID:
+    // they append duplicate parts. Submit at most once, then only poll the
+    // exact message. A transport failure is ambiguous and follows the same
+    // confirmation-only path.
+    let status: number | null = null;
+    try {
+      status = await promptSession(target.id, {
+        messageID: delivery.messageId,
+        parts: [{ type: 'text', text: delivery.text }],
+      });
+    } catch (err) {
+      log(`entry ${delivery.entryId} submission outcome unavailable: ${err}`);
+    }
+
+    delivery.state = 'delivered-unconfirmed';
+    if (status !== null && status !== 200 && status !== 204) {
+      if (status === 404) clearBinding();
+      return 'failed';
+    }
+
+    for (
+      let confirmationAttempt = 0;
+      confirmationAttempt < OPEN_CODE_DELIVERY_RETRY_DELAYS_MS.length;
+      confirmationAttempt++
+    ) {
+      if (confirmationAttempt > 0) {
+        delivery.state = 'retried';
+        owner.totalEntriesRetried++;
+        await waitForDeliveryRetry(confirmationAttempt);
+        if (state !== owner || !owner.connected) return 'delivered-unconfirmed';
+        delivery.state = 'delivered-unconfirmed';
+      }
+      try {
+        if (await getSessionMessage(target.id, delivery.messageId) === 'found') {
+          return 'delivered';
+        }
+      } catch (err) {
+        log(`entry ${delivery.entryId} post-acceptance confirmation unavailable: ${err}`);
+      }
+    }
+
+    return 'delivered-unconfirmed';
+  }
+
+  // A replay begins from a durable inbox record but cannot know whether the
+  // prior process stopped before or after submission. Missing confirmation
+  // therefore remains unknown, not a definite delivery failure.
+  return delivery.allowSubmit ? 'failed' : 'delivered-unconfirmed';
+}
+
+async function processOpenCodeDeliveries(owner: OpenCodeDroneState): Promise<void> {
+  if (owner.processingDeliveries) return;
+  owner.processingDeliveries = true;
+  try {
+    while (state === owner && owner.deliveryQueue.length > 0) {
+      const delivery = owner.deliveryQueue.shift()!;
+      let outcome: OpenCodeDeliveryOutcome = 'failed';
+      try {
+        outcome = await deliverOpenCodeEntry(owner, delivery);
+      } catch (err) {
+        log(`entry ${delivery.entryId} delivery error: ${err}`);
+      }
+
+      owner.activeDeliveries.delete(delivery.entryId);
+      if (outcome === 'delivered') {
+        owner.unconfirmedEntries.delete(delivery.entryId);
+        owner.failedEntries.delete(delivery.entryId);
+        rememberBounded(owner.deliveredEntries, delivery.entryId, delivery.text);
+        owner.totalEntriesInjected++;
+        delivery.resolve(true);
+      } else if (outcome === 'delivered-unconfirmed') {
+        owner.failedEntries.delete(delivery.entryId);
+        rememberBounded(owner.unconfirmedEntries, delivery.entryId, delivery.text);
+        delivery.resolve(true);
+      } else {
+        owner.unconfirmedEntries.delete(delivery.entryId);
+        rememberBounded(owner.failedEntries, delivery.entryId, delivery.text);
+        delivery.resolve(false);
+      }
+    }
+  } finally {
+    owner.processingDeliveries = false;
+  }
 }
 
 // ---------------------------------------------------------------------------
@@ -434,42 +641,67 @@ export async function injectInitialKickoff(launch: OpenCodeLaunchKickoff): Promi
 }
 
 /**
- * Inject a silent context entry (noReply) into our session.
- * Falls through silently — caller falls back to inbox write.
+ * Queue one durable inbox entry for delivery into the bound OpenCode session.
+ * The SSE entry ID becomes a stable OpenCode message ID, so retries and replay
+ * can confirm an earlier ambiguous submission without running it twice.
  */
-export async function injectOpenCodeEntry(text: string): Promise<boolean> {
-  if (!state?.connected) return false;
-
-  try {
-    const target = await resolveInjectionSession();
-    if (!target) return false;
+export function injectOpenCodeEntry(
+  text: string,
+  entryId: string = createHash('sha256').update(text).digest('hex'),
+  allowSubmit: boolean = true,
+): Promise<boolean> {
+  const owner = state;
+  if (!owner?.connected) return Promise.resolve(false);
+
+  const deliveredText = owner.deliveredEntries.get(entryId);
+  if (deliveredText !== undefined) {
+    if (deliveredText !== text) {
+      log(`entry ${entryId} replay text mismatch`);
+      rememberBounded(owner.failedEntries, entryId, text);
+      return Promise.resolve(false);
+    }
+    return Promise.resolve(true);
+  }
 
-    const body = {
-      parts: [{ type: 'text', text }],
-    };
-    if (await promptSession(target.id, body)) {
-      state.totalEntriesInjected++;
-      return true;
+  const unconfirmedText = owner.unconfirmedEntries.get(entryId);
+  if (unconfirmedText !== undefined) {
+    if (unconfirmedText !== text) {
+      log(`entry ${entryId} unconfirmed replay text mismatch`);
+      rememberBounded(owner.failedEntries, entryId, text);
+      return Promise.resolve(false);
     }
+    return Promise.resolve(true);
+  }
 
-    // A failed prompt means the cached target is no longer trustworthy. Clear
-    // it before considering only a newer root created by `/new`; never fall
-    // through to a child or arbitrary newest session.
-    const knownRootSessionIds = [...state.knownRootSessionIds];
-    clearBinding();
-    const replacement = await rebindAfterFailure(knownRootSessionIds);
-    if (!replacement) return false;
-    if (await promptSession(replacement.id, body)) {
-      state.totalEntriesInjected++;
-      return true;
+  const active = owner.activeDeliveries.get(entryId);
+  if (active) {
+    if (active.text !== text) {
+      log(`entry ${entryId} active text mismatch`);
+      rememberBounded(owner.failedEntries, entryId, text);
+      return Promise.resolve(false);
     }
-    clearBinding();
-    return false;
-  } catch (err) {
-    log(`entry error: ${err}`);
-    clearBinding();
-    return false;
+    return active.promise;
   }
+
+  let resolveDelivery!: (delivered: boolean) => void;
+  const promise = new Promise<boolean>((resolve) => {
+    resolveDelivery = resolve;
+  });
+  const delivery: OpenCodeDelivery = {
+    entryId,
+    text,
+    messageId: openCodeMessageId(entryId),
+    allowSubmit,
+    state: 'queued',
+    resolve: resolveDelivery,
+    promise,
+  };
+  owner.unconfirmedEntries.delete(entryId);
+  owner.failedEntries.delete(entryId);
+  owner.activeDeliveries.set(entryId, delivery);
+  owner.deliveryQueue.push(delivery);
+  void processOpenCodeDeliveries(owner);
+  return promise;
 }
 
 export async function probeOpenCodeDroneArmed(): Promise<boolean | null> {
@@ -483,24 +715,39 @@ export async function probeOpenCodeDroneArmed(): Promise<boolean | null> {
     clearBinding();
     return false;
   } catch {
-    clearBinding();
     return false;
   }
 }
 
 export function disconnectOpenCodeDrone(): void {
+  abandonOpenCodeDeliveries(state);
   state = null;
 }
 
-export function getOpenCodeConnectionState(): {
+export interface OpenCodeConnectionState {
   connected: boolean;
   sessionId: string | null;
   totalEntriesInjected: number;
-} {
+  totalEntriesRetried: number;
+  deliveryStates: Record<OpenCodeDeliveryState, number>;
+}
+
+export function getOpenCodeConnectionState(): OpenCodeConnectionState {
+  const deliveryStates: Record<OpenCodeDeliveryState, number> = {
+    queued: 0,
+    'delivered-unconfirmed': state?.unconfirmedEntries.size ?? 0,
+    retried: 0,
+    failed: state?.failedEntries.size ?? 0,
+  };
+  for (const delivery of state?.activeDeliveries.values() ?? []) {
+    deliveryStates[delivery.state]++;
+  }
   return {
     connected: state?.connected ?? false,
     sessionId: state?.sessionId ?? null,
     totalEntriesInjected: state?.totalEntriesInjected ?? 0,
+    totalEntriesRetried: state?.totalEntriesRetried ?? 0,
+    deliveryStates,
   };
 }
 
@@ -516,6 +763,7 @@ export function computeOpenCodePort(droneId: string, base: number = 14096): numb
 
 /** Test-only cleanup for module state and the local cross-process binding. */
 export function __resetOpenCodeDroneForTests(): void {
+  abandonOpenCodeDeliveries(state);
   state = null;
   for (const path of bindingPathsForTests) {
     try {

package/src/opencode-wake-copy.ts

@@ -0,0 +1,8 @@
+export const OPENCODE_WAKE_PATH_GUIDANCE =
+  'OpenCode wakes through HTTP entry injection into its session through the local HTTP API. ' +
+  'Borg writes each entry to the durable inbox before one injection attempt and ' +
+  'confirms delivery by exact message ID; no inbox Monitor or secondary wake loop is used. ' +
+  'If injection is rejected or cannot be ' +
+  'confirmed, the durable entry remains available and `borg_stream-status` reports ' +
+  'it as failed or delivered-unconfirmed; run `borg_read-log unread_only=true` and ' +
+  'drain the unread log to recover.';

package/src/regen-format.ts

@@ -18,6 +18,7 @@ import {
 } from './roster-render.js';
 import { shellEscape } from './shell-escape.js';
 import { resolveInboxMonitorPath } from './self-path.js';
+import { OPENCODE_WAKE_PATH_GUIDANCE } from './opencode-wake-copy.js';
 
 /**
  * Extract the SessionStart `source` from a Claude Code hook payload (gh#926).
@@ -85,11 +86,7 @@ export function wakePathArming(
     ].join(' ');
   }
   if (agentKind === 'opencode') {
-    return (
-      'Wake path: OpenCode wakes via SDK-driven entry injection into the TUI session — ' +
-      'there is no tail-Monitor or `/loop` heartbeat to arm. Cube posts are delivered ' +
-      'directly into your active session. Use \`borg_regen\` at any time for fresh context.'
-    );
+    return OPENCODE_WAKE_PATH_GUIDANCE;
   }
   // gh#client#18: use absolute path to THIS installation's borg-inbox-monitor
   // so the orientation command always resolves to the same version as the
@@ -249,7 +246,9 @@ You're a Drone in a Cube. Coordinate with other drones through the activity log.
 2. Apply your role's conventions to each entry. Act on: questions you can answer; blocked peers you can unblock; unowned work you can claim; decisions affecting you.
 3. Actionable signal → act + post the convention. Don't wait to be asked.
 4. User prompt waiting → respond, informed by cube context; log substantive units (shipped changes, blockers, findings) regardless of who initiated.
-5. Nothing actionable + no prompt → done; wait for next wake.
+5. Holding unfinished assigned work? Resume it now, in this turn. An acknowledgement
+   or a status reply must never be the last action of a turn while work is outstanding.
+6. Nothing actionable, no prompt, and no work of your own outstanding → done; wait for next wake.
 
 **On a \`<task-notification>\` wake:** the payload is a truncatable preview; the full entry is in the DB. Drain: \`borg_read-log unread_only=true limit=20\`, repeat until \`behind_by=0\`. Do NOT triage with \`since=<notification timestamp>\` (strict-after — skips the boundary entry) or a bare window (skips older-unread during bursts).
 ${arrivalInstruction}
@@ -261,6 +260,7 @@ ${arrivalInstruction}
 **When stuck:** post your blocker per your role's conventions, continue other work. Escalation is per your role detail, not by stalling.
 
 **Anti-passive (lane idle = no work routed to you, no actionable signal in the log):**
+**Completion contract:** A work item is finished when you post its completion or blocked signal, not when you answer a question. If you hold unfinished assigned work, your lane is not idle; resume it in this turn.
 - If your work arrives via dispatch / a work queue: when your lane goes idle, post your role's availability signal (capacity clean, awaiting next assignment from your coordinating role) — once per idle period, don't spam. No assignment in ~15 min → ping your coordinating role (capacity available since <time>; any queue item to pick up?).
 - If your work is SELF-DIRECTED (not dispatch-driven): do NOT post an availability signal — proactively surface lane-substantive work per your role (reviews, audits, proposals, coherence / quality sweeps on relevant in-flight work).
 - Route work-asks through your cube's coordinating role, never directly to the human Queen.

package/src/repository-cube-init.ts

@@ -46,6 +46,8 @@ export interface RepositoryCubeInitDeps {
   isTTY(): boolean;
   prompt(message: string): Promise<string>;
   write(text: string): void;
+  writeResult?(text: string): void;
+  useColor?(): boolean;
   getIdentity(context: GitRepositoryContext): Promise<CreateCubeRepository>;
   getAssociation(repository: CreateCubeRepository): Promise<RepositoryAssociation | null>;
   saveAssociation(repository: CreateCubeRepository, association: RepositoryAssociation): Promise<void>;
@@ -132,8 +134,16 @@ function renderResult(
     adopted?: boolean;
   },
 ): void {
+  const resultWriter = deps.writeResult ?? deps.write;
+  const heading = input.adopted
+    ? 'Existing cube associated with this repository.'
+    : input.existing
+      ? 'Cube already initialized.'
+      : 'Cube created.';
   const lines = [
-    input.adopted ? 'Existing cube associated with this repository.' : input.existing ? 'Cube already initialized.' : 'Cube created.',
+    input.mode === 'cube-init'
+      ? `${deps.useColor?.() ? '\u001b[32m✓\u001b[0m' : '✓'} ${heading}`
+      : heading,
     `  Name: ${input.response.name}`,
     `  Template: ${presentation(input.response.template).label}`,
     `  Repository: ${input.root}`,
@@ -150,7 +160,7 @@ function renderResult(
   } else {
     lines.push('Continuing with role and seat setup...');
   }
-  deps.write(`${lines.join('\n')}\n`);
+  resultWriter(`${lines.join('\n')}\n`);
 }
 
 export async function initializeRepositoryCube(input: {
@@ -300,8 +310,11 @@ export async function initializeRepositoryCube(input: {
   if (proposedAdoption) return proposedAdoption;
 
   if (input.canCreate === false) {
+    const retryCommand = input.mode === 'cube-init'
+      ? `borg server cube init --host ${shellEscape(input.serverOrigin)}`
+      : `borg assimilate --host ${shellEscape(input.serverOrigin)}`;
     deps.write(
-      `This enrolled client cannot create a cube on ${input.serverOrigin}. Ask the server operator to grant access to a cube, then rerun borg assimilate --host ${shellEscape(input.serverOrigin)}.\n`,
+      `This enrolled client cannot create a cube on ${input.serverOrigin}. Ask the server operator to grant access to a cube, then rerun ${retryCommand}.\n`,
     );
     return { kind: 'stop', code: 1 };
   }