ticlawk 0.1.17-dev.18 → 0.1.17-dev.19

package/src/runtimes/pi/index.mjs

@@ -6,8 +6,7 @@
 
 import { basename } from 'node:path';
 import { buildAgentRuntimeEnv } from '../../core/runtime-env.mjs';
-import { getGoalTaskProtocolOverlayKey } from '../_shared/goal-task-protocol.mjs';
-import { buildStandingPrompt } from '../_shared/standing-prompt.mjs';
+import { buildRuntimeBaseInstructions } from '../_shared/runtime-base-instructions.mjs';
 import { ensureAgentHome } from '../../core/agent-home.mjs';
 import {
   buildPiImagesFromInbound,
@@ -19,18 +18,15 @@ import {
   requirePiPath,
   runPiPrompt,
 } from './session.mjs';
-import { emitWorkerEventBestEffort } from '../../core/events/worker-events.mjs';
+import { emitWorkerEvent } from '../../core/events/worker-events.mjs';
 import {
   shouldStreamRuntime,
+  createDeltaAggregator,
   reportSubprocessFailure,
   terminalRuntimeFailure,
   updateBindingRuntimeMeta,
-  resolveRuntimeSessionScope,
-  buildRuntimeSessionMetaPatch,
 } from '../../core/runtime-support.mjs';
 
-const standingPromptSeen = new Set();
-
 export const piRuntime = {
   name: 'pi',
 
@@ -42,8 +38,7 @@ export const piRuntime = {
       images: opts.images,
       piPath,
       agentEnv,
-      standingPrompt: opts.standingPrompt || null,
-      forceStandingPrompt: Boolean(opts.forceStandingPrompt),
+      runtimeBaseInstructions: opts.runtimeBaseInstructions || null,
       timeoutMs: opts.timeoutMs,
     });
   },
@@ -56,8 +51,7 @@ export const piRuntime = {
       images: opts.images,
       piPath,
       agentEnv,
-      standingPrompt: opts.standingPrompt || null,
-      forceStandingPrompt: Boolean(opts.forceStandingPrompt),
+      runtimeBaseInstructions: opts.runtimeBaseInstructions || null,
       timeoutMs: opts.timeoutMs,
       onEvent: opts.onEvent,
     });
@@ -134,39 +128,46 @@ export const piRuntime = {
       message = captionText || 'Please analyze the attached image(s).';
     }
 
