ticlawk 0.1.16-dev.15 → 0.1.16-dev.17

package/src/cli/agent-commands.mjs

@@ -12,7 +12,8 @@
  *   ticlawk message read --target <t> [--around <msg>] [--limit N]
  *   ticlawk task claim --message-id <id> [--lease-seconds N]
  *   ticlawk task update --task-id <id> --status <s>
- *   ticlawk task list [--target <t>]
+ *   ticlawk task list [--target <t>]   # group admins see the full task board
+ *   ticlawk charter get/set --target <t>
  *   ticlawk group members --target <t>
  *   ticlawk server info [--refresh]
  *
@@ -41,6 +42,9 @@ function requireAgentEnv() {
     agentId,
     hostId: String(process.env.TICLAWK_RUNTIME_HOST_ID || '').trim() || null,
     sessionId: String(process.env.TICLAWK_RUNTIME_SESSION_ID || '').trim() || null,
+    currentConversationId: String(process.env.TICLAWK_RUNTIME_CONVERSATION_ID || '').trim() || null,
+    currentMessageId: String(process.env.TICLAWK_RUNTIME_MESSAGE_ID || '').trim() || null,
+    currentTarget: String(process.env.TICLAWK_RUNTIME_TARGET || '').trim() || null,
   };
 }
 
@@ -51,6 +55,11 @@ function commonHeaders(env) {
   };
   if (env.hostId) headers['X-Ticlawk-Runtime-Host-Id'] = env.hostId;
   if (env.sessionId) headers['X-Ticlawk-Runtime-Session-Id'] = env.sessionId;
+  if (env.currentConversationId) headers['X-Ticlawk-Current-Conversation-Id'] = env.currentConversationId;
+  if (env.currentMessageId) headers['X-Ticlawk-Current-Message-Id'] = env.currentMessageId;
+  if (env.currentTarget && /^[\x00-\x7F]*$/.test(env.currentTarget)) {
+    headers['X-Ticlawk-Current-Target'] = env.currentTarget;
+  }
   return headers;
 }
 
@@ -161,7 +170,7 @@ export async function runMessageSendCommand(args) {
   }
 
   // Optional --kind <s> classifies the message via metadata.kind. The
-  // canonical user-facing value is 'briefing' (Office Briefings surface). Anything else
+  // canonical user-facing value is 'briefing'. Anything else
   // is passed through as-is so we don't have to update this list to add
   // new conventions.
   const kind = getArg(args, 'kind');
@@ -173,6 +182,7 @@ export async function runMessageSendCommand(args) {
     text: text.replace(/\n+$/, ''),
     seen_up_to_seq: getNumberArg(args, 'seen-up-to-seq'),
     reply_to_message_id: getArg(args, 'reply-to'),
+    allow_cross_target: Boolean(args['allow-cross-target']),
     media_asset_ids: mediaAssetIds.length > 0 ? mediaAssetIds : undefined,
     metadata,
   };
