Dal lifecycle manager — wake, sleep, sync AI agent containers

GitHub repository AGPL-3.0 License

한국어

Architecture

LXC: dalcenter
├── dalcenter serve HTTP API + Docker management
│ ├── repo-watcher git fetch/pull every 2min → auto sync on .dal/ changes
│ ├── cred-watcher token expiry detection → auto refresh
│ ├── scheduled-dalroot pipeline surveillance (orphan issues, stale PRs, merge directives)
│ ├── ops-watcher multi-team health polling → auto wake empty teams
│ ├── leader-watcher leader health check → auto recovery
│ └── issue-watcher GitHub issue polling → auto wake on issue link
│
├── Docker: leader (claude) dalcli-leader inside — team routing & task assignment
├── Docker: dev (claude) dalcli inside — core development
├── Docker: reviewer (codex) dalcli inside — independent code review
└── Docker: dev-2 (claude) multiple instances supported
dalbridge (CT or same host)
└── MM outgoing webhook → SSE stream relay (:4280)
dalroot (Proxmox host)
└── Claude Code with infrastructure management charter
 ├── dalroot-listener SSE stream → inbox file delivery
 ├── dalroot-check-notifications inbox reader (Claude Code hook)
 └── dalroot-register session registration + MM identity

Binaries

Scope Matrix

 dalcenter (operator) dalcli-leader (lead) dalcli (member)
Infrastructure
 serve O - -
 init O - -
 validate O - -
Lifecycle
 wake O (all) O (own team) -
 sleep O (all) O (own team) -
Observation
 ps O (all) O (own team) O (own team)
 status O (all) O (own team) O (self only)
 logs O (all) O (own team) -
 attach O (all) O (own team) -
Sync
 sync O O -
Collaboration (Mattermost)
 assign - O (to members) -
 report - - O (to leader)

Dal Roles

Active Roles

Template Roles (.dal/template/)

API Endpoints

Read (no auth)

Write (Bearer token required)

dalbridge — MM Webhook-to-SSE Relay

Endpoints

Message Flow

User types in Mattermost channel
 → MM outgoing webhook → dalbridge POST /webhook
 → Normalize to streamMessage {text, username, channel, gateway, post_id, timestamp}
 → SSE broadcast to all connected clients
 → dal containers (GET /stream) receive and process mentions
 → dalroot-listener (GET /stream) writes to inbox files

Configuration

ACK Flow

dalroot — Infrastructure Management

Notification Pipeline

