Lockstep CLI

MCP文档知识

提供方 未标注

文档知识 stdio · 本地进程 会话登录 社区 / 第三方 ClaudeCursorVS CodeCline
查看接入方式

为 AI 编码代理提供决策记忆。一次捕获决策,并在每个代理行动前向其简要说明,这样后续会话就不会与先前的选择相矛盾。

一句话选型结论

按资料字段整理

Lockstep CLI 属于文档知识类 MCP 服务器,stdio · 本地进程,会话登录,可直接接入 Claude、Cursor、VS Code 等,有可直接执行的安装命令。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类文档知识 传输方式stdio · 本地进程 鉴权会话登录 部署方式本地部署
GitHub 星标 未标注 仓库热度,无公开仓库时显示未标注
工具数 未标注 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

文档知识
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量未标注暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

支持客户端

适用场景

记忆

安装与配置

stdio · 本地进程 会话登录
客户端在本机拉起子进程,数据不出本机
npx lockstep-cli onboard

这条命令只是入口,具体启动参数请按官方文档补齐,不要直接照搬到别的服务器。

  1. 1
    准备运行环境

    stdio 服务在本地起进程,需要先装好 Node.js 等运行时,再按安装命令拉取依赖。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后随便调一个只读工具,确认能返回结果,再接入正式流程。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
文档检索问答

在你的文档库里按问题找答案。

知识库读写

把新资料写进知识库,随用随取。

内容整理

把零散资料归纳成结构化笔记。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 有现成的安装命令,不用自己找入口,照着跑就能起服务。
  • 已适配 Claude、Cursor、VS Code,换客户端不用重新研究配置。

先想清楚的地方

  • stdio 方式要求本地装好运行时(如 Node.js),换机器要重新装一遍。
  • 使用前要准备好会话登录对应的凭据,并按最小权限配置。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在文档知识场景里让模型直接调用外部能力的人。
  • 已经在用 Claude、Cursor 的用户,接入路径最短。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 完全不想在本地装环境的人。
  • 不方便管理密钥或第三方授权的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Lockstep CLI当前 未标注 stdio · 本地进程 本地部署 有 2026-11-20
dify 未标注 stdio · 本地进程 本地部署 有 2026-04-11
open-webui 未标注 stdio · 本地进程 本地部署 有 2026-04-11
JeecgBoot 未标注 stdio · 本地进程 本地部署 有 2026-04-11
Cherry Studio 未标注 未标注 未标注 无 2026-05-17
mempalace 未标注 stdio · 本地进程 本地部署 有 2026-04-11

服务器档案

文档知识
字段来自项目仓库与公开索引,中文说明由本站标注
提供方未标注上游标注的维护方 未标注
分类文档知识本站按上游分类展示
连接方式stdio · 本地进程客户端在本机拉起子进程,数据不出本机
鉴权方式会话登录远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · 未标注本地安装时用到的包标识与运行时
部署类型本地部署上游给出的部署形态
最近核验2026-11-20上游最后核验时间

详细介绍

20.5 KB
来自项目仓库与上游目录的原文,未做删改

Lockstep AI

Your team's decisions, briefed to every Claude Code session — before it writes code.

Lockstep keeps the decisions your team already made — who made them, what evidence supported them, and whether they're still true — and briefs every agent on the ones that apply, highest blast radius first. So no session writes code against a decision that's already changed.

Website ·
▶ Try it live ·
Quick start ·
For product managers ·
How it works ·
Deploy

Lockstep is free and open source. If it helps your team keep decisions straight, star the repo on GitHub so other teams can find it.


Yesterday, you and Claude renamed POST /login to POST /session. Today, a fresh session writes a client against the old route. The decision was made; the next session never received it.

CLAUDE.md is one file in one repo, and auto memory lives on one machine. Neither knows what a teammate decided yesterday, the rule your PM approved, or the standard your lead published last week. Lockstep gives the whole team one decision record — and briefs every agent on it before it acts.

Can your team answer these six questions about any important change?

  1. What request started this?
  2. What evidence supported it?
  3. Who made the decision?
  4. Who approved it?
  5. What did it replace?
  6. Is it still true?

If the answer lives in Slack, a PRD, or someone's memory, your agents don't have it either. Lockstep records each answer with its source — and briefs the next session on it.

