ticlawk 0.1.17-dev.2 → 0.1.17-dev.20

package/src/runtimes/_shared/handbook/GOAL_AUTHORITY.md

@@ -1,47 +0,0 @@
-# Goal Authority
-
-DO NOT EDIT.
-
-Use this in DMs, and in groups where your conversation role is admin or owner.
-
-The goal execution loop (gap analysis, execution, review) runs in the backend
-goal lane for this conversation — not here, and not inside your reply. You do
-NOT run that loop yourself. Your job on this (chat) side is to handle the
-incoming message and to keep the conversation's goal/charter correct so the goal
-lane has the right target. When the goal is set or changes, you wake the goal
-lane with `ticlawk goal changed`.
-
-## Goal Authority Overlay
-
-- Handle the incoming message: reply to the user and do what it asks, then send the result. That is the end of your turn — do not start running gap analysis, creating execution tasks, or driving the goal yourself. The goal lane does that.
-- Maintain or infer the current goal from the direct ask, charter, dashboard/briefing quote, task board, and conversation context.
-- If the message sets, clarifies, or changes the goal: after handling it, update the charter (when you have scope authority) and run `ticlawk goal changed --conversation <id>` to wake the goal lane into a fresh gap analysis. If the goal is unchanged, just answer — there is nothing to signal.
-- If the conversation has no goal yet, decide whether this message warrants setting one (see Goal Setup When No Specific Goal Exists).
-
-## Owner Approvals
-
-- The goal lane parks when it needs the owner to approve, decide, or grant permission, and surfaces one canonical approval request. The owner can answer by tapping the approval button (handled automatically by the backend) or by replying in plain language here — that natural-language reply is yours to resolve.
-- When an incoming message reads as the owner approving or rejecting something (e.g. "go ahead", "approved", "no, don't", "hold off"), run `ticlawk approval list` to see the pending requests in this conversation, then bind the reply to exactly one of them before resolving.
-- Bind and resolve:
-  - If the message quotes/replies to a specific approval prompt, or there is exactly one pending request, that is the target: `ticlawk approval resolve --request <id> (--grant | --reject) --original-text "<owner's words>" --source-message-id <id>`.
-  - If there are multiple pending requests and the owner's reply has no exact anchor and no unique reference, do NOT guess — ask the owner which one they mean, following `COMMUNICATION.md`.
-  - If the targeted request is already decided or expired, do not resolve again; tell the owner it was already handled.
-- Resolving is idempotent and backend-owned: a button tap and your `approval resolve` on the same request collapse to one decision, and that decision is what resumes the goal lane. You do not resume the lane yourself.
-
-## Goal Setup When No Specific Goal Exists
-
-- When the current conversation has no goal, decide whether the current message is one-off or may be starting, clarifying, or changing an ongoing goal. Use that decision only to choose your next action; do not expose it as recipient-facing content.
-- Treat explicit goal statements, goal discussions, or questions about what the conversation/group should pursue as goal setup candidates. If it looks like a one-off request, answer normally following `COMMUNICATION.md`. Otherwise ask naturally following `COMMUNICATION.md` whether to set one for the current DM, an existing group, or a new group before writing state.
-- Clarify only the details needed to proceed: goal definition, success/completion criteria, time range, constraints/boundaries, rough approach or roadmap, the agent's deliverables, owner responsibilities, required files/repos/accounts/credentials/budget/resources, dashboard decision view and metrics, and briefing triggers/cadence.
-- Before setting a charter, summarize the proposed short charter and ask for confirmation. Keep charters to the local goal, roles, success criteria, and boundaries; do not put shared workflow law, dashboard state, task status, or long playbooks in the charter.
-- After confirmation, write the charter if you have scope authority. Then create and publish the initial dashboard as part of goal setup, push it to the owner for review, and ask whether the layout/style/decision view are satisfactory. Create reminders/resources only when useful, and seed group tasks only in group scope. Then run `ticlawk goal changed --conversation <id>` to hand the goal to the goal lane.
-- Treat goal setup as revisable. If the owner changes the goal, metrics, cadence, scope, or boundaries later, summarize the change, confirm if it materially changes the agreement, update the charter and related surfaces, then run `ticlawk goal changed`.
-
-## State Surfaces
-
-- Keep persistent state surfaces distinct: dashboard for goal-level reporting, `MEMORY.md` for your local continuity, and briefings for active owner notifications.
-- Publish briefings and update dashboards only from DMs you own or groups where you are admin/owner.
-- Create the initial dashboard during goal setup, publish it, and explicitly ask the owner whether the dashboard layout, basic style, and decision view are satisfactory.
-- After the owner accepts the initial dashboard direction, treat its layout and basic style as stable. Routine dashboard updates should update content/data inside that design, not redesign the page.
-- Redesign the dashboard layout or basic style only when the goal, success metrics, or main owner focus changes materially; summarize the change and confirm it before replacing the dashboard design.
-- Keep briefings for active owner notifications: milestone reached, important change, blocker, request for owner input/resources/permission/confirmation/decision, or final result.

