@homeostat/core 0.1.4 → 0.1.6

package/dist/src/automation.d.ts

@@ -51,9 +51,16 @@ export interface RunReport {
         dailyPr?: string;
         reviewPr?: string;
         mergeError?: string;
+        /** Why the host refused to request the reviewers, e.g. they are not collaborators. */
+        reviewError?: string;
     }[];
     /** Review PRs from earlier runs that a reviewer merged or closed since. */
     settled: number;
+    /** Review threads read this run that gave no lesson, and why (one-off, skip marker, too long...). */
+    skipped?: {
+        url: string;
+        reason: string;
+    }[];
     lessons: {
         member: string;
         id: string;

package/dist/src/curator/curate.js

@@ -107,7 +107,7 @@ export async function curate(input) {
                 }
                 const { thread: safe, redacted } = redactThread(thread);
                 result.redacted += redacted;
-                const draft = await input.drafter.draft(safe, { areas: config.areas });
+                let draft = await input.drafter.draft(safe, { areas: config.areas });
                 if (input.patcher) {
                     await docPatchStep({ files, config, result, today: input.today }, input.patcher, safe, url);
                 }
@@ -115,17 +115,34 @@ export async function curate(input) {
                     skip("no lasting rule in the thread");
                     continue;
                 }
-                const area = draft.area === CORE_AREA || config.areas[draft.area] ? draft.area : CORE_AREA;
-                let entry = buildEntry(config, {
-                    draft: { ...draft, area },
-                    id: uniqueId(slugify(draft.title) ?? `review-${pr.id}-${thread.root.id}`, ids),
-                    url,
-                    author: reviewer.id,
-                    today: input.today,
-                });
-                const errors = validate({ ...files, [entry.path]: entry.text }).issues.filter((i) => i.file === entry.path && i.severity === "error");
+                const check = (d) => {
+                    const area = d.area === CORE_AREA || config.areas[d.area] ? d.area : CORE_AREA;
+                    const built = buildEntry(config, {
+                        draft: { ...d, area },
+                        id: uniqueId(slugify(d.title) ?? `review-${pr.id}-${thread.root.id}`, ids),
+                        url,
+                        author: reviewer.id,
+                        today: input.today,
+                    });
+                    const errs = validate({ ...files, [built.path]: built.text }).issues.filter((i) => i.file === built.path && i.severity === "error");
+                    return { built, errs };
+                };
                 const isRisk = (i) => i.code.startsWith("risk.");
-                const blocking = errors.filter((i) => !isRisk(i));
+                let { built: entry, errs: errors } = check(draft);
+                let blocking = errors.filter((i) => !isRisk(i));
+                // A draft over a length limit is worth one rewrite rather than losing the lesson.
+                if (blocking.length > 0 && blocking.every(isLengthIssue)) {
+                    const problems = blocking.map((i) => i.message);
+                    const second = await input.drafter.draft(safe, {
+                        areas: config.areas,
+                        revise: { previous: draft, problems },
+                    });
+                    if (second) {
+                        draft = second;
+                        ({ built: entry, errs: errors } = check(draft));
+                        blocking = errors.filter((i) => !isRisk(i));
+                    }
+                }
                 if (blocking.length > 0) {
                     skip(`draft did not validate: ${blocking.map((i) => i.message).join("; ")}`);
                     continue;
@@ -214,6 +231,8 @@ async function docPatchStep(ctx, patcher, thread, url) {
         ctx.result.docs.push({ path: proposal.path, text, sections: [section], risks });
     }
 }
+/** Over a word or character limit: fixable by rewriting shorter. */
+const isLengthIssue = (i) => i.code.endsWith(".tooLong") || /at most \d+ characters/.test(i.message);
 function uniqueId(base, taken) {
     let id = base;
     for (let n = 2; taken.has(id); n++)

package/dist/src/curator/draft.d.ts

@@ -10,6 +10,11 @@ export interface Draft {
 export interface DraftContext {
     /** Area name → path globs, from homeostat.yaml. `core` is always available. */
     areas: Record<string, readonly string[]>;
+    /** A second try: the previous draft and the limits it broke. */
+    revise?: {
+        previous: Draft;
+        problems: string[];
+    };
 }
 /** Turns one review thread into at most one rule; null when the thread holds no lasting lesson. */
 export interface Drafter {

package/dist/src/curator/draft.js

@@ -37,7 +37,19 @@ ${conversation}
 </thread>
 
 Areas and the paths they cover:
-${areas.map((a) => `- ${a}`).join("\n")}`;
+${areas.map((a) => `- ${a}`).join("\n")}${ctx.revise
+        ? `
+
+Your previous draft broke these limits:
+${ctx.revise.problems.map((p) => `- ${p}`).join("\n")}
+
+Previous draft:
+Title: ${ctx.revise.previous.title}
+Rule: ${ctx.revise.previous.rule}
+Why: ${ctx.revise.previous.why}
+
+Write it again within the limits, keeping every name and fact it states.`
+        : ""}`;
 }
 /** Drafts with Claude through either runtime (API or Claude Code). */
 export class ClaudeDrafter {

package/dist/src/version.d.ts

@@ -1,2 +1,2 @@
 /** The release version; `scripts/version.mjs` keeps it in step with every package.json. */
-export declare const VERSION = "0.1.4";
+export declare const VERSION = "0.1.6";

package/dist/src/version.js

@@ -1,2 +1,2 @@
 /** The release version; `scripts/version.mjs` keeps it in step with every package.json. */
-export const VERSION = "0.1.4";
+export const VERSION = "0.1.6";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homeostat/core",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Schemas, validation, scoring and agents behind homeostat, the team knowledge base for coding agents.",
   "keywords": [
     "homeostat",