devcd 0.2.0

Local developer context daemon with explicit state, memory, and policy layers.

Stop re-explaining your work to every new AI agent session.

DevCD is a local continuity layer for mixed AI-agent setups. It gives a fresh Copilot, Claude, Codex, OpenClaw, or MCP-capable session a policy-filtered Action Packet before it asks you to recap the task.

That packet gives the next agent the current goal, latest failure or blocker, do-not-repeat guidance, one suggested next action, and a clear note when context was withheld by policy. DevCD is the warm-start layer for your agent stack, not another agent runtime to manage.

It is not a model, chat app, remote service, or task runner. DevCD is the local state and policy layer between your workspace and the agents that help you.

Getting Started | Examples | Agent Resurrection | OpenClaw Integration | Real-World Testing Playbook | Context Packs | Security | Release Readiness | Publishing | Brand System | Architecture | Contributing

Status

DevCD is pre-alpha. The core local continuity loop is implemented and tested.

Surface	Status
PyPI install (pip install devcd)	Working
devcd onboard first-run path	Working
Agent Passport / Continuity Packet	Working
Action Packet for the next agent	Working
Read-only MCP resources	Working
OpenClaw MCP shape check	Working on the DevCD side
Context Packs	Developer and research packs built in
PyPI release	Published — devcd 0.2.0
Hosted/cloud mode	Not planned for alpha

See Release Readiness for the full alpha bar.

Install

python -m pip install --disable-pip-version-check --quiet devcd && devcd setup

Use this as the default first-run flow. devcd setup is the install-time wizard: it configures one or multiple projects, lets you select your agent targets, and seeds an initial local handoff so the next agent can continue without an extra manual setup step. The --quiet install keeps first-run output focused.

Want a quick install confirmation first?

devcd smoke

pipx and uvx work too:

pipx install devcd
uvx devcd smoke

From source (contributors only):

git clone https://github.com/mick-gsk/DevCD.git
cd DevCD
python -m pip install -e ".[dev]"

Primary Path

DevCD now has one primary first-run path for real workspaces:

1. Run devcd setup.
2. Select project paths and agent targets in the wizard.
3. Start or resume work from devcd agentic action-packet.

Need proof before touching a real workspace?

devcd agentic action-packet-demo --events examples/agentic-action-packet/sample-events.jsonl

That demo is the shortest honest proof: a fresh agent gets a useful handoff, including withheld-context notes, without a daemon, remote service, or pasted chat recap.

When you are ready for the real workspace, start here:

devcd setup

devcd setup applies the local-first setup path directly and seeds the initial goal plus next action for the first handoff. Use --projects for comma-separated paths and --agents for an explicit target subset.

devcd onboard remains available when you want a single-workspace guided flow with stage-by-stage output (--preview, --yes, --no-tui).

Start from the handoff surface the next agent should read first:

devcd agentic action-packet

By default, devcd setup prepares workspace instruction targets plus a local DevCD startup skill and continuity templates. OpenClaw MCP is optional and can be added explicitly with --agents ...openclaw or via integration commands.

If the local ledger is still empty, seed safe metadata instead of pasting raw logs, transcripts, or file contents:

devcd handoff --goal "Ship the failing release gate" --failure "make check failed on policy tests" --next-action "Inspect the failing policy assertion"
devcd capture --kind goal --summary "Ship the failing release gate"
devcd capture --kind failure --summary "make check failed on policy tests" --next-action "Inspect the failing policy assertion"

Use devcd handoff at the end of a session or before switching agents. Use devcd capture when you want to record one granular continuity fact during work.

Then inspect the broader interactive activation report:

devcd quickstart

Use devcd context passport when you want the broader policy-filtered passport directly.

Optional: connect an MCP-capable runtime such as OpenClaw:

devcd integrations openclaw --smoke-test

Run the local daemon only when you want live API event ingestion:

devcd run

What The Next Agent Gets

An agent that reads DevCD before asking you to recap can see policy-filtered continuity like this:

