ticlawk 0.1.17-dev.17 → 0.1.17-dev.19

package/src/runtimes/_shared/standing-prompt.mjs

@@ -1,331 +0,0 @@
-/**
- * Standing prompt injected into every runtime turn.
- *
- * Three audiences, each fully separated:
- *   - goal lane:          one backend FSM step (transition delivery)
- *   - chat-authority:     DM agent, or group admin/owner
- *   - chat-worker:        group member, no goal authority
- *
- * Chat-authority is further branched on whether a charter exists in the
- * conversation — the no-charter and with-charter prompts have different
- * chat-lane overview bullets and different goal-control subsections
- * because the agent's job is materially different in each.
- *
- * Every audience prompt is built as:
- *   1) Overview (audience + lane breakdown)
- *   2) ## Workspace (private cwd + MEMORY.md format)
- *   3) ## Tools that you can use
- *      ### subsection per tool family (short workflow intro + command bullets)
- *   4) ## Conduct (groups only — DM is trivial; goal lane has no conduct)
- *
- * The per-turn user-message wrapper still comes from wake-prompt.mjs
- * (chat lane) or goal-step-prompt.mjs (goal lane).
- */
-
-import { selectGoalTaskProtocolOverlays } from './goal-task-protocol.mjs';
-
-function promptBlock(text) {
-  return text.trim();
-}
-
-function getInboundRaw(ctx = {}) {
-  return ctx?.inbound?.raw && typeof ctx.inbound.raw === 'object'
-    ? ctx.inbound.raw
-    : {};
-}
-
-function readDeliveryReason(ctx = {}) {
-  const raw = getInboundRaw(ctx);
-  return String(raw.reason || '').trim() || 'unknown';
-}
-
-function isGoalLane(ctx = {}) {
-  return ctx?.inbound?.lane === 'goal' || readDeliveryReason(ctx) === 'transition';
-}
-
-function readString(value) {
-  return typeof value === 'string' ? value.trim() : '';
-}
-
-function readCharter(ctx = {}) {
-  return readString(getInboundRaw(ctx).conversation_charter);
-}
-
-function readConversationName(ctx = {}) {
-  const raw = getInboundRaw(ctx);
-  return readString(raw.conversation_name || raw.conversation_display_name || raw.conversation_id);
-}
-
-// ---------------------------------------------------------------------------
-// Shared: Workspace (varies on the "don't record" tail by audience)
-// ---------------------------------------------------------------------------
-
-function workspaceBlock(audience) {
-  const dontRecordTail = audience === 'worker'
-    ? `that is the admin's job and its source of truth is in ticlawk.`
-    : audience === 'goal'
-      ? `its single source of truth is the charter, dashboard, and task board, accessed through ticlawk.`
-      : `its single source of truth is maintained by ticlawk tools (\`ticlawk charter set\`, \`ticlawk approval resolve\`, etc.).`;
-  return `## Workspace
-
-Your cwd is your private workspace. Unless told otherwise, you keep \`MEMORY.md\` and all artifacts you generate in this directory. If told to work in another directory, record that in \`MEMORY.md\` and cd into it for your work.
-
-\`MEMORY.md\` keeps key context and learnings of all conversations you are in, organized like:
-
-\`\`\`
-#<conv id>
-<your memory>
-
-#<conv id>
-<your memory>
-\`\`\`
-
-Do not record any goal-lane setup or status data in memory — ${dontRecordTail} Never record secrets.`;
-}
-
-// ---------------------------------------------------------------------------
-// Shared: Reminders (identical text for all audiences; reminder routing is
-// handled automatically by the backend per fire_due_reminders — see
-// 20260529170000_reminder_wakes_goal_lane.sql)
-// ---------------------------------------------------------------------------
-
-function remindersSubsection() {
-  return `### Reminders
-
-Schedule a reminder for time-based follow-up. For a fixed cadence, use ONE recurring reminder rather than many one-shots.
-
-- \`ticlawk reminder schedule --title <t> (--fire-at <iso>|--in-seconds N|--in-minutes N) (--target <target>|--anchor-conversation-id <id>) [--recur-at HH:MM] [--recur-weekday 1,2,3]\` — schedule a reminder. \`--recur-at\` is the owner's local wall-clock; the system fills the timezone. On each fire, a recurring reminder auto-advances.`;
-}
-
-// The lane breakdown above is how YOU operate — your own model. It is never
-// something to explain to a person. When someone asks what you do or what your
-// role is, answer by what you help them accomplish, not by how the system is
-// built.
-const INTERNAL_MODEL_NOTE = `This split is your own operating model — never something to explain to a person. When the owner asks what you do or what your role is, answer by what you help them accomplish, not by how the system is built.`;
-
-// ---------------------------------------------------------------------------
-// Chat-authority (DM or group admin/owner)
-// ---------------------------------------------------------------------------
-
-function chatAuthorityOverviewBlock(ctx) {
-  const { scope, recipientRole } = selectGoalTaskProtocolOverlays(ctx);
-  const name = readConversationName(ctx);
-  const hasCharter = !!readCharter(ctx);
-
-  let whereLine;
-  if (scope === 'group') {
-    const groupLabel = name ? `#${name}` : 'a group chat';
-    const role = recipientRole === 'owner' ? 'owner' : 'admin';
-    whereLine = `You are in a group chat named ${groupLabel} as the ${role}.`;
-  } else {
-    whereLine = `You are in a one-on-one conversation with a human.`;
-  }
-
-  const goalLaneBullet = `- Goal lane — once the charter of the conversation is set, the goal lane captures a "goal update" event and kicks off its state machine that pursues the goal on its own (gap analysis → execute → review), looping until the stop condition is met. When necessary, it surfaces its need or status through dashboards and briefings.`;
-
-  const chatLaneBullet = hasCharter
-    ? `- Chat lane — where you are right now, the interface between external messages and the goal lane. A charter exists and the goal lane is pursuing it. The per-turn context below shows the current charter and the lane's current state. If the incoming message is a plain request not tied to the goal, you just do the work needed and reply. If it shows intention of changing the goal, you discuss with the owner and rewrite the charter to re-aim the lane. If it's about the existing goal — for status questions, point the owner at the dashboard in the app; for approvals the owner is answering, use \`ticlawk approval list\` to match the reply to a pending request. You send messages to external recipients with \`ticlawk message send\`, and you affect the goal lane through exactly two writes: \`ticlawk charter set\` (change the goal) and \`ticlawk approval resolve\` (resume the lane after the owner answers an approval).`
-    : `- Chat lane — where you are right now, the interface between external messages and the goal lane. If the incoming message is a plain request not related to setting up a durable goal, you just do the work needed and reply. If the incoming message shows intention of setting up a durable goal, you propose a charter, discuss with the owner, and set the charter to start the goal lane. You send messages to external recipients with \`ticlawk message send\`, and you start the goal lane by calling \`ticlawk charter set\`.`;
-
-  return `${whereLine} The conversation is part of an agent system that drives itself to achieve a goal. It has two components:
-
-${goalLaneBullet}
-${chatLaneBullet}
-
-${INTERNAL_MODEL_NOTE}`;
-}
-
-function chatAuthorityMessagingSubsection(ctx) {
-  const { scope } = selectGoalTaskProtocolOverlays(ctx);
-  const extraBullets = scope === 'group'
-    ? `\n- \`ticlawk group members --target <target>\` — who is in this group.
-- \`ticlawk agent list\` — other agents the owner has, useful for routing decisions.`
-    : '';
-  return `### Messaging
-
-You reply to incoming messages with \`ticlawk message send\`. Pass body via stdin or heredoc so quotes and code blocks survive. The body is plain natural language. Never expose how the system works inside or how your work is organized behind the scenes (tracks, loops, internal states, codes, run names, task numbers) — none of it means anything to them.
-
-- \`ticlawk message send --target <target> --phase progress|final [--attach <path>]\` — send a reply. Copy \`<target>\` from the incoming message verbatim. Body via stdin. Use \`--phase progress\` for any intermediate update and \`--phase final\` for the last message of the turn; after the final send succeeds, output exactly \`<turn_end>\` and stop.
-- \`ticlawk message read --target <target> [--around <message-id>]\` — recent chat context, or context around one specific message.
-- \`ticlawk attachment view <asset-id>\` — fetch metadata and a signed URL for an asset the owner attached.${extraBullets}`;
-}
-
-function chatAuthorityGoalControlSubsection(ctx) {
-  const hasCharter = !!readCharter(ctx);
-  if (!hasCharter) {
-    return `### Goal control
-
-When the incoming message intends to set up a durable goal, clarify these elements with the owner: the goal itself, completion criteria, scope and boundaries, what to surface on the dashboard, the rough approach, roles and responsibilities (in a group), required resources, and deliverables. Together these are the charter. Propose it, get confirmation, then set it — that automatically starts the goal lane.
-
-- \`ticlawk charter set --conversation <id>\` — write or replace the charter (body on stdin). The only way to start or re-aim the goal lane.
-- \`ticlawk charter get --conversation <id>\` — read the current charter.`;
-  }
-  return `### Goal control
-
-A charter exists and the goal lane is pursuing it. The per-turn context below shows the current charter and the lane's current state. For each incoming message, classify and act:
-
-- Approving / rejecting ("go ahead", "approved", "no, hold off") → the goal lane is parked on an approval. Resolve it; the lane resumes on its own. Don't redo the work yourself.
-- Setting / clarifying / changing the goal → rewrite the charter. Change only what actually changed; keep the rest verbatim. That re-aims the lane.
-- "Get going" / "run it" / "continue" → that's goal-lane work. Acknowledge, make sure the charter and any pending approval are right, and let the lane carry it out.
-- A genuine one-off aside not tied to the chartered goal → just answer it.
-
-- \`ticlawk charter set --conversation <id>\` — rewrite the charter to re-aim the lane. Body via stdin.
-- \`ticlawk charter get --conversation <id>\` — read the current charter.
-- \`ticlawk approval list [--conversation <id>]\` — see pending approvals in this conversation.
-- \`ticlawk approval resolve --request <id> (--grant|--reject) --original-text "<owner's words>" --source-message-id <id>\` — bind an owner reply to a specific approval. Resolve only when the reply unambiguously matches one pending request (it quotes one, or only one is pending); otherwise ask which one. Idempotent — safe even if the owner also taps approve.`;
-}
-
-function chatAuthorityGroupConductBlock() {
-  return `## Conduct
-
-When the owner asks something without naming an agent, you (the admin) answer or route it. Mentions, assignments, and reminders to you normally need action. Ambient messages are context, not a task — stay quiet unless you are clearly the right responder and can add concrete value.
-
-Write like a teammate: what changed, who does what next, what evidence matters, what is blocked. Don't narrate process. Don't echo someone else's report — whoever did the work reports on it.
-
-A delegation or handoff is a compact instruction: desired outcome, key constraints, expected evidence, where to report back. Pair it with a task record.`;
-}
-
-function buildChatAuthorityStandingPrompt(ctx) {
-  const { scope } = selectGoalTaskProtocolOverlays(ctx);
-  const sections = [
-    chatAuthorityOverviewBlock(ctx),
-    workspaceBlock('authority'),
-    `## Tools that you can use`,
-    chatAuthorityMessagingSubsection(ctx),
-    chatAuthorityGoalControlSubsection(ctx),
-    remindersSubsection(),
-  ];
-  if (scope === 'group') sections.push(chatAuthorityGroupConductBlock());
-  return sections.join('\n\n');
-}
-
-// ---------------------------------------------------------------------------
-// Chat-worker (group member, no goal authority)
-// ---------------------------------------------------------------------------
-
-function chatWorkerOverviewBlock(ctx) {
-  const name = readConversationName(ctx);
-  const groupLabel = name ? `#${name}` : 'a group chat';
-  return `You are in a group chat named ${groupLabel} as a member, not the admin. The group is part of an agent system that drives itself to achieve a goal. It has two components:
-
-- Goal lane — backend state machine that pursues the goal, owned by the group admin. It runs on its own; you don't drive it.
-- Chat lane — where you are right now. Your job is to take tasks the admin or owner assigns to you and execute them. You don't set goals or touch the admin-owned surfaces (charter, dashboard, briefings, membership). You send messages to external recipients with \`ticlawk message send\`, and you execute work through \`ticlawk task claim\` / \`ticlawk task update\`.
-
-${INTERNAL_MODEL_NOTE}`;
-}
-
-function chatWorkerMessagingSubsection() {
-  return `### Messaging
-
-You reply to incoming messages with \`ticlawk message send\`. Pass body via stdin or heredoc so quotes and code blocks survive. The body is plain natural language. Never expose how the system works inside or how your work is organized behind the scenes (tracks, loops, internal states, codes, run names, task numbers) — none of it means anything to them.
-
-- \`ticlawk message send --target <target> --phase progress|final [--attach <path>]\` — send a reply. Copy \`<target>\` from the incoming message verbatim. Body via stdin. Use \`--phase progress\` for any intermediate update and \`--phase final\` for the last message of the turn; after the final send succeeds, output exactly \`<turn_end>\` and stop.
-- \`ticlawk message read --target <target> [--around <message-id>]\` — recent chat context, or context around one specific message.
-- \`ticlawk attachment view <asset-id>\` — fetch metadata and a signed URL for an asset the owner attached.
-- \`ticlawk group members --target <target>\` — who else is in this group.`;
-}
-
-function chatWorkerTasksSubsection() {
-  return `### Tasks
-
-Your work in this group flows through tasks the admin or owner assigns to you. Lifecycle: \`todo\` → \`in_progress\` → \`in_review\` → \`done\` (or \`canceled\`). Claim before substantive work, update as you go, and move to \`in_review\` when finished — the admin closes it to \`done\`. If the task is mis-scoped, underspecified, or blocked on an owner decision, say so to the admin instead of taking over the goal.
-
-- \`ticlawk task list\` — see your tasks.
-- \`ticlawk task claim --number <n>\` — claim a claimable task before substantive work.
-- \`ticlawk task update --number <n> --status <in_progress|in_review>\` — advance the status. You do NOT set \`done\`.`;
-}
-
-function chatWorkerConductBlock() {
-  return `## Conduct
-
-Act on work assigned or clearly routed to you. Don't answer the owner's questions by default — let the admin route them. Ignore ambient messages unless your expertise is directly needed and no better responder exists.
-
-Report like a worker handing off evidence: what changed, where the evidence is, what is blocked if anything, and whether it is ready for review. Concise, tied to concrete task state. Don't echo someone else's report — whoever did the work reports on it.`;
-}
-
-function buildChatWorkerStandingPrompt(ctx) {
-  return [
-    chatWorkerOverviewBlock(ctx),
-    workspaceBlock('worker'),
-    `## Tools that you can use`,
-    chatWorkerMessagingSubsection(),
-    chatWorkerTasksSubsection(),
-    remindersSubsection(),
-    chatWorkerConductBlock(),
-  ].join('\n\n');
-}
-
-// ---------------------------------------------------------------------------
-// Goal lane (transition delivery)
-// ---------------------------------------------------------------------------
-
-function goalLaneOverviewBlock() {
-  return `You are executing one backend goal-loop step for this conversation, dispatched by the system — not a message from a person. The conversation is part of an agent system that drives itself to achieve a goal. It has two components:
-
-- Chat lane — a separate agent surface that handles the owner's conversation and owns the goal charter (your target). You do not run chat.
-- Goal lane — that's you. The state machine cycles gap analysis → execute → review until there is no gap, then parks until something changes.
-
-Do only what this step requires; leave work for other steps to those steps. The exact step instruction and the single \`ticlawk goal report\` command for this turn are in the per-turn prompt below — act on those.`;
-}
-
-function goalLaneOwnerSurfacesSubsection() {
-  return `### Owner surfaces (dashboard + briefing)
-
-You reach the owner only through dashboard (pull) and briefing (push). You do NOT use \`ticlawk message send\` — chat is the chat lane's. Write what changed and why it matters in plain language; refer to things by what they are and do, 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).
-
-Dashboard is the owner's at-a-glance progress report. Design it during goal setup (or when first needed), keep the design stable, update content as progress moves; redesign only when the goal, metrics, or main focus changes materially. Briefings are scarce pushes that interrupt the owner: send only when the owner must act or decide (\`--mode approval\`), asked to be told (\`--mode info\`), or would be wrong not to know now — goal done, blocked, materially off-track, or a result they are waiting on (\`--mode info\`).
-
-- \`ticlawk dashboard set (--target <t>|--conversation-id <id>)\` — publish or update the dashboard. Body (stdin) is JSON: \`{"html_template": "...", "data_json": ...}\`. Either field may be omitted to leave unchanged.
-- \`ticlawk briefing publish --text "..." --mode info|approval [--attach <path>]\` — push a briefing to the owner. \`--mode approval\` both asks the owner and suspends the loop until they answer; a tap or chat reply, resolved by the chat lane, resumes you.`;
-}
-
-function goalLaneTasksSubsection() {
-  return `### Tasks
-
-Tasks are the executable units toward the goal. The execute step usually creates the next task and drives it to completion; the review step accepts or returns it. Use one task per concrete unit of work — small enough that "done" is unambiguous.
-
-- \`ticlawk task list\` — see open tasks.
-- \`ticlawk task create --target <target>\` — create a new task. Body via stdin.
-- \`ticlawk task update --task-id <id> --status <todo|in_progress|in_review|done|canceled>\` — advance task state.`;
-}
-
-function goalLaneServicesSubsection() {
-  return `### Services and credentials
-
-Use a shared service when one matches the task (browser lanes, account sessions, API keys, build queues, connectors). Request a credential when work is blocked on a secret. Never put secrets in memory, notes, dashboards, briefings, or chat.
-
-- \`ticlawk service list\` — see active shared services.
-- \`ticlawk service info --name <name>\` — see a service's contract and description.
-- \`ticlawk service call --name <name>\` — invoke it. Input via stdin (JSON). No retry-loop on failure.
-- \`ticlawk credential request --name <ENV_VAR>\` — request a secret. Returns a deep link the owner fills; the daemon injects the value as an env var on next spawn.`;
-}
-
-function goalLaneHtmlArtifactsSubsection() {
-  return `### HTML artifacts
-
-For a polished dashboard or briefing visual, generate the HTML with \`/vibeshare generate\` (install from https://vibeshare.page/skill if missing). Publish via \`ticlawk dashboard set\` or \`ticlawk briefing publish\` — not \`/vibeshare publish\`.`;
-}
-
-function buildGoalLaneStandingPrompt() {
-  return [
-    goalLaneOverviewBlock(),
-    workspaceBlock('goal'),
-    `## Tools that you can use`,
-    goalLaneOwnerSurfacesSubsection(),
-    goalLaneTasksSubsection(),
-    remindersSubsection(),
-    goalLaneServicesSubsection(),
-    goalLaneHtmlArtifactsSubsection(),
-  ].join('\n\n');
-}
-
-// ---------------------------------------------------------------------------
-// Entry point
-// ---------------------------------------------------------------------------
-
-export function buildStandingPrompt(ctx = {}) {
-  if (isGoalLane(ctx)) return promptBlock(buildGoalLaneStandingPrompt());
-  const { goalAuthority } = selectGoalTaskProtocolOverlays(ctx);
-  if (goalAuthority) return promptBlock(buildChatAuthorityStandingPrompt(ctx));
-  return promptBlock(buildChatWorkerStandingPrompt(ctx));
-}

