@1mancompany/onemancompany 0.7.44 → 0.7.48

package/frontend/task-tree-g6.js

@@ -26,11 +26,11 @@ const STATUS_STYLES = {
     blocked:    { color: '#f97316', label: '\u2298 Blocked' },
 };
 
-const CARD_W = 240;
+const CARD_W = 260;
 const CARD_MIN_H = 72;       // minimum card height (no description)
 const DESC_LINE_H = 14;      // height per description line
-const DESC_MAX_LINES = 6;    // cap description lines
-const DESC_CHARS_PER_LINE = 34;
+const DESC_MAX_LINES = 12;   // cap description lines (was 6 — caused overflow/truncation)
+const DESC_CHARS_PER_LINE = 38;
 const CHILDREN_PAGE_SIZE = 5;
 
 /* ─────────────────── Word-wrap helper (shared with old code) ────── */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1mancompany/onemancompany",
-  "version": "0.7.44",
+  "version": "0.7.48",
   "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.44"
+version = "0.7.48"
 description = "A one-man company simulation with pixel art visualization and LangChain AI agents"
 requires-python = ">=3.12"
 dependencies = [

package/src/onemancompany/agents/base.py

@@ -641,6 +641,7 @@ class BaseAgentRunner:
                         content = last_msg.content or ""
                         if isinstance(content, str):
                             on_log("llm_input", f"[{type(last_msg).__name__}] {content}")
+                            logger.debug("[LLM INPUT] employee={}: {}", self.employee_id, content[:3000])
             elif kind == "on_chat_model_end":
                 output = data.get("output", None)
                 if output:
@@ -671,6 +672,7 @@ class BaseAgentRunner:
                         if text.strip():
                             final_content = text  # track last AI output
                             on_log("llm_output", text)
+                            logger.debug("[LLM OUTPUT] employee={}: {}", self.employee_id, text[:3000])
                         tool_calls = getattr(output, "tool_calls", None)
                         if tool_calls:
                             last_tool_calls = []
@@ -685,11 +687,13 @@ class BaseAgentRunner:
                                     "tool_args": args_dict,
                                     "content": f"{name}({args})",
                                 })
+                                logger.debug("[TOOL CALL] employee={}: {}({})", self.employee_id, name, args[:1000])
             elif kind == "on_tool_end":
                 output = data.get("output", "")
                 name = event.get("name", "tool")
                 result_str = str(output)
                 last_tool_results.append(f"{name} → {result_str}")
