A number for the day

DailyFlowScore: A Dollar-Denominated, Energy-Aware, Buffer-Managed Prioritization Score for the Attention-Constrained Solo Operator

2026-06-26 · dollarized revision 2026-06-30

Abstract

A single knowledge worker who runs several concurrent projects faces a scheduling problem whose binding constraint is not time, money, or headcount, but their own finite attention. We present DailyFlowScore, a scalar task-prioritization function that unifies three previously separate bodies of practice (energy-aware capacity management, Critical Chain feeding-buffer management, and weighted cost-of-delay scoring) into one interpretable number. The score is DailyFlowScore = CoD_rate × TimeCriticality / Effort, where CoD_rate = CostOfDelay($/week) × ThemeFit, and the daily plan is a capacity-constrained selection bounded by DrumHours × CapacityScalar(sleep, mental). We first subjected the model to an adversarial battery (eight families, 25 checks, stdlib Python); it broke the naive formulation twice. A greedy-by-ratio packer stranded the single highest-value due-today task, and a global buffer-burn multiplier promoted nothing. Both forced three corrective mechanisms: an optimal 0/1-knapsack daily selection, per-arc buffer-burn, and commitments-first scheduling with an explicit overcommitment flag. The score carried one deliberate weakness its own author flagged: Value was an abstract index, so the headline (“4.38”) was uninterpretable without a personal trend, a reading as meaningless as “14 degrees” to someone who has never felt Celsius. This revision resolves it by denominating the driver: Value becomes a real $/week Cost-of-Delay rate, so the headline reads in dollars per focus-hour. The denomination unlocks two mechanisms the abstract score could not express: a logistic elapsed-time decay term that makes a no-deadline task get more urgent the longer it is neglected (flat early, steepest in the day-10–35 window, then plateauing), and a multi-horizon NPV lens under which small daily compounders overtake big one-offs at an 18-month crossover. Both hold together only because Cost of Delay is kept a rate; we prove in-harness that feeding a cumulative dollar-days quantity into the ranking inverts it. Re-running the full battery in dollar units with both mechanisms live: 34/34 checks pass, and a dollarized 30-day Monte Carlo (60 seeds) again dominates the naive policies (0.17 missed deadlines and $18,974 weighted value against 2.92/$18,103 for value-greedy and 0.07/$17,692 for deadline-greedy). We argue that outcome simulation, not invariant satisfaction alone, is the decisive evidence the number is meaningful rather than merely plausible, and we report its limitations honestly.

1. Introduction

The solo multi-project operator (a consultant, founder, or content creator who simultaneously ships client work, produces a publication cadence, and maintains an improvement backlog) confronts a scheduling dilemma that classical project-management tooling addresses poorly. Standard tools assume a project as the unit of optimization and a resource pool (people, budget) as the constraint. For the solo operator neither assumption holds. There is exactly one resource, and that resource’s binding capacity is not the 8–16 nominal working hours in the day but the far smaller quantity of deep, deciding attention the operator can muster on a given morning, a quantity that varies with sleep, mood, and recovery.

We frame this through the lens of the Theory of Constraints (TOC) [11, 16]. TOC’s first focusing step is to identify the constraint, the single resource whose throughput caps the throughput of the whole system. For the solo operator, that constraint is their own attention. Everything downstream (which task moves, which cancels, which stays today) should be subordinated to keeping that constraint fed with the highest-value ready work. The operator’s recurring question, “are we doing the things that matter, and are we keeping our commitments?”, is exactly a constraint-subordination question.

The research question of this paper is narrow and falsifiable: can a single scalar score be simultaneously (a) interpretable, decomposable into named, ratio-scaled drivers with fixed units, and (b) productive of measurably better outcomes than the naive heuristics an operator would otherwise use (do the most valuable thing; do the most urgent thing; do whatever)? A scalar that is interpretable but no better than “work on the most valuable item” is decoration. A scalar that produces better outcomes but is an opaque index (“priority = 73”) is unactionable, because the operator cannot reason about it, tune it, or trust it. We require both.

Our contribution is fivefold. First, we formalize the hand-waved components of an energy-aware flow score into concrete functional forms that can be attacked. Second, we report an adversarial validation methodology in which outcome simulation, not invariant-checking, is the arbiter of meaning. Third, we document the three corrective mechanisms that the pressure test forced; those corrections are themselves the substantive engineering result, since the naive model failed. Fourth, we denominate the score in dollars, replacing the abstract value index with a $/week Cost-of-Delay rate so the headline is interpretable in isolation. Fifth, we show that this denomination is not cosmetic: it makes two new mechanisms expressible (an elapsed-time urgency term that rescues neglected no-deadline work, and a multi-horizon lens that re-ranks recurring against one-off work) while a single load-bearing invariant (Cost of Delay must stay a rate) keeps the ranking from inverting.

A note on why money is the right unit, not an arbitrary one. The entire Cost-of-Delay / WSJF / CD3 lineage [7, 5, 6] defines prioritization in money-over-time; the score was always a CD3 with the dollars thrown away. Restoring them turns the headline from “4.38” into “$438 per focus-hour,” a quantity readable at a glance because a lifetime has calibrated us in dollars. And once value is real money, two questions the abstract version could not even ask become answerable: where does urgency come from when there is no deadline? (a workout skipped for three weeks costs more every day) and does the ranking depend on the horizon? (a small recurring action is worth far more at five years than a one-off is). These are the substantive additions of the dollarized revision.

