@rubytech/create-sitedesk-code 0.1.529 → 0.1.531

package/payload/platform/plugins/memory/PLUGIN.md

@@ -1,6 +1,6 @@
 ---
 name: memory
-description: "Graph memory plugin. Provides memory-search (with optional `fields` projection for known-shape lookups), memory-write, memory-update, memory-edge (create/delete typed directed edges between pre-existing nodes), memory-update-by-name (repair surface that resolves an elementId from a (label, name, accountId) tuple when search cannot return one), memory-lookup-by-name (deterministic read surface that returns nodes by case-insensitive exact `name` match — a Person, which carries no `name`, is matched on its composed `givenName` + `familyName` display name instead — optionally constrained by labels, bypassing the memory-search ranking stack so a present entity is never missed because a diluted query ranked it below the cut), and the :Report surface (memory-report-write / memory-report-read-latest / memory-report-list) for reading from, writing to, and updating the Neo4j knowledge graph. Includes conversational memory — organic preference learning, evidence-backed recall, and transparent 'what do you know about me?' responses. Document ingestion goes through memory-ingest; the dispatched specialist produces typed-section JSON in-turn from the loaded ontology. Operator-solicited reclassify of an already-stored thread-shaped KD (today: email-thread KDs) is exposed as `kd-classify <attachmentId>` — runs a body-growth gate (proceed iff body grew ≥25% since the last classify, or first-ever classify), stages the body to a temp file under `$ACCOUNT_DIR/tmp/`, and returns a dispatch envelope for the `librarian`; on success `memory-ingest` replaces the prior :Section children and stamps `lastClassifiedAt` + `lastClassifiedBodyLength` on the parent KD. Two modes: `document` (default) for unstructured PDF/web content → :KnowledgeDocument (keyed on `attachmentId`) + :Section, and `chat` for conversation transcripts → :ConversationArchive (keyed on `conversationIdentity`) + :Section chunks; two parent labels, two writer paths chosen by which identity property is set. Conversation-archive Phase 2 splits across two read-only tools: `conversation-archive-list-chunks` pages chunk bodies for the dispatched specialist to read in-turn; `conversation-archive-derive-insights` converts the specialist's per-chunk claims into operator-facing proposals with per-kind cypher. `conversation-archive-enrich-rejection` records (or undoes) durable per-row rejections so already-triaged claims do not re-surface on re-runs. Ships five skills: `conversational-memory`, `document-ingest`, `conversation-archive` (source-agnostic transcript ingest for WhatsApp, Telegram, Signal, LinkedIn DMs, Zoom, meeting minutes, iMessage, Slack), `conversation-archive-mcp` (operator-initiated MCP-driven ingest for Granola, Otter, Circleback meetings — sibling of `conversation-archive` sharing the same writer surface and identity formula), and `conversation-archive-enrich` (per-row operator-gated insight derivation over a named archive's chunks). Ships three thinking-tool skills: `challenge` (adversarial retrieval — strongest counter-evidence from the graph for a given claim), `connect` (bridge-finding between two topics via shared graph neighbors), and `emerge` (clusters uncategorised KnowledgeDocument and Section nodes into operator-approved Concept proposals)."
+description: "Graph memory plugin. Provides memory-search (with optional `fields` projection for known-shape lookups), memory-write, memory-update, memory-edge (create/delete typed directed edges between pre-existing nodes), memory-update-by-name (repair surface that resolves an elementId from a (label, name, accountId) tuple when search cannot return one), memory-lookup-by-name (deterministic read surface that returns nodes by case-insensitive exact `name` match — a Person, which carries no `name`, is matched on its composed `givenName` + `familyName` display name instead — optionally constrained by labels, bypassing the memory-search ranking stack so a present entity is never missed because a diluted query ranked it below the cut), and the :Report surface (memory-report-write / memory-report-read-latest / memory-report-list) for reading from, writing to, and updating the Neo4j knowledge graph. Includes conversational memory — organic preference learning, evidence-backed recall, and transparent 'what do you know about me?' responses. Document ingestion goes through memory-ingest; the dispatched specialist produces typed-section JSON in-turn from the loaded ontology. Operator-solicited reclassify of an already-stored thread-shaped KD (today: email-thread KDs) is exposed as `kd-classify <attachmentId>` — runs a body-growth gate (proceed iff body grew ≥25% since the last classify, or first-ever classify), stages the body to a temp file under `$ACCOUNT_DIR/tmp/`, and returns a dispatch envelope for the `librarian`; on success `memory-ingest` replaces the prior :Section children and stamps `lastClassifiedAt` + `lastClassifiedBodyLength` on the parent KD. Two modes: `document` (default) for unstructured PDF/web content → :KnowledgeDocument (keyed on `attachmentId`) + :Section, and `chat` for conversation transcripts → :ConversationArchive (keyed on `conversationIdentity`) + :Section chunks; two parent labels, two writer paths chosen by which identity property is set. Conversation-archive Phase 2 splits across two read-only tools: `conversation-archive-list-chunks` pages chunk bodies for the dispatched specialist to read in-turn; `conversation-archive-derive-insights` converts the specialist's per-chunk claims into operator-facing proposals with per-kind cypher. `conversation-archive-enrich-rejection` records (or undoes) durable per-row rejections so already-triaged claims do not re-surface on re-runs. Ships five skills: `conversational-memory`, `document-ingest`, `conversation-archive` (source-agnostic transcript ingest for WhatsApp, Telegram, Signal, LinkedIn DMs, Zoom, meeting minutes, iMessage, Slack), `conversation-archive-mcp` (operator-initiated MCP-driven ingest for Granola, Otter, Circleback meetings — sibling of `conversation-archive` sharing the same writer surface and identity formula), and `conversation-archive-enrich` (per-row operator-gated insight derivation over a named archive's chunks). Ships three thinking-tool skills: `challenge` (adversarial retrieval — strongest counter-evidence from the graph for a given claim), `connect` (bridge-finding between two topics via shared graph neighbors), and `emerge` (clusters uncategorised KnowledgeDocument and Section nodes into operator-approved Concept proposals). The learnings surface is three tools plus the `learnings-recall` skill: `learnings-scan` pages session transcripts off disk (requiring CLAUDE_CONFIG_DIR, refusing without it rather than guessing a projects root), `learnings-derive` reconciles the turn's claims into `:Learning` writes on a confidence curve (create at 0.5, reinforce as c + 0.15(1-c), contradict by 0.3 with contradictedAt stamped) and optionally runs the decay pass, and `learnings-recall` is the only path from a title injected into a system prompt to its full body."
 account-owned-dirs: [{"dir": "archive", "description": "Archived obsidian imports and their embedded attachments."}]
 tools:
   - name: memory-search
