@geminilight/mindos 0.6.57 → 0.6.59

package/skills/mindos-max-workspace/iteration-1/search-past-decision-zh/old_skill/outputs/transcript.md

@@ -0,0 +1,143 @@
+# Transcript: Search Past Decision — API Rate Limiting
+
+## User Request
+
+> 上周我记得我们讨论过API限流的方案，具体是怎么定的来着？好像是每分钟100次还是200次？我找不到了。
+
+## Decision Tree Classification
+
+**Category: Lookup / summarize / quote**
+→ Read-only path: search → read → answer with citations. No writes.
+
+The user wants to recall a past decision about API rate limiting. They remember discussing it but can't find it. This is a pure search-and-retrieve task.
+
+---
+
+## Step 1: Bootstrap — List KB Tree
+
+**Command:**
+```bash
+mindos file list
+```
+
+**Purpose:** Understand the knowledge base structure before searching. Identify likely directories where meeting notes, decisions, or architecture docs might live (e.g., `meetings/`, `decisions/`, `architecture/`, `discussions/`, etc.).
+
+**Expected output:** A tree listing of all files and directories in the knowledge base, which tells us where to focus our search.
+
+---
+
+## Step 2: Parallel Multi-Keyword Search
+
+Per the skill rule: **"NEVER search with a single keyword. Fire 2-4 parallel searches (synonyms, abbreviations, Chinese/English variants)."**
+
+The user's query involves API rate limiting discussed last week. We fire 4 parallel searches covering Chinese/English variants and synonyms:
+
+**Search 1 — Chinese term (限流):**
+```bash
+mindos search "API限流"
+```
+
+**Search 2 — Chinese synonym (速率限制):**
+```bash
+mindos search "速率限制"
+```
+
+**Search 3 — English term:**
+```bash
+mindos search "rate limit"
+```
+
+**Search 4 — Specific numbers the user recalls:**
+```bash
+mindos search "每分钟100次"
+```
+
+All four searches run in parallel to maximize coverage.
+
+---
+
+## Step 3: Read Matching Files
+
+Based on the search results, read the top matching files to find the specific discussion/decision.
+
+**Commands (example — actual paths depend on search results):**
+```bash
+mindos file read "meetings/2026-03-31-api-design.md"
+mindos file read "decisions/api-rate-limiting.md"
+mindos file read "architecture/api-gateway.md"
+```
+
+We would read each file that matched the search queries, looking for:
+- Specific rate limit numbers (100/min vs 200/min)
+- Decision rationale
+- Date of discussion (last week)
+- Participants or context
+
+---
+
+## Step 4: Answer with Citations
+
+After reading the matching files, synthesize the answer and **cite the file paths** (per the skill rule: "KB-cited facts must include the file path").
+
+**Example response (simulated — actual content depends on KB):**
+
+---
+
+### If results are found:
+
+> 找到了！根据 `meetings/2026-03-31-api-design.md` 的记录：
+>
+> 上周讨论的 API 限流方案最终定为 **每分钟 200 次**（per user），具体决策如下：
+>
+> - 普通用户：200 次/分钟
+> - 免费用户：60 次/分钟
+> - 超限返回 HTTP 429，附带 `Retry-After` header
+>
+> 讨论中也考虑过 100 次/分钟的方案，但因为 [具体原因] 最终选择了 200 次。
+>
+> **来源：** `meetings/2026-03-31-api-design.md`，第 45-62 行
+
+### If no results are found:
+
+> 我在知识库中搜索了以下关键词，但没有找到关于 API 限流讨论的记录：
+> - "API限流"
+> - "速率限制"
+> - "rate limit"
+> - "每分钟100次"
+>
+> 可能的原因：
+> 1. 这次讨论还没有被记录到知识库中
+> 2. 记录使用了不同的措辞
+>
+> 建议：
+> - 你是否记得是在哪个文件或哪次会议中讨论的？我可以缩小搜索范围
+> - 如果你回忆起了具体内容，我可以帮你记录下来
+
+---
+
+## Step 5: Post-Task Check
+
+Since this is a **read-only** task, no post-task hooks apply. The skill states:
+> "After write tasks (not simple reads), scan this table."
+
+No writes were performed, so no hooks are triggered.
+
+---
+
+## Summary of Simulated Actions
+
+| Step | Action | Command(s) | Write? |
+|------|--------|------------|--------|
+| 1 | Bootstrap KB tree | `mindos file list` | No |
+| 2 | Parallel search (4 queries) | `mindos search "API限流"`, `mindos search "速率限制"`, `mindos search "rate limit"`, `mindos search "每分钟100次"` | No |
+| 3 | Read matching files | `mindos file read <path>` (for each match) | No |
+| 4 | Answer with citations | (text response to user) | No |
+| 5 | Post-task hooks | Skipped (read-only task) | No |
+
+## Key Skill Rules Applied
+
+1. **Bootstrap first** — Listed KB tree before searching (Rule 1)
+2. **Default to read-only** — User is looking up info, not saving; no writes performed (Rule 2)
+3. **NEVER search with a single keyword** — Fired 4 parallel searches with Chinese/English variants and synonyms (NEVER rule 4)
+4. **Citation** — All KB-cited facts would include file paths (Judgment heuristic)
+5. **Decision tree** — Correctly classified as "Lookup / summarize / quote" → read-only path