2. Related Work

DailyFlowScore is a synthesis. Each component layer is independently published and battle-tested; the novelty is in the composition. We survey the source literatures and then state the gap explicitly.

Energy management. Loehr and Schwartz’s The Power of Full Engagement [9] reframes performance as a function of energy rather than time, decomposed into four dimensions (physical, emotional, mental, spiritual). This supplies the vocabulary for a daily capacity rating: the operator’s available throughput is an energetic quantity, not a clock quantity.

Chronotypes and timing. Pink’s When [8] establishes that cognitive performance varies systematically across the day by chronotype, motivating the placement of high-stakes “deciding” work in peak windows.

Ultradian rhythms. Kleitman’s basic rest–activity cycle, popularized for knowledge work by Huberman [10], frames focused attention as arriving in ~90-minute ultradian blocks rather than as a uniform fluid, which reinforces that the constraint (deep-work hours) is small, discrete, and depletable.

Theme days. Dorsey’s practice of assigning each weekday a single cognitive theme [12], and Newport’s “rhythmic” scheduling in Deep Work [13], let the operator commit each day’s constraint to one mode (e.g., Monday–Thursday = delivery, Friday = continuous improvement). In our model the day’s theme shifts the strategic-fit weight applied to every task.

Make Time. Knapp and Zeratsky’s Make Time [1] supplies the Highlight·Laser·Energize·Reflect loop: a daily “Highlight” plus an end-of-day reflection that feeds learned personal coefficients.

Recovery-driven workload. WHOOP’s recovery model [14] translates physiological recovery (green/yellow/red) into a recommended workload, the direct industrial analogue of a morning capacity scalar gating the day’s plan.

Theory of Constraints, Critical Chain, and fever charts. Goldratt’s TOC [11] and its Critical Chain Project Management (CCPM) extension introduce project and feeding buffers and the fever chart (buffer-burn plotted against percent-complete) [3, 4]. A missed slot consumes feeding buffer; when burn outpaces progress the chain goes “yellow,” and its time-criticality should spike. CCPM buffers are documented in mainstream PM tooling [2].

Drum-Buffer-Rope. The DBR scheduling discipline [16], applied to knowledge work via Forte Labs’ TOC series, supplies the Drum (the constraint sets the beat), the Buffer (slack ahead of the constraint), and the Rope (backpressure blocking new starts until the buffer is restocked), the mechanism that forces make-up work before new work.

Cost of Delay, WSJF, and CD3. Reinertsen’s Principles of Product Development Flow [7] establishes Cost of Delay (CoD) as the economic quantity prioritization should optimize. SAFe’s Weighted Shortest Job First, WSJF = CoD / job size [5], and Arnold’s CD3, CoD / duration [6], make the ratio operational. DailyFlowScore is structurally a WSJF/CD3 score with an energy-aware capacity gate.

RICE. Intercom’s RICE score [15] (Reach × Impact × Confidence ÷ Effort) contributes the Confidence term as an uncertainty discount and the division-by-effort form.

Weighted decision / MCDA matrices. Weighted decision matrices, Pugh matrices, AHP, and multi-criteria decision analysis [17] supply the central property the operator wanted: tweak a weight, and the whole ranking recomputes. The impact of a change is visible immediately.

Personal Kanban. Benson and Barry [18] contribute explicit work-in-progress limits, capping the constraint’s queue.

Upstream filters. What is even eligible for the list is governed by McKeown’s Essentialism 90% rule [19], Keller’s The ONE Thing [20], Burkeman’s Four Thousand Weeks finitude argument [21], and Doerr’s OKRs [22] for strategic alignment.

The dollarized revision draws on three further literatures. Cost of Delay as a rate, and CD3. Reinertsen [7] establishes Cost of Delay as the economic quantity prioritization should optimize, and is emphatic that it is a rate: dollars per unit time, not a stock. Arnold’s CD3 [6], CoD($/wk) ÷ Duration, makes the rate operational. The famous Maersk case (a feature worth ≈ $200,000/week sitting 38 weeks in queue, ≈ $8M lost) is the integral of the rate; Arnold warns that confusing the integral with the rate inverts priorities, a warning that becomes a load-bearing invariant in §3.2. TOC dollar-days. Goldratt’s Throughput-Dollar-Days and Inventory-Dollar-Days [25, 26] measure $ × days, a cumulative penalty that Schragenheim stresses is meaningful only comparatively and as a trend (“60,000 dollar-days has no standalone meaning”). That is precisely the operator’s Celsius/Fahrenheit point, arriving from the TOC side. We use dollar-days as the retrospective gauge (the odometer) to CoD’s prospective gauge (the speedometer).

Elapsed-time decay: detraining and the abstinence-violation effect. That urgency can rise without a deadline is grounded in two empirical curves. Detraining research [27] gives a hard, time-indexed loss of fitness (VO₂max ≈ −4% by day 12–14, −10% by week 5, −13–20% by ≈ 2 months, then a plateau at ≈ 12 weeks): slow, then steep in the day-10–35 window, then flat. Habit research [28] and the abstinence-violation effect [29] add that a single miss is harmless but sustained neglect compounds non-linearly, and that framing inaction as accumulating loss (loss aversion ≈ 2× gain) is more motivating. We fit a logistic to this shape (§3.3). To our knowledge no prior prioritization score makes urgency a function of days-since-last-action. Multi-horizon valuation. NPV mechanics [30] and the annuity formula PV = B·[1−(1+r)^−n]/r give the horizon dependence: with a personal discount rate of 5–8% [31], a recurring $1/day benefit is worth ≈ $342 at one year and ≈ $958 at three, while a one-off is horizon-invariant. We keep this finance lens separate from motivational “compounding” heuristics (e.g. Clear’s 1.01⁷⁶⁵ [32]), which have no ceiling and are not NPV.

