@codyswann/lisa 2.121.0 → 2.122.0

package/plugins/lisa-wiki-agy/scripts/wiki-status.mjs

@@ -0,0 +1,345 @@
+#!/usr/bin/env node
+/**
+ * wiki-status.mjs — read-only Lisa wiki source freshness report.
+ *
+ * Usage: node wiki-status.mjs [--wiki <wikiRoot>] [--config <path>] [--json]
+ * Exit 0 = report rendered. Missing wiki/config are represented in the report.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { loadConfig, walkFiles } from "./_wiki-lib.mjs";
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_STALE_AFTER_DAYS = 7;
+
+const argv = process.argv.slice(2);
+const flag = name => argv.includes(name);
+const opt = name => {
+  const i = argv.indexOf(name);
+  return i !== -1 ? argv[i + 1] : undefined;
+};
+
+function relToCwd(filePath) {
+  return path.relative(process.cwd(), filePath).replaceAll(path.sep, "/");
+}
+
+function relToWikiParent(filePath, wikiRoot) {
+  const wikiParent = path.dirname(wikiRoot);
+  return normalizeWikiPath(path.relative(wikiParent, filePath));
+}
+
+function normalizeWikiPath(filePath) {
+  return filePath.replaceAll("\\", "/").replace(/^\.?\//, "");
+}
+
+function parseDate(value) {
+  if (!value || typeof value !== "string") return undefined;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? undefined : date;
+}
+
+function newestDate(values) {
+  return values
+    .map(parseDate)
+    .filter(Boolean)
+    .sort((a, b) => b.getTime() - a.getTime())[0];
+}
+
+function readTextSafe(filePath) {
+  try {
+    return fs.readFileSync(filePath, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+function readJsonSafe(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return undefined;
+  }
+}
+
+function enabledConnectors(config) {
+  const connectors = config?.connectors ?? {};
+  return Object.entries(connectors)
+    .filter(([, connectorConfig]) => connectorConfig?.enabled !== false)
+    .filter(
+      ([, connectorConfig]) => connectorConfig?.sideEffects !== "external-write"
+    )
+    .map(([name, connectorConfig]) => ({
+      name,
+      sideEffects: connectorConfig?.sideEffects ?? "unknown",
+    }))
+    .sort((a, b) => a.name.localeCompare(b.name));
+}
+
+function logSections(logText) {
+  const lines = logText.split("\n");
+  const sections = [];
+  let current;
+
+  for (const line of lines) {
+    const heading = line.match(/^##\s+(\d{4}-\d{2}-\d{2})(?:\s+-\s+(.*))?$/);
+    if (heading) {
+      if (current) sections.push(current);
+      current = {
+        date: heading[1],
+        title: heading[2] ?? "",
+        lines: [line],
+      };
+      continue;
+    }
+    if (current) current.lines.push(line);
+  }
+
+  if (current) sections.push(current);
+  return sections;
+}
+
+function connectorLogFacts(logText, connectorName) {
+  const sections = logSections(logText);
+  const escaped = connectorName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const quoted = new RegExp(`\`${escaped}\``, "i");
+  const bare = new RegExp(`\\b${escaped}\\b`, "i");
+
+  for (const section of [...sections].reverse()) {
+    const lines = section.lines.filter(
+      line => quoted.test(line) || bare.test(line)
+    );
+    if (lines.length === 0) continue;
+
+    const lower = lines.join("\n").toLowerCase();
+    const status = lower.includes("skipped")
+      ? "skipped"
+      : lower.includes("blocked") || lower.includes("failed")
+        ? "blocked"
+        : lower.includes("ingested") || lower.includes("refreshed")
+          ? "ingested"
+          : "observed";
+
+    return {
+      date: section.date,
+      status,
+      reason: lines.map(line => line.replace(/^-\s*/, "").trim()).join(" "),
+    };
+  }
+
+  return undefined;
+}
+
+function stateFacts(wikiRoot, connectorName) {
+  const stateDir = path.join(wikiRoot, "state", connectorName);
+  const files = walkFiles(stateDir, { ext: ".json" });
+  const states = files
+    .map(filePath => ({ filePath, data: readJsonSafe(filePath) }))
+    .filter(item => item.data);
+  const dated = states
+    .map(item => ({
+      ...item,
+      date:
+        parseDate(item.data.ingested_at) ??
+        parseDate(item.data.cursor?.lastIngest) ??
+        parseDate(item.data.updated_at),
+    }))
+    .sort((a, b) => (b.date?.getTime() ?? 0) - (a.date?.getTime() ?? 0));
+  const latest = dated[0] ?? states[0];
+  const sourceNotes = new Set();
+
+  for (const item of states) {
+    const notes = item.data.source_notes ?? item.data.sourceNotes ?? [];
+    if (Array.isArray(notes)) {
+      for (const note of notes) {
+        if (typeof note === "string") sourceNotes.add(normalizeWikiPath(note));
+      }
+    }
+    if (typeof item.data.source_note === "string") {
+      sourceNotes.add(normalizeWikiPath(item.data.source_note));
+    }
+  }
+
+  return {
+    stateFiles: files.map(filePath => relToWikiParent(filePath, wikiRoot)),
+    latestObservedAt: latest?.date?.toISOString() ?? latest?.data?.ingested_at,
+    sourceNotes: [...sourceNotes],
+  };
+}
+
+function sourceFacts(wikiRoot, connectorName, configuredSourceNotes) {
+  const sourceDir = path.join(wikiRoot, "sources", connectorName);
+  const markdownFiles = walkFiles(sourceDir, { ext: ".md" });
+  const wikiParent = path.dirname(wikiRoot);
+  const sourceNoteExists = note =>
+    fs.existsSync(path.resolve(note)) ||
+    fs.existsSync(path.resolve(wikiParent, note));
+  const existingConfigured = configuredSourceNotes.filter(note =>
+    sourceNoteExists(note)
+  );
+
+  return {
+    sourceNotes:
+      existingConfigured.length > 0
+        ? existingConfigured
+        : markdownFiles.map(filePath => relToWikiParent(filePath, wikiRoot)),
+  };
+}
+
+function nextActionFor(verdict, connectorName, reason) {
+  if (verdict === "fresh") return "No action needed.";
+  if (verdict === "skipped") {
+    return reason?.toLowerCase().includes("project-scoped memory")
+      ? "Provide project-scoped memory for this repo, or accept the expected skip."
+      : `Review the skip reason, then run /lisa-wiki:ingest --source ${connectorName} when available.`;
+  }
+  if (verdict === "blocked") {
+    return `Resolve the blocker, then run /lisa-wiki:ingest --source ${connectorName}.`;
+  }
+  return `Run /lisa-wiki:ingest --source ${connectorName}.`;
+}
+
+export function createWikiFreshnessReport({
+  configPath = "wiki/lisa-wiki.config.json",
+  wikiRoot,
+  now = new Date(),
+  staleAfterDays = DEFAULT_STALE_AFTER_DAYS,
+} = {}) {
+  const parsed = parseWikiSourceFreshness({
+    configPath,
+    wikiRoot,
+    now,
+    staleAfterDays,
+  });
+
+  return {
+    generatedAt: now.toISOString(),
+    configPath: relToCwd(parsed.configPath),
+    wikiRoot: relToCwd(parsed.wikiRoot),
+    items: parsed.connectors.map(connector => ({
+      connector: connector.connector,
+      sideEffects: connector.sideEffects,
+      verdict: connector.verdict,
+      evidence: connector.evidencePaths,
+      lastObserved: connector.lastObservedDate ?? "unknown",
+      reason: connector.reason,
+      nextAction: connector.nextAction,
+    })),
+  };
+}
+
+export function parseWikiSourceFreshness({
+  configPath = "wiki/lisa-wiki.config.json",
+  wikiRoot,
+  now = new Date(),
+  staleAfterDays = DEFAULT_STALE_AFTER_DAYS,
+} = {}) {
+  const { config, configPath: resolvedConfigPath } = loadConfig(configPath);
+  const resolvedWikiRoot = path.resolve(wikiRoot ?? config?.wikiRoot ?? "wiki");
+  const logPath = path.join(resolvedWikiRoot, "log.md");
+  const logText = readTextSafe(logPath);
+  const connectors = enabledConnectors(config);
+  const staleAfterMs = staleAfterDays * DAY_MS;
+
+  const connectorRecords = connectors.map(connector => {
+    const state = stateFacts(resolvedWikiRoot, connector.name);
+    const sources = sourceFacts(
+      resolvedWikiRoot,
+      connector.name,
+      state.sourceNotes
+    );
+    const log = connectorLogFacts(logText, connector.name);
+    const observedDate =
+      newestDate([state.latestObservedAt, log?.date]) ??
+      newestDate(
+        sources.sourceNotes.map(note => note.match(/\d{4}-\d{2}-\d{2}/)?.[0])
+      );
+    const hasState = state.stateFiles.length > 0;
+    const hasSourceNotes = sources.sourceNotes.length > 0;
+    const isStale =
+      observedDate && now.getTime() - observedDate.getTime() > staleAfterMs;
+
+    const verdict =
+      log?.status === "blocked"
+        ? "blocked"
+        : log?.status === "skipped" && !hasState && !hasSourceNotes
+          ? "skipped"
+          : !hasState && !hasSourceNotes
+            ? "never_ingested"
+            : !hasState || !hasSourceNotes || isStale
+              ? "stale"
+              : "fresh";
+
+    const evidence = [
+      ...sources.sourceNotes,
+      ...state.stateFiles,
+      fs.existsSync(logPath)
+        ? relToWikiParent(logPath, resolvedWikiRoot)
+        : undefined,
+    ].filter(Boolean);
+
+    return {
+      connector: connector.name,
+      sideEffects: connector.sideEffects,
+      verdict,
+      evidencePaths: evidence,
+      lastObservedDate: observedDate?.toISOString().slice(0, 10),
+      reason: verdict === "fresh" ? "" : (log?.reason ?? ""),
+      nextAction: nextActionFor(verdict, connector.name, log?.reason),
+    };
+  });
+
+  return {
+    configPath: resolvedConfigPath,
+    wikiRoot: resolvedWikiRoot,
+    connectors: connectorRecords,
+  };
+}
+
+export function renderWikiFreshnessReport(report) {
+  const lines = [
+    "# Lisa wiki source freshness",
+    "",
+    `Generated: ${report.generatedAt}`,
+    `Config: ${report.configPath}`,
+    `Wiki root: ${report.wikiRoot}`,
+    "",
+    "| Connector | Verdict | Last observed | Evidence | Next action |",
+    "| --- | --- | --- | --- | --- |",
+  ];
+
+  for (const item of report.items) {
+    const evidence =
+      item.evidence.length > 0
+        ? item.evidence.slice(0, 3).join("<br>")
+        : "none";
+    lines.push(
+      `| ${item.connector} | ${item.verdict} | ${item.lastObserved} | ${evidence} | ${item.nextAction} |`
+    );
+    if (item.reason && item.verdict !== "fresh") {
+      lines.push(
+        `| ${item.connector} | reason | ${item.lastObserved} | log | ${item.reason} |`
+      );
+    }
+  }
+
+  lines.push(
+    "",
+    "Integrity follow-up: run /lisa-wiki:lint separately for broken links, stale claims, or structure issues."
+  );
+
+  return `${lines.join("\n")}\n`;
+}
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  const report = createWikiFreshnessReport({
+    configPath: opt("--config") ?? "wiki/lisa-wiki.config.json",
+    wikiRoot: opt("--wiki"),
+  });
+
+  if (flag("--json")) {
+    console.log(JSON.stringify(report, null, 2));
+  } else {
+    process.stdout.write(renderWikiFreshnessReport(report));
+  }
+}

