@sweny-ai/core 0.1.10 → 0.1.12

package/dist/cli/main.js

@@ -9,6 +9,7 @@ import chalk from "chalk";
 import { execute } from "../executor.js";
 import { triageWorkflow } from "../workflows/triage.js";
 import { implementWorkflow } from "../workflows/implement.js";
+import { seedContentWorkflow } from "../workflows/seed-content.js";
 import { consoleLogger } from "../types.js";
 import { ClaudeClient } from "../claude.js";
 import { createSkillMap, configuredSkills } from "../skills/index.js";
@@ -579,25 +580,38 @@ export async function workflowRunAction(file, options) {
             }
         };
     const observer = composeObservers(wfProgressObserver, options.stream ? createStreamObserver() : undefined);
-    // Build workflow input from config
-    const workflowInput = {
-        timeRange: config.timeRange,
-        severityFocus: config.severityFocus,
-        serviceFilter: config.serviceFilter,
-        repository: config.repository,
-        dryRun: config.dryRun,
-        baseBranch: config.baseBranch,
-        prLabels: config.prLabels,
-        additionalInstructions: config.additionalInstructions,
-        observabilityProvider: config.observabilityProvider,
-        ...(config.observabilityCredentials.sourceId && {
-            betterstackSourceId: config.observabilityCredentials.sourceId,
-        }),
-        ...(config.observabilityCredentials.tableName && {
-            betterstackTableName: config.observabilityCredentials.tableName,
-        }),
-        context: buildProviderCtx(config, mcpServers),
-    };
+    // Build workflow input — prefer --input JSON if provided, else fall back to config-derived input
+    let workflowInput;
+    if (options.input && typeof options.input === "string") {
+        try {
+            workflowInput = JSON.parse(options.input);
+        }
+        catch {
+            console.error(chalk.red("  --input must be valid JSON"));
+            process.exit(1);
+            return;
+        }
+    }
+    else {
+        workflowInput = {
+            timeRange: config.timeRange,
+            severityFocus: config.severityFocus,
+            serviceFilter: config.serviceFilter,
+            repository: config.repository,
+            dryRun: config.dryRun,
+            baseBranch: config.baseBranch,
+            prLabels: config.prLabels,
+            additionalInstructions: config.additionalInstructions,
+            observabilityProvider: config.observabilityProvider,
+            ...(config.observabilityCredentials.sourceId && {
+                betterstackSourceId: config.observabilityCredentials.sourceId,
+            }),
+            ...(config.observabilityCredentials.tableName && {
+                betterstackTableName: config.observabilityCredentials.tableName,
+            }),
+            context: buildProviderCtx(config, mcpServers),
+        };
+    }
     try {
         const results = await execute(workflow, workflowInput, {
             skills,
@@ -633,8 +647,11 @@ export function workflowExportAction(name) {
     else if (name === "implement") {
         workflow = implementWorkflow;
     }
+    else if (name === "seed-content") {
+        workflow = seedContentWorkflow;
+    }
     else {
-        console.error(chalk.red(`  Unknown workflow "${name}". Available: triage, implement`));
+        console.error(chalk.red(`  Unknown workflow "${name}". Available: triage, implement, seed-content`));
         process.exit(1);
         return;
     }
@@ -695,6 +712,7 @@ workflowCmd
     .option("--dry-run", "Validate workflow without running")
     .option("--json", "Output result as JSON on stdout; suppress progress output")
     .option("--stream", "Stream NDJSON events to stdout (for Studio / automation)")
+    .option("--input <json>", "JSON string of input data to pass to the workflow")
     .action(workflowRunAction);
 workflowCmd
     .command("export <name>")

package/dist/index.d.ts

@@ -27,7 +27,7 @@ export { execute } from "./executor.js";
 export type { ExecuteOptions } from "./executor.js";
 export { ClaudeClient } from "./claude.js";
 export type { ClaudeClientOptions } from "./claude.js";
-export { github, linear, slack, sentry, datadog, notification, builtinSkills, createSkillMap, allSkills, isSkillConfigured, configuredSkills, validateWorkflowSkills, } from "./skills/index.js";
+export { github, linear, slack, sentry, datadog, notification, supabase, builtinSkills, createSkillMap, allSkills, isSkillConfigured, configuredSkills, validateWorkflowSkills, } from "./skills/index.js";
 export type { SkillValidationResult } from "./skills/index.js";
 export { workflowZ, nodeZ, edgeZ, skillZ, parseWorkflow, validateWorkflow, workflowJsonSchema } from "./schema.js";
 export type { WorkflowError } from "./schema.js";

package/dist/index.js

@@ -27,7 +27,7 @@ export { execute } from "./executor.js";
 // Claude client
 export { ClaudeClient } from "./claude.js";
 // Skills
-export { github, linear, slack, sentry, datadog, notification, builtinSkills, createSkillMap, allSkills, isSkillConfigured, configuredSkills, validateWorkflowSkills, } from "./skills/index.js";
+export { github, linear, slack, sentry, datadog, notification, supabase, builtinSkills, createSkillMap, allSkills, isSkillConfigured, configuredSkills, validateWorkflowSkills, } from "./skills/index.js";
 // Schema & validation
 export { workflowZ, nodeZ, edgeZ, skillZ, parseWorkflow, validateWorkflow, workflowJsonSchema } from "./schema.js";
 // MCP auto-injection

package/dist/skills/index.d.ts

@@ -11,8 +11,9 @@ import { sentry } from "./sentry.js";
 import { datadog } from "./datadog.js";
 import { betterstack } from "./betterstack.js";
 import { notification } from "./notification.js";
+import { supabase } from "./supabase.js";
 export declare const builtinSkills: Skill[];
-export { github, linear, slack, sentry, datadog, betterstack, notification };
+export { github, linear, slack, sentry, datadog, betterstack, notification, supabase };
 /**
  * Build a skill map from an array of skills.
  * Pass to `execute()` as the `skills` option.

package/dist/skills/index.js

@@ -10,9 +10,10 @@ import { sentry } from "./sentry.js";
 import { datadog } from "./datadog.js";
 import { betterstack } from "./betterstack.js";
 import { notification } from "./notification.js";
+import { supabase } from "./supabase.js";
 // ─── Built-in skill catalog ─────────────────────────────────────
-export const builtinSkills = [github, linear, slack, sentry, datadog, betterstack, notification];
-export { github, linear, slack, sentry, datadog, betterstack, notification };
+export const builtinSkills = [github, linear, slack, sentry, datadog, betterstack, notification, supabase];
+export { github, linear, slack, sentry, datadog, betterstack, notification, supabase };
 // ─── Registry helpers ───────────────────────────────────────────
 /**
  * Build a skill map from an array of skills.

package/dist/skills/supabase.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Supabase Skill
+ *
+ * Query, insert, update, and manage data in a Supabase project.
+ * Uses the Supabase REST API (PostgREST) for data operations
+ * and the Management API for project-level operations.
+ */
+import type { Skill } from "../types.js";
+export declare const supabase: Skill;

package/dist/skills/supabase.js

@@ -0,0 +1,334 @@
+/**
+ * Supabase Skill
+ *
+ * Query, insert, update, and manage data in a Supabase project.
+ * Uses the Supabase REST API (PostgREST) for data operations
+ * and the Management API for project-level operations.
+ */
+async function supabaseRest(path, ctx, init) {
+    const url = ctx.config.SUPABASE_URL;
+    const key = ctx.config.SUPABASE_SERVICE_ROLE_KEY;
+    const res = await fetch(`${url}/rest/v1${path}`, {
+        ...init,
+        headers: {
+            apikey: key,
+            Authorization: `Bearer ${key}`,
+            "Content-Type": "application/json",
+            Prefer: init?.method === "POST" ? "return=representation" : "return=representation",
+            ...init?.headers,
+        },
+        signal: AbortSignal.timeout(30_000),
+    });
+    if (!res.ok) {
+        throw new Error(`[Supabase] REST API failed (HTTP ${res.status}): ${await res.text()}`);
+    }
+    const text = await res.text();
+    return text ? JSON.parse(text) : null;
+}
+async function supabaseEdgeFunction(functionName, body, ctx) {
+    const url = ctx.config.SUPABASE_URL;
+    const key = ctx.config.SUPABASE_SERVICE_ROLE_KEY;
+    const res = await fetch(`${url}/functions/v1/${functionName}`, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${key}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(60_000),
+    });
+    if (!res.ok) {
+        throw new Error(`[Supabase] Edge function "${functionName}" failed (HTTP ${res.status}): ${await res.text()}`);
+    }
+    return res.json();
+}
+export const supabase = {
+    id: "supabase",
+    name: "Supabase",
+    description: "Query, insert, update data and invoke edge functions on a Supabase project",
+    category: "general",
+    config: {
+        SUPABASE_URL: {
+            description: "Supabase project URL (e.g., https://xxxx.supabase.co)",
+            required: true,
+            env: "SUPABASE_URL",
+        },
+        SUPABASE_SERVICE_ROLE_KEY: {
+            description: "Supabase service role key (full access, server-side only)",
+            required: true,
+            env: "SUPABASE_SERVICE_ROLE_KEY",
+        },
+    },
+    tools: [
+        // ─── Read ────────────────────────────────────────────────
+        {
+            name: "supabase_query",
+            description: "Query rows from a Supabase table. Uses PostgREST query syntax. " + "Returns an array of matching rows.",
+            input_schema: {
+                type: "object",
+                properties: {
+                    table: { type: "string", description: "Table name (e.g., 'games', 'profiles')" },
+                    select: {
+                        type: "string",
+                        description: "Columns to select (PostgREST syntax). Default: '*'. Examples: 'id,title,subject', 'id,title,course_modules(id,title)'",
+                    },
+                    filters: {
+                        type: "array",
+                        description: "PostgREST filter strings. Examples: ['subject=eq.math', 'difficulty=eq.easy', 'created_at=gte.2026-01-01']",
+                        items: { type: "string" },
+                    },
+                    order: {
+                        type: "string",
+                        description: "Order by clause. Examples: 'created_at.desc', 'title.asc'",
+                    },
+                    limit: {
+                        type: "number",
+                        description: "Maximum rows to return. Default: 100",
+                    },
+                },
+                required: ["table"],
+            },
+            handler: async (input, ctx) => {
+                const params = new URLSearchParams();
+                params.set("select", input.select || "*");
+                if (input.order)
+                    params.set("order", input.order);
+                params.set("limit", String(input.limit || 100));
+                let path = `/${input.table}?${params}`;
+                if (input.filters) {
+                    for (const f of input.filters) {
+                        path += `&${f}`;
+                    }
+                }
+                return supabaseRest(path, ctx);
+            },
+        },
+        {
+            name: "supabase_count",
+            description: "Count rows in a table, optionally with filters.",
+            input_schema: {
+                type: "object",
+                properties: {
+                    table: { type: "string", description: "Table name" },
+                    filters: {
+                        type: "array",
+                        description: "PostgREST filter strings",
+                        items: { type: "string" },
+                    },
+                },
+                required: ["table"],
+            },
+            handler: async (input, ctx) => {
+                const url = ctx.config.SUPABASE_URL;
+                const key = ctx.config.SUPABASE_SERVICE_ROLE_KEY;
+                let path = `${url}/rest/v1/${input.table}?select=count`;
+                if (input.filters) {
+                    for (const f of input.filters) {
+                        path += `&${f}`;
+                    }
+                }
+                const res = await fetch(path, {
+                    headers: {
+                        apikey: key,
+                        Authorization: `Bearer ${key}`,
+                        Prefer: "count=exact",
+                    },
+                    signal: AbortSignal.timeout(15_000),
+                });
+                if (!res.ok) {
+                    throw new Error(`[Supabase] Count failed: ${await res.text()}`);
+                }
+                const range = res.headers.get("content-range");
+                const count = range ? parseInt(range.split("/")[1], 10) : 0;
+                return { table: input.table, count };
+            },
+        },
+        // ─── Write ───────────────────────────────────────────────
+        {
+            name: "supabase_insert",
+            description: "Insert one or more rows into a table. Returns the inserted rows. " +
+                "Use upsert=true to update existing rows on conflict.",
+            input_schema: {
+                type: "object",
+                properties: {
+                    table: { type: "string", description: "Table name" },
+                    rows: {
+                        type: "array",
+                        description: "Array of row objects to insert",
+                        items: { type: "object" },
+                    },
+                    upsert: {
+                        type: "boolean",
+                        description: "If true, update on conflict instead of failing. Default: false",
+                    },
+                },
+                required: ["table", "rows"],
+            },
+            handler: async (input, ctx) => {
+                const headers = {};
+                if (input.upsert) {
+                    headers["Prefer"] = "resolution=merge-duplicates,return=representation";
+                }
+                return supabaseRest(`/${input.table}`, ctx, {
+                    method: "POST",
+                    headers,
+                    body: JSON.stringify(input.rows),
+                });
+            },
+        },
+        {
+            name: "supabase_update",
+            description: "Update rows matching filters. Returns the updated rows.",
+            input_schema: {
+                type: "object",
+                properties: {
+                    table: { type: "string", description: "Table name" },
+                    filters: {
+                        type: "array",
+                        description: "PostgREST filter strings to match rows (REQUIRED — prevents accidental full-table updates)",
+                        items: { type: "string" },
+                    },
+                    data: {
+                        type: "object",
+                        description: "Fields to update",
+                    },
+                },
+                required: ["table", "filters", "data"],
+            },
+            handler: async (input, ctx) => {
+                if (!input.filters || input.filters.length === 0) {
+                    throw new Error("Filters are required for update operations to prevent accidental full-table updates");
+                }
+                let path = `/${input.table}`;
+                const filterParts = input.filters.map((f) => f);
+                path += `?${filterParts.join("&")}`;
+                return supabaseRest(path, ctx, {
+                    method: "PATCH",
+                    body: JSON.stringify(input.data),
+                });
+            },
+        },
+        {
+            name: "supabase_delete",
+            description: "Delete rows matching filters. Returns the deleted rows.",
+            input_schema: {
+                type: "object",
+                properties: {
+                    table: { type: "string", description: "Table name" },
+                    filters: {
+                        type: "array",
+                        description: "PostgREST filter strings (REQUIRED — prevents accidental full-table deletes)",
+                        items: { type: "string" },
+                    },
+                },
+                required: ["table", "filters"],
+            },
+            handler: async (input, ctx) => {
+                if (!input.filters || input.filters.length === 0) {
+                    throw new Error("Filters are required for delete operations");
+                }
+                const path = `/${input.table}?${input.filters.join("&")}`;
+                return supabaseRest(path, ctx, { method: "DELETE" });
+            },
+        },
+        // ─── RPC ─────────────────────────────────────────────────
+        {
+            name: "supabase_rpc",
+            description: "Call a Supabase RPC (stored procedure / database function).",
+            input_schema: {
+                type: "object",
+                properties: {
+                    function_name: { type: "string", description: "Name of the database function" },
+                    params: {
+                        type: "object",
+                        description: "Parameters to pass to the function",
+                    },
+                },
+                required: ["function_name"],
+            },
+            handler: async (input, ctx) => {
+                return supabaseRest(`/rpc/${input.function_name}`, ctx, {
+                    method: "POST",
+                    body: JSON.stringify(input.params || {}),
+                });
+            },
+        },
+        // ─── Edge Functions ──────────────────────────────────────
+        {
+            name: "supabase_invoke_function",
+            description: "Invoke a Supabase Edge Function by name with a JSON body.",
+            input_schema: {
+                type: "object",
+                properties: {
+                    function_name: {
+                        type: "string",
+                        description: "Edge function name (e.g., 'agent-gateway', 'seed-content')",
+                    },
+                    body: {
+                        type: "object",
+                        description: "JSON body to send to the function",
+                    },
+                },
+                required: ["function_name", "body"],
+            },
+            handler: async (input, ctx) => {
+                return supabaseEdgeFunction(input.function_name, input.body, ctx);
+            },
+        },
+        // ─── Auth Admin ──────────────────────────────────────────
+        {
+            name: "supabase_list_users",
+            description: "List auth users. Returns user IDs, emails, and metadata.",
+            input_schema: {
+                type: "object",
+                properties: {
+                    page: { type: "number", description: "Page number (1-based). Default: 1" },
+                    per_page: { type: "number", description: "Users per page. Default: 50" },
+                },
+            },
+            handler: async (input, ctx) => {
+                const url = ctx.config.SUPABASE_URL;
+                const key = ctx.config.SUPABASE_SERVICE_ROLE_KEY;
+                const page = input.page || 1;
+                const perPage = input.per_page || 50;
+                const res = await fetch(`${url}/auth/v1/admin/users?page=${page}&per_page=${perPage}`, {
+                    headers: {
+                        Authorization: `Bearer ${key}`,
+                        apikey: key,
+                    },
+                    signal: AbortSignal.timeout(15_000),
+                });
+                if (!res.ok) {
+                    throw new Error(`[Supabase] List users failed: ${await res.text()}`);
+                }
+                return res.json();
+            },
+        },
+        // ─── Schema Introspection ────────────────────────────────
+        {
+            name: "supabase_list_tables",
+            description: "List all public tables with row counts. Useful for content auditing.",
+            input_schema: {
+                type: "object",
+                properties: {},
+            },
+            handler: async (_input, ctx) => {
+                return supabaseRest("/rpc/get_table_counts", ctx, { method: "POST", body: JSON.stringify({}) }).catch(async () => {
+                    // Fallback: query information_schema
+                    const url = ctx.config.SUPABASE_URL;
+                    const key = ctx.config.SUPABASE_SERVICE_ROLE_KEY;
+                    const res = await fetch(`${url}/rest/v1/rpc/`, {
+                        method: "POST",
+                        headers: {
+                            apikey: key,
+                            Authorization: `Bearer ${key}`,
+                            "Content-Type": "application/json",
+                        },
+                        body: JSON.stringify({}),
+                    });
+                    return { note: "get_table_counts RPC not available. Use supabase_query to check specific tables." };
+                });
+            },
+        },
+    ],
+};

package/dist/workflows/index.d.ts

@@ -1,2 +1,3 @@
 export { triageWorkflow } from "./triage.js";
 export { implementWorkflow } from "./implement.js";
+export { seedContentWorkflow } from "./seed-content.js";

package/dist/workflows/index.js

@@ -1,2 +1,3 @@
 export { triageWorkflow } from "./triage.js";
 export { implementWorkflow } from "./implement.js";
+export { seedContentWorkflow } from "./seed-content.js";

package/dist/workflows/seed-content.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Content Generation Workflow
+ *
+ * A DAG that audits a Supabase-backed educational platform for content gaps,
+ * generates high-quality content using Claude, validates it, and publishes it.
+ *
+ * Designed for solo operators bootstrapping educational SaaS platforms.
+ * Uses Claude (via your existing subscription) for generation instead of
+ * burning API credits on external AI gateways.
+ *
+ * @example
+ * ```ts
+ * import { execute, ClaudeClient, createSkillMap, supabase } from '@sweny-ai/core'
+ * import { seedContentWorkflow } from '@sweny-ai/core/workflows'
+ *
+ * const skills = createSkillMap([supabase])
+ * const claude = new ClaudeClient()
+ *
+ * const results = await execute(seedContentWorkflow, {
+ *   contentType: 'worksheet',           // 'worksheet' | 'game' | 'lesson'
+ *   subject: 'math',
+ *   topic: 'fractions',
+ *   difficulty: 'easy',
+ *   gradeLevel: '3rd-grade',
+ *   count: 5,
+ * }, { skills, claude })
+ * ```
+ */
+import type { Workflow } from "../types.js";
+export declare const seedContentWorkflow: Workflow;

package/dist/workflows/seed-content.js

@@ -0,0 +1,217 @@
+/**
+ * Content Generation Workflow
+ *
+ * A DAG that audits a Supabase-backed educational platform for content gaps,
+ * generates high-quality content using Claude, validates it, and publishes it.
+ *
+ * Designed for solo operators bootstrapping educational SaaS platforms.
+ * Uses Claude (via your existing subscription) for generation instead of
+ * burning API credits on external AI gateways.
+ *
+ * @example
+ * ```ts
+ * import { execute, ClaudeClient, createSkillMap, supabase } from '@sweny-ai/core'
+ * import { seedContentWorkflow } from '@sweny-ai/core/workflows'
+ *
+ * const skills = createSkillMap([supabase])
+ * const claude = new ClaudeClient()
+ *
+ * const results = await execute(seedContentWorkflow, {
+ *   contentType: 'worksheet',           // 'worksheet' | 'game' | 'lesson'
+ *   subject: 'math',
+ *   topic: 'fractions',
+ *   difficulty: 'easy',
+ *   gradeLevel: '3rd-grade',
+ *   count: 5,
+ * }, { skills, claude })
+ * ```
+ */
+export const seedContentWorkflow = {
+    id: "seed-content",
+    name: "Content Generation Pipeline",
+    description: "Audit content gaps, generate educational content, validate quality, and publish to Supabase",
+    entry: "audit",
+    nodes: {
+        // ─── Step 1: Audit ─────────────────────────────────────
+        audit: {
+            name: "Audit Content Gaps",
+            instruction: `You are auditing an educational platform's content library.
+
+Use supabase_count to check how many items exist for each combination of:
+- Content types: worksheets, games, lessons
+- Subjects: math, science, english, history, geography, economics, music, art, life-skills, foreign-language
+- Difficulties: beginner, easy, medium, hard
+
+Also check the input parameters — if the user specified a subject, topic, difficulty, and count,
+skip the full audit and just report what they want generated.
+
+Return a structured content plan: what to generate, how many, at what difficulty and grade level.
+Prioritize gaps where a subject has ZERO content of a given type.`,
+            skills: ["supabase"],
+            output: {
+                type: "object",
+                properties: {
+                    plan: {
+                        type: "array",
+                        items: {
+                            type: "object",
+                            properties: {
+                                contentType: { type: "string" },
+                                subject: { type: "string" },
+                                topic: { type: "string" },
+                                difficulty: { type: "string" },
+                                gradeLevel: { type: "string" },
+                                count: { type: "number" },
+                                reason: { type: "string" },
+                            },
+                            required: ["contentType", "subject", "topic", "difficulty", "count"],
+                        },
+                    },
+                    summary: { type: "string" },
+                },
+                required: ["plan", "summary"],
+            },
+        },
+        // ─── Step 2: Generate ──────────────────────────────────
+        generate: {
+            name: "Generate Content",
+            instruction: `You are an expert educator creating content for children ages 5-14.
+
+For each item in the content plan from the previous step, generate the content directly.
+The content must be high-quality, engaging, age-appropriate, and educationally sound.
+
+**For worksheets:**
+Generate a JSON array of problems. Each problem needs: "problem", "answer", "format" (answer-line | multiple-choice | write-on).
+Requirements:
+- Every answer MUST be correct. Double-check math, facts, spelling.
+- Problems must progress in difficulty within the set.
+- Use at least 2 different problem structures (e.g., equations + word problems for math).
+- Vary phrasing — no two problems should feel copy-pasted.
+- For the target grade level, use appropriate vocabulary and complexity.
+
+**For lessons:**
+Generate complete HTML + CSS + JS for an interactive lesson.
+Requirements:
+- Must have substantial educational content (not just a shell with navigation).
+- Include interactive elements: quizzes, click-to-reveal, drag-and-drop.
+- Must be visually engaging with colors, icons, and clear typography.
+- Include practice exercises with immediate feedback.
+- Minimum 5 teaching sections plus 2 practice activities.
+
+**For games:**
+Generate a description and educational requirements only (actual game code is generated
+by the platform's Phaser-based generator).
+
+Use supabase_insert to write each piece of content to the appropriate table.
+
+Table schemas:
+- worksheets: id (auto), title, subject, topic, difficulty, grade_level, num_questions, problems (jsonb), status='published', source='ai-seed'
+- lessons: id (auto), title, subject, difficulty, grade_level, lesson_type, html_code, css_code, js_code, status='published', source='ai-seed'
+- games: id (auto), title, subject, difficulty, grade_level, game_type, html_code, css_code, js_code, status='published', source='ai-seed'
+
+Return a summary of what was generated and inserted.`,
+            skills: ["supabase"],
+            output: {
+                type: "object",
+                properties: {
+                    generated: {
+                        type: "array",
+                        items: {
+                            type: "object",
+                            properties: {
+                                contentType: { type: "string" },
+                                title: { type: "string" },
+                                subject: { type: "string" },
+                                id: { type: "string" },
+                                status: { type: "string" },
+                            },
+                        },
+                    },
+                    totalGenerated: { type: "number" },
+                    errors: { type: "array", items: { type: "string" } },
+                },
+                required: ["generated", "totalGenerated"],
+            },
+        },
+        // ─── Step 3: Validate ──────────────────────────────────
+        validate: {
+            name: "Validate Content Quality",
+            instruction: `Review the content that was just generated and inserted.
+
+For each item, use supabase_query to fetch it back and verify:
+
+**Worksheets:**
+- Parse the problems JSON — are all answers correct?
+- Are problems diverse (not repetitive)?
+- Is difficulty appropriate for the stated grade level?
+- Are there the right number of questions?
+
+**Lessons:**
+- Is the HTML substantial (> 500 characters)?
+- Does it contain actual educational content (not just navigation shells)?
+- Are there interactive elements?
+
+**Games:**
+- Does the HTML contain a working game structure?
+
+Flag any issues. If critical issues are found (wrong answers, empty content),
+use supabase_update to set status='draft' and add a note.
+
+Return a quality report.`,
+            skills: ["supabase"],
+            output: {
+                type: "object",
+                properties: {
+                    totalReviewed: { type: "number" },
+                    passed: { type: "number" },
+                    flagged: { type: "number" },
+                    issues: {
+                        type: "array",
+                        items: {
+                            type: "object",
+                            properties: {
+                                id: { type: "string" },
+                                title: { type: "string" },
+                                issue: { type: "string" },
+                                severity: { type: "string" },
+                                action: { type: "string" },
+                            },
+                        },
+                    },
+                    summary: { type: "string" },
+                },
+                required: ["totalReviewed", "passed", "flagged", "summary"],
+            },
+        },
+        // ─── Step 4: Report ────────────────────────────────────
+        report: {
+            name: "Generate Report",
+            instruction: `Compile a final report of the content generation run.
+
+Include:
+- Total content generated by type and subject
+- Quality validation results
+- Any issues found and actions taken
+- Recommendations for next content generation run (what gaps remain)
+
+Format as a clean markdown summary that a solo operator can scan in 30 seconds.`,
+            skills: [],
+            output: {
+                type: "object",
+                properties: {
+                    markdown: { type: "string" },
+                    nextPriorities: {
+                        type: "array",
+                        items: { type: "string" },
+                    },
+                },
+                required: ["markdown"],
+            },
+        },
+    },
+    edges: [
+        { from: "audit", to: "generate" },
+        { from: "generate", to: "validate" },
+        { from: "validate", to: "report" },
+    ],
+};

package/dist/workflows/triage.js

@@ -104,9 +104,10 @@ Downstream nodes will act ONLY on novel findings. Duplicates will be +1'd automa
 4. Link to relevant commits, PRs, or existing issues.
 
 **For each DUPLICATE finding** (is_duplicate = true):
-1. Find the existing issue using the issue tracker (check duplicate_of field).
-2. Add a comment: "+1 — SWEny triage confirmed this issue is still active (seen again at {current UTC timestamp}). Latest context: {1-2 sentence summary}."
-3. If the existing issue is closed/done, reopen it or note in the comment that the bug has recurred.
+1. Find the existing issue (check duplicate_of field).
+2. Check the issue's comments — if the most recent comment is already from SWEny (contains "+1") within the last 24 hours, skip adding another comment.
+3. Otherwise add a SHORT comment: "+1 — seen again {UTC timestamp}. {one sentence of new context}." (Keep it under 2 lines. No markdown headers, no emoji, no formatting.)
+4. If the existing issue is closed/done, reopen it.
 
 If context.issueTemplate is provided, use it as the format for new issue bodies. Otherwise use a clear structure with: Summary, Root Cause, Impact, Steps to Reproduce, and Recommended Fix.
 
@@ -118,9 +119,10 @@ Use whichever issue tracker is available to you. Output the created/updated issu
             instruction: `Every finding from the investigation was either a duplicate or low-priority. No new issues need to be created.
 
 For each **duplicate** finding (check the findings array for items where is_duplicate = true):
-1. Find the existing issue using the issue tracker (check duplicate_of field).
-2. Add a comment: "+1 — SWEny triage confirmed this issue is still active (seen again at {current UTC timestamp}). Latest context: {1-2 sentence summary of what was found this run}."
-3. If the issue is closed/done, reopen it or note in the comment that the bug has recurred.
+1. Find the existing issue (check duplicate_of field).
+2. Check the issue's comments — if the most recent comment is already from SWEny (contains "+1") within the last 24 hours, skip adding another comment.
+3. Otherwise add a SHORT comment: "+1 — seen again {UTC timestamp}. {one sentence of new context}." (Keep it under 2 lines. No markdown headers, no emoji, no formatting.)
+4. If the issue is closed/done, reopen it.
 
 For **low priority** findings, log a brief note about why they were skipped.`,
             skills: ["linear", "github"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sweny-ai/core",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "type": "module",
   "bin": {
     "sweny": "./dist/cli/main.js"