The gap. Every layer above is published. Yet no prior work assembles energy-aware capacity, CCPM feeding-buffer management, and weighted cost-of-delay scoring into one score for a solo multi-project content operator. In particular, CCPM fever charts have, to our knowledge, never been applied to creator publication cadence. And that synthesis, in its first form, still scored in abstract units, took urgency only from deadlines, and was horizon-blind. Denominating it in dollars, making urgency rise with neglect, and adding a horizon lens (while preserving the rate-based ranking guarantee) is the second gap this work fills.

3. Model / Formalization

We pin every hand-waved component to a concrete functional form, because an underspecified equation cannot be tested. The act of specifying it is what surfaced the defects of Section 5. All constants below are configuration knobs in the deployed system.

3.1 The Drum and the capacity scalar try it above ↑

Let DrumHours = 4.0 be the operator’s deep-work attention budget on a full-capacity day. The day’s actual budget is gated by a capacity scalar computed from a 60-second morning rating of sleep and mental state, each on a 1–5 scale with 3 as baseline:

CapacityScalar(sleep, mental) = clamp( 1.0 + 0.6·(sleep−3)/2 + 0.4·(mental−3)/2 , 0.4 , 1.1 )
Capacity_hours = DrumHours × CapacityScalar(sleep, mental)

Sleep is weighted 0.6, mental state 0.4; the scalar ranges from 0.4 (a depleted day yields 1.6 attention-hours) to 1.1 (a peak day yields 4.4). A poor morning rating shrinks capacity, fewer tasks fit, and the cascade falls out deterministically.

3.2 Dollarized Cost of Delay, and the rate invariant try it above ↑

CoD_rate(Value, ThemeFit) = Value × ThemeFit          # units: $/week

Value is now the task’s Cost of Delay as a rate: the dollars of value-at-stake bled per week the task is not advanced, in real currency. It is elicited from the operator’s plan via the standard CoD ladder (attribute the plan’s annual value pool to drivers, divide by 52) or from researched per-domain anchors for non-revenue work: a skipped workout defends ≈ $3.7–5.6/day in avoided healthcare; a learning block a slice of a 5–9%/yr earnings uplift; a content post the expected value of opportunity flow. This replaces v1’s abstract Value index, which was ratio-scaled but unitless, the source of the “4.38 means nothing” critique. ThemeFit ∈ [THEME_FLOOR, 1] is unchanged, with THEME_FLOOR = 0.20: an off-theme task retains 20% of its weekly bleed rather than zero, an anti-starvation guard against a task that never matches the day’s theme becoming permanently unschedulable.

The rate invariant. CD3’s outcome-superiority depends on CoD being a rate. A cumulative quantity (dollar-days, the integral of the rate over elapsed delay) must never enter the ranking. The danger is concrete: a task bleeding $50/week that has been late 80 days has accumulated far more dollar-days (≈ 571) than a fresh task bleeding $1,000/week (≈ 143), yet the second should obviously be done first, because it is losing value twenty times faster. Ranking by the cumulative inverts this. We therefore state the invariant explicitly and test it (§5): the score’s numerator is CoD_rate × urgency, a rate times a dimensionless multiplier; it never accumulates. Dollar-days is retained only as a separate retrospective gauge to watch trend, never as a ranking key.

3.3 Time criticality: deadlines or neglect try it above ↑

The urgency multiplier (≥ 1, dimensionless) rises as slack shrinks, explodes when the commitment is already late, and (new in the dollarized revision) also rises when a task that rots when ignored has been neglected, even with no deadline in sight:

days_needed = max(Effort, EFFORT_FLOOR) / DrumHours
slack       = daysToDue − days_needed
due_press   = 2.0 · exp( −max(slack, 0) / 3 )                       if daysToDue is set, else 0
            + 4.0 · (1 + min(−slack, 5))    when slack < 0         (hard late penalty)
decay_press = k_decay · S · σ( (daysSince − d_mid) / d_scale )     σ(x) = 1/(1+e^−x)
buf_press   = 1.5 · max(0, bufferBurn)
TimeCriticality = 1.0 + max(due_press, decay_press) + buf_press

The exponential due_press term produces the smooth “deadline rescue”: as a task’s due date approaches, its urgency climbs monotonically, and once overdue the discontinuous late penalty makes the commitment dominate. bufferBurn is the CCPM fever signal (fraction of feeding buffer consumed beyond progress).

The elapsed-time (neglect) term. daysSince is days since the task was last done; S ∈ [0,1] is its neglect-susceptibility (high for health and content cadence, ≈ 0 for a one-off deliverable). With defaults k_decay = 2.0, d_mid = 18, d_scale = 7, the logistic decay_press is small for the first days, steepest across the day-10–35 window, and plateaus at k_decay·S; it does not grow without bound. Two choices carry weight. First, the combination is max(due_press, decay_press), not a sum, so a task that is both late and neglected is not double-counted. Second, decay_press is gated by S, so elapsed time touches only tasks that actually rot when ignored; a non-susceptible task is invariant to days-since. (Try it: set Rots if ignored? above 0, then drag Days since last done, and the score climbs; return susceptibility to 0 and it goes inert.)

