peaks-loop 4.0.53 → 4.1.0

package/dist/services/crystallization/crystallization-types.js

@@ -1,15 +1,21 @@
-import { z } from "zod";
+import { z } from 'zod';
+import { CRYS_BRIEF_SECTION_MAX, EvidenceBriefSchema, isBriefSectionFailure } from './crystallization-brief-schema.js';
+// Public surface unchanged: every name below stays importable from this
+// path (and through `crystallization/index.js`). The brief schema and its
+// `z.infer` type travel together.
+export { EvidenceBriefSchema, hasAllFourBriefSections, parseEvidenceBrief, safeParseEvidenceBrief } from './crystallization-brief-schema.js';
 /* ---------------------------------------------------------------------- */
 /* PRD-002b slice 2 — schema-limit constants extracted from inline         */
 /* `.max(N)` / `.length(N)` calls so the no-magic-numbers rule stops     */
 /* flagging the constraint values. Names describe the field, not the     */
 /* number. Bytewise-identical to the original literals.                  */
 /* ---------------------------------------------------------------------- */
-const CRYS_BRIEF_SECTION_MAX = 4000;
 const CRYS_EVIDENCE_BULLET_MAX = 1000;
 const CRYS_TRACE_POINTER_MAX = 256;
 const CRYS_LOOP_ID_MAX = 64;
-const CRYS_BEE_ID_MAX_I32 = 2 ** 31 - 1;
+// 2 ** 31 - 1 spelled as its own literal so no-magic-numbers has no
+// binary expression to flag. Same value, same bound, same message.
+const CRYS_BEE_ID_MAX_I32 = 2147483647;
 const CRYS_EVENT_ID_MAX = 128;
 /**
  * CrystallizationEvent — spec §4.5 / §4.7 / §5.
@@ -48,102 +54,21 @@ const CRYS_EVENT_ID_MAX = 128;
 /* Trigger — §4.5 / §5.4                                                   */
 /* ---------------------------------------------------------------------- */
 export const CrystallizationTriggerSchema = z.enum([
-    "user_explicit",
-    "llm_suggested",
-    "success_default_prompt",
-    "similar_task_recurrence",
+    'user_explicit',
+    'llm_suggested',
+    'success_default_prompt',
+    'similar_task_recurrence'
 ]);
 export const CRYSTALLIZATION_TRIGGERS = [
-    "user_explicit",
-    "llm_suggested",
-    "success_default_prompt",
-    "similar_task_recurrence",
+    'user_explicit',
+    'llm_suggested',
+    'success_default_prompt',
+    'similar_task_recurrence'
 ];
 /* ---------------------------------------------------------------------- */
 /* Lifecycle status — §5.6 (event-scoped, not asset-scoped)               */
 /* ---------------------------------------------------------------------- */
