ticlawk 0.1.16-dev.11 → 0.1.16-dev.12

package/bin/ticlawk.mjs

@@ -32,6 +32,22 @@ import {
   AGENT_COMMAND_HELP,
   runAttachmentViewCommand,
   runGroupCreateCommand,
+  runWorkstreamCharterGetCommand,
+  runWorkstreamCharterSetCommand,
+  runWorkstreamCreateCommand,
+  runWorkstreamDeleteCommand,
+  runWorkstreamListCommand,
+  runAgentCreateCommand,
+  runAgentDeleteCommand,
+  runDashboardSetCommand,
+  runDashboardGetCommand,
+  runCredentialRequestCommand,
+  runServiceCreateCommand,
+  runServiceUpdateCommand,
+  runServiceDeleteCommand,
+  runServiceListCommand,
+  runServiceInfoCommand,
+  runServiceCallCommand,
   runGroupMembersAddCommand,
   runGroupMembersCommand,
   runGroupMembersRemoveCommand,
@@ -453,6 +469,107 @@ async function main() {
     process.exit(1);
   }
 
+  if (command === 'workstream') {
+    const sub = args._[1];
+    if (args.help || args.h || !sub) {
+      console.log(AGENT_COMMAND_HELP.workstream);
+      return;
+    }
+    if (sub === 'create') {
+      process.exitCode = await runWorkstreamCreateCommand(args);
+      return;
+    }
+    if (sub === 'delete') {
+      process.exitCode = await runWorkstreamDeleteCommand(args);
+      return;
+    }
+    if (sub === 'list') {
+      process.exitCode = await runWorkstreamListCommand(args);
+      return;
+    }
+    if (sub === 'charter') {
+      const op = args._[2];
+      if (op === 'get') {
+        process.exitCode = await runWorkstreamCharterGetCommand(args);
+        return;
+      }
+      if (op === 'set') {
+        process.exitCode = await runWorkstreamCharterSetCommand(args);
+        return;
+      }
+      console.error(`unknown workstream charter op: ${op}`);
+      process.exit(1);
+    }
+    console.error(`unknown workstream subcommand: ${sub}`);
+    process.exit(1);
+  }
+
+  if (command === 'agent') {
+    const sub = args._[1];
+    if (args.help || args.h || !sub) {
+      console.log(AGENT_COMMAND_HELP.agent);
+      return;
+    }
+    if (sub === 'create') {
+      process.exitCode = await runAgentCreateCommand(args);
+      return;
+    }
+    if (sub === 'delete') {
+      process.exitCode = await runAgentDeleteCommand(args);
+      return;
+    }
+    console.error(`unknown agent subcommand: ${sub}`);
+    process.exit(1);
+  }
+
+  if (command === 'service') {
+    const sub = args._[1];
+    if (args.help || args.h || !sub) {
+      console.log(AGENT_COMMAND_HELP.service);
+      return;
+    }
+    if (sub === 'create') { process.exitCode = await runServiceCreateCommand(args); return; }
+    if (sub === 'update') { process.exitCode = await runServiceUpdateCommand(args); return; }
+    if (sub === 'delete') { process.exitCode = await runServiceDeleteCommand(args); return; }
+    if (sub === 'list')   { process.exitCode = await runServiceListCommand(args); return; }
+    if (sub === 'info')   { process.exitCode = await runServiceInfoCommand(args); return; }
+    if (sub === 'call')   { process.exitCode = await runServiceCallCommand(args); return; }
+    console.error(`unknown service subcommand: ${sub}`);
+    process.exit(1);
+  }
+
+  if (command === 'credential') {
+    const sub = args._[1];
+    if (args.help || args.h || !sub) {
+      console.log(AGENT_COMMAND_HELP.credential);
+      return;
+    }
+    if (sub === 'request') {
+      process.exitCode = await runCredentialRequestCommand(args);
+      return;
+    }
+    console.error(`unknown credential subcommand: ${sub}`);
+    process.exit(1);
+  }
+
+  if (command === 'dashboard') {
+    const sub = args._[1];
+    if (args.help || args.h || !sub) {
+      console.log(AGENT_COMMAND_HELP.dashboard);
+      return;
+    }
+    if (sub === 'set') {
+      process.exitCode = await runDashboardSetCommand(args);
+      return;
+    }
+    if (sub === 'get') {
+      process.exitCode = await runDashboardGetCommand(args);
+      return;
+    }
+    console.error(`unknown dashboard subcommand: ${sub}`);
+    process.exit(1);
+  }
+
   if (command === 'group') {
     const sub = args._[1];
     if (args.help || args.h || !sub) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ticlawk",
-  "version": "0.1.16-dev.11",
+  "version": "0.1.16-dev.12",
   "description": "Local connector that links agent harnesses (Claude Code, Codex, OpenClaw, opencode, Pi) to the Ticlawk mobile app.",
   "type": "module",
   "main": "ticlawk.mjs",

package/src/adapters/ticlawk/api.mjs

@@ -188,6 +188,7 @@ export async function sendAgentMessage({
   runtimeHostId,
   visibility,
   mediaAssetIds,
+  metadata,
 }) {
   const { data } = await apiFetch('/api/agent/messages/send', {
     method: 'POST',
@@ -200,6 +201,7 @@ export async function sendAgentMessage({
       runtime_host_id: runtimeHostId ?? null,
       visibility: visibility || null,
       media_asset_ids: Array.isArray(mediaAssetIds) && mediaAssetIds.length > 0 ? mediaAssetIds : undefined,
+      metadata: metadata ?? undefined,
     }),
   });
   return data || null;
@@ -484,6 +486,193 @@ export async function removeAgentGroupMember({
   );
 }
 
+// ── Workstreams (CoS-managed groups) ──
+
+export async function createWorkstream({
+  actingAgentId, name, description, charter, memberAgentIds,
+}) {
+  return apiFetch('/api/agent/workstreams', {
+    method: 'POST',
+    body: JSON.stringify({
+      acting_as_agent_id: actingAgentId,
+      name,
+      description: description ?? null,
+      charter: charter ?? null,
+      member_agent_ids: memberAgentIds || [],
+    }),
+  });
+}
+
+export async function deleteWorkstream({ actingAgentId, conversationId }) {
+  return apiFetch(
+    `/api/agent/workstreams/${encodeURIComponent(conversationId)}`,
+    {
+      method: 'DELETE',
+      body: JSON.stringify({ acting_as_agent_id: actingAgentId }),
+    },
+  );
+}
+
+export async function listWorkstreams({ actingAgentId }) {
+  const params = new URLSearchParams();
+  params.set('acting_as_agent_id', actingAgentId);
+  const { data } = await apiFetch(`/api/agent/workstreams?${params}`);
+  return data || [];
+}
+
+// ── Agents (CoS pre-allocation) ──
+
+export async function createAgentSlot({
+  actingAgentId, name, runtime, description, displayName, model,
+}) {
+  return apiFetch('/api/agent/agents', {
+    method: 'POST',
+    body: JSON.stringify({
+      acting_as_agent_id: actingAgentId,
+      name,
+      runtime,
+      description: description ?? null,
+      display_name: displayName ?? null,
+      model: model ?? null,
+    }),
+  });
+}
+
+export async function archiveAgentSlot({ actingAgentId, agentId }) {
+  return apiFetch(
+    `/api/agent/agents/${encodeURIComponent(agentId)}`,
+    {
+      method: 'DELETE',
+      body: JSON.stringify({ acting_as_agent_id: actingAgentId }),
+    },
+  );
+}
+
+// ── Services ──
+
+export async function createService({
+  actingAgentId, name, description, contractSchema, endpointConfig,
+}) {
+  return apiFetch('/api/agent/services', {
+    method: 'POST',
+    body: JSON.stringify({
+      acting_as_agent_id: actingAgentId,
+      name,
+      description: description ?? null,
+      contract_schema: contractSchema ?? null,
+      endpoint_config: endpointConfig,
+    }),
+  });
+}
+
+export async function updateService({ actingAgentId, serviceId, ...patch }) {
+  return apiFetch(
+    `/api/agent/services/${encodeURIComponent(serviceId)}`,
+    {
+      method: 'PATCH',
+      body: JSON.stringify({ acting_as_agent_id: actingAgentId, ...patch }),
+    },
+  );
+}
+
+export async function deleteService({ actingAgentId, serviceId }) {
+  return apiFetch(
+    `/api/agent/services/${encodeURIComponent(serviceId)}`,
+    {
+      method: 'DELETE',
+      body: JSON.stringify({ acting_as_agent_id: actingAgentId }),
+    },
+  );
+}
+
+export async function listServices({ actingAgentId }) {
+  const params = new URLSearchParams();
+  params.set('acting_as_agent_id', actingAgentId);
+  const { data } = await apiFetch(`/api/agent/services?${params}`);
+  return data || [];
+}
+
+export async function getServiceInfo({ actingAgentId, name }) {
+  const params = new URLSearchParams();
+  params.set('acting_as_agent_id', actingAgentId);
+  return apiFetch(
+    `/api/agent/services/${encodeURIComponent(name)}/info?${params}`,
+  );
+}
+
+export async function callService({ actingAgentId, name, input }) {
+  return apiFetch(
+    `/api/agent/services/${encodeURIComponent(name)}/call`,
+    {
+      method: 'POST',
+      body: JSON.stringify({ acting_as_agent_id: actingAgentId, input }),
+    },
+  );
+}
+
+// ── Credentials (CoS slot creation) ──
+
+export async function requestCredential({
+  actingAgentId, name, description, workstreamId,
+}) {
+  return apiFetch('/api/agent/credentials', {
+    method: 'POST',
+    body: JSON.stringify({
+      acting_as_agent_id: actingAgentId,
+      name,
+      description: description ?? null,
+      workstream_id: workstreamId ?? null,
+    }),
+  });
+}
+
+// ── Workstream dashboard ──
+
+export async function setWorkstreamDashboard({
+  actingAgentId, conversationId, dataJson, htmlTemplate,
+}) {
+  const body = { acting_as_agent_id: actingAgentId };
+  // Distinguish "omit" from "set to null" — only include keys the caller
+  // explicitly passed (including null clears the field).
+  if (dataJson !== undefined) body.data_json = dataJson;
+  if (htmlTemplate !== undefined) body.html_template = htmlTemplate;
+  return apiFetch(
+    `/api/agent/workstreams/${encodeURIComponent(conversationId)}/dashboard`,
+    { method: 'POST', body: JSON.stringify(body) },
+  );
+}
+
+export async function getWorkstreamDashboard({ actingAgentId, conversationId }) {
+  const params = new URLSearchParams();
+  params.set('acting_as_agent_id', actingAgentId);
+  return apiFetch(
+    `/api/agent/workstreams/${encodeURIComponent(conversationId)}/dashboard?${params}`,
+  );
+}
+
+// ── Workstream charter ──
+
+export async function getWorkstreamCharter({ actingAgentId, conversationId }) {
+  const params = new URLSearchParams();
+  params.set('acting_as_agent_id', actingAgentId);
+  return apiFetch(
+    `/api/agent/workstreams/${encodeURIComponent(conversationId)}/charter?${params}`,
+  );
+}
+
+export async function setWorkstreamCharter({ actingAgentId, conversationId, charter }) {
+  return apiFetch(
+    `/api/agent/workstreams/${encodeURIComponent(conversationId)}/charter`,
+    {
+      method: 'POST',
+      body: JSON.stringify({
+        acting_as_agent_id: actingAgentId,
+        charter: charter ?? null,
+      }),
+    },
+  );
+}
+
 // ── Channel event pipe ──
 
 export async function postEvent({ agent, agent_id, runtime_host_id, session_id, cwd, runtime_version, event, required = false }) {

package/src/adapters/ticlawk/index.mjs

@@ -140,14 +140,61 @@ function buildGroupContextBlock(msg) {
   ].join('\n');
 }
 
+// Charter is the workstream's CoS-authored markdown spec. It's a stable
+// prefix-cacheable block — same bytes across every turn in the same
+// conversation — so it sits above the per-turn envelope.
+function buildCharterBlock(msg) {
+  const charter = (msg.conversation_charter || '').trim();
+  if (!charter) return '';
+  return ['[charter]', charter, '[/charter]'].join('\n');
+}
+
+// CoS-only addendum. Splice above the per-turn envelope (after charter,
+// before group context) when the recipient is the user's CoS.
+// Same bytes every turn → still prefix-cache-friendly.
+const COS_ADDENDUM = [
+  '[cos-role]',
+  'You are the user\'s Chief of Staff (CoS). You answer to the user. In every workstream:',
+  '',
+  '1. Push — break goals into agent-executable tasks, supervise progress, do not let work stall in place.',
+  '2. Simplify — agents should work simply and reliably. Stop over-engineering, junk-code piles, and detours.',
+  '3. Track — keep an entry per workstream in MEMORY.md; update it whenever state changes.',
+  '4. Represent — bundle resource / decision / approval requests and bring them to the user; do not flood the user with raw asks.',
+  '',
+  'Wake-on-event: every turn (including ambient delivery) you must read the message, update MEMORY.md if anything changed, and only reply when you need to intervene. Otherwise stop silently.',
+  '',
+  'Posture: bring a proposal, default to acting on it, change course if the user objects. "I propose A — reasons 1/2/3. Unless you redirect within 24h, I\'ll proceed with A." Not "should we do A or B?"',
+  '',
+  'Owner model: hold the user\'s preferences and constraints across workstreams. Apply them consistently. Do not "for-your-own-good" around stated preferences.',
+  '',
+  '奏折 / report posture: publish status to the user by sending a message into the CoS DM with `ticlawk message send --target dm:@<owner> --kind report` (stdin = the report body). Use this for scheduled summaries, escalations, or workstream check-ins. Reports surface in the Office → 奏折 sub-tab; chat replies do not. Do not over-spam reports — one per meaningful state change.',
+  '',
+  'Dashboard posture: maintain a per-workstream dashboard via `ticlawk dashboard set --target "#<ws>"` (stdin JSON: { data_json, html_template }). data_json holds the live numbers; html_template is the hand-written rendering. CoS replaces wholesale — there is no partial update protocol, and there is no schema lock-in on data_json. Use the dashboard for at-a-glance state; use 奏折 for narrative.',
+  '',
+  'Cadence: schedule your own daily 晨报 via `ticlawk reminder schedule --title "晨报" --in-minutes 1440 --anchor-conversation-id <your DM with owner>` after you handle this turn. The reminder fires by waking you with a system message; treat that wake as the trigger to compile the day\'s 奏折 across workstreams. Re-schedule on each fire so the cadence persists. Skip a day only if you are explicitly told to.',
+  '[/cos-role]',
+].join('\n');
+
+function buildCosAddendum(msg) {
+  if (!msg.recipient_is_cos) return '';
+  return COS_ADDENDUM;
+}
+
 // Wrap each per-turn message with an explicit reply instruction so the
 // runtime LLM never has to remember the standing prompt to figure out
 // HOW to reply. Codex in particular treats the developerInstructions as
 // background and ignores the chat-send pattern without this per-turn
 // nudge.
-function buildWakePromptText({ envelopeHeader, target, rawText, groupContext }) {
+function buildWakePromptText({ envelopeHeader, target, rawText, groupContext, charterBlock, cosAddendum }) {
   const body = `${envelopeHeader} ${rawText || ''}`.trim();
-  const lines = ['New message received:', '', body];
+  const lines = [];
+  if (charterBlock) {
+    lines.push(charterBlock, '');
+  }
+  if (cosAddendum) {
+    lines.push(cosAddendum, '');
+  }
+  lines.push('New message received:', '', body);
   if (groupContext) {
     lines.push('', groupContext);
   }
@@ -181,8 +228,10 @@ export function normalizeInboundMessage(msg) {
   const header = baseHeader + taskSuffix + reactionsSuffix;
   const target = buildEnvelopeTarget(enriched);
   const groupContext = buildGroupContextBlock(enriched);
+  const charterBlock = buildCharterBlock(enriched);
+  const cosAddendum = buildCosAddendum(enriched);
   const text = header
-    ? buildWakePromptText({ envelopeHeader: header, target, rawText, groupContext })
+    ? buildWakePromptText({ envelopeHeader: header, target, rawText, groupContext, charterBlock, cosAddendum })
     : rawText;
   return {
     bindingId: recipientAgentId,
@@ -1013,7 +1062,17 @@ export function createTiclawkAdapter(ctx) {
 
   function connectWakeSocket() {
     connectorSocket = new TiclawkWakeClient({
-      getUrl: api.getConnectorWsUrl,
+      // host_id rides on the WS query string so connector-wake can flip
+      // runtime_hosts.online for the right row. Empty host_id is
+      // tolerated by the server (it just skips the state write).
+      getUrl: () => {
+        const base = String(api.getConnectorWsUrl() || '').trim();
+        if (!base) return '';
+        const hostId = String(getHostId() || '').trim();
+        if (!hostId) return base;
+        const sep = base.includes('?') ? '&' : '?';
+        return `${base}${sep}host_id=${encodeURIComponent(hostId)}`;
+      },
       getApiKey: api.getApiKey,
       onEvent: handleWakeEvent,
       onStatus: handleWakeStatus,