3.4 The score and its units try it above ↑

                       CoD_rate(Value, ThemeFit) × TimeCriticality(daysToDue, daysSince, S, Effort, bufferBurn)
DailyFlowScore(task) = ──────────────────────────────────────────────────────────────────────────────────────────
                                              max(Effort, EFFORT_FLOOR)

with EFFORT_FLOOR = 0.25 hours. The floor is the second anti-degeneracy guard: without it, a trivial Effort → 0 chore would dominate by division-by-near-zero. The units of the score are now ($/week of Cost of Delay × dimensionless urgency) per attention-hour, i.e. dollars per focus-hour. A score of $438 reads literally as “doing this buys down about $438 of weekly Cost of Delay per scarce hour today.” The number is interpretable in isolation, with no personal trend required (which was the entire point of the operator’s critique), and because the units are fixed, scores are comparable across tasks and across days.

3.5 A multi-horizon lens (recurring vs one-off)

Once values are real dollars, present-value arithmetic applies, and the time horizon re-orders the backlog rather than merely rescaling it. We add a horizon lens (a strategic ranking kept separate from the daily score) that values each task by the discounted dollars it unlocks over a chosen horizon H ∈ {6mo, 1yr, 3yr, 5yr}:

horizon_value(task, H) = (cod_per_week / 7) · AnnuityPV($1/day, H)   if recurring (annuity)
                         cod_per_week · capture_weeks                  if one-off  (horizon-invariant)
AnnuityPV($1/day, H)   = (1 − (1+r)^−n) / r ,   n = 365·H days ,   r = daily rate for 7%/yr

A one-off is delivered once and captures its rate over a short fixed window; a recurring action is an annuity captured across the whole horizon. Because the annuity grows with H and the one-off does not, there is a crossover where a cheap daily compounder overtakes a large one-off; our harness places it at 18 months (§5.5). This lens is kept separate from the daily CD3 score precisely to honor §3.2: horizon arithmetic operates on present-valued stocks for strategic sequencing, while the daily score stays a pure rate for tactical sequencing. Mixing them would re-introduce a cumulative into the ranking. (An interactive version of this crossover sits below the paper.)

3.6 The daily plan as capacity-constrained optimization

The naive prescription was: take tasks by descending score until Σ Effort ≥ Capacity_hours. The corrected plan is a capacity-bounded selection problem. We present the three corrective mechanisms as formal design decisions.

(F1) Optimal 0/1-knapsack selection vs greedy-by-ratio. Given the residual capacity, select the subset of tasks maximizing total realized CoD subject to Σ Effort ≤ capacity. This is a 0/1 knapsack, solved exactly by dynamic programming over 0.25-hour units. Greedy-by-ratio (the naive packer) can strand the single most valuable item when a small task is admitted first and consumes the budget.

(F2) Per-chain (per-arc) buffer-burn vs a global multiplier. Buffer-burn is attached to the content arc (chain) a task feeds, not to the day globally. A task feels burn only if its own arc’s buffer is depleting:

arc_burn(task) = bufferBurn[task.arc]   if task.arc is set, else 0

A global multiplier raises every task’s score equally and therefore promotes nothing; it changes no rankings.

(F3) Commitments-first scheduling with an overcommitment flag. Tasks with an imminent hard due date (daysToDue ≤ commit_horizon, default 1 day) are scheduled first, sorted by realized CoD, before the knapsack optimizes the remainder. If imminent commitments exceed capacity, the unschedulable ones are flagged as an overcommitment signal, never silently dropped. This is the operator’s correction that due dates must sit alongside buffers as first-class commitments, not be subsumed by buffer logic.

4. Methodology

We test the model with an adversarial validation battery (flowscore_pressure_test.py), stdlib-only and deterministic via fixed seeds. The intent is not to confirm the model but to break it. The battery comprises eight test families.

1. Units / interpretability. Decompose a worked example into named drivers and confirm the score equals CoD × urgency / max(Effort, floor) and reduces to fixed units.
2. Monotonicity invariants. Confirm the score’s response to each input has the correct sign: ↑Value ⇒ ↑score; ↑Effort ⇒ ↓score; closer due date ⇒ ↑score; ↑bufferBurn ⇒ ↑score on the task’s own arc; ↑ThemeFit ⇒ ↑score; and that an off-theme task is reduced but never zeroed.
3. Degenerate inputs. Confirm Effort → 0 is bounded (finite score, no infinity), that a trivial chore does not outrank real high-value work, and that a missing due date yields a finite baseline urgency of 1.0.
4. Capacity cascade. On a low-energy day, confirm the plan drops the right tasks, honors the highest-value imminent commitment, flags over-capacity commitments, never overshoots capacity, and that the optimal pack realizes at least the greedy pack’s value.
5. Buffer make-up promotion. Confirm that burning a content arc’s buffer pulls the corresponding make-up task into today’s plan, and that it does not bump unrelated tasks.
6. Deadline rescue. Confirm a low-value task’s score rises monotonically as its deadline approaches and that it enters the plan once imminent.
7. Packer quality vs optimal. Over 300 random days, compare greedy realized value to the DP-optimal, reporting the mean and worst-case ratio and the share of days the optimal strictly wins.
8. 30-day Monte Carlo outcome simulation. Simulate 30 days of stochastic work arrival, energy variation, theme rotation, content-buffer depletion, and deadline ticking, under four policies (DailyFlowScore, by_value, by_deadline, random) and measure missed deadlines, cumulative weighted value, and content stockouts, averaged across 60 seeds.

