# The factory > The factory is the public measurement store for Desk, a plugin that gives coding agents a durable desk of tracks and tasks. It measures agentic work the way Lean measures a factory floor: where each task's time went, which part added value, and which part was waste. It names no person, no machine and no content: the only calendar facts are each task's finish day (UTC), times on a task's own clock, and pull request times from GitHub. This file indexes the data behind every view, for agents. Site: https://ourostack.github.io/factory/ Source and raw data: https://github.com/ourostack/factory (the `reports` branch holds the built reports) ## How to walk it The site walks the four steps Lean uses to see waste, in this order. Read the data in the same order. 1. Follow a task (`#/task/`): one real task end to end, and where its time went. `#/` opens on the latest-finished task that has something to teach and waste labels, named or private. In `data.json` `jobs[]`: of the tasks whose `status` is `done` or `cancelled` and whose `finish_date` has a `value`, keep those whose `lead_time_ms` is measured, or partial with `bound: "lower"`, at 3600000 ms or more; whose `active_time_ms` is measured, or partial with a value, at 300000 ms or more; `map_bursts` has a value of 1 or more and is not `unavailable`; `human_turns` has a value of 1 or more; and `waste.sessions_labeled` has a value of 1 or more (the task has evaluator waste labels). Open the one with the latest `finish_date.value`. The store knows no order within a day, so tasks with the same day are a tie, and a tie goes to the larger `lead_time_ms.value`. If no task qualifies, the label condition is dropped; if still none qualifies, the page opens the latest-finished task whose `lead_time_ms` is measured, or partial with `bound: "lower"`, at 3600000 ms or more (ties the same way), then the latest dated finished task, then the finished task with the largest `finish_order`. The page says which rule chose the task and why the finished tasks after it in finish order were skipped. `map_bursts` counts the work bursts the task's map draws: `unavailable` when Desk could not tell the bursts, so the map draws none. 2. Compare tasks (`#/compare`): every task side by side on one scale, as a stack-up of working time by label and waiting by cause, in hours of all elapsed time (`?mode=all`), hours of agent working time only (`?mode=working`) or each task's shares of its own lead time on a 0 to 100% axis (`?mode=share`), with each finished task's finish day (UTC) under its bar. Its "Over time" section reads `rollups/by_week.json` and opens with the base it covers (how many finished tasks and lead-time hours are dated) and how many of their finish days are exact, "on or before", "on or after" or of no known direction; it claims a change between two weeks only when no bounded finish day could fall into either: every task in them has an exact day, no "on or before" day lies in them or a later week, no "on or after" day in them or an earlier week, and no day lacks a direction; otherwise it says there are not yet enough exact finish days to compare. It shows, newest week on the right: "By week" (`?over=week`, the default), one stacked bar per finish week in the stack-up's colors, as each week's shares of its own lead time (`?otmode=share`, the default, so a week of 5 tasks and a week of 1 compare), hours of all elapsed time (`?otmode=all`) or hours of agent working time (`?otmode=working`); "Each task" (`?over=task`), the stack-up's dated tasks in finish order in the same modes; a cause × week table (rows are causes, largest first; columns are finish weeks; each cell its hours or share with a bar on one stated scale, and ≥, ≤ or ~ for a partial figure), which scrolls inside its frame, opened at the newest week; flow efficiency by finish week, each task as a dot when measured or as the range its partial value may lie in, with each week's median; and a table of the weeks, newest first. Each week header says how its tasks' days lean, and a week whose tasks may belong to an earlier or later week says so. A finished task with no finish day is counted in one line with its hours, listed behind it with its reason, and never placed on a guessed date. 3. Rank causes (`#/causes`): causes of waste ranked by the time they cost, in a Pareto chart; each cause has its own page (`#/causes/`, for example `#/causes/waiting:next_prompt`) with its tasks, its stretches and a prompt that starts an A3, or, when a kaizen issue already works on that cause, a link to it and a prompt to check or extend it. 4. Act (`#/act`): the problems taken on (kaizen issues, `data.json` `kaizen_issues`), each with its countermeasure, its cause where the site maps one (`kaizen_issues[].cause`), and its check, and the issues that own the status line's alarms. Reference pages: `#/why` (why Lean, the eight wastes and a glossary), `#/about` (how the data gets here and the privacy rules), `#/store` (everything else the store measures). ## Reading the numbers Every number is an object `{ state, value?, reasons }`. `measured` is the whole figure. `partial` is part of it, and `bound` says whether the true figure is higher (`lower`) or lower (`upper`); when the direction is not known, `data.json` says `unknown` and every file under `rollups/` and `map/`, Desk's and the store's, says `null`, with `bound_reason` giving why where Desk states it (`reasons.json` has its words). `unavailable` means not measured: its value is absent or null, and it is never zero. `reasons` are codes; `reasons.json` gives the words the page shows for each. `data.json` gives `bound` on every partial figure. So does `rollups/causes.json` (1). The rollups give it on only some: `rollups/tasks.json` on 1417 of its 1451 and `rollups/stackup.json` on 1128 of its 1162. Where the key is absent, the file does not say which way the figure is off, so do not assume one; the store does not add a direction Desk did not state. For a task's figures, read the direction from `data.json` `jobs[]`, or work it out: idle time is lead time minus working time, so a working time that is a lower bound makes idle time an upper bound, and a lead time that is a lower bound makes it a lower bound. A rollup also carries `n` of `N` and what it counts. Every task has a `finish_date` (`data.json` `jobs[]`, and on each row of `rollups/tasks.json` and each file under `map/`): `{ state, value, basis, bound?, reasons }`, whose `value` is the UTC day the task finished ("YYYY-MM-DD"), never a time of day. `basis` says where the day comes from, and the first source that gives one wins: `desk_transition` (Desk's record of the day the session moved the card to done or cancelled, measured), `desk_card_updated` (the day the card was last updated, so the task finished on or before it: `partial`, `bound: "upper"`), `pr_anchor` (the task's pull requests tie its clock to GitHub's `created_at` for them, and the day is that anchor plus the end of the task's lead window: the anchor is the one that places pull request times on the map: measured when a pull request the session opened sets it or several agree; `partial` with `bound: "lower"` (the task finished on or after the day) and reason `anchor_unconfirmed` when nothing confirms the pull requests it rests on; when they disagree, `partial` with reason `anchor_spread`: with `bound: "lower"` and the added reason `anchor_unconfirmed` when the anchor rests on timed pull requests the session is not known to have opened (each of them is at or before the true start), and with no direction when pull requests the session opened disagree; when the task's lead window is partial only because the card's dates are shorter than the work, the day is that of the last recorded work, `partial`, `bound: "upper"`, reason `finish_from_last_work`; any other partial window gives reason `lead_window_partial` and no direction), `labels_landed` (the UTC day the task's waste labels first landed in the store, so the task finished on or before it: `partial`, `bound: "upper"`, reason `finish_from_labels_landing`; if the task's pull requests put its finish after that day and that anchored day is not itself an "at most" day, the labels day is shown as `partial` with no direction and reason `anchor_after_labels`, because the two disagree (two "at most" days do not disagree: the earlier one, the labels day, stands as `bound: "upper"`); when GitHub could not be read for the anchor, the labels day also carries the reason, for example `github_unreadable` or `github_lookup_capped`). A task still open has no finish day (`open_job`), a task whose status could not be read has `status_unavailable`, a desk that withholds job timing has `job_offsets_withheld`, and a finished task no source gives has `no_finish_source`. Tasks are ordered by `finish_order`: by `finish_date` value, earliest first; ties, and then finished tasks with no date, by the order in which each task's first waste labels landed in the store; open tasks and tasks whose status could not be read last, by their first facts file. In `rollups/` and `map/`, a finish day whose reasons pull both ways (an "at least" anchor and an "at most" last-work day) has `bound: null` and `bound_reason: "bound_reasons_conflict"`. `finish_basis` is `labels` for a task with labels, `date` for a dated task with none yet, and `facts` for the rest. Tasks whose labels landed in the same commit share a `finish_group` and are ordered within it by lead time, so the longest of them takes the latest position. A task's `name` is the title of its earliest-opened public pull request, or null for a private task; `name_basis: "partial"` (in `data.json`) means some of its pull requests could not be read, so an earlier one may exist. The store adds `name`, `finish_order`, `finish_group`, `finish_basis` and `finish_date` to every row of `rollups/tasks.json`. `rollups/by_week.json` (`factory.site.by_week/1`) counts each finished task in the ISO week (UTC, Monday first) of its `finish_date` (`basis: "by_finish_week"`); every week from the first finished task to the last is listed, and a week with no finished task is `{ n: 0 }`, never zero hours. Each sum is a stated number, and `n_partial` counts the tasks in a week that rest on a partial figure. A sum of members whose directions agree takes that direction, and a missing member makes it "at least"; a member whose `bound_reason` is `bound_not_moved` is exact and adds no direction to a sum, while one with any other `bound: null` makes the sum `bound: null` too. `n_unsplit` counts a week's tasks whose time does not split into working and waiting yet (no working time), and `unsplit_reasons` gives why; their hours are in the week's `lead_ms` and in no cause, so a cause's zero in such a week is only "at least", and the page says "not measured for k" instead of "≥0". Every week, empty or not, counts its tasks' finish days: `n_day_measured` (exact), `n_day_on_or_before` (`bound: "upper"`, so a task may have finished in an earlier week), `n_day_on_or_after` (`bound: "lower"`, perhaps a later week) and `n_day_about` (no direction); the four add up to `n`, which equals the length of `jobs`, and each matches the week's tasks' own `finish_date`. A share of a week's lead time carries its own direction, worked out from its part and the lead time: a partial part over a partial lead time has no direction unless the two lean so the ratio provably does. A week's flow efficiency median is over the finished tasks with a flow efficiency figure (`n` of `N`): measured when every figure is; when partial figures all lean one way, the median of the known values is a bound in that direction (for example at most 43%, 4 of 5 tasks); when they lean both ways or have no direction, it is the median of the exact figures only with reason `median_of_subset`, or unavailable with `bound_reasons_conflict` when no figure is exact. A finished task with no finish date is under `unplaced`. "Waiting" means idle time only: lead time minus working time, when no agent was working on the task. It is split by what it waited on (`waited_on`): `next_prompt` (the agent had stopped for the operator's next prompt), `other_task` (a session of the task was running, but its agent was working on another task; the other task is never named), `api_retry`, `tool_failure`, `long_tool_call`, `queue_before_start`, `no_session` (no session of the task was running) and `unknown` (no agent was working on the task, and the cause was not recorded). A gap's `waited_on` is its largest cause; where Desk gives `gaps[].idle_by_waited_on_ms`, that is the gap's exact split. The evaluator's labels (value-adding, necessary, each waste) describe working time only. Waiting for the next prompt is split by why the agent stopped (Desk's reports; each key is absent until Desk publishes it, and the page then shows that waiting unsplit and says why is not known yet, never a zero split). The classes, in the order the page stacks them: `stopped_short` (the agent ended its turn although its authorization covered the next step and nothing blocked it), `question` (it needed information only the operator has), `error_limit` (an API error, a rate or usage limit, an output cap or a refusal), `interrupted` (the operator interrupted it), then the human gates `decision`, `approval` and `acceptance`, then `not_known`. Each wait on the operator is listed in `jobs/.json` `timeline.waits[]` and `map/.json` `waits[]`: `{ session, start_ms, end_ms, next_prompt_ms, stop: { end, asks, pending_agents }, why, why_source, confidence, reasons }`, where `stop` holds the mechanical facts of how the turn ended (never any text), `why_source` is `rule` (decided from `stop.end`), `evaluator` (the evaluator's stop label) or `none`, and `reasons` say why a `not_known` why is not known: `not_labeled`, `could_not_tell`, `stop_not_recorded` (no recorded wait holds the time), `outside_own_share` or `not_in_published_facts` (older facts record no stop). A prompt joins the wait it ends by session and `end_ms == at_ms`, and `map/.json` `human_turns[].why` carries it. `gaps[].idle_by_why_ms` and `bursts[].idle_by_why_ms` split each item's next-prompt idle time by why; `rollups/tasks.json` rows carry `next_prompt_by_why_ms` (each class, and `not_known`, a stated number) and `not_known_by_reason_ms`, which together add up to `waiting_by_waited_on_ms.next_prompt`; while any of it is not known each class is partial, `bound: "lower"`, reason `stop_partly_classified` (at least this much; at most this plus the not-known time). Each stack-up row (Compare tasks) carries `next_prompt_by_why_ms` too, and `longest_gap.value.why` names the why that holds most of a task's longest wait. In `rollups/causes.json` the row `waiting:next_prompt` gains `children[]`, its sub-causes `waiting:next_prompt:` with `parent: "waiting:next_prompt"`, which add up to it and are never ranked beside it; each has its own page, `#/causes/waiting:next_prompt:` (for example `#/causes/waiting:next_prompt:stopped_short`), listing every such wait from the tasks' map files with its stop facts, source and confidence, and a prompt that starts an A3. The Pareto chart stacks the `waiting:next_prompt` bar by why ("Split by why", on by default). ## Data files ### Connected process learning `data.json.learning` and `rollups/learning.json` are the identical, validated `factory-learning/1` object. `learning.js` publishes the pure browser `FactoryLearning.buildLearning({data,causes,history,checks})` and `FactoryLearning.validateLearning(doc)` interfaces; CommonJS exports the same functions. `history` is `{by_week,evidence}`: `by_week` is the existing `factory.site.by_week/1` builder output, and `evidence` contains only public `{job,timeline:{waits,agents}}` inputs. No comparison or grouping is rerun. The legacy `data.overview`/`rollups/overview.json` contract remains separate and unchanged. The existing UI has not yet migrated to this new projection. - `sources.reports` identifies the report generation; `sources.checks` retains the independent Desk/facts/reports revisions supplied by the canonical checker. `alignment:"same_reports"` means only the report revisions agree, not that facts, issues and reports were captured together. Different or unavailable report generations limit the overview conclusion. - `scope.outcome_records` and `accepted_outcomes` come from the full `outcomes.signoff` population, including outcomes without timed work. `task_reports` counts `data.jobs` rows; `timed_tasks` counts those with a recorded-window figure. Neither is the accepted-outcome denominator. `attention` and `attention_turns` retain the canonical sample `n`, accepted denominator `N`, state, direction and exclusions. No attention ratio is reported beside zero accepted outcomes. `capture` and `first_pass_yield` retain their own distinct populations and uncertainty. - `overview` gives one supported conclusion, `finding` and `improvement` references when available, material `limits` and an explicit safe `href`. No data means `code:"evidence_unavailable"`, not an all-clear conclusion. - `findings` is bounded to 24 public cause rows, including explicitly reported next-prompt sub-causes. Each carries a stated `figure`, `population`, `affected_tasks`, up to six representative `examples`, source JSON paths and a deep destination. Its population `n` is the finished, fully labeled jobs with readable intervals counted by the cause builder; `N` is all considered records, including excluded/open jobs. `basis:job_hours` in the source means task exposure, not unique factory time or utilization. Waiting observations, evaluator-classified waste, unclassified work and reported stop classifications stay distinct. A tool-kind suffix identifies the evidence for a defect label; it never identifies a production stage. Classification is not proof of avoidability. - `behaviors` asks about review/repair, human stops and team coordination. Recorded return counts retain catch-point/sample limits, not a count of complete review cycles. Their `by_reason` figures keep agent error, changed ask, new information and external causes separate; a changed ask is not automatically corrective waste. Stop `observation` is the host's end/asks/pending facts; `judgment` separately retains actual why/source/confidence/reasons. Older facts with no recorded host stop preserve `observation:null`; this does not erase a separately recorded judgment or invent host facts. Never infer one from the other. Team root/child counts are published topology, not task-exclusive worker allocation. Stage and coordination `duration` remain unavailable; each question states its `missing_observation` and owning `collection_path`. Examples are bounded, not a census of events. - `evolution.versions` retains every available canonical release grouping, including `mixed`, with each measure's population. `evolution.weeks` preserves all available finish weeks, their time/class/waste figures, task points, bounded finish dates, empty weeks, unsplit tasks and `unplaced` jobs. Its weekly `production_ms` is unavailable: `lead_ms` is the distinct recorded window, never a substitute production clock. Task mix, shared workers, changed capture and bounded finish dates prevent a before/after causal claim. No history is interpolated. - `improvements` summarizes the canonical `data.improvement_checks` (`factory-improvement-checks/1`). Each row links its exact `source_path` there and retains `card`, `sample_jobs`, exclusions, before/after jobs, independent groups, median states, change and interval with capture bounds. A missing median is unavailable; an observed zero is measured or partial zero. The interval is the canonical bootstrap interval, not a causal guarantee. A partial difference/interval has unknown capture bound. `status:"checked",verdict:"too_few_jobs"` is a completed **inconclusive** result in `section:"results_available"`; it is not a missing check. `waiting_for_version` and `no_check` are `awaiting_result`; malformed (`refused`) or unavailable checks remain explicit under `investigating`. Checked `confirmed`, `not_confirmed` and `no_clear_change` retain the hypothesis-relative results better, worse and no detected change. GitHub `issue_state` and `implementation.merged` are separate observations, never the measurement result or proof that a change helped. Only the producer's explicit public `kaizen_issues[].cause` mapping can connect a finding and an improvement (`association:"mapped_measure_only"`). These examples are not original triggering jobs; `original_evidence` is `not_published`. Unknown public/private review associations are not guessed. No issue bodies, titles, prompts, local paths, session associations or private decision prose are copied into this projection. Handoffs identify `file:"rollups/learning.json"`, an exact JSON selector, a safe existing local `href` and `authority_limit:"inspect_only_no_new_authority"`. For example, inspect `$.findings[?(@.id=="waiting:next_prompt")]`, its example's `map_path`, `start_ms`/`end_ms` task offsets and `source_path` in `rollups/causes.json`; then inspect the related improvement at `$.improvements.rows[?(@.ref=="ourostack/factory#53")]` and its canonical `data.json` check. A map's existing period selector must be resolved from that map, not invented from a source-list index. Routes currently point at the supported cause/task/compare/improvements destinations; no future UI route or execution authority is implied. The exact top-level `data.learning` subtree has a closed numeric/privacy validator: counts, populations, offsets, bounds, comparison conservation, source revisions, fixed text, enums and destinations are checked before publication. Unknown fields or invalid projections refuse publication without overwriting the last good twin. Other data and nested subtrees retain the ordinary number gate; there is no general numeric exemption. `validateLearning` returns `{ok:false,codes:["learning_projection_invalid"]}` without echoing rejected content. Browser consumers should withhold only the learning panel when validation fails, keeping unrelated views usable. ### Improvement annotations: inspect, do not execute `data.json.improvements` and `rollups/improvements.json` contain the same `factory-improvements/1` queue. This is a separate closed transport/presentation contract, not a stated measurement: bounded integer counts are known only under `coverage.state:"known"`; unknown coverage has null counts. The exact top-level queue is validated separately by the maintained numbers gate. Other measurements retain the stated-number rules above. No batches means `state:"not_reviewed"`. Highest revisions win; equal-revision or shared-public-issue conflicts remain explicit. Omission is never withdrawal. Publication freshness is at most 72 hours, not an exact review timestamp; incomplete/conflicting coverage is unknown, never summed across machines. `runner` is the publishing machine's own report of its triage runner, from the same newest fresh batch as coverage: `state` is one of Desk's runner states (`ran`, `no_agent_cli`, `timeout` and so on) and `last_success_age` is `recent`, `aging`, `stale`, `never` or `unknown`. It is `{state:"unknown",last_success_age:"unknown"}` with no single fresh source, with any invalid batch file, or when the newest batches of the one generation share a commit time and disagree about the runner. It is a coarse age, not a time, and a runner that ran says nothing about any one row. Rows carry `availability`, fixed `gate_explanation`, public `context`, specific `decision`/`recommendation`/`safe_continuation` availability, `next_action` and `handoff`. With no verified matching public context, decision details are private or not published. Current public issue/PR/job sources do not supply validated specific decisions or continuations: unavailable fields are `{state:"unavailable",reason:"detail_not_published"}`, never guessed from titles. Ownership not published is unknown. Known limit of this version: the store verifies no public context. A public issue, pull request or job report carries no revision the store can check against a pointer's revision, so the build passes no public evidence to the queue. Every row therefore reads `private_detail_not_published` or `stale_or_conflicting` and has an empty `context`, even when its evidence points at a public issue. `verified_public_context` is defined but not produced. The action is “Ask your linked agent to inspect the local annotation.” The handoff contains the public opaque annotation ID/revision and public basis/pointers, not a canonical card key or local path. Its authority limit is `inspect_only_no_new_authority`, even for stale/conflicting rows. Ask the linked agent to resolve the acknowledged ID on its own desk, inspect authorized local detail and bring a recommendation to the actual decision owner. Missing or stale resolution is an honest inability to resolve, not a reason to guess a card, publish private details, claim work or begin implementation. Paths are relative to the site. A file up to 256 KB is marked small enough to read whole. ## Connected process learning - rollups/learning.json (115 KB, small enough to read whole): the exact factory-learning/1 data.learning twin: one supported conclusion, bounded observation versus classification findings, task evidence and inspect-only handoffs, review/repair/human-stop/team questions, all available release/week history and canonical current improvement-check summaries; task exposure is not utilization and a merged change is not a measured benefit ## Start here: the whole site in one file - data.json (759 KB, large: read only the parts you need): every number on the page, each with its state (measured, partial or no data), reasons and, when partial, its bound; jobs[] holds each task's name, finish date and finish order; kaizen_issues (the problems in hand, each with the `cause` key it works on when one is known) and alarm_issues (who owns each alarm) are step 4, Act ## Factory briefing - rollups/overview.json (3 KB, small enough to read whole): the exact factory-overview/1 data.overview twin: attention, public claims, one investigation and explicit monitoring/review limitations; triage handoffs are inspection-only, not execution authority; automation is not demonstrated ## Reading the reasons - reasons.json (12 KB, small enough to read whole): every reason code a figure can carry (censored, log_truncated, card_dates_shorter_than_work, …) with the plain words the page shows for it ## Step 1, follow a task: each task's answer - rollups/tasks.json (311 KB, large: read only the parts you need): one row per task, keyed by `job`: its lead time, working time, idle time and its split by what it waited on (`waiting_by_waited_on_ms`), top causes and longest wait, as stated numbers in milliseconds (keys and codes, not the page's sentences; reasons.json gives the words), plus the store's `name` (null for a private task), `finish_order`, `finish_group`, `finish_basis` and `finish_date` (the UTC day the task finished, and the basis it rests on), and Desk's lifecycle `clocks` (production, recorded working inside production, production not recorded as active, request to delivery, queue, and production periods; see Lifecycle clocks above) ## Step 1, follow a task: one task's map - map/015ff969ffb5247b877c8cabb9c20967.json (51 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task 015ff969: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/01a32fdec23074e972afb8c53959a60d.json (6 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task 01a32fde: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/01c65fa7fe0f204ccd10bba77f9a3d7c.json (4 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task 01c65fa7: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/05d95a2b9677da9c76e8e02302fb626a.json (3 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task 05d95a2b: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/0e3101710a6dc93c84b72d5b96af770d.json (2 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task 0e310171: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/145d192baea801b0d958ef1ba371db23.json (7 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task 145d192b: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/16781e25c724c2f641199594fee2d407.json (4 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task 16781e25: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/1abc2341dc6b7e6b32cf64b7b5bb116a.json (117 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task 1abc2341: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/1f0ae588c4005f5834263305eff79640.json (473 KB, large: read only the parts you need): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task 1f0ae588: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/219889e5e586dc2760a21a57f0b806d0.json (79 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task 219889e5: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/21ed3b3de83c2e8c51bf457535c25f7f.json (3 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task 21ed3b3d: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/232de3a5bae0a2867da341bcde0adda5.json (43 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task 232de3a5: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/23de0fa29522ea3ae7f9e29efd313772.json (14 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task 23de0fa2: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/23e26d3f51b4e04e135aa6c73fea1240.json (11 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task 23e26d3f: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/29cab8d37d007313c0e080f4503dcf14.json (5 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task 29cab8d3: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/2b8f4ba0d9754fc50b0cc47675a2d412.json (3 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task 2b8f4ba0: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/346c8d506104085baf14c1d62e53f418.json (4 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task 346c8d50: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/3a1b9a1430c336ba00fbebbbc9336cef.json (3 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task 3a1b9a14: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/3e243489d61561d8cd8a419e21612e52.json (143 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task 3e243489: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/430d4daebf3a2c79a4434a0380fea5d2.json (50 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task 430d4dae: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/45d37f1db9a5490812f16952142e2b78.json (10 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task 45d37f1d: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/6716e031d7a292492b4fbcbf2c6c84de.json (6 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task 6716e031: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/690331ddfef609ca0c05da241914917d.json (37 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task 690331dd: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/691bbb01f05eb923e7925702aa2d20b8.json (4 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task 691bbb01: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/696170203a0b5d1a8e88daa1474a9977.json (5 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task 69617020: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/69642e31753414f73de1b72b4f9f794f.json (8 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task 69642e31: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/6ed962d32c01138c3dc92d30fe4a1479.json (3 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task 6ed962d3: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/70d7a6090fe01ecfcf6a730f7c4cd1fe.json (13 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task 70d7a609: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/79056b8c38d3aeb9d2f7b8d2e1e5f2f8.json (7 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task 79056b8c: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/7b8416a02cb09d651725f0e5a86f390b.json (4 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task 7b8416a0: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/800163a15783a69bceaf189f60d686fd.json (258 KB, large: read only the parts you need): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task 800163a1: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/825084c9676f1da79f49e868ff950abb.json (22 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task 825084c9: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/84d092dbf627e849341593767a06ad3a.json (37 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task 84d092db: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/86bda7ccdcc6ab31fe043c6d8109f6b8.json (14 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task 86bda7cc: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/86df72b98beb838965d0bc5c96996d9e.json (268 KB, large: read only the parts you need): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task 86df72b9: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/8ca9660aa2bbe62a35fd125c9ffe8845.json (45 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task 8ca9660a: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/a1f4eede69cc5e6462d3e6fc931abc06.json (14 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task a1f4eede: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/ae2e54d9a5c4743486b8217eebae1739.json (9 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task ae2e54d9: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/af723dd1d3f70796b0eafee3c337ddbd.json (8 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task af723dd1: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/b0174d12da0f501e34dd35b5fd0b2448.json (5 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task b0174d12: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/b93b442957bae64932a7666a4f9f3bf8.json (4 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task b93b4429: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/c87c243fe6149fafb9296c32cd11dca0.json (21 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task c87c243f: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/c9235d85d3661b139658f4f89ce53dd7.json (3 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task c9235d85: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/d862488ecd388445e7268b3099b7b05b.json (3 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task d862488e: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/d9716335f7cb1fd16b8ae55468ab3cfb.json (2 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task d9716335: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/de5884785a6a73bd0c1e97be335a7ef9.json (308 KB, large: read only the parts you need): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task de588478: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/eaa7a23cb71326d0aa5e8d2fb3b350c8.json (13 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task eaa7a23c: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/ef48b05e1854f22c0349aa2924bb93b8.json (4 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task ef48b05e: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/f30ef731387cce1fd7d0eb83befe98df.json (132 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task f30ef731: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/f4319eb1db398e556ee0c0f66df7d824.json (63 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task f4319eb1: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/f735ccc87afeee40373ed3bedf2e3550.json (58 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task f735ccc8: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/f82705130e041be56fbc3420539bc9b9.json (3 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task f8270513: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/fb423a9340eeb5628b0014c81b3d70e7.json (20 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task fb423a93: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/fc43ef39fb00740b71904c314e3fbe99.json (4 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task fc43ef39: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/fc8b915afe8c5247931343ab0f1eb9ab.json (5 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task fc8b915a: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) - map/fe517446563daa43c5239dc8158776d6.json (3 KB, small enough to read whole): the work bursts, waits, card status changes, operator prompts (each with its why), the waits before them, and pull requests with their opened and merged times on the task clock, of task fe517446: what its value stream map draws; every time is an offset on the task clock (factory.site.map/2), and each operator prompt's `day` is its UTC day where a measured clock anchor ties the task to the calendar, else null; each pull request time states whether it is measured or partial (and which way), and is not placed when the task's clock anchor may be off by more than 15 minutes, the gap that splits two work bursts, or rests on one pull request nothing confirms (anchor_unconfirmed) ## Step 1, follow a task: one task's timeline - jobs/015ff969ffb5247b877c8cabb9c20967.json (1.65 MB, large: read only the parts you need): the timeline and measures of task 015ff969 - jobs/01a32fdec23074e972afb8c53959a60d.json (145 KB, small enough to read whole): the timeline and measures of task 01a32fde - jobs/01c65fa7fe0f204ccd10bba77f9a3d7c.json (586 KB, large: read only the parts you need): the timeline and measures of task 01c65fa7 - jobs/05d95a2b9677da9c76e8e02302fb626a.json (19 KB, small enough to read whole): the timeline and measures of task 05d95a2b - jobs/0e3101710a6dc93c84b72d5b96af770d.json (20 KB, small enough to read whole): the timeline and measures of task 0e310171 - jobs/145d192baea801b0d958ef1ba371db23.json (43 KB, small enough to read whole): the timeline and measures of task 145d192b - jobs/16781e25c724c2f641199594fee2d407.json (34 KB, small enough to read whole): the timeline and measures of task 16781e25 - jobs/1abc2341dc6b7e6b32cf64b7b5bb116a.json (2.11 MB, large: read only the parts you need): the timeline and measures of task 1abc2341 - jobs/1f0ae588c4005f5834263305eff79640.json (12.61 MB, large: read only the parts you need): the timeline and measures of task 1f0ae588 - jobs/219889e5e586dc2760a21a57f0b806d0.json (3.72 MB, large: read only the parts you need): the timeline and measures of task 219889e5 - jobs/21ed3b3de83c2e8c51bf457535c25f7f.json (16 KB, small enough to read whole): the timeline and measures of task 21ed3b3d - jobs/232de3a5bae0a2867da341bcde0adda5.json (310 KB, large: read only the parts you need): the timeline and measures of task 232de3a5 - jobs/23de0fa29522ea3ae7f9e29efd313772.json (61 KB, small enough to read whole): the timeline and measures of task 23de0fa2 - jobs/23e26d3f51b4e04e135aa6c73fea1240.json (451 KB, large: read only the parts you need): the timeline and measures of task 23e26d3f - jobs/29cab8d37d007313c0e080f4503dcf14.json (51 KB, small enough to read whole): the timeline and measures of task 29cab8d3 - jobs/2b8f4ba0d9754fc50b0cc47675a2d412.json (15 KB, small enough to read whole): the timeline and measures of task 2b8f4ba0 - jobs/346c8d506104085baf14c1d62e53f418.json (31 KB, small enough to read whole): the timeline and measures of task 346c8d50 - jobs/3a1b9a1430c336ba00fbebbbc9336cef.json (18 KB, small enough to read whole): the timeline and measures of task 3a1b9a14 - jobs/3e243489d61561d8cd8a419e21612e52.json (2.11 MB, large: read only the parts you need): the timeline and measures of task 3e243489 - jobs/430d4daebf3a2c79a4434a0380fea5d2.json (800 KB, large: read only the parts you need): the timeline and measures of task 430d4dae - jobs/45d37f1db9a5490812f16952142e2b78.json (163 KB, small enough to read whole): the timeline and measures of task 45d37f1d - jobs/6716e031d7a292492b4fbcbf2c6c84de.json (166 KB, small enough to read whole): the timeline and measures of task 6716e031 - jobs/690331ddfef609ca0c05da241914917d.json (189 KB, small enough to read whole): the timeline and measures of task 690331dd - jobs/691bbb01f05eb923e7925702aa2d20b8.json (34 KB, small enough to read whole): the timeline and measures of task 691bbb01 - jobs/696170203a0b5d1a8e88daa1474a9977.json (59 KB, small enough to read whole): the timeline and measures of task 69617020 - jobs/69642e31753414f73de1b72b4f9f794f.json (251 KB, small enough to read whole): the timeline and measures of task 69642e31 - jobs/6ed962d32c01138c3dc92d30fe4a1479.json (15 KB, small enough to read whole): the timeline and measures of task 6ed962d3 - jobs/70d7a6090fe01ecfcf6a730f7c4cd1fe.json (204 KB, small enough to read whole): the timeline and measures of task 70d7a609 - jobs/79056b8c38d3aeb9d2f7b8d2e1e5f2f8.json (91 KB, small enough to read whole): the timeline and measures of task 79056b8c - jobs/7b8416a02cb09d651725f0e5a86f390b.json (63 KB, small enough to read whole): the timeline and measures of task 7b8416a0 - jobs/800163a15783a69bceaf189f60d686fd.json (3.17 MB, large: read only the parts you need): the timeline and measures of task 800163a1 - jobs/825084c9676f1da79f49e868ff950abb.json (209 KB, small enough to read whole): the timeline and measures of task 825084c9 - jobs/84d092dbf627e849341593767a06ad3a.json (874 KB, large: read only the parts you need): the timeline and measures of task 84d092db - jobs/86bda7ccdcc6ab31fe043c6d8109f6b8.json (61 KB, small enough to read whole): the timeline and measures of task 86bda7cc - jobs/86df72b98beb838965d0bc5c96996d9e.json (9.80 MB, large: read only the parts you need): the timeline and measures of task 86df72b9 - jobs/8ca9660aa2bbe62a35fd125c9ffe8845.json (1.85 MB, large: read only the parts you need): the timeline and measures of task 8ca9660a - jobs/a1f4eede69cc5e6462d3e6fc931abc06.json (135 KB, small enough to read whole): the timeline and measures of task a1f4eede - jobs/ae2e54d9a5c4743486b8217eebae1739.json (303 KB, large: read only the parts you need): the timeline and measures of task ae2e54d9 - jobs/af723dd1d3f70796b0eafee3c337ddbd.json (63 KB, small enough to read whole): the timeline and measures of task af723dd1 - jobs/b0174d12da0f501e34dd35b5fd0b2448.json (41 KB, small enough to read whole): the timeline and measures of task b0174d12 - jobs/b93b442957bae64932a7666a4f9f3bf8.json (49 KB, small enough to read whole): the timeline and measures of task b93b4429 - jobs/c87c243fe6149fafb9296c32cd11dca0.json (85 KB, small enough to read whole): the timeline and measures of task c87c243f - jobs/c9235d85d3661b139658f4f89ce53dd7.json (13 KB, small enough to read whole): the timeline and measures of task c9235d85 - jobs/d862488ecd388445e7268b3099b7b05b.json (24 KB, small enough to read whole): the timeline and measures of task d862488e - jobs/d9716335f7cb1fd16b8ae55468ab3cfb.json (8 KB, small enough to read whole): the timeline and measures of task d9716335 - jobs/de5884785a6a73bd0c1e97be335a7ef9.json (2.54 MB, large: read only the parts you need): the timeline and measures of task de588478 - jobs/eaa7a23cb71326d0aa5e8d2fb3b350c8.json (75 KB, small enough to read whole): the timeline and measures of task eaa7a23c - jobs/ef48b05e1854f22c0349aa2924bb93b8.json (38 KB, small enough to read whole): the timeline and measures of task ef48b05e - jobs/f30ef731387cce1fd7d0eb83befe98df.json (5.25 MB, large: read only the parts you need): the timeline and measures of task f30ef731 - jobs/f4319eb1db398e556ee0c0f66df7d824.json (611 KB, large: read only the parts you need): the timeline and measures of task f4319eb1 - jobs/f735ccc87afeee40373ed3bedf2e3550.json (677 KB, large: read only the parts you need): the timeline and measures of task f735ccc8 - jobs/f82705130e041be56fbc3420539bc9b9.json (12 KB, small enough to read whole): the timeline and measures of task f8270513 - jobs/fb423a9340eeb5628b0014c81b3d70e7.json (419 KB, large: read only the parts you need): the timeline and measures of task fb423a93 - jobs/fc43ef39fb00740b71904c314e3fbe99.json (36 KB, small enough to read whole): the timeline and measures of task fc43ef39 - jobs/fc8b915afe8c5247931343ab0f1eb9ab.json (45 KB, small enough to read whole): the timeline and measures of task fc8b915a - jobs/fe517446563daa43c5239dc8158776d6.json (17 KB, small enough to read whole): the timeline and measures of task fe517446 ## Step 1, follow a task: one session in detail - jobs/015ff969ffb5247b877c8cabb9c20967/64dccd7a-fa04-441c-82ab-3ab6de5c5d4d.json (885 KB, large: read only the parts you need): one session of task 015ff969 - jobs/01a32fdec23074e972afb8c53959a60d/104edfba-a039-4437-bdc2-72810b99e34e.json (1 KB, small enough to read whole): one session of task 01a32fde - jobs/01a32fdec23074e972afb8c53959a60d/27c8ba3e-9103-4669-9f25-6df80289992f.json (1 KB, small enough to read whole): one session of task 01a32fde - jobs/01a32fdec23074e972afb8c53959a60d/29c084a1-b40b-4141-80cc-a8b8804654a5.json (73 KB, small enough to read whole): one session of task 01a32fde - jobs/01a32fdec23074e972afb8c53959a60d/2b189ca5-498e-4d90-83b2-bca351228beb.json (1 KB, small enough to read whole): one session of task 01a32fde - jobs/01a32fdec23074e972afb8c53959a60d/a2d6aefa-8329-4050-8b2f-3e44ab1fd81f.json (1 KB, small enough to read whole): one session of task 01a32fde - jobs/01a32fdec23074e972afb8c53959a60d/eecd6bcc-3037-4fbe-835c-b0a84e4b68b7.json (1 KB, small enough to read whole): one session of task 01a32fde - jobs/01c65fa7fe0f204ccd10bba77f9a3d7c/36c514c5-484e-4e36-9dc4-d7220be9a618.json (323 KB, large: read only the parts you need): one session of task 01c65fa7 - jobs/05d95a2b9677da9c76e8e02302fb626a/29c084a1-b40b-4141-80cc-a8b8804654a5.json (5 KB, small enough to read whole): one session of task 05d95a2b - jobs/0e3101710a6dc93c84b72d5b96af770d/de04d6d0-72f8-4c10-9f63-2158c9336f7b.json (6 KB, small enough to read whole): one session of task 0e310171 - jobs/145d192baea801b0d958ef1ba371db23/36c514c5-484e-4e36-9dc4-d7220be9a618.json (10 KB, small enough to read whole): one session of task 145d192b - jobs/16781e25c724c2f641199594fee2d407/30090ebf-880e-4a8f-ad4f-7999cfc0836e.json (8 KB, small enough to read whole): one session of task 16781e25 - jobs/1abc2341dc6b7e6b32cf64b7b5bb116a/b6f712a9-8a14-4ffc-ab43-897d72018656.json (1.07 MB, large: read only the parts you need): one session of task 1abc2341 - jobs/1f0ae588c4005f5834263305eff79640/03c445c1-8bde-445e-8683-c0e52462cb17.json (1 KB, small enough to read whole): one session of task 1f0ae588 - jobs/1f0ae588c4005f5834263305eff79640/25ae207f-f947-4fce-9132-0415cb21216b.json (1.46 MB, large: read only the parts you need): one session of task 1f0ae588 - jobs/1f0ae588c4005f5834263305eff79640/27385dee-e212-40aa-9c60-31e827732c83.json (854 KB, large: read only the parts you need): one session of task 1f0ae588 - jobs/1f0ae588c4005f5834263305eff79640/29c084a1-b40b-4141-80cc-a8b8804654a5.json (2.58 MB, large: read only the parts you need): one session of task 1f0ae588 - jobs/1f0ae588c4005f5834263305eff79640/37c8ddd8-d327-4bc6-a0d8-df60de4a23a4.json (1 KB, small enough to read whole): one session of task 1f0ae588 - jobs/1f0ae588c4005f5834263305eff79640/3c8c094e-7ca4-450a-8130-f7f6ce61686c.json (1 KB, small enough to read whole): one session of task 1f0ae588 - jobs/1f0ae588c4005f5834263305eff79640/433467b2-9504-4f27-9b75-ac21560b9d8c.json (1 KB, small enough to read whole): one session of task 1f0ae588 - jobs/1f0ae588c4005f5834263305eff79640/4b721f47-cca2-46e6-8fa5-77477ca9c870.json (578 KB, large: read only the parts you need): one session of task 1f0ae588 - jobs/1f0ae588c4005f5834263305eff79640/82554b4c-4f1a-4a6b-9a33-57398692901a.json (928 KB, large: read only the parts you need): one session of task 1f0ae588 - jobs/1f0ae588c4005f5834263305eff79640/94a4c44c-9bc2-4913-bf38-4d000d229f16.json (1 KB, small enough to read whole): one session of task 1f0ae588 - jobs/1f0ae588c4005f5834263305eff79640/9cb9ce78-1e27-4d1a-bf04-357e3062fff1.json (1 KB, small enough to read whole): one session of task 1f0ae588 - jobs/1f0ae588c4005f5834263305eff79640/b8f70051-b6b8-4c66-9fa5-be57e712052e.json (1 KB, small enough to read whole): one session of task 1f0ae588 - jobs/1f0ae588c4005f5834263305eff79640/c1aab893-2a4a-4c8a-953a-3449d7ec5bdc.json (209 KB, small enough to read whole): one session of task 1f0ae588 - jobs/1f0ae588c4005f5834263305eff79640/c2cbee09-ef97-4c31-bc8a-c3e54e36fe54.json (1 KB, small enough to read whole): one session of task 1f0ae588 - jobs/219889e5e586dc2760a21a57f0b806d0/36c514c5-484e-4e36-9dc4-d7220be9a618.json (878 KB, large: read only the parts you need): one session of task 219889e5 - jobs/219889e5e586dc2760a21a57f0b806d0/8dff4f7b-78f1-4f5c-b429-9af063ecb4c6.json (265 KB, large: read only the parts you need): one session of task 219889e5 - jobs/219889e5e586dc2760a21a57f0b806d0/b6f712a9-8a14-4ffc-ab43-897d72018656.json (28 KB, small enough to read whole): one session of task 219889e5 - jobs/219889e5e586dc2760a21a57f0b806d0/f4492717-8e09-4456-aec2-fda4cccfd9d5.json (870 KB, large: read only the parts you need): one session of task 219889e5 - jobs/21ed3b3de83c2e8c51bf457535c25f7f/5e9477e8-7dda-4488-afda-fc65326b7878.json (5 KB, small enough to read whole): one session of task 21ed3b3d - jobs/232de3a5bae0a2867da341bcde0adda5/91bea024-803e-448f-8044-14a05daa68d9.json (72 KB, small enough to read whole): one session of task 232de3a5 - jobs/232de3a5bae0a2867da341bcde0adda5/c19c8dea-f20d-40f4-92e7-8fecd5bc73ca.json (12 KB, small enough to read whole): one session of task 232de3a5 - jobs/23de0fa29522ea3ae7f9e29efd313772/e5fa2d4a-27f0-4235-a499-ab5480d431ba.json (7 KB, small enough to read whole): one session of task 23de0fa2 - jobs/23e26d3f51b4e04e135aa6c73fea1240/29c084a1-b40b-4141-80cc-a8b8804654a5.json (241 KB, small enough to read whole): one session of task 23e26d3f - jobs/29cab8d37d007313c0e080f4503dcf14/29c084a1-b40b-4141-80cc-a8b8804654a5.json (18 KB, small enough to read whole): one session of task 29cab8d3 - jobs/2b8f4ba0d9754fc50b0cc47675a2d412/56a7a583-9fa5-478f-85a8-6acfbd06c222.json (2 KB, small enough to read whole): one session of task 2b8f4ba0 - jobs/346c8d506104085baf14c1d62e53f418/64dccd7a-fa04-441c-82ab-3ab6de5c5d4d.json (12 KB, small enough to read whole): one session of task 346c8d50 - jobs/3a1b9a1430c336ba00fbebbbc9336cef/29c084a1-b40b-4141-80cc-a8b8804654a5.json (4 KB, small enough to read whole): one session of task 3a1b9a14 - jobs/3e243489d61561d8cd8a419e21612e52/4954a343-f0ce-49db-9784-112a21c6dd51.json (643 KB, large: read only the parts you need): one session of task 3e243489 - jobs/3e243489d61561d8cd8a419e21612e52/9ef94c36-f132-4332-84b4-ef3c87072007.json (348 KB, large: read only the parts you need): one session of task 3e243489 - jobs/430d4daebf3a2c79a4434a0380fea5d2/d739d7c9-9c61-43f6-95e2-4a511a6d5790.json (22 KB, small enough to read whole): one session of task 430d4dae - jobs/430d4daebf3a2c79a4434a0380fea5d2/de04d6d0-72f8-4c10-9f63-2158c9336f7b.json (347 KB, large: read only the parts you need): one session of task 430d4dae - jobs/45d37f1db9a5490812f16952142e2b78/29c084a1-b40b-4141-80cc-a8b8804654a5.json (74 KB, small enough to read whole): one session of task 45d37f1d - jobs/6716e031d7a292492b4fbcbf2c6c84de/36c514c5-484e-4e36-9dc4-d7220be9a618.json (82 KB, small enough to read whole): one session of task 6716e031 - jobs/690331ddfef609ca0c05da241914917d/c40554c3-944e-4f7a-bec4-a4c227145381.json (44 KB, small enough to read whole): one session of task 690331dd - jobs/691bbb01f05eb923e7925702aa2d20b8/fec179cb-5d0a-4768-85ba-eaeb2e9cfb28.json (12 KB, small enough to read whole): one session of task 691bbb01 - jobs/696170203a0b5d1a8e88daa1474a9977/29c084a1-b40b-4141-80cc-a8b8804654a5.json (24 KB, small enough to read whole): one session of task 69617020 - jobs/69642e31753414f73de1b72b4f9f794f/29c084a1-b40b-4141-80cc-a8b8804654a5.json (125 KB, small enough to read whole): one session of task 69642e31 - jobs/6ed962d32c01138c3dc92d30fe4a1479/49556f76-62ba-4da2-85a4-3e9d359b3bbd.json (2 KB, small enough to read whole): one session of task 6ed962d3 - jobs/70d7a6090fe01ecfcf6a730f7c4cd1fe/29c084a1-b40b-4141-80cc-a8b8804654a5.json (86 KB, small enough to read whole): one session of task 70d7a609 - jobs/79056b8c38d3aeb9d2f7b8d2e1e5f2f8/9ef94c36-f132-4332-84b4-ef3c87072007.json (33 KB, small enough to read whole): one session of task 79056b8c - jobs/7b8416a02cb09d651725f0e5a86f390b/9ef94c36-f132-4332-84b4-ef3c87072007.json (27 KB, small enough to read whole): one session of task 7b8416a0 - jobs/800163a15783a69bceaf189f60d686fd/800a0a56-633e-4e8f-b35f-0ebc686a462b.json (10 KB, small enough to read whole): one session of task 800163a1 - jobs/800163a15783a69bceaf189f60d686fd/c2a25a10-d203-4cb5-82d0-02195923a8d8.json (19 KB, small enough to read whole): one session of task 800163a1 - jobs/800163a15783a69bceaf189f60d686fd/d34c4a7c-c990-40af-be2a-eeea5d1494a2.json (991 KB, large: read only the parts you need): one session of task 800163a1 - jobs/800163a15783a69bceaf189f60d686fd/d99a5955-3d48-48c8-b455-e9196452e623.json (390 KB, large: read only the parts you need): one session of task 800163a1 - jobs/825084c9676f1da79f49e868ff950abb/5f4879fb-c33d-497e-b19c-3aa37045f317.json (91 KB, small enough to read whole): one session of task 825084c9 - jobs/84d092dbf627e849341593767a06ad3a/29c084a1-b40b-4141-80cc-a8b8804654a5.json (432 KB, large: read only the parts you need): one session of task 84d092db - jobs/86bda7ccdcc6ab31fe043c6d8109f6b8/5e71fd91-9a07-4d6f-a9e0-ef748d85c411.json (5 KB, small enough to read whole): one session of task 86bda7cc - jobs/86bda7ccdcc6ab31fe043c6d8109f6b8/9c690b39-0282-46ae-9e1a-65f20b757e00.json (3 KB, small enough to read whole): one session of task 86bda7cc - jobs/86df72b98beb838965d0bc5c96996d9e/61cd26b5-ddef-416a-bab5-325b6c0075c9.json (588 KB, large: read only the parts you need): one session of task 86df72b9 - jobs/86df72b98beb838965d0bc5c96996d9e/b3c69c05-7a6b-427f-bab5-16b2a48fc746.json (704 KB, large: read only the parts you need): one session of task 86df72b9 - jobs/86df72b98beb838965d0bc5c96996d9e/b76a3a21-e7bb-463f-8ac9-16ade0921673.json (405 KB, large: read only the parts you need): one session of task 86df72b9 - jobs/86df72b98beb838965d0bc5c96996d9e/c5ca294a-9d51-4996-99ed-c8baf0ee3725.json (109 KB, small enough to read whole): one session of task 86df72b9 - jobs/86df72b98beb838965d0bc5c96996d9e/d0c57c3e-558b-468b-a913-ae1bfc9176be.json (989 KB, large: read only the parts you need): one session of task 86df72b9 - jobs/86df72b98beb838965d0bc5c96996d9e/e1c92170-2f9b-4805-b98c-5a15f0cfe2e1.json (2.52 MB, large: read only the parts you need): one session of task 86df72b9 - jobs/8ca9660aa2bbe62a35fd125c9ffe8845/30090ebf-880e-4a8f-ad4f-7999cfc0836e.json (226 KB, small enough to read whole): one session of task 8ca9660a - jobs/8ca9660aa2bbe62a35fd125c9ffe8845/8f8c7288-cd47-4544-8dcf-0ad9bbadfeb5.json (778 KB, large: read only the parts you need): one session of task 8ca9660a - jobs/a1f4eede69cc5e6462d3e6fc931abc06/d739d7c9-9c61-43f6-95e2-4a511a6d5790.json (58 KB, small enough to read whole): one session of task a1f4eede - jobs/ae2e54d9a5c4743486b8217eebae1739/4b721f47-cca2-46e6-8fa5-77477ca9c870.json (2 KB, small enough to read whole): one session of task ae2e54d9 - jobs/ae2e54d9a5c4743486b8217eebae1739/c1aab893-2a4a-4c8a-953a-3449d7ec5bdc.json (154 KB, small enough to read whole): one session of task ae2e54d9 - jobs/af723dd1d3f70796b0eafee3c337ddbd/32baeec2-2c15-47ba-9cbe-4389265e58d0.json (22 KB, small enough to read whole): one session of task af723dd1 - jobs/b0174d12da0f501e34dd35b5fd0b2448/29c084a1-b40b-4141-80cc-a8b8804654a5.json (12 KB, small enough to read whole): one session of task b0174d12 - jobs/b93b442957bae64932a7666a4f9f3bf8/9ef94c36-f132-4332-84b4-ef3c87072007.json (19 KB, small enough to read whole): one session of task b93b4429 - jobs/c87c243fe6149fafb9296c32cd11dca0/48eca258-4c06-4830-a794-bc768ea55c40.json (7 KB, small enough to read whole): one session of task c87c243f - jobs/c87c243fe6149fafb9296c32cd11dca0/4b34c4fa-57d6-4fe0-a822-d452dc681b1f.json (12 KB, small enough to read whole): one session of task c87c243f - jobs/c9235d85d3661b139658f4f89ce53dd7/4dcaf76c-9e60-4197-90f5-3abac586ceab.json (1 KB, small enough to read whole): one session of task c9235d85 - jobs/d862488ecd388445e7268b3099b7b05b/29c084a1-b40b-4141-80cc-a8b8804654a5.json (5 KB, small enough to read whole): one session of task d862488e - jobs/de5884785a6a73bd0c1e97be335a7ef9/668d1c3e-f263-411b-a41f-fa19f8815c4d.json (116 KB, small enough to read whole): one session of task de588478 - jobs/de5884785a6a73bd0c1e97be335a7ef9/82df4704-749b-427d-86b5-37bd3e3ca233.json (599 KB, large: read only the parts you need): one session of task de588478 - jobs/de5884785a6a73bd0c1e97be335a7ef9/eb5781f6-f71a-4f96-945c-1819c09962c2.json (167 KB, small enough to read whole): one session of task de588478 - jobs/eaa7a23cb71326d0aa5e8d2fb3b350c8/32baeec2-2c15-47ba-9cbe-4389265e58d0.json (22 KB, small enough to read whole): one session of task eaa7a23c - jobs/ef48b05e1854f22c0349aa2924bb93b8/de04d6d0-72f8-4c10-9f63-2158c9336f7b.json (14 KB, small enough to read whole): one session of task ef48b05e - jobs/f30ef731387cce1fd7d0eb83befe98df/8fa1e004-7c07-4f4f-8803-0866fe2bb332.json (1.68 MB, large: read only the parts you need): one session of task f30ef731 - jobs/f30ef731387cce1fd7d0eb83befe98df/d5078b5a-5993-4015-a99d-d6c2deed2921.json (1.14 MB, large: read only the parts you need): one session of task f30ef731 - jobs/f4319eb1db398e556ee0c0f66df7d824/30090ebf-880e-4a8f-ad4f-7999cfc0836e.json (210 KB, small enough to read whole): one session of task f4319eb1 - jobs/f4319eb1db398e556ee0c0f66df7d824/46d24be5-74a4-4eb7-8702-05b4dd84e472.json (2 KB, small enough to read whole): one session of task f4319eb1 - jobs/f735ccc87afeee40373ed3bedf2e3550/9b38068a-6f87-4a1a-8489-3e4691b7bc0f.json (316 KB, large: read only the parts you need): one session of task f735ccc8 - jobs/f82705130e041be56fbc3420539bc9b9/27385dee-e212-40aa-9c60-31e827732c83.json (1 KB, small enough to read whole): one session of task f8270513 - jobs/fb423a9340eeb5628b0014c81b3d70e7/29c084a1-b40b-4141-80cc-a8b8804654a5.json (202 KB, small enough to read whole): one session of task fb423a93 - jobs/fc43ef39fb00740b71904c314e3fbe99/29c084a1-b40b-4141-80cc-a8b8804654a5.json (12 KB, small enough to read whole): one session of task fc43ef39 - jobs/fc8b915afe8c5247931343ab0f1eb9ab/64dccd7a-fa04-441c-82ab-3ab6de5c5d4d.json (12 KB, small enough to read whole): one session of task fc8b915a - jobs/fe517446563daa43c5239dc8158776d6/de04d6d0-72f8-4c10-9f63-2158c9336f7b.json (3 KB, small enough to read whole): one session of task fe517446 ## Step 2, compare tasks - rollups/stackup.json (273 KB, large: read only the parts you need): one row per task: its lead time split into working time by the evaluator's labels and waiting (idle time) by what it waited on; what each bar of the stack-up draws, with each task's lifecycle `clocks` for the production and request modes (their sums are task exposure, not factory time) ## Step 3, rank causes - rollups/causes.json (14 KB, small enough to read whole): each cause's time in job-hours (a moment two tasks share counts for each), largest first with its running share, and the tasks and stretches behind it; what the Pareto chart and each #/causes/ page draw ## Step 2, compare tasks over time - rollups/by_week.json (34 KB, small enough to read whole): finished tasks' hours by finish week (`basis: "by_finish_week"`: each task counts in the ISO week, UTC with Monday as the first day, in which it finished): per week the lead, working and idle time, working time by class and waste, idle time by what it waited on, and the median flow efficiency of the tasks measured (n of N); `tasks[]` is one dot per task (finish date and flow efficiency); `unplaced` lists finished tasks with no finish date; what Compare's Over time view draws ## Improvement annotations - rollups/improvements.json (43 KB, small enough to read whole): the identical data.json.improvements inspection queue (factory-improvements/1): explicit coverage/absence/conflict, the publishing machine's runner state, safe public context availability and opaque inspect-only handoffs; no private decision prose or new authority ## Other rollups - rollups/coverage.json (2 KB, small enough to read whole): the pipeline's coverage rollup - rollups/measures.json (57 KB, small enough to read whole): the pipeline's measures rollup - rollups/muda.json (23 KB, small enough to read whole): the pipeline's muda rollup - rollups/outcomes.json (34 KB, small enough to read whole): the pipeline's outcomes rollup - rollups/tool-kinds.json (1 KB, small enough to read whole): the pipeline's tool-kinds rollup - rollups/totals.json (3 KB, small enough to read whole): the pipeline's totals rollup ## The site's own health - health.json (2 KB, small enough to read whole): whether the site data is current ### Factory briefing and evidence navigation (consumer milestone) `#/` is Overview; `#/tasks`, `#/compare`, `#/improvements` and `#/why` are directly usable. `#/help` replays the optional three-stop guide. Existing task/session/cause links and `#/act` remain supported. Production and request clocks are shown where Desk publishes them. Triage reviews appear in the improvements queue only when Desk has published them; `state:"not_reviewed"` means none has. `data.json.overview` and `rollups/overview.json` are identical `factory-overview/1` projections with `generation`, `attention`, `agents`, `investigation`, `changes`, `state` and `reasons`. The overview is a closed public presentation contract checked separately at this exact top-level path; other measurements remain governed by the stated-number checks. Work/quality, collection and improvement-system problems remain distinct. Alarms precede suggested investigations. Missing monitoring is unknown, never all-clear. A triage route cannot create ownership, activity or execution authority. Rows expose a public ID, family, title, observed-impact limitation, ownership availability, next action and validated local destination; optional figures retain number states. Triage context is copied from the validated Node2 queue, with its opaque public handoff and inspection-only authority. Private decision/recommendation/continuation remain unavailable. Do not infer them from gate codes or issue titles. Display preferences are versioned and origin-local. Browser storage failure does not break navigation or imply persistence. Since-last-visit text compares only compatible bounded public briefing snapshots, never a complete change history. Selected IANA zones apply only to supported instants. Published finish days and finish weeks remain UTC; relative offsets and durations are invariant. Missing lifecycle clocks are unavailable, not legacy lead relabeled as production. Lifecycle clocks: each task carries `clocks` in `data.json` `jobs[]` and on its row of the task and stack-up rollups and its map file, where those are published, with the same values in every twin. Desk computes them; the site only words them. Each clock is a number object as above: `production_ms` (production elapsed time: from the first recorded work of each production episode to its recorded delivery, summed over episodes, leaving out the time between deliveries), `active_in_production_ms` (recorded working inside production: the union of this task's recorded agent activity, so overlapping workers count once), `production_remainder_ms` (production time not recorded as active: not proof of idle time or waste, because some work is not captured), `request_to_delivery_ms` (from the original request to recorded delivery) and `queue_ms` (from the original request to the first recorded work). `production_periods` lists the episodes as `{ start_ms, end_ms, so_far? }` offsets on the task's own clock; the gap between one episode's end and the next one's start is time between deliveries, which is neither production time nor an exact acceptance duration. A value of a task still open carries `so_far: true` and may grow. When Desk has no record of the original request, `request_to_delivery_ms` and `queue_ms` are `unavailable` with reason `original_request_not_recorded`: never zero, and never the legacy lead time relabelled. The acceptance wait stays its own coarse class (`signoff_wait`: under one hour, under one day, under seven days, seven days or more), outside production time. On Compare, the production and request modes draw one bar per task; their sums are task exposure (the same hour counts once for every task open in it), not factory time, and no ratio of them is a utilization figure. A ratio of figures with different bounds keeps its uncertainty rather than taking a direction.