@pushpalsdev/cli 1.0.66 → 1.0.68

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushpalsdev/cli",
-  "version": "1.0.66",
+  "version": "1.0.68",
   "description": "PushPals terminal CLI for LocalBuddy -> RemoteBuddy orchestration",
   "license": "MIT",
   "repository": {

package/runtime/configs/local.example.toml

@@ -8,7 +8,7 @@
 
 [localbuddy.llm]
 backend = "openai_codex"
-model = "gpt-5.4"
+model = "gpt-5.5"
 codex_auth_mode = "chatgpt"
 codex_bin = "bun x --yes @openai/codex"
 codex_timeout_ms = 120000
@@ -16,7 +16,7 @@ reasoning_effort = "high"
 
 [remotebuddy.llm]
 backend = "openai_codex"
-model = "gpt-5.4"
+model = "gpt-5.5"
 codex_auth_mode = "chatgpt"
 codex_bin = "bun x --yes @openai/codex"
 codex_timeout_ms = 120000
@@ -43,7 +43,7 @@ retention_days = 30
 
 [workerpals.llm]
 backend = "openai_codex"
-model = "gpt-5.4"
+model = "gpt-5.5"
 codex_auth_mode = "chatgpt"
 codex_bin = "bun x --yes @openai/codex"
 codex_timeout_ms = 120000

package/runtime/sandbox/apps/workerpals/src/backends/openai_codex/openai_codex_executor.py

@@ -43,7 +43,8 @@ from executor_base import (
 )
 
 LOG_PREFIX = "[OpenAICodexExecutor]"
-DEFAULT_CODEX_MODEL = "gpt-5.4"
+DEFAULT_CODEX_MODEL = "gpt-5.5"
+LEGACY_CODEX_MODEL_FALLBACK = "gpt-5.4"
 _ACTIVE_CHILD: Optional[subprocess.Popen[str]] = None
 _INTERRUPTED_SIGNAL: Optional[int] = None
 log = Logger(LOG_PREFIX)
@@ -76,6 +77,10 @@ _CODEX_WORKAROUND_NEGATION_HINTS = (
     "codex cli is required infrastructure",
 )
 _REJECTED_EXEC_COMMAND_PATTERN = re.compile(r"exec_command failed for `([^`]+)`", re.IGNORECASE)
+_MODEL_REQUIRES_NEWER_CODEX_PATTERN = re.compile(
+    r"model requires a newer version of codex|requires a newer version of codex|upgrade to the latest app or cli",
+    re.IGNORECASE,
+)
 _DISALLOWED_SHELL_WRAPPER_PREFIXES = (
     "/bin/bash -lc ",
     "/bin/bash -c ",
@@ -210,6 +215,19 @@ def shutil_which(binary: str) -> str:
     return which(binary) or ""
 
 
+def _resolve_command_executable(binary: str) -> str:
+    value = str(binary or "").strip()
+    if not value or os.path.dirname(value) or os.path.isabs(value):
+        return value
+    return shutil_which(value) or value
+
+
+def _normalize_command_prefix(parts: List[str]) -> List[str]:
+    if not parts:
+        return []
+    return [_resolve_command_executable(parts[0]), *parts[1:]]
+
+
 def _truncate(text: str, max_chars: int = 4000) -> str:
     value = str(text or "")
     if len(value) <= max_chars:
@@ -376,7 +394,7 @@ def _resolve_codex_command_prefix(config: OpenAICodexRuntimeConfig) -> List[str]
             if isinstance(parsed, list):
                 parts = [str(p).strip() for p in parsed if str(p).strip()]
                 if parts:
-                    return parts
+                    return _normalize_command_prefix(parts)
         except Exception:
             log.info(
                 "Invalid PUSHPALS_OPENAI_CODEX_BIN_JSON; expected JSON array of command segments."
@@ -391,13 +409,15 @@ def _resolve_codex_command_prefix(config: OpenAICodexRuntimeConfig) -> List[str]
                 "Invalid PUSHPALS_OPENAI_CODEX_BIN value; expected a command string parseable by shlex."
             )
             return []
-        return parts
+        return _normalize_command_prefix(parts)
 
     # Prefer bunx to avoid requiring a separate node runtime in the container.
-    if shutil_which("bunx"):
-        return ["bunx", "--yes", "@openai/codex"]
-    if shutil_which("codex"):
-        return ["codex"]
+    bunx = shutil_which("bunx")
+    if bunx:
+        return [bunx, "--yes", "@openai/codex"]
+    codex = shutil_which("codex")
+    if codex:
+        return [codex]
     return []
 
 
@@ -964,6 +984,10 @@ def _safe_model_for_codex(raw_model: str, base_url: str) -> str:
     return DEFAULT_CODEX_MODEL
 
 
+def _requires_newer_codex_for_model(*texts: str) -> bool:
+    return any(_MODEL_REQUIRES_NEWER_CODEX_PATTERN.search(str(text or "")) for text in texts)
+
+
 def _build_instruction(instruction: str, supplemental_guidance: List[str]) -> str:
     system_prompt = (_load_prompt_template(_TASK_SYSTEM_PROMPT_PATH) or "").strip()
     if not system_prompt:
@@ -1343,6 +1367,8 @@ def _run_codex_task(
     supplemental_guidance: List[str],
     *,
     wrapper_recovery_attempt: int = 0,
+    model_compatibility_recovery_attempt: int = 0,
+    model_override: Optional[str] = None,
     baseline_changes: Optional[List[str]] = None,
 ) -> Dict[str, Any]:
     global _ACTIVE_CHILD, _INTERRUPTED_SIGNAL
@@ -1377,7 +1403,12 @@ def _run_codex_task(
     configured_model, api_key, base_url = resolve_llm_config(DEFAULT_CODEX_MODEL, logger=log)
     auth_mode_raw = runtime_config.auth_mode
     auth_mode_configured = _normalize_auth_mode(auth_mode_raw)
-    model = _safe_model_for_codex(configured_model, base_url)
+    model = str(model_override or "").strip() or _safe_model_for_codex(configured_model, base_url)
+    if model_override:
+        log.info(
+            f"Using Codex model compatibility override {model!r} instead of configured/default "
+            f"model {configured_model!r}."
+        )
     approval = _normalize_choice(
         runtime_config.approval_policy,
         _VALID_APPROVAL_POLICIES,
@@ -1743,6 +1774,8 @@ def _run_codex_task(
                             recovery_guidance,
                         ],
                         wrapper_recovery_attempt=wrapper_recovery_attempt + 1,
+                        model_compatibility_recovery_attempt=model_compatibility_recovery_attempt,
+                        model_override=model_override,
                         baseline_changes=baseline_snapshot,
                     )
                     retry_result["usage"] = _merge_usage_records(usage, retry_result.get("usage"))
@@ -1808,6 +1841,36 @@ def _run_codex_task(
         exit_code = int(return_code)
 
         if exit_code != 0:
+            if (
+                model_compatibility_recovery_attempt < 1
+                and model.strip().lower() == DEFAULT_CODEX_MODEL.lower()
+                and LEGACY_CODEX_MODEL_FALLBACK.strip().lower() != DEFAULT_CODEX_MODEL.lower()
+                and _requires_newer_codex_for_model(stdout, stderr)
+            ):
+                log.warning(
+                    f"Codex CLI rejected default model {DEFAULT_CODEX_MODEL}; retrying once with "
+                    f"{LEGACY_CODEX_MODEL_FALLBACK}. Upgrade Codex CLI to use {DEFAULT_CODEX_MODEL}."
+                )
+                retry_result = _run_codex_task(
+                    repo,
+                    instruction,
+                    effective_supplemental_guidance,
+                    wrapper_recovery_attempt=wrapper_recovery_attempt,
+                    model_compatibility_recovery_attempt=model_compatibility_recovery_attempt + 1,
+                    model_override=LEGACY_CODEX_MODEL_FALLBACK,
+                    baseline_changes=baseline_snapshot,
+                )
+                retry_result["usage"] = _merge_usage_records(usage, retry_result.get("usage"))
+                if retry_result.get("ok"):
+                    recovered_stdout = str(retry_result.get("stdout") or "").strip()
+                    retry_result["stdout"] = _truncate(
+                        (
+                            f"Codex CLI rejected default model {DEFAULT_CODEX_MODEL} because it "
+                            "requires a newer Codex version; recovered by retrying with "
+                            f"{LEGACY_CODEX_MODEL_FALLBACK}.\n\n{recovered_stdout}"
+                        ).strip()
+                    )
+                return retry_result
             detail = stderr.strip() or stdout.strip() or "codex exec exited with a non-zero status"
             if last_message:
                 detail = f"{detail}\nLast assistant message:\n{last_message}"

package/runtime/sandbox/apps/workerpals/src/backends/openai_codex/test_openai_codex_runtime_config.py

@@ -34,6 +34,7 @@ from openai_codex_executor import (
     _extract_usage_counts,
     _load_prompt_template,
     _repo_root_for_prompt_loading,
+    _resolve_codex_command_prefix,
     _unwrap_shell_wrapper_command,
     _usage_from_trace_or_estimate,
 )
@@ -79,14 +80,52 @@ class OpenAICodexRuntimeConfigTests(unittest.TestCase):
         self.assertEqual(cfg.reasoning_effort, "high")
         self.assertFalse(cfg.json_output)
 
-    def test_reasoning_effort_caps_extra_high_for_gpt_5_4(self) -> None:
+    def test_resolve_codex_command_prefix_resolves_configured_executable(self) -> None:
+        cfg = OpenAICodexRuntimeConfig.from_sources(
+            SettingsResolver(
+                env={"PUSHPALS_OPENAI_CODEX_BIN": "bun x --yes @openai/codex"},
+                config_loader=lambda: {},
+            ),
+        )
+        with mock.patch(
+            "openai_codex_executor.shutil_which",
+            side_effect=lambda binary: {"bun": r"C:\Tools\bun.CMD"}.get(binary, ""),
+        ):
+            self.assertEqual(
+                _resolve_codex_command_prefix(cfg),
+                [r"C:\Tools\bun.CMD", "x", "--yes", "@openai/codex"],
+            )
+
+    def test_resolve_codex_command_prefix_resolves_fallback_executable(self) -> None:
+        cfg = OpenAICodexRuntimeConfig.from_sources(
+            SettingsResolver(env={}, config_loader=lambda: {}),
+        )
+        with mock.patch(
+            "openai_codex_executor.shutil_which",
+            side_effect=lambda binary: {"bunx": "/usr/local/bin/bunx" }.get(binary, ""),
+        ):
+            self.assertEqual(
+                _resolve_codex_command_prefix(cfg),
+                ["/usr/local/bin/bunx", "--yes", "@openai/codex"],
+            )
+
+    def test_reasoning_effort_caps_extra_high_for_legacy_gpt_5_4(self) -> None:
+        cfg = OpenAICodexRuntimeConfig.from_sources(
+            SettingsResolver(
+                env={"WORKERPALS_OPENAI_CODEX_REASONING_EFFORT": "extra high"},
+                config_loader=lambda: {},
+            ),
+        )
+        self.assertEqual(_resolve_reasoning_effort(cfg, model="gpt-5.4"), "high")
+
+    def test_reasoning_effort_preserves_extra_high_for_default_gpt_5_5(self) -> None:
         cfg = OpenAICodexRuntimeConfig.from_sources(
             SettingsResolver(
                 env={"WORKERPALS_OPENAI_CODEX_REASONING_EFFORT": "extra high"},
                 config_loader=lambda: {},
             ),
         )
-        self.assertEqual(_resolve_reasoning_effort(cfg), "high")
+        self.assertEqual(_resolve_reasoning_effort(cfg), "xhigh")
 
     def test_reasoning_effort_preserves_extra_high_for_future_models(self) -> None:
         cfg = OpenAICodexRuntimeConfig.from_sources(
@@ -436,6 +475,88 @@ class OpenAICodexRuntimeConfigTests(unittest.TestCase):
         self.assertIn("strict wrapper recovery", str(result.get("stdout") or "").lower())
         self.assertIn("backend-supplied direct command bootstrap", str(result.get("stdout") or ""))
 
+    def test_run_codex_task_recovers_when_default_model_requires_newer_codex(self) -> None:
+        with tempfile.TemporaryDirectory(prefix="pushpals-codex-model-compat-") as temp_dir:
+            repo = Path(temp_dir) / "repo"
+            repo.mkdir(parents=True, exist_ok=True)
+            (repo / "README.md").write_text("# model compatibility test\n", encoding="utf-8")
+            subprocess.run(["git", "init"], cwd=repo, check=True, capture_output=True, text=True)
+            subprocess.run(
+                ["git", "config", "user.name", "PushPals Test"],
+                cwd=repo,
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+            subprocess.run(
+                ["git", "config", "user.email", "pushpals-tests@example.com"],
+                cwd=repo,
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+            subprocess.run(["git", "add", "README.md"], cwd=repo, check=True, capture_output=True, text=True)
+            subprocess.run(
+                ["git", "commit", "-m", "chore: seed model compatibility repo"],
+                cwd=repo,
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+
+            stub_path = Path(temp_dir) / "fake_codex_model_compat.py"
+            stub_path.write_text(
+                "\n".join(
+                    [
+                        "from pathlib import Path",
+                        "import sys",
+                        "",
+                        "argv = sys.argv[1:]",
+                        "model = ''",
+                        "last_message_path = None",
+                        "for index, arg in enumerate(argv):",
+                        "    if arg == '-m' and index + 1 < len(argv):",
+                        "        model = argv[index + 1]",
+                        "    if arg == '--output-last-message' and index + 1 < len(argv):",
+                        "        last_message_path = argv[index + 1]",
+                        "",
+                        "if model == 'gpt-5.5':",
+                        "    print(\"ERROR: {'detail': \\\"The 'gpt-5.5' model requires a newer version of Codex. Please upgrade to the latest app or CLI and try again.\\\"}\", file=sys.stderr)",
+                        "    sys.exit(1)",
+                        "",
+                        "if model == 'gpt-5.4':",
+                        "    if last_message_path:",
+                        "        Path(last_message_path).write_text('Recovered on legacy model fallback.', encoding='utf-8')",
+                        "    print('item.completed | Used legacy model fallback.', flush=True)",
+                        "    sys.exit(0)",
+                        "",
+                        "print(f'unexpected model {model}', file=sys.stderr)",
+                        "sys.exit(2)",
+                    ]
+                ),
+                encoding="utf-8",
+            )
+
+            env_overrides = {
+                "PUSHPALS_OPENAI_CODEX_BIN_JSON": json.dumps([sys.executable, str(stub_path)]),
+                "PUSHPALS_OPENAI_CODEX_AUTH_MODE": "api_key",
+                "OPENAI_API_KEY": "pushpals-model-compat-test-key",
+                "WORKERPALS_OPENAI_CODEX_TIMEOUT_S": "10",
+                "WORKERPALS_OPENAI_CODEX_PROGRESS_LOG_INTERVAL_S": "1",
+            }
+            with mock.patch.dict(os.environ, env_overrides, clear=False):
+                result = _run_codex_task(
+                    str(repo),
+                    "Use the configured Codex model.",
+                    [],
+                )
+
+        self.assertTrue(result.get("ok"), result)
+        stdout = str(result.get("stdout") or "")
+        self.assertIn("rejected default model gpt-5.5", stdout.lower())
+        self.assertIn("gpt-5.4", stdout)
+        self.assertIn("Recovered on legacy model fallback.", stdout)
+
     def test_usage_falls_back_to_estimate_when_trace_has_no_usage(self) -> None:
         usage = _usage_from_trace_or_estimate({}, "abc" * 30, "done", model="gpt-5.4")
         self.assertTrue(usage["estimated"])

package/runtime/sandbox/apps/workerpals/src/execute_job.ts

@@ -7,13 +7,17 @@ import { existsSync, readFileSync, rmSync, unlinkSync } from "fs";
 import { resolve } from "path";
 import {
   deriveAutonomyComponentArea,
+  buildGitCommitArgs as buildSourceControlGitCommitArgs,
+  explicitSourceControlCommitIdentityFromEnv,
   loadPromptTemplate,
   loadPushPalsConfig,
   matchesGlob,
   normalizeAutonomyComponentArea,
   normalizeTargetPath,
+  sanitizeSourceControlIdentityField,
   validateScopeInvariants,
   type AutonomyComponentArea,
+  type SourceControlCommitIdentity,
 } from "shared";
 import { resolveExecutor, type WorkerpalsRuntimeConfig } from "./common/executor_backend.js";
 import type { JobPublishBlockedInfo, JobResult } from "./common/types.js";
@@ -1432,6 +1436,35 @@ export async function git(
 // ─── Git commit creation ─────────────────────────────────────────────────────
 
 /** Create commit for job result and return commit info */
+export type WorkerGitCommitIdentity = SourceControlCommitIdentity;
+
+export const explicitWorkerCommitIdentityFromEnv = explicitSourceControlCommitIdentityFromEnv;
+
+async function resolveGitConfigValue(repo: string, key: string): Promise<string> {
+  const value = await git(repo, ["config", "--get", key]);
+  return value.ok ? sanitizeSourceControlIdentityField(value.stdout) : "";
+}
+
+export async function resolveWorkerCommitIdentity(
+  repo: string,
+  _runtimeConfig: WorkerpalsRuntimeConfig = DEFAULT_CONFIG,
+): Promise<WorkerGitCommitIdentity | null> {
+  const fallbackEmail = await resolveGitConfigValue(repo, "user.email");
+  const explicit = explicitWorkerCommitIdentityFromEnv(process.env, fallbackEmail);
+  if (explicit) return explicit;
+
+  const name = await resolveGitConfigValue(repo, "user.name");
+  if (name && fallbackEmail) return { name, email: fallbackEmail, source: "source-control-config" };
+  return null;
+}
+
+export function buildGitCommitArgs(
+  commitMsg: string,
+  identity: WorkerGitCommitIdentity | null,
+): string[] {
+  return buildSourceControlGitCommitArgs(commitMsg, identity);
+}
+
 export interface CreateJobCommitResult {
   ok: boolean;
   branch?: string;
@@ -1574,8 +1607,10 @@ export async function createJobCommit(
     }
     const commitMsg = llmCommitMsg ?? buildWorkerCommitMessage(workerId, job, changedPaths);
 
-    // Commit changes
-    result = await git(repo, ["commit", "-m", commitMsg]);
+    // Commit changes with a PushPals-resolved author so generated commits use
+    // source-control identity instead of falling through to the host account.
+    const commitIdentity = await resolveWorkerCommitIdentity(repo, runtimeConfig);
+    result = await git(repo, buildGitCommitArgs(commitMsg, commitIdentity));
     if (!result.ok) {
       return { ok: false, error: `Failed to commit: ${result.stderr}` };
     }
@@ -2484,7 +2519,8 @@ async function createMergeConflictJobCommit(
       );
     }
     const commitMsg = llmCommitMsg ?? buildWorkerCommitMessage(workerId, job, changedPaths);
-    const commit = await git(repo, ["commit", "-m", commitMsg]);
+    const commitIdentity = await resolveWorkerCommitIdentity(repo, runtimeConfig);
+    const commit = await git(repo, buildGitCommitArgs(commitMsg, commitIdentity));
     if (!commit.ok) {
       return { ok: false, error: `Failed to commit merge-conflict resolution: ${commit.stderr}` };
     }

package/runtime/sandbox/configs/local.example.toml

@@ -8,7 +8,7 @@
 
 [localbuddy.llm]
 backend = "openai_codex"
-model = "gpt-5.4"
+model = "gpt-5.5"
 codex_auth_mode = "chatgpt"
 codex_bin = "bun x --yes @openai/codex"
 codex_timeout_ms = 120000
@@ -16,7 +16,7 @@ reasoning_effort = "high"
 
 [remotebuddy.llm]
 backend = "openai_codex"
-model = "gpt-5.4"
+model = "gpt-5.5"
 codex_auth_mode = "chatgpt"
 codex_bin = "bun x --yes @openai/codex"
 codex_timeout_ms = 120000
@@ -43,7 +43,7 @@ retention_days = 30
 
 [workerpals.llm]
 backend = "openai_codex"
-model = "gpt-5.4"
+model = "gpt-5.5"
 codex_auth_mode = "chatgpt"
 codex_bin = "bun x --yes @openai/codex"
 codex_timeout_ms = 120000

package/runtime/sandbox/packages/shared/src/index.ts

@@ -43,6 +43,17 @@ export {
   type GitTokenSource,
   type ResolveGitTokenOptions,
 } from "./git_backend.js";
+export {
+  assertSupportedSourceControlProvider,
+  buildGitCommitArgs,
+  explicitSourceControlCommitIdentityFromEnv,
+  normalizeSourceControlProvider,
+  resolveSourceControlProvider,
+  sanitizeSourceControlIdentityField,
+  type SourceControlCommitIdentity,
+  type SourceControlCommitIdentitySource,
+  type SourceControlProvider,
+} from "./source_control_api.js";
 export {
   DEFAULT_WORKERPALS_EXECUTOR,
   invalidatePushPalsConfigCache,

package/runtime/sandbox/packages/shared/src/source_control_api.ts

@@ -0,0 +1,117 @@
+export type SourceControlProvider = "git" | "sapling" | "mercurial";
+
+export type SourceControlCommitIdentitySource = "env" | "source-control-config";
+
+export interface SourceControlCommitIdentity {
+  name: string;
+  email: string;
+  source: SourceControlCommitIdentitySource;
+}
+
+export function normalizeSourceControlProvider(value: unknown): SourceControlProvider | null {
+  const normalized = String(value ?? "")
+    .trim()
+    .toLowerCase()
+    .replace(/[_\s]+/g, "-");
+
+  if (!normalized) return null;
+  if (normalized === "auto") return "git";
+  if (normalized === "git") return "git";
+  if (normalized === "sapling" || normalized === "sl") return "sapling";
+  if (normalized === "mercurial" || normalized === "mercury" || normalized === "hg") {
+    return "mercurial";
+  }
+  return null;
+}
+
+function hasSourceControlProviderValue(value: unknown): boolean {
+  return String(value ?? "").trim().length > 0;
+}
+
+function formatUnknownSourceControlProvider(value: unknown): string {
+  return String(value ?? "").trim() || "(empty)";
+}
+
+export function resolveSourceControlProvider(
+  value?: unknown,
+  env: Record<string, string | undefined> = process.env as Record<string, string | undefined>,
+): SourceControlProvider {
+  if (hasSourceControlProviderValue(value)) {
+    const explicit = normalizeSourceControlProvider(value);
+    if (explicit) return explicit;
+    throw new Error(`Unknown source control provider '${formatUnknownSourceControlProvider(value)}'.`);
+  }
+
+  const envValue = env.PUSHPALS_SOURCE_CONTROL_PROVIDER ?? env.SOURCE_CONTROL_PROVIDER;
+  if (hasSourceControlProviderValue(envValue)) {
+    const fromEnv = normalizeSourceControlProvider(envValue);
+    if (fromEnv) return fromEnv;
+    throw new Error(
+      `Unknown source control provider '${formatUnknownSourceControlProvider(envValue)}'.`,
+    );
+  }
+
+  return "git";
+}
+
+export function assertSupportedSourceControlProvider(provider: SourceControlProvider): "git" {
+  if (provider === "git") return "git";
+  throw new Error(
+    `Source control provider '${provider}' is recognized but not supported yet. PushPals currently supports git only.`,
+  );
+}
+
+function firstNonEmptyString(...values: Array<string | null | undefined>): string {
+  for (const value of values) {
+    const trimmed = String(value ?? "").trim();
+    if (trimmed) return trimmed;
+  }
+  return "";
+}
+
+export function sanitizeSourceControlIdentityField(value: unknown): string {
+  return String(value ?? "")
+    .replace(/[\u0000-\u001f\u007f]/g, " ")
+    .replace(/[<>]/g, "")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+export function explicitSourceControlCommitIdentityFromEnv(
+  env: Record<string, string | undefined>,
+  fallbackEmail = "",
+): SourceControlCommitIdentity | null {
+  const name = sanitizeSourceControlIdentityField(
+    firstNonEmptyString(
+      env.WORKERPALS_GIT_AUTHOR_NAME,
+      env.PUSHPALS_GIT_AUTHOR_NAME,
+      env.GIT_AUTHOR_NAME,
+    ),
+  );
+  const email = sanitizeSourceControlIdentityField(
+    firstNonEmptyString(
+      env.WORKERPALS_GIT_AUTHOR_EMAIL,
+      env.PUSHPALS_GIT_AUTHOR_EMAIL,
+      env.GIT_AUTHOR_EMAIL,
+      fallbackEmail,
+    ),
+  );
+  if (!name || !email) return null;
+  return { name, email, source: "env" };
+}
+
+export function buildGitCommitArgs(
+  commitMsg: string,
+  identity: SourceControlCommitIdentity | null,
+): string[] {
+  const args: string[] = [];
+  if (identity?.name && identity.email) {
+    args.push("-c", `user.name=${identity.name}`, "-c", `user.email=${identity.email}`);
+  }
+  args.push("commit");
+  if (identity?.name && identity.email) {
+    args.push("--author", `${identity.name} <${identity.email}>`);
+  }
+  args.push("-m", commitMsg);
+  return args;
+}