@homeostat/core 0.1.0 → 0.1.1

package/dist/src/automation.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Shared names for the automated daily flow (local pending lessons → one daily PR per developer
+ * → a decision by confidence score). Laptops and the daily run talk only through git refs on the
+ * KB repo's origin, so nothing needs a service:
+ *
+ * - `candidates/<member>`: the base branch plus that developer's pending lessons and a heartbeat,
+ *   force-pushed by the developer's sync. Transport only; never merged.
+ * - `homeostat/state`: written by the daily run: each developer's decisions, collected heartbeats
+ *   and one report per run. Laptops read their decisions from it; the dashboard reads all of it.
+ */
+export declare const STATE_BRANCH = "homeostat/state";
+export declare const candidatesBranch: (member: string) => string;
+export declare const HEARTBEAT_PATH = ".homeostat-sync/heartbeat.json";
+export declare const decisionsPath: (member: string) => string;
+/** Identifies one version of a lesson file, so a decision applies to exactly what was submitted. */
+export declare const lessonHash: (text: string) => string;
+export type Decision = "merged" | "declined" | "review";
+export interface DecisionRecord {
+    path: string;
+    id: string;
+    hash: string;
+    decision: Decision;
+    /** Why: the score breakdown summary, or the reviewer's action. */
+    reason: string;
+    confidence?: number;
+    pr?: string;
+    at: string;
+}
+export interface DecisionsFile {
+    member: string;
+    decided: DecisionRecord[];
+}
+export interface Heartbeat {
+    member: string;
+    at: string;
+    /** The base-branch commit the developer's clone was on after the sync. */
+    kbCommit: string | null;
+    /** Commits the clone could not fast-forward (local edits in the way), 0 when current. */
+    behind: number;
+    pending: number;
+    version: string;
+}
+/** One daily run, written to `runs/<date>.json` on the state branch. */
+export interface RunReport {
+    at: string;
+    members: {
+        member: string;
+        merged: number;
+        declined: number;
+        review: number;
+        dailyPr?: string;
+        reviewPr?: string;
+        mergeError?: string;
+    }[];
+    /** Review PRs from earlier runs that a reviewer merged or closed since. */
+    settled: number;
+    lessons: {
+        member: string;
+        id: string;
+        decision: Decision;
+        confidence?: number;
+        reason: string;
+    }[];
+}
+/** Review items older than this are repeated in the morning notice and marked on the dashboard. */
+export declare const REVIEW_REMINDER_DAYS = 2;
+/** A developer whose sync has not reported for this long is shown as not syncing. */
+export declare const STALE_HEARTBEAT_HOURS = 48;

package/dist/src/automation.js

@@ -0,0 +1,21 @@
+import { createHash } from "node:crypto";
+/**
+ * Shared names for the automated daily flow (local pending lessons → one daily PR per developer
+ * → a decision by confidence score). Laptops and the daily run talk only through git refs on the
+ * KB repo's origin, so nothing needs a service:
+ *
+ * - `candidates/<member>`: the base branch plus that developer's pending lessons and a heartbeat,
+ *   force-pushed by the developer's sync. Transport only; never merged.
+ * - `homeostat/state`: written by the daily run: each developer's decisions, collected heartbeats
+ *   and one report per run. Laptops read their decisions from it; the dashboard reads all of it.
+ */
+export const STATE_BRANCH = "homeostat/state";
+export const candidatesBranch = (member) => `candidates/${member}`;
+export const HEARTBEAT_PATH = ".homeostat-sync/heartbeat.json";
+export const decisionsPath = (member) => `decisions/${member}.json`;
+/** Identifies one version of a lesson file, so a decision applies to exactly what was submitted. */
+export const lessonHash = (text) => createHash("sha256").update(text).digest("hex").slice(0, 16);
+/** Review items older than this are repeated in the morning notice and marked on the dashboard. */
+export const REVIEW_REMINDER_DAYS = 2;
+/** A developer whose sync has not reported for this long is shown as not syncing. */
+export const STALE_HEARTBEAT_HOURS = 48;

package/dist/src/check.js

@@ -37,10 +37,9 @@ export function checkEntry(entry, ctx) {
             }
         }
     }
