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

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

@@ -158,6 +158,7 @@ export async function handleMessageSend(req, body, ctx) {
       replyToMessageId: body?.reply_to_message_id || threadRootMsgId || null,
       runtimeHostId: getRuntimeHostId(req, body),
       mediaAssetIds,
+      metadata: body?.metadata,
     });
     debugLog('agent-cli', 'send.ok', {
       actingAgentId,
@@ -716,6 +717,305 @@ export async function handleGroupMembersRemove(req, body, ctx) {
   }
 }
 
+export async function handleWorkstreamCreate(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 name = String(body?.name || '').trim();
+  if (!name) return { status: 400, body: { error: 'name is required' } };
+  try {
+    const data = await api.createWorkstream({
+      actingAgentId,
+      name,
+      description: body?.description || null,
+      charter: body?.charter ?? null,
+      memberAgentIds: Array.isArray(body?.member_agent_ids) ? body.member_agent_ids : [],
+    });
+    invalidateServerInfoCache(actingAgentId);
+    debugLog('agent-cli', 'workstream.create', {
+      actingAgentId, conversationId: data?.conversation?.id,
+    });
+    return { status: 200, body: data };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'workstream create failed' } };
+  }
+}
+
+export async function handleWorkstreamDelete(req, body, ctx) {
+  const actingAgentId = getActingAgentId(req, body);
+  const v = validateActingAgent(actingAgentId, ctx);
+  if (!v.ok) return { status: v.status, body: { error: v.error } };
+  let conversationId = body?.conversation_id || 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;
+  }
+  if (!conversationId) return { status: 400, body: { error: 'target or conversation_id is required' } };
+  try {
+    const data = await api.deleteWorkstream({ actingAgentId, conversationId });
+    invalidateServerInfoCache(actingAgentId);
+    return { status: 200, body: data };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'workstream delete failed' } };
+  }
+}
+
+export async function handleWorkstreamList(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.listWorkstreams({ actingAgentId });
+    return { status: 200, body: { data } };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'workstream list failed' } };
+  }
+}
+
+export async function handleAgentCreate(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 name = String(body?.name || '').trim();
+  const runtime = String(body?.runtime || '').trim();
+  if (!name) return { status: 400, body: { error: 'name is required' } };
+  if (!runtime) return { status: 400, body: { error: 'runtime is required' } };
+  try {
+    const data = await api.createAgentSlot({
+      actingAgentId,
+      name,
+      runtime,
+      description: body?.description || null,
+      displayName: body?.display_name || null,
+      model: body?.model || null,
+    });
+    return { status: 200, body: data };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'agent create failed' } };
+  }
+}
+
+export async function handleAgentDelete(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 agentId = String(body?.agent_id || '').trim();
+  if (!agentId) return { status: 400, body: { error: 'agent_id is required' } };
+  try {
+    const data = await api.archiveAgentSlot({ actingAgentId, agentId });
+    return { status: 200, body: data };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'agent delete failed' } };
+  }
+}
+
+export async function handleServiceCreate(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 name = String(body?.name || '').trim();
+  if (!name) return { status: 400, body: { error: 'name is required' } };
+  if (!body?.endpoint_config || typeof body.endpoint_config !== 'object') {
+    return { status: 400, body: { error: 'endpoint_config is required' } };
+  }
+  try {
+    const data = await api.createService({
+      actingAgentId, name,
+      description: body?.description || null,
+      contractSchema: body?.contract_schema ?? null,
+      endpointConfig: body.endpoint_config,
+    });
+    return { status: 200, body: data };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'service create failed' } };
+  }
+}
+
+export async function handleServiceUpdate(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 serviceId = String(body?.service_id || '').trim();
+  if (!serviceId) return { status: 400, body: { error: 'service_id is required' } };
+  const patch = {};
+  if ('description' in (body || {})) patch.description = body.description;
+  if ('contract_schema' in (body || {})) patch.contract_schema = body.contract_schema;
+  if ('endpoint_config' in (body || {})) patch.endpoint_config = body.endpoint_config;
+  if ('status' in (body || {})) patch.status = body.status;
+  try {
+    const data = await api.updateService({ actingAgentId, serviceId, ...patch });
+    return { status: 200, body: data };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'service update failed' } };
+  }
+}
+
+export async function handleServiceDelete(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 serviceId = String(body?.service_id || '').trim();
+  if (!serviceId) return { status: 400, body: { error: 'service_id is required' } };
+  try {
+    const data = await api.deleteService({ actingAgentId, serviceId });
+    return { status: 200, body: data };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'service delete failed' } };
+  }
+}
+
+export async function handleServiceList(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.listServices({ actingAgentId });
+    return { status: 200, body: { data } };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'service list failed' } };
+  }
+}
+
+export async function handleServiceInfo(req, query, ctx) {
+  const actingAgentId = getActingAgentId(req, query);
+  const v = validateActingAgent(actingAgentId, ctx);
+  if (!v.ok) return { status: v.status, body: { error: v.error } };
+  const name = String(query?.name || '').trim();
+  if (!name) return { status: 400, body: { error: 'name is required' } };
+  try {
+    const data = await api.getServiceInfo({ actingAgentId, name });
+    return { status: 200, body: data };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'service info failed' } };
+  }
+}
+
+export async function handleServiceCall(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 name = String(body?.name || '').trim();
+  if (!name) return { status: 400, body: { error: 'name is required' } };
+  try {
+    const data = await api.callService({
+      actingAgentId, name,
+      input: body?.input ?? null,
+    });
+    return { status: 200, body: data };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'service call failed' } };
+  }
+}
+
+export async function handleCredentialRequest(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 name = String(body?.name || '').trim();
+  if (!name) return { status: 400, body: { error: 'name is required' } };
+  let workstreamId = body?.workstream_id || null;
+  if (!workstreamId && body?.target) {
+    const resolved = await resolveTarget(actingAgentId, String(body.target));
+    if (resolved.error) return { status: 404, body: { error: resolved.error } };
+    workstreamId = resolved.conversationId;
+  }
+  try {
+    const data = await api.requestCredential({
+      actingAgentId,
+      name,
+      description: body?.description || null,
+      workstreamId,
+    });
+    return { status: 200, body: data };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'credential request failed' } };
+  }
+}
+
+export async function handleWorkstreamDashboardSet(req, body, ctx) {
+  const actingAgentId = getActingAgentId(req, body);
+  const v = validateActingAgent(actingAgentId, ctx);
+  if (!v.ok) return { status: v.status, body: { error: v.error } };
+  let conversationId = body?.conversation_id || 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;
+  }
+  if (!conversationId) return { status: 400, body: { error: 'target or conversation_id is required' } };
+  const payload = { actingAgentId, conversationId };
+  if ('data_json' in (body || {})) payload.dataJson = body.data_json;
+  if ('html_template' in (body || {})) payload.htmlTemplate = body.html_template;
+  try {
+    const data = await api.setWorkstreamDashboard(payload);
+    return { status: 200, body: data };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'dashboard set failed' } };
+  }
+}
+
+export async function handleWorkstreamDashboardGet(req, query, ctx) {
+  const actingAgentId = getActingAgentId(req, query);
+  const v = validateActingAgent(actingAgentId, ctx);
+  if (!v.ok) return { status: v.status, body: { error: v.error } };
+  let conversationId = query?.conversation_id || null;
+  if (!conversationId && query?.target) {
+    const resolved = await resolveTarget(actingAgentId, String(query.target));
+    if (resolved.error) return { status: 404, body: { error: resolved.error } };
+    conversationId = resolved.conversationId;
+  }
+  if (!conversationId) return { status: 400, body: { error: 'target or conversation_id is required' } };
+  try {
+    const data = await api.getWorkstreamDashboard({ actingAgentId, conversationId });
+    return { status: 200, body: data };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'dashboard get failed' } };
+  }
+}
+
+export async function handleWorkstreamCharterGet(req, query, ctx) {
+  const actingAgentId = getActingAgentId(req, query);
+  const v = validateActingAgent(actingAgentId, ctx);
+  if (!v.ok) return { status: v.status, body: { error: v.error } };
+  let conversationId = query?.conversation_id || null;
+  if (!conversationId && query?.target) {
+    const resolved = await resolveTarget(actingAgentId, String(query.target));
+    if (resolved.error) return { status: 404, body: { error: resolved.error } };
+    conversationId = resolved.conversationId;
+  }
+  if (!conversationId) return { status: 400, body: { error: 'target or conversation_id is required' } };
+  try {
+    const data = await api.getWorkstreamCharter({ actingAgentId, conversationId });
+    return { status: 200, body: data };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'charter get failed' } };
+  }
+}
+
+export async function handleWorkstreamCharterSet(req, body, ctx) {
+  const actingAgentId = getActingAgentId(req, body);
+  const v = validateActingAgent(actingAgentId, ctx);
+  if (!v.ok) return { status: v.status, body: { error: v.error } };
+  let conversationId = body?.conversation_id || 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;
+  }
+  if (!conversationId) return { status: 400, body: { error: 'target or conversation_id is required' } };
+  const charter = typeof body?.charter === 'string' ? body.charter : null;
+  try {
+    const data = await api.setWorkstreamCharter({ actingAgentId, conversationId, charter });
+    debugLog('agent-cli', 'workstream.charter.set', {
+      actingAgentId, conversationId, len: charter?.length ?? 0,
+    });
+    return { status: 200, body: data };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'charter set failed' } };
+  }
+}
+
 export async function handleServerInfo(req, query, ctx) {
   const actingAgentId = getActingAgentId(req, query);
   const v = validateActingAgent(actingAgentId, ctx);

package/src/core/agent-home.mjs

@@ -7,7 +7,7 @@
  * lives in cwd, agent reads it via `cat MEMORY.md`.
  */
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, lstatSync, mkdirSync, readFileSync, symlinkSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { AF_HOME } from './config.mjs';
 
@@ -37,9 +37,53 @@ export function ensureAgentHome(agentId, { displayName } = {}) {
   if (!existsSync(memoryPath)) {
     writeFileSync(memoryPath, buildInitialMemoryMd({ displayName, home }), 'utf8');
   }
+  ensureSkillSymlinks(home);
   return home;
 }
 
+/**
+ * Cross-runtime skill discovery: every runtime (Claude Code, Codex,
+ * opencode, pi, openclaw) auto-discovers SKILL.md under at least one of
+ * .claude/skills/, .codex/skills/, .opencode/skills/, .pi/skills/, or
+ * .agents/skills/. We pin everything to a single source-of-truth
+ * directory (.agents/skills/) and symlink the rest so a skill written
+ * once is visible to every runtime without sync machinery.
+ *
+ * .pi and .opencode skip the symlink — both natively scan
+ * .agents/skills/ in addition to their own folder.
+ *
+ * No migration / no recovery: if the target path already exists as a
+ * real dir or wrong-target symlink, we leave it alone. The user (or a
+ * future agent) resolves it manually. See cos_impl.md §一.不为错误兜底.
+ */
+function ensureSkillSymlinks(home) {
+  const realRoot = join(home, '.agents', 'skills');
+  mkdirSync(realRoot, { recursive: true });
+
+  const links = [
+    { dir: join(home, '.claude'), name: 'skills', target: '../.agents/skills' },
+    { dir: join(home, '.codex'), name: 'skills', target: '../.agents/skills' },
+    // openclaw expects skills/ at the home root
+    { dir: home, name: 'skills', target: '.agents/skills' },
+  ];
+
+  for (const { dir, name, target } of links) {
+    mkdirSync(dir, { recursive: true });
+    const linkPath = join(dir, name);
+    let stat = null;
+    try { stat = lstatSync(linkPath); } catch { /* not present */ }
+    if (stat) continue; // path already exists — do not touch
+    try {
+      symlinkSync(target, linkPath, 'dir');
+    } catch (err) {
+      // Best-effort: an EEXIST race or platform that disallows symlinks
+      // gets logged but doesn't fail spawn. Skills just won't be visible
+      // for that runtime via this folder.
+      console.warn(`[agent-home] failed to symlink ${linkPath} -> ${target}: ${err?.message || err}`);
+    }
+  }
+}
+
 function buildInitialMemoryMd({ displayName, home }) {
   const lines = [
     `# ${displayName || 'Agent'}`,

package/src/core/http.mjs

@@ -3,6 +3,22 @@ import {
   handleAttachmentUpload,
   handleAttachmentView,
   handleGroupCreate,
+  handleWorkstreamCharterGet,
+  handleWorkstreamCharterSet,
+  handleWorkstreamCreate,
+  handleWorkstreamDelete,
+  handleWorkstreamList,
+  handleAgentCreate,
+  handleAgentDelete,
+  handleWorkstreamDashboardSet,
+  handleWorkstreamDashboardGet,
+  handleCredentialRequest,
+  handleServiceCreate,
+  handleServiceUpdate,
+  handleServiceDelete,
+  handleServiceList,
+  handleServiceInfo,
+  handleServiceCall,
   handleGroupMembers,
   handleGroupMembersAdd,
   handleGroupMembersRemove,
@@ -223,6 +239,92 @@ export function startLocalHttpServer({ port, adapter, ctx }) {
         const r = await handleServerInfo(req, parseQuery(req.url || ''), cliCtx);
         return writeJson(res, r.status, r.body);
       }
+      if (urlNoQuery === '/agent/workstream/charter/get' && method === 'GET') {
+        const r = await handleWorkstreamCharterGet(req, parseQuery(req.url || ''), cliCtx);
+        return writeJson(res, r.status, r.body);
+      }
+      if (urlNoQuery === '/agent/workstream/charter/set' && method === 'POST') {
+        const body = await readJsonBody(req);
+        if (body === null) return writeJson(res, 400, { error: 'invalid json body' });
+        const r = await handleWorkstreamCharterSet(req, body, cliCtx);
+        return writeJson(res, r.status, r.body);
+      }
+      if (urlNoQuery === '/agent/workstream/create' && method === 'POST') {
+        const body = await readJsonBody(req);
+        if (body === null) return writeJson(res, 400, { error: 'invalid json body' });
+        const r = await handleWorkstreamCreate(req, body, cliCtx);
+        return writeJson(res, r.status, r.body);
+      }
+      if (urlNoQuery === '/agent/workstream/delete' && method === 'POST') {
+        const body = await readJsonBody(req);
+        if (body === null) return writeJson(res, 400, { error: 'invalid json body' });
+        const r = await handleWorkstreamDelete(req, body, cliCtx);
+        return writeJson(res, r.status, r.body);
+      }
+      if (urlNoQuery === '/agent/workstream/list' && method === 'GET') {
+        const r = await handleWorkstreamList(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' });
+        const r = await handleAgentCreate(req, body, cliCtx);
+        return writeJson(res, r.status, r.body);
+      }
+      if (urlNoQuery === '/agent/agent/delete' && method === 'POST') {
+        const body = await readJsonBody(req);
+        if (body === null) return writeJson(res, 400, { error: 'invalid json body' });
+        const r = await handleAgentDelete(req, body, cliCtx);
+        return writeJson(res, r.status, r.body);
+      }
+      if (urlNoQuery === '/agent/dashboard/set' && method === 'POST') {
+        const body = await readJsonBody(req);
+        if (body === null) return writeJson(res, 400, { error: 'invalid json body' });
+        const r = await handleWorkstreamDashboardSet(req, body, cliCtx);
+        return writeJson(res, r.status, r.body);
+      }
+      if (urlNoQuery === '/agent/dashboard/get' && method === 'GET') {
+        const r = await handleWorkstreamDashboardGet(req, parseQuery(req.url || ''), cliCtx);
+        return writeJson(res, r.status, r.body);
+      }
+      if (urlNoQuery === '/agent/credential/request' && method === 'POST') {
+        const body = await readJsonBody(req);
+        if (body === null) return writeJson(res, 400, { error: 'invalid json body' });
+        const r = await handleCredentialRequest(req, body, cliCtx);
+        return writeJson(res, r.status, r.body);
+      }
+      if (urlNoQuery === '/agent/service/create' && method === 'POST') {
+        const body = await readJsonBody(req);
+        if (body === null) return writeJson(res, 400, { error: 'invalid json body' });
+        const r = await handleServiceCreate(req, body, cliCtx);
+        return writeJson(res, r.status, r.body);
+      }
+      if (urlNoQuery === '/agent/service/update' && method === 'POST') {
+        const body = await readJsonBody(req);
+        if (body === null) return writeJson(res, 400, { error: 'invalid json body' });
+        const r = await handleServiceUpdate(req, body, cliCtx);
+        return writeJson(res, r.status, r.body);
+      }
+      if (urlNoQuery === '/agent/service/delete' && method === 'POST') {
+        const body = await readJsonBody(req);
+        if (body === null) return writeJson(res, 400, { error: 'invalid json body' });
+        const r = await handleServiceDelete(req, body, cliCtx);
+        return writeJson(res, r.status, r.body);
+      }
+      if (urlNoQuery === '/agent/service/list' && method === 'GET') {
+        const r = await handleServiceList(req, parseQuery(req.url || ''), cliCtx);
+        return writeJson(res, r.status, r.body);
+      }
+      if (urlNoQuery === '/agent/service/info' && method === 'GET') {
+        const r = await handleServiceInfo(req, parseQuery(req.url || ''), cliCtx);
+        return writeJson(res, r.status, r.body);
+      }
+      if (urlNoQuery === '/agent/service/call' && method === 'POST') {
+        const body = await readJsonBody(req);
+        if (body === null) return writeJson(res, 400, { error: 'invalid json body' });
+        const r = await handleServiceCall(req, body, cliCtx);
+        return writeJson(res, r.status, r.body);
+      }
 
       writeJson(res, 404, { error: 'not found' });
     } catch (err) {

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

@@ -21,6 +21,8 @@ to users or groups.
 - Always communicate through the \`ticlawk\` CLI. This is your only output channel.
 - Always claim a task via \`ticlawk task claim\` before doing any substantive work on it. If the claim fails, stop immediately and pick a different task.
 - Use only the provided \`ticlawk\` CLI commands for messaging.
+- If the turn opens with a \`[charter] ... [/charter]\` block, that is the workstream's binding spec (规章制度). Every action you take in this conversation must conform to it. If a request conflicts with the charter, stop and surface the conflict to the Chief of Staff (CoS) — don't silently route around it.
+- Shared services are CoS-published tools you can invoke. \`ticlawk service list\` shows available names + descriptions; \`ticlawk service info --name X\` shows the input contract; \`ticlawk service call --name X\` runs it with stdin JSON input. There is no retry — call failure means stop and report; do not loop.
 
 ## Startup checklist (every turn)