package/plugins/lisa-wiki-agy/skills/lisa-wiki-add-ingest/SKILL.md

@@ -0,0 +1,34 @@
+---
+name: lisa-wiki-add-ingest
+description: Scaffold a project-specific "front-door" ingest skill that does something unique (classify a source, fetch from a special system, stamp domain frontmatter) and then chains into /ingest. Use when a project needs a bespoke ingestion path that the core connectors do not cover — instead of forking the kernel. The generated skill enriches and delegates; the kernel still owns synthesis, index, log, verify, state, and PR.
+---
+
+# lisa-wiki-add-ingest
+
+Generate a thin, project-local front-door ingest skill so a project can extend ingestion **without
+forking** the kernel. The front-door does only the unique part, then hands enriched parameters to
+`/ingest`.
+
+## Workflow
+1. **Interview** the project: a short name; what the source is; which `wiki/sources/<sourceSystem>/`
+   bucket and page type/frontmatter it should produce; whether it merely *enriches/classifies* an
+   input or also *fetches* from an external system; and its **side-effect class**
+   (`read-only-ingest` | `repo-write` | `external-write`).
+2. **Generate** the front-door skill on both runtimes —
+   `.claude/skills/lisa-wiki-local-<name>/SKILL.md` and `.agents/skills/lisa-wiki-local-<name>/SKILL.md`.
+   Its body does the unique step, then **delegates to the `lisa-wiki-ingest` skill** (Claude facade
+   `/ingest`) passing the bucket/type/metadata. If it fetches, it writes only a sanitized source note
+   (+ run metadata) and lets the kernel do synthesis/index/log/verify/state/PR.
+3. **Register** it in `wiki/lisa-wiki.config.json` under `customConnectors`
+   (`{ name, skill, sourceSystem, stateFile, sideEffects }`). `/ingest` dispatches **only** to
+   registered names — no auto-discovery.
+
+## Rules (the front-door contract)
+- A generated front-door writes **only** its source note + run metadata. It must not write synthesis
+  pages, `index.md`, `log.md`, or final state — the kernel does those, in order, after it returns.
+- `external-write` front-doors require config opt-in **and** explicit per-run intent, and their PRs
+  never auto-merge.
+- Side effects outside the declared class are a hard failure (enforced by the touched-file guard).
+
+## Related
+`lisa-wiki-ingest` (what it chains into), `lisa-wiki-add-role`, `lisa-wiki-doctor`.