-    const sessionScope = resolveRuntimeSessionScope(meta, inbound);
-    const shouldRotate = sessionScope.shouldRotate;
-    const targetSessionId = shouldRotate ? null : sessionScope.sessionId;
+    const shouldRotate = !meta.sessionId || meta.rotatePending;
+    const deltaAggregator = createDeltaAggregator({
+      flushDelta: async ({ text, sessionId, cwd }) => {
+        await emitWorkerEvent({
+          adapter,
+          binding,
+          agent: this.name,
+          sessionId: sessionId || meta.sessionId || binding.id,
+          cwd: cwd || agentHome,
+          replyToMessageId: inbound.messageId || null,
+          event: {
+            hook_event_name: 'worker.message.delta',
+            worker_event_name: 'worker.message.delta',
+            delta: text,
+          },
+          logger: ctx.logger,
+        });
+      },
+    });
 
     try {
       const runtimePiPath = requirePiPath(meta.piPath || meta.runtimePath);
       const runtimePiVersion = getPiRuntimeHealth(runtimePiPath).version || meta.piVersion || null;
       const agentEnv = buildAgentRuntimeEnv({
         agentId: binding.id,
-        sessionId: targetSessionId,
+        sessionId: meta.sessionId,
         hostId: binding.runtime_host_id,
-        conversationId: inbound.conversationId,
-        messageId: inbound.messageId,
-        target: inbound.envelopeTarget,
       });
-      const standingPrompt = buildStandingPrompt({ agentId: binding.id, inbound });
-      const protocolOverlayKey = getGoalTaskProtocolOverlayKey({ agentId: binding.id, inbound });
-      const standingPromptSeenKey = targetSessionId
-        ? `${binding.id}|${targetSessionId}|${protocolOverlayKey}`
-        : null;
-      const forceStandingPrompt = Boolean(standingPromptSeenKey && !standingPromptSeen.has(standingPromptSeenKey));
+      const runtimeBaseInstructions = buildRuntimeBaseInstructions({ agentId: binding.id });
       const result = shouldStreamRuntime(this.name, this)
-        ? await this.runTurnStream({ sessionId: targetSessionId, cwd: agentHome, piPath: runtimePiPath, agentEnv }, message, {
-            standingPrompt,
-            forceStandingPrompt,
+        ? await this.runTurnStream({ sessionId: shouldRotate ? null : meta.sessionId, cwd: agentHome, piPath: runtimePiPath, agentEnv }, message, {
+            runtimeBaseInstructions,
             images,
             onEvent: async (event) => {
               if (event?.type === 'turn.started') {
-                emitWorkerEventBestEffort({
+                await emitWorkerEvent({
                   adapter,
                   binding,
                   agent: this.name,
-                  sessionId: event.sessionId || targetSessionId || binding.id,
+                  sessionId: event.sessionId || meta.sessionId || binding.id,
                   cwd: agentHome,
                   replyToMessageId: inbound.messageId || null,
                   event: {
@@ -175,29 +176,31 @@ export const piRuntime = {
                   },
                   logger: ctx.logger,
                 });
+              } else if (event?.type === 'message.delta' && event.text) {
+                deltaAggregator.push(event.text, {
+                  sessionId: event.sessionId || meta.sessionId || binding.id,
+                  cwd: agentHome,
+                });
               }
             },
           })
-        : await this.runTurn({ sessionId: targetSessionId, cwd: agentHome, piPath: runtimePiPath, agentEnv }, message, { images, standingPrompt, forceStandingPrompt });
+        : await this.runTurn({ sessionId: shouldRotate ? null : meta.sessionId, cwd: agentHome, piPath: runtimePiPath, agentEnv }, message, { images, runtimeBaseInstructions });
 
-      const observedSessionId = result?.sessionId || targetSessionId;
-      if (observedSessionId) {
-        standingPromptSeen.add(`${binding.id}|${observedSessionId}|${protocolOverlayKey}`);
-      }
+      await deltaAggregator.flush();
       const nextBinding = await updateBindingRuntimeMeta(ctx, binding, {
-        ...buildRuntimeSessionMetaPatch(meta, sessionScope, {
-          sessionId: result?.sessionId,
-          path: result?.path,
-        }),
+        sessionId: result?.sessionId || meta.sessionId,
+        path: result?.path || meta.path || null,
         runtimePath: runtimePiPath,
         piPath: runtimePiPath,
         piVersion: runtimePiVersion,
+        rotatePending: false,
+        lastRotatedAt: shouldRotate ? new Date().toISOString() : meta.lastRotatedAt,
       }, { status: 'connected' });
-      emitWorkerEventBestEffort({
+      await emitWorkerEvent({
         adapter,
         binding: nextBinding,
         agent: this.name,
-        sessionId: result?.sessionId || targetSessionId || binding.id,
+        sessionId: result?.sessionId || meta.sessionId || binding.id,
         cwd: result?.cwd || agentHome,
         replyToMessageId: inbound.messageId || null,
         event: {
@@ -208,11 +211,12 @@ export const piRuntime = {
       });
       return true;
     } catch (err) {
-      emitWorkerEventBestEffort({
+      await deltaAggregator.flush().catch(() => {});
+      await emitWorkerEvent({
         adapter,
         binding,
         agent: this.name,
-        sessionId: targetSessionId || binding.id,
+        sessionId: meta.sessionId || binding.id,
         cwd: agentHome,
         replyToMessageId: inbound.messageId || null,
         event: {
@@ -238,6 +242,24 @@ export const piRuntime = {
     }
   },
 
+  async reconcileAfterRestart(binding, ctx) {
+    const meta = binding.runtimeMeta || {};
+    await emitWorkerEvent({
+      adapter: ctx.adapter,
+      binding,
+      agent: this.name,
+      sessionId: meta.sessionId || binding.id,
+      cwd: ensureAgentHome(binding.id) || '',
+      event: {
+        hook_event_name: 'Stop',
+        worker_event_name: 'worker.turn.complete',
+        reason: 'connector.restart.reconcile',
+      },
+      logger: ctx.logger,
+    });
+    return 1;
+  },
+
   sessionsDir: PI_SESSIONS_DIR,
   maxAgeMs: PI_MAX_AGE_MS,
 };

package/src/runtimes/pi/session.mjs

@@ -196,16 +196,13 @@ export function runPiPrompt({
   images = [],
   piPath = null,
   agentEnv = null,
-  standingPrompt = null,
-  forceStandingPrompt = false,
+  runtimeBaseInstructions = null,
   timeoutMs = Number(process.env.PI_RUN_TIMEOUT_MS || DEFAULT_PI_RUN_TIMEOUT_MS),
   onEvent,
 }) {
-  // pi has no documented system-prompt flag. Prepend on first turn, and
-  // let callers force one resumed-session injection for a newly selected
-  // protocol overlay.
-  const finalMessage = standingPrompt && (!sessionId || forceStandingPrompt)
-    ? `${standingPrompt}\n\n---\n\n${message}`
+  // pi has no documented system-prompt flag — prepend on first turn.
+  const finalMessage = runtimeBaseInstructions && !sessionId
+    ? `${runtimeBaseInstructions}\n\n---\n\n${message}`
     : message;
   return new Promise((resolve, reject) => {
     const startedAt = Date.now();
@@ -223,13 +220,12 @@ export function runPiPrompt({
     let activeSessionFile = null;
     let finalText = '';
     let settled = false;
+    let eventChain = Promise.resolve();
     const pending = new Map();
 
     const emit = (event) => {
       if (typeof onEvent !== 'function') return;
-      void Promise.resolve()
-        .then(() => onEvent(event))
-        .catch(() => {});
+      eventChain = eventChain.then(() => onEvent(event)).catch(() => {});
     };
 
     const settle = (fn, value) => {
@@ -241,7 +237,7 @@ export function runPiPrompt({
       }
       pending.clear();
       try { child.kill('SIGTERM'); } catch {}
-      fn(value);
+      eventChain.catch(() => {}).finally(() => fn(value));
     };
 
     const sendRaw = (payload) => {
@@ -309,6 +305,7 @@ export function runPiPrompt({
           const delta = extractDeltaFromEvent(event);
           if (delta) {
             finalText += delta;
+            emit({ type: 'message.delta', sessionId: activeSessionId, text: delta });
           }
           return;
         }

package/ticlawk.mjs

@@ -211,6 +211,35 @@ async function recoverAllRuntimes(runtimeList, adapter) {
   }
 }
 
+async function reconcileBindingsAfterRestart(runtimes, adapter) {
+  const hostId = getHostId();
+  for (const binding of listBindings({ adapter: adapter.id })) {
+    if (!belongsToRuntimeHost(binding, hostId)) {
+      logger.debugError('core', 'binding.reconcile-host-mismatch', {
+        bindingId: binding.id,
+        adapter: binding.adapter,
+        hostId,
+        runtime_host_id: getBindingRuntimeHostId(binding),
+      });
+      continue;
+    }
+    const runtime = binding.runtime ? runtimes[binding.runtime] : null;
+    if (typeof runtime?.reconcileAfterRestart !== 'function') continue;
+    try {
+      await runtime.reconcileAfterRestart(binding, {
+        adapter,
+        logger,
+      });
+    } catch (err) {
+      logger.debugError('startup', 'reconcileAfterRestart.failed', {
+        runtime: binding.runtime,
+        bindingId: binding.id,
+        error: err?.message || String(err),
+      });
+    }
+  }
+}
+
 export async function startTiclawk() {
   if (started) return;
   started = true;
@@ -249,6 +278,7 @@ export async function startTiclawk() {
   });
   startReminderTicker();
   await recoverAllRuntimes(runtimeList, adapter);
+  await reconcileBindingsAfterRestart(runtimes, adapter);
   await adapter.start();
 }
 

package/src/runtimes/_shared/agent-handbook.mjs

@@ -1,38 +0,0 @@
-/**
- * Legacy handbook cleanup.
- *
- * As of the lane-separation refactor, all handbook content is inlined into
- * the standing prompt (see standing-prompt.mjs). The daemon no longer
- * syncs handbook .md files into per-agent workspaces. This module now
- * exists only to enumerate the historical filenames so `agent-home.mjs`
- * can remove them from workspaces that still have them.
- */
-
-export const LEGACY_HANDBOOK_FILE_NAMES = Object.freeze([
-  // Previously active set (inlined into standing-prompt.mjs).
-  'BASICS.md',
-  'COMMUNICATION.md',
-  'COLLABORATION.md',
-  'GOAL_TASK_CORE.md',
-  'GOAL_AUTHORITY.md',
-  'TASK_WORKER.md',
-  'SURFACES.md',
-  // Older names from prior reorganizations.
-  'TICLAWK.md',
-  'TICLAWK_CLI.md',
-  'TICLAWK_COLLABORATION.md',
-  'TICLAWK_GOAL_TASK_PROTOCOL.md',
-  'TICLAWK_GOAL_TASK_CORE.md',
-  'TICLAWK_GOAL_AUTHORITY.md',
-  'TICLAWK_TASK_WORKER.md',
-  'TICLAWK_DM_SCOPE.md',
-  'TICLAWK_GROUP_ADMIN_SCOPE.md',
-  'TICLAWK_GROUP_MEMBER_SCOPE.md',
-  'TICLAWK_SURFACES.md',
-  'TICLAWK_WORKSPACE.md',
-  'WORKSPACE.md',
-  'GOAL_TASK_PROTOCOL.md',
-  'DM_SCOPE.md',
-  'GROUP_ADMIN_SCOPE.md',
-  'GROUP_MEMBER_SCOPE.md',
-]);

package/src/runtimes/_shared/brand.mjs

@@ -1,2 +0,0 @@
-export const BRAND_NAME = 'Ticlawk';
-export const CLI_NAME = 'ticlawk';

package/src/runtimes/_shared/goal-step-prompt.mjs

@@ -1,133 +0,0 @@
-/**
- * Per-step goal-lane (FSM) prompt builder.
- *
- * A transition delivery is an FSM event, not a chat message: it has no
- * backing message, only a payload carrying { transition_id, kind,
- * goal_version, step }. The goal lane runs exactly the step named in the
- * payload, then reports the outcome with `ticlawk goal report`, which
- * advances the state machine and (for running states) schedules the next
- * step as a fresh transition. This is the goal-lane analogue of
- * buildInboundWakePrompt — same {header, target, text, rawText} contract.
- */
-
-import { buildEnvelopeTarget, buildCharterBlock } from './wake-prompt.mjs';
-
-const STEP_GUIDES = {
-  gap_analysis: {
-    title: 'GAP ANALYSIS',
-    body: `Compare the current state against the goal and success criteria. The [goal_context] block above gives you the open tasks, active reminders, and dashboard state — judge from it; read the charter/repo/prior messages only for what it doesn't cover. The dashboard is the owner's at-a-glance visualization of how far this goal has progressed — this step owns keeping it true to reality: create it if a durable goal has none, refresh it when progress moved materially (\`ticlawk dashboard set\`).
-- Judge "due now" against the current owner-local time above. Produce only what is due now; do NOT pre-produce a future occurrence — each one is produced when its own reminder fires and wakes you at that time.
-- If there is concrete work to do NOW, make sure the next unit exists as a task (\`ticlawk task ...\`), then report outcome=gap.
-- If nothing needs doing this instant but the goal is ONGOING/STANDING — its job is to keep something maintained and work recurs (e.g. an active recurring reminder above already covers the next occurrence) — report outcome=wait. Do NOT report no_gap for a standing goal: it has no "done", and parking on no_gap would stop it from waking at the next occurrence. If nothing is scheduled to resume it yet, schedule a reminder first, then report wait.
-- Report outcome=no_gap ONLY if the goal is genuinely, permanently met and will never need action again (an achievement goal that is finished). When it is, the owner is waiting on this result and has not been told yet: before you report, publish ONE briefing handing it to them (\`ticlawk briefing publish --mode info\`) — a just-finished goal is exactly the "would be wrong not to know" case. (Chat never delivered this; you are the only one who can.)
-- Judge done-ness by the goal's real deliverable — the work itself and the dashboard — NOT by whether the task board is tidy. A task still showing open, or one you could not close, is not by itself remaining work: if the deliverable is met, report no_gap. Never keep the loop alive, or spend this turn, just to reconcile the board.`,
-    outcomes: ['gap', 'no_gap', 'wait'],
-  },
-  execute: {
-    title: 'EXECUTE',
-    body: `Do the next concrete unit of work toward the goal (or drive the current task to completion). Keep progress on the dashboard (\`ticlawk dashboard set\`); the goal lane reaches the owner only through the dashboard and briefings — never \`message send\`.
-- When the unit of work is finished and ready to be checked, report outcome=task_completed.
-- If you cannot proceed without something only the owner can grant — a decision, a permission, or approval to spend money or use a resource — ask for it with ONE approval briefing: \`ticlawk briefing publish --mode approval\` (short: what you need and why). That single call both asks the owner and suspends the loop on the approval. Then report outcome=needs_approval. Their answer (tapping approve, or a natural-language reply) resumes you automatically.
-- If you are blocked by something an owner decision cannot fix — an external failure, or a missing input no decision of theirs unblocks — surface it with \`ticlawk briefing publish --mode info\` only if they would be wrong not to know, then report outcome=blocked.`,
-    outcomes: ['task_completed', 'needs_approval', 'blocked'],
-  },
-  review: {
-    title: 'REVIEW',
-    body: `Review the work that was just completed against the task and the goal.
-- If it meets the bar, report outcome=accepted. Mark the task done if the board supports it (\`ticlawk task update ... --status done\`), but a close that fails or does not apply must NOT stop you from reporting accepted — the board is a coordination aid, not a gate.
-- If it needs rework, return it with a clean, specific redo instruction, then report outcome=rejected.`,
-    outcomes: ['accepted', 'rejected'],
-  },
-};
-
-function readPayload(msg) {
-  const payload = msg?.payload && typeof msg.payload === 'object' ? msg.payload : {};
-  return {
-    transitionId: String(payload.transition_id || '').trim(),
-    goalVersion: payload.goal_version != null ? String(payload.goal_version) : '',
-    kind: String(payload.kind || '').trim(),
-    step: String(payload.step || '').trim(),
-  };
-}
-
-// Per-step context: the claim attaches msg.goal_context (open tasks, active
-// reminders, current task, dashboard) for transition deliveries. Render the
-// slice THIS step needs so each step decides on facts, not guesses.
-function buildGoalContextBlock(msg, step) {
-  const gc = msg && msg.goal_context && typeof msg.goal_context === 'object' ? msg.goal_context : null;
-  if (!gc) return '';
-  const lines = ['[goal_context] Current state for this goal (given to you — use it, do not re-derive):'];
-  if (gc.now_local) {
-    lines.push(`- current time (owner local): ${gc.now_local}${gc.timezone ? ` [${gc.timezone}]` : ''}`);
-  }
-  if (step === 'gap_analysis' || !STEP_GUIDES[step]) {
-    const tasks = Array.isArray(gc.open_tasks) ? gc.open_tasks : [];
-    const rems = Array.isArray(gc.active_reminders) ? gc.active_reminders : [];
-    lines.push(`- open tasks (${tasks.length}): ${tasks.length
-      ? tasks.map((t) => `#${t.number} ${t.title} [${t.status}]`).join('; ')
-      : 'none'}`);
-    lines.push(`- active reminders (${rems.length}): ${rems.length
-      ? rems.map((r) => `"${r.title}" @ ${r.fire_at}${r.recurrence ? ' (recurring)' : ''}`).join('; ')
-      : 'none'}`);
-    lines.push(`- dashboard: ${gc.dashboard ? 'exists' : 'none yet'}`);
-  } else {
-    const ct = gc.current_task;
-    lines.push(ct ? `- current task: #${ct.number} ${ct.title} [${ct.status}]` : '- current task: (none set)');
-  }
-  lines.push('[/goal_context]');
-  return lines.join('\n');
-}
-
-function buildGoalStepHeader(msg, { step, transitionId, goalVersion, kind }) {
-  const target = buildEnvelopeTarget(msg);
-  const time = msg.created_at || new Date().toISOString();
-  return `[goal_lane target=${target} step=${step || 'unknown'} transition=${transitionId} goal_version=${goalVersion} kind=${kind} time=${time}]`;
-}
-
-export function buildGoalStepPrompt(msg) {
-  const { transitionId, goalVersion, kind, step } = readPayload(msg);
-  const target = buildEnvelopeTarget(msg);
-  const conversationId = msg.conversation_id || '';
-  const header = buildGoalStepHeader(msg, { step, transitionId, goalVersion, kind });
-  const charterBlock = buildCharterBlock(msg);
-  const guide = STEP_GUIDES[step] || null;
-
-  const reportCmd = `ticlawk goal report --conversation ${conversationId} --transition ${transitionId} --outcome <${guide ? guide.outcomes.join('|') : 'outcome'}>`;
-
-  const sections = [];
-  if (charterBlock) sections.push(charterBlock);
-  const goalContextBlock = buildGoalContextBlock(msg, step);
-  if (goalContextBlock) sections.push(goalContextBlock);
-
-  if (guide) {
-    sections.push([
-      `[goal_step] You are running one step of the goal loop for this conversation — a backend FSM step. Act on it and report the outcome; there is no message to reply to.`,
-      ``,
-      `Current step: ${guide.title}`,
-      guide.body,
-      ``,
-      `Briefings are scarce pushes that interrupt the owner; routine progress belongs on the dashboard (the owner pulls it). Send one (\`ticlawk briefing publish\`) only when the owner must act or decide (\`--mode approval\`), asked to be told, or would be wrong not to know now — goal done, blocked, off-track, or a result they are waiting on (\`--mode info\`). If unsure, it is not a briefing.`,
-      ``,
-      `When the step is done, advance the state machine by running EXACTLY ONE report:`,
-      `  ${reportCmd}`,
-      ``,
-      `Reporting the outcome continues the loop: a running next state comes back as a fresh step; with no gap or a wait, the loop parks itself. Report exactly once — do not loop inside this turn.`,
-      `Reach the owner only through two surfaces: \`ticlawk dashboard set\` (the goal report — routine progress, the owner pulls it) and \`ticlawk briefing publish\` (a scarce push, per the rule above). The goal lane never uses \`ticlawk message send\` — chat is the chat lane's. Write owner-facing text for someone reading cold who has never seen your plan or task board: what changed, why it matters, and what (if anything) they must do — naming things by what they are, never exposing how the system works inside or how your work is organized behind the scenes (tracks, loops, internal states, codes, run names, task numbers).`,
-      `[/goal_step]`,
-    ].join('\n'));
-  } else {
-    sections.push([
-      `[goal_step] Goal-loop FSM step with an unrecognized step "${step}". Re-evaluate the goal as a gap analysis: decide whether there is a gap, and report with:`,
-      `  ${reportCmd}`,
-      `[/goal_step]`,
-    ].join('\n'));
-  }
-
-  const text = sections.filter(Boolean).join('\n\n');
-  return {
-    header,
-    target,
-    text,
-    rawText: '',
-  };
-}

package/src/runtimes/_shared/goal-task-protocol.mjs

@@ -1,50 +0,0 @@
-/**
- * Runtime goal/task branch selection.
- *
- * Prompt text lives in the managed handbook files. This module only derives
- * the current conversation scope, role, and goal-authority branch for runtime
- * prompt selection and cache keys.
- */
-
-function getInboundRaw(ctx = {}) {
-  return ctx?.inbound?.raw && typeof ctx.inbound.raw === 'object'
-    ? ctx.inbound.raw
-    : {};
-}
-
-function inferScope(ctx = {}) {
-  const raw = getInboundRaw(ctx);
-  const conversationType = String(raw.conversation_type || '').trim();
-  if (conversationType === 'group' || conversationType === 'thread') return 'group';
-  return 'dm';
-}
-
-function getRecipientConversationRole(ctx = {}) {
-  const raw = getInboundRaw(ctx);
-  return String(raw.recipient_conversation_role || raw.recipient_role || '').trim().toLowerCase() || 'member';
-}
-
-function hasConversationAdminRole(ctx = {}) {
-  const raw = getInboundRaw(ctx);
-  if (raw.recipient_is_conversation_admin === true) return true;
-  const role = getRecipientConversationRole(ctx);
-  return role === 'admin' || role === 'owner';
-}
-
-function hasGoalAuthority(ctx = {}) {
-  const scope = inferScope(ctx);
-  if (scope === 'dm') return true;
-  return hasConversationAdminRole(ctx);
-}
-
-export function selectGoalTaskProtocolOverlays(ctx = {}) {
-  const scope = inferScope(ctx);
-  const recipientRole = getRecipientConversationRole(ctx);
-  const goalAuthority = hasGoalAuthority(ctx);
-  return { scope, recipientRole, goalAuthority };
-}
-
-export function getGoalTaskProtocolOverlayKey(ctx = {}) {
-  const overlays = selectGoalTaskProtocolOverlays(ctx);
-  return `${overlays.scope}:${overlays.recipientRole}:${overlays.goalAuthority ? 'goal' : 'task'}`;
-}