synabun 2026.4.21 → 2026.4.25-beta.2

package/skills/synabun/modules/schedule.md

@@ -0,0 +1,285 @@
+# Schedule Wizard — AI-Driven Schedule Creation
+
+You are now in **schedule wizard mode**. Your job is to walk the user through creating a new SynaBun schedule end-to-end via interactive option cards, then create the underlying loop-template (if needed) and the schedule itself via REST. The Schedules Studio refreshes automatically through WebSocket sync — no manual reload needed.
+
+**Input hint**: $ARGUMENTS (optional free-text describing the goal — may be empty)
+
+## CRITICAL: Tool Quirks
+
+- All SynaBun MCP calls **sequentially** (never parallel — one failure cascades).
+- `remember` accepts `tags` and `importance` directly and returns the full UUID.
+- `reflect` requires the **FULL UUID**.
+- Make every interactive prompt an **interactive option card**, NEVER plain text. The Claude sidepanel renders plain-text choices as static markdown.
+
+## Runtime Compatibility — Interactive Choice Prompt
+
+- **Claude Code (REQUIRED path):** `AskUserQuestion` is a deferred tool. Before the first prompt, call `ToolSearch` with query `select:AskUserQuestion` to load it. Then call `AskUserQuestion` with 2-4 options per question, max 4 questions per turn.
+- **OpenCode (REQUIRED path):** call the native `question` tool.
+- **Codex (REQUIRED path):** call `request_user_input`.
+- Never write the choices as plain text.
+
+## API Endpoints (use `Bash` curl)
+
+Base URL: `http://localhost:3344`
+
+| Endpoint | Method | Purpose |
+|----------|--------|---------|
+| `/api/loop/templates` | GET | List existing templates |
+| `/api/loop/templates` | POST | Create new template |
+| `/api/schedules` | GET | List existing schedules (avoid duplicates) |
+| `/api/schedules` | POST | Create schedule |
+| `/api/schedule-groups` | GET | List groups |
+| `/api/schedule-groups` | POST | Create group |
+
+All bodies are JSON. All responses are JSON.
+
+### Template payload (POST `/api/loop/templates`)
+
+```json
+{
+  "name": "Morning Native Post",
+  "description": "Twitter daily content publisher",
+  "task": "<full task instructions for the AI to run on every schedule fire>",
+  "iterations": 50,
+  "maxMinutes": 120,
+  "usesBrowser": true,
+  "icon": "twitter",
+  "category": "social",
+  "profile": "claude-code",
+  "model": "claude-sonnet-4-6",
+  "effort": "off",
+  "mcpProfile": "full"
+}
+```
+
+Returned object includes `id` — capture it for the schedule.
+
+### Schedule payload (POST `/api/schedules`)
+
+```json
+{
+  "name": "Morning Native Post",
+  "templateId": "<id from template POST>",
+  "cron": "0 8 * * *",
+  "timezone": "America/Sao_Paulo",
+  "enabled": true,
+  "groupId": null,
+  "profile": "claude-code",
+  "model": "claude-sonnet-4-6",
+  "effort": "off",
+  "usesBrowser": true,
+  "dayThemes": {}
+}
+```
+
+`profile`, `model`, `effort`, `usesBrowser` on the schedule are **launch overrides** — set only when the user wants them different from the template defaults; otherwise omit (or null).
+
+---
+
+## Phase 0 — Boot
+
+Execute sequentially:
+
+1. `recall` query `"schedule loop template platform cadence"` with `limit: 5`. Surface relevant prior schedule patterns for context.
+2. `Bash`: `curl -s http://localhost:3344/api/loop/templates` → cache as `$TEMPLATES`.
+3. `Bash`: `curl -s http://localhost:3344/api/schedule-groups` → cache as `$GROUPS`.
+4. `Bash`: `curl -s http://localhost:3344/api/schedules` → cache as `$SCHEDULES` (just for awareness, avoid creating obvious duplicates).
+5. Detect timezone — `Bash`: `readlink /etc/localtime | sed -E 's|.*/zoneinfo/||'` to get the IANA name. Fall back to `America/Sao_Paulo` only if detection fails.
+
+Brief one-line greeting to the user: "Schedule Wizard — let's build this in 5 quick steps."
+
+---
+
+## Phase 1 — Goal Capture
+
+Use ONE interactive choice prompt with ONE question:
+
+- **Question**: "What should this schedule do?"
+- **Header**: "Goal"
+- **Options** (multiSelect: false):
+  - **Social posting** — "Post to a social platform on a recurring cadence"
+  - **Lead miner** — "Scrape / discover leads or signals on a schedule"
+  - **Content publisher** — "Generate and publish content on a cadence"
+  - **Custom** — "Something else — describe in Other"
+
+If user picks "Other", capture free text as the goal description.
+
+---
+
+## Phase 2 — Template Match or Create
+
+Fuzzy-match the goal against `$TEMPLATES` by name + description + task.
+
+### If a strong match exists (>1 candidate)
+
+Interactive choice prompt:
+- **Question**: "Use an existing automation or create a new one?"
+- **Header**: "Template"
+- **Options** (multiSelect: false):
+  - **Use `<best match name>`** — "Reuse this existing automation, adjust only the schedule"
+  - **Use `<second match name>`** — (only if exists) "Reuse this existing automation"
+  - **Create new** — "Build a new automation tailored to your goal"
+
+### If creating new (or no match)
+
+Interactive choice prompt with TWO questions in one card:
+- Q1 **Platform** (header "Platform"):
+  - Twitter / Facebook / LinkedIn / Instagram / Custom (Other)
+- Q2 **Browser** (header "Browser") — multiSelect false:
+  - **Yes** — "This automation needs the SynaBun browser session"
+  - **No** — "Headless / pure-LLM task, no browser"
+
+Then internally draft the `task` field — a complete instruction block for the loop AI. Include:
+- Goal sentence
+- Platform context
+- Output rules (formatting, language matching, link placement)
+- Memory storage block telling the loop AI to call `remember` with a sensible category + tags after each iteration
+
+Build `description`, `name`, `icon` (twitter/facebook/linkedin/instagram/sparkle), `category` (social / leads / content / custom).
+
+---
+
+## Phase 3 — Cadence
+
+Interactive choice prompt:
+- **Question**: "How often should it run?"
+- **Header**: "Cadence"
+- **Options** (multiSelect: false):
+  - **Every 3 hours** — "0 */3 * * * — light cadence"
+  - **3× daily** — "0 9,14,19 * * * — morning, afternoon, evening"
+  - **Once daily morning** — "0 9 * * * — every day at 9am"
+  - **Custom cron** — "I'll type the 5-field expression in Other"
+
+If "Other" / Custom → validate it has 5 whitespace-separated fields. Re-prompt if invalid.
+
+---
+
+## Phase 4 — Runtime Overrides
+
+Interactive choice prompt with TWO questions in one card:
+- Q1 **CLI profile** (header "CLI"):
+  - **Claude Code** (Recommended, first option, label appended " (Recommended)")
+  - **Codex CLI**
+  - **Gemini CLI**
+  - **OpenCode CLI**
+- Q2 **Effort** (header "Think"):
+  - **Off** (Recommended)
+  - **Low** / **Medium** / **High**
+
+Pick a sensible default model based on profile: claude-code → `claude-sonnet-4-6`; codex → `gpt-5.4-mini`; gemini → `gemini-2.5-pro`; opencode → leave null (uses last-used).
+
+---
+
+## Phase 5 — Group Assignment
+
+Build options list dynamically from `$GROUPS`. Always include "Ungrouped" and "Create new group".
+
+Interactive choice prompt:
+- **Question**: "Which group should this schedule live in?"
+- **Header**: "Group"
+- **Options** (multiSelect: false): 2-4 entries (truncate group list if needed; offer "More..." if >2 existing groups would push over 4):
+  - **Ungrouped**
+  - **`<existing group 1>`**
+  - **`<existing group 2>`** (if exists)
+  - **Create new group**
+
+If "Create new group", ask another single-question card for group name (free text via Other) and pick a default color (`#4fc3f7`). Then `Bash` curl POST `/api/schedule-groups` with `{ name, color }`. Capture returned `id` as `$GROUP_ID`.
+
+---
+
+## Phase 6 — Confirm Summary
+
+Render summary in the question text of an interactive choice prompt. Use markdown line breaks via `\n`:
+
+- **Question** (insert line breaks via newlines):
+  ```
+  Ready to create:
+
+  Name: <name>
+  Template: <template name> (<new|existing>)
+  Cron: <expr>  (<human description>)
+  Group: <group name>
+  CLI: <profile> · Model: <model> · Think: <effort>
+  Browser: <yes|no>
+
+  Confirm?
+  ```
+- **Header**: "Confirm"
+- **Options** (multiSelect: false):
+  - **Create it** (first, " (Recommended)")
+  - **Edit name** — "Re-prompt for name only"
+  - **Edit cron** — "Re-prompt for cron only"
+  - **Cancel** — "Abort wizard"
+
+If "Edit name" or "Edit cron" → ask single open question (Other) for that field, then re-render summary.
+
+If "Cancel" → stop wizard, tell user nothing was created.
+
+---
+
+## Phase 7 — Execute
+
+Sequentially:
+
+### 7a. Create template (only if new)
+
+`Bash`:
+```bash
+curl -s -X POST http://localhost:3344/api/loop/templates \
+  -H 'Content-Type: application/json' \
+  -d '<template JSON>'
+```
+
+Parse response, capture `id` as `$TEMPLATE_ID`. If response is non-2xx or contains `error`, abort and show error via interactive prompt with retry / cancel options.
+
+### 7b. Create schedule
+
+`Bash`:
+```bash
+curl -s -X POST http://localhost:3344/api/schedules \
+  -H 'Content-Type: application/json' \
+  -d '<schedule JSON with templateId=$TEMPLATE_ID, groupId=$GROUP_ID>'
+```
+
+Same error handling.
+
+### 7c. Persist context to memory
+
+`remember` with:
+- `category`: `schedules` (use `category` tool action `create` with parent `synabun` if missing).
+- `project`: `synabun`
+- `importance`: 6
+- `tags`: `["schedule", "<platform>", "wizard-created"]`
+- `content`: 4-6 line summary (name, template id, schedule id, cron, group, runtime overrides, creation date).
+
+---
+
+## Phase 8 — Done
+
+One-line success message:
+
+> ✓ Schedule **`<name>`** created. The Schedules Studio refreshed automatically — switch to the studio window to see it.
+
+If the studio is not currently open, also note: "Open Automations → Schedules to view."
+
+---
+
+## Failure Handling
+
+- Any HTTP non-2xx → present interactive choice prompt:
+  - **Retry** — "Re-send the same payload"
+  - **Edit and retry** — "Open the failed payload for adjustment"
+  - **Cancel** — "Abort wizard"
+- Validation errors (e.g., bad cron) → re-prompt the relevant phase, do not advance.
+- Network failure → say "Neural Interface unreachable on `:3344` — is the dev server running?" and exit.
+
+---
+
+## Guidelines
+
+- **Maximum 7 interactive prompts total** across all phases. Combine where possible (e.g., Platform + Browser in one card).
+- **Default to "Recommended" first option** in every multi-choice question. Append " (Recommended)" to the first label.
+- **Never invent template fields**. Only the keys listed in the API section above are accepted by the server.
+- **Always quote IDs in JSON** (they are strings).
+- **Timezones** are IANA names. Do not pass abbreviations like "EST".
+- **Stop hooks** — emit only one tool block per turn that contains an interactive question. Do NOT chain `Bash` or `Write` after `AskUserQuestion` in the same turn — wait for the user's answer first.