package/src/runtimes/_shared/wake-prompt.mjs

@@ -1,296 +0,0 @@
-/**
- * Per-turn inbound wake prompt builder.
- *
- * Standing prompts define durable runtime behavior. This module owns the
- * dynamic wrapper around each delivered Ticlawk message: who sent it, why it
- * reached this agent, the exact reply target, and any attached goal/task/quote
- * context for this turn.
- */
-
-function promptBlock(text) {
-  return text.trim();
-}
-
-export function buildEnvelopeTarget(msg) {
-  const convType = msg.conversation_type || 'dm';
-  const conversationId = msg.conversation_id || '';
-  const senderHandle = msg.sender_display_name || msg.sender_user_id || msg.sender_agent_id || '';
-  if (convType === 'dm') {
-    return senderHandle ? `dm:@${senderHandle}` : `dm:${conversationId}`;
-  }
-  if (convType === 'thread') {
-    const groupName = msg.conversation_name || conversationId;
-    const replyRoot = msg.thread_root_message_id || msg.message_id || '';
-    return `#${groupName}:${replyRoot}`;
-  }
-  // group
-  const groupName = msg.conversation_name || conversationId;
-  return `#${groupName}`;
-}
-
-export function buildDebugTaskSuffix(msg) {
-  if (msg.task_number == null) return '';
-  const status = msg.task_status || 'todo';
-  const parts = [`task #${msg.task_number} status=${status}`];
-  if (msg.task_assignee_agent_id || msg.task_assignee_user_id) {
-    const t = msg.task_assignee_type || 'agent';
-    const id = msg.task_assignee_agent_id || msg.task_assignee_user_id;
-    parts.push(`assignee=${t}:${id}`);
-  }
-  if (msg.task_title) {
-    parts.push(`title=${JSON.stringify(msg.task_title)}`);
-  }
-  return ` [${parts.join(' ')}]`;
-}
-
-export function buildDebugReactionsSuffix(msg) {
-  const entries = Array.isArray(msg.reactions_summary) ? msg.reactions_summary : [];
-  if (entries.length === 0) return '';
-  return ` [reactions: ${entries.join('; ')}]`;
-}
-
-function normalizeDeliveryReasonForPrompt(reason) {
-  return reason === 'thread_follow' ? 'reply_follow' : reason;
-}
-
-export function buildDebugEnvelopeHeader(msg) {
-  const target = buildEnvelopeTarget(msg);
-  const msgId = msg.id || msg.message_id || '';
-  const seq = msg.seq != null ? msg.seq : '';
-  const time = msg.created_at || new Date().toISOString();
-  const type = msg.sender_type || 'human';
-  const sender = msg.sender_display_name || msg.sender_user_id || msg.sender_agent_id || 'unknown';
-  const convType = msg.conversation_type || 'dm';
-  const displayReason = normalizeDeliveryReasonForPrompt(msg.reason || '');
-  const reason = displayReason ? ` reason=${displayReason}` : '';
-  const recipientRole = String(msg.recipient_conversation_role || msg.recipient_role || '').trim().toLowerCase();
-  const role = convType === 'group' && recipientRole ? ` role=${recipientRole}` : '';
-  return `[target=${target} msg=${msgId} seq=${seq} time=${time} type=${type}${reason}${role}] @${sender}:`;
-}
-
-export const buildEnvelopeHeader = buildDebugEnvelopeHeader;
-
-export function buildGroupContextBlock(msg) {
-  // Only useful in groups — DMs don't need group-purpose context.
-  if ((msg.conversation_type || 'dm') !== 'group') return '';
-  const lines = [];
-  const name = msg.conversation_name || msg.conversation_display_name || '';
-  if (name) lines.push(`Group: #${name}`);
-  const description = (msg.conversation_description || '').trim();
-  if (description) lines.push(`Purpose: ${description}`);
-  if (lines.length === 0) return '';
-  return lines.join('\n');
-}
-
-export function buildCharterBlock(msg) {
-  const charter = (msg.conversation_charter || '').trim();
-  const conversationId = msg.conversation_id || '';
-
-  // No charter yet: the goal loop has never been bootstrapped. A transition
-  // cannot arrive before a goal exists, and only the goal-authority agent may
-  // start one — so give that agent (and only it) the bootstrap path. Without
-  // this, a conversation's FIRST goal can never reach the goal lane, because
-  // the steady-state guidance below is gated on a charter already existing.
-  // The detailed discovery playbook is inlined into the chat-authority
-  // standing prompt; here we just confirm the situation for this turn.
-  if (!charter) {
-    if (msg.reason === 'transition' || !hasGoalAuthority(msg)) return '';
-    return promptBlock(`
-[conversation_goal]
-This conversation has no goal charter yet.
-If this message sets a goal, write the charter with \`ticlawk charter set --conversation ${conversationId}\` (body on stdin). That starts the goal lane. Otherwise handle the message normally.
-[/conversation_goal]
-`);
-  }
-
-  // For the goal-authority chat lane, lead with what work on the goal is doing
-  // right now (from goal_lane_state, attached by the claim) — in plain terms,
-  // not internal state names — so the agent acts on fact: resolve a pending
-  // approval, don't redo work already running, and use charter set for a goal
-  // change. Transition deliveries (the goal loop's own steps) get the spec only.
-  const gl = msg.goal_lane_state && typeof msg.goal_lane_state === 'object' ? msg.goal_lane_state : null;
-  const stateLine = !gl
-    ? ''
-    : gl.pending_approval
-      ? `Work on this goal is paused, waiting for you to approve: "${gl.pending_approval.title}". A go-ahead from you here is that approval — resolve it; the work then resumes on its own, you don't redo it.`
-      : (gl.state && gl.state !== 'suspended')
-        ? `Work on this goal is already running on its own in the background — don't redo it in your reply.`
-        : `No work on this goal is running right now.`;
-  const authorityLine = msg.reason === 'transition'
-    ? 'This is the goal and success spec for this conversation. Run the current step against it.'
-    : hasGoalAuthority(msg)
-      ? `${stateLine ? stateLine + ' ' : ''}Handle this message and reply. If it changes the goal, edit the charter shown above and write it back in full with \`ticlawk charter set --conversation ${conversationId}\` (body on stdin) — change only what actually changed and keep the rest verbatim. That re-aims the work.`
-      : 'Use it as current group goal and role context. The group admin owns charter and dashboard changes unless they explicitly delegate them.';
-  return promptBlock(`
-[conversation_goal]
-Current charter for this conversation:
-${charter}
-
-${authorityLine}
-[/conversation_goal]
-`);
-}
-
-export function buildGoalStateBlock(msg) {
-  if ((msg.conversation_charter || '').trim()) return '';
-  // Goal-authority agents (DM + group admin/owner) already get the
-  // bootstrap context from buildCharterBlock's no-charter branch and the
-  // discovery playbook inlined into the chat-authority standing prompt.
-  // This block exists only for group members, who need a short reminder
-  // that goal setup is not their job.
-  if (hasGoalAuthority(msg)) return '';
-  const convType = msg.conversation_type || 'dm';
-  const subject = convType === 'group' ? 'This group' : 'This conversation';
-  return promptBlock(`
-[conversation_goal]
-${subject} does not have a chartered goal yet. The group admin owns goal setup; follow direct mentions or assigned tasks normally.
-[/conversation_goal]
-`);
-}
-
-function hasGoalAuthority(msg) {
-  const convType = msg.conversation_type || 'dm';
-  if (convType !== 'group') return true;
-  if (msg.recipient_is_conversation_admin === true) return true;
-  const recipientRole = String(msg.recipient_conversation_role || msg.recipient_role || '').trim().toLowerCase();
-  return recipientRole === 'admin' || recipientRole === 'owner';
-}
-
-export function buildQuoteBlock(msg, target = '') {
-  const meta = msg.message_metadata || msg.metadata || null;
-  const quote = meta && typeof meta === 'object' ? meta.quote : null;
-  if (!quote || typeof quote !== 'object') return '';
-  const kind = String(quote.kind || '').trim();
-  const ref = String(quote.ref || '').trim();
-  const snippet = String(quote.snippet || '').trim();
-  if (!kind || !ref) return '';
-  // Only `message` quotes get a fetch hint — chat lane can `message read`.
-  // Briefing/dashboard quotes carry the snippet only; chat lane does not
-  // have `briefing get` / `dashboard get` (those are goal-lane internals).
-  const fetchHint = kind === 'message'
-    ? `ticlawk message read --target ${JSON.stringify(target)} --around ${ref}`
-    : '';
-  const lines = [
-    `The incoming message is a reply to a ${kind}.`,
-    `Referenced ${kind}: \`${ref}\``,
-  ];
-  if (snippet) lines.push(`Quoted snippet: ${snippet}`);
-  if (fetchHint) lines.push(`Fetch it if needed: \`${fetchHint}\``);
-  return lines.join('\n');
-}
-
-function senderDescription(msg) {
-  const type = msg.sender_type === 'agent' ? 'an agent' : 'a human user';
-  const sender = msg.sender_display_name || msg.sender_user_id || msg.sender_agent_id || '';
-  return sender ? `@${sender}, ${type}` : type;
-}
-
-function senderFactDescription(msg) {
-  const type = msg.sender_type === 'agent' ? 'agent' : 'human user';
-  const sender = msg.sender_display_name || msg.sender_user_id || msg.sender_agent_id || '';
-  return sender ? `@${sender}, ${type}` : type;
-}
-
-function conversationLabel(msg, target) {
-  const convType = msg.conversation_type || 'dm';
-  if (convType === 'dm') return 'a one-on-one conversation';
-  return target || 'this group';
-}
-
-function buildMessageSummary(msg, target) {
-  const convType = msg.conversation_type || 'dm';
-  const reason = normalizeDeliveryReasonForPrompt(msg.reason || '');
-  const sender = senderDescription(msg);
-  const senderFact = senderFactDescription(msg);
-  const where = conversationLabel(msg, target);
-
-  if (convType === 'dm') {
-    return `This is a one-on-one message from ${sender}.`;
-  }
-  if (reason === 'assignment') {
-    return `This message assigns or routes work to you in ${where}.\nSender: ${senderFact}`;
-  }
-  if (reason === 'ambient') {
-    return `Sender: ${senderFact}`;
-  }
-  if (reason === 'mention') {
-    return `You were mentioned in ${where} by ${sender}.`;
-  }
-  if (reason === 'reply_follow') {
-    return `This is a reply in ${where} from ${sender}.`;
-  }
-  if (reason === 'manual') {
-    return `This is a manual wake-up or reminder for ${where}.\nSource: ${senderFact}`;
-  }
-  return `This is a message in ${where} from ${sender}.`;
-}
-
-function buildTaskDetailsBlock(msg) {
-  if (msg.task_number == null) return '';
-  const lines = [`Task #${msg.task_number} is currently \`${msg.task_status || 'todo'}\`.`];
-  if (msg.task_title) lines.push(`Task title: ${msg.task_title}`);
-  if (msg.task_assignee_agent_id || msg.task_assignee_user_id) {
-    const t = msg.task_assignee_type || 'agent';
-    const id = msg.task_assignee_agent_id || msg.task_assignee_user_id;
-    lines.push(`Assignee: ${t} \`${id}\``);
-  }
-  return lines.join('\n');
-}
-
-function buildReactionsBlock(msg) {
-  const entries = Array.isArray(msg.reactions_summary) ? msg.reactions_summary : [];
-  if (entries.length === 0) return '';
-  return `Recent reactions: ${entries.join('; ')}`;
-}
-
-function buildContentBlock(rawText) {
-  const text = String(rawText || '').trim();
-  if (!text) return '';
-  return promptBlock(`
-Content:
-${text}
-`);
-}
-
-// Wrap each per-turn message with the concrete dynamic context for this
-// delivery. Durable communication rules are inlined into the standing
-// prompt (see standing-prompt.mjs); this block only carries the current
-// message and its exact reply target.
-export function buildWakePromptText({ messageSummary, target, rawText, groupContext, charterBlock, goalStateBlock, quoteBlock, taskDetails, reactionsBlock }) {
-  const contextPrefix = [charterBlock, goalStateBlock, quoteBlock].filter(Boolean).join('\n\n');
-  const prefix = contextPrefix ? `${contextPrefix}\n\n` : '';
-  const detailBlocks = [
-    messageSummary,
-    `Reply target: \`${target}\``,
-    groupContext,
-    taskDetails ? `Task details:\n${taskDetails}` : '',
-    reactionsBlock,
-    buildContentBlock(rawText),
-  ].filter(Boolean).join('\n\n');
-  return promptBlock(`
-${prefix}New message received:
-
-${detailBlocks}
-`);
-}
-
-export function buildInboundWakePrompt(msg) {
-  const rawText = msg.text || '';
-  const baseHeader = buildDebugEnvelopeHeader(msg);
-  const header = baseHeader + buildDebugTaskSuffix(msg) + buildDebugReactionsSuffix(msg);
-  const target = buildEnvelopeTarget(msg);
-  const groupContext = buildGroupContextBlock(msg);
-  const charterBlock = buildCharterBlock(msg);
-  const goalStateBlock = buildGoalStateBlock(msg);
-  const quoteBlock = buildQuoteBlock(msg, target);
-  const messageSummary = buildMessageSummary(msg, target);
-  const taskDetails = buildTaskDetailsBlock(msg);
-  const reactionsBlock = buildReactionsBlock(msg);
-  const text = buildWakePromptText({ messageSummary, target, rawText, groupContext, charterBlock, goalStateBlock, quoteBlock, taskDetails, reactionsBlock });
-  return {
-    header,
-    target,
-    text,
-    rawText,
-  };
-}