feat: improve MCP discovery and canvas authoring prompts (#3522)

apps/backend/config/prompts/kandev-context.md

@@ -1,33 +1,32 @@
-KANDEV MCP TOOLS — You have access to the following MCP tools from the "kandev" server.
-The exact `_kandev` names below are the canonical MCP protocol names. Agent clients may show a server-qualified form in their display or tool registry; treat that form as a client-specific alias for the same tool, not a separate capability, and use the exact form exposed by the active client.
+KANDEV MCP TOOLS — Selected tools from the "kandev" server are available here.
+Names ending in `_kandev` are canonical MCP protocol names. A client-specific alias may be server-qualified; use the exact callable name and schema exposed by the client.
 
 Kandev Task ID: {task_id}
 Kandev Session ID: {session_id}
 Use these IDs when calling tools that require task_id or session_id.
 
 DELEGATION POLICY:
-For ordinary coding, research, review, or parallel work, use your host agent's native subagent mechanism (for example Codex's native subagent tool, Claude Code's Agent tool, Cursor custom subagents, or OpenCode's Task tool) only when the user has explicitly authorized delegation for this task. Otherwise continue in this session or ask the user. Do NOT use Kandev task or session tools as a generic worker mechanism.
-Use create_task_kandev only when the user explicitly wants a persistent Kandev task or subtask, workflow tracking, or Kandev task lifecycle. Use spawn_session_kandev only when the user explicitly wants another Kandev session/tab. If no native subagent tool is available, continue in this session or ask the user; do not silently create a Kandev task or session.
-
+For ordinary coding, research, review, or parallel work, use your host agent's native subagent mechanism only when the user has explicitly authorized delegation; otherwise continue in this session or ask the user. Never use Kandev task or session tools as generic workers.
+Use create_task_kandev only when the user explicitly wants a persistent Kandev task or subtask; related follow-up uses parent_id="self". Use spawn_session_kandev only when the user explicitly wants another Kandev session/tab; otherwise do not silently create a Kandev task or session.
 {autopilot_section}
 
+MCP DISCOVERY:
+These instructions list selected Kandev tools, not the complete MCP catalog.
+For Kandev operations, use tools exposed by the "kandev" server. If the needed tool is already callable, use its current schema; otherwise use your client's native tool search or discovery when available.
+Search for "kandev" plus the operation or known canonical tool name. If search is unavailable, inspect the MCP tools available in your client.
+Use the exact callable name and schema exposed by the client. An omitted entry here does not mean that the tool is unavailable. If discovery cannot find a required tool, report that limitation before substituting another result.
+
+ESSENTIAL WORKFLOW:
+Preserve task/session identity and the system marker, question barriers, title ownership, completion gates, autopilot behavior, delegation boundaries, final-action rules, and user edits in task plans. Use create/get/update plan tools. For data requests that need a chart, preview, or metric, call show_rich_output_kandev with the schema returned by discovery.
+
 Available tools:
 {question_tool_section}
-{step_complete_section}{task_title_section}- create_task_plan_kandev: Save an implementation plan for a task.
-- get_task_plan_kandev: Read a task plan, including user edits.
-- update_task_plan_kandev: Update an existing task plan.
-- delete_task_plan_kandev: Delete a task plan.
-- show_rich_output_kandev: When user asks for chart/graph/plot/file preview/KPI/metrics with data: call now. Do not implement the display as ASCII/SVG/HTML or with another app. Else prose; small text table: Markdown. Send version=1,title,blocks (1-4). Inline: {"type":"chart","chart_type":"bar","title":"T","summary":"S","labels":["A","B"],"series":[{"label":"Count","values":[42,27]}]}. CSV line: {"type":"chart","chart_type":"line","title":"T","summary":"S","csv":{"path":"reports/latency.csv","x_column":"recorded_at","series":[{"column":"p95_ms","label":"p95 (ms)"}]}}. Metrics: {"type":"metrics","items":[{"label":"Passed","value":"38"}]}. Paths workspace-relative. Kandev owns axes/legends/tooltips/layout. Label series with units.
-- show_walkthrough_kandev: Store an ordered, file-anchored code walkthrough.
-- get_walkthrough_kandev: Read a task's stored walkthrough.
-- delete_walkthrough_kandev: Delete a task's walkthrough.
-- list_workspaces_kandev: List all workspaces.
-- list_workflows_kandev: List workflows in a workspace.
-- list_tasks_kandev: List tasks in a workflow.
-- create_task_kandev: Create user-requested persistent Kandev-tracked work. Use parent_id="self" for a current-task subtask; its context is inherited unless explicitly overridden.
-- update_task_kandev: Update a task, including a deferred launch prompt for blocked work that has not started.
-- spawn_session_kandev: Start an additional Kandev session/tab without creating a task. Use only when the user explicitly requests one.
-- message_task_kandev: Send a prompt to an existing Kandev task session.{coordinator_task_control_section}
-- list_task_sessions_kandev: List a task's sessions and their IDs.
+{step_complete_section}{task_title_section}{canvas_guidance_section}- create_task_plan_kandev, get_task_plan_kandev, update_task_plan_kandev: preserve user edits.
+{rich_output_section}
+- show_walkthrough_kandev, get_walkthrough_kandev, delete_walkthrough_kandev.
+- create_task_kandev: Create explicitly requested persistent work; related follow-up uses parent_id="self".
+- spawn_session_kandev: Start an explicitly requested additional session/tab.
+- message_task_kandev: Send a prompt to an existing task session.{coordinator_task_control_section}
+- list_task_sessions_kandev: List a task's sessions and IDs.
 
-IMPORTANT: You MUST use these MCP tools when instructed to create plans, ask questions, or interact with the Kandev platform. Do not skip them.
+IMPORTANT: Use these tools when instructed; do not skip them.

apps/backend/internal/backendapp/adapters.go

@@ -1045,6 +1045,25 @@ func (w *orchestratorWrapper) StartCreatedSessionWithPromptContext(
 	)
 }
 
+// StartCreatedSessionWithPromptContextAndCanvasGuidance forwards direct
+// startup together with the server-resolved capability projection used when
+// the message was persisted.
+func (w *orchestratorWrapper) StartCreatedSessionWithPromptContextAndCanvasGuidance(
+	ctx context.Context,
+	taskID, sessionID, agentProfileID, prompt string,
+	skipMessageRecord, planMode, autoStart bool,
+	attachments []v1.MessageAttachment,
+	references []v1.EntityReference,
+	promptReferenceContext string,
+	canvasGuidanceResolved, includeCanvasGuidance bool,
+) (*executor.TaskExecution, error) {
+	return w.svc.StartCreatedSessionWithPromptContextAndCanvasGuidance(
+		ctx, taskID, sessionID, agentProfileID, prompt,
+		skipMessageRecord, planMode, autoStart, attachments, references, promptReferenceContext,
+		canvasGuidanceResolved, includeCanvasGuidance,
+	)
+}
+
 type githubTaskIssueStoreAdapter struct {
 	svc *taskservice.Service
 }
@@ -1136,6 +1155,12 @@ func (w *orchestratorWrapper) StepRequiresCompletionSignal(ctx context.Context,
 	return w.svc.StepRequiresCompletionSignal(ctx, taskID)
 }
 
+// TaskSessionCanvasGuidanceEnabled forwards the resolved capability used when
+// the message handler persists a first-turn prompt.
+func (w *orchestratorWrapper) TaskSessionCanvasGuidanceEnabled(ctx context.Context, taskID, sessionID string) (bool, error) {
+	return w.svc.TaskSessionCanvasGuidanceEnabled(ctx, taskID, sessionID)
+}
+
 // ForegroundActivity forwards to the orchestrator service (ADR-0049).
 func (w *orchestratorWrapper) ForegroundActivity(sessionID string) v1.ForegroundActivity {
 	return w.svc.ForegroundActivity(sessionID)

apps/backend/internal/mcp/server/sysprompt_sync_test.go

@@ -192,6 +192,24 @@ func TestRichOutputDocs_MakeExplicitAndCSVUseDiscoverable(t *testing.T) {
 			}
 			require.NotEmpty(t, richOutputLine)
 			assert.LessOrEqual(t, utf8.RuneCountInString(richOutputLine), 750)
+			if name == "task" {
+				for _, phrase := range []string{
+					"For a chart, graph, plot, file preview, KPI, or metrics request with data, call this now",
+					"Do not implement it as ASCII, SVG, HTML, or another app",
+					"Get the schema and examples from tool discovery",
+					"workspace-relative",
+					"Label series with units",
+					"Otherwise use prose or a small Markdown table",
+					"Kandev owns layout, axes, legends, and tooltips",
+				} {
+					assert.Contains(t, richOutputLine, phrase)
+				}
+				for _, recipe := range []string{inlineRecipe, csvRecipe, metricsRecipe} {
+					assert.NotContains(t, richOutputLine, recipe,
+						"task context should obtain rich-output schemas and examples through discovery")
+				}
+				return
+			}
 			for _, phrase := range []string{
 				"When user asks for chart/graph/plot/file preview/KPI/metrics with data: call now",
 				"Do not implement the display as ASCII/SVG/HTML or with another app",

apps/backend/internal/orchestrator/canvas_prompt_test.go

@@ -0,0 +1,175 @@
+package orchestrator
+
+import (
+	"context"
+	"strings"
+	"testing"
+
+	"github.com/kandev/kandev/internal/orchestrator/executor"
+	"github.com/kandev/kandev/internal/sysprompt"
+	"github.com/kandev/kandev/internal/task/models"
+	v1 "github.com/kandev/kandev/pkg/api/v1"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestWrapCreatedSessionPrompt_CanvasPromptFollowsResolvedCapability(t *testing.T) {
+	session := &models.TaskSession{ID: "session"}
+	task := &models.Task{ID: "task"}
+
+	withoutCanvas := (&Service{}).wrapCreatedSessionPrompt(
+		context.Background(), "build the requested app", "task", "session", session, task,
+		false, false, false, false, nil, "",
+	)
+	assert.NotContains(t, withoutCanvas, "create_canvas_kandev")
+
+	withCanvas := (&Service{}).wrapCreatedSessionPrompt(
+		context.Background(), "build the requested app", "task", "session", session, task,
+		false, false, false, true, nil, "",
+	)
+	assertCanvasPrompt(t, withCanvas)
+}
+
+func TestApplyLaunchPromptContext_CanvasPromptFollowsResolvedCapability(t *testing.T) {
+	withoutCanvas := (&Service{}).applyLaunchPromptContext(context.Background(), launchPromptContext{
+		prompt:    "build the requested app",
+		taskID:    "task",
+		sessionID: "session",
+	})
+	assert.NotContains(t, withoutCanvas, "create_canvas_kandev")
+
+	withCanvas := (&Service{}).applyLaunchPromptContext(context.Background(), launchPromptContext{
+		prompt:                "build the requested app",
+		taskID:                "task",
+		sessionID:             "session",
+		includeCanvasGuidance: true,
+	})
+	assertCanvasPrompt(t, withCanvas)
+	assert.Contains(t, withCanvas, "build the requested app")
+	assert.Equal(t, 1, countSystemBlocks(withCanvas))
+
+	assert.NotContains(t, sysprompt.StripSystemContent(withCanvas), "create_canvas_kandev")
+}
+
+func TestTaskSessionCanvasGuidanceEnabledRejectsMismatchedPair(t *testing.T) {
+	repo := setupTestRepo(t)
+	seedTaskAndSession(t, repo, "task-a", "session-a", models.TaskSessionStateCreated)
+	seedTaskAndSession(t, repo, "task-b", "session-b", models.TaskSessionStateCreated)
+
+	_, err := (&Service{repo: repo}).TaskSessionCanvasGuidanceEnabled(context.Background(), "task-a", "session-b")
+	require.ErrorIs(t, err, ErrTaskSessionPairMismatch)
+}
+
+// @covers AC-AGENTS-MCP-DISCOVERY-002.2
+func TestStartCreatedSession_UsesResolvedCanvasCapabilityForRecordedPrompt(t *testing.T) {
+	for _, tt := range []struct {
+		name       string
+		canvases   bool
+		wantCanvas bool
+	}{
+		{name: "canvas enabled", canvases: true, wantCanvas: true},
+		{name: "canvas disabled", canvases: false, wantCanvas: false},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			ctx := context.Background()
+			repo := setupTestRepo(t)
+			seedTaskAndSession(t, repo, "task", "session", models.TaskSessionStateCreated)
+			seedExecutorRunning(t, repo, "session", "task", "exec-1")
+
+			taskRepo := newMockTaskRepo()
+			taskRepo.tasks["task"] = &v1.Task{
+				ID: "task", Title: "Build a canvas", Description: "Build the requested app",
+				State: v1.TaskStateInProgress,
+			}
+			agentMgr := &mockAgentManager{repoForExecutionLookup: repo}
+			svc := createTestServiceWithScheduler(repo, newMockStepGetter(), taskRepo, agentMgr)
+			svc.SetCanvasesEnabled(tt.canvases)
+			messages := &mockMessageCreator{}
+			svc.messageCreator = messages
+
+			_, err := svc.StartCreatedSession(
+				ctx, "task", "session", "profile-1", "Build the requested app",
+				false, false, false, nil, nil,
+			)
+			require.NoError(t, err)
+			require.Len(t, messages.userMessages, 1)
+			agentMgr.mu.Lock()
+			descriptions := append([]promptCall(nil), agentMgr.setExecutionDescriptionCalls...)
+			agentMgr.mu.Unlock()
+			require.Len(t, descriptions, 1)
+			if tt.wantCanvas {
+				assertCanvasPrompt(t, messages.userMessages[0].content)
+				assertCanvasPrompt(t, descriptions[0].Prompt)
+			} else {
+				assert.NotContains(t, messages.userMessages[0].content, "create_canvas_kandev")
+				assert.NotContains(t, descriptions[0].Prompt, "create_canvas_kandev")
+			}
+		})
+	}
+}
+
+// @covers AC-AGENTS-MCP-DISCOVERY-002.2
+func TestStartTask_UsesResolvedCanvasCapabilityForRecordedAndDispatchedPrompt(t *testing.T) {
+	for _, tt := range []struct {
+		name       string
+		canvases   bool
+		wantCanvas bool
+	}{
+		{name: "canvas enabled", canvases: true, wantCanvas: true},
+		{name: "canvas disabled", canvases: false, wantCanvas: false},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			ctx := context.Background()
+			repo := setupTestRepo(t)
+			seedTaskAndSession(t, repo, "task", "completed-session", models.TaskSessionStateCompleted)
+
+			taskRepo := newMockTaskRepo()
+			taskRepo.tasks["task"] = &v1.Task{
+				ID: "task", Title: "Build a canvas", Description: "Build the requested app",
+				State: v1.TaskStateInProgress,
+			}
+			var dispatchedPrompt string
+			agentMgr := &mockAgentManager{
+				launchAgentFunc: func(_ context.Context, req *executor.LaunchAgentRequest) (*executor.LaunchAgentResponse, error) {
+					dispatchedPrompt = req.TaskDescription
+					return &executor.LaunchAgentResponse{AgentExecutionID: "exec-1"}, nil
+				},
+			}
+			svc := createTestServiceWithScheduler(repo, newMockStepGetter(), taskRepo, agentMgr)
+			svc.SetCanvasesEnabled(tt.canvases)
+			messages := &mockMessageCreator{}
+			svc.messageCreator = messages
+
+			_, err := svc.StartTask(
+				ctx, "task", "profile-1", "", "", "", "Build the requested app",
+				"", false, false, nil,
+			)
+			require.NoError(t, err)
+			require.Len(t, messages.userMessages, 1)
+			if tt.wantCanvas {
+				assertCanvasPrompt(t, messages.userMessages[0].content)
+				assertCanvasPrompt(t, dispatchedPrompt)
+			} else {
+				assert.NotContains(t, messages.userMessages[0].content, "create_canvas_kandev")
+				assert.NotContains(t, dispatchedPrompt, "create_canvas_kandev")
+			}
+			assert.Contains(t, messages.userMessages[0].content, "Build the requested app")
+			assert.Contains(t, dispatchedPrompt, "Build the requested app")
+		})
+	}
+}
+
+func countSystemBlocks(prompt string) int {
+	return strings.Count(prompt, sysprompt.TagStart)
+}
+
+func assertCanvasPrompt(t *testing.T, prompt string) {
+	t.Helper()
+	for _, tool := range []string{
+		"create_canvas_kandev",
+		"read_canvas_authoring_skill_kandev",
+		"publish_canvas_kandev",
+	} {
+		assert.Contains(t, prompt, tool)
+	}
+}

apps/backend/internal/orchestrator/event_handlers_workflow.go

@@ -4354,32 +4354,39 @@ func (s *Service) resolveAutoStartPromptContext(
 	ctx context.Context,
 	taskID string,
 	session *models.TaskSession,
-) (bool, *models.Task, bool, error) {
+) (bool, *models.Task, bool, bool, error) {
 	isOfficeTask, err := s.lookupOfficeTask(ctx, taskID)
 	if err != nil {
-		return false, nil, false, fmt.Errorf("resolve MCP mode for workflow auto-start: %w", err)
+		return false, nil, false, false, fmt.Errorf("resolve MCP mode for workflow auto-start: %w", err)
 	}
 	if isOfficeTask {
-		return true, nil, false, nil
+		return true, nil, false, false, nil
 	}
 
 	taskForPrompt, err := s.repo.GetTask(ctx, taskID)
 	if err != nil {
-		return false, nil, false, fmt.Errorf("load task for autopilot prompt: %w", err)
+		return false, nil, false, false, fmt.Errorf("load task for autopilot prompt: %w", err)
+	}
+	configMode, _ := session.Metadata["config_mode"].(bool)
+	includeCanvasGuidance := false
+	if !session.IsPassthrough && !configMode {
+		includeCanvasGuidance, err = s.taskSessionCanvasGuidanceEnabled(ctx, taskID, session, true)
+		if err != nil {
+			return false, nil, false, false, fmt.Errorf("resolve canvas prompt capability for workflow auto-start: %w", err)
+		}
 	}
 	if session.State != models.TaskSessionStateCreated {
-		return false, taskForPrompt, false, nil
+		return false, taskForPrompt, false, includeCanvasGuidance, nil
 	}
 
-	configMode, _ := session.Metadata["config_mode"].(bool)
 	if configMode {
-		return false, taskForPrompt, false, nil
+		return false, taskForPrompt, false, includeCanvasGuidance, nil
 	}
 	titleOwner, err := s.ClaimTaskTitleSession(ctx, taskID, session.ID)
 	if err != nil {
-		return false, nil, false, fmt.Errorf("claim task title for workflow auto-start: %w", err)
+		return false, nil, false, false, fmt.Errorf("claim task title for workflow auto-start: %w", err)
 	}
-	return false, taskForPrompt, titleOwner, nil
+	return false, taskForPrompt, titleOwner, includeCanvasGuidance, nil
 }
 
 // handleCreatedAutoStartLaunchFailure preserves a workflow prompt when the
