light-plan 0.0.0-stage → 0.1.0

package/dist/core/board/scope.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scope.js","sourceRoot":"","sources":["../../../src/core/board/scope.ts"],"names":[],"mappings":"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"}

package/dist/core/board/simulate.d.ts

@@ -0,0 +1,138 @@
+import type { Issue, Period, Resource } from '../model/types.js';
+import type { LoadedBoard } from './load.js';
+import type { TaskOptions, TaskRoute } from './tasks.js';
+/**
+ * "If this one person were the only contributor, what would they do, and in
+ * what order?"
+ *
+ * The queue answers "what is next" one step at a time, which is the question a
+ * developer has. The question a plan owner has is the whole sequence: take the
+ * top of the queue, finish it, ask again, and keep going until nothing is left
+ * that this person could ever pick up. That is all this is — `nextTasks` in a
+ * loop over a board held in memory.
+ *
+ * Two properties make it worth having rather than guessing:
+ *
+ *   - **It drives the real queue.** Every step comes from `nextTasks` against a
+ *     board with the earlier steps marked finished, so the order it reports is
+ *     the order the board would actually offer. A second copy of the ranking
+ *     rules that agreed today and drifted tomorrow would be worse than nothing.
+ *   - **Nothing is written and no clock moves.** The overlay lives for the
+ *     length of the call, and `today` is fixed throughout, so a period that has
+ *     not started stays not-started for the whole run. This reports an order,
+ *     never a schedule: it does not know how long anything takes and must not
+ *     appear to.
+ *
+ * There is deliberately nothing here that decides *what* may be picked up.
+ * Every rule about that — routing, scope, work units, blockers, parked periods —
+ * lives in `candidatesFor` and reaches this file only through `nextTasks`, so a
+ * developer running `lpm task next` step by step gets the sequence this reports.
+ * The moment this module grows a filter of its own, that stops being true.
+ *
+ * What the run *cannot* reach is the other half of the answer, and is reported
+ * beside it. Under "only contributor", work held by somebody else is never
+ * finished, so anything waiting on it waits forever — which is exactly the
+ * thing a reader wants to see.
+ *
+ * The one place the run is allowed to start from something the queue does not
+ * offer is work already in flight — it has been picked up, and pretending it is
+ * not there would leave its dependents blocked forever. That licence stops at a
+ * **flag**: a flag says the work has stopped and needs a person, and this run
+ * has nobody else in it, so taking a flagged issue as step 1 would assume away
+ * the very thing holding the queue up and report everything behind it as
+ * reachable. Flagged work is reported as skipped instead, which is what makes
+ * this agree with `lpm task next` and `lpm queue agent` on a stalled board.
+ *
+ * That licence is not this file's to grant either: it is `resumableTasks` in
+ * `board/tasks/ranking.ts`, and `lpm queue agent` resumes through exactly the
+ * same call. A private copy here is how the two came to disagree — the run
+ * predicted a sequence starting from work the agent could never pick back up.
+ */
+/** Why a piece of work was never picked up. */
+export type SkipReason = 
+/** Flagged: whoever holds it has said the work has stopped. */
+'flagged'
+/** Somebody else has it in flight, and this run never finishes their work. */
+ | 'active'
+/** The reader's profile does not offer it. */
+ | 'scope'
+/** Assigned elsewhere, or to nobody when nobody was being considered. */
+ | 'routing'
+/** The period is owned by a squad the resource does not belong to. */
+ | 'squad'
+/** In a period somebody switched off. Asked for with `includeParked`. */
+ | 'parked'
+/** Waiting on work this run never finished. */
+ | 'blocked'
+/** Reachable and ready — only possible when `limit` cut the run short. */
+ | 'ready';
+export interface SimulationStep {
+    /** 1-based position in the sequence. */
+    order: number;
+    issue: Issue;
+    route: TaskRoute;
+    /** The pool the work was parked in, when `route` is 'pool'. */
+    pool: Resource | null;
+    period: Period | null;
+    /**
+     * True when this issue was already in an active status when the run began.
+     * Work in flight is not offered by the queue — it has been picked up — so it
+     * is done first rather than ignored, or everything waiting on it would look
+     * blocked forever.
+     */
+    started: boolean;
+    /** Effort declared on this issue, or null when none is recorded. */
+    effort: number | null;
+    /** Effort of every step so far including this one; null on a board with none. */
+    cumulative: number | null;
+    /** Work that stopped being blocked because this step finished. */
+    unblocked: Issue[];
+}
+export interface SimulationSkip {
+    issue: Issue;
+    reason: SkipReason;
+    /** Unfinished blockers left when the run ended. Only for `reason` 'blocked'. */
+    blockedBy: Issue[];
+    /** Who is holding it, when somebody is and the board knows them. */
+    holder: Resource | null;
+    /** The period it sits in, so a parked one can be named rather than implied. */
+    period: Period | null;
+}
+export interface QueueSimulation {
+    resource: Resource;
+    /** The sequence, in the order the board would offer it. */
+    steps: SimulationStep[];
+    /** Open work units the run never reached, with the reason for each. */
+    skipped: SimulationSkip[];
+    /** Total effort of the steps; null when the board measures no effort. */
+    effort: number | null;
+    /** Steps carrying no effort, when the board measures effort at all. */
+    unestimated: number;
+    /** True when `limit` stopped the run with work still takeable. */
+    truncated: boolean;
+    /**
+     * Open work the queue withheld because its period is switched off. Always
+     * reported, so a run that is short because the team parked six sprints says
+     * so rather than looking like a board with nothing left on it.
+     */
+    parked: number;
+    /**
+     * Work of this resource's that is flagged, and so was never started from.
+     * Reported for the same reason `parked` is: a run that is empty because every
+     * issue this person holds has stopped is not a board with nothing left on it,
+     * and the difference is the whole answer.
+     */
+    flagged: number;
+}
+export interface SimulateOptions extends TaskOptions {
+    /** Stop after this many steps. Omit to run the queue dry. */
+    limit?: number;
+}
+/**
+ * Work the queue through as one person, and report the sequence.
+ *
+ * The caller resolves the resource, because naming somebody is the CLI's job
+ * (`findResource` takes a name as readily as an id) and a report about a person
+ * who does not exist has nothing to say.
+ */
+export declare function simulateQueue(board: LoadedBoard, resource: Resource, options?: SimulateOptions): QueueSimulation;