package/CLAUDE.md

@@ -1,217 +0,0 @@
-# CLAUDE.md
-
-## Memory Ruleset
-
-> Portable ruleset — copy into any project's `CLAUDE.md`. Copy button in Neural Interface: Settings > Connections > Claude Code > Copy Ruleset.
-
-### Tools
-
-| Tool | Purpose |
-|------|---------|
-| `remember` | Store memory (content, category, project, tags, importance, related_files) |
-| `recall` | Semantic search across memories |
-| `forget` / `restore` | Trash / restore a memory by ID |
-| `reflect` | Update existing memory (importance, tags, content, category) |
-| `memories` | List recent or stats (recent, by-category, by-project) |
-| `sync` | Detect stale memories (file content changed) |
-| `category_create/update/delete/list` | Manage category hierarchy |
-
-### Auto-Recall
-
-- Session start: `recall` current project context
-- Topic mentioned: `recall` what you know
-- Before decisions: `recall` past decisions
-- Debugging: `recall` similar bugs
-
-### Auto-Remember (MANDATORY)
-
-After ANY task (bug fix, feature, refactor, config change, investigation, architecture decision), MUST `remember` BEFORE responding.
-
-**Steps:**
-1. `remember` — what + why + how, appropriate category, set project, related_files, importance (5=routine, 6-7=significant, 8+=critical), and 3-5 tags
-
-`remember` now returns the full UUID and accepts all fields (tags, importance) directly. No need to recall+reflect afterward.
-
-**NOT triggered by:** Simple Q&A, file reads with no findings, trivial typos.
-
-**Importance:** 1-2=trivial, 3-4=low, 5=normal, 6-7=significant, 8-9=critical, 10=foundational. User says "remember this" → 8+. Architecture decisions → 8+. API quirks → 6+.
-
-### Response Ordering (IMPORTANT)
-
-When finishing a task, structure your response as:
-1. Call `remember` (and any other memory tools) **FIRST**
-2. Write your completion summary / final message **LAST**
-
-Tool call results appear above text within a single response, so the summary naturally ends up at the bottom where the user sees it. This prevents memory tool calls from burying your completion message under noise.
-
-**Never** write your summary first and then call memory tools — the stop hook will block you, forcing a new response of memory tool calls that pushes your summary off-screen.
-
-### Category Selection
-
-1. Match existing child → use it
-2. Parent fits but no child → `category_create` child → use it
-3. Nothing fits → `category_create` parent + child → use it
-
-Never store directly in parent categories.
-
-### Tool Quirks
-
-- `remember` returns the full UUID and accepts tags + importance directly.
-- `reflect` requires FULL UUID — use the one returned by `remember`, or `recall` to find existing memories.
-- Sequential MCP calls only — never parallel.
-
-### Browser Sessions
-
-- When starting a browser session, **always create a new tab** — never reuse or navigate an existing tab. Existing tabs may contain the user's active work, unsaved state, or authenticated sessions that must not be disrupted.
-
-### Plan Mode (MANDATORY)
-
-**CRITICAL**: Plan mode = research and planning ONLY. Do NOT use Edit, Write, or NotebookEdit. Read files, search code, investigate — then present the plan. Do NOT implement until the user approves and you exit plan mode.
-
-When you need clarification or have questions:
-- **ALWAYS** use `AskUserQuestion` to present options — never write questions as plain text
-- Load the tool via `ToolSearch` first if its schema is not yet available
-- Structure as distinct choices (2-4 options per question, max 4 questions)
-- Use for approach clarification BEFORE finalizing the plan
-- Use `ExitPlanMode` (not AskUserQuestion) for final plan approval
-
-### Multi-Select Questions
-
-When using `AskUserQuestion`, set `multiSelect: true` when options are NOT mutually exclusive — i.e., the user could reasonably want more than one. Examples: selecting multiple features, tags, effects, or follow-up actions. Keep single-select (default) for inherently exclusive choices (one model, one style, one dimension).
-
----
-
-## Coexistence with Other Tools
-
-When running SynaBun alongside other memory or code intelligence tools (CogniLayer, mem0, etc.):
-
-**SynaBun owns ALL memory operations:**
-- Storing information: `remember`
-- Searching past context: `recall`
-- Updating memories: `reflect`
-- Deleting/restoring: `forget` / `restore`
-- Browsing: `memories`
-- Stale detection: `sync`
-- Categories: `category` (create/update/delete/list)
-
-**Other tools** should be restricted to their non-memory capabilities only (e.g., AST-based code search, code impact analysis).
-
-**Enforcement rule for CLAUDE.md / project instructions:**
-```
-For ALL memory operations (store, search, recall, update, delete), use SynaBun tools exclusively.
-[OtherTool] is restricted to [specific use case, e.g., code_search, code_context, code_impact].
-Never use [OtherTool] for remembering, recalling, or reflecting on past work.
-```
-
-If you notice the AI defaulting to another tool's memory features, add the enforcement rule above to your project's `CLAUDE.md`.
-
-====================================END SYNBUN
-
-## Architecture
-
-Two independently running processes that share one SQLite database:
-
-### MCP Server (`mcp-server/`)
-TypeScript, compiles to `dist/`. Entry point: `run.mjs` → `dist/preload.js` → `dist/index.js`. Communicates with AI tools via MCP protocol (stdio or HTTP). 72 tools across 9 groups: Memory (8), Browser (39), Whiteboard (5), Cards (5), Discord (8), Leonardo (4), Git (1), Loop (1), TicTacToe (1).
-
-- `src/index.ts` — tool registration, schema refresh, server creation
-- `src/config.ts` — env config, project detection from `claude-code-projects.json`
-- `src/types.ts` — `MemoryPayload` interface
-- `src/http.ts` — HTTP MCP transport (stateless, fresh server per request)
-- `src/services/sqlite.ts` — storage layer, vectors as Float32Array BLOBs, cosine similarity in JS
-- `src/services/local-embeddings.ts` — Transformers.js embedding generation
-- `src/services/categories.ts` — category CRUD, hierarchy, dynamic schema refresh
-- `src/tools/` — one file per tool (or per tool group with a registration function)
-
-### Neural Interface (`neural-interface/`)
-Express server (`server.js`, ~15K lines) serving a vanilla JS + Three.js frontend. 55+ REST API endpoints. Runs on port 3344.
-
-- `server.js` — monolithic Express server with all API routes, WebSocket, terminal (node-pty), Playwright browser management, session registry, loop orchestration
-- `public/index.html` — 3D force-directed graph (Three.js)
-- `public/index2d.html` — 2D canvas variant
-- `public/onboarding.html` — first-time setup wizard
-- `public/claude-chat.html` — standalone Claude Code chat page
-- `public/shared/` — modular JS/CSS (~50 files): `ui-*.js` modules, `storage.js` (server-synced state), `styles.css`, `utils.js`
-- `lib/db.js` — shared SQLite access (same DB as MCP server)
-- `lib/session-indexer.js` — conversation session indexing
-- `skins/` — theme system (CSS + JSON per skin)
-- `i18n/` — internationalization (en.json)
-- `templates/CLAUDE-template.md` — source of truth for memory rulesets injected into project CLAUDE.md files
-
-### Hooks (`hooks/claude-code/`)
-7 ESM (.mjs) lifecycle hooks for Claude Code, registered in `.claude/settings.json`:
-
-| Hook | Event | Purpose |
-|------|-------|---------|
-| `session-start.mjs` | SessionStart | Greeting, boot sequence, compaction recovery, loop detection |
-| `prompt-submit.mjs` | UserPromptSubmit | Tiered recall nudges, loop iteration injection |
-| `pre-compact.mjs` | PreCompact | Transcript capture before context compaction |
-| `stop.mjs` | Stop | Combined obligations: compaction, loops, task memory, user learning |
-| `post-remember.mjs` | PostToolUse | Edit tracking, flag clearing, user learning |
-| `pre-websearch.mjs` | PreToolUse | Blocks WebSearch/WebFetch during active browser sessions |
-| `post-plan.mjs` | PostToolUse | Auto-stores plans as memories on ExitPlanMode |
-
-`shared.mjs` contains utilities used across hooks.
-
-### Skills (`skills/`)
-Claude Code slash commands with `SKILL.md` entry points and `modules/` subdirectories:
-- `synabun/` — `/synabun` command hub (brainstorm, audit, health, search)
-- `leonardo/` — `/leonardo` master media prompter (video, image, model advisor, prompt library)
-
-### Data Flow
-```
-AI tool calls remember → MCP server embeds content → SQLite stores vector + payload
-AI tool calls recall   → MCP server embeds query  → cosine similarity search → re-ranked results
-Neural Interface       → reads same SQLite DB      → renders 3D graph, REST API, WebSocket
-Hooks                  → fire on Claude Code events → inject context, enforce memory obligations
-```
-
-### Shared State
-- `data/memory.db` — single SQLite database (memories, session chunks, trash)
-- `data/ui-state.json` — Neural Interface UI state (synced via `storage.js`)
-- `data/pending-compact/` — per-session compaction flags
-- `data/pending-remember/` — per-session edit tracking flags
-- `mcp-server/data/custom-categories-{connId}.json` — per-connection category definitions
-
-## Key Patterns
-
-- **Category descriptions are routing instructions**: Claude reads all category descriptions from the MCP tool schema to decide where to store memories. Descriptions must be prescriptive rules, not vague labels.
-- **Dynamic schema refresh**: Category changes trigger `refreshCategorySchemas()` → `notifications/tools/list_changed` → Claude re-fetches tool list. No restart needed.
-- **Per-tab session isolation**: Project/model/effort state stored per-tab in sidepanel (`ui-claude-panel.js`) and per-tab via `sessionStorage` in standalone (`claude-chat.js`). Global `ui-state.json` keys are "last used" defaults only.
-- **Browser sessions**: Playwright with persistent Chromium profiles. Multi-session isolation via dedicated browser session per automation. Leonardo tools are 100% browser-based (no API key).
-- **Compaction chain**: PreCompact → flag → SessionStart injects → Claude remembers(conversations) → PostToolUse clears → Stop allows.
-- **MCP calls must be sequential**: Parallel MCP tool calls can cascade failures. Always call memory tools one at a time.
-
-## Environment
-
-- Node.js 22.5+ required (for built-in `node:sqlite`)
-- `.env` at project root — `SQLITE_DB_PATH`, `NEURAL_PORT` (default 3344), `DISCORD_BOT_TOKEN`, `DISCORD_GUILD_ID`
-- CLAUDE.md is gitignored (user-local)
-
-## Persistent Memory
-
-### Auto-Remember (MANDATORY)
-After ANY task (bug fix, feature, refactor, config change, investigation, architecture decision), MUST `remember` BEFORE responding.
-
-Steps:
-1. `remember` — what + why + how, appropriate category, set project, related_files, importance (5=routine, 6-7=significant, 8+=critical), and 3-5 tags
-
-`remember` returns the full UUID and accepts all fields (tags, importance) directly. No need to recall+reflect afterward.
-
-**NOT triggered by:** Simple Q&A, file reads with no findings, trivial typos.
-
-**Importance scale:** 1-2=trivial, 3-4=low, 5=normal, 6-7=significant, 8-9=critical, 10=foundational. User says "remember this" → 8+. Architecture decisions → 8+.
-
-### Response Ordering
-When finishing a task: call `remember` (and any other memory tools) **FIRST**, then write your completion summary **LAST**. Never summary-then-tools — the stop hook will block you.
-
-### Tool Quirks
-- `remember` returns the full UUID and accepts tags + importance directly.
-- `reflect` requires FULL UUID — use the one from `remember`, or `recall` to find existing memories.
-- Sequential MCP calls only — never parallel.
-
-### Plan Mode
-When in plan mode and you need clarification:
-- ALWAYS use `AskUserQuestion` to present options — never plain text questions
-- Use `ExitPlanMode` for final plan approval
-- Use `multiSelect: true` in AskUserQuestion when options aren't mutually exclusive