total-recall-brain 3.35.0 → 3.36.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "total-recall-brain",
-  "version": "3.35.0",
+  "version": "3.36.0",
   "description": "Personal AI system — database-free, SSSS-powered intelligence engine deployable to any POSIX host.",
   "type": "module",
   "workspaces": [
@@ -22,8 +22,6 @@
     "frontend/index.html",
     "frontend/src/",
     "extension/",
-    "plugins/",
-    "!plugins/**/*.spec.mjs",
     "templates/",
     "scaffold/",
     "docs/ARCHITECTURE.md",
@@ -47,7 +45,7 @@
     "routes:manifest": "node scripts/generate-route-manifest.mjs",
     "clean": "rm -rf scratch/* .remember/* *.log",
     "check:dist": "node scripts/check-dist-freshness.mjs",
-    "prepublishOnly": "npm run check:dist",
+    "prepublishOnly": "npm run check:dist && node scripts/check-scaffold-state.mjs",
     "check:ssss-registry": "node scripts/check-ssss-registry.mjs"
   },
   "repository": {
@@ -82,7 +80,6 @@
     "natural": "^8.1.1",
     "preact": "^10.29.7",
     "sqlite-vss": "^0.1.2",
-    "total-recall-brain": "^3.17.0",
     "ws": "^8.18.0",
     "yaml": "^2.9.0",
     "zod": "^4.4.3"

package/scaffold/.agent/skills/plugins/SKILL.md

@@ -1,15 +1,209 @@
 ---
 name: plugins
-description: Create, validate, install or share Total Recall plugins.
+description: Standards, authoring guide, and CLI workflows for Total Recall plugins.
 repo_scoped: false
 ---
 
-<!-- total-recall:skill-router:v1 -->
+# Total Recall Plugin Standard & Authoring Guide
 
-# Plugins
+Total Recall capabilities beyond portable memory belong in standalone plugins. This specification details the executable plugin contract, step-by-step authoring procedures, and CLI workflows ensuring any user-authored plugin remains completely compatible across the Total Recall ecosystem.
 
-Use the plugin workspace and current `plugin.json`/extension contracts. Keep optional capabilities in plugins rather than portable memory core. Every claimed command, schedule, UI/API action or memory extension needs a real handler and validation.
+## Core Architectural Invariants
 
-Read implementation or installation references for that operation. Verify scopes, invalid input, canonical SSSS writes, failure reporting and actual execution. Sharing requires explicit authorization; public bundles exclude credentials, private vault content and runtime state. Read sharing procedures only when sharing is requested.
+1. **Portable Memory Separation**: Core Total Recall maintains only portable memory, the SSSS vault, and instruction compilers. Auxiliary tools, domain features, telephony, specialized analyzers, and user interfaces must exist as independent plugins.
+2. **Standard Manifest (`plugin.json`)**: Every plugin defines an authoritative `plugin.json` adhering to `metadata.plugin.schema.json`.
+3. **Canonical State via SSSS**: Plugins must never perform unmanaged raw filesystem writes. Persistent records, configuration overlays, and event telemetry must use SSSS VFS operations.
+4. **Token-Driven UI Elements**: Plugin interface components must avoid hardcoded color values. Visual styling must reference standard design tokens from `DESIGN.md`.
+5. **No AI Slop & Clean Copy**: Plugin documentation and user-facing text must avoid trite terms such as "sovereign", "synergy", or "leverage", and must never conclude any sentence with a preposition.
 
-Before an operation, read its [task references](references/optimized/index.md), including prerequisites and constraints. If the applicable procedure is unclear, read the preserved original instead of guessing. Commands assume the skill root.
+---
+
+## The Plugin Manifest Contract (`plugin.json`)
+
+A valid plugin contains `plugin.json` at its root:
+
+```json
+{
+  "$schema": "https://github.com/gregiteen/total-recall/blob/main/metadata.plugin.schema.json",
+  "id": "my-plugin",
+  "name": "My Plugin",
+  "version": "1.0.0",
+  "description": "Concrete explanation of the exact job this plugin performs.",
+  "author": "Author Name",
+  "license": "MIT",
+  "use_cases": ["developer-tools"],
+  "cli": {
+    "command": "my-tool",
+    "handler": "./cli.mjs",
+    "subcommands": [
+      { "name": "status", "description": "Display runtime status" },
+      { "name": "run", "description": "Execute main capability" }
+    ]
+  },
+  "runtime": {
+    "jobs": [
+      {
+        "id": "periodic-check",
+        "schedule": "0 * * * *",
+        "command": "status",
+        "description": "Hourly status verification"
+      }
+    ],
+    "daemons": [],
+    "startup": []
+  },
+  "deploy": {
+    "targets": ["ssss-app", "nextjs", "react", "flask"],
+    "required_ssss_version": ">=0.9.3",
+    "access_grants": ["ssss:vault:read", "ssss:vault:write"]
+  }
+}
+```
+
+### Manifest Specifications
+
+- **`id`** *(required)*: Lowercase kebab-case string (`^[a-z][a-z0-9-]{1,63}$`). Must match the repository or folder identifier.
+- **`name`** *(required)*: Human-readable display label.
+- **`version`** *(required)*: Semantic version string (`x.y.z`).
+- **`description`** *(required)*: Clear, functional explanation (minimum 5 characters).
+- **`use_cases`** *(optional)*: Array of kebab-case tags used for catalog indexing and search filters.
+- **`cli`** *(optional)*: Declares the CLI command name, the relative ES module handler (`cli.mjs`), and an array of subcommands.
+- **`runtime`** *(optional)*:
+  - **`jobs`**: Scheduled background cron routines (`schedule`, `command`, `timeout_seconds`, `secrets`).
+  - **`daemons`**: Continuously running background services (`handler`, `restart`, `stop_signal`).
+  - **`startup`**: Lifecycle initialization hooks executed when the host begins execution.
+- **`deploy`** *(optional)*: Target application hosts and required SSSS permission scopes.
+- **`ui`** *(optional)*: Declares reusable custom web component elements (`elements[]`), property interfaces, and required design tokens.
+
+---
+
+## Step-by-Step Plugin Creation Workflow
+
+### Step 1: Scaffold the Plugin
+Initialize a new plugin structure through the CLI:
+```bash
+total-recall plugin create my-plugin --name "My Plugin" --description "Handles custom workflows" --use-case automation --with-cli
+```
+This scaffolds a standard directory containing `plugin.json`, `cli.mjs`, and documentation.
+
+### Step 2: Implement the Command Handler (`cli.mjs`)
+The handler module must export a callable function:
+```javascript
+/**
+ * CLI Handler for my-plugin
+ * @param {string[]} argv - Command-line arguments passed after the command name
+ */
+export async function run(argv) {
+  const [subcommand, ...args] = argv.slice(2);
+  
+  if (subcommand === "status") {
+    console.log("My Plugin is fully operational.");
+    return;
+  }
+  
+  if (subcommand === "run") {
+    console.log("Executing capability with arguments:", args);
+    return;
+  }
+
+  console.log("Usage: total-recall my-tool <status|run>");
+}
+
+export default run;
+```
+
+### Step 3: Add SSSS Memory Categories (Optional)
+If your plugin defines new structured memory types, declare them inside `plugin.json`:
+```json
+"ssss_schemas": {
+  "categories": [
+    {
+      "name": "custom-audit",
+      "description": "Structured records for compliance tracking",
+      "node_type": "memory",
+      "template": "./templates/audit.md"
+    }
+  ]
+}
+```
+
+### Step 4: Validate the Plugin
+Run validation before publishing or deploying:
+```bash
+total-recall plugin info my-plugin
+```
+Ensure the validator returns zero schema errors.
+
+---
+
+## Operating Plugins Through the Total Recall CLI
+
+The Total Recall CLI provides complete lifecycle management for plugins:
+
+### 1. Discover and Search
+- **List installed plugins**:
+  ```bash
+  total-recall plugin list
+  ```
+- **List available bundled plugins**:
+  ```bash
+  total-recall plugin available
+  ```
+- **Search plugins by keyword or use case**:
+  ```bash
+  total-recall plugin search telemetry --use-case monitoring
+  ```
+
+### 2. Install and Link
+- **Install from a local directory (symlink during active development)**:
+  ```bash
+  total-recall plugin install /path/to/my-plugin --link
+  ```
+- **Install globally for all workspaces across the machine**:
+  ```bash
+  total-recall plugin install /path/to/my-plugin --global
+  ```
+- **Install from a remote git repository**:
+  ```bash
+  total-recall plugin install https://github.com/org/plugin-repo.git
+  ```
+- **Install from a mesh peer node**:
+  ```bash
+  total-recall plugin install peer:mac-mini/code-quality
+  ```
+
+### 3. Inspect and Execute
+- **Inspect detailed plugin metadata, hashes, and scheduled task logs**:
+  ```bash
+  total-recall plugin info my-plugin
+  ```
+- **Execute installed plugin commands directly**:
+  ```bash
+  total-recall my-tool status
+  ```
+
+### 4. Share and Distribute
+- **Share a plugin via a verified hash-pinned link**:
+  ```bash
+  total-recall plugin share my-plugin
+  ```
+- **Revoke sharing access**:
+  ```bash
+  total-recall plugin unshare my-plugin
+  ```
+- **Remove or uninstall a plugin**:
+  ```bash
+  total-recall plugin remove my-plugin
+  ```
+
+---
+
+## Authoring Standards Checklist
+
+Before distributing any plugin, confirm each requirement:
+- [ ] `plugin.json` passes validation against `metadata.plugin.schema.json`.
+- [ ] CLI commands exit with code `0` on success and non-zero on failure.
+- [ ] No private secrets, personal user paths, or session tokens exist in the repository.
+- [ ] SSSS data modifications use validated operations rather than raw disk writes.
+- [ ] User interface components utilize design tokens without hardcoded colors.
+- [ ] All written documentation avoids forbidden words and concludes every sentence without a preposition.

package/src/cli/plugin/create.mjs

@@ -1,6 +1,10 @@
 import fs from "node:fs";
 import path from "node:path";
-import { validatePluginManifest, projectPluginsDir, globalPluginsDir } from "../../core/plugin-loader.mjs";
+import { spawnSync } from "node:child_process";
+import { validatePluginManifest } from "../../core/plugin-loader.mjs";
+import { installPlugin } from "../../core/plugin-store.mjs";
+import { parseCron } from "../../core/plugin-tasks.mjs";
+import { generateUiElements } from "../../core/app-deploy/ui-elements.mjs";
 
 function toTitleCase(kebab) {
   return kebab
@@ -13,19 +17,29 @@ export async function createPlugin(args = []) {
   const isGlobal = args.includes("--global") || args.includes("-g");
   const withCli = args.includes("--with-cli");
   const withGenerator = args.includes("--with-generator");
+  const withUi = args.includes("--with-ui");
+  const withTask = args.includes("--with-task");
+  const createGithub = args.includes("--github");
+  const publicRepo = args.includes("--public");
+  const skipInstall = args.includes("--no-install");
+  let repoDirArg = null;
 
   let name = null;
   let description = null;
   let category = null;
   let fromSkillPath = null;
+  let taskCommand = null;
+  let taskSchedule = null;
+  let taskIntent = null;
   const useCases = [];
 
   const cleanArgs = [];
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
-    if (arg === "--global" || arg === "-g" || arg === "--with-cli" || arg === "--with-generator") {
+    if (["--global", "-g", "--with-cli", "--with-generator", "--with-ui", "--with-task", "--with-skill", "--capability", "--github", "--public", "--no-install"].includes(arg)) {
       continue;
     }
+    if (arg === "--repo-dir" && args[i + 1]) { repoDirArg = args[++i]; continue; }
     if (arg === "--name" && args[i + 1]) {
       name = args[i + 1];
       i++;
@@ -51,6 +65,9 @@ export async function createPlugin(args = []) {
       i++;
       continue;
     }
+    if (arg === "--task-command" && args[i + 1]) { taskCommand = args[++i]; continue; }
+    if (arg === "--task-schedule" && args[i + 1]) { taskSchedule = args[++i]; continue; }
+    if (arg === "--task-intent" && args[i + 1]) { taskIntent = args[++i]; continue; }
     cleanArgs.push(arg);
   }
 
@@ -102,18 +119,28 @@ export async function createPlugin(args = []) {
     process.exit(1);
   }
 
-  const pluginsBaseDir = isGlobal ? globalPluginsDir() : projectPluginsDir(process.cwd());
+  if (withTask) {
+    if (!taskCommand || !/^[a-z][a-z0-9-]*$/.test(taskCommand) || !taskSchedule || !taskIntent) {
+      throw new Error('--with-task requires --task-command <subcommand>, --task-schedule "<five-field cron>", and --task-intent <description>');
+    }
+    parseCron(taskSchedule);
+  } else if (taskCommand || taskSchedule || taskIntent) {
+    throw new Error('--task-* options require --with-task');
+  }
 
-  const pluginDir = path.join(pluginsBaseDir, id);
-  if (fs.existsSync(pluginDir)) {
-    console.error(`❌ Error: Plugin directory already exists at ${pluginDir}`);
+  // Every plugin is its own repository (tr-plugin-<id>). The repo root IS the
+  // plugin directory (plugin.json at the root); the project/global install is
+  // a symlink to it, so edits in the repo are what runs.
+  const pluginDir = path.resolve(repoDirArg || path.join(path.dirname(process.cwd()), `tr-plugin-${id}`));
+  if (fs.existsSync(pluginDir) && fs.readdirSync(pluginDir).length > 0) {
+    console.error(`❌ Error: Plugin repository directory already exists and is not empty: ${pluginDir}`);
     process.exit(1);
   }
 
   fs.mkdirSync(pluginDir, { recursive: true });
 
   const pluginName = name || skillFrontmatter.name || toTitleCase(id);
-  const pluginDesc = description || skillFrontmatter.description || `${pluginName} extension for Total Recall AI OS`;
+  const pluginDesc = description || skillFrontmatter.description || `${pluginName} extension for Total Recall`;
 
   const manifest = {
     $schema: "https://github.com/gregiteen/total-recall/blob/main/metadata.plugin.schema.json",
@@ -140,7 +167,7 @@ export async function createPlugin(args = []) {
   const withSkill = args.includes("--with-skill") || args.includes("--capability") || Boolean(fromSkillPath);
   const isCapability = args.includes("--capability") || Boolean(fromSkillPath);
 
-  if (withCli || isCapability) {
+  if (withCli || isCapability || withTask) {
     manifest.cli = {
       command: id,
       handler: "./cli.mjs",
@@ -171,6 +198,7 @@ export async function run(argv = []) {
       : \`${pluginName}: scaffold only — no subcommands implemented yet.\`);
     return;
   }
+
   if (IMPLEMENTED[sub]) return IMPLEMENTED[sub](args.slice(1));
 
   console.error(\`${pluginName}: "\${sub}" is not implemented.\`);
@@ -181,6 +209,21 @@ export default run;
     fs.writeFileSync(path.join(pluginDir, "cli.mjs"), cliContent, "utf8");
   }
 
+  if (withTask) {
+    manifest.tasks = [{ intent: taskIntent, schedule: taskSchedule, command: taskCommand, placement: 'selected-node' }];
+  }
+
+  if (withUi) {
+    manifest.ui = {
+      design_tokens: 'ui/DESIGN.md',
+      elements: [{ id: 'panel', kind: 'panel', tag: `${id}-panel`, module: 'ui/panel.js', description: `${pluginName} panel`, events: [], tokens: ['color-text', 'color-surface', 'color-border', 'spacing-md', 'radius-md'], optional_tokens: [] }],
+    };
+    const panelClass = `${id.split('-').map((part) => part[0].toUpperCase() + part.slice(1)).join('')}Panel`;
+    fs.mkdirSync(path.join(pluginDir, 'ui'), { recursive: true });
+    fs.writeFileSync(path.join(pluginDir, 'ui', 'DESIGN.md'), '---\ncolors:\n  text: "#20242a"\n  surface: "#ffffff"\n  border: "#dce2e8"\nspacing:\n  md: 12px\nrounded:\n  md: 8px\n---\n\n# Design tokens\n\nReplace these defaults with the host design tokens.\n');
+    fs.writeFileSync(path.join(pluginDir, 'ui', 'panel.js'), `class ${panelClass} extends HTMLElement {\n  connectedCallback() {\n    const root = this.shadowRoot || this.attachShadow({ mode: 'open' });\n    root.replaceChildren();\n    const style = document.createElement('style');\n    style.textContent = ':host { display:block; color:var(--color-text); background:var(--color-surface); border:1px solid var(--color-border); border-radius:var(--radius-md); padding:var(--spacing-md); }';\n    const text = document.createElement('p');\n    text.textContent = ${JSON.stringify(`${pluginName} panel scaffold. Add the actual capability before sharing.`)};\n    root.append(style, text);\n  }\n}\ncustomElements.define('${id}-panel', ${panelClass});\n`);
+  }
+
   if (isCapability) {
     manifest.deploy = {
       targets: ["ssss-app", "nextjs", "react", "flask"],
@@ -269,6 +312,10 @@ export default generateContext;
     fs.rmSync(pluginDir, { recursive: true, force: true });
     process.exit(1);
   }
+  if (withUi) {
+    try { generateUiElements(manifest, { pluginDir, target: 'web-components' }); }
+    catch (error) { fs.rmSync(pluginDir, { recursive: true, force: true }); throw error; }
+  }
 
   fs.writeFileSync(
     path.join(pluginDir, "plugin.json"),
@@ -299,17 +346,115 @@ export default generateContext;
   if (useCases.length) lines.push(`- **Use cases**: ${useCases.join(", ")}`);
   if (category) lines.push(`- **SSSS Category**: \`${category}\``);
   if (withCli) lines.push(`- **CLI Command**: \`npx total-recall ${id}\``);
+  if (withTask) lines.push(`- **Scheduled task**: \`${taskCommand}\` at \`${taskSchedule}\` (selected node; implement the command and choose a node before use)`);
+  if (withUi) lines.push('- **UI**: `ui/panel.js` custom element with DESIGN.md tokens');
   lines.push("");
 
   fs.writeFileSync(path.join(pluginDir, "README.md"), lines.join("\n"), "utf8");
 
-  console.log(`\n🎉 Successfully scaffolded plugin "${pluginName}"!`);
-  console.log(`   Location: \x1b[36m${pluginDir}\x1b[0m`);
-  console.log(`   Manifest: \x1b[33m${path.join(pluginDir, "plugin.json")}\x1b[0m`);
+  // ── Standalone repository files ──────────────────────────────────────────
+  const holder = gitOutput(['config', 'user.name']) || 'Plugin authors';
+  fs.writeFileSync(path.join(pluginDir, 'package.json'), JSON.stringify({
+    name: `tr-plugin-${id}`,
+    version: '0.1.0',
+    private: true,
+    type: 'module',
+    description: pluginDesc,
+    scripts: { test: 'node --test test/*.test.mjs' },
+    devDependencies: { 'total-recall-brain': '^3.35.0' },
+    license: 'MIT'
+  }, null, 2) + '\n', 'utf8');
+  fs.writeFileSync(path.join(pluginDir, '.gitignore'), 'node_modules/\n.env*\n.agent/skills/total-recall/\ndist/\nreports/\n.DS_Store\nINSTRUCTIONS.md\nAGENTS.md\nGEMINI.md\n', 'utf8');
+  fs.writeFileSync(path.join(pluginDir, 'LICENSE'), mitLicense(holder), 'utf8');
+  fs.mkdirSync(path.join(pluginDir, 'test'), { recursive: true });
+  fs.writeFileSync(path.join(pluginDir, 'test', 'manifest.test.mjs'), `import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const manifest = JSON.parse(fs.readFileSync(path.join(root, 'plugin.json'), 'utf8'));
+
+test('manifest identifies the plugin', () => {
+  assert.equal(manifest.id, ${JSON.stringify(id)});
+  assert.match(manifest.version, /^\\\\d+\\\\.\\\\d+\\\\.\\\\d+/);
+  assert.equal(manifest.license, 'MIT');
+});
+
+test('every file the manifest references exists', () => {
+  const refs = [manifest.cli?.handler, manifest.compile?.generator, manifest.ui?.design_tokens, ...(manifest.skills || []).map((s) => s.path), ...(manifest.ui?.elements || []).map((e) => e.module)].filter(Boolean);
+  for (const ref of refs) assert.ok(fs.existsSync(path.join(root, ref)), \`missing \${ref}\`);
+});
+`, 'utf8');
+
+  gitOutput(['init', '-q', '-b', 'main'], pluginDir);
+  gitOutput(['remote', 'add', 'origin', `https://github.com/${githubOwner() || 'OWNER'}/tr-plugin-${id}.git`], pluginDir);
+
+  // ── Install: a link to the repo, so the repo is what runs ───────────────
+  let installed = false;
+  if (!skipInstall) {
+    await installPlugin(pluginDir, { link: true, global: isGlobal, projectRoot: process.cwd() });
+    installed = true;
+  }
+
+  // ── Optional GitHub repository (private unless --public) ────────────────
+  let githubUrl = null;
+  if (createGithub) {
+    const out = spawnSync('gh', ['repo', 'create', `tr-plugin-${id}`, publicRepo ? '--public' : '--private', '--description', pluginDesc, '--source', pluginDir, '--remote', 'origin'], { encoding: 'utf8' });
+    if (out.status !== 0) {
+      console.error(`❌ GitHub repository creation failed: ${(out.stderr || out.stdout || '').trim()}`);
+      process.exitCode = 1;
+    } else {
+      githubUrl = (out.stdout || '').trim().split('\n').pop();
+    }
+  }
+
+  console.log(`\n🎉 Successfully scaffolded plugin "${pluginName}" as its own repository!`);
+  console.log(`   Repository: \x1b[36m${pluginDir}\x1b[0m`);
+  console.log(`   Manifest:   \x1b[33m${path.join(pluginDir, "plugin.json")}\x1b[0m`);
   if (withCli) {
     console.log(`   CLI Handler: \x1b[32m${path.join(pluginDir, "cli.mjs")}\x1b[0m`);
   }
+  console.log(`   Installed:  ${installed ? `linked into ${isGlobal ? 'the global' : 'this project\'s'} plugins` : 'no (--no-install)'}`);
+  console.log(`   GitHub:     ${githubUrl || (createGithub ? 'creation failed' : 'not created (re-run with --github, or: gh repo create tr-plugin-' + id + ' --private --source ' + pluginDir + ')')}`);
   console.log(`\nNext steps:`);
+  console.log(`   Test:    \x1b[32mcd ${pluginDir} && npm test\x1b[0m`);
   console.log(`   Inspect: \x1b[32mnpx total-recall plugin info ${id}\x1b[0m`);
   console.log(`   List:    \x1b[32mnpx total-recall plugin list\x1b[0m\n`);
 }
+
+function gitOutput(gitArgs, cwd) {
+  const out = spawnSync('git', gitArgs, { cwd, encoding: 'utf8' });
+  return out.status === 0 ? (out.stdout || '').trim() : '';
+}
+
+function githubOwner() {
+  const out = spawnSync('gh', ['api', 'user', '--jq', '.login'], { encoding: 'utf8' });
+  return out.status === 0 ? (out.stdout || '').trim() : '';
+}
+
+function mitLicense(holder) {
+  return `MIT License
+
+Copyright (c) ${new Date().getFullYear()} ${holder}
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+`;
+}

package/src/cli/plugin/index.mjs

@@ -44,6 +44,11 @@ Commands:
                               --category <cat>      Declare an SSSS memory category
                               --with-cli            Generate CLI command handler
                               --with-generator      Generate context generator
+                              --with-ui             Generate token-driven panel element
+                              --with-task           Declare a selected-node scheduled task
+                              --task-command <cmd>  Task CLI subcommand (requires --with-task)
+                              --task-schedule <cron> Five-field local-time schedule
+                              --task-intent <text>   Human description of the task
                               --global, -g          Create machine-wide
 
 Examples:

package/src/core/embeddings.mjs

@@ -449,6 +449,8 @@ export function nodeToEmbedText(node) {
   parts.push(`Title: ${title}`);
   if (node.category) parts.push(`Category: ${node.category}`);
   if (node.tags?.length) parts.push(`Tags: ${node.tags.join(', ')}`);
+  if (node.description) parts.push(`Description: ${node.description}`);
+  if (node.commands?.length) parts.push(`Commands: ${node.commands.join(', ')}`);
   if (node.body) parts.push(`Body: ${node.body.slice(0, 2000)}`);
   return parts.join('\n\n');
 }

package/src/core/plugin-loader.mjs

@@ -347,9 +347,24 @@ export function discoverPlugins(projectRoot = process.cwd()) {
   return plugins;
 }
 
-/** Plugins shipped inside the total-recall package, installable on any node. */
-export function listBundledPlugins() {
-  return readPluginsDir(bundledPluginsDir(), 'bundled');
+/** Plugins shipped inside the total-recall package or repository, installable on any node. */
+export function listBundledPlugins(projectRoot = process.cwd()) {
+  const seen = new Set();
+  const out = [];
+  const dirs = [
+    bundledPluginsDir(),
+    path.join(PACKAGE_ROOT, '.agent', 'skills', 'total-recall', 'plugins')
+  ];
+  for (const dir of dirs) {
+    if (!fs.existsSync(dir)) continue;
+    for (const p of readPluginsDir(dir, 'bundled')) {
+      if (!seen.has(p.id)) {
+        seen.add(p.id);
+        out.push(p);
+      }
+    }
+  }
+  return out;
 }
 
 /**