package/dist/core/board/simulate.js

@@ -0,0 +1,141 @@
+import { isActiveStatus, isTerminalStatus, terminalStatusId } from '../config/lookup.js';
+import { BoardError } from '../errors.js';
+import { periodOf, workUnits } from './query.js';
+import { inScope } from './scope.js';
+import { blockersOf, effortOf, isParked, nextTasks, resumableTasks, routeOf } from './tasks.js';
+/**
+ * The board as it would be with `issue` finished.
+ *
+ * A shallow overlay: only the status of one issue changes, so every index that
+ * does not depend on status (`dependents`, `resourcesById`, the trees) is shared
+ * rather than rebuilt. The trees are the one thing left holding a stale status,
+ * and nothing that ranks work reads them.
+ */
+function withFinished(board, issue, status) {
+    const finished = { ...issue, status };
+    const byId = new Map(board.byId);
+    byId.set(issue.id, finished);
+    return {
+        ...board,
+        issues: board.issues.map((other) => (other.id === issue.id ? finished : other)),
+        byId,
+    };
+}
+/** Work that had `issue` as its last unfinished blocker. */
+function unblockedBy(before, after, issue) {
+    return (before.dependents.get(issue.id) ?? [])
+        .map((id) => after.byId.get(id))
+        .filter((other) => Boolean(other))
+        .filter((other) => blockersOf(after, other).length === 0);
+}
+/** Why this open work unit was never picked up. Most specific cause first. */
+function classify(board, issue, resource, options) {
+    const holder = issue.assignee ? (board.resourcesById.get(issue.assignee) ?? null) : null;
+    const skip = (reason, blockedBy = []) => ({
+        issue,
+        reason,
+        blockedBy,
+        holder,
+        period: periodOf(board, issue),
+    });
+    // Ahead of everything: a flag is a statement that this work has stopped and
+    // needs a person, which is the answer a reader can act on. It is also why the
+    // run is short, so it must not be reported as something vaguer.
+    if (issue.flag)
+        return skip('flagged');
+    if (isActiveStatus(board.config, issue.status))
+        return skip('active');
+    if (options.scope && !inScope(options.scope, issue))
+        return skip('scope');
+    if (!routeOf(board, issue, resource, options))
+        return skip('routing');
+    const squadGate = issue.period ? board.periodSquadMembers.get(issue.period) : undefined;
+    if (squadGate && !squadGate.has(resource.id))
+        return skip('squad');
+    // Ahead of 'blocked': parked work was never a candidate, so saying what it is
+    // waiting on would answer a question the queue never got as far as asking.
+    if (!options.includeParked && isParked(board, issue))
+        return skip('parked');
+    const blockedBy = blockersOf(board, issue);
+    return blockedBy.length ? skip('blocked', blockedBy) : skip('ready');
+}
+/**
+ * Work the queue through as one person, and report the sequence.
+ *
+ * The caller resolves the resource, because naming somebody is the CLI's job
+ * (`findResource` takes a name as readily as an id) and a report about a person
+ * who does not exist has nothing to say.
+ */
+export function simulateQueue(board, resource, options = {}) {
+    const done = terminalStatusId(board.config);
+    if (!done) {
+        throw new BoardError('This board has no end state, so nothing can be simulated as finished', [
+            'Mark one of the statuses in .lpm/config.yml with `terminal: true`.',
+        ]);
+    }
+    const measuresEffort = Boolean(board.config.effort_attribute);
+    const limit = options.limit === undefined ? Infinity : Math.max(0, options.limit);
+    const steps = [];
+    let state = board;
+    let total = 0;
+    const take = (candidate, started) => {
+        const effort = effortOf(state, candidate.issue);
+        if (effort !== null)
+            total += effort;
+        const next = withFinished(state, candidate.issue, done);
+        steps.push({
+            order: steps.length + 1,
+            issue: candidate.issue,
+            route: candidate.route,
+            pool: candidate.pool,
+            period: candidate.period,
+            started,
+            effort,
+            cumulative: measuresEffort ? total : null,
+            unblocked: unblockedBy(state, next, candidate.issue),
+        });
+        state = next;
+    };
+    // The limit is checked only once something takeable has been found, so a run
+    // that happened to end on exactly the limit is not reported as cut short.
+    let truncated = false;
+    // Work already picked up comes first: the queue does not offer it, and a run
+    // that pretended it was not there would leave its dependents blocked forever.
+    // `resumableTasks` is the same call `lpm queue agent` makes to resume its own
+    // work, which is what keeps the prediction and the run in step.
+    for (const candidate of resumableTasks(board, resource.id, options)) {
+        if (steps.length >= limit) {
+            truncated = true;
+            break;
+        }
+        take(candidate, true);
+    }
+    // Then the queue itself, re-asked after every step — the whole point being
+    // that finishing one thing changes what the board offers next.
+    while (!truncated) {
+        const [top] = nextTasks(state, resource.id, { ...options, limit: 1 });
+        if (!top)
+            break;
+        if (steps.length >= limit) {
+            truncated = true;
+            break;
+        }
+        take(top, false);
+    }
+    const taken = new Set(steps.map((step) => step.issue.id));
+    const skipped = workUnits(state)
+        .filter((issue) => !taken.has(issue.id))
+        .filter((issue) => !isTerminalStatus(state.config, issue.status))
+        .map((issue) => classify(state, issue, resource, options));
+    return {
+        resource,
+        steps,
+        skipped,
+        effort: measuresEffort ? total : null,
+        unestimated: measuresEffort ? steps.filter((step) => step.effort === null).length : 0,
+        truncated,
+        parked: skipped.filter((skip) => skip.reason === 'parked').length,
+        flagged: skipped.filter((skip) => skip.reason === 'flagged' && skip.issue.assignee === resource.id).length,
+    };
+}
+//# sourceMappingURL=simulate.js.map

