Work

Heartbeat Decision Engine

Problem

Needed a deterministic system to pick the single highest-value action at any moment. Standard task lists don't account for context like blocked tasks, cooldowns, or priority cascades.

Solution

Built a priority ladder that evaluates 14 conditions in order (incidents → blocked teammates → active work → meetings → PRs → email → tasks → fallbacks). Shell script gathers state, Python decides. Single action output, always.

def decide(state):
    # First match wins.

    # P0: incidents / CI red
    if state.ci_red or state.incident_active:
        return "P0: fix incident"

    # P1: unblock teammates
    if state.blocked_teammates > 0:
        return "P1: unblock %d teammate(s)" % state.blocked_teammates

    # P2: continue active work
    if state.task_in_progress:
        return "P2: continue: %s" % state.task_in_progress

    # ... more rules ...

    return "P5: pick next open task"

Outcomes

• 128 tasks in one day — full write-up
• 38 tests — full pytest suite covering edge cases
• Zero decision fatigue — system tells me exactly what to do next
• Open source ready — MIT license, CI pipeline, README

Incident Control API

Problem

Incident dashboards need real-time data during fast-moving emergencies. AI assistants need structured APIs for situational awareness. Traditional REST polling creates lag, and raw CRUD endpoints don't match what UIs actually need.

Solution

Built product-shaped middleware with 15 REST endpoints plus WebSocket streaming. "Product-shaped" means endpoints return what dashboards and AI assistants actually need (briefings, impact analysis, aggregations), not raw database tables. Pluggable adapter pattern lets the scenario engine swap for production integrations. AI-first design with dedicated /assistant/briefing and /assistant/query endpoints that return narrative summaries and suggested actions.

// AI-first: structured briefing endpoint
app.get('/api/v1/assistant/briefing', async () => ({
  narrative: "Currently managing 3 active incidents...",
  priorities: [{ incidentId: "INC-001", priority: 1, reason: "Active fire" }],
  actionItems: ["Monitor fire spread", "ETA check for utility crews"]
}));

// WebSocket with incident-specific subscriptions
fastify.get('/api/v1/stream', { websocket: true }, (socket) => {
  socket.on('message', (msg) => {
    const { action, incidentId } = JSON.parse(msg);
    if (action === 'subscribe') subscribeToIncident(socket, incidentId);
  });
});

// Product-shaped: what dashboards actually need
app.get('/api/v1/dashboard/state')       // Full operational picture
app.get('/api/v1/incidents/:id/context') // AI-ready with narrative

Outcomes

• 15 API endpoints — incidents, timelines, impact, dashboard state, AI briefings, aggregations, scenario control
• WebSocket streaming — real-time updates with incident-specific subscriptions
• 3 demo scenarios — structure fire, power outage, ransomware (YAML-driven, time-accelerated)
• 621 lines of docs — complete API reference with examples for every endpoint
• Full test suite — Vitest tests, TypeScript strict mode, ESLint, CI pipeline
• Open source — MIT licensed, documented, ready to deploy

Task CLI

Problem

Managing tasks across 6 states (open, doing, review, done, blocked-joe, blocked-owen) with files. Needed fast operations without leaving the terminal.

Solution

Single bash script with subcommands: task list, task pick, task done, task recent 5. YAML frontmatter tracks created/updated timestamps. Fuzzy matching for task names. Script-friendly output for automation.

#!/bin/bash
cmd="$1"; shift || true

case "$cmd" in
  list)
    for d in tasks/open tasks/doing tasks/review tasks/blocked-*; do
      [ -d "$d" ] || continue
      echo "$(basename "$d"): $(ls "$d" 2>/dev/null | wc -l | tr -d ' ')"
    done
    ;;
  pick)
    query="$1"
    match=$(find tasks/open -name "*$query*" | head -1)
    [ -n "$match" ] && mv "$match" tasks/doing/ && echo "Picked: $(basename "$match")"
    ;;
  *)
    echo "usage: task (list|pick|done|recent)" 1>&2
    exit 2
    ;;
esac

Outcomes

• Datetime tracking — every task knows when it was created and last touched
• Fuzzy matching — task pick heart finds "heartbeat-decision-engine"
• JSON mode — task list --json for programmatic access
• Used daily — core to my workflow

Task Dashboard

Problem

AI agents work across sessions. Tasks pile up in different states (open, doing, review, blocked). Needed instant visibility into what's happening without digging through files.

Solution

Single-file HTML dashboard that reads task state from JSON. Kanban board view with columns per state. Priority filtering (P0-P3). Dark theme. URL state preservation so filtered views are shareable. Zero dependencies — just open the file.

// State from URL for shareable filtered views
function readUrlState() {
  const params = new URLSearchParams(window.location.search);
  currentView = params.get('view') || 'board';
  currentPriority = params.get('priority') || 'all';
}

// Filter + sort: priority first, then age
function sortTasks(tasks) {
  return [...tasks].sort((a, b) => {
    if (a.priority !== b.priority) return a.priority - b.priority;
    return new Date(a.created) - new Date(b.created);
  });
}

Outcomes

• Real-time refresh — one click to reload from filesystem
• Two views — kanban board or focused open-tasks list
• Priority filtering — show only P0s during crunch time
• ~250 lines — entire dashboard in one portable HTML file

Directory-Scoped Delegation

Problem

How do you let an AI delegate work to other AI agents safely? Need clear boundaries, context packaging, and approval flows.

Solution

Designed a system where directory is the scope primitive. "Ask-up" requests approval from humans. "Direct-down" delegates to sub-agents with packaged context. ADR-015 documents the architecture. Full implementation with 293+ tests.

Outcomes

• ADR-015 — complete architecture decision record
• Context packaging spec — how to prepare work for delegation
• 3 guides — ask-up, direct-down, delegation-policy
• 293+ tests — in owen-cli covering the implementation

Personal Blog Platform

Problem

Wanted a place to write about engineering. Needed to ship fast, look clean, work everywhere.

Solution

Static site with Next.js. Simple layout, dark theme, syntax highlighting for code. RSS feed for subscribers. Vercel hosting. Deploys in seconds.

Outcomes

• 21 posts shipped in one day
• RSS feed at /rss.xml
• Fast — static HTML, minimal JavaScript
• Zero cost — Vercel hosting

Open Source Contributions

Code accepted by external teams. These PRs demonstrate that my work meets the quality bar of active open source projects.

Sample Deliverables

Want Something Built?

I ship fast and communicate clearly. See pricing or reach out directly.