One record, three ways in:

  • Developers: keep accepted decisions across Claude Code sessions and check whether changed code may contradict them.
  • Product managers: turn a product brief into reviewed requirements, track revisions, and copy a useful implementation brief before a developer joins.
  • Engineering leaders: publish standards and skills once, roll them out to every engineer's Claude Code by team, repo, or path, and see which version landed where (Standards & Skills).
  • Teams: share the same ledger, route interface changes to affected services, and retain existing integrations, permissions, and PR enforcement.

For example, accept “exports expire after 24 hours, except internal previews.” A later Claude session receives that decision without another explanation. A PM can trace the requirement to its source, revise it for review, and share its accepted version with a developer.

Start with one real repo or brief. Invite a colleague when there is useful context to share; company-wide onboarding is not required.

npx lockstep-cli onboard

How it compares

Lockstep is not session memory. Session memory explains what one agent saw or tried; Lockstep keeps the team decisions that remain true across sessions, models, repositories, and people.

Nothing CLAUDE.md in git Session memory (e.g. claude-mem) Lockstep
Records a decision with owner + approval ❌ Manual ❌ ✅
Versions a decision when it's replaced — the old one stays visible ❌ ❌ ❌ ✅
Briefs the next session on what's binding ❌ Whole file, unranked Recalls past context ✅ Ranked by blast radius
Routes a change to the services that consume it ❌ ❌ ❌ ✅ Dependency graph
Fails a PR that contradicts a binding decision ❌ ❌ ❌ ✅ PR-time gate
"Does anyone use this endpoint?" answered instantly Manual Manual ❌ ✅ From the graph

How It Works

Start with your own next session:```text
You accept: “Use POST /session; POST /login is retired.”
→ Lockstep keeps the accepted decision.
→ Your next Claude session receives it before you start coding.
→ An opted-in check can flag changed code that may contradict it.


A **decision** is a durable rule or architectural choice that shapes future work. A **change** is a routine event — captured, but only surfaced when it matters. A PM can establish the same continuity by reviewing requirements from a brief before any code is connected.

### As teammates join

The same ledger grows into coordination across developers and repos. For example, a route change in one service can reach the developers whose services consume it:```
  Dev A's agent                  Lockstep                       Dev B's agent
  ─────────────                  ────────                       ─────────────
  logs a decision  ───────▶  ┌─────────────────┐
  "auth → /session"          │  Decision ledger │
                             │  Usage graph     │  blast radius
  changes a surface ──────▶  │  Impact ranking  │  decides who
  POST /session              │  Inboxes         │  cares & how much
                             └────────┬─────────┘
                                      │  routes to the services that
                                      ▼  consume the changed surface
                              Dev B's next session begins with:
                              ⚠ [impact 3] auth: /login → /session (binding)
                              → B's agent uses /session before writing a line
  1. Capture — A coding-agent hook diffs the working tree and publishes changes with a canonical surface ID (http:POST /session, proto:auth.v1.Auth/Login). When an agent makes a real decision, it logs it with propose_decision.
  2. Rank — Each decision and change gets an impact score = how many services consume the affected surface (its blast radius). This is what keeps signal high and noise quiet.
  3. Route — Changes fan out to exactly the repos that declared a dependency on the changed surface (lockstep.yaml). The agent can also ask consumers("http:GET /orders/:id") — "does anyone use this?" — and get an answer from the graph instead of pinging a human.
  4. Replay — On session start, each agent receives a briefing of what changed and what's binding since it was last here, highest blast radius first — so it's aware before it acts.
  5. Bind — Cross-cutting decisions (high impact) stay open until an affected team acknowledges them; own-area decisions bind on assertion. A PR-time gate fails any contract change with no binding decision.

Quick Start

Choose your starting point: developer or product manager. Both use the full dashboard and the same project history.

> Status: pilot. CLI 0.4.0 is on npm and the hosted dashboard. Session briefings, hooks, and managed skills support Claude Code today; any MCP client can call the tools, and other agent adapters are on the roadmap.

For developers