package/dist/core/board/simulate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"simulate.js","sourceRoot":"","sources":["../../../src/core/board/simulate.ts"],"names":[],"mappings":"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"}

package/dist/core/board/tasks/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * "What should I work on?" plus "who is carrying how much?" — the read-only
+ * resource dimension of the board.
+ *
+ * Split across two modules so each answers one question:
+ *
+ * - `ranking.ts` — ranking work: `nextTasks`, `blockedTasks`, `resumableTasks`,
+ *   `currentTasks`, `previousTasks`, `rankCandidates`, `routeOf`, `isParked`,
+ *   `blockersOf`, `isBlocked`, `upstreamOf`, `effortOf`, `TaskOptions`,
+ *   `TaskCandidate`, `TaskRoute`, `UpstreamIssue`.
+ *
+ * - `roster.ts` — reporting load: `resourceLoad`, `LoadRow`, `LoadReport`.
+ *
+ * Everything here derives from the board plus the config; nothing writes.
+ * `lpm task` and `lpm team` are thin printers over these functions.
+ *
+ * The export surface is load-bearing: `simulate.ts` deliberately imports
+ * `resumableTasks`, `routeOf` and `isParked` so the simulator can never
+ * disagree with the queue — and `src/runner/loop.ts` imports `resumableTasks`
+ * for the same reason, so `lpm queue agent` resumes exactly the work
+ * `lpm queue simulate` says it will. `test/simulate.test.ts` and
+ * `test/runner-loop.test.ts` enforce it.
+ */
+export * from './ranking.js';
+export * from './roster.js';

