@sweny-ai/core 0.1.166 → 0.1.168

package/dist/cli/main.js

@@ -34,6 +34,7 @@ import { nonInteractiveUsage, runNew } from "./new.js";
 import { formatFinalMarkdown, formatFinalOutput, resolveFinalOutput, writeFinalOutput } from "./final-output.js";
 import { buildRunRecord, createNodeTimer, historyDisabled, newRunId, recordRun } from "./run-history.js";
 import { registerRunsCommand } from "./runs.js";
+import { registerTryCommand } from "./try.js";
 import { JournalLockedError, JournalMismatchError, RunJournal } from "../journal.js";
 import { journalDisabled, prepareResume, RESUME_SHARED_RUN_FLAGS, WORKFLOW_RESUME_OPTIONS, } from "./resume.js";
 import { runE2eRun, runWithWallClockBudget, DEFAULT_WORKFLOW_TIMEOUT_MS } from "./e2e.js";
@@ -76,9 +77,12 @@ function composeObservers(...observers) {
     };
 }
 // Auto-load .env before Commander parses (so env vars are available for defaults)
-loadDotenv();
-// Agent sandbox / env-passthrough keys from .sweny.yml -> SWENY_* env (#360).
-applyAgentFileConfig(loadConfigFile());
+// `sweny try` (#475) reads no .env and no config: it is a recording replay with no credentials.
+if (process.argv[2] !== "try") {
+    loadDotenv();
+    // Agent sandbox / env-passthrough keys from .sweny.yml -> SWENY_* env (#360).
+    applyAgentFileConfig(loadConfigFile());
+}
 const program = new Command()
     .name("sweny")
     .description("Workflows for coding agents. One set of rules, a receipt for every run.")
@@ -89,6 +93,7 @@ program
     .description("Create a new workflow. With no id, opens the interactive picker. With an id, uses that built-in template.")
     .option("--template <id>", "Use a built-in template without the picker")
     .option("-y, --yes", "Skip every prompt (never overwrites existing files)")
+    .option("--no-ci", "Do not write a pack's GitHub Actions trigger to .github/workflows/")
     .action(async (id, options) => {
     // Prompts need a terminal. Without one (CI, pipes), a prompt never
     // settles, so print usage and exit 2 instead of hanging.
@@ -96,8 +101,10 @@ program
         console.error(nonInteractiveUsage());
         process.exit(2);
     }
-    await runNew({ marketplaceId: id, template: options.template, yes: options.yes });
+    await runNew({ marketplaceId: id, template: options.template, yes: options.yes, ci: options.ci });
 });
+// ── sweny try ─────────────────────────────────────────────────────────
+registerTryCommand(program);
 // ── sweny check ───────────────────────────────────────────────────────
 /** validateInputs' generic agent-auth lines, replaced by the harness preflight reason (#339). */
 const AGENT_AUTH_ERROR_PREFIXES = ["Missing: ANTHROPIC_API_KEY or CLAUDE_CODE_OAUTH_TOKEN", "Missing: CODEX_API_KEY"];

package/dist/cli/new.d.ts

@@ -7,6 +7,7 @@
  * Pure functions for file generation + thin @clack/prompts interactive layer.
  * Tests cover the pure functions; the interactive wizard is thin glue.
  */
