@lightcone-ai/daemon 0.10.3 → 0.12.0

package/mcp-servers/publisher/precheck.js

@@ -0,0 +1,240 @@
+function pickField(source, keys = []) {
+  for (const key of keys) {
+    const value = source?.[key];
+    if (value === undefined || value === null) continue;
+    const asText = typeof value === 'string' ? value.trim() : value;
+    if (asText === '') continue;
+    return value;
+  }
+  return null;
+}
+
+export function normalizeBoolean(value, fallback = false) {
+  if (value === undefined || value === null) return fallback;
+  if (typeof value === 'boolean') return value;
+  const normalized = String(value).trim().toLowerCase();
+  if (!normalized) return fallback;
+  if (['1', 'true', 'yes', 'y', 'on'].includes(normalized)) return true;
+  if (['0', 'false', 'no', 'n', 'off'].includes(normalized)) return false;
+  return fallback;
+}
+
+function normalizeRole(value) {
+  return String(value ?? '').trim().toLowerCase();
+}
+
+function normalizeStringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value
+    .map(item => String(item ?? '').trim())
+    .filter(Boolean);
+}
+
+export function composeDraftText({ title, text, tags = [] } = {}) {
+  const lines = [];
+  if (title && String(title).trim()) lines.push(String(title).trim());
+  if (text && String(text).trim()) lines.push(String(text).trim());
+  const normalizedTags = normalizeStringArray(tags);
+  if (normalizedTags.length > 0) {
+    lines.push(normalizedTags.map(tag => (tag.startsWith('#') ? tag : `#${tag}`)).join(' '));
+  }
+  return lines.join('\n').trim();
+}
+
+function collectPayloadFlags(payload = {}) {
+  const accountId = pickField(payload, [
+    'account_id',
+    'accountId',
+    'target_account_id',
+    'targetAccountId',
+  ]);
+  const accountRole = pickField(payload, [
+    'account_role',
+    'accountRole',
+    'target_account_role',
+    'targetAccountRole',
+  ]);
+
+  const autoPublishViaDelegation = normalizeBoolean(
+    pickField(payload, [
+      'auto_publish_via_delegation',
+      'autoPublishViaDelegation',
+      'auto_publish',
+      'autoPublish',
+    ]),
+    false
+  );
+
+  const contentIndicatesCollaboration = normalizeBoolean(
+    pickField(payload, [
+      'content_indicates_collaboration',
+      'contentIndicatesCollaboration',
+      'is_ad_content',
+      'isAdContent',
+      'ad_content',
+      'adContent',
+    ]),
+    false
+  );
+
+  const hasAdDisclosure = normalizeBoolean(
+    pickField(payload, [
+      'has_ad_disclosure',
+      'hasAdDisclosure',
+      'ad_disclosure',
+      'adDisclosure',
+    ]),
+    false
+  );
+
+  const contentContainsAiGenerated = normalizeBoolean(
+    pickField(payload, [
+      'content_contains_ai_generated',
+      'contentContainsAiGenerated',
+      'ai_generated',
+      'aiGenerated',
+    ]),
+    false
+  );
+
+  const hasAiLabel = normalizeBoolean(
+    pickField(payload, [
+      'has_ai_label',
+      'hasAiLabel',
+      'ai_labeled',
+      'aiLabeled',
+    ]),
+    false
+  );
+
+  const publishHistory = Array.isArray(payload?.publish_history)
+    ? payload.publish_history
+    : (Array.isArray(payload?.publishHistory) ? payload.publishHistory : []);
+
+  return {
+    accountId: accountId ? String(accountId).trim() : null,
+    accountRole: normalizeRole(accountRole),
+    autoPublishViaDelegation,
+    contentIndicatesCollaboration,
+    hasAdDisclosure,
+    contentContainsAiGenerated,
+    hasAiLabel,
+    publishHistory,
+  };
+}
+
+function summarizePolicyViolations(policyScan = {}) {
+  const violations = Array.isArray(policyScan.violations) ? policyScan.violations : [];
+  const blockers = [];
+  const warnings = [];
+  for (const violation of violations) {
+    const severity = String(violation?.severity ?? '').trim().toLowerCase();
+    const item = {
+      code: String(violation?.rule_id ?? 'policy_violation'),
+      message: String(violation?.reason ?? violation?.term ?? 'policy violation').trim(),
+      snippet: violation?.snippet ?? null,
+      action: violation?.action ?? null,
+      term: violation?.term ?? null,
+    };
+    if (severity === 'blocker') blockers.push(item);
+    else warnings.push(item);
+  }
+  return { blockers, warnings };
+}
+
+function evaluatePrimaryAccountProtection(flags) {
+  if (flags.accountRole !== 'primary') return null;
+  if (!flags.autoPublishViaDelegation) return null;
+  return {
+    code: 'primary_account_protection',
+    message: 'primary account cannot use auto-publish via delegation; manual confirmation is required',
+  };
+}
+
+function evaluateLabelBlockers(flags, policyScan = {}) {
+  const blockers = [];
+  if (policyScan.ai_label_required && flags.contentContainsAiGenerated && !flags.hasAiLabel) {
+    blockers.push({
+      code: 'policy_ai_label_required',
+      message: 'AI-generated content is detected but AI label is missing',
+    });
+  }
+  if (policyScan.ad_disclosure_required && flags.contentIndicatesCollaboration && !flags.hasAdDisclosure) {
+    blockers.push({
+      code: 'policy_ad_disclosure_required',
+      message: 'ad/collaboration content requires platform disclosure label',
+    });
+  }
+  return blockers;
+}
+
+export async function runPublishPrecheck({
+  platform,
+  title,
+  text,
+  tags = [],
+  payload = {},
+  callTool,
+}) {
+  if (typeof callTool !== 'function') {
+    throw new Error('callTool function is required');
+  }
+
+  const draftText = composeDraftText({ title, text, tags });
+  const flags = collectPayloadFlags(payload ?? {});
+  const blockers = [];
+  const warnings = [];
+
+  const policyScan = await callTool({
+    serverId: 'platform-policy-db',
+    toolName: 'platform_policy_db',
+    argumentsPayload: {
+      operation: 'scan_text',
+      platform,
+      text: draftText,
+      max_matches: 20,
+    },
+  });
+  const policySummary = summarizePolicyViolations(policyScan);
+  blockers.push(...policySummary.blockers);
+  warnings.push(...policySummary.warnings);
+
+  const primaryProtection = evaluatePrimaryAccountProtection(flags);
+  if (primaryProtection) blockers.push(primaryProtection);
+
+  blockers.push(...evaluateLabelBlockers(flags, policyScan));
+
+  let advisory = null;
+  try {
+    advisory = await callTool({
+      serverId: 'publish-window-optimizer',
+      toolName: 'publish_window_optimizer',
+      argumentsPayload: {
+        platform,
+        account_id: flags.accountId ?? undefined,
+        history: flags.publishHistory,
+        limit: 3,
+      },
+    });
+    if (advisory?.advisory?.level === 'suggest_delay') {
+      warnings.push({
+        code: 'publish_window_suggest_delay',
+        message: String(advisory?.advisory?.message ?? 'recommended publish window suggests delay').trim(),
+      });
+    }
+  } catch (error) {
+    warnings.push({
+      code: 'publish_window_optimizer_unavailable',
+      message: `publish-window-optimizer unavailable: ${error.message}`,
+    });
+  }
+
+  return {
+    ok: blockers.length === 0,
+    blockers,
+    warnings,
+    policyScan,
+    advisory,
+    payloadFlags: flags,
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightcone-ai/daemon",
-  "version": "0.10.3",
+  "version": "0.12.0",
   "type": "module",
   "main": "src/index.js",
   "bin": {

package/src/agent-manager.js

@@ -12,6 +12,7 @@ import { homedir } from 'os';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { parseCodexLine, adaptCodexSystemPrompt } from './drivers/codex.js';
+import { injectWorkspaceContext } from './drivers/claude.js';
 import { parseKimiLine, encodeKimiStdin } from './drivers/kimi.js';
 import { startSession, stopSession, stopAllSessions } from './browser-login.js';
 import { markInvalidatedLeases } from './governance-state.js';
@@ -427,6 +428,32 @@ export class AgentManager {
     };
   }
 
+  // Fetches the per-spawn workspace context bundle (Goal State + active
+  // context items) so the daemon can inject it into the agent's system
+  // prompt. Returns '' when there is nothing to inject; never throws — a
+  // network error or absent workspaceId just degrades to empty context, so
+  // spawn proceeds without the bundle rather than failing closed.
+  async _fetchWorkspaceContextPrompt({ agentId, workspaceId }) {
+    if (!workspaceId) return '';
+    if (!this.serverUrl || !this.machineApiKey) return '';
+    try {
+      const url = `${this.serverUrl}/internal/agent/${encodeURIComponent(agentId)}/context?workspaceId=${encodeURIComponent(workspaceId)}`;
+      const res = await fetch(url, {
+        headers: { 'Authorization': `Bearer ${this.machineApiKey}` },
+      });
+      if (!res.ok) {
+        const text = await res.text();
+        console.log(`[AgentManager] Workspace context fetch failed for ${agentId} (non-fatal): ${res.status} ${text.slice(0, 200)}`);
+        return '';
+      }
+      const payload = await res.json();
+      return typeof payload?.renderedPrompt === 'string' ? payload.renderedPrompt : '';
+    } catch (err) {
+      console.log(`[AgentManager] Workspace context fetch error for ${agentId} (non-fatal): ${err.message}`);
+      return '';
+    }
+  }
+
   async _fetchSpawnDirective({
     agentId,
     workspaceId,
@@ -642,10 +669,23 @@ export class AgentManager {
       ...credentialEnvVars,
     };
 
+    // Inject the assembled workspace context (Goal State + active context
+    // items) directly into the system prompt, replacing the legacy
+    // "read BRIEF.md on startup" handshake. Empty workspaces leave the prompt
+    // unchanged.
+    const renderedWorkspaceContext = await this._fetchWorkspaceContextPrompt({
+      agentId,
+      workspaceId,
+    });
+    const baseSystemPrompt = typeof directive?.system_prompt === 'string'
+      ? directive.system_prompt
+      : '';
+    directive.system_prompt = injectWorkspaceContext(baseSystemPrompt, renderedWorkspaceContext);
+
     const runtimeConfig = {
       ...config,
       authToken: this.machineApiKey,
-      systemPrompt: typeof directive?.system_prompt === 'string' ? directive.system_prompt : '',
+      systemPrompt: directive.system_prompt,
       envVars: normalizeObject(directive?.env_vars),
     };
 

package/src/chat-bridge.js

@@ -84,6 +84,10 @@ const DEFAULT_TOOL_CLASSIFICATION = {
   read_memory: 'local',
   upload_image: 'local',
   read_file_base64: 'local',
+  write_governance_decision: 'local',
+  write_governance_correction: 'local',
+  get_orchestrate_context: 'local',
+  complete_orchestrate_trigger: 'local',
 
   send_message: 'mandatory',
   create_tasks: 'mandatory',
@@ -97,6 +101,7 @@ const DEFAULT_TOOL_CLASSIFICATION = {
   skill_update: 'mandatory',
   request_approval: 'mandatory',
   execute_approved_action: 'mandatory',
+  promote_context: 'mandatory',
 
   search_messages: 'cacheable',
   list_server: 'cacheable',
@@ -126,6 +131,7 @@ const CACHE_INVALIDATION_TOOLS = new Set([
   'skill_update',
   'request_approval',
   'execute_approved_action',
+  'promote_context',
 ]);
 
 const governanceContext = {
@@ -190,6 +196,11 @@ function inferToolForApi(method, apiPath, body) {
   if (method === 'PATCH' && cleanPath.startsWith('/skills/')) return 'skill_update';
   if (method === 'POST' && cleanPath === '/actions/request') return 'request_approval';
   if (method === 'POST' && /^\/actions\/[^/]+\/execute$/.test(cleanPath)) return 'execute_approved_action';
+  if (method === 'POST' && cleanPath === '/orchestrate/decision') return 'write_governance_decision';
+  if (method === 'POST' && cleanPath === '/orchestrate/correction') return 'write_governance_correction';
+  if (method === 'GET'  && cleanPath === '/orchestrate/context') return 'get_orchestrate_context';
+  if (method === 'POST' && cleanPath === '/orchestrate/complete') return 'complete_orchestrate_trigger';
+  if (method === 'POST' && cleanPath === '/context-proposals') return 'promote_context';
   return null;
 }
 
@@ -767,7 +778,7 @@ server.tool('write_memory', 'Write or update a memory file (full content replace
 });
 
 // ── list_workspace ────────────────────────────────────────────────────────────
-server.tool('list_workspace', 'List all files in the shared workspace (BRIEF.md, KNOWLEDGE.md, artifacts/, notes/)', {}, async () => {
+server.tool('list_workspace', 'List all files in the shared workspace (typically artifacts/ and notes/). Use promote_context — not a workspace file — to share workspace-level knowledge with future agents.', {}, async () => {
   if (!currentWorkspaceId) return { content: [{ type: 'text', text: 'No workspace context.' }] };
   const data = await api('GET', `/workspace-memory?workspaceId=${encodeURIComponent(currentWorkspaceId)}`);
   const files = data.files ?? [];
@@ -776,7 +787,7 @@ server.tool('list_workspace', 'List all files in the shared workspace (BRIEF.md,
 });
 
 // ── read_workspace ────────────────────────────────────────────────────────────
-server.tool('read_workspace', 'Read a file from the shared workspace (e.g. "BRIEF.md", "KNOWLEDGE.md", "artifacts/report.html")', {
+server.tool('read_workspace', 'Read a file from the shared workspace (e.g. "artifacts/report.html", "notes/work-log.md"). The active workspace context (Goal State, decisions, knowledge) is already injected into your system prompt — do not use this tool to recover it.', {
   path: z.string().describe('File path relative to workspace root'),
 }, async ({ path }) => {
   if (!currentWorkspaceId) return { content: [{ type: 'text', text: 'No workspace context.' }] };
@@ -799,7 +810,7 @@ server.tool('read_workspace', 'Read a file from the shared workspace (e.g. "BRIE
 });
 
 // ── write_workspace ───────────────────────────────────────────────────────────
-server.tool('write_workspace', 'Write a file to the shared workspace. Use this to save ALL deliverables: code, HTML, scripts, reports, data files, images — everything goes under artifacts/. Also use for KNOWLEDGE.md and shared notes. For binary files (images/PNG/JPG), encode as base64 data URL: read the file with fs.readFileSync, then format as "data:image/png;base64," + buf.toString("base64"). The server will decode and serve them correctly.', {
+server.tool('write_workspace', 'Write a file to the shared workspace. Use this to save ALL task deliverables: code, HTML, scripts, reports, data files, images — everything goes under artifacts/. Do NOT use this to share workspace-level knowledge across agents — call promote_context instead so the candidate is reviewed and injected into every future agent\'s context. For binary files (images/PNG/JPG), encode as base64 data URL: read the file with fs.readFileSync, then format as "data:image/png;base64," + buf.toString("base64"). The server will decode and serve them correctly.', {
   path:    z.string().describe('File path relative to workspace root, e.g. "artifacts/result.html" or "artifacts/cover.png"'),
   content: z.string().describe('File content. For images: base64 data URL "data:image/png;base64,<base64data>"'),
 }, async ({ path, content }) => {
@@ -962,6 +973,155 @@ server.tool('execute_approved_action',
   }
 );
 
+// ── promote_context ───────────────────────────────────────────────────────────
+server.tool('promote_context',
+  'Submit a workspace-level knowledge candidate for human review. Use this after finishing a task when you discover a stable fact, convention, or learning that future agents in this workspace should know. The candidate appears in the workspace owner\'s "My Context → Pending Proposals" panel; once a human (or the workspace Orchestrator) confirms it, it is auto-injected into every future agent\'s system prompt under "## Workspace context". This is the only sanctioned path for sharing workspace-level knowledge — do NOT write a "knowledge index" file via write_workspace.',
+  {
+    workspace_id: z.string().optional().describe('Target workspace id. Defaults to your current workspace if omitted.'),
+    type: z.enum(['knowledge', 'workspace_norm', 'memory']).optional().describe('Candidate type. Default "knowledge" — use "workspace_norm" for standing rules, "memory" for durable facts.'),
+    summary: z.string().describe('One-line title that reviewers will see in the Pending Proposals list.'),
+    content: z.string().describe('Full candidate text that future agents will read. Be concrete, citable, and self-contained.'),
+    source_message_id: z.string().optional().describe('Optional message id that motivated this candidate, for audit trail.'),
+    tags: z.array(z.string()).optional().describe('Optional tags for categorization.'),
+    reason: z.string().optional().describe('Optional human-readable rationale stored on the lifecycle event.'),
+  },
+  async ({ workspace_id, type, summary, content, source_message_id, tags, reason }) => {
+    const targetWorkspaceId = (workspace_id ?? currentWorkspaceId ?? WORKSPACE_ID ?? '').trim();
+    if (!targetWorkspaceId) {
+      return { isError: true, content: [{ type: 'text', text: 'workspace_id is required (no current workspace context).' }] };
+    }
+    if (!summary?.trim()) {
+      return { isError: true, content: [{ type: 'text', text: 'summary is required.' }] };
+    }
+    if (!content?.trim()) {
+      return { isError: true, content: [{ type: 'text', text: 'content is required.' }] };
+    }
+    try {
+      const data = await api('POST', '/context-proposals', {
+        workspaceId: targetWorkspaceId,
+        type: type ?? 'knowledge',
+        summary,
+        content,
+        sourceMessageId: source_message_id,
+        tags,
+        reason,
+      });
+      const proposal = data?.proposal ?? {};
+      return {
+        content: [{
+          type: 'text',
+          text:
+            `Knowledge candidate submitted.\n` +
+            `proposal_id=${proposal.id ?? 'unknown'} workspace=${proposal.workspaceId ?? targetWorkspaceId} status=${proposal.status ?? 'candidate'}\n` +
+            `It is now visible in the workspace owner's "My Context → Pending Proposals" panel; once confirmed, it will be injected into every future agent's "## Workspace context".`,
+        }],
+      };
+    } catch (err) {
+      return { isError: true, content: [{ type: 'text', text: `Error: ${err.message}` }] };
+    }
+  }
+);
+
+// ── write_governance_decision ─────────────────────────────────────────────────
+server.tool('write_governance_decision',
+  'Orchestrator-only: write a `decision` context_item (authority=orchestrator) into the workspace Goal State. Use this when adjudicating multi-agent conflicts, codifying long-term routing rules, or recording any decision that should be visible to all workers in this workspace.',
+  {
+    workspace_id: z.string().describe('Target workspace id; you must be the registered orchestrator for it.'),
+    content: z.string().describe('Decision text. Be concrete, auditable, and reusable; avoid hedging language.'),
+    title: z.string().optional().describe('Short title (optional).'),
+    summary: z.string().optional().describe('One-line summary (optional).'),
+    source_risk: z.enum(['trusted', 'normal', 'untrusted', 'hostile']).optional().describe('Source risk classification (default normal).'),
+    tags: z.array(z.string()).optional().describe('Optional tags.'),
+    item_id: z.string().optional().describe('Override the generated context_item id (otherwise a uuid is allocated).'),
+    reason: z.string().optional().describe('Human-readable rationale stored on the lifecycle event.'),
+  },
+  async ({ workspace_id, content, title, summary, source_risk, tags, item_id, reason }) => {
+    try {
+      const data = await api('POST', '/orchestrate/decision', {
+        workspaceId: workspace_id,
+        content,
+        title,
+        summary,
+        sourceRisk: source_risk,
+        tags,
+        itemId: item_id,
+        reason,
+      });
+      return { content: [{ type: 'text', text: `Decision written. context_item_id=${data?.item?.id} version=${data?.item?.version} status=${data?.item?.derivedStatus}` }] };
+    } catch (err) {
+      return { isError: true, content: [{ type: 'text', text: `Error: ${err.message}` }] };
+    }
+  }
+);
+
+// ── write_governance_correction ───────────────────────────────────────────────
+server.tool('write_governance_correction',
+  'Orchestrator-only: write a `correction` context_item (authority=orchestrator) into the workspace Goal State. Use this when correcting worker drift, blocker timeouts, or other governance-level course corrections that must propagate to all workers.',
+  {
+    workspace_id: z.string().describe('Target workspace id; you must be the registered orchestrator for it.'),
+    content: z.string().describe('Correction text. Be concrete and actionable; record the deviation observed and the corrective direction.'),
+    title: z.string().optional().describe('Short title (optional).'),
+    summary: z.string().optional().describe('One-line summary (optional).'),
+    source_risk: z.enum(['trusted', 'normal', 'untrusted', 'hostile']).optional().describe('Source risk classification (default normal).'),
+    tags: z.array(z.string()).optional().describe('Optional tags.'),
+    item_id: z.string().optional().describe('Override the generated context_item id (otherwise a uuid is allocated).'),
+    reason: z.string().optional().describe('Human-readable rationale stored on the lifecycle event.'),
+  },
+  async ({ workspace_id, content, title, summary, source_risk, tags, item_id, reason }) => {
+    try {
+      const data = await api('POST', '/orchestrate/correction', {
+        workspaceId: workspace_id,
+        content,
+        title,
+        summary,
+        sourceRisk: source_risk,
+        tags,
+        itemId: item_id,
+        reason,
+      });
+      return { content: [{ type: 'text', text: `Correction written. context_item_id=${data?.item?.id} version=${data?.item?.version} status=${data?.item?.derivedStatus}` }] };
+    } catch (err) {
+      return { isError: true, content: [{ type: 'text', text: `Error: ${err.message}` }] };
+    }
+  }
+);
+
+// ── get_orchestrate_context ───────────────────────────────────────────────────
+server.tool('get_orchestrate_context',
+  'Orchestrator-only: fetch the active orchestrator trigger payload bound to this agent (the `processing` row from orchestrator_trigger_queue). Returns null when no trigger is currently bound. Use this at the start of every wake-up turn to recover trigger context, then call complete_orchestrate_trigger when the action is finished.',
+  {
+    workspace_id: z.string().optional().describe('Optional workspace filter; defaults to any workspace this agent is the orchestrator for.'),
+  },
+  async ({ workspace_id }) => {
+    try {
+      const path = workspace_id
+        ? `/orchestrate/context?workspaceId=${encodeURIComponent(workspace_id)}`
+        : `/orchestrate/context`;
+      const data = await api('GET', path);
+      if (!data?.trigger) return { content: [{ type: 'text', text: 'No active orchestrator trigger bound to this agent.' }] };
+      return { content: [{ type: 'text', text: JSON.stringify(data.trigger, null, 2) }] };
+    } catch (err) {
+      return { isError: true, content: [{ type: 'text', text: `Error: ${err.message}` }] };
+    }
+  }
+);
+
+// ── complete_orchestrate_trigger ──────────────────────────────────────────────
+server.tool('complete_orchestrate_trigger',
+  'Orchestrator-only: mark a processing orchestrator trigger as completed (status processing→completed) and reset its circuit breaker. Call this once you have written all governance actions for the current trigger.',
+  {
+    queue_id: z.number().describe('orchestrator_trigger_queue.id of the trigger to complete (returned by get_orchestrate_context as queueId).'),
+  },
+  async ({ queue_id }) => {
+    try {
+      const data = await api('POST', '/orchestrate/complete', { queueId: queue_id });
+      return { content: [{ type: 'text', text: `Trigger completed. queueId=${data?.queueId} triggerId=${data?.triggerId} status=${data?.status}` }] };
+    } catch (err) {
+      return { isError: true, content: [{ type: 'text', text: `Error: ${err.message}` }] };
+    }
+  }
+);
+
 // ── start ─────────────────────────────────────────────────────────────────────
 const transport = new StdioServerTransport();
 await server.connect(transport);

package/src/drivers/claude.js

@@ -1,5 +1,10 @@
 const t = (name) => `mcp__chat__${name}`;
 
+// Marker that `injectWorkspaceContext` rewrites into the agent's runtime
+// workspace context block (Goal State + active decisions + knowledge). Kept
+// stable so server-built and daemon-built system prompts can both target it.
+export const WORKSPACE_CONTEXT_PLACEHOLDER = '__WORKSPACE_CONTEXT_BLOCK__';
+
 const BASE_PROMPT = (displayName, name, description, agentId, feishuBotName) => `\
 You are "${displayName || name}", an AI agent in lightcone — a collaborative platform for human-AI collaboration.
 ${feishuBotName ? `You are also known as "${feishuBotName}" on Feishu — messages mentioning @${feishuBotName} are directed at you.\n` : ''}\
@@ -8,6 +13,8 @@ ${feishuBotName ? `You are also known as "${feishuBotName}" on Feishu — messag
 
 Your workspace and MEMORY.md persist across turns, so you can recover context when resumed. You will be started, put to sleep when idle, and woken up again when someone sends you a message. Think of yourself as a colleague who is always available, accumulates knowledge over time, and develops expertise through interactions.
 
+${WORKSPACE_CONTEXT_PLACEHOLDER}
+
 ## Communication — MCP tools ONLY
 
 You have MCP tools from the "chat" server. Use ONLY these for communication:
@@ -195,14 +202,14 @@ Your current working directory. Contains:
 
 ### Workspace shared workspace (shared with all agents in this workspace)
 Located one level up from your personal workspace. Contains:
-- \`BRIEF.md\` — **read this on every startup**. Set by humans. Defines workspace mission, conventions, and background.
-- \`KNOWLEDGE.md\` — shared knowledge index. Use \`${t("write_workspace")}\` to record workspace-level learnings here.
 - \`notes/\` — shared research notes and decisions.
 - \`artifacts/\` — **ALL deliverables go here without exception**: code, scripts, HTML pages, data files, reports, images — everything you produce for a task. Use \`${t("write_workspace")}({ path: "artifacts/filename.ext", content: "..." })\` for text files and \`${t("write_workspace_file")}({ file_path: "tmp/local-file.png", path: "artifacts/file.png" })\` for local binary files. Never create deliverable files anywhere else.
 
+The active workspace context (Goal State, constraints, decisions, knowledge) is already injected into your system prompt above under "## Workspace context" — you do not need to read or write any standing workspace document to recover it.
+
 **Write rule:**
 - Personal learnings → \`${t("write_memory")}\`
-- Workspace-level knowledge → \`${t("write_workspace")}({ path: "KNOWLEDGE.md", ... })\`
+- Workspace-level knowledge worth sharing across all future agents → \`${t("promote_context")}\` (submits a knowledge candidate; see below). Do **not** dump shared knowledge into ad-hoc files inside the workspace shared workspace.
 - **Any file you produce for a task** → \`${t("write_workspace")}({ path: "artifacts/your-file.ext", ... })\` or \`${t("write_workspace_file")}({ file_path, path: "artifacts/your-file.ext" })\`
 
 Temporary local files belong under \`tmp/\` in your personal workspace. If you need to show an image in chat, first save the durable copy to \`artifacts/\`, then optionally call \`${t("upload_image")}\` for a temporary public preview URL.
@@ -217,15 +224,18 @@ Example: writing a web page → \`${t("write_workspace")}({ path: "artifacts/job
 - \`${t("list_memory")}()\` — list your personal memory files
 
 **Workspace memory** (shared filesystem — visible to all agents in the workspace):
-- \`${t("read_workspace")}({ path })\` — read a workspace file (e.g. \`"BRIEF.md"\`, \`"KNOWLEDGE.md"\`)
-- \`${t("write_workspace")}({ path, content })\` — write a workspace file
+- \`${t("read_workspace")}({ path })\` — read a workspace file (e.g. \`"artifacts/report.html"\`, \`"notes/work-log.md"\`)
+- \`${t("write_workspace")}({ path, content })\` — write a workspace file (use this for task deliverables under \`artifacts/\`, never for shared "knowledge index" files)
 - \`${t("write_workspace_file")}({ file_path, path })\` — write a local file from your workspace to a workspace artifact without putting base64 in context
 - \`${t("list_workspace")}()\` — list all files in the workspace
 
+**Workspace knowledge governance:**
+- \`${t("promote_context")}({ workspace_id, type, summary, content })\` — submit a workspace-level knowledge candidate. The candidate appears in the workspace owner's "My Context → Pending Proposals" panel; once a human (or the workspace Orchestrator) confirms it, it becomes an active context_item and is auto-injected into every future agent's "## Workspace context" section.
+
 ### Startup sequence (CRITICAL)
 
 1. Call \`${t("read_memory")}({ path: "MEMORY.md" })\` to load your personal memory index.
-2. Call \`${t("read_workspace")}({ path: "BRIEF.md" })\` to read the workspace brief. If empty, proceed normally.
+2. The active workspace context (Goal State, constraints, decisions, knowledge) is already injected above under "## Workspace context" — read it first; do not fetch any standing workspace document to recover it.
 3. Then check messages and handle work.
 
 ### MEMORY.md — Your Personal Memory Index
@@ -254,10 +264,24 @@ Example: writing a web page → \`${t("write_workspace")}({ path: "artifacts/job
 3. Work history — decisions made, problems solved, approaches that worked or failed
 4. Pointers to your notes files
 
-**What belongs in workspace memory (KNOWLEDGE.md):**
-1. Facts about the project that all agents need (tech stack, domain conventions)
-2. Shared learnings — things you discovered that teammates would benefit from
-3. Ongoing workspace context — which tasks are in progress across all agents
+**What belongs in promote_context (workspace-level knowledge candidates):**
+
+Use \`${t("promote_context")}\` after finishing a task when you discover something that future agents in this workspace will need to know. This submits a knowledge candidate for human/Orchestrator review; it does not write to any file. Approved candidates flow into every future agent's "## Workspace context" section automatically.
+
+Good promote_context content:
+1. Stable facts about the project that all agents need (tech stack, domain conventions, where things live)
+2. Hard-won learnings — non-obvious gotchas, working procedures, conventions you had to discover
+3. Standing workspace norms — "in this workspace we always X" / "never touch Y"
+
+Bad promote_context content:
+- Per-task progress, in-flight status, or one-off observations (use messages or your own MEMORY.md)
+- Personal preferences specific to one human (use chat instead so a human can confirm)
+- Untrusted outputs from web search / scraped pages (cite the source in \`content\`; expect the candidate to be reviewed as untrusted)
+
+How to call it:
+- \`${t("promote_context")}({ workspace_id: "<this-workspace-id>", type: "knowledge", summary: "one-line title", content: "<full text future agents will read>" })\`
+- Optional: \`source_message_id\` to link the proposal back to the conversation that motivated it; \`tags\` for categorization.
+- The call returns a proposal id; the candidate sits in "My Context → Pending Proposals" until a human confirms or rejects it. Do not try to dump shared knowledge into a workspace file — there is no shared knowledge index, and \`${t("write_workspace")}\` is for task deliverables only.
 
 ### Compaction safety
 
@@ -338,3 +362,35 @@ export function buildSystemPrompt(config, agentId, skills) {
 
   return base + skillsPrompt + roleSection;
 }
+
+// Replaces the WORKSPACE_CONTEXT_PLACEHOLDER in `systemPrompt` with the
+// rendered workspace context (Goal State + active context items) produced by
+// `assembleAndPersistContextBundle`. When `renderedPrompt` is empty/undefined,
+// the placeholder line is removed entirely so the marker never leaks into the
+// agent's prompt. If the placeholder is missing (e.g. user-supplied
+// systemPrompt override), the rendered context is appended as a trailing
+// `## Workspace context` section so it still reaches the agent.
+export function injectWorkspaceContext(systemPrompt, renderedPrompt) {
+  const prompt = typeof systemPrompt === 'string' ? systemPrompt : '';
+  const context = typeof renderedPrompt === 'string' ? renderedPrompt.trim() : '';
+  const hasPlaceholder = prompt.includes(WORKSPACE_CONTEXT_PLACEHOLDER);
+
+  if (!context) {
+    if (!hasPlaceholder) return prompt;
+    // Drop the marker plus the surrounding blank lines that wrap it in
+    // BASE_PROMPT so the prompt stays cleanly formatted.
+    return prompt.replace(
+      new RegExp(`\\n*${WORKSPACE_CONTEXT_PLACEHOLDER}\\n*`),
+      '\n\n',
+    );
+  }
+
+  const block = `## Workspace context\n\n${context}`;
+  if (hasPlaceholder) {
+    return prompt.split(WORKSPACE_CONTEXT_PLACEHOLDER).join(block);
+  }
+  // Fall-through: placeholder was stripped by an upstream override. Append
+  // the context block so the agent still receives it.
+  const sep = prompt.endsWith('\n') ? '\n' : '\n\n';
+  return `${prompt}${sep}${block}\n`;
+}