@@ -4507,12 +4514,13 @@ func (s *Service) autoStartStepPrompt(
 	dispatchPrompt := agentPrompt
 	titleOwner := false
 	isOfficeTask := false
+	includeCanvasGuidance := false
 	var taskForPrompt *models.Task
 	needsRuntimeContext := session.State == models.TaskSessionStateCreated ||
 		(step != nil && step.HasOnEnterAction(wfmodels.OnEnterResetAgentContext))
 	if needsRuntimeContext {
 		var contextErr error
-		isOfficeTask, taskForPrompt, titleOwner, contextErr = s.resolveAutoStartPromptContext(ctx, taskID, session)
+		isOfficeTask, taskForPrompt, titleOwner, includeCanvasGuidance, contextErr = s.resolveAutoStartPromptContext(ctx, taskID, session)
 		if contextErr != nil {
 			requeueTaken()
 			return contextErr
@@ -4545,6 +4553,7 @@ func (s *Service) autoStartStepPrompt(
 				RequiresCompletionSignal:       requiresSignal,
 				IncludeCoordinatorTaskControls: !configMode,
 				IncludeTaskTitleTool:           !configMode && titleOwner,
+				IncludeCanvasGuidance:          includeCanvasGuidance,
 				Autopilot:                      taskForPrompt != nil && taskForPrompt.Autopilot,
 				IncludeUserQuestionTool:        taskForPrompt == nil || !taskForPrompt.Autopilot,
 				IncludeParentQuestionTool:      taskForPrompt != nil && taskForPrompt.Autopilot && taskForPrompt.ParentID != "",
@@ -4553,6 +4562,7 @@ func (s *Service) autoStartStepPrompt(
 				RequiresCompletionSignal:       requiresSignal,
 				IncludeCoordinatorTaskControls: !configMode,
 				IncludeTaskTitleTool:           !configMode && titleOwner,
+				IncludeCanvasGuidance:          includeCanvasGuidance,
 				Autopilot:                      taskForPrompt != nil && taskForPrompt.Autopilot,
 				IncludeUserQuestionTool:        taskForPrompt == nil || !taskForPrompt.Autopilot,
 				IncludeParentQuestionTool:      taskForPrompt != nil && taskForPrompt.Autopilot && taskForPrompt.ParentID != "",

apps/backend/internal/orchestrator/event_handlers_workflow_profile_test.go

@@ -277,6 +277,7 @@ func TestAutoStartStepPrompt_ResetContextInjectsCompletionContractForReusedSessi
 	agentMgr := &mockAgentManager{repoForExecutionLookup: repo, isAgentRunning: true}
 	messages := &mockMessageCreator{}
 	svc := createTestServiceWithScheduler(repo, stepGetter, newMockTaskRepo(), agentMgr)
+	svc.SetCanvasesEnabled(true)
 	svc.messageCreator = messages
 	err = svc.autoStartStepPrompt(ctx, "task-reused", session, step, "Review the change", false, false, nil)
 	if err != nil {
@@ -288,6 +289,17 @@ func TestAutoStartStepPrompt_ResetContextInjectsCompletionContractForReusedSessi
 	if len(agentMgr.capturedPromptCalls) != 1 || !strings.Contains(agentMgr.capturedPromptCalls[0].Prompt, "step_complete_kandev") {
 		t.Fatalf("executor prompt lacks completion contract: %#v", agentMgr.capturedPromptCalls)
 	}
+	for _, prompt := range []string{messages.userMessages[0].content, agentMgr.capturedPromptCalls[0].Prompt} {
+		for _, tool := range []string{
+			"create_canvas_kandev",
+			"read_canvas_authoring_skill_kandev",
+			"publish_canvas_kandev",
+		} {
+			if !strings.Contains(prompt, tool) {
+				t.Fatalf("reset-context prompt lacks %s: %s", tool, prompt)
+			}
+		}
+	}
 	if !strings.Contains(messages.userMessages[0].content, "ask_parent_question_kandev") || strings.Contains(messages.userMessages[0].content, "ask_user_question_kandev") {
 		t.Fatalf("reused autopilot prompt has the wrong question contract: %s", messages.userMessages[0].content)
 	}
@@ -330,6 +342,9 @@ func TestAutoStartStepPrompt_ResetContextPreservesOfficeModeForReusedSession(t *
 	if !strings.Contains(messages.userMessages[0].content, "KANDEV OFFICE MCP TOOLS") || strings.Contains(messages.userMessages[0].content, "list_workspaces_kandev") {
 		t.Fatalf("reused Office prompt has the wrong tool contract: %s", messages.userMessages[0].content)
 	}
+	if strings.Contains(messages.userMessages[0].content, "create_canvas_kandev") {
+		t.Fatalf("reused Office prompt must not advertise canvas authoring: %s", messages.userMessages[0].content)
+	}
 }
 func TestResolveStepAgentProfile(t *testing.T) {
 	t.Run("returns step profile when set", func(t *testing.T) {

apps/backend/internal/orchestrator/executor/executor_execute.go

@@ -101,6 +101,19 @@ func (e *Executor) resolveTaskSessionMCPProfile(ctx context.Context, taskID stri
 	return e.withCanvasCapability(mcpprofile.New(surface, capabilities, nil)), nil
 }
 
+// ResolveTaskSessionMCPProfile returns the backend-owned MCP profile that will
+// be sent to a session launch. Prompt producers use this read-only view so
+// optional guidance follows the same surface and capability resolver as the
+// runtime MCP server.
+func (e *Executor) ResolveTaskSessionMCPProfile(
+	ctx context.Context,
+	taskID string,
+	session *models.TaskSession,
+	allowTitleTool bool,
+) (mcpprofile.Context, error) {
+	return e.resolveTaskSessionMCPProfile(ctx, taskID, session, allowTitleTool)
+}
+
 func (e *Executor) withCanvasCapability(profile mcpprofile.Context) mcpprofile.Context {
 	if e != nil && e.canvasesEnabled && profile.Surface == mcpprofile.SurfaceKanbanTask {
 		return profile.WithCapability(mcpprofile.CapabilityCanvas)

apps/backend/internal/orchestrator/executor/executor_mcp_mode_test.go

@@ -114,6 +114,64 @@ func TestResolveTaskSessionMCPProfile_SelectsSurfaceAndQuestionCapability(t *tes
 	}
 }
 
+func TestResolveTaskSessionMCPProfile_CanvasCapabilityFollowsFeatureAndSurface(t *testing.T) {
+	tests := []struct {
+		name          string
+		task          *models.Task
+		expectCanvas  bool
+		expectSurface mcpprofile.Surface
+	}{
+		{
+			name:          "kanban task",
+			task:          &models.Task{ID: "task-kanban"},
+			expectCanvas:  true,
+			expectSurface: mcpprofile.SurfaceKanbanTask,
+		},
+		{
+			name:          "office task",
+			task:          &models.Task{ID: "task-office", IsFromOffice: true},
+			expectCanvas:  false,
+			expectSurface: mcpprofile.SurfaceOfficeTask,
+		},
+		{
+			name:          "configuration session",
+			task:          &models.Task{ID: "task-config"},
+			expectCanvas:  false,
+			expectSurface: mcpprofile.SurfaceConfiguration,
+		},
+		{
+			name:          "automation task",
+			task:          &models.Task{ID: "task-automation", Origin: models.TaskOriginAutomationRun},
+			expectCanvas:  false,
+			expectSurface: mcpprofile.SurfaceAutomation,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			repo := newMockRepository()
+			session := &models.TaskSession{ID: "session", TaskID: tt.task.ID}
+			if tt.expectSurface == mcpprofile.SurfaceConfiguration {
+				session.Metadata = map[string]interface{}{"config_mode": true}
+			}
+			repo.tasks[tt.task.ID] = tt.task
+			repo.sessions[session.ID] = session
+			exec := newTestExecutor(t, &mockAgentManager{}, repo)
+			exec.SetCanvasesEnabled(true)
+
+			profile, err := exec.ResolveTaskSessionMCPProfile(context.Background(), tt.task.ID, session, true)
+			require.NoError(t, err)
+			require.Equal(t, tt.expectSurface, profile.Surface)
+			require.Equal(t, tt.expectCanvas, profile.HasCapability(mcpprofile.CapabilityCanvas))
+
+			exec.SetCanvasesEnabled(false)
+			profile, err = exec.ResolveTaskSessionMCPProfile(context.Background(), tt.task.ID, session, true)
+			require.NoError(t, err)
+			require.False(t, profile.HasCapability(mcpprofile.CapabilityCanvas))
+		})
+	}
+}
+
 func TestResolveTaskSessionMCPMode_TitlePendingIsTaskModeVariant(t *testing.T) {
 	ctx := context.Background()
 	repo := newMockRepository()

apps/backend/internal/orchestrator/service.go

@@ -28,6 +28,7 @@ import (
 	"github.com/kandev/kandev/internal/common/logger"
 	"github.com/kandev/kandev/internal/events"
 	"github.com/kandev/kandev/internal/events/bus"
+	mcpprofile "github.com/kandev/kandev/internal/mcp/profile"
 	"github.com/kandev/kandev/internal/orchestrator/executor"
 	"github.com/kandev/kandev/internal/orchestrator/messagequeue"
 	"github.com/kandev/kandev/internal/orchestrator/queue"
@@ -281,6 +282,23 @@ type DirectPromptStarter interface {
 	) (*executor.TaskExecution, error)
 }
 
+// DirectPromptStarterWithCanvasGuidance starts a prepared direct-message
+// session with the server-resolved canvas projection that was used before the
+// message was persisted. The projection is deliberately separate from the
+// prompt text so a second canonicalization cannot independently re-resolve a
+// different capability state.
+type DirectPromptStarterWithCanvasGuidance interface {
+	StartCreatedSessionWithPromptContextAndCanvasGuidance(
+		ctx context.Context,
+		taskID, sessionID, agentProfileID, prompt string,
+		skipMessageRecord, planMode, autoStart bool,
+		attachments []v1.MessageAttachment,
+		references []v1.EntityReference,
+		promptReferenceContext string,
+		canvasGuidanceResolved, includeCanvasGuidance bool,
+	) (*executor.TaskExecution, error)
+}
+
 // repoStore is the repository interface accepted by NewService.
 // It covers both the orchestrator's own needs (sessionExecutorStore) and
 // the executor package's needs (executor.executorStore).
@@ -1706,6 +1724,40 @@ func (s *Service) SetCanvasesEnabled(enabled bool) {
 	}
 }
 
+// TaskSessionCanvasGuidanceEnabled reports whether the resolved MCP profile for
+// a session includes canvas authoring. It is the narrow read-only seam used by
+// message handlers before they persist the first prompt.
+func (s *Service) TaskSessionCanvasGuidanceEnabled(ctx context.Context, taskID, sessionID string) (bool, error) {
+	if err := s.authorizeTaskSessionPair(ctx, taskID, sessionID); err != nil {
+		return false, err
+	}
+	session, err := s.repo.GetTaskSession(ctx, sessionID)
+	if err != nil {
+		return false, err
+	}
+	return s.taskSessionCanvasGuidanceEnabled(ctx, taskID, session, true)
+}
+
+// ErrTaskSessionPairMismatch reports that a task/session API request named
+// two rows that do not belong together.
+var ErrTaskSessionPairMismatch = errors.New("task session pair mismatch")
+
+func (s *Service) taskSessionCanvasGuidanceEnabled(
+	ctx context.Context,
+	taskID string,
+	session *models.TaskSession,
+	allowTitleTool bool,
+) (bool, error) {
+	if s.executor == nil || session == nil {
+		return false, nil
+	}
+	profile, err := s.executor.ResolveTaskSessionMCPProfile(ctx, taskID, session, allowTitleTool)
+	if err != nil {
+		return false, err
+	}
+	return profile.HasCapability(mcpprofile.CapabilityCanvas), nil
+}
+
 // SetLaunchAttachmentClaimer wires staged-descriptor admission into the
 // unified session launch boundary.
 func (s *Service) SetLaunchAttachmentClaimer(claimer LaunchAttachmentClaimer) {
@@ -1906,7 +1958,7 @@ func (s *Service) authorizeTaskSessionPair(ctx context.Context, taskID, sessionI
 		return nil //nolint:nilerr // both IDs authorized; consistency is best-effort
 	}
 	if session.TaskID != taskID {
-		return fmt.Errorf("session %s does not belong to task %s", sessionID, taskID)
+		return fmt.Errorf("%w: session %s does not belong to task %s", ErrTaskSessionPairMismatch, sessionID, taskID)
 	}
 	return nil
 }

apps/backend/internal/orchestrator/task_operations.go

@@ -498,6 +498,29 @@ func (s *Service) StartCreatedSessionWithPromptContext(
 	)
 }
 
+// StartCreatedSessionWithPromptContextAndCanvasGuidance starts a prepared
+// direct-message session with the exact server-side canvas capability decision
+// made while the user message was admitted. This prevents the launch-time
+// canonicalizer from producing a prompt that differs from the persisted row.
+func (s *Service) StartCreatedSessionWithPromptContextAndCanvasGuidance(
+	ctx context.Context,
+	taskID, sessionID, agentProfileID, prompt string,
+	skipMessageRecord, planMode, autoStart bool,
+	attachments []v1.MessageAttachment,
+	references []v1.EntityReference,
+	promptReferenceContext string,
+	canvasGuidanceResolved, includeCanvasGuidance bool,
+) (*executor.TaskExecution, error) {
+	return s.startCreatedSession(
+		ctx, taskID, sessionID, agentProfileID, prompt,
+		skipMessageRecord, planMode, autoStart, attachments, references, promptReferenceContext,
+		startCreatedSessionOptions{
+			canvasGuidanceResolved: canvasGuidanceResolved,
+			includeCanvasGuidance:  includeCanvasGuidance,
+		},
+	)
+}
+
 // startCreatedSessionWithComposedPrompt launches a prepared session from an
 // auto-start path whose prompt was already composed and recorded by the
 // orchestrator. The ordinary public entry point intentionally applies the
@@ -527,6 +550,11 @@ type startCreatedSessionOptions struct {
 	skipTaskDescriptionFallback bool
 	promptAlreadyComposed       bool
 	retryPrompt                 string
+	// canvasGuidanceResolved carries the server-side capability projection
+	// from message admission. When false, this launch resolves the capability
+	// locally because no earlier producer has made a trusted decision.
+	canvasGuidanceResolved bool
+	includeCanvasGuidance  bool
 }
 
 //nolint:cyclop,funlen,gocognit // Existing complexity inherited from session-lifecycle handling.
@@ -739,10 +767,21 @@ func (s *Service) startCreatedSession(
 	// Passthrough profiles skip the wrap: the prompt is typed straight into the
 	// agent CLI's TTY and the user sees it verbatim — they don't want a wall of
 	// MCP-tool boilerplate prepended to "hello".
+	includeCanvasGuidance := false
+	if (effectivePrompt != "" || len(attachments) > 0) && !isOfficeTask && !session.IsPassthrough && !configMode {
+		if options.canvasGuidanceResolved {
+			includeCanvasGuidance = options.includeCanvasGuidance
+		} else {
+			includeCanvasGuidance, err = s.taskSessionCanvasGuidanceEnabled(ctx, taskID, session, true)
+			if err != nil {
+				return nil, fmt.Errorf("failed to resolve canvas prompt capability: %w", err)
+			}
+		}
+	}
 	if effectivePrompt != "" || len(attachments) > 0 {
 		effectivePrompt = s.wrapCreatedSessionPrompt(
 			ctx, effectivePrompt, taskID, sessionID, session, dbTask,
-			isOfficeTask, configMode, titleOwner, references, promptReferenceContext,
+			isOfficeTask, configMode, titleOwner, includeCanvasGuidance, references, promptReferenceContext,
 		)
 	}
 
@@ -795,7 +834,7 @@ func (s *Service) wrapCreatedSessionPrompt(
 	prompt, taskID, sessionID string,
 	session *models.TaskSession,
 	dbTask *models.Task,
-	isOfficeTask, configMode, titleOwner bool,
+	isOfficeTask, configMode, titleOwner, includeCanvasGuidance bool,
 	references []v1.EntityReference,
 	promptReferenceContext string,
 ) string {
@@ -820,6 +859,7 @@ func (s *Service) wrapCreatedSessionPrompt(
 			RequiresCompletionSignal:       s.WorkflowStepRequiresCompletionSignal(ctx, dbTask.WorkflowStepID),
 			IncludeCoordinatorTaskControls: !configMode,
 			IncludeTaskTitleTool:           !configMode && titleOwner,
+			IncludeCanvasGuidance:          includeCanvasGuidance,
 			Autopilot:                      dbTask.Autopilot,
 			IncludeUserQuestionTool:        !dbTask.Autopilot && !session.IsPassthrough,
 			IncludeParentQuestionTool:      dbTask.Autopilot && dbTask.ParentID != "",
@@ -1267,6 +1307,13 @@ func (s *Service) startTask(ctx context.Context, taskID string, agentProfileID s
 	// directly is wrong because it can be empty on manual user-initiated starts
 	// while the task is already bound to a signal-gated step in the DB.
 	if effectivePrompt != "" || len(attachments) > 0 {
+		includeCanvasGuidance := false
+		if !isOfficeTask && !skipKandevMCPWrap && !configMode {
+			includeCanvasGuidance, err = s.taskSessionCanvasGuidanceEnabled(ctx, task.ID, launchSession, true)
+			if err != nil {
+				return nil, fmt.Errorf("failed to resolve canvas prompt capability: %w", err)
+			}
+		}
 		effectivePrompt = s.applyLaunchPromptContext(ctx, launchPromptContext{
 			prompt:                    effectivePrompt,
 			taskID:                    task.ID,
@@ -1276,6 +1323,7 @@ func (s *Service) startTask(ctx context.Context, taskID string, agentProfileID s
 			configMode:                configMode,
 			referenceContext:          promptReferenceContext,
 			includeTaskTitleTool:      !configMode && titleOwner,
+			includeCanvasGuidance:     includeCanvasGuidance,
 			autopilot:                 task.Autopilot,
 			includeParentQuestionTool: task.Autopilot && task.ParentID != "",
 			spawnOrigin:               opts.SpawnOrigin,
@@ -1365,6 +1413,7 @@ type launchPromptContext struct {
 	isPassthrough             bool
 	configMode                bool
 	includeTaskTitleTool      bool
+	includeCanvasGuidance     bool
 	autopilot                 bool
 	includeParentQuestionTool bool
 	referenceContext          string
@@ -1405,6 +1454,7 @@ func (s *Service) applyLaunchPromptContext(ctx context.Context, p launchPromptCo
 		RequiresCompletionSignal:       s.StepRequiresCompletionSignal(ctx, p.taskID),
 		IncludeCoordinatorTaskControls: !p.configMode,
 		IncludeTaskTitleTool:           p.includeTaskTitleTool,
+		IncludeCanvasGuidance:          p.includeCanvasGuidance,
 		Autopilot:                      p.autopilot,
 		IncludeUserQuestionTool:        !p.autopilot && !p.isPassthrough,
 		IncludeParentQuestionTool:      p.autopilot && p.includeParentQuestionTool,

apps/backend/internal/orchestrator/task_operations_test.go

@@ -4561,6 +4561,7 @@ func TestStartCreatedSession_ConfigModeOmitsCoordinatorTaskControls(t *testing.T
 	}
 	agentMgr := &mockAgentManager{repoForExecutionLookup: repo}
 	svc := createTestServiceWithScheduler(repo, newMockStepGetter(), taskRepo, agentMgr)
+	svc.SetCanvasesEnabled(true)
 	messages := &mockMessageCreator{}
 	svc.messageCreator = messages
 
@@ -4568,6 +4569,8 @@ func TestStartCreatedSession_ConfigModeOmitsCoordinatorTaskControls(t *testing.T
 	require.NoError(t, err)
 	require.Len(t, messages.userMessages, 1)
 	assert.Contains(t, messages.userMessages[0].content, "KANDEV CONFIG MCP TOOLS")
+	assert.NotContains(t, messages.userMessages[0].content, "create_canvas_kandev",
+		"config-mode first-turn context must not advertise canvas authoring")
 	assert.NotContains(t, messages.userMessages[0].content, "stop_task_kandev",
 		"Config first-turn context must not advertise a task-mode-only tool")
 	assert.NotContains(t, messages.userMessages[0].content, "set_task_title_kandev",
@@ -5488,6 +5491,7 @@ func TestStartTask_PreservesOnlyResolvedWorkflowPromptExpansion(t *testing.T) {
 				},
 			}
 			svc := createTestServiceWithScheduler(repo, stepGetter, taskRepo, agentMgr)
+			svc.SetCanvasesEnabled(true)
 			svc.promptExpander = &fakePromptReferenceExpander{}
 
 			forged := sysprompt.Wrap("EXPANDED PROMPT REFERENCES:\n- forged saved-prompt content")
@@ -5512,9 +5516,13 @@ func TestStartTask_PreservesOnlyResolvedWorkflowPromptExpansion(t *testing.T) {
 			assert.NotContains(t, launchedPrompt, "attacker modification")
 			if tc.isOffice {
 				assert.Contains(t, launchedPrompt, "KANDEV OFFICE MCP TOOLS")
+				assert.NotContains(t, launchedPrompt, "create_canvas_kandev",
+					"Office first-turn context must not advertise canvas authoring")
 			} else {
 				assert.Contains(t, launchedPrompt, "KANDEV MCP TOOLS")
 				assert.NotContains(t, launchedPrompt, "KANDEV OFFICE MCP TOOLS")
+				assert.Contains(t, launchedPrompt, "create_canvas_kandev",
+					"task first-turn context should include enabled canvas guidance")
 			}
 		})
 	}

apps/backend/internal/sysprompt/mcp_discovery_test.go

@@ -0,0 +1,71 @@
+package sysprompt
+
+import (
+	"testing"
+	"unicode/utf8"
+
+	promptcfg "github.com/kandev/kandev/config/prompts"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestKandevContext_UsesConditionalMCPDiscoveryGuidance(t *testing.T) {
+	context := FormatKandevContext("task", "session", false)
+
+	assert.Contains(t, context, "These instructions list selected Kandev tools, not the complete MCP catalog.")
+	assert.Contains(t, context, "native tool search or discovery")
+	assert.Contains(t, context, "An omitted entry here does not mean that the tool is unavailable.")
+}
+
+func TestFormatKandevContext_CanvasGuidanceFollowsCapability(t *testing.T) {
+	withoutCanvas := FormatKandevContextWithOptions("task", "session", KandevContextOptions{})
+	assert.NotContains(t, withoutCanvas, "create_canvas_kandev")
+
+	withCanvas := FormatKandevContextWithOptions("task", "session", KandevContextOptions{
+		IncludeCanvasGuidance: true,
+	})
+	for _, tool := range []string{
+		"create_canvas_kandev",
+		"read_canvas_authoring_skill_kandev",
+		"publish_canvas_kandev",
+	} {
+		assert.Contains(t, withCanvas, tool)
+	}
+	assert.Contains(t, withCanvas, "Use these tools only when the user explicitly asks for a Kandev canvas")
+	assert.Contains(t, withCanvas, "Create it in Kandev before writing app files.")
+	assert.Contains(t, withCanvas, "Report publication status, including failures.")
+	assert.Contains(t, withCanvas, "Local files or a successful build do not publish a canvas.")
+	assert.NotContains(t, withCanvas, "Create the draft in Kandev before writing application files.")
+	assert.Contains(t, withCanvas, "Get the schema and examples from tool discovery.")
+	assert.NotContains(t, withCanvas, `"chart_type":"bar"`)
+}
+
+func TestKandevContextTemplate_IsCompactEnoughForEveryTask(t *testing.T) {
+	template := promptcfg.Get("kandev-context")
+
+	require.LessOrEqual(t, len([]byte(template)), 2800)
+	assert.True(t, utf8.ValidString(template))
+}
+
+func TestKandevContext_RenderedSizesDeliverRecordedCompaction(t *testing.T) {
+	ordinary := FormatKandevContext("task", "session", false)
+	canvas := FormatKandevContextWithOptions("task", "session", KandevContextOptions{
+		IncludeCoordinatorTaskControls: true,
+		IncludeCanvasGuidance:          true,
+	})
+
+	const (
+		recordedOrdinaryPromptBytesBeforeCompaction = 4804
+		minimumRenderedReductionBytes               = 400
+	)
+	// This baseline is a recorded rendered prompt from before rich-output
+	// examples moved behind tool discovery. Keep the assertion on rendered
+	// bytes, not the reusable raw template, so interpolation cannot hide prompt
+	// growth or make a prompt-reduction claim from source-file size alone.
+	require.LessOrEqual(t, len([]byte(ordinary)), recordedOrdinaryPromptBytesBeforeCompaction-minimumRenderedReductionBytes)
+	assert.True(t, utf8.ValidString(ordinary))
+	assert.True(t, utf8.ValidString(canvas))
+	t.Logf("rendered prompt sizes: ordinary=%d bytes, canvas=%d bytes, baseline=%d bytes, reduction=%d bytes",
+		len([]byte(ordinary)), len([]byte(canvas)), recordedOrdinaryPromptBytesBeforeCompaction,
+		recordedOrdinaryPromptBytesBeforeCompaction-len([]byte(ordinary)))
+}

apps/backend/internal/sysprompt/sysprompt.go

@@ -217,6 +217,8 @@ func PlanMode() string { return prompts.Get("plan-mode") }
 func KandevContext() string {
 	return Resolve("kandev-context", map[string]string{
 		"coordinator_task_control_section": coordinatorTaskControlSection,
+		"canvas_guidance_section":          "",
+		"rich_output_section":              richOutputSection,
 		"task_title_section":               "",
 		"autopilot_section":                "",
 		"question_tool_section":            userQuestionSection,
@@ -233,6 +235,13 @@ const autopilotSection = `AUTOPILOT MODE:
 This task runs in autopilot mode. Continue independently and make reasonable decisions without asking the operator. Ask for help only when a decision is critical, unsafe, or cannot be inferred from the task context. If a direct parent exists, use the available parent-question tool for that critical question. The question tool ends the current turn, so do not make another tool call or continue working after you ask it. If there is no parent, do not ask a question; choose the safest reversible path and report the limitation in your final response.
 `
 
+const canvasGuidanceSection = `CANVAS AUTHORING:
+Use these tools only when the user explicitly asks for a Kandev canvas: create_canvas_kandev, read_canvas_authoring_skill_kandev, and publish_canvas_kandev. Create it in Kandev before writing app files. Read the skill once, edit only in its returned source directory, then publish through MCP. Report publication status, including failures. Local files or a successful build do not publish a canvas.
+`
+
+const richOutputSection = `- show_rich_output_kandev: For a chart, graph, plot, file preview, KPI, or metrics request with data, call this now. Do not implement it as ASCII, SVG, HTML, or another app. Otherwise use prose or a small Markdown table. Get the schema and examples from tool discovery. Paths are workspace-relative; Kandev owns layout, axes, legends, and tooltips. Label series with units.
+`
+
 // stepCompleteSection is the description + instruction block for the
 // step_complete_kandev MCP tool. Only injected when the current workflow step
 // has `auto_advance_requires_signal = true` (ADR 0015). Agents on legacy
@@ -292,6 +301,7 @@ type KandevContextOptions struct {
 	RequiresCompletionSignal       bool
 	IncludeCoordinatorTaskControls bool
 	IncludeTaskTitleTool           bool
+	IncludeCanvasGuidance          bool
 	Autopilot                      bool
 	IncludeUserQuestionTool        bool
 	IncludeParentQuestionTool      bool
@@ -335,12 +345,18 @@ func FormatKandevContextWithOptions(taskID, sessionID string, options KandevCont
 	if options.Autopilot {
 		autopilot = autopilotSection
 	}
+	canvasGuidance := ""
+	if options.IncludeCanvasGuidance {
+		canvasGuidance = canvasGuidanceSection
+	}
 	return Resolve("kandev-context", map[string]string{
 		"task_id":                          taskID,
 		"session_id":                       sessionID,
 		"step_complete_section":            section,
 		"task_title_section":               taskTitle,
 		"coordinator_task_control_section": coordinatorControls,
+		"canvas_guidance_section":          canvasGuidance,
+		"rich_output_section":              richOutputSection,
 		"autopilot_section":                autopilot,
 		"question_tool_section":            questionTool,
 	})

apps/backend/internal/task/handlers/message_handlers.go

@@ -53,6 +53,15 @@ type taskTitleSessionClaimer interface {
 	ClaimTaskTitleSession(ctx context.Context, taskID, sessionID string) (bool, error)
 }
 
+type taskCanvasGuidanceResolver interface {
+	TaskSessionCanvasGuidanceEnabled(ctx context.Context, taskID, sessionID string) (bool, error)
+}
+
+type canvasGuidanceProjection struct {
+	resolved bool
+	include  bool
+}
+
 // MessageHandlers handles WebSocket requests for messages
 type MessageHandlers struct {
 	service             *service.Service
@@ -153,6 +162,7 @@ func (h *MessageHandlers) injectMessageContext(
 	configMode bool,
 	startCreatedSession bool,
 	titleOwner bool,
+	includeCanvasGuidance bool,
 	content string,
 	trustedPromptContext string,
 ) string {
@@ -178,12 +188,24 @@ func (h *MessageHandlers) injectMessageContext(
 		RequiresCompletionSignal:       requiresSignal,
 		IncludeCoordinatorTaskControls: !configMode,
 		IncludeTaskTitleTool:           !configMode && titleOwner,
+		IncludeCanvasGuidance:          includeCanvasGuidance,
 		Autopilot:                      task.Autopilot,
 		IncludeUserQuestionTool:        !task.Autopilot && !sessionResp.Session.IsPassthrough,
 		IncludeParentQuestionTool:      task.Autopilot && task.ParentID != "",
 	}, referenceContext, trustedPromptContext, pullRequestTargetContext)
 }
 
+func (h *MessageHandlers) resolveCanvasGuidance(
+	ctx context.Context,
+	taskID, sessionID string,
+) (bool, error) {
+	resolver, ok := h.orchestrator.(taskCanvasGuidanceResolver)
+	if !ok {
+		return false, nil
+	}
+	return resolver.TaskSessionCanvasGuidanceEnabled(ctx, taskID, sessionID)
+}
+
 func (h *MessageHandlers) prepareDirectPrompt(
 	ctx context.Context,
 	content string,
@@ -429,6 +451,10 @@ type wsAddMessageRequest struct {
 	Attachments       []v1.MessageAttachment `json:"attachments,omitempty"`
 	ContextFiles      []v1.ContextFileMeta   `json:"context_files,omitempty"`
 	EntityReferences  []v1.EntityReference   `json:"entity_references,omitempty"`
+	// These fields are server-owned and are carried only from message admission
+	// to the created-session dispatch. They are intentionally not JSON fields.
+	canvasGuidanceResolved bool
+	includeCanvasGuidance  bool
 }
 
 // wsAddMessage handles an incoming add-message WebSocket action, persisting the user message and dispatching the turn and orchestrator flow.
@@ -593,10 +619,29 @@ func (h *MessageHandlers) wsAddMessage(ctx context.Context, msg *ws.Message) (*w
 		// "type in chat to start the agent" path. Wrap with the Kandev MCP
 		// system block before persisting so the DB row matches what the agent
 		// receives (and "Show formatted" reveals it).
+		includeCanvasGuidance := false
+		canvasGuidanceResolved := false
+		if task != nil && !task.IsFromOffice && !sessionResp.Session.IsPassthrough && !configMode {
+			canvasGuidanceResolved = true
+			var resolveErr error
+			includeCanvasGuidance, resolveErr = h.resolveCanvasGuidance(ctx, req.TaskID, req.TaskSessionID)
+			if resolveErr != nil {
+				if errors.Is(resolveErr, orchestrator.ErrTaskSessionPairMismatch) {
+					return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeValidation, "Task and session do not match", nil)
+				}
+				h.logger.Warn("failed to resolve canvas prompt capability; omitting optional guidance",
+					zap.String("task_id", req.TaskID),
+					zap.String("session_id", req.TaskSessionID),
+					zap.Error(resolveErr))
+				includeCanvasGuidance = false
+			}
+		}
 		storedContent = h.injectMessageContext(
-			ctx, req, sessionResp, task, configMode, startCreatedSession, titleOwner, storedContent,
+			ctx, req, sessionResp, task, configMode, startCreatedSession, titleOwner, includeCanvasGuidance, storedContent,
 			trustedPromptContext,
 		)
+		req.canvasGuidanceResolved = canvasGuidanceResolved
+		req.includeCanvasGuidance = includeCanvasGuidance
 	}
 	req.Content = storedContent
 	if err := h.service.ClaimMessageAttachments(ctx, req.TaskID, req.TaskSessionID, req.Attachments); err != nil {
@@ -865,7 +910,10 @@ func (h *MessageHandlers) dispatchPromptAsync(
 		h.forwardMessageAsPrompt(
 			promptCtx, taskID, sessionID, agentProfileID,
 			content, model, planMode, attachments, req.EntityReferences, isCreatedSession,
-			trustedPromptContext,
+			trustedPromptContext, canvasGuidanceProjection{
+				resolved: req.canvasGuidanceResolved,
+				include:  req.includeCanvasGuidance,
+			},
 		)
 	}()
 }
@@ -923,11 +971,22 @@ func (h *MessageHandlers) forwardMessageAsPrompt(
 	references []v1.EntityReference,
 	startCreated bool,
 	trustedPromptContext string,
+	canvasGuidance ...canvasGuidanceProjection,
 ) {
 	// For CREATED sessions, start the agent with this message as the initial prompt
 	if startCreated {
 		var err error
-		if starter, ok := h.orchestrator.(orchestrator.DirectPromptStarter); ok {
+		projection := canvasGuidanceProjection{}
+		if len(canvasGuidance) > 0 {
+			projection = canvasGuidance[0]
+		}
+		if starter, ok := h.orchestrator.(orchestrator.DirectPromptStarterWithCanvasGuidance); ok && len(canvasGuidance) > 0 {
+			_, err = starter.StartCreatedSessionWithPromptContextAndCanvasGuidance(
+				ctx, taskID, sessionID, agentProfileID,
+				content, true, planMode, false, attachments, references, trustedPromptContext,
+				projection.resolved, projection.include,
+			)
+		} else if starter, ok := h.orchestrator.(orchestrator.DirectPromptStarter); ok {
 			_, err = starter.StartCreatedSessionWithPromptContext(
 				ctx, taskID, sessionID, agentProfileID,
 				content, true, planMode, false, attachments, references, trustedPromptContext,

apps/backend/internal/task/handlers/message_handlers_saved_prompt_test.go

@@ -2,6 +2,7 @@ package handlers
 
 import (
 	"context"
+	"errors"
 	"strings"
 	"testing"
 	"testing/synctest"
@@ -16,6 +17,7 @@ import (
 	"github.com/kandev/kandev/internal/task/service"
 	v1 "github.com/kandev/kandev/pkg/api/v1"
 	ws "github.com/kandev/kandev/pkg/websocket"
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
@@ -32,16 +34,27 @@ const savedPromptTrustedContext = "EXPANDED PROMPT REFERENCES: current trusted s
 
 type savedPromptDeliveryOrchestrator struct {
 	firstTurnCaptureOrchestrator
-	preparedPrompt      string
-	preparedPassthrough bool
-	prepareCalls        int
-	dispatched          chan string
-	started             chan savedPromptStarted
+	preparedPrompt              string
+	preparedPassthrough         bool
+	prepareCalls                int
+	skipPromptPreparation       bool
+	canvasGuidanceResults       []canvasGuidanceResult
+	canvasGuidanceCalls         int
+	independentlyResolvesCanvas bool
+	dispatched                  chan string
+	started                     chan savedPromptStarted
+}
+
+type canvasGuidanceResult struct {
+	enabled bool
+	err     error
 }
 
 type savedPromptStarted struct {
 	prompt                 string
 	promptReferenceContext string
+	canvasGuidanceResolved bool
+	includeCanvasGuidance  bool
 }
 
 func (o *savedPromptDeliveryOrchestrator) PrepareDirectPrompt(
@@ -52,9 +65,24 @@ func (o *savedPromptDeliveryOrchestrator) PrepareDirectPrompt(
 	o.prepareCalls++
 	o.preparedPrompt = prompt
 	o.preparedPassthrough = isPassthrough
+	if o.skipPromptPreparation {
+		return prompt, ""
+	}
 	return prompt + "\n\n" + sysprompt.Wrap(savedPromptTrustedContext), savedPromptTrustedContext
 }
 
+func (o *savedPromptDeliveryOrchestrator) TaskSessionCanvasGuidanceEnabled(
+	context.Context, string, string,
+) (bool, error) {
+	index := o.canvasGuidanceCalls
+	o.canvasGuidanceCalls++
+	if index >= len(o.canvasGuidanceResults) {
+		return false, nil
+	}
+	result := o.canvasGuidanceResults[index]
+	return result.enabled, result.err
+}
+
 func (o *savedPromptDeliveryOrchestrator) PromptTask(
 	_ context.Context,
 	_, _, content, _ string,
@@ -67,16 +95,40 @@ func (o *savedPromptDeliveryOrchestrator) PromptTask(
 }
 
 func (o *savedPromptDeliveryOrchestrator) StartCreatedSessionWithPromptContext(
+	ctx context.Context,
+	taskID, sessionID, _ string, prompt string,
+	_, _, _ bool,
+	_ []v1.MessageAttachment,
+	_ []v1.EntityReference,
+	promptReferenceContext string,
+) (*executor.TaskExecution, error) {
+	if o.independentlyResolvesCanvas {
+		includeCanvasGuidance, resolveErr := o.TaskSessionCanvasGuidanceEnabled(ctx, taskID, sessionID)
+		if resolveErr == nil && includeCanvasGuidance {
+			prompt = sysprompt.InjectKandevContext(taskID, sessionID, prompt, false)
+		}
+	}
+	o.started <- savedPromptStarted{
+		prompt:                 prompt,
+		promptReferenceContext: promptReferenceContext,
+	}
+	return &executor.TaskExecution{}, nil
+}
+
+func (o *savedPromptDeliveryOrchestrator) StartCreatedSessionWithPromptContextAndCanvasGuidance(
 	_ context.Context,
 	_, _, _, prompt string,
 	_, _, _ bool,
 	_ []v1.MessageAttachment,
 	_ []v1.EntityReference,
 	promptReferenceContext string,
+	canvasGuidanceResolved, includeCanvasGuidance bool,
 ) (*executor.TaskExecution, error) {
 	o.started <- savedPromptStarted{
 		prompt:                 prompt,
 		promptReferenceContext: promptReferenceContext,
+		canvasGuidanceResolved: canvasGuidanceResolved,
+		includeCanvasGuidance:  includeCanvasGuidance,
 	}
 	return &executor.TaskExecution{}, nil
 }
@@ -157,6 +209,167 @@ func TestWSAddMessage_PreparesSavedPromptBeforePersistenceAndDispatch(t *testing
 	})
 }
 
+// @covers AC-AGENTS-MCP-DISCOVERY-002.4
+func TestWSAddMessage_CanvasGuidanceUsesOneResolutionForSavedAndDispatchedPrompt(t *testing.T) {
+	synctest.Test(t, func(t *testing.T) {
+		now := time.Now().UTC()
+		repo := &messageAddSwitchRepo{
+			tasks: map[string]*models.Task{
+				"task-quick": {
+					ID: "task-quick", WorkspaceID: "workspace-1", State: v1.TaskStateInProgress,
+					IsEphemeral: true, UpdatedAt: now,
+				},
+			},
+			sessions: map[string]*models.TaskSession{
+				"session-1": {
+					ID: "session-1", TaskID: "task-quick", State: models.TaskSessionStateCreated,
+					AgentProfileID: "profile-1", UpdatedAt: now,
+				},
+			},
+			primaryID: "session-1",
+		}
+		log, err := logger.NewLogger(logger.LoggingConfig{Level: "error", Format: "json"})
+		require.NoError(t, err)
+		svc := service.NewService(service.Repos{
+			Workspaces: repo, Tasks: repo, TaskRepos: repo,
+			Workflows: repo, Messages: repo, Turns: repo,
+			Sessions: repo, GitSnapshots: repo, RepoEntities: repo,
+			Executors: repo, Environments: repo, TaskEnvironments: repo,
+			Reviews: repo,
+		}, nil, log, service.RepositoryDiscoveryConfig{})
+		orch := &savedPromptDeliveryOrchestrator{
+			started:                     make(chan savedPromptStarted, 1),
+			skipPromptPreparation:       true,
+			independentlyResolvesCanvas: true,
+			canvasGuidanceResults: []canvasGuidanceResult{
+				{err: errors.New("capability lookup temporarily unavailable")},
+				{enabled: true},
+			},
+		}
+		h := NewMessageHandlers(svc, orch, log)
+
+		req, err := ws.NewRequest("canvas-recovery", ws.ActionMessageAdd, map[string]interface{}{
+			"task_id": "task-quick", "session_id": "session-1", "content": "Build the app",
+		})
+		require.NoError(t, err)
+		resp, err := h.wsAddMessage(context.Background(), req)
+		require.NoError(t, err)
+		require.Equal(t, ws.MessageTypeResponse, resp.Type)
+		require.Len(t, repo.messages, 1)
+
+		synctest.Wait()
+		started := <-orch.started
+		stored := repo.messages[0].Content
+		assert.Equal(t, stored, started.prompt)
+		assert.NotContains(t, stored, "create_canvas_kandev")
+		assert.True(t, started.canvasGuidanceResolved)
+		assert.False(t, started.includeCanvasGuidance)
+		assert.Equal(t, 1, orch.canvasGuidanceCalls,
+			"the launch must use the handler's failed resolution instead of retrying")
+	})
+}
+
+// @covers AC-AGENTS-MCP-DISCOVERY-002.3
+func TestWSAddMessage_CanvasGuidanceResolverControlsSavedPrompt(t *testing.T) {
+	for _, tt := range []struct {
+		name       string
+		result     canvasGuidanceResult
+		wantCanvas bool
+	}{
+		{name: "enabled", result: canvasGuidanceResult{enabled: true}, wantCanvas: true},
+		{name: "disabled", result: canvasGuidanceResult{}, wantCanvas: false},
+		{name: "lookup failure falls back", result: canvasGuidanceResult{err: errors.New("lookup failed")}, wantCanvas: false},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			synctest.Test(t, func(t *testing.T) {
+				now := time.Now().UTC()
+				repo := &messageAddSwitchRepo{
+					tasks: map[string]*models.Task{"task-quick": {
+						ID: "task-quick", WorkspaceID: "workspace-1", State: v1.TaskStateInProgress,
+						IsEphemeral: true, UpdatedAt: now,
+					}},
+					sessions: map[string]*models.TaskSession{"session-1": {
+						ID: "session-1", TaskID: "task-quick", State: models.TaskSessionStateCreated,
+						AgentProfileID: "profile-1", UpdatedAt: now,
+					}},
+					primaryID: "session-1",
+				}
+				log, err := logger.NewLogger(logger.LoggingConfig{Level: "error", Format: "json"})
+				require.NoError(t, err)
+				svc := service.NewService(service.Repos{
+					Workspaces: repo, Tasks: repo, TaskRepos: repo,
+					Workflows: repo, Messages: repo, Turns: repo,
+					Sessions: repo, GitSnapshots: repo, RepoEntities: repo,
+					Executors: repo, Environments: repo, TaskEnvironments: repo,
+					Reviews: repo,
+				}, nil, log, service.RepositoryDiscoveryConfig{})
+				orch := &savedPromptDeliveryOrchestrator{
+					started:               make(chan savedPromptStarted, 1),
+					skipPromptPreparation: true,
+					canvasGuidanceResults: []canvasGuidanceResult{tt.result},
+				}
+				h := NewMessageHandlers(svc, orch, log)
+
+				req, err := ws.NewRequest("canvas-"+tt.name, ws.ActionMessageAdd, map[string]interface{}{
+					"task_id": "task-quick", "session_id": "session-1", "content": "Build the app",
+				})
+				require.NoError(t, err)
+				resp, err := h.wsAddMessage(context.Background(), req)
+				require.NoError(t, err)
+				require.Equal(t, ws.MessageTypeResponse, resp.Type)
+				require.Len(t, repo.messages, 1)
+
+				synctest.Wait()
+				started := <-orch.started
+				stored := repo.messages[0].Content
+				assert.Equal(t, stored, started.prompt)
+				assert.Equal(t, tt.wantCanvas, strings.Contains(stored, "create_canvas_kandev"))
+				assert.True(t, started.canvasGuidanceResolved)
+				assert.Equal(t, tt.wantCanvas, started.includeCanvasGuidance)
+				assert.Equal(t, 1, orch.canvasGuidanceCalls)
+			})
+		})
+	}
+}
+
+// @covers AC-AGENTS-MCP-DISCOVERY-002.5
+func TestWSAddMessage_RejectsCanvasGuidancePairMismatch(t *testing.T) {
+	now := time.Now().UTC()
+	repo := &messageAddSwitchRepo{
+		tasks: map[string]*models.Task{"task-quick": {
+			ID: "task-quick", WorkspaceID: "workspace-1", State: v1.TaskStateInProgress,
+			IsEphemeral: true, UpdatedAt: now,
+		}},
+		sessions: map[string]*models.TaskSession{"session-1": {
+			ID: "session-1", TaskID: "other-task", State: models.TaskSessionStateCreated,
+			AgentProfileID: "profile-1", UpdatedAt: now,
+		}},
+		primaryID: "session-1",
+	}
+	log, err := logger.NewLogger(logger.LoggingConfig{Level: "error", Format: "json"})
+	require.NoError(t, err)
+	svc := service.NewService(service.Repos{
+		Workspaces: repo, Tasks: repo, TaskRepos: repo,
+		Workflows: repo, Messages: repo, Turns: repo,
+		Sessions: repo, GitSnapshots: repo, RepoEntities: repo,
+		Executors: repo, Environments: repo, TaskEnvironments: repo,
+		Reviews: repo,
+	}, nil, log, service.RepositoryDiscoveryConfig{})
+	orch := &savedPromptDeliveryOrchestrator{
+		started:               make(chan savedPromptStarted, 1),
+		canvasGuidanceResults: []canvasGuidanceResult{{err: orchestrator.ErrTaskSessionPairMismatch}},
+	}
+	h := NewMessageHandlers(svc, orch, log)
+	req, err := ws.NewRequest("canvas-mismatch", ws.ActionMessageAdd, map[string]interface{}{
+		"task_id": "task-quick", "session_id": "session-1", "content": "Build the app",
+	})
+	require.NoError(t, err)
+	resp, err := h.wsAddMessage(context.Background(), req)
+	require.NoError(t, err)
+	require.Equal(t, ws.MessageTypeError, resp.Type)
+	assert.Empty(t, repo.messages)
+}
+
 func TestWSAddMessage_PassesTrustedPromptContextToCreatedSessionStart(t *testing.T) {
 	synctest.Test(t, func(t *testing.T) {
 		now := time.Now().UTC()

apps/web/components/canvas/canvas-task-prompt.test.ts

@@ -0,0 +1,45 @@
+import enCanvases from "@/src/locales/en/canvases.json";
+import pseudoCanvases from "@/src/locales/pseudo/canvases.json";
+import ptCanvases from "@/src/locales/pt-pt/canvases.json";
+import zhCnCanvases from "@/src/locales/zh-cn/canvases.json";
+import zhHkCanvases from "@/src/locales/zh-hk/canvases.json";
+import zhTwCanvases from "@/src/locales/zh-tw/canvases.json";
+import { describe, expect, it } from "vitest";
+
+const canvasCatalogs = {
+  en: enCanvases,
+  "pt-pt": ptCanvases,
+  "zh-cn": zhCnCanvases,
+  "zh-hk": zhHkCanvases,
+  "zh-tw": zhTwCanvases,
+  pseudo: pseudoCanvases,
+};
+
+const requiredCanvasTools = [
+  "create_canvas_kandev",
+  "read_canvas_authoring_skill_kandev",
+  "publish_canvas_kandev",
+];
+
+describe("canvas creation task preset", () => {
+  it("keeps the authoring workflow and callable tool names in every catalog", () => {
+    for (const [locale, catalog] of Object.entries(canvasCatalogs)) {
+      const prompt = catalog.createCanvasTaskPrompt;
+      expect(prompt, locale).toMatch(/\S/);
+      for (const tool of requiredCanvasTools) {
+        expect(prompt, `${locale} is missing ${tool}`).toContain(tool);
+      }
+    }
+  });
+
+  it("requires Kandev publication instead of treating files or a build as a release", () => {
+    const prompt = enCanvases.createCanvasTaskPrompt;
+
+    expect(prompt).toContain("Create the draft in Kandev");
+    expect(prompt).toContain("Build inside the returned directory");
+    expect(prompt).toContain("A local build alone does not publish a canvas inside Kandev");
+    expect(prompt).toContain("If publication is unsuccessful, report the failure");
+    expect(prompt).toContain("do not claim that the canvas is published");
+    expect(prompt).toContain("report the limitation instead of claiming");
+  });
+});

apps/web/e2e/helpers/api-client.ts

@@ -2485,6 +2485,7 @@ export class ApiClient {
   async getTask(taskId: string): Promise<{
     id: string;
     title: string;
+    description?: string;
     autopilot?: boolean;
     primary_session_id?: string | null;
     primary_executor_type?: string | null;

apps/web/e2e/tests/canvas/mobile-plugin-canvas.spec.ts

@@ -1,4 +1,5 @@
 import { expect, test } from "../../fixtures/test-base";
+import { waitForHttp } from "../../helpers/causal-waits";
 import { SessionPage } from "../../pages/session-page";
 import type { ApiClient } from "../../helpers/api-client";
 import type { Page } from "@playwright/test";
@@ -119,6 +120,21 @@ test.describe("Plugin-backed canvases on mobile", () => {
       // the option, so this remains deterministic under strict locators.
       await testPage.getByRole("button", { name: "E2E Workflow", exact: true }).last().tap();
 
+      const defaultPrompt = await dialog.getByTestId("task-description-input").inputValue();
+      for (const tool of [
+        "create_canvas_kandev",
+        "read_canvas_authoring_skill_kandev",
+        "publish_canvas_kandev",
+      ]) {
+        expect(defaultPrompt, `mobile preset is missing ${tool}`).toContain(tool);
+      }
+      expect(defaultPrompt).not.toContain("e2e:mcp:");
+      await expect
+        .poll(() =>
+          testPage.evaluate(() => document.documentElement.scrollWidth <= window.innerWidth),
+        )
+        .toBe(true);
+
       const canvasTitle = "E2E Guided Canvas";
       const taskTitle = "E2E Guided Canvas Task";
       const description = [
@@ -131,12 +147,9 @@ test.describe("Plugin-backed canvases on mobile", () => {
       await dialog.getByTestId("task-title-input").fill(taskTitle);
       await dialog.getByTestId("task-description-input").fill(description);
 
-      const responsePromise = testPage.waitForResponse(
-        (response) =>
-          response.url().endsWith("/api/v1/tasks") && response.request().method() === "POST",
-      );
       const startAgent = dialog.getByTestId("submit-start-agent");
-      await expect(startAgent).toBeEnabled({ timeout: 30_000 });
+      await expect(startAgent).toBeEnabled();
+      const responsePromise = waitForHttp(testPage, "POST", /\/api\/v1\/tasks$/);
       await startAgent.tap();
       const response = await responsePromise;
       const responseBody = await response.text();
@@ -178,6 +191,7 @@ test.describe("Plugin-backed canvases on mobile", () => {
       await approvePendingCanvasThroughHost(testPage, apiClient, published);
 
       const createdTask = await apiClient.getTask(taskId);
+      expect(createdTask.description).toBe(description);
       expect(createdTask.repositories ?? []).toHaveLength(0);
       const { sessions } = await apiClient.listTaskSessions(taskId);
       expect(

apps/web/e2e/tests/canvas/plugin-canvas.spec.ts

@@ -1,5 +1,7 @@
 import { expect, test } from "../../fixtures/test-base";
+import { waitForHttp } from "../../helpers/causal-waits";
 import { resizeColumnViaSplitview } from "../../helpers/dockview-resize";
+import { SessionPage } from "../../pages/session-page";
 import {
   enableCanvasFeature,
   expectCanvasFrameFillsHost,
@@ -8,6 +10,85 @@ import {
 } from "./canvas-fixture";
 
 test.describe("Plugin-backed canvases in the desktop task workbench", () => {
+  test("shows the canvas creation prompt and retains the edited description on desktop", async ({
+    testPage,
+    apiClient,
+    backend,
+    seedData,
+  }) => {
+    test.setTimeout(150_000);
+
+    const releaseFeature = await enableCanvasFeature(backend, apiClient, seedData.workspaceId);
+    let taskId: string | undefined;
+    try {
+      const { executors } = await apiClient.listExecutors();
+      const localExecutor = executors.find((executor) =>
+        ["local", "local_pc"].includes(executor.type),
+      );
+      const localProfile = localExecutor?.profiles?.[0];
+      expect(
+        localProfile,
+        "a direct local executor profile is required by the fixture",
+      ).toBeDefined();
+
+      await testPage.goto(
+        `/settings/workspaces/${encodeURIComponent(seedData.workspaceId)}/canvases`,
+      );
+      await expect(testPage.getByTestId("workspace-canvases-page")).toBeVisible();
+      await testPage.getByTestId("settings-create-canvas").click();
+
+      const dialog = testPage.getByTestId("create-task-dialog");
+      await expect(dialog).toBeVisible();
+      await expect(dialog.getByTestId("source-mode-scratch")).toHaveAttribute(
+        "aria-checked",
+        "true",
+      );
+      await expect(dialog.getByTestId("executor-profile-selector")).toContainText(
+        localProfile!.name,
+      );
+
+      const defaultPrompt = await dialog.getByTestId("task-description-input").inputValue();
+      for (const tool of [
+        "create_canvas_kandev",
+        "read_canvas_authoring_skill_kandev",
+        "publish_canvas_kandev",
+      ]) {
+        expect(defaultPrompt, `desktop preset is missing ${tool}`).toContain(tool);
+      }
+      expect(defaultPrompt).not.toContain("e2e:mcp:");
+
+      const editedDescription = "desktop canvas prompt override";
+      await dialog.getByTestId("task-title-input").fill("E2E Desktop Canvas Task");
+      await dialog.getByTestId("task-description-input").fill(editedDescription);
+
+      const startAgent = dialog.getByTestId("submit-start-agent");
+      await expect(startAgent).toBeEnabled();
+      const responsePromise = waitForHttp(testPage, "POST", /\/api\/v1\/tasks$/);
+      await startAgent.click();
+      const response = await responsePromise;
+      const responseBody = await response.text();
+      expect(response.status(), responseBody).toBe(200);
+      const created = JSON.parse(responseBody) as { id: string };
+      taskId = created.id;
+      expect(taskId).toBeTruthy();
+
+      await expect(testPage).toHaveURL(new RegExp(`/t/${taskId}(?:[?]|$)`));
+      const session = new SessionPage(testPage);
+      await session.waitForLoad();
+      await expect
+        .poll(async () => (await apiClient.getTask(taskId!)).description)
+        .toBe(editedDescription);
+      await expect
+        .poll(() =>
+          testPage.evaluate(() => document.documentElement.scrollWidth <= window.innerWidth),
+        )
+        .toBe(true);
+    } finally {
+      if (taskId) await apiClient.deleteTask(taskId).catch(() => undefined);
+      await releaseFeature();
+    }
+  });
+
   test("discovers, reviews, and operates the first task canvas from the workbench", async ({
     testPage,
     apiClient,

apps/web/scripts/generate-pseudo-locale.mjs

@@ -7,8 +7,8 @@
  * string that was never routed through `t()`. This is the completeness oracle
  * for the i18n sweep (see docs/i18n.md).
  *
- * `{{interpolation}}` placeholders and <0>tag</0> markers are preserved
- * verbatim — transforming them would break interpolation and Trans nesting.
+ * `{{interpolation}}` placeholders, <0>tag</0> markers, and Markdown code spans
+ * are preserved verbatim. Code spans can contain callable names or commands.
  *
  * Covers the Go catalog too (apps/backend/internal/i18n/locales). The backend
  * renders its own user-facing copy — error pages and the shared-task page — so
@@ -88,10 +88,10 @@ const MAP = {
   Z: "Ź",
 };
 
-/** Accent letters outside {{...}} placeholders and <n>…</n> tag markers. */
+/** Accent letters outside placeholders, tags, and Markdown code spans. */
 function pseudolocalize(text) {
-  // Split on placeholders/tags so their contents survive untouched.
-  const parts = text.split(/(\{\{[^}]*\}\}|<\/?\d+>)/g);
+  // Split on placeholders/tags/code spans so their contents survive untouched.
+  const parts = text.split(/(`[^`]*`|\{\{[^}]*\}\}|<\/?\d+>)/g);
   return parts
     .map((part, i) => (i % 2 === 1 ? part : part.replace(/[A-Za-z]/g, (c) => MAP[c] ?? c)))
     .join("");

apps/web/src/locales/en/canvases.json

@@ -5,7 +5,7 @@
   "setUpCanvas": "Set up a canvas",
   "createCanvas": "Create canvas",
   "createCanvasTaskTitle": "Create a canvas",
-  "createCanvasTaskPrompt": "Create a polished interactive canvas application. Use the Kandev canvas authoring workflow and publish the first release for review.",
+  "createCanvasTaskPrompt": "Create an interactive canvas inside Kandev for the application I describe. If the application goal is missing, ask what the canvas must show or do. Find the Kandev canvas MCP tools before writing application files. If they are not callable, use native tool search for \"kandev canvas\" or inspect the available MCP catalog. Create the draft in Kandev before writing application files. Call `create_canvas_kandev` to create the draft and obtain its source directory. Read `read_canvas_authoring_skill_kandev` once without a path. Build inside the returned directory and use authorized live Kandev data for domain views. Call `publish_canvas_kandev` and address any validation errors. Report the canvas identity and whether its release is active, awaits permission review, or was unsuccessful. If publication is unsuccessful, report the failure and do not claim that the canvas is published. If workspace access requires promotion, explain the user action that is still required. A local build alone does not publish a canvas inside Kandev. If the tools remain unavailable, report the limitation instead of claiming that workspace files are a Kandev canvas.",
   "loadingCanvas": "Loading canvas",
   "loadingCanvasDescription": "Loading canvas metadata.",
   "pendingFirstRelease": "Waiting for the first release",

apps/web/src/locales/pseudo/canvases.json

@@ -5,7 +5,7 @@
   "setUpCanvas": "Śēţ ũƥ à ćàńvàś",
   "createCanvas": "Ćŕēàţē ćàńvàś",
   "createCanvasTaskTitle": "Ćŕēàţē à ćàńvàś",
-  "createCanvasTaskPrompt": "Ćŕēàţē à ƥōĺĩśĥēď ĩńţēŕàćţĩvē ćàńvàś àƥƥĺĩćàţĩōń. Ũśē ţĥē Ķàńďēv ćàńvàś àũţĥōŕĩńĝ ŵōŕķƒĺōŵ àńď ƥũƀĺĩśĥ ţĥē ƒĩŕśţ ŕēĺēàśē ƒōŕ ŕēvĩēŵ.",
+  "createCanvasTaskPrompt": "Ćŕēàţē àń ĩńţēŕàćţĩvē ćàńvàś ĩńśĩďē Ķàńďēv ƒōŕ ţĥē àƥƥĺĩćàţĩōń Ĩ ďēśćŕĩƀē. Ĩƒ ţĥē àƥƥĺĩćàţĩōń ĝōàĺ ĩś ḿĩśśĩńĝ, àśķ ŵĥàţ ţĥē ćàńvàś ḿũśţ śĥōŵ ōŕ ďō. Ƒĩńď ţĥē Ķàńďēv ćàńvàś ḾĆƤ ţōōĺś ƀēƒōŕē ŵŕĩţĩńĝ àƥƥĺĩćàţĩōń ƒĩĺēś. Ĩƒ ţĥēŷ àŕē ńōţ ćàĺĺàƀĺē, ũśē ńàţĩvē ţōōĺ śēàŕćĥ ƒōŕ \"ķàńďēv ćàńvàś\" ōŕ ĩńśƥēćţ ţĥē àvàĩĺàƀĺē ḾĆƤ ćàţàĺōĝ. Ćŕēàţē ţĥē ďŕàƒţ ĩń Ķàńďēv ƀēƒōŕē ŵŕĩţĩńĝ àƥƥĺĩćàţĩōń ƒĩĺēś. Ćàĺĺ `create_canvas_kandev` ţō ćŕēàţē ţĥē ďŕàƒţ àńď ōƀţàĩń ĩţś śōũŕćē ďĩŕēćţōŕŷ. Ŕēàď `read_canvas_authoring_skill_kandev` ōńćē ŵĩţĥōũţ à ƥàţĥ. Ɓũĩĺď ĩńśĩďē ţĥē ŕēţũŕńēď ďĩŕēćţōŕŷ àńď ũśē àũţĥōŕĩźēď ĺĩvē Ķàńďēv ďàţà ƒōŕ ďōḿàĩń vĩēŵś. Ćàĺĺ `publish_canvas_kandev` àńď àďďŕēśś àńŷ vàĺĩďàţĩōń ēŕŕōŕś. Ŕēƥōŕţ ţĥē ćàńvàś ĩďēńţĩţŷ àńď ŵĥēţĥēŕ ĩţś ŕēĺēàśē ĩś àćţĩvē, àŵàĩţś ƥēŕḿĩśśĩōń ŕēvĩēŵ, ōŕ ŵàś ũńśũććēśśƒũĺ. Ĩƒ ƥũƀĺĩćàţĩōń ĩś ũńśũććēśśƒũĺ, ŕēƥōŕţ ţĥē ƒàĩĺũŕē àńď ďō ńōţ ćĺàĩḿ ţĥàţ ţĥē ćàńvàś ĩś ƥũƀĺĩśĥēď. Ĩƒ ŵōŕķśƥàćē àććēśś ŕēqũĩŕēś ƥŕōḿōţĩōń, ēxƥĺàĩń ţĥē ũśēŕ àćţĩōń ţĥàţ ĩś śţĩĺĺ ŕēqũĩŕēď. À ĺōćàĺ ƀũĩĺď àĺōńē ďōēś ńōţ ƥũƀĺĩśĥ à ćàńvàś ĩńśĩďē Ķàńďēv. Ĩƒ ţĥē ţōōĺś ŕēḿàĩń ũńàvàĩĺàƀĺē, ŕēƥōŕţ ţĥē ĺĩḿĩţàţĩōń ĩńśţēàď ōƒ ćĺàĩḿĩńĝ ţĥàţ ŵōŕķśƥàćē ƒĩĺēś àŕē à Ķàńďēv ćàńvàś.",
   "loadingCanvas": "Ĺōàďĩńĝ ćàńvàś",
   "loadingCanvasDescription": "Ĺōàďĩńĝ ćàńvàś ḿēţàďàţà.",
   "pendingFirstRelease": "Ŵàĩţĩńĝ ƒōŕ ţĥē ƒĩŕśţ ŕēĺēàśē",

apps/web/src/locales/pseudo/executors.json

@@ -398,5 +398,5 @@
   "allowUserNamespacesTitle": "Ũśēŕ ńàḿēśƥàćē śũƥƥōŕţ",
   "allowUserNamespacesDescription": "Àĺĺōŵ ũńƥŕĩvĩĺēĝēď ũśēŕ ńàḿēśƥàćē ćŕēàţĩōń àńď ḿōũńţ ōƥēŕàţĩōńś ĩńśĩďē ćōńţàĩńēŕś. Ēńàƀĺēś śàńďƀōxĩńĝ ţōōĺś ĺĩķē ƀŵŕàƥ.",
   "allowUserNamespacesNote": "Ţĥĩś śēţţĩńĝ ōńĺŷ àƒƒēćţś ńēŵĺŷ ćŕēàţēď ćōńţàĩńēŕś. Ēxĩśţĩńĝ ţàśķ ēńvĩŕōńḿēńţś ḿũśţ ƀē ŕēśēţ ƒōŕ ţĥē ćĥàńĝē ţō ţàķē ēƒƒēćţ.",
-  "allowUserNamespacesWarning": "⟦This disables Docker's default AppArmor restrictions for opted-in containers. Enable it only for trusted agent runtimes that need user-namespace sandboxing.⟧"
+  "allowUserNamespacesWarning": "Ţĥĩś ďĩśàƀĺēś Ďōćķēŕ'ś ďēƒàũĺţ ÀƥƥÀŕḿōŕ ŕēśţŕĩćţĩōńś ƒōŕ ōƥţēď-ĩń ćōńţàĩńēŕś. Ēńàƀĺē ĩţ ōńĺŷ ƒōŕ ţŕũśţēď àĝēńţ ŕũńţĩḿēś ţĥàţ ńēēď ũśēŕ-ńàḿēśƥàćē śàńďƀōxĩńĝ."
 }

apps/web/src/locales/pseudo/github.json

@@ -45,7 +45,7 @@
   "autoFixCiAndAddressComments": "Àũţō-ƒĩx ĆĨ àńď àďďŕēśś ćōḿḿēńţś",
   "autoFixPrompt": "Àũţō-ƒĩx ƥŕōḿƥţ",
   "autoFixPromptDescription": "Ţĥĩś ƥŕōḿƥţ ĩś ũśēď ōńĺŷ ƒōŕ ţĥĩś ţàśķ. Ĺēàvē ĩţ ƀĺàńķ ţō ũśē ţĥē ďēƒàũĺţ ƥŕōḿƥţ. Àďď <0>{{placeholder}}</0> ŵĥēń ŷōũ ŵàńţ Ķàńďēv ţō ĩńćĺũďē ƤŔ ƒēēďƀàćķ, ōŕďĩńàŕŷ ḿēŕĝē-ćōńƒĺĩćţ ćōńţēxţ, àćţĩōńàƀĺē qũēũē-ŕēḿōvàĺ ćōńţēxţ, àńď àvàĩĺàƀĺē ƒàĩĺēď ḿēŕĝē-ĝŕōũƥ ćĥēćķś.",
-  "autoFixRoundExplanation": "Àũţō-ƒĩx ĥàś ũśēď {{current}} ōƒ {{max}} ŕōũńďś ƒōŕ ţĥĩś ƤŔ. À ŕōũńď ĩś ćōũńţēď ŵĥēń Ķàńďēv śēńďś ōŕ qũēũēś à ĆĨ àũţō-ƒĩx ḿēśśàĝē. Ķàńďēv ŵàĩţś ƒōŕ àĺĺ ƤŔ ćĥēćķś ţō ƒĩńĩśĥ ƀēƒōŕē śţàŕţĩńĝ à ńēŵ ĆĨ àũţō-ƒĩx ţũŕń, śō ţĥē àĝēńţ ĝēţś ţĥē ƒĩńàĺ ƒàĩĺēď ćĥēćķś, ćũŕŕēńţ ćōḿḿēńţś, ōŕďĩńàŕŷ ḿēŕĝē ćōńƒĺĩćţś, àńď àćţĩōńàƀĺē ḿēŕĝē-qũēũē ŕēḿōvàĺś ţōĝēţĥēŕ. Ũƥďàţĩńĝ àń àĺŕēàďŷ qũēũēď àũţō-ƒĩx ḿēśśàĝē ďōēś ńōţ ũśē àńōţĥēŕ ŕōũńď. Ŵĥēń ţĥĩś ĩś àţ {{max}}/{{max}} àńď ţĥēŕē ĩś ńō ƥēńďĩńĝ àũţō-ƒĩx ḿēśśàĝē ĺēƒţ ţō ũƥďàţē, Ķàńďēv ƥàũśēś àũţō-ƒĩx ƒōŕ ţĥĩś ƤŔ śō ĩţ ćàńńōţ ĺōōƥ ƒōŕēvēŕ. Ďĩśàƀĺē àńď ŕē-ēńàƀĺē àũţō-ƒĩx àƒţēŕ ḿàńũàĺ ŕēvĩēŵ ţō śţàŕţ ōvēŕ.",
+  "autoFixRoundExplanation": "Àũţō-ƒĩx ĥàś ũśēď {{current}} ōƒ {{max}} ŕōũńďś ƒōŕ ţĥĩś ƤŔ. À ŕōũńď ĩś ćōũńţēď ŵĥēń Ķàńďēv śēńďś ōŕ qũēũēś à ĆĨ àũţō-ƒĩx ḿēśśàĝē. Ķàńďēv ŵàĩţś ƒōŕ àĺĺ ƤŔ ćĥēćķś ţō ƒĩńĩśĥ ƀēƒōŕē śţàŕţĩńĝ à ńēŵ ĆĨ àũţō-ƒĩx ţũŕń, śō ţĥē àĝēńţ ĝēţś ţĥē ƒĩńàĺ ƒàĩĺēď ćĥēćķś, ćũŕŕēńţ ćōḿḿēńţś, ōŕďĩńàŕŷ ḿēŕĝē ćōńƒĺĩćţś, àńď àćţĩōńàƀĺē ḿēŕĝē-qũēũē ŕēḿōvàĺś ţōĝēţĥēŕ. Ũƥďàţĩńĝ àń àĺŕēàďŷ qũēũēď àũţō-ƒĩx ḿēśśàĝē ďōēś ńōţ ũśē àńōţĥēŕ ŕōũńď. Ŵĥēń ţĥĩś ĩś àţ {{max}}/{{max}} àńď ţĥēŕē ĩś ńō ƥēńďĩńĝ àũţō-ƒĩx ḿēśśàĝē ĺēƒţ ţō ũƥďàţē, Ķàńďēv ƥàũśēś àũţō-ƒĩx ƒōŕ ţĥĩś ƤŔ śō ĩţ ćàńńōţ ĺōōƥ ƒōŕēvēŕ. Ďĩśàƀĺē àńď ŕē-ēńàƀĺē àũţō-ƒĩx àƒţēŕ ḿàńũàĺ ŕēvĩēŵ ţō śţàŕţ ōvēŕ. Ĩƒ à ţũŕń ēńďś ŵĩţĥōũţ à ŕēćōŕďēď ōũţćōḿē, Ķàńďēv ćàń ŕēţŕŷ ţĥē śàḿē śēţţĺēď ƒēēďƀàćķ, àńď ţĥàţ ŕēţŕŷ ũśēś àńōţĥēŕ ŕōũńď. Àƒţēŕ àń àćţĩōń-ţàķēń ōũţćōḿē, Ķàńďēv ŵàĩţś ƒōŕ ƥŕōvĩďēŕ ƥŕōĝŕēśś ƀēƒōŕē ŕēţŕŷĩńĝ. À ńōń-àćţĩōńàƀĺē ōŕ ƀĺōćķēď ōũţćōḿē àćķńōŵĺēďĝēś ũńćĥàńĝēď ƒēēďƀàćķ àńď ďōēś ńōţ ŕēţŕŷ ĩţ.",
   "autoMerge": "Àũţō-ḿēŕĝē",
   "autoMergeEnabledAria": "àũţō-ḿēŕĝē ēńàƀĺēď",
   "autoMergeWhenReady": "Àũţō-ḿēŕĝē ŵĥēń ŕēàďŷ",

apps/web/src/locales/pseudo/task.json

@@ -127,10 +127,10 @@
   "authenticationRequiredPleaseLogInVia": "Àũţĥēńţĩćàţĩōń ŕēqũĩŕēď; ƥĺēàśē ĺōĝ ĩń vĩà ţĥē ţēŕḿĩńàĺ",
   "autoMarkReviewedOnScroll": "Àũţō-ḿàŕķ ŕēvĩēŵēď ōń śćŕōĺĺ",
   "autoStart": "Àũţō-śţàŕţ",
-  "automaticColorSource": "Àũţōḿàţĩć: {{rule}}. Màńũàĺ ćōĺōŕ ĩś ĥĩďďēń ŵĥĩĺē ţĥĩś ŕũĺē ḿàţćĥēś.",
+  "automaticColorSource": "Àũţōḿàţĩć: {{rule}}. Ḿàńũàĺ ćōĺōŕ ĩś ĥĩďďēń ŵĥĩĺē ţĥĩś ŕũĺē ḿàţćĥēś.",
   "automaticColors": "Àũţōḿàţĩć ćōĺōŕś",
   "automaticColorsAddRule": "Àďď ŕũĺē",
-  "automaticColorsBackToRule": "Bàćķ ţō ŕũĺē",
+  "automaticColorsBackToRule": "Ɓàćķ ţō ŕũĺē",
   "automaticColorsCompleteRule": "Ćōḿƥĺēţē ţĥĩś ŕũĺē ƀēƒōŕē ēńàƀĺĩńĝ ĩţ.",
   "automaticColorsCondition": "Ćōńďĩţĩōń",
   "automaticColorsDimensionExecutorProfile": "Ēxēćũţōŕ ƥŕōƒĩĺē",
@@ -142,20 +142,20 @@
   "automaticColorsDimensionWorkflowStep": "Ŵōŕķƒĺōŵ śţēƥ",
   "automaticColorsEnable": "Ēńàƀĺē ŕũĺē",
   "automaticColorsEnabled": "Àũţōḿàţĩć ćōĺōŕś",
-  "automaticColorsFixedColor": "Fĩxēď ćōĺōŕ",
+  "automaticColorsFixedColor": "Ƒĩxēď ćōĺōŕ",
   "automaticColorsHelp": "Ŕũĺēś ŕũń ŵĥēń ţàśķś àƥƥēàŕ àńď ŵĥēńēvēŕ ţĥēĩŕ ŵōŕķƒĺōŵ śţēƥ, ŕēƥōśĩţōŕŷ, ŵōŕķƒĺōŵ, ēxēćũţōŕ ƥŕōƒĩĺē, śţàţē, ƥŕĩōŕĩţŷ, ōŕ ōŕĩĝĩń ćĥàńĝēś. Ćĥàńĝĩńĝ ŕũĺē ōŕďēŕ, ōũţƥũţ, ōŕ ēńàƀĺēď śţàţē àĺśō ũƥďàţēś ćōĺōŕś.",
   "automaticColorsHelpLabel": "Ŵĥēń àũţōḿàţĩć ćōĺōŕś àƥƥĺŷ",
   "automaticColorsIncomplete": "Ĩńćōḿƥĺēţē",
-  "automaticColorsMoveDown": "Mōvē ŕũĺē ďōŵń",
-  "automaticColorsMoveUp": "Mōvē ŕũĺē ũƥ",
-  "automaticColorsNoRepositories": "Nō ŕēƥōśĩţōŕĩēś ƒōũńď.",
+  "automaticColorsMoveDown": "Ḿōvē ŕũĺē ďōŵń",
+  "automaticColorsMoveUp": "Ḿōvē ŕũĺē ũƥ",
+  "automaticColorsNoRepositories": "Ńō ŕēƥōśĩţōŕĩēś ƒōũńď.",
   "automaticColorsOutput": "Ōũţƥũţ",
   "automaticColorsPersonalGlobal": "Ƥēŕśōńàĺ śēţţĩńĝ. Àƥƥĺĩēś àćŕōśś śĩďēƀàŕ vĩēŵś àńď ŵōŕķśƥàćēś.",
-  "automaticColorsPrecedence": "Ţĥē ƒĩŕśţ ḿàţćĥĩńĝ ŕũĺē ŵĩńś. Màńũàĺ ćōĺōŕś ŕēḿàĩń àś ƒàĺĺƀàćķ.",
+  "automaticColorsPrecedence": "Ţĥē ƒĩŕśţ ḿàţćĥĩńĝ ŕũĺē ŵĩńś. Ḿàńũàĺ ćōĺōŕś ŕēḿàĩń àś ƒàĺĺƀàćķ.",
   "automaticColorsRefreshRepositories": "Ŕēƒŕēśĥ ŕēƥōśĩţōŕĩēś",
   "automaticColorsRemoveRule": "Ŕēḿōvē ŕũĺē",
   "automaticColorsRepositoryError": "Śōḿē ŕēƥōśĩţōŕŷ śōũŕćēś ćōũĺď ńōţ ƀē ĺōàďēď.",
-  "automaticColorsRepositoryLocal": "Đĩśćōvēŕēď ĺōćàĺ ŕēƥōśĩţōŕĩēś",
+  "automaticColorsRepositoryLocal": "Ďĩśćōvēŕēď ĺōćàĺ ŕēƥōśĩţōŕĩēś",
   "automaticColorsRepositoryRemote": "Ŕēḿōţē ŕēƥōśĩţōŕĩēś",
   "automaticColorsRepositoryUnavailable": "Ũńàvàĩĺàƀĺē ţàŕĝēţ",
   "automaticColorsRepositoryWorkspace": "Ŵōŕķśƥàćē ŕēƥōśĩţōŕĩēś",
@@ -164,7 +164,7 @@
   "automaticColorsRule": "Ŕũĺē {{number}}",
   "automaticColorsRuleCount_one": "{{count}} ŕũĺē",
   "automaticColorsRuleCount_other": "{{count}} ŕũĺēś",
-  "automaticColorsRuleLimit": "Ýōũ ćàń àďď ũƥ ţō 50 ŕũĺēś.",
+  "automaticColorsRuleLimit": "Ŷōũ ćàń àďď ũƥ ţō 50 ŕũĺēś.",
   "automaticColorsSaveError": "Ćōũĺď ńōţ śàvē àũţōḿàţĩć ćōĺōŕś.",
   "manualColorSaveError": "Ćōũĺď ńōţ śàvē ţĥē ţàśķ ćōĺōŕ.",
   "automaticColorsSearchRepositories": "Śēàŕćĥ ŕēƥōśĩţōŕĩēś",
@@ -179,8 +179,8 @@
   "automaticColorsOriginAgentCreated": "Àĝēńţ-ćŕēàţēď",
   "automaticColorsOriginAutomationRun": "Àũţōḿàţĩōń ŕũń",
   "automaticColorsOriginAutomationTask": "Àũţōḿàţĩōń ţàśķ",
-  "automaticColorsOriginKanban": "Kàńƀàń",
-  "automaticColorsOriginManual": "Màńũàĺ",
+  "automaticColorsOriginKanban": "Ķàńƀàń",
+  "automaticColorsOriginManual": "Ḿàńũàĺ",
   "automaticColorsOriginOnboarding": "Ōńƀōàŕďĩńĝ",
   "automaticColorsOriginRoutine": "Ŕōũţĩńē",
   "availableModes": "Àvàĩĺàƀĺē Ḿōďēś",
@@ -560,7 +560,7 @@
   "htmlPreviewLoading": "Ĺōàďĩńĝ ĤŢḾĹ ƥŕēvĩēŵ...",
   "htmlPreviewPublishFailed": "ĤŢḾĹ ƥŕēvĩēŵ ćōũĺď ńōţ ƀē ōƥēńēď. Ţŕŷ àĝàĩń.",
   "htmlPreviewTooLarge": "Ţĥĩś ĤŢḾĹ ƀũƒƒēŕ ĩś ţōō ĺàŕĝē ţō ƥŕēvĩēŵ. Śĥōŵ ćōďē àńď ţŕŷ àĝàĩń ŵĩţĥ à śḿàĺĺēŕ ƒĩĺē.",
-  "htmlPreviewTrustedCode": "Ƥŕēvĩēŵĩńĝ ŕũńś ŵōŕķśƥàćē ćōďē ŵĩţĥ ƀŕōŵśēŕ-ƥàńēĺ ćàƥàƀĩĺĩţĩēś. Ōńĺŷ ƥŕēvĩēŵ ƒĩĺēś ŷōũ ţŕũśţ.",
+  "htmlPreviewTrustedCode": "Ƥŕēvĩēŵĩńĝ ŕũńś ŵōŕķśƥàćē ćōďē ŵĩţĥ Ɓŕōŵśēŕ-ƥàńēĺ ćàƥàƀĩĺĩţĩēś. Ōńĺŷ ƥŕēvĩēŵ ƒĩĺēś ŷōũ ţŕũśţ.",
   "htmlPreviewUnavailable": "Ţĥē ĤŢḾĹ ƥŕēvĩēŵ śēśśĩōń ĩś ńōţ àvàĩĺàƀĺē. Ćĥēćķ ţĥē ţàśķ śēśśĩōń àńď ţŕŷ àĝàĩń.",
   "refreshHtmlPreview": "Ŕēƒŕēśĥ ĤŢḾĹ ƥŕēvĩēŵ",
   "failedToLoadRevision": "Ƒàĩĺēď ţō ĺōàď ŕēvĩśĩōń",
@@ -1455,7 +1455,7 @@
   "shortcutTogglesChatInput": "Śĥōŕţćũţ: <1>{{shortcut}}</1> ţōĝĝĺēś ţĥĩś ćĥàţ ĩńƥũţ.",
   "showBranchAndGitCredentialDetails": "Śĥōŵ ƀŕàńćĥ àńď Ĝĩţ ćŕēďēńţĩàĺ ďēţàĩĺś",
   "showCode": "Śĥōŵ ćōďē",
-  "retryHtmlPreview": "Řēţŕŷ ĤŢḾĹ ƥŕēvĩēŵ",
+  "retryHtmlPreview": "Ŕēţŕŷ ĤŢḾĹ ƥŕēvĩēŵ",
   "showCommandOutput": "Śĥōŵ ćōḿḿàńď ōũţƥũţ",
   "showDebugInfo": "Śĥōŵ Ďēƀũĝ Ĩńƒō",
   "showDetails": "Śĥōŵ ďēţàĩĺś",
@@ -1510,7 +1510,7 @@
   "sortCustom": "Ćũśţōḿ",
   "sortCustomDescription": "Ţĥē ḿàńũàĺ ōŕďēŕ ŷōũ śēţ ƒōŕ ţàśķś.",
   "sortDirection": "Śōŕţ ďĩŕēćţĩōń {{direction}}",
-  "sortSummary": "{{sort}}，{{direction}}",
+  "sortSummary": "{{sort}}, {{direction}}",
   "sortLastActivity": "Ĺàśţ àćţĩvĩţŷ",
   "sortLastActivityDescription": "Ĺàśţ ũśēŕ ōŕ àĝēńţ àćţĩōń. Vĩēŵĩńĝ à ţàśķ ďōēś ńōţ ćĥàńĝē ĩţ.",
   "sortStatus": "Śţàţũś",
@@ -1950,7 +1950,7 @@
   "branchTooltipCurrent": "Ŷōũŕ ŕēƥōśĩţōŕŷ'ś ćũŕŕēńţ ćĥēćķōũţ. Ţĥē àĝēńţ ŕũńś àĝàĩńśţ ĩţ àś-ĩś, ńō ĝĩţ ōƥēŕàţĩōńś.",
   "branchTooltipFrom": "Ɓàśē ƀŕàńćĥ. À ńēŵ ƀŕàńćĥ (ōŕ ŵōŕķţŕēē) ĩś ƒōŕķēď ƒŕōḿ ĥēŕē àńď ţĥē àĝēńţ ŕũńś ţĥēŕē.",
   "branchTooltipGeneric": "Ɓŕàńćĥ ţĥē àĝēńţ ŵĩĺĺ ŕũń àĝàĩńśţ.",
-  "branchTooltipWillSwitchTo": "Ţĥē ƀàćķēńď ŵĩĺĺ ŕũń `ĝĩţ ćĥēćķōũţ` ţō śŵĩţćĥ ŷōũŕ ŕēƥōśĩţōŕŷ ţō ţĥĩś ƀŕàńćĥ ƀēƒōŕē ţĥē àĝēńţ śţàŕţś.",
+  "branchTooltipWillSwitchTo": "Ţĥē ƀàćķēńď ŵĩĺĺ ŕũń `git checkout` ţō śŵĩţćĥ ŷōũŕ ŕēƥōśĩţōŕŷ ţō ţĥĩś ƀŕàńćĥ ƀēƒōŕē ţĥē àĝēńţ śţàŕţś.",
   "cleanupAgentSessionsStopped": "Àńŷ ŕũńńĩńĝ àĝēńţ śēśśĩōńś ŵĩĺĺ ƀē śţōƥƥēď.",
   "cleanupBulkLocal_one": "{{count}} ĺōćàĺ ţàśķ ŕàń ďĩŕēćţĺŷ ĩń ŷōũŕ ŕēƥō. Ŷōũŕ ŕēƥō ƒōĺďēŕś ŵōń'ţ ƀē ţōũćĥēď.",
   "cleanupBulkLocal_other": "{{count}} ĺōćàĺ ţàśķś ŕàń ďĩŕēćţĺŷ ĩń ŷōũŕ ŕēƥō. Ŷōũŕ ŕēƥō ƒōĺďēŕś ŵōń'ţ ƀē ţōũćĥēď.",

apps/web/src/locales/pseudo/workspaces.json

@@ -46,10 +46,10 @@
   "devScriptChip": "ďēv śćŕĩƥţ",
   "devScriptHelp": "Ũśēď ţō śţàŕţ ţĥē ƥŕēvĩēŵ ďēv śēŕvēŕ ƒōŕ ţĥĩś ŕēƥōśĩţōŕŷ. Ũśē <0>{{port}}</0> ƒōŕ àũţōḿàţĩć ƥōŕţ àĺĺōćàţĩōń.",
   "discoverRepositoryDescription": "Śēĺēćţ à ďĩśćōvēŕēď ŕēƥōśĩţōŕŷ ōŕ ƥŕōvĩďē àń àƀśōĺũţē ƥàţĥ ţō vàĺĩďàţē.",
-  "chooseFoldersToDiscoverRepositories": "Ćħōōśē ƒōĺďēŕś ţō ďĩśćōvēŕ ŕēƥōśĩţōŕĩēś",
-  "chooseFoldersToDiscoverRepositoriesDescription": "Śēĺēćţ Ĥōḿē ōŕ à ńàŕŕōŵēŕ ƒōĺďēŕ. Ķàńďēṽ śćàńś ĩţ ōńĺŷ ŵħĩĺē ŷōũ ũśē ŕēƥōśĩţōŕŷ śēĺēćţĩōń.",
-  "continueHomeDiscovery": "Ćōńţĩńũē Ĥōḿē Ďĩśćōṽēŕŷ",
-  "homeDiscoveryConfirmationDescription": "Ţħĩś ĩńśţàĺĺàţĩōń ƥŕēṽĩōũśĺŷ śēàŕćĥēď Ĥōḿē. Ćōńţĩńũē ōńĺŷ ĩƒ ŷōũ ŵàńţ ţō àĺĺōŵ Ĥōḿē ďĩśćōṽēŕŷ.",
+  "chooseFoldersToDiscoverRepositories": "Ćĥōōśē ƒōĺďēŕś ţō ďĩśćōvēŕ ŕēƥōśĩţōŕĩēś",
+  "chooseFoldersToDiscoverRepositoriesDescription": "Śēĺēćţ Ĥōḿē ōŕ à ńàŕŕōŵēŕ ƒōĺďēŕ. Ķàńďēv śćàńś ĩţ ōńĺŷ ŵĥĩĺē ŷōũ ũśē ŕēƥōśĩţōŕŷ śēĺēćţĩōń.",
+  "continueHomeDiscovery": "Ćōńţĩńũē Ĥōḿē Ďĩśćōvēŕŷ",
+  "homeDiscoveryConfirmationDescription": "Ţĥĩś ĩńśţàĺĺàţĩōń ƥŕēvĩōũśĺŷ śēàŕćĥēď Ĥōḿē. Ćōńţĩńũē ōńĺŷ ĩƒ ŷōũ ŵàńţ ţō àĺĺōŵ Ĥōḿē ďĩśćōvēŕŷ.",
   "discoveredRepositories": "Ďĩśćōvēŕēď ŕēƥōśĩţōŕĩēś",
   "edit": "Ēďĩţ",
   "environmentSecrets": "Ēńvĩŕōńḿēńţ śēćŕēţś",
@@ -98,8 +98,8 @@
   "repositories": "Ŕēƥōśĩţōŕĩēś",
   "refreshRepositories": "Ŕēƒŕēśĥ ŕēƥōśĩţōŕĩēś",
   "reconnectDiscoveryRoot": "Ŕēćōńńēćţ",
-  "removeDiscoveryRoot": "Ŕēḿōṽē",
-  "repositoryDiscoveryNoRoots": "Ćħōōśē à ƒōĺďēŕ ţō śţàŕţ ŕēƥōśĩţōŕŷ ďĩśćōṽēŕŷ.",
+  "removeDiscoveryRoot": "Ŕēḿōvē",
+  "repositoryDiscoveryNoRoots": "Ćĥōōśē à ƒōĺďēŕ ţō śţàŕţ ŕēƥōśĩţōŕŷ ďĩśćōvēŕŷ.",
   "resourceCount_one": "{{count}} ŕēśōũŕćē",
   "resourceCount_other": "{{count}} ŕēśōũŕćēś",
   "repositoriesInThisWorkspace": "Ŕēƥōśĩţōŕĩēś ĩń ţĥĩś ŵōŕķśƥàćē",

apps/web/src/locales/pt-pt/canvases.json

@@ -5,7 +5,7 @@
   "setUpCanvas": "Configurar um canvas",
   "createCanvas": "Criar canvas",
   "createCanvasTaskTitle": "Criar um canvas",
-  "createCanvasTaskPrompt": "Cria uma aplicação canvas interativa e cuidada. Usa o fluxo de autoria de canvas do Kandev e publica a primeira versão para revisão.",
+  "createCanvasTaskPrompt": "Cria um canvas interativo dentro do Kandev para a aplicação que descrevo. Se faltar o objetivo da aplicação, pergunta o que o canvas deve mostrar ou fazer. Encontra as ferramentas MCP de canvas do Kandev antes de escrever ficheiros da aplicação. Se não estiverem disponíveis, usa a pesquisa nativa de ferramentas por \"kandev canvas\" ou consulta o catálogo MCP disponível. Cria o rascunho no Kandev antes de escrever os ficheiros da aplicação. Chama `create_canvas_kandev` para criar o rascunho e obter o diretório de origem. Lê `read_canvas_authoring_skill_kandev` uma vez, sem indicar um caminho. Desenvolve dentro do diretório devolvido e usa dados ativos autorizados do Kandev para as vistas do domínio. Chama `publish_canvas_kandev` e corrige quaisquer erros de validação. Indica a identidade do canvas e se a versão está ativa, aguarda revisão de permissões ou não foi publicada com sucesso. Se a publicação não tiver sucesso, indica o erro e não afirmes que o canvas foi publicado. Se o acesso à área de trabalho exigir promoção, explica a ação que o utilizador ainda deve executar. Uma compilação local não publica um canvas dentro do Kandev. Se as ferramentas continuarem indisponíveis, informa a limitação em vez de afirmar que os ficheiros da área de trabalho são um canvas do Kandev.",
   "loadingCanvas": "A carregar o canvas",
   "loadingCanvasDescription": "A carregar os metadados do canvas.",
   "pendingFirstRelease": "À espera da primeira versão",

apps/web/src/locales/zh-cn/canvases.json

@@ -5,7 +5,7 @@
   "setUpCanvas": "设置画布",
   "createCanvas": "创建画布",
   "createCanvasTaskTitle": "创建画布",
-  "createCanvasTaskPrompt": "创建一个精致的交互式画布应用。使用 Kandev 画布创作流程，并发布第一个版本以供审核。",
+  "createCanvasTaskPrompt": "在 Kandev 中为我描述的应用创建一个交互式画布。如果缺少应用目标，询问画布需要展示或执行什么。编写应用文件前，先查找 Kandev 画布 MCP 工具。如果工具不可调用，使用原生工具搜索查找“kandev canvas”，或检查客户端可用的 MCP 目录。在编写应用文件前，先在 Kandev 中创建草稿。调用 `create_canvas_kandev` 创建草稿并获取源目录。无需路径参数调用一次 `read_canvas_authoring_skill_kandev`。在返回的目录中构建，并使用已授权的 Kandev 实时数据展示领域视图。调用 `publish_canvas_kandev` 并处理验证错误。报告画布标识，以及版本是已激活、等待权限审核还是发布失败。如果发布失败，报告错误，不要声称画布已发布。如果工作区访问需要提升权限，说明仍需用户执行的操作。本地构建成功不会在 Kandev 中发布画布。如果工具仍不可用，报告限制，不要声称工作区文件就是 Kandev 画布。",
   "loadingCanvas": "正在加载画布",
   "loadingCanvasDescription": "正在加载画布元数据。",
   "pendingFirstRelease": "等待首个版本",

apps/web/src/locales/zh-hk/canvases.json

@@ -5,75 +5,75 @@
   "setUpCanvas": "設定畫布",
   "createCanvas": "建立畫布",
   "createCanvasTaskTitle": "建立畫布",
-  "createCanvasTaskPrompt": "建立精緻的互動式畫布應用程式。使用 Kandev 畫布製作流程，並發佈第一個版本供審核。",
+  "createCanvasTaskPrompt": "在 Kandev 中為我描述的應用建立一個交互式畫布。如果缺少應用目標，詢問畫布需要展示或執行什麼。編寫應用檔案前，先查找 Kandev 畫布 MCP 工具。如果工具不可呼叫，使用原生工具搜尋查找「kandev canvas」，或檢查用戶端可用的 MCP 目錄。在編寫應用檔案前，先在 Kandev 中建立草稿。呼叫 `create_canvas_kandev` 建立草稿並擷取源目錄。無需路徑參數呼叫一次 `read_canvas_authoring_skill_kandev`。在返回的目錄中構建，並使用已授權的 Kandev 實時數據展示領域視圖。呼叫 `publish_canvas_kandev` 並處理驗證錯誤。報告畫布標識，以及版本是已激活、等待權限審核還是發佈失敗。如果發佈失敗，報告錯誤，不要聲稱畫布已發佈。如果工作區存取需要提升權限，說明仍需用戶執行的操作。本地構建成功不會在 Kandev 中發佈畫布。如果工具仍不可用，報告限制，不要聲稱工作區檔案就是 Kandev 畫布。",
   "loadingCanvas": "正在載入畫布",
-  "loadingCanvasDescription": "正在載入畫布中繼資料。",
-  "pendingFirstRelease": "等待第一個版本",
-  "pendingFirstReleaseDescription": "此畫布尚未有已發佈的版本。",
-  "pendingPermission": "需要審閱權限",
+  "loadingCanvasDescription": "正在載入畫布元數據。",
+  "pendingFirstRelease": "等待首個版本",
+  "pendingFirstReleaseDescription": "此畫布還沒有已發佈的版本。",
+  "pendingPermission": "需要審核權限",
   "pendingPermissionDescription": "活動版本需要獲得權限批准後才能開啟。",
-  "loadingRuntime": "正在載入畫布執行階段",
-  "loadingRuntimeDescription": "正在準備已發佈的畫布應用程式。",
-  "ready": "已準備就緒",
-  "readyDescription": "畫布應用程式已準備就緒。",
+  "loadingRuntime": "正在載入畫布執行時",
+  "loadingRuntimeDescription": "正在準備已發佈的畫布應用。",
+  "ready": "已就緒",
+  "readyDescription": "畫布應用已就緒。",
   "offline": "畫布離線",
-  "offlineDescription": "無法連接畫布執行階段。請檢查連線後再試。",
+  "offlineDescription": "無法存取畫布執行時。請檢查連接後重試。",
   "invalidRelease": "版本無效",
-  "invalidReleaseDescription": "活動版本未能通過驗證。請檢視版本或編輯畫布。",
-  "unavailable": "畫布無法使用",
-  "unavailableDescription": "活動畫布版本無法使用。",
-  "archived": "畫布已封存",
-  "archivedDescription": "請在工作區設定中還原此畫布，然後再次開啟。",
+  "invalidReleaseDescription": "活動版本未通過驗證。請查看版本或編輯畫布。",
+  "unavailable": "畫布不可用",
+  "unavailableDescription": "活動畫布版本不可用。",
+  "archived": "畫布已歸檔",
+  "archivedDescription": "請在工作區設定中恢復此畫布，然後再次開啟。",
   "loadFailed": "載入畫布失敗。",
   "actionFailed": "畫布操作失敗。",
   "canvasActions": "畫布操作",
   "editCanvas": "編輯畫布",
-  "editCanvasHelp": "開啟畫布製作工作。",
+  "editCanvasHelp": "開啟畫布創作任務。",
   "promoteCanvas": "提升畫布",
-  "promoteCanvasHelp": "讓此工作畫布顯示在工作區導覽中。",
-  "promoteCanvasUnavailable": "有效版本獲批准後才可提升。",
-  "openInNewTab": "在新分頁開啟",
-  "openInNewTabHelp": "在專注的瀏覽器分頁中開啟此畫布。",
-  "promoteCanvasDescription": "將 {{title}} 移至工作區範圍前，請先檢閱權限。",
-  "loadingPermissions": "正在載入要求的權限",
-  "promotionScopeChange": "提升後，此畫布會出現在工作區導覽中。",
-  "noAdditionalPermissions": "未要求其他權限。",
+  "promoteCanvasHelp": "讓此任務畫布顯示在工作區導航中。",
+  "promoteCanvasUnavailable": "有效版本獲批准後才能提升。",
+  "openInNewTab": "在新標籤頁中開啟",
+  "openInNewTabHelp": "在聚焦的瀏覽器標籤頁中開啟此畫布。",
+  "promoteCanvasDescription": "將 {{title}} 移至工作區範圍前，請先查看權限。",
+  "loadingPermissions": "正在載入請求的權限",
+  "promotionScopeChange": "提升後，此畫布會出現在工作區導航中。",
+  "noAdditionalPermissions": "未請求其他權限。",
   "sharedState": "共享狀態",
   "promotingCanvas": "正在提升畫布",
   "confirmPromotion": "確認提升",
-  "releasesAndPermissions": "版本及權限",
-  "releasesAndPermissionsHelp": "檢視版本並批准要求的權限。",
-  "releasesDescription": "檢視此畫布的待處理權限及保留版本。",
+  "releasesAndPermissions": "版本和權限",
+  "releasesAndPermissionsHelp": "查看版本並批准請求的權限。",
+  "releasesDescription": "查看此畫布的待處理權限和保留版本。",
   "loadingReleases": "正在載入版本",
   "noReleases": "沒有可用版本。",
   "approveRelease": "批准版本",
   "rejectRelease": "拒絕版本",
-  "rollbackRelease": "回復版本",
+  "rollbackRelease": "回滾版本",
   "permissionDeclaration": "已聲明的權限",
   "missingPermissions": "仍需的權限",
   "retry": "重試",
-  "refresh": "重新整理",
-  "statusActive": "使用中",
-  "statusArchived": "已封存",
+  "refresh": "刷新",
+  "statusActive": "活動",
+  "statusArchived": "已歸檔",
   "statusPending": "待處理",
   "statusDisabled": "已停用",
   "statusError": "錯誤",
   "workspaceCanvases": "工作區畫布",
   "workspaceCanvasesDescription": "管理 {{workspace}} 中可用的畫布。",
   "loadingCanvases": "正在載入工作區畫布",
-  "noWorkspaceCanvases": "工作區中暫時沒有畫布。",
-  "activeCanvases": "使用中畫布",
-  "archivedCanvases": "已封存畫布",
-  "permissionsAndReleases": "權限及版本",
+  "noWorkspaceCanvases": "工作區中還沒有畫布。",
+  "activeCanvases": "活動畫布",
+  "archivedCanvases": "已歸檔畫布",
+  "permissionsAndReleases": "權限和版本",
   "openCanvas": "開啟畫布",
-  "restoreCanvas": "還原",
-  "archiveCanvas": "封存",
+  "restoreCanvas": "恢復",
+  "archiveCanvas": "歸檔",
   "removeCanvas": "移除",
-  "removeCanvasDescription": "移除 {{title}} 及其畫布版本？此操作無法復原。",
-  "runtimeTokenExpired": "執行階段權杖已過期。請重試。",
+  "removeCanvasDescription": "移除 {{title}} 及其畫布版本？此操作無法撤銷。",
+  "runtimeTokenExpired": "執行時權杖已過期。請重試。",
   "promotionSourceScope": "來源範圍",
   "promotionSourceActor": "來源操作者",
-  "promotionSourceTask": "來源工作",
+  "promotionSourceTask": "來源任務",
   "promotionSourceSession": "來源工作階段",
   "promotionTargetScope": "目標範圍",
   "promotionPlacement": "工作區位置",
@@ -81,6 +81,6 @@
   "permissionWrites": "API 寫入",
   "permissionEvents": "事件",
   "permissionExternalOrigins": "外部來源",
-  "archivedCanvasActionHelp": "此畫布已封存。請先在工作區設定中還原，然後再作出變更。",
-  "disabledCanvasActionHelp": "此畫布已停用。請先啟用，然後再作出變更。"
+  "archivedCanvasActionHelp": "此畫布已歸檔。請先在工作區設定中恢復它，然後再進行更改。",
+  "disabledCanvasActionHelp": "此畫布已停用。請先啓用它，然後再進行更改。"
 }

apps/web/src/locales/zh-hk/executors.json

@@ -395,8 +395,8 @@
   "portableConfigNotFound": "未找到",
   "portableConfigNotFoundHint": "這只是編輯提示。你可以先儲存設定，稍後再新增該檔案。",
   "portableConfigTitle": "代理程式設定檔",
-  "allowUserNamespacesTitle": "使用者命名空間支援",
-  "allowUserNamespacesDescription": "允許在容器內建立無特權的使用者命名空間和執行掛載操作。啟用如 bwrap 的沙盒工具。",
-  "allowUserNamespacesNote": "此設定僅影響新建立的容器。現有任務環境必須重設才能使變更生效。",
-  "allowUserNamespacesWarning": "這會為選擇啟用的容器停用 Docker 預設的 AppArmor 限制。只應為需要使用者命名空間沙盒的可信代理執行環境啟用。"
+  "allowUserNamespacesTitle": "用戶命名空間支援",
+  "allowUserNamespacesDescription": "允許在容器內建立無特權的用戶命名空間和執行掛載操作。啓用類似 bwrap 的沙箱工具。",
+  "allowUserNamespacesNote": "此設定僅影響新建立的容器。現有任務環境必須重置才能使更改生效。",
+  "allowUserNamespacesWarning": "這會為選擇啓用的容器停用 Docker 預設的 AppArmor 限制。僅為需要用戶命名空間沙箱的可信代理執行環境啓用。"
 }

apps/web/src/locales/zh-hk/system.json

@@ -534,7 +534,7 @@
   "versionLatest": "最新",
   "versionTitle": "版本",
   "versionViewUpdates": "查看更新",
-  "messageQueueAutoMergeDescription": "設定所有工作階段的預設值。工作階段會沿用此值，直到您在該工作階段的佇列中變更自動合併。",
+  "messageQueueAutoMergeDescription": "設定所有工作階段的預設值。工作階段會沿用此值，直到您在該工作階段的佇列中更改自動合併。",
   "messageQueueAutoMergeNotice": "如果某條訊息的來源不同，或任務、模型、模式、元數據或共享限制不兼容，它會保持為單獨的排隊訊息。這隻適用於新接收的訊息，不會改變手動合併控制。",
   "messageQueueAutoMergeToggleLabel": "自動合併連續訊息"
 }

apps/web/src/locales/zh-hk/task.json

@@ -540,9 +540,9 @@
   "htmlPreviewError": "無法呈現 HTML 預覽。",
   "htmlPreviewLoading": "正在載入 HTML 預覽...",
   "htmlPreviewPublishFailed": "無法開啟 HTML 預覽。請重試。",
-  "htmlPreviewTooLarge": "此 HTML 緩衝區太大，無法預覽。請顯示程式碼，並使用較小的檔案重試。",
+  "htmlPreviewTooLarge": "此 HTML 緩衝區太大，無法預覽。請顯示程式碼並使用較小的檔案重試。",
   "htmlPreviewTrustedCode": "預覽會使用瀏覽器面板的功能執行工作區程式碼。請只預覽你信任的檔案。",
-  "htmlPreviewUnavailable": "HTML 預覽工作階段不可用。請檢查工作項工作階段並重試。",
+  "htmlPreviewUnavailable": "HTML 預覽工作階段不可用。請檢查任務工作階段並重試。",
   "refreshHtmlPreview": "刷新 HTML 預覽",
   "failedToLoadRevision": "載入修訂失敗",
   "failedToLoadRevisionContent": "載入修訂內容失敗",
@@ -922,7 +922,7 @@
   "selectedAgentNotConfiguredFor": "{{agent}} 未在 {{target}} 上設定。請在「設定 → 執行器」中設定代理程式認證資料。",
   "selectedAgentProfileFallback": "所選代理程式設定檔",
   "selectedAgentProfileFallbackInline": "所選代理程式設定檔",
-  "selectedAgentProfileUnavailable": "{{agent}} 不可用。請選擇相容的代理程式設定檔。",
+  "selectedAgentProfileUnavailable": "{{agent}} 不可用。請選擇兼容的代理程式設定檔。",
   "noContent": "無內容",
   "noDecisionYet": "尚未決定",
   "noDocumentsFound": "未找到文檔。",
@@ -1963,7 +1963,7 @@
   "modelSelectionReasonCatalogEmpty": "執行器未公佈模型目錄。",
   "modelSelectionReasonFallbackNotAdvertised": "執行器未公佈已儲存的備選模型。",
   "modelSelectionReasonRequestedNotAdvertised": "執行器未公佈已儲存的模型。",
-  "modelSelectionReasonUniqueVariation": "執行器套用了已儲存模型唯一公佈的變體。",
+  "modelSelectionReasonUniqueVariation": "執行器應用了已儲存模型唯一公佈的變體。",
   "modelSelectionReasonUnknown": "{{reason}}",
   "modelSelectionReasonUnsupported": "該執行器不支援選擇模型。",
   "modelSelectionRemediationAgentVersion": "請檢查執行器中的代理程式版本。",
@@ -2010,7 +2010,7 @@
   "promptHistoryPromptLabelGeneric": "提示",
   "promptHistoryEmpty": "暫無提示。",
   "launchDestinationHelpLabel": "了解任務開始步驟",
-  "launchDestinationHelp": "任務會在此工作流程步驟開始。有任務描述時，自動啓動代理程式的步驟可能優先於已設定的開始步驟。",
+  "launchDestinationHelp": "任務會在此工作流程步驟開始。有任務描述時，自動啓動代理程式的步驟可能優先於設定的開始步驟。",
   "launchErrorBaseBranchMissing": "任務無法啓動，因為基礎分支不可用。",
   "launchErrorDefaultBranchUnresolved": "無法解析儲存庫的預設分支。",
   "launchErrorPrAlreadyClosed": "任務關聯的拉取要求已關閉。",
@@ -2018,7 +2018,7 @@
   "launchErrorGeneric": "任務無法啓動。",
   "launchErrorSessionPreview": "任務啓動需要處理。",
   "launchNeedsAttention": "啓動需要處理",
-  "launchErrorNoChanges": "任務或分支設定未有變更。",
+  "launchErrorNoChanges": "任務或分支設定未更改。",
   "launchPromptPreview": "啓動提示詞預覽",
   "retryWithDefaultBranch": "使用預設分支重試",
   "pickBaseBranch": "選擇基礎分支",

apps/web/src/locales/zh-hk/workspaces.json

@@ -47,7 +47,7 @@
   "devScriptHelp": "用於啓動此儲存庫的預覽開發伺服器。使用 <0>{{port}}</0> 自動分配端口。",
   "discoverRepositoryDescription": "選擇已發現的儲存庫，或提供絕對路徑進行驗證。",
   "chooseFoldersToDiscoverRepositories": "選擇用於發現儲存庫的資料夾",
-  "chooseFoldersToDiscoverRepositoriesDescription": "選取主目錄或更窄的資料夾。Kandev 只會在你使用儲存庫選擇功能時掃描它。",
+  "chooseFoldersToDiscoverRepositoriesDescription": "選擇主目錄或更小的資料夾。Kandev 只會在你使用儲存庫選擇功能時掃描它。",
   "continueHomeDiscovery": "繼續發現主目錄中的儲存庫",
   "homeDiscoveryConfirmationDescription": "此安裝以前會搜尋主目錄。只有在你允許發現主目錄時才繼續。",
   "discoveredRepositories": "已發現的儲存庫",
@@ -96,10 +96,10 @@
   "patternSyntax": "模式語法",
   "remoteRepository": "遠端儲存庫",
   "repositories": "儲存庫",
-  "refreshRepositories": "重新整理儲存庫",
-  "reconnectDiscoveryRoot": "重新連線",
+  "refreshRepositories": "刷新儲存庫",
+  "reconnectDiscoveryRoot": "重新連接",
   "removeDiscoveryRoot": "移除",
-  "repositoryDiscoveryNoRoots": "選擇資料夾以開始發現儲存庫。",
+  "repositoryDiscoveryNoRoots": "選擇一個資料夾以開始發現儲存庫。",
   "resourceCount_one": "{{count}} 個資源",
   "resourceCount_other": "{{count}} 個資源",
   "repositoriesInThisWorkspace": "此工作區中的儲存庫",

apps/web/src/locales/zh-tw/canvases.json

@@ -5,72 +5,72 @@
   "setUpCanvas": "設定畫布",
   "createCanvas": "建立畫布",
   "createCanvasTaskTitle": "建立畫布",
-  "createCanvasTaskPrompt": "建立精緻的互動式畫布應用程式。使用 Kandev 畫布製作流程，並發佈第一個版本供審閱。",
+  "createCanvasTaskPrompt": "在 Kandev 中為我描述的應用建立一個互動式畫布。如果缺少應用目標，詢問畫布需要展示或執行什麼。編寫應用檔案前，先查詢 Kandev 畫布 MCP 工具。如果工具不可呼叫，使用原生工具搜尋查詢「kandev canvas」，或檢查用戶端可用的 MCP 目錄。在編寫應用檔案前，先在 Kandev 中建立草稿。呼叫 `create_canvas_kandev` 建立草稿並擷取源目錄。無需路徑引數呼叫一次 `read_canvas_authoring_skill_kandev`。在返回的目錄中構建，並使用已授權的 Kandev 即時資料展示領域檢視。呼叫 `publish_canvas_kandev` 並處理驗證錯誤。報告畫布標識，以及版本是已啟用、等待權限稽核還是釋出失敗。如果釋出失敗，報告錯誤，不要聲稱畫布已釋出。如果工作區存取需要提升權限，說明仍需使用者執行的操作。本地構建成功不會在 Kandev 中釋出畫布。如果工具仍不可用，報告限制，不要聲稱工作區檔案就是 Kandev 畫布。",
   "loadingCanvas": "正在載入畫布",
-  "loadingCanvasDescription": "正在載入畫布中繼資料。",
-  "pendingFirstRelease": "等待第一個版本",
-  "pendingFirstReleaseDescription": "此畫布尚未有已發佈的版本。",
-  "pendingPermission": "需要審查權限",
-  "pendingPermissionDescription": "活動版本需要獲得權限核准後才能開啟。",
-  "loadingRuntime": "正在載入畫布執行階段",
-  "loadingRuntimeDescription": "正在準備已發佈的畫布應用程式。",
+  "loadingCanvasDescription": "正在載入畫布後設資料。",
+  "pendingFirstRelease": "等待首個版本",
+  "pendingFirstReleaseDescription": "此畫布還沒有已釋出的版本。",
+  "pendingPermission": "需要稽核權限",
+  "pendingPermissionDescription": "活動版本需要獲得權限批准後才能開啟。",
+  "loadingRuntime": "正在載入畫布執行時",
+  "loadingRuntimeDescription": "正在準備已釋出的畫布應用。",
   "ready": "已就緒",
-  "readyDescription": "畫布應用程式已就緒。",
+  "readyDescription": "畫布應用已就緒。",
   "offline": "畫布離線",
-  "offlineDescription": "無法存取畫布執行階段。請檢查連線後重試。",
+  "offlineDescription": "無法存取畫布執行時。請檢查連線後重試。",
   "invalidRelease": "版本無效",
   "invalidReleaseDescription": "活動版本未通過驗證。請檢視版本或編輯畫布。",
-  "unavailable": "畫布無法使用",
-  "unavailableDescription": "活動畫布版本無法使用。",
-  "archived": "畫布已封存",
-  "archivedDescription": "請在工作區設定中還原此畫布，然後再次開啟。",
+  "unavailable": "畫布不可用",
+  "unavailableDescription": "活動畫布版本不可用。",
+  "archived": "畫布已歸檔",
+  "archivedDescription": "請在工作區設定中恢復此畫布，然後再次開啟。",
   "loadFailed": "載入畫布失敗。",
-  "actionFailed": "畫布動作失敗。",
-  "canvasActions": "畫布動作",
+  "actionFailed": "畫布操作失敗。",
+  "canvasActions": "畫布操作",
   "editCanvas": "編輯畫布",
-  "editCanvasHelp": "開啟畫布創作工作。",
+  "editCanvasHelp": "開啟畫布創作任務。",
   "promoteCanvas": "提升畫布",
   "promoteCanvasHelp": "讓此任務畫布顯示在工作區導覽中。",
-  "promoteCanvasUnavailable": "有效版本獲核准後才能提升。",
-  "openInNewTab": "在新分頁中開啟",
-  "openInNewTabHelp": "在專注的瀏覽器分頁中開啟此畫布。",
+  "promoteCanvasUnavailable": "有效版本獲批准後才能提升。",
+  "openInNewTab": "在新標籤頁中開啟",
+  "openInNewTabHelp": "在聚焦的瀏覽器標籤頁中開啟此畫布。",
   "promoteCanvasDescription": "將 {{title}} 移至工作區範圍前，請先檢視權限。",
-  "loadingPermissions": "正在載入要求的權限",
+  "loadingPermissions": "正在載入請求的權限",
   "promotionScopeChange": "提升後，此畫布會出現在工作區導覽中。",
-  "noAdditionalPermissions": "未要求其他權限。",
+  "noAdditionalPermissions": "未請求其他權限。",
   "sharedState": "共享狀態",
   "promotingCanvas": "正在提升畫布",
   "confirmPromotion": "確認提升",
   "releasesAndPermissions": "版本和權限",
-  "releasesAndPermissionsHelp": "檢視版本並核准要求的權限。",
+  "releasesAndPermissionsHelp": "檢視版本並批准請求的權限。",
   "releasesDescription": "檢視此畫布的待處理權限和保留版本。",
   "loadingReleases": "正在載入版本",
   "noReleases": "沒有可用版本。",
-  "approveRelease": "核准版本",
+  "approveRelease": "批准版本",
   "rejectRelease": "拒絕版本",
-  "rollbackRelease": "回復版本",
+  "rollbackRelease": "回滾版本",
   "permissionDeclaration": "已宣告的權限",
   "missingPermissions": "仍需的權限",
   "retry": "重試",
   "refresh": "重新整理",
   "statusActive": "活動",
-  "statusArchived": "已封存",
+  "statusArchived": "已歸檔",
   "statusPending": "待處理",
   "statusDisabled": "已停用",
   "statusError": "錯誤",
   "workspaceCanvases": "工作區畫布",
   "workspaceCanvasesDescription": "管理 {{workspace}} 中可用的畫布。",
   "loadingCanvases": "正在載入工作區畫布",
-  "noWorkspaceCanvases": "工作區中尚無畫布。",
+  "noWorkspaceCanvases": "工作區中還沒有畫布。",
   "activeCanvases": "活動畫布",
-  "archivedCanvases": "已封存畫布",
+  "archivedCanvases": "已歸檔畫布",
   "permissionsAndReleases": "權限和版本",
   "openCanvas": "開啟畫布",
-  "restoreCanvas": "還原",
-  "archiveCanvas": "封存",
+  "restoreCanvas": "恢復",
+  "archiveCanvas": "歸檔",
   "removeCanvas": "移除",
-  "removeCanvasDescription": "移除 {{title}} 及其畫布版本？此動作無法復原。",
-  "runtimeTokenExpired": "執行階段權杖已過期。請重試。",
+  "removeCanvasDescription": "移除 {{title}} 及其畫布版本？此操作無法撤銷。",
+  "runtimeTokenExpired": "執行時權杖已過期。請重試。",
   "promotionSourceScope": "來源範圍",
   "promotionSourceActor": "來源操作者",
   "promotionSourceTask": "來源任務",
@@ -81,6 +81,6 @@
   "permissionWrites": "API 寫入",
   "permissionEvents": "事件",
   "permissionExternalOrigins": "外部來源",
-  "archivedCanvasActionHelp": "此畫布已封存。請先在工作區設定中還原，然後再進行變更。",
-  "disabledCanvasActionHelp": "此畫布已停用。請先啟用，然後再進行變更。"
+  "archivedCanvasActionHelp": "此畫布已歸檔。請先在工作區設定中恢復它，然後再進行更改。",
+  "disabledCanvasActionHelp": "此畫布已停用。請先啟用它，然後再進行更改。"
 }

apps/web/src/locales/zh-tw/executors.json

@@ -395,8 +395,8 @@
   "portableConfigNotFound": "未找到",
   "portableConfigNotFoundHint": "這只是編輯提示。你可以先儲存設定，稍後再新增該檔案。",
   "portableConfigTitle": "代理程式設定檔",
-  "allowUserNamespacesTitle": "使用者命名空間支援",
-  "allowUserNamespacesDescription": "允許在容器內建立無特權的使用者命名空間和執行掛載操作。啟用如 bwrap 的沙盒工具。",
-  "allowUserNamespacesNote": "此設定僅影響新建立的容器。現有任務環境必須重設才能使變更生效。",
-  "allowUserNamespacesWarning": "這會為選擇啟用的容器停用 Docker 預設的 AppArmor 限制。僅應為需要使用者命名空間沙盒的可信代理執行環境啟用。"
+  "allowUserNamespacesTitle": "使用者名稱空間支援",
+  "allowUserNamespacesDescription": "允許在容器內建立無特權的使用者名稱空間和執行掛載操作。啟用類似 bwrap 的沙箱工具。",
+  "allowUserNamespacesNote": "此設定僅影響新建立的容器。現有任務環境必須重置才能使更改生效。",
+  "allowUserNamespacesWarning": "這會為選擇啟用的容器停用 Docker 預設的 AppArmor 限制。僅為需要使用者名稱空間沙箱的可信代理執行環境啟用。"
 }

apps/web/src/locales/zh-tw/system.json

@@ -534,7 +534,7 @@
   "versionLatest": "最新",
   "versionTitle": "版本",
   "versionViewUpdates": "檢視更新",
-  "messageQueueAutoMergeDescription": "設定所有工作階段的預設值。工作階段會沿用此值，直到您在該工作階段的佇列中變更自動合併。",
+  "messageQueueAutoMergeDescription": "設定所有工作階段的預設值。工作階段會沿用此值，直到您在該工作階段的佇列中更改自動合併。",
   "messageQueueAutoMergeNotice": "如果某條訊息的來源不同，或任務、模型、模式、後設資料或共享限制不相容，它會保持為單獨的排隊訊息。這隻適用於新接收的訊息，不會改變手動合併控制。",
   "messageQueueAutoMergeToggleLabel": "自動合併連續訊息"
 }

apps/web/src/locales/zh-tw/task.json

@@ -540,9 +540,9 @@
   "htmlPreviewError": "無法呈現 HTML 預覽。",
   "htmlPreviewLoading": "正在載入 HTML 預覽...",
   "htmlPreviewPublishFailed": "無法開啟 HTML 預覽。請重試。",
-  "htmlPreviewTooLarge": "此 HTML 緩衝區太大，無法預覽。請顯示程式碼，並使用較小的檔案重試。",
+  "htmlPreviewTooLarge": "此 HTML 緩衝區太大，無法預覽。請顯示程式碼並使用較小的檔案重試。",
   "htmlPreviewTrustedCode": "預覽會使用瀏覽器面板的功能執行工作區程式碼。請只預覽你信任的檔案。",
-  "htmlPreviewUnavailable": "HTML 預覽工作階段無法使用。請檢查工作項工作階段並重試。",
+  "htmlPreviewUnavailable": "HTML 預覽工作階段不可用。請檢查任務工作階段並重試。",
   "refreshHtmlPreview": "重新整理 HTML 預覽",
   "failedToLoadRevision": "載入修訂失敗",
   "failedToLoadRevisionContent": "載入修訂內容失敗",
@@ -922,7 +922,7 @@
   "selectedAgentNotConfiguredFor": "{{agent}} 未在 {{target}} 上設定。請在「設定 → 執行器」中設定代理程式認證資訊。",
   "selectedAgentProfileFallback": "所選代理程式設定檔",
   "selectedAgentProfileFallbackInline": "所選代理程式設定檔",
-  "selectedAgentProfileUnavailable": "{{agent}} 無法使用。請選擇相容的代理程式設定檔。",
+  "selectedAgentProfileUnavailable": "{{agent}} 不可用。請選擇相容的代理程式設定檔。",
   "noContent": "無內容",
   "noDecisionYet": "尚未決定",
   "noDocumentsFound": "未找到檔案。",
@@ -1963,7 +1963,7 @@
   "modelSelectionReasonCatalogEmpty": "執行器未公佈模型目錄。",
   "modelSelectionReasonFallbackNotAdvertised": "執行器未公佈已儲存的備選模型。",
   "modelSelectionReasonRequestedNotAdvertised": "執行器未公佈已儲存的模型。",
-  "modelSelectionReasonUniqueVariation": "執行器套用了已儲存模型唯一公佈的變體。",
+  "modelSelectionReasonUniqueVariation": "執行器應用了已儲存模型唯一公佈的變體。",
   "modelSelectionReasonUnknown": "{{reason}}",
   "modelSelectionReasonUnsupported": "該執行器不支援選擇模型。",
   "modelSelectionRemediationAgentVersion": "請檢查執行器中的代理程式版本。",
@@ -2009,8 +2009,8 @@
   "promptHistoryPromptLabel": "提示 {{number}}",
   "promptHistoryPromptLabelGeneric": "提示",
   "promptHistoryEmpty": "暫無提示。",
-  "launchDestinationHelpLabel": "瞭解任務開始步驟",
-  "launchDestinationHelp": "任務會在此工作流程步驟開始。有任務描述時，自動啟動代理程式的步驟可能優先於已設定的開始步驟。",
+  "launchDestinationHelpLabel": "了解任務開始步驟",
+  "launchDestinationHelp": "任務會在此工作流程步驟開始。有任務描述時，自動啟動代理程式的步驟可能優先於設定的開始步驟。",
   "launchErrorBaseBranchMissing": "任務無法啟動，因為基礎分支不可用。",
   "launchErrorDefaultBranchUnresolved": "無法解析儲存庫的預設分支。",
   "launchErrorPrAlreadyClosed": "任務關聯的提取要求已關閉。",
@@ -2018,7 +2018,7 @@
   "launchErrorGeneric": "任務無法啟動。",
   "launchErrorSessionPreview": "任務啟動需要處理。",
   "launchNeedsAttention": "啟動需要處理",
-  "launchErrorNoChanges": "任務或分支設定沒有變更。",
+  "launchErrorNoChanges": "任務或分支設定未更改。",
   "launchPromptPreview": "啟動提示詞預覽",
   "retryWithDefaultBranch": "使用預設分支重試",
   "pickBaseBranch": "選擇基礎分支",

apps/web/src/locales/zh-tw/workspaces.json

@@ -47,7 +47,7 @@
   "devScriptHelp": "用於啟動此儲存庫的預覽開發伺服器。使用 <0>{{port}}</0> 自動分配埠。",
   "discoverRepositoryDescription": "選擇已發現的儲存庫，或提供絕對路徑進行驗證。",
   "chooseFoldersToDiscoverRepositories": "選擇用於發現儲存庫的資料夾",
-  "chooseFoldersToDiscoverRepositoriesDescription": "選取主目錄或更窄的資料夾。Kandev 只會在你使用儲存庫選擇功能時掃描它。",
+  "chooseFoldersToDiscoverRepositoriesDescription": "選擇主目錄或更小的資料夾。Kandev 只會在你使用儲存庫選擇功能時掃描它。",
   "continueHomeDiscovery": "繼續發現主目錄中的儲存庫",
   "homeDiscoveryConfirmationDescription": "此安裝以前會搜尋主目錄。只有在你允許發現主目錄時才繼續。",
   "discoveredRepositories": "已發現的儲存庫",
@@ -99,7 +99,7 @@
   "refreshRepositories": "重新整理儲存庫",
   "reconnectDiscoveryRoot": "重新連線",
   "removeDiscoveryRoot": "移除",
-  "repositoryDiscoveryNoRoots": "選擇資料夾以開始發現儲存庫。",
+  "repositoryDiscoveryNoRoots": "選擇一個資料夾以開始發現儲存庫。",
   "resourceCount_one": "{{count}} 個資源",
   "resourceCount_other": "{{count}} 個資源",
   "repositoriesInThisWorkspace": "此工作區中的儲存庫",

docs/plans/mcp-discovery-canvas-prompts/plan.md

@@ -0,0 +1,126 @@
+---
+created: 2026-09-08
+status: complete
+requirements:
+  - REQ-AGENTS-MCP-DISCOVERY-001
+  - REQ-AGENTS-MCP-DISCOVERY-002
+  - REQ-CANVASES-AGENT-WEB-APPS-001
+  - REQ-CANVASES-AGENT-WEB-APPS-009
+system_design:
+  - ../../specs/agents/system-design/mcp-tool-discovery-guidance.md
+  - ../../specs/canvases/system-design/agent-authored-web-apps.md
+legacy_specs: []
+---
+
+# Implementation plan: MCP discovery and canvas prompts
+
+## Overview
+
+Make Kandev tool discovery explicit, reduce repeated tool descriptions, and
+direct canvas requests through draft creation and publication.
+
+The failed task `efb43c76-a2ab-44cf-9169-b38fb5e3da9f` created a standalone app.
+Its conversation contained no canvas calls. Its original MCP server exposed
+seven canvas tools, but its injected task prompt omitted all canvas guidance.
+The canvas list was empty. These observations motivate the prompt changes.
+
+Agents owns the shared discovery contract because it spans task operations and
+clients. Canvases owns its creation preset and authoring outcome. The paired
+specifications link those independent contracts without duplicating ownership.
+
+## Scope
+
+### In scope
+
+- Conditional client-native discovery with an available-catalog fallback.
+- A compact task prompt with essential workflow and authorization rules.
+- Canvas instructions derived from the resolved session MCP profile.
+- A stronger localized Create canvas preset in the existing task dialog.
+- Targeted prompt, producer, catalog, desktop, and mobile verification.
+
+### Out of scope
+
+- MCP transport, permission, scope, promotion, or runtime flag changes.
+- A new tool-search API or provider-specific discovery adapter.
+- Office/configuration prompt compaction or a new canvas editor.
+- Repairing the previous task, publishing its files, or contacting its agent.
+
+## Technical approach
+
+Task 01 changes `config/prompts/kandev-context.md` and `internal/sysprompt`.
+It preserves critical dynamic sections and replaces routine tool listings with
+discovery guidance. It wires the canvas option through all existing task
+prompt producers using the executor's resolved MCP profile.
+
+Task 02 changes the localized canvas preset. `CanvasTaskCreateLauncher` keeps
+the normal task dialog and scratch/local defaults. It adds tests against real
+catalog text, because the current component test substitutes a mock sentence.
+The mobile E2E currently replaces the preset with explicit MCP commands, so
+that test alone cannot detect weak authoring guidance.
+
+The system designs contain the proposed discovery and canvas wording. The
+implementation wires the capability projection through task launch, prepared
+session launch, workflow context reset, and the first direct message path.
+
+## Tests
+
+| Criteria | Evidence |
+| --- | --- |
+| `AC-AGENTS-MCP-DISCOVERY-001.1` through `.6` | New focused sysprompt discovery tests. |
+| `AC-AGENTS-MCP-DISCOVERY-002.1`, `.2`, `.5` | Compact size and preserved workflow assertions. |
+| `AC-AGENTS-MCP-DISCOVERY-002.3`, `.4` | Producer tests for start, prepared start, and reset; MCP inventory tests. |
+| `AC-CANVASES-AGENT-WEB-APPS-001.10` through `.12` | Gated authoring instruction tests and negative profile cases. |
+| `AC-CANVASES-AGENT-WEB-APPS-009.6`, `.8` | Real locale preset contract tests with exact tool identifiers. |
+| `AC-CANVASES-AGENT-WEB-APPS-009.7` | Desktop/mobile dialog and submitted-description tests. |
+
+## E2E tests
+
+Task 02 extends the guided creation case in
+`apps/web/e2e/tests/canvas/mobile-plugin-canvas.spec.ts` and adds the equivalent
+focused case in `plugin-canvas.spec.ts`. The projects are `mobile-chrome` and
+`chromium`. Assert the actual preset before editing it, then assert that the
+submitted task retains the edited description.
+
+Use isolated managed runners. Existing mock lifecycle coverage proves canvas
+registration and publication. It does not prove an external model's compliance
+with the prompt. Do not report that stronger claim from deterministic tests.
+
+## Work orders
+
+- [x] [Task 01: Compact MCP discovery guidance](task-01-mcp-discovery-guidance.md) — done
+- [x] [Task 02: Canvas creation preset](task-02-canvas-creation-preset.md) — done
+
+Both work orders are sequential. Implementation requires the later explicit
+request specified by the repository workflow.
+
+## Verification results
+
+- `rtk python3 scripts/lint-spec-files.test.py`: 30 tests passed.
+- `rtk python3 scripts/lint-spec-files.py --all`: all specification files passed.
+- `rtk git diff --check`: passed.
+
+Implementation verification is complete. The new prompt producers and locale
+contract tests pass, and focused desktop and mobile E2E coverage confirms the
+editable preset reaches the task creation flow and retains user edits.
+
+The prompt file is 2,744 bytes, or 2,743 bytes after loading its trailing
+newline. The rendered ordinary context is 4,394 bytes, versus the recorded
+4,804-byte pre-compaction baseline, for a 410-byte reduction. Canvas-enabled
+context is 4,867 bytes. These measurements are bytes, not model tokens.
+
+## Risks
+
+- Removing tool descriptions can erase a mandatory workflow rule. Retain its
+  current condition and test it independently from prose formatting.
+- A global canvas flag alone can advertise tools to an excluded profile.
+  Reuse the existing profile resolver and cover negative surfaces.
+- Exact text snapshots can hide missing behavior behind frequent rewrites.
+  Assert required instructions and invariant tool names instead.
+- Existing models can still ignore instructions. Prompt delivery tests do not
+  guarantee model compliance.
+
+## Documentation impact
+
+Internal requirements, designs, and work orders change in this package.
+Public canvas usage and navigation remain the same. The implementation must
+check existing public canvas guidance before its final handoff.

docs/plans/mcp-discovery-canvas-prompts/task-01-mcp-discovery-guidance.md

@@ -0,0 +1,132 @@
+---
+id: "01-mcp-discovery-guidance"
+title: "Compact MCP discovery guidance"
+status: done
+wave: 1
+depends_on: []
+plan: "plan.md"
+requirements:
+  - REQ-AGENTS-MCP-DISCOVERY-001
+  - REQ-AGENTS-MCP-DISCOVERY-002
+  - REQ-CANVASES-AGENT-WEB-APPS-001
+acceptance_criteria:
+  - AC-AGENTS-MCP-DISCOVERY-001.1
+  - AC-AGENTS-MCP-DISCOVERY-001.2
+  - AC-AGENTS-MCP-DISCOVERY-001.3
+  - AC-AGENTS-MCP-DISCOVERY-001.4
+  - AC-AGENTS-MCP-DISCOVERY-001.5
+  - AC-AGENTS-MCP-DISCOVERY-001.6
+  - AC-AGENTS-MCP-DISCOVERY-002.1
+  - AC-AGENTS-MCP-DISCOVERY-002.2
+  - AC-AGENTS-MCP-DISCOVERY-002.3
+  - AC-AGENTS-MCP-DISCOVERY-002.4
+  - AC-AGENTS-MCP-DISCOVERY-002.5
+  - AC-CANVASES-AGENT-WEB-APPS-001.10
+  - AC-CANVASES-AGENT-WEB-APPS-001.11
+  - AC-CANVASES-AGENT-WEB-APPS-001.12
+system_design:
+  - ../../specs/agents/system-design/mcp-tool-discovery-guidance.md
+  - ../../specs/canvases/system-design/agent-authored-web-apps.md
+---
+
+# Task 01: Compact MCP discovery guidance
+
+## Summary
+
+Replace the partial catalog with discovery instructions and essential workflow
+guidance. Add canvas authoring instructions only for eligible task sessions.
+
+## In scope
+
+- Use the proposed discovery wording and essential-section table in the design.
+- Add a canvas option to `KandevContextOptions` and resolve it through the
+  executor's existing `resolveTaskSessionMCPProfile` path.
+- Cover prepared-session launch, normal launch, and workflow context reset.
+- Preserve marker canonicalization, user content, task/session identities,
+  question barriers, title ownership, completion, autopilot, and delegation.
+- Preserve coordinator interrupt/stop/restart guidance and its condition.
+- Use TDD for option and producer changes. Add small dedicated test files.
+
+## Out of scope
+
+- Tool registration changes or duplicate feature-flag state.
+- Canvas locale changes, live-session restarts, or unsolicited messages.
+
+## Acceptance
+
+1. A missing callable tool triggers search/catalog guidance, while directly
+   available tools need no redundant discovery. The raw template is at most
+   2,800 UTF-8 bytes, compared with the 3,482-byte baseline.
+2. All task prompt producers advertise canvas operations exactly when the
+   resolved session profile exposes them. Recorded/dispatched text agrees.
+3. Existing mandatory rules and MCP inventories remain intact. Tests cover
+   flag-off, Office, configuration, automation, and passthrough cases.
+
+## Verification
+
+From `apps/backend`:
+
+```bash
+rtk go test ./internal/sysprompt ./internal/prompts ./internal/mcp/profile ./internal/mcp/server -count=1
+rtk go test ./internal/orchestrator ./internal/orchestrator/executor -run 'Test.*(CanvasPrompt|MCPDiscovery|KandevContext|StartCreatedSession|AutoStart.*Context|MCPProfile)' -count=1
+```
+
+Name new producer cases with `CanvasPrompt` so the focused command selects
+every new case. Include `StartTask` and reset paths within those cases.
+Record normal and canvas-enabled rendered sizes in Results. Run the failing
+new tests before implementing their behavior.
+
+## Files likely touched
+
+- `apps/backend/config/prompts/kandev-context.md`
+- `apps/backend/internal/sysprompt/sysprompt.go`
+- `apps/backend/internal/sysprompt/mcp_discovery_test.go` (new)
+- `apps/backend/internal/sysprompt/sysprompt_test.go`
+- `apps/backend/internal/orchestrator/task_operations.go`
+- `apps/backend/internal/orchestrator/event_handlers_workflow.go`
+- `apps/backend/internal/orchestrator/canvas_prompt_test.go` (new)
+- `apps/backend/internal/orchestrator/executor/executor_execute.go`
+- `apps/backend/internal/orchestrator/executor/canvas_prompt_test.go` (new)
+
+## Dependencies
+
+None.
+
+## Risks
+
+The formatter currently has no resolved profile input. Keep any query narrow
+and reuse the existing resolver. Do not infer eligibility from client identity
+or add a second canvas flag owner.
+
+## Parallelism
+
+`sequential`
+
+## Inputs
+
+- Both linked requirements and designs.
+- `TestFormatKandevContext_TitleToolFollowsCapability` and question barrier tests.
+- `wrapCreatedSessionPrompt`, `applyLaunchPromptContext`, and workflow reset.
+- Typed MCP profile and canonical tool-name ADRs linked by the agent design.
+
+## Results
+
+- Compacted `kandev-context.md` to a 2,743-byte loaded UTF-8 template (2,744
+  bytes on disk) while retaining
+  task/session identity, question barriers, title ownership, completion gates,
+  autopilot, delegation, plan, rich-output, and coordinator guidance.
+- Added conditional canvas authoring guidance and reused the executor's typed
+  MCP profile resolver for normal launch, prepared-session launch, workflow
+  context reset, and the first direct message path. Office, configuration,
+  automation, and passthrough sessions remain excluded.
+- Added discovery, profile, prepared-launch, reset, and prompt-rendering
+  regression coverage. StartTask and StartCreatedSession now test the real
+  producer paths, and direct-message admission passes one server-resolved
+  canvas projection to both persistence and launch. Lookup failure, pair
+  mismatch, and excluded Office/configuration surfaces are covered.
+- Replaced inline rich-output schemas and examples with a discovery routing
+  rule. The ordinary rendered context is 4,394 bytes, a 410-byte reduction
+  from the recorded 4,804-byte pre-compaction baseline. Canvas-enabled context
+  is 4,867 bytes. These measurements are bytes, not model tokens.
+- Verification: focused backend packages passed with 5,396 tests across seven
+  packages; `rtk make lint` reported 0 issues; `rtk git diff --check` passed.

docs/plans/mcp-discovery-canvas-prompts/task-02-canvas-creation-preset.md

@@ -0,0 +1,121 @@
+---
+id: "02-canvas-creation-preset"
+title: "Canvas creation preset"
+status: done
+wave: 2
+depends_on:
+  - "01-mcp-discovery-guidance"
+plan: "plan.md"
+requirements:
+  - REQ-CANVASES-AGENT-WEB-APPS-009
+acceptance_criteria:
+  - AC-CANVASES-AGENT-WEB-APPS-009.6
+  - AC-CANVASES-AGENT-WEB-APPS-009.7
+  - AC-CANVASES-AGENT-WEB-APPS-009.8
+system_design:
+  - ../../specs/canvases/system-design/agent-authored-web-apps.md
+---
+
+# Task 02: Canvas creation preset
+
+## Summary
+
+Strengthen the editable Create canvas prompt with explicit MCP discovery and
+publication steps. Preserve the normal task dialog on desktop and mobile.
+
+## In scope
+
+- Use the proposed wording in the canvas design's discovery section.
+- Update English, Portuguese, and Simplified Chinese catalogs. Generate the
+  Traditional Chinese pair and pseudo-locale through repository scripts.
+- Preserve exact tool identifiers in each locale.
+- Cover real catalog content instead of only mocked translation values.
+- Extend the mobile guided task case to inspect the default prompt before
+  replacing it. Add a desktop case with the same user outcome.
+- Assert the submitted description preserves a user's edit. Retain the
+  existing scratch/local defaults and editable workflow/profile controls.
+
+## Out of scope
+
+- Canvas service changes, approval automation, or a new dialog layout.
+- Live models, persistent demo tasks, or repair of the original failed task.
+
+## Acceptance
+
+1. Every supported locale explains discovery, create, one core skill read,
+   assigned-directory edits, live data, publication, and accurate status.
+2. Desktop and mobile show an editable preset and submit the edited value.
+   The longer text leaves the task dialog usable without horizontal overflow.
+3. Catalog, component, and targeted E2E checks pass. Evidence distinguishes
+   prompt delivery from external model compliance.
+
+## Verification
+
+From `apps`, install dependencies once if this worktree has no installation:
+
+```bash
+rtk pnpm install --frozen-lockfile
+```
+
+From `apps/web`:
+
+```bash
+rtk pnpm run i18n:zh-hant
+rtk pnpm run i18n:pseudo
+rtk pnpm exec vitest run components/canvas/canvas-task-create-launcher.test.tsx components/canvas/canvas-task-prompt.test.ts
+rtk pnpm run i18n:check
+rtk pnpm e2e:run --project chromium tests/canvas/plugin-canvas.spec.ts -- --grep 'canvas creation prompt'
+rtk pnpm e2e:run --project mobile-chrome tests/canvas/mobile-plugin-canvas.spec.ts -- --grep 'creates a scratch canvas task'
+```
+
+Use `canvas creation prompt` in the new desktop test title. The managed E2E
+runner builds production artifacts and owns isolated instance cleanup. Run
+desktop and mobile sequentially. Inspect the rendered phone dialog screenshot.
+Use TDD for the new prompt contract and submission assertions.
+
+## Files likely touched
+
+- `apps/web/src/locales/en/canvases.json`
+- `apps/web/src/locales/pt-pt/canvases.json`
+- `apps/web/src/locales/zh-cn/canvases.json`
+- Generated `zh-hk`, `zh-tw`, and pseudo canvas catalogs.
+- `apps/web/components/canvas/canvas-task-create-launcher.test.tsx`
+- `apps/web/components/canvas/canvas-task-prompt.test.ts` (new)
+- `apps/web/e2e/tests/canvas/plugin-canvas.spec.ts`
+- `apps/web/e2e/tests/canvas/mobile-plugin-canvas.spec.ts`
+
+## Dependencies
+
+Task 01 supplies the common discovery and capability-aware guidance.
+
+## Risks
+
+Mocking the locale value can pass while production wording is wrong. Inspect
+the real catalog text. Existing MCP fixture commands test the lifecycle, not
+whether a model discovers the tools from the default prompt.
+
+## Parallelism
+
+`sequential`
+
+## Inputs
+
+- Canvas requirements and design, especially guided launch and discovery.
+- `CanvasTaskCreateLauncher` and its current preset test.
+- Existing mobile guided task case and the standard full-screen task dialog.
+- Repository i18n, mobile-parity, and E2E guidance.
+
+## Results
+
+- Strengthened the English, Portuguese, Simplified Chinese, Traditional
+  Chinese, and pseudo-locale canvas task presets with conditional discovery,
+  draft creation, one skill read, returned-directory editing, authorized live
+  data, publication, permission review, and accurate release reporting.
+- Updated pseudo-locale generation to preserve Markdown code spans so the
+  exact callable canvas tool names remain unchanged in development catalogs.
+- Added real-catalog unit coverage: 2 files and 4 tests passed. i18n key,
+  punctuation, non-JSX-copy, and new-code ratchet checks passed; TypeScript,
+  ESLint, and Prettier checks passed.
+- Desktop E2E passed 1 test. Mobile E2E passed 1 test. Both flows showed the
+  editable preset, retained the submitted description, and had no horizontal
+  viewport overflow.

docs/specs/agents/README.md

@@ -61,6 +61,7 @@ surface shared by task and Office consumers.
 - [Managed Agent Runtime Versions and Updates](requirements/runtime-updates.md)
 - [MCP Bridge Reliability](requirements/mcp-bridge-reliability.md)
 - [MCP Protocol Compatibility](requirements/mcp-protocol-compatibility.md)
+- [MCP tool discovery guidance](requirements/mcp-tool-discovery-guidance.md)
 - [Simplify the agent settings profile layout](requirements/settings-profile-layout.md)
 - [Spawn Session Effective Agent Profile](requirements/spawn-session-effective-profile.md)
 - [Subagent context persistence](requirements/subagent-context-persistence.md)
@@ -85,6 +86,7 @@ surface shared by task and Office consumers.
 - [MCP Bridge Reliability](system-design/mcp-bridge-reliability.md)
 - [Agent MCP Timeout Budgets](system-design/mcp-timeout-budgets.md)
 - [MCP Protocol Compatibility](system-design/mcp-protocol-compatibility.md)
+- [MCP tool discovery guidance](system-design/mcp-tool-discovery-guidance.md)
 - [Subagent context persistence System Design Part 1](system-design/subagent-context-persistence-01.md)
 - [Subagent context persistence System Design Part 2](system-design/subagent-context-persistence-02.md)
 - [Subagent context persistence System Design Part 3](system-design/subagent-context-persistence-03.md)

docs/specs/agents/requirements/mcp-tool-discovery-guidance.md

@@ -0,0 +1,69 @@
+---
+status: draft
+system: agents
+created: 2026-09-08
+owners:
+  - kandev
+---
+
+# MCP tool discovery guidance requirements
+
+## Overview
+
+Task agents need to discover Kandev operations without an exhaustive tool list
+in every prompt. The Agents system owns this instruction contract across agent
+clients. Canvases owns its authoring workflow and task creation preset.
+
+## Requirements
+
+### REQ-AGENTS-MCP-DISCOVERY-001: Discoverable Kandev operations
+
+**Intent:** Agents receive enough guidance to find operations that the prompt
+does not list.
+
+#### Acceptance criteria
+
+- **AC-AGENTS-MCP-DISCOVERY-001.1:** Task instructions shall identify the
+  injected tool list as selected guidance, not the complete available catalog.
+- **AC-AGENTS-MCP-DISCOVERY-001.2:** When a needed Kandev tool is not callable,
+  instructions shall direct agents to native tool search when available.
+- **AC-AGENTS-MCP-DISCOVERY-001.3:** Search guidance shall include the Kandev
+  server name and the requested operation or known canonical tool name.
+- **AC-AGENTS-MCP-DISCOVERY-001.4:** When native search is absent, instructions
+  shall direct agents to the available MCP catalog. They shall not assume a
+  client-specific search API.
+- **AC-AGENTS-MCP-DISCOVERY-001.5:** Instructions shall require the callable
+  name and schema returned by the client. An omitted prompt entry shall not
+  imply an unavailable tool.
+- **AC-AGENTS-MCP-DISCOVERY-001.6:** When discovery cannot find the required
+  operation, instructions shall require an accurate limitation report. They
+  shall not direct agents to claim an equivalent platform result from files.
+
+### REQ-AGENTS-MCP-DISCOVERY-002: Compact capability-aware guidance
+
+**Intent:** Shorter prompts preserve mandatory workflow behavior and capability
+boundaries.
+
+#### Acceptance criteria
+
+- **AC-AGENTS-MCP-DISCOVERY-002.1:** The default task instructions shall omit
+  routine inventory and CRUD descriptions that agents can discover on demand.
+- **AC-AGENTS-MCP-DISCOVERY-002.2:** The instructions shall preserve question
+  barriers, title ownership, completion conditions, autopilot rules, and
+  delegation authorization.
+- **AC-AGENTS-MCP-DISCOVERY-002.3:** Optional operation guidance shall match the
+  resolved session capabilities on task launch and context reset.
+- **AC-AGENTS-MCP-DISCOVERY-002.4:** Recorded and dispatched task instructions
+  shall agree about discovery and optional capabilities.
+- **AC-AGENTS-MCP-DISCOVERY-002.5:** Shorter instructions shall retain the use
+  of Kandev plans and native rich output when the user requests those results.
+
+## Out of scope
+
+- New MCP tools, client search implementations, or tool registration changes.
+- Exhaustive catalog redesign for Office or configuration sessions.
+- Changes to canvas permissions, promotion, or package validation.
+- Automatic repair of existing task files or conversations.
+
+Canvas-specific outcomes remain in the
+[canvas requirements](../../canvases/requirements/agent-authored-web-apps.md).

docs/specs/agents/system-design/mcp-tool-discovery-guidance.md

@@ -0,0 +1,128 @@
+---
+status: draft
+system: agents
+requirements:
+  - REQ-AGENTS-MCP-DISCOVERY-001
+  - REQ-AGENTS-MCP-DISCOVERY-002
+---
+
+# MCP tool discovery guidance system design
+
+## Purpose and boundaries
+
+The Agents system owns compact runtime instructions for Kandev tool discovery.
+The MCP registry remains authoritative for callable operations and schemas.
+This change uses the existing typed profile and canonical tool-name contracts.
+It does not add a search tool or a client-name switch.
+
+The Canvases system owns the
+[canvas authoring and task preset](../../canvases/system-design/agent-authored-web-apps.md#agent-authoring-guidance).
+
+## Requirement mapping
+
+| Requirement | Design section |
+| --- | --- |
+| `REQ-AGENTS-MCP-DISCOVERY-001` | Discovery instructions |
+| `REQ-AGENTS-MCP-DISCOVERY-002` | Essential guidance and capability projection |
+
+## Discovery instructions
+
+`apps/backend/config/prompts/kandev-context.md` keeps the `KANDEV MCP TOOLS`
+marker and trusted task/session placeholders. The introductory text identifies
+the subsequent list as selected workflow guidance.
+
+Proposed shared discovery text:
+
+> These instructions list selected Kandev tools, not the complete MCP catalog.
+> For Kandev operations, use the tools exposed by the `kandev` server.
+> If the needed tool is already callable, use its current schema.
+> Otherwise, use your client's native tool search or discovery when available.
+> Search for `kandev` plus the operation, such as `canvas`, or the known canonical tool name.
+> If search is unavailable, inspect the MCP tools available in your client.
+> Use the exact callable name and schema that the client exposes.
+> Canonical names end in `_kandev`; clients can display a server-qualified alias.
+> An omitted entry here does not mean that the tool is unavailable.
+> If discovery cannot find a required tool, report that limitation before substituting another result.
+
+Known names are search terms, not instructions to fabricate a tool invocation.
+The prompt does not prescribe `ToolSearch`, `tool_search`, or any provider API.
+Discovery is conditional on a missing callable tool, so eager clients avoid
+redundant searches. Previously discovered definitions remain usable during the
+same turn unless the client reports a catalog change or an unavailable tool.
+
+## Essential guidance and capability projection
+
+The compact template retains these behavior-critical sections:
+
+| Section | Treatment |
+| --- | --- |
+| Task/session identity | Preserve trusted placeholders and marker. |
+| Delegation | Preserve explicit authorization and persistent-task/session boundaries. |
+| Questions | Preserve the current capability-selected tool and complete hard barrier. |
+| Title | Preserve the pending-title condition and first-action instruction. |
+| Completion | Preserve the step gate, discovery hint, and final-action semantics. |
+| Autopilot | Preserve parent-question selection and root behavior. |
+| Plans | One short line for create/get/update and preserving user edits. |
+| Rich output | One short routing rule; obtain schemas and examples from tool discovery. |
+| Coordinator controls | Preserve the gated interrupt/stop/restart rules. |
+| Canvas | One gated create/read/write/publish workflow, owned by Canvases. |
+
+Remove standalone descriptions for routine task/workspace/workflow/session
+lists, generic updates, plan deletion, and walkthrough CRUD. Keep their tools
+registered. Keep task creation and session names only where authorization rules
+need them. Rename `Available tools` to `Essential workflow guidance`.
+
+The raw template currently has 3,482 UTF-8 bytes. Target at most 2,800 bytes
+after compaction, including the discovery text and optional placeholders.
+Record rendered sizes for an ordinary task and a canvas-enabled task too. The
+rendered budgets are separate because capability sections and runtime values
+expand the reusable template at render time.
+Byte counts measure prompt size without adding a model-specific tokenizer.
+
+`sysprompt.KandevContextOptions` adds an explicit canvas-guidance boolean.
+Its zero value omits canvas guidance. The caller derives the value from the
+same resolved MCP profile that determines `CapabilityCanvas` registration.
+Prompt text and user metadata cannot enable that capability.
+
+The executor already owns `resolveTaskSessionMCPProfile` and
+`withCanvasCapability`. Expose a narrow read-only profile query if the
+orchestrator needs it. Reuse this resolver instead of storing another flag in
+the orchestrator or reproducing its surface rules.
+
+Wire the projection through `wrapCreatedSessionPrompt`,
+`applyLaunchPromptContext`, and the workflow auto-start/context-reset path.
+Compute the workflow projection once for both recorded and dispatched text.
+Retain the existing Office and passthrough branches. Configuration and
+automation profiles do not acquire canvas guidance from a global flag alone.
+
+## Failure and recovery
+
+A profile resolution error retains existing launch error behavior. The prompt
+must not advertise capabilities from a guessed profile. Missing tools produce
+an accurate limitation report after the client-specific discovery options are
+exhausted. Discovery never authorizes a mutation outside the user's request.
+
+Existing conversations and stored prompts remain historical records. Normal
+launch/reset injection receives the new template. This change does not send
+unsolicited messages or restart live sessions.
+
+## Verification
+
+Tests in `internal/sysprompt` cover discovery, essential invariants, the canvas
+boolean, compact size, and removal of routine catalog entries. Assertions check
+instructions and conditions rather than a complete prose snapshot.
+
+Producer tests in `internal/orchestrator` cover task start, prepared-session
+start, and context reset with canvas capability present and absent. They also
+cover excluded surfaces and agreement between recorded and dispatched text.
+MCP profile/server tests prove that prompt compaction does not remove tools.
+
+Deterministic tests prove instruction delivery and tool exposure. They cannot
+prove that every external model will obey prose on every turn.
+
+## Related decisions
+
+- [Typed MCP tool profiles](../../../decisions/2026-08-08-mcp-tool-profiles.md)
+- [Canonical MCP tool names](../../../decisions/2026-08-31-agent-aware-mcp-tool-names.md)
+
+No new ADR is required. This change improves guidance within those boundaries.

docs/specs/canvases/README.md

@@ -4,7 +4,7 @@ owner: canvases
 specification_version: 1
 status: draft
 migration: complete
-last_updated: 2026-08-30
+last_updated: 2026-09-08
 ---
 
 # Canvases
@@ -29,6 +29,8 @@ remains authoritative for task data and permissions.
 
 ## Related context
 
+- [Agent MCP discovery guidance](../agents/system-design/mcp-tool-discovery-guidance.md)
+- [MCP discovery and canvas prompt plan](../../plans/mcp-discovery-canvas-prompts/plan.md)
 - [GitHub Copilot App Canvas reference](../../copilot-canvas-reference.md)
 - [Plugin-backed web-app canvases decision](../../decisions/2026-08-26-plugin-backed-web-app-canvases.md)
 - [Plugin-backed canvases implementation plan](../../plans/plugin-backed-canvases/plan.md)

docs/specs/canvases/requirements/agent-authored-web-apps.md

@@ -6,7 +6,7 @@ system: canvases
 owners:
   - canvases
 created: 2026-08-26
-last_updated: 2026-08-30
+last_updated: 2026-09-08
 ---
 
 # Agent-authored web-app canvases Requirements
@@ -67,6 +67,15 @@ the task, so that the interface matches the work.
 - **AC-CANVASES-AGENT-WEB-APPS-001.9:** Local, container, and remote task
   agents shall use the same authoring contract without access to a Kandev host
   file path.
+- **AC-CANVASES-AGENT-WEB-APPS-001.10:** Canvas-capable task instructions shall
+  identify the create, skill-read, and publish operations, including discovery
+  guidance when those tools are not immediately callable.
+- **AC-CANVASES-AGENT-WEB-APPS-001.11:** Authoring instructions shall require
+  creation in Kandev, edits inside the assigned source directory, and a publish
+  result before a completion claim.
+- **AC-CANVASES-AGENT-WEB-APPS-001.12:** Authoring instructions shall distinguish
+  an active release, a release awaiting permission review, and an unsuccessful
+  publish. Local files or a successful build shall not imply publication.
 
 ### REQ-CANVASES-AGENT-WEB-APPS-002: Durable source and releases
 
@@ -248,6 +257,15 @@ agent and review the canvas in the same task.
   and review the canvas.
 - **AC-CANVASES-AGENT-WEB-APPS-009.5:** On a phone, workspace Canvases settings
   shall expose the same task creation flow without a canvas-only form.
+- **AC-CANVASES-AGENT-WEB-APPS-009.6:** The localized preset shall name the
+  canvas discovery, creation, skill-read, source-directory, and publication
+  steps. Tool identifiers shall remain exact in every locale.
+- **AC-CANVASES-AGENT-WEB-APPS-009.7:** On desktop and phone, the user shall
+  be able to read and edit the preset before submission. The submitted task
+  shall retain those edits.
+- **AC-CANVASES-AGENT-WEB-APPS-009.8:** The preset shall direct agents to use
+  authorized live Kandev data for domain views and report any required user
+  permission review or workspace promotion.
 
 ## Out of scope
 

docs/specs/canvases/system-design/agent-authored-web-apps.md

@@ -6,7 +6,7 @@ system: canvases
 owners:
   - canvases
 created: 2026-08-26
-last_updated: 2026-09-05
+last_updated: 2026-09-08
 requirements:
   - REQ-CANVASES-AGENT-WEB-APPS-001
   - REQ-CANVASES-AGENT-WEB-APPS-002
@@ -235,6 +235,59 @@ not request canvas counts, add a settings tab, or register the task preset.
 
 ## Agent authoring guidance
 
+### Discovery and creation prompts
+
+The shared task prompt uses the
+[agent discovery contract](../../agents/system-design/mcp-tool-discovery-guidance.md).
+When the resolved session profile includes `CapabilityCanvas`, it also includes
+this compact instruction:
+
+> For a requested Kandev canvas, discover `create_canvas_kandev`, `read_canvas_authoring_skill_kandev`, and `publish_canvas_kandev`.
+> Create the draft in Kandev before writing application files.
+> Read the authoring skill once and edit only inside the returned source directory.
+> Publish through MCP and report the returned release status.
+> If publication is unsuccessful, report the failure and do not claim that the canvas is published.
+> Files or a successful local build do not create a published Kandev canvas.
+
+The optional section is absent when the resolved profile lacks canvas tools.
+This covers canvas requests inside ordinary task conversations, independently
+of the guided task preset.
+
+`CanvasTaskCreateLauncher` retains the localized
+`canvases:createCanvasTaskPrompt` preset in the normal `TaskCreateDialog`.
+The preset is visible and editable. Proposed English wording:
+
+> Create an interactive canvas inside Kandev for the application I describe.
+> If the application goal is missing, ask what the canvas must show or do.
+> Find the Kandev canvas MCP tools before writing application files.
+> If they are not callable, use native tool search for `kandev canvas` or inspect the available MCP catalog.
+> Call `create_canvas_kandev` to create the draft and obtain its source directory.
+> Read `read_canvas_authoring_skill_kandev` once without a path.
+> Build inside the returned directory and use authorized live Kandev data for domain views.
+> Call `publish_canvas_kandev` and address any validation errors.
+> Report the canvas identity and whether its release is active, awaits permission review, or was unsuccessful.
+> If publication is unsuccessful, report the failure and do not claim that the canvas is published.
+> If workspace access requires promotion, explain the user action that is still required.
+> A local build alone does not publish a canvas inside Kandev.
+> If the tools remain unavailable, report the limitation instead of claiming that workspace files are a Kandev canvas.
+
+The existing selected question capability governs any clarification. The
+preset cannot grant a question tool to an autopilot session that lacks one.
+An application goal already supplied by the user needs no repeated interview.
+
+English, Portuguese, and Simplified Chinese catalogs receive equivalent
+wording. Traditional Chinese catalogs use the repository generator. Tool names
+remain literal protocol identifiers. The pseudo-locale uses its generator.
+
+The nearest mobile exemplar is the existing full-screen `TaskCreateDialog`
+opened from workspace Canvases settings. This is a content change within that
+surface. Its scroll owner, touch controls, and navigation remain unchanged.
+Focused desktop and mobile tests cover the longer editable prompt and its
+submitted value. Tests inspect the real catalog value before replacing any
+description with mock-agent commands.
+
+### Bundled authoring skill
+
 Kandev bundles a read-only `kandev-canvas-authoring` system skill in a canvas
 embed that is separate from the Office skill embed. At startup, Kandev writes
 the current skill and its supporting files to