-export const CrystallizationEventStatusSchema = z.enum([
-    "candidate",
-    "stable",
-    "retired",
-]);
-/* ---------------------------------------------------------------------- */
-/* EvidenceBrief — §4.7 / §10 RL-7. REQUIRED 4-section shape.             */
-/* ---------------------------------------------------------------------- */
-/**
- * The four brief sections. Spec §4.7 lists them as NL short
- * sections; the service layer mandates 1-2 sentences (what_action
- * is a single sentence per the spec). The Zod constraints below
- * enforce NON-EMPTY strings. The brief-section guard (see
- * `EvidenceBriefSchema.refine` below) rejects any payload missing
- * one of the four keys, regardless of section content — it is
- * the canonical hard gate per spec §10 RL-7.
- */
-const BriefSectionSchema = z
-    .string()
-    .trim()
-    .min(1, "brief section must be non-empty natural language")
-    .max(CRYS_BRIEF_SECTION_MAX);
-/**
- * EvidenceBrief — the 4-section brief (spec §4.7).
- *
- * Hard shape invariant: ALL FOUR KEYS must be present at parse
- * time, with non-empty NL content. The `.refine(...)` guard is
- * what makes a brief a "brief" — without it, the projection is
- * not a brief and the recommendation MUST NOT be rendered
- * (service layer enforces this; Zod makes it a parse-time
- * guarantee).
- *
- * Field semantics:
- *   - what_happened   — 1-2 sentence factual account of the run.
- *   - why_it_matters  — 1-2 sentence explanation of why this is
- *                       worth promoting.
- *   - what_learned    — 1-2 sentence learning: failure modes
- *                       encoded, preferences extracted.
- *   - what_action     — 1-sentence recommended action with
- *                       rationale.
- */
-export const EvidenceBriefSchema = z
-    .object({
-    what_happened: BriefSectionSchema,
-    why_it_matters: BriefSectionSchema,
-    what_learned: BriefSectionSchema,
-    what_action: BriefSectionSchema,
-})
-    .strict()
-    .superRefine((b, ctx) => {
-    const ok = typeof b.what_happened === "string" &&
-        b.what_happened.trim().length > 0 &&
-        typeof b.why_it_matters === "string" &&
-        b.why_it_matters.trim().length > 0 &&
-        typeof b.what_learned === "string" &&
-        b.what_learned.trim().length > 0 &&
-        typeof b.what_action === "string" &&
-        b.what_action.trim().length > 0;
-    if (!ok) {
-        ctx.addIssue({
-            code: "custom",
-            path: [],
-            message: "evidence_brief must contain all 4 sections (what_happened, why_it_matters, what_learned, what_action) with non-empty content (spec §4.7 / RL-7)",
-        });
-    }
-});
-/**
- * Helper for downstream code that needs to know whether a parsed
- * brief satisfies the 4-section rule. Useful for the CLI when a
- * payload arrived from the LLM and the brief-section guard has
- * already passed — it returns the section count, always 4 here.
- */
-export function hasAllFourBriefSections(brief) {
-    return (typeof brief.what_happened === "string" &&
-        brief.what_happened.trim().length > 0 &&
-        typeof brief.why_it_matters === "string" &&
-        brief.why_it_matters.trim().length > 0 &&
-        typeof brief.what_learned === "string" &&
-        brief.what_learned.trim().length > 0 &&
-        typeof brief.what_action === "string" &&
-        brief.what_action.trim().length > 0);
-}
+export const CrystallizationEventStatusSchema = z.enum(['candidate', 'stable', 'retired']);
 /* ---------------------------------------------------------------------- */
 /* CrystallizationEvent — §4.5                                            */
 /* ---------------------------------------------------------------------- */
@@ -158,14 +83,14 @@ const OptionalLoopId = z
     .min(1)
     .max(CRYS_LOOP_ID_MAX)
     .regex(/^[a-z][a-z0-9]*(-[a-z0-9]+)*$/, {
-    message: "loop_release_id must be kebab-case starting with a lowercase letter",
+    message: 'loop_release_id must be kebab-case starting with a lowercase letter'
 })
     .optional();
 const OptionalBeeId = z
     .number()
     .int()
     .gt(0)