@@ -662,6 +672,11 @@ function inferContentType(filePath) {
     case '.jpg': case '.jpeg': return 'image/jpeg';
     case '.gif': return 'image/gif';
     case '.webp': return 'image/webp';
+    case '.mp4': return 'video/mp4';
+    case '.mov': return 'video/quicktime';
+    case '.m4v': return 'video/x-m4v';
+    case '.webm': return 'video/webm';
+    case '.html': case '.htm': return 'text/html';
     case '.pdf': return 'application/pdf';
     case '.txt': return 'text/plain';
     case '.md': return 'text/markdown';
@@ -868,6 +883,17 @@ export async function runWorkstreamListCommand(args) {
   return exitFromStatus(res.statusCode);
 }
 
+export async function runAgentListCommand(args) {
+  const env = requireAgentEnv();
+  const res = await daemonRequest({
+    method: 'GET',
+    path: '/agent/agent/list',
+    headers: commonHeaders(env),
+  });
+  printJson(res.body);
+  return exitFromStatus(res.statusCode);
+}
+
 export async function runAgentCreateCommand(args) {
   const env = requireAgentEnv();
   const name = getArg(args, 'name');
@@ -1040,33 +1066,38 @@ export async function runBriefingGetCommand(args) {
 export async function runBriefingPublishCommand(args) {
   const env = requireAgentEnv();
   const textArg = getArg(args, 'text');
-  const htmlPath = getArg(args, 'html');
-  if ((textArg && htmlPath) || (!textArg && !htmlPath)) {
-    console.error('exactly one of --text "<short>" or --html <path> is required');
+  const attachPath = getArg(args, 'attach');
+  if (!textArg) {
+    console.error('--text "<short>" is required');
     return 2;
   }
-  let bodyText = null;
-  let bodyHtml = null;
-  if (textArg) {
-    if (textArg.length > 100) {
-      console.error('--text must be ≤100 chars');
+  if (textArg.length > 140) {
+    console.error('--text must be ≤140 chars');
+    return 2;
+  }
+  let attachmentAssetId = null;
+  if (attachPath) {
+    const contentType = inferContentType(String(attachPath));
+    if (!contentType.startsWith('image/') && !contentType.startsWith('video/') && contentType !== 'text/html') {
+      console.error('--attach must be an image, video, or HTML file');
       return 2;
     }
-    bodyText = textArg;
-  } else {
-    try {
-      const fs = await import('node:fs');
-      bodyHtml = fs.readFileSync(String(htmlPath), 'utf8');
-    } catch (err) {
-      console.error(`could not read --html file: ${err?.message || err}`);
-      return 2;
+    const upload = await uploadFileViaDaemon(env, String(attachPath));
+    if (!upload.ok) {
+      console.error(`attachment upload failed for ${attachPath}: ${upload.error}`);
+      return 1;
     }
+    attachmentAssetId = upload.assetId;
   }
   const res = await daemonRequest({
     method: 'POST',
     path: '/agent/briefing/publish',
     headers: commonHeaders(env),
-    body: { body_text: bodyText, body_html: bodyHtml },
+    body: {
+      body_text: textArg,
+      attachment_asset_id: attachmentAssetId,
+      current_conversation_id: env.currentConversationId,
+    },
   });
   printJson(res.body);
   return exitFromStatus(res.statusCode);
@@ -1077,7 +1108,7 @@ export async function runCredentialRequestCommand(args) {
   const name = getArg(args, 'name');
   if (!name) { console.error('--name is required (e.g. GEMINI_API_KEY)'); return 2; }
   const description = getArg(args, 'description');
-  const workstream = getArg(args, 'workstream');
+  const groupTarget = getArg(args, 'group') || getArg(args, 'workstream');
   const res = await daemonRequest({
     method: 'POST',
     path: '/agent/credential/request',
@@ -1085,7 +1116,7 @@ export async function runCredentialRequestCommand(args) {
     body: {
       name,
       description,
-      target: workstream,
+      target: groupTarget,
     },
   });
   printJson(res.body);
@@ -1149,9 +1180,9 @@ export async function runDashboardGetCommand(args) {
 export async function runWorkstreamCharterGetCommand(args) {
   const env = requireAgentEnv();
   const target = getArg(args, 'target');
-  const conversationId = getArg(args, 'conversation-id');
+  const conversationId = getArg(args, 'conversation-id') || env.currentConversationId;
   if (!target && !conversationId) {
-    console.error('--target or --conversation-id is required');
+    console.error('--target or --conversation-id is required outside a delivered conversation');
     return 2;
   }
   const params = new URLSearchParams();
@@ -1169,9 +1200,9 @@ export async function runWorkstreamCharterGetCommand(args) {
 export async function runWorkstreamCharterSetCommand(args) {
   const env = requireAgentEnv();
   const target = getArg(args, 'target');
-  const conversationId = getArg(args, 'conversation-id');
+  const conversationId = getArg(args, 'conversation-id') || env.currentConversationId;
   if (!target && !conversationId) {
-    console.error('--target or --conversation-id is required');
+    console.error('--target or --conversation-id is required outside a delivered conversation');
     return 2;
   }
   // Body from stdin (heredoc / pipe). Empty input clears the charter.
@@ -1205,15 +1236,16 @@ export async function runServerInfoCommand(args) {
 
 export const AGENT_COMMAND_HELP = {
   message: `ticlawk message <send|read|check|search|react>
-  ticlawk message send --target "<target>" [--seen-up-to-seq N] [--reply-to <msg-id>] [--attach <file> ...] [--kind <kind>]
+  ticlawk message send --target "<target>" [--seen-up-to-seq N] [--reply-to <msg-id>] [--allow-cross-target] [--attach <file> ...] [--kind <kind>]
     Body is read from stdin (use <<'EOF' ... EOF for multiline).
-    --kind <kind> tags this message via metadata.kind. The CoS uses
-      --kind briefing to publish a status briefing that the Office
-      tab can list separately.
+    During a delivered turn, sending to a different conversation is blocked
+      unless --allow-cross-target is passed deliberately.
+    --kind <kind> tags this message via metadata.kind.
     Targets:
-      dm:@<user>         private message
-      #<group>           group conversation
-      #<group>:<msgid>   thread under a top-level message in that group
+      dm:<conversation-id>  private message by conversation id
+      dm:@<user>            private message by user/agent handle
+      #<group>              group conversation by name or id
+      #<group>:<msgid>      replies under a top-level message in that group
     --attach <file> uploads a local file and attaches it to the message
       (repeatable; max 10 attachments per message).
   ticlawk message read --target "<target>" [--around <msg-id>] [--before-seq N] [--limit N]
@@ -1225,7 +1257,11 @@ export const AGENT_COMMAND_HELP = {
     Use sparingly: prefer acknowledgement/follow-up signals like 👀. Do not
     auto-react to every merge, deploy, or task completion with celebratory emoji.
 `,
-  profile: `ticlawk profile <show|update>
+  profile: `ticlawk profile <list|current|use|show|update>
+  ticlawk profile list
+  ticlawk profile current
+  ticlawk profile use ticlawk:<user-id>
+
   ticlawk profile show [@handle | --id <agent-id>]
   ticlawk profile update [--display-name X] [--description Y] [--avatar-file path]
 `,
@@ -1247,39 +1283,41 @@ export const AGENT_COMMAND_HELP = {
 `,
   task: `ticlawk task <create|claim|unclaim|update|list>
   ticlawk task create --target "<target>" [--title <t>]
-    Body is read from stdin. Creates a brand-new message published as a todo
-    task. To own it, follow up with \`ticlawk task claim --message-id <id>\`.
+    Body is read from stdin. Creates a brand-new group task.
   ticlawk task claim --message-id <id> [--lease-seconds N]
   ticlawk task claim --number <N> --target "<target>" [--lease-seconds N]
   ticlawk task unclaim --task-id <id>
   ticlawk task update --task-id <id> --status <todo|in_progress|in_review|done|canceled>
-  ticlawk task list [--target <target>]
+    Only a group admin can set status=done. Other agents should set
+    in_review and let the group's admin finalize.
+  ticlawk task list [--target <target>|--conversation-id <id>]
+    Default view is open tasks plus tasks owned by the caller. When the
+    caller is a group admin and --target/--conversation-id scopes the
+    request to that group, the list shows the full task board, including
+    other agents' in_progress, in_review, and done tasks.
 `,
   workstream: `ticlawk workstream <create|delete|list|charter>
-  workstream create --name X [--description Y] [--member <agent-id> ...] [--charter [<text>]]
-    CoS-only. Create a managed group conversation. If --charter has no
-    value, body is read from stdin (heredoc / pipe). Empty stdin = no
-    charter. Members are joined alongside CoS.
-  workstream delete --target "#<group>"
-    CoS-only. Hard-delete the workstream (messages, members, deliveries
-    cascade). Use carefully.
-  workstream list
-    List all workstreams (group conversations) owned by your user.
-  workstream charter get --target "#<group>"
-    Print the workstream's charter (CoS-authored markdown).
-  workstream charter set --target "#<group>"   # body via stdin
-    Replace the workstream charter. CoS-only — non-CoS callers get 403.
-    Empty stdin clears the charter. Hard cap 4096 chars (DB-enforced).
+    Compatibility alias for group admin commands. Prefer \`ticlawk group ...\`
+    for groups and \`ticlawk charter ...\` for conversation charters.
+`,
+  charter: `ticlawk charter <get|set> [--target "<target>" | --conversation-id <id>]
+  ticlawk charter get [--target "<target>" | --conversation-id <id>]
+    Print the conversation charter. DM/group members can read.
+  ticlawk charter set [--target "<target>" | --conversation-id <id>]   # body via stdin
+    Replace the conversation charter. DM member agents can write their DM
+    charter; group writes require group admin/owner. Empty stdin clears it.
+    During a delivered turn, omitting target/conversation-id uses the
+    current conversation.
 `,
   service: `ticlawk service <create|update|delete|list|info|call>
   service create --name X --endpoint <path-or-json> [--description Y] [--contract <path-or-json>]
-    CoS-only. Register a callable service. --endpoint takes either a
+    Any agent. Register a callable service. --endpoint takes either a
     .json file path or a JSON string; same for --contract.
     endpoint_config shape: { url, method?, headers? }.
   service update --service-id <id> [--description Y] [--contract <json>] [--endpoint <json>] [--status <active|down|archived>]
-    CoS-only.
+    Any agent.
   service delete --service-id <id>
-    CoS-only. Soft-archives.
+    Any agent. Soft-archives.
   service list
     Any agent. Returns active services (no endpoint_config).
   service info --name X
@@ -1288,47 +1326,62 @@ export const AGENT_COMMAND_HELP = {
     Any agent. Backend proxies to endpoint_config.url. No retry.
 `,
   briefing: `ticlawk briefing <publish|get>
-  briefing publish (--text "..." | --html <path>)
-    CoS-only. Publish a briefing to the owner's Office → Briefings.
-    --text  short plain text (≤100 chars), use for one-liner pings
-    --html  path to an HTML file; body is rendered as a full-screen card
-    Briefings are independent of chat — they do NOT appear in the CoS
-    DM message stream. Use this verb (not \`message send\`) for any
-    status surface the owner consumes in Office.
+  briefing publish --text "..." [--attach <image|video|html path>]
+    Publish a briefing to the owner's Briefings. Allowed from DMs, or
+    from groups where this agent is admin/owner.
+    --text  short plain text (≤140 chars)
+    --attach optional image, video, or HTML file when visual context matters
+    Briefings are independent of chat — they do NOT appear in any DM
+    message stream. Use this verb (not \`message send\`) for any status
+    surface the owner consumes in Briefings.
   briefing get <id>
-    Fetch a briefing including body_text/body_html. Use this when a
+    Fetch a briefing including text and attachment metadata. Use this when a
     quote (metadata.quote.kind=briefing) points at a briefing whose
     full body you want to read.
 `,
-  credential: `ticlawk credential request --name <ENV_VAR> [--description Y] [--workstream "#<ws>"]
-    CoS-only. Pre-allocate a credential slot. Response includes a deep
-    link the user opens in the mobile app (Settings → Connections) to
-    fill the value. Once filled, the daemon injects it as an env var
-    when spawning agents.
+  credential: `ticlawk credential request --name <ENV_VAR> [--description Y] [--group "#<group>"]
+    Any agent. Pre-allocate a credential slot. Response includes a deep
+    link the user opens in the mobile app (HQ Settings → Credentials)
+    to fill the value. Once filled, the daemon syncs it locally and
+    injects it as an env var when spawning agents.
 `,
-  dashboard: `ticlawk dashboard <set|get> --target "#<workstream>"
-  dashboard set --target "#<workstream>"   # body via stdin (JSON)
-    CoS-only. stdin = { "data_json": ..., "html_template": "..." }.
+  dashboard: `ticlawk dashboard <set|get> (--target "<target>" | --conversation-id <id>)
+  dashboard set (--target "<target>" | --conversation-id <id>)   # body via stdin (JSON)
+    Allowed from DMs, or from groups where this agent is admin/owner.
+    stdin = { "data_json": ..., "html_template": "..." }.
     Either field may be omitted (leaves unchanged) or null (clears).
-  dashboard get --target "#<workstream>"
-    Any member of the workstream can read.
+  dashboard get (--target "<target>" | --conversation-id <id>)
+    Conversation members can read.
 `,
-  agent: `ticlawk agent <create|delete>
+  agent: `ticlawk agent <list|create|delete>
+  agent list
+    Any agent. List all non-archived agents owned by the user, including
+    descriptions, runtime/status, and group memberships.
   agent create --name X --runtime <claude_code|codex|opencode|openclaw|pi> [--description Y] [--display-name N] [--model M]
-    CoS-only. Pre-allocate an agent slot (status='unpaired'). User
+    Any agent. Pre-allocate an agent slot (status='unpaired'). User
     later pairs a runtime to fill it.
   agent delete --agent-id <id>
-    CoS-only. Soft-delete the agent (status='archived'). Cannot archive
-    self.
+    Owner-only. Agent-facing deletion is disabled.
 `,
-  group: `ticlawk group <create|members>
+  group: `ticlawk group <create|list|delete|charter|members>
   ticlawk group create --name <n> [--description <d>] [--member <agent-id> ...]
-    Agent self-creates a new group. The agent is added as a member; the
+    Agent self-creates a new group. The agent is added as admin; the
     conversation owner is set to the user that owns this agent. Other
-    member agents must belong to the same user (RLS enforces).
-  ticlawk group members --target "<target>"
-  ticlawk group members --target "<target>" --add <agent-id> [--add <agent-id> ...]
-  ticlawk group members --target "<target>" --remove <agent-id>
+    member agents join as regular members and must belong to the same user
+    (RLS enforces).
+  ticlawk group list
+    List group conversations the caller belongs to, including agent members,
+    descriptions, charters, and dashboard presence.
+  ticlawk group delete --target "#<group>"
+    Group-admin only. Hard-delete the group (messages, members, deliveries).
+  ticlawk group charter get (--target "#<group>" | --conversation-id <id>)
+    Compatibility alias for \`ticlawk charter get\` on groups.
+  ticlawk group charter set (--target "#<group>" | --conversation-id <id>)   # body via stdin
+    Compatibility alias for \`ticlawk charter set\` on groups. Group-admin only.
+  ticlawk group members (--target "<target>" | --conversation-id <id>)
+  ticlawk group members (--target "<target>" | --conversation-id <id>) --add <agent-id> [--add <agent-id> ...]
+  ticlawk group members (--target "<target>" | --conversation-id <id>) --remove <agent-id>
+    Listing requires membership; add/remove requires group admin.
 `,
   server: `ticlawk server info [--refresh]
 `,

package/src/core/agent-cli-handlers.mjs

@@ -7,7 +7,8 @@
  * and forwards to the ticlawk backend using the connector API key.
  *
  * Targets are parsed in the daemon (not on the wire to backend) so the
- * CLI can speak `#<group>` / `dm:@<user>` / `#<group>:<short-msg-id>`
+ * CLI can speak `#<group>` / `dm:<conversation-id>` / `dm:@<user>` /
+ * `#<group>:<short-msg-id>`
  * while backend keeps a flat conversation_id contract.
  */
 
@@ -34,7 +35,7 @@ export function invalidateServerInfoCache(actingAgentId = null) {
 }
 
 /**
- * Parse a target string into { conversationId, threadRootMsgId } using a
+ * Parse a target string into { conversationId, replyToMessageId } using a
  * cached server-info lookup. Returns null fields if the target cannot be
  * resolved; callers should treat that as a 404.
  *
@@ -43,29 +44,29 @@ export function invalidateServerInfoCache(actingAgentId = null) {
  *   dm:@<handle>          -> find DM conversation whose other member is <handle>
  *   #<uuid>               -> conversation_id = <uuid>
  *   #<group-name>         -> find group conversation by name
- *   <foo>:<short-msg-id>  -> thread under <foo>, root = first message whose
+ *   <foo>:<short-msg-id>  -> replies under <foo>, root = first message whose
  *                            id startsWith <short-msg-id>
  */
 export async function resolveTarget(actingAgentId, target) {
-  if (!target) return { conversationId: null, threadRootMsgId: null, error: 'target is required' };
+  if (!target) return { conversationId: null, replyToMessageId: null, error: 'target is required' };
 
-  // Strip optional thread suffix.
+  // Strip optional message-reply suffix.
   let base = target;
-  let threadShort = null;
+  let replyToMessageId = null;
   const colonIdx = target.indexOf(':', target.startsWith('dm:') ? 3 : 1);
   if (colonIdx > 0 && colonIdx < target.length - 1) {
-    threadShort = target.slice(colonIdx + 1);
+    replyToMessageId = target.slice(colonIdx + 1);
     base = target.slice(0, colonIdx);
   }
 
   if (/^[0-9a-f-]{36}$/i.test(base)) {
-    return { conversationId: base, threadRootMsgId: threadShort, error: null };
+    return { conversationId: base, replyToMessageId, error: null };
   }
   if (base.startsWith('dm:') && /^[0-9a-f-]{36}$/i.test(base.slice(3))) {
-    return { conversationId: base.slice(3), threadRootMsgId: threadShort, error: null };
+    return { conversationId: base.slice(3), replyToMessageId, error: null };
   }
   if (base.startsWith('#') && /^[0-9a-f-]{36}$/i.test(base.slice(1))) {
-    return { conversationId: base.slice(1), threadRootMsgId: threadShort, error: null };
+    return { conversationId: base.slice(1), replyToMessageId, error: null };
   }
 
   const info = await getCachedServerInfo(actingAgentId);
@@ -76,19 +77,30 @@ export async function resolveTarget(actingAgentId, target) {
     const match = convs.find((c) =>
       c.type === 'dm' && (String(c.display_name || c.name || '').toLowerCase() === handle)
     );
-    if (match) return { conversationId: match.id, threadRootMsgId: threadShort, error: null };
-    return { conversationId: null, threadRootMsgId: null, error: `unknown dm target: ${target}` };
+    if (match) return { conversationId: match.id, replyToMessageId, error: null };
+    return { conversationId: null, replyToMessageId: null, error: `unknown dm target: ${target}` };
   }
   if (base.startsWith('#')) {
     const name = base.slice(1).toLowerCase();
     const match = convs.find((c) =>
       c.type === 'group' && (String(c.name || c.display_name || '').toLowerCase() === name)
     );
-    if (match) return { conversationId: match.id, threadRootMsgId: threadShort, error: null };
-    return { conversationId: null, threadRootMsgId: null, error: `unknown group target: ${target}` };
+    if (match) return { conversationId: match.id, replyToMessageId, error: null };
+
+    if (info?.agent?.is_cos) {
+      const workstreams = await api.listWorkstreams({ actingAgentId });
+      const workstreamMatch = workstreams.find((c) =>
+        String(c.name || c.display_name || '').toLowerCase() === name
+      );
+      if (workstreamMatch) {
+        return { conversationId: workstreamMatch.id, replyToMessageId, error: null };
+      }
+    }
+
+    return { conversationId: null, replyToMessageId: null, error: `unknown group target: ${target}` };
   }
 
-  return { conversationId: null, threadRootMsgId: null, error: `invalid target syntax: ${target}` };
+  return { conversationId: null, replyToMessageId: null, error: `invalid target syntax: ${target}` };
 }
 
 function getActingAgentId(req, body = {}) {
@@ -109,6 +121,15 @@ function getRuntimeHostId(req, body = {}) {
   return null;
 }
 
+function getCurrentConversationId(req, body = {}) {
+  const fromHeader = req.headers['x-ticlawk-current-conversation-id'];
+  if (typeof fromHeader === 'string' && fromHeader.trim()) return fromHeader.trim();
+  if (typeof body?.current_conversation_id === 'string' && body.current_conversation_id.trim()) {
+    return body.current_conversation_id.trim();
+  }
+  return null;
+}
+
 function validateActingAgent(actingAgentId, ctx) {
   if (!actingAgentId) {
     return { ok: false, status: 400, error: 'TICLAWK_RUNTIME_AGENT_ID required (passed via X-Ticlawk-Acting-Agent-Id or body.acting_as_agent_id)' };
@@ -132,19 +153,38 @@ export async function handleMessageSend(req, body, ctx) {
   if (!text) return { status: 400, body: { error: 'text is required' } };
 
   let conversationId = body?.conversation_id || null;
-  let threadRootMsgId = null;
+  let targetReplyToMessageId = null;
   if (!conversationId && body?.target) {
     const resolved = await resolveTarget(actingAgentId, String(body.target));
     if (resolved.error) {
       return { status: 404, body: { error: resolved.error } };
     }
     conversationId = resolved.conversationId;
-    threadRootMsgId = resolved.threadRootMsgId;
+    targetReplyToMessageId = resolved.replyToMessageId;
   }
   if (!conversationId) {
     return { status: 400, body: { error: 'target or conversation_id is required' } };
   }
 
+  const currentConversationId = getCurrentConversationId(req, body);
+  if (currentConversationId && currentConversationId !== conversationId && !body?.allow_cross_target) {
+    debugLog('agent-cli', 'send.blocked-cross-target', {
+      actingAgentId,
+      currentConversationId,
+      conversationId,
+      target: body?.target || null,
+    });
+    return {
+      status: 409,
+      body: {
+        error: 'refusing to send to a different conversation from the current runtime turn',
+        current_conversation_id: currentConversationId,
+        target_conversation_id: conversationId,
+        hint: 'Use --allow-cross-target only for an intentional cross-conversation send.',
+      },
+    };
+  }
+
   const mediaAssetIds = Array.isArray(body?.media_asset_ids)
     ? body.media_asset_ids.map((v) => String(v).trim()).filter(Boolean)
     : [];
@@ -155,7 +195,7 @@ export async function handleMessageSend(req, body, ctx) {
       conversationId,
       text,
       seenUpToSeq: body?.seen_up_to_seq,
-      replyToMessageId: body?.reply_to_message_id || threadRootMsgId || null,
+      replyToMessageId: body?.reply_to_message_id || targetReplyToMessageId || null,
       runtimeHostId: getRuntimeHostId(req, body),
       mediaAssetIds,
       metadata: body?.metadata,
@@ -773,6 +813,18 @@ export async function handleWorkstreamList(req, query, ctx) {
   }
 }
 
+export async function handleAgentList(req, query, ctx) {
+  const actingAgentId = getActingAgentId(req, query);
+  const v = validateActingAgent(actingAgentId, ctx);
+  if (!v.ok) return { status: v.status, body: { error: v.error } };
+  try {
+    const data = await api.listAgentSlots({ actingAgentId });
+    return { status: 200, body: { data } };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'agent list failed' } };
+  }
+}
+
 export async function handleAgentCreate(req, body, ctx) {
   const actingAgentId = getActingAgentId(req, body);
   const v = validateActingAgent(actingAgentId, ctx);
@@ -926,16 +978,24 @@ export async function handleBriefingPublish(req, body, ctx) {
   const actingAgentId = getActingAgentId(req, body);
   const v = validateActingAgent(actingAgentId, ctx);
   if (!v.ok) return { status: v.status, body: { error: v.error } };
-  const bodyText = typeof body?.body_text === 'string' && body.body_text.trim() ? body.body_text : null;
-  const bodyHtml = typeof body?.body_html === 'string' && body.body_html.trim() ? body.body_html : null;
-  if ((bodyText && bodyHtml) || (!bodyText && !bodyHtml)) {
-    return { status: 400, body: { error: 'exactly one of body_text or body_html is required' } };
+  const bodyText = typeof body?.body_text === 'string' && body.body_text.trim() ? body.body_text.trim() : null;
+  const attachmentAssetId = typeof body?.attachment_asset_id === 'string' && body.attachment_asset_id.trim()
+    ? body.attachment_asset_id.trim()
+    : null;
+  if (!bodyText) {
+    return { status: 400, body: { error: 'body_text is required' } };
   }
-  if (bodyText && bodyText.length > 100) {
-    return { status: 400, body: { error: 'body_text must be ≤100 chars' } };
+  if (bodyText && bodyText.length > 140) {
+    return { status: 400, body: { error: 'body_text must be ≤140 chars' } };
   }
+  const currentConversationId = getCurrentConversationId(req, body);
   try {
-    const data = await api.publishBriefing({ actingAgentId, bodyText, bodyHtml });
+    const data = await api.publishBriefing({
+      actingAgentId,
+      bodyText,
+      attachmentAssetId,
+      currentConversationId,
+    });
     return { status: 200, body: data };
   } catch (err) {
     return { status: err?.status || 500, body: { error: err?.message || 'briefing publish failed' } };

package/src/core/http.mjs

@@ -8,6 +8,7 @@ import {
   handleWorkstreamCreate,
   handleWorkstreamDelete,
   handleWorkstreamList,
+  handleAgentList,
   handleAgentCreate,
   handleAgentDelete,
   handleWorkstreamDashboardSet,
@@ -267,6 +268,10 @@ export function startLocalHttpServer({ port, adapter, ctx }) {
         const r = await handleWorkstreamList(req, parseQuery(req.url || ''), cliCtx);
         return writeJson(res, r.status, r.body);
       }
+      if (urlNoQuery === '/agent/agent/list' && method === 'GET') {
+        const r = await handleAgentList(req, parseQuery(req.url || ''), cliCtx);
+        return writeJson(res, r.status, r.body);
+      }
       if (urlNoQuery === '/agent/agent/create' && method === 'POST') {
         const body = await readJsonBody(req);
         if (body === null) return writeJson(res, 400, { error: 'invalid json body' });

package/src/core/runtime-env.mjs

@@ -15,6 +15,7 @@
 const STRIPPED_KEYS = new Set([
   'TICLAWK_CONNECTOR_API_KEY',
   'TICLAWK_CONNECTOR_WS_URL',
+  'TICLAWK_CREDENTIAL_NAMES',
   'TICLAWK_SETUP_CODE',
 ]);
 
@@ -35,11 +36,17 @@ export function buildAgentRuntimeEnv({
   sessionId,
   hostId,
   daemonUrl,
+  conversationId,
+  messageId,
+  target,
 } = {}) {
   const out = {};
   if (agentId) out.TICLAWK_RUNTIME_AGENT_ID = String(agentId);
   if (sessionId) out.TICLAWK_RUNTIME_SESSION_ID = String(sessionId);
   if (hostId) out.TICLAWK_RUNTIME_HOST_ID = String(hostId);
+  if (conversationId) out.TICLAWK_RUNTIME_CONVERSATION_ID = String(conversationId);
+  if (messageId) out.TICLAWK_RUNTIME_MESSAGE_ID = String(messageId);
+  if (target) out.TICLAWK_RUNTIME_TARGET = String(target);
   out.TICLAWK_RUNTIME_DAEMON_URL = daemonUrl || 'http://127.0.0.1:8741';
   return out;
 }