The dollarized re-run. For the dollarized revision we re-implemented the model in a second stdlib-only, deterministic harness (flowscore_v2_pressure_test.py), leaving the validated v1 harness untouched. Six families port directly into dollar units; four are new, and three of those are adversarial probes aimed squarely at the two new mechanisms:

• Elapsed-time decay shape. Confirm decay_press is monotone in days-since, steepest in the day-10–35 window, and plateaus rather than diverging; and confirm a non-susceptible task is invariant to elapsed time (the no-double-count probe).
• Rate-preservation (adversarial). Confirm ranking by the rate-based score picks the faster-bleeding task, while ranking by the cumulative dollar-days picks the wrong one, proving the §3.2 invariant is necessary, not decorative.
• Elapsed-time rescue. Confirm a susceptible no-deadline task that loses to a higher-value rival when fresh is pulled into the plan once neglected, and that an otherwise-identical non-susceptible twin is not rescued, isolating susceptibility as the cause, not mere time.
• Horizon crossover. Confirm a recurring annuity loses to a one-off at 6 months, wins at 5 years, that the crossover lands in the 12–24 month band, and that horizon selection re-ranks (the order flips) rather than merely rescaling.

Why outcome simulation is the decisive test. Invariants and degenerate-safety are necessary but not sufficient. A score can satisfy every monotonicity invariant and still produce worse schedules than a one-line heuristic. Indeed, the broken greedy packer of Section 5 passed every monotonicity check while stranding the most valuable task. The only test that distinguishes a meaningful number from a merely plausible one is whether following the score actually yields better outcomes than the naive alternatives, measured on the outcomes the operator cares about: kept commitments and delivered value. Outcome simulation is therefore the arbiter; the invariants are guardrails.

5. Results

5.1 The naive formulation failed twice

The pressure test found two real defects in the naive “take by score until full” model.

Defect 1, greedy stranding (motivates F1). With by-ratio greedy packing on a low-energy day (capacity 2.0 h), admitting a small task first consumed the budget and stranded the single highest-value due-today item. In Test 4 the optimal knapsack realizes 17.0 CoD units against greedy’s 5.5 on the same backlog and capacity. Across 300 random days (Test 7), greedy’s realized value averages 0.969 of optimal with a worst case of 0.503 (i.e., on a bad day greedy delivers barely half the achievable value), and the optimal strictly beats greedy on 98 of 300 days. Greedy-by-ratio is an unsafe packer; F1 (DP knapsack) removes the stranding.

Defect 2, global buffer-burn promotes nothing (motivates F2). A global, day-wide buffer-burn multiplier raises every task’s score by the same factor and therefore changes no ranking; the make-up task is never promoted. Re-attaching burn to the affected arc (F2) makes the content make-up task enter the plan precisely when its arc’s buffer depletes, while leaving unrelated tasks untouched (Test 5: the admin task’s score is identical with and without content-arc burn).

A third correction (F3, commitments-first) was an operator-supplied design requirement rather than a discovered defect: due dates must be honored as first-class commitments alongside buffers, with explicit overcommitment flagging.

Two failures observed on later test iterations were ultimately test-logic bugs (mis-specified invariants), not equation bugs; distinguishing the two honestly is part of the method.

5.2 The corrected model passes 25/25

After F1–F3, the full battery passes 25/25 checks, EXIT OK. Representative figures from the run:

• Units (Test 1): CoD = 5.40 (Value 6.0 × Theme 0.90), urgency = 1.62, Effort = 2.00 → score 4.38 = “≈ 4.4 weighted-value-points per scarce hour.”
• Degeneracy (Test 3): tiny 0.01 h chore scores 4.0 (bounded by the 0.25 h floor) and does not outrank a real 2 h high-value piece (6.7).
• Monotonicity (Test 2): off-theme score 0.72 vs on-theme 2.89, reduced but non-zero.
• Deadline rescue (Test 6): the same low-value task scores 1.20 → 1.22 → 1.45 → 2.16 → 3.07 as its due date moves from 30 → 15 → 7 → 3 → 1 days out: strictly monotone.
• Cascade (Test 4): full-energy capacity 4.40 h does {arc-post, invoice, research}; low-energy capacity 2.00 h does {arc-post}; the unfittable imminent commitment {invoice} is flagged, not dropped.

5.3 The dollarized re-run passes 34/34

Re-running the battery in dollar units, with both new mechanisms live, passes 34/34 checks, EXIT OK (identical across repeated runs). The headline result is the units:

• The score is now a dollar figure (Test 1). A content task with cod_per_week = $600, ThemeFit 0.90, due in 4 days, 2.0 h effort yields a CoD rate of $540/wk, urgency 1.62, and score = $438 per focus-hour, read as “buys down ≈ $438 of weekly Cost of Delay per scarce hour.” The abstract “4.38” is gone.
• Elapsed-time decay behaves as designed (Test 3). With S = 1, decay_press rises 0.14 → 0.27 → 0.48 → 1.14 → 1.84 → 1.99 → 2.00 at days-since 0, 5, 10, 20, 35, 60, 90, then is flat. The slope across day-10–35 (0.054/day) far exceeds day-90–180 (≈ 0): concentrated in the empirical window, then plateaus at k_decay·S = 2.0. A non-susceptible task (S = 0) is bit-for-bit invariant to days-since (no double-count confirmed).
• Elapsed-time rescue (Test 7). A susceptible workout (no deadline) that loses to a higher-value rival when fresh is pulled into the plan once neglected 28 days; an identical non-susceptible twin is not. Reported honestly, the rescue operates within the discretionary tier: neglect does not, and should not, let a $77/focus-hour habit displace $600/focus-hour committed client work.