+import { type WorkflowTemplate } from "./templates.js";
 import { type Skill } from "../types.js";
 export interface Credential {
     key: string;
@@ -113,6 +114,18 @@ export declare function writeSwenyYmlIfMissing(cwd: string, sourceControl: strin
 /** Append credential keys to .env that aren't already present. Returns count appended. */
 export declare function appendMissingEnvKeys(cwd: string, credentials: Credential[]): number;
 /** Write workflow YAML into .sweny/workflows/<id>.yml. Returns info about what happened. */
+/** Where a pack's GitHub Actions trigger is written: `.github/workflows/sweny-<pack>.yml`. */
+export declare function packTriggerPath(id: string): string;
+/**
+ * Write a pack's Actions trigger (#474). Never overwrites: an existing file is
+ * left exactly as it is. Returns `skipped` for a template that is not a pack.
+ */
+export declare function writePackTrigger(cwd: string, template: WorkflowTemplate): {
+    written: boolean;
+    exists?: boolean;
+    skipped?: boolean;
+    path: string;
+};
 export declare function writeWorkflowFile(cwd: string, id: string, yaml: string, options?: {
     overwrite?: boolean;
 }): {
@@ -153,6 +166,8 @@ export declare function runNew(options?: {
     template?: string;
     /** Skip every confirmation prompt (never overwrites existing files). */
     yes?: boolean;
+    /** `false` (`--no-ci`) skips writing a pack's GitHub Actions trigger file. */
+    ci?: boolean;
     /** Internal: the id came from the marketplace picker, skip the built-in shortcut. */
     forceMarketplace?: boolean;
 }): Promise<void>;

package/dist/cli/new.js

@@ -431,6 +431,24 @@ export function appendMissingEnvKeys(cwd, credentials) {
     return newKeys.length;
 }
 /** Write workflow YAML into .sweny/workflows/<id>.yml. Returns info about what happened. */
+/** Where a pack's GitHub Actions trigger is written: `.github/workflows/sweny-<pack>.yml`. */
+export function packTriggerPath(id) {
+    return path.join(".github", "workflows", `sweny-${id}.yml`);
+}
+/**
+ * Write a pack's Actions trigger (#474). Never overwrites: an existing file is
+ * left exactly as it is. Returns `skipped` for a template that is not a pack.
+ */
+export function writePackTrigger(cwd, template) {
+    const target = path.join(cwd, packTriggerPath(template.id));
+    if (!template.pack)
+        return { written: false, skipped: true, path: target };
+    if (fs.existsSync(target))
+        return { written: false, exists: true, path: target };
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, template.pack.trigger, "utf-8");
+    return { written: true, path: target };
+}
 export function writeWorkflowFile(cwd, id, yaml, options) {
     const dir = path.join(cwd, ".sweny", "workflows");
     fs.mkdirSync(dir, { recursive: true });
@@ -522,7 +540,12 @@ export async function runNew(options) {
     // so it works with no network. Only other ids go to the marketplace.
     if (options?.marketplaceId && options.marketplaceId !== "e2e" && !options.forceMarketplace) {
         if (WORKFLOW_TEMPLATES.some((t) => t.id === options.marketplaceId)) {
-            return runNew({ template: options.marketplaceId, skipIntro: options.skipIntro, yes: options.yes });
+            return runNew({
+                template: options.marketplaceId,
+                skipIntro: options.skipIntro,
+                yes: options.yes,
+                ci: options.ci,
+            });
         }
     }
     if (options?.template && !WORKFLOW_TEMPLATES.some((t) => t.id === options.template)) {
@@ -700,6 +723,9 @@ export async function runNew(options) {
         files.push(".sweny.yml", ".env");
     if (template)
         files.push(`.sweny/workflows/${template.id}.yml`);
+    const writeTrigger = !!template?.pack && options?.ci !== false;
+    if (template && writeTrigger)
+        files.push(packTriggerPath(template.id));
     const inferred = [
         `  Source control:  ${sourceControl}${gitInfo ? " (detected)" : ""}`,
         `  Issue tracker:   ${issueTracker}`,
@@ -759,11 +785,22 @@ export async function runNew(options) {
     else {
         p.log.info(".env already contains all required keys — skipped");
     }
+    // The pack's Actions trigger (#474): never overwritten, skipped with --no-ci.
+    const installTrigger = () => {
+        if (!template || !writeTrigger)
+            return;
+        const r = writePackTrigger(cwd, template);
+        if (r.written)
+            p.log.success(`Created ${packTriggerPath(template.id)}`);
+        else if (r.exists)
+            p.log.info(`${packTriggerPath(template.id)} already exists, not overwritten`);
+    };
     // 3. Workflow template
     if (template) {
         const firstAttempt = writeWorkflowFile(cwd, template.id, template.yaml, { overwrite: false });
         if (firstAttempt.exists && options?.yes) {
             p.log.info(`.sweny/workflows/${template.id}.yml already exists, not overwritten`);
+            installTrigger();
             p.outro("Done.");
             return;
         }
@@ -782,6 +819,7 @@ export async function runNew(options) {
             writeWorkflowFile(cwd, template.id, template.yaml, { overwrite: true });
         }
         p.log.success(`Created .sweny/workflows/${template.id}.yml`);
+        installTrigger();
     }
     // 4. Keep .env out of version control
     const ignoreResult = ensureGitignoreEnv(cwd);
@@ -801,7 +839,10 @@ export async function runNew(options) {
     }
     if (template) {
         steps.push(`${stepNum++}. Run your workflow:`, `   ${cli} workflow run .sweny/workflows/${template.id}.yml`);
-        if (template.pack) {
+        if (template.pack && writeTrigger) {
+            steps.push("", `${stepNum++}. Run it automatically: add the CLAUDE_CODE_OAUTH_TOKEN repo secret, then commit`, `   .sweny/workflows/${template.id}.yml and ${packTriggerPath(template.id)}`, `   https://docs.sweny.ai/workflows/packs/#${template.id}`);
+        }
+        else if (template.pack) {
             steps.push("", `${stepNum++}. Run it automatically (GitHub Actions trigger and permissions):`, `   https://docs.sweny.ai/workflows/packs/#${template.id}`);
         }
     }

package/dist/cli/packs.js

@@ -336,11 +336,45 @@ nodes:
             - github_add_comment
             - github_create_issue
 
+
+  quiet:
+    name: Nothing to Report
+    instruction: |
+      The week had no commits, merged PRs, or issues opened or closed, so there is nothing worth a digest. Do not call any tool and deliver nothing. Return
+      delivered false and one short sentence saying why.
+    permissions: read
+    max_turns: 2
+    output:
+      type: object
+      properties:
+        delivered:
+          type: boolean
+        reason:
+          type: string
+      required: [delivered, reason]
+    eval:
+      - name: quiet_delivers_nothing
+        kind: function
+        rule:
+          no_tool_called:
+            - github_create_issue
+            - github_add_comment
+            - github_create_pr
+            - slack_send_message
+            - notify_webhook
+
+# Quiet weeks (#474): sweny decides on the counts, with no model call. A week
+# with any activity is delivered; an empty one routes to quiet and nothing is
+# sent, so the digest is never noise.
 edges:
   - from: collect
     to: analyze
   - from: analyze
     to: publish
+    when:
+      expr: "analyze.stats.commits > 0 || analyze.stats.prs_merged > 0 || analyze.stats.issues_opened > 0 || analyze.stats.issues_closed > 0"
+  - from: analyze
+    to: quiet
 `;
 const DIGEST_TRIGGER = `name: SWEny weekly digest
 on:
@@ -350,19 +384,21 @@ on:
 
 permissions:
   contents: read
-  issues: write # only needed for deliver: issue
+  issues: write # deliver: issue, and the failure alert
 
 jobs:
   digest:
     runs-on: ubuntu-latest
     timeout-minutes: 15
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
           fetch-depth: 0
+          persist-credentials: false
       - uses: swenyai/sweny@v5
         with:
           workflow: .sweny/workflows/weekly-digest.yml
+          notify-on-failure: issue # one sticky issue, only when a run fails
           claude-oauth-token: \${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
           input: '{"repo": "\${{ github.repository }}"}'
           # input: '{"repo": "\${{ github.repository }}", "days": 7, "deliver": "slack"}'
@@ -680,6 +716,35 @@ nodes:
             - path: result
               in: [created, updated, unchanged, none]
 
+
+  quiet:
+    name: Nothing to Report
+    instruction: |
+      Nothing actionable: no advisory at or above the severity floor and no lockfile drift. Do not call any tool and deliver nothing. Return
+      delivered false and one short sentence saying why.
+    permissions: read
+    max_turns: 2
+    output:
+      type: object
+      properties:
+        delivered:
+          type: boolean
+        reason:
+          type: string
+      required: [delivered, reason]
+    eval:
+      - name: quiet_delivers_nothing
+        kind: function
+        rule:
+          no_tool_called:
+            - github_create_issue
+            - github_add_comment
+            - github_create_pr
+            - slack_send_message
+            - notify_webhook
+
+# Quiet weeks (#474): sweny routes on the action, with no model call. Nothing
+# actionable skips the issue step, so a clean week files and posts nothing.
 edges:
   - from: inventory
     to: advisories
@@ -687,6 +752,10 @@ edges:
     to: assess
   - from: assess
     to: file-issue
+    when:
+      expr: "assess.action == 'file'"
+  - from: assess
+    to: quiet
 `;
 const DRIFT_TRIGGER = `name: SWEny dependency drift
 on:
@@ -703,10 +772,13 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 15
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          persist-credentials: false
       - uses: swenyai/sweny@v5
         with:
           workflow: .sweny/workflows/dependency-drift.yml
+          notify-on-failure: issue # one sticky issue, only when a run fails
           claude-oauth-token: \${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
           input: '{"repo": "\${{ github.repository }}"}'
         env:
@@ -994,7 +1066,9 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 10
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          persist-credentials: false
       - uses: swenyai/sweny@v5
         with:
           workflow: .sweny/workflows/pr-risk-review.yml

package/dist/cli/try-fixture.json

@@ -0,0 +1,35 @@
+{
+  "schema_version": 1,
+  "illustrative": true,
+  "notice": "ILLUSTRATIVE SAMPLE DATA. This is not output from a real run and not about your code. The repo (acme-notes-api) is fictional; timings, tool-call counts, token usage and cost are plausible numbers for a small repo, written by hand. Replace this file with a recorded real run (metadata plus the sample answer only) and set illustrative to false.",
+  "workflow": "explain-repo",
+  "sample_repo": "acme-notes-api",
+  "harness": { "id": "claude-code", "version": "sample" },
+  "policy": { "envScope": true, "sandbox": "auto", "sandboxStarted": true },
+  "nodes": {
+    "survey": {
+      "duration_ms": 18400,
+      "tool_calls": { "Glob": 3, "Read": 7, "Grep": 2 },
+      "usage": { "inputTokens": 21300, "outputTokens": 1150, "costUsd": 0.09, "numTurns": 8 }
+    },
+    "explain": {
+      "duration_ms": 9100,
+      "tool_calls": {},
+      "usage": { "inputTokens": 6800, "outputTokens": 640, "costUsd": 0.04, "numTurns": 1 },
+      "output": {
+        "purpose": "A small REST API for storing and searching notes, built with Express and TypeScript on top of SQLite. Meant as the backend for a notes app.",
+        "how_to_run": ["npm install", "npm run build", "npm test", "npm start (serves on http://localhost:3000)"],
+        "key_files": [
+          "src/server.ts: the entry point, wires routes and the database",
+          "src/routes/notes.ts: the CRUD and search endpoints",
+          "src/db/schema.sql: the tables, applied on first start",
+          "test/notes.test.ts: the API tests, a good map of expected behavior"
+        ],
+        "risks": [
+          "No auth on any route: fine locally, not safe to expose as is.",
+          "The README does not mention the PORT or DB_PATH environment variables that src/server.ts reads."
+        ]
+      }
+    }
+  }
+}

package/dist/cli/try.d.ts

@@ -0,0 +1,89 @@
+/**
+ * `sweny try`: a zero-credential demo (#475).
+ *
+ * Replays a recorded explain-repo run through the REAL executor, with a replay
+ * harness standing in for the agent, so the real progress line, answer block
+ * (#460), receipt, policy segment and PR-comment markdown (#396) are what a
+ * user sees. No agent, no model, no network, no env credentials, no files
+ * written (no `.sweny/runs`, no journal). The environment handed to the
+ * executor is empty by construction.
+ *
+ * The recording lives in `try-fixture.json` (metadata plus the sample answer
+ * only). Until a real run is recorded it is labelled illustrative.
+ */
+import type { Command } from "commander";
+import type { AgentHarness } from "../harness/types.js";
+import type { Workflow } from "../types.js";
+export interface TryFixtureNode {
+    /** Recorded wall-clock time of the node. */
+    duration_ms: number;
+    /** Tool name to number of calls. Counts only: no inputs or outputs are recorded. */
+    tool_calls: Record<string, number>;
+    usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        costUsd?: number;
+        numTurns?: number;
+    };
+    /** The node's declared output fields (the sample answer). */
+    output?: Record<string, unknown>;
+}
+export interface TryFixture {
+    schema_version: 1;
+    /** True until the owner replaces the file with a recording of a real run. */
+    illustrative: boolean;
+    notice: string;
+    /** Built-in template id the recording is of. */
+    workflow: string;
+    sample_repo: string;
+    harness: {
+        id: string;
+        version: string;
+    };
+    policy?: {
+        envScope: boolean;
+        sandbox: "off" | "auto" | "strict";
+        sandboxStarted: boolean;
+    };
+    /** Node id to recording, in execution order. */
+    nodes: Record<string, TryFixtureNode>;
+}
+/** Shape check with a message naming the first bad field. Throws on a malformed fixture. */
+export declare function parseTryFixture(raw: unknown): TryFixture;
+/** The shipped fixture: `try-fixture.json` next to this module (src/cli or dist/cli). */
+export declare function loadTryFixture(file?: string): TryFixture;
+/** The real explain-repo template, parsed and validated like any workflow file. */
+export declare function loadTryWorkflow(templateId: string): Workflow;
+/**
+ * An AgentHarness that plays the recording back: node N of the run gets
+ * recording N. It never spawns a process, reads env, or touches the network.
+ * `paceMs` is how long each node takes to replay (0 = instant); tool calls are
+ * reported through `onProgress` spread across that time so progress feels live.
+ */
+export declare function createReplayHarness(fixture: TryFixture, opts: {
+    paceMs: number;
+}): AgentHarness;
+export declare const TRY_BANNER_TITLE = "Recorded demo";
+/** The real commands, same as the README quickstart. */
+export declare const TRY_NEXT_COMMANDS: readonly ["npm install -g @sweny-ai/core", "sweny new --template explain-repo --yes", "sweny workflow run .sweny/workflows/explain-repo.yml"];
+/** Appended to `sweny try --help`. */
+export declare const TRY_HELP_NOTE: string;
+export declare function formatTryBanner(fixture: TryFixture): string;
+export declare function formatTryNext(): string;
+export interface TryOptions {
+    /** Replay instantly. */
+    fast?: boolean;
+    /** Milliseconds each node takes to replay. Default 1200. Ignored with `fast`. */
+    paceMs?: number;
+    /** Also write the PR-comment markdown here. */
+    commentFile?: string;
+    /** Output sink. Default stdout. */
+    write?: (s: string) => void;
+    /** Rewrite progress lines in place. Default: stdout is a TTY. */
+    tty?: boolean;
+    fixture?: TryFixture;
+}
+export declare const DEFAULT_TRY_PACE_MS = 1200;
+/** Replay the recording. Returns the process exit code. */
+export declare function runTry(opts?: TryOptions): Promise<number>;
+export declare function registerTryCommand(program: Command): Command;

package/dist/cli/try.js

@@ -0,0 +1,284 @@
+/**
+ * `sweny try`: a zero-credential demo (#475).
+ *
+ * Replays a recorded explain-repo run through the REAL executor, with a replay
+ * harness standing in for the agent, so the real progress line, answer block
+ * (#460), receipt, policy segment and PR-comment markdown (#396) are what a
+ * user sees. No agent, no model, no network, no env credentials, no files
+ * written (no `.sweny/runs`, no journal). The environment handed to the
+ * executor is empty by construction.
+ *
+ * The recording lives in `try-fixture.json` (metadata plus the sample answer
+ * only). Until a real run is recorded it is labelled illustrative.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import chalk from "chalk";
+import { parse as parseYaml } from "yaml";
+import { execute } from "../executor.js";
+import { validateParsed } from "../loader.js";
+import { WORKFLOW_TEMPLATES } from "./templates.js";
+import { formatFinalOutput, resolveFinalOutput } from "./final-output.js";
+import { formatRunComment } from "./comment-output.js";
+import { formatReceiptDuration, renderReceiptLine, summarizeRun } from "./run-output.js";
+import { c } from "./output.js";
+const isObj = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+/** Shape check with a message naming the first bad field. Throws on a malformed fixture. */
+export function parseTryFixture(raw) {
+    const bad = (what) => {
+        throw new Error(`try-fixture.json: ${what}`);
+    };
+    if (!isObj(raw))
+        return bad("expected an object");
+    if (raw.schema_version !== 1)
+        bad("schema_version must be 1");
+    for (const key of ["notice", "workflow", "sample_repo"]) {
+        if (typeof raw[key] !== "string" || raw[key] === "")
+            bad(`${key} must be a non-empty string`);
+    }
+    if (typeof raw.illustrative !== "boolean")
+        bad("illustrative must be a boolean");
+    if (!isObj(raw.harness) || typeof raw.harness.id !== "string" || typeof raw.harness.version !== "string") {
+        bad("harness must be { id, version }");
+    }
+    if (!isObj(raw.nodes) || Object.keys(raw.nodes).length === 0)
+        return bad("nodes must be a non-empty object");
+    for (const [id, n] of Object.entries(raw.nodes)) {
+        if (!isObj(n) || typeof n.duration_ms !== "number" || !isObj(n.tool_calls)) {
+            bad(`nodes.${id} needs duration_ms and tool_calls`);
+        }
+        for (const [tool, count] of Object.entries(n.tool_calls)) {
+            if (!Number.isInteger(count) || count < 0)
+                bad(`nodes.${id}.tool_calls.${tool} must be a count`);
+        }
+    }
+    return raw;
+}
+/** The shipped fixture: `try-fixture.json` next to this module (src/cli or dist/cli). */
+export function loadTryFixture(file) {
+    const p = file ?? fileURLToPath(new URL("./try-fixture.json", import.meta.url));
+    return parseTryFixture(JSON.parse(fs.readFileSync(p, "utf-8")));
+}
+/** The real explain-repo template, parsed and validated like any workflow file. */
+export function loadTryWorkflow(templateId) {
+    const tpl = WORKFLOW_TEMPLATES.find((t) => t.id === templateId);
+    if (!tpl)
+        throw new Error(`try-fixture.json: unknown template "${templateId}"`);
+    const loaded = validateParsed(parseYaml(tpl.yaml));
+    if (!loaded.ok)
+        throw new Error(`template ${templateId} is invalid: ${loaded.errors.map((e) => e.message).join("; ")}`);
+    return loaded.workflow;
+}
+// ── Replay harness ──────────────────────────────────────────────
+const REPLAY_CAPABILITIES = {
+    structuredOutput: "prompt",
+    toolTrace: "skill-only",
+    builtinDeny: "none",
+    mcp: { inject: false, exclusive: "none" },
+    sandbox: { fs: false, network: false },
+    readOnly: "none",
+    turnLimit: "none",
+    usage: { tokens: true, costUsd: true, live: false },
+    cancel: "signal",
+    resume: false,
+};
+function sleep(ms, signal) {
+    if (ms <= 0)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        const t = setTimeout(resolve, ms);
+        signal?.addEventListener("abort", () => {
+            clearTimeout(t);
+            resolve();
+        }, { once: true });
+    });
+}
+/**
+ * An AgentHarness that plays the recording back: node N of the run gets
+ * recording N. It never spawns a process, reads env, or touches the network.
+ * `paceMs` is how long each node takes to replay (0 = instant); tool calls are
+ * reported through `onProgress` spread across that time so progress feels live.
+ */
+export function createReplayHarness(fixture, opts) {
+    const order = Object.keys(fixture.nodes);
+    let next = 0;
+    return {
+        id: "mock",
+        capabilities: REPLAY_CAPABILITIES,
+        async preflight() {
+            return { ok: true, version: "replay" };
+        },
+        // Routing and judging never run in a linear recorded workflow; fail closed if asked.
+        async complete() {
+            return null;
+        },
+        async run(req) {
+            const id = order[next++];
+            const rec = id ? fixture.nodes[id] : undefined;
+            const harness = { id: fixture.harness.id, version: fixture.harness.version };
+            if (!rec) {
+                return {
+                    status: "failed",
+                    data: { error: "recording has no more nodes" },
+                    toolCalls: [],
+                    harness,
+                    degraded: [],
+                };
+            }
+            const toolCalls = [];
+            for (const [tool, count] of Object.entries(rec.tool_calls)) {
+                for (let i = 0; i < count; i++)
+                    toolCalls.push({ tool, input: {} });
+            }
+            const step = toolCalls.length > 0 ? opts.paceMs / toolCalls.length : opts.paceMs;
+            for (const tc of toolCalls) {
+                await sleep(step, req.signal);
+                req.onProgress?.(tc.tool);
+            }
+            if (toolCalls.length === 0)
+                await sleep(step, req.signal);
+            return {
+                status: "success",
+                data: { ...(rec.output ?? {}) },
+                toolCalls,
+                ...(rec.usage ? { usage: rec.usage } : {}),
+                ...(fixture.policy ? { policy: fixture.policy } : {}),
+                harness,
+                degraded: [],
+            };
+        },
+    };
+}
+// ── Output ──────────────────────────────────────────────────────
+export const TRY_BANNER_TITLE = "Recorded demo";
+/** The real commands, same as the README quickstart. */
+export const TRY_NEXT_COMMANDS = [
+    "npm install -g @sweny-ai/core",
+    "sweny new --template explain-repo --yes",
+    "sweny workflow run .sweny/workflows/explain-repo.yml",
+];
+/** Appended to `sweny try --help`. */
+export const TRY_HELP_NOTE = "The recording is ILLUSTRATIVE SAMPLE DATA (a fictional repo, hand-written timings and token counts), not output from a real run. " +
+    "Nothing runs: no agent, no network, no credentials read, no files written.";
+export function formatTryBanner(fixture) {
+    const lines = [
+        `${c.brand("▲")} ${chalk.bold("sweny try")}  ${chalk.bold.yellow(TRY_BANNER_TITLE)}, not a live run`,
+        chalk.dim(`  A replay of an ${fixture.workflow} run on a sample repo (${fixture.sample_repo}).`),
+        chalk.dim(fixture.illustrative
+            ? "  The sample data is illustrative, not output from your code. No agent, no network, no credentials."
+            : "  No agent, no network, no credentials."),
+    ];
+    return lines.map((l, i) => (i === 0 ? `  ${l}` : l)).join("\n");
+}
+export function formatTryNext() {
+    return [
+        `  ${chalk.bold("Run it for real")} on your own repo:`,
+        "",
+        ...TRY_NEXT_COMMANDS.map((cmd) => `    ${cmd}`),
+        "",
+        chalk.dim("  Needs a Claude login (`claude` signed in) or ANTHROPIC_API_KEY. Your run ends with the same receipt."),
+    ].join("\n");
+}
+export const DEFAULT_TRY_PACE_MS = 1200;
+const silentLogger = { info() { }, warn() { }, error() { }, debug() { } };
+/** Replay the recording. Returns the process exit code. */
+export async function runTry(opts = {}) {
+    const write = opts.write ?? ((s) => void process.stdout.write(s));
+    const tty = opts.tty ?? Boolean(process.stdout.isTTY);
+    const paceMs = opts.fast ? 0 : Math.max(0, opts.paceMs ?? DEFAULT_TRY_PACE_MS);
+    const fixture = opts.fixture ?? loadTryFixture();
+    const workflow = loadTryWorkflow(fixture.workflow);
+    for (const id of Object.keys(fixture.nodes)) {
+        if (!workflow.nodes[id])
+            throw new Error(`try-fixture.json: node "${id}" is not in ${fixture.workflow}`);
+    }
+    write(`\n${formatTryBanner(fixture)}\n\n`);
+    const ticks = new Map();
+    const observer = (event) => {
+        switch (event.type) {
+            case "workflow:start":
+                write(`  ${c.brand("▲")} ${chalk.bold(event.workflow)}\n\n`);
+                break;
+            case "node:enter":
+                ticks.set(event.node, 0);
+                if (tty)
+                    write(`  ${c.subtle("○")} ${chalk.dim(event.node)}…`);
+                break;
+            case "node:progress": {
+                const n = (ticks.get(event.node) ?? 0) + 1;
+                ticks.set(event.node, n);
+                if (tty) {
+                    write(`\r\x1B[2K  ${c.subtle("○")} ${chalk.dim(event.node)}… ${chalk.dim(`${n} tool ${n === 1 ? "call" : "calls"}`)}`);
+                }
+                break;
+            }
+            case "node:exit": {
+                const rec = fixture.nodes[event.node];
+                const ok = event.result.status === "success";
+                const icon = ok ? c.ok("✓") : c.fail("✗");
+                const calls = event.result.toolCalls.length;
+                const detail = [formatReceiptDuration(rec?.duration_ms ?? 0), ...(calls > 0 ? [`${calls} tool calls`] : [])];
+                write(`${tty ? "\r\x1B[2K" : ""}  ${icon} ${event.node}  ${chalk.dim(detail.join(" · "))}\n`);
+                break;
+            }
+        }
+    };
+    const { results, trace } = await execute(workflow, {}, {
+        skills: new Map(),
+        harness: createReplayHarness(fixture, { paceMs }),
+        observer,
+        logger: silentLogger,
+        // Nothing for the executor to read: no credentials, no PATH, no config.
+        env: {},
+        offline: true,
+        harnessPolicy: "warn",
+    });
+    write("\n");
+    // The recording's timings, not the replay's wall clock.
+    const durationsMs = Object.fromEntries(Object.entries(fixture.nodes).map(([id, n]) => [id, n.duration_ms]));
+    const totalMs = Object.values(durationsMs).reduce((a, b) => a + b, 0);
+    const receipt = summarizeRun(results, totalMs, false, trace);
+    const answer = resolveFinalOutput(workflow, results);
+    if (answer)
+        write(`${formatFinalOutput(answer)}\n\n`);
+    write(`  ${renderReceiptLine(receipt, tty)}\n\n`);
+    const comment = formatRunComment(workflow, results, receipt, { trace, durationsMs });
+    write(`  ${chalk.dim("What CI posts on a pull request (sweny workflow run --comment-file):")}\n\n`);
+    write(`${comment
+        .split("\n")
+        .map((l) => (l === "" ? l : `    ${l}`))
+        .join("\n")}\n`);
+    if (opts.commentFile) {
+        try {
+            fs.mkdirSync(path.dirname(path.resolve(opts.commentFile)), { recursive: true });
+            fs.writeFileSync(opts.commentFile, comment);
+        }
+        catch (err) {
+            process.stderr.write(`  ⚠ could not write comment file: ${err instanceof Error ? err.message : err}\n`);
+        }
+    }
+    write(`${formatTryNext()}\n\n`);
+    return receipt.ok ? 0 : 1;
+}
+export function registerTryCommand(program) {
+    return program
+        .command("try")
+        .description("Replay a recorded demo run: no credentials, no network, no model calls (illustrative sample data)")
+        .option("--fast", "Replay instantly instead of pacing the progress")
+        .option("--pace <ms>", `Milliseconds each node takes to replay (default ${DEFAULT_TRY_PACE_MS})`)
+        .option("--comment-file <path>", "Also write the PR-comment markdown to <path>")
+        .addHelpText("after", `\n${TRY_HELP_NOTE}\n`)
+        .action(async (options) => {
+        let paceMs;
+        if (options.pace !== undefined) {
+            paceMs = Number(options.pace);
+            if (!Number.isFinite(paceMs) || paceMs < 0) {
+                console.error(chalk.red(`\n  --pace must be a non-negative number of milliseconds, got "${options.pace}"\n`));
+                process.exitCode = 1;
+                return;
+            }
+        }
+        process.exitCode = await runTry({ fast: options.fast, paceMs, commentFile: options.commentFile });
+    });
+}

package/dist/cli/version-check.js

@@ -38,6 +38,9 @@ export function shouldSkip(env, isTty, commandName) {
         return true;
     if (commandName === "upgrade" || commandName === "update")
         return true;
+    // `sweny try` makes no network calls, the version check included.
+    if (commandName === "try")
+        return true;
     return false;
 }
 export function readCache(cachePath) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sweny-ai/core",
-  "version": "0.1.166",
+  "version": "0.1.168",
   "type": "module",
   "bin": {
     "sweny": "./dist/cli/main.js"
@@ -50,7 +50,7 @@
     "dist"
   ],
   "scripts": {
-    "build": "rm -rf dist && tsc -p tsconfig.build.json && cp src/workflows/*.yml dist/workflows/ && node scripts/build-workflow-browser.mjs && node scripts/write-public-schema.mjs",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json && cp src/workflows/*.yml dist/workflows/ && cp src/cli/try-fixture.json dist/cli/ && node scripts/build-workflow-browser.mjs && node scripts/write-public-schema.mjs",
     "typecheck": "tsc --noEmit",
     "test": "vitest run --exclude 'src/__tests__/integration/**' --exclude 'dist/**'",
     "test:integration": "vitest run --config vitest.integration.config.ts",