ex-workflow 0.0.0-stage → 0.2.0-stage

package/dist/kanban/index.d.ts

@@ -0,0 +1,225 @@
+import { ClassOfService, Policy, WorkflowState, Role, Stage, Rule, Methodology, Ceremony, CeremonyInput, ItemStatus, WorkItem, Event, CoreTerm } from '../types.js';
+
+type KanbanCadence = "replenishment" | "delivery-planning" | "service-delivery-review" | "operations-review" | "risk-review" | "strategy-review";
+declare const KANBAN_CADENCES: readonly KanbanCadence[];
+declare const CLASSES: readonly ClassOfService[];
+declare const DAY_MS = 86400000;
+interface KanbanColumn {
+    id: string;
+    name: string;
+    wipLimit?: number;
+    /** Explicit policies a card must satisfy before it LEAVES the column (checked by complete()). */
+    policies: Policy[];
+    commitmentPoint?: boolean;
+    deliveryPoint?: boolean;
+    /** Cards entering this column wait for a reviewer (status "review"). */
+    review?: boolean;
+}
+interface ServiceLevel {
+    percentile: number;
+    targetMs: number;
+}
+interface ClassConfig {
+    wipBypass?: number;
+    sle?: ServiceLevel;
+}
+interface KanbanConfig {
+    columns: KanbanColumn[];
+    classesOfService: Partial<Record<ClassOfService, ClassConfig>>;
+    fairness: {
+        aging: boolean;
+        maxDeferralRounds: number;
+    };
+    cadences: Partial<Record<KanbanCadence, {
+        everyTurns?: number;
+    }>>;
+    throughputWindowMs: number;
+    maxExpedite: number;
+}
+declare function configOf(state: WorkflowState): KanbanConfig;
+declare const DEFAULT_COLUMNS: KanbanColumn[];
+declare function validateKanbanConfig(raw: unknown): KanbanConfig;
+
+declare function kanbanRoles(): Role[];
+
+declare function kanbanStages(config: KanbanConfig): Stage[];
+
+declare function kanbanRules(): Rule[];
+
+/** input.items as a non-empty, duplicate-free string[] of existing item ids. */
+declare function wantItems(state: WorkflowState, input: CeremonyInput, cadence: string): string[];
+declare function kanbanCeremonies(methodology: () => Methodology): Record<string, Ceremony>;
+
+/** Statuses that hold a WIP slot. */
+declare const ACTIVE: ReadonlySet<ItemStatus>;
+/** Every status but done and dropped: the cards on the board. */
+declare const OPEN: ReadonlySet<ItemStatus>;
+declare function optionsColumn(state: WorkflowState): Stage;
+declare function commitmentColumn(state: WorkflowState): Stage;
+declare function deliveryColumn(state: WorkflowState): Stage;
+declare function columnIndex(state: WorkflowState, stageId: string): number;
+/** Committed and not yet delivered: column index in [commitment, delivery). */
+declare function onBoard(state: WorkflowState, item: WorkItem): boolean;
+declare function activeExpedites(state: WorkflowState): string[];
+/** ISO time the item last entered its current column; undefined when it was added there and never moved. */
+declare function enteredStageAt(item: WorkItem): string | undefined;
+
+interface BoardCard {
+    id: string;
+    title: string;
+    type: string;
+    status: ItemStatus;
+    classOfService: string;
+    role: string | null;
+    ageMs: number;
+    blocked: boolean;
+    deadline: string | null;
+}
+interface BoardColumn {
+    id: string;
+    name: string;
+    wipLimit: number | null;
+    active: number;
+    queued: number;
+    overLimit: boolean;
+    commitmentPoint: boolean;
+    deliveryPoint: boolean;
+    cards: BoardCard[];
+}
+/** Time the item was added (its item.added event), else the first event's time. */
+declare function addedAt(state: WorkflowState, id: string): string;
+declare function cardAge(state: WorkflowState, item: WorkItem, now: string): number;
+declare function board(state: WorkflowState, now: string): BoardColumn[];
+declare const CADENCE_EVENT: (c: KanbanCadence) => string;
+interface CadenceStatus {
+    cadence: KanbanCadence;
+    everyTurns: number | null;
+    lastAt: string | null;
+    turnsSince: number;
+    due: boolean;
+}
+declare function cadencesDue(state: WorkflowState): CadenceStatus[];
+
+interface OpsReport {
+    blockers: Array<{
+        item: string;
+        blocker: string;
+        owner: string;
+        reason: string;
+        ageMs: number;
+    }>;
+    agingWip: Array<{
+        item: string;
+        column: string;
+        status: string;
+        ageMs: number;
+        p85Ms: number | null;
+        overP85: boolean;
+    }>;
+    queued: Record<string, number>;
+    active: Record<string, number>;
+}
+declare function opsReport(state: WorkflowState, now: string): OpsReport;
+interface RiskReport {
+    fixedDate: Array<{
+        item: string;
+        deadline: string;
+        timeLeftMs: number;
+        projectedRemainingMs: number | null;
+        atRisk: boolean;
+    }>;
+    staleBlockers: Array<{
+        item: string;
+        blocker: string;
+        owner: string;
+        ageMs: number;
+    }>;
+    expediteActive: string[];
+}
+declare function riskReport(state: WorkflowState, now: string, staleAfterMs: number): RiskReport;
+
+interface Stay {
+    stage: string;
+    enteredAt: string;
+    leftAt?: string;
+}
+interface ReplayedItem {
+    id: string;
+    /** item type from item.added; "question" items are escalations, not deliveries */
+    type: string;
+    stage: string;
+    status: ItemStatus;
+    /** one entry per contiguous visit to a column; status changes inside a column do not end a stay */
+    stays: Stay[];
+    /** first entry into the commitment column */
+    committedAt?: string;
+    /** first entry into the delivery column */
+    deliveredAt?: string;
+    /** from the replenishment payload; "standard" when never replenished */
+    classOfService: ClassOfService;
+    deadline?: string;
+    /** closed in_progress intervals */
+    activeMs: number;
+    /** closed blocked intervals */
+    blockedMs: number;
+    /** the open status interval */
+    since: {
+        status: ItemStatus;
+        at: string;
+    };
+}
+interface ReplayedBlocker {
+    item: string;
+    blocker: string;
+    raisedAt: string;
+    clearedAt?: string;
+}
+interface Replay {
+    items: Map<string, ReplayedItem>;
+    blockers: ReplayedBlocker[];
+    /** time of the last event: the clock every "still open" measurement uses */
+    lastAt: string;
+}
+declare function replay(events: Event[], commitment: string, delivery: string): Replay;
+
+interface KanbanMetrics {
+    leadTimeMs: number[];
+    leadTimeP50: number;
+    leadTimeP85: number;
+    cycleTimeMsByColumn: Record<string, number>;
+    throughput: number[];
+    wipByColumn: Record<string, number>;
+    flowEfficiency: number;
+    agingWipMs: Record<string, number>;
+    cumulativeFlow: Record<string, number>;
+    sleCompliance: Record<string, number>;
+    blockerTimeMs: number;
+    meanBlockerTimeMs: number;
+}
+/** Nearest-rank percentile; 0 for an empty list. */
+declare function percentile(values: number[], p: number): number;
+/** Completed stay durations per column. */
+declare function columnStays(state: WorkflowState): Record<string, number[]>;
+declare function kanbanMetrics(state: WorkflowState): KanbanMetrics;
+
+declare const KANBAN_VOCABULARY: Record<CoreTerm, string>;
+
+/** What the priority function needs besides the card: how long it has been passed over, and the fairness config. */
+interface PriorityContext {
+    /** next() rounds that resolved since the card entered its column */
+    deferrals: number;
+    aging: boolean;
+    maxDeferralRounds: number;
+}
+/**
+ * Class band x 1e15 + an in-band offset. Bands: question 5, expedite 4, fixed-date 3, standard 2,
+ * intangible 1. Fixed-date: earlier deadline = larger offset. Others: own priority (clamped to +-1e9)
+ * plus, with aging, 4e9 per full window of maxDeferralRounds deferrals (priority decides within a window). An intangible card deferred that many
+ * times is scored in the standard band, so it overtakes fresh standard cards.
+ */
+declare function priorityByClass(item: WorkItem, ctx: PriorityContext): number;
+/** Class rank, then the card that has waited longest in its column, then id (FIFO by aging). */
+declare function byClassThenAge(a: WorkItem, b: WorkItem): number;
+declare function kanban(): Methodology<KanbanConfig>;
+
+export { ACTIVE, type BoardCard, type BoardColumn, CADENCE_EVENT, CLASSES, type CadenceStatus, type ClassConfig, DAY_MS, DEFAULT_COLUMNS, KANBAN_CADENCES, KANBAN_VOCABULARY, type KanbanCadence, type KanbanColumn, type KanbanConfig, type KanbanMetrics, OPEN, type OpsReport, type PriorityContext, type Replay, type ReplayedBlocker, type ReplayedItem, type RiskReport, type ServiceLevel, type Stay, activeExpedites, addedAt, board, byClassThenAge, cadencesDue, cardAge, columnIndex, columnStays, commitmentColumn, configOf, deliveryColumn, enteredStageAt, kanban, kanbanCeremonies, kanbanMetrics, kanbanRoles, kanbanRules, kanbanStages, onBoard, opsReport, optionsColumn, percentile, priorityByClass, replay, riskReport, validateKanbanConfig, wantItems };

package/dist/kanban/index.mjs

@@ -0,0 +1,2 @@
+export{a as ACTIVE,s as CADENCE_EVENT,k as CLASSES,l as DAY_MS,n as DEFAULT_COLUMNS,j as KANBAN_CADENCES,F as KANBAN_VOCABULARY,b as OPEN,h as activeExpedites,p as addedAt,r as board,H as byClassThenAge,t as cadencesDue,q as cardAge,f as columnIndex,w as columnStays,d as commitmentColumn,m as configOf,e as deliveryColumn,i as enteredStageAt,I as kanban,B as kanbanCeremonies,x as kanbanMetrics,C as kanbanRoles,D as kanbanRules,E as kanbanStages,g as onBoard,y as opsReport,c as optionsColumn,v as percentile,G as priorityByClass,u as replay,z as riskReport,o as validateKanbanConfig,A as wantItems}from'../chunk-XSXHEEJX.mjs';import'../chunk-NQU5TH3A.mjs';import'../chunk-2FRRD6A3.mjs';//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/kanban/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.mjs"}

package/dist/roles-BLBRKhUZ.d.ts

@@ -0,0 +1,14 @@
+import { WorkflowState, Role, Capability } from './types.js';
+
+declare function registerRole(state: WorkflowState, role: Role, by: string, now?: string): WorkflowState;
+declare function retireRole(state: WorkflowState, roleId: string, by: string, now?: string): WorkflowState;
+declare function hasCapability(role: Role, cap: Capability): boolean;
+declare function rolesWith(state: WorkflowState, cap: Capability): Role[];
+declare function approversFor(state: WorkflowState, gateId: string): Role[];
+declare function requireCapabilities(state: WorkflowState, required: Capability[], exclusive: Capability[]): void;
+declare function separationLost(state: WorkflowState, required: Capability[]): Role[];
+/** `human` may do anything; a role must hold at least one of `caps`; unknown ids may do nothing. */
+declare function canDo(state: WorkflowState, by: string, ...caps: Capability[]): boolean;
+declare function requireCap(state: WorkflowState, by: string, ...caps: Capability[]): void;
+
+export { approversFor as a, requireCap as b, canDo as c, requireCapabilities as d, retireRole as e, rolesWith as f, hasCapability as h, registerRole as r, separationLost as s };

package/dist/roles-aneKYJ3Z.d.cts

@@ -0,0 +1,14 @@
+import { WorkflowState, Role, Capability } from './types.cjs';
+
+declare function registerRole(state: WorkflowState, role: Role, by: string, now?: string): WorkflowState;
+declare function retireRole(state: WorkflowState, roleId: string, by: string, now?: string): WorkflowState;
+declare function hasCapability(role: Role, cap: Capability): boolean;
+declare function rolesWith(state: WorkflowState, cap: Capability): Role[];
+declare function approversFor(state: WorkflowState, gateId: string): Role[];
+declare function requireCapabilities(state: WorkflowState, required: Capability[], exclusive: Capability[]): void;
+declare function separationLost(state: WorkflowState, required: Capability[]): Role[];
+/** `human` may do anything; a role must hold at least one of `caps`; unknown ids may do nothing. */
+declare function canDo(state: WorkflowState, by: string, ...caps: Capability[]): boolean;
+declare function requireCap(state: WorkflowState, by: string, ...caps: Capability[]): void;
+
+export { approversFor as a, requireCap as b, canDo as c, requireCapabilities as d, retireRole as e, rolesWith as f, hasCapability as h, registerRole as r, separationLost as s };

package/dist/scrum/index.cjs

@@ -0,0 +1,2 @@
+'use strict';var chunk472WEDPJ_cjs=require('../chunk-472WEDPJ.cjs');require('../chunk-QDT35LXB.cjs');var chunkJDVE7DQR_cjs=require('../chunk-JDVE7DQR.cjs');require('../chunk-S3BXVHO7.cjs');Object.defineProperty(exports,"SCRUM_VOCABULARY",{enumerable:true,get:function(){return chunk472WEDPJ_cjs.h}});Object.defineProperty(exports,"closeSprint",{enumerable:true,get:function(){return chunk472WEDPJ_cjs.j}});Object.defineProperty(exports,"configOf",{enumerable:true,get:function(){return chunk472WEDPJ_cjs.i}});Object.defineProperty(exports,"dailyReport",{enumerable:true,get:function(){return chunk472WEDPJ_cjs.a}});Object.defineProperty(exports,"scrum",{enumerable:true,get:function(){return chunk472WEDPJ_cjs.k}});Object.defineProperty(exports,"scrumCeremonies",{enumerable:true,get:function(){return chunk472WEDPJ_cjs.b}});Object.defineProperty(exports,"scrumMetrics",{enumerable:true,get:function(){return chunk472WEDPJ_cjs.d}});Object.defineProperty(exports,"scrumRoles",{enumerable:true,get:function(){return chunk472WEDPJ_cjs.e}});Object.defineProperty(exports,"scrumRules",{enumerable:true,get:function(){return chunk472WEDPJ_cjs.f}});Object.defineProperty(exports,"scrumStages",{enumerable:true,get:function(){return chunk472WEDPJ_cjs.g}});Object.defineProperty(exports,"validateScrumConfig",{enumerable:true,get:function(){return chunk472WEDPJ_cjs.c}});Object.defineProperty(exports,"canDo",{enumerable:true,get:function(){return chunkJDVE7DQR_cjs.n}});//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/scrum/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.cjs"}

package/dist/scrum/index.d.cts

@@ -0,0 +1,59 @@
+import { Budget, Policy, WorkflowState, Role, Rule, Stage, ItemStatus, Methodology, Ceremony, CoreTerm } from '../types.cjs';
+export { c as canDo } from '../roles-aneKYJ3Z.cjs';
+
+interface ScrumConfig {
+    sprintBudget: Budget;
+    productGoal: string;
+    definitionOfDone: Policy[];
+    refinementSharePct: number;
+    allowMidSprintAdd: "never" | "po-only" | "any";
+    inProgressWipLimit?: number;
+}
+declare function validateScrumConfig(raw: unknown): ScrumConfig;
+
+interface ScrumMetrics {
+    velocity: number[];
+    meanVelocity: number;
+    burndown: number[];
+    commitmentReliability: number;
+    sprintGoalHitRate: number;
+    carryoverRatio: number;
+    budgetUtilisation: number;
+    costPerPoint: number;
+}
+declare function scrumMetrics(state: WorkflowState): ScrumMetrics;
+
+declare function scrumRoles(): Role[];
+
+declare function scrumRules(): Rule[];
+
+declare function scrumStages(config: ScrumConfig): Stage[];
+
+interface DailyReport {
+    sprint: string | null;
+    goal: string | null;
+    byStatus: Record<ItemStatus, number>;
+    blockers: Array<{
+        item: string;
+        blocker: string;
+        owner: string;
+        reason: string;
+    }>;
+    spent: Required<Budget>;
+    remaining: Budget;
+    remainingWeight: number;
+    raisedLessons: number;
+    velocity: number | null;
+    forecast: "on-track" | "at-risk" | "unknown";
+}
+declare function dailyReport(state: WorkflowState): DailyReport;
+declare function scrumCeremonies(methodology: () => Methodology): Record<string, Ceremony>;
+
+declare const SCRUM_VOCABULARY: Record<CoreTerm, string>;
+/** Advanced; used by ceremonies. */
+declare function configOf(state: WorkflowState): ScrumConfig;
+/** Advanced; used by ceremonies. Closes the open sprint and returns unfinished work (and its open questions) to the backlog. */
+declare function closeSprint(state: WorkflowState, reason: "budget" | "review" | "cancel", now: string): WorkflowState;
+declare function scrum(): Methodology<ScrumConfig>;
+
+export { type DailyReport, SCRUM_VOCABULARY, type ScrumConfig, type ScrumMetrics, closeSprint, configOf, dailyReport, scrum, scrumCeremonies, scrumMetrics, scrumRoles, scrumRules, scrumStages, validateScrumConfig };

package/dist/scrum/index.d.ts

@@ -0,0 +1,59 @@
+import { Budget, Policy, WorkflowState, Role, Rule, Stage, ItemStatus, Methodology, Ceremony, CoreTerm } from '../types.js';
+export { c as canDo } from '../roles-BLBRKhUZ.js';
+
+interface ScrumConfig {
+    sprintBudget: Budget;
+    productGoal: string;
+    definitionOfDone: Policy[];
+    refinementSharePct: number;
+    allowMidSprintAdd: "never" | "po-only" | "any";
+    inProgressWipLimit?: number;
+}
+declare function validateScrumConfig(raw: unknown): ScrumConfig;
+
+interface ScrumMetrics {
+    velocity: number[];
+    meanVelocity: number;
+    burndown: number[];
+    commitmentReliability: number;
+    sprintGoalHitRate: number;
+    carryoverRatio: number;
+    budgetUtilisation: number;
+    costPerPoint: number;
+}
+declare function scrumMetrics(state: WorkflowState): ScrumMetrics;
+
+declare function scrumRoles(): Role[];
+
+declare function scrumRules(): Rule[];
+
+declare function scrumStages(config: ScrumConfig): Stage[];
+
+interface DailyReport {
+    sprint: string | null;
+    goal: string | null;
+    byStatus: Record<ItemStatus, number>;
+    blockers: Array<{
+        item: string;
+        blocker: string;
+        owner: string;
+        reason: string;
+    }>;
+    spent: Required<Budget>;
+    remaining: Budget;
+    remainingWeight: number;
+    raisedLessons: number;
+    velocity: number | null;
+    forecast: "on-track" | "at-risk" | "unknown";
+}
+declare function dailyReport(state: WorkflowState): DailyReport;
+declare function scrumCeremonies(methodology: () => Methodology): Record<string, Ceremony>;
+
+declare const SCRUM_VOCABULARY: Record<CoreTerm, string>;
+/** Advanced; used by ceremonies. */
+declare function configOf(state: WorkflowState): ScrumConfig;
+/** Advanced; used by ceremonies. Closes the open sprint and returns unfinished work (and its open questions) to the backlog. */
+declare function closeSprint(state: WorkflowState, reason: "budget" | "review" | "cancel", now: string): WorkflowState;
+declare function scrum(): Methodology<ScrumConfig>;
+
+export { type DailyReport, SCRUM_VOCABULARY, type ScrumConfig, type ScrumMetrics, closeSprint, configOf, dailyReport, scrum, scrumCeremonies, scrumMetrics, scrumRoles, scrumRules, scrumStages, validateScrumConfig };

package/dist/scrum/index.mjs

@@ -0,0 +1,2 @@
+export{h as SCRUM_VOCABULARY,j as closeSprint,i as configOf,a as dailyReport,k as scrum,b as scrumCeremonies,d as scrumMetrics,e as scrumRoles,f as scrumRules,g as scrumStages,c as validateScrumConfig}from'../chunk-IBRC36PE.mjs';import'../chunk-PD5FBDN7.mjs';export{n as canDo}from'../chunk-NQU5TH3A.mjs';import'../chunk-2FRRD6A3.mjs';//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/scrum/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.mjs"}

package/dist/types.cjs

@@ -0,0 +1,2 @@
+'use strict';require('./chunk-PO2SPQJP.cjs');//# sourceMappingURL=types.cjs.map
+//# sourceMappingURL=types.cjs.map

package/dist/types.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"types.cjs"}