cairn-work 0.7.1 → 0.8.0

package/README.md

@@ -1,241 +1,160 @@
-# Cairn 🦮
+# Cairn
 
-AI-native project management where markdown files are the source of truth.
+Project management for AI agents. Markdown files are the source of truth.
 
-## Quick Start
+## Setup
 
 ```bash
 npm install -g cairn-work
 cairn onboard
 ```
 
-That's it! Cairn will detect your AI agent (Clawdbot, Claude Code, Cursor, etc.) and configure everything automatically.
+This creates a workspace and writes two context files your agent reads automatically:
 
-## What is Cairn?
+- **`CLAUDE.md`** — Compact reference for day-to-day operations (statuses, CLI commands, autonomy rules)
+- **`.cairn/planning.md`** — Full guide for creating projects and tasks with real content
 
-Cairn is a project management system designed for working with AI agents. Instead of databases and web UIs, Cairn uses simple markdown files that both you and your AI agent can read and edit.
+No agent-specific configuration. Any AI agent that can read files is ready to go.
 
-**Key features:**
-- **Files are the source of truth** - No database, just markdown
-- **AI-native** - Designed for AI agents to understand and work with
-- **Agent detection** - Auto-configures for Clawdbot, Claude Code, Cursor, Windsurf
-- **Simple hierarchy** - Projects → Tasks
-- **Status tracking** - pending, active, review, blocked, completed
+## How it works
 
-## Installation
+You and your AI agent share a folder of markdown files. Projects have charters. Tasks have objectives. Status fields track where everything stands — like a kanban board backed by text files.
 
-### Global Install (Recommended)
-
-```bash
-npm install -g cairn-work
-# or
-bun install -g cairn-work
 ```
-
-### Test Locally
-
-```bash
-git clone https://github.com/gregoryehill/cairn-cli.git
-cd cairn-cli
-bun install
-bun link
+~/cairn/
+  CLAUDE.md                        # Agent context (auto-generated)
+  .cairn/planning.md               # Planning guide (auto-generated)
+  projects/
+    launch-app/
+      charter.md                   # Why, success criteria, context
+      tasks/
+        setup-database.md          # Individual task
+        build-api.md
+        deploy.md
+  inbox/                           # Ideas to triage
 ```
 
-## Commands
-
-### `cairn onboard`
+### The workflow
 
-Set up Cairn and configure your AI agent automatically.
+1. **You create a project** — tell your agent what you want to build. It creates the project and tasks using `cairn create`, fills in real content (not placeholders), and sets everything to `pending`.
 
-```bash
-cairn onboard                    # Auto-detect agent
-cairn onboard --agent clawdbot   # Specific agent
-cairn onboard --force            # Re-run onboarding
-```
+2. **You manage the board** — move tasks to `next_up` or `in_progress` when you're ready to start. Or tell your agent "work on the API task" and it picks it up.
 
-### `cairn init`
+3. **The agent keeps status updated** — when it starts a task, it moves to `in_progress`. When it finishes, it moves to `review` (so you can approve) or `completed` (if you gave it full autonomy). If it gets stuck, it moves to `blocked` and tells you what it needs.
 
-Initialize workspace without agent configuration.
+4. **You always know where things stand** — statuses are the shared language. The agent is accountable for keeping them accurate.
 
-```bash
-cairn init                # Create workspace in current directory
-cairn init --path /custom # Custom location
-```
+### Statuses
 
-### `cairn create`
+`pending` · `next_up` · `in_progress` · `review` · `blocked` · `completed`
 
-Create projects and tasks.
+### Autonomy
 
-```bash
-# Create a project
-cairn create project "Launch My App"
+Each task has an autonomy level that controls what the agent can do:
 
-# Create a task
-cairn create task "Set up database" \\
-  --project launch-my-app
-```
+| Level | Agent behavior | Finishes as |
+|-------|---------------|-------------|
+| `propose` | Plans the approach, doesn't do the work | `review` |
+| `draft` | Does the work, no irreversible actions | `review` |
+| `execute` | Does everything, including deploy/publish/send | `completed` |
 
