@1mancompany/onemancompany 0.7.25 → 0.7.30

package/frontend/app.js

@@ -7528,6 +7528,9 @@ class AppController {
     const tabDefs = [
       { id: 'overview', label: 'Overview' },
       { id: 'issues', label: `Issues (${issues.length})` },
+      { id: 'kanban', label: 'Kanban' },
+      { id: 'roadmap', label: 'Roadmap' },
+      { id: 'activity', label: 'Activity' },
       { id: 'projects', label: `Projects (${projects.length})` },
     ];
     const tabContent = document.createElement('div');
@@ -7559,6 +7562,12 @@ class AppController {
       this._renderProductOverview(product, versions, slug, container);
     } else if (tabId === 'issues') {
       this._renderProductIssues(issues, slug, container, data);
+    } else if (tabId === 'kanban') {
+      this._renderProductKanban(slug, container, data);
+    } else if (tabId === 'roadmap') {
+      this._renderProductRoadmap(slug, container);
+    } else if (tabId === 'activity') {
+      this._renderProductActivity(slug, container);
     } else if (tabId === 'projects') {
       this._renderProductProjects(projects, container);
     }
@@ -8246,6 +8255,322 @@ class AppController {
     }
   }
 
+  // ---------------------------------------------------------------------------
+  // Kanban Board Tab
+  // ---------------------------------------------------------------------------
+
+  _renderProductKanban(slug, container, fullData) {
+    container.innerHTML = '<div class="loading-text">Loading kanban...</div>';
+    fetch(`/api/product/${encodeURIComponent(slug)}/kanban`)
+      .then(r => r.json())
+      .then(data => {
+        container.innerHTML = '';
+        const board = document.createElement('div');
+        board.className = 'kanban-board';
+
+        const statusLabels = {
+          backlog: 'Backlog',
+          planned: 'Planned',
+          in_progress: 'In Progress',
+          in_review: 'In Review',
+          done: 'Done',
+          released: 'Released',
+        };
+        const blockedSet = new Set(data.blocked_ids || []);
+
+        for (const [status, label] of Object.entries(statusLabels)) {
+          const col = document.createElement('div');
+          col.className = 'kanban-column';
+          col.dataset.status = status;
+
+          const colHeader = document.createElement('div');
+          colHeader.className = 'kanban-column-header';
+          const items = data.columns[status] || [];
+          colHeader.textContent = `${label} (${items.length})`;
+          col.appendChild(colHeader);
+
+          const cardList = document.createElement('div');
+          cardList.className = 'kanban-card-list';
+
+          // Drag-drop: allow dropping on column
+          cardList.addEventListener('dragover', (e) => { e.preventDefault(); cardList.classList.add('kanban-drop-target'); });
+          cardList.addEventListener('dragleave', () => cardList.classList.remove('kanban-drop-target'));
+          cardList.addEventListener('drop', (e) => {
+            e.preventDefault();
+            cardList.classList.remove('kanban-drop-target');
+            const issueId = e.dataTransfer.getData('text/plain');
+            if (issueId) {
+              fetch(`/api/product/${encodeURIComponent(slug)}/issue/${encodeURIComponent(issueId)}`, {
+                method: 'PUT',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ status }),
+              }).then(() => this._renderProductKanban(slug, container, fullData));
+            }
+          });
+
+          for (const issue of items) {
+            const card = document.createElement('div');
+            card.className = `kanban-card priority-${(issue.priority || 'p2').toLowerCase()}`;
+            card.draggable = true;
+            card.dataset.issueId = issue.id;
+            if (blockedSet.has(issue.id)) card.classList.add('kanban-blocked');
+
+            card.addEventListener('dragstart', (e) => {
+              e.dataTransfer.setData('text/plain', issue.id);
+              card.classList.add('dragging');
+            });
+            card.addEventListener('dragend', () => card.classList.remove('dragging'));
+
+            const priTag = document.createElement('span');
+            priTag.className = `kanban-priority priority-${(issue.priority || 'p2').toLowerCase()}`;
+            priTag.textContent = issue.priority || 'P2';
+
+            const title = document.createElement('span');
+            title.className = 'kanban-card-title';
+            title.textContent = issue.title;
+
+            const meta = document.createElement('div');
+            meta.className = 'kanban-card-meta';
+            if (issue.assignee_id) {
+              meta.textContent = issue.assignee_id;
+            }
+            if (issue.story_points) {
+              const sp = document.createElement('span');
+              sp.className = 'kanban-sp';
+              sp.textContent = `${issue.story_points}sp`;
+              meta.appendChild(sp);
+            }
+            if (blockedSet.has(issue.id)) {
+              const lock = document.createElement('span');
+              lock.className = 'kanban-blocked-icon';
+              lock.textContent = '🔒';
+              lock.title = 'Blocked by dependency';
+              meta.appendChild(lock);
+            }
+
+            card.appendChild(priTag);
+            card.appendChild(title);
+            card.appendChild(meta);
+            cardList.appendChild(card);
+          }
+
+          col.appendChild(cardList);
+          board.appendChild(col);
+        }
+
+        container.appendChild(board);
+      })
+      .catch(err => { container.innerHTML = `<div class="error-text">Failed to load kanban: ${err.message}</div>`; });
+  }
+
+  // ---------------------------------------------------------------------------
+  // Roadmap Timeline Tab
+  // ---------------------------------------------------------------------------
+
+  _renderProductRoadmap(slug, container) {
+    container.innerHTML = '<div class="loading-text">Loading roadmap...</div>';
+    fetch(`/api/product/${encodeURIComponent(slug)}/roadmap`)
+      .then(r => r.json())
+      .then(data => {
+        container.innerHTML = '';
+
+        if (!data.sprints.length && !data.versions.length && !data.milestoned_issues.length) {
+          container.innerHTML = '<div class="task-empty">No sprints, versions, or milestoned issues yet.</div>';
+          return;
+        }
+
+        // Sprints section
+        if (data.sprints.length) {
+          const section = document.createElement('div');
+          section.className = 'roadmap-section';
+          const h = document.createElement('h3');
+          h.textContent = 'Sprints';
+          section.appendChild(h);
+
+          const timeline = document.createElement('div');
+          timeline.className = 'roadmap-timeline';
+
+          for (const s of data.sprints) {
+            const bar = document.createElement('div');
+            bar.className = `roadmap-sprint-bar roadmap-status-${s.status}`;
+
+            const label = document.createElement('div');
+            label.className = 'roadmap-bar-label';
+            label.textContent = `${s.name} (${s.issue_count} issues)`;
+
+            const dates = document.createElement('div');
+            dates.className = 'roadmap-bar-dates';
+            dates.textContent = `${s.start_date} → ${s.end_date}`;
+
+            const statusBadge = document.createElement('span');
+            statusBadge.className = `roadmap-status-badge roadmap-status-${s.status}`;
+            statusBadge.textContent = s.status;
+
+            bar.appendChild(label);
+            bar.appendChild(dates);
+            bar.appendChild(statusBadge);
+            if (s.goal) {
+              const goal = document.createElement('div');
+              goal.className = 'roadmap-goal';
+              goal.textContent = s.goal;
+              bar.appendChild(goal);
+            }
+            timeline.appendChild(bar);
+          }
+          section.appendChild(timeline);
+          container.appendChild(section);
+        }
+
+        // Versions section
+        if (data.versions.length) {
+          const section = document.createElement('div');
+          section.className = 'roadmap-section';
+          const h = document.createElement('h3');
+          h.textContent = 'Releases';
+          section.appendChild(h);
+
+          for (const v of data.versions) {
+            const row = document.createElement('div');
+            row.className = 'roadmap-version-row';
+
+            const ver = document.createElement('span');
+            ver.className = 'roadmap-version-tag';
+            ver.textContent = `v${v.version}`;
+
+            const date = document.createElement('span');
+            date.className = 'roadmap-version-date';
+            date.textContent = v.released_at ? v.released_at.split('T')[0] : '';
+
+            const count = document.createElement('span');
+            count.className = 'roadmap-version-count';
+            count.textContent = `${v.resolved_count} issues resolved`;
+
+            row.appendChild(ver);
+            row.appendChild(date);
+            row.appendChild(count);
+            section.appendChild(row);
+          }
+          container.appendChild(section);
+        }
+
+        // Milestoned issues
+        if (data.milestoned_issues.length) {
+          const section = document.createElement('div');
+          section.className = 'roadmap-section';
+          const h = document.createElement('h3');
+          h.textContent = 'Milestoned Issues';
+          section.appendChild(h);
+
+          // Group by milestone_version
+          const groups = {};
+          for (const i of data.milestoned_issues) {
+            const mv = i.milestone_version;
+            if (!groups[mv]) groups[mv] = [];
+            groups[mv].push(i);
+          }
+
+          for (const [ver, items] of Object.entries(groups).sort()) {
+            const group = document.createElement('div');
+            group.className = 'roadmap-milestone-group';
+
+            const gh = document.createElement('div');
+            gh.className = 'roadmap-milestone-header';
+            gh.textContent = `v${ver} (${items.length} issues)`;
+            group.appendChild(gh);
+
+            for (const item of items) {
+              const row = document.createElement('div');
+              row.className = `roadmap-issue-row priority-${(item.priority || 'p2').toLowerCase()}`;
+              row.innerHTML = `<span class="roadmap-issue-pri">[${item.priority}]</span> ${item.title} <span class="roadmap-issue-status">${item.status}</span>`;
+              group.appendChild(row);
+            }
+
+            section.appendChild(group);
+          }
+          container.appendChild(section);
+        }
+      })
+      .catch(err => { container.innerHTML = `<div class="error-text">Failed to load roadmap: ${err.message}</div>`; });
+  }
+
+  // ---------------------------------------------------------------------------
+  // Activity Feed Tab
+  // ---------------------------------------------------------------------------
+
+  _renderProductActivity(slug, container) {
+    container.innerHTML = '<div class="loading-text">Loading activity...</div>';
+    fetch(`/api/product/${encodeURIComponent(slug)}/activity?limit=100`)
+      .then(r => r.json())
+      .then(entries => {
+        container.innerHTML = '';
+
+        if (!entries.length) {
+          container.innerHTML = '<div class="task-empty">No activity recorded yet.</div>';
+          return;
+        }
+
+        const feed = document.createElement('div');
+        feed.className = 'activity-feed';
+
+        const eventIcons = {
+          issue_created: '📋',
+          issue_closed: '✅',
+          issue_assigned: '👤',
+          sprint_created: '🏃',
+          sprint_closed: '🏁',
+          version_released: '🚀',
+          review_created: '📝',
+          review_completed: '☑️',
+          kr_updated: '📊',
+        };
+
+        for (const entry of entries) {
+          const item = document.createElement('div');
+          item.className = 'activity-item';
+
+          const icon = document.createElement('span');
+          icon.className = 'activity-icon';
+          icon.textContent = eventIcons[entry.event_type] || '•';
+
+          const content = document.createElement('div');
+          content.className = 'activity-content';
+
+          const headerLine = document.createElement('div');
+          headerLine.className = 'activity-header';
+          const typeLabel = document.createElement('span');
+          typeLabel.className = 'activity-type';
+          typeLabel.textContent = (entry.event_type || '').replace(/_/g, ' ');
+          const actor = document.createElement('span');
+          actor.className = 'activity-actor';
+          actor.textContent = entry.actor || '';
+          headerLine.appendChild(typeLabel);
+          headerLine.appendChild(actor);
+
+          const detail = document.createElement('div');
+          detail.className = 'activity-detail';
+          detail.textContent = entry.detail || '';
+
+          const ts = document.createElement('div');
+          ts.className = 'activity-ts';
+          if (entry.ts) {
+            const d = new Date(entry.ts);
+            ts.textContent = d.toLocaleString();
+          }
+
+          content.appendChild(headerLine);
+          content.appendChild(detail);
+          content.appendChild(ts);
+
+          item.appendChild(icon);
+          item.appendChild(content);
+          feed.appendChild(item);
+        }
+
+        container.appendChild(feed);
+      })
+      .catch(err => { container.innerHTML = `<div class="error-text">Failed to load activity: ${err.message}</div>`; });
+  }
+
   _doUpdateProjectsPanel() {
     const panel = document.getElementById('projects-panel-list');
     if (!panel) return;

package/frontend/style.css

@@ -6173,6 +6173,291 @@ body.resize-dragging {
   align-items: center;
 }
 
+/* ================================================================
+   Kanban Board
+   ================================================================ */
+
+.kanban-board {
+  display: flex;
+  gap: 8px;
+  overflow-x: auto;
+  padding: 4px 0;
+  min-height: 200px;
+}
+
+.kanban-column {
+  flex: 1;
+  min-width: 130px;
+  max-width: 200px;
+  background: rgba(255,255,255,0.02);
+  border: 1px solid var(--border);
+  border-radius: 2px;
+}
+
+.kanban-column-header {
+  padding: 6px 8px;
+  font-size: calc(6px + var(--font-boost));
+  color: var(--pixel-cyan);
+  border-bottom: 1px solid var(--border);
+  text-align: center;
+  font-weight: bold;
+}
+
+.kanban-card-list {
+  padding: 4px;
+  min-height: 40px;
+}
+
+.kanban-card-list.kanban-drop-target {
+  background: rgba(0,255,255,0.05);
+  outline: 1px dashed var(--pixel-cyan);
+}
+
+.kanban-card {
+  background: rgba(0,0,0,0.3);
+  border: 1px solid var(--border);
+  border-left: 3px solid var(--text-dim);
+  border-radius: 2px;
+  padding: 4px 6px;
+  margin-bottom: 4px;
+  cursor: grab;
+  font-size: calc(5px + var(--font-boost));
+  transition: opacity 0.15s;
+}
+
+.kanban-card.dragging {
+  opacity: 0.4;
+}
+
+.kanban-card.priority-p0 { border-left-color: #ff4444; }
+.kanban-card.priority-p1 { border-left-color: #ff8800; }
+.kanban-card.priority-p2 { border-left-color: var(--pixel-yellow); }
+.kanban-card.priority-p3 { border-left-color: var(--text-dim); }
+
+.kanban-card.kanban-blocked {
+  background: rgba(255,68,68,0.08);
+}
+
+.kanban-priority {
+  font-size: calc(4px + var(--font-boost));
+  padding: 0 3px;
+  border-radius: 1px;
+  margin-right: 4px;
+}
+
+.kanban-card-title {
+  color: var(--pixel-white);
+  word-break: break-word;
+}
+
+.kanban-card-meta {
+  color: var(--text-dim);
+  font-size: calc(4px + var(--font-boost));
+  margin-top: 3px;
+  display: flex;
+  gap: 4px;
+  align-items: center;
+}
+
+.kanban-sp {
+  background: rgba(255,255,255,0.08);
+  padding: 0 3px;
+  border-radius: 1px;
+}
+
+.kanban-blocked-icon {
+  font-size: calc(5px + var(--font-boost));
+}
+
+/* ================================================================
+   Roadmap Timeline
+   ================================================================ */
+
+.roadmap-section {
+  margin-bottom: 16px;
+}
+
+.roadmap-section h3 {
+  color: var(--pixel-cyan);
+  font-size: calc(7px + var(--font-boost));
+  margin: 0 0 8px 0;
+  border-bottom: 1px solid var(--border);
+  padding-bottom: 4px;
+}
+
+.roadmap-timeline {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+
+.roadmap-sprint-bar {
+  background: rgba(0,255,255,0.05);
+  border: 1px solid var(--border);
+  border-left: 3px solid var(--pixel-cyan);
+  border-radius: 2px;
+  padding: 6px 8px;
+}
+
+.roadmap-sprint-bar.roadmap-status-active {
+  border-left-color: var(--pixel-green);
+  background: rgba(0,255,0,0.05);
+}
+
+.roadmap-sprint-bar.roadmap-status-closed {
+  border-left-color: var(--text-dim);
+  opacity: 0.7;
+}
+
+.roadmap-bar-label {
+  color: var(--pixel-white);
+  font-size: calc(6px + var(--font-boost));
+  font-weight: bold;
+}
+
+.roadmap-bar-dates {
+  color: var(--text-dim);
+  font-size: calc(5px + var(--font-boost));
+  margin-top: 2px;
+}
+
+.roadmap-status-badge {
+  display: inline-block;
+  font-size: calc(4px + var(--font-boost));
+  padding: 0 4px;
+  border-radius: 2px;
+  margin-top: 3px;
+  color: var(--pixel-cyan);
+  border: 1px solid var(--border);
+}
+
+.roadmap-status-badge.roadmap-status-active { color: var(--pixel-green); border-color: var(--pixel-green); }
+.roadmap-status-badge.roadmap-status-closed { color: var(--text-dim); border-color: var(--text-dim); }
+
+.roadmap-goal {
+  color: var(--text-dim);
+  font-size: calc(5px + var(--font-boost));
+  font-style: italic;
+  margin-top: 2px;
+}
+
+.roadmap-version-row {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  padding: 4px 0;
+  border-bottom: 1px solid rgba(255,255,255,0.03);
+  font-size: calc(6px + var(--font-boost));
+}
+
+.roadmap-version-tag {
+  color: var(--pixel-green);
+  font-weight: bold;
+  min-width: 60px;
+}
+
+.roadmap-version-date {
+  color: var(--text-dim);
+  min-width: 80px;
+}
+
+.roadmap-version-count {
+  color: var(--pixel-white);
+}
+
+.roadmap-milestone-group {
+  margin-bottom: 10px;
+}
+
+.roadmap-milestone-header {
+  color: var(--pixel-yellow);
+  font-size: calc(6px + var(--font-boost));
+  font-weight: bold;
+  margin-bottom: 4px;
+}
+
+.roadmap-issue-row {
+  padding: 2px 8px;
+  font-size: calc(5px + var(--font-boost));
+  color: var(--pixel-white);
+  border-left: 2px solid var(--text-dim);
+  margin-left: 8px;
+}
+
+.roadmap-issue-row.priority-p0 { border-left-color: #ff4444; }
+.roadmap-issue-row.priority-p1 { border-left-color: #ff8800; }
+
+.roadmap-issue-pri {
+  color: var(--text-dim);
+  margin-right: 4px;
+}
+
+.roadmap-issue-status {
+  color: var(--text-dim);
+  font-size: calc(4px + var(--font-boost));
+  margin-left: 6px;
+}
+
+/* ================================================================
+   Activity Feed
+   ================================================================ */
+
+.activity-feed {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+}
+
+.activity-item {
+  display: flex;
+  gap: 8px;
+  padding: 6px 8px;
+  border-bottom: 1px solid rgba(255,255,255,0.03);
+}
+
+.activity-icon {
+  font-size: calc(7px + var(--font-boost));
+  flex-shrink: 0;
+  width: 20px;
+  text-align: center;
+}
+
+.activity-content {
+  flex: 1;
+  min-width: 0;
+}
+
+.activity-header {
+  display: flex;
+  gap: 8px;
+  align-items: center;
+}
+
+.activity-type {
+  color: var(--pixel-cyan);
+  font-size: calc(5px + var(--font-boost));
+  font-weight: bold;
+  text-transform: capitalize;
+}
+
+.activity-actor {
+  color: var(--text-dim);
+  font-size: calc(4px + var(--font-boost));
+}
+
+.activity-detail {
+  color: var(--pixel-white);
+  font-size: calc(5px + var(--font-boost));
+  margin-top: 1px;
+  word-break: break-word;
+}
+
+.activity-ts {
+  color: var(--text-dim);
+  font-size: calc(4px + var(--font-boost));
+  margin-top: 1px;
+}
+
 /* Product Detail Button in panel */
 .product-detail-btn {
   margin-left: auto;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1mancompany/onemancompany",
-  "version": "0.7.25",
+  "version": "0.7.30",
   "description": "The AI Operating System for One-Person Companies",
   "bin": {
     "onemancompany": "bin/cli.js"

package/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "onemancompany"
-version = "0.7.25"
+version = "0.7.30"
 description = "A one-man company simulation with pixel art visualization and LangChain AI agents"
 requires-python = ">=3.12"
 dependencies = [

package/src/onemancompany/api/routes.py

@@ -7197,8 +7197,11 @@ async def api_list_issues(slug: str, status: str = "", priority: str = "") -> li
     from onemancompany.core import product as prod
     from onemancompany.core.models import IssuePriority, IssueStatus
 
-    status_filter = IssueStatus(status) if status else None
-    priority_filter = IssuePriority(priority) if priority else None
+    try:
+        status_filter = IssueStatus(status) if status else None
+        priority_filter = IssuePriority(priority) if priority else None
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
     return prod.list_issues(slug, status=status_filter, priority=priority_filter)
 
 
@@ -7223,13 +7226,17 @@ async def api_update_issue(slug: str, issue_id: str, request: Request) -> dict:
     ISSUE_MUTABLE_FIELDS = {"title", "status", "priority", "assignee_id", "labels", "milestone_version", "description", "story_points", "sprint"}
     body = await request.json()
     filtered = {k: v for k, v in body.items() if k in ISSUE_MUTABLE_FIELDS}
-    if "status" in filtered:
-        filtered["status"] = _IS(filtered["status"]).value
-    if "priority" in filtered:
-        filtered["priority"] = _IP2(filtered["priority"]).value
-    result = prod.update_issue(slug, issue_id, **filtered)
-    if not result:
-        raise HTTPException(status_code=404, detail=f"Issue '{issue_id}' not found")
+    try:
+        if "status" in filtered:
+            filtered["status"] = _IS(filtered["status"]).value
+        if "priority" in filtered:
+            filtered["priority"] = _IP2(filtered["priority"]).value
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+    try:
+        result = prod.update_issue(slug, issue_id, **filtered)
+    except ValueError as exc:
+        raise HTTPException(status_code=404, detail=str(exc))
 
     # Publish ISSUE_ASSIGNED event when assignee changes
     if "assignee_id" in filtered and filtered["assignee_id"]:
@@ -7257,9 +7264,14 @@ async def api_close_issue(slug: str, issue_id: str, request: Request) -> dict:
 
     body = await request.json() if request.headers.get("content-length", "0") != "0" else {}
     resolution_str = body.get("resolution", "fixed")
-    result = prod.close_issue(slug, issue_id, resolution=IssueResolution(resolution_str))
-    if not result:
-        raise HTTPException(status_code=404, detail=f"Issue '{issue_id}' not found")
+    try:
+        resolution = IssueResolution(resolution_str)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+    try:
+        result = prod.close_issue(slug, issue_id, resolution=resolution)
+    except ValueError as exc:
+        raise HTTPException(status_code=404, detail=str(exc))
     await event_bus.publish(
         CompanyEvent(
             type=EventType.ISSUE_CLOSED,
@@ -7275,9 +7287,10 @@ async def api_reopen_issue(slug: str, issue_id: str) -> dict:
     """Reopen a closed issue."""
     from onemancompany.core import product as prod
 
-    result = prod.reopen_issue(slug, issue_id)
-    if not result:
-        raise HTTPException(status_code=404, detail=f"Issue '{issue_id}' not found")
+    try:
+        result = prod.reopen_issue(slug, issue_id)
+    except ValueError as exc:
+        raise HTTPException(status_code=404, detail=str(exc))
     return result
 
 
@@ -7645,3 +7658,48 @@ async def api_complete_review(slug: str, review_id: str) -> dict:
         return prod.complete_review(slug, review_id)
     except ValueError as exc:
         raise HTTPException(status_code=400, detail=str(exc))
+
+
+# ---------------------------------------------------------------------------
+# Kanban Board
+# ---------------------------------------------------------------------------
+
+
+@router.get("/api/product/{slug}/kanban")
+async def api_kanban_board(slug: str) -> dict:
+    """Return issues grouped by status columns for kanban view."""
+    from onemancompany.core import product as prod
+
+    try:
+        return prod.kanban_board(slug)
+    except ValueError as exc:
+        raise HTTPException(status_code=404, detail=str(exc))
+
+
+# ---------------------------------------------------------------------------
+# Roadmap Timeline
+# ---------------------------------------------------------------------------
+
+
+@router.get("/api/product/{slug}/roadmap")
+async def api_roadmap_timeline(slug: str) -> dict:
+    """Return sprints, versions, and milestoned issues for timeline view."""
+    from onemancompany.core import product as prod
+
+    try:
+        return prod.roadmap_timeline(slug)
+    except ValueError as exc:
+        raise HTTPException(status_code=404, detail=str(exc))
+
+
+# ---------------------------------------------------------------------------
+# Product Activity Feed
+# ---------------------------------------------------------------------------
+
+
+@router.get("/api/product/{slug}/activity")
+async def api_product_activity(slug: str, limit: int = 50) -> list[dict]:
+    """Return product-scoped activity feed, newest first."""
+    from onemancompany.core import product as prod
+
+    return prod.list_product_activity(slug, limit=limit)

package/src/onemancompany/core/config.py

@@ -63,6 +63,7 @@ ISSUES_DIR_NAME = "issues"
 VERSIONS_DIR_NAME = "versions"
 SPRINTS_DIR_NAME = "sprints"
 REVIEWS_DIR_NAME = "reviews"
+ACTIVITY_LOG_DIR_NAME = "activity"
 TALENT_PERSONA_FILENAME = "talent_persona.md"
 MCP_CONFIG_FILENAME = "mcp_config.json"
 CONVERSATIONS_DIR_NAME = "conversations"

package/src/onemancompany/core/product.py

@@ -18,6 +18,7 @@ from pathlib import Path
 from loguru import logger
 
 from onemancompany.core.config import (
+    ACTIVITY_LOG_DIR_NAME,
     ISSUES_DIR_NAME,
     PRODUCT_YAML_FILENAME,
     PRODUCTS_DIR,
@@ -286,9 +287,11 @@ def create_issue(
     sprint: str | None = None,
 ) -> dict:
     """Create an issue for a product. Returns the issue dict."""
-    issue_id = _gen_id("issue_")
     product = load_product(slug)
-    product_id = product["id"] if product else ""
+    if not product:
+        raise ValueError(f"Product '{slug}' not found")
+    issue_id = _gen_id("issue_")
+    product_id = product["id"]
     now = datetime.now().isoformat()
 
     data = {
@@ -379,14 +382,13 @@ def list_issues(
     return results
 
 
-def update_issue(slug: str, issue_id: str, **fields) -> dict | None:
-    """Update issue fields. Returns updated dict or None if not found."""
+def update_issue(slug: str, issue_id: str, **fields) -> dict:
+    """Update issue fields. Returns updated dict. Raises ValueError if not found."""
     with _get_slug_lock(slug):
         path = _issues_dir(slug) / f"{issue_id}.yaml"
         data = _read_yaml(path)
         if not data:
-            logger.warning("update_issue: issue {} not found in {}", issue_id, slug)
-            return None
+            raise ValueError(f"Issue '{issue_id}' not found in product '{slug}'")
         for key, value in fields.items():
             if value is not None:
                 old_value = data.get(key)
@@ -403,14 +405,13 @@ def close_issue(
     issue_id: str,
     *,
     resolution: IssueResolution = IssueResolution.FIXED,
-) -> dict | None:
-    """Close an issue with a resolution. Returns updated dict or None."""
+) -> dict:
+    """Close an issue with a resolution. Returns updated dict. Raises ValueError if not found."""
     with _get_slug_lock(slug):
         path = _issues_dir(slug) / f"{issue_id}.yaml"
         data = _read_yaml(path)
         if not data:
-            logger.warning("close_issue: issue {} not found in {}", issue_id, slug)
-            return None
+            raise ValueError(f"Issue '{issue_id}' not found in product '{slug}'")
         old_status = data.get("status")
         _append_history(data, "status", old_status, IssueStatus.DONE.value, changed_by="system")
         data["status"] = IssueStatus.DONE.value
@@ -422,14 +423,13 @@ def close_issue(
     return data
 
 
-def reopen_issue(slug: str, issue_id: str) -> dict | None:
-    """Reopen a closed issue. Increments reopened_count. Returns updated dict or None."""
+def reopen_issue(slug: str, issue_id: str) -> dict:
+    """Reopen a closed issue. Increments reopened_count. Returns updated dict. Raises ValueError if not found."""
     with _get_slug_lock(slug):
         path = _issues_dir(slug) / f"{issue_id}.yaml"
         data = _read_yaml(path)
         if not data:
-            logger.warning("reopen_issue: issue {} not found in {}", issue_id, slug)
-            return None
+            raise ValueError(f"Issue '{issue_id}' not found in product '{slug}'")
         old_status = data.get("status")
         _append_history(data, "status", old_status, IssueStatus.BACKLOG.value, changed_by="system")
         data["status"] = IssueStatus.BACKLOG.value
@@ -477,6 +477,13 @@ def add_issue_link(
     rel_value = relation.value if hasattr(relation, "value") else relation
     reverse_rel = _REVERSE_RELATION[rel_value]
 
+    # Circular dependency check for blocking relations
+    if rel_value == IssueRelation.BLOCKS.value:
+        _check_block_cycle(slug, issue_id, target_id)
+    elif rel_value == IssueRelation.BLOCKED_BY.value:
+        # blocked_by is the reverse: target blocks issue
+        _check_block_cycle(slug, target_id, issue_id)
+
     # Add forward link (idempotent)
     _add_link_entry(slug, issue_id, target_id, rel_value)
     # Add reverse link
@@ -486,6 +493,34 @@ def add_issue_link(
     logger.debug("Linked {} —{}→ {}", issue_id, rel_value, target_id)
 
 
+def _check_block_cycle(slug: str, blocker_id: str, blocked_id: str) -> None:
+    """Raise ValueError if adding 'blocker_id blocks blocked_id' would create a cycle.
+
+    Walks the existing 'blocks' graph starting from blocked_id to see if
+    blocker_id is reachable (meaning blocked_id already transitively blocks blocker_id).
+    """
+    visited: set[str] = set()
+    queue = [blocked_id]
+    while queue:
+        current = queue.pop()
+        if current in visited:
+            continue
+        visited.add(current)
+        issue = load_issue(slug, current)
+        if not issue:
+            continue
+        for link in issue.get("issue_links", []):
+            if link["relation"] != IssueRelation.BLOCKS.value:
+                continue
+            downstream = link["issue_id"]
+            if downstream == blocker_id:
+                raise ValueError(
+                    f"Circular dependency: {blocked_id} already transitively "
+                    f"blocks {blocker_id}"
+                )
+            queue.append(downstream)
+
+
 def _add_link_entry(slug: str, issue_id: str, target_id: str, relation: str) -> None:
     """Add a single link entry to an issue (idempotent)."""
     with _get_slug_lock(slug):
@@ -662,6 +697,143 @@ def complete_review(slug: str, review_id: str) -> dict:
     return data
 
 
+# ---------------------------------------------------------------------------
+# Kanban Board
+# ---------------------------------------------------------------------------
+
+
+def kanban_board(slug: str) -> dict:
+    """Return issues grouped by IssueStatus columns + blocked IDs.
+
+    Raises ValueError if product not found.
+    """
+    product = load_product(slug)
+    if not product:
+        raise ValueError(f"Product '{slug}' not found")
+
+    all_issues = list_issues(slug)
+    columns: dict[str, list[dict]] = {s.value: [] for s in IssueStatus}
+    blocked_ids: list[str] = []
+
+    for issue in all_issues:
+        status = issue.get("status", IssueStatus.BACKLOG.value)
+        if status in columns:
+            columns[status].append(issue)
+        if is_blocked(slug, issue["id"]):
+            blocked_ids.append(issue["id"])
+
+    return {"columns": columns, "blocked_ids": blocked_ids}
+
+
+# ---------------------------------------------------------------------------
+# Roadmap Timeline
+# ---------------------------------------------------------------------------
+
+
+def roadmap_timeline(slug: str) -> dict:
+    """Return sprints, versions, and milestoned issues for timeline display.
+
+    Raises ValueError if product not found.
+    """
+    product = load_product(slug)
+    if not product:
+        raise ValueError(f"Product '{slug}' not found")
+
+    sprints = list_sprints(slug)
+    sprint_summaries = []
+    for s in sprints:
+        issue_count = len(list_issues(slug, sprint=s["id"]))
+        sprint_summaries.append({
+            "id": s["id"],
+            "name": s["name"],
+            "start_date": s["start_date"],
+            "end_date": s["end_date"],
+            "status": s["status"],
+            "goal": s.get("goal", ""),
+            "issue_count": issue_count,
+        })
+
+    versions = list_versions(slug)
+    version_summaries = []
+    for v in versions:
+        version_summaries.append({
+            "version": v["version"],
+            "released_at": v["released_at"],
+            "resolved_count": len(v.get("resolved_issue_ids", [])),
+            "changelog": v.get("changelog", ""),
+        })
+
+    all_issues = list_issues(slug)
+    milestoned = [
+        {
+            "issue_id": i["id"],
+            "title": i["title"],
+            "priority": i.get("priority", "P2"),
+            "milestone_version": i["milestone_version"],
+            "status": i.get("status", "backlog"),
+        }
+        for i in all_issues
+        if i.get("milestone_version")
+    ]
+
+    return {
+        "sprints": sprint_summaries,
+        "versions": version_summaries,
+        "milestoned_issues": milestoned,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Product Activity Log
+# ---------------------------------------------------------------------------
+
+_MAX_ACTIVITY_ENTRIES = 500
+
+
+def _activity_dir(slug: str) -> Path:
+    return _product_dir(slug) / ACTIVITY_LOG_DIR_NAME
+
+
+def append_product_activity(
+    slug: str,
+    *,
+    event_type: str,
+    actor: str,
+    detail: str,
+) -> None:
+    """Append an activity entry to the product's activity log."""
+    adir = _activity_dir(slug)
+    adir.mkdir(parents=True, exist_ok=True)
+    log_path = adir / "log.yaml"
+
+    entry = {
+        "ts": datetime.now().isoformat(),
+        "event_type": event_type,
+        "actor": actor,
+        "detail": detail,
+    }
+
+    with _get_slug_lock(slug):
+        log = _read_yaml(log_path) or []
+        if not isinstance(log, list):
+            log = []
+        log.append(entry)
+        if len(log) > _MAX_ACTIVITY_ENTRIES:
+            log = log[-_MAX_ACTIVITY_ENTRIES:]
+        _write_yaml(log_path, log)
+
+
+def list_product_activity(slug: str, *, limit: int = 50) -> list[dict]:
+    """Return product activity entries, newest first."""
+    log_path = _activity_dir(slug) / "log.yaml"
+    log = _read_yaml(log_path)
+    if not log or not isinstance(log, list):
+        return []
+    # Newest first
+    log.reverse()
+    return log[:limit]
+
+
 # ---------------------------------------------------------------------------
 # Product Versioning
 # ---------------------------------------------------------------------------

package/src/onemancompany/core/product_triggers.py

@@ -701,6 +701,37 @@ async def handle_sprint_closed(event: CompanyEvent) -> None:
     logger.info("[PRODUCT_TRIGGER] Auto-created review for sprint {} in {}", sprint_id, slug)
 
 
+def _log_product_activity(event: CompanyEvent) -> None:
+    """Log a product event to the product-scoped activity feed."""
+    slug = event.payload.get("product_slug", "")
+    if not slug:
+        return
+    detail = event.payload.get("detail", "")
+    if not detail:
+        # Build a default detail string from event type + payload
+        etype = event.type.value
+        title = event.payload.get("title", "")
+        issue_id = event.payload.get("issue_id", "")
+        sprint_id = event.payload.get("sprint_id", "")
+        if title:
+            detail = f"{etype}: {title}"
+        elif issue_id:
+            detail = f"{etype}: {issue_id}"
+        elif sprint_id:
+            detail = f"{etype}: {sprint_id}"
+        else:
+            detail = etype
+    try:
+        prod.append_product_activity(
+            slug,
+            event_type=event.type.value,
+            actor=event.agent,
+            detail=detail,
+        )
+    except Exception:
+        logger.debug("[PRODUCT_TRIGGER] Failed to log activity for {}", slug)
+
+
 # ---------------------------------------------------------------------------
 # Registration
 # ---------------------------------------------------------------------------
@@ -718,10 +749,27 @@ def register_product_triggers() -> "asyncio.Task":
 
     queue = event_bus.subscribe()
 
+    # Event types that should be auto-logged to product activity feed
+    _ACTIVITY_EVENT_TYPES = {
+        EventType.ISSUE_CREATED,
+        EventType.ISSUE_CLOSED,
+        EventType.ISSUE_ASSIGNED,
+        EventType.SPRINT_CREATED,
+        EventType.SPRINT_CLOSED,
+        EventType.VERSION_RELEASED,
+        EventType.REVIEW_CREATED,
+        EventType.REVIEW_COMPLETED,
+        EventType.KR_UPDATED,
+    }
+
     async def _dispatch_loop() -> None:
         while True:
             event = await queue.get()
             try:
+                # Auto-log product events to activity feed
+                if event.type in _ACTIVITY_EVENT_TYPES:
+                    _log_product_activity(event)
+
                 if event.type == EventType.ISSUE_CREATED:
                     await handle_issue_created(event)
                 elif event.type == EventType.ISSUE_ASSIGNED: