@femtomc/mu-core 26.2.70 → 26.2.72

package/dist/dag.d.ts

@@ -3,11 +3,44 @@ export type ValidationResult = {
     is_final: boolean;
     reason: string;
 };
+export type RetryableDagCandidate = {
+    issue: Issue;
+    reason: string;
+};
+/**
+ * Deterministic DAG reconcile primitives used by orchestrator reconciliation.
+ *
+ * Contract: these helpers are pure functions over the provided issue snapshot and must remain
+ * side-effect free so reconcile passes are replayable/idempotent.
+ */
+export declare const DAG_RECONCILE_PRIMITIVE_INVARIANTS: readonly ["DAG-RECON-001: `readyLeaves` only returns open, unblocked, leaf issues within the requested subtree scope.", "DAG-RECON-002: `readyLeaves` ordering is deterministic for a fixed input snapshot (priority-ordered candidate set).", "DAG-RECON-003: `validateDag(...).is_final=true` implies no remaining non-expanded open work in the subtree.", "DAG-RECON-004: closed(failure|needs_work) and expanded-without-children are non-final and require reconcile action.", "DAG-RECON-005: `retryableDagCandidates` selection is deterministic and side-effect free for a fixed snapshot + attempts map."];
 export declare function subtreeIds(issues: readonly Issue[], rootId: string): string[];
+/**
+ * Reconcile selection primitive: the orchestrator must only dispatch from this ready set (or an
+ * equivalent deterministic adapter) to preserve replayability.
+ */
 export declare function readyLeaves(issues: readonly Issue[], opts?: {
     root_id?: string;
     tags?: readonly string[];
 }): Issue[];
+/**
+ * Reconcile retry primitive.
+ *
+ * Produces a deterministic list of closed nodes that are eligible to be reopened for orchestration.
+ * The orchestrator decides whether/when to apply the reopen side effect.
+ */
+export declare function retryableDagCandidates(issues: readonly Issue[], opts: {
+    root_id: string;
+    retry_outcomes?: readonly string[];
+    attempts_by_issue_id?: ReadonlyMap<string, number>;
+    max_attempts?: number;
+}): RetryableDagCandidate[];
 export declare function collapsible(issues: readonly Issue[], rootId: string): Issue[];
+/**
+ * Reconcile termination primitive.
+ *
+ * `is_final=false` is a hard signal that orchestrator must continue reconciling (or repair invalid
+ * expanded state) before the root run can be considered terminal.
+ */
 export declare function validateDag(issues: readonly Issue[], rootId: string): ValidationResult;
 //# sourceMappingURL=dag.d.ts.map