@@ -167,6 +167,18 @@ tools:
     publicAllowlist: false
     adminAllowlist: true
     riskClass: read
+  - name: learnings-scan
+    publicAllowlist: false
+    adminAllowlist: true
+    riskClass: read
+  - name: learnings-derive
+    publicAllowlist: false
+    adminAllowlist: true
+    riskClass: write_local
+  - name: learnings-recall
+    publicAllowlist: false
+    adminAllowlist: true
+    riskClass: read
 hidden:
   - name: session-compact
     riskClass: write_local
@@ -185,6 +197,7 @@ skills:
   - skills/challenge/SKILL.md
   - skills/connect/SKILL.md
   - skills/emerge/SKILL.md
+  - skills/learnings-recall/SKILL.md
 always: true
 embed: false
 mcp:
@@ -200,6 +213,7 @@ mcp:
     SESSION_ID: ${SESSION_ID}
     AGENT_SLUG: ${AGENT_SLUG}
     AGENT_SLUG_SCOPE: ${AGENT_SLUG_SCOPE}
+    CLAUDE_CONFIG_DIR: ${CLAUDE_CONFIG_DIR}
 mcp-manifest: auto
 ---
 

package/payload/platform/plugins/memory/mcp/dist/index.js

@@ -49,6 +49,9 @@ import { graphPruneDenylistRemove } from "./tools/graph-prune-denylist-remove.js
 import { conversationMemoryExpunge } from "./tools/conversation-memory-expunge.js";
 import { conversationArchiveDeriveInsights, PROPOSAL_KINDS, } from "./tools/conversation-archive-derive-insights.js";
 import { conversationArchiveListChunks } from "./tools/conversation-archive-list-chunks.js";
