From aea57f40df56639fabffc677bfa419202d002bd1 Mon Sep 17 00:00:00 2001 From: Konstantin Zaytcev Date: Wed, 14 Oct 2026 02:36:45 +0300 Subject: [PATCH] fix(secretary): explain unavailable knowledge and verify resumed reads --- README.md | 6 ++++ core/claude/delegated.go | 10 ++++++ core/claude/delegated_integration_test.go | 7 +++- core/claude/delegated_test.go | 44 +++++++++++++++++++++++ core/knowledge/proxy.go | 31 ++++++++-------- core/knowledge/proxy_test.go | 22 +++++++++++- 6 files changed, 104 insertions(+), 16 deletions(-) diff --git a/README.md b/README.md index 9d706de..d8c6f13 100644 --- a/README.md +++ b/README.md @@ -66,6 +66,12 @@ work; its returned files are not installed as bot rules. Existing tokens may lac `knowledge:read`; use DuckBug's token/access flow to grant it. This MCP wiring is currently supported on the Claude backend. +Delegated runs use the effective catalog of the current credential, including +deployment availability. If no authorized KB operations are present, ordinary +replies still work, but the agent is told that the knowledge base is unavailable +and must not promise a lookup or invent document sources. Product MCP documents +and app-admin document pickers are not substitutes for the owner's knowledge base. + Roles and prompts are behavioral preferences, not an execution sandbox. The bot retains its configured tools. MCP capabilities enforce data access; a project credential can also expose shared organization documents. Use an appropriate diff --git a/core/claude/delegated.go b/core/claude/delegated.go index dc7e2eb..77f15d5 100644 --- a/core/claude/delegated.go +++ b/core/claude/delegated.go @@ -40,6 +40,12 @@ func prepareDelegated(ctx context.Context, o Options) (Options, func(), error) { if err != nil { return o, nil, err } + if len(servers) == 0 { + instructions = append(instructions, []byte("\n\nCurrent run: no authorized knowledge-base tools are available. "+ + "Answer ordinary requests within the owner's rules, but if an answer requires knowledge-base documents, "+ + "say that this knowledge source is currently unavailable. Do not promise a lookup, fabricate sources, "+ + "or claim to have read documents.\n")...) + } dir, err := os.MkdirTemp("", "flock-secretary-") if err != nil { closeKnowledge() @@ -131,6 +137,10 @@ func delegatedServers(ctx context.Context, path string) (map[string]MCPServer, f if err != nil { return nil, nil, errors.New("delegated knowledge connection unavailable") } + if !proxy.Available { + proxy.Close() + return servers, cleanup, nil + } servers["secretary_knowledge"] = MCPServer{URL: proxy.URL, BearerToken: proxy.Token} return servers, proxy.Close, nil } diff --git a/core/claude/delegated_integration_test.go b/core/claude/delegated_integration_test.go index 0464a9f..788e6d4 100644 --- a/core/claude/delegated_integration_test.go +++ b/core/claude/delegated_integration_test.go @@ -115,6 +115,11 @@ func TestIntegration_DelegatedCLIReadOnlyAndScopedResume(t *testing.T) { if step == 0 { block["input"] = map[string]any{"query": "recipient-safe fixture"} } + } else if step == 5 { + block = map[string]any{ + "type": fixtureToolUse, "id": "resumed_read", "name": "mcp__secretary_knowledge__kb_search", + "input": map[string]any{"query": "resumed recipient-safe fixture"}, + } } writeModelFixture(t, w, block) })) @@ -167,7 +172,7 @@ func TestIntegration_DelegatedCLIReadOnlyAndScopedResume(t *testing.T) { run("recipient-B-marker", options) mu.Lock() defer mu.Unlock() - if reads != 1 || deliveries != 0 || len(requests) < 7 { + if reads != 2 || deliveries != 0 || len(requests) < 8 { t.Fatalf("read/resume requests = %d/%d", reads, len(requests)) } assertDelegatedInventory(t, inventories) diff --git a/core/claude/delegated_test.go b/core/claude/delegated_test.go index a7b79d8..1385ee1 100644 --- a/core/claude/delegated_test.go +++ b/core/claude/delegated_test.go @@ -4,11 +4,15 @@ package claude import ( "context" "encoding/json" + "net/http" + "net/http/httptest" "os" "path/filepath" "slices" "strings" "testing" + + "github.com/modelcontextprotocol/go-sdk/mcp" ) func TestDelegatedLaunchExcludesCredentialsAndOrdinaryWorkspace(t *testing.T) { @@ -68,6 +72,11 @@ func TestDelegatedLaunchExcludesCredentialsAndOrdinaryWorkspace(t *testing.T) { if err != nil || string(config) != `{"mcpServers":{}}` { t.Fatal("empty scope inherited other MCP servers") } + instructions, err := os.ReadFile(filepath.Join(prepared.Workdir, "instructions.txt")) + if err != nil || !strings.Contains(string(instructions), "no authorized knowledge-base tools are available") || + !strings.Contains(string(instructions), "Owner disclosure rules") { + t.Fatal("unavailable knowledge or owner policy was not communicated") + } cleanup() if _, err := os.Stat(prepared.Workdir); !os.IsNotExist(err) { t.Fatal("temporary run files retained") @@ -87,3 +96,38 @@ func TestDelegatedLaunchFailsClosedWithoutExplicitAuthentication(t *testing.T) { t.Fatal("conflicting execution policies were permitted") } } + +func TestDelegatedLaunchExplainsEmptyAuthorizedKnowledgeCatalog(t *testing.T) { + server := mcp.NewServer(&mcp.Implementation{Name: "fixture", Version: "1"}, nil) + server.AddTool(&mcp.Tool{Name: "discover_tools", InputSchema: json.RawMessage(`{"type":"object"}`)}, + func(context.Context, *mcp.CallToolRequest) (*mcp.CallToolResult, error) { + return &mcp.CallToolResult{StructuredContent: map[string]any{"tools": []any{}}}, nil + }) + upstream := httptest.NewServer(mcp.NewStreamableHTTPHandler(func(*http.Request) *mcp.Server { return server }, + &mcp.StreamableHTTPOptions{Stateless: true, JSONResponse: true})) + t.Cleanup(upstream.Close) + owner := t.TempDir() + if err := os.WriteFile(filepath.Join(owner, "CLAUDE.md"), []byte("Owner disclosure rules"), 0o600); err != nil { + t.Fatal(err) + } + config := filepath.Join(owner, "mcp.json") + if _, err := WriteMCPConfig(config, map[string]MCPServer{"duckbug": {URL: upstream.URL, BearerToken: "fixture"}}); err != nil { + t.Fatal(err) + } + prepared, cleanup, err := prepareDelegated(t.Context(), Options{ + Workdir: owner, MCPConfig: config, + Env: []string{"ANTHROPIC_API_KEY=synthetic-provider"}, + }) + if err != nil { + t.Fatal(err) + } + t.Cleanup(cleanup) + instructions, err := os.ReadFile(filepath.Join(prepared.Workdir, "instructions.txt")) + if err != nil || !strings.Contains(string(instructions), "no authorized knowledge-base tools are available") { + t.Fatal("empty discovery was hidden from the delegated agent") + } + data, err := os.ReadFile(prepared.MCPConfig) + if err != nil || string(data) != `{"mcpServers":{}}` { + t.Fatal("empty discovery inherited other MCP access") + } +} diff --git a/core/knowledge/proxy.go b/core/knowledge/proxy.go index c373360..ff4b2d6 100644 --- a/core/knowledge/proxy.go +++ b/core/knowledge/proxy.go @@ -29,9 +29,10 @@ var leaves = [...]string{"kb_search", "kb_get", "kb_list"} // Proxy keeps the upstream credential inside the trusted host process. type Proxy struct { - URL string - Token string - close func() + URL string + Token string + Available bool + close func() } // Close releases the local listener and its upstream session. @@ -104,7 +105,7 @@ func Start(ctx context.Context, endpoint, authorization string) (*Proxy, error) } discoveryCtx, cancel := context.WithTimeout(ctx, operationTimeout) defer cancel() - server, err := readServer(discoveryCtx, session) + server, available, err := readServer(discoveryCtx, session) if err != nil { _ = session.Close() return nil, err @@ -133,7 +134,7 @@ func Start(ctx context.Context, endpoint, authorization string) (*Proxy, error) } go func() { _ = host.Serve(listener) }() var once sync.Once - return &Proxy{URL: "http://" + listener.Addr().String() + "/mcp", Token: token, close: func() { + return &Proxy{URL: "http://" + listener.Addr().String() + "/mcp", Token: token, Available: available, close: func() { once.Do(func() { _ = host.Close() _ = session.Close() @@ -150,40 +151,41 @@ type catalogTool struct { InputSchema json.RawMessage `json:"inputSchema"` } -func readServer(ctx context.Context, session *mcp.ClientSession) (*mcp.Server, error) { +func readServer(ctx context.Context, session *mcp.ClientSession) (*mcp.Server, bool, error) { server := mcp.NewServer(&mcp.Implementation{Name: "flock-secretary-knowledge", Version: "1"}, nil) + available := false for _, leaf := range leaves { response, err := session.CallTool(ctx, &mcp.CallToolParams{ Name: "discover_tools", Arguments: map[string]any{"name": leaf, "includeSchema": true}, }) if err != nil { - return nil, errors.New("knowledge discovery failed") + return nil, false, errors.New("knowledge discovery failed") } var discovery struct { Tools []catalogTool `json:"tools"` } if err := resultJSON(response, &discovery); err != nil { - return nil, err + return nil, false, err } if len(discovery.Tools) == 0 { - continue // The bot token does not authorize this operation. + continue // This operation is absent from the effective catalog. } if len(discovery.Tools) != 1 { - return nil, errors.New("ambiguous knowledge tool") + return nil, false, errors.New("ambiguous knowledge tool") } tool := discovery.Tools[0] if tool.Name != leaf || tool.Mutates == nil || *tool.Mutates || tool.Execution != "read" || tool.Surface != "catalog" || tool.DirectOnly { - return nil, errors.New("knowledge tool is not an authorized catalog read") + return nil, false, errors.New("knowledge tool is not an authorized catalog read") } var schema jsonschema.Schema if err := json.Unmarshal(tool.InputSchema, &schema); err != nil || schema.Type != "object" { - return nil, errors.New("invalid knowledge tool schema") + return nil, false, errors.New("invalid knowledge tool schema") } resolved, err := schema.Resolve(&jsonschema.ResolveOptions{ValidateDefaults: true}) if err != nil { - return nil, errors.New("unsupported knowledge tool schema") + return nil, false, errors.New("unsupported knowledge tool schema") } // Low-level registration deliberately uses the pre-resolved schema so a // malformed upstream schema cannot panic or fetch external references. @@ -215,8 +217,9 @@ func readServer(ctx context.Context, session *mcp.ClientSession) (*mcp.Server, e } return &mcp.CallToolResult{Content: []mcp.Content{&mcp.TextContent{Text: string(envelope.Result)}}}, nil }) + available = true } - return server, nil + return server, available, nil } func resultJSON(result *mcp.CallToolResult, target any) error { diff --git a/core/knowledge/proxy_test.go b/core/knowledge/proxy_test.go index 25d9c80..53d2d09 100644 --- a/core/knowledge/proxy_test.go +++ b/core/knowledge/proxy_test.go @@ -73,6 +73,26 @@ func proxyClient(t *testing.T, proxy *Proxy) *mcp.ClientSession { return session } +func TestProxyReportsEmptyAuthorizedCatalog(t *testing.T) { + server := mcp.NewServer(&mcp.Implementation{Name: "fixture", Version: "1"}, nil) + server.AddTool(&mcp.Tool{Name: "discover_tools", InputSchema: json.RawMessage(`{"type":"object"}`)}, + func(context.Context, *mcp.CallToolRequest) (*mcp.CallToolResult, error) { + return &mcp.CallToolResult{StructuredContent: map[string]any{"tools": []any{}}}, nil + }) + upstream := httptest.NewServer(mcp.NewStreamableHTTPHandler(func(*http.Request) *mcp.Server { return server }, + &mcp.StreamableHTTPOptions{Stateless: true, JSONResponse: true})) + t.Cleanup(upstream.Close) + proxy, err := Start(t.Context(), upstream.URL, "Bearer fixture") + if err != nil { + t.Fatal(err) + } + t.Cleanup(proxy.Close) + listed, err := proxyClient(t, proxy).ListTools(t.Context(), nil) + if err != nil || len(listed.Tools) != 0 || proxy.Available { + t.Fatal("empty knowledge catalog reported as available") + } +} + func TestProxyOnlyReadsKnowledgeAndPreservesBotScope(t *testing.T) { endpoint, calls, mu := fakeKnowledge(t, false) proxy, err := Start(t.Context(), endpoint, "Bearer upstream-fixture") @@ -82,7 +102,7 @@ func TestProxyOnlyReadsKnowledgeAndPreservesBotScope(t *testing.T) { t.Cleanup(proxy.Close) client := proxyClient(t, proxy) listed, err := client.ListTools(t.Context(), nil) - if err != nil || len(listed.Tools) != 3 { + if err != nil || len(listed.Tools) != 3 || !proxy.Available { t.Fatalf("tools = %v, error %v", listed, err) } for _, tool := range listed.Tools {