-    const score = ctx.score ?? fm.score;
-    if (fm.status === "accepted" && score < ctx.autoMergeThreshold && !fm.approvedBy) {
-        issues.push(error("accepted.belowThreshold", `accepted with score ${score} below the auto-merge threshold ${ctx.autoMergeThreshold}; set approvedBy or lower the status`, { path: "status", file }));
-    }
+    // No approval field is required: a rule is accepted by the merge that put it on the base
+    // branch, decided by the daily run's confidence score or a reviewer (branch protection makes
+    // sure nothing else can merge).
     const tokens = countTokens(entry.body);
     if (fm.tokens !== tokens) {
         issues.push({

package/dist/src/codeowners.js

@@ -1,5 +1,5 @@
 import { CORE_AREA } from "./check.js";
-import { CONFIG_FILE } from "./config.js";
+import { CONFIG_FILE, isSenior } from "./config.js";
 import { error } from "./issues.js";
 export const CODEOWNERS_FILE = "CODEOWNERS";
 const HEADER = `# Generated by homeostat from ${CONFIG_FILE} and knowledge/. Do not edit; run \`homeostat codeowners\`.`;
@@ -21,7 +21,7 @@ export function generateCodeowners(config, entries) {
             missingHandle.add(id);
         return handle ? [handle] : [];
     });
-    const seniors = members.filter((m) => m.role === "senior").map((m) => m.id);
+    const seniors = members.filter((m) => isSenior(m.role)).map((m) => m.id);
     if (seniors.length === 0) {
         issues.push(error("codeowners.noSeniors", "no member has role senior, so nobody would own homeostat.yaml", {
             file: CONFIG_FILE,

package/dist/src/confidence.d.ts

@@ -0,0 +1,39 @@
+import type { Decision } from "./automation.ts";
+import type { Config } from "./config.ts";
+import type { Entry } from "./entry.ts";
+/**
+ * How sure the team can be that a lesson is right and worth every agent following, 0–100. The
+ * daily run merges lessons at or above `accept`, declines those below `decline`, and sends the
+ * rest to a reviewer. Every point comes with a reason, printed in the daily PR (automation, step 3).
+ */
+export interface ConfidenceInput {
+    entry: Entry;
+    config: Config;
+    /** The member the lesson came from: its writer, or the reviewer whose comment it is drawn from. */
+    originator: string;
+    /** Times the same lesson turned up independently in this run, the first included. */
+    occurrences?: number;
+    /** The model's own rating of a drafted lesson, 0–1. */
+    modelRating?: number;
+    /** Risky-content findings: they always send the lesson to a person. */
+    risks?: readonly string[];
+    /** Validation errors other than risky content: the lesson cannot be merged. */
+    errors?: readonly string[];
+    /** An accepted rule this lesson repeats: it reconfirms that rule instead of adding a new one. */
+    duplicateOf?: string;
+    /** Accepted rules this lesson contradicts. */
+    conflictsWith?: readonly string[];
+}
+export interface Confidence {
+    score: number;
+    parts: {
+        label: string;
+        delta: number;
+    }[];
+    decision: Decision;
+    /** One line for the PR and the developer's notice. */
+    reason: string;
+}
+export declare function confidence(input: ConfidenceInput): Confidence;
+/** The breakdown as one readable line, e.g. "+50 review comment… · +14 from dana (senior)". */
+export declare const explainConfidence: (c: Confidence) => string;

package/dist/src/confidence.js

@@ -0,0 +1,101 @@
+import { CORE_AREA } from "./check.js";
+const SPECIFIC = /`[^`]+`|\w+\(\)|[\w.-]+\/[\w./*-]+|@[\w-]+\/[\w-]+|\b[a-z]+[A-Z]\w*\b|\b[A-Z][a-z]+[A-Z]\w*\b/;
+const VAGUE_TITLE = /^(lesson|note|rule|todo|misc|fix|update)\s*\d*$/i;
+export function confidence(input) {
+    const { entry, config } = input;
+    const c = config.scoring.confidence;
+    const fm = entry.frontmatter;
+    const parts = [];
+    const add = (label, delta) => {
+        if (delta !== 0)
+            parts.push({ label, delta });
+    };
+    const sourceBase = {
+        "pr-feedback": fm.source.changedCode ? c.base.prFeedbackChangedCode : c.base.prFeedback,
+        manual: c.base.manual,
+        "agent-handoff": c.base.agentHandoff,
+        "deep-dive": c.base.deepDive,
+    }[fm.source.type];
+    add(fm.source.type === "pr-feedback"
+        ? fm.source.changedCode
+            ? "review comment followed by a code change"
+            : "review comment, no code change after it"
+        : fm.source.type === "agent-handoff"
+            ? "written by an agent"
+            : fm.source.type === "deep-dive"
+                ? "produced by the deep dive"
+                : "written by a team member", sourceBase);
+    const member = config.team.members.find((m) => m.id === input.originator);
+    if (member) {
+        add(`from ${member.id} (${member.role})`, c.roles[member.role]);
+        const owns = member.areas.includes(fm.area) ||
+            Object.values(config.teams).some((t) => t.members.includes(member.id) && t.areas.includes(fm.area));
+        if (owns)
+            add(`${member.id} works in ${fm.area}`, c.bonus.areaOwner);
+    }
+    const text = `${entry.sections.rule ?? ""} ${fm.title}`;
+    if (SPECIFIC.test(text))
+        add("names a concrete function, path or package", c.bonus.specific);
+    const words = fm.title.trim().split(/\s+/).length;
+    if (VAGUE_TITLE.test(fm.title.trim()) || words < 3)
+        add(`vague title "${fm.title}"`, -c.penalty.vagueTitle);
+    else
+        add("clear title", c.bonus.goodTitle);
+    const repeats = Math.min(2, Math.max(0, (input.occurrences ?? 1) - 1));
+    if (repeats)
+        add(`seen ${repeats + 1} times independently`, repeats * c.bonus.repeat);
+    if (input.modelRating !== undefined) {
+        add("model rating", Math.round((input.modelRating - 0.5) * 2 * c.bonus.modelRating));
+    }
+    for (const f of fm.flags ?? [])
+        add(`flagged by ${f.by}`, -c.penalty.flag);
+    if (input.conflictsWith?.length)
+        add(`contradicts ${input.conflictsWith.join(", ")}`, -c.penalty.conflict);
+    const score = Math.max(0, Math.min(100, parts.reduce((n, p) => n + p.delta, 0)));
+    const accept = fm.area === CORE_AREA || fm.scope.some((g) => g === "**") ? c.coreAccept : c.accept;
+    const summary = `confidence ${score}`;
+    // Hard rules first: some outcomes never depend on the score.
+    if (input.errors?.length)
+        return { score, parts, decision: "declined", reason: `does not validate: ${input.errors[0]}` };
+    if (input.duplicateOf) {
+        return {
+            score,
+            parts,
+            decision: "declined",
+            reason: `duplicate of ${input.duplicateOf}, which it reconfirms`,
+        };
+    }
+    if (input.risks?.length)
+        return {
+            score,
+            parts,
+            decision: "review",
+            reason: `${summary}; risky content always goes to a person`,
+        };
+    if (input.conflictsWith?.length && score >= c.decline) {
+        return {
+            score,
+            parts,
+            decision: "review",
+            reason: `${summary}; contradicts ${input.conflictsWith.join(", ")}`,
+        };
+    }
+    const gate = config.scoring.autoMerge;
+    const inScope = gate.enabled &&
+        !gate.excludeAreas.includes(fm.area) &&
+        (gate.areas.length === 0 || gate.areas.includes(fm.area));
+    if (score < c.decline)
+        return { score, parts, decision: "declined", reason: `${summary}, below ${c.decline}` };
+    if (score >= accept && inScope)
+        return { score, parts, decision: "merged", reason: `${summary}, at least ${accept}` };
+    return {
+        score,
+        parts,
+        decision: "review",
+        reason: score >= accept
+            ? `${summary}; area ${fm.area} always gets a reviewer`
+            : `${summary}, between ${c.decline} and ${accept}`,
+    };
+}
+/** The breakdown as one readable line, e.g. "+50 review comment… · +14 from dana (senior)". */
+export const explainConfidence = (c) => c.parts.map((p) => `${p.delta > 0 ? "+" : ""}${p.delta} ${p.label}`).join(" · ");

package/dist/src/config.d.ts

@@ -1,6 +1,10 @@
 import { z } from "zod";
 import { type Issue } from "./issues.ts";
 export declare const CONFIG_FILE = "homeostat.yaml";
+export declare const ROLES: readonly ["junior", "member", "senior", "lead"];
+export type Role = (typeof ROLES)[number];
+/** Seniors and leads: they own the config and unclaimed areas, and add the senior-author bonus. */
+export declare const isSenior: (role: Role) => role is "lead" | "senior";
 /** Point values for each scoring signal; see `score()`. */
 export declare const DEFAULT_WEIGHTS: {
     /** pr-feedback where the PR's code changed after the comment: the accepted-feedback signal. */
@@ -27,6 +31,8 @@ export declare const configSchema: z.ZodObject<{
         members: z.ZodArray<z.ZodObject<{
             id: z.ZodString;
             role: z.ZodEnum<{
+                junior: "junior";
+                lead: "lead";
                 member: "member";
                 senior: "senior";
             }>;
@@ -65,6 +71,36 @@ export declare const configSchema: z.ZodObject<{
             daily: "daily";
             weekly: "weekly";
         }>>;
+        confidence: z.ZodPrefault<z.ZodObject<{
+            accept: z.ZodDefault<z.ZodInt>;
+            coreAccept: z.ZodDefault<z.ZodInt>;
+            decline: z.ZodDefault<z.ZodInt>;
+            base: z.ZodPrefault<z.ZodObject<{
+                prFeedbackChangedCode: z.ZodDefault<z.ZodInt>;
+                prFeedback: z.ZodDefault<z.ZodInt>;
+                manual: z.ZodDefault<z.ZodInt>;
+                agentHandoff: z.ZodDefault<z.ZodInt>;
+                deepDive: z.ZodDefault<z.ZodInt>;
+            }, z.core.$strict>>;
+            roles: z.ZodPrefault<z.ZodObject<{
+                junior: z.ZodDefault<z.ZodInt>;
+                member: z.ZodDefault<z.ZodInt>;
+                senior: z.ZodDefault<z.ZodInt>;
+                lead: z.ZodDefault<z.ZodInt>;
+            }, z.core.$strict>>;
+            bonus: z.ZodPrefault<z.ZodObject<{
+                areaOwner: z.ZodDefault<z.ZodInt>;
+                specific: z.ZodDefault<z.ZodInt>;
+                goodTitle: z.ZodDefault<z.ZodInt>;
+                repeat: z.ZodDefault<z.ZodInt>;
+                modelRating: z.ZodDefault<z.ZodInt>;
+            }, z.core.$strict>>;
+            penalty: z.ZodPrefault<z.ZodObject<{
+                vagueTitle: z.ZodDefault<z.ZodInt>;
+                conflict: z.ZodDefault<z.ZodInt>;
+                flag: z.ZodDefault<z.ZodInt>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
     }, z.core.$strict>>;
     agents: z.ZodPrefault<z.ZodObject<{
         runtime: z.ZodDefault<z.ZodEnum<{

package/dist/src/config.js

@@ -5,6 +5,9 @@ import { error } from "./issues.js";
 import { ID_PATTERN } from "./schema.js";
 import { fromZod } from "./zod-issues.js";
 export const CONFIG_FILE = "homeostat.yaml";
+export const ROLES = ["junior", "member", "senior", "lead"];
+/** Seniors and leads: they own the config and unclaimed areas, and add the senior-author bonus. */
+export const isSenior = (role) => role === "senior" || role === "lead";
 /** Point values for each scoring signal; see `score()`. */
 export const DEFAULT_WEIGHTS = {
     /** pr-feedback where the PR's code changed after the comment: the accepted-feedback signal. */
@@ -41,7 +44,11 @@ export const configSchema = z.strictObject({
         members: z
             .array(z.strictObject({
             id: name,
-            role: z.enum(["senior", "member"]),
+            /**
+             * junior, member, senior or lead (team manager). Seniors and leads own the config and
+             * unclaimed areas; the role also weighs a member's lessons in the daily decision.
+             */
+            role: z.enum(ROLES),
             /** The curator never reads this member's pull requests or review comments. */
             optOut: z.boolean().optional(),
             areas: z.array(z.string()).default([]),
@@ -92,6 +99,50 @@ export const configSchema = z.strictObject({
         })
             .prefault({}),
         reviewCadence: z.enum(["daily", "weekly", "biweekly"]).default("weekly"),
+        /**
+         * The daily run's 0–100 confidence per lesson: merged at or above `accept` (`coreAccept` for
+         * rules that reach every session), declined below `decline`, a reviewer in between.
+         */
+        confidence: z
+            .strictObject({
+            accept: z.int().min(0).max(100).default(70),
+            coreAccept: z.int().min(0).max(100).default(80),
+            decline: z.int().min(0).max(100).default(35),
+            base: z
+                .strictObject({
+                prFeedbackChangedCode: z.int().default(50),
+                prFeedback: z.int().default(20),
+                manual: z.int().default(45),
+                agentHandoff: z.int().default(25),
+                deepDive: z.int().default(40),
+            })
+                .prefault({}),
+            roles: z
+                .strictObject({
+                junior: z.int().default(0),
+                member: z.int().default(6),
+                senior: z.int().default(14),
+                lead: z.int().default(20),
+            })
+                .prefault({}),
+            bonus: z
+                .strictObject({
+                areaOwner: z.int().default(6),
+                specific: z.int().default(8),
+                goodTitle: z.int().default(4),
+                repeat: z.int().default(10),
+                modelRating: z.int().default(10),
+            })
+                .prefault({}),
+            penalty: z
+                .strictObject({
+                vagueTitle: z.int().default(15),
+                conflict: z.int().default(25),
+                flag: z.int().default(20),
+            })
+                .prefault({}),
+        })
+            .prefault({}),
     })
         .prefault({}),
     agents: z

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

@@ -18,6 +18,8 @@ export interface CuratedEntry {
     path: string;
     text: string;
     frontmatter: Frontmatter;
+    /** The member whose pull request the review comment was on; the daily run files it under them. */
+    prAuthor?: string;
     /**
      * Risky-content findings (see `risk.ts`). Such an entry stays a candidate and fails `validate`
      * until a member reads it and sets `riskReviewedBy`, so the PR shows it but cannot merge it.
@@ -32,6 +34,7 @@ export interface DocUpdate {
         id: string;
         reason: string;
         url: string;
+        prAuthor?: string;
     }[];
     /** Risky-content findings; such an update fails validate until a member signs it off. */
     risks: string[];

package/dist/src/curator/curate.js

@@ -136,7 +136,8 @@ export async function curate(input) {
                 files = { ...files, [entry.path]: entry.text };
                 ids.add(entry.frontmatter.id);
                 known.add(key);
-                result.entries.push(entry);
+                const prAuthor = config.team.members.find((m) => m.handle === `@${pr.author.id}`)?.id;
+                result.entries.push(prAuthor ? { ...entry, prAuthor } : entry);
             }
         }
     }
@@ -197,7 +198,13 @@ async function docPatchStep(ctx, patcher, thread, url) {
     }
     const risks = errors.map((i) => i.message);
     const existing = ctx.result.docs.find((d) => d.path === proposal.path);
-    const section = { id: proposal.sectionId, reason: proposal.reason, url };
+    const prAuthor = ctx.config.team.members.find((m) => m.handle === `@${thread.pullRequest.author.id}`)?.id;
+    const section = {
+        id: proposal.sectionId,
+        reason: proposal.reason,
+        url,
+        ...(prAuthor ? { prAuthor } : {}),
+    };
     if (existing) {
         existing.text = text;
         existing.sections.push(section);

package/dist/src/describe.js

@@ -18,7 +18,7 @@ export function explainEntry(e, config) {
                 : []),
         `Applies to: ${fm.scope.join(", ")}`,
         `Source: ${fm.source.type} by ${fm.source.author}${fm.source.url ? ` — ${fm.source.url}` : ""}${fm.source.changedCode ? " (code changed after the comment)" : ""}`,
-        `Created ${fm.created}, last confirmed ${fm.lastConfirmed}`,
+        `Created ${fm.created}, last confirmed ${fm.lastConfirmed}${fm.approvedBy ? `, approved by ${fm.approvedBy}` : ""}`,
         ...(fm.conflictsWith?.length ? [`Conflicts with: ${fm.conflictsWith.join(", ")}`] : []),
         ...(fm.supersedes ? [`Supersedes: ${fm.supersedes}`] : []),
         ...(fm.flags ?? []).map((f) => `Flagged by ${f.by} on ${f.date}: ${f.reason}`),

package/dist/src/files.d.ts

@@ -2,3 +2,23 @@ import type { KbFiles } from "./validate.ts";
 /** Reads the parts of a KB that `validate()` looks at: the config and everything under knowledge/. */
 export declare function readKbFiles(root: string): KbFiles;
 export declare function writeKbFile(root: string, path: string, content: string): void;
+/**
+ * A developer's own lessons, not yet decided by the daily run. They live in the KB clone but
+ * outside git (`.homeostat/` is ignored), so the clone stays clean for its daily pull, and they
+ * apply to that developer's sessions at once. Paths mirror the KB: `knowledge/<area>/<id>.md`.
+ */
+export declare const PENDING_DIR = ".homeostat/pending";
+export declare function readPendingFiles(root: string): KbFiles;
+/**
+ * The KB as one developer sees it: the committed files with their pending lessons on top. With
+ * `inForce`, a pending candidate reads as accepted, so the developer's own sessions follow their
+ * own lessons right away; the daily run still decides whether the team gets them.
+ */
+export declare function readKbView(root: string, opts?: {
+    inForce?: boolean;
+}): {
+    files: KbFiles;
+    pending: Set<string>;
+};
+export declare function writePendingFile(root: string, path: string, content: string): void;
+export declare function removePendingFile(root: string, path: string): void;

package/dist/src/files.js

@@ -1,5 +1,5 @@
-import { existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join, sep } from "node:path";
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join, sep } from "node:path";
 import { CONFIG_FILE } from "./config.js";
 /** Reads the parts of a KB that `validate()` looks at: the config and everything under knowledge/. */
 export function readKbFiles(root) {
@@ -20,3 +20,46 @@ export function readKbFiles(root) {
 export function writeKbFile(root, path, content) {
     writeFileSync(join(root, ...path.split("/")), content);
 }
+/**
+ * A developer's own lessons, not yet decided by the daily run. They live in the KB clone but
+ * outside git (`.homeostat/` is ignored), so the clone stays clean for its daily pull, and they
+ * apply to that developer's sessions at once. Paths mirror the KB: `knowledge/<area>/<id>.md`.
+ */
+export const PENDING_DIR = ".homeostat/pending";
+export function readPendingFiles(root) {
+    const files = {};
+    const base = join(root, PENDING_DIR, "knowledge");
+    if (!existsSync(base))
+        return files;
+    for (const rel of readdirSync(base, { recursive: true, encoding: "utf8" })) {
+        if (!rel.endsWith(".md"))
+            continue;
+        files[`knowledge/${rel.split(sep).join("/")}`] = readFileSync(join(base, rel), "utf8");
+    }
+    return files;
+}
+/**
+ * The KB as one developer sees it: the committed files with their pending lessons on top. With
+ * `inForce`, a pending candidate reads as accepted, so the developer's own sessions follow their
+ * own lessons right away; the daily run still decides whether the team gets them.
+ */
+export function readKbView(root, opts = {}) {
+    const pending = readPendingFiles(root);
+    if (opts.inForce) {
+        for (const [path, text] of Object.entries(pending)) {
+            // A flagged lesson is out of force until the daily run or a reviewer settles it.
+            if (/^flags:\s*\n\s+-/m.test(text))
+                continue;
+            pending[path] = text.replace(/^status: candidate$/m, "status: accepted");
+        }
+    }
+    return { files: { ...readKbFiles(root), ...pending }, pending: new Set(Object.keys(pending)) };
+}
+export function writePendingFile(root, path, content) {
+    const full = join(root, PENDING_DIR, ...path.split("/"));
+    mkdirSync(dirname(full), { recursive: true });
+    writeFileSync(full, content);
+}
+export function removePendingFile(root, path) {
+    rmSync(join(root, PENDING_DIR, ...path.split("/")), { force: true });
+}

package/dist/src/index.d.ts

@@ -1,3 +1,4 @@
+export { candidatesBranch, type Decision, type DecisionRecord, type DecisionsFile, decisionsPath, HEARTBEAT_PATH, type Heartbeat, lessonHash, REVIEW_REMINDER_DAYS, type RunReport, STALE_HEARTBEAT_HOURS, STATE_BRANCH, } from "./automation.ts";
 export { type AutoMergeDecision, autoMergeDecision, type MergeCandidate, splitAutoMerge, } from "./automerge.ts";
 export { type BodySections, parseBody, RULE_MAX_WORDS, WHY_MAX_WORDS } from "./body.ts";
 export { type CheckContext, CORE_AREA, checkEntry } from "./check.ts";
@@ -5,7 +6,8 @@ export { type ApiAskerOptions, type Asker, apiAsker, type ClaudeClient, ClaudeUn
 export { AGENT_ENV, type ClaudeCodeAskerOptions, type CommandRunner, claudeCodeArgs, claudeCodeAsker, type RunResult, } from "./claude-code.ts";
 export { bedrockAsker, bedrockModelId, type CloudAskerOptions, type CloudClient, vertexAsker, } from "./cloud.ts";
 export { CODEOWNERS_FILE, generateCodeowners } from "./codeowners.ts";
-export { CONFIG_FILE, type Config, configSchema, DEFAULT_AGENT_MODEL, DEFAULT_WEIGHTS, EXPORT_TARGETS, parseConfig, type Weights, } from "./config.ts";
+export { type Confidence, type ConfidenceInput, confidence, explainConfidence, } from "./confidence.ts";
+export { CONFIG_FILE, type Config, configSchema, DEFAULT_AGENT_MODEL, DEFAULT_WEIGHTS, EXPORT_TARGETS, isSenior, parseConfig, ROLES, type Role, type Weights, } from "./config.ts";
 export { type Conflict, type ConflictKind, detectConflicts, scopesOverlap, TITLE_SIMILARITY, titleSimilarity, } from "./conflicts.ts";
 export { type AgentName, cronMatches, digestCron, digestDue, dueAgents, nextRun, } from "./cron.ts";
 export { type CuratedEntry, CurateError, type CurateInput, type CurateResult, curate, type DocUpdate, type Skipped, } from "./curator/curate.ts";
@@ -24,7 +26,7 @@ export { type Entry, formatEntry, parseEntry } from "./entry.ts";
 export { describeEvent, EVENTS_DB, type Event, type EventQuery, formatEvent, LEGACY_EVENTS, logEvent, logFailure, pruneEvents, readEvents, } from "./events.ts";
 export { BLOCK_FILES, type ExportDoc, type ExportOutput, type ExportTarget, exportRules, OWNED_DIRS, } from "./export.ts";
 export { BLOCK_END, BLOCK_START, removeBlock, replaceBlock } from "./export-block.ts";
-export { readKbFiles, writeKbFile } from "./files.ts";
+export { PENDING_DIR, readKbFiles, readKbView, readPendingFiles, removePendingFile, writeKbFile, writePendingFile, } from "./files.ts";
 export { applyFixes } from "./fix.ts";
 export { type Flag, flagEntry } from "./flag.ts";
 export { error, type Fix, hasErrors, type Issue, type Severity } from "./issues.ts";

package/dist/src/index.js

@@ -1,3 +1,4 @@
+export { candidatesBranch, decisionsPath, HEARTBEAT_PATH, lessonHash, REVIEW_REMINDER_DAYS, STALE_HEARTBEAT_HOURS, STATE_BRANCH, } from "./automation.js";
 export { autoMergeDecision, splitAutoMerge, } from "./automerge.js";
 export { parseBody, RULE_MAX_WORDS, WHY_MAX_WORDS } from "./body.js";
 export { CORE_AREA, checkEntry } from "./check.js";
@@ -5,7 +6,8 @@ export { apiAsker, ClaudeUnavailableError, } from "./claude.js";
 export { AGENT_ENV, claudeCodeArgs, claudeCodeAsker, } from "./claude-code.js";
 export { bedrockAsker, bedrockModelId, vertexAsker, } from "./cloud.js";
 export { CODEOWNERS_FILE, generateCodeowners } from "./codeowners.js";
-export { CONFIG_FILE, configSchema, DEFAULT_AGENT_MODEL, DEFAULT_WEIGHTS, EXPORT_TARGETS, parseConfig, } from "./config.js";
+export { confidence, explainConfidence, } from "./confidence.js";
+export { CONFIG_FILE, configSchema, DEFAULT_AGENT_MODEL, DEFAULT_WEIGHTS, EXPORT_TARGETS, isSenior, parseConfig, ROLES, } from "./config.js";
 export { detectConflicts, scopesOverlap, TITLE_SIMILARITY, titleSimilarity, } from "./conflicts.js";
 export { cronMatches, digestCron, digestDue, dueAgents, nextRun, } from "./cron.js";
 export { CurateError, curate, } from "./curator/curate.js";
@@ -24,7 +26,7 @@ export { formatEntry, parseEntry } from "./entry.js";
 export { describeEvent, EVENTS_DB, formatEvent, LEGACY_EVENTS, logEvent, logFailure, pruneEvents, readEvents, } from "./events.js";
 export { BLOCK_FILES, exportRules, OWNED_DIRS, } from "./export.js";
 export { BLOCK_END, BLOCK_START, removeBlock, replaceBlock } from "./export-block.js";
-export { readKbFiles, writeKbFile } from "./files.js";
+export { PENDING_DIR, readKbFiles, readKbView, readPendingFiles, removePendingFile, writeKbFile, writePendingFile, } from "./files.js";
 export { applyFixes } from "./fix.js";
 export { flagEntry } from "./flag.js";
 export { error, hasErrors } from "./issues.js";

package/dist/src/providers/github.d.ts

@@ -19,6 +19,7 @@ export declare class GitHubProvider implements Provider {
         id: number;
         url: string;
     }>;
+    requestReviewers(repo: RepoRef, pullRequestId: number, logins: string[]): Promise<void>;
     mergePullRequest(repo: RepoRef, pullRequestId: number): Promise<void>;
     private repoUrl;
     private headers;

package/dist/src/providers/github.js

@@ -101,6 +101,11 @@ export class GitHubProvider {
         const created = body;
         return { id: created.number, url: created.html_url };
     }
+    async requestReviewers(repo, pullRequestId, logins) {
+        if (logins.length === 0)
+            return;
+        await requestJson("GitHub", this.fetch, `${this.repoUrl(repo)}/pulls/${pullRequestId}/requested_reviewers`, { method: "POST", headers: this.headers(), body: { reviewers: logins } });
+    }
     async mergePullRequest(repo, pullRequestId) {
         await requestJson("GitHub", this.fetch, `${this.repoUrl(repo)}/pulls/${pullRequestId}/merge`, {
             method: "PUT",

package/dist/src/providers/types.d.ts

@@ -63,6 +63,8 @@ export interface Provider {
     }>;
     /** Squash-merges a PR on the KB repo; used only for entries that pass every auto-merge gate. */
     mergePullRequest(repo: RepoRef, pullRequestId: number): Promise<void>;
+    /** Asks these git-host users (logins, no @) to review; hosts without it mention them instead. */
+    requestReviewers?(repo: RepoRef, pullRequestId: number, logins: string[]): Promise<void>;
 }
 export interface ProviderOptions {
     /** Access token owned by the team (see the permissions model in the execution plan). */

package/dist/src/score.d.ts

@@ -1,4 +1,4 @@
-import type { Config, Weights } from "./config.ts";
+import { type Config, type Weights } from "./config.ts";
 import type { Frontmatter } from "./schema.ts";
 export interface ScoreContext {
     config: Config;

package/dist/src/score.js

@@ -1,3 +1,4 @@
+import { isSenior } from "./config.js";
 const BASE_SIGNAL = {
     manual: "manual",
     "agent-handoff": "agentHandoff",
@@ -26,8 +27,8 @@ export function score(entry, ctx) {
         add(BASE_SIGNAL[source.type], `source is ${source.type}`);
     }
     const author = ctx.config.team.members.find((m) => m.id === source.author);
-    if (author?.role === "senior")
-        add("seniorAuthor", `author ${author.id} is senior`);
+    if (author && isSenior(author.role))
+        add("seniorAuthor", `author ${author.id} is ${author.role}`);
     if (entry.conflictsWith?.length) {
         add("conflict", `conflicts with ${entry.conflictsWith.join(", ")}`);
     }

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.0";
+export declare const VERSION = "0.1.1";

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.0";
+export const VERSION = "0.1.1";

package/package.json

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