feat: add built-in /triage command for GitHub issue triage

Replaces the user-level triage skill with a first-class slash command.
/triage [focus] lists untriaged open issues via gh, classifies them,
autonomously fixes the safe ones with verification, and reports back.
Works locally and over the remote transport, with help text and tests.

Author: 1jehuang

crates/jcode-tui/src/tui/app/commands.rs

@@ -1726,6 +1726,12 @@ pub(super) fn handle_session_command(app: &mut App, trimmed: &str) -> bool {
         return true;
     }
 
+    if trimmed == "/triage" || trimmed.starts_with("/triage ") {
+        let rest = trimmed.strip_prefix("/triage").unwrap_or_default();
+        handle_triage_command_local(app, rest);
+        return true;
+    }
+
     if trimmed == "/resume" || trimmed == "/sessions" || trimmed == "/session" {
         app.open_session_picker();
         app.record_keybinding_slow(super::shortcut_hints::LearnableAction::Resume);
@@ -2195,6 +2201,47 @@ pub(super) fn build_remote_release_prompt() -> String {
     )
 }
 
+pub(super) fn build_triage_prompt(focus: &str) -> String {
+    let mut prompt = String::from(
+        "Triage the open GitHub issues for the repository in the current working directory, then autonomously fix the ones that are safe to fix. \
+        Hard rules: every public comment, issue reply, or PR description you post MUST end with a clear agent attribution line like '--- *— Jcode agent (automated triage), on behalf of @<repo-owner>*' so it can never be mistaken for the human. \
+        Never close an issue as wontfix/invalid without user confirmation (closing as completed is fine only after a verified fix). Be brief, friendly, and factual toward reporters. Prefer a branch + PR unless the repo's established norm is committing directly to the default branch. \
+        Workflow: (1) Collect: verify gh auth status, identify the repo with gh repo view, list open issues newest-first (gh issue list --state open --limit 50 --json number,title,labels,createdAt,author,comments,body), focus on untriaged ones (no labels or no maintainer/agent comment), and read each candidate fully with gh issue view <n> --comments. \
+        (2) Classify each into exactly one bucket and track them in a todo list: auto-fix (clear, reproducible, low-risk, verifiable), needs-info (comment asking for the specific missing details), needs-human (design decisions, breaking changes, security-sensitive, large refactors), duplicate (link the original, do not close without confirmation unless unambiguous), or question/support (answer directly if verifiable against the code or docs). Apply existing labels only (check gh label list first, never invent labels). \
+        (3) Fix the auto-fix bucket: locate the root cause first (demote to needs-human if you cannot pin it confidently), implement the smallest correct fix with a test when practical, verify with builds/tests before claiming anything, commit referencing the issue (fix: <summary> (fixes #<n>)), and comment on the issue describing what was done, signed. If there are more than about 3 auto-fix issues, consider spawning swarm workers, one per issue, and synthesize their reports. \
+        (4) Report back with a compact table of issue number, title, bucket, and action taken, plus links to commits/PRs and one-line recommendations for the needs-human issues.",
+    );
+    let focus = focus.trim();
+    if !focus.is_empty() {
+        prompt.push_str(" Additional focus from the user: ");
+        prompt.push_str(focus);
+    }
+    prompt
+}
+
+pub(super) fn triage_launch_notice(interrupted: bool) -> String {
+    if interrupted {
+        "👉 Interrupting and starting GitHub issue triage...".to_string()
+    } else {
+        "🚀 Starting GitHub issue triage...".to_string()
+    }
+}
+
+fn handle_triage_command_local(app: &mut App, rest: &str) {
+    let prompt = build_triage_prompt(rest);
+    if app.is_processing {
+        super::commands_improve::interrupt_and_queue_synthetic_message(
+            app,
+            prompt,
+            "Interrupting for /triage...",
+            triage_launch_notice(true),
+        );
+    } else {
+        app.push_display_message(DisplayMessage::system(triage_launch_notice(false)));
+        super::commands_improve::start_synthetic_user_turn(app, prompt);
+    }
+}
+
 pub(super) fn commit_launch_notice(interrupted: bool) -> String {
     if interrupted {
         "👉 Interrupting and starting logical commits...".to_string()

crates/jcode-tui/src/tui/app/input_help.rs

@@ -70,6 +70,9 @@ impl App {
             "remote-release" => {
                 "/remote-release\nSame as /commit-push, then push the release tag without running any local build.\n\nThe agent picks the semver bump, updates Cargo.toml/Cargo.lock and the changelog, commits and pushes, then runs scripts/quick-release.sh --remote. GitHub Actions builds, signs, checksums, and publishes every platform; the release remains a draft until the remote gates pass."
             }
+            "triage" => {
+                "/triage [focus]\nTriage open GitHub issues for the current repo, then autonomously fix the safe ones.\n\nThe agent lists untriaged issues with gh, classifies each (auto-fix, needs-info, needs-human, duplicate, question), applies existing labels, fixes and verifies the clear-cut bugs, and reports back with a summary table. Every public comment is clearly signed as the Jcode agent, and issues are never closed as wontfix/invalid without your confirmation.\n\nOptional focus text narrows the triage, for example /triage only crash reports."
+            }
             "catchup" => {
                 "/catchup\nOpen the Catch Up picker for finished sessions that need attention.\n\n/catchup next\nTeleport to the next session needing attention and open a Catch Up brief in the side panel.\n\n/catchup list\nAlias for opening the picker."
             }

crates/jcode-tui/src/tui/app/remote/key_handling.rs

@@ -1919,14 +1919,21 @@ async fn handle_remote_key_internal(
                     || trimmed == "/remote-release"
                     || trimmed == "/cut-release"
                     || trimmed == "/commit-push-release"
+                    || trimmed == "/triage"
+                    || trimmed.starts_with("/triage ")
                 {
+                    let is_triage = trimmed == "/triage" || trimmed.starts_with("/triage ");
                     let is_fast_release = matches!(
                         trimmed,
                         "/fast-release" | "/cut-release" | "/commit-push-release"
                     );
                     let is_remote_release = trimmed == "/remote-release";
                     let is_push = trimmed != "/commit";
-                    let prompt = if is_fast_release {
+                    let prompt = if is_triage {
+                        app_mod::commands::build_triage_prompt(
+                            trimmed.strip_prefix("/triage").unwrap_or_default(),
+                        )
+                    } else if is_fast_release {
                         app_mod::commands::build_fast_release_prompt()
                     } else if is_remote_release {
                         app_mod::commands::build_remote_release_prompt()
@@ -1936,7 +1943,9 @@ async fn handle_remote_key_internal(
                         app_mod::commands::build_commit_prompt()
                     };
                     let launch_notice = |interrupted: bool| {
-                        if is_fast_release {
+                        if is_triage {
+                            app_mod::commands::triage_launch_notice(interrupted)
+                        } else if is_fast_release {
                             app_mod::commands::fast_release_launch_notice(interrupted)
                         } else if is_remote_release {
                             app_mod::commands::remote_release_launch_notice(interrupted)
@@ -1946,7 +1955,9 @@ async fn handle_remote_key_internal(
                             app_mod::commands::commit_launch_notice(interrupted)
                         }
                     };
-                    let cmd_label = if is_fast_release {
+                    let cmd_label = if is_triage {
+                        "/triage"
+                    } else if is_fast_release {
                         "/fast-release"
                     } else if is_remote_release {
                         "/remote-release"

crates/jcode-tui/src/tui/app/state_ui_input_helpers.rs

@@ -79,6 +79,10 @@ const REGISTERED_COMMANDS: &[RegisteredCommand] = &[
     ),
     RegisteredCommand::hidden("/cut-release", "Alias for /fast-release"),
     RegisteredCommand::hidden("/commit-push-release", "Alias for /cut-release"),
+    RegisteredCommand::public(
+        "/triage",
+        "Triage new GitHub issues and autonomously fix the safe ones",
+    ),
     RegisteredCommand::public("/transcript", "Open the current session transcript file"),
     RegisteredCommand::public("/subagent-model", "Show/change subagent model policy"),
     RegisteredCommand::public("/autoreview", "Show/toggle automatic end-of-turn review"),

crates/jcode-tui/src/tui/app/tests/commands_accounts_01/part_01.rs

@@ -600,6 +600,29 @@ fn test_fast_release_command_starts_synthetic_user_turn() {
         .contains("Starting logical commits + push + fast local release"));
 }
 
+#[test]
+fn test_triage_command_starts_synthetic_user_turn() {
+    let mut app = create_test_app();
+    app.input = "/triage".to_string();
+    app.submit_input();
+
+    assert!(app.is_processing);
+    assert!(app.pending_turn);
+    let notice = app
+        .display_messages()
+        .last()
+        .expect("missing launch notice");
+    assert_eq!(notice.role, "system");
+    assert!(notice.content.contains("Starting GitHub issue triage"));
+}
+
+#[test]
+fn test_triage_command_includes_focus_in_prompt() {
+    let prompt = crate::tui::app::commands::build_triage_prompt(" only crash reports");
+    assert!(prompt.contains("Triage the open GitHub issues"));
+    assert!(prompt.contains("Additional focus from the user: only crash reports"));
+}
+
 #[test]
 fn test_cut_release_alias_starts_fast_release_turn() {
     let mut app = create_test_app();