@lightcone-ai/daemon 0.7.2 → 0.8.0

package/package.json

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

package/src/agent-manager.js

@@ -1,5 +1,5 @@
 import { spawn } from 'child_process';
-import { mkdirSync, statSync } from 'fs';
+import { mkdirSync, statSync, writeFileSync, readdirSync, unlinkSync } from 'fs';
 import { homedir } from 'os';
 import path from 'path';
 import { buildSystemPrompt } from './drivers/claude.js';
@@ -40,14 +40,36 @@ export class AgentManager {
 
   // ── private ───────────────────────────────────────────────────────────────
 
+  _teamWorkspaceDir(teamId) {
+    const dir = path.join(homedir(), '.lightcone', 'workspace', teamId ?? '_global');
+    mkdirSync(path.join(dir, 'artifacts'), { recursive: true });
+    mkdirSync(path.join(dir, 'notes'), { recursive: true });
+    return dir;
+  }
+
   _workspaceDir(agentId, teamId) {
-    const dir = teamId
-      ? path.join(homedir(), '.lightcone', 'agents', teamId, agentId)
-      : path.join(homedir(), '.lightcone', 'agents', agentId);
+    const dir = path.join(homedir(), '.lightcone', 'workspace', teamId ?? '_global', agentId);
     mkdirSync(dir, { recursive: true });
     return dir;
   }
 
+  _materializeSkills(workspaceDir, skills) {
+    const skillsDir = path.join(workspaceDir, '.skills');
+    mkdirSync(skillsDir, { recursive: true });
+    // Remove stale skill files
+    try {
+      for (const f of readdirSync(skillsDir)) {
+        unlinkSync(path.join(skillsDir, f));
+      }
+    } catch { /* ignore */ }
+    // Write each skill with content
+    for (const skill of skills) {
+      if (!skill.content) continue;
+      const filename = skill.name.replace(/[^a-zA-Z0-9_-]/g, '-') + '.md';
+      writeFileSync(path.join(skillsDir, filename), `# ${skill.name}\n\n${skill.content}\n`);
+    }
+  }
+
   _formatDeliveryText(message) {
     return `New message in ${message.team_type === 'dm' ? 'dm from' : `#${message.team_name} from`} ${message.sender_name}: ${message.content}`;
   }
@@ -70,15 +92,15 @@ export class AgentManager {
     this.starting.add(key);
 
     const runtime = config.runtime ?? 'claude';
+    const teamWorkspaceDir = this._teamWorkspaceDir(teamId);
     const workspaceDir = this._workspaceDir(agentId, teamId);
     const chatBridgePath = new URL('./chat-bridge.js', import.meta.url).pathname;
     const startupMsg = runtime === 'codex' ? this._takePendingMessage(key) : null;
 
-    // Fetch skills index for system prompt + MCP derivation (non-blocking on failure)
+    // Fetch skills for system prompt + MCP derivation (non-blocking on failure)
     let skills = [];
     try {
-      const chParam = teamId ? `?teamId=${encodeURIComponent(teamId)}` : '';
-      const res = await fetch(`${this.serverUrl}/internal/agent/${agentId}/skills${chParam}`, {
+      const res = await fetch(`${this.serverUrl}/internal/agent/${agentId}/skills`, {
         headers: { 'Authorization': `Bearer ${this.machineApiKey}` },
       });
       if (res.ok) skills = await res.json();
@@ -86,6 +108,9 @@ export class AgentManager {
       console.log(`[AgentManager] Skills fetch failed for ${agentId} (non-fatal): ${err.message}`);
     }
 
+    // Materialize bound skills into .skills/ directory
+    this._materializeSkills(workspaceDir, skills);
+
     let proc;
 
     if (runtime === 'kimi') {

package/src/chat-bridge.js

@@ -260,10 +260,42 @@ server.tool('write_memory', 'Write or update a memory file (full content replace
   return { content: [{ type: 'text', text: `Saved ${path}` }] };
 });
 
+// ── list_team_memory ──────────────────────────────────────────────────────────
+server.tool('list_team_memory', 'List all files in the shared team workspace (BRIEF.md, KNOWLEDGE.md, artifacts/, notes/)', {}, async () => {
+  if (!currentTeamId) return { content: [{ type: 'text', text: 'No team context.' }] };
+  const data = await api('GET', `/team-memory?teamId=${encodeURIComponent(currentTeamId)}`);
+  const files = data.files ?? [];
+  if (files.length === 0) return { content: [{ type: 'text', text: 'Team workspace is empty.' }] };
+  return { content: [{ type: 'text', text: files.map(f => f.path).join('\n') }] };
+});
+
+// ── read_team_memory ──────────────────────────────────────────────────────────
+server.tool('read_team_memory', 'Read a file from the shared team workspace (e.g. "BRIEF.md", "KNOWLEDGE.md", "notes/decisions.md")', {
+  path: z.string().describe('File path relative to team workspace root'),
+}, async ({ path }) => {
+  if (!currentTeamId) return { content: [{ type: 'text', text: 'No team context.' }] };
+  try {
+    const data = await api('GET', `/team-memory?path=${encodeURIComponent(path)}&teamId=${encodeURIComponent(currentTeamId)}`);
+    return { content: [{ type: 'text', text: data.content }] };
+  } catch (err) {
+    if (err.message.includes('404')) return { content: [{ type: 'text', text: `(empty — ${path} has no content yet)` }] };
+    throw err;
+  }
+});
+
+// ── write_team_memory ─────────────────────────────────────────────────────────
+server.tool('write_team_memory', 'Write a file to the shared team workspace. Use for team-level knowledge (KNOWLEDGE.md), shared notes, and completed artifacts.', {
+  path:    z.string().describe('File path relative to team workspace root, e.g. "KNOWLEDGE.md" or "artifacts/report.md"'),
+  content: z.string().describe('Full file content to store'),
+}, async ({ path, content }) => {
+  if (!currentTeamId) return { content: [{ type: 'text', text: 'No team context.' }] };
+  await api('PUT', `/team-memory?path=${encodeURIComponent(path)}&teamId=${encodeURIComponent(currentTeamId)}`, { content });
+  return { content: [{ type: 'text', text: `Saved to team workspace: ${path}` }] };
+});
+
 // ── skill_list ───────────────────────────────────────────────────────────────
 server.tool('skill_list', 'List all skills available to you (platform + bound). Returns index only (name + description), not full content.', {}, async () => {
-  const chParam = currentTeamId ? `?teamId=${encodeURIComponent(currentTeamId)}` : '';
-  const skills = await api('GET', `/skills${chParam}`);
+  const skills = await api('GET', `/skills`);
   if (!skills || skills.length === 0) return { content: [{ type: 'text', text: 'No skills available.' }] };
   const lines = skills.map(s => `- [${s.type}] **${s.name}** — ${s.description}`);
   return { content: [{ type: 'text', text: lines.join('\n') }] };
@@ -283,16 +315,14 @@ server.tool('skill_read', 'Read the full content of a skill by name or ID', {
 });
 
 // ── skill_create ─────────────────────────────────────────────────────────────
-server.tool('skill_create', 'Create a new reusable skill from what you have learned. Auto-binds to the current team.', {
+server.tool('skill_create', 'Create a new reusable skill from what you have learned. Auto-binds to this agent.', {
   name:        z.string().describe('Short skill name (lowercase, hyphens ok), e.g. "xhs-posting"'),
   description: z.string().describe('One-line description of what this skill covers'),
   content:     z.string().describe('Full skill content in markdown — procedures, steps, tips'),
   tags:        z.array(z.string()).optional().describe('Optional tags for categorization'),
 }, async ({ name, description, content, tags }) => {
-  const body = { name, description, content, tags: tags ?? [] };
-  if (currentTeamId) body.teamId = currentTeamId;
-  const result = await api('POST', '/skills', body);
-  return { content: [{ type: 'text', text: `Skill "${result.name}" created and bound to current team.` }] };
+  const result = await api('POST', '/skills', { name, description, content, tags: tags ?? [] });
+  return { content: [{ type: 'text', text: `Skill "${result.name}" created and bound to this agent.` }] };
 });
 
 // ── skill_update ─────────────────────────────────────────────────────────────

package/src/drivers/claude.js

@@ -26,7 +26,7 @@ You have MCP tools from the "chat" server. Use ONLY these for communication:
 12. **${t("view_file")}** — Download an attached image by its attachment ID so you can view it. Use when messages contain image attachments.
 
 CRITICAL RULES:
-- Always communicate through ${t("send_message")}. This is your only output channel.
+- Always communicate through ${t("send_message")}. This is your only output method.
 - Use only the provided MCP tools for messaging — they are already available and ready.
 - Always claim a task via ${t("claim_tasks")} before starting work on it. If the claim fails, move on to a different task.
 
@@ -188,30 +188,58 @@ When writing a URL next to non-ASCII punctuation (Chinese, Japanese, etc.), alwa
 - You have full filesystem access via Bash, Read, Write, Edit tools.
 - The shared web server public directory is: \`/home/ubuntu/lightcone/public/\`
 - Write web app files directly there so they are served immediately.
-- Your current working directory is a temporary workspace for code, scripts, and build artifacts.
 
-## Workspace & Memory
+## Workspace Structure
 
-Your memory is stored on the server and persists across machines and restarts. Use these MCP tools:
+Your workspace is organized in two layers:
 
-- \`${t("read_memory")}({ path })\` — read a memory file (e.g. \`"MEMORY.md"\`, \`"notes/work-log.md"\`)
-- \`${t("write_memory")}({ path, content })\` — save a memory file (full replace)
-- \`${t("list_memory")}()\` — list all your memory files
+### Personal workspace (this team only)
+Your current working directory. Contains:
+- \`MEMORY.md\` — your memory index for this team context (managed via \`${t("read_memory")}\` / \`${t("write_memory")}\`)
+- \`notes/\` — your personal notes for this team
+- \`tmp/\` — in-progress work files
+- \`.skills/\` — **read-only**, system-injected skill files. Each \`.md\` file is a skill bound to you. Read them with your Read tool — they are already on disk.
 
-### MEMORY.md — Your Memory Index (CRITICAL)
+### Team shared workspace (shared with all agents in this team)
+Located one level up from your personal workspace. Contains:
+- \`BRIEF.md\` — **read this on every startup**. Set by humans. Defines team mission, conventions, and background.
+- \`KNOWLEDGE.md\` — shared knowledge index. Use \`${t("write_team_memory")}\` to record team-level learnings here.
+- \`notes/\` — shared research notes and decisions.
+- \`artifacts/\` — completed team outputs (images, documents, reports). Move finished work here.
 
-\`MEMORY.md\` is the **entry point** to all your knowledge. It is the first file read on every startup (including after context compression). Structure it as an index that points to everything you know.
+**Write rule:** personal learnings → \`${t("write_memory")}\`. Team-level knowledge → \`${t("write_team_memory")}\`. Finished files → \`artifacts/\` via \`${t("write_team_memory")}\`.
+
+## Memory MCP tools
+
+**Personal memory** (per-agent, per-team — stored server-side):
+- \`${t("read_memory")}({ path })\` — read a personal memory file (e.g. \`"MEMORY.md"\`)
+- \`${t("write_memory")}({ path, content })\` — save a personal memory file (full replace)
+- \`${t("list_memory")}()\` — list your personal memory files
+
+**Team memory** (shared filesystem — visible to all agents in the team):
+- \`${t("read_team_memory")}({ path })\` — read a team workspace file (e.g. \`"BRIEF.md"\`, \`"KNOWLEDGE.md"\`)
+- \`${t("write_team_memory")}({ path, content })\` — write a team workspace file
+- \`${t("list_team_memory")}()\` — list all files in the team workspace
+
+### Startup sequence (CRITICAL)
+
+1. Call \`${t("read_memory")}({ path: "MEMORY.md" })\` to load your personal memory index.
+2. Call \`${t("read_team_memory")}({ path: "BRIEF.md" })\` to read the team brief. If empty, proceed normally.
+3. Then check messages and handle work.
+
+### MEMORY.md — Your Personal Memory Index
+
+\`MEMORY.md\` is re-read after every context compression. It must be self-sufficient as a recovery point.
 
 \`\`\`markdown
 # <Your Name>
 
 ## Role
-<your role definition, evolved over time>
+<your role in this team, evolved over time>
 
 ## Key Knowledge
-- Read notes/user-preferences.md for user preferences and conventions
-- Read notes/teams.md for what each team is about and ongoing work
-- Read notes/domain.md for domain-specific knowledge and conventions
+- Read notes/work-log.md for decisions and completed work
+- Read notes/domain.md for domain-specific knowledge
 - ...
 
 ## Active Context
@@ -219,38 +247,20 @@ Your memory is stored on the server and persists across machines and restarts. U
 - Last interaction: <brief summary>
 \`\`\`
 
-### What to memorize
-
-**Actively observe and record** the following kinds of knowledge as you encounter them in conversations:
-
-1. **User preferences** — How the user likes things done, communication style, coding conventions, tool preferences, recurring patterns in their requests.
-2. **World/project context** — The project structure, tech stack, architectural decisions, team conventions, deployment patterns.
-3. **Domain knowledge** — Domain-specific terminology, conventions, best practices you learn through tasks.
-4. **Work history** — What has been done, decisions made and why, problems solved, approaches that worked or failed.
-5. **Team context** — What each team is about, who participates, what's being discussed, ongoing tasks per team.
-6. **Other agents** — What other agents do, their specialties, collaboration patterns, how to work with them effectively.
-
-### How to organize memory
-
-- **MEMORY.md** is always the index. Keep it concise but comprehensive as a table of contents.
-- Create a \`notes/\` directory for detailed knowledge files. Use descriptive names:
-  - \`notes/user-preferences.md\` — User's preferences and conventions
-  - \`notes/teams.md\` — Summary of each team and its purpose
-  - \`notes/work-log.md\` — Important decisions and completed work
-  - \`notes/<domain>.md\` — Domain-specific knowledge
-- You can also create any other files or directories for your work (scripts, notes, data, etc.)
-- **Update notes proactively** — Don't wait to be asked. When you learn something important, write it down.
-- **Keep MEMORY.md current** — After updating notes, update the index in MEMORY.md if new files were added.
-- Do NOT store memory as local files — always use \`${t("write_memory")}\` so it persists server-side.
+**What belongs in personal memory:**
+1. Your role and how it has evolved in this team
+2. User preferences and communication style
+3. Work history — decisions made, problems solved, approaches that worked or failed
+4. Pointers to your notes files
 
-### Compaction safety (CRITICAL)
+**What belongs in team 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 team context — which tasks are in progress across all agents
 
-Your context will be periodically compressed to stay within limits. When this happens, you lose your in-context conversation history but MEMORY.md is always re-read. Therefore:
+### Compaction safety
 
-- **MEMORY.md must be self-sufficient as a recovery point.** After reading it, you should be able to understand who you are, what you know, and what you were working on.
-- **Before a long task**, write a brief "Active Context" note in MEMORY.md so you can resume if interrupted mid-task.
-- **After completing work**, update your notes and MEMORY.md index so nothing is lost.
-- Keep MEMORY.md complete enough that context compression preserves: which team is about what, what tasks are in progress, what the user has asked for, and what other agents are doing.
+Before a long task, write a brief "Active Context" note in MEMORY.md. After completing work, update notes and MEMORY.md so nothing is lost after compression.
 
 ## Capabilities