@oss-scout/core 0.6.0 → 0.7.1

package/dist/core/issue-vetting.d.ts

@@ -23,6 +23,15 @@ export interface ScoutStateReader {
     getProjectCategories(): ProjectCategory[];
     /** Numeric quality score for a repo, or null if not evaluated. */
     getRepoScore(repo: string): number | null;
+    /**
+     * SLM pre-triage config (oss-autopilot#1122). Returns the configured
+     * model id and Ollama host, or empty strings when not configured —
+     * vetIssue treats either of these as "skip the SLM call".
+     */
+    getSLMTriageConfig?(): {
+        model: string;
+        host: string;
+    };
 }
 export declare class IssueVetter {
     private octokit;

package/dist/core/issue-vetting.js

@@ -15,6 +15,7 @@ import { checkNoExistingPR, checkNotClaimed, checkUserMergedPRsInRepo, analyzeRe
 import { checkProjectHealth, fetchContributionGuidelines, } from "./repo-health.js";
 import { fetchAndScanAntiLLMPolicy } from "./anti-llm-policy.js";
 import { getHttpCache } from "./http-cache.js";
+import { triageWithSLM, buildTriageInput, } from "./slm-triage.js";
 const MODULE = "issue-vetting";
 /** Vetting concurrency: kept low to reduce burst pressure on GitHub's secondary rate limit. */
 const MAX_CONCURRENT_VETTING = 3;
@@ -221,11 +222,28 @@ export class IssueVetter {
         else if (starredRepos.includes(repoFullName)) {
             searchPriority = "starred";
         }
+        // Optional SLM pre-triage (oss-autopilot#1122). Fail-open: any error
+        // path returns null and the rest of the pipeline is unaffected.
+        const slmConfig = this.stateReader.getSLMTriageConfig?.() ?? {
+            model: "",
+            host: "",
+        };
+        let slmTriage = null;
+        if (slmConfig.model) {
+            const slmOpts = { model: slmConfig.model };
+            if (slmConfig.host)
+                slmOpts.host = slmConfig.host;
+            slmTriage = await triageWithSLM(buildTriageInput({
+                issue: { ...trackedIssue, body: ghIssue.body ?? "" },
+                linkedPR: existingPRCheck.linkedPR ?? null,
+            }), slmOpts);
+        }
         const result = {
             issue: trackedIssue,
             vettingResult,
             projectHealth,
             antiLLMPolicy,
+            slmTriage,
             recommendation,
             reasonsToSkip,
             reasonsToApprove,

package/dist/core/schemas.d.ts

@@ -252,6 +252,8 @@ export declare const ScoutPreferencesSchema: z.ZodObject<{
     }>>>;
     broadPhaseDelayMs: z.ZodDefault<z.ZodNumber>;
     skipBroadWhenSufficientResults: z.ZodDefault<z.ZodNumber>;
+    slmTriageModel: z.ZodDefault<z.ZodString>;
+    slmTriageHost: z.ZodDefault<z.ZodString>;
 }, z.core.$strip>;
 export declare const ScoutStateSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
@@ -293,6 +295,8 @@ export declare const ScoutStateSchema: z.ZodObject<{
         }>>>;
         broadPhaseDelayMs: z.ZodDefault<z.ZodNumber>;
         skipBroadWhenSufficientResults: z.ZodDefault<z.ZodNumber>;
+        slmTriageModel: z.ZodDefault<z.ZodString>;
+        slmTriageHost: z.ZodDefault<z.ZodString>;
     }, z.core.$strip>>;
     repoScores: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
         repo: z.ZodString;

package/dist/core/schemas.js

@@ -164,6 +164,19 @@ export const ScoutPreferencesSchema = z.object({
     defaultStrategy: z.array(SearchStrategySchema).optional(),
     broadPhaseDelayMs: z.number().min(0).max(300000).default(90000),
     skipBroadWhenSufficientResults: z.number().int().min(0).max(100).default(15),
+    /**
+     * Optional Ollama model id used for SLM pre-triage during vetting
+     * (oss-autopilot#1122). Empty disables the feature. Recommended values:
+     * `gemma4:e4b` (default for capable hardware) or `gemma4:e2b` /
+     * `qwen3:1.7b` for low-RAM machines.
+     */
+    slmTriageModel: z.string().default(""),
+    /**
+     * Override the Ollama HTTP host. Defaults to `http://127.0.0.1:11434`
+     * when empty. Useful when Ollama runs on a different machine on the
+     * local network.
+     */
+    slmTriageHost: z.string().default(""),
 });
 // ── Root state schema ───────────────────────────────────────────────
 export const ScoutStateSchema = z.object({

package/dist/core/slm-triage.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Optional SLM (small language model) pre-triage pass for vetted issues
+ * (oss-autopilot#1122).
+ *
+ * When the user has an Ollama instance running locally and a model
+ * configured via `slmTriageModel`, vetting can call out to that model
+ * for a structured classification of each candidate issue. The result
+ * is surfaced on `IssueCandidate.slmTriage` so consumers (autopilot
+ * agents, dashboard, vet-list output) can show the call up-front and
+ * skip the cost of reading every issue body manually.
+ *
+ * Design highlights:
+ * - **Fail open.** Any failure (no model configured, Ollama down,
+ *   timeout, malformed JSON, schema mismatch) returns `null`. Triage
+ *   must never block the rest of the vetting pipeline.
+ * - **Schema-enforced JSON.** Uses Ollama's `format` parameter so the
+ *   decoder produces JSON conformant to a fixed schema; eliminates the
+ *   "model returned partial JSON" failure mode that plagues prompt-only
+ *   structured-output schemes.
+ * - **15s timeout.** Local SLMs vary widely in latency; 15s covers
+ *   small-to-mid models on consumer hardware (Gemma 4 e4b, Qwen 3 4b).
+ *   Slower models simply produce `null` and don't block vetting.
+ */
+import type { TrackedIssue, LinkedPR } from "./schemas.js";
+/**
+ * Result of an SLM triage call. The same shape Ollama is constrained to
+ * produce via `format` schema enforcement.
+ */
+export interface SLMTriageResult {
+    /** Three buckets that match human triage decisions. */
+    decision: "pursue" | "investigate" | "skip";
+    /** How sure the model is. Surface in UI; don't gate on it server-side. */
+    confidence: "high" | "medium" | "low";
+    /** Short phrases (not sentences) explaining the decision. 1–3 entries. */
+    reasons: string[];
+    /** Model id that produced this result. Useful when comparing runs. */
+    modelVersion: string;
+}
+/** Inputs to a triage call. */
+export interface SLMTriageInput {
+    issue: Pick<TrackedIssue, "title" | "labels"> & {
+        body?: string;
+    };
+    linkedPRExists: boolean;
+}
+/** Runtime options for `triageWithSLM`. */
+export interface SLMTriageOptions {
+    /** Model id (e.g. `gemma4:e4b`). Empty/unset disables triage. */
+    model: string;
+    /** Override Ollama base URL. Defaults to `http://127.0.0.1:11434`. */
+    host?: string;
+    /** Override request timeout. */
+    timeoutMs?: number;
+    /** Override fetch implementation (for tests). */
+    fetchImpl?: typeof fetch;
+}
+/**
+ * Run an SLM triage classification. Returns `null` on any failure path
+ * — caller treats `null` as "no SLM signal available".
+ */
+export declare function triageWithSLM(input: SLMTriageInput, options: SLMTriageOptions): Promise<SLMTriageResult | null>;
+/**
+ * Adapter: build an `SLMTriageInput` from the standard scout types we
+ * carry through `vetIssue`. Centralizes the mapping so callers don't
+ * have to know about the prompt internals.
+ */
+export declare function buildTriageInput(args: {
+    issue: TrackedIssue & {
+        body?: string;
+    };
+    linkedPR: LinkedPR | null | undefined;
+}): SLMTriageInput;

package/dist/core/slm-triage.js

@@ -0,0 +1,135 @@
+/** Default Ollama HTTP endpoint when not overridden. */
+const DEFAULT_OLLAMA_HOST = "http://127.0.0.1:11434";
+/** Default per-call timeout. */
+const DEFAULT_TIMEOUT_MS = 15_000;
+/** Hard cap on issue body length we send to the model. */
+const MAX_BODY_CHARS = 2000;
+/** JSON schema enforced server-side by Ollama's `format` parameter. */
+const SLM_TRIAGE_SCHEMA = {
+    type: "object",
+    properties: {
+        decision: { type: "string", enum: ["pursue", "investigate", "skip"] },
+        confidence: { type: "string", enum: ["high", "medium", "low"] },
+        reasons: {
+            type: "array",
+            items: { type: "string" },
+            minItems: 1,
+            maxItems: 3,
+        },
+    },
+    required: ["decision", "confidence", "reasons"],
+};
+/** Build the user-message prompt from an issue. */
+function buildPrompt(input) {
+    const { issue, linkedPRExists } = input;
+    const body = (issue.body ?? "").slice(0, MAX_BODY_CHARS);
+    return [
+        "You triage open-source issues for an autonomous contribution agent.",
+        "Classify the issue into exactly one bucket:",
+        "- pursue: small, concrete bug or feature with clear acceptance; safe for an autonomous agent to attempt without further design input",
+        "- investigate: tractable but needs human reading first (ambiguous scope, design questions, recently-touched files)",
+        "- skip: not actionable autonomously (epic, creative, blocked, requires upstream change, requires infra)",
+        "",
+        "Return JSON only matching the provided schema. Reasons must be short phrases, not sentences. 1-3 reasons total.",
+        "",
+        "Issue:",
+        `Title: ${issue.title}`,
+        `Body: ${body}`,
+        `Labels: ${issue.labels.join(", ")}`,
+        `Linked PR exists: ${linkedPRExists}`,
+    ].join("\n");
+}
+/**
+ * Run an SLM triage classification. Returns `null` on any failure path
+ * — caller treats `null` as "no SLM signal available".
+ */
+export async function triageWithSLM(input, options) {
+    if (!options.model)
+        return null;
+    const host = options.host ?? DEFAULT_OLLAMA_HOST;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const fetchFn = options.fetchImpl ?? fetch;
+    let response;
+    try {
+        response = await fetchFn(`${host}/api/chat`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                model: options.model,
+                messages: [{ role: "user", content: buildPrompt(input) }],
+                stream: false,
+                format: SLM_TRIAGE_SCHEMA,
+                options: { temperature: 0.1 },
+            }),
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+    }
+    catch {
+        // Connection refused, timeout, DNS error, etc.
+        return null;
+    }
+    if (!response.ok)
+        return null;
+    let payload;
+    try {
+        payload = await response.json();
+    }
+    catch {
+        return null;
+    }
+    // Ollama `chat` returns { message: { content: string }, ... }.
+    const content = payload?.message
+        ?.content;
+    if (typeof content !== "string")
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+    if (!isValidTriageShape(parsed))
+        return null;
+    return {
+        decision: parsed.decision,
+        confidence: parsed.confidence,
+        reasons: parsed.reasons,
+        modelVersion: options.model,
+    };
+}
+/**
+ * Adapter: build an `SLMTriageInput` from the standard scout types we
+ * carry through `vetIssue`. Centralizes the mapping so callers don't
+ * have to know about the prompt internals.
+ */
+export function buildTriageInput(args) {
+    return {
+        issue: {
+            title: args.issue.title,
+            labels: args.issue.labels,
+            body: args.issue.body,
+        },
+        linkedPRExists: !!args.linkedPR,
+    };
+}
+function isValidTriageShape(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const v = value;
+    if (v.decision !== "pursue" &&
+        v.decision !== "investigate" &&
+        v.decision !== "skip")
+        return false;
+    if (v.confidence !== "high" &&
+        v.confidence !== "medium" &&
+        v.confidence !== "low")
+        return false;
+    if (!Array.isArray(v.reasons) ||
+        v.reasons.length === 0 ||
+        v.reasons.length > 3)
+        return false;
+    if (!v.reasons.every((r) => typeof r === "string"))
+        return false;
+    return true;
+}

package/dist/core/types.d.ts

@@ -28,12 +28,26 @@ export interface AntiLLMPolicyResult {
     matchedKeywords: string[];
     sourceFile: AntiLLMPolicySourceFile | null;
 }
+/**
+ * Optional SLM (small language model) pre-triage classification for an
+ * issue (oss-autopilot#1122). Populated when the user has configured
+ * `slmTriageModel` and a local Ollama instance is reachable. Always
+ * fail-open: any error path leaves this `null`.
+ */
+export interface SLMTriageSummary {
+    decision: "pursue" | "investigate" | "skip";
+    confidence: "high" | "medium" | "low";
+    reasons: string[];
+    modelVersion: string;
+}
 /** A fully vetted issue candidate with scoring. */
 export interface IssueCandidate {
     issue: TrackedIssue;
     vettingResult: IssueVettingResult;
     projectHealth: ProjectHealth;
     antiLLMPolicy: AntiLLMPolicyResult;
+    /** SLM pre-triage result, or `null` when not configured / unavailable. */
+    slmTriage: SLMTriageSummary | null;
     recommendation: "approve" | "skip" | "needs_review";
     reasonsToSkip: string[];
     reasonsToApprove: string[];

package/dist/scout.d.ts

@@ -63,6 +63,14 @@ export declare class OssScout implements ScoutStateReader {
     getStarredRepos(): string[];
     getProjectCategories(): ProjectCategory[];
     getRepoScore(repo: string): number | null;
+    /**
+     * Optional SLM pre-triage config read from preferences (oss-autopilot#1122).
+     * Empty `model` disables the call; the vetter treats it as a no-op.
+     */
+    getSLMTriageConfig(): {
+        model: string;
+        host: string;
+    };
     /** Get current preferences (read-only). */
     getPreferences(): Readonly<ScoutPreferences>;
     /** Get repo score record for a specific repository. */

package/dist/scout.js

@@ -258,6 +258,16 @@ export class OssScout {
         const score = this.state.repoScores[repo];
         return score ? score.score : null;
     }
+    /**
+     * Optional SLM pre-triage config read from preferences (oss-autopilot#1122).
+     * Empty `model` disables the call; the vetter treats it as a no-op.
+     */
+    getSLMTriageConfig() {
+        return {
+            model: this.state.preferences.slmTriageModel ?? "",
+            host: this.state.preferences.slmTriageHost ?? "",
+        };
+    }
     /** Get current preferences (read-only). */
     getPreferences() {
         return this.state.preferences;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oss-scout/core",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "Personalized GitHub issue finder with multi-strategy search, deep vetting, and viability scoring — CLI, library, MCP server, and Claude Code plugin",
   "type": "module",
   "bin": {