triflux 10.45.0 → 10.46.0

package/scripts/__tests__/resolve-auto-release.test.mjs

@@ -0,0 +1,216 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, it } from "node:test";
+import { resolveAutoRelease } from "../release/resolve-auto-release.mjs";
+
+function resolveVersion(
+  version,
+  {
+    tags = [],
+    headSha = "current",
+    main = "current",
+    parentVersion = "1.2.2",
+    ancestorStatus = 0,
+  } = {},
+) {
+  const rootDir = mkdtempSync(join(tmpdir(), "tfx-resolve-release-"));
+  // The checkout metadata must not override the exact CI commit.
+  writeFileSync(
+    join(rootDir, "package.json"),
+    JSON.stringify({ version: "99.0.0" }),
+  );
+  try {
+    return resolveAutoRelease({
+      rootDir,
+      eventName: "workflow_run",
+      headSha,
+      execFileSyncFn(command, args, options) {
+        assert.equal(command, "git");
+        assert.equal(options.cwd, rootDir);
+        if (args[0] === "show") {
+          if (args[1] === `${headSha}:package.json`)
+            return JSON.stringify({ version });
+          assert.equal(args[1], `${headSha}^1:package.json`);
+          return JSON.stringify({ version: parentVersion });
+        }
+        if (args[0] === "fetch") {
+          assert.deepEqual(args, ["fetch", "--no-tags", "origin", main]);
+          return "";
+        }
+        if (args[0] === "merge-base") {
+          assert.deepEqual(args, [
+            "merge-base",
+            "--is-ancestor",
+            headSha,
+            main,
+          ]);
+          if (ancestorStatus !== 0)
+            throw Object.assign(new Error("ancestry check failed"), {
+              status: ancestorStatus,
+            });
+          return "";
+        }
+        assert.notEqual(
+          parentVersion,
+          version,
+          "unchanged commits must not query remote refs",
+        );
+        assert.deepEqual(args, [
+          "ls-remote",
+          "--refs",
+          "origin",
+          "refs/heads/main",
+          "refs/tags/v*",
+        ]);
+        assert.equal(options.cwd, rootDir);
+        return [
+          ...(main ? [`${main}\trefs/heads/main`] : []),
+          ...tags.map((tag) => `tag-sha\trefs/tags/${tag}`),
+        ].join("\n");
+      },
+    });
+  } finally {
+    rmSync(rootDir, { recursive: true, force: true });
+  }
+}
+
+describe("automatic release resolution", () => {
+  it("skips an already released version even when its CI is stale", () => {
+    const result = resolveVersion("1.2.3", {
+      tags: ["v1.2.3"],
+      headSha: "older",
+    });
+    assert.equal(result.release, false);
+    assert.match(result.reason, /already released.*v1\.2\.3/i);
+  });
+
+  it("skips a commit whose first parent already has the same version", () => {
+    const result = resolveVersion("1.2.4", { parentVersion: "1.2.4" });
+    assert.equal(result.release, false);
+    assert.match(result.reason, /did not change.*version/i);
+  });
+
+  it("releases a version bump even when main has advanced beyond the CI head", () => {
+    const result = resolveVersion("1.2.4", { headSha: "older" });
+    assert.equal(result.release, true);
+    assert.equal(result.sha, "older");
+    assert.equal(result.npm_tag, "latest");
+  });
+
+  it("skips a CI head removed from main by a force push", () => {
+    const result = resolveVersion("1.2.4", {
+      headSha: "removed",
+      ancestorStatus: 1,
+    });
+    assert.equal(result.release, false);
+    assert.match(result.reason, /not.*ancestor.*main/i);
+  });
+
+  it("fails closed on ancestry errors other than a non-ancestor result", () => {
+    assert.throws(
+      () => resolveVersion("1.2.4", { ancestorStatus: 128 }),
+      /ancestry check failed/,
+    );
+  });
+
+  it("leaves prereleases to manual dispatch", () => {
+    const result = resolveVersion("1.3.0-rc.1");
+    assert.equal(result.release, false);
+    assert.match(result.reason, /prerelease.*dispatch/i);
+  });
+
+  it("rejects a regression with both candidate and latest stable versions", () => {
+    assert.throws(
+      () =>
+        resolveVersion("1.2.4", { tags: ["v1.2.3", "v1.3.0", "v9.0.0-rc.1"] }),
+      /1\.2\.4.*1\.3\.0/,
+    );
+  });
+
+  it("compares numeric version components, ignoring prerelease and unrelated tags", () => {
+    const result = resolveVersion("1.10.0", {
+      tags: ["v1.9.0", "v1.8.12", "v2.0.0-rc.1", "vnext"],
+    });
+    assert.equal(result.release, true);
+    assert.equal(result.version, "1.10.0");
+    assert.equal(result.channel, "stable");
+    assert.equal(result.mode, "auto");
+  });
+
+  it("rejects a lower numeric version even when tag enumeration is unsorted", () => {
+    assert.throws(
+      () => resolveVersion("1.9.1", { tags: ["v1.10.0", "v1.9.0"] }),
+      /1\.9\.1.*1\.10\.0/,
+    );
+  });
+
+  it("allows the first stable release when no stable tags exist", () => {
+    assert.equal(
+      resolveVersion("1.0.0", { tags: ["v1.0.0-rc.1"] }).release,
+      true,
+    );
+  });
+
+  it("fails closed if the remote main ref cannot be found", () => {
+    assert.throws(
+      () => resolveVersion("1.2.3", { main: null }),
+      /origin\/main/,
+    );
+  });
+
+  it("rejects malformed versions before querying the remote", () => {
+    assert.throws(() => resolveVersion("not-a-version"), /invalid.*version/i);
+  });
+
+  it("passes manual version and channel through without git or metadata reads", () => {
+    assert.deepEqual(
+      resolveAutoRelease({
+        eventName: "workflow_dispatch",
+        version: "2.0.0-canary.4",
+        channel: "canary",
+        headSha: "dispatch-sha",
+        rootDir: "/nonexistent",
+        execFileSyncFn: () => assert.fail("dispatch must not query git"),
+      }),
+      {
+        release: true,
+        version: "2.0.0-canary.4",
+        channel: "canary",
+        mode: "dispatch",
+        npm_tag: "canary",
+        sha: "dispatch-sha",
+      },
+    );
+  });
+
+  it("writes all six workflow outputs for dispatch", () => {
+    const root = mkdtempSync(join(tmpdir(), "tfx-resolve-output-"));
+    const output = join(root, "output");
+    try {
+      execFileSync(
+        process.execPath,
+        ["scripts/release/resolve-auto-release.mjs"],
+        {
+          cwd: new URL("../../", import.meta.url),
+          env: {
+            ...process.env,
+            GITHUB_EVENT_NAME: "workflow_dispatch",
+            GITHUB_OUTPUT: output,
+            RELEASE_VERSION: "2.0.0-canary.4",
+            RELEASE_CHANNEL: "canary",
+            RELEASE_HEAD_SHA: "dispatch-sha",
+          },
+        },
+      );
+      assert.equal(
+        readFileSync(output, "utf8"),
+        "release=true\nversion=2.0.0-canary.4\nchannel=canary\nmode=dispatch\nnpm_tag=canary\nsha=dispatch-sha\n",
+      );
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+});

package/scripts/__tests__/tfx-route-bash-node-parity.test.mjs

@@ -87,7 +87,7 @@ describe("tfx-route bash/node parity — Phase 0 회귀가드", () => {
     assert.equal(plan.agent, "executor");
     assert.equal(plan.cliType, "codex");
     assert.equal(plan.adapter, "codex");
-    assert.equal(plan.effort, "gpt56_terra_high");
+    assert.equal(plan.effort, "gpt6_sol_high");
     assert.equal(plan.runMode, "fg");
   });
 

package/scripts/__tests__/tfx-route-node-entry.test.mjs

@@ -234,14 +234,14 @@ describe("tfx-route.mjs — buildRoutePlan (agent-map.json 전수)", () => {
 });
 
 describe("cli-codex.mjs — 핵심 매핑", () => {
-  test("executor → gpt56_terra_high / 1080s / fg / mcp=implement", () => {
+  test("executor → gpt6_sol_high / 1080s / fg / mcp=implement", () => {
     const p = codexAdapter.plan({
       agent: "executor",
       prompt: "x",
       mcpProfile: "auto",
     });
-    assert.equal(p.effort, "gpt56_terra_high");
-    assert.equal(p.profile, "gpt56_terra_high");
+    assert.equal(p.effort, "gpt6_sol_high");
+    assert.equal(p.profile, "gpt6_sol_high");
     assert.equal(p.timeoutMs, 1_080_000);
     assert.equal(p.runMode, "fg");
     assert.equal(p.opusOversight, false);
@@ -334,7 +334,7 @@ describe("cli-codex.mjs — 핵심 매핑", () => {
       prompt: "x",
       mcpProfile: "auto",
     });
-    assert.equal(p.effort, "gpt56_terra_high");
+    assert.equal(p.effort, "gpt6_sol_high");
     assert.equal(p.timeoutMs, 1_080_000);
   });
 

package/scripts/lib/agent-route-policy.mjs

@@ -7,7 +7,7 @@ import {
 
 const policy = {
   executor: {
-    profile: "gpt56_terra_high",
+    profile: "gpt6_sol_high",
     timeoutSec: 1080,
     runMode: "fg",
     opusOversight: false,
@@ -15,7 +15,7 @@ const policy = {
     subcommand: "exec",
   },
   codex: {
-    profile: "gpt56_terra_high",
+    profile: "gpt6_sol_high",
     timeoutSec: 1080,
     runMode: "fg",
     opusOversight: false,
@@ -23,7 +23,7 @@ const policy = {
     subcommand: "exec",
   },
   "build-fixer": {
-    profile: "gpt56_luna_low",
+    profile: "gpt6_luna_high",
     timeoutSec: 540,
     runMode: "fg",
     opusOversight: false,
@@ -31,7 +31,7 @@ const policy = {
     subcommand: "exec",
   },
   cleanup: {
-    profile: "gpt56_terra_med",
+    profile: "gpt6_sol_med",
     timeoutSec: 540,
     runMode: "fg",
     opusOversight: false,
@@ -39,7 +39,7 @@ const policy = {
     subcommand: "exec",
   },
   deslop: {
-    profile: "gpt56_terra_med",
+    profile: "gpt6_sol_med",
     timeoutSec: 540,
     runMode: "fg",
     opusOversight: false,
@@ -95,7 +95,7 @@ const policy = {
     subcommand: "exec",
   },
   "code-reviewer": {
-    profile: "gpt56_terra_high",
+    profile: "gpt6_sol_high",
     timeoutSec: 1800,
     runMode: "bg",
     opusOversight: false,
@@ -103,7 +103,7 @@ const policy = {
     subcommand: "review",
   },
   "quality-reviewer": {
-    profile: "gpt56_terra_high",
+    profile: "gpt6_sol_high",
     timeoutSec: 1800,
     runMode: "bg",
     opusOversight: false,
@@ -119,7 +119,7 @@ const policy = {
     subcommand: "review",
   },
   scientist: {
-    profile: "gpt56_terra_high",
+    profile: "gpt6_sol_high",
     timeoutSec: 1440,
     runMode: "bg",
     opusOversight: false,
@@ -127,7 +127,7 @@ const policy = {
     subcommand: "exec",
   },
   "document-specialist": {
-    profile: "gpt56_terra_high",
+    profile: "gpt6_sol_high",
     timeoutSec: 1440,
     runMode: "bg",
     opusOversight: false,
@@ -143,7 +143,7 @@ const policy = {
     subcommand: "exec",
   },
   verifier: {
-    profile: "gpt56_terra_high",
+    profile: "gpt6_sol_high",
     timeoutSec: 1200,
     runMode: "fg",
     opusOversight: false,
@@ -151,7 +151,7 @@ const policy = {
     subcommand: "review",
   },
   "test-engineer": {
-    profile: "gpt56_terra_high",
+    profile: "gpt6_sol_high",
     timeoutSec: 1200,
     runMode: "bg",
     opusOversight: false,
@@ -159,7 +159,7 @@ const policy = {
     subcommand: "exec",
   },
   "qa-tester": {
-    profile: "gpt56_terra_high",
+    profile: "gpt6_sol_high",
     timeoutSec: 1200,
     runMode: "bg",
     opusOversight: false,
@@ -167,7 +167,7 @@ const policy = {
     subcommand: "review",
   },
   spark: {
-    profile: "gpt56_luna_low",
+    profile: "gpt6_luna_low",
     timeoutSec: 180,
     runMode: "fg",
     opusOversight: false,
@@ -185,7 +185,7 @@ const policy = {
     subcommand: "exec",
   },
   writer: {
-    profile: "gpt56_luna_low",
+    profile: "gpt6_luna_high",
     timeoutSec: 900,
     runMode: "bg",
     opusOversight: false,
@@ -210,9 +210,10 @@ export const DEFAULT_CODEX_AGENT = "executor";
 
 export const CANONICAL_CODEX_PROFILE_OVERRIDES = Object.freeze(
   new Set([
-    "gpt56_luna_low",
-    "gpt56_terra_med",
-    "gpt56_terra_high",
+    "gpt6_luna_low",
+    "gpt6_luna_high",
+    "gpt6_sol_med",
+    "gpt6_sol_high",
     "gpt6_astra_xhigh",
     "gpt6_astra_max",
     "gpt6_astra_ultra",

package/scripts/lib/codex-profile-config.mjs

@@ -19,18 +19,24 @@ const EFFORT_BY_SUFFIX = {
 };
 
 const CANONICAL_PROFILE_VALUES = Object.freeze({
-  gpt56_luna_low: { model: "gpt-5.6-luna", effort: "low" },
-  gpt56_terra_med: { model: "gpt-5.6-terra", effort: "medium" },
-  gpt56_terra_high: { model: "gpt-5.6-terra", effort: "high" },
+  gpt6_luna_low: { model: "gpt-6-luna", effort: "low" },
+  gpt6_luna_high: { model: "gpt-6-luna", effort: "high" },
+  gpt6_sol_med: { model: "gpt-6-sol", effort: "medium" },
+  gpt6_sol_high: { model: "gpt-6-sol", effort: "high" },
   gpt6_astra_xhigh: { model: "gpt-6-astra", effort: "xhigh" },
   gpt6_astra_max: { model: "gpt-6-astra", effort: "max" },
   gpt6_astra_ultra: { model: "gpt-6-astra", effort: "ultra" },
 });
 
+// GPT-5.6 lane names map to the GPT-6 lane with the same effort. GPT-6 has no
+// Terra tier, so Terra lanes move to Sol.
 const LEGACY_CANONICAL_PROFILE_ALIASES = Object.freeze({
   gpt56_sol_xhigh: "gpt6_astra_xhigh",
   gpt56_sol_max: "gpt6_astra_max",
   gpt56_sol_ultra: "gpt6_astra_ultra",
+  gpt56_terra_high: "gpt6_sol_high",
+  gpt56_terra_med: "gpt6_sol_med",
+  gpt56_luna_low: "gpt6_luna_low",
 });
 
 export function normalizeCodexProfileName(profileName) {
@@ -38,6 +44,14 @@ export function normalizeCodexProfileName(profileName) {
   return LEGACY_CANONICAL_PROFILE_ALIASES[normalized] || normalized;
 }
 
+/** Model ID of a canonical profile (after legacy normalization), or null. */
+export function canonicalCodexProfileModel(profileName) {
+  return (
+    CANONICAL_PROFILE_VALUES[normalizeCodexProfileName(profileName)]?.model ??
+    null
+  );
+}
+
 function readProfileScalar(raw, key) {
   const match = String(raw).match(
     new RegExp(
@@ -51,7 +65,7 @@ function readProfileScalar(raw, key) {
 }
 
 /**
- * Resolve a Codex effort profile name (e.g. "gpt56_terra_high") to the `-c key=value`
+ * Resolve a Codex effort profile name (e.g. "gpt6_sol_high") to the `-c key=value`
  * config overrides that `codex exec` accepts, so the headless CLI lanes can
  * select a profile WITHOUT `codex exec --profile <name>`. codex 0.134+ rejects
  * `--profile X` whenever config.toml still contains an inline `[profiles.X]`
@@ -69,7 +83,7 @@ function readProfileScalar(raw, key) {
  *
  * @param {string} profileName
  * @param {{ codexHome?: string }} [opts]
- * @returns {string[]} e.g. ['model="gpt-5.6-terra"', 'model_reasoning_effort="high"']
+ * @returns {string[]} e.g. ['model="gpt-6-sol"', 'model_reasoning_effort="high"']
  */
 export function resolveCodexProfileConfigValues(profileName, opts = {}) {
   if (typeof profileName !== "string" || !profileName) {

package/scripts/release/publish.mjs

@@ -47,6 +47,7 @@ export async function publishRelease({
   provenance = false,
   allowExistingArtifacts = false,
   pushBranch = true,
+  allowAncestor = false,
   tagPoll = {},
   execFileSyncFn,
 } = {}) {
@@ -194,7 +195,19 @@ export async function publishRelease({
           stdio: "pipe",
         }),
       ).trim();
-      if (head !== remote) {
+      if (allowAncestor) {
+        try {
+          runCommand(
+            "git",
+            ["merge-base", "--is-ancestor", "HEAD", `origin/${branch}`],
+            { cwd: rootDir, execFileSyncFn, stdio: "pipe" },
+          );
+        } catch {
+          throw new Error(
+            `Refusing tag-only publish: HEAD ${head} is not an ancestor of origin/${branch} ${remote}`,
+          );
+        }
+      } else if (head !== remote) {
         throw new Error(
           `Refusing tag-only publish: HEAD ${head} != origin/${branch} ${remote} (stale checkout or unpushed ${branch})`,
         );
@@ -235,6 +248,7 @@ export async function publishRelease({
     provenance,
     allowExistingArtifacts,
     pushBranch,
+    allowAncestor,
     dryRun,
     notesPath,
     steps: steps.map((step) => ({
@@ -260,6 +274,7 @@ if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
     provenance: Boolean(args.provenance || envProvenance),
     allowExistingArtifacts: Boolean(args["allow-existing"]),
     pushBranch: !args["tag-only"],
+    allowAncestor: Boolean(args["allow-ancestor"]),
   });
   console.log(JSON.stringify(result, null, 2));
 }

package/scripts/release/resolve-auto-release.mjs

@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+import { execFileSync } from "node:child_process";
+import { appendFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { isSemver, ROOT } from "./lib.mjs";
+
+function compareStableVersions(left, right) {
+  const a = left.split(".").map(BigInt);
+  const b = right.split(".").map(BigInt);
+  for (let i = 0; i < 3; i++) {
+    if (a[i] !== b[i]) return a[i] > b[i] ? 1 : -1;
+  }
+  return 0;
+}
+
+export function resolveAutoRelease({
+  eventName,
+  version,
+  channel,
+  headSha,
+  rootDir = ROOT,
+  execFileSyncFn = execFileSync,
+} = {}) {
+  if (eventName === "workflow_dispatch") {
+    return {
+      release: true,
+      version,
+      channel,
+      mode: "dispatch",
+      npm_tag: channel === "canary" ? "canary" : "latest",
+      sha: headSha,
+    };
+  }
+  if (eventName !== "workflow_run" || !headSha) {
+    throw new Error(
+      "Automatic release requires workflow_run and its head SHA.",
+    );
+  }
+
+  const git = (args) =>
+    execFileSyncFn("git", args, { cwd: rootDir, encoding: "utf8" });
+  const releaseVersion = JSON.parse(
+    git(["show", `${headSha}:package.json`]),
+  ).version;
+  if (!isSemver(releaseVersion)) {
+    throw new Error(`Invalid package.json version: ${releaseVersion}`);
+  }
+  const result = {
+    release: false,
+    version: releaseVersion,
+    channel: "stable",
+    mode: "auto",
+    npm_tag: "latest",
+    sha: headSha,
+  };
+  const parentVersion = JSON.parse(
+    git(["show", `${headSha}^1:package.json`]),
+  ).version;
+  if (releaseVersion === parentVersion) {
+    return {
+      ...result,
+      reason: "This commit did not change the package.json version.",
+    };
+  }
+  // A remote snapshot avoids stale local tags and origin/main tracking refs.
+  const refs = new Map(
+    execFileSyncFn(
+      "git",
+      ["ls-remote", "--refs", "origin", "refs/heads/main", "refs/tags/v*"],
+      { cwd: rootDir, encoding: "utf8" },
+    )
+      .trim()
+      .split(/\r?\n/)
+      .filter(Boolean)
+      .map((line) => {
+        const [sha, ref] = line.split(/\s+/);
+        return [ref, sha];
+      }),
+  );
+  if (refs.has(`refs/tags/v${releaseVersion}`)) {
+    return { ...result, reason: `Already released: v${releaseVersion}.` };
+  }
+  const mainSha = refs.get("refs/heads/main");
+  if (!mainSha) throw new Error("Cannot resolve origin/main from remote refs.");
+  // main may have advanced after checkout; fetch the exact remote snapshot
+  // before checking ancestry so a missing local object cannot look like a skip.
+  git(["fetch", "--no-tags", "origin", mainSha]);
+  try {
+    git(["merge-base", "--is-ancestor", headSha, mainSha]);
+  } catch (error) {
+    if (error.status !== 1) throw error;
+    return { ...result, reason: "CI head is not an ancestor of origin/main." };
+  }
+  if (releaseVersion.includes("-")) {
+    return {
+      ...result,
+      reason: `Prerelease ${releaseVersion} requires manual dispatch.`,
+    };
+  }
+
+  const stableVersions = [...refs.keys()]
+    .map((ref) => /^refs\/tags\/v(\d+\.\d+\.\d+)$/.exec(ref)?.[1])
+    .filter(Boolean)
+    .sort(compareStableVersions);
+  const latest = stableVersions.at(-1);
+  if (latest && compareStableVersions(releaseVersion, latest) <= 0) {
+    throw new Error(
+      `Version ${releaseVersion} must be greater than latest stable tag v${latest}.`,
+    );
+  }
+  return { ...result, release: true };
+}
+
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
+  try {
+    const result = resolveAutoRelease({
+      eventName: process.env.GITHUB_EVENT_NAME,
+      version: process.env.RELEASE_VERSION,
+      channel: process.env.RELEASE_CHANNEL,
+      headSha: process.env.RELEASE_HEAD_SHA,
+    });
+    if (process.env.GITHUB_OUTPUT) {
+      appendFileSync(
+        process.env.GITHUB_OUTPUT,
+        ["release", "version", "channel", "mode", "npm_tag", "sha"]
+          .map((key) => `${key}=${result[key]}\n`)
+          .join(""),
+      );
+    }
+    if (!result.release) console.log(`::notice::${result.reason}`);
+    console.log(JSON.stringify(result, null, 2));
+  } catch (error) {
+    console.error(`::error::${error.message}`);
+    process.exitCode = 1;
+  }
+}