Known Issues
This page lists defects and limitations in what TruePPM already ships. It is the companion to What TruePPM Doesn’t Do Yet, which covers capabilities that were never built. The split is worth keeping straight:
- Doesn’t do yet — resource leveling, cost and earned value, a mobile app. Absent by plan.
- Known issues (this page) — something that exists but is wrong, incomplete, or slower than it should be.
Every entry names its tracking issue and target release where one exists. When an issue closes, its entry comes off this page.
What holds up
Section titled “What holds up”Read the list below with this in mind. An independent assessment of TruePPM 0.4-beta.1
(2026-09-17) installed trueppm-scheduler from PyPI with no --pre flag and reproduced all
three values in the README exactly. It found the Monte Carlo seed-reproducible and ran a
2,000-task chain through the engine in 0.05 s. The falsifiability claim — that you can
check our numbers yourself — holds. The assessment did not drive the web UI, so it says
nothing about the interface.
The deterministic single-project CPM pass is the most mature part of TruePPM and the part we are most confident in. Nothing on this page removes that. What follows is where the edges are, ordered so that what is most likely to affect your day-to-day work comes first and engine internals and test-tooling scope come last. Each entry ends with what it means for you, what to do instead, and where it is tracked.
Scheduling engine
Section titled “Scheduling engine”These are the edges of the scheduling engine.
Monte Carlo what-if runs on the request thread
Section titled “Monte Carlo what-if runs on the request thread”Through 0.4 every Monte Carlo simulation executes inline in the HTTP request cycle,
gated only by a per-user rate-limit scope. On a large project at a high run count this
occupies a web worker for the duration of the simulation. Once 0.5 ships, only the what-if
(GET /projects/{id}/monte-carlo/whatif/, two simulations per call) will still run
this way.
- Impact: a slow simulation can crowd out other requests on a small deployment.
- Workaround: lower the run count; the P50/P80/P95 converge well before the default 1 000 runs on most networks.
- Partly fixed in 0.5 — #2273
moves the forecast run (
POST /projects/{id}/monte-carlo/) onto a Celery worker: the endpoint will answer202with a task-run id for the client to poll, and the web app will do that polling for you. API clients that read the forecast from thePOSTresponse will need to readGET /projects/{id}/monte-carlo/latest/once the run succeeds. The what-if keeps its tightermonte_carlo_whatifthrottle and is not moved.
Program-scoped Monte Carlo is not exposed — stretch goal for 0.5
Section titled “Program-scoped Monte Carlo is not exposed — stretch goal for 0.5”The program schedule view computes a program-true critical path across member projects, but only deterministically. There is no program-scoped Monte Carlo endpoint and no MCP tool for it, so the one scope where a confidence date matters most is the scope that cannot produce one.
The engine restriction that made this impossible lifted in 0.4
(#1385
— monte_carlo() honors per-task calendars, see ADR-0672).
What remains after that is the API surface, which is why this entry is separate.
- Impact: a program manager gets a deterministic finish date with no band around it. Ask for a what-if at program scope over MCP and the tool cannot answer.
- Workaround: run Monte Carlo per member project and reason about the combination manually — this understates joint risk and is not a substitute.
- Stretch goal for 0.5, not committed — #2467. It lands only if there is time.
The risk register does not affect the forecast — planned for 0.5
Section titled “The risk register does not affect the forecast — planned for 0.5”The risk register and Monte Carlo are separate systems that do not exchange information. A risk’s severity is the product of two 1–5 ordinals; a simulated finish date is computed from three-point estimates and team velocity. Nothing connects them.
The register’s probability × impact score therefore says nothing about the
schedule. A high-severity risk sitting on a task with weeks of total float moves
the finish date not at all, while a low-severity risk on the critical path may be
the single largest driver of the P80 — and the register ranks them the other way
around. Linking a risk to a task (which the register supports) records the
relationship for a human to read; it does not reach the engine.
- Impact: P80 does not reflect known risks. The register cannot answer “what would mitigating this buy me?”, so mitigation work completes without the forecast moving.
- Workaround: widen the pessimistic value of the three-point estimate on the affected task. This is a genuine workaround with genuine costs, and it is worth knowing what they are: a 40%-likely 10-day event is not a wider spread but a second peak, and PERT-Beta cannot represent one — it spreads probability across a gap the real distribution does not have. The padding is also unattributable (nothing records which risk it was for, so it is never removed when the risk closes) and uncorrelated (one risk affecting five tasks becomes five independent spreads, which understates the tail rather than overstating it).
- Fix planned for 0.5 — #3660 tracks the build,
per ADR-0711: risks become
first-class simulation inputs, with one shared draw per risk per iteration across
every task it touches. The design closed as
#2556
(that issue tracked the ADR, not the build — verified against
mainfor #3628:engine.pystill has noRiskDriverconcept). - Cost impact is a separate axis and lands later. ADR-0711 treats schedule and
cost as the two axes a simulation can answer. The released versions have no cost
data model. 0.5 ships a labor cost model: a project budget, a resource rate, and
actual cost from logged time
(#754)
(the issue is closed because that model merged — verified against
mainfor #754:projects/cost.pyexists, but nothing in the scheduler’s Monte Carlo prices a sampled duration yet). The Monte Carlo is planned to report a P80 cost beside the P80 date. That cost comes from duration uncertainty priced at resource rates, not from risk-register impacts, which stay schedule-only. Non-labor direct costs follow later (#2557). Risk impact on scope, quality, safety, and compliance is recorded but deliberately never simulated or folded into a combined score.
Velocity-driven P80/P95 is a lower bound — planned for 0.5
Section titled “Velocity-driven P80/P95 is a lower bound — planned for 0.5”For sprint-delivered work sampled from team velocity, each run’s sprint horizon is clamped. Runs that have not burned down by that horizon are clamped to it rather than sampled further, which truncates the slow right tail.
The weekly-throughput sampler used by a continuous-flow board clamps its horizon the same way, so the same caveat applies to the throughput forecast.
- Impact: for a team with high throughput variance, the agile P80/P95 is optimistic — a loose lower bound rather than an unbiased estimate. The bias runs in the unhelpful direction.
- Workaround: treat a velocity-driven P95 as a floor. Three-point (PERT) estimates are not affected.
- Surfaced in the product: every affected number carries a “a floor, not a percentile” qualifier and a help icon explaining the clamp — on the backlog forecast, the sprint release-horizon chips, and the board’s flow analytics card. See Interpreting results.
- Partly fixed in 0.5 — #2469.
0.5 will report the truncation but will not remove the bias. The project Monte Carlo
forecast response will carry
velocity_saturated_runs, the count of runs clamped at the sprint horizon, and the backlog forecast will carryhorizon_saturated, so a caller can tell a truncated P80/P95 from an ordinary one. The percentiles themselves will still be lower bounds when either is non-zero.
Resource management and capacity
Section titled “Resource management and capacity”A task with only an assignee contributes no load to any capacity view
Section titled “A task with only an assignee contributes no load to any capacity view”There are two ways to record who is working on a task, and only one of them creates capacity load. Setting a task’s assignee names the person responsible. Either an assignee or a resource assignment grants a Member the “edit and delete their own tasks” permission. Adding a resource assignment — a person plus the fraction of their time the task takes — is the only one that creates load: it is what the heatmap, the utilization card, overallocation warnings and resource contention all sum.
A task that has an assignee but no resource assignment is therefore real, visible, and owned, while counting as zero load for the person it is assigned to. Nothing in the product currently says so.
- Impact: a resource manager reading the heatmap can see someone as available while they carry assigned work. The numbers are internally consistent — they sum exactly what they say they sum — but they will disagree with what a team is actually doing if assignments were made the simpler way.
- Workaround: add a resource assignment (with units) to any task whose load should appear in capacity views, not only an assignee. A task that has both is counted once, from the assignment. The assignment has to be on a resource linked to the assignee’s user account — one on a different resource does not stand in for them.
- Partly fixed in 0.5 — #3059.
0.5 will count an assignee-only task at an assumed full-time load (
1.0) in three places: the overallocation indicator on a task, the overallocated row in the project’s attention feed, and the overallocation warning shown when you assign someone. The task indicator and the attention row will say when that estimate is part of the over-capacity day. The assignment warning flags any such task on the assignee, wherever it falls. The heatmap, daily utilization and the digest will still count such a task as zero (#4936). - Tracked on #3605, which will rule on whether the two paths are reconciled, disclosed in the product, or collapsed.
Baselines
Section titled “Baselines”Baseline comparison is a table, not a Gantt overlay — ships in 0.5
Section titled “Baseline comparison is a table, not a Gantt overlay — ships in 0.5”0.4 brings baseline capture, management, and comparison into the app, but the comparison is a text table in the task drawer. The planned-vs-current ghost-bar overlay on the Gantt is not in this release; it ships in 0.5 as Display → Chart → Baseline bars.
- Impact: you can see that a task slipped and by how much, but you cannot see the slip drawn against the plan on the timeline, which is the reading most people expect from the word “baseline”.
- Workaround: none — use the drawer’s comparison table.
- What to do: capture baselines as usual; the data is all there. Read slippage from the drawer table until the overlay lands.
- Fix ships in 0.5. The legend previously carried a stray “Planned baseline” swatch with no matching draw call behind it — that was #2696 (closed, fixed): the legend no longer renders it, and the new “Baseline (planned)” row appears only while the bars are drawn.
MCP and agents
Section titled “MCP and agents”The team-level agent opt-out exists at project scope only
Section titled “The team-level agent opt-out exists at project scope only”The instance → workspace → program → project cascade that decides whether agents may
read a scope is real and correctly enforced, and the mcp_enabled field is already
writable at all three scopes over the API. The UI to set it exists only at
Project settings → Agents; there is no Agents section on program or workspace
settings in 0.4.
- Impact: an operator following the runbook to “Program settings → Agents” or the workspace equivalent finds nothing there.
- Workaround: set project-scope opt-outs in the UI; workspace and program scope are
settable through the API (
PATCH /api/v1/workspace/orPATCH /api/v1/programs/{id}/), and the instance-wide kill switch is theTRUEPPM_MCP_ENABLEDenvironment variable (which is enforced first, ahead of every other check). - Fix ships in 0.5 — the workspace and program Agents sections (#2700 and #2716).
A computed answer does not name the engine that produced it
Section titled “A computed answer does not name the engine that produced it”Every value the MCP read tools return is computed by the scheduling engine rather than
guessed, and the primary answer tools carry a why block explaining the derivation.
What they do not carry is the provenance envelope
ADR-0112 §2 specifies — the stamp naming which engine
version produced the number, inline on the answer itself.
- Impact: an operator cannot cite an engine version alongside a forecast, or reproduce an answer later against the version that generated it. For an agent workflow that records what it was told, the answer is attributable to a point in time but not to a build.
- Workaround: the engine version is captured in the agent-action audit log, so the
pairing is recoverable after the fact — query
GET /api/v1/agent-actions/and match on the action’s timestamp. - Tracked on #2642, currently
sequenced for 0.5. The related refusal-transparency gap closed with
#2689 :
a refused agent request now carries its
refusalenvelope — verdict, reason and constraint — to the MCP client, per ADR-0809.
Findability and filtering
Section titled “Findability and filtering”Filtering matured on the Board first and will reach the other views unevenly. Label filtering reached the Table/Grid and the Product Backlog in 0.4; the Schedule does not have it, and today no view except the Board can save a filter by name.
| Issue | Symptom | Fix planned for |
|---|---|---|
| #2443 | The Schedule is the only task view with no label filter — the Board, Table/Grid, and Product Backlog all get one with 0.4, the Gantt does not | 0.5 |
| #2444 | The Schedule has no text search and no owner/status filter — you cannot find a task on the Gantt | 0.5 |
| #2445 | Saved views are Board-only; Grid, Schedule, Backlog and My Work cannot save a named filter | 0.5 |
| #2443 | Filter state does not survive a view switch, and the vocabulary differs per view | 0.5 |
| #2446 | My Work has no project filter, so a PM running several projects gets one undifferentiated list | 0.5 |
What to do: until these land, use the Board or Table/Grid when you need to find or filter tasks, and keep a saved filter on the Board if you need it again. Each row is tracked by the issue it links; all are planned for 0.5.
Performance and scale
Section titled “Performance and scale”The measured ceilings themselves are covered on What TruePPM Doesn’t Do Yet and in the sizing guide. These are the specific defects behind them.
| Issue | Symptom | Fix planned for |
|---|---|---|
| #3381 | Each page of the task list skips the rows before it, and skipping a row still evaluates its per-task subqueries — the last page of a 100 000-task project takes 8.7 s against 0.11 s for the first. This is what sets the ~2 000-task comfort ceiling | 0.5 |
| #3119 | The Schedule view loads the whole project before it draws anything — about 2.3 KB of JSON per task, 229 MB at 100 000 tasks | 0.5 |
| #3831 | Schedule recalculation holds about 30 KB of memory per task, so the chart’s 2 GiB Celery worker limit is exceeded near 60 000 tasks in one project or one cross-linked program. Raise resources.limits.memory on the worker before then | 0.5 |
| #3832 | The Schedule has never been measured in a browser at scale: heap size, first paint, and interaction latency above a few thousand tasks are unknown | 0.5 |
What to do: below roughly 2 000 tasks per project none of these bite. Above that, split work across projects in a program rather than one large project, raise the Celery worker memory limit before 60 000 tasks, and expect the Schedule view to load slowly. The sizing guide above has the measured envelope. Each row is tracked by the issue it links; all are planned for 0.5.
Accessibility
Section titled “Accessibility”A foothold, not full WCAG 2.1 AA conformance
Section titled “A foothold, not full WCAG 2.1 AA conformance”The CI pipeline enforces an axe-core WCAG 2.1 A/AA scan inside the Playwright E2E suite, and a critical or serious violation fails the pipeline — that gate runs today, on every merge, not just in a future release. The 0.4 remediation pass — focus traps across roughly seventy dialogs, drawers, and popovers, 44px touch targets on the board and schedule surfaces, contrast fixes in both light and dark themes, live-region announcements for route changes and async writes, and keyboard operability on the Gantt, board, and outline — shipped with the 0.4 beta. The axe gate itself is #1685 and #2202 ; the remediation ran across the release rather than under one tracking issue.
What that gate does not prove:
-
moderateaxe findings do not block a merge. They are being ratcheted in route by route as each surface’s audit lands, so the enforced floor is narrower than the stated commitment. -
There has been no formal, end-to-end WCAG 2.1 AA audit of the product. The gate above is automated and partial; a professional audit — including manual screen-reader and keyboard-only passes — has not been run.
-
Impact: an evaluator doing PMO due diligence on accessibility will not find a conformance statement anywhere in the product docs before this page, because there isn’t one to give yet. Treat 0.4 as “actively improving, automated-gate-enforced, and not yet audited” — not as “WCAG 2.1 AA compliant.”
-
What to do: if you need a conformance statement, run your own audit against the running app (the axe gate and the remediation above are a sound starting point, not a substitute), and tell us what you find using Report a bug below.
-
Fix planned for 0.9 — the formal audit is a GA-hardening item on the roadmap. It has no tracking issue; the roadmap is the record.
The second engine (Rust / WASM)
Section titled “The second engine (Rust / WASM)”TruePPM ships two coordinated CPM implementations: the Python library
(trueppm-scheduler, the authority) and a Rust engine compiled to WebAssembly.
They are not yet at parity, and the gap is wider than the architecture diagram
suggests.
The WASM engine is not wired into the browser — frozen until the 0.6 decision
Section titled “The WASM engine is not wired into the browser — frozen until the 0.6 decision”The Rust engine ships as a CI-validated conformance reference. The browser’s drag-preview path still uses a TypeScript CPM worker that approximates the calendar as a fixed Mon–Fri week.
- Impact: the sub-100 ms in-browser drag preview is calendar-approximate. The authoritative server CPM reconciles exact dates on commit, so a committed schedule is always correct — but a preview can differ from what lands.
- The fix for the holiday and working-week half lands in 0.5 — #4170 (merged) sends the project’s composed calendar to the browser, so the 0.5 preview steps through its holidays and custom working week the way the server does. That fix does not depend on the WASM engine below.
- What to do: treat the drag preview as an estimate and read the dates after the drop, once the server has reconciled them. Those are the ones that count.
- Frozen, with a decision date — the WASM engine takes no new feature work in the crate until the decision on its fate (#4743), due no later than 0.6 planning. #1777 (wiring it in) is held until then. Conformance-parity maintenance for Python-side semantic changes already committed for 0.5 continues. Its output is advisory and never produces a refusal; the server has the last word.
The Rust engine has no Monte Carlo — not scheduled
Section titled “The Rust engine has no Monte Carlo — not scheduled”The Rust engine implements forward pass, backward pass, floats, and incremental recompute. It has no Monte Carlo at all. Offline and in-browser recompute is therefore deterministic-only; every probabilistic answer requires the server.
- Impact: offline and in-browser recompute can give you dates but never a P50/P80/P95.
- What to do: run Monte Carlo against the server when you are online; do not expect a confidence band from an offline session.
- Tracked: not scheduled, and no issue tracks adding Monte Carlo to the Rust engine. The decision on the WASM engine’s future is #4743, above.
Test and quality gates
Section titled “Test and quality gates”Mutation testing does not cover the engine core — planned for 0.5
Section titled “Mutation testing does not cover the engine core — planned for 0.5”Mutation testing proves the suite’s assertions catch regressions rather than merely
executing lines. Its scope is models.py, derive.py, and cli.py. engine.py
— the CPM and Monte Carlo core — is out of scope. The score floor within that
scope does gate: MUTATION_MIN is 0.92 against an observed 96.8%, and a
nightly below it reds.
- Impact: the strongest available evidence of assertion strength deliberately excludes the code that matters most. Where the roadmap describes “mutation testing on the scheduler”, read it as covering the models/serialization layer, not the engine.
- What to do: do not cite the 96.8% mutation score as evidence about the CPM or Monte Carlo core. For the engine, rely on the conformance suite and the reproducible README values described above, and run the published package against your own schedules.
- Fix planned for 0.5 — #2468.
Reporting a new one
Section titled “Reporting a new one”If you hit something that is not on this page, the user menu and the ⌘K palette both have a Report a bug entry that opens the tracker with your version, edition, build SHA, and current route already filled in. It is a link, not a beacon — nothing is transmitted by rendering it, and you can read and edit the context before submitting.
Maintainers: every issue linked from this page carries a comment pointing back here. When you close one, update this page in the same merge request — remove the entry, or move it to the roadmap as shipped.