+import { learningsScan } from "./tools/learnings-scan.js";
+import { learningsDerive } from "./tools/learnings-derive.js";
+import { learningsRecall } from "./tools/learnings-recall.js";
 import { conversationArchiveEnrichRejection } from "./tools/conversation-archive-enrich-rejection.js";
 import { fetchImageAsContent } from "./tools/image-fetch.js";
 import { memoryReportWrite } from "./tools/memory-report-write.js";
@@ -2688,6 +2691,172 @@ lifelineTool(server, "memory-review-queue", "Read-only summary of the dream-cycl
         };
     }
 });
+// ---------------------------------------------------------------------------
+// Task 2220 — the learnings surface. Three tools:
+//   learnings-scan    pages session transcripts off disk to the caller's turn
+//   learnings-derive  reconciles the turn's claims into :Learning writes, decays
+//   learnings-recall  the only path from an injected title to a body
+// The scan/derive split mirrors conversation-archive-list-chunks +
+// conversation-archive-derive-insights: the agent reads chunks in-turn and
+// hands back claims, rather than the server guessing what a transcript meant.
+// ---------------------------------------------------------------------------
+lifelineTool(server, "learnings-scan", "Page through session transcripts written since `sinceIso` and return turn-attributed chunk bodies. Read each chunk in-turn, form per-chunk claims about what the session established, then hand those claims to `learnings-derive`. Read-only; writes nothing. Requires CLAUDE_CONFIG_DIR and refuses without it rather than guessing a projects root.", {
+    sinceIso: z
+        .string()
+        .optional()
+        .describe("Only sessions whose last write is strictly after this ISO timestamp. Omit to scan every session. The overnight pass supplies the previous run's :Report timestamp."),
+    sessionOffset: z
+        .number()
+        .int()
+        .nonnegative()
+        .optional()
+        .describe("Zero-based session offset. Default 0. Advance by sessionLimit per page."),
+    sessionLimit: z
+        .number()
+        .int()
+        .positive()
+        .max(25)
+        .optional()
+        .describe("Sessions per page (1..25). Default 5."),
+    chunkIndex: z
+        .number()
+        .int()
+        .nonnegative()
+        .optional()
+        .describe("Zero-based chunk within each returned session. Default 0."),
+    chunkTurns: z
+        .number()
+        .int()
+        .positive()
+        .max(200)
+        .optional()
+        .describe("Turns per chunk (1..200). Default 40. Counts turns, not file lines."),
+    targetAccountId: z.string().optional().describe(XACCT_DESC),
+}, async ({ sinceIso, sessionOffset, sessionLimit, chunkIndex, chunkTurns, targetAccountId }) => {
+    const scoped = resolveToolAccount("learnings-scan", targetAccountId);
+    if ("reject" in scoped)
+        return scoped.reject;
+    const accountId = scoped.accountId;
+    try {
+        const result = await learningsScan({
+            accountId,
+            sinceIso,
+            sessionOffset,
+            sessionLimit,
+            chunkIndex,
+            chunkTurns,
+        });
+        const header = `sinceIso=${result.sinceIso ?? "-"} candidateFiles=${result.candidateFiles} ` +
+            `sessions=${result.sessions} skipped=${result.skipped} returned=${result.rows.length}`;
+        const blocks = result.rows
+            .map((r) => [
+            `Session ${r.sessionId} (last write ${r.lastWriteIso}):`,
+            `  chunk=${r.chunkIndex + 1}/${r.totalChunks}`,
+            `  body=${JSON.stringify(r.body)}`,
+        ].join("\n"))
+            .join("\n\n");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: result.rows.length === 0
+                        ? `${header}\n(no sessions at this offset)`
+                        : `${header}\n\n${blocks}`,
+                },
+            ],
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: "text", text: msg }], isError: true };
+    }
+});
+lifelineTool(server, "learnings-derive", "Turn the claims you formed from `learnings-scan` output into :Learning writes. Each claim resolves against existing learnings first: a same-subject match reinforces or contradicts that node, anything novel is created at initial confidence. Set `runDecay` on the overnight pass to age learnings nobody re-observed.", {
+    sessionId: z
+        .string()
+        .describe("The session id the claims were read from (required). Recorded in sourceSessionIds."),
+    claims: z
+        .array(z.object({
+        title: z
+            .string()
+            .describe("Short handle for the learning. This is the text that reaches a system prompt."),
+        body: z
+            .string()
+            .describe("The full text. Never injected into a prompt; fetched on demand via learnings-recall."),
+        mode: z
+            .enum(["reinforce", "contradict"])
+            .describe("Your stance. `reinforce` when the claim agrees with what is already known, `contradict` when it disputes it. The tool never infers this from the text."),
+    }))
+        .describe("Per-chunk claims from your reading of learnings-scan output."),
+    runDecay: z
+        .boolean()
+        .optional()
+        .describe("Run the decay pass after the claims land. The overnight pass sets it true; an ad-hoc call leaves it false."),
+    targetAccountId: z.string().optional().describe(XACCT_DESC),
+}, async ({ sessionId, claims, runDecay, targetAccountId }) => {
+    const scoped = resolveToolAccount("learnings-derive", targetAccountId);
+    if ("reject" in scoped)
+        return scoped.reject;
+    const accountId = scoped.accountId;
+    try {
+        const result = await learningsDerive({ accountId, sessionId, claims, runDecay });
+        const decayLine = result.decay
+            ? ` decayExamined=${result.decay.examined} decayed=${result.decay.decayed} floored=${result.decay.floored}`
+            : "";
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `created=${result.created} amplified=${result.amplified} ` +
+                        `relegated=${result.relegated}${decayLine}`,
+                },
+            ],
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: "text", text: msg }], isError: true };
+    }
+});
+lifelineTool(server, "learnings-recall", "Fetch the full text of a learning by title or id. Your system prompt carries learning titles only; this is the single path to a body. Returns confidence, when it was last observed, how many sessions produced it, and whether a later session contradicted it.", {
+    title: z
+        .string()
+        .optional()
+        .describe("Case-insensitive substring of the learning title, as it appeared in the learnings index in your system prompt."),
+    learningId: z.string().optional().describe("Exact learningId, when you have one."),
+    targetAccountId: z.string().optional().describe(XACCT_DESC),
+}, async ({ title, learningId, targetAccountId }) => {
+    const scoped = resolveToolAccount("learnings-recall", targetAccountId);
+    if ("reject" in scoped)
+        return scoped.reject;
+    const accountId = scoped.accountId;
+    try {
+        const result = await learningsRecall({ accountId, title, learningId });
+        if (result.rows.length === 0) {
+            return {
+                content: [{ type: "text", text: "rows=0 (no learning matched)" }],
+            };
+        }
+        const blocks = result.rows
+            .map((r) => [
+            `learningId=${r.learningId}`,
+            `  title=${JSON.stringify(r.title)}`,
+            `  confidence=${r.confidence} observations=${r.observationCount} observedAt=${r.observedAt}`,
+            r.contradictedAt ? `  contradictedAt=${r.contradictedAt}` : null,
+            `  body=${JSON.stringify(r.body)}`,
+        ]
+            .filter((l) => l !== null)
+            .join("\n"))
+            .join("\n\n");
+        return {
+            content: [{ type: "text", text: `rows=${result.rows.length}\n\n${blocks}` }],
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: "text", text: msg }], isError: true };
+    }
+});
 // Cleanup on exit
 process.on("SIGINT", async () => {
     liveSchemaRuntime.cache.stop();