feat(mcp): add direct knowledge dump via ask all=true

When all=true, the ask tool now returns all nodes directly from SQLite
grouped by type, bypassing semantic search and LLM calls entirely.
Single request, instant response. Updates the context skill to use it.

Author: josephgoksu

cmd/mcp_server.go

@@ -164,7 +164,7 @@ func runMCPServer(ctx context.Context) error {
 	// Register ask tool - retrieves stored codebase knowledge for AI context
 	tool := &mcpsdk.Tool{
 		Name:        "ask",
-		Description: "Search project knowledge: decisions, patterns, constraints, and code symbols. Returns an AI-synthesized answer and relevant context by default. Use {\"query\":\"search term\"} for semantic search.",
+		Description: "Search project knowledge: decisions, patterns, constraints, and code symbols. Returns an AI-synthesized answer and relevant context by default. Use {\"query\":\"search term\"} for semantic search. Use {\"all\":true} for a complete knowledge dump (no LLM calls, instant).",
 	}
 
 	mcpsdk.AddTool(server, tool, func(ctx context.Context, session *mcpsdk.ServerSession, params *mcpsdk.CallToolParamsFor[mcppresenter.ProjectContextParams]) (*mcpsdk.CallToolResultFor[any], error) {
@@ -320,6 +320,16 @@ REQUIRED FIELDS BY ACTION:
 // This ensures MCP and CLI use identical search logic with zero drift.
 // Uses the app.AskApp for all business logic - single source of truth.
 func handleNodeContext(ctx context.Context, repo *memory.Repository, params mcppresenter.ProjectContextParams) (*mcpsdk.CallToolResultFor[any], error) {
+	// Fast path: all=true dumps every node from SQLite with no LLM calls.
+	// This is the MCP equivalent of `taskwing knowledge`.
+	if params.All {
+		nodes, err := repo.ListNodes("")
+		if err != nil {
+			return mcpErrorResponse(fmt.Errorf("list nodes: %w", err))
+		}
+		return mcpMarkdownResponse(mcppresenter.FormatKnowledgeDump(nodes))
+	}
+
 	// Create app context with query role - respects llm.models.query config (same as CLI)
 	appCtx := app.NewContextForRole(repo, llm.RoleQuery)
 	askApp := app.NewAskApp(appCtx)
@@ -337,9 +347,8 @@ func handleNodeContext(ctx context.Context, repo *memory.Repository, params mcpp
 	}
 
 	// Resolve workspace filtering
-	// params.All=true or empty workspace = search all workspaces
 	var workspace string
-	if !params.All && params.Workspace != "" {
+	if params.Workspace != "" {
 		if err := app.ValidateWorkspace(params.Workspace); err != nil {
 			return mcpValidationErrorResponse("workspace", err.Error())
 		}

internal/mcp/presenter.go

@@ -12,11 +12,64 @@ import (
 	"github.com/josephgoksu/TaskWing/internal/app"
 	"github.com/josephgoksu/TaskWing/internal/codeintel"
 	"github.com/josephgoksu/TaskWing/internal/knowledge"
+	"github.com/josephgoksu/TaskWing/internal/memory"
 	"github.com/josephgoksu/TaskWing/internal/task"
 	"golang.org/x/text/cases"
 	"golang.org/x/text/language"
 )
 
+// FormatKnowledgeDump formats all knowledge nodes as Markdown, grouped by type.
+// This is the MCP equivalent of `taskwing knowledge` -- a direct SQLite dump
+// with no LLM calls, semantic search, or embedding lookups.
+func FormatKnowledgeDump(nodes []memory.Node) string {
+	if len(nodes) == 0 {
+		return "No knowledge nodes found. Run `taskwing bootstrap` to populate."
+	}
+
+	var sb strings.Builder
+	sb.WriteString(fmt.Sprintf("## Knowledge (%d nodes)\n\n", len(nodes)))
+
+	typeOrder := []string{"constraint", "decision", "feature", "pattern", "plan", "note", "metadata", "documentation"}
+	grouped := make(map[string][]memory.Node)
+	for i := range nodes {
+		t := nodes[i].Type
+		if t == "" {
+			t = "unknown"
+		}
+		grouped[t] = append(grouped[t], nodes[i])
+	}
+
+	for _, t := range typeOrder {
+		group := grouped[t]
+		if len(group) == 0 {
+			continue
+		}
+		sb.WriteString(fmt.Sprintf("### %s (%d)\n", cases.Title(language.English).String(t), len(group)))
+		for _, n := range group {
+			title := n.Summary
+			if title == "" {
+				title = truncate(n.Content, 120)
+			}
+			sb.WriteString(fmt.Sprintf("- **%s**", title))
+			if n.Workspace != "" && n.Workspace != "root" {
+				sb.WriteString(fmt.Sprintf(" [%s]", n.Workspace))
+			}
+			// Include content preview when it adds info beyond the summary
+			if n.Content != "" && n.Content != n.Summary {
+				content := cleanContent(n.Content, title)
+				if content != "" {
+					preview := truncate(content, 200)
+					sb.WriteString(fmt.Sprintf("\n  %s", preview))
+				}
+			}
+			sb.WriteString("\n")
+		}
+		sb.WriteString("\n")
+	}
+
+	return strings.TrimSpace(sb.String())
+}
+
 // FormatAsk converts an AskResult into token-efficient Markdown.
 // Structure: Answer (if present) -> Knowledge (grouped by type) -> Symbols
 // Includes debt warnings for patterns/decisions marked as technical debt.

skills/taskwing-context/SKILL.md

@@ -32,16 +32,12 @@ Inject the complete project knowledge base into this conversation so you have fu
 
 ## Steps
 
-1. Call MCP tool `ask` with a broad query to retrieve all knowledge:
+1. Call MCP tool `ask` with `all=true` to dump all knowledge directly from SQLite (no LLM calls, instant):
 ```json
-{"query": "project decisions patterns constraints features", "all": true}
+{"all": true}
 ```
 
-2. Present the returned knowledge organized by type:
-   - **Constraints** first (mandatory rules)
-   - **Decisions** (technology and architecture choices)
-   - **Patterns** (recurring practices)
-   - **Features** (product capabilities)
+2. Present the returned knowledge verbatim. The response is already organized by type (constraints, decisions, patterns, features).
 
 3. After presenting, confirm: "Project context loaded. I now have full visibility into your architecture. What would you like to work on?"