package/dist/core/board/tasks/index.js

@@ -0,0 +1,26 @@
+/**
+ * "What should I work on?" plus "who is carrying how much?" — the read-only
+ * resource dimension of the board.
+ *
+ * Split across two modules so each answers one question:
+ *
+ * - `ranking.ts` — ranking work: `nextTasks`, `blockedTasks`, `resumableTasks`,
+ *   `currentTasks`, `previousTasks`, `rankCandidates`, `routeOf`, `isParked`,
+ *   `blockersOf`, `isBlocked`, `upstreamOf`, `effortOf`, `TaskOptions`,
+ *   `TaskCandidate`, `TaskRoute`, `UpstreamIssue`.
+ *
+ * - `roster.ts` — reporting load: `resourceLoad`, `LoadRow`, `LoadReport`.
+ *
+ * Everything here derives from the board plus the config; nothing writes.
+ * `lpm task` and `lpm team` are thin printers over these functions.
+ *
+ * The export surface is load-bearing: `simulate.ts` deliberately imports
+ * `resumableTasks`, `routeOf` and `isParked` so the simulator can never
+ * disagree with the queue — and `src/runner/loop.ts` imports `resumableTasks`
+ * for the same reason, so `lpm queue agent` resumes exactly the work
+ * `lpm queue simulate` says it will. `test/simulate.test.ts` and
+ * `test/runner-loop.test.ts` enforce it.
+ */
+export * from './ranking.js';
+export * from './roster.js';
+//# sourceMappingURL=index.js.map

package/dist/core/board/tasks/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/core/board/tasks/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC"}

package/dist/core/board/tasks/ranking.d.ts

