@sweny-ai/core 0.1.200 → 0.1.202

package/dist/cli/config.js

@@ -1,10 +1,11 @@
 import { execSync } from "node:child_process";
 import { hasCodexLogin } from "../agent-env.js";
+import { registerDeprecatedFlags } from "./deprecated-flags.js";
 import { parseAcpAgent, unsupportedAgentError } from "../harness/agents.js";
 export function registerTriageCommand(program) {
     // NOTE: File-eligible options omit Commander defaults so parseCliInputs() can
     // distinguish "user passed flag" from "not passed" and fall through to .sweny.yml.
-    return program
+    const cmd = program
         .command("triage")
         .description("Run the SWEny triage workflow")
         .option("--agent <provider>", "Coding agent: claude (default), codex, pi (experimental), or acp:<command> for any ACP agent (experimental)")
@@ -55,6 +56,7 @@ export function registerTriageCommand(program) {
         .option("--workspace-tools <tools>", "Comma-separated workspace tool integrations to enable (slack, notion, pagerduty, monday)")
         .option("--offline", "Skip URL Sources and fail fast if any are referenced", false)
         .option("--file-root [dir]", "Sandbox file: Sources to this directory tree (defaults to the working directory when the flag is given without a value)");
+    return registerDeprecatedFlags(cmd);
 }
 export function parseCliInputs(options, fileConfig = {}) {
     const env = process.env;
@@ -615,7 +617,7 @@ function parseObservabilityCredentials(provider, options, fileConfig = {}) {
     }
 }
 export function registerImplementCommand(program) {
-    return program
+    const cmd = program
         .command("implement <issueId>")
         .description("Implement a fix for a specific issue and open a PR")
         .option("--agent <provider>", "Coding agent: claude (default), codex, pi (experimental), or acp:<command> for any ACP agent (experimental)")
@@ -634,6 +636,7 @@ export function registerImplementCommand(program) {
         .option("--verbose", "Print each tool call's input and output inline (human-readable, truncated). Use --stream for full untruncated NDJSON.", false)
         .option("--offline", "Skip URL Sources and fail fast if any are referenced", false)
         .option("--file-root [dir]", "Sandbox file: Sources to this directory tree (defaults to the working directory when the flag is given without a value)");
+    return registerDeprecatedFlags(cmd);
 }
 /**
  * Parse a JSON string into MCP server configs.

package/dist/cli/deprecated-flags.d.ts

@@ -0,0 +1,35 @@
+import { type Command } from "commander";
+/**
+ * CLI flags that sweny parsed but never read, removed in #528 and restored
+ * here as deprecated no-ops so existing callers (the swenyai/triage action
+ * passes most of them) keep working through a deprecation period.
+ *
+ * Each one is accepted, hidden from `--help`, changes nothing, and prints one
+ * stderr warning per run. This table is the only place the list lives;
+ * `registerDeprecatedFlags` is the only place it is wired in, once per command.
+ *
+ * Env vars and `.sweny.yml` keys for the same settings are not parsed at all
+ * and are never rejected, so they need no handling.
+ *
+ * Remove an entry (and its command wiring) in a minor release after the
+ * deprecation period; the docs-cloud-positioning test keeps these out of
+ * `--help` and out of the supported-option docs tables.
+ */
+export interface DeprecatedFlag {
+    /** Commander flag spec, e.g. "--cache-dir <path>". */
+    flag: string;
+    /** Commands that accepted this flag before it was removed. */
+    commands: readonly string[];
+    /** Why it has no effect (kept for maintainers; not printed). */
+    note: string;
+}
+export declare const DEPRECATED_FLAGS: readonly DeprecatedFlag[];
+/** `--cache-dir <path>` -> `--cache-dir`. */
+export declare function deprecatedFlagName(spec: string): string;
+export declare function deprecationWarning(flags: readonly string[]): string;
+/**
+ * Accept every deprecated flag that `cmd` used to have. Hidden from help, no
+ * effect, and exactly one stderr warning per run naming the flags that were
+ * passed.
+ */
+export declare function registerDeprecatedFlags(cmd: Command): Command;

package/dist/cli/deprecated-flags.js

@@ -0,0 +1,44 @@
+import { Option } from "commander";
+const TRIAGE_AND_IMPLEMENT = ["triage", "implement"];
+const TRIAGE_ONLY = ["triage"];
+export const DEPRECATED_FLAGS = [
+    { flag: "--cache-dir <path>", commands: TRIAGE_ONLY, note: "no step cache exists" },
+    { flag: "--cache-ttl <seconds>", commands: TRIAGE_ONLY, note: "no step cache exists" },
+    { flag: "--no-cache", commands: TRIAGE_ONLY, note: "no step cache exists" },
+    { flag: "--output-dir <path>", commands: TRIAGE_AND_IMPLEMENT, note: "file providers do not read it" },
+    { flag: "--service-map-path <path>", commands: TRIAGE_ONLY, note: "service maps are not read" },
+    { flag: "--gitlab-base-url <url>", commands: TRIAGE_ONLY, note: "the GitLab provider reads GITLAB_URL" },
+    { flag: "--linear-team-id <id>", commands: TRIAGE_AND_IMPLEMENT, note: "the agent gets team ids from the node" },
+    { flag: "--linear-bug-label-id <id>", commands: TRIAGE_ONLY, note: "never read" },
+    { flag: "--linear-triage-label-id <id>", commands: TRIAGE_ONLY, note: "never read" },
+    { flag: "--linear-state-backlog <name>", commands: TRIAGE_ONLY, note: "never read" },
+    { flag: "--linear-state-in-progress <name>", commands: TRIAGE_AND_IMPLEMENT, note: "never read" },
+    { flag: "--linear-state-peer-review <name>", commands: TRIAGE_AND_IMPLEMENT, note: "never read" },
+];
+/** `--cache-dir <path>` -> `--cache-dir`. */
+export function deprecatedFlagName(spec) {
+    return spec.split(/[ ,]/)[0];
+}
+export function deprecationWarning(flags) {
+    const list = flags.join(", ");
+    const subject = flags.length === 1 ? `${list} is deprecated` : `${list} are deprecated`;
+    return `warning: ${subject}, has no effect and will be removed in a future minor version.\n`;
+}
+/**
+ * Accept every deprecated flag that `cmd` used to have. Hidden from help, no
+ * effect, and exactly one stderr warning per run naming the flags that were
+ * passed.
+ */
+export function registerDeprecatedFlags(cmd) {
+    const options = DEPRECATED_FLAGS.filter((d) => d.commands.includes(cmd.name())).map((d) => new Option(d.flag).hideHelp());
+    for (const option of options)
+        cmd.addOption(option);
+    cmd.hook("preAction", (_thisCommand, actionCommand) => {
+        const used = options
+            .filter((o) => actionCommand.getOptionValueSource(o.attributeName()) === "cli")
+            .map((o) => o.long);
+        if (used.length > 0)
+            process.stderr.write(deprecationWarning(used));
+    });
+    return cmd;
+}

package/dist/journal.d.ts

@@ -653,4 +653,57 @@ export declare class RunJournal implements ExecutionJournal {
     private probe;
     private wrapTool;
 }
+/**
+ * How the journal treats each `NodeResult` field (#581). `Record<keyof NodeResult, ...>` makes a
+ * field added to the type fail the build until it is listed here as journaled or excluded, so a
+ * new field cannot silently vanish on resume replay.
+ *
+ * - `verbatim`: copied as is when present (secrets are redacted by `clean` on append).
+ * - `reduced`: journaled in a smaller form, see {@link journalResult}.
+ * - `excluded`: never journaled; the reason is part of the schema.
+ *
+ * Fields stay optional on read: a journal written before a field was journaled just replays
+ * without it. Adding a journaled field needs no record version bump.
+ */
+export declare const NODE_RESULT_JOURNAL: {
+    readonly status: {
+        readonly journal: "verbatim";
+    };
+    readonly data: {
+        readonly journal: "verbatim";
+    };
+    readonly toolCalls: {
+        readonly journal: "reduced";
+    };
+    readonly evals: {
+        readonly journal: "verbatim";
+    };
+    readonly usage: {
+        readonly journal: "verbatim";
+    };
+    readonly skippedWrites: {
+        readonly journal: "verbatim";
+    };
+    readonly harness: {
+        readonly journal: "verbatim";
+    };
+    readonly degraded: {
+        readonly journal: "verbatim";
+    };
+    readonly policy: {
+        readonly journal: "verbatim";
+    };
+    readonly outputs: {
+        readonly journal: "verbatim";
+    };
+    readonly budget: {
+        readonly journal: "verbatim";
+    };
+    readonly contained: {
+        readonly journal: "excluded";
+        readonly reason: string;
+    };
+};
+/** What a node result needs to continue a run. Tool call inputs and outputs are dropped. */
+export declare function journalResult(r: NodeResult): NodeResult;
 export {};

package/dist/journal.js

@@ -2108,9 +2108,39 @@ function namesProduced(o, depth = 0) {
         return o.some((v) => namesProduced(v, depth + 1));
     return Object.entries(o).some(([k, v]) => (PRODUCED_KEYS.has(k) && v !== undefined && v !== null) || namesProduced(v, depth + 1));
 }
+/**
+ * How the journal treats each `NodeResult` field (#581). `Record<keyof NodeResult, ...>` makes a
+ * field added to the type fail the build until it is listed here as journaled or excluded, so a
+ * new field cannot silently vanish on resume replay.
+ *
+ * - `verbatim`: copied as is when present (secrets are redacted by `clean` on append).
+ * - `reduced`: journaled in a smaller form, see {@link journalResult}.
+ * - `excluded`: never journaled; the reason is part of the schema.
+ *
+ * Fields stay optional on read: a journal written before a field was journaled just replays
+ * without it. Adding a journaled field needs no record version bump.
+ */
+export const NODE_RESULT_JOURNAL = {
+    status: { journal: "verbatim" },
+    data: { journal: "verbatim" },
+    toolCalls: { journal: "reduced" }, // tool names and statuses; inputs and outputs are large and may hold secrets
+    evals: { journal: "verbatim" },
+    usage: { journal: "verbatim" },
+    skippedWrites: { journal: "verbatim" },
+    harness: { journal: "verbatim" },
+    degraded: { journal: "verbatim" },
+    policy: { journal: "verbatim" }, // booleans and a mode; the run receipt reads it for replayed nodes
+    outputs: { journal: "verbatim" },
+    budget: { journal: "verbatim" }, // a replayed node that crossed a budget must still be the node that stopped the run
+    contained: {
+        journal: "excluded",
+        reason: "containment is journaled per visit as an agent:unsandboxed record; a replayed result must not assert that " +
+            "an earlier attempt was contained, and an absent flag already reads as not contained",
+    },
+};
 /** What a node result needs to continue a run. Tool call inputs and outputs are dropped. */
-function journalResult(r) {
-    return {
+export function journalResult(r) {
+    const out = {
         status: r.status,
         data: r.data ?? {},
         toolCalls: (r.toolCalls ?? []).map((t) => ({
@@ -2118,11 +2148,13 @@ function journalResult(r) {
             input: null,
             ...(t.status ? { status: t.status } : {}),
         })),
-        ...(r.evals ? { evals: r.evals } : {}),
-        ...(r.usage ? { usage: r.usage } : {}),
-        ...(r.skippedWrites ? { skippedWrites: r.skippedWrites } : {}),
-        ...(r.harness ? { harness: r.harness } : {}),
-        ...(r.degraded ? { degraded: r.degraded } : {}),
-        ...(r.outputs ? { outputs: r.outputs } : {}),
     };
+    const source = r;
+    for (const [field, rule] of Object.entries(NODE_RESULT_JOURNAL)) {
+        if (rule.journal !== "verbatim" || field in out)
+            continue;
+        if (source[field] !== undefined)
+            out[field] = source[field];
+    }
+    return out;
 }

package/package.json

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