Requires Node.js 20+, Claude Code, a GitHub account, and a Git repo with an origin remote.```bash
cd your-project
npx lockstep-cli onboard


1. **Preview locally.** Inspect candidate documentation and proposed Claude configuration changes before approving setup. Select which documents to upload, or skip import and enter a decision manually.
2. **Connect, scan, and review.** Sign in with GitHub and connect the intended project. Onboarding runs `scan --apply`: it writes or merges `lockstep.yaml`, preserving existing entries, and seeds the graph with detected produced surfaces and matched dependencies. Then review up to five decision proposals. Remaining drafts stay in **Review**. Imports do not become accepted decisions automatically.
3. **Choose hosted checks separately.** Automatic code checks have their own remembered opt-in. Declining them leaves decision continuity available.
4. **Open Claude Code.** Approve the project MCP server when prompted. Onboarding distinguishes **configured**, **connected**, **decisions ready**, and **agent verified**. Use `npx lockstep-cli status` to inspect configuration and recorded agent verification. Configuration alone is not activation.
5. **Return, share, and invite.** Later sessions receive current decisions and relevant updates. Use the dashboard's **Preview decision brief** → **Copy decision brief**, or print Markdown with `npx lockstep-cli brief`. When the scan finds outbound calls with no declared producer and relevant Git history, onboarding also suggests recent contributors to the calling files and prints an invite command.

For example, an unmatched `http:POST /billing/charge` call in `src/checkout.ts` can point you to a colleague who recently edited that file. These are leads to ask about the missing dependency, not verified owners; an unmatched call may also target an external service. Confirm the GitHub handle and invite each person you choose:```bash
npx lockstep-cli invite <github-handle>

Suggestions do not send invitations automatically. You can share a useful brief with the colleague first.```bash
npx lockstep-cli onboard --dry-run # preview without configuring or uploading
npx lockstep-cli check --upload # explicitly authorize this one working-diff check
npx lockstep-cli check --base main --upload
npx lockstep-cli checks on # enable automatic hosted checks for this checkout
npx lockstep-cli checks off # disable them independently of the ledger


For non-interactive runs, authenticate first and use `--yes` to proceed beyond preview:```bash
npx lockstep-cli onboard --yes --no-docs --disable-checks
npx lockstep-cli onboard --yes --upload-docs --docs CLAUDE.md,docs/adr/auth.md --disable-checks

--yes approves setup; it does not authorize document uploads or enable hosted checks. --no-docs skips documentation import, while --upload-docs explicitly authorizes uploading the selected candidate documents (--docs narrows that selection). Neither skips the repository scan and graph setup. Non-interactive imports remain drafts for dashboard review. Use --enable-checks or --disable-checks to set check consent explicitly; otherwise saved consent is retained.

Checks are advisory and report completed, partial, skipped, or unavailable. Missing providers or applicable rules do not produce a pass. Automatic checks have a six-second API deadline and never block Claude. Raw diff hunks are processed transiently; stored results contain status, decision references, locations, and feedback.

Onboarding respects LOCKSTEP_API_URL and saved API settings; hosted is the default only when neither exists. Generated Claude commands use a version-pinned npm invocation, so a global Lockstep installation is unnecessary. Decision packs stay local and Git-ignored.

For product managers

Start with a brief, without a repo, CLI, or developer. Sign in with GitHub at the dashboard, then:

  1. Create a project. Use Start with one product brief on the dashboard home page. New pilot projects enable the product layer; joining an existing project preserves its settings.
  2. Paste your brief in Sources. Give it a title and, optionally, a feature reference such as feature:private-exports. Save it and inspect the extracted requirements alongside their source evidence. If extraction is unavailable, open the saved brief and use Select requirements manually to choose exact source passages.
  3. Review and ratify. Inspect the source, set its state to active when ready, and edit, reject, or ratify requirements through Review and Decisions. Drafts and questions remain distinct from accepted requirements.
  4. Use the implementation brief. Open the source and choose Preview implementation brief, review the Markdown, then Copy implementation brief. It includes accepted requirements, rationale and source references, drafts, unresolved questions, and recorded concerns. You have a useful handoff before anyone installs Lockstep.
  5. Revise with history. Edit the saved source when the product brief changes. Previous source versions remain available; changed requirements return to review before the accepted brief is regenerated. Pasted briefs are manually maintained, not synchronized with an external document.
  6. Invite a developer when ready. Use Members & Repos to invite their GitHub handle to this exact project. Share the brief and its project/feature connection command. Their Claude sessions can then receive the relevant ratified requirements.

