feat: shared Agent Memory — write path + cross-agent injection

- collect_memory: parse shared/tags from memory frontmatter, pass to API
- inject_memory: fetch shared memories matching task labels, inject
  as "Shared Team Knowledge" section alongside own memories
- AgentMemory interface: add agent_name, shared, tags fields
- putAgentMemory: accept shared and tags parameters

Agents can now write shared: true in memory frontmatter to share
knowledge across the team, with tag-based pinpoint injection.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: recuu-pfeg

src/agent-templates.ts

@@ -1035,24 +1035,52 @@ ${outputFormat}`;
             } catch { /* non-fatal */ }
           }
 
-          // Inject agent memories
+          // Inject agent memories + shared memories
           const memories = await ctx.api.fetchAgentMemories(ctx.agentName);
-          if (memories.length > 0) {
+          // Fetch shared memories matching task labels
+          const taskLabels: string[] = (() => {
+            const raw = (ctx.task as Record<string, unknown>).labels;
+            if (Array.isArray(raw)) return raw;
+            if (typeof raw === "string") { try { return JSON.parse(raw); } catch { return []; } }
+            return [];
+          })();
+          let sharedMemories: AgentMemory[] = [];
+          try {
+            const res = await fetch(`${ctx.config.apiUrl}/api/v1/agents/memories/shared${taskLabels.length ? `?tags=${taskLabels.join(",")}` : ""}`, {
+              headers: { Authorization: `Bearer ${ctx.config.apiKey}`, "Content-Type": "application/json" },
+            });
+            if (res.ok) {
+              const data = (await res.json()) as { memories: AgentMemory[] };
+              // Exclude own memories (already in `memories`)
+              const ownKeys = new Set(memories.map((m) => m.key));
+              sharedMemories = data.memories.filter((m) => !ownKeys.has(m.key));
+            }
+          } catch { /* non-fatal */ }
+
+          const allMemories = [...memories, ...sharedMemories];
+          if (allMemories.length > 0) {
+            const ownBlock = memories.length > 0
+              ? memories.map((m) => `## ${m.type}: ${m.key}\n${m.content}`).join("\n\n")
+              : "";
+            const sharedBlock = sharedMemories.length > 0
+              ? `\n# Shared Team Knowledge\n\n${sharedMemories.map((m) => `## ${m.type}: ${m.key} (from @${m.agent_name})\n${m.content}`).join("\n\n")}`
+              : "";
             const memoryBlock = [
               "<!-- TOBAN_MEMORY_START -->",
               "# Agent Memory (auto-injected by Toban)",
               "",
-              ...memories.map((m) => `## ${m.type}: ${m.key}\n${m.content}`),
+              ownBlock,
+              sharedBlock,
               "<!-- TOBAN_MEMORY_END -->",
-            ].join("\n");
+            ].filter(Boolean).join("\n");
 
             let existing = fs.existsSync(claudeMdPath)
               ? fs.readFileSync(claudeMdPath, "utf-8")
               : "";
             // Remove existing memory block to prevent duplicates
             existing = existing.replace(/<!-- TOBAN_MEMORY_START -->[\s\S]*?<!-- TOBAN_MEMORY_END -->\n?/g, "").trimEnd();
             fs.writeFileSync(claudeMdPath, existing + "\n\n" + memoryBlock + "\n");
-            injected = memories.length;
+            injected = allMemories.length;
           }
 
           // Mark CLAUDE.md as assume-unchanged so inject_memory additions don't get committed
@@ -1113,7 +1141,13 @@ ${outputFormat}`;
               const memType = getType[1].trim();
               if (!["identity", "feedback", "project", "reference"].includes(memType)) continue;
 
-              await ctx.api.putAgentMemory(ctx.agentName, key, { type: memType, content: body });
+              // Parse optional shared and tags from frontmatter
+              const getShared = frontmatter.match(/^shared:\s*(true|false)$/m);
+              const getTags = frontmatter.match(/^tags:\s*(.+)$/m);
+              const shared = getShared?.[1] === "true";
+              const tags = getTags?.[1]?.trim() || undefined;
+
+              await ctx.api.putAgentMemory(ctx.agentName, key, { type: memType, content: body, shared, tags });
               saved++;
             } catch {
               // Skip unparseable files

src/api-client.ts

@@ -75,6 +75,9 @@ export interface AgentMemory {
   key: string;
   type: string;
   content: string;
+  agent_name?: string;
+  shared?: boolean;
+  tags?: string;
 }
 
 export interface ApiClient {
@@ -100,7 +103,7 @@ export interface ApiClient {
   fetchMySecrets(): Promise<Record<string, string>>;
   fetchApiDocs(agentName: string): Promise<string>;
   fetchAgentMemories(agentName: string): Promise<AgentMemory[]>;
-  putAgentMemory(agentName: string, key: string, data: { type: string; content: string }): Promise<void>;
+  putAgentMemory(agentName: string, key: string, data: { type: string; content: string; shared?: boolean; tags?: string }): Promise<void>;
   fetchRelevantFailures(): Promise<Array<{ summary: string; failure_type: string; agent_name: string | null; created_at: string }>>;
   recordFailure(data: { task_id: string; failure_type: string; summary: string; agent_name?: string; sprint?: number; review_comment?: string; files_involved?: string }): Promise<void>;
 }
@@ -313,7 +316,7 @@ export function createApiClient(apiUrl: string, apiKey: string): ApiClient {
       }
     },
 
-    async putAgentMemory(agentName: string, key: string, data: { type: string; content: string }): Promise<void> {
+    async putAgentMemory(agentName: string, key: string, data: { type: string; content: string; shared?: boolean; tags?: string }): Promise<void> {
       try {
         await fetch(`${apiUrl}/api/v1/agents/${encodeURIComponent(agentName)}/memories/${encodeURIComponent(key)}`, {
           method: "PUT",