taskflow-agent 0.2.2__tar.gz → 0.3.0__tar.gz

{taskflow_agent-0.2.2 → taskflow_agent-0.3.0}/.gitignore

@@ -10,3 +10,4 @@ logs/
 data/taskflow-web.pid
 data/agent_memory.md
 data/repos.json
+data/workflows/

{taskflow_agent-0.2.2 → taskflow_agent-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: taskflow-agent
-Version: 0.2.2
+Version: 0.3.0
 Summary: Lightweight project and task manager with MCP tools for Claude Code
 Project-URL: Repository, https://github.com/henrysouchien/taskflow-agent
 Author: Henry Chien
@@ -31,31 +31,92 @@ SQLite backend, 23+ MCP tools, web UI with embedded AI chat, and a FastAPI REST
 
 ## Features
 
-- **23+ MCP tools** — projects, tasks, sections, goals, daily focus, search, views, repo integration, service lifecycle
+- **23+ MCP tools** — projects, tasks, sections, goals, daily focus, search, views, repo integration
 - **Web UI** — dark-theme SPA with project boards, task details, inline editing
 - **AI chat** — embedded Claude chat with workspace awareness, tool access, and persistent memory
 - **Daily focus** — Today view with goals, focus list, and AI-assisted daily planning
 - **Goals** — timeframe-scoped goals (day/week/month/quarter) that guide daily prioritization
-- **Agent memory** — persistent context across chat sessions (preferences, decisions, patterns)
+- **Agent memory** — persistent context across chat sessions
 - **Repo integration** — read-only git status, recent commits, and TODOs across connected repos
 - **FTS search** — full-text search across task names and notes
-- **Server-side chat storage** — chat history persisted in SQLite with compaction
 - **Asana import** — bulk import from Asana CSV exports
-- **Service management** — start/stop the web server via MCP tools or Makefile
 
 ## Quick Start
 
 ```bash
-pip install -e ".[web]"
+pip install taskflow-agent[web]
 
 # Start the MCP server (for Claude Code)
 taskflow
 
-# Start the web UI
-make serve          # foreground
-taskflow-web        # via CLI
+# Start the web UI (port 8787)
+taskflow-web
 ```
 
+## Setup
+
+### 1. Environment
+
+Create a `.env` file in your working directory:
+
+```bash
+# Auth — pick one mode
+ANTHROPIC_AUTH_MODE=api_key          # "oauth" or "api_key"
+ANTHROPIC_API_KEY=sk-ant-...         # if using api_key mode
+ANTHROPIC_AUTH_TOKEN=...             # if using oauth mode
+
+# Optional
+ANTHROPIC_MODEL=claude-sonnet-4-6   # default model for chat
+LOG_LEVEL=INFO                       # DEBUG, INFO, WARNING, ERROR
+```
+
+The MCP server (task management tools) works without auth. Auth is only needed for the web UI's embedded AI chat.
+
+### 2. Register MCP Server
+
+Add to `~/.claude.json`:
+
+```json
+{
+  "mcpServers": {
+    "taskflow": {
+      "type": "stdio",
+      "command": "path/to/venv/bin/python",
+      "args": ["-m", "src.server"],
+      "cwd": "path/to/taskflow"
+    }
+  }
+}
+```
+
+### 3. Configure Repos (optional)
+
+Create `data/repos.json` to connect git repos for status tracking:
+
+```json
+{
+  "my-project": "/absolute/path/to/my-project",
+  "another-repo": "/absolute/path/to/another-repo"
+}
+```
+
+`tf_repo_list` and `tf_repo_status` use this to show branch, state, recent commits, and TODOs. Read-only.
+
+### 4. Run
+
+```bash
+# Web UI
+taskflow-web                # port 8787
+# or with make (if developing from source):
+make serve                  # foreground
+make dev                    # with auto-reload
+
+# MCP server only
+taskflow
+```
+
+Open `http://localhost:8787`.
+
 ## MCP Tools
 
 ### Projects
@@ -123,41 +184,36 @@ taskflow-web        # via CLI
 | `tf_serve_start` | Start web server in background |
 | `tf_serve_stop` | Stop web server |
 
-## MCP Registration
+## Embedded Chat
 
-Add to `~/.claude.json`:
+The web UI includes an AI chat panel (toggle with `C`) powered by [ai-agent-gateway](https://pypi.org/project/ai-agent-gateway/).
 
-```json
-{
-  "mcpServers": {
-    "taskflow": {
-      "type": "stdio",
-      "command": "path/to/venv/bin/python",
-      "args": ["-m", "src.server"],
-      "cwd": "path/to/taskflow"
-    }
-  }
-}
-```
-
-## Web UI
+### What the chat agent can do
 
-Start the web server on port 8787:
+- All `tf_*` tools — manage projects, tasks, goals, focus
+- `read_file` / `list_dir` / `run_shell` — filesystem access
+- `notes_search` / `notes_read` — Apple Notes integration
+- `tf_memory_read` / `tf_memory_update` — persistent memory across sessions (stored in `data/agent_memory.md`, 12 KB max)
+- `load_tools` — dynamically load any MCP server from `~/.claude.json` on demand
 
-```bash
-make serve    # foreground, Ctrl-C to stop
-make dev      # with auto-reload
-make status   # check if running
-make stop     # stop the server
-```
+### Deferred MCP Servers
 
-Or manage via MCP tools from Claude Code — ask Claude to "start the taskflow server."
+The chat agent can load any `stdio`-type MCP server registered in your `~/.claude.json` on demand. The agent calls `load_tools("server-name")` and gains access to that server's tools for the session.
 
 ## Database
 
-SQLite with WAL mode. Tables: `projects`, `sections`, `tasks`, `tags`, `task_tags`, `tasks_fts` (FTS5), `goals`, `today_focus`, `chat_messages`.
+SQLite with WAL mode. Created automatically on first run.
+
+Tables: `projects`, `sections`, `tasks`, `tags`, `task_tags`, `tasks_fts` (FTS5), `goals`, `daily_focus`, `chat_messages`.
+
+## Asana Import
+
+```bash
+# Via MCP tool:
+tf_import_asana directory=/path/to/Asana-Export/
+```
 
-Database is created automatically on first run via `db.init_db()`.
+Import is additive — re-importing creates duplicates. Delete `taskflow.db` first for a clean re-import.
 
 ## License
 

{taskflow_agent-0.2.2 → taskflow_agent-0.3.0}/README.md

@@ -6,31 +6,92 @@ SQLite backend, 23+ MCP tools, web UI with embedded AI chat, and a FastAPI REST
 
 ## Features
 
-- **23+ MCP tools** — projects, tasks, sections, goals, daily focus, search, views, repo integration, service lifecycle
+- **23+ MCP tools** — projects, tasks, sections, goals, daily focus, search, views, repo integration
 - **Web UI** — dark-theme SPA with project boards, task details, inline editing
 - **AI chat** — embedded Claude chat with workspace awareness, tool access, and persistent memory
 - **Daily focus** — Today view with goals, focus list, and AI-assisted daily planning
 - **Goals** — timeframe-scoped goals (day/week/month/quarter) that guide daily prioritization
-- **Agent memory** — persistent context across chat sessions (preferences, decisions, patterns)
+- **Agent memory** — persistent context across chat sessions
 - **Repo integration** — read-only git status, recent commits, and TODOs across connected repos
 - **FTS search** — full-text search across task names and notes
-- **Server-side chat storage** — chat history persisted in SQLite with compaction
 - **Asana import** — bulk import from Asana CSV exports
-- **Service management** — start/stop the web server via MCP tools or Makefile
 
 ## Quick Start
 
 ```bash
-pip install -e ".[web]"
+pip install taskflow-agent[web]
 
 # Start the MCP server (for Claude Code)
 taskflow
 
-# Start the web UI
-make serve          # foreground
-taskflow-web        # via CLI
+# Start the web UI (port 8787)
+taskflow-web
 ```
 
+## Setup
+
+### 1. Environment
+
+Create a `.env` file in your working directory:
+
+```bash
+# Auth — pick one mode
+ANTHROPIC_AUTH_MODE=api_key          # "oauth" or "api_key"
+ANTHROPIC_API_KEY=sk-ant-...         # if using api_key mode
+ANTHROPIC_AUTH_TOKEN=...             # if using oauth mode
+
+# Optional
+ANTHROPIC_MODEL=claude-sonnet-4-6   # default model for chat
+LOG_LEVEL=INFO                       # DEBUG, INFO, WARNING, ERROR
+```
+
+The MCP server (task management tools) works without auth. Auth is only needed for the web UI's embedded AI chat.
+
+### 2. Register MCP Server
+
+Add to `~/.claude.json`:
+
+```json
+{
+  "mcpServers": {
+    "taskflow": {
+      "type": "stdio",
+      "command": "path/to/venv/bin/python",
+      "args": ["-m", "src.server"],
+      "cwd": "path/to/taskflow"
+    }
+  }
+}
+```
+
+### 3. Configure Repos (optional)
+
+Create `data/repos.json` to connect git repos for status tracking:
+
+```json
+{
+  "my-project": "/absolute/path/to/my-project",
+  "another-repo": "/absolute/path/to/another-repo"
+}
+```
+
+`tf_repo_list` and `tf_repo_status` use this to show branch, state, recent commits, and TODOs. Read-only.
+
+### 4. Run
+
+```bash
+# Web UI
+taskflow-web                # port 8787
+# or with make (if developing from source):
+make serve                  # foreground
+make dev                    # with auto-reload
+
+# MCP server only
+taskflow
+```
+
+Open `http://localhost:8787`.
+
 ## MCP Tools
 
 ### Projects
@@ -98,41 +159,36 @@ taskflow-web        # via CLI
 | `tf_serve_start` | Start web server in background |
 | `tf_serve_stop` | Stop web server |
 
-## MCP Registration
+## Embedded Chat
 
-Add to `~/.claude.json`:
+The web UI includes an AI chat panel (toggle with `C`) powered by [ai-agent-gateway](https://pypi.org/project/ai-agent-gateway/).
 
-```json
-{
-  "mcpServers": {
-    "taskflow": {
-      "type": "stdio",
-      "command": "path/to/venv/bin/python",
-      "args": ["-m", "src.server"],
-      "cwd": "path/to/taskflow"
-    }
-  }
-}
-```
-
-## Web UI
+### What the chat agent can do
 
-Start the web server on port 8787:
+- All `tf_*` tools — manage projects, tasks, goals, focus
+- `read_file` / `list_dir` / `run_shell` — filesystem access
+- `notes_search` / `notes_read` — Apple Notes integration
+- `tf_memory_read` / `tf_memory_update` — persistent memory across sessions (stored in `data/agent_memory.md`, 12 KB max)
+- `load_tools` — dynamically load any MCP server from `~/.claude.json` on demand
 
-```bash
-make serve    # foreground, Ctrl-C to stop
-make dev      # with auto-reload
-make status   # check if running
-make stop     # stop the server
-```
+### Deferred MCP Servers
 
-Or manage via MCP tools from Claude Code — ask Claude to "start the taskflow server."
+The chat agent can load any `stdio`-type MCP server registered in your `~/.claude.json` on demand. The agent calls `load_tools("server-name")` and gains access to that server's tools for the session.
 
 ## Database
 
-SQLite with WAL mode. Tables: `projects`, `sections`, `tasks`, `tags`, `task_tags`, `tasks_fts` (FTS5), `goals`, `today_focus`, `chat_messages`.
+SQLite with WAL mode. Created automatically on first run.
+
+Tables: `projects`, `sections`, `tasks`, `tags`, `task_tags`, `tasks_fts` (FTS5), `goals`, `daily_focus`, `chat_messages`.
+
+## Asana Import
+
+```bash
+# Via MCP tool:
+tf_import_asana directory=/path/to/Asana-Export/
+```
 
-Database is created automatically on first run via `db.init_db()`.
+Import is additive — re-importing creates duplicates. Delete `taskflow.db` first for a clean re-import.
 
 ## License
 

{taskflow_agent-0.2.2 → taskflow_agent-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "taskflow-agent"
-version = "0.2.2"
+version = "0.3.0"
 description = "Lightweight project and task manager with MCP tools for Claude Code"
 readme = "README.md"
 requires-python = ">=3.10"

{taskflow_agent-0.2.2 → taskflow_agent-0.3.0}/src/server.py

@@ -14,7 +14,7 @@ from typing import Optional
 
 from mcp.server.fastmcp import FastMCP
 
-from . import db
+from . import db, workflows
 
 mcp = FastMCP(
     "taskflow",
@@ -28,6 +28,7 @@ mcp = FastMCP(
 db.init_db()
 
 _PROJECT_ROOT = Path(__file__).resolve().parent.parent
+_VENV_PYTHON = _PROJECT_ROOT / "venv" / "bin" / "python"
 _PID_FILE = _PROJECT_ROOT / "data" / "taskflow-web.pid"
 _LOG_DIR = _PROJECT_ROOT / "logs"
 _LOG_FILE = _LOG_DIR / "web.log"
@@ -659,7 +660,7 @@ def tf_serve_start() -> str:
     log_fh = open(_LOG_FILE, "a")
     try:
         proc = subprocess.Popen(
-            [sys.executable, "-m", "src.web"],
+            [str(_VENV_PYTHON) if _VENV_PYTHON.exists() else sys.executable, "-m", "src.web"],
             cwd=str(_PROJECT_ROOT),
             stdout=log_fh,
             stderr=subprocess.STDOUT,
@@ -750,6 +751,39 @@ def tf_repo_status(repo: str = "all", commits: int = 10) -> str:
     return _json(repos.repo_status(repo, commit_count=commits))
 
 
+@mcp.tool()
+def tf_workflow_list() -> str:
+    """List available workflow templates."""
+    workflow_items = workflows.list_workflows()
+    return _json({"workflows": workflow_items, "count": len(workflow_items)})
+
+
+@mcp.tool()
+def tf_workflow_get(slug: str) -> str:
+    """Read a workflow template by slug."""
+    try:
+        workflow = workflows.get_workflow(slug)
+    except ValueError as exc:
+        return _error(str(exc))
+    except OSError as exc:
+        return _error(f"Could not read workflow '{slug}': {exc}")
+    if workflow is None:
+        return _error(f"Workflow '{slug}' not found")
+    return _json(workflow)
+
+
+@mcp.tool()
+def tf_workflow_save(slug: str, content: str) -> str:
+    """Create or update a workflow template."""
+    try:
+        result = workflows.save_workflow(slug, content)
+    except ValueError as exc:
+        return _error(str(exc))
+    except OSError as exc:
+        return _error(f"Could not write workflow '{slug}': {exc}")
+    return _json(result)
+
+
 def main():
     mcp.run()
 

{taskflow_agent-0.2.2 → taskflow_agent-0.3.0}/src/web.py

@@ -10,6 +10,7 @@ import os
 import sqlite3
 import subprocess
 import time
+from datetime import date as dt_date
 from logging.handlers import RotatingFileHandler
 from pathlib import Path
 
@@ -53,13 +54,14 @@ logging.getLogger("claude_gateway").addHandler(_file_handler)
 from typing import Any, Literal, Optional
 from uuid import uuid4
 
-from claude_gateway import AgentRunner, EventLog, McpClientManager, ToolDispatcher
+from claude_gateway import AgentRunner, EventLog, McpClientManager
+from claude_gateway.tool_dispatcher import ToolDispatcher
 from fastapi import FastAPI, HTTPException, Request
 from fastapi.responses import FileResponse, JSONResponse, StreamingResponse
 from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel, Field
 
-from . import db
+from . import db, workflows
 
 app = FastAPI(title="Taskflow")
 
@@ -147,6 +149,7 @@ class TaskUpdate(BaseModel):
     due_date: Optional[str] = None
     tags: Optional[str] = None
     section_id: Optional[int] = None
+    position: Optional[int] = None
 
 
 class ProjectCreate(BaseModel):
@@ -701,15 +704,19 @@ that code projects get naturally: everything in one place, AI collaborator, clea
 
 Structure follows three layers:
 - Project plan = the orientation ("what are we doing and why") — freeform markdown
-- Sections = independent workstreams, each with their own plan
+- Sections = PHASES IN A SEQUENCE, not categories. They answer "what order do I do this in."
+  Good: "Phase 1: Schema", "Phase 2: API". Bad: "API", "Frontend", "Database" (that's just filing).
+  Do NOT default to grouping by category — always think about sequencing and what comes next.
 - Tasks = atomic action items extracted from plans
 
 Key principles:
 - Plans before tasks — think first, structure second, execute third. Don't jump to creating tasks.
 - Goals set direction — concrete targets (not vague aspirations) that drive daily focus choices.
-- The daily loop: Goals → "what's highest leverage today?" → Today view → execute → review.
+- Daily planning = prioritization + scoping against time. What's highest leverage? What unblocks things?
+  How much time is available? What fits, what gets cut? Rough-estimate in conversation, not schema fields.
 - Collaborator, not task bot — read the plan, understand context, suggest and act, don't just CRUD.
 - Connected — you can reach into Roam, Drive, Sheets, Gmail, etc. to do real work, not just manage tasks.
+- Taskflow is for projects with forward motion. Admin tasks, routines, and errands stay in Roam.
 
 MEMORY MANAGEMENT:
 Use tf_memory_read / tf_memory_update to maintain persistent context across sessions.
@@ -746,6 +753,7 @@ Core (always loaded):
 - `tf_*` tools — manage Taskflow projects, sections, tasks, search, and workspace views.
 - `tf_today` / `tf_focus` / `tf_unfocus` / `tf_move_focus` — daily focus list management.
 - `tf_create_goal` / `tf_update_goal` / `tf_goal_list` / `tf_goal_complete` / `tf_goal_reopen` / `tf_goal_remove` — goal management.
+- `tf_workflow_list` / `tf_workflow_get` / `tf_workflow_save` — reusable project templates.
 - `read_file` / `list_dir` / `run_shell` — read files, browse directories, run shell commands (git, grep, etc.).
 - `notes_search` / `notes_read` — search and read Apple Notes (the user's phone-accessible capture tool).
 - `tf_repo_list` / `tf_repo_status` — check git status, recent commits, and open TODOs across connected repositories.
@@ -758,6 +766,13 @@ Deferred MCP servers (call `load_tools` with server_name first):
 - `notify` — Send notifications via Telegram or iMessage.
 - Other servers: {', '.join(s for s in deferred_tools if s not in ('roam-research', 'drive-mcp', 'gsheets-mcp', 'gmail-mcp', 'notify'))}
 
+Sub-agent delegation:
+- You have a `run_agent` tool that spawns a focused sub-agent with its own context window.
+- Use it for intensive work that would bloat this conversation: code exploration, audits, file analysis, searching through notes or Roam pages, or research tasks that require many tool calls.
+- The sub-agent is read-only. It cannot create, update, or delete tasks or projects. You handle all mutations based on its findings.
+- Write detailed, specific instructions in the `task` field. The sub-agent has access to `read_file`, `list_dir`, git repo tools, read-only task tools, Apple Notes, and any MCP servers you've already loaded via `load_tools`. It does NOT have `run_shell`.
+- If you need the sub-agent to access an MCP server such as Roam, call `load_tools` first, then spawn the agent.
+
 BEHAVIORAL GUIDELINES:
 - When the user is looking at a project, treat that project as the default context.
 - Reference project plans when suggesting next steps.
@@ -765,11 +780,15 @@ BEHAVIORAL GUIDELINES:
 - For planning-heavy requests, improve the plan markdown first, then extract tasks.
 - When the user mentions notes or ideas they captured, check Apple Notes or Roam.
 - When discussing code projects or repo work, use `tf_repo_status` to check current state before making recommendations.
+- When the user wants to start a repeatable project type (video, thesis, blog post), check `tf_workflow_list` first. If a matching workflow exists, read it with `tf_workflow_get` and propose using it to scaffold the project. Wait for user confirmation before creating. Customize the plan from context; workflows are starting points, not rigid scripts.
+- When a project reveals a repeatable process, suggest saving it as a workflow for next time.
+- Workflows live in `data/workflows/` as markdown files. The user can also edit them directly.
 - Load deferred MCP servers proactively when the conversation clearly needs them.
 - Daily planning:
-  When the user asks what to focus on today, or the Today view is empty, read goals first, survey overdue and due-soon work, consider carry-forward items, propose 3-5 high-leverage tasks with reasons, iterate with the user, then pin the agreed tasks with `tf_focus`.
+  When the user asks what to focus on today, or the Today view is empty: read goals first, survey active projects (in phase sequence), consider carry-forward items, ask about time constraints ("how much time do you have today?"), then propose 3-5 high-leverage tasks with reasons. Focus on what moves the needle most and what unblocks other work. Rough-estimate task duration in conversation to help scope. Iterate with the user, then pin the agreed tasks with `tf_focus`.
 - Prioritization heuristics:
-  Overdue work with external stakeholders beats internal deadlines, unblockers beat isolated work, goal-aligned tasks beat dormant projects, quick wins are useful early, and focus lists should stay short.
+  Unblockers beat isolated work, goal-aligned tasks beat dormant projects, sequential dependencies matter (what's blocking the next phase?), quick wins are useful early, and focus lists should stay short. Be ruthless about cutting — if it doesn't fit the time available, defer it.
+- When structuring projects, organize sections as phases/sequence (what to do first, second, third), NOT by category (API, Frontend, Database). Sequencing tells you what's next; categories are just filing.
 """.strip()
     return _trim_for_token_budget(prompt, PROMPT_TOKEN_BUDGET)
 
@@ -1071,6 +1090,24 @@ TF_TOOL_DEFINITIONS = [
         "description": "Load deferred MCP tools for a configured server from ~/.claude.json.",
         "input_schema": _schema({"server_name": {"type": "string"}}, ["server_name"]),
     },
+    {
+        "name": "run_agent",
+        "description": "Spawn a read-only sub-agent to perform a focused task. The sub-agent gets its own context window and returns a structured response. Use this for intensive work that would bloat the main conversation: code audits, file exploration, note triage, research. The sub-agent cannot create, update, or delete tasks or projects; you handle mutations based on its findings.",
+        "input_schema": _schema(
+            {
+                "task": {
+                    "type": "string",
+                    "description": "Detailed instructions for the sub-agent.",
+                },
+                "model": {
+                    "type": "string",
+                    "description": "Model override. Defaults to claude-sonnet-4-6.",
+                    "enum": ["claude-sonnet-4-6", "claude-opus-4-6"],
+                },
+            },
+            required=["task"],
+        ),
+    },
     # --- Apple Notes tools ---
     {
         "name": "notes_search",
@@ -1104,6 +1141,24 @@ TF_TOOL_DEFINITIONS = [
             ["content"],
         ),
     },
+    {
+        "name": "tf_workflow_list",
+        "description": "List available project workflow templates.",
+        "input_schema": _schema({}),
+    },
+    {
+        "name": "tf_workflow_get",
+        "description": "Read a workflow template by slug.",
+        "input_schema": _schema({"slug": {"type": "string"}}, ["slug"]),
+    },
+    {
+        "name": "tf_workflow_save",
+        "description": "Create or update a workflow template. Content is markdown with simple frontmatter (--- delimited, plain 'key: value' lines, no quoting or nesting). Required field: name.",
+        "input_schema": _schema(
+            {"slug": {"type": "string"}, "content": {"type": "string"}},
+            ["slug", "content"],
+        ),
+    },
     # --- Filesystem tools ---
     {
         "name": "read_file",
@@ -1183,6 +1238,30 @@ MUTATING_TOOL_NAMES = {
     "tf_goal_reopen",
     "tf_goal_remove",
 }
+_SUB_AGENT_EXCLUDED_TOOLS: set[str] = {
+    "run_agent",
+    "run_shell",
+    "load_tools",
+    "tf_memory_read",
+    "tf_memory_update",
+} | MUTATING_TOOL_NAMES
+
+_SUB_AGENT_SYSTEM_PROMPT = (
+    "You are a focused research assistant working on behalf of a project manager. "
+    "You have read-only access to files, git repos, task data, and notes. "
+    "You do NOT have shell access or the ability to modify tasks/projects.\n"
+    "Complete the assigned task thoroughly and return a clear, structured response.\n\n"
+    "Be concise — your output will be read by the orchestrator agent, not a human. "
+    "If any tool call fails or returns unexpected data, note the issue clearly in "
+    "your response rather than silently proceeding.\n\n"
+    "Today's date: {date}"
+)
+
+_SUB_AGENT_MAX_TURNS = 15
+_SUB_AGENT_TIMEOUT = int(os.getenv("SUB_AGENT_TIMEOUT", "300"))
+_SUB_AGENT_CLIENT_TIMEOUT = 90
+_SUB_AGENT_MAX_TOKENS = 32_000
+_SUB_AGENT_DEFAULT_MODEL = "claude-sonnet-4-6"
 
 mcp_manager = McpClientManager(
     allowed_servers=None,
@@ -1701,7 +1780,12 @@ async def load_tools_handler(tool_input, *, call_index=0):
 
     async with mcp_manager._lock:
         if server_name in mcp_manager._servers:
-            return {"status": "ok", "server_name": server_name, "already_loaded": True}, None
+            return {
+                "status": "ok",
+                "server_name": server_name,
+                "already_loaded": True,
+                "_load_servers": [server_name],
+            }, None
 
         config = _claude_config()
         mcp_servers = config.get("mcpServers")
@@ -1731,6 +1815,63 @@ async def load_tools_handler(tool_input, *, call_index=0):
     }, None
 
 
+def make_run_agent_handler(
+    runner_ref: list[Any],
+    local_tool_handlers: dict[str, Any],
+    mcp_manager: McpClientManager,
+):
+    async def _handle_run_agent(
+        tool_input: dict,
+        *,
+        call_index: int = 0,
+    ) -> tuple[Any | None, dict[str, Any] | None]:
+        runner = runner_ref[0]
+        if runner is None:
+            return None, {"code": "internal_error", "message": "Runner not initialized"}
+
+        task = tool_input.get("task", "")
+        if not task or not isinstance(task, str):
+            return None, {"code": "invalid_input", "message": "task is required"}
+
+        raw_model = tool_input.get("model")
+        allowed = {"claude-sonnet-4-6", "claude-opus-4-6"}
+        if raw_model is not None and raw_model not in allowed:
+            return None, {"code": "invalid_input", "message": f"Invalid model: {raw_model}"}
+
+        system_prompt = _SUB_AGENT_SYSTEM_PROMPT.format(
+            date=dt_date.today().isoformat()
+        )
+        effective_model = raw_model or _SUB_AGENT_DEFAULT_MODEL
+
+        sub_local = {
+            name: handler
+            for name, handler in local_tool_handlers.items()
+            if name not in _SUB_AGENT_EXCLUDED_TOOLS
+        }
+
+        sub_dispatcher = ToolDispatcher(
+            mcp_client=mcp_manager,
+            local_tool_handlers=sub_local,
+            needs_approval=lambda _: False,
+        )
+
+        result, error = await runner.spawn_sub_agent(
+            task,
+            model=effective_model,
+            system_prompt=system_prompt,
+            dispatcher=sub_dispatcher,
+            excluded_tools=_SUB_AGENT_EXCLUDED_TOOLS,
+            max_turns=_SUB_AGENT_MAX_TURNS,
+            timeout=_SUB_AGENT_TIMEOUT,
+            client_timeout=_SUB_AGENT_CLIENT_TIMEOUT,
+            max_tokens=_SUB_AGENT_MAX_TOKENS,
+            call_index=call_index,
+        )
+        return result, error
+
+    return _handle_run_agent
+
+
 def _run_osascript(script: str, timeout: float = 15.0) -> str:
     proc = subprocess.run(
         ["osascript", "-e", script],
@@ -1845,6 +1986,50 @@ async def tf_memory_update_handler(tool_input, *, call_index=0):
     return {"status": "ok", "path": str(MEMORY_FILE_PATH), "chars": len(content)}, None
 
 
+def _workflow_value_error(exc: ValueError):
+    message = str(exc)
+    if message.startswith("Invalid slug:") or message == "Frontmatter must include 'name' field":
+        return _tool_error("invalid_input", message)
+    if "exceeds size limit" in message or message == "Content exceeds limit (16 KB / 200 lines)":
+        return _tool_error("too_large", message)
+    return _tool_error("invalid_input", message)
+
+
+async def tf_workflow_list_handler(tool_input, *, call_index=0):
+    del tool_input, call_index
+    try:
+        workflow_items = workflows.list_workflows()
+    except OSError as exc:
+        return _tool_error("file_error", f"Could not list workflows: {exc}")
+    return {"workflows": workflow_items, "count": len(workflow_items)}, None
+
+
+async def tf_workflow_get_handler(tool_input, *, call_index=0):
+    del call_index
+    slug = str(tool_input.get("slug", ""))
+    try:
+        workflow_item = workflows.get_workflow(slug)
+    except ValueError as exc:
+        return _workflow_value_error(exc)
+    except OSError as exc:
+        return _tool_error("file_error", f"Could not read workflow '{slug}': {exc}")
+    if workflow_item is None:
+        return _tool_error("not_found", f"Workflow '{slug}' not found")
+    return workflow_item, None
+
+
+async def tf_workflow_save_handler(tool_input, *, call_index=0):
+    del call_index
+    slug = str(tool_input.get("slug", ""))
+    content = str(tool_input.get("content", ""))
+    try:
+        return workflows.save_workflow(slug, content), None
+    except ValueError as exc:
+        return _workflow_value_error(exc)
+    except OSError as exc:
+        return _tool_error("file_error", f"Could not write workflow '{slug}': {exc}")
+
+
 _READ_FILE_MAX_LINES = 2000
 _SHELL_TIMEOUT = 30
 _SHELL_MAX_OUTPUT = 50_000  # ~50 KB
@@ -1996,6 +2181,9 @@ LOCAL_TOOL_HANDLERS = {
     "notes_read": notes_read_handler,
     "tf_memory_read": tf_memory_read_handler,
     "tf_memory_update": tf_memory_update_handler,
+    "tf_workflow_list": tf_workflow_list_handler,
+    "tf_workflow_get": tf_workflow_get_handler,
+    "tf_workflow_save": tf_workflow_save_handler,
     "read_file": read_file_handler,
     "list_dir": list_dir_handler,
     "run_shell": run_shell_handler,
@@ -2375,7 +2563,7 @@ def create_task(body: TaskCreate):
 def update_task(task_id: int, body: TaskUpdate):
     conn = _conn()
     fields = {}
-    for key in ("name", "notes", "assignee", "start_date", "due_date", "section_id"):
+    for key in ("name", "notes", "assignee", "start_date", "due_date", "section_id", "position"):
         val = getattr(body, key)
         if val is not None:
             fields[key] = val
@@ -2389,6 +2577,23 @@ def update_task(task_id: int, body: TaskUpdate):
     return {"status": "ok"}
 
 
+@app.post("/api/tasks/reorder")
+def reorder_tasks(body: dict[str, Any]):
+    """Batch update task positions. Body: { task_ids: [id1, id2, ...] }
+    Sets position = index for each task in the array."""
+    task_ids = body.get("task_ids", [])
+    if not task_ids or not isinstance(task_ids, list):
+        raise HTTPException(400, "task_ids must be a non-empty list")
+    conn = _conn()
+    try:
+        for i, tid in enumerate(task_ids):
+            db.update_task(conn, int(tid), position=i)
+    finally:
+        conn.close()
+    invalidate_workspace_summary_cache()
+    return {"status": "ok", "count": len(task_ids)}
+
+
 @app.post("/api/tasks/{task_id}/complete")
 def complete_task(task_id: int):
     conn = _conn()
@@ -2726,18 +2931,36 @@ async def chat(body: ChatRequest, request: Request):
         session_id = f"tf-{uuid4().hex[:8]}"
         log.info("chat_start | %s | view=%s messages=%d", session_id, body.context.view, len(messages))
         event_log = EventLog(session_id=session_id)
+        request_handlers = dict(LOCAL_TOOL_HANDLERS)
+        loaded_mcp_servers: set[str] = set()
+        runner_ref: list[AgentRunner | None] = [None]
+        request_handlers["run_agent"] = make_run_agent_handler(
+            runner_ref,
+            request_handlers,
+            mcp_manager,
+        )
         dispatcher = ToolDispatcher(
             mcp_client=mcp_manager,
-            local_tool_handlers=LOCAL_TOOL_HANDLERS,
+            local_tool_handlers=request_handlers,
+            needs_approval=lambda _: False,
         )
+
+        def get_tool_definitions():
+            mcp_defs = mcp_manager.get_server_tool_definitions(loaded_mcp_servers)
+            return TF_TOOL_DEFINITIONS + mcp_defs
+
         runner = AgentRunner(
             dispatcher=dispatcher,
             event_log=event_log,
             session_id=event_log._session_id,
             auth_config=_anthropic_auth_config(),
             mcp_client=mcp_manager,
-            get_tool_definitions=lambda: TF_TOOL_DEFINITIONS + mcp_manager.get_tool_definitions(),
+            loaded_mcp_servers=loaded_mcp_servers,
+            get_tool_definitions=get_tool_definitions,
+            client_timeout=90.0,
+            per_turn_timeout=120.0,
         )
+        runner_ref[0] = runner
         runner_task = asyncio.create_task(
             runner.run(
                 messages=messages,

taskflow_agent-0.3.0/src/workflows.py

@@ -0,0 +1,138 @@
+"""Shared workflow template storage helpers."""
+
+from __future__ import annotations
+
+import re
+import tempfile
+from pathlib import Path
+
+WORKFLOWS_DIR = Path(__file__).resolve().parent.parent / "data" / "workflows"
+MAX_BYTES = 16_384
+MAX_LINES = 200
+SLUG_RE = re.compile(r"^[a-z0-9]+(-[a-z0-9]+)*$")
+MAX_SLUG_LEN = 60
+
+_FRONTMATTER_LINE_RE = re.compile(r"^([a-zA-Z0-9_]+):\s*(.*)$")
+
+
+def validate_slug(slug: str) -> str | None:
+    """Return an error message when a workflow slug is invalid."""
+    if not isinstance(slug, str):
+        return "must be kebab-case, 1-60 chars"
+    if not slug or len(slug) > MAX_SLUG_LEN or not SLUG_RE.fullmatch(slug):
+        return "must be kebab-case, 1-60 chars"
+    return None
+
+
+def parse_frontmatter(content: str) -> dict[str, str]:
+    """Extract recognized frontmatter fields from markdown content."""
+    metadata = {"name": "", "description": ""}
+    lines = content.splitlines()
+    if not lines or lines[0] != "---":
+        return metadata
+
+    closing_index = None
+    for index, line in enumerate(lines[1:], start=1):
+        if line == "---":
+            closing_index = index
+            break
+    if closing_index is None:
+        return metadata
+
+    for line in lines[1:closing_index]:
+        match = _FRONTMATTER_LINE_RE.match(line)
+        if not match:
+            continue
+        key, value = match.groups()
+        if key in metadata:
+            metadata[key] = value.strip()
+    return metadata
+
+
+def list_workflows() -> list[dict[str, str]]:
+    """Return workflow metadata for all valid workflow files."""
+    if not WORKFLOWS_DIR.is_dir():
+        return []
+
+    workflow_items = []
+    for path in sorted(WORKFLOWS_DIR.glob("*.md")):
+        try:
+            if path.stat().st_size > MAX_BYTES:
+                continue
+            content = path.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            continue
+        slug = path.stem
+        if validate_slug(slug):
+            continue
+        if _line_count(content) > MAX_LINES:
+            continue
+        workflow_items.append(_build_workflow_metadata(slug, content))
+    return workflow_items
+
+
+def get_workflow(slug: str) -> dict[str, str] | None:
+    """Return workflow metadata plus raw markdown content for a slug."""
+    error = validate_slug(slug)
+    if error:
+        raise ValueError(f"Invalid slug: {error}")
+
+    path = WORKFLOWS_DIR / f"{slug}.md"
+    try:
+        size = path.stat().st_size
+    except FileNotFoundError:
+        return None
+    if size > MAX_BYTES:
+        raise ValueError(f"Workflow '{slug}' exceeds size limit")
+
+    content = path.read_text(encoding="utf-8", errors="replace")
+    if _line_count(content) > MAX_LINES:
+        raise ValueError(f"Workflow '{slug}' exceeds size limit")
+    return _build_workflow_metadata(slug, content) | {"content": content}
+
+
+def save_workflow(slug: str, content: str) -> dict[str, str | int]:
+    """Create or replace a workflow markdown file atomically."""
+    error = validate_slug(slug)
+    if error:
+        raise ValueError(f"Invalid slug: {error}")
+
+    if len(content.encode("utf-8")) > MAX_BYTES or _line_count(content) > MAX_LINES:
+        raise ValueError("Content exceeds limit (16 KB / 200 lines)")
+
+    metadata = parse_frontmatter(content)
+    if not metadata.get("name"):
+        raise ValueError("Frontmatter must include 'name' field")
+
+    WORKFLOWS_DIR.mkdir(parents=True, exist_ok=True)
+    path = WORKFLOWS_DIR / f"{slug}.md"
+    tmp_path: Path | None = None
+    try:
+        with tempfile.NamedTemporaryFile(
+            "w",
+            encoding="utf-8",
+            dir=WORKFLOWS_DIR,
+            prefix=f".{slug}-",
+            suffix=".tmp",
+            delete=False,
+        ) as tmp_file:
+            tmp_file.write(content)
+            tmp_path = Path(tmp_file.name)
+        tmp_path.replace(path)
+    except OSError:
+        if tmp_path is not None:
+            tmp_path.unlink(missing_ok=True)
+        raise
+
+    return {"status": "ok", "slug": slug, "path": str(path), "chars": len(content)}
+
+
+def _line_count(content: str) -> int:
+    return len(content.splitlines())
+
+
+def _build_workflow_metadata(slug: str, content: str) -> dict[str, str]:
+    metadata = parse_frontmatter(content)
+    name = metadata.get("name") or slug.replace("-", " ").title()
+    description = metadata.get("description") or ""
+    return {"slug": slug, "name": name, "description": description}

{taskflow_agent-0.2.2 → taskflow_agent-0.3.0}/static/index.html

@@ -613,6 +613,17 @@ button { cursor: pointer; }
 }
 .task-row:hover { background: var(--bg-surface); }
 .task-row.selected { background: var(--bg-surface-2); }
+.task-row[draggable="true"] { cursor: grab; }
+.task-row.dragging { opacity: 0.4; }
+.task-row.drag-over { border-top: 2px solid var(--accent); margin-top: -2px; }
+.t-drag {
+  flex-shrink: 0; width: 14px; margin-top: 2px;
+  color: var(--text-muted); font-size: 10px; cursor: grab;
+  opacity: 0; transition: opacity var(--transition);
+  user-select: none;
+}
+.task-row:hover .t-drag { opacity: 0.6; }
+.t-drag:hover { opacity: 1 !important; }
 
 .t-check {
   width: 16px; height: 16px; border: 1.5px solid var(--border);
@@ -1154,6 +1165,13 @@ button { cursor: pointer; }
   font-size: 11px;
   color: var(--accent);
 }
+.chat-tool-hint {
+  color: var(--text-muted);
+  font-family: var(--font-mono);
+  font-size: 10px;
+  margin-left: 4px;
+  opacity: 0.7;
+}
 .chat-tool-state {
   font-size: 10px;
   text-transform: uppercase;
@@ -1162,6 +1180,28 @@ button { cursor: pointer; }
 }
 .chat-tool-card.complete .chat-tool-state { color: var(--green); }
 .chat-tool-card.error .chat-tool-state { color: var(--red); }
+.chat-tool-group {
+  width: 100%;
+  background: var(--bg-surface-2);
+  border: 1px solid var(--border-subtle);
+  border-radius: 12px;
+  overflow: hidden;
+}
+.chat-tool-group summary {
+  list-style: none;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+  padding: 9px 12px;
+  cursor: pointer;
+  font-size: 12px;
+  color: var(--text-secondary);
+}
+.chat-tool-group summary::-webkit-details-marker { display: none; }
+.chat-tool-group .chat-tool-state.error { color: var(--red); }
+.chat-tool-group-body { padding: 4px 8px 8px; }
+.chat-tool-group-body .tool { margin-bottom: 4px; }
 .chat-tool-body {
   padding: 0 12px 12px;
   border-top: 1px solid var(--border-subtle);
@@ -1585,17 +1625,21 @@ function renderSidebar() {
     }
     html += '</div>'
   } else {
+    const collapsiblePhases = new Set(['done', 'reference'])
     let first = true
     for (const ph of phaseOrder) {
       const projs = active.filter(p => p.phase === ph)
       if (!projs.length) continue
+      const collapsible = collapsiblePhases.has(ph)
+      const collapseAttr = collapsible ? ' style="cursor:pointer;user-select:none" onclick="this.nextElementSibling.classList.toggle(\'collapsed\')"' : ''
+      const countHint = collapsible ? ` <span style="opacity:.5">${projs.length}</span>` : ''
       if (first) {
-        html += `<div class="sb-group-label">${phaseLabels[ph] || ph} <span class="sb-group-toggle" onclick="event.stopPropagation();setSidebarSort('recent')" title="Sort by recent">↕</span></div>`
+        html += `<div class="sb-group-label"${collapseAttr}>${phaseLabels[ph] || ph}${countHint} <span class="sb-group-toggle" onclick="event.stopPropagation();setSidebarSort('recent')" title="Sort by recent">↕</span></div>`
         first = false
       } else {
-        html += `<div class="sb-group-label">${phaseLabels[ph] || ph}</div>`
+        html += `<div class="sb-group-label"${collapseAttr}>${phaseLabels[ph] || ph}${countHint}</div>`
       }
-      html += '<div class="sb-projects">'
+      html += `<div class="sb-projects${collapsible ? ' collapsed' : ''}">`
       for (const p of projs) {
         html += `<div class="sb-proj ${p.id === S.projectId ? 'active' : ''}" onclick="goProject(${p.id})">
           <span class="phase-dot ph-${p.phase}"></span>
@@ -1943,6 +1987,62 @@ function renderProject() {
   }
 
   c.innerHTML = html
+  initDragReorder(c)
+}
+
+/* ---- Drag-to-reorder tasks ---- */
+let _dragId = null
+function initDragReorder(container) {
+  container.querySelectorAll('.task-row[draggable="true"]').forEach(row => {
+    row.addEventListener('dragstart', e => {
+      _dragId = +row.dataset.id
+      row.classList.add('dragging')
+      e.dataTransfer.effectAllowed = 'move'
+      e.dataTransfer.setData('text/plain', row.dataset.id)
+    })
+    row.addEventListener('dragend', () => {
+      _dragId = null
+      row.classList.remove('dragging')
+      container.querySelectorAll('.drag-over').forEach(r => r.classList.remove('drag-over'))
+    })
+    row.addEventListener('dragover', e => {
+      e.preventDefault()
+      e.dataTransfer.dropEffect = 'move'
+      if (+row.dataset.id === _dragId) return
+      container.querySelectorAll('.drag-over').forEach(r => r.classList.remove('drag-over'))
+      row.classList.add('drag-over')
+    })
+    row.addEventListener('dragleave', () => {
+      row.classList.remove('drag-over')
+    })
+    row.addEventListener('drop', async e => {
+      e.preventDefault()
+      row.classList.remove('drag-over')
+      const targetId = +row.dataset.id
+      if (!_dragId || _dragId === targetId) return
+      // Find the spec-body (container) for this row
+      const body = row.closest('.spec-body')
+      if (!body) return
+      const rows = [...body.querySelectorAll('.task-row[draggable="true"]')]
+      const ids = rows.map(r => +r.dataset.id)
+      const fromIdx = ids.indexOf(_dragId)
+      const toIdx = ids.indexOf(targetId)
+      if (fromIdx < 0 || toIdx < 0) return
+      // Reorder: remove from old position, insert before target
+      ids.splice(fromIdx, 1)
+      ids.splice(toIdx > fromIdx ? toIdx - 1 : toIdx, 0, _dragId)
+      // Optimistic DOM reorder
+      const draggedRow = body.querySelector(`.task-row[data-id="${_dragId}"]`)
+      if (draggedRow) body.insertBefore(draggedRow, row)
+      // Persist
+      try {
+        await api('/api/tasks/reorder', { method: 'POST', body: JSON.stringify({ task_ids: ids }) })
+      } catch (err) {
+        toast('Reorder failed')
+        await refreshProject()
+      }
+    })
+  })
 }
 
 function filteredTasks() {
@@ -1959,8 +2059,10 @@ function setFilter(f) {
 function taskRow(t) {
   const done = t.status === 'completed'
   const dc = dueClass(t.due_date, t.status)
+  const draggable = S.view === 'project' && !done
   return `<div class="task-row ${done ? 'completed' : ''} ${t.id === S.selTaskId ? 'selected' : ''}"
-    data-id="${t.id}" onclick="selTask(${t.id})">
+    data-id="${t.id}" ${draggable ? 'draggable="true"' : ''} onclick="selTask(${t.id})">
+    ${draggable ? '<div class="t-drag" onmousedown="event.stopPropagation()">⠿</div>' : ''}
     <div class="t-check ${done ? 'done' : ''}"
       onclick="event.stopPropagation();toggleTask(${t.id},'${t.status}')"></div>
     <div class="t-info">
@@ -2593,6 +2695,14 @@ function updateStreamingAssistant(text) {
   scrollChatToBottom()
 }
 
+function _toolHint(name, input) {
+  if (!input || typeof input !== 'object') return ''
+  const v = input.project_id || input.task_id || input.query || input.name || input.text || input.repo || input.path || input.command || input.server_name || ''
+  if (!v) return ''
+  const s = String(v)
+  return s.length > 40 ? s.slice(0, 40) + '…' : s
+}
+
 function appendToolCard(toolCallId, toolName, toolInput) {
   clearChatEmptyState()
   const row = document.createElement('div')
@@ -2600,9 +2710,11 @@ function appendToolCard(toolCallId, toolName, toolInput) {
   const details = document.createElement('details')
   details.className = 'chat-tool-card'
   details.open = true
+  const hint = _toolHint(toolName, toolInput)
+  const hintHtml = hint ? ` <span class="chat-tool-hint">${esc(hint)}</span>` : ''
   details.innerHTML = `
     <summary>
-      <span class="chat-tool-name">${esc(toolName)}</span>
+      <span class="chat-tool-name">${esc(toolName)}${hintHtml}</span>
       <span class="chat-tool-state">running</span>
     </summary>
     <div class="chat-tool-body">
@@ -2967,6 +3079,35 @@ function finishChatStream(assistantText) {
     S.chat.currentAssistantEl = null
   }
 
+  // Collapse individual tool cards into a single summary row above the assistant message
+  const chatMsgs = document.getElementById('chat-messages')
+  const toolRows = Array.from(chatMsgs.querySelectorAll('.chat-row.tool'))
+  if (toolRows.length > 0) {
+    const uniqueTools = [...new Set(S.chat.turnTools.map(t => t.name.replace(/^tf_/, '')))]
+    const label = uniqueTools.length <= 3 ? uniqueTools.join(', ') : `${toolRows.length} tools`
+    const groupRow = document.createElement('div')
+    groupRow.className = 'chat-row tool'
+    const groupDetails = document.createElement('details')
+    groupDetails.className = 'chat-tool-group'
+    const hasError = S.chat.turnTools.some(t => t.error)
+    groupDetails.innerHTML = `<summary><span class="chat-tool-name">${esc(label)}</span> <span class="chat-tool-state ${hasError ? 'error' : ''}">${hasError ? 'errors' : 'done'}</span></summary>`
+    const groupBody = document.createElement('div')
+    groupBody.className = 'chat-tool-group-body'
+    toolRows.forEach(tr => {
+      tr.classList.remove('chat-row')
+      groupBody.appendChild(tr)
+    })
+    groupDetails.appendChild(groupBody)
+    groupRow.appendChild(groupDetails)
+    // Insert before the assistant bubble
+    const assistantRow = S.chat.currentAssistantEl ? S.chat.currentAssistantEl.closest('.chat-row') : null
+    if (assistantRow) {
+      chatMsgs.insertBefore(groupRow, assistantRow)
+    } else {
+      chatMsgs.appendChild(groupRow)
+    }
+  }
+
   S.chat.messages.push({ role: 'assistant', content: fullContent })
   saveChatMessages()
   resetChatTurnState()