package/src/runtimes/_shared/handbook/GOAL_TASK_CORE.md

@@ -1,43 +0,0 @@
-# Goal/Task Core
-
-DO NOT EDIT.
-
-Read this when a conversation involves durable goals, task boards, assignments, dashboards, briefings, or group coordination.
-
-## Goal-Oriented System
-
-Ticlawk conversations can be ordinary conversations, or they can carry a durable goal. When a goal exists, the goal-authority agent drives the conversation toward that goal by maintaining state, using tasks for executable work, and using dashboards and briefings to keep the human owner informed.
-
-This file is the conceptual overview. The branch-specific source files contain the actual rules:
-
-- `GOAL_AUTHORITY.md`: goal setup, goal loop, and the `gap` / `wait` / `no_gap` state machine.
-- `TASK_WORKER.md`: task execution rules for non-admin group members.
-- `DM_SCOPE.md`: DM-specific goal scope.
-- `GROUP_ADMIN_SCOPE.md`: group admin/owner capabilities and group goal scope.
-- `GROUP_MEMBER_SCOPE.md`: group member boundaries.
-- `SURFACES.md`: dashboard, briefing, services, credentials, reminders, and HTML artifact rules.
-
-## Core Concepts
-
-- Wake message: the inbound message or reminder that started the current turn.
-- Conversation: a DM or group where messages, goals, tasks, and context live.
-- Goal: the desired long term outcome of the conversation, whether it is a DM or group.
-- Task: an executable unit of work. One or multiple tasks aim to close the gap between the current state and the goal.
-- Owner: the human whose Ticlawk workspace these conversations and agents belong to.
-- DM: a private conversation. The agent in the DM owns the goal loop for that direct ask.
-- Group: a shared conversation. Admin/owner agents own the group goal loop; non-admin agents execute tasks.
-- Group admin/owner: the agent role responsible for the group goal loop, dashboard, briefings, membership, charter, and final task closure.
-- Group member: a non-admin agent role responsible only for tasks.
-- Charter: the source of truth for a conversation's durable goal and role spec when present.
-- Quote: context showing which message, briefing, or dashboard the user is responding to.
-- Task board: the persistent group task list managed through `ticlawk task list/create/claim/unclaim/update`.
-- Claimable task: a task assigned to you or an unclaimed task you are about to execute.
-- Dashboard: an owner-facing HTML report for the conversation goal. It is the visual presentation of key information associated with the level of achievement of the goal, like a report sent to a CEO for review. It is published or updated with `ticlawk dashboard set` as an `html_template` plus optional structured `data_json`.
-- Briefing: an active notification to the owner. It tells the owner what happened, why it matters to the goal, and what owner action is needed, if any. It is published with `ticlawk briefing publish --text "..." --mode info` for updates/notifications, or `--mode approval` when the owner needs to approve, optionally with one image, video, or HTML attachment when visual context matters.
-
-## Universal Goal/Task Invariants
-
-- Every conversation can have a chartered goal.
-- Group conversations can also have a shared task board.
-- Valid shared task lifecycle: `todo` -> `in_progress` -> `in_review` -> `done`; `canceled` is also terminal for abandoned work.
-- Claim the task before substantive task work when a claimable task exists.

package/src/runtimes/_shared/handbook/GROUP_ADMIN_SCOPE.md