package/skills/mindos-max-workspace/iteration-1/search-past-decision-zh/with_skill/grading.json

@@ -0,0 +1,28 @@
+{
+  "eval_id": 2,
+  "eval_name": "search-past-decision-zh",
+  "run_type": "with_skill",
+  "skill": "mindos-max",
+  "expectations": [
+    {
+      "text": "Uses mindos search with multiple keyword variants (synonyms, Chinese/English)",
+      "passed": true,
+      "evidence": "Fired 4 parallel searches: 'API限流', 'rate limit', '每分钟100次 OR 每分钟200次', 'rate limiting 100 200'."
+    },
+    {
+      "text": "Searches for API rate limiting related terms",
+      "passed": true,
+      "evidence": "All 4 search queries are relevant to API rate limiting."
+    },
+    {
+      "text": "Read-only approach - does not write to KB",
+      "passed": true,
+      "evidence": "Transcript explicitly states 'This was a read-only task. No writes were performed.' No write commands used."
+    },
+    {
+      "text": "Would cite file path if results found",
+      "passed": true,
+      "evidence": "Response cites both 'decisions/api-rate-limiting.md' and 'meetings/2026-04-01-api-design.md'."
+    }
+  ]
+}

package/skills/mindos-max-workspace/iteration-1/search-past-decision-zh/with_skill/outputs/transcript.md