5.4 Rate-preservation: the dollarization does not break CD3

Test 5 (adversarial). Task A bleeds $1,000/week (fresh); Task B bleeds $50/week but has been late 80 days. The rate-based score ranks A first ($1,000 against $50 per focus-hour), which is correct, since A loses value 20× faster. Ranking by cumulative dollar-days ranks B first (571 against 143 dollar-days), which is wrong. The invariant of §3.2 is therefore necessary, not decorative: keep CoD a rate, or the ranking inverts. This is also the formal justification for keeping the horizon lens separate from the daily score.

5.5 The horizon re-ranks, with an 18-month crossover

Test 9. The harness’s $1/day annuity PV reproduces the verified reference values (6mo $179, 1yr $353, 3yr $991, 5yr $1,548 against literature $174/$342/$958/$1,526). A $5/day habit against a $2,560 one-off: at 6 months the one-off leads ($2,560 against $895); at 5 years the habit leads ($7,741 against $2,560). The crossover lands at 18 months, and the two tasks’ order flips between the 6-month and 5-year horizons. The horizon is a genuine strategic lever: a short horizon favors big one-offs, a long horizon favors cheap daily compounders. (The widget below the paper lets you watch the crossover move.)

5.6 The 30-day Monte Carlo (dollarized) still dominates

Averaged across 60 seeds, with the elapsed-time decay term live for a standing habit and content arcs (lower is better for missed deadlines and stockouts; higher is better for value, now in dollars):

DailyFlowScore passes all four outcome checks: it misses far fewer deadlines than by_value (0.17 vs 2.92), delivers more dollar value than by_deadline ($18,974 vs $17,692), beats random on both axes, and keeps the content buffer healthiest (0.32 stockouts). The dollarization and the two new mechanisms preserve, and slightly sharpen, the balanced-optimum result of the original abstract run (0.15 / 196.2 weighted-value units).

5.7 Honest interpretation of the value–deadline trade-off

We report the one place DailyFlowScore is not the strict winner. by_deadline misses marginally fewer deadlines (0.07 vs 0.17), unsurprising, since it optimizes for exactly that single objective. But it does so by sacrificing value: it delivers the least dollar value of any non-random policy ($17,692), because it will always service a low-value imminent task ahead of a high-value one. Symmetrically, by_value maximizes nothing useful: it misses 2.92 deadlines per month (roughly one blown commitment every ten days) because it is blind to urgency. DailyFlowScore is the balanced optimum: it accepts ≈ 0.10 additional missed deadlines per month relative to the deadline-obsessed policy in exchange for +$1,282/week-equivalent of value and a healthier production buffer. For an operator whose reputation depends on both keeping commitments and shipping work that matters, this balance, not either single-axis extreme, is the objective; dollarizing the value axis simply makes the trade legible in currency.

5.8 Sensitivity / tornado analysis

A one-at-a-time (OAT) sensitivity analysis (flowscore_sensitivity.py, 50 seeds) varied each model constant across its plausible operating range and measured the swing in a composite outcome (weighted value, penalized for missed deadlines and stockouts). The ranking is unambiguous and on-thesis:

The operator’s deep-work attention budget (DrumHours) dominates every other knob by roughly a 7× margin on the composite objective. Expanding attention from 3 to 5 hours per day removes ≈ 2 missed deadlines per month and adds ≈ 13 weighted-value units, more than all scoring-parameter knobs combined. This is a direct empirical corroboration of the paper’s central framing: the binding constraint is the operator’s attention, and the highest-leverage intervention is to protect and expand it, not to re-tune the score’s weights. The day’s theme floor is a real but secondary lever (it governs how much off-theme work is admitted); the remaining constants are near-inert within their tested ranges and may be treated as defaults.

The finding is load-dependent. The near-inertness of the deadline- and buffer-pressure constants (k_due, k_buf, commit horizon) partly reflects the simulation’s moderate deadline density; under tighter commitment load these levers would carry more weight. The analysis is also OAT rather than global, so it does not capture knob interactions. A variance-based global sensitivity analysis (e.g., Sobol indices) under a realistic load profile is future work. It also predates the dollarized revision: the three elapsed-time constants (k_decay, d_mid, d_scale) and the horizon discount rate r have not yet been put through any sensitivity analysis, and their values are defensible defaults, not tuned optima.

6. Discussion

What makes DailyFlowScore actionable rather than arbitrary is the conjunction of five properties, each verified above.

Fixed units. The score is not a unitless index; it is dollars of Cost of Delay bought down per attention-hour. The operator can state what a score means in isolation (“$438 per focus-hour” needs no personal trend) and compare two scores as a ratio.

Decomposability. Every score reduces to named drivers (value, theme fit, urgency, effort), so the operator can answer “why is this ranked here?” and intervene on the responsible input. This is the MCDA “tweak-a-weight-see-the-impact” property [17] the operator explicitly wanted.

Monotonicity. Each input moves the score in the intuitively correct direction, so the operator’s mental model and the math never diverge, a precondition for trust.

Degenerate-safety. The effort and theme floors are not cosmetic; they are the guards that prevent a trivial chore from hijacking the day and prevent an off-theme task from permanent starvation.

