TTal 2.0 Roadmap — What's Coming

[birdmanmandbir]

Three pillars for 2.0. Plus one that's already live.

🏛️ Temenos — Secure Agent Sandbox

Agents currently have raw access to Bash, Read, Write, Edit — no guardrails. That changes in 2.0.

Temenos is a sandboxed execution layer between agents and the filesystem. Workers get write access (they need to code), managers get read-only (they coordinate). All tool access goes through MCP — no more built-in shell access.

Once an agent has a specialized role, the sandbox config writes itself. You know which paths to mount, whether they're read-only or read/write, whether there's network access. No more permission prompts, no regex allowlists. The role defines the boundary.

Prompt rules are suggestions. Sandbox boundaries are walls.

🌳 Task Tree — Local-First Sync via TaskWarrior Fork

Flat task lists with depends: chains pretending to be hierarchies don't cut it. The GuionAI/taskwarrior fork adds parent_id — real parent-child relationships, tree views, and proper subtask decomposition.

The bigger story is sync. Upstream taskwarrior uses a manual pull/push model — you explicitly sync, resolve conflicts, hope for the best. The fork uses PowerSync as a local-first sync backend. Changes propagate automatically, offline-first by design, conflict resolution built in.

What this unlocks:

• Break epics into subtasks without losing the relationship
• Tree-filtered views (task tree shows the hierarchy)
• Real-time sync across agents and devices — no manual push/pull

🚀 Pipelines — Already Shipped

This one's already live. Every task flows through a tag-based pipeline. One command drives everything: ttal go <uuid>. Brainstorm done? ttal go. Plan reviewed? ttal go. PR merged? ttal go. It reads the tags, figures out the stage, and advances — spawning agents, notifying humans, merging PRs, cleaning up.

Pipelines are defined in pipelines.toml — hotfix goes straight to implement, features go through plan → review → implement. Human gates keep a checkpoint before committing direction. Configurable per pipeline.

🔀 Session Fork — Zero-Context-Loss Parallelism

When a brainstorm session forks, each fork inherits the full conversation — zero loss. No summaries, no lossy handoffs.

Context flows forward: brainstorm figures out what and why, plan forks figure out how, workers carry all of it into implementation.

One brainstorm can fork into multiple subtask trees in parallel:

Brainstorm — what & why (manager plane)
    │
    ├── Fork → ttal-cli  → plan (how)  → implement
    ├── Fork → temenos    → plan (how)  → implement
    └── Fork → organon    → plan (how)  → implement

Plan writing moves to the worker plane — isolated worktrees, dedicated tmux sessions. Managers stay lean coordinators.

The subtask tree IS the plan

Instead of writing a plan document and translating it into tasks, the subtask tree itself is the plan. Brainstorm creates subtasks, each gets a session fork, forks write details as annotations. No translation step, no drift.

The planner doesn't need to guess intent or reconstruct reasoning. It was there.

---

Temenos, task trees, and session forking are under active development. Pipelines are live today. Follow progress at github.com/tta-lab/ttal-cli.