package/plugins/lisa-wiki-agy/skills/lisa-wiki-add-role/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: lisa-wiki-add-role
+description: Scaffold a domain-expert "digital staff" role over the wiki — a dual-runtime subagent (Claude + Codex) plus a staff doc page — from a config.staff[] entry. Use when a project wants a role-scoped expert (e.g. Legal, Finance, Sales) whose knowledge is a slice of the wiki. The plugin only SETS UP the subagent; whether it is ever invoked, scheduled, or routed is out of scope.
+---
+
+# lisa-wiki-add-role
+
+Turn a role definition into two generated artifacts: a documentation page in the wiki and a runnable,
+brain-pointed subagent on both runtimes. **Running the subagent (invocation, scheduling, Telegram /
+agent-team routing, private notebooks) is out of scope** — this skill only creates it.
+
+## Workflow
+1. **Resolve the role** from a `config.staff[]` entry (or interview to add one): `id`, `role`,
+   `expertise`, `owns` (categories / connectors / skills), `sensitivity`.
+2. **Doc page:** generate `wiki/staff/<id>.md` describing the role, its owned domain, and who it
+   reports to. This page is wiki content and is itself ingestible (the `roles` connector).
+3. **Subagents (dual-runtime), rendered from the role-agent templates:**
+   - Claude: `.claude/agents/<id>.md`.
+   - Codex: `.codex/agents/<id>.toml` (keys `name`, `description`, `developer_instructions`; optional
+     `model`, `model_reasoning_effort`, `sandbox_mode`).
+4. **Brain-pointed, not baked:** the subagent's instructions say *"your domain is `wiki/<owned>/`;
+   `/query` it first, contribute via `/ingest`; stay in your lane."* It points at the live wiki so it
+   never goes stale. Only its one-line `description` is synthesized from the wiki at generation time.
+
+## Rules
+- v1 instructs lane-keeping but does not *enforce* per-role write isolation (deferred).
+- Setup seeds the starter roster by delegating here per `config.staff[]` entry.
+
+## Related
+`lisa-wiki-setup` (seeds the roster), `lisa-wiki-add-ingest`, `lisa-wiki-onboard-me`.