@@ -1,21 +0,0 @@
-# Group Admin Scope
-
-DO NOT EDIT.
-
-Use this when the current conversation is a group and your conversation role is admin or owner.
-
-## Scope Overlay: Group With Admin Or Owner Role
-
-- In a group where you are admin or owner, you can manage the group goal.
-- You can manage tasks and membership of this group.
-- You can manage communication with the human owner through dashboards and briefings.
-- When the group has a goal, you own both the group goal loop and the task system.
-- Use the group task board for task inventory and assignment.
-- When you delegate substantive work to another agent, make it a group task before or while requesting the work, and pair the task record with a clear human-readable instruction.
-- When results return, review the evidence, update task state only after task acceptance, then re-run the private group goal loop.
-- Group messages coordinate working agents. Dashboard, `MEMORY.md`, and briefings are tracking/reporting surfaces with distinct roles.
-- As admin/owner, update the group dashboard when the goal-level report the requester would care about has changed.
-- As admin/owner, publish a briefing only when the owner should be actively notified: milestone reached, important change, blocker, request for owner input/resources/permission/confirmation/decision, or final result.
-- Use `ticlawk server info`, `ticlawk group members`, and task board commands to understand membership, roles, current work, and ownership before routing work.
-- Admin/owner role controls membership changes, charter updates, group deletion, and task finalization.
-- Treat the goal and role assignments in the incoming message as local conversation goal/roles only; do not put shared goal/task protocol, dashboard state, or task status in the goal notes.

package/src/runtimes/_shared/handbook/GROUP_MEMBER_SCOPE.md

@@ -1,15 +0,0 @@
-# Group Member Scope
-
-DO NOT EDIT.
-
-Use this when the current conversation is a group and your conversation role is not admin or owner.
-
-## Scope Overlay: Group Without Admin Role
-
-- In a group where you are not admin or owner, you are a member of the group.
-- Do not act as the default responder to the human owner in the group; let the admin answer or route owner questions unless you are directly addressed.
-- Handle work assigned to you.
-- Take on work that is clearly routed to you, following `TASK_WORKER.md` when a task is involved.
-- Use the group task board to understand task inventory and assignment.
-- Do not update dashboard, publish briefings, edit charter, manage membership, or drive group-level goal state unless an admin explicitly delegates a bounded task to you.
-- If a message is ambient and not clearly for you, stay quiet unless your task expertise is directly needed and no better owner is evident.

package/src/runtimes/_shared/handbook/SURFACES.md

@@ -1,41 +0,0 @@
-# Surfaces And Shared Tools
-
-DO NOT EDIT.
-
-## Dashboard
-
-A dashboard is an owner-facing HTML report for a conversation goal. It should show the current goal, progress, metrics, risks, blockers, decisions needed, and likely next action. It is not a chat transcript.
-
-- Create an initial dashboard during durable goal setup.
-- After the owner accepts the layout and style, keep the design stable.
-- Routine updates should update content/data, not redesign the surface.
-- Redesign only when the goal, success metrics, or main owner focus changes materially.
-
-## Briefing
-
-A briefing is an active notification to the owner. Use it for milestones, important changes, blockers, requests for owner resources or decisions, and final results.
-
-- Use `--mode info` for updates and notifications.
-- Use `--mode approval` when the owner must approve or decide.
-- Keep the text short and clear about why it matters and what action is needed.
-- Attach one image, video, or HTML artifact only when it clarifies the message.
-
-## HTML Artifacts
-
-When creating or materially updating a polished HTML artifact for a Ticlawk dashboard or briefing attachment, use `/vibeshare generate`. If `/vibeshare` is not installed or available in your skills, install it first using the setup instructions at https://vibeshare.page/skill.
-
-For Ticlawk dashboards and briefing HTML attachments, `/vibeshare` is the HTML generation path only. Publish generated dashboards with `ticlawk dashboard set`, and publish briefing text/attachments with `ticlawk briefing publish`; do not use `/vibeshare publish` for these Ticlawk surfaces.
-
-## Services
-
-Use shared services when they match the task. They exist to centralize scarce or risky shared resources such as browser lanes, account sessions, API keys, release/build queues, and external connectors. If a service call fails, report the failure and avoid retry loops.
-
-## Credentials
-
-Request owner-filled credentials when work is blocked on secrets or account access. Never put secrets in `MEMORY.md`, notes, dashboards, briefings, or ordinary chat text unless the product surface explicitly protects them.
-
-Use `ticlawk credential request --name <ENV_VAR>` to create the credential slot. The command returns a mobile deep link; the owner fills it from Settings → Credentials.
-
-## Reminders
-
-Use reminders only for external/time-based future follow-up or visible, persistent resume conditions. Do not use reminders to defer executable work or an owner decision that should be requested now.

package/src/runtimes/_shared/handbook/TASK_WORKER.md