@@ -0,0 +1,155 @@
+import type { Issue, Period, Resource } from '../../model/types.js';
+import type { BlockingLookup, UpstreamEntry } from '../../../shared/blocking.js';
+import type { LoadedBoard } from '../load.js';
+import type { ResolvedScope } from '../scope.js';
+/**
+ * "What should I work on?" — ranking work by schedule, priority, status and
+ * how far along the part of the plan it sits in already is.
+ * Everything here derives from the board plus the config; nothing writes.
+ * `lpm task` and `lpm task next` are thin printers over these functions.
+ */
+export interface TaskOptions {
+    /** Also consider issues nobody is assigned to. */
+    includeUnassigned?: boolean;
+    /**
+     * Also consider work in a period somebody switched off. Off by default: the
+     * switch means "not this one", so parked work is not offered until it is
+     * asked for. It stays reachable by id, like everything else the switch and a
+     * profile's scope steer — see `isParked`.
+     */
+    includeParked?: boolean;
+    /** Today as YYYY-MM-DD. Injectable so recommendations are testable. */
+    today?: string;
+    limit?: number;
+    /**
+     * Only offer work inside this scope — the reader's profile, resolved. Omit
+     * it for the whole board. It narrows what is *offered*: `currentTasks` and
+     * `previousTasks` deliberately ignore it, because work already picked up
+     * stays yours even if the scope it came from moves.
+     */
+    scope?: ResolvedScope | null;
+    /**
+     * Prefer work under this parent (by id) ahead of everything else, so a run
+     * finishes the feature it is inside before starting another. This is the
+     * emphatic form of the cohesion every ranking applies (`src/shared/cohesion.ts`
+     * keeps a queue inside the containers already under way); it outranks even the
+     * schedule, which is why it is off by default and only `lpm queue agent` sets
+     * it, to the parent of the task it just finished.
+     * It reorders what is *offered* and never widens it: the sibling still has to
+     * be a ready, in-scope, routable work unit to be picked at all.
+     */
+    focusParent?: string | null;
+}
+/** How a piece of work reached the person being advised. */
+export type TaskRoute = 'direct' | 'pool' | 'unassigned';
+export interface TaskCandidate {
+    issue: Issue;
+    route: TaskRoute;
+    /** The pool the work is parked in, when `route` is 'pool'. */
+    pool: Resource | null;
+    period: Period | null;
+    /** Issues that must finish first. Empty for anything `nextTasks` returns. */
+    blockedBy: Issue[];
+}
+/**
+ * Adapt a `LoadedBoard` to the id-based lookup `src/shared/blocking.ts` reads.
+ *
+ * Exported because `validation/checks/dependencies.ts` runs the cycle check
+ * over the *inherited* graph these rules produce, and a second adapter there
+ * would be a second answer to "what gates this issue".
+ */
+export declare function blockingLookupFor(board: LoadedBoard): BlockingLookup;
+/**
+ * Issues that must be finished before `issue` can start, nearest cause first.
+ *
+ * Dependencies are inherited: an issue waits on everything its ancestors wait
+ * on. A dependency on a container is cleared by the work inside it rather than
+ * by the container's own status.
+ *
+ * @see src/shared/blocking.ts for the rules and why they are that way.
+ */
+export declare function blockersOf(board: LoadedBoard, issue: Issue): Issue[];
+export declare function isBlocked(board: LoadedBoard, issue: Issue): boolean;
+/** An upstream issue with the document resolved. @see upstreamOf */
+export interface UpstreamIssue extends UpstreamEntry {
+    issue: Issue;
+}
+/**
+ * Everything that has to be finished before `issue` can be, nearest cause
+ * first — the whole chain, not just the nearest link of it.
+ *
+ * `blockersOf` says why the work cannot start today. This says what would have
+ * to happen for it to be closed at all: what the blockers wait on, what those
+ * wait on, and the open work inside each blocking container, which is what a
+ * container amounts to and what somebody would actually be handed.
+ *
+ * Read-only, and it answers for the board as it stands — a dangling id blocks
+ * nothing, exactly as it does for the queue.
+ *
+ * @see src/shared/blocking.ts for the rules and why they are that way.
+ */
+export declare function upstreamOf(board: LoadedBoard, issue: Issue): UpstreamIssue[];
+/**
+ * Work sitting in a period somebody switched off — including one nested inside
+ * a switched-off period, since `periodStance` cascades the way parking an
+ * increment parks the sprints in it.
+ *
+ * This is the one definition of "parked", and `candidatesFor` is the one place
+ * that acts on it, so `lpm task next`, `lpm task start`, MCP `next_tasks` and
+ * `simulateQueue` cannot disagree about whether a parked sprint is on offer.
+ */
+export declare function isParked(board: LoadedBoard, issue: Issue): boolean;
+/** Effort declared on an issue, when the board measures effort at all. */
+export declare function effortOf(board: LoadedBoard, issue: Issue): number | null;
+/**
+ * The order the queue offers work in, applied to candidates that did not come
+ * from `candidatesFor` — work already under way, say. Exported so a caller that
+ * assembles its own list still ranks it the one way the board ranks work.
+ */
+export declare function rankCandidates(board: LoadedBoard, candidates: TaskCandidate[], options?: TaskOptions): TaskCandidate[];
+/**
+ * How a piece of work reaches a resource, or null when it never does: assigned
+ * to it, parked in a pool it covers, or assigned to nobody when the caller is
+ * willing to consider that.
+ *
+ * The public face of the rule `candidatesFor` filters by. It answers *routing*
+ * alone and says nothing about whether the work is ready, in scope or finished
+ * — a caller explaining why something was never offered needs to separate those
+ * reasons, and asking this is how it does so without restating the rule.
+ */
+export declare function routeOf(board: LoadedBoard, issue: Issue, resource: Resource, options?: TaskOptions): {
+    route: TaskRoute;
+    pool: Resource | null;
+} | null;
+/** What to work on next: ready, unblocked work, best first. */
+export declare function nextTasks(board: LoadedBoard, resourceId: string, options?: TaskOptions): TaskCandidate[];
+/** Work that would be next if something else were finished first. */
+export declare function blockedTasks(board: LoadedBoard, resourceId: string, options?: TaskOptions): TaskCandidate[];
+/**
+ * Work this resource has already picked up and may carry straight on with.
+ *
+ * The queue never offers what has been picked up — `candidatesFor` skips an
+ * active status, because a thing in progress is not a thing to start. That
+ * leaves a hole for anything working the queue on its own: a run that only ever
+ * asked `nextTasks` could never come back to a task it left half-finished, so
+ * one interrupted task dammed the board and everything waiting on it was
+ * blocked for ever. This is the one definition of "what may I carry on with",
+ * called by `simulateQueue` to seed a run and by `lpm queue agent` to resume
+ * one, so the prediction and the run cannot disagree about it.
+ *
+ * Two things are not resumable. A container somebody moved into an active
+ * column is not a thing you pick up — its children are, and counting it would
+ * double the work it stands for. And a **flag** ends the licence: it says the
+ * work has stopped and needs a person, which is a decision no one-person run
+ * is going to make on its own, so carrying on with it would assume away the
+ * very thing holding the queue up.
+ *
+ * Like `currentTasks`, this ignores scope and the period switch: work already
+ * picked up stays yours even if the queue that offered it has moved. It is
+ * ranked but never truncated — the caller decides how much of it to take.
+ */
+export declare function resumableTasks(board: LoadedBoard, resourceId: string, options?: TaskOptions): TaskCandidate[];
+/** What a resource is working on right now: assigned to it, in an active status. */
+export declare function currentTasks(board: LoadedBoard, resourceId: string): Issue[];
+/** What a resource finished most recently, newest first. */
+export declare function previousTasks(board: LoadedBoard, resourceId: string, limit?: number): Issue[];