Mattermost (#dalcenter, #host, ...)
 │
 ▼ outgoing webhook
dalbridge (:4280/webhook)
 │
 ▼ SSE stream (:4280/stream)
dalroot-listener (host daemon)
 │
 ▼ file write
/var/lib/dalroot/inbox/{dalroot-id}/*.msg
 │
 ▼ Claude Code hook (UserPromptSubmit)
dalroot-check-notifications → stdout → dalroot processes

Scripts (proxmox-host-setup/dalroot/)

Claude Code Hooks (dalroot)

{
 "hooks": {
 "SessionStart": [{"type": "command", "command": "dalroot-register"}],
 "UserPromptSubmit": [{"type": "command", "command": "dalroot-check-notifications"}],
 "Notification": [{"type": "command", "command": "dalroot-check-notifications"}]
 }
}

Guardrail Hooks

Scheduled Pipeline Surveillance

Automation Pipeline

Human (creates GitHub issue)
 → scheduled dalroot (watches issues, sends reminders)
 → dal team (implements via branch + PR)
 → dal-control channel (reports progress)
 → Human (approves/directs via emoji or comment)

Installation

Prerequisites

Build

go build -o /usr/local/bin/dalcenter ./cmd/dalcenter/
go build -o /usr/local/bin/dalcli ./cmd/dalcli/
go build -o /usr/local/bin/dalcli-leader ./cmd/dalcli-leader/
go build -o /usr/local/bin/dalbridge ./cmd/dalbridge/

Docker Images

cd dockerfiles && docker build -t dalcenter/claude:latest -f claude.Dockerfile .

Quick Start

# 1. Start the daemon
dalcenter serve --addr :11190 --repo /path/to/your-project \
 --mm-url http://mattermost:8065 --mm-token TOKEN --mm-team myteam
# 2. Initialize localdal in your project
dalcenter init --repo /path/to/your-project
# 3. Create dal templates (via git)
# .dal/leader/dal.cue + instructions.md
# .dal/dev/dal.cue + instructions.md
# .dal/skills/code-review/SKILL.md
# 4. Validate
dalcenter validate
# 5. Wake dals
dalcenter wake leader
dalcenter wake dev
dalcenter ps
# 6. Sleep when done
dalcenter sleep --all

CLI Reference

dalcenter (operator)

dalcenter serve # daemon (HTTP API + watchers + Docker)
dalcenter init --repo <path> # initialize localdal (.dal/ + subtree)
dalcenter wake <dal> [--all] # create Docker container
dalcenter sleep <dal> [--all] # stop Docker container
dalcenter sync # propagate .dal/ changes to running containers
dalcenter validate [path] # CUE schema + reference validation
dalcenter status [dal] # show dal status
dalcenter ps # list awake dals
dalcenter logs <dal> # container logs
dalcenter attach <dal> # enter container
dalcenter tell <repo> "<msg>" # send message to another team's leader

dalcli-leader (inside leader container)

dalcli-leader wake <dal> # wake team member
dalcli-leader sleep <dal> # sleep team member
dalcli-leader ps # list team members
dalcli-leader status <dal> # member status
dalcli-leader logs <dal> # member logs
dalcli-leader sync # sync .dal/ changes
dalcli-leader assign <dal> <task> # assign task via @mention

dalcli (inside member containers)

dalcli status # own status
dalcli ps # team member list
dalcli report <message> # report to leader

How It Works

Wake Flow

dalcenter wake dev
 1. Read .dal/dev/dal.cue → player, skills, git config
 2. Create Docker container (dalcenter/claude:latest)
 3. Convert instructions.md → CLAUDE.md (bind mount)
 4. Mount skills/ → ~/.claude/skills/ (bind mount)
 5. Mount .credentials.json (read-only)
 6. Mount service repo → /workspace (bind mount)
 7. Inject GitHub token (from dal.cue git.github_token)
 8. Inject dalcli/dalcli-leader binary (docker cp)
 9. Create Mattermost bot account + join channel
 10. Set env: DAL_NAME, DAL_UUID, DAL_ROLE, DALCENTER_URL, GH_TOKEN

Sync Flow

.dal/ change → git push (GitHub)
 → repo-watcher detects remote changes (within 2min)
 → git pull --ff-only
 → diff .dal/ → runSync()
 → bind mount files (instructions.md, skills/) → instant reflection
 → dal.cue structure change (player, skills) → container auto-restart

Issue Workflow

POST /api/issue-workflow {issue_id, member, task}
 → pending → waking (wake member with issue branch)
 → assigned (send task via @mention)
 → working (track execution)
 → done/failed (notify dalroot via MM)

localdal Structure

.dal/
 dal.spec.cue schema definition
 leader/
 dal.cue uuid, player, role:leader
 charter.md role charter
 instructions.md → CLAUDE.md at wake
 dev/
 dal.cue uuid, player, role:member
 charter.md
 instructions.md
 skills/ shared skill pool
 code-review/SKILL.md
 testing/SKILL.md
 git-workflow/SKILL.md
 ...
 template/ cross-team reusable templates
 auditor/
 config-manager/
 dalops/
 test-writer/
 dal-infra/
 skills/ shared template skills
 dalroot/
 dal.cue infrastructure management role
 charter.md

dal.cue

uuid: "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
name: "dev"
version: "1.0.0"
player: "claude"
role: "member"
channel_only: true
skills: ["skills/code-review", "skills/testing"]
hooks: []
git: {
 user: "dal-dev"
 email: "dal-dev@myproject.dev"
 github_token: "env:GITHUB_TOKEN"
}

File Name Conversion

Communication

Credentials

Token Refresh

Environment Variables

Contributing