@@ -0,0 +1,233 @@
+# Transcript: Search Past Decision — API 限流方案
+
+## User Query
+
+> 上周我记得我们讨论过API限流的方案，具体是怎么定的来着？好像是每分钟100次还是200次？我找不到了。
+
+## Skill Applied
+
+**mindos-max** (v3.0.0-max) — Persistent global memory / knowledge base skill.
+
+## Decision Tree Classification
+
+This is a **Lookup / summarize / quote** request:
+- User wants to find a past decision
+- No writes needed
+- Read-only path: **search → read → answer with citations**
+
+---
+
+## Step 1: Bootstrap — List KB tree to understand structure
+
+Per Rule #1: "Bootstrap first — list the KB tree to understand structure before searching or writing."
+
+### Command
+
+```bash
+mindos file list
+```
+
+### Expected Output (simulated)
+
+```
+/
+├── INSTRUCTION.md
+├── README.md
+├── .mindos/
+│   └── user-preferences.md
+├── projects/
+│   ├── ...
+├── meetings/
+│   ├── 2026-03-31-weekly.md
+│   ├── 2026-04-01-api-design.md
+│   ├── 2026-04-03-standup.md
+│   └── ...
+├── decisions/
+│   ├── ...
+│   └── api-rate-limiting.md  (possible hit)
+├── architecture/
+│   ├── ...
+├── notes/
+│   └── ...
+└── inbox/
+    └── ...
+```
+
+### Rationale
+
+Before searching, I need to see the directory layout. The KB might have a `decisions/` folder, a `meetings/` folder, or use Chinese directory names. I must not assume.
+
+---
+
+## Step 2: Multi-keyword parallel search
+
+Per SKILL rule: "NEVER search with a single keyword. Fire 2-4 parallel searches (synonyms, abbreviations, Chinese/English variants)."
+
+### Commands (run in parallel)
+
+```bash
+# Search 1: Chinese term — 限流
+mindos search "API限流"
+
+# Search 2: English term — rate limit
+mindos search "rate limit"
+
+# Search 3: Specific numbers user mentioned
+mindos search "每分钟100次 OR 每分钟200次"
+
+# Search 4: English variant with numbers
+mindos search "rate limiting 100 200"
+```
+
+### Expected Output (simulated)
+
+```
+# Search 1: "API限流"
+Results:
+  - meetings/2026-04-01-api-design.md (score: 0.92)
+    "...讨论了API限流方案，最终确定..."
+  - decisions/api-rate-limiting.md (score: 0.88)
+    "...API限流策略：每分钟..."
+
+# Search 2: "rate limit"
+Results:
+  - decisions/api-rate-limiting.md (score: 0.95)
+    "...Rate Limiting Policy..."
+  - architecture/api-gateway.md (score: 0.61)
+    "...rate limiting middleware..."
+
+# Search 3: "每分钟100次 OR 每分钟200次"
+Results:
+  - decisions/api-rate-limiting.md (score: 0.85)
+    "...认证用户每分钟200次，未认证每分钟100次..."
+
+# Search 4: "rate limiting 100 200"
+Results:
+  - decisions/api-rate-limiting.md (score: 0.82)
+```
+
+### Rationale
+
+Multiple parallel searches maximize recall. The user's memory is fuzzy ("100次还是200次?"), so we search for both numbers and both languages. The convergence on `decisions/api-rate-limiting.md` and `meetings/2026-04-01-api-design.md` gives high confidence.
+
+---
+
+## Step 3: Read the top-hit files
+
+Per decision tree: "search → read → answer with citations."
+
+### Commands
+
+```bash
+# Read the decision document (highest relevance)
+mindos file read decisions/api-rate-limiting.md
+
+# Read the meeting notes for additional context
+mindos file read meetings/2026-04-01-api-design.md
+```
+
+### Expected Output — decisions/api-rate-limiting.md (simulated)
+
+```markdown
+# API 限流策略
+
+**决定日期**: 2026-04-01
+**参与者**: @user, @backend-team
+**状态**: ✅ 已确定
+
+## 决定
+
+| 用户类型 | 限流阈值 | 窗口 | 超限行为 |
+|---------|---------|------|---------|
+| 认证用户 | 200 次 | 每分钟 | 返回 429 + Retry-After header |
+| 未认证用户 | 100 次 | 每分钟 | 返回 429 + Retry-After header |
+| 管理员 API | 500 次 | 每分钟 | 返回 429 + 告警通知 |
+
+## 背景
+
+- 当前无限流，高峰期出现过 P99 延迟飙升
+- 参考了 GitHub API (5000/h ≈ 83/min) 和 Stripe (100/s) 的方案
+- 最终选择 sliding window 算法 + Redis 实现
+
+## 后续 TODO
+
+- [ ] 在 API Gateway 层实现
+- [ ] 添加 X-RateLimit-* response headers
+- [ ] 监控 dashboard 配置
+```
+
+### Expected Output — meetings/2026-04-01-api-design.md (simulated)
+
+```markdown
+# 会议记录: API 设计讨论
+
+**日期**: 2026-04-01
+**参会人**: ...
+
+## 议题 3: API 限流
+
+讨论了三个方案：
+1. 固定窗口 — 简单但有边界突发问题
+2. 滑动窗口 — 选定方案，更平滑
+3. 令牌桶 — 过于复杂，暂不需要
+
+最终确定：认证用户 200次/分钟，未认证 100次/分钟。
+用 Redis sorted set 实现 sliding window。
+
+详细决策记录见 `decisions/api-rate-limiting.md`。
+```
+
+---
+
+## Step 4: Synthesize answer with citations
+
+Per SKILL rule: "KB-cited facts must include the file path."
+
+### Response to User (simulated)
+
+---
+
+找到了！根据知识库中的记录，**上周（4月1日）的 API 设计会议**确定了限流方案，两个数字都对——分用户类型：
+
+| 用户类型 | 限流阈值 |
+|---------|---------|
+| **认证用户** | **200 次/分钟** |
+| **未认证用户** | **100 次/分钟** |
+| 管理员 API | 500 次/分钟 |
+
+超限统一返回 `429 Too Many Requests` + `Retry-After` header。技术方案选的是 **sliding window + Redis**。
+
+**来源**：
+- `decisions/api-rate-limiting.md` — 完整决策文档
+- `meetings/2026-04-01-api-design.md` — 会议记录（议题 3）
+
+---
+
+## Step 5: Post-task hooks check
+
+Per SKILL: "After write tasks (not simple reads), scan this table."
+
+**This was a read-only task. No writes were performed. No post-task hooks apply.**
+
+---
+
+## Summary of Commands Executed
+
+| # | Command | Purpose |
+|---|---------|---------|
+| 1 | `mindos file list` | Bootstrap — understand KB structure |
+| 2 | `mindos search "API限流"` | Search — Chinese term |
+| 3 | `mindos search "rate limit"` | Search — English term |
+| 4 | `mindos search "每分钟100次 OR 每分钟200次"` | Search — specific numbers |
+| 5 | `mindos search "rate limiting 100 200"` | Search — English variant |
+| 6 | `mindos file read decisions/api-rate-limiting.md` | Read top hit |
+| 7 | `mindos file read meetings/2026-04-01-api-design.md` | Read supporting context |
+
+## Skill Rules Followed
+
+- ✅ **Bootstrap first** (Rule 1) — Listed KB tree before searching
+- ✅ **Default to read-only** (Rule 2) — No writes performed for a lookup task
+- ✅ **Never search with single keyword** (NEVER rule) — Used 4 parallel searches with Chinese/English variants
+- ✅ **Read before write** (Rule 6) — N/A (no writes)
+- ✅ **Citation with file path** (Judgment heuristic) — Both source files cited in answer
+- ✅ **Decision tree** — Correctly classified as "Lookup / summarize / quote" → read-only path