package/plugins/lisa-wiki-agy/skills/lisa-wiki-connector-confluence/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: lisa-wiki-connector-confluence
+description: Produce sanitized Confluence source notes for lisa-wiki ingest via the Atlassian MCP. Use only when lisa-wiki-ingest routes to the confluence connector. Read-only; tenant-guarded.
+---
+
+# lisa-wiki-connector-confluence
+
+Skill-driven connector (Atlassian MCP). Writes ONLY source notes under `wiki/sources/confluence/` and
+emits a proposed cursor; the kernel does the rest.
+
+## Flow
+1. Confirm `connectors.confluence.enabled` and `sideEffects: read-only-ingest`.
+2. **Tenant guard:** verify the Atlassian connection matches `connectors.confluence.tenantGuard`
+   (same site/cloudId discipline as jira). Abort on mismatch.
+3. **Window:** read `wiki/state/confluence/*.json`. First run → configured window; incremental →
+   pages updated since the cursor. Scope to the configured spaces.
+4. **Fetch (read-only)** page content + metadata via the Atlassian MCP. Never edit Confluence.
+5. **Write source notes** under `wiki/sources/confluence/<YYYY-MM-DD>-confluence-ingest.md` with
+   frontmatter and citations (`Source: <space>/<page>`). Redact secrets; honor retention/sensitivity.
+6. **Emit run metadata** (proposed cursor, counts) to the handoff file; return to `lisa-wiki-ingest`.
+
+## Rules
+- Abort on tenant mismatch; do not invent pages/decisions; weak evidence → open-questions.
+- Disabled if the Atlassian MCP is absent (`scripts/mcp-doctor.mjs`).
+- Writes only source notes + handoff meta; the kernel advances state.