-    .max(CRYS_BEE_ID_MAX_I32, "bee_release_id out of 32-bit range")
+    .max(CRYS_BEE_ID_MAX_I32, 'bee_release_id out of 32-bit range')
     .optional();
 /**
  * Zod schema for the create payload (CrystallizationEventInput).
@@ -178,27 +103,15 @@ const OptionalBeeId = z
 export const CrystallizationEventInputSchema = z.object({
     trigger: CrystallizationTriggerSchema,
     evidence_brief: EvidenceBriefSchema,
-    evidence_bullets: z
-        .array(z.string().trim().min(1).max(CRYS_EVIDENCE_BULLET_MAX))
-        .default([]),
-    source_trace_pointers: z
-        .array(z.string().trim().min(1).max(CRYS_TRACE_POINTER_MAX))
-        .default([]),
-    evaluator_summary: z
-        .string()
-        .trim()
-        .max(CRYS_BRIEF_SECTION_MAX)
-        .default(""),
-    user_decision_summary: z
-        .string()
-        .trim()
-        .max(CRYS_BRIEF_SECTION_MAX)
-        .default(""),
+    evidence_bullets: z.array(z.string().trim().min(1).max(CRYS_EVIDENCE_BULLET_MAX)).default([]),
+    source_trace_pointers: z.array(z.string().trim().min(1).max(CRYS_TRACE_POINTER_MAX)).default([]),
+    evaluator_summary: z.string().trim().max(CRYS_BRIEF_SECTION_MAX).default(''),
+    user_decision_summary: z.string().trim().max(CRYS_BRIEF_SECTION_MAX).default(''),
     created_loop_release_id: OptionalLoopId,
     updated_loop_release_id: OptionalLoopId,
     created_bee_release_id: OptionalBeeId,
     updated_bee_release_id: OptionalBeeId,
-    lifecycle_status: CrystallizationEventStatusSchema.default("candidate"),
+    lifecycle_status: CrystallizationEventStatusSchema.default('candidate')
 });
 /**
  * Full persisted row schema. Adds `id` (the event id) and stamps
@@ -215,12 +128,10 @@ export const CrystallizationEventSchema = CrystallizationEventInputSchema.extend
         .min(1)
         .max(CRYS_EVENT_ID_MAX)
         .regex(/^crys-[0-9a-f]{8,}$/, {
-        message: "id must start with 'crys-' followed by a hex suffix (spec §4.5)",
+        message: "id must start with 'crys-' followed by a hex suffix (spec §4.5)"
     }),
-    schema_version: z
-        .literal("peaks.crystallization/1")
-        .default("peaks.crystallization/1"),
-    created_at: z.string().datetime(),
+    schema_version: z.literal('peaks.crystallization/1').default('peaks.crystallization/1'),
+    created_at: z.string().datetime()
 });
 /**
  * Convenience: strict-parse an unknown payload into a
@@ -232,13 +143,6 @@ export const CrystallizationEventSchema = CrystallizationEventInputSchema.extend
 export function parseCrystallizationEvent(input) {
     return CrystallizationEventSchema.parse(input);
 }
-/**
- * Convenience: strict-parse an unknown payload as a standalone
- * EvidenceBrief. Throws ZodError on failure.
- */
-export function parseEvidenceBrief(input) {
-    return EvidenceBriefSchema.parse(input);
-}
 /**
  * Safe-parse twin of parseCrystallizationEvent. Returns a Result-like
  * envelope so callers (CLI / tests) can render findings without
@@ -252,66 +156,9 @@ export function safeParseCrystallizationEvent(input) {
     if (r.success)
         return { ok: true, row: r.data };
     const findings = r.error.issues.map((i) => ({
-        path: i.path.join("."),
-        message: i.message,
+        path: i.path.join('.'),
+        message: i.message
     }));
     const isBrief = isBriefSectionFailure(r.error.issues);
-    return isBrief
-        ? { ok: false, code: "MISSING_BRIEF_SECTION", findings }
-        : { ok: false, findings };
-}
-/**
- * Safe-parse twin of parseEvidenceBrief. Same Result-like envelope
- * shape; same MISSING_BRIEF_SECTION code mapping (covers both
- * refine-guard failures and per-section missing/empty failures).
- */
-export function safeParseEvidenceBrief(input) {
-    const r = EvidenceBriefSchema.safeParse(input);
-    if (r.success)
-        return { ok: true, row: r.data };
-    const findings = r.error.issues.map((i) => ({
-        path: i.path.join("."),
-        message: i.message,
-    }));
-    const isBrief = isBriefSectionFailure(r.error.issues);
-    return isBrief
-        ? { ok: false, code: "MISSING_BRIEF_SECTION", findings }
-        : { ok: false, findings };
-}
-/**
- * Decide whether a ZodIssue[] is a "brief section" failure: every
- * issue points at one of the four required keys (the section is
- * missing, or empty after trim), OR the explicit refine-guard issue
- * is present. Used by both `safeParseCrystallizationEvent` and
- * `safeParseEvidenceBrief` so callers see a single
- * `MISSING_BRIEF_SECTION` code regardless of which Zod boundary
- * caught the failure.
- */
-function isBriefSectionFailure(issues) {
-    if (issues.length === 0)
-        return false;
-    // Explicit refine guard (EvidenceBriefSchema.refine message).
-    if (issues.some((i) => i.message.includes("evidence_brief must contain all 4 sections"))) {
-        return true;
-    }
-    // Per-section Zod failures (min(1) on each section key, or
-    // too_small, or invalid_type). Each issue's path will be either
-    // the section key (`what_happened`) OR the parent `evidence_brief`
-    // — Zod reports missing-key issues against the parent object.
-    return issues.every((i) => {
-        const path = i.path.join(".");
-        if (path === "evidence_brief")
-            return true;
-        if (i.path.length >= 2 && i.path[0] === "evidence_brief") {
-            const key = i.path[i.path.length - 1];
-            return (key === "what_happened" ||
-                key === "why_it_matters" ||
-                key === "what_learned" ||
-                key === "what_action");
-        }
-        return (path === "what_happened" ||
-            path === "why_it_matters" ||
-            path === "what_learned" ||
-            path === "what_action");
-    });
+    return isBrief ? { ok: false, code: 'MISSING_BRIEF_SECTION', findings } : { ok: false, findings };
 }