package/skills/mindos-max-workspace/skill-snapshot/mindos-original/SKILL.md

@@ -0,0 +1,165 @@
+---
+name: mindos
+description: >
+  Operate a MindOS knowledge base: update notes, search, organize files, execute SOPs/workflows,
+  retrospective, append CSV, cross-agent handoff, route unstructured input to the right files,
+  distill experience, sync related docs.
+  Use when the task targets files inside the user's MindOS KB (mindRoot).
+  NOT for editing app source, project docs, or paths outside the KB.
+  Core concepts: Space, Instruction (INSTRUCTION.md), Skill (SKILL.md); notes can embody both.
+  Trigger when user asks to: save or record a note, search their knowledge base, update or edit
+  a file, organize notes, run a workflow or SOP, capture decisions from a session, append rows
+  to a table or CSV, hand off context to another agent.
+---
+
+# MindOS Skill
+
+<!-- version: 3.0.0 — CLI-first, MCP optional -->
+
+## CLI commands
+
+Use `mindos file <subcommand>` for all knowledge base operations. Add `--json` for structured output.
+
+| Operation | Command |
+|-----------|---------|
+| List files | `mindos file list` |
+| Read file | `mindos file read <path>` |
+| Write/overwrite | `mindos file write <path> --content "..."` |
+| Create new file | `mindos file create <path> --content "..."` |
+| Append to file | `mindos file append <path> --content "..."` |
+| Edit section | `mindos file edit-section <path> -H "## Heading" --content "..."` |
+| Insert after heading | `mindos file insert-heading <path> -H "## Heading" --content "..."` |
+| Append CSV row | `mindos file append-csv <path> --row "col1,col2,col3"` |
+| Delete file | `mindos file delete <path>` |
+| Rename/move | `mindos file rename <old> <new>` |
+| Search | `mindos search "query"` |
+| Backlinks | `mindos file backlinks <path>` |
+| Recent files | `mindos file recent --limit 10` |
+| Git history | `mindos file history <path>` |
+| List spaces | `mindos space list` |
+| Create space | `mindos space create "name"` |
+
+> **MCP users:** If you only have MCP tools (`mindos_*`), use them directly — they are self-describing via their schemas. Prefer CLI when available (lower token cost).
+
+### CLI setup
+
+```bash
+npm install -g @geminilight/mindos
+# Remote mode: mindos config set url http://<IP>:<PORT> && mindos config set authToken <token>
+```
+
+---
+
+## Rules
+
+1. **Bootstrap first** — list the KB tree to understand structure before searching or writing.
+2. **Default to read-only.** Only write when the user explicitly asks to save, record, organize, or edit. Lookup / summarize / quote = no writes.
+3. **Rule precedence** (highest wins): user's current-turn instruction → `.mindos/user-preferences.md` → nearest directory `INSTRUCTION.md` → root `INSTRUCTION.md` → this SKILL's defaults.
+4. **Multi-file edits require a plan first.** Present the full change list; execute only after approval.
+5. After create/delete/move/rename → **sync affected READMEs** automatically.
+6. **Read before write.** Always read a file before overwriting it. Never write based on assumptions.
+
+---
+
+## NEVER do (hard-won pitfalls)
+
+- **NEVER write to the KB root** unless explicitly told. Root is for governance files only. New content goes under the most fitting subdirectory.
+- **NEVER assume directory names.** Infer from the actual bootstrap tree — the KB may use Chinese names or flat layout.
+- **NEVER use full-file overwrite for a small edit.** Use `mindos file edit-section` or `mindos file insert-heading` for targeted changes. Full rewrites destroy git diffs.
+- **NEVER search with a single keyword.** Fire 2-4 parallel searches (synonyms, abbreviations, Chinese/English variants).
+- **NEVER modify `INSTRUCTION.md` or `README.md` without confirmation.** Governance docs — treat as high-sensitivity.
+- **NEVER create a file without checking siblings.** Read 1-2 files in the target directory to learn local style.
+- **NEVER leave orphan references.** After rename/move, check backlinks and update every referring file.
+- **NEVER skip routing confirmation for multi-file writes.** The user's mental model may differ from yours.
+
+---
+
+## MindOS concepts
+
+- **Space** — Knowledge partitions organized the way you think. Agents follow the same structure.
+- **Instruction** — A rules file (`INSTRUCTION.md`) all connected agents obey.
+- **Skill** — Teaches agents how to read, write, and organize the KB.
+
+Notes can embody both Instruction and Skill — they're just Markdown files in the tree.
+
+---
+
+## Decision tree
+
+```
+User request
+  │
+  ├─ Lookup / summarize / quote?
+  │   └─ [Read-only]: search → read → answer with citations. No writes.
+  │
+  ├─ Save / record / update / organize specific content?
+  │   ├─ Single file → [Single-file edit]
+  │   └─ Multiple files or unclear → [Multi-file routing] — plan first
+  │
+  ├─ Structural change (rename / move / delete / reorganize)?
+  │   └─ [Structural path] — check backlinks before and after
+  │
+  ├─ Procedural / repeatable task?
+  │   └─ [SOP path] — find and follow existing SOP, or create one
+  │
+  ├─ Retrospective / distill / handoff?
+  │   └─ [Retrospective path]
+  │
+  └─ Ambiguous?
+      └─ ASK. Propose 2-3 specific options based on KB state.
+```
+
+---
+
+## Judgment heuristics
+
+**Save intent boundary:**
+- "save this" / "record" / "write down" = write
+- "search" / "summarize" / "look up" = read-only
+- "organize" → ask: display only, or write back?
+
+**File location uncertainty:**
+- Can't decide in 5 seconds → use nearest existing directory, inform user
+- "Just put it somewhere" → inbox, propose classification after
+
+**Scope creep:**
+- Input routes to >5 files → pause, confirm scope
+- "Update all of these" spanning multiple topics → split into batches
+
+**Citation:** KB-cited facts must include the file path.
+
+---
+
+## Post-task hooks
+
+After write tasks (not simple reads), scan this table. At most 1 proposal; highest priority wins. Check `.mindos/user-preferences.md` suppression first.
+
+| Hook | Priority | Condition |
+|------|----------|-----------|
+| Experience capture | high | Debugging, troubleshooting, or multi-round work |
+| Consistency sync | high | Edited file with backlinks |
+| SOP drift | medium | Followed SOP but diverged |
+| Linked update | medium | Changed CSV/TODO status with related docs |
+| Structure classification | medium | Created file in inbox/temp location |
+| Pattern extraction | low | 3+ similar operations this session |
+
+If a hook triggers → read [references/post-task-hooks.md](./references/post-task-hooks.md).
+
+## Preference capture
+
+When user expresses a standing preference → read [references/preference-capture.md](./references/preference-capture.md) and follow confirm-then-write flow.
+
+## SOP authoring
+
+When creating/rewriting an SOP → read [references/sop-template.md](./references/sop-template.md).
+
+---
+
+## Error handling (CLI)
+
+```bash
+"command not found: mindos"  → npm install -g @geminilight/mindos
+"Mind root not configured"   → mindos onboard
+"401 Unauthorized"           → Check AUTH_TOKEN: mindos token (on server)
+"ECONNREFUSED"               → Start server: mindos start
+```

