@rubytech/create-sitedesk-code 0.1.530 → 0.1.531

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();