feat(flow): workflow /<name> slash commands across TUI, Web, and ACP (#120)

* feat(flow): workflow /<name> slash commands across TUI, Web, and ACP

Every saved workflow now surfaces as a `/<name>` slash command on all three
frontends, badged as a workflow so it's distinct from skills. Typing the slash
runs the saved workflow by name via the workflow_run tool; any text after the
slash is handed to the agent as the workflow's `args`.

- internal/flow/slash.go: shared SlashRunPrompt + GetBySlash so every frontend
  expands a workflow slash identically
- internal/web: /api/slash-commands advertises workflow slashes (type "flow")
  alongside skills; the web autocomplete surfaces and badges them
- TUI + ACP: workflow slashes join the command menu / availableCommandList
- docs: workflows.md documents the slash entry point
- .gitignore: ignore the local .jcode workflow store

Generated with Jack AI bot

* fix(flow): address PR #120 review — task-scope workflow slashes, fix badge token, doc fence

- Web slash advertising (/api/slash-commands) and slash rewrites (submitMessage)
  now resolve against the foreground task's project loader (Engine.flowLoader),
  falling back to the boot loader, so a task running in a different project sees
  its own .jcode/workflows — matching the per-task loader workflow_run already
  uses. Per-task loader is carried on the Engine via EngineConfig.FlowLoader.
- Fix the workflow badge referencing an undefined token: --color-accent-wash
  does not exist; tokens.css defines --accent-wash.
- Tag the docs example fence as `text` so markdownlint (MD040) stays clean.

Generated with Jack AI bot

---------

Co-authored-by: t <t@example.com>

Author: cnjack

.gitignore

@@ -14,3 +14,4 @@ docs/.jekyll-metadata
 .claude
 site/dist
 site/node_modules
+.jcode

internal/command/acp.go

@@ -20,6 +20,7 @@ import (
 
 	"github.com/cnjack/jcode/internal/agent"
 	"github.com/cnjack/jcode/internal/config"
+	"github.com/cnjack/jcode/internal/flow"
 	"github.com/cnjack/jcode/internal/handler"
 	"github.com/cnjack/jcode/internal/hooks"
 	mempipeline "github.com/cnjack/jcode/internal/memory/pipeline"
@@ -80,6 +81,7 @@ type acpSession struct {
 	normalPrompt string
 	planPrompt   string
 	skillLoader  *skills.Loader
+	flowLoader   *flow.Loader
 }
 
 // Close releases resources held by the session (recorder file handle, tracer).
@@ -145,7 +147,7 @@ func handleACPSubcommand() {
 
 // availableCommandList builds the slash commands advertised to ACP clients:
 // the built-in /goal command plus any skill-based commands.
-func availableCommandList(skillLoader *skills.Loader) []acp.AvailableCommand {
+func availableCommandList(skillLoader *skills.Loader, flowLoader *flow.Loader) []acp.AvailableCommand {
 	cmds := []acp.AvailableCommand{
 		{
 			Name:        "goal",
@@ -176,13 +178,32 @@ func availableCommandList(skillLoader *skills.Loader) []acp.AvailableCommand {
 			})
 		}
 	}
+	if flowLoader != nil {
+		for _, fc := range flowLoader.SlashCommands() {
+			name := strings.TrimPrefix(fc.Slash, "/")
+			if name == "goal" {
+				continue
+			}
+			// ACP has no "type" field, so mark workflows in the description so
+			// editor command palettes distinguish them from skills.
+			cmds = append(cmds, acp.AvailableCommand{
+				Name:        name,
+				Description: "workflow — " + fc.Description,
+				Input: &acp.AvailableCommandInput{
+					Unstructured: &acp.UnstructuredCommandInput{
+						Hint: "args / context",
+					},
+				},
+			})
+		}
+	}
 	return cmds
 }
 
 // broadcastSlashCommands sends the available slash commands to the client via
 // an available_commands_update session notification.
 func (a *acpAgent) broadcastSlashCommands(sessionID acp.SessionId, sess *acpSession) {
-	cmds := availableCommandList(sess.skillLoader)
+	cmds := availableCommandList(sess.skillLoader, sess.flowLoader)
 	if len(cmds) == 0 {
 		return
 	}
@@ -324,6 +345,9 @@ func (a *acpAgent) buildAgentSession(
 	skillLoader := skills.NewLoader()
 	skillLoader.ScanProjectSkills(pwd)
 
+	flowLoader := flow.NewLoader()
+	flowLoader.LoadProject(pwd)
+
 	providerName, modelName := cfg.GetProviderModel()
 	providers := cfg.GetProviders()
 	providerCfg := providers[providerName]
@@ -371,6 +395,7 @@ func (a *acpAgent) buildAgentSession(
 		env.NewWorkflowRunTool(&tools.WorkflowToolDeps{
 			ModelFactory: internalmodel.NewModelFactory(cfg, chatModel),
 			Recorder:     rec,
+			Loader:       flowLoader,
 		}),
 	}
 	if config.MemoryEnabled(cfg) {
@@ -522,6 +547,7 @@ func (a *acpAgent) buildAgentSession(
 		normalPrompt:  normalPrompt,
 		planPrompt:    planPrompt,
 		skillLoader:   skillLoader,
+		flowLoader:    flowLoader,
 	}
 
 	// Reconcile the session's advertised mode when the handler promotes to
@@ -623,13 +649,26 @@ func (a *acpAgent) Prompt(ctx context.Context, params acp.PromptRequest) (acp.Pr
 		}
 
 		// Check if it's a skill slash command.
+		matchedSkill := false
 		if sess.skillLoader != nil {
 			if sk := sess.skillLoader.GetBySlash("/" + cmdName); sk != nil {
 				userInput := ""
 				if len(parts) > 1 {
 					userInput = parts[1]
 				}
 				prompt = fmt.Sprintf("Use the load_skill tool with name=%q and follow its instructions. %s", sk.Name, userInput)
+				matchedSkill = true
+			}
+		}
+
+		// Otherwise check workflow slash commands (e.g. /repo-audit).
+		if !matchedSkill && sess.flowLoader != nil {
+			if wf, ok := sess.flowLoader.GetBySlash("/" + cmdName); ok {
+				userInput := ""
+				if len(parts) > 1 {
+					userInput = parts[1]
+				}
+				prompt = flow.SlashRunPrompt(wf.Meta.Name, userInput)
 			}
 		}
 	}

internal/command/acp_goal_test.go

@@ -3,7 +3,7 @@ package command
 import "testing"
 
 func TestAvailableCommandList_IncludesGoal(t *testing.T) {
-	cmds := availableCommandList(nil)
+	cmds := availableCommandList(nil, nil)
 	if len(cmds) == 0 {
 		t.Fatal("expected at least the goal command")
 	}

internal/command/interactive.go

@@ -23,6 +23,7 @@ import (
 	"github.com/cnjack/jcode/internal/browser"
 	"github.com/cnjack/jcode/internal/channel"
 	"github.com/cnjack/jcode/internal/config"
+	"github.com/cnjack/jcode/internal/flow"
 	"github.com/cnjack/jcode/internal/handler"
 	"github.com/cnjack/jcode/internal/hooks"
 	mempipeline "github.com/cnjack/jcode/internal/memory/pipeline"
@@ -62,6 +63,7 @@ type interactiveState struct {
 	platform        string
 	registry        *internalmodel.ModelRegistry
 	skillLoader     *skills.Loader
+	flowLoader      *flow.Loader
 	langfuseTracer  *telemetry.LangfuseTracer
 	h               handler.AgentEventHandler
 	askUserDeps     *tools.AskUserDeps
@@ -108,6 +110,7 @@ func (s *interactiveState) buildAllTools() []tool.BaseTool {
 			ModelFactory: internalmodel.NewModelFactory(s.cfg, s.chatModel),
 			Recorder:     s.rec,
 			Tracer:       s.langfuseTracer,
+			Loader:       s.flowLoader,
 		}),
 		tools.NewAskUserTool(s.askUserDeps),
 		skills.NewLoadSkillTool(s.skillLoader),
@@ -812,6 +815,19 @@ func (s *interactiveState) runEventLoop(initialHistory []adk.Message, initialRes
 		s.p.Send(tui.SkillsLoadedMsg{SlashCommands: slashInfos})
 	}
 
+	if s.flowLoader != nil {
+		if slashFlows := s.flowLoader.SlashCommands(); len(slashFlows) > 0 {
+			var flowInfos []tui.FlowSlashInfo
+			for _, fc := range slashFlows {
+				flowInfos = append(flowInfos, tui.FlowSlashInfo{
+					Slash:       fc.Slash,
+					Description: fc.Description,
+				})
+			}
+			s.p.Send(tui.FlowsLoadedMsg{SlashCommands: flowInfos})
+		}
+	}
+
 	s.history = initialHistory
 	if initialResumeUUID != "" {
 		s.p.Send(tui.SessionResumedMsg{UUID: initialResumeUUID, Entries: initialResumeEntries})
@@ -977,6 +993,9 @@ func RunInteractive(prompt, resumeUUID string, unsafe bool) error {
 	skillLoader := skills.NewLoaderWithDisabled(cfg.DisabledSkills)
 	skillLoader.ScanProjectSkills(pwd)
 
+	flowLoader := flow.NewLoader()
+	flowLoader.LoadProject(pwd)
+
 	// Memory distillation runs in the background on session start (design
 	// §5.1); one-shot -p runs are excluded, gates (cooldown/budget/lock) are
 	// inside the pipeline.
@@ -1071,6 +1090,7 @@ func RunInteractive(prompt, resumeUUID string, unsafe bool) error {
 		platform:     platform,
 		registry:     registry,
 		skillLoader:  skillLoader,
+		flowLoader:   flowLoader,
 		askUserDeps:  askUserDeps,
 		mcpTools:     mcpTools,
 		rec:          rec,

internal/command/web.go

@@ -29,6 +29,7 @@ import (
 	"github.com/cnjack/jcode/internal/channel/ble"
 	"github.com/cnjack/jcode/internal/config"
 	"github.com/cnjack/jcode/internal/feature"
+	"github.com/cnjack/jcode/internal/flow"
 	"github.com/cnjack/jcode/internal/handler"
 	mempipeline "github.com/cnjack/jcode/internal/memory/pipeline"
 	"github.com/cnjack/jcode/internal/mode"
@@ -239,6 +240,9 @@ func runWebServer(port int, host string, openBrowser bool, authToken string) err
 	skillLoader := skills.NewLoaderWithDisabled(cfg.DisabledSkills)
 	skillLoader.ScanProjectSkills(pwd)
 
+	flowLoader := flow.NewLoader()
+	flowLoader.LoadProject(pwd)
+
 	var providerName, modelName string
 	if !needsSetup {
 		providerName, modelName = cfg.GetProviderModel()
@@ -406,6 +410,14 @@ func runWebServer(port int, host string, openBrowser bool, authToken string) err
 			taskEnvInfo = util.CollectEnvInfo(taskPwd)
 		}
 
+		// Per-task flow loader (builtin + user + this task's project workflows),
+		// shared with the workflow_run tool so slash triggers and inline runs
+		// resolve the same set. Project workflows only apply to a local exec.
+		taskFlowLoader := flow.NewLoader()
+		if exec == nil {
+			taskFlowLoader.LoadProject(taskPwd)
+		}
+
 		tbg := tools.NewBackgroundManager(tenv)
 		trec, _ := session.NewRecorder(projectKey, providerName, modelName)
 		if taskID != "" && trec != nil {
@@ -494,6 +506,7 @@ func runWebServer(port int, host string, openBrowser bool, authToken string) err
 				tenv.NewWorkflowRunTool(&tools.WorkflowToolDeps{
 					ModelFactory: internalmodel.NewModelFactory(cfg, cm),
 					Recorder:     trec,
+					Loader:       taskFlowLoader,
 				}),
 				tools.NewAskUserTool(&tools.AskUserDeps{
 					BatchRequestFn: twh.RequestAskUser,
@@ -710,6 +723,7 @@ func runWebServer(port int, host string, openBrowser bool, authToken string) err
 			BreakdownFn:    breakdownFn,
 			CreateAgent:    createAgent,
 			RebuildForMode: rebuildForMode,
+			FlowLoader:     taskFlowLoader,
 		}, nil
 	}
 
@@ -764,6 +778,7 @@ func runWebServer(port int, host string, openBrowser bool, authToken string) err
 		Registry:           registry,
 		ApprovalState:      bootEC.ApprovalState,
 		SkillLoader:        skillLoader,
+		FlowLoader:         flowLoader,
 		ReloadMCP:          reloadMCPTools,
 		InitialMCPStatuses: initialMCPStatuses,
 		WechatClient:       wechatClient,

internal/flow/slash.go

@@ -0,0 +1,29 @@
+package flow
+
+import (
+	"fmt"
+	"strings"
+)
+
+// GetBySlash returns the workflow whose auto-generated "/<name>" trigger matches
+// slash. Workflows only expose auto-generated slashes (see SlashCommands), so this
+// is a name lookup with the leading "/" stripped.
+func (l *Loader) GetBySlash(slash string) (Workflow, bool) {
+	return l.Get(strings.TrimPrefix(slash, "/"))
+}
+
+// SlashRunPrompt is the agent instruction a "/<workflow>" slash command expands
+// to on every frontend (TUI / Web / ACP). It tells the agent to run the named
+// saved workflow via the workflow_run tool rather than authoring an inline
+// script; any text the user typed after the slash is handed over so the agent can
+// shape it into the workflow's `args` object. Keeping the wording here means all
+// frontends stay in lockstep.
+func SlashRunPrompt(name, userInput string) string {
+	var b strings.Builder
+	fmt.Fprintf(&b, "Run the saved workflow %q by calling the workflow_run tool with name=%q. "+
+		"Do not write an inline script — run the saved workflow by name.", name, name)
+	if s := strings.TrimSpace(userInput); s != "" {
+		fmt.Fprintf(&b, "\n\nShape the workflow's `args` from this input: %s", s)
+	}
+	return b.String()
+}

internal/tui/input_views.go

@@ -11,6 +11,7 @@ import (
 	tea "charm.land/bubbletea/v2"
 	"charm.land/lipgloss/v2"
 	"github.com/cnjack/jcode/internal/config"
+	"github.com/cnjack/jcode/internal/flow"
 	"github.com/cnjack/jcode/internal/memory"
 	"github.com/cnjack/jcode/internal/mode"
 	"github.com/cnjack/jcode/internal/tools"
@@ -42,9 +43,23 @@ func (m Model) getAllCommands() []commandSuggestion {
 	for _, sc := range m.skillSlashCommands {
 		commands = append(commands, commandSuggestion{sc.Slash, sc.Description})
 	}
+	for _, fc := range m.flowSlashCommands {
+		commands = append(commands, commandSuggestion{fc.Slash, fc.Description})
+	}
 	return commands
 }
 
+// isFlowSlash reports whether cmd (e.g. "/repo-audit") is a workflow slash
+// command, used to mark it distinctly in the suggestion list.
+func (m Model) isFlowSlash(cmd string) bool {
+	for _, fc := range m.flowSlashCommands {
+		if fc.Slash == cmd {
+			return true
+		}
+	}
+	return false
+}
+
 // filterCommands returns commands that match the given prefix.
 func filterCommands(commands []commandSuggestion, prefix string) []commandSuggestion {
 	var matches []commandSuggestion
@@ -158,18 +173,27 @@ func (m Model) renderCommandSuggestions() string {
 		s := suggestions[i]
 		cmdText := s.cmd
 		descText := s.desc
+		isFlow := m.isFlowSlash(s.cmd)
 		if i == m.cmdSuggestionIndex {
 			// Highlighted item
 			cmdStyled := lipgloss.NewStyle().Bold(true).Foreground(colorOnPrimary).Background(colorPrimary).Render(cmdText)
 			descStyled := lipgloss.NewStyle().Foreground(colorOnPrimary).Background(colorPrimary).Render(" " + descText)
+			tag := ""
+			if isFlow {
+				tag = lipgloss.NewStyle().Italic(true).Foreground(colorOnPrimary).Background(colorPrimary).Render(" workflow")
+			}
 			// Indicator
 			indicator := lipgloss.NewStyle().Foreground(colorPrimary).Render("❯")
-			lines = append(lines, fmt.Sprintf("  %s %s%s", indicator, cmdStyled, descStyled))
+			lines = append(lines, fmt.Sprintf("  %s %s%s%s", indicator, cmdStyled, tag, descStyled))
 		} else {
 			cmdStyled := lipgloss.NewStyle().Foreground(colorText).Render(cmdText)
 			descStyled := lipgloss.NewStyle().Foreground(colorMuted).Render(" " + descText)
+			tag := ""
+			if isFlow {
+				tag = lipgloss.NewStyle().Italic(true).Foreground(colorPrimary).Render(" workflow")
+			}
 			indicator := lipgloss.NewStyle().Foreground(colorMuted).Render(" ")
-			lines = append(lines, fmt.Sprintf("  %s %s%s", indicator, cmdStyled, descStyled))
+			lines = append(lines, fmt.Sprintf("  %s %s%s%s", indicator, cmdStyled, tag, descStyled))
 		}
 	}
 
@@ -442,6 +466,51 @@ func (m *Model) handleSkillSlashInput(skillName, userInput string, cmds []tea.Cm
 	return m, tea.Batch(cmds...)
 }
 
+// matchFlowSlash checks if the prompt matches a registered workflow slash command.
+// Returns a FlowSlashMsg if matched, nil otherwise.
+func (m Model) matchFlowSlash(prompt string) *FlowSlashMsg {
+	for _, fc := range m.flowSlashCommands {
+		if prompt == fc.Slash || strings.HasPrefix(prompt, fc.Slash+" ") {
+			userInput := ""
+			if strings.HasPrefix(prompt, fc.Slash+" ") {
+				userInput = strings.TrimSpace(prompt[len(fc.Slash):])
+			}
+			return &FlowSlashMsg{
+				FlowName:  strings.TrimPrefix(fc.Slash, "/"),
+				UserInput: userInput,
+			}
+		}
+	}
+	return nil
+}
+
+// handleFlowSlashInput handles a workflow slash command by sending a prompt that
+// runs the saved workflow via the workflow_run tool.
+func (m *Model) handleFlowSlashInput(flowName, userInput string, cmds []tea.Cmd) (tea.Model, tea.Cmd) {
+	prompt := flow.SlashRunPrompt(flowName, userInput)
+
+	displayLabel := "/" + flowName
+	if userInput != "" {
+		displayLabel += " " + userInput
+	}
+
+	m.mode = ModeAgent
+	m.agentDone = false
+	m.thinking = true
+	m.lines = append(m.lines, textLine(fmt.Sprintf("%s %s",
+		userLabelStyle.Render("Workflow:"), displayLabel)))
+	if m.ready {
+		m.viewport.SetHeight(m.calcViewportHeight(false))
+		m.viewport.SetContent(m.renderViewportContent())
+		m.viewport.GotoBottom()
+	}
+	cmds = append(cmds, func() tea.Msg {
+		return PromptSubmitMsg{Prompt: prompt}
+	})
+	cmds = append(cmds, m.spinner.Tick)
+	return m, tea.Batch(cmds...)
+}
+
 // renderModePills renders the unified Ask for approval/Plan/Full access mode selector line
 // above the input. The three states map onto distinct pill styles; Shift+Tab
 // cycles between them.