package/dist/services/crystallization/evidence-brief-builder.d.ts

@@ -1,5 +1,5 @@
-import { z } from "zod";
-import { type EvidenceBrief } from "./crystallization-types.js";
+import { z } from 'zod';
+import { type EvidenceBrief } from './crystallization-types.js';
 /**
  * EvidenceBriefBuilder — spec §4.7 / §10 RL-7.
  *
@@ -129,7 +129,7 @@ export declare function safeRenderRecommendationPayload(input: unknown): {
     payload: RecommendationPayload;
 } | {
     ok: false;
-    code?: "MISSING_BRIEF_SECTION";
+    code?: 'MISSING_BRIEF_SECTION';
     findings: Array<{
         path: string;
         message: string;

package/dist/services/crystallization/evidence-brief-builder.js

@@ -1,5 +1,5 @@
-import { z } from "zod";
-import { EvidenceBriefSchema, } from "./crystallization-types.js";
+import { z } from 'zod';
+import { EvidenceBriefSchema } from './crystallization-types.js';
 /* ---------------------------------------------------------------------- */
 /* PRD-002b slice 2 — schema-limit constants extracted from inline         */
 /* `.max(N)` calls so the no-magic-numbers rule stops flagging the        */
@@ -88,9 +88,7 @@ export const BriefTraceInputSchema = z.object({
      * Source trace ids backing the brief (the column on
      * crystallization_event spec §4.5).
      */
-    source_trace_pointers: z
-        .array(z.string().trim().min(1).max(BRIEF_TRACE_POINTER_MAX))
-        .default([]),
+    source_trace_pointers: z.array(z.string().trim().min(1).max(BRIEF_TRACE_POINTER_MAX)).default([])
 });
 /**
  * The summary emitted by the independent evaluators (spec §4.5
@@ -99,8 +97,8 @@ export const BriefTraceInputSchema = z.object({
  * flows into the recommendation envelope.
  */
 export const EvaluatorSummarySchema = z.object({
-    one_liner: z.string().trim().max(BRIEF_EVALUATOR_ONE_LINER_MAX).default(""),
-    risk_tags: z.array(z.string().trim().min(1).max(BRIEF_EVALUATOR_RISK_TAG_MAX)).default([]),
+    one_liner: z.string().trim().max(BRIEF_EVALUATOR_ONE_LINER_MAX).default(''),
+    risk_tags: z.array(z.string().trim().min(1).max(BRIEF_EVALUATOR_RISK_TAG_MAX)).default([])
 });
 /* ---------------------------------------------------------------------- */
 /* Recommendation envelope — the CLI renders this.                       */
@@ -108,23 +106,21 @@ export const EvaluatorSummarySchema = z.object({
 export const RecommendationPayloadSchema = z.object({
     brief: EvidenceBriefSchema,
     bullets: z.array(z.string().trim().min(1).max(BRIEF_BULLET_MAX)).default([]),
-    source_trace_pointers: z
-        .array(z.string().trim().min(1).max(BRIEF_TRACE_POINTER_MAX))
-        .default([]),
+    source_trace_pointers: z.array(z.string().trim().min(1).max(BRIEF_TRACE_POINTER_MAX)).default([]),
     evaluator_summary: EvaluatorSummarySchema.default({
-        one_liner: "",
-        risk_tags: [],
-    }),
+        one_liner: '',
+        risk_tags: []
+    })
 });
 /* ---------------------------------------------------------------------- */
 /* Errors                                                                 */
 /* ---------------------------------------------------------------------- */
 export class BriefSectionError extends Error {
-    code = "MISSING_BRIEF_SECTION";
+    code = 'MISSING_BRIEF_SECTION';
     findings;
     constructor(message, findings = []) {
         super(message);
-        this.name = "BriefSectionError";
+        this.name = 'BriefSectionError';
         this.findings = findings;
     }
 }