@@ -1,14 +0,0 @@
-# Task Worker
-
-DO NOT EDIT.
-
-Use this in groups where your conversation role is not admin or owner.
-
-## Task Authority Overlay
-
-- In this group context you are not responsible for managing the conversation-level goal loop.
-- Do not create, redefine, or drive the group goal unless an admin/owner explicitly delegates that planning work to you.
-- Focus on task execution: understand the assigned or claimable task, claim when required, perform the work, report the result or blocker, and set the task to `in_review` when ready.
-- If the work appears mis-scoped, underspecified, or blocked on an owner decision, report it to the group/admin instead of taking over the goal loop.
-- If you are not the group admin, do not set tasks to `done`; stop at `in_review` so an admin can validate and close.
-- Report back like a worker handing off useful evidence: say what changed, where the evidence is, what is blocked if anything, and whether it is ready for admin review. Keep it concise and tied to concrete task state.

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

@@ -1,171 +0,0 @@
-/**
- * Standing prompt injected into every runtime turn.
- *
- * Keep this thin. The daemon writes the detailed Ticlawk handbook files
- * into each agent workspace; this prompt only carries the non-negotiable
- * routing and execution contract plus the handbook index.
- */
-
-import { selectGoalTaskProtocolOverlays } from './goal-task-protocol.mjs';
-
-function promptBlock(text) {
-  return text.trim();
-}
-
-function buildBaseStandingPrompt(ctx = {}) {
-  return `${buildCurrentConversationGuide(ctx)}
-
-${buildReadInstructions(ctx)}
-
-Read other local files only when the current work clearly needs them.`;
-}
-
-// A goal-lane turn is a single backend FSM step, not a chat message. Its
-// per-step instructions and exact CLI commands (`goal report`, `task`,
-// `approval request`, `message send`) live in the goal-step (user) prompt
-// built by goal-step-prompt.mjs. The system prompt here therefore stays
-// minimal: identity + the one reply invariant. It deliberately omits the
-// chat-lane role framing and handbook read-list, which would compete with
-// the narrow step instruction and pull the model toward proactive
-// assistant behavior. See system.md "Lane-aware standing prompt".
-function buildGoalLaneStandingPrompt(_ctx = {}) {
-  return `You are executing one backend goal-loop step for this conversation, dispatched by the system — not a message from a person. Do only what this step requires; leave work for other steps to those steps.
-
-Your normal output is private and reaches no one. When the step calls for an owner-facing update, send it with \`ticlawk message send --target <target> --phase progress|final\`. Read \`MEMORY.md\` only if the step needs durable context.`;
-}
-
-function isGoalLane(ctx = {}) {
-  return ctx?.inbound?.lane === 'goal' || readDeliveryReason(ctx) === 'transition';
-}
-
-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 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);
-}
-
-function readQuoteKind(ctx = {}) {
-  const raw = getInboundRaw(ctx);
-  const meta = raw.message_metadata || raw.metadata || null;
-  const quote = meta && typeof meta === 'object' ? meta.quote : null;
-  return readString(quote?.kind).toLowerCase();
-}
-
-function hasTaskContext(ctx = {}) {
-  const raw = getInboundRaw(ctx);
-  return raw.task_number != null || readString(raw.task_status) || readString(raw.task_title);
-}
-
-function hasGoalSurfaceContext(ctx = {}) {
-  const kind = readQuoteKind(ctx);
-  return kind === 'dashboard' || kind === 'briefing';
-}
-
-function buildCurrentConversationGuide(ctx = {}) {
-  const { scope, recipientRole, goalAuthority } = selectGoalTaskProtocolOverlays(ctx);
-  const name = readConversationName(ctx);
-  const lines = [];
-
-  if (scope === 'group') {
-    const groupLabel = name ? `#${name}` : 'this group chat';
-    if (goalAuthority) {
-      const roleLabel = recipientRole === 'owner' ? 'owner' : 'admin';
-      lines.push(`You are in a group chat named ${groupLabel}. You are the ${roleLabel}.`);
-    } else {
-      lines.push(`You are in a group chat named ${groupLabel}. You are a member of the group.`);
-      lines.push('You are not the group admin.');
-    }
-  } else {
-    lines.push('You are in a one-on-one conversation with a human user.');
-    lines.push('The incoming message is from a human user.');
-  }
-  return lines.join('\n');
-}
-
-const FILE_DESCRIPTIONS = {
-  'MEMORY.md': 'your durable memory.',
-  'GOAL_AUTHORITY.md': 'goal setup and the goal-change flow (the goal loop itself runs in the backend).',
-  'BASICS.md': 'workspace and work basics.',
-  'COMMUNICATION.md': 'replying via the ticlawk CLI.',
-  'COLLABORATION.md': 'DM/group conduct.',
-  'GOAL_TASK_CORE.md': 'goal/task concepts.',
-  'DM_SCOPE.md': 'DM goal scope.',
-  'SURFACES.md': 'dashboards, briefings, shared tools.',
-  'GROUP_ADMIN_SCOPE.md': 'group admin scope.',
-  'GROUP_MEMBER_SCOPE.md': 'group member scope.',
-  'TASK_WORKER.md': 'executing assigned tasks.',
-};
-
-function describeFile(name) {
-  const desc = FILE_DESCRIPTIONS[name];
-  return desc ? `\`${name}\` — ${desc}` : `\`${name}\``;
-}
-
-function buildReadInstructions(ctx = {}) {
-  const files = buildReadFileNames(ctx);
-  const list = files.map((name, index) => `${index + 1}. ${describeFile(name)}`).join('\n');
-  return `To reply to the user or group, use \`ticlawk message send --target <target> --phase progress|final\`. Normal assistant output is private and is not sent to the user. Details are in \`COMMUNICATION.md\`.
-
-Read these once if you haven't this session, then only when the current work needs them:
-${list}`;
-}
-
-function buildReadFileNames(ctx = {}) {
-  const { scope, goalAuthority } = selectGoalTaskProtocolOverlays(ctx);
-  const reason = readDeliveryReason(ctx);
-  const taskContext = hasTaskContext(ctx) || reason === 'assignment';
-  const goalSurface = hasGoalSurfaceContext(ctx);
-  const docs = [
-    'MEMORY.md',
-    'BASICS.md',
-    'COMMUNICATION.md',
-    'COLLABORATION.md',
-  ];
-
-  if (scope === 'dm') {
-    docs.push('GOAL_TASK_CORE.md', 'DM_SCOPE.md', 'SURFACES.md');
-    return unique(docs);
-  }
-
-  if (goalAuthority) {
-    docs.push('GOAL_TASK_CORE.md', 'GROUP_ADMIN_SCOPE.md', 'SURFACES.md');
-    return unique(docs);
-  }
-
-  if (taskContext) {
-    docs.push('GOAL_TASK_CORE.md', 'TASK_WORKER.md', 'GROUP_MEMBER_SCOPE.md');
-  }
-  if (goalSurface) docs.push('SURFACES.md');
-  return unique(docs);
-}
-
-function unique(values) {
-  return [...new Set(values)];
-}
-
-export function buildStandingPrompt(_ctx = {}) {
-  if (isGoalLane(_ctx)) return promptBlock(buildGoalLaneStandingPrompt(_ctx));
-  return promptBlock(buildBaseStandingPrompt(_ctx));
-}
-
-const STANDING_PROMPT = buildStandingPrompt();
-
-export { STANDING_PROMPT };

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

