@sweny-ai/core 0.1.9 → 0.1.10

package/dist/cli/output.js

@@ -201,6 +201,15 @@ export function formatDagResultHuman(results, durationMs, config) {
     if (createPrResult?.data?.prUrl) {
         return formatDagSuccessResult(results, duration);
     }
+    // Dry run — show findings summary, no side effects taken
+    if (config?.dryRun) {
+        return formatDagDryRunResult(results, duration);
+    }
+    // Issues created but no PR (fix too complex)
+    const createIssueResult = results.get("create_issue");
+    if (createIssueResult && createIssueResult.status === "success") {
+        return formatDagIssuesCreatedResult(results, duration);
+    }
     // No action / skip
     return formatDagNoActionResult(results, duration, config);
 }
@@ -226,6 +235,56 @@ function formatDagSuccessResult(results, duration) {
     }
     return ["", boxTop(), ...boxSection(header), boxDivider(), ...boxSection(body), boxBottom(), ""].join("\n");
 }
+function formatDagIssuesCreatedResult(results, duration) {
+    const title = `${c.ok("\u2713")} ${chalk.bold("Issues Created")}`;
+    const titlePad = BOX_WIDTH - 4 - visLen(title) - visLen(duration);
+    const header = [title + " ".repeat(Math.max(1, titlePad)) + c.subtle(duration)];
+    const body = [];
+    const issueData = results.get("create_issue")?.data;
+    if (issueData?.issueIdentifier) {
+        body.push(`${c.subtle("Issue")}${" ".repeat(5)}${chalk.bold(String(issueData.issueIdentifier))}`);
+        if (issueData.issueTitle)
+            body.push(`${" ".repeat(10)}${String(issueData.issueTitle)}`);
+        if (issueData.issueUrl)
+            body.push(`${" ".repeat(10)}${c.link(String(issueData.issueUrl))}`);
+        body.push("");
+    }
+    const investigateData = results.get("investigate")?.data;
+    const rec = investigateData?.recommendation;
+    if (rec) {
+        body.push(`${c.subtle("Next")}${" ".repeat(6)}${String(rec)}`);
+    }
+    return ["", boxTop(), ...boxSection(header), boxDivider(), ...boxSection(body), boxBottom(), ""].join("\n");
+}
+function formatDagDryRunResult(results, duration) {
+    const title = `${c.ok("\u2713")} ${chalk.bold("Triage Complete (Dry Run)")}`;
+    const titlePad = BOX_WIDTH - 4 - visLen(title) - visLen(duration);
+    const header = [title + " ".repeat(Math.max(1, titlePad)) + c.subtle(duration)];
+    const body = [];
+    const investigateData = results.get("investigate")?.data;
+    const findings = investigateData?.findings;
+    const novelCount = investigateData?.novel_count;
+    const severity = investigateData?.highest_severity;
+    if (findings && findings.length > 0) {
+        body.push(`${c.subtle("Findings")}${" ".repeat(2)}${chalk.bold(String(findings.length))} total, ${chalk.bold(String(novelCount ?? 0))} novel`);
+        if (severity)
+            body.push(`${c.subtle("Severity")}${" ".repeat(2)}${chalk.bold(severity)}`);
+        body.push("");
+        for (const f of findings.slice(0, 5)) {
+            const dup = f.is_duplicate ? c.subtle(" (dup)") : "";
+            body.push(`  ${f.severity === "critical" || f.severity === "high" ? c.fail("\u25CF") : c.subtle("\u25CB")} ${String(f.title)}${dup}`);
+        }
+        if (findings.length > 5)
+            body.push(c.subtle(`  ... and ${findings.length - 5} more`));
+        body.push("");
+    }
+    const rec = investigateData?.recommendation;
+    if (rec)
+        body.push(`${c.subtle("Next")}${" ".repeat(6)}${String(rec)}`);
+    body.push("");
+    body.push(c.subtle("No side effects — dry run mode"));
+    return ["", boxTop(), ...boxSection(header), boxDivider(), ...boxSection(body), boxBottom(), ""].join("\n");
+}
 function formatDagFailureResult(nodeId, result, duration) {
     const title = `${c.fail("\u2717")} ${chalk.bold("Workflow Failed")}`;
     const titlePad = BOX_WIDTH - 4 - visLen(title) - visLen(duration);
@@ -244,11 +303,9 @@ function formatDagNoActionResult(results, duration, config) {
     const header = [title + " ".repeat(Math.max(1, titlePad)) + c.subtle(duration)];
     const body = [];
     const investigateData = results.get("investigate")?.data;
-    if (investigateData?.is_duplicate) {
-        body.push("Issue identified as a duplicate of an existing ticket.");
-        if (investigateData.duplicate_of) {
-            body.push(`${" ".repeat(2)}${c.link(String(investigateData.duplicate_of))}`);
-        }
+    const novelCount = investigateData?.novel_count;
+    if (novelCount === 0) {
+        body.push("All findings were duplicates of existing issues.");
     }
     else {
         const rec = investigateData?.recommendation;

package/dist/executor.js

@@ -61,8 +61,21 @@ export async function execute(workflow, input, options) {
         results.set(currentId, result);
         safeObserve(observer, { type: "node:exit", node: currentId, result }, logger);
         logger.info(`  ✓ ${result.status}`, { node: currentId, toolCalls: result.toolCalls.length });
+        // Dry run hard gate — stop at the first conditional routing decision.
+        // Unconditional edges are analysis flow (prepare→gather→investigate);
+        // conditional edges are action decisions (investigate→create_issue/skip).
+        // Enforced in the executor so it cannot be bypassed by LLM evaluation.
+        const isDryRun = input && typeof input === "object" && input.dryRun === true;
+        if (isDryRun) {
+            const outEdges = workflow.edges.filter((e) => e.from === currentId);
+            if (outEdges.some((e) => e.when)) {
+                safeObserve(observer, { type: "route", from: currentId, to: "(end)", reason: "dry run" }, logger);
+                currentId = null;
+                continue;
+            }
+        }
         // Resolve next node via edge conditions
-        currentId = await resolveNext(workflow, currentId, results, claude, observer);
+        currentId = await resolveNext(workflow, currentId, results, input, claude, observer);
     }
     safeObserve(observer, {
         type: "workflow:end",
@@ -148,7 +161,7 @@ function resolveConfig(skills, overrides) {
  * - 1 unconditional edge → follow it
  * - Multiple or conditional → Claude evaluates
  */
-async function resolveNext(workflow, current, results, claude, observer) {
+async function resolveNext(workflow, current, results, input, claude, observer) {
     const outEdges = workflow.edges.filter((e) => e.from === current);
     if (outEdges.length === 0)
         return null;
@@ -160,8 +173,12 @@ async function resolveNext(workflow, current, results, claude, observer) {
     // Check for a default (unconditional) edge among conditionals
     const defaultEdge = outEdges.find((e) => !e.when);
     const conditionalEdges = outEdges.filter((e) => e.when);
-    // Claude evaluates which condition matches
-    const context = Object.fromEntries([...results.entries()].map(([k, v]) => [k, v.data]));
+    // Claude evaluates which condition matches — include input so conditions
+    // can reference workflow-level flags like dryRun
+    const context = {
+        input,
+        ...Object.fromEntries([...results.entries()].map(([k, v]) => [k, v.data])),
+    };
     const choices = conditionalEdges.map((e) => ({
         id: e.to,
         description: e.when,

package/dist/workflows/triage.js

@@ -47,66 +47,82 @@ Be thorough — the investigation step depends on complete context. Use every to
         },
         investigate: {
             name: "Root Cause Analysis",
-            instruction: `Based on the gathered context, perform a root cause analysis:
-
-1. Correlate the error with recent code changes, deploys, or config changes.
-2. Identify the most likely root cause.
-3. Assess severity: critical (service down), high (major feature broken), medium (degraded), low (cosmetic/minor).
-4. Determine affected services and users.
-5. Recommend a fix approach.
-6. Assess fix complexity: "simple" (a few lines, clear change), "moderate" (multiple files but well-understood), or "complex" (architectural, risky, or unclear).
-
-**Novelty check (REQUIRED — you MUST do this before finishing):**
-Search the issue tracker for existing issues (BOTH open AND closed) that cover the same root cause, error pattern, or affected service. Use github_search_issues and/or linear_search_issues with multiple keyword variations.
-
-A match means ANY of:
-- An issue about the same root cause (even if closed/fixed)
-- An issue about the same error message or pattern in the same service
-- An issue that a human would consider "the same bug"
-
-Set is_duplicate=true if ANY match is found. Set is_duplicate=false ONLY if you searched and found zero matches. You MUST always set this field.`,
+            instruction: `Based on the gathered context, classify every distinct issue you found into one of two buckets: **novel** or **duplicate**.
+
+For EACH issue found:
+1. Identify the root cause and affected code/service.
+2. Assess severity: critical (service down), high (major feature broken), medium (degraded), low (cosmetic/minor).
+3. Assess fix complexity: "simple" (a few lines, clear change), "moderate" (multiple files but well-understood), or "complex" (architectural, risky, or unclear).
+4. **Novelty check (REQUIRED):** Search the issue tracker for existing issues (BOTH open AND closed) that cover the same root cause, error pattern, or affected service. Use github_search_issues and/or linear_search_issues with multiple keyword variations.
+   - A match = same root cause, same error message/pattern, or a human would call it "the same bug."
+   - If matched → it's a **duplicate**. Record the existing issue ID.
+   - If no match → it's **novel**.
+
+**Output rules:**
+- \`findings\`: array of ALL issues found (both novel and duplicate).
+- \`novel_count\`: how many findings are novel (not duplicates).
+- \`highest_severity\`: the highest severity across ALL findings.
+- \`recommendation\`: what should happen next.
+
+Downstream nodes will act ONLY on novel findings. Duplicates will be +1'd automatically.`,
             skills: ["github", "linear"],
             output: {
                 type: "object",
                 properties: {
-                    root_cause: { type: "string" },
-                    severity: { type: "string", enum: ["critical", "high", "medium", "low"] },
-                    affected_services: { type: "array", items: { type: "string" } },
-                    is_duplicate: { type: "boolean" },
-                    duplicate_of: { type: "string", description: "Issue ID/URL if duplicate" },
+                    findings: {
+                        type: "array",
+                        items: {
+                            type: "object",
+                            properties: {
+                                title: { type: "string", description: "Short description of the issue" },
+                                root_cause: { type: "string" },
+                                severity: { type: "string", enum: ["critical", "high", "medium", "low"] },
+                                affected_services: { type: "array", items: { type: "string" } },
+                                is_duplicate: { type: "boolean" },
+                                duplicate_of: { type: "string", description: "Existing issue ID/URL if duplicate" },
+                                fix_approach: { type: "string" },
+                                fix_complexity: { type: "string", enum: ["simple", "moderate", "complex"] },
+                            },
+                            required: ["title", "root_cause", "severity", "is_duplicate"],
+                        },
+                    },
+                    novel_count: { type: "number", description: "Count of novel (non-duplicate) findings" },
+                    highest_severity: { type: "string", enum: ["critical", "high", "medium", "low"] },
                     recommendation: { type: "string" },
-                    fix_approach: { type: "string" },
-                    fix_complexity: { type: "string", enum: ["simple", "moderate", "complex"] },
                 },
-                required: ["root_cause", "severity", "is_duplicate", "recommendation"],
+                required: ["findings", "novel_count", "highest_severity", "recommendation"],
             },
         },
         create_issue: {
-            name: "Create Issue",
-            instruction: `Create an issue documenting the investigation findings:
+            name: "Create Issues & Triage Duplicates",
+            instruction: `Process ALL findings from the investigation. The findings array contains both novel and duplicate issues.
 
-1. Use a clear, actionable title.
+**For each NOVEL finding** (is_duplicate = false):
+1. Create a new issue with a clear, actionable title.
 2. Include: root cause, severity, affected services, reproduction steps, and recommended fix.
 3. Add appropriate labels (bug, severity level, affected service).
 4. Link to relevant commits, PRs, or existing issues.
 
-**Safety check**: If during creation you notice a very similar issue already exists, add a comment to it using github_add_comment or linear_add_comment instead of creating a duplicate.
+**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.
 
-If context.issueTemplate is provided, use it as the format for the issue body. Otherwise use a clear structure with: Summary, Root Cause, Impact, Steps to Reproduce, and Recommended Fix.
+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.
 
-Create the issue in whichever tracker is available to you.`,
+Use whichever issue tracker is available to you. Output the created/updated issue identifiers.`,
             skills: ["linear", "github"],
         },
         skip: {
-            name: "Skip — Duplicate or Low Priority",
-            instruction: `This alert was determined to be a duplicate or low-priority.
+            name: "Skip — All Duplicates or Low Priority",
+            instruction: `Every finding from the investigation was either a duplicate or low-priority. No new issues need to be created.
 
-If this is a **duplicate** of an existing issue (check context for duplicate_of):
-1. Find the existing issue using the issue tracker tools.
+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.
 
-If this is just **low priority**, log a brief note about why it was skipped.`,
+For **low priority** findings, log a brief note about why they were skipped.`,
             skills: ["linear", "github"],
         },
         implement: {
@@ -155,42 +171,32 @@ Use whichever notification channel is available to you.`,
         { from: "prepare", to: "gather" },
         // gather → investigate (always)
         { from: "gather", to: "investigate" },
-        // investigate → create_issue (if novel and actionable)
+        // investigate → create_issue (novel findings worth acting on)
         {
             from: "investigate",
             to: "create_issue",
-            when: "is_duplicate is false AND severity is medium or higher",
+            when: "novel_count is greater than 0 AND highest_severity is medium or higher",
         },
-        // investigate → skip (if duplicate or low priority)
+        // investigate → skip (everything is a duplicate or low priority)
         {
             from: "investigate",
             to: "skip",
-            when: "is_duplicate is true, OR severity is low",
+            when: "novel_count is 0, OR highest_severity is low",
         },
-        // create_issue → implement (if fix is clear and not too complex)
+        // create_issue → implement (novel findings have a clear, feasible fix)
         {
             from: "create_issue",
             to: "implement",
-            when: "fix_complexity is simple or moderate AND fix_approach is provided AND dryRun is not true",
+            when: "at least one novel finding has fix_complexity simple or moderate AND fix_approach is provided",
         },
-        // create_issue → notify (if fix is too complex or risky, or dry run)
+        // create_issue → notify (fixes too complex)
         {
             from: "create_issue",
             to: "notify",
-            when: "fix_complexity is complex, OR no clear fix_approach, OR dryRun is true",
-        },
-        // skip → implement (duplicate exists but has a clear unfixed bug with a simple fix)
-        {
-            from: "skip",
-            to: "implement",
-            when: "is_duplicate is true AND the duplicate issue is still open/unfixed AND fix_complexity is simple or moderate AND fix_approach is provided AND dryRun is not true",
-        },
-        // skip → notify (duplicate was +1'd, no implementation needed or too complex)
-        {
-            from: "skip",
-            to: "notify",
-            when: "is_duplicate is true AND (fix_complexity is complex OR no fix_approach OR the issue already has a PR in progress OR dryRun is true), OR severity is low",
+            when: "all novel findings have fix_complexity complex, OR no clear fix_approach",
         },
+        // skip → notify (nothing to implement — all duplicates +1'd or low priority)
+        { from: "skip", to: "notify" },
         // implement → create_pr (always after successful implementation)
         { from: "implement", to: "create_pr" },
         // create_pr → notify (always)

package/package.json

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