package/plugins/lisa-wiki-agy/skills/lisa-wiki-connector-docs/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: lisa-wiki-connector-docs
+description: Ingest a local document (PDF, DOCX, Markdown, text) into a sanitized source note for lisa-wiki ingest. Use only when lisa-wiki-ingest routes to the docs connector (a file-path input). Uses available local converters; no heavy bundled dependency.
+---
+
+# lisa-wiki-connector-docs
+
+Skill-driven connector. Converts a local document to markdown using whatever converter is available,
+writes a source note, and hands off; the kernel does the rest.
+
+## Converters (no bundled heavy dependency)
+- **Markdown / text**: ingest directly.
+- **PDF**: `pdftotext` (Poppler) if available, else `pandoc`.
+- **DOCX**: `pandoc` if available, else `textutil` (macOS).
+If no suitable converter is installed, **skip that source and record a `docs` doctor finding** (the
+file could not be converted) so the user can install a converter — a targeted `/ingest <file>` reports
+the skip rather than pretending success. Missing converters are connector-specific, never a
+plugin-install blocker.
+
+## Flow
+1. Confirm `connectors.docs.enabled` and `sideEffects: read-only-ingest`.
+2. Resolve the input file; pick the converter by extension; convert to markdown (read-only).
+3. Write a source note under `wiki/sources/docs/<YYYY-MM-DD>-<slug>.md` with frontmatter
+   (`type: source`, dates, `source_system: docs`, original filename) and the converted, reader-safe
+   text. Redact secrets; honor `sourceRetention`/`sensitivity`.
+4. Emit run metadata (source-note path) to the handoff file; return to `lisa-wiki-ingest`.
+
+## Rules
+- Read-only on the source document; never modify the original.
+- Writes only the source note + handoff meta; the kernel advances state.