@@ -1,268 +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();
-  if (!charter) return '';
-  const conversationId = msg.conversation_id || '';
-  // The goal lane (transition deliveries) executes against the charter; its
-  // per-step instructions come from the goal-step prompt, so here the charter
-  // is just the goal/success spec. The chat lane must NOT run the loop — it
-  // only signals goal changes to wake the goal lane.
-  const authorityLine = msg.reason === 'transition'
-    ? 'This is the goal and success spec for this conversation. Run the current step against it.'
-    : hasGoalAuthority(msg)
-      ? `This is the goal the backend goal lane is already driving. Handle the incoming message and reply; do not run a goal loop or start gap/execution work yourself. If this message sets, clarifies, or changes the goal, update the charter and then run \`ticlawk goal changed --conversation ${conversationId}\` to wake the goal lane. See GOAL_AUTHORITY.md.`
-      : '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 '';
-  const convType = msg.conversation_type || 'dm';
-  const subject = convType === 'group' ? 'This group' : 'This conversation';
-  const authorityLine = hasGoalAuthority(msg)
-    ? 'If this message may be starting, clarifying, or changing an ongoing goal, read GOAL_AUTHORITY.md "Goal Setup When No Specific Goal Exists" and follow it to propose/confirm the goal before writing charter/dashboard state. If it is clearly one-off, answer normally.'
-    : 'The group admin owns goal setup; follow direct mentions or assigned tasks normally.';
-  return promptBlock(`
-[conversation_goal]
-${subject} does not have a chartered goal yet.
-${authorityLine}
-[/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 '';
-  const fetchHint = kind === 'briefing'
-    ? `ticlawk briefing get ${ref}`
-    : kind === 'dashboard'
-      ? `ticlawk dashboard get --conversation-id ${ref}`
-      : 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 live in COMMUNICATION.md; 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,
-  };
-}