Thread context.Context through blocking I/O entry points

Accept ctx as the first parameter on the blocking I/O entry points and
propagate it to downstream blocking calls so the work is cancellable from
the process entry point:

- appconfig.Load / LoadWithOptions: honor ctx before the blocking file
  reads, returning defaults on a cancelled context.
- LSP: lsp.Server.Run(ctx) ties the serve loop to the caller context via a
  new watchParentContext bridge (cancels the server context, aborting
  in-flight LLM work). Threaded through hexailsp.Run/RunWithConfig/
  RunWithFactory and runtimeconfig.Store.Reload.
- MCP: mcp.Server.Run(ctx) stops accepting requests once ctx is cancelled;
  threaded through hexaimcp.Run/RunWithFactory/RunBackfill.
- editor: RunEditor/OpenTempAndEdit/OpenFile take ctx and use
  exec.CommandContext so a cancelled context kills the editor subprocess;
  threaded through hexaicli, hexaiaction and askcli call sites.

Top-level callers (cmd/hexai-lsp-server, cmd/hexai-mcp-server) now build a
signal-cancelled context (SIGINT/SIGTERM) so shutdown tears the run down
cleanly. Updated comments to explain the cancellation flow and added
cancellation tests for the LSP/MCP loops, editor, and config load.

All tests pass with -race; cross-package coverage 86.2%.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

1 files changed, 8 insertions, 8 deletions

diff --git a/internal/hexailsp/run_more_test.go b/internal/hexailsp/run_more_test.go
index d0f17b5..b0b99fd 100644
--- a/internal/hexailsp/run_more_test.go
+++ b/internal/hexailsp/run_more_test.go
@@ -15,11 +15,11 @@ import (
 
 type recRunner struct{ ran bool }
 
-func (r *recRunner) Run() error { r.ran = true; return nil }
+func (r *recRunner) Run(context.Context) error { r.ran = true; return nil }
 
 type applyRunner struct{ opts []lsp.ServerOptions }
 
-func (r *applyRunner) Run() error                          { return nil }
+func (r *applyRunner) Run(context.Context) error           { return nil }
 func (r *applyRunner) ApplyOptions(opts lsp.ServerOptions) { r.opts = append(r.opts, opts) }
 
 type stubClient struct{}
@@ -43,13 +43,13 @@ func TestRunWithFactory_BuildsOptionsAndClient(t *testing.T) {
 	}
 	var in, out bytes.Buffer
 	logger := log.New(&out, "", 0)
-	cfg := appconfig.Load(logger)
+	cfg := appconfig.Load(context.Background(), logger)
 	// Use ollama to avoid API keys
 	cfg.Provider = "ollama"
 	cfg.MaxTokens = 123
 	cfg.PromptCodeActionRewriteSystem = "RSYS"
 	cfg.PromptCodeActionRewriteUser = "RUSER"
-	if err := RunWithFactory("", "", &in, &out, logger, cfg, nil, factory); err != nil {
+	if err := RunWithFactory(context.Background(), "", "", &in, &out, logger, cfg, nil, factory); err != nil {
 		t.Fatalf("RunWithFactory error: %v", err)
 	}
 	if captured.Config == nil {
@@ -76,10 +76,10 @@ func TestRunWithFactory_SubscriptionAppliesUpdates(t *testing.T) {
 		runner.opts = append(runner.opts, opts)
 		return runner
 	}
-	cfg := appconfig.Load(nil)
+	cfg := appconfig.Load(context.Background(), nil)
 	cfg.StatsWindowMinutes = 0
 	cfg.ContextMode = " WINDOW "
-	if err := RunWithFactory("", "", &in, &out, logger, cfg, stubClient{}, factory); err != nil {
+	if err := RunWithFactory(context.Background(), "", "", &in, &out, logger, cfg, stubClient{}, factory); err != nil {
 		t.Fatalf("RunWithFactory error: %v", err)
 	}
 	if capturedStore == nil {
@@ -115,8 +115,8 @@ func TestRunWithDependencies_UsesInjectedClientBuilderAndStatusSink(t *testing.T
 		captured = opts
 		return &recRunner{}
 	}
-	cfg := appconfig.Load(nil)
-	if err := runWithDependencies("", "", bytes.NewBuffer(nil), bytes.NewBuffer(nil), log.New(io.Discard, "", 0), cfg, nil, factory, runDependencies{
+	cfg := appconfig.Load(context.Background(), nil)
+	if err := runWithDependencies(context.Background(), "", "", bytes.NewBuffer(nil), bytes.NewBuffer(nil), log.New(io.Discard, "", 0), cfg, nil, factory, runDependencies{
 		buildClient: func(appconfig.App, llm.Client) llm.Client {
 			buildCalls++
 			return stubClient{}