Goal: Ship the failing release gate
Latest failure: make check failed on policy tests
Do not repeat: rerunning the same patch without checking the policy assertion
Suggested next action: inspect the failing policy assertion
Withheld context: raw logs or sensitive notes were not included by policy

That packet is derived from local structured events and metadata. It is not model memory, not telemetry, and not remote sync.

Why DevCD Exists

Every AI coding tool starts cold unless you manually rebuild context. That means lost time, repeated failed attempts, accidental stale fixes, and unnecessary copy/paste of sensitive context.

DevCD gives agents a local, typed, policy-filtered continuity layer:

• Agent resurrection - new sessions can continue from the previous goal, failure, stale attempts, blockers, and next action.
• Warm-start handoff - the next agent gets a concrete starting point before it asks for a recap.
• Local-first context - data stays on your machine unless a future explicit policy says otherwise.
• Policy visibility - every observation, storage decision, export, or action has an explainable policy reason.
• Structured continuity instead of pasted recap - captures are designed for compact metadata, not raw logs, transcripts, file contents, or secrets.
• Runtime-neutral consumption - CLI, localhost API, and read-only MCP expose the same policy-filtered state to different agent surfaces.

Highlights

• devcd setup - install-time wizard for multi-project config, manual agent-target selection, initial handoff seeding, and immediate Action Packet readiness.
• devcd onboard - single-workspace guided wrapper for config, selected agent instruction files, and staged setup output.
• devcd handoff - one-command goal, failure, and next-action capture before switching to a fresh agent.
• devcd capture - daemonless, policy-gated continuity metadata capture.
• devcd agentic action-packet - next-action packet for the next local agent.
• devcd quickstart - interactive activation report that expands on the same Action Packet workflow after onboarding, including an Agent Layer console.
• devcd context workspace-analysis and devcd context profile - read-only inspectors for the detected workspace layer and persisted profile.
• devcd context passport - broader live continuity view from the configured local ledger.
• devcd context control - visibility report for included and withheld context.
• devcd doctor --fix - policy-gated local repairs for missing config/profile scaffolding.
• devcd mcp serve - read-only local MCP stdio resources.
• devcd integrations openclaw --smoke-test - verifies the local MCP shape without installing OpenClaw or mutating its config.
• devcd recipe research-session - local recipe that proves non-developer continuity through the research Context Pack.
• make distribution - builds and verifies wheel/sdist artifacts and installed CLI behavior.
• make smoke - quick daemonless confidence check for evaluators.

Local Agent Skills

This repo also carries local agent skills for repeatable engineering workflows under .github/skills/.

• agent-ops-observability - diagnose instruction drift, weak handoffs, tool misuse, and missing verification in agent-driven work.
• devils-advocate - stress-test plans, ADRs, policy changes, and rollout ideas before implementation.
• deep-interview, brainstorming, systematic-debugging, and verification-before-completion cover clarification, design, debugging, and evidence discipline.

These are repository workflow assets, not DevCD product features. They exist to make agent work in this repo more reliable and reviewable.

Security Defaults

DevCD is built around local-first privacy boundaries.

• Local storage and loopback API by default.
• No telemetry.
• No remote export by default.
• Observations are policy-gated.
• Actions are denied by default.
• Sensitive or raw-content events are denied or withheld by default.
• MCP exposes read-only resources and no write-capable tools.
• Agent capture should record metadata only, never raw file contents, raw logs, full chat transcripts, private notes, credentials, or secrets.

Read Security before adding any feature that observes, stores, exports, or acts on local context.

OpenClaw And MCP

DevCD can be used as a read-only MCP context source for OpenClaw:

devcd integrations openclaw --smoke-test

The smoke test verifies the DevCD MCP server shape locally: initialize, resources/list, tools/list, and prompts/list. Current expected shape: resources present, tools empty, prompts empty.

DevCD does not claim to be an OpenClaw plugin, ClawHub package, or fully end-to-end verified OpenClaw gateway integration yet. See OpenClaw Integration for the exact claim boundary and config snippet.

Context Packs