package/plugins/lisa-wiki-agy/skills/lisa-wiki-connector-git/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: lisa-wiki-connector-git
+description: Produce sanitized git/PR-history source notes for lisa-wiki ingest. Use only when lisa-wiki-ingest routes to the git connector (self repo or a registered project). Read-only — never checks out, fetches, or mutates the target repo.
+---
+
+# lisa-wiki-connector-git
+
+A universal, deterministic connector backed by `scripts/ingest-git.mjs`. It writes ONLY a source note
+under `wiki/sources/git/` (or a per-project path) and emits a proposed cursor; the kernel performs
+synthesis/index/log/verify/state/PR.
+
+## Flow
+1. Confirm `connectors.git` is enabled and `read-only-ingest`.
+2. For the self repo (and each registered project under `projects/`), run:
+   ```
+   node "${PLUGIN_ROOT}/scripts/ingest-git.mjs" --repo <path> --slug <name> \
+     --config wiki/lisa-wiki.config.json --source-dir wiki/sources/git \
+     --state wiki/state/git/<slug>.json --emit-meta wiki/state/handoff/git-<slug>-<runId>.json
+   ```
+3. Hand the emitted source-note paths + proposed cursor back to `lisa-wiki-ingest`.
+
+## Rules
+- Read-only: only `git log`/`rev-parse`/`gh pr list` against the repo; never checkout/fetch/reset/pull.
+- In wrapper/standalone mode, the registered child repos are read-only inputs and are never staged.
+- Writes only its source note + handoff meta; the kernel advances `wiki/state/git/<slug>.json`.

package/plugins/lisa-wiki-agy/skills/lisa-wiki-connector-jira/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: lisa-wiki-connector-jira
+description: Produce sanitized JIRA source notes for lisa-wiki ingest via the Atlassian MCP. Use only when lisa-wiki-ingest routes to the jira connector. Read-only; tenant-guarded.
+---
+
+# lisa-wiki-connector-jira
+
+Skill-driven connector (Atlassian MCP). Writes ONLY source notes under `wiki/sources/jira/` and emits
+a proposed cursor; the kernel does synthesis/index/log/verify/state/PR.
+
+## Flow
+1. Confirm `connectors.jira.enabled` and `sideEffects: read-only-ingest`.
+2. **Tenant guard:** verify the active Atlassian connection resolves to
+   `connectors.jira.tenantGuard.site` / `cloudId`. If it resolves to a different account/tenant,
+   **abort** (do not ingest) — this is the cross-tenant contamination guard.
+3. **Window:** read `wiki/state/jira/*.json`. First run → last 4 months (or configured window);
+   incremental → issues `updated >=` the cursor watermark. Scope to `connectors.jira.projects[]`.
+4. **Fetch (read-only)** via the Atlassian MCP (JQL search + issue read). Never write to JIRA.
+5. **Write source notes** under `wiki/sources/jira/<YYYY-MM-DD>-jira-ingest.md` — reader-safe, with
+   frontmatter (`type: source`, dates, `source_system: jira`) and citations (`Source: <issue key>`).
+   Redact secrets; honor `sourceRetention`/`sensitivity`.
+6. **Emit run metadata** (proposed cursor: latest `updated` watermark, counts) to the handoff file,
+   then return to `lisa-wiki-ingest`.
+
+## Rules
+- Abort on tenant mismatch; never invent issues/PRs/people; weak evidence → open-questions.
+- If the Atlassian MCP is absent, the connector is disabled (see `scripts/mcp-doctor.mjs`).
+- Writes only source notes + handoff meta; the kernel advances state.

