ventilatepro-cli 0.5.0__tar.gz → 0.5.2__tar.gz

{ventilatepro_cli-0.5.0 → ventilatepro_cli-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ventilatepro-cli
-Version: 0.5.0
+Version: 0.5.2
 Summary: VentilatePro CLI
 Project-URL: Homepage, https://ventilatepro.com/exam/cli/
 Project-URL: Documentation, https://ventilatepro.com/exam/cli/
@@ -61,6 +61,11 @@ ventilatepro notes sync
 ventilatepro meetings context --project 1 --json
 ventilatepro meetings record --project 1 --input meeting.json --json
 ventilatepro meetings list --project 1
+ventilatepro decisions create --project 1 --text "Use heat recovery on AHU-2" --reason "Energy model payback" --tags ahu,energy
+ventilatepro decisions list --project 1
+ventilatepro decisions revise 51 --text "Use heat recovery with bypass control"
+ventilatepro tasks context --project 1 --json
+ventilatepro tasks create --project 1 --description "Issue updated duct plan" --assignee-id 12 --priority high
 ventilatepro mcp doctor
 ventilatepro-mcp
 ```
@@ -74,6 +79,17 @@ stable project-member IDs, interprets the PM's prose into a structured JSON
 payload, and calls `meetings record`. The server atomically creates the meeting,
 decisions, and assigned project tasks and returns a direct web-app link.
 
+For standalone work, Codex reads `tasks context` to resolve an assignee to a
+stable project-member user ID, then calls `tasks create`. The same workflow is
+available through the typed `vp_get_task_context` and
+`vp_create_project_task` MCP tools.
+
+Design decisions do not require meeting minutes. Codex can call `decisions
+create` or `vp_create_decision` as soon as a PM communicates a decision, with
+an optional meeting ID only when the relationship is useful. Listing, showing,
+and revising decisions are available through first-class CLI and MCP surfaces;
+revisions preserve the prior version as immutable history.
+
 For room classification, Codex can read the project-specific categorization
 review resource or use the dedicated MCP tools. Review manifests default every
 room to rejected so ambiguous spaces remain visible until a category is

{ventilatepro_cli-0.5.0 → ventilatepro_cli-0.5.2}/README.md

@@ -46,6 +46,11 @@ ventilatepro notes sync
 ventilatepro meetings context --project 1 --json
 ventilatepro meetings record --project 1 --input meeting.json --json
 ventilatepro meetings list --project 1
+ventilatepro decisions create --project 1 --text "Use heat recovery on AHU-2" --reason "Energy model payback" --tags ahu,energy
+ventilatepro decisions list --project 1
+ventilatepro decisions revise 51 --text "Use heat recovery with bypass control"
+ventilatepro tasks context --project 1 --json
+ventilatepro tasks create --project 1 --description "Issue updated duct plan" --assignee-id 12 --priority high
 ventilatepro mcp doctor
 ventilatepro-mcp
 ```
@@ -59,6 +64,17 @@ stable project-member IDs, interprets the PM's prose into a structured JSON
 payload, and calls `meetings record`. The server atomically creates the meeting,
 decisions, and assigned project tasks and returns a direct web-app link.
 
+For standalone work, Codex reads `tasks context` to resolve an assignee to a
+stable project-member user ID, then calls `tasks create`. The same workflow is
+available through the typed `vp_get_task_context` and
+`vp_create_project_task` MCP tools.
+
+Design decisions do not require meeting minutes. Codex can call `decisions
+create` or `vp_create_decision` as soon as a PM communicates a decision, with
+an optional meeting ID only when the relationship is useful. Listing, showing,
+and revising decisions are available through first-class CLI and MCP surfaces;
+revisions preserve the prior version as immutable history.
+
 For room classification, Codex can read the project-specific categorization
 review resource or use the dedicated MCP tools. Review manifests default every
 room to rejected so ambiguous spaces remain visible until a category is

{ventilatepro_cli-0.5.0 → ventilatepro_cli-0.5.2}/tests/test_cli.py

@@ -362,6 +362,267 @@ class CliTests(unittest.TestCase):
         self.assertEqual(payload["members"][0]["user_id"], 12)
         fake_client.meeting_context.assert_called_once_with(1)
 
+    def test_tasks_context_outputs_assignable_directory(self):
+        fake_client = mock.Mock()
+        fake_client.task_context.return_value = {
+            "project": {"id": 1, "name": "Hospital"},
+            "members": [
+                {
+                    "user_id": 12,
+                    "name": "Alex Engineer",
+                    "email": "alex@example.com",
+                    "role": "engineer",
+                },
+            ],
+        }
+        with mock.patch.object(
+            auth,
+            "get_authenticated_client",
+            return_value=(fake_client, "http://localhost:8000"),
+        ):
+            result = self.runner.invoke(
+                app,
+                ["tasks", "context", "--project", "1", "--json"],
+            )
+
+        self.assertEqual(result.exit_code, 0)
+        payload = json.loads(result.stdout)
+        self.assertEqual(payload["members"][0]["user_id"], 12)
+        fake_client.task_context.assert_called_once_with(1)
+
+    def test_tasks_create_assigns_project_member(self):
+        fake_client = mock.Mock()
+        fake_client.base_url = "https://ventilatepro.com"
+        fake_client.create_project_task.return_value = {
+            "id": 46,
+            "project": 1,
+            "description": "Issue diffuser update",
+            "assigned_user": 12,
+            "priority": "high",
+            "include_in_minutes": False,
+        }
+        with mock.patch.object(
+            auth,
+            "get_authenticated_client",
+            return_value=(fake_client, "https://ventilatepro.com"),
+        ):
+            result = self.runner.invoke(
+                app,
+                [
+                    "tasks",
+                    "create",
+                    "--project",
+                    "1",
+                    "--description",
+                    "Issue diffuser update",
+                    "--assignee-id",
+                    "12",
+                    "--due-at",
+                    "2026-08-05T17:00:00-07:00",
+                    "--priority",
+                    "high",
+                    "--notes",
+                    "Coordinate with architecture.",
+                    "--estimated-hours",
+                    "2.5",
+                    "--json",
+                ],
+            )
+
+        self.assertEqual(result.exit_code, 0)
+        payload = json.loads(result.stdout)
+        self.assertEqual(payload["task"]["id"], 46)
+        self.assertIn("view=project-tasks", payload["deep_link"])
+        sent_payload = fake_client.create_project_task.call_args.args[0]
+        self.assertEqual(sent_payload["project"], 1)
+        self.assertEqual(sent_payload["assigned_user"], 12)
+        self.assertEqual(sent_payload["priority"], "high")
+        self.assertFalse(sent_payload["include_in_minutes"])
+        self.assertEqual(sent_payload["source"], "cli")
+
+    def test_decisions_create_logs_standalone_decision_immediately(self):
+        fake_client = mock.Mock()
+        fake_client.base_url = "https://ventilatepro.com"
+        fake_client.create_decision.return_value = {
+            "project": 1,
+            "created": [{
+                "model": "notes.Decision",
+                "id": 51,
+                "data": {
+                    "id": 51,
+                    "project": 1,
+                    "minute": None,
+                    "text": "Use heat recovery on AHU-2.",
+                    "reason": "Energy model payback.",
+                    "impact": "Add a heat recovery wheel.",
+                    "code_reference": "ASHRAE 90.1",
+                    "tags": ["ahu", "energy"],
+                    "version": 1,
+                    "is_active": True,
+                },
+            }],
+            "audit_entry_id": 52,
+            "idempotent": False,
+        }
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            os.environ[config.DATA_ENV_VAR] = tmpdir
+            try:
+                with mock.patch.object(
+                    auth,
+                    "get_authenticated_client",
+                    return_value=(fake_client, "https://ventilatepro.com"),
+                ):
+                    result = self.runner.invoke(
+                        app,
+                        [
+                            "decisions",
+                            "create",
+                            "--project",
+                            "1",
+                            "--text",
+                            "Use heat recovery on AHU-2.",
+                            "--reason",
+                            "Energy model payback.",
+                            "--impact",
+                            "Add a heat recovery wheel.",
+                            "--code-reference",
+                            "ASHRAE 90.1",
+                            "--tags",
+                            "ahu, energy, ahu",
+                            "--idempotency-key",
+                            "decision-51",
+                            "--json",
+                        ],
+                    )
+            finally:
+                os.environ.pop(config.DATA_ENV_VAR, None)
+
+        self.assertEqual(result.exit_code, 0)
+        payload = json.loads(result.stdout)
+        self.assertEqual(payload["decision_ref"], "decision:51")
+        self.assertIn("view=decision-log", payload["deep_link"])
+        sent = fake_client.create_decision.call_args.args[0]
+        self.assertEqual(sent["project_id"], 1)
+        self.assertEqual(sent["idempotency_key"], "decision-51")
+        decision_data = sent["writes"][0]["data"]
+        self.assertNotIn("minute", decision_data)
+        self.assertEqual(decision_data["references"], ["ahu", "energy"])
+        self.assertEqual(decision_data["source"], "cli")
+
+    def test_decisions_list_and_revise_use_first_class_commands(self):
+        fake_client = mock.Mock()
+        fake_client.list_decisions.return_value = [{
+            "id": 51,
+            "text": "Use heat recovery on AHU-2.",
+            "version": 1,
+            "is_active": True,
+        }]
+        fake_client.revise_decision.return_value = {
+            "id": 54,
+            "text": "Use heat recovery on AHU-2 with bypass.",
+            "version": 2,
+            "supersedes": 51,
+        }
+        with mock.patch.object(
+            auth,
+            "get_authenticated_client",
+            return_value=(fake_client, "https://ventilatepro.com"),
+        ):
+            list_result = self.runner.invoke(
+                app,
+                ["decisions", "list", "--project", "1", "--json"],
+            )
+            revise_result = self.runner.invoke(
+                app,
+                [
+                    "decisions",
+                    "revise",
+                    "51",
+                    "--text",
+                    "Use heat recovery on AHU-2 with bypass.",
+                    "--tags",
+                    "ahu,energy",
+                    "--json",
+                ],
+            )
+
+        self.assertEqual(list_result.exit_code, 0)
+        self.assertEqual(json.loads(list_result.stdout)["results"][0]["id"], 51)
+        fake_client.list_decisions.assert_called_once_with(
+            1,
+            search=None,
+            include_history=False,
+        )
+        self.assertEqual(revise_result.exit_code, 0)
+        fake_client.revise_decision.assert_called_once_with(
+            51,
+            {
+                "text": "Use heat recovery on AHU-2 with bypass.",
+                "tags": ["ahu", "energy"],
+            },
+        )
+
+    def test_decisions_create_queues_offline_and_syncs_with_same_key(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            os.environ[config.DATA_ENV_VAR] = tmpdir
+            try:
+                offline_client = mock.Mock()
+                offline_client.create_decision.side_effect = NetworkError("offline")
+                with mock.patch.object(
+                    auth,
+                    "get_authenticated_client",
+                    return_value=(offline_client, "https://ventilatepro.com"),
+                ):
+                    queued_result = self.runner.invoke(
+                        app,
+                        [
+                            "decisions",
+                            "create",
+                            "--project",
+                            "1",
+                            "--text",
+                            "Use heat recovery.",
+                            "--idempotency-key",
+                            "offline-decision-1",
+                            "--json",
+                        ],
+                    )
+                self.assertEqual(queued_result.exit_code, 0)
+                queued_payload = json.loads(queued_result.stdout)
+                self.assertEqual(queued_payload["status"], "queued")
+
+                online_client = mock.Mock()
+                online_client.base_url = "https://ventilatepro.com"
+                online_client.create_decision.return_value = {
+                    "created": [{
+                        "model": "notes.Decision",
+                        "id": 61,
+                        "data": {"id": 61, "text": "Use heat recovery."},
+                    }],
+                    "audit_entry_id": 62,
+                    "idempotent": False,
+                }
+                with mock.patch.object(
+                    auth,
+                    "get_authenticated_client",
+                    return_value=(online_client, "https://ventilatepro.com"),
+                ):
+                    sync_result = self.runner.invoke(
+                        app,
+                        ["decisions", "sync", "--project", "1", "--json"],
+                    )
+
+                self.assertEqual(sync_result.exit_code, 0)
+                self.assertEqual(json.loads(sync_result.stdout)["synced"], 1)
+                sent = online_client.create_decision.call_args.args[0]
+                self.assertEqual(sent["idempotency_key"], "offline-decision-1")
+                operation = QueueStore().get_operation(queued_payload["local_id"])
+                self.assertEqual(operation.sync_state, "synced")
+                self.assertEqual(operation.server_ref, "decision:61")
+            finally:
+                os.environ.pop(config.DATA_ENV_VAR, None)
+
     def test_meetings_record_reads_structured_stdin_and_saves_immediately(self):
         fake_client = mock.Mock()
         fake_client.record_meeting.return_value = {

{ventilatepro_cli-0.5.0 → ventilatepro_cli-0.5.2}/tests/test_mcp_server.py

@@ -41,6 +41,45 @@ class FakeClient:
             "deep_link": "https://ventilatepro.com/?view=meeting-minutes&project=7&minute=31",
         }
 
+    def task_context(self, project_id):
+        self.calls.append(("task_context", project_id))
+        return {
+            "project": {"id": project_id, "name": "Hospital"},
+            "members": [{"user_id": 12, "name": "Alex Engineer"}],
+        }
+
+    def create_project_task(self, payload):
+        self.calls.append(("create_project_task", payload))
+        return {"id": 46, **payload}
+
+    def create_decision(self, payload):
+        self.calls.append(("create_decision", payload))
+        return {
+            "project": payload["project_id"],
+            "created": [{
+                "model": "notes.Decision",
+                "id": 51,
+                "data": {
+                    "id": 51,
+                    "project": payload["project_id"],
+                    "minute": payload["writes"][0]["data"].get("minute"),
+                    "text": payload["writes"][0]["data"]["text"],
+                    "version": 1,
+                    "is_active": True,
+                },
+            }],
+            "audit_entry_id": 52,
+            "idempotent": False,
+        }
+
+    def list_decisions(self, project_id, *, search=None, include_history=False):
+        self.calls.append(("list_decisions", project_id, search, include_history))
+        return [{"id": 51, "project": project_id, "text": "Use heat recovery."}]
+
+    def show_decision(self, decision_id, *, project):
+        self.calls.append(("show_decision", decision_id, project))
+        return {"id": decision_id, "project": project, "text": "Use heat recovery."}
+
     def revit_import_pending(self, project_id):
         self.calls.append(("revit_import_pending", project_id))
         return self.revit_session
@@ -74,9 +113,14 @@ class McpServerTests(unittest.TestCase):
             self.assertIn("vp_get_categorization_review", names)
             self.assertIn("vp_apply_categorization", names)
             self.assertIn("vp_get_meeting_context", names)
+            self.assertIn("vp_get_task_context", names)
+            self.assertIn("vp_create_project_task", names)
             self.assertIn("vp_record_meeting", names)
             self.assertIn("vp_list_meetings", names)
             self.assertIn("vp_get_meeting", names)
+            self.assertIn("vp_create_decision", names)
+            self.assertIn("vp_list_decisions", names)
+            self.assertIn("vp_get_decision", names)
             self.assertIn("vp_revise_decision", names)
             self.assertIn("vp_review_revit_import", names)
             self.assertIn("vp_confirm_revit_import", names)
@@ -168,6 +212,92 @@ class McpServerTests(unittest.TestCase):
 
         asyncio.run(run())
 
+    def test_create_project_task_tool_assigns_member_without_confirmation(self):
+        async def run():
+            server = build_server()
+            fake_client = FakeClient()
+            fake_client.base_url = "https://ventilatepro.com"
+            with mock.patch(
+                "ventilatepro.mcp_server.auth.get_authenticated_client",
+                return_value=(fake_client, "https://ventilatepro.com"),
+            ):
+                _content, structured = await server.call_tool(
+                    "vp_create_project_task",
+                    {
+                        "project_id": 7,
+                        "description": "Issue diffuser update",
+                        "assigned_user_id": 12,
+                        "priority": "high",
+                        "due_at": "2026-08-05T17:00:00-07:00",
+                    },
+                )
+
+            result = structured["result"]
+            self.assertEqual(result["status"], "created")
+            self.assertEqual(result["task"]["id"], 46)
+            self.assertIn("view=project-tasks", result["deep_link"])
+            call_name, sent_payload = fake_client.calls[0]
+            self.assertEqual(call_name, "create_project_task")
+            self.assertEqual(sent_payload["assigned_user"], 12)
+            self.assertFalse(sent_payload["include_in_minutes"])
+
+        asyncio.run(run())
+
+    def test_create_decision_tool_logs_without_meeting_or_confirmation(self):
+        async def run():
+            server = build_server()
+            fake_client = FakeClient()
+            fake_client.base_url = "https://ventilatepro.com"
+            with mock.patch(
+                "ventilatepro.mcp_server.auth.get_authenticated_client",
+                return_value=(fake_client, "https://ventilatepro.com"),
+            ), mock.patch("ventilatepro.mcp_server.QueueStore"):
+                _content, structured = await server.call_tool(
+                    "vp_create_decision",
+                    {
+                        "project_id": 7,
+                        "text": "Use heat recovery.",
+                        "reason": "Energy savings.",
+                        "tags": ["ahu", "energy"],
+                        "idempotency_key": "decision-51",
+                    },
+                )
+
+            result = structured["result"]
+            self.assertEqual(result["status"], "created")
+            self.assertEqual(result["decision_ref"], "decision:51")
+            self.assertIn("view=decision-log", result["deep_link"])
+            call_name, sent = fake_client.calls[0]
+            self.assertEqual(call_name, "create_decision")
+            self.assertEqual(sent["project_id"], 7)
+            self.assertNotIn("minute", sent["writes"][0]["data"])
+
+        asyncio.run(run())
+
+    def test_decision_read_tools_are_project_scoped(self):
+        async def run():
+            server = build_server()
+            fake_client = FakeClient()
+            with mock.patch(
+                "ventilatepro.mcp_server.auth.get_authenticated_client",
+                return_value=(fake_client, "https://ventilatepro.com"),
+            ):
+                _content, listed = await server.call_tool(
+                    "vp_list_decisions",
+                    {"project_id": 7, "query": "recovery"},
+                )
+                _content, shown = await server.call_tool(
+                    "vp_get_decision",
+                    {"project_id": 7, "decision_id": 51},
+                )
+
+            self.assertEqual(listed["result"]["results"][0]["id"], 51)
+            self.assertEqual(shown["result"]["project"], 7)
+            self.assertIn(("list_decisions", 7, "recovery", False), fake_client.calls)
+            self.assertIn(("show_decision", 51, 7), fake_client.calls)
+
+        asyncio.run(run())
+
     def test_generic_api_tool_blocks_prefixed_revit_commit_path(self):
         async def run():
             server = build_server()

{ventilatepro_cli-0.5.0 → ventilatepro_cli-0.5.2}/ventilatepro/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.5.0"
+__version__ = "0.5.2"

{ventilatepro_cli-0.5.0 → ventilatepro_cli-0.5.2}/ventilatepro/api_client.py

@@ -523,6 +523,16 @@ class ApiClient:
             params={"project": project},
         )
 
+    def task_context(self, project: int):
+        return self.meeting_context(project)
+
+    def create_project_task(self, payload: Dict[str, Any]):
+        return self.cli_proxy(
+            "POST",
+            "api/notes/action-items/",
+            json_payload=payload,
+        )
+
     def record_meeting(self, payload: Dict[str, Any]):
         return self.cli_proxy(
             "POST",
@@ -549,6 +559,40 @@ class ApiClient:
             params={"project": project},
         )
 
+    def create_decision(self, payload: Dict[str, Any]):
+        return self.cli_proxy(
+            "POST",
+            "api/notes/ingest/",
+            json_payload=payload,
+        )
+
+    def list_decisions(
+        self,
+        project: int,
+        *,
+        search: Optional[str] = None,
+        include_history: bool = False,
+    ):
+        params: Dict[str, Any] = {"project": project}
+        if search:
+            params["search"] = search
+        response = self.cli_proxy(
+            "GET",
+            "api/notes/decisions/",
+            params=params,
+        )
+        decisions = response.get("results", []) if isinstance(response, dict) else response
+        if include_history:
+            return decisions
+        return [decision for decision in decisions if decision.get("is_active", True)]
+
+    def show_decision(self, decision_id: int, *, project: int):
+        return self.cli_proxy(
+            "GET",
+            f"api/notes/decisions/{decision_id}/",
+            params={"project": project},
+        )
+
     def revise_decision(self, decision_id: int, payload: Dict[str, Any]):
         return self.cli_proxy(
             "POST",

{ventilatepro_cli-0.5.0 → ventilatepro_cli-0.5.2}/ventilatepro/cli.py

@@ -4,7 +4,7 @@ from pathlib import Path
 
 import typer
 
-from . import auth, meetings, notes
+from . import auth, decisions, meetings, notes, tasks
 from .api_client import ApiError, NetworkError
 from .calc import app as calc_app
 from .categorization import app as categorization_app
@@ -29,6 +29,8 @@ app = typer.Typer(help="VentilatePro CLI")
 auth_app = typer.Typer(help="Authentication commands")
 notes_app = typer.Typer(help="Notes commands")
 meetings_app = typer.Typer(help="Meeting minutes commands")
+decisions_app = typer.Typer(help="Design decision commands")
+tasks_app = typer.Typer(help="Project task commands")
 
 app.add_typer(auth_app, name="auth")
 app.add_typer(projects_app, name="projects")
@@ -45,6 +47,8 @@ app.add_typer(revit_imports_app, name="revit-imports")
 app.add_typer(design_day_app, name="design-day")
 app.add_typer(notes_app, name="notes")
 app.add_typer(meetings_app, name="meetings")
+app.add_typer(decisions_app, name="decisions")
+app.add_typer(tasks_app, name="tasks")
 app.add_typer(mcp_app, name="mcp")
 
 
@@ -430,5 +434,226 @@ def meetings_sync(
         raise typer.Exit(1)
 
 
+@decisions_app.command("create")
+def decisions_create(
+    project: int = typer.Option(..., "--project", help="Target project ID"),
+    text: str = typer.Option(..., "--text", help="Decision text"),
+    reason: str = typer.Option(None, "--reason", help="Decision rationale"),
+    impact: str = typer.Option(None, "--impact", help="Design or delivery impact"),
+    code_reference: str = typer.Option(None, "--code-reference", help="Code or standard reference"),
+    tags: str = typer.Option(None, "--tags", help="Comma-separated tags"),
+    meeting_id: int = typer.Option(None, "--meeting-id", help="Optional related meeting-minute ID"),
+    captured_at: str = typer.Option(None, "--captured-at", help="Capture timestamp in ISO-8601 format"),
+    source_message: str = typer.Option(None, "--source-message", help="Original PM input retained for audit"),
+    idempotency_key: str = typer.Option(None, "--idempotency-key", help="Stable retry key"),
+    json_output: bool = typer.Option(False, "--json", help="Return JSON output"),
+):
+    """Log a project decision directly; linking meeting minutes is optional."""
+    try:
+        client, _ = auth.get_authenticated_client()
+        result = decisions.create_decision(
+            client,
+            QueueStore(),
+            project=project,
+            text=text,
+            reason=reason,
+            impact=impact,
+            code_reference=code_reference,
+            tags=notes.parse_tags(tags),
+            meeting_id=meeting_id,
+            captured_at=captured_at,
+            source_message=source_message,
+            idempotency_key=idempotency_key,
+        )
+    except (ValueError, ApiError, NetworkError) as exc:
+        emit_error(str(exc), json_output=json_output)
+        raise typer.Exit(1)
+
+    if result["status"] == "queued":
+        lines = [f"Queued decision locally as operation #{result['local_id']}."]
+    else:
+        lines = [
+            f"Created {result['decision_ref']} in project {project}.",
+            result.get("deep_link") or "",
+        ]
+    emit(result, json_output=json_output, lines=[line for line in lines if line])
+
+
+@decisions_app.command("list")
+def decisions_list(
+    project: int = typer.Option(..., "--project", help="Target project ID"),
+    query: str = typer.Option(None, "--query", help="Search decision content"),
+    include_history: bool = typer.Option(False, "--include-history", help="Include superseded versions"),
+    json_output: bool = typer.Option(False, "--json", help="Return JSON output"),
+):
+    try:
+        client, _ = auth.get_authenticated_client()
+        result = client.list_decisions(
+            project,
+            search=query,
+            include_history=include_history,
+        )
+    except (ValueError, ApiError, NetworkError) as exc:
+        emit_error(str(exc), json_output=json_output)
+        raise typer.Exit(1)
+
+    lines = [
+        f"decision:{item.get('id')}\tv{item.get('version', 1)}\t{item.get('text', '')}"
+        for item in result
+    ]
+    emit({"results": result}, json_output=json_output, lines=lines or ["No decisions found."])
+
+
+@decisions_app.command("show")
+def decisions_show(
+    decision_id: int = typer.Argument(..., help="Decision ID"),
+    project: int = typer.Option(..., "--project", help="Target project ID"),
+    json_output: bool = typer.Option(False, "--json", help="Return JSON output"),
+):
+    try:
+        client, _ = auth.get_authenticated_client()
+        result = client.show_decision(decision_id, project=project)
+    except (ValueError, ApiError, NetworkError) as exc:
+        emit_error(str(exc), json_output=json_output)
+        raise typer.Exit(1)
+
+    emit(
+        result,
+        json_output=json_output,
+        lines=[
+            f"decision:{result.get('id')} v{result.get('version', 1)}"
+            f"{' (superseded)' if not result.get('is_active', True) else ''}",
+            result.get("text") or "",
+            f"Reason: {result.get('reason') or 'None'}",
+            f"Impact: {result.get('impact') or result.get('impact_text') or 'None'}",
+            f"Code reference: {result.get('code_reference') or result.get('code_reference_text') or 'None'}",
+            f"Tags: {', '.join(result.get('tags') or result.get('references') or []) or 'None'}",
+            f"Meeting: {result.get('minute') or 'None'}",
+        ],
+    )
+
+
+@decisions_app.command("revise")
+def decisions_revise(
+    decision_id: int = typer.Argument(..., help="Active decision ID"),
+    text: str = typer.Option(None, "--text", help="Revised decision text"),
+    reason: str = typer.Option(None, "--reason", help="Revised rationale"),
+    impact: str = typer.Option(None, "--impact", help="Revised impact"),
+    code_reference: str = typer.Option(None, "--code-reference", help="Revised code or standard reference"),
+    tags: str = typer.Option(None, "--tags", help="Replacement comma-separated tags"),
+    clear_tags: bool = typer.Option(False, "--clear-tags", help="Clear all tags"),
+    json_output: bool = typer.Option(False, "--json", help="Return JSON output"),
+):
+    """Create an immutable successor version of an existing decision."""
+    try:
+        payload = {}
+        if text is not None:
+            payload["text"] = text
+        if reason is not None:
+            payload["reason"] = reason
+        if impact is not None:
+            payload["impact"] = impact
+        if code_reference is not None:
+            payload["code_reference"] = code_reference
+        if clear_tags:
+            payload["tags"] = []
+        elif tags is not None:
+            payload["tags"] = notes.parse_tags(tags)
+        if not payload:
+            raise ValueError("Provide at least one field to revise.")
+        client, _ = auth.get_authenticated_client()
+        result = client.revise_decision(decision_id, payload)
+    except (ValueError, ApiError, NetworkError) as exc:
+        emit_error(str(exc), json_output=json_output)
+        raise typer.Exit(1)
+
+    emit(
+        result,
+        json_output=json_output,
+        lines=[
+            f"Created decision:{result.get('id')} v{result.get('version')} as the successor to decision:{decision_id}."
+        ],
+    )
+
+
+@decisions_app.command("sync")
+def decisions_sync(
+    project: int = typer.Option(None, "--project", help="Only sync this project"),
+    json_output: bool = typer.Option(False, "--json", help="Return JSON output"),
+):
+    try:
+        client, _ = auth.get_authenticated_client()
+        result = decisions.sync_decisions(client, QueueStore(), project=project)
+    except (ValueError, ApiError, NetworkError) as exc:
+        emit_error(str(exc), json_output=json_output)
+        raise typer.Exit(1)
+    emit(
+        result,
+        json_output=json_output,
+        lines=[f"Processed {result['total']} queued decisions: {result['synced']} synced, {result['failed']} failed."],
+    )
+    if result["failed"]:
+        raise typer.Exit(1)
+
+
+@tasks_app.command("context")
+def tasks_context(
+    project: int = typer.Option(..., "--project", help="Target project ID"),
+    json_output: bool = typer.Option(False, "--json", help="Return JSON output"),
+):
+    """Show the stable user IDs that may be assigned project tasks."""
+    try:
+        client, _ = auth.get_authenticated_client()
+        result = client.task_context(project)
+    except (ValueError, ApiError, NetworkError) as exc:
+        emit_error(str(exc), json_output=json_output)
+        raise typer.Exit(1)
+
+    lines = [
+        f"Project: {(result.get('project') or {}).get('name')} ({project})",
+        *[
+            f"{member.get('user_id')}\t{member.get('name')}\t{member.get('email') or ''}\t{member.get('role') or ''}"
+            for member in result.get("members", [])
+        ],
+    ]
+    emit(result, json_output=json_output, lines=lines)
+
+
+@tasks_app.command("create")
+def tasks_create(
+    project: int = typer.Option(..., "--project", help="Target project ID"),
+    description: str = typer.Option(..., "--description", help="Task description"),
+    assignee_id: int = typer.Option(None, "--assignee-id", help="Assignable project-member user ID"),
+    due_at: str = typer.Option(None, "--due-at", help="Due timestamp in ISO-8601 format"),
+    priority: str = typer.Option("medium", "--priority", help="low, medium, high, or critical"),
+    notes_text: str = typer.Option(None, "--notes", help="Internal task notes"),
+    estimated_hours: float = typer.Option(None, "--estimated-hours", help="Estimated effort in hours"),
+    json_output: bool = typer.Option(False, "--json", help="Return JSON output"),
+):
+    """Create a standalone project task and optionally assign it to a member."""
+    try:
+        client, _ = auth.get_authenticated_client()
+        result = tasks.create_project_task(
+            client,
+            project=project,
+            description=description,
+            assigned_user_id=assignee_id,
+            due_at=due_at,
+            priority=priority,
+            notes=notes_text,
+            estimated_hours=estimated_hours,
+        )
+    except (ValueError, ApiError, NetworkError) as exc:
+        emit_error(str(exc), json_output=json_output)
+        raise typer.Exit(1)
+
+    task = result.get("task") or {}
+    lines = [
+        f"Created project-task:{task.get('id')} in project {project}.",
+        result.get("deep_link") or "",
+    ]
+    emit(result, json_output=json_output, lines=[line for line in lines if line])
+
+
 if __name__ == "__main__":
     main()

ventilatepro_cli-0.5.2/ventilatepro/decisions.py

@@ -0,0 +1,178 @@
+from __future__ import annotations
+
+import uuid
+from typing import Any, Dict, Optional
+
+from .api_client import ApiError, ApiClient, NetworkError
+from .queue import QueueStore
+
+
+DECISION_OPERATION = "decision.create"
+
+
+def prepare_payload(
+    *,
+    project: int,
+    text: str,
+    reason: Optional[str] = None,
+    impact: Optional[str] = None,
+    code_reference: Optional[str] = None,
+    tags: Optional[list[str]] = None,
+    meeting_id: Optional[int] = None,
+    captured_at: Optional[str] = None,
+    source_message: Optional[str] = None,
+    idempotency_key: Optional[str] = None,
+) -> Dict[str, Any]:
+    if project <= 0:
+        raise ValueError("Project ID must be a positive integer.")
+    normalized_text = (text or "").strip()
+    if not normalized_text:
+        raise ValueError("Decision text is required.")
+    if meeting_id is not None and meeting_id <= 0:
+        raise ValueError("Meeting ID must be a positive integer.")
+
+    normalized_tags = []
+    for tag in tags or []:
+        normalized = str(tag).strip()
+        if normalized and normalized not in normalized_tags:
+            normalized_tags.append(normalized)
+
+    decision: Dict[str, Any] = {
+        "text": normalized_text,
+        "reason": (reason or "").strip(),
+        "impact_text": (impact or "").strip(),
+        "code_reference_text": (code_reference or "").strip(),
+        "references": normalized_tags,
+        "source": "cli",
+    }
+    if meeting_id is not None:
+        decision["minute"] = meeting_id
+    if captured_at:
+        decision["captured_at"] = captured_at
+
+    return {
+        "project_id": project,
+        "idempotency_key": idempotency_key or str(uuid.uuid4()),
+        "source_message": source_message if source_message is not None else normalized_text,
+        "writes": [{"model": "notes.Decision", "data": decision}],
+    }
+
+
+def _created_result(client: ApiClient, project: int, response: Dict[str, Any]) -> Dict[str, Any]:
+    created = [
+        item
+        for item in response.get("created", [])
+        if item.get("model") == "notes.Decision"
+    ]
+    if len(created) != 1:
+        raise ValueError(
+            "The idempotency key did not resolve to exactly one decision. Use a new key."
+        )
+    decision = created[0].get("data") or {}
+    decision_id = created[0].get("id") or decision.get("id")
+    return {
+        "status": "created",
+        "decision": decision,
+        "decision_ref": f"decision:{decision_id}",
+        "audit_entry_id": response.get("audit_entry_id"),
+        "idempotent": bool(response.get("idempotent")),
+        "deep_link": f"{client.base_url}/?view=decision-log&project={project}&decision={decision_id}",
+    }
+
+
+def create_decision(
+    client: ApiClient,
+    queue_store: QueueStore,
+    *,
+    project: int,
+    text: str,
+    reason: Optional[str] = None,
+    impact: Optional[str] = None,
+    code_reference: Optional[str] = None,
+    tags: Optional[list[str]] = None,
+    meeting_id: Optional[int] = None,
+    captured_at: Optional[str] = None,
+    source_message: Optional[str] = None,
+    idempotency_key: Optional[str] = None,
+) -> Dict[str, Any]:
+    payload = prepare_payload(
+        project=project,
+        text=text,
+        reason=reason,
+        impact=impact,
+        code_reference=code_reference,
+        tags=tags,
+        meeting_id=meeting_id,
+        captured_at=captured_at,
+        source_message=source_message,
+        idempotency_key=idempotency_key,
+    )
+    try:
+        return _created_result(client, project, client.create_decision(payload))
+    except NetworkError as exc:
+        return _queue_decision(queue_store, project, payload, exc)
+    except ApiError as exc:
+        if exc.status_code < 500:
+            raise
+        return _queue_decision(queue_store, project, payload, exc)
+
+
+def _queue_decision(
+    queue_store: QueueStore,
+    project: int,
+    payload: Dict[str, Any],
+    error: Exception,
+) -> Dict[str, Any]:
+    queued = queue_store.enqueue_operation(
+        operation_type=DECISION_OPERATION,
+        project_id=project,
+        payload=payload,
+        idempotency_key=payload["idempotency_key"],
+    )
+    return {
+        "status": "queued",
+        "project": project,
+        "local_id": queued.local_id,
+        "idempotency_key": queued.idempotency_key,
+        "error": str(error),
+    }
+
+
+def sync_decisions(
+    client: ApiClient,
+    queue_store: QueueStore,
+    *,
+    project: Optional[int] = None,
+) -> Dict[str, Any]:
+    queued = queue_store.list_unsynced_operations(
+        operation_type=DECISION_OPERATION,
+        project_id=project,
+    )
+    results = []
+    synced = 0
+    failed = 0
+    for operation in queued:
+        queue_store.mark_operation_syncing(operation.local_id)
+        try:
+            result = _created_result(
+                client,
+                operation.project_id,
+                client.create_decision(operation.payload),
+            )
+            queue_store.mark_operation_synced(operation.local_id, result["decision_ref"])
+            synced += 1
+            results.append({"local_id": operation.local_id, "status": "synced", **result})
+        except (ValueError, NetworkError, ApiError) as exc:
+            queue_store.mark_operation_failed(operation.local_id, str(exc))
+            failed += 1
+            results.append({
+                "local_id": operation.local_id,
+                "status": "failed",
+                "error": str(exc),
+            })
+    return {
+        "total": len(queued),
+        "synced": synced,
+        "failed": failed,
+        "results": results,
+    }

{ventilatepro_cli-0.5.0 → ventilatepro_cli-0.5.2}/ventilatepro/mcp_server.py

@@ -7,7 +7,9 @@ from pathlib import Path
 from typing import Any, Dict, Optional
 
 from . import auth
+from . import decisions
 from . import meetings
+from . import tasks
 from .api_client import ApiError, NetworkError
 from .categorization import _validate_apply_manifest
 from .queue import QueueStore
@@ -432,6 +434,41 @@ def build_server():
             detail = getattr(exc, "payload", None)
             return _error_payload(exc.__class__.__name__, str(exc), detail=detail)
 
+    @server.tool()
+    def vp_get_task_context(project_id: int) -> Dict[str, Any]:
+        """Get the project-member directory and stable user IDs available for task assignment."""
+        try:
+            return _client().task_context(project_id)
+        except (ValueError, ApiError, NetworkError) as exc:
+            detail = getattr(exc, "payload", None)
+            return _error_payload(exc.__class__.__name__, str(exc), detail=detail)
+
+    @server.tool()
+    def vp_create_project_task(
+        project_id: int,
+        description: str,
+        assigned_user_id: Optional[int] = None,
+        due_at: Optional[str] = None,
+        priority: str = "medium",
+        notes: Optional[str] = None,
+        estimated_hours: Optional[float] = None,
+    ) -> Dict[str, Any]:
+        """Create a standalone project task and optionally assign it to a project member."""
+        try:
+            return tasks.create_project_task(
+                _client(),
+                project=project_id,
+                description=description,
+                assigned_user_id=assigned_user_id,
+                due_at=due_at,
+                priority=priority,
+                notes=notes,
+                estimated_hours=estimated_hours,
+            )
+        except (ValueError, ApiError, NetworkError) as exc:
+            detail = getattr(exc, "payload", None)
+            return _error_payload(exc.__class__.__name__, str(exc), detail=detail)
+
     @server.tool()
     def vp_record_meeting(
         project_id: int,
@@ -472,6 +509,67 @@ def build_server():
             detail = getattr(exc, "payload", None)
             return _error_payload(exc.__class__.__name__, str(exc), detail=detail)
 
+    @server.tool()
+    def vp_create_decision(
+        project_id: int,
+        text: str,
+        reason: Optional[str] = None,
+        impact: Optional[str] = None,
+        code_reference: Optional[str] = None,
+        tags: Optional[list[str]] = None,
+        meeting_id: Optional[int] = None,
+        captured_at: Optional[str] = None,
+        source_message: Optional[str] = None,
+        idempotency_key: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Log a project decision immediately; a meeting-minute link is optional."""
+        try:
+            return decisions.create_decision(
+                _client(),
+                QueueStore(),
+                project=project_id,
+                text=text,
+                reason=reason,
+                impact=impact,
+                code_reference=code_reference,
+                tags=tags,
+                meeting_id=meeting_id,
+                captured_at=captured_at,
+                source_message=source_message,
+                idempotency_key=idempotency_key,
+            )
+        except (ValueError, ApiError, NetworkError) as exc:
+            detail = getattr(exc, "payload", None)
+            return _error_payload(exc.__class__.__name__, str(exc), detail=detail)
+
+    @server.tool()
+    def vp_list_decisions(
+        project_id: int,
+        query: Optional[str] = None,
+        include_history: bool = False,
+    ) -> Dict[str, Any]:
+        """List active project decisions, optionally including superseded versions."""
+        try:
+            return {
+                "results": _client().list_decisions(
+                    project_id,
+                    search=query,
+                    include_history=include_history,
+                )
+            }
+        except (ValueError, ApiError, NetworkError) as exc:
+            detail = getattr(exc, "payload", None)
+            return _error_payload(exc.__class__.__name__, str(exc), detail=detail)
+
+    @server.tool()
+    def vp_get_decision(project_id: int, decision_id: int) -> Dict[str, Any]:
+        """Get one decision, including its immutable version and optional meeting link."""
+        try:
+            return _client().show_decision(decision_id, project=project_id)
+        except (ValueError, ApiError, NetworkError) as exc:
+            detail = getattr(exc, "payload", None)
+            return _error_payload(exc.__class__.__name__, str(exc), detail=detail)
+
     @server.tool()
     def vp_revise_decision(
         decision_id: int,

ventilatepro_cli-0.5.2/ventilatepro/tasks.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+from .api_client import ApiClient
+
+
+VALID_PRIORITIES = {"low", "medium", "high", "critical"}
+
+
+def create_project_task(
+    client: ApiClient,
+    *,
+    project: int,
+    description: str,
+    assigned_user_id: Optional[int] = None,
+    due_at: Optional[str] = None,
+    priority: str = "medium",
+    notes: Optional[str] = None,
+    estimated_hours: Optional[float] = None,
+) -> Dict[str, Any]:
+    description = (description or "").strip()
+    if not description:
+        raise ValueError("Task description is required.")
+    if project <= 0:
+        raise ValueError("Project ID must be a positive integer.")
+
+    normalized_priority = (priority or "medium").strip().lower()
+    if normalized_priority not in VALID_PRIORITIES:
+        choices = ", ".join(sorted(VALID_PRIORITIES))
+        raise ValueError(f"Priority must be one of: {choices}.")
+    if assigned_user_id is not None and assigned_user_id <= 0:
+        raise ValueError("Assignee user ID must be a positive integer.")
+    if estimated_hours is not None and estimated_hours < 0:
+        raise ValueError("Estimated hours cannot be negative.")
+
+    payload: Dict[str, Any] = {
+        "project": project,
+        "description": description,
+        "priority": normalized_priority,
+        "source": "cli",
+        "include_in_minutes": False,
+    }
+    if assigned_user_id is not None:
+        payload["assigned_user"] = assigned_user_id
+    if due_at:
+        payload["due_at"] = due_at
+    if notes:
+        payload["notes"] = notes
+    if estimated_hours is not None:
+        payload["estimated_hours"] = estimated_hours
+
+    task = client.create_project_task(payload)
+    return {
+        "status": "created",
+        "task": task,
+        "deep_link": f"{client.base_url}/?view=project-tasks&project={project}",
+    }

{ventilatepro_cli-0.5.0 → ventilatepro_cli-0.5.2}/ventilatepro_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ventilatepro-cli
-Version: 0.5.0
+Version: 0.5.2
 Summary: VentilatePro CLI
 Project-URL: Homepage, https://ventilatepro.com/exam/cli/
 Project-URL: Documentation, https://ventilatepro.com/exam/cli/
@@ -61,6 +61,11 @@ ventilatepro notes sync
 ventilatepro meetings context --project 1 --json
 ventilatepro meetings record --project 1 --input meeting.json --json
 ventilatepro meetings list --project 1
+ventilatepro decisions create --project 1 --text "Use heat recovery on AHU-2" --reason "Energy model payback" --tags ahu,energy
+ventilatepro decisions list --project 1
+ventilatepro decisions revise 51 --text "Use heat recovery with bypass control"
+ventilatepro tasks context --project 1 --json
+ventilatepro tasks create --project 1 --description "Issue updated duct plan" --assignee-id 12 --priority high
 ventilatepro mcp doctor
 ventilatepro-mcp
 ```
@@ -74,6 +79,17 @@ stable project-member IDs, interprets the PM's prose into a structured JSON
 payload, and calls `meetings record`. The server atomically creates the meeting,
 decisions, and assigned project tasks and returns a direct web-app link.
 
+For standalone work, Codex reads `tasks context` to resolve an assignee to a
+stable project-member user ID, then calls `tasks create`. The same workflow is
+available through the typed `vp_get_task_context` and
+`vp_create_project_task` MCP tools.
+
+Design decisions do not require meeting minutes. Codex can call `decisions
+create` or `vp_create_decision` as soon as a PM communicates a decision, with
+an optional meeting ID only when the relationship is useful. Listing, showing,
+and revising decisions are available through first-class CLI and MCP surfaces;
+revisions preserve the prior version as immutable history.
+
 For room classification, Codex can read the project-specific categorization
 review resource or use the dedicated MCP tools. Review manifests default every
 room to rejected so ambiguous spaces remain visible until a category is

{ventilatepro_cli-0.5.0 → ventilatepro_cli-0.5.2}/ventilatepro_cli.egg-info/SOURCES.txt

@@ -11,6 +11,7 @@ ventilatepro/calc.py
 ventilatepro/categorization.py
 ventilatepro/cli.py
 ventilatepro/config.py
+ventilatepro/decisions.py
 ventilatepro/design_day.py
 ventilatepro/entities.py
 ventilatepro/mcp_cli.py
@@ -23,6 +24,7 @@ ventilatepro/projects.py
 ventilatepro/queue.py
 ventilatepro/revit_imports.py
 ventilatepro/systems.py
+ventilatepro/tasks.py
 ventilatepro_cli.egg-info/PKG-INFO
 ventilatepro_cli.egg-info/SOURCES.txt
 ventilatepro_cli.egg-info/dependency_links.txt