+                logger.debug("[TOOL RESULT] employee={}: {} → {}", self.employee_id, name, result_str[:2000])
                 on_log("tool_result", {
                     "tool_name": name,
                     "tool_result": result_str,

package/src/onemancompany/agents/product_tools.py

@@ -743,6 +743,46 @@ async def delete_product_tool(product_slug: str) -> str:
         return f"Error: {e}"
 
 
+@tool
+async def assign_issue_tool(
+    product_slug: str,
+    issue_id: str,
+    assignee_id: str,
+) -> str:
+    """Assign (or reassign) an issue to an employee.
+
+    Args:
+        product_slug: The product slug
+        issue_id: The issue ID
+        assignee_id: Employee ID to assign
+    """
+    try:
+        issue = prod.update_issue(product_slug, issue_id, assignee_id=assignee_id)
+        return f"Issue {issue_id} assigned to {assignee_id}"
+    except (ValueError, FileNotFoundError) as e:
+        return f"Error: {e}"
+
+
+@tool
+async def transfer_product_ownership_tool(
+    product_slug: str,
+    new_owner_id: str,
+) -> str:
+    """Transfer product ownership to a different employee.
+
+    Args:
+        product_slug: The product slug
+        new_owner_id: Employee ID of the new owner
+    """
+    try:
+        result = prod.update_product(product_slug, owner_id=new_owner_id)
+        if result is None:
+            return f"Error: product '{product_slug}' not found"
+        return f"Product '{product_slug}' ownership transferred to {new_owner_id}"
+    except (ValueError, FileNotFoundError) as e:
+        return f"Error: {e}"
+
+
 # ---------------------------------------------------------------------------
 # Export
 # ---------------------------------------------------------------------------
@@ -770,4 +810,6 @@ PRODUCT_TOOLS = [
     version_management_tool,
     update_product_tool,
     delete_product_tool,
+    assign_issue_tool,
+    transfer_product_ownership_tool,
 ]

package/src/onemancompany/core/product.py

@@ -19,6 +19,7 @@ from loguru import logger
 
 from onemancompany.core.config import (
     ACTIVITY_LOG_DIR_NAME,
+    EMPLOYEES_DIR,
     ISSUES_DIR_NAME,
     PRODUCT_YAML_FILENAME,
     PRODUCTS_DIR,
@@ -99,6 +100,17 @@ def _gen_id(prefix: str) -> str:
     return f"{prefix}{uuid.uuid4().hex[:8]}"
 
 
+def _validate_employee_id(emp_id: str, label: str = "Employee") -> None:
+    """Raise ValueError if emp_id does not correspond to a valid employee directory.
+
+    Empty string is allowed (means "no owner/assignee assigned").
+    """
+    if not emp_id:
+        return  # empty = unassigned, valid
+    if not (EMPLOYEES_DIR / emp_id).is_dir():
+        raise ValueError(f"{label} '{emp_id}' not found in employee registry")
+
+
 # ---------------------------------------------------------------------------
 # Product CRUD
 # ---------------------------------------------------------------------------
@@ -112,6 +124,7 @@ def create_product(
     current_version: str = "0.1.0",
 ) -> dict:
     """Create a new product. Returns the product dict."""
+    _validate_employee_id(owner_id, label="Owner")
     slug = _dedup_slug(_slugify(name))
     product_id = _gen_id("prod_")
     now = datetime.now().isoformat()
@@ -165,6 +178,8 @@ def list_products() -> list[dict]:
 
 def update_product(slug: str, **fields) -> dict | None:
     """Update product fields. Returns updated dict or None if not found."""
+    if "owner_id" in fields and fields["owner_id"] is not None:
+        _validate_employee_id(fields["owner_id"], label="Owner")
     with _get_slug_lock(slug):
         path = _product_yaml_path(slug)
         data = _read_yaml(path)
@@ -314,6 +329,8 @@ def create_issue(
     product = load_product(slug)
     if not product:
         raise ValueError(f"Product '{slug}' not found")
+    if assignee_id:
+        _validate_employee_id(assignee_id, label="Assignee")
     issue_id = _gen_id("issue_")
     product_id = product["id"]
     now = datetime.now().isoformat()
@@ -424,6 +441,9 @@ def update_issue(slug: str, issue_id: str, *, _skip_transition_check: bool = Fal
     _skip_transition_check: internal flag for system-derived status updates
     that may jump non-adjacent states (e.g. sync_issue_statuses).
     """
+    new_assignee = fields.get("assignee_id")
+    if new_assignee is not None and new_assignee != "":
+        _validate_employee_id(new_assignee, label="Assignee")
     with _get_slug_lock(slug):
         path = _issues_dir(slug) / f"{issue_id}.yaml"
         data = _read_yaml(path)
@@ -441,6 +461,11 @@ def update_issue(slug: str, issue_id: str, *, _skip_transition_check: bool = Fal
                 if old_value != value:
                     _append_history(data, key, old_value, value, changed_by="system")
                 data[key] = value
+        # Auto-set closed_at and resolution when status transitions to DONE
+        if new_status == IssueStatus.DONE.value and not data.get("closed_at"):
+            data["closed_at"] = datetime.now().isoformat()
+            if not data.get("resolution"):
+                data["resolution"] = IssueResolution.FIXED.value
         _write_yaml(path, data)
     mark_dirty(DirtyCategory.PRODUCTS)
     return data
@@ -999,12 +1024,25 @@ def release_version(
         product["current_version"] = new_version
         _write_yaml(_product_yaml_path(product_slug), product)
 
-    # Mark resolved issues as released (bypass validation — release is a system operation)
+    # Mark resolved issues as released — only DONE issues are eligible
+    skipped_issues: list[str] = []
     for issue_id in resolved_issue_ids:
         issue = load_issue(product_slug, issue_id)
-        if issue and issue.get("status") != IssueStatus.RELEASED.value:
-            update_issue(product_slug, issue_id, _skip_transition_check=True, status=IssueStatus.RELEASED.value)
+        if not issue:
+            skipped_issues.append(issue_id)
+            continue
+        if issue.get("status") == IssueStatus.RELEASED.value:
+            continue  # already released
+        if issue.get("status") != IssueStatus.DONE.value:
+            skipped_issues.append(issue_id)
+            logger.warning(
+                "[VERSION] Skipping issue {} — status '{}' is not DONE",
+                issue_id, issue.get("status"),
+            )
+            continue
+        update_issue(product_slug, issue_id, _skip_transition_check=True, status=IssueStatus.RELEASED.value)
 
+    version_record["skipped_issues"] = skipped_issues
     mark_dirty(DirtyCategory.PRODUCTS)
     logger.info("[VERSION] Released {} for product '{}'", new_version, product_slug)
     return version_record
@@ -1355,6 +1393,24 @@ def create_sprint(
             f"End date '{end_date}' must be after start date '{start_date}'"
         )
 
+    # Check for date overlap with non-closed sprints
+    existing_sprints = list_sprints(slug)
+    for existing in existing_sprints:
+        if existing.get("status") == SprintStatus.CLOSED.value:
+            continue
+        try:
+            ex_sd = datetime.strptime(existing["start_date"], "%Y-%m-%d")
+            ex_ed = datetime.strptime(existing["end_date"], "%Y-%m-%d")
+        except (ValueError, KeyError):
+            logger.debug("Skipping overlap check for sprint with invalid dates: {}", existing.get("id"))
+            continue
+        # Overlap: ranges overlap if start < other_end AND other_start < end
+        if sd < ex_ed and ex_sd < ed:
+            raise ValueError(
+                f"Sprint dates {start_date}..{end_date} overlap with "
+                f"'{existing['name']}' ({existing['start_date']}..{existing['end_date']})"
+            )
+
     sprint_id = _gen_id("sprint_")
     now = datetime.now().isoformat()
 
@@ -1478,8 +1534,9 @@ def close_sprint(slug: str, sprint_id: str) -> dict:
     total_count = len(all_issues)
     unfinished = [i for i in all_issues if i.get("status") not in _DONE_STATUSES]
 
-    # 3. Carry-over: find next planning sprint
+    # 3. Carry-over: find next planning sprint (sorted by start_date, earliest first)
     planning_sprints = list_sprints(slug, status=SprintStatus.PLANNING.value)
+    planning_sprints.sort(key=lambda s: s.get("start_date", ""))
     next_sprint = planning_sprints[0] if planning_sprints else None
 
     for issue in unfinished:

package/src/onemancompany/core/product_triggers.py

@@ -34,6 +34,12 @@ STALE_REVIEW_HOURS: int = 24            # Hours before an open review is conside
 BLOCKED_DAYS_THRESHOLD: int = 7         # Days before a blocked issue is flagged
 UNHANDLED_BACKLOG_THRESHOLD: int = 2    # Unhandled backlog issues before alert
 
+def _get_threshold(product: dict, key: str, default: int) -> int:
+    """Read per-product config threshold, falling back to module-level default."""
+    config = product.get("config") or {}
+    return config.get(key, default)
+
+
 # ---------------------------------------------------------------------------
 # Trigger handlers
 # ---------------------------------------------------------------------------
@@ -148,6 +154,76 @@ async def _create_project_for_issue(slug: str, issue: dict) -> str:
         return ""
 
 
+async def _create_review_project(product_slug: str, reason: str) -> str:
+    """Create a standalone review project for the product owner.
+
+    Unlike _create_project_for_issue, this doesn't take an issue dict —
+    it constructs a proper review-scoped project.
+    Returns project_id or empty string.
+    """
+    from pathlib import Path
+    from onemancompany.core.config import CEO_ID, EA_ID, TASK_TREE_FILENAME
+    from onemancompany.core.project_archive import async_create_project_from_task, get_project_dir
+    from onemancompany.core.task_lifecycle import NodeType, TaskPhase
+
+    product = prod.load_product(product_slug)
+    if not product:
+        return ""
+    product_id = product["id"]
+    owner_id = product.get("owner_id", "")
+    task_description = f"Product review for '{product['name']}': {reason}"
+
+    try:
+        project_id, iter_id = await async_create_project_from_task(
+            task_description,
+            product_id=product_id,
+        )
+        pdir = get_project_dir(project_id)
+        ctx_id = f"{project_id}/{iter_id}" if iter_id else project_id
+
+        product_ctx = prod.build_product_context(product_slug)
+        review_task = (
+            f"Product review needed: {reason}\n\n"
+            f"{product_ctx}\n\n"
+            f"[Project ID: {ctx_id}] [Project workspace: {pdir}]"
+        )
+
+        from onemancompany.core.task_tree import TaskTree
+        from onemancompany.core.vessel import _save_project_tree
+
+        tree = TaskTree(project_id=ctx_id, mode="standard")
+        ceo_root = tree.create_root(employee_id=CEO_ID, description=task_description)
+        ceo_root.node_type = NodeType.CEO_PROMPT.value
+        ceo_root.set_status(TaskPhase.PROCESSING)
+
+        owner_node = tree.add_child(
+            parent_id=ceo_root.id,
+            employee_id=owner_id or EA_ID,
+            description=review_task,
+            acceptance_criteria=[],
+            title=f"Product review: {reason[:50]}",
+        )
+        _save_project_tree(pdir, tree)
+
+        from onemancompany.core.agent_loop import employee_manager
+        target_id = owner_id or EA_ID
+        tree_path = str(Path(pdir) / TASK_TREE_FILENAME)
+        employee_manager.schedule_node(target_id, owner_node.id, tree_path)
+        employee_manager._schedule_next(target_id)
+
+        logger.info(
+            "[PRODUCT_TRIGGER] Created review project {} for product '{}' (reason: {})",
+            project_id, product_slug, reason,
+        )
+        return project_id
+    except Exception:
+        logger.exception(
+            "[PRODUCT_TRIGGER] Failed to create review project for '{}'",
+            product_slug,
+        )
+        return ""
+
+
 async def handle_project_complete(event: CompanyEvent) -> None:
     """When a project with product context completes, close issues + release version."""
     slug = event.payload.get("product_slug", "")
@@ -236,78 +312,69 @@ async def notify_owner(product_slug: str, reason: str = "") -> bool:
         f"[skill: product-review]"
     )
 
-    try:
-        from pathlib import Path
-        from onemancompany.core.config import CEO_ID, TASK_TREE_FILENAME
-        from onemancompany.core.project_archive import list_projects, get_project_dir
-        from onemancompany.core.task_tree import get_tree
-        from onemancompany.core.vessel import _save_project_tree
+    from pathlib import Path
+    from onemancompany.core.config import CEO_ID, TASK_TREE_FILENAME
+    from onemancompany.core.project_archive import list_projects, get_project_dir
+    from onemancompany.core.task_tree import get_tree
+    from onemancompany.core.vessel import _save_project_tree
 
-        # Find existing active project for this product
-        all_projects = list_projects()
-        active_product_projects = [
-            p for p in all_projects
-            if p.get("product_id") == product["id"] and p.get("status") == "active"
-        ]
+    # Find existing active project for this product
+    all_projects = list_projects()
+    active_product_projects = [
+        p for p in all_projects
+        if p.get("product_id") == product["id"] and p.get("status") == "active"
+    ]
 
-        if active_product_projects:
-            # Add task to existing project's tree
-            proj = active_product_projects[0]
-            pdir = get_project_dir(proj["project_id"])
-            tree_path = Path(pdir) / TASK_TREE_FILENAME
-            if not tree_path.exists():
-                logger.debug("[PRODUCT_TRIGGER] Tree not found for project {}", proj["project_id"])
+    if active_product_projects:
+        # Add task to existing project's tree
+        proj = active_product_projects[0]
+        pdir = get_project_dir(proj["project_id"])
+        tree_path = Path(pdir) / TASK_TREE_FILENAME
+        if not tree_path.exists():
+            logger.debug("[PRODUCT_TRIGGER] Tree not found for project {}", proj["project_id"])
+            return False
+
+        tree = get_tree(str(tree_path))
+
+        # Check if owner already has a pending/processing review task — skip if so
+        from onemancompany.core.task_lifecycle import TaskPhase
+        for node in tree.all_nodes():
+            if (node.employee_id == owner_id
+                    and node.status in (TaskPhase.PENDING.value, TaskPhase.PROCESSING.value)
+                    and "review" in (node.title or node.description or "").lower()):
+                logger.debug("[PRODUCT_TRIGGER] Owner {} already has pending review task {}, skip",
+                             owner_id, node.id)
                 return False
 
-            tree = get_tree(str(tree_path))
-
-            # Check if owner already has a pending/processing review task — skip if so
-            from onemancompany.core.task_lifecycle import TaskPhase
-            for node in tree.all_nodes():
-                if (node.employee_id == owner_id
-                        and node.status in (TaskPhase.PENDING.value, TaskPhase.PROCESSING.value)
-                        and "review" in (node.title or node.description or "").lower()):
-                    logger.debug("[PRODUCT_TRIGGER] Owner {} already has pending review task {}, skip",
-                                 owner_id, node.id)
-                    return False
-
-            # Find a suitable parent (EA node or root)
-            ea_node = tree.get_ea_node()
-            parent_id = ea_node.id if ea_node else tree.root_id
-
-            child = tree.add_child(
-                parent_id=parent_id,
-                employee_id=owner_id,
-                description=task_desc,
-                acceptance_criteria=[],
-                title=f"Product review: {reason[:50]}",
-            )
-            _save_project_tree(pdir, tree)
+        # Find a suitable parent (EA node or root)
+        ea_node = tree.get_ea_node()
+        parent_id = ea_node.id if ea_node else tree.root_id
 
-            # Schedule owner to execute
-            from onemancompany.core.agent_loop import employee_manager
-            employee_manager.schedule_node(owner_id, child.id, str(tree_path))
-            employee_manager._schedule_next(owner_id)
+        child = tree.add_child(
+            parent_id=parent_id,
+            employee_id=owner_id,
+            description=task_desc,
+            acceptance_criteria=[],
+            title=f"Product review: {reason[:50]}",
+        )
+        _save_project_tree(pdir, tree)
 
-            logger.info("[PRODUCT_TRIGGER] Pushed review task to owner {} on project {} (reason: {})",
-                        owner_id, proj["project_id"], reason)
-        else:
-            # No active project — create one
-            project_id = await _create_project_for_issue(product_slug, {
-                "id": f"review_{product_slug}",
-                "title": f"Product review: {product['name']}",
-                "description": task_desc,
-                "priority": IssuePriority.P2.value,
-            })
-            if not project_id:
-                return False
-            logger.info("[PRODUCT_TRIGGER] Created review project {} for owner {} (reason: {})",
-                        project_id, owner_id, reason)
+        # Schedule owner to execute
+        from onemancompany.core.agent_loop import employee_manager
+        employee_manager.schedule_node(owner_id, child.id, str(tree_path))
+        employee_manager._schedule_next(owner_id)
 
-        return True
-    except Exception:
-        logger.exception("[PRODUCT_TRIGGER] Failed to push review task for '{}'", product_slug)
-        return False
+        logger.info("[PRODUCT_TRIGGER] Pushed review task to owner {} on project {} (reason: {})",
+                    owner_id, proj["project_id"], reason)
+    else:
+        # No active project — create a dedicated review project
+        project_id = await _create_review_project(product_slug, reason)
+        if not project_id:
+            return False
+        logger.info("[PRODUCT_TRIGGER] Created review project {} for owner {} (reason: {})",
+                    project_id, owner_id, reason)
+
+    return True
 
 
 def sync_issue_statuses(product_slug: str) -> list[dict]:
@@ -398,6 +465,8 @@ async def run_product_check(product_slug: str) -> dict:
     if not owner_id:
         return {"skipped": True, "reason": "no owner"}
 
+    max_active = _get_threshold(product, "max_active_projects", MAX_ACTIVE_PROJECTS)
+
     from onemancompany.core.project_archive import list_projects
     all_projects = list_projects()
     active_for_product = [
@@ -425,7 +494,7 @@ async def run_product_check(product_slug: str) -> dict:
 
         # High priority + no active project → create project
         if priority in _AUTO_PROJECT_PRIORITIES and not linked:
-            if len(active_for_product) >= MAX_ACTIVE_PROJECTS:
+            if len(active_for_product) >= max_active:
                 logger.debug("[PRODUCT_CHECK] Skipping project for issue {} — 3+ active projects", issue["id"])
                 continue
             project_id = await _create_project_for_issue(product_slug, issue)
@@ -440,7 +509,7 @@ async def run_product_check(product_slug: str) -> dict:
 
         # Has assignee but no project → create project
         elif issue.get("assignee_id") and not linked:
-            if len(active_for_product) >= MAX_ACTIVE_PROJECTS:
+            if len(active_for_product) >= max_active:
                 continue
             project_id = await _create_project_for_issue(product_slug, issue)
             if project_id:
@@ -460,10 +529,12 @@ async def run_product_check(product_slug: str) -> dict:
         if target <= 0 or current >= target:
             continue  # met or invalid
 
+        kr_id = kr.get("id", "")
         kr_title = kr.get("title", "")
-        # Check if any open issue is related to this KR (by title match)
+        kr_label = f"kr:{kr_id}"
+        # Check if any open issue is already tracking this KR (by kr_id label)
         has_issue = any(
-            kr_title in i.get("title", "") or kr.get("id", "") in i.get("title", "")
+            kr_label in i.get("labels", [])
             for i in all_issues
             if i.get("status") not in (IssueStatus.DONE.value, IssueStatus.RELEASED.value)
         )
@@ -475,7 +546,7 @@ async def run_product_check(product_slug: str) -> dict:
                 description=f"Key result '{kr_title}' is at {current}/{target}. Create and execute work to advance this metric.",
                 priority=IssuePriority.P2,
                 created_by="system",
-                labels=["kr-tracking", "auto-created"],
+                labels=["kr-tracking", "auto-created", kr_label],
             )
             actions_taken.append(f"Created issue for KR: {kr_title}")
             all_issues.append(issue)  # prevent duplicate creation in same cycle
@@ -665,6 +736,12 @@ async def handle_issue_assigned(event: CompanyEvent) -> None:
         logger.debug("[PRODUCT_TRIGGER] Issue {} already has linked tasks {}, skip", issue_id, linked)
         return
 
+    # Re-read to guard against race with handle_issue_created
+    fresh_issue = prod.load_issue(slug, issue_id)
+    if fresh_issue and fresh_issue.get("linked_task_ids"):
+        logger.debug("[PRODUCT_TRIGGER] Race guard: issue {} got linked_task_ids before project creation", issue_id)
+        return
+
     logger.info("[PRODUCT_TRIGGER] Issue {} assigned to {} — creating project", issue_id, assignee_id)
     project_id = await _create_project_for_issue(slug, issue)