-### `cairn doctor`
+Default is `draft` — the agent works but you approve before anything ships.
 
-Check workspace health and fix issues.
-
-```bash
-cairn doctor
-```
+## Commands
 
-### `cairn update-skill`
+### `cairn onboard`
 
-Update agent skill documentation.
+Set up workspace and write agent context files.
 
 ```bash
-cairn update-skill              # Update all detected agents
-cairn update-skill --agent cursor  # Specific agent
+cairn onboard                  # Interactive setup
+cairn onboard --path ./mywork  # Non-interactive, specific path
+cairn onboard --force          # Re-run on existing workspace
 ```
 
-### `cairn update`
+### `cairn create`
 
-Check for and install CLI updates.
+Create projects and tasks. Always pass real content — the CLI enforces `--description` and `--objective`.
 
 ```bash
-cairn update  # Check npm for latest version and prompt to upgrade
-```
+cairn create project "Launch App" \
+  --description "Ship the MVP by March" \
+  --objective "We need to validate the idea with real users" \
+  --criteria "App live on production, 10 beta signups" \
+  --context "React Native, Supabase backend, deploy to Vercel"
 
-## Supported Agents
-
-Cairn auto-detects and configures:
-
-- **[Clawdbot](https://clawd.bot)** - Full integration via skills system
-- **Claude Code** - Workspace context integration
-- **Cursor** - .cursorrules integration
-- **Windsurf** - Workspace integration
-- **Generic** - Manual setup instructions for any AI agent
-
-## How It Works
-
-### File Structure
-
-```
-~/cairn/
-  projects/
-    launch-my-app/
-      charter.md           # Project overview
-      tasks/
-        setup-database.md  # Individual task
-        deploy-api.md      # Another task
-  inbox/                   # Incoming ideas
-  _drafts/                 # Work in progress
+cairn create task "Set up database" \
+  --project launch-app \
+  --description "Configure Supabase tables and RLS policies" \
+  --objective "Database schema matches the data model, RLS prevents cross-tenant access"
 ```
 
-### Project → Task
-
-**Project** - A goal or initiative (e.g., "Launch My App")
-**Task** - An atomic piece of work (e.g., "Set up database")
-
-### Status Workflow
-
-`pending` → `active` → `review` → `completed`
-
-Or if blocked: `active` → `blocked` → `active`
-
-### Working with AI Agents
-
-After onboarding, your agent understands how to:
-- Create and update projects/tasks
-- Follow status workflows
-- Log work with timestamps
-- Ask for input when blocked
-
-**Example conversation:**
-```
-You: "Help me plan out my app launch"
-Agent: "I'll create a project structure. What's your app called?"
-You: "TaskMaster - a todo app"
-Agent: *creates project with tasks for backend, frontend, deployment*
-```
+### `cairn doctor`
 
-## Updates
+Check workspace health — verifies folder structure, `CLAUDE.md`, and `.cairn/planning.md` exist.
 
 ```bash
-cairn update
+cairn doctor
 ```
 
-Checks npm for the latest version and prompts to upgrade.
+### `cairn update-skill`
+
+Refresh `CLAUDE.md` and `.cairn/planning.md` with the latest templates (e.g. after a CLI update).
 
-Or update manually:
 ```bash
-npm update -g cairn
+cairn update-skill
 ```
 
-Updates only affect the CLI and agent skills. Your workspace files are never touched.
-
-## Configuration
+### `cairn update`
 
-Cairn uses sensible defaults:
-- **Workspace:** Current directory or `~/cairn`
-- **Agent detection:** Automatic
-- **Files:** Plain markdown with YAML frontmatter
+Check for a new CLI version and install it.
 
-Override workspace location:
 ```bash
-export CAIRN_WORKSPACE=/custom/path
+cairn update
 ```
 
-## Philosophy
-
-1. **Context is King** - Keep all context in one place
-2. **Files > Databases** - Text files are portable and future-proof
-3. **Simple Beats Complete** - Start simple, add complexity when needed
-4. **AI-First** - Designed for human-AI collaboration
-
-## Troubleshooting
+## File format
 
-### Agent not detected
+All files use YAML frontmatter + markdown sections.
 
-```bash
-cairn doctor              # Check setup
-cairn onboard --force     # Re-run onboarding
-```
-
-### Workspace issues
+**Charter** (`charter.md`):
+```yaml
+---
+title: Launch App
+status: in_progress
+priority: 1
+default_autonomy: draft
+---
 
-```bash
-cairn doctor              # Auto-fix common issues
-cairn init --path ~/cairn  # Recreate structure
+## Why This Matters
+## Success Criteria
+## Context
+## Work Log
 ```
 
-### Skill not updating
+**Task** (`tasks/setup-database.md`):
+```yaml
+---
+title: Set up database
+assignee: agent-name
+status: pending
+autonomy: draft
+---
 
-```bash
-cairn update-skill        # Refresh agent skill
+## Objective
+## Work Log
 ```
 
-## Development
+The agent logs all work in the `## Work Log` section with timestamps and its name.
 
-```bash
-git clone https://github.com/gregoryehill/cairn-cli.git
-cd cairn-cli
-bun install
-bun link                  # Test locally
-```
+## Troubleshooting
 
-Run tests:
 ```bash
-bun test
+cairn doctor              # Diagnose issues
+cairn onboard --force     # Regenerate context files
+cairn update-skill        # Refresh templates after CLI update
 ```
 
-## Contributing
-
-Contributions welcome! Open an issue or PR on GitHub.
-
 ## License
 
-MIT © Gregory Hill
-
-## Links
-
-- **GitHub:** https://github.com/gregoryehill/cairn-cli
-- **npm:** https://www.npmjs.com/package/cairn
-
----
-
-Built with ❤️ for AI-human collaboration
+MIT

package/bin/cairn.js

@@ -21,6 +21,8 @@ program
 import onboard from '../lib/commands/onboard.js';
 import init from '../lib/commands/init.js';
 import create from '../lib/commands/create.js';
+import list from '../lib/commands/list.js';
+import log from '../lib/commands/log.js';
 import doctor from '../lib/commands/doctor.js';
 import updateSkill from '../lib/commands/update-skill.js';
 import update from '../lib/commands/update.js';
@@ -48,6 +50,7 @@ program
   .option('--project <slug>', 'Parent project (required for tasks)')
   .option('--assignee <name>', 'Assignee name', 'you')
   .option('--status <status>', 'Initial status', 'pending')
+  .option('--autonomy <level>', 'Autonomy level: propose, draft, or execute (tasks only)', 'draft')
   .option('--due <date>', 'Due date (YYYY-MM-DD)')
   .option('--description <text>', 'Short description')
   .option('--objective <text>', 'Detailed objective')
@@ -55,6 +58,26 @@ program
   .option('--context <text>', 'Background context (projects only)')
   .action(create);
 
+// List command - query and filter tasks
+program
+  .command('list <entity>')
+  .description('List tasks with optional filtering')
+  .option('--status <statuses>', 'Filter by status (comma-separated: pending,in_progress,blocked)')
+  .option('--assignee <name>', 'Filter by assignee')
+  .option('--project <slug>', 'Filter by project')
+  .option('--due-before <date>', 'Filter by due date (YYYY-MM-DD)')
+  .option('--overdue', 'Show only overdue tasks')
+  .option('--format <format>', 'Output format (table|json)', 'table')
+  .action(list);
+
+// Log command - add work log entries to tasks
+program
+  .command('log <task-slug> <message>')
+  .description('Add a work log entry to a task')
+  .option('--title <text>', 'Custom log entry title (default: "Update")')
+  .option('--project <slug>', 'Project to search for the task')
+  .action(log);
+
 // Doctor command - check workspace health
 program
   .command('doctor')

package/lib/commands/create.js

@@ -156,6 +156,15 @@ async function createTask(workspacePath, name, slug, options) {
     process.exit(1);
   }
 
+  // Validate autonomy level if provided
+  const validAutonomy = ['propose', 'draft', 'execute'];
+  const autonomy = options.autonomy || 'draft';
+  if (!validAutonomy.includes(autonomy)) {
+    console.error(chalk.red('Error:'), `Invalid autonomy level: ${autonomy}`);
+    console.log(chalk.dim('Valid values:'), validAutonomy.join(', '));
+    process.exit(1);
+  }
+
   // Create task file
   const taskSection = (text) => text ? `\n${expandNewlines(text)}\n` : '\n';
   const task = `---
@@ -165,7 +174,7 @@ assignee: ${options.assignee || 'you'}
 status: ${options.status || 'pending'}
 created: ${getToday()}
 due: ${options.due || getDueDate(7)}
-autonomy: draft
+autonomy: ${autonomy}
 spend: 0
 artifacts: []
 ---

package/lib/commands/list.js

@@ -0,0 +1,231 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import chalk from 'chalk';
+import yaml from 'js-yaml';
+
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return null;
+  
+  try {
+    return yaml.load(match[1]);
+  } catch (error) {
+    return null;
+  }
+}
+
+function findAllTasks(workspacePath, projectFilter = null) {
+  const tasks = [];
+  const projectsDir = join(workspacePath, 'projects');
+  
+  if (!existsSync(projectsDir)) {
+    return tasks;
+  }
+  
+  const projects = readdirSync(projectsDir).filter(item => {
+    const path = join(projectsDir, item);
+    return statSync(path).isDirectory();
+  });
+  
+  for (const project of projects) {
+    // Skip if filtering by project and this doesn't match
+    if (projectFilter && project !== projectFilter) {
+      continue;
+    }
+    
+    const tasksDir = join(projectsDir, project, 'tasks');
+    if (!existsSync(tasksDir)) {
+      continue;
+    }
+    
+    const taskFiles = readdirSync(tasksDir).filter(file => file.endsWith('.md'));
+    
+    for (const taskFile of taskFiles) {
+      const taskPath = join(tasksDir, taskFile);
+      try {
+        const content = readFileSync(taskPath, 'utf8');
+        const frontmatter = parseFrontmatter(content);
+        
+        if (frontmatter) {
+          tasks.push({
+            project,
+            file: taskFile.replace('.md', ''),
+            path: taskPath,
+            ...frontmatter
+          });
+        }
+      } catch (error) {
+        console.error(chalk.yellow('Warning:'), `Failed to parse ${taskPath}`);
+      }
+    }
+  }
+  
+  return tasks;
+}
+
+function filterTasks(tasks, options) {
+  let filtered = [...tasks];
+  
+  // Filter by status
+  if (options.status) {
+    const statuses = options.status.split(',').map(s => s.trim());
+    filtered = filtered.filter(task => statuses.includes(task.status));
+  }
+  
+  // Filter by assignee
+  if (options.assignee) {
+    filtered = filtered.filter(task => task.assignee === options.assignee);
+  }
+  
+  // Filter by project
+  if (options.project) {
+    filtered = filtered.filter(task => task.project === options.project);
+  }
+  
+  // Filter by due date
+  if (options.dueBefore) {
+    const dueDate = new Date(options.dueBefore);
+    filtered = filtered.filter(task => {
+      if (!task.due) return false;
+      return new Date(task.due) <= dueDate;
+    });
+  }
+  
+  // Filter overdue
+  if (options.overdue) {
+    const today = new Date();
+    today.setHours(0, 0, 0, 0);
+    filtered = filtered.filter(task => {
+      if (!task.due) return false;
+      const dueDate = new Date(task.due);
+      return dueDate < today && task.status !== 'completed';
+    });
+  }
+  
+  return filtered;
+}
+
+function formatAsTable(tasks) {
+  if (tasks.length === 0) {
+    console.log(chalk.dim('No tasks found matching criteria.'));
+    return;
+  }
+  
+  // Calculate column widths
+  const projectWidth = Math.max(7, ...tasks.map(t => t.project.length));
+  const titleWidth = Math.max(5, ...tasks.map(t => (t.title || t.file).length));
+  const statusWidth = Math.max(6, ...tasks.map(t => (t.status || '').length));
+  const assigneeWidth = Math.max(8, ...tasks.map(t => (t.assignee || '').length));
+  const dueWidth = 10;
+  
+  // Header
+  console.log(
+    chalk.bold('Project'.padEnd(projectWidth)) + '  ' +
+    chalk.bold('Title'.padEnd(titleWidth)) + '  ' +
+    chalk.bold('Status'.padEnd(statusWidth)) + '  ' +
+    chalk.bold('Assignee'.padEnd(assigneeWidth)) + '  ' +
+    chalk.bold('Due')
+  );
+  
+  console.log(
+    '─'.repeat(projectWidth) + '  ' +
+    '─'.repeat(titleWidth) + '  ' +
+    '─'.repeat(statusWidth) + '  ' +
+    '─'.repeat(assigneeWidth) + '  ' +
+    '─'.repeat(dueWidth)
+  );
+  
+  // Rows
+  for (const task of tasks) {
+    const project = (task.project || '').padEnd(projectWidth);
+    const title = (task.title || task.file).padEnd(titleWidth);
+    const status = colorizeStatus(task.status || '').padEnd(statusWidth + 10); // +10 for ANSI codes
+    const assignee = (task.assignee || '').padEnd(assigneeWidth);
+    const due = formatDueDate(task.due, task.status);
+    
+    console.log(`${project}  ${title}  ${status}  ${assignee}  ${due}`);
+  }
+  
+  console.log();
+  console.log(chalk.dim(`${tasks.length} task${tasks.length !== 1 ? 's' : ''} found`));
+}
+
+function colorizeStatus(status) {
+  switch (status) {
+    case 'completed':
+      return chalk.green(status);
+    case 'in_progress':
+      return chalk.blue(status);
+    case 'review':
+      return chalk.magenta(status);
+    case 'blocked':
+      return chalk.red(status);
+    case 'next_up':
+      return chalk.yellow(status);
+    case 'pending':
+      return chalk.gray(status);
+    default:
+      return status;
+  }
+}
+
+function formatDueDate(due, status) {
+  if (!due) return chalk.dim('—');
+  
+  // Handle both string and Date objects
+  const dueString = due instanceof Date ? due.toISOString().split('T')[0] : due;
+  const dueDate = new Date(dueString);
+  const today = new Date();
+  today.setHours(0, 0, 0, 0);
+  
+  const formatted = dueString; // YYYY-MM-DD format
+  
+  if (status === 'completed') {
+    return chalk.dim(formatted);
+  }
+  
+  if (dueDate < today) {
+    return chalk.red(formatted + ' ⚠');
+  }
+  
+  const daysUntilDue = Math.ceil((dueDate - today) / (1000 * 60 * 60 * 24));
+  
+  if (daysUntilDue <= 3) {
+    return chalk.yellow(formatted);
+  }
+  
+  return formatted;
+}
+
+function formatAsJSON(tasks) {
+  console.log(JSON.stringify(tasks, null, 2));
+}
+
+export default async function list(entity, options) {
+  const workspacePath = join(homedir(), 'pms');
+  
+  if (!existsSync(workspacePath)) {
+    console.error(chalk.red('Error:'), 'Workspace not found. Run:', chalk.cyan('cairn init'));
+    process.exit(1);
+  }
+  
+  if (entity !== 'tasks') {
+    console.error(chalk.red('Error:'), `Unknown entity: ${entity}`);
+    console.log(chalk.dim('Valid entities: tasks'));
+    process.exit(1);
+  }
+  
+  // Find all tasks
+  const allTasks = findAllTasks(workspacePath, options.project);
+  
+  // Apply filters
+  const filtered = filterTasks(allTasks, options);
+  
+  // Format output
+  if (options.format === 'json') {
+    formatAsJSON(filtered);
+  } else {
+    formatAsTable(filtered);
+  }
+}

package/lib/commands/log.js

@@ -0,0 +1,219 @@
+import { existsSync, readdirSync, readFileSync, writeFileSync, statSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+import { resolveWorkspace } from '../setup/workspace.js';
+
+function getAgentName() {
+  // Try $USER first
+  if (process.env.USER) {
+    return process.env.USER;
+  }
+  
+  // Try git config
+  try {
+    const gitName = execSync('git config user.name', { encoding: 'utf8' }).trim();
+    if (gitName) return gitName;
+  } catch (error) {
+    // Git not configured or not available
+  }
+  
+  // Fallback
+  return 'Agent';
+}
+
+function getTimestamp() {
+  const now = new Date();
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, '0');
+  const day = String(now.getDate()).padStart(2, '0');
+  const hours = String(now.getHours()).padStart(2, '0');
+  const minutes = String(now.getMinutes()).padStart(2, '0');
+  
+  return `${year}-${month}-${day} ${hours}:${minutes}`;
+}
+
+function findTaskBySlug(workspacePath, taskSlug, projectFilter = null) {
+  const projectsDir = join(workspacePath, 'projects');
+  
+  if (!existsSync(projectsDir)) {
+    return null;
+  }
+  
+  const projects = readdirSync(projectsDir).filter(item => {
+    const path = join(projectsDir, item);
+    return statSync(path).isDirectory();
+  });
+  
+  for (const project of projects) {
+    // Skip if filtering by project and this doesn't match
+    if (projectFilter && project !== projectFilter) {
+      continue;
+    }
+    
+    const tasksDir = join(projectsDir, project, 'tasks');
+    if (!existsSync(tasksDir)) {
+      continue;
+    }
+    
+    const taskFile = `${taskSlug}.md`;
+    const taskPath = join(tasksDir, taskFile);
+    
+    if (existsSync(taskPath)) {
+      return {
+        path: taskPath,
+        project,
+        slug: taskSlug
+      };
+    }
+  }
+  
+  return null;
+}
+
+function addLogEntry(content, timestamp, title, agentName, message) {
+  const lines = content.split('\n');
+  
+  // Find Work Log section
+  let workLogIndex = -1;
+  let nextSectionIndex = -1;
+  
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    
+    // Look for Work Log header (## Work Log)
+    if (line === '## Work Log') {
+      workLogIndex = i;
+    } else if (workLogIndex !== -1 && line.startsWith('## ') && i > workLogIndex) {
+      // Found the next section after Work Log
+      nextSectionIndex = i;
+      break;
+    }
+  }
+  
+  // Prepare the log entry
+  const logTitle = title || 'Update';
+  const logEntry = [
+    `### ${timestamp} - ${logTitle}`,
+    `[${agentName}] ${message}`,
+    ''
+  ];
+  
+  if (workLogIndex === -1) {
+    // Work Log section doesn't exist, add it at the end
+    const newSection = [
+      '',
+      '## Work Log',
+      '',
+      ...logEntry
+    ];
+    return lines.join('\n') + '\n' + newSection.join('\n');
+  }
+  
+  // Work Log section exists
+  if (nextSectionIndex === -1) {
+    // Work Log is the last section, append at the end
+    const beforeWorkLog = lines.slice(0, workLogIndex + 1).join('\n');
+    const afterWorkLog = lines.slice(workLogIndex + 1).join('\n');
+    
+    // Remove trailing newlines from afterWorkLog
+    const trimmedAfter = afterWorkLog.trimEnd();
+    
+    return beforeWorkLog + '\n\n' + (trimmedAfter ? trimmedAfter + '\n\n' : '') + logEntry.join('\n');
+  }
+  
+  // Work Log has content and another section follows
+  const beforeWorkLog = lines.slice(0, workLogIndex + 1).join('\n');
+  const workLogContent = lines.slice(workLogIndex + 1, nextSectionIndex).join('\n').trimEnd();
+  const afterWorkLog = lines.slice(nextSectionIndex).join('\n');
+  
+  return beforeWorkLog + '\n\n' + (workLogContent ? workLogContent + '\n\n' : '') + logEntry.join('\n') + '\n' + afterWorkLog;
+}
+
+export default async function log(taskSlug, message, options) {
+  // Try to resolve workspace, fallback to ~/pms for compatibility
+  let workspacePath = resolveWorkspace();
+  
+  if (!workspacePath) {
+    // Fallback to ~/pms (common default)
+    const fallbackPath = join(homedir(), 'pms');
+    if (existsSync(join(fallbackPath, 'projects'))) {
+      workspacePath = fallbackPath;
+    }
+  }
+  
+  if (!workspacePath) {
+    console.error(chalk.red('Error:'), 'No workspace found. Run:', chalk.cyan('cairn init'));
+    process.exit(1);
+  }
+  
+  if (!taskSlug) {
+    console.error(chalk.red('Error:'), 'Missing task slug');
+    console.log(chalk.dim('Usage:'), chalk.cyan('cairn log <task-slug> <message>'));
+    console.log(chalk.dim('Example:'), chalk.cyan('cairn log implement-auth "Added OAuth2 flow"'));
+    process.exit(1);
+  }
+  
+  if (!message) {
+    console.error(chalk.red('Error:'), 'Missing log message');
+    console.log(chalk.dim('Usage:'), chalk.cyan('cairn log <task-slug> <message>'));
+    console.log(chalk.dim('Example:'), chalk.cyan('cairn log implement-auth "Added OAuth2 flow"'));
+    process.exit(1);
+  }
+  
+  // Find the task
+  const task = findTaskBySlug(workspacePath, taskSlug, options.project);
+  
+  if (!task) {
+    if (options.project) {
+      console.error(chalk.red('Error:'), `Task "${taskSlug}" not found in project "${options.project}"`);
+    } else {
+      console.error(chalk.red('Error:'), `Task "${taskSlug}" not found in any project`);
+      console.log(chalk.dim('Tip:'), 'Use', chalk.cyan('--project <slug>'), 'to search within a specific project');
+    }
+    process.exit(1);
+  }
+  
+  // Read the task file
+  let content;
+  try {
+    content = readFileSync(task.path, 'utf8');
+  } catch (error) {
+    console.error(chalk.red('Error:'), `Failed to read task file: ${error.message}`);
+    process.exit(1);
+  }
+  
+  // Get timestamp and agent name
+  const timestamp = getTimestamp();
+  const agentName = getAgentName();
+  
+  // Add log entry
+  const updatedContent = addLogEntry(content, timestamp, options.title, agentName, message);
+  
+  // Write back atomically (write to temp file, then rename)
+  const tempPath = task.path + '.tmp';
+  try {
+    writeFileSync(tempPath, updatedContent, 'utf8');
+    writeFileSync(task.path, updatedContent, 'utf8');
+    
+    // Clean up temp file
+    try {
+      if (existsSync(tempPath)) {
+        // Note: In production, we'd use fs.unlinkSync here, but for atomic writes
+        // we're doing a direct write above
+      }
+    } catch (cleanupError) {
+      // Ignore cleanup errors
+    }
+    
+    console.log(chalk.green('✓'), `Log entry added to task: ${chalk.cyan(taskSlug)}`);
+    console.log(chalk.dim(`  Project: ${task.project}`));
+    console.log(chalk.dim(`  Time: ${timestamp}`));
+    console.log(chalk.dim(`  Agent: ${agentName}`));
+    console.log(chalk.dim(`  Message: ${message}`));
+  } catch (error) {
+    console.error(chalk.red('Error:'), `Failed to write task file: ${error.message}`);
+    process.exit(1);
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cairn-work",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "description": "AI-native project management - work with AI agents using markdown files",
   "type": "module",
   "bin": {
@@ -34,7 +34,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/gregoryehill/cairn.git"
+    "url": "git+https://github.com/gregoryehill/cairn.git"
   },
   "homepage": "https://cairn.app",
   "bugs": {
@@ -44,10 +44,11 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
-    "commander": "^11.0.0",
     "chalk": "^5.3.0",
-    "ora": "^8.0.0",
-    "inquirer": "^9.2.0"
+    "commander": "^11.0.0",
+    "inquirer": "^9.2.0",
+    "js-yaml": "^4.1.1",
+    "ora": "^8.0.0"
   },
   "devDependencies": {
     "@types/bun": "^1.1.0",