{"id":51029011,"url":"https://github.com/poyi/tenbo","last_synced_at":"2026-06-21T22:03:27.497Z","repository":{"id":355346471,"uuid":"1227733539","full_name":"poyi/tenbo","owner":"poyi","description":"An agentic project manager for AI-assisted coding — persistent memory, living roadmaps, and automatic architecture tracking","archived":false,"fork":false,"pushed_at":"2026-06-14T17:24:30.000Z","size":2207,"stargazers_count":1,"open_issues_count":0,"forks_count":0,"subscribers_count":0,"default_branch":"main","last_synced_at":"2026-06-14T19:12:14.880Z","etag":null,"topics":["ai","architecture","claude-code-skill","developer-tool","project-management","roadmap","vide-coding"],"latest_commit_sha":null,"homepage":"","language":"TypeScript","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/poyi.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2026-05-03T04:59:21.000Z","updated_at":"2026-06-14T17:24:34.000Z","dependencies_parsed_at":null,"dependency_job_id":null,"html_url":"https://github.com/poyi/tenbo","commit_stats":null,"previous_names":["poyi/tenbo"],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/poyi/tenbo","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/poyi%2Ftenbo","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/poyi%2Ftenbo/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/poyi%2Ftenbo/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/poyi%2Ftenbo/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/poyi","download_url":"https://codeload.github.com/poyi/tenbo/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/poyi%2Ftenbo/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":34627243,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-05-26T15:22:16.424Z","status":"online","status_checked_at":"2026-06-21T02:00:05.568Z","response_time":54,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["ai","architecture","claude-code-skill","developer-tool","project-management","roadmap","vide-coding"],"created_at":"2026-06-21T22:03:26.887Z","updated_at":"2026-06-21T22:03:27.491Z","avatar_url":"https://github.com/poyi.png","language":"TypeScript","funding_links":[],"categories":[],"sub_categories":[],"readme":"# tenbo\n\n[![npm](https://img.shields.io/npm/v/tenbo-dashboard)](https://www.npmjs.com/package/tenbo-dashboard)\n\nAn agentic project manager for AI-assisted coding. tenbo gives your AI coding assistant a persistent project memory — it tracks architecture, roadmaps, and priorities so you can build fast without losing the plot.\n\n## The problem\n\nAI-assisted coding lets you ship features fast. But speed creates a new problem: **projects drift.**\n\n- Architecture decisions are made in chat and forgotten by the next session\n- Boundaries between components blur as the AI takes shortcuts to get things working\n- Features get half-built, parked, and never revisited\n- No one tracks what was built, why, or what's next\n- The codebase grows but the shared understanding of it doesn't\n\nAfter a few weeks of vibe coding, you have working software and zero navigability. Your AI can re-read the entire codebase to answer \"what does this project do?\" — but that costs thousands of tokens every session and still misses the decisions that shaped it.\n\n## How tenbo helps\n\ntenbo is an AI coding assistant skill / rule package that runs alongside your normal coding workflow. It watches what you build, maintains a structured map of your project, and keeps a living roadmap — all without you having to learn any commands or schemas.\n\n- **Persistent memory across sessions.** Architecture decisions, roadmap items, and project context survive between conversations. Your AI assistant starts every session knowing where you left off.\n- **Automatic structure maintenance.** As you code, tenbo silently updates architecture docs, dependency maps, and code maps. Drift is caught early, not after it's too late.\n- **Living roadmap.** Ideas, tasks, and priorities tracked in plain YAML. Items flow from \"later\" to \"now\" to \"done\" with acceptance criteria and completion checks.\n- **Health signals.** Stale items, orphaned layers, threshold violations, and architectural drift are surfaced proactively — not buried in tech debt.\n- **Natural language interface.** Just talk: \"what should I build next?\", \"this is getting messy\", \"finished the auth system\". No commands to memorize.\n\n## What's in this repo\n\n- **`skill/`** — The Claude Code and Codex skill (SKILL.md + references + templates).\n- **`cursor/`** — The Cursor rule package (multiple flat `.mdc` files, mirroring the skill). Same content, Cursor-native frontmatter.\n- **`tenbo-dashboard/`** — An optional local web dashboard for visual roadmap browsing, item triage, and drag-reorder. Published to npm as `tenbo-dashboard`. Editor-agnostic — works for Claude Code, Cursor, and Codex users.\n\n## Install\n\nOne line — detects which editor(s) you have installed (Claude Code, Cursor, Codex) and installs tenbo for each, plus the optional `tenbo-dashboard` companion. Safe to re-run as an updater.\n\n```bash\ncurl -fsSL https://raw.githubusercontent.com/poyi/tenbo/main/install.sh | bash\n```\n\nSame `.tenbo/` data on disk works for every supported editor — a project set up in one is portable to the others.\n\n\u003e **What does it do?** Run `--dry-run` first if you want to see exactly what changes:\n\u003e ```bash\n\u003e curl -fsSL https://raw.githubusercontent.com/poyi/tenbo/main/install.sh | bash -s -- --dry-run\n\u003e ```\n\u003e\n\u003e Other useful flags:\n\u003e - `--list` — show the editor matrix and exit\n\u003e - `--only cursor` (or `--only claude` / `--only codex`) — install for one editor only\n\u003e - `--minimal` — skip the npm dashboard install\n\u003e - `--help` — full reference\n\u003e\n\u003e For reproducible installs, pin a tag instead of `main`:\n\u003e ```bash\n\u003e curl -fsSL https://raw.githubusercontent.com/poyi/tenbo/v0.4.0/install.sh | bash\n\u003e ```\n\nThat's it. Open your editor in a project and ask: **\"set up tenbo\"**.\n\n### Manual install (if you'd rather not curl-pipe a script)\n\nThe installer just runs `git clone` + `cp -r` under the hood. If you'd rather do it by hand:\n\n```bash\n# Clone once\ngit clone https://github.com/poyi/tenbo.git /tmp/tenbo\n\n# Claude Code skill (only if you use Claude Code)\nmkdir -p .claude/skills \u0026\u0026 cp -r /tmp/tenbo/skill/ .claude/skills/tenbo/\n\n# Cursor rule (only if you use Cursor)\nmkdir -p .cursor/rules \u0026\u0026 cp -r /tmp/tenbo/cursor/. .cursor/rules/\n\n# Codex skill (only if you use Codex)\nmkdir -p \"${CODEX_HOME:-$HOME/.codex}/skills\" \u0026\u0026 cp -r /tmp/tenbo/skill/ \"${CODEX_HOME:-$HOME/.codex}/skills/tenbo/\"\n\n# Optional dashboard\nnpm install -g tenbo-dashboard@latest\n\nrm -rf /tmp/tenbo\n```\n\nOpen your editor and ask: **\"set up tenbo\"**.\n\n\u003e **Allowlist tip for Cursor:** to avoid permission prompts when tenbo runs CLI commands, add `npx tenbo-dashboard *` to Cursor's auto-run allowlist (Settings → Features → Agent → Auto-run).\n\n#### If tenbo doesn't activate\n\nCursor's Agent Requested mode loads rules based on intent inferred from the message. It's mostly invisible, but a few patterns are worth knowing if the agent doesn't pick up tenbo when you'd expect:\n\n| Reliability | What to type |\n|---|---|\n| **Most reliable** — phrases that mention \"tenbo\" by name | `\"set up tenbo\"`, `\"refresh tenbo\"`, `\"update tenbo\"`, `\"tenbo, track this: \u003cidea\u003e\"`, `\"what does tenbo say I should build next?\"`, `\"populate tenbo for [layer]\"` |\n| **Mostly reliable** — natural-language phrases (Claude-Code-style) | `\"what should I build next?\"`, `\"this code is getting messy\"`, `\"finished the auth system\"`, `\"can this scale to multiplayer?\"` |\n| **Always works** — explicit `@`-mention | `@tenbo` (forces the entry rule into context; from there the intent router takes over) |\n\nIf you find natural-language phrases consistently miss in your Cursor setup, mention \"tenbo\" explicitly or `@tenbo` once at the start — both prime the rule for the rest of the session.\n\n### What happens next (all supported editors)\n\n1. The agent detects the skill / rule and offers to set up tenbo (\"Want me to map the project structure?\")\n2. tenbo creates a `.tenbo/` directory in your repo with architecture docs, roadmaps, and layer definitions\n3. From then on, tenbo listens for planning signals, tracks work, and maintains docs as you code\n\n## Getting started\n\nThe first prompt depends on whether you're starting fresh or layering tenbo onto something that already exists.\n\n### Brand new codebase\n\nYou haven't written code yet — or you have a scaffold and not much more. tenbo works conversationally: it asks what you're building, proposes a structure, and seeds a starter roadmap so you have somewhere to begin.\n\n```\n\"Set up tenbo. I want to build [a 2D farming sim / a habit tracker / a pricing API].\"\n```\n\nWhat happens: tenbo asks a couple of questions about who it's for, proposes 3–5 product-shaped layers (e.g. \"Inventory\", \"Day Cycle\", \"Save System\" — not \"controllers\" and \"models\"), and writes a `.tenbo/` directory with empty layer skeletons and 3–5 starter roadmap items derived from your description. You leave the conversation with a plan, not just an empty repo.\n\n```\n\"What should I build first?\"\n```\n\nBest follow-up. Picks one of the seeded items, with a short rationale.\n\n### Existing codebase\n\nYou already have a working project — possibly a messy one — and you want tenbo to map what's there before you do anything else.\n\n```\n\"Set up tenbo.\"\n```\n\nWhat happens: tenbo scans your source tree, detects workspaces (monorepo or single app), proposes 5–10 product-shaped layers per scope, asks you to confirm or adjust, then writes the `.tenbo/` scaffolding. It also imports any existing `ROADMAP.md`, GitHub issues, and TODO/FIXME comments it finds, classifying them into the right layers. Setup ends with an inline health summary — file counts, doc-drift findings, hotspot signals — and offers to capture the most important ones as roadmap items.\n\n```\n\"What should I work on first?\"\n```\n\nIf the health scan surfaced anything critical, this picks it up. Otherwise it points you at the highest-priority `next` item from imported issues.\n\n```\n\"Document the [auth / billing / X] layer.\"\n```\n\nUse this when you want tenbo to populate a layer's `intent.md` and `code-map.md` in depth — responsibilities, boundaries, key files, extension recipes. Best for a layer you understand well so you can correct anything tenbo gets wrong.\n\n### Example prompts (everyday use)\n\n| Say this | What tenbo does |\n|---|---|\n| `\"What should I build next?\"` | Reads your current roadmap, weighs `now`/`next`/priority/blockers, and recommends 2–4 items with a short rationale — not a queue dump. |\n| `\"Add OAuth support later\"` | Captures it as a `later` roadmap item under the right layer, with a one-line note. No follow-up questions unless the layer is ambiguous. |\n| `\"This code is getting messy\"` | Runs a health pass — hotspots, doc drift, coupling — and proposes a prioritized cleanup plan. Picks the top 2–3 issues, not all of them. |\n| `\"Finished the auth system\"` | Marks the matching item done, refreshes the layer's docs to match the code, runs validation, and stamps the completion. |\n| `\"Can this scale to multiplayer?\"` | Reads architecture and principles, surfaces the layers and invariants that would break, and gives a yes/no with the specific risks. |\n| `\"What does this app do?\"` | Plain-language summary built from the project overview and per-layer narratives — useful for new contributors or for jogging your own memory. |\n| `\"Refresh tenbo\"` | Re-scans the tree, updates layer file globs, and recomputes health findings. Run this after a significant refactor. |\n| `\"Update tenbo\"` | Checks GitHub + npm for newer skill or dashboard versions, semver-compares, and walks you through any updates. |\n| `\"Complete all next items\"` | Dispatches a subagent per item in `next`, runs each through the completion bar, and reports a batch summary. Has guardrails on batch size and cost.|\n\n## Install the dashboard (optional)\n\nThe dashboard is a local web UI that visualizes the same `.tenbo/` files your AI assistant maintains. Skill / rule package and dashboard read and write the same data — edits in one show up in the other on next refresh.\n\n```bash\n# Run in your project directory (where .tenbo/ lives)\nnpx tenbo-dashboard\n```\n\nOpens at http://localhost:5174 (or the next available port).\n\n### What the dashboard gives you\n\nThree views, each solving a different problem AI-assisted projects accumulate over time.\n\n#### Roadmap — \"What should I work on next?\"\n\n![tenbo dashboard — kanban board view](docs/images/dashboard-kanban.png)\n\nA kanban board across `now` / `next` / `later` / `done`, grouped by scope and layer. Drag to reprioritize, click to edit, see at a glance what's in flight versus blocked. The roadmap is the same one your AI assistant reads — when you say \"what should I build next?\", this is what's behind the answer. Useful when planning a week, triaging a backlog dump, or showing someone else what's happening on the project without scrolling git log.\n\n#### Docs — \"What does this project actually do?\"\n\n![tenbo dashboard — docs view](docs/images/dashboard-docs.png)\n\nThe project overview, principles, and glossary in one place — alongside per-layer narratives, intents (responsibilities + boundaries + invariants), and code maps (entry points + key files + extension recipes). This is the cure for the \"I haven't touched this codebase in a month and I have no idea where anything lives\" problem. New contributors (human or AI) can read the docs view to get oriented in minutes instead of grep-ing for an hour.\n\n#### Health — \"Where is this codebase quietly rotting?\"\n\n![tenbo dashboard — health view](docs/images/dashboard-health.png)\n\nA surface for the things that would otherwise become tech debt nobody mentions: layers that have grown past healthy thresholds (hotspots), code-map references that no longer match real files (doc drift), unreferenced source files that may indicate orphaned code, coupling violations, dead code. Each finding carries a severity, the file it points at, and a suggested fix. Catches drift early — when it costs an afternoon to address — instead of after it costs a refactor sprint.\n\n### Dashboard CLI tools\n\nThe same package ships a few commands the skill uses behind the scenes (and that you can run yourself):\n\n```bash\nnpx tenbo-dashboard item show sk-030 --json\nnpx tenbo-dashboard item set-status sk-030 done\nnpx tenbo-dashboard item add-note sk-030 \"Implemented; live verification pending\"\nnpx tenbo-dashboard item verify sk-030 --status pending_live --evidence \"npm test -- --run\"\nnpx tenbo-dashboard item link-commit sk-030 7fc09a5\nnpx tenbo-dashboard items --status done --verification pending_live --json\nnpx tenbo-dashboard next --json\nnpx tenbo-dashboard context feature --query \"help me build X\" --json\nnpx tenbo-dashboard validate          # Schema + consistency checks\nnpx tenbo-dashboard init-check        # Strict completeness check after fresh init\nnpx tenbo-dashboard metrics --all     # Recompute scope metrics + health findings\nnpx tenbo-dashboard next-id \u003cprefix\u003e  # Allocate next roadmap item ID\nnpx tenbo-dashboard --version         # Print the installed version\n```\n\nInstalled packages also expose a shorter `tenbo` binary alias for the same commands.\n\nThe `context feature` command is the agent fast path: it turns a natural-language\nbuild request into a compact JSON bundle with likely scope/layers, matching roadmap\nitems, active work, goal refs, files to read, and context freshness warnings.\n\n### Opt-in: stricter local validation\n\nA pre-commit hook that runs the deterministic validator on `.tenbo/` before every commit. Catches duplicate IDs, broken refs, and schema violations before they enter history. Pure JavaScript, sub-second, no LLM calls.\n\n```bash\nnpx tenbo-dashboard hook install      # See exactly what would change first: --dry-run\nnpx tenbo-dashboard hook uninstall    # Idempotent and surgical\n```\n\nErrors block the commit; warnings print but don't block. Existing `.git/hooks/pre-commit` (or `.husky/pre-commit`) is preserved — tenbo chains rather than clobbers. Bypass per-commit with `git commit --no-verify`.\n\n## How it works\n\ntenbo maintains a `.tenbo/` directory in your repo:\n\n```\n.tenbo/\n├── workspace.yaml          # Scopes, prefixes, project metadata\n├── overview.md             # Project vision and constraints\n├── principles.md           # Architectural principles\n├── glossary.md             # Project-specific terminology\n├── agent-context.md        # Session briefing (auto-generated)\n├── roadmap.yaml            # Cross-cutting roadmap items\n└── scopes/\n    └── \u003cscope\u003e/\n        ├── architecture.yaml   # Layers, file globs, dependencies\n        ├── roadmap.yaml        # Scope-specific roadmap items\n        └── layers/\n            └── \u003clayer\u003e/\n                ├── README.md       # Plain-English narrative\n                ├── intent.md       # Responsibilities, boundaries, invariants\n                └── code-map.md     # Entry points, key files, dependencies\n```\n\nAll files are plain YAML and Markdown — human-readable, version-controlled, and editable by hand.\n\n## Updating\n\nUpdates are user-initiated. Just ask your AI assistant in any session:\n\n```\n\"Update tenbo\"\n```\n\ntenbo detects every install path that exists — the Claude Code skill (`.claude/skills/tenbo/`), the Cursor rule package (`.cursor/rules/tenbo*.mdc`), the Codex skill (`${CODEX_HOME:-$HOME/.codex}/skills/tenbo/`), and the `tenbo-dashboard` npm package — and checks each against its remote. Updates happen in lockstep: if a newer skill or rule requires a newer dashboard than you have, tenbo refuses the editor-package update first and walks you through upgrading the dashboard, so the two never drift out of sync. Your project data in `.tenbo/` is never touched.\n\nOther prompts that work:\n\n```\n\"Is tenbo up to date?\"\n\"Check for tenbo updates\"\n```\n\n### Manual update\n\nIf you'd rather update by hand:\n\n```bash\ngit clone --depth 1 https://github.com/poyi/tenbo.git /tmp/tenbo\n\n# Claude Code skill (only if installed)\ncp -r /tmp/tenbo/skill/ .claude/skills/tenbo/\n\n# Cursor rule (only if installed)\ncp -r /tmp/tenbo/cursor/. .cursor/rules/\n\n# Codex skill (only if installed)\ncp -r /tmp/tenbo/skill/ \"${CODEX_HOME:-$HOME/.codex}/skills/tenbo/\"\n\nrm -rf /tmp/tenbo\n\n# Dashboard (only if installed)\nnpm install -g tenbo-dashboard@latest\n```\n\n## Troubleshooting\n\n### Stale npx cache\n\n`npx` caches packages locally. If you previously ran an older `tenbo-dashboard`, the cache may keep serving the old binary even after a new version is published. Symptoms: commands that should exist don't, or bugs that were fixed reappear.\n\n**Fix:** force the latest version:\n\n```bash\nnpx tenbo-dashboard@latest\n```\n\nOr clear the npx cache entirely:\n\n```bash\nnpx clear-npx-cache\n```\n\nThen run `npx tenbo-dashboard` normally.\n\n\u003e **Tip:** The installer (`install.sh`) checks for stale cached versions automatically and warns you if the resolved binary is older than the latest published release.\n\n### Dashboard shows \"Loading...\" for a long time\n\nFirst launch on a cold cache takes ~10 seconds while Vite optimizes the dependency graph. If it persists beyond that, check the terminal for errors. Running `npx tenbo-dashboard@latest` (see above) rules out stale-cache issues.\n\n## Requirements\n\n- **Skill / rule package**: Any project. Works with any language — Rust, Python, Go, TypeScript, etc. Requires [Claude Code](https://claude.ai/code), [Cursor](https://cursor.com), or Codex.\n- **Dashboard**: Node.js 18+.\n\n## License\n\nMIT. See [LICENSE](LICENSE).\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fpoyi%2Ftenbo","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fpoyi%2Ftenbo","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fpoyi%2Ftenbo/lists"}