package/plugins/lisa-wiki-agy/skills/lisa-wiki-connector-memory/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: lisa-wiki-connector-memory
+description: Ingest the agent's PROJECT-SCOPED memory into a sanitized source note. Use only when lisa-wiki-ingest routes to the memory connector. NEVER ingests global or unrelated memory — global Codex memory and the Chronicle store are refused.
+---
+
+# lisa-wiki-connector-memory
+
+A universal connector backed by `scripts/ingest-memory.mjs`. **Project-scoped only.**
+
+## Resolve the memory directory (then pass it explicitly)
+- **Claude**: per-project memory at `~/.claude/projects/<encoded-project-path>/memory/` — inherently
+  project-scoped; always eligible.
+- **Codex**: eligible ONLY if a project-scoped memory store exists (e.g. a per-project `CODEX_HOME`).
+  The global `~/.codex/memories/` and the Chronicle store are **never** ingested (the script
+  hard-refuses them).
+
+## Flow
+```
+node "${PLUGIN_ROOT}/scripts/ingest-memory.mjs" --memory-dir <project-scoped-dir> \
+  --config wiki/lisa-wiki.config.json --source-dir wiki/sources/memory \
+  --state wiki/state/memory/memory.json --emit-meta wiki/state/handoff/memory-<runId>.json
+```
+Hand the source note + proposed cursor back to `lisa-wiki-ingest`.
+
+## Rules
+- Secrets are redacted; sensitivity is at least `internal`.
+- If no project-scoped memory exists, ingest nothing rather than reaching for global memory.
+- Writes only its source note + handoff meta; the kernel advances state.

package/plugins/lisa-wiki-agy/skills/lisa-wiki-connector-notion/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: lisa-wiki-connector-notion
+description: Produce sanitized Notion source notes for lisa-wiki ingest via the Notion MCP. Use only when lisa-wiki-ingest routes to the notion connector. Read-only; teamspace-guarded.
+---
+
+# lisa-wiki-connector-notion
+
+Skill-driven connector (Notion MCP). Writes ONLY source notes under `wiki/sources/notion/` and emits a
+proposed cursor; the kernel does the rest.
+
+## Flow
+1. Confirm `connectors.notion.enabled` and `sideEffects: read-only-ingest`.
+2. **Tenant guard:** verify the Notion connection resolves to
+   `connectors.notion.tenantGuard.teamspace` / `teamspaceId`. Abort on a different workspace/teamspace.
+3. **Window:** read `wiki/state/notion/*.json`. First run → configured window; incremental → pages
+   edited since the cursor.
+4. **Fetch (read-only)** via the Notion MCP. Never edit Notion.
+5. **Write source notes** under `wiki/sources/notion/<YYYY-MM-DD>-notion-ingest.md` with frontmatter
+   and citations (`Source: <notion page>`). Redact secrets; honor retention/sensitivity.
+6. **Emit run metadata** (proposed cursor, counts) to the handoff file; return to `lisa-wiki-ingest`.
+
+## Rules
+- Abort on teamspace mismatch; do not invent pages; weak evidence → open-questions.
+- Disabled if the Notion MCP is absent (`scripts/mcp-doctor.mjs`).
+- Writes only source notes + handoff meta; the kernel advances state.

package/plugins/lisa-wiki-agy/skills/lisa-wiki-connector-roles/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: lisa-wiki-connector-roles
+description: Ingest the wiki's own digital-staff roster (config.staff[] + wiki/staff/*) into a sanitized source note. Use only when lisa-wiki-ingest routes to the roles connector. Does not run any subagent.
+---
+
+# lisa-wiki-connector-roles
+
+A universal, deterministic connector backed by `scripts/ingest-roles.mjs`. It captures the roster so
+the wiki documents its own digital staff.
+
+## Flow
+```
+node "${PLUGIN_ROOT}/scripts/ingest-roles.mjs" --config wiki/lisa-wiki.config.json \
+  --wiki wiki --source-dir wiki/sources/roles \
+  --state wiki/state/roles/roles.json --emit-meta wiki/state/handoff/roles-<runId>.json
+```
+Hand the source note + proposed cursor back to `lisa-wiki-ingest`.
+
+## Rules
+- Reads `config.staff[]` and `wiki/staff/*.md` only; never invokes/schedules the role subagents
+  (that is out of scope — see lisa-wiki-add-role).
+- Writes only its source note + handoff meta; the kernel advances state.