Empirically superior outcomes. The score beats all three naive heuristics on the outcomes that matter, which is the property that elevates it from plausible to meaningful.

DailyFlowScore also operationalizes the operator’s strategic question (“are we doing the things that matter?”) through two channels. The ThemeFit term ties each day’s ranking to that day’s strategic mode (delivery vs. improvement), so “what matters today” is encoded structurally. The commitments-first rule with overcommitment flagging operationalizes “are we keeping our promises?”: imminent commitments are honored before discretionary optimization, and when capacity cannot cover them, the system raises a visible flag rather than failing silently. The juggling the operator previously did by hand (move, cancel, keep) becomes the output of the function: change one number (a morning energy rating, a value estimate, a due date) and the whole plan re-ranks. The human’s residual job shrinks to the 60-second morning rating, occasional weight/theme setting, and approving the move/cancel/keep proposals the arithmetic produces.

What dollarization added. The original argument was that an underspecified prioritization formula cannot be tested; the dollarized revision makes a companion point: an un-denominated one cannot be read. Putting real dollars into the driver did three things at once. It removed the calibration friction a reader named: “$438 per focus-hour” needs no personal trend. It made two new mechanisms expressible, because “what does a week of neglect cost?” and “what is this worth at a five-year horizon?” are only answerable once value is money. And it forced a discipline (the rate invariant) that the abstract version could quietly violate without consequence. Both new mechanisms are kept honest by that invariant: neither may smuggle a cumulative into the daily ranking, which §5.4 proves would invert it. As with the original two failures, we did not assert the elapsed-time term works; we built a probe that tries to make it misbehave, and reported that our first rescue test was mis-specified (it pitted a $77/focus-hour habit against $600/focus-hour committed work, a contest neglect neither does nor should win) before we corrected it. The act of trying to break a mechanism is what tells you what it actually does.

7. Limitations & Future Work

We state the limitations plainly; the model’s credibility depends on it.

Dollar-rate elicitation is still unvalidated. Denominating the driver in dollars removed the “unitless index” problem, but the model now needs a dollar rate, not just a ratio, and we have not validated that an operator can reliably produce one. “Be brave,” the reassurance that an estimate off by 2× still ranks correctly because real backlogs span 10:1–50:1, is a reassurance, not a protocol. A structured CoD-elicitation workflow (best question: “what does it cost us per week to wait?”, loss-framed) remains future work.

The decay curve is extrapolated. No peer-reviewed dose-response exists for habit/content “cost of inaction.” The logistic shape and the day-10–35 steepest window are extrapolated from detraining [27] and the abstinence-violation literature [29]; k_decay, d_mid, d_scale and per-task susceptibility S are defensible defaults, not measured constants. A single-subject calibration is the obvious next step.

The discount rate is personal and uncertain. The horizon lens uses a 7%/yr personal discount rate; empirical personal rates run 10–30%+. The 18-month crossover is a function of the assumed r and the chosen one-off magnitude, and should be presented as a tunable lever, not a universal constant. We deliberately excluded motivational “compounding” heuristics from the dollar math.

Dollar anchors are population averages. The per-domain cod_per_week figures for non-revenue work (health, learning, content) are population averages with wide ranges and selection caveats; they belong in the tool as editable defaults, not fixed truths.

Simulation assumptions and external validity. All quantitative outcome evidence comes from a synthetic Monte Carlo with N=1 (one simulated operator), stochastic but modeled work arrivals, idealized buffer dynamics, and the assumption that the operator perfectly executes the plan the score proposes. Real arrivals are bursty and correlated; real execution is imperfect. The simulation establishes that the score is internally sound and dominates naive policies under its own model; it does not establish real-world effect sizes.

Sensitivity is one-at-a-time and load-dependent. The OAT tornado of §5.5 identifies DrumHours as the dominant lever and most scoring constants (the capacity weights 0.6/0.4, the bounds 0.4/1.1, k_due = 2.0, k_buf = 1.5, the exponential decay constant 3.0, the late-penalty slope and cap, the two floors) as near-inert at the simulated load. It is not, however, a global variance-based analysis (e.g., Sobol indices) and does not capture knob interactions, and its conclusions are conditioned on the simulation’s moderate deadline density; under tighter commitment load the deadline- and buffer-pressure constants would matter more. The configuration values should accordingly be treated as load-specific defaults, not universally tuned optima.

Synthetic capacity input. CapacityScalar currently consumes a self-reported sleep/mental rating. Integrating real biometric inputs (WHOOP or Oura recovery scores [14]) would replace a subjective rating with a measured one and enable the learned personal coefficients (e.g., “under 6.5 h sleep → −40% capacity”) that the Make Time Reflect loop [1] and Quantified Self practice [23] envision.

Human-subject validation. The decisive next step is a single-subject (or small-N) field trial: deploy the score for a real operator over a quarter, log proposed vs. executed plans and realized outcomes, and compare against the operator’s pre-deployment baseline. Only that can convert “dominates naive policies in simulation” into “improves a real operator’s kept-commitment and shipped-value rates.”

8. Conclusion