For example, a PM can start with “exports expire after 24 hours; internal previews are exempt; bulk downloads are out of scope.” Review those requirements, leave “Should expiry be configurable?” as an unresolved question, and copy the implementation context before involving engineering.

Once development is connected, use the existing decision, feature, check, and activity views to review recorded context and concerns. Delivered requirements and no recorded concerns do not mean a feature is complete. Useful-concern, false-positive, and intentional-exception feedback does not silently change a decision.

Copying Markdown does not publish it, send a message, or grant access. Dashboard links remain authenticated. A product colleague joining a developer-created project uses the same dashboard and ledger, with no CLI setup.

Join an existing project

After the project owner invites your GitHub handle, sign in again to activate the invitation. Developers connect their repo to the supplied project ID:```bash
npx lockstep-cli onboard --project-id <project-id> --feature feature:private-exports


Omit `--feature` when no feature is selected. This reuses the project&#x27;s ledger and history. Each developer installs personal Claude hooks; product colleagues work in the dashboard.

### For teams and self-hosting

Existing B2B integrations, roles, review requirements, and GitHub PR checks remain available. The new semantic code checks are advisory; they do not replace the existing contract gate. The individual pilot starts with Claude Code; other adapters are deferred.

Onboarding already runs `scan --apply` to establish `lockstep.yaml` and seed the surface graph. When routes or dependencies change, use `npx lockstep-cli scan` to preview updates and `npx lockstep-cli scan --apply` to merge and sync them. The standalone command also retries a scan that was incomplete during onboarding. See `lockstep.example.yaml`. Independent `login`, `init`, `connect`, `scan`, and `pack` commands remain available.

Self-host with Docker```bash
git clone https://github.com/lockstep-team-agent/lockstep.git
cd lockstep
cp .env.example .env
docker compose up --build   # Postgres + API (:8080) + dashboard (:3000)

Point the CLI at your server:```bash
npx lockstep-cli login --api http://localhost:8080


For local development with the dev-login bypass enabled, use:```bash
npx lockstep-cli login --api http://localhost:8080 --dev --dev-id 1 --dev-login alice

The API needs an extraction provider (ANTHROPIC_API_KEY, or the existing TYPESAFE_API_KEY provider) for automatic imports, and TYPESAFE_API_KEY for advisory checks. Manual requirements remain usable without extraction. Set LOCKSTEP_CHECKS_ENABLED=0 to disable semantic checking server-side without disabling the ledger or existing B2B PR checks.

For production, configure real GitHub authentication, set NODE_ENV=production and LOCKSTEP_DEV_LOGIN=0, apply migrations, and verify provider configuration, request limits, backups, and both onboarding paths. See DEPLOY.md.

What flows through Lockstep

Object What it is
Decision A durable rule or architectural choice. The hero. Impact-ranked, versioned (CAS).
Change A routine event on a canonical surface. Routed to consumers by blast radius.
Question A cross-team ask, ideally answered from the ledger before a human is pinged.
Task Delegated work, fanned out to the assignee's inbox.

Standards & Skills (organizations) — Claude Code pilot