package/skills/mindos-max-workspace/skill-snapshot/mindos-original/references/README.md

@@ -0,0 +1,12 @@
+# MindOS skill — reference bundle
+
+Long-form supplements for `../SKILL.md`. Load a file only when the task needs it.
+
+| File | When to read |
+|------|----------------|
+| [write-supplement.md](./write-supplement.md) | Any write / SOP / structural task (startup protocol + execution steps) |
+| [post-task-hooks.md](./post-task-hooks.md) | Only when a hook condition in SKILL.md has already triggered |
+| [sop-template.md](./sop-template.md) | Creating or rewriting a workflow SOP in the KB |
+| [preference-capture.md](./preference-capture.md) | User expresses standing preferences to persist |
+
+Chinese mirror: `skills/mindos-zh/references/` (same filenames).

package/skills/mindos-max-workspace/skill-snapshot/mindos-original/references/post-task-hooks.md

@@ -0,0 +1,27 @@
+# Post-task hooks — propose format
+
+Conditions are listed in SKILL.md. Read this file only when a hook has already triggered.
+
+## Propose format
+
+One sentence + specific target file/path. Only expand if the user says yes.
+
+| Hook | Propose template |
+|------|-----------------|
+| Experience capture | "Record this experience to {related experience file}?" — Format: problem → cause → solution → rule |
+| Consistency sync | "{B} references what you just changed — sync it?" |
+| SOP drift | "Execution diverged from {SOP file} — update the SOP?" — Action: update diverged steps, append pitfalls, set `<!-- last-used: -->` to today |
+| Linked update | "Sync the corresponding info in {related doc}?" |
+| Structure classification | "Move this to {recommended directory}?" |
+| Pattern extraction | "This operation repeated multiple times — create an SOP?" |
+| Conversation retrospective | "This conversation had some decisions worth capturing — do a retrospective?" |
+
+## User-defined hooks
+
+Add your own below, same format:
+
+```markdown
+### Weekly report material (priority: medium)
+- Condition: updated a Project-related file.
+- Propose: "Record this change in the weekly report?"
+```