We set out to determine whether a single scalar can be both interpretable and outcome-superior for the attention-constrained solo operator, and then whether it could be denominated in dollars without sacrificing that superiority. The answer to both is a qualified yes. DailyFlowScore (a WSJF/CD3-shaped cost-of-delay score, gated by an energy-aware capacity scalar and pressured by CCPM per-arc buffer-burn) decomposes into named, fixed-unit drivers, behaves monotonically, is safe on degenerate inputs, and dominates value-greedy, deadline-greedy, and random heuristics on the balanced objective of keeping commitments while delivering value. Replacing the abstract Value with a $/week Cost-of-Delay rate makes the headline a dollar figure, “$438 per focus-hour,” readable without any personal trend. A logistic elapsed-time decay term makes urgency rise with neglect (flat, then steep, then plateau), rescuing a susceptible no-deadline task from starvation while provably not double-counting or touching tasks that do not rot. A separate multi-horizon NPV lens re-ranks recurring annuities against one-offs, with an 18-month crossover. All of it holds together only because Cost of Delay is kept a rate, a constraint we proved necessary by showing, in-harness, that the cumulative inverts the ranking. The re-run battery passes 34/34, and the dollarized 30-day Monte Carlo again dominates the naive heuristics ($18,974 weighted value at 0.17 missed deadlines). The qualification remains essential: the naive formulation failed, and only the corrections (optimal-knapsack selection, per-arc buffer-burn, commitments-first scheduling, and the rate invariant) made it actionable. The lesson generalizes: an underspecified formula cannot be tested, an un-denominated one cannot be read, and the discipline that makes a number legible (keeping the rate a rate) is the same discipline that keeps it correct.

References

Verification key: ✓ = URL independently fetched and spot-checked during the source synthesis; (canonical) = canonical-domain source retrieved by research agents but not independently re-fetched.

1. J. Knapp and J. Zeratsky, Make Time (Highlight·Laser·Energize·Reflect). Summary ✓
2. Asana, “Critical Chain Project Management” (project & feeding buffers). asana.com ✓ (fever charts not on this page)
3. Epicflow, “Bubble Graph / Critical Chain Fever Chart Re-imagined.” epicflow.com (canonical)
4. Tameflow, “How to Draw Buffer Fever Charts.” tameflow.com (canonical)
5. Scaled Agile Framework, “WSJF = Cost of Delay ÷ Job Size.” framework.scaledagile.com ✓
6. J. Arnold, “Cost of Delay Divided by Duration (CD3).” Black Swan Farming. blackswanfarming.com (canonical)
7. D. G. Reinertsen, The Principles of Product Development Flow. Talk summary (canonical)
8. D. H. Pink, When: The Scientific Secrets of Perfect Timing (chronotypes). Summary (canonical)
9. J. Loehr and T. Schwartz, The Power of Full Engagement (four energy dimensions). fs.blog (canonical)
10. A. Huberman, ultradian 90-minute focus blocks (after N. Kleitman’s basic rest–activity cycle). hubermanlab (canonical)
11. E. M. Goldratt, “Theory of Constraints for Personal Productivity” (TOC Handbook, ch. 38). toc-goldratt.com (canonical)
12. J. Dorsey, themed working days. CNN Money. money.cnn.com (canonical)
13. C. Newport, Deep Work (rhythmic scheduling philosophy). (book)
14. WHOOP, “How Does WHOOP Recovery Work?” (recovery → workload). whoop.com (canonical)
15. Intercom, “RICE: Simple Prioritization for Product Managers.” intercom.com (canonical)
16. Forte Labs, “Theory of Constraints 106: The Five Focusing Steps” (and TOC 105: Drum-Buffer-Rope at Microsoft). fortelabs.com (canonical)
17. airfocus, “Weighted Decision Matrix for Prioritization” (weights re-rank the list). airfocus.com ✓
18. J. Benson and T. DeMaria Barry, Personal Kanban (WIP limits). personalkanban.com (canonical)
19. G. McKeown, Essentialism: The Disciplined Pursuit of Less (90% rule). goodreads (canonical)
20. G. Keller and J. Papasan, The ONE Thing. goodreads (canonical)
21. O. Burkeman, Four Thousand Weeks: Time Management for Mortals. wikipedia (canonical)
22. J. Doerr, Measure What Matters (OKRs). (book)
23. Quantified Self / Personal Science (N=1 learning loop). quantifiedself.com (canonical)
24. “Dollarizing DailyFlowScore: TOC dollar-days, cross-domain $ values, urgency-with-delay, and multi-horizon valuation.” Companion research report (extensive mode, sources verified). (internal)
25. E. Schragenheim, “Throughput-Dollar-Days (TDD) and Inventory-Dollar-Days (IDD): the value and limitations.” elischragenheim.com ✓
26. M. Gupta et al., “Throughput/Inventory Dollar-Days,” International Journal of Production Research 56(13), 2018. EconPapers ✓
27. Detraining and cardiorespiratory/strength loss (systematic review). PMC, 2023. PMC10853933 (canonical)
28. P. Lally et al., “How are habits formed” (median 66 days; a single miss does not impair formation). Eur. J. Soc. Psychol. 2010; summary Scientific American (canonical)
29. G. A. Marlatt and J. R. Gordon, the Abstinence-Violation Effect; behavioral-economics toolkit on loss framing. NCBI NBK593511 (canonical)
30. Net Present Value and the annuity formula PV = B·[1−(1+r)^−n]/r. Wikipedia (canonical)
31. A. Damodaran, time-value mechanics; empirical personal discount rates. stern.nyu.edu (canonical)
32. J. Clear, “Continuous Improvement” (1.01⁷⁶⁵ as a directional leverage heuristic, explicitly NOT NPV). jamesclear.com (canonical)