feat: wiki single-source-of-memory replaces FTS5 memory tools (#83)

* chore: sync package-lock.json with png2icons + sharp devDeps

CI npm ci was failing — package-lock.json was generated before the
icon-build devDeps (png2icons, sharp) were added. Regenerated lockfile
to include the missing entries.

* feat: replace FTS5 memory tools with markdown wiki single source of truth

Switching daemora's memory model to a Karpathy-style wiki: persistent,
LLM-maintained markdown under data/wiki/ instead of a separate FTS5
notebook the agent queries via memory_save / memory_recall. One source of
truth, accessed through existing filesystem tools (read_file, write_file,
edit_file, glob, grep) — no new tool surface, no parallel APIs that
encourage hallucinating which path to use.

Architecture:
- data/wiki/{projects,people,topics,decisions}/*.md  — synthesis pages
- data/wiki/index.md                                  — table of contents
- data/wiki/log.md                                    — append-only event ledger
- data/wiki/.sync-cursor                              — heartbeat sync watermark

Phase 1 — skeleton + write hooks
- New src/wiki/WikiLog.ts: idempotent skeleton + atomic append.
- MemoryStore.save() and FileProjectStore mutations append one structured
  line to log.md so every fact and gallery change shows up for synthesis.

Phase 2 — idle maintenance turn
- Heartbeat gets a third mode (wikiSyncCheck) that runs every 10 min
  (WIKI_SYNC_INTERVAL_MINUTES env override). Reads the unsynced tail of
  log.md, hands the agent a delta + new cursor, and the same main agent
  folds events into pages with its existing tools. Skips when the user
  has been active in the last 5 min (SessionStore now tracks user-role
  message timestamps).

Phase 3 — drop the duplicate path
- Remove memory_save and memory_recall from the tool registry. The agent
  now has exactly one place to read and write memory. MemoryStore stays
  wired so existing rows remain queryable from internal code.

SOUL.md
- Replaced ## Memory section with a principle-led ## Wiki section: page
  health (50–200 lines, hard cap 350), conflict handling (in-place
  blockquotes), source provenance (every claim traces to log.md or
  data/file-projects/), idle-maintenance contract.
- Fixed stale searchMemory/writeMemory references in teamTask section.

* docs(soul): tighten Wiki section — concept framing, subfolder semantics, conventions

The Wiki section now opens with what the wiki *is* (a small interlinked
book of synthesis that compounds over time) instead of jumping to where
files live. Adds explicit semantics for projects/people/topics/decisions,
the slug + frontmatter convention each page follows, and the 1:1 mapping
between projects/<slug>.md and data/file-projects/<slug>/. Read/write/
health/conflict/idle-maintenance rules retained from the prior pass.

* chore(gitignore): ignore /wiki/ — local-only project knowledge base

* feat: auto-install playwright chromium + crew freshSession + agent fallback rules

- Add ensurePlaywrightChromium() helper that runs `npx -y @playwright/mcp@latest install-browser chrome-for-testing` so the browser binary is on disk before the MCP server is asked to drive it. Hooked into the UI enable route, the agent's manage_mcp enable, and boot when playwright is already enabled. No more "Browser chrome-for-testing is not installed" mid-task.
- Add `freshSession` flag to use_crew so the parent agent can fork a clean crew session for unrelated tasks against the same crewId, instead of inheriting unrelated history. Stops the token bloat + hallucination when the same crew is reused for distinct workstreams.
- SOUL.md + crew system prompt: keep generated/temp files under data/. Main agent: when an MCP/integration/API is disabled or unreachable, default to computer-use to drive the user's machine instead of asking them to enable it.
- Bump to 1.0.0-alpha.7.

Author: UmarFarooq75

.gitignore

@@ -32,6 +32,8 @@ GIT_RULES.md         # local dev notes
 .FEATURES.md         # internal feature planning
 FEATURES.md          # internal feature inventory
 ROADMAP.md           # internal development roadmap
+# daemora project wiki — local-only knowledge base for agents
+/wiki/
 
 # ── Claude Code project context ───────────────────────────────────────────────
 .claude/

SOUL.md

@@ -13,6 +13,8 @@ When typing via text — same personality, just adapt the format. You can use ma
 
 ## Execution
 
+- Save every generated/downloaded/temp file under `data/` (e.g. `data/outputs/`, `data/file-projects/<slug>/`, `data/temp/`). Never write outside `data/`.
+- If a needed MCP server, integration, or API is disabled or unreachable, default to the `computer-use` MCP and drive the user's machine (open the app, click, type) to complete the task.
 - Tool calls, not text. When given a task, call tools immediately. Do not describe what you would do.
 - Run to completion without confirmation. Only pause for genuine blockers requiring human decision.
 - Exhaust alternatives before reporting failure. If approach A fails, try B/C/D.
@@ -85,6 +87,7 @@ Three delegation tools. Each spawns isolated sub-agents with their own tools, sk
 - `references` — typed array of every file/URL/slug/prior output the crew needs. Required when sources exist.
 
 - **Crew member failed? Re-spawn same crewId — it retains previous session and context. Adjust the contract.**
+- **Same crewId reuses its session by default. Pass `freshSession: true` when the new task is unrelated to its last call (different deliverable/topic). Continue (omit) only when extending the same workstream.**
 
 ### parallelCrew(tasks, sharedContext)
 - `tasks: [{description, profile}, ...]` — spawns multiple crew members simultaneously.
@@ -93,8 +96,8 @@ Three delegation tools. Each spawns isolated sub-agents with their own tools, sk
 ### teamTask(action, params) — Swarm Teams
 Code orchestrator. Spawns workers, passes completed results to dependent workers, handles dependencies. No AI lead.
 
-Before creating: `searchMemory("[project]")` — check if team exists. If yes → `relaunchProject`. Never duplicate.
-After creating: `writeMemory("Team '[name]' (id: [teamId]) for [project]. Status: active.", "projects")`.
+Before creating: `listTeams` — check if a team for this project already exists. If yes → `relaunchProject`. Never duplicate.
+After creating: note the team in `data/wiki/projects/<slug>.md` so future turns can find it without re-listing teams.
 
 Actions:
 - `createTeam` — `{ name, task, workers: [{name, profile|crew, task, blockedByWorkers?}], project?, projectType?, projectRepo?, projectStack? }`
@@ -139,13 +142,66 @@ When delegating to a crew, pass the resolved project as `references: [{ kind: "g
 
 If no gallery exists or none matches, say so once and continue without invented assets.
 
-## Memory
-
-- Task completed → `writeDailyLog(entry)` with one-line summary.
-- Reusable insight (preference, pattern, project, fix) → `writeMemory(entry, category?)`.
-- Categories: preferences, patterns, projects, people, debug. Omit = general.
-- Before asking user something you might know → `readMemory()` or `searchMemory(query)`.
-- Never store secrets, tokens, or credentials.
+## Wiki — your source of memory
+
+`data/wiki/` is your accumulated knowledge — a small, interlinked book
+of markdown that gets richer every time you learn something. It is the
+only memory you have. Read it with `read_file`, `glob`, `grep`. Write
+it with `write_file`, `edit_file`. There are no other memory tools.
+
+**Two layers.** `log.md` is the raw event ledger — timestamped lines
+the system writes for you whenever a memory is saved or gallery content
+changes; treat it as input only and never edit it. Pages under
+`projects/`, `people/`, `topics/`, `decisions/` are the synthesis you
+own, write, and rewrite over time. `index.md` is the table of contents
+— one line per page in the format `- [Title](path) — one-sentence
+hook`, kept in sync as pages come and go.
+
+**What goes where.**
+- `projects/<slug>.md` mirrors `data/file-projects/<slug>/` — one per
+  ongoing piece of work; what it is, where it stands, what's been
+  decided, links to its assets.
+- `people/<slug>.md` — one per person worth remembering across turns:
+  role, preferences, prior interactions.
+- `topics/<slug>.md` — recurring concepts or subjects not tied to a
+  single project or person.
+- `decisions/<slug>.md` — one per material decision, with date and
+  rationale, so future turns don't relitigate settled questions.
+
+**Conventions.** Filenames are lowercase, hyphenated slugs. Each page
+opens with frontmatter — `name`, `type`, `updated` (ISO date), and
+`sources` (list of log timestamps or gallery paths the page draws
+from). Prefer markdown links between pages over duplicating their
+content.
+
+**Reading.** When a question touches a project, person, topic, or
+prior decision, open `index.md` first, then follow the link to the
+page that owns it. If no page exists for the thing being asked about,
+the wiki doesn't know yet — say so plainly. Don't fabricate a
+synthesis from fragments.
+
+**Writing.** When a turn produces something future-you should remember
+(a fact, a decision, a project update, who said what), update the page
+that owns the concept in the same turn. New concept with no home yet?
+Create the page with frontmatter, add one line to `index.md`, keep
+going.
+
+**Page health.** Aim for 50–200 lines. A page over ~350 lines has
+usually started covering two concepts — split it and cross-link rather
+than letting it grow. Every claim should trace to a `log.md` entry or
+a file under `data/file-projects/`; if you can't point to a source,
+the claim doesn't belong on the page yet.
+
+**Conflicts.** A new fact that contradicts the page does not silently
+overwrite. Note both in place with a brief blockquote and the date —
+let a future turn or the user resolve which is current.
+
+**Idle maintenance.** A system message may hand you a delta from
+`log.md` and a new cursor. Fold those events into the pages they
+touch, refresh `index.md` if the page list changed, then write the
+cursor file the message names. Otherwise, leave the log alone.
+
+Never store secrets, tokens, or credentials anywhere in the wiki.
 
 ## Safety
 

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "daemora",
-  "version": "1.0.0-alpha.6",
+  "version": "1.0.0-alpha.7",
   "description": "Self-hosted AI agent platform — autonomous, multi-channel, multi-model.",
   "type": "module",
   "license": "AGPL-3.0-or-later",

package.json

@@ -56,6 +56,7 @@ import { Cleanup } from "../../services/Cleanup.js";
 import { Embeddings } from "../../embeddings/Embeddings.js";
 import { DeclarativeMemoryStore } from "../../memory/DeclarativeMemoryStore.js";
 import { MemoryStore } from "../../memory/MemoryStore.js";
+import { WikiLog } from "../../wiki/WikiLog.js";
 import { SessionStore } from "../../memory/SessionStore.js";
 import { ModelRouter } from "../../models/ModelRouter.js";
 import { GoalStore } from "../../goals/GoalStore.js";
@@ -127,7 +128,8 @@ export async function startCommand(): Promise<void> {
 
   const models = new ModelRouter(cfg);
   const sessions = new SessionStore(cfg.database);
-  const memory = new MemoryStore(cfg.database);
+  const wikiLog = new WikiLog(cfg.env.dataDir);
+  const memory = new MemoryStore(cfg.database, wikiLog);
   const declarativeMemory = new DeclarativeMemoryStore(
     process.env["MEMORY_DIR"] ?? `${cfg.env.dataDir}/memory`,
   );
@@ -219,11 +221,26 @@ export async function startCommand(): Promise<void> {
     mcpServers: mcpManager.listStatus().length,
     mcpTools: mcpManager.allTools().length,
   }, "MCP servers connected");
+  // If playwright was already enabled by a previous run, make sure the
+  // Chromium binary is on disk. Don't block boot — the install can take
+  // 30–60s and the user may not need browser tools immediately.
+  const playwrightEntry = mcpStore.get("playwright");
+  if (playwrightEntry?.enabled === true) {
+    void import("../../mcp/playwrightInstall.js").then(({ ensurePlaywrightChromium }) =>
+      ensurePlaywrightChromium().then((r) => {
+        if (r.status === "failed") {
+          log.warn({ error: r.error }, "playwright chromium install failed at boot");
+        } else {
+          log.info({ status: r.status }, "playwright chromium ready");
+        }
+      }),
+    );
+  }
   // FileProjectStore is built here (before AgentLoop) so the
   // list_gallery_projects tool gets registered in the agent's tool
   // catalog at boot. ScanQueue construction is deferred below where
   // it can pick up the same store reference.
-  const fileProjectStore = new FileProjectStore(cfg.env.dataDir);
+  const fileProjectStore = new FileProjectStore(cfg.env.dataDir, wikiLog);
   const agent = new AgentLoop({
     cfg, models, skills, guard, memory,
     mcp: mcpManager, hooks: hookRunner,
@@ -352,7 +369,10 @@ export async function startCommand(): Promise<void> {
       rootDir: process.cwd(),
       daemonMode: cfg.env.daemonMode,
       proactiveIntervalMinutes: heartbeatIntervalMin,
+      wikiSyncIntervalMinutes: Number.parseInt(process.env["WIKI_SYNC_INTERVAL_MINUTES"] ?? "10", 10) || 10,
+      wikiDataDir: cfg.env.dataDir,
       enabledFn: () => (cfg.setting("HEARTBEAT_ENABLED") as boolean | undefined) ?? true,
+      lastUserActivityAt: () => sessions.lastUserActivityAt(),
     },
   );
   if (heartbeatEnabled && heartbeatIntervalMin > 0) heartbeat.start();

src/cli/commands/start.ts

@@ -91,6 +91,8 @@ export interface CrewRunInput {
   readonly parentModelId: string;
   readonly maxSteps?: number;
   readonly abortSignal: AbortSignal;
+  /** When true, skip the per-crew session reuse and start a fresh session — for unrelated tasks against the same crew. */
+  readonly freshSession?: boolean;
 }
 
 export interface CrewRunResult {
@@ -136,10 +138,13 @@ export class CrewAgentRunner {
     // instead of it floating as an orphan.
     const sourceTag = `crew:${crew.manifest.id}`;
     const parentSessionId = "main";
-    const cached = this.crewSessionIds.get(crew.manifest.id);
-    let reused = cached ? this.sessions.getSession(cached) : null;
-    if (!reused) {
-      reused = this.sessions.findLatestSessionBySource(sourceTag, parentSessionId);
+    let reused = null;
+    if (!input.freshSession) {
+      const cached = this.crewSessionIds.get(crew.manifest.id);
+      reused = cached ? this.sessions.getSession(cached) : null;
+      if (!reused) {
+        reused = this.sessions.findLatestSessionBySource(sourceTag, parentSessionId);
+      }
     }
     const session = reused ?? this.sessions.createSession({
       title: `Crew: ${crew.manifest.name}`,
@@ -406,6 +411,7 @@ function buildCrewSystemPrompt(crew: LoadedCrew, skillsIndex: string): string {
     crew.manifest.profile.systemPrompt,
     "",
     "— You are being called as a specialist by the main Daemora agent.",
+    "— Save every generated/downloaded/temp file under `data/` (e.g. `data/outputs/`, `data/file-projects/<slug>/`, `data/temp/`). Never write outside `data/`.",
     "— Your last message MUST be a plain-text summary for the main agent: what you did, what worked, what failed, what's left, and the deliverable (path/URL/exact text). Never end on a tool call. Never reply empty.",
     "— You DO NOT have access to delegate further. Complete the task with the tools you have.",
     "— If you lack a tool required for the task, say so explicitly and return what partial result you can.",

src/crew/CrewAgentRunner.ts

@@ -30,7 +30,10 @@ const MANIFEST = "project.json";
 export class FileProjectStore {
   private readonly root: string;
 
-  constructor(dataDir: string) {
+  constructor(
+    dataDir: string,
+    private readonly wikiLog?: { append(kind: string, attrs: Record<string, string | number | undefined | null>): void },
+  ) {
     this.root = join(dataDir, "file-projects");
     mkdirSync(this.root, { recursive: true });
   }
@@ -86,6 +89,11 @@ export class FileProjectStore {
       files: [],
     };
     this.write(project);
+    this.wikiLog?.append("gallery.project.create", {
+      slug,
+      name: opts.name,
+      description: opts.description,
+    });
     return project;
   }
 
@@ -104,13 +112,19 @@ export class FileProjectStore {
       updatedAt: new Date().toISOString(),
     };
     this.write(updated);
+    this.wikiLog?.append("gallery.project.update", {
+      slug,
+      ...(patch.name !== undefined ? { name: patch.name } : {}),
+      ...(patch.description !== undefined ? { description: patch.description } : {}),
+    });
     return updated;
   }
 
   delete(slug: string): boolean {
     const dir = this.pathOf(slug);
     if (!existsSync(dir)) return false;
     rmSync(dir, { recursive: true, force: true });
+    this.wikiLog?.append("gallery.project.delete", { slug });
     return true;
   }
 
@@ -132,6 +146,11 @@ export class FileProjectStore {
       updatedAt: new Date().toISOString(),
     };
     this.write(updated);
+    this.wikiLog?.append("gallery.file.add", {
+      slug,
+      file: record.path,
+      kind: record.kind,
+    });
     return record;
   }
 
@@ -151,6 +170,7 @@ export class FileProjectStore {
       updatedAt: new Date().toISOString(),
     };
     this.write(updated);
+    this.wikiLog?.append("gallery.file.remove", { slug, file: file.path });
     return true;
   }
 

src/files/FileProjectStore.ts

@@ -0,0 +1,69 @@
+/**
+ * Ensure the `@playwright/mcp` server's `chrome-for-testing` browser
+ * binary is installed on disk.
+ *
+ * The MCP server defers its browser download to the first navigation —
+ * so the MCP server "connects" successfully but fails the first real
+ * tool call with `Browser "chrome-for-testing" is not installed. Run
+ * npx @playwright/mcp install-browser chrome-for-testing to install`.
+ * The model can't auto-recover from that.
+ *
+ * We just run that exact command. It's idempotent — fast when already
+ * installed, correct when not. We don't try to be clever with cache
+ * lookups: the MCP server's own install-browser subcommand owns the
+ * truth about "what binary does this MCP build want?".
+ *
+ * Single-flight: concurrent callers (UI Enable click + agent's
+ * `manage_mcp enable` tool firing at the same time) share one install
+ * run.
+ */
+
+import { spawn } from "node:child_process";
+
+import { createLogger } from "../util/logger.js";
+
+const log = createLogger("mcp.playwright-install");
+
+export type EnsureResult =
+  | { status: "installed" }
+  | { status: "failed"; error: string };
+
+let inflight: Promise<EnsureResult> | null = null;
+
+export function ensurePlaywrightChromium(): Promise<EnsureResult> {
+  if (inflight) return inflight;
+  inflight = run().finally(() => {
+    inflight = null;
+  });
+  return inflight;
+}
+
+async function run(): Promise<EnsureResult> {
+  log.info("ensuring chrome-for-testing via 'npx -y @playwright/mcp@latest install-browser chrome-for-testing'");
+  return await new Promise<EnsureResult>((resolve) => {
+    const proc = spawn("npx", ["-y", "@playwright/mcp@latest", "install-browser", "chrome-for-testing"], {
+      stdio: ["ignore", "pipe", "pipe"],
+      env: process.env,
+    });
+    let stderr = "";
+    proc.stdout?.on("data", (b: Buffer) => log.debug({ out: b.toString().trim() }, "mcp install-browser"));
+    proc.stderr?.on("data", (b: Buffer) => {
+      const line = b.toString();
+      stderr += line;
+      log.debug({ err: line.trim() }, "mcp install-browser");
+    });
+    proc.on("error", (err) => {
+      log.error({ err: err.message }, "mcp install-browser spawn failed");
+      resolve({ status: "failed", error: err.message });
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        log.info("chrome-for-testing ready");
+        resolve({ status: "installed" });
+      } else {
+        log.error({ code, stderr: stderr.slice(-500) }, "mcp install-browser exited non-zero");
+        resolve({ status: "failed", error: `@playwright/mcp install-browser exited ${code}` });
+      }
+    });
+  });
+}

src/mcp/playwrightInstall.ts

@@ -86,7 +86,10 @@ export class MemoryStore {
   private readonly recall: Database.Statement;
   private readonly listRecent: Database.Statement;
 
-  constructor(private readonly db: Database.Database) {
+  constructor(
+    private readonly db: Database.Database,
+    private readonly wikiLog?: { append(kind: string, attrs: Record<string, string | number | undefined | null>): void },
+  ) {
     db.exec(SCHEMA);
 
     this.insertEntry = db.prepare(
@@ -132,6 +135,12 @@ export class MemoryStore {
     const source = opts.source?.trim() || "agent";
     this.insertEntry.run(id, content, tagsJson, source, now, now);
     log.debug({ id, tagCount: tags.length, source }, "memory saved");
+    this.wikiLog?.append("memory.save", {
+      id,
+      source,
+      tags: tags.length ? tags.join(",") : undefined,
+      content,
+    });
     return { id, content, tags, source, createdAt: now, updatedAt: now };
   }