@sweny-ai/core 0.1.185 → 0.1.186

package/dist/cli/comment-output.d.ts

@@ -4,7 +4,8 @@
  * `--comment-file`, and any runner (the GitHub Action, GitLab, a script) posts it.
  *
  * METADATA ONLY. Node names, statuses, counts, and durations. Never prompts,
- * tool inputs, node outputs, errors, or model prose.
+ * tool inputs, node outputs, errors, or model prose. The optional "since last
+ * run" line carries counts of added and resolved answers, never their text.
  */
 import type { ExecutionTrace, NodeResult, Workflow } from "../types.js";
 import { type RunSummary } from "./run-output.js";
@@ -15,6 +16,8 @@ export interface RunCommentOptions {
     durationsMs?: Record<string, number>;
     /** Run id; the ticket shows its short hash. */
     runId?: string;
+    /** Pre-rendered "since last run" markdown line (run-answers.ts formatSinceLastMarkdown): counts only. */
+    sinceLast?: string | null;
 }
 /** Hidden marker the poster searches for to update the comment in place. */
 export declare function runCommentMarker(workflowId: string): string;

package/dist/cli/comment-output.js

@@ -4,7 +4,8 @@
  * `--comment-file`, and any runner (the GitHub Action, GitLab, a script) posts it.
  *
  * METADATA ONLY. Node names, statuses, counts, and durations. Never prompts,
- * tool inputs, node outputs, errors, or model prose.
+ * tool inputs, node outputs, errors, or model prose. The optional "since last
+ * run" line carries counts of added and resolved answers, never their text.
  */
 import { workspaceRoot, writeFileNoFollow } from "../safe-file.js";
 import { toMermaidBlock } from "../mermaid.js";