package/dist/dag.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dag.d.ts","sourceRoot":"","sources":["../src/dag.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC;AAEvC,MAAM,MAAM,gBAAgB,GAAG;IAC9B,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CACf,CAAC;AAiBF,wBAAgB,UAAU,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAuB7E;AAED,wBAAgB,WAAW,CAC1B,MAAM,EAAE,SAAS,KAAK,EAAE,EACxB,IAAI,GAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAAO,GACvD,KAAK,EAAE,CAuCT;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,KAAK,EAAE,CA2B7E;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,gBAAgB,CAqDtF"}
+{"version":3,"file":"dag.d.ts","sourceRoot":"","sources":["../src/dag.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC;AAEvC,MAAM,MAAM,gBAAgB,GAAG;IAC9B,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IACnC,KAAK,EAAE,KAAK,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CACf,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,kCAAkC,slBAMrC,CAAC;AA0BX,wBAAgB,UAAU,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAuB7E;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAC1B,MAAM,EAAE,SAAS,KAAK,EAAE,EACxB,IAAI,GAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAAO,GACvD,KAAK,EAAE,CAuCT;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACrC,MAAM,EAAE,SAAS,KAAK,EAAE,EACxB,IAAI,EAAE;IACL,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,oBAAoB,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnD,YAAY,CAAC,EAAE,MAAM,CAAC;CACtB,GACC,qBAAqB,EAAE,CAsCzB;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,KAAK,EAAE,CA6B7E;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,gBAAgB,CAqDtF"}

package/dist/dag.js

@@ -1,3 +1,16 @@
+/**
+ * Deterministic DAG reconcile primitives used by orchestrator reconciliation.
+ *
+ * Contract: these helpers are pure functions over the provided issue snapshot and must remain
+ * side-effect free so reconcile passes are replayable/idempotent.
+ */
+export const DAG_RECONCILE_PRIMITIVE_INVARIANTS = [
+    "DAG-RECON-001: `readyLeaves` only returns open, unblocked, leaf issues within the requested subtree scope.",
+    "DAG-RECON-002: `readyLeaves` ordering is deterministic for a fixed input snapshot (priority-ordered candidate set).",
+    "DAG-RECON-003: `validateDag(...).is_final=true` implies no remaining non-expanded open work in the subtree.",
+    "DAG-RECON-004: closed(failure|needs_work) and expanded-without-children are non-final and require reconcile action.",
+    "DAG-RECON-005: `retryableDagCandidates` selection is deterministic and side-effect free for a fixed snapshot + attempts map.",
+];
 function childrenByParent(issues) {
     const byParent = new Map();
     for (const issue of issues) {
@@ -12,6 +25,14 @@ function childrenByParent(issues) {
     }
     return byParent;
 }
+function compareByPriorityThenId(a, b) {
+    const pa = a.priority ?? 3;
+    const pb = b.priority ?? 3;
+    if (pa !== pb) {
+        return pa - pb;
+    }
+    return a.id.localeCompare(b.id);
+}
 export function subtreeIds(issues, rootId) {
     const children = childrenByParent(issues);
     const result = [];
@@ -33,6 +54,10 @@ export function subtreeIds(issues, rootId) {
     }
     return result;
 }
+/**
+ * Reconcile selection primitive: the orchestrator must only dispatch from this ready set (or an
+ * equivalent deterministic adapter) to preserve replayability.
+ */
 export function readyLeaves(issues, opts = {}) {
     const byId = new Map(issues.map((i) => [i.id, i]));
     const idsInScope = new Set(opts.root_id ? subtreeIds(issues, opts.root_id) : byId.keys());
@@ -66,14 +91,55 @@ export function readyLeaves(issues, opts = {}) {
         }
         result.push(issue);
     }
-    result.sort((a, b) => (a.priority ?? 3) - (b.priority ?? 3));
+    result.sort(compareByPriorityThenId);
     return result;
 }
+/**
+ * Reconcile retry primitive.
+ *
+ * Produces a deterministic list of closed nodes that are eligible to be reopened for orchestration.
+ * The orchestrator decides whether/when to apply the reopen side effect.
+ */
+export function retryableDagCandidates(issues, opts) {
+    const idsInScope = new Set(subtreeIds(issues, opts.root_id));
+    const children = childrenByParent(issues);
+    const retryOutcomes = new Set(opts.retry_outcomes ?? ["failure", "needs_work"]);
+    const maxAttempts = typeof opts.max_attempts === "number" && Number.isFinite(opts.max_attempts)
+        ? Math.max(1, Math.trunc(opts.max_attempts))
+        : Number.POSITIVE_INFINITY;
+    const out = [];
+    for (const issue of issues) {
+        if (!idsInScope.has(issue.id)) {
+            continue;
+        }
+        if (issue.status !== "closed") {
+            continue;
+        }
+        const attempts = opts.attempts_by_issue_id?.get(issue.id) ?? 0;
+        if (attempts >= maxAttempts) {
+            continue;
+        }
+        if (issue.outcome && retryOutcomes.has(issue.outcome)) {
+            const hasOpenChildren = (children.get(issue.id) ?? []).some((child) => child.status !== "closed");
+            if (!hasOpenChildren) {
+                out.push({ issue, reason: `outcome=${issue.outcome}` });
+            }
+            continue;
+        }
+        if (issue.outcome === "expanded" && (children.get(issue.id)?.length ?? 0) === 0) {
+            out.push({ issue, reason: "outcome=expanded_without_children" });
+        }
+    }
+    out.sort((a, b) => compareByPriorityThenId(a.issue, b.issue));
+    return out;
+}
 export function collapsible(issues, rootId) {
     const byId = new Map(issues.map((i) => [i.id, i]));
     const idsInScope = new Set(subtreeIds(issues, rootId));
     const children = childrenByParent(issues);
-    const terminalOutcomes = new Set(["success", "skipped"]);
+    // `refine` is terminal for a closed reviewer node; refinement itself is
+    // orchestrated by root-phase reconcile transitions.
+    const terminalOutcomes = new Set(["success", "skipped", "refine"]);
     const result = [];
     for (const issueId of idsInScope) {
         const node = byId.get(issueId);
@@ -94,6 +160,12 @@ export function collapsible(issues, rootId) {
     result.sort((a, b) => a.id.localeCompare(b.id));
     return result;
 }
+/**
+ * Reconcile termination primitive.
+ *
+ * `is_final=false` is a hard signal that orchestrator must continue reconciling (or repair invalid
+ * expanded state) before the root run can be considered terminal.
+ */
 export function validateDag(issues, rootId) {
     const byId = new Map(issues.map((i) => [i.id, i]));
     const ids = new Set(subtreeIds(issues, rootId));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@femtomc/mu-core",
-  "version": "26.2.70",
+  "version": "26.2.72",
   "description": "Core primitives for mu: IDs, events, DAG helpers, and persistence interfaces.",
   "keywords": [
     "mu",