@1mancompany/onemancompany 0.7.12 → 0.7.20

package/frontend/app.js

@@ -795,6 +795,9 @@ class AppController {
     // Create Product modal
     this._initCreateProductModal();
 
+    // Product selector feedback
+    this._initProductSelector();
+
     hrBtn?.addEventListener('click', () => {
       hrBtn.disabled = true;
       this.logEntry('CEO', '🔄 Triggering quarterly review...', 'ceo');
@@ -7262,6 +7265,20 @@ class AppController {
   }
 
   // ===== Product Selector =====
+  _initProductSelector() {
+    const sel = document.getElementById('ceo-product-select');
+    if (!sel) return;
+    sel.addEventListener('change', () => {
+      if (sel.value) {
+        sel.style.borderColor = 'var(--pixel-cyan)';
+        sel.style.color = 'var(--pixel-white)';
+      } else {
+        sel.style.borderColor = '';
+        sel.style.color = '';
+      }
+    });
+  }
+
   async _refreshProductSelector() {
     try {
       const data = await fetch('/api/products').then(r => r.json());

package/package.json

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

package/src/onemancompany/agents/common_tools.py

@@ -1916,6 +1916,11 @@ def _register_all_internal_tools() -> None:
     for t in _product_tools:
         tool_registry.register(t, ToolMeta(name=t.name, category="base"))
 
+    # Product workspace tools — promote_to_product
+    from onemancompany.agents.product_workspace_tools import PRODUCT_WORKSPACE_TOOLS as _pw_tools
+    for t in _pw_tools:
+        tool_registry.register(t, ToolMeta(name=t.name, category="base"))
+
     # Tree tools self-register on import
     from onemancompany.agents import tree_tools as _tt  # noqa: F401
 

package/src/onemancompany/agents/product_workspace_tools.py

@@ -0,0 +1,113 @@
+"""Product workspace tools for LangChain agents.
+
+Provides promote_to_product — merges a project worktree back into the shared
+product workspace (main branch).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from langchain_core.tools import tool
+from loguru import logger
+
+from onemancompany.core import product_workspace as pw
+
+
+# ---------------------------------------------------------------------------
+# Context resolver
+# ---------------------------------------------------------------------------
+
+
+def _resolve_product_workspace() -> tuple[Path, Path, str]:
+    """Resolve the current execution context to find the product workspace.
+
+    Returns (workspace_dir, worktree_path, project_id).
+    """
+    from onemancompany.core.vessel import _current_vessel
+    from onemancompany.core.project_archive import load_named_project
+    from onemancompany.core.product import find_slug_by_product_id
+    from onemancompany.core.config import PRODUCTS_DIR, PROJECTS_DIR, PRODUCT_WORKTREE_DIR_NAME
+
+    vessel = _current_vessel.get()
+    if not vessel:
+        raise ValueError("No active vessel context")
+
+    # Get project_id from the running node
+    project_id = ""
+    if hasattr(vessel, "_running_node") and vessel._running_node:
+        project_id = vessel._running_node.project_id or ""
+    if not project_id:
+        raise ValueError("Current task is not part of a project")
+
+    proj_doc = load_named_project(project_id)
+    if not proj_doc:
+        raise ValueError(f"Project {project_id} not found")
+
+    product_id = proj_doc.get("product_id", "")
+    if not product_id:
+        raise ValueError(f"Project {project_id} is not linked to a product")
+
+    slug = find_slug_by_product_id(product_id)
+    if not slug:
+        raise ValueError(f"Product not found for id={product_id}")
+
+    workspace_dir = PRODUCTS_DIR / slug / "workspace"
+    worktree_path = PROJECTS_DIR / project_id / PRODUCT_WORKTREE_DIR_NAME
+
+    if not workspace_dir.exists():
+        raise ValueError(f"Product workspace not initialized for {slug}")
+    if not worktree_path.exists():
+        raise ValueError(f"Product worktree not found at {worktree_path}")
+
+    return workspace_dir, worktree_path, project_id
+
+
+# ---------------------------------------------------------------------------
+# Tools
+# ---------------------------------------------------------------------------
+
+
+@tool
+async def promote_to_product(abort: bool = False) -> str:
+    """Merge your product workspace changes into the shared product.
+
+    Syncs with the latest product state, then merges your changes.
+    If there are conflicts, returns both versions for each conflicted file.
+    Edit the files in your product workspace to resolve, then call again.
+
+    Args:
+        abort: Set to True to abort an in-progress merge and restore clean state.
+    """
+    workspace_dir, worktree_path, project_id = _resolve_product_workspace()
+    logger.debug(
+        "promote_to_product: project_id={} abort={} ws={} wt={}",
+        project_id, abort, workspace_dir, worktree_path,
+    )
+
+    result = pw.promote(workspace_dir, worktree_path, project_id, abort=abort)
+    status = result.get("status", "")
+    message = result.get("message", "")
+    conflicts = result.get("conflicts", [])
+
+    if status == "conflict" and conflicts:
+        lines = [f"Merge conflicts detected in {len(conflicts)} file(s):\n"]
+        for c in conflicts:
+            lines.append(f"--- {c['file']} ---")
+            lines.append(f"YOUR VERSION:\n{c['your_version']}")
+            lines.append(f"PRODUCT VERSION:\n{c['product_version']}")
+            lines.append("")
+        lines.append(
+            "Edit the conflicted files in your product workspace to resolve, "
+            "then call promote_to_product() again."
+        )
+        return "\n".join(lines)
+
+    return message
+
+
+# ---------------------------------------------------------------------------
+# Export
+# ---------------------------------------------------------------------------
+
+PRODUCT_WORKSPACE_TOOLS = [promote_to_product]

package/src/onemancompany/api/routes.py

@@ -655,7 +655,7 @@ async def ceo_submit_task(
 
 @router.post("/api/task/{project_id}/followup")
 async def task_followup(project_id: str, body: dict) -> dict:
-    """CEO adds follow-up instructions to an existing task, dispatched to EA with context."""
+    """CEO adds follow-up instructions to an existing task, dispatched to assignee (product owner or EA) with context."""
     from datetime import datetime as _dt
 
     from onemancompany.core.agent_loop import get_agent_loop
@@ -699,7 +699,23 @@ async def task_followup(project_id: str, body: dict) -> dict:
             for fname in deliverables:
                 work_summary_lines.append(f"  {fname}")
 
-    # Build follow-up task for EA
+    # Determine assignee: product owner if product-linked, else EA
+    assignee_id = EA_ID
+    product_id = doc.get("product_id", "")
+    if product_id:
+        from onemancompany.core.product import find_slug_by_product_id, load_product
+        product_slug = find_slug_by_product_id(product_id)
+        if product_slug:
+            product = load_product(product_slug)
+            if product and product.get("owner_id"):
+                assignee_id = product["owner_id"]
+                logger.debug("[FOLLOWUP] Product-linked project {}, routing to owner {}",
+                             project_id, assignee_id)
+        if assignee_id == EA_ID:
+            logger.debug("[FOLLOWUP] No product owner found for project {}, falling back to EA",
+                         project_id)
+
+    # Build follow-up task for assignee
     context_parts = [
         f"CEO has added follow-up instructions to a completed task:\n",
         f"Original task: {original_task}\n",
@@ -721,11 +737,11 @@ async def task_followup(project_id: str, body: dict) -> dict:
     else:
         tree = TaskTree(project_id=project_id)
 
-    ea_loop = get_agent_loop(EA_ID)
-    if not ea_loop:
-        raise HTTPException(status_code=503, detail="EA agent not available")
+    assignee_loop = get_agent_loop(assignee_id)
+    if not assignee_loop:
+        raise HTTPException(status_code=503, detail=f"Agent {assignee_id} not available")
 
-    schedule_node_id = ""  # will be set to the EA node to schedule
+    schedule_node_id = ""  # will be set to the assignee node to schedule
 
     if tree.root_id:
         # Add a new subtree from CEO root — old subtree stays intact
@@ -741,39 +757,39 @@ async def task_followup(project_id: str, body: dict) -> dict:
         followup_node.node_type = NodeType.CEO_FOLLOWUP
         followup_node.status = TaskPhase.ACCEPTED.value
 
-        # Create a new EA node under the followup node for execution
-        ea_child = tree.add_child(
+        # Create execution node under the followup node
+        exec_child = tree.add_child(
             parent_id=followup_node.id,
-            employee_id=EA_ID,
+            employee_id=assignee_id,
             description=followup_task,
             acceptance_criteria=[],
         )
-        schedule_node_id = ea_child.id
+        schedule_node_id = exec_child.id
 
         # Keep CEO root in PROCESSING while new subtree runs
         if root and root.node_type == NodeType.CEO_PROMPT:
             root.status = TaskPhase.PROCESSING.value
     else:
-        # No root yet — create CEO root + EA child
+        # No root yet — create CEO root + assignee child
         ceo_root = tree.create_root(employee_id=CEO_ID, description=instructions)
         ceo_root.node_type = NodeType.CEO_PROMPT
         ceo_root.set_status(TaskPhase.PROCESSING)
-        ea_child = tree.add_child(
+        exec_child = tree.add_child(
             parent_id=ceo_root.id,
-            employee_id=EA_ID,
+            employee_id=assignee_id,
             description=instructions,
             acceptance_criteria=[],
         )
-        schedule_node_id = ea_child.id
+        schedule_node_id = exec_child.id
 
     _save_project_tree(pdir, tree)
 
-    # Schedule the EA node for execution
+    # Schedule the assignee node for execution
     if schedule_node_id:
         tree_path = str(Path(pdir) / TASK_TREE_FILENAME)
         from onemancompany.core.agent_loop import employee_manager
-        employee_manager.schedule_node(EA_ID, schedule_node_id, tree_path)
-        employee_manager._schedule_next(EA_ID)
+        employee_manager.schedule_node(assignee_id, schedule_node_id, tree_path)
+        employee_manager._schedule_next(assignee_id)
 
     # Update project.yaml status back to in_progress
     doc["status"] = "in_progress"

package/src/onemancompany/core/config.py

@@ -69,6 +69,7 @@ SRC_DIR_NAME = "src"
 LAUNCH_SH_FILENAME = "launch.sh"
 PROMPTS_DIR_NAME = "prompts"
 WORKSPACE_DIR_NAME = "workspace"
+PRODUCT_WORKTREE_DIR_NAME = "product_worktree"
 VESSEL_DIR_NAME = "vessel"
 AGENT_DIR_NAME = "agent"
 

package/src/onemancompany/core/product.py

@@ -113,6 +113,7 @@ def create_product(
         "status": status,
         "current_version": current_version,
         "key_results": [],
+        "workspace_initialized": False,
         "created_at": now,
         "updated_at": now,
     }
@@ -645,6 +646,14 @@ def delete_product(slug: str) -> dict:
                         employee_manager.abort_project(proj["project_id"])
                     except Exception as e:
                         logger.debug("[PRODUCT] Could not abort project {}: {}", proj["project_id"], e)
+
+                    # Remove product worktree dir if it exists
+                    from onemancompany.core.config import PRODUCT_WORKTREE_DIR_NAME
+                    wt_dir = proj_dir / PRODUCT_WORKTREE_DIR_NAME
+                    if wt_dir.exists():
+                        _shutil.rmtree(wt_dir)
+                        logger.debug("[PRODUCT] Removed product worktree for project {}", proj["project_id"])
+
                     _shutil.rmtree(proj_dir)
                     deleted_projects += 1
                     logger.debug("[PRODUCT] Deleted linked project {}", proj["project_id"])

package/src/onemancompany/core/product_workspace.py

@@ -0,0 +1,248 @@
+"""Git operations for product workspaces — init, worktree management, and promote."""
+
+from __future__ import annotations
+
+import os
+import re
+import subprocess
+from pathlib import Path
+
+from filelock import FileLock
+from loguru import logger
+
+
+# ---------------------------------------------------------------------------
+# Helper
+# ---------------------------------------------------------------------------
+
+
+def _git(
+    args: list[str],
+    cwd: Path,
+    *,
+    check: bool = True,
+) -> subprocess.CompletedProcess[str]:
+    """Run a git command with debug logging.
+
+    Strips ``GIT_*`` env vars so that tests running inside a git worktree
+    (or after other tests that leak git env) don't interfere.
+    """
+    cmd = ["git", *args]
+    logger.debug("git: {} (cwd={})", " ".join(cmd), cwd)
+    env = {k: v for k, v in os.environ.items() if not k.startswith("GIT_")}
+    result = subprocess.run(cmd, cwd=cwd, capture_output=True, text=True, check=False, env=env)
+    logger.debug("git rc={} stdout={!r} stderr={!r}", result.returncode, result.stdout[:200], result.stderr[:200])
+    if check and result.returncode != 0:
+        raise subprocess.CalledProcessError(
+            result.returncode, cmd, result.stdout, result.stderr
+        )
+    return result
+
+
+# ---------------------------------------------------------------------------
+# init_workspace
+# ---------------------------------------------------------------------------
+
+
+def init_workspace(workspace_dir: Path) -> None:
+    """``git init`` a directory with an initial commit. Idempotent."""
+    if (workspace_dir / ".git").is_dir():
+        logger.debug("init_workspace: already initialised at {}", workspace_dir)
+        return
+
+    workspace_dir.mkdir(parents=True, exist_ok=True)
+    _git(["init", "-b", "main"], workspace_dir)
+    _git(["config", "user.email", "workspace@localhost"], workspace_dir)
+    _git(["config", "user.name", "workspace"], workspace_dir)
+
+    readme = workspace_dir / "README.md"
+    readme.write_text("# Product Workspace\n")
+    _git(["add", "README.md"], workspace_dir)
+    _git(["commit", "-m", "Initial commit"], workspace_dir)
+
+
+# ---------------------------------------------------------------------------
+# add_worktree / remove_worktree
+# ---------------------------------------------------------------------------
+
+
+def add_worktree(workspace_dir: Path, worktree_path: Path, project_id: str) -> None:
+    """``git worktree add`` on branch ``project/{project_id}``. Idempotent."""
+    branch = f"project/{project_id}"
+
+    if worktree_path.is_dir():
+        logger.debug("add_worktree: {} already exists, skipping", worktree_path)
+        return
+
+    _git(["worktree", "add", "-b", branch, str(worktree_path)], workspace_dir)
+
+
+def remove_worktree(workspace_dir: Path, worktree_path: Path, project_id: str) -> None:
+    """Remove a worktree and delete its branch. Idempotent / noop if missing."""
+    branch = f"project/{project_id}"
+
+    # Guard: if workspace_dir itself is gone (e.g. product already deleted),
+    # there's nothing to clean up in git — just remove the directory.
+    if not (workspace_dir / ".git").is_dir():
+        logger.debug("remove_worktree: workspace {} gone, skipping git cleanup", workspace_dir)
+        if worktree_path.is_dir():
+            import shutil
+            shutil.rmtree(worktree_path)
+        return
+
+    if worktree_path.is_dir():
+        _git(["worktree", "remove", "--force", str(worktree_path)], workspace_dir)
+
+    # Prune stale worktree bookkeeping
+    _git(["worktree", "prune"], workspace_dir)
+
+    # Delete branch if it exists
+    result = _git(["branch", "--list", branch], workspace_dir)
+    if branch in result.stdout:
+        _git(["branch", "-D", branch], workspace_dir)
+
+
+# ---------------------------------------------------------------------------
+# promote
+# ---------------------------------------------------------------------------
+
+
+def _is_merging(workspace_dir: Path) -> bool:
+    """Check if the workspace is in a merge state."""
+    return (workspace_dir / ".git" / "MERGE_HEAD").exists()
+
+
+def _has_conflict_markers(workspace_dir: Path) -> bool:
+    """Check if any unmerged file still has conflict markers in its working-tree content.
+
+    Two-step check: first find unmerged paths via the index, then read the
+    actual file content for ``<<<<<<<`` markers.  This avoids false positives
+    from ``git diff --check`` (which also flags trailing-whitespace) while
+    correctly detecting resolved-but-unstaged files.
+    """
+    result = _git(["diff", "--name-only", "--diff-filter=U"], workspace_dir, check=False)
+    unmerged = [f for f in result.stdout.strip().splitlines() if f]
+    if not unmerged:
+        return False
+    for fname in unmerged:
+        fpath = workspace_dir / fname
+        if fpath.is_file() and "<<<<<<<" in fpath.read_text():
+            return True
+    return False
+
+
+def _parse_conflicts(workspace_dir: Path) -> list[dict]:
+    """Parse unmerged files and extract ours/theirs content."""
+    result = _git(["diff", "--name-only", "--diff-filter=U"], workspace_dir)
+    conflicts = []
+    for fname in result.stdout.strip().splitlines():
+        if not fname:
+            continue
+        raw = (workspace_dir / fname).read_text()
+        ours = ""
+        theirs = ""
+        for match in re.finditer(
+            r"<<<<<<<[^\n]*\n(.*?)=======\n(.*?)>>>>>>>[^\n]*\n",
+            raw,
+            re.DOTALL,
+        ):
+            ours += match.group(1)
+            theirs += match.group(2)
+        conflicts.append({"file": fname, "your_version": theirs, "product_version": ours})
+    return conflicts
+
+
+def _workspace_lock(workspace_dir: Path) -> FileLock:
+    """Return a per-workspace file lock to serialise promote operations."""
+    return FileLock(workspace_dir / ".git" / "promote.lock", timeout=120)
+
+
+def promote(
+    workspace_dir: Path,
+    worktree_path: Path,
+    project_id: str,
+    *,
+    abort: bool = False,
+) -> dict:
+    """Stateful merge of project branch into main.
+
+    Acquires a per-workspace file lock so concurrent promote calls on the
+    same product are serialised.  Returns dict with keys: status, conflicts,
+    message.
+    """
+    branch = f"project/{project_id}"
+
+    with _workspace_lock(workspace_dir):
+        # --- Abort mode ---
+        if abort:
+            if _is_merging(workspace_dir):
+                _git(["merge", "--abort"], workspace_dir)
+                return {"status": "aborted", "conflicts": [], "message": "Merge aborted."}
+            return {"status": "aborted", "conflicts": [], "message": "No merge in progress."}
+
+        # --- Resume after conflict resolution ---
+        if _is_merging(workspace_dir):
+            if _has_conflict_markers(workspace_dir):
+                conflicts = _parse_conflicts(workspace_dir)
+                return {
+                    "status": "conflict",
+                    "conflicts": conflicts,
+                    "message": "Conflicts still present.",
+                }
+            # All resolved — stage and finalize
+            _git(["add", "-A"], workspace_dir)
+            _git(["commit", "--no-edit"], workspace_dir)
+            return {"status": "merged", "conflicts": [], "message": "Merge completed after conflict resolution."}
+
+        # --- Normal flow: sync main into branch, then merge branch into main ---
+
+        # Step 1: merge main into project branch (sync — best effort)
+        # If the sync conflicts, abort it to avoid leaving the worktree dirty.
+        # The promote still works because Step 3 merges the branch HEAD (not
+        # the worktree state) into main.
+        sync = _git(["merge", "main", "--no-edit"], worktree_path, check=False)
+        if sync.returncode != 0:
+            _git(["merge", "--abort"], worktree_path, check=False)
+            logger.debug("promote: sync merge into branch failed for {}, proceeding", branch)
+
+        # Step 2: check if branch has anything beyond main
+        result = _git(["log", f"main..{branch}", "--oneline"], workspace_dir)
+        if not result.stdout.strip():
+            return {"status": "nothing", "conflicts": [], "message": "Nothing to merge."}
+
+        # Step 3: merge project branch into main
+        merge = _git(["merge", branch, "--no-edit"], workspace_dir, check=False)
+
+        if merge.returncode == 0:
+            return {"status": "merged", "conflicts": [], "message": "Branch merged into main."}
+
+        # Conflict
+        conflicts = _parse_conflicts(workspace_dir)
+        return {
+            "status": "conflict",
+            "conflicts": conflicts,
+            "message": "Merge conflicts detected.",
+        }
+
+
+# ---------------------------------------------------------------------------
+# Context injection helpers
+# ---------------------------------------------------------------------------
+
+
+def format_workspace_context(worktree_path: str, product_name: str, file_count: int) -> str:
+    """Build the context string injected into task descriptions."""
+    return (
+        f'[Product "{product_name}" workspace: {worktree_path} ({file_count} files)\n'
+        f" Read and write files here using your normal tools.\n"
+        f" When changes are ready, call promote_to_product() to merge into the product.]"
+    )
+
+
+def count_worktree_files(worktree_path: Path) -> int:
+    """Count user-facing files in a worktree (excluding .git, README.md)."""
+    count = 0
+    for f in worktree_path.rglob("*"):
+        if f.is_file() and ".git" not in f.parts and f.name != "README.md":
+            count += 1
+    return count

package/src/onemancompany/core/project_archive.py

@@ -24,6 +24,8 @@ import yaml
 
 from onemancompany.core.config import (
     NODES_DIR_NAME,
+    PRODUCT_WORKTREE_DIR_NAME,
+    PRODUCTS_DIR,
     PROJECT_YAML_FILENAME,
     PROJECTS_DIR,
     TASK_TREE_FILENAME,
@@ -325,6 +327,46 @@ def create_project_from_task(task: str, routed_to: str = "pending",
     return project_id, iter_id
 
 
+def _setup_product_worktree(project_id: str, product_id: str) -> None:
+    """Create/reuse a product workspace and add a worktree for this project."""
+    from onemancompany.core.product import find_slug_by_product_id, load_product, update_product
+    from onemancompany.core.product_workspace import init_workspace, add_worktree
+
+    product_slug = find_slug_by_product_id(product_id)
+    if not product_slug:
+        logger.warning("[PROJECT] product_id={} not found, skipping worktree setup", product_id)
+        return
+
+    product = load_product(product_slug)
+    workspace_dir = PRODUCTS_DIR / product_slug / "workspace"
+
+    if not product.get("workspace_initialized"):
+        init_workspace(workspace_dir)
+        update_product(product_slug, workspace_initialized=True)
+
+    worktree_path = PROJECTS_DIR / project_id / PRODUCT_WORKTREE_DIR_NAME
+    add_worktree(workspace_dir, worktree_path, project_id)
+
+
+def _cleanup_product_worktree(project_id: str, proj_doc: dict) -> None:
+    """Remove the product worktree for an archived project."""
+    product_id = proj_doc.get("product_id", "")
+    if not product_id:
+        return
+
+    from onemancompany.core.product import find_slug_by_product_id
+    from onemancompany.core.product_workspace import remove_worktree
+
+    product_slug = find_slug_by_product_id(product_id)
+    if not product_slug:
+        logger.debug("[PROJECT] product_id={} not found during worktree cleanup", product_id)
+        return
+
+    workspace_dir = PRODUCTS_DIR / product_slug / "workspace"
+    worktree_path = PROJECTS_DIR / project_id / PRODUCT_WORKTREE_DIR_NAME
+    remove_worktree(workspace_dir, worktree_path, project_id)
+
+
 def create_named_project(name: str, *, product_id: str = "") -> str:
     """Create a persistent named project. Returns the project_id (UUID-based)."""
     slug = uuid.uuid4().hex[:12]
@@ -352,6 +394,10 @@ def create_named_project(name: str, *, product_id: str = "") -> str:
     lock = _get_project_lock(slug)
     with lock, open_utf(path, "w") as f:
         yaml.dump(doc, f, allow_unicode=True, default_flow_style=False)
+
+    if product_id:
+        _setup_product_worktree(slug, product_id)
+
     return slug
 
 
@@ -513,6 +559,8 @@ def archive_project(project_id: str) -> None:
     with lock, open_utf(path, "w") as f:
         yaml.dump(proj, f, allow_unicode=True, default_flow_style=False)
 
+    _cleanup_product_worktree(project_id, proj)
+
     # Close project conversation so it disappears from CEO console
     try:
         from onemancompany.core.conversation import get_conversation_service

package/src/onemancompany/core/vessel.py

@@ -1459,6 +1459,12 @@ class EmployeeManager:
                 if _effective_dir:
                     task_with_ctx += f"\n\n[Project workspace: {_effective_dir} — save all outputs here]"
 
+                # Product workspace — inject if project has a product worktree
+                if project_id:
+                    _pw_ctx = self._get_product_workspace_context(project_id)
+                    if _pw_ctx:
+                        task_with_ctx += f"\n\n{_pw_ctx}"
+
                 if project_id:
                     proj_ctx = self._get_project_history_context(project_id)
                     if proj_ctx:
@@ -2065,6 +2071,37 @@ class EmployeeManager:
     _CTX_MAX_WORKSPACE_FILES = 30
     _CTX_MAX_CRITERIA = 5
 
+    @staticmethod
+    def _get_product_workspace_context(project_id: str) -> str:
+        """Build product workspace context string if project is linked to a product."""
+        from onemancompany.core.project_archive import load_named_project
+        from onemancompany.core.product import find_slug_by_product_id, load_product
+        from onemancompany.core.config import PRODUCTS_DIR, PROJECTS_DIR, PRODUCT_WORKTREE_DIR_NAME
+
+        base_project_id = project_id.split("/")[0]
+        proj_doc = load_named_project(base_project_id)
+        if not proj_doc:
+            return ""
+        product_id = proj_doc.get("product_id", "")
+        if not product_id:
+            return ""
+
+        slug = find_slug_by_product_id(product_id)
+        if not slug:
+            return ""
+
+        product = load_product(slug)
+        if not product or not product.get("workspace_initialized", False):
+            return ""
+
+        worktree_path = PROJECTS_DIR / base_project_id / PRODUCT_WORKTREE_DIR_NAME
+        if not worktree_path.is_dir():
+            return ""
+
+        from onemancompany.core.product_workspace import format_workspace_context, count_worktree_files
+        file_count = count_worktree_files(worktree_path)
+        return format_workspace_context(str(worktree_path), product.get("name", slug), file_count)
+
     def _get_project_history_context(self, project_id: str) -> str:
         from onemancompany.core.project_archive import (
             _is_iteration, _find_project_for_iteration,