@@ -164,15 +160,15 @@ export function buildEvidenceBrief(trace, evaluatorSummary) {
         what_happened: parsedTrace.what_happened,
         why_it_matters: parsedTrace.why_it_matters,
         what_learned: parsedTrace.what_learned,
-        what_action: parsedTrace.what_action,
+        what_action: parsedTrace.what_action
     };
     const result = EvidenceBriefSchema.safeParse(candidate);
     if (!result.success) {
         const findings = result.error.issues.map((i) => ({
-            path: i.path.join("."),
-            message: i.message,
+            path: i.path.join('.'),
+            message: i.message
         }));
-        throw new BriefSectionError("evidence_brief must contain all 4 sections (what_happened, why_it_matters, what_learned, what_action) with non-empty content (spec §4.7 / RL-7)", findings);
+        throw new BriefSectionError('evidence_brief must contain all 4 sections (what_happened, why_it_matters, what_learned, what_action) with non-empty content (spec §4.7 / RL-7)', findings);
     }
     // Silence the unused-var lint on evaluatorSummary at this layer —
     // the builder currently does not consume it (the brief is NL
@@ -188,22 +184,22 @@ export function buildEvidenceBrief(trace, evaluatorSummary) {
 function translateBriefZodError(err) {
     if (err instanceof z.ZodError) {
         const issues = err.issues;
-        const allBrief = issues.every((i) => BRIEF_SECTION_KEYS.has(i.path.join(".")));
+        const allBrief = issues.every((i) => BRIEF_SECTION_KEYS.has(i.path.join('.')));
         if (allBrief) {
             const findings = issues.map((i) => ({
-                path: i.path.join("."),
-                message: i.message,
+                path: i.path.join('.'),
+                message: i.message
             }));
-            throw new BriefSectionError("evidence_brief must contain all 4 sections (what_happened, why_it_matters, what_learned, what_action) with non-empty content (spec §4.7 / RL-7)", findings);
+            throw new BriefSectionError('evidence_brief must contain all 4 sections (what_happened, why_it_matters, what_learned, what_action) with non-empty content (spec §4.7 / RL-7)', findings);
         }
     }
     throw err;
 }
 const BRIEF_SECTION_KEYS = new Set([
-    "what_happened",
-    "why_it_matters",
-    "what_learned",
-    "what_action",
+    'what_happened',
+    'why_it_matters',
+    'what_learned',
+    'what_action'
 ]);
 /**
  * Render the user-facing recommendation envelope (brief + bullets +
@@ -214,13 +210,13 @@ const BRIEF_SECTION_KEYS = new Set([
  * On success, returns the validated `RecommendationPayload`. On a
  * missing-section brief, throws `BriefSectionError`.
  */
-export function renderRecommendationPayload(trace, evaluatorSummary = { one_liner: "", risk_tags: [] }) {
+export function renderRecommendationPayload(trace, evaluatorSummary = { one_liner: '', risk_tags: [] }) {
     const brief = buildEvidenceBrief(trace, evaluatorSummary);
     const payload = RecommendationPayloadSchema.parse({
         brief,
         bullets: trace.bullets ?? [],
         source_trace_pointers: trace.source_trace_pointers ?? [],
-        evaluator_summary: evaluatorSummary,
+        evaluator_summary: evaluatorSummary
     });
     return payload;
 }
@@ -235,17 +231,15 @@ export function safeRenderRecommendationPayload(input) {
     if (r.success)
         return { ok: true, payload: r.data };
     const findings = r.error.issues.map((i) => ({
-        path: i.path.join("."),
-        message: i.message,
+        path: i.path.join('.'),
+        message: i.message
     }));
     // Map brief failures to MISSING_BRIEF_SECTION. A failure is
     // recognized as brief iff (a) every issue points at the brief or
     // its sections, OR (b) the explicit refine message is present.
-    const isBrief = r.error.issues.every((i) => i.message.includes("evidence_brief must contain all 4 sections") ||
-        BRIEF_SECTION_KEYS.has(i.path.join(".")) ||
-        i.path[0] === "brief" ||
-        (i.path.length >= 2 && i.path[0] === "brief"));
-    return isBrief
-        ? { ok: false, code: "MISSING_BRIEF_SECTION", findings }
-        : { ok: false, findings };
+    const isBrief = r.error.issues.every((i) => i.message.includes('evidence_brief must contain all 4 sections') ||
+        BRIEF_SECTION_KEYS.has(i.path.join('.')) ||
+        i.path[0] === 'brief' ||
+        (i.path.length >= 2 && i.path[0] === 'brief'));
+    return isBrief ? { ok: false, code: 'MISSING_BRIEF_SECTION', findings } : { ok: false, findings };
 }

package/dist/services/crystallization/index.d.ts

@@ -7,7 +7,7 @@
  * subpackage stays standalone and does NOT depend on the main
  * peaks-loop package (avoiding workspace:* circular trap).
  */
-export { CrystallizationService, CrystallizationIntegrityError, type CrystallizationOptions, type CrystallizationTaskState, } from './crystallization-service.js';
-export { ensureCrystallizationEventTable, insertCrystallizationEvent, getCrystallizationEvent, listCrystallizationEvents, newCrystallizationId, updateCrystallizationEventStatus, } from './crystallization-store.js';
-export { CRYSTALLIZATION_TRIGGERS, parseEvidenceBrief, EvidenceBriefSchema, CrystallizationEventSchema, parseCrystallizationEvent, safeParseEvidenceBrief, safeParseCrystallizationEvent, hasAllFourBriefSections, type CrystallizationTrigger, type CrystallizationEvent, type CrystallizationEventInput, type CrystallizationEventStatus, type EvidenceBrief, } from './crystallization-types.js';
-export { BriefSectionError, renderRecommendationPayload, safeRenderRecommendationPayload, buildEvidenceBrief, type BriefTraceInput, } from './evidence-brief-builder.js';
+export { CrystallizationService, CrystallizationIntegrityError, type CrystallizationOptions, type CrystallizationTaskState } from './crystallization-service.js';
+export { ensureCrystallizationEventTable, insertCrystallizationEvent, getCrystallizationEvent, listCrystallizationEvents, newCrystallizationId, updateCrystallizationEventStatus } from './crystallization-store.js';
+export { CRYSTALLIZATION_TRIGGERS, parseEvidenceBrief, EvidenceBriefSchema, CrystallizationEventSchema, parseCrystallizationEvent, safeParseEvidenceBrief, safeParseCrystallizationEvent, hasAllFourBriefSections, type CrystallizationTrigger, type CrystallizationEvent, type CrystallizationEventInput, type CrystallizationEventStatus, type EvidenceBrief } from './crystallization-types.js';
+export { BriefSectionError, renderRecommendationPayload, safeRenderRecommendationPayload, buildEvidenceBrief, type BriefTraceInput } from './evidence-brief-builder.js';

package/dist/services/crystallization/index.js

@@ -7,7 +7,7 @@
  * subpackage stays standalone and does NOT depend on the main
  * peaks-loop package (avoiding workspace:* circular trap).
  */
-export { CrystallizationService, CrystallizationIntegrityError, } from './crystallization-service.js';
-export { ensureCrystallizationEventTable, insertCrystallizationEvent, getCrystallizationEvent, listCrystallizationEvents, newCrystallizationId, updateCrystallizationEventStatus, } from './crystallization-store.js';
-export { CRYSTALLIZATION_TRIGGERS, parseEvidenceBrief, EvidenceBriefSchema, CrystallizationEventSchema, parseCrystallizationEvent, safeParseEvidenceBrief, safeParseCrystallizationEvent, hasAllFourBriefSections, } from './crystallization-types.js';
-export { BriefSectionError, renderRecommendationPayload, safeRenderRecommendationPayload, buildEvidenceBrief, } from './evidence-brief-builder.js';
+export { CrystallizationService, CrystallizationIntegrityError } from './crystallization-service.js';
+export { ensureCrystallizationEventTable, insertCrystallizationEvent, getCrystallizationEvent, listCrystallizationEvents, newCrystallizationId, updateCrystallizationEventStatus } from './crystallization-store.js';
+export { CRYSTALLIZATION_TRIGGERS, parseEvidenceBrief, EvidenceBriefSchema, CrystallizationEventSchema, parseCrystallizationEvent, safeParseEvidenceBrief, safeParseCrystallizationEvent, hasAllFourBriefSections } from './crystallization-types.js';
+export { BriefSectionError, renderRecommendationPayload, safeRenderRecommendationPayload, buildEvidenceBrief } from './evidence-brief-builder.js';

package/dist/services/dashboard/project-dashboard-service.js

@@ -21,7 +21,13 @@ function defaultClock() {
     return new Date().toISOString();
 }
 function groupRequestsByRole(items) {
-    const byRole = { prd: [], ui: [], rd: [], qa: [], sc: [] };
+    const byRole = {
+        prd: [],
+        ui: [],
+        rd: [],
+        qa: [],
+        sc: []
+    };
     for (const item of items) {
         byRole[item.role].push(item);
     }

package/dist/services/dispatch/await-batch-helpers.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Read a dispatch record's `status` and `outcome` off disk. Missing or
+ * unreadable (including unparseable JSON) reads as `{ null, null }`, which is
+ * what keeps a corrupt record a timeout rather than a thrown error.
+ */
+export declare function defaultReadOutcome(recordPath: string): {
+    status: string | null;
+    outcome: string | null;
+};
+/** One slot's mutable state — the value type of `awaitBatch`'s slot map. */
+export interface AwaitBatchSlot {
+    recordPath: string;
+    status: 'done' | 'failed' | 'cancelled' | 'timeout';
+    note: string | null;
+    finishedAt: number | null;
+    lastProgress: number;
+}
+/** The slot table plus the batch start time the watchdog and the notes read. */
+export interface AwaitBatchSlotTable {
+    readonly startedAt: number;
+    readonly slots: Map<number, AwaitBatchSlot>;
+    readonly lastProgressAt: Map<number, number>;
+}
+/** One per-dispatch result — the element type of `AwaitBatchResult.results`. */
+export interface AwaitBatchSlotResult {
+    readonly dispatchIndex: number;
+    readonly recordPath: string;
+    readonly status: 'done' | 'failed' | 'cancelled' | 'timeout';
+    readonly durationMs: number;
+    readonly note: string | null;
+}
+/**
+ * Seed one slot per record path, all of them `timeout` until a tick proves
+ * otherwise, plus the progress map the no-progress watchdog runs off.
+ */
+export declare function createSlotTable(recordPaths: readonly string[], startedAt: number): AwaitBatchSlotTable;
+/**
+ * One observation pass over the pending slots. Returns the `allDone` the loop
+ * branched on: `true` only when every slot reached a terminal state.
+ */
+export declare function pollSlotsOnce(table: AwaitBatchSlotTable, readOutcome: (recordPath: string) => string | null, readRecord: (recordPath: string) => {
+    status: string | null;
+    outcome: string | null;
+}, now: () => number): boolean;
+/**
+ * No-progress watchdog: every slot has been without observable
+ * progress for `noProgressBudget`, and there is at least one slot.
+ */
+export declare function hasNoProgress(table: AwaitBatchSlotTable, now: () => number, noProgressBudget: number): boolean;
+/** Sleep a tick on the resolved scheduler. */
+export declare function sleepTick(schedule: (cb: () => void, ms: number) => void): Promise<void>;
+/**
+ * Build the per-dispatch results in dispatchIndex order.
+ */
+export declare function buildBatchResults(table: AwaitBatchSlotTable, notePrefix: string | undefined, effectiveTimeoutMs: number): readonly AwaitBatchSlotResult[];