Overview

EgenSkriven is a local-first kanban task manager with CLI and web UI, designed for AI agents from the ground up. It replaces ephemeral todo systems (like TodoWrite) with persistent, structured task tracking.

Quick Start Commands

bash

# Get project status summary
egenskriven context --json

# Get recommended next task
egenskriven suggest --json

# List actionable (unblocked) tasks
egenskriven list --ready --json

# Create a new task
egenskriven add "Task title" --type feature --priority medium

Essential CRUD Operations

Command	Description
`add "title"`	Create task (flags: `--type`, `--priority`, `--column`)
`list`	List tasks (flags: `--ready`, `--column`, `--type`)
`show <ref>`	Display task details
`move <ref> <column>`	Move task between columns
`update <ref>`	Modify task properties
`delete <ref>`	Remove task (`--force` skips confirmation)

Task Reference Formats

Tasks can be referenced by:

•Full ID: abc123def456
•ID prefix: abc (minimum unique prefix)
•Display ID: WRK-123 (board prefix + sequence)
•Title substring: "dark mode" (case-insensitive match)

Columns (Workflow States)

Column	Description
`backlog`	Ideas and future work
`todo`	Ready to start
`in_progress`	Currently being worked on
`need_input`	Blocked, waiting for human input
`review`	Awaiting review
`done`	Completed

JSON Output

All commands support --json for machine-readable output:

bash

# Get specific fields only (reduces tokens)
egenskriven list --json --fields id,title,column

# Full task details
egenskriven show <ref> --json

Exit Codes

Code	Meaning
0	Success
1	General error
2	Invalid arguments
3	Task not found
4	Ambiguous reference
5	Validation error

When to Use EgenSkriven

•Multi-step work spanning multiple exchanges
•Work that might be interrupted
•Features with dependencies
•Bugs that need tracking

Not needed for: Simple questions, one-off commands, trivial changes.

Tool Integrations

Before using the collaborative workflow (blocking tasks, resume flow), initialize the tool integration for your AI coding tool:

OpenCode

bash

egenskriven init --opencode

This creates .opencode/tool/egenskriven-session.ts. When working on a task, call the egenskriven-session tool to get your session ID:

code

Agent: [calls egenskriven-session tool]
Response: { session_id: "abc-123", link_command: "egenskriven session link <task> --tool opencode --ref abc-123" }
Agent: [runs link command to associate session with task]

Claude Code

bash

egenskriven init --claude-code

This creates:

•.claude/hooks/egenskriven-session.sh - Hook script that runs on SessionStart
•.claude/settings.json - Hook configuration (merged with existing settings)

After the hook runs, your session ID is available as $CLAUDE_SESSION_ID. Link your session with:

bash

egenskriven session link <task-ref> --tool claude-code --ref $CLAUDE_SESSION_ID

Codex CLI

bash

egenskriven init --codex

This creates .codex/get-session-id.sh. Get your session ID with:

bash

SESSION_ID=$(.codex/get-session-id.sh)
egenskriven session link <task-ref> --tool codex --ref $SESSION_ID

All Integrations

Generate all tool integrations at once:

bash

egenskriven init --all
egenskriven init --all --force  # Overwrite existing files

Human-AI Collaborative Workflow

EgenSkriven supports a collaborative workflow where AI agents can request human input and resume work once they receive a response. This enables seamless back-and-forth communication between humans and AI coding assistants.

Workflow Overview

code

Agent starts work on task
        │
        ▼
Agent encounters decision point
        │
        ▼
Agent blocks task: egenskriven block <task> "question"
        │
        ▼
Human sees blocked task in UI or CLI
        │
        ▼
Human adds response: egenskriven comment <task> "response"
        │
        ▼
Resume (manual, command, or auto)
        │
        ▼
Agent continues with full context

Setting Up Tool Integration

Before using the collaborative workflow, set up the integration for your AI tool:

OpenCode

bash

egenskriven init --opencode

Creates .opencode/tool/egenskriven-session.ts. Call the egenskriven-session tool to get your session ID.

Claude Code

bash

egenskriven init --claude-code

Creates hooks that set $CLAUDE_SESSION_ID automatically on session start.

Codex CLI

bash

egenskriven init --codex

Creates .codex/get-session-id.sh helper script.

Linking Your Session

Before blocking a task, link your session:

bash

# OpenCode: Call the egenskriven-session tool first, then:
egenskriven session link <task-ref> --tool opencode --ref <session-id>

# Claude Code:
egenskriven session link <task-ref> --tool claude-code --ref $CLAUDE_SESSION_ID

# Codex:
SESSION_ID=$(.codex/get-session-id.sh)
egenskriven session link <task-ref> --tool codex --ref $SESSION_ID

Blocking a Task

When you need human input:

bash

# Block with a question (atomic operation)
egenskriven block <task-ref> "What authentication approach should I use?"

# For longer questions, use stdin
echo "I need to decide between several approaches..." | egenskriven block <task-ref> --stdin

This will:

•Move the task to the need_input column
•Add your question as a comment
•Preserve your session for later resume

Adding Comments

bash

# Add a response comment
egenskriven comment <task-ref> "Use JWT with refresh tokens"

# Add with explicit author
egenskriven comment <task-ref> "Approved" --author "jane"

# Add from stdin for longer responses
cat response.txt | egenskriven comment <task-ref> --stdin

Viewing Comments

bash

# List all comments
egenskriven comments <task-ref>

# As JSON
egenskriven comments <task-ref> --json

# Only recent comments
egenskriven comments <task-ref> --since "2026-01-07T10:00:00Z"

Listing Blocked Tasks

bash

# List all tasks needing input
egenskriven list --need-input

# As JSON
egenskriven list --need-input --json

Resume Modes

Configure per-board:

Mode	Behavior
`manual`	Print command for user to copy
`command`	User runs `egenskriven resume --exec`
`auto`	Auto-resume on `@agent` comment

bash

# Set resume mode
egenskriven board update <board> --resume-mode auto

Resuming Work

Depending on the board's resume mode:

bash

# Print the resume command (manual mode)
egenskriven resume <task-ref>

# Execute the resume directly (command mode)
egenskriven resume <task-ref> --exec

# Use minimal prompt (fewer tokens)
egenskriven resume <task-ref> --exec --minimal

For auto mode, add a comment with @agent and the session will resume automatically.

Example: Complete Workflow

bash

# 1. Agent links session
egenskriven session link WRK-42 --tool opencode --ref abc-123

# 2. Agent works, then gets blocked
egenskriven block WRK-42 "Should I implement REST or GraphQL first?"

# 3. Human responds
egenskriven comment WRK-42 "Start with REST, we'll add GraphQL later"

# 4. Human resumes agent
egenskriven resume WRK-42 --exec

# Agent continues with full context...

Tips

•Always link your session BEFORE blocking a task
•Be specific in your blocking questions
•Use the --json flag for scripting and automation
•Check comments periodically if working on multiple tasks

Related Skills

•egenskriven-workflows - Workflow modes (strict/light/minimal) and agent behaviors
•egenskriven-advanced - Epics, dependencies, sub-tasks, batch operations