package/plugins/lisa-wiki-agy/skills/lisa-wiki-connector-slack/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: lisa-wiki-connector-slack
+description: Ingest a Slack channel into sanitized source notes via a user token. Use only when lisa-wiki-ingest routes to the slack connector AND the run carries explicit external-write intent (Slack OAuth opens a browser and stores a token file). Centralized stdlib-Python scripts; secrets are redacted.
+---
+
+# lisa-wiki-connector-slack
+
+The centralized Slack connector backed by `scripts/slack_oauth_user.py` (one-time OAuth) and
+`scripts/ingest_slack_channel.py` (ingest). These are the stdlib-Python scripts previously duplicated
+verbatim across projects, now shipped once by the plugin.
+
+## Side effects — `external-write`
+Slack OAuth opens a browser and writes a user-token file to a local secrets path. The slack connector
+is therefore `external-write`: it runs ONLY with config opt-in **and** explicit per-run intent, is
+skipped during an unattended full ingest, and its PR never auto-merges.
+
+## Flow
+1. One-time auth (explicit): `python3 "${PLUGIN_ROOT}/scripts/slack_oauth_user.py"` — stores a
+   `xoxp-` user token under an ignored secrets path. The token file is never committed.
+2. Ingest: `python3 "${PLUGIN_ROOT}/scripts/ingest_slack_channel.py" --channel <id-or-name> \
+   --config wiki/lisa-wiki.config.json --emit-meta wiki/state/handoff/slack-<runId>.json` — verifies
+   the Slack tenant against config, then writes sanitized source notes under `wiki/sources/slack/`
+   (tokens/keys redacted) and emits a **proposed** cursor to the handoff file.
+3. Hand the source notes + handoff meta back to `lisa-wiki-ingest` (the kernel advances final state
+   after verification).
+
+## Rules
+- Verify the Slack team/tenant matches config before ingesting.
+- Token/OAuth artifacts stay in `.gitignore` and are never committed.
+- Writes only Slack source notes; the kernel performs synthesis/index/log/verify/PR.

package/plugins/lisa-wiki-agy/skills/lisa-wiki-connector-web/SKILL.md

@@ -0,0 +1,23 @@
+---
+name: lisa-wiki-connector-web
+description: Ingest a public URL into a sanitized source note for lisa-wiki ingest (via WebFetch). Use only when lisa-wiki-ingest routes to the web connector (a URL input). Read-only.
+---
+
+# lisa-wiki-connector-web
+
+Skill-driven connector. Fetches a public URL (WebFetch / equivalent), reduces it to a reader-safe
+source note, and hands off; the kernel does synthesis/index/log/verify/state/PR.
+
+## Flow
+1. Confirm `connectors.web.enabled` and `sideEffects: read-only-ingest`.
+2. Fetch the URL read-only (WebFetch). Do not follow suspicious cross-host redirects without care.
+3. Write a source note under `wiki/sources/web/<YYYY-MM-DD>-<slug>.md` with frontmatter
+   (`type: source`, dates, `source_system: web`, the URL) and a faithful, reader-safe summary +
+   key excerpts. Redact secrets; honor `sourceRetention` (e.g. `external-pointer-only` keeps just the
+   URL + minimal note).
+4. Emit run metadata (the source-note path) to the handoff file; return to `lisa-wiki-ingest`.
+
+## Rules
+- Read-only; never submit forms or trigger actions on the page.
+- Do not invent content not present on the page; weak/uncertain material → open-questions.
+- Writes only the source note + handoff meta; the kernel advances state.