Context Packs are DevCD's current extension surface. They define which metadata signals matter for a workflow and how a policy-filtered Continuity Packet should be rendered for an agent surface.

Built-in packs:

• developer - coding-agent continuity across goals, git state, files, failures, blockers, and next actions.
• research - metadata-only research continuity across reviewed sources, hypotheses, decisions, and failed attempts.

List them:

devcd context packs
devcd context packs --json

See Context Packs and Context Pack examples.

Architecture

IDE / Git / Tasks / Notes / Recipes
          |
          v
    Normalized DevEvents
          |
          v
  +---------------------+      +----------------+
  | DevCD Host          | ---> | Policy Layer   |
  | Event API           |      | allow / deny   |
  | State Engine        |      +----------------+
  | Memory Layer        |
  | Ambient Context     | ---> Agent Passport / Action Packet / MCP resources
  +---------------------+
          |
          v
 local JSONL ledger + local memory store

The codebase uses Vertical Slice Architecture. Slice-owned models, API routes, services, and tests live under packages/devcd-core/src/devcd/slices/<slice>/. Shared infrastructure belongs in devcd/kernel/ only when multiple slices need it.

Trust And Public Signals

DevCD should earn trust by making current maturity visible instead of pretending to be more finished than it is.

Signal	Where
Security policy and threat model	SECURITY.md
Alpha readiness and known limitations	Release Readiness
Distribution artifact checks	Publishing
Container sandbox and CI proof path	Container Sandbox
Brand system and project assets	Brand System
Funding configuration	GitHub Sponsors
Community contribution path	Contributing

No PyPI, Homebrew, Discord, hosted service, or production-support badge appears here until that surface actually exists.

Operator Quick Refs

• First run: devcd onboard
• Quick health check: devcd smoke
• Full local verification: make check
• Distribution verification: make distribution
• Local daemon: devcd run
• Agent Passport: devcd context passport
• Action Packet: devcd agentic action-packet
• Context control report: devcd context control
• OpenClaw snippet and shape check: devcd integrations openclaw --smoke-test
• Read-only MCP server: devcd mcp serve

Docs By Goal

• New here: Getting Started, Agent Resurrection, Release Readiness
• Agent runtime integration: Agent Consumption, OpenClaw Integration
• Context and privacy: Security, Policy, Memory, Context Packs
• Examples: Context Brief, Agent Resurrection, Research Continuity, OpenClaw MCP Context
• Internals: Architecture, Decisions, Schemas
• Release work: Publishing, Container Sandbox, Changelog

Development

git clone https://github.com/mick-gsk/DevCD.git
cd DevCD
python -m pip install -e ".[dev]"
make smoke
make check

Useful targets:

make smoke         # daemonless CLI sanity check
make check         # ruff + mypy + pytest
make distribution  # build, twine check, wheel content check, installed CLI smoke
make docs          # strict MkDocs build
make run           # run the local daemon

Configuration

devcd onboard and devcd init create devcd.toml with local-first defaults. The daemon binds to 127.0.0.1:8765 by default, stores runtime data locally, and uses a local bearer token for protected API routes.

Example shape:

[devcd]
host = "127.0.0.1"
port = 8765
runtime_dir = ".devcd"
working_memory_ttl_seconds = 300
allowed_data_classes = ["metadata"]
allow_observation = true
allow_local_storage = true
allow_remote_export = false
allow_actions = false

Roadmap

Milestone	Focus
0.1	Local continuity foundation, Agent Passport, policy layer, read-only MCP
Public alpha	PyPI publish, install docs, release notes, OpenClaw E2E verification
Next	Native IDE event sources, more recipes, pack authoring guide
Later	Policy editor, stable API contracts, broader runtime integrations

DevCD will stay local-first by default. Remote export, write-capable MCP tools, hosted deployment, and arbitrary plugin execution are not part of the first alpha boundary.

Community

DevCD is maintained by Mick Gottschalk. Community contributions are welcome, especially focused bug reports, reproducible Context Pack proposals, Event Recipe proposals, and policy-boundary reviews.

See Contributing, Security, Open issues, and GitHub Sponsors.