@@ -40,6 +41,7 @@ export function formatRunComment(workflow, results, summary, opts = {}) {
         "",
         ticketBlock(workflow, summary, opts.runId),
         "",
+        ...(opts.sinceLast ? [opts.sinceLast, ""] : []),
         toMermaidBlock(workflow, { state, trace: opts.trace }),
         "",
         "<details>",

package/dist/cli/main.js

@@ -35,6 +35,7 @@ import { nonInteractiveUsage, runNew } from "./new.js";
 import { formatFinalMarkdown, formatFinalOutput, formatSavedOutputLine, resolveFinalOutput, shouldPrintFinalOutput, writeFinalOutput, } from "./final-output.js";
 import { buildRunRecord, createNodeTimer, historyDisabled, newRunId, recordRun } from "./run-history.js";
 import { registerRunsCommand } from "./runs.js";
+import { formatSinceLast, formatSinceLastMarkdown, recordRunAnswers } from "./run-answers.js";
 import { registerTryCommand } from "./try.js";
 import { JournalLockedError, JournalMismatchError, RunJournal, runSecretValues } from "../journal.js";
 import { journalDisabled, prepareResume, RESUME_SHARED_RUN_FLAGS, WORKFLOW_RESUME_OPTIONS, } from "./resume.js";
@@ -1053,6 +1054,16 @@ resume) {
         const wfHasFailed = [...results.values()].some((r) => r.status === "failed");
         journal?.end(wfHasFailed ? "failed" : "success");
         recordHistory(results, trace, false);
+        // What the run answered (declared output fields, redacted), beside the history record, then a
+        // comparison with the previous run of this workflow for the "since last run" line.
+        const sinceLast = historyDisabled(options.history, fileConfig["history"])
+            ? null
+            : recordRunAnswers({
+                runId,
+                workflow,
+                results,
+                secrets: runSecretValues([...skills.values(), ...builtinSkills], process.env),
+            });
         // Close the cloud lifecycle session BEFORE the JSON early-exit so
         // every workflow run reports a terminal status, regardless of how
         // the CLI returns (json, mermaid, or normal stdout).
@@ -1069,6 +1080,7 @@ resume) {
                 trace,
                 durationsMs: Object.fromEntries(nodeTimer.durations),
                 runId,
+                sinceLast: sinceLast ? formatSinceLastMarkdown(sinceLast) : null,
             });
         }
         if (isJson) {
@@ -1094,7 +1106,7 @@ resume) {
         // Run receipt (metadata only) + optional $GITHUB_STEP_SUMMARY.
         runLogger.flush();
         const receipt = summarizeRun(results, wfDurationMs, false, trace);
-        writeStepSummary(workflow, results, receipt, trace);
+        writeStepSummary(workflow, results, receipt, trace, process.env, sinceLast ? formatSinceLastMarkdown(sinceLast) : null);
         // The answer, above the receipt: the terminal node's result, or the failed node's error.
         // Also saved to .sweny/runs/<id>/output.md (local only; --no-history skips the file).
         // Redacted with the journal's redactor; in CI printed only with --show-output.
@@ -1117,12 +1129,16 @@ resume) {
         // The receipt: a ticket on a TTY, one plain line in CI and pipes.
         if (wfHasFailed) {
             await writeReceipt(receipt, { workflow: workflow.id, runId, stream: process.stderr });
+            if (sinceLast)
+                console.error(createPaint(colorEnabled(process.stderr)).muted(`  ${formatSinceLast(sinceLast)}`));
             if (journal?.active)
                 console.error(c.subtle(`  resume with: sweny workflow resume ${runId}\n`));
             process.exit(1);
             return;
         }
         await writeReceipt(receipt, { workflow: workflow.id, runId, stream: process.stdout });
+        if (sinceLast)
+            console.log(createPaint(colorEnabled(process.stdout)).muted(`  ${formatSinceLast(sinceLast)}`));
         process.exit(0);
     }
     catch (err) {

package/dist/cli/run-answers.d.ts

@@ -0,0 +1,162 @@
+/**
+ * What a run answered, kept so the next run can say what changed.
+ *
+ * `sweny workflow run` saves `.sweny/runs/<run-id>/answers.json` beside the
+ * output.md: each successful node's DECLARED output fields (the node's
+ * `output` schema is the contract; with no schema, only a string `summary`).
+ * Local only, mode 0600, redacted with the run journal's redactor before
+ * anything is stored. The run record itself (run-history.ts) stays metadata
+ * only; answers live in their own file so that contract is untouched.
+ *
+ * Everything under `.sweny/runs/` is writable by an agent, so it is untrusted:
+ * ids are validated against the generator's pattern before any path is built,
+ * the embedded id must match the one asked for, and the PUBLIC line (PR
+ * comment, step summary) carries only the current workflow's own id and
+ * integer counts, never text read from history.
+ *
+ * `compareAnswers` is the diff behind `sweny runs diff` and the "since last
+ * run" line. Identity rules (what counts as "the same finding") are explicit
+ * and tested; see {@link itemIdentity}.
+ */
+import type { NodeResult, Workflow } from "../types.js";
+export declare const RUN_ANSWERS_SCHEMA_VERSION = 1;
+/** Strings longer than this are cut (with an ellipsis) before they are stored. */
+export declare const ANSWER_STRING_MAX = 2000;
+export interface RunAnswers {
+    schema_version: number;
+    run_id: string;
+    workflow_id: string;
+    /** node id -> declared output fields (redacted). Only nodes that succeeded and produced a field. */
+    nodes: Record<string, Record<string, unknown>>;
+    /**
+     * Strings longer than {@link ANSWER_STRING_MAX} are cut in `nodes` (display only). This mirrors
+     * `nodes` and holds the sha256 of each cut string's FULL text, so a change past the cut still
+     * compares as changed. Absent when nothing was cut.
+     */
+    digests?: Record<string, Record<string, unknown>>;
+}
+export interface BuildRunAnswersInput {
+    runId: string;
+    workflow: Workflow;
+    results: Map<string, NodeResult>;
+    /** Secret values to redact (the same set the journal and output.md use). */
+    secrets?: string[];
+}
+/**
+ * Declared fields of each successful node, deep, redacted (values and keys). A failed or skipped
+ * node records nothing, so the diff never reads a failure as "everything resolved".
+ */
+export declare function buildRunAnswers(i: BuildRunAnswersInput): RunAnswers;
+/** Relative path: `.sweny/runs/<id>/answers.json`. */
+export declare function answersRelPath(runId: string): string;
+/** Write answers.json (mode 0600; the run dir ignores itself in git). Returns the relative path, or null. Never throws. */
+export declare function writeRunAnswers(answers: RunAnswers, cwd?: string): string | null;
+/**
+ * Read a run's answers. Null when the id is not a generated run id (checked before any path is
+ * built), the file is missing, oversized, reached through a link, corrupt, an unknown schema
+ * version, or carries a different run id than the one asked for.
+ */
+export declare function readRunAnswers(runId: string, cwd?: string): RunAnswers | null;
+/** Fields that name an item, in priority order. */
+export declare const IDENTITY_KEYS: readonly ["id", "key", "fingerprint", "title", "name"];
+/**
+ * "Is this the same finding as that one?" The rule, in order:
+ *  1. An object item is identified by the first of `id`, `key`, `fingerprint`,
+ *     `title`, `name` that holds a non-empty string or a number, normalized
+ *     (trimmed, lowercased, whitespace collapsed).
+ *  2. An object with none of those is identified by its whole content (a
+ *     short hash of its canonical JSON): any edit reads as resolved + added.
+ *  3. A plain string, number or boolean item is identified by its normalized value.
+ * Two items of one list with the same identity pair up in order.
+ */
+export declare function itemIdentity(item: unknown): string;
+export interface DiffCounts {
+    added: number;
+    resolved: number;
+    changed: number;
+    unchanged: number;
+}
+export interface DiffItem {
+    /** Normalized identity (see {@link itemIdentity}). */
+    id: string;
+    /** Human label: the raw identity value, else the first string field. */
+    label: string;
+    value: unknown;
+}
+export interface FieldChange {
+    field: string;
+    /** Absent when the field is new on this item. */
+    before?: unknown;
+    /** Absent when the field was dropped from this item. */
+    after?: unknown;
+}
+export interface ChangedItem {
+    id: string;
+    /** Label from the newer run. */
+    label: string;
+    fields: FieldChange[];
+}
+export interface CollectionEntry {
+    node: string;
+    field: string;
+    kind: "collection";
+    added: DiffItem[];
+    resolved: DiffItem[];
+    changed: ChangedItem[];
+    unchanged: number;
+}
+export interface ValueEntry {
+    node: string;
+    field: string;
+    kind: "value";
+    status: "added" | "resolved" | "changed" | "unchanged";
+    before?: unknown;
+    after?: unknown;
+}
+export type AnswerEntry = CollectionEntry | ValueEntry;
+export interface AnswerDiff {
+    available: true;
+    counts: DiffCounts;
+    entries: AnswerEntry[];
+    /** Nodes with answers in only one run: not compared, never counted as added or resolved. */
+    not_compared: Array<{
+        node: string;
+        only_in: "a" | "b";
+    }>;
+}
+export type AnswersComparison = AnswerDiff | {
+    available: false;
+    reason: "different_workflows";
+} | {
+    available: false;
+    reason: "missing_answers";
+    missing: Array<"a" | "b">;
+};
+/**
+ * Compare an older run's answers (a) with a newer one's (b), node by node and
+ * field by field. A list field (all objects, or all scalars) is diffed item by
+ * item using {@link itemIdentity}; any other field is one value. Cut strings
+ * compare by the digest of their full text.
+ */
+export declare function compareAnswers(a: RunAnswers | null, b: RunAnswers | null): AnswersComparison;
+export interface SinceLast {
+    /** The CURRENT run's own workflow id, from the loaded workflow, never from history. */
+    workflow_id: string;
+    /** The run this one was compared with. */
+    previous_run_id: string;
+    counts: DiffCounts;
+    /** Nodes with answers in only one of the two runs (failed, skipped or no output): not compared. */
+    not_compared: number;
+}
+/**
+ * Compare a recorded run with the run of the same workflow just before it. `workflowId` comes from
+ * the caller's loaded workflow; history only picks WHICH earlier run, never what is printed.
+ * Null when there is no earlier run, either run has no answers, or anything fails.
+ */
+export declare function sinceLastRun(runId: string, workflowId: string, cwd?: string): SinceLast | null;
+/** Save this run's answers, then compare with the previous run. Never throws. */
+export declare function recordRunAnswers(i: BuildRunAnswersInput, cwd?: string): SinceLast | null;
+/** Plain text, one line: for the terminal and CI logs. */
+export declare function formatSinceLast(s: SinceLast): string;
+/** Markdown, one line: for the step summary and the PR comment. */
+export declare function formatSinceLastMarkdown(s: SinceLast): string;