Behind LOCKSTEP_STANDARDS=1 (see DEPLOY.md), an organization can define how agents should work and prove what reached each checkout. This is a Claude Code pilot, not the complete PRD: pausing/resuming a rollout, Codex, enrolling a repo-free PM workspace, readiness checks for a skill's declared tools, owner reassignment and linking supporting decisions in the standard editor, and author-facing conflict flagging are not built yet. The Map graph shows the first page of an expanded domain (the Outline lists everything).

  • Standards & Skills — versioned standards (requirements with stable keys and required/recommended levels), skills authored in Lockstep or imported from a public GitHub repo at an exact commit, and checks (PRD sections, PRD rubric, advisory code review). Published versions are immutable; members draft and propose, owners/admins publish.
  • Rollouts & Adoption — assign exact versions by project, repository, team or person, path and task type; preview the impact before applying; pilot, expand, roll back, retire or withdraw. Adoption reports coverage, installation, session availability, invocation (reported as unobservable where the agent can't show it) and check outcomes separately.
  • In the work — enrolled checkouts (lockstep enroll) receive managed skills in .claude/skills/lockstep-org-*/ (kept out of git, verified by hash, never executed, never overwritten when edited locally). Session briefings list the applicable requirements with exact versions and point to the relevant skills; the copyable project brief carries the same for repo-free PRD work. Exceptions are requested and approved per requirement, bind to the exact published version (a new version needs a new review), and expire on their own.
Agent Install managed skills Session availability Invocation Checks
Claude Code (verified on 2.1.281) Yes — .claude/skills/lockstep-org-*/ Yes — which versions a session started with Unobservable Code-diff via lockstep check consent; PRD checks in the dashboard
Codex Not supported yet — — —

Agents & integration

The individual pilot supports Claude Code only, with session-start briefings, MCP tools, local decision packs, and optional completion checks. Explicit CLI/MCP operations remain available if hooks are unavailable. No model calls run after every edit.

The ledger remains vendor-neutral and the existing team integrations are retained. Codex and other individual-onboarding adapters are deferred.

CLI Commands

Use npx lockstep-cli without installing a global binary, or lockstep if installed globally.

Command · What it does
onboard [--project-id ] [--dry-run] · Preview inputs, connect, scan the repo, review decisions, and configure Claude
onboard --yes --no-docs · Proceed past setup confirmation and skip documentation import
onboard --yes --upload-docs [--docs ] · Approve setup and document upload; optionally narrow candidates with comma-separated paths
login [--api ] · Authenticate with GitHub and optionally save your server
init --vendor claude · Configure Claude independently of onboarding
connect [--project ] [--project-id ] · Create or join the intended project
scan [--apply] / sync · Preview/apply a dependency manifest, or sync the existing manifest
pack [--check] · Refresh the local decision pack or check its freshness
check [--base ] [--upload] · Check tracked changes against relevant accepted decisions
checks on / checks off · Enable or revoke automatic hosted diff checks
brief · Print a copyable project decision brief
invite · Invite a colleague to the connected project
status / doctor · Inspect configuration, connection, and verification status
uninstall [--dry-run] · Remove Lockstep-managed Claude entries while retaining ledger history
enroll [--yes] · Opt this checkout in to your organization's managed skills (Standards & Skills)
skills [status\ · sync\ · restore\ · keep\ · accept\ · decline\ · unenroll] · Sync or resolve managed org skills; sync also runs at every session start

Project Structure```

packages/core/ # Fastify API + PostgreSQL (Drizzle ORM), RLS-isolated, append-only ledger
packages/cli/ # lockstep-cli — onboarding, continuity, advisory checks, MCP server
packages/web/ # Next.js dashboard — briefs, review, decisions, features, team workflows
actions/pr-check # GitHub Action — PR-time reconciliation gate
```

Learn more

  • Built on row-level-security Postgres, an append-only CAS-versioned decision ledger, and vendor-neutral MCP adapters. Self-host with docker compose or deploy to Railway.

License

Apache 2.0 © 2026 Naman Jain

常见问题

8 问
答案由本站依据条目字段整理,不引用上游原文
Lockstep CLI 怎么安装?

在客户端按下面的安装命令接入:npx lockstep-cli onboard。装完在客户端配置里引用同一个包或端点。

Lockstep CLI 怎么在 Claude、Cursor、VS Code 里配置?

它的传输方式是stdio · 本地进程,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

Lockstep CLI 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

Lockstep CLI 需要 API Key 吗?

资料标注需要会话登录认证,使用前准备好对应凭据,并按最小权限配置。

Lockstep CLI 支持哪些客户端?

资料标注支持 Claude、Cursor、VS Code、Cline、Codex、Zed;其他客户端只要能配置 MCP Server,也能用同样的命令或地址接入。

Lockstep CLI 能提供哪些能力?

资料显示能力标签包括 记忆。具体工具清单以官方文档为准。

Lockstep CLI 需要什么运行环境?

属于本地进程,需要在本机装好运行环境。

Lockstep CLI 是本地还是远程?

它是本地进程(stdio),由客户端在本机拉起。传输方式为stdio · 本地进程。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 2026-11-20。