package/skills/mindos-max-workspace/skill-snapshot/mindos-original/references/preference-capture.md

@@ -0,0 +1,41 @@
+# Preference capture (`user-preferences.md`)
+
+## When to capture
+
+The user expresses a preference correction (e.g. "don't do X", "next time remember…", "this should go in… not in…").
+
+## Confirm-then-write flow
+
+1. **First occurrence of a new preference**: propose the rule and target file before writing.
+   - "Record this preference to `user-preferences.md`? Rule: _{summary}_"
+   - Write only after user confirms.
+2. **Repeated confirmation on similar category**: after the user confirms the same category of preference 3+ times, auto-write future rules in that category without asking. Add an `auto-confirm: true` flag to the category header in `user-preferences.md`.
+3. **User explicitly grants blanket permission** (e.g. "just record preferences directly"): set a top-level `auto-confirm-all: true` flag and skip confirmation for all future captures.
+
+## File location
+
+- Target: `.mindos/user-preferences.md` in the knowledge base (read by `mindos_bootstrap` when present).
+- If the file does not exist, create it with the template below on first confirmed write.
+
+## File template
+
+```markdown
+# User Skill Rules
+<!-- auto-confirm-all: false -->
+
+## Preferences
+<!-- Group by category. Mark auto-confirm: true on categories confirmed 3+ times. -->
+
+## Suppressed Hooks
+<!-- List post-task hooks the user has opted out of. -->
+```
+
+## Rule format
+
+Each rule is a bullet under its category:
+
+```markdown
+### {Category}
+<!-- auto-confirm: false -->
+- {Rule description} — _{date captured}_
+```