fix(security): propagate parent context to delegate_tasks so sub-agents die on cancel (M3)

delegateTasksTool.runTask() created its per-task context from
context.Background(), completely detached from the parent agent.
When the parent was cancelled (Ctrl+C, restart, timeout), the
sub-agent processes kept running for the full 120s timeout,
blocking the parent loop.

Fix:
- Add ctx field + SetContext() to delegateTasksTool
- runTask now derives its timeout context from the parent's context
  instead of context.Background()
- In the agent loop (loop.go:741), before calling t.Call(), check
  if the tool implements SetContext(context.Context) and propagate
  the agent's context

Result: when the parent is cancelled, all running sub-agents are
killed promptly via exec.CommandContext cancellation chain, instead
of running the full 120s timeout.

Fixes M3 from security audit.

Author: molty3000

cmd/odek/subagent_tool.go

@@ -26,6 +26,12 @@ type delegateTasksTool struct {
 	odekPath       string // path to the odek binary
 	timeout        time.Duration
 
+	// ctx is the parent agent's context, set by the agent loop before each
+	// Call invocation. When the parent is cancelled (Ctrl+C, restart, timeout),
+	// runTask derives its per-task context from this, so sub-agent processes
+	// are killed promptly instead of running the full timeout.
+	ctx context.Context
+
 	// OnSubagentLog, if set, is called with each NDJSON progress line
 	// emitted by a sub-agent. taskIdx is the index within the current
 	// batch. Used by the WebUI for live log streaming.
@@ -34,6 +40,13 @@ type delegateTasksTool struct {
 
 func (t *delegateTasksTool) Name() string { return "delegate_tasks" }
 
+// SetContext sets the parent agent's context on the tool.
+// Called by the agent loop before each Call invocation to propagate
+// cancellation signals (Ctrl+C, restart, timeout) to sub-agents.
+func (t *delegateTasksTool) SetContext(ctx context.Context) {
+	t.ctx = ctx
+}
+
 func (t *delegateTasksTool) Description() string {
 	return `Spawn one or more sub-agent OS processes to work on focused sub-tasks in parallel. Each sub-agent gets its own process, config, and context window. Use this when the task has clear independent sub-tasks that can be worked on simultaneously.
 
@@ -142,7 +155,14 @@ func (t *delegateTasksTool) Call(args string) (string, error) {
 }
 
 func (t *delegateTasksTool) runTask(taskIdx int, goal, taskContext, system string) string {
-	ctx, cancel := context.WithTimeout(context.Background(), t.timeout)
+	// Derive per-task context from the parent's context (if set).
+	// When the parent is cancelled, all running sub-agents are killed
+	// promptly instead of running the full timeout.
+	parentCtx := context.Background()
+	if t.ctx != nil {
+		parentCtx = t.ctx
+	}
+	ctx, cancel := context.WithTimeout(parentCtx, t.timeout)
 	defer cancel()
 
 	// Write task to temp file (avoids CLI arg length limits)

internal/loop/loop.go

@@ -738,6 +738,11 @@ if e.approver != nil && len(result.ToolCalls) > 1 {
 					t := e.registry.Get(tcRef.Function.Name)
 					output := fmt.Sprintf("error: tool %q not found", tcRef.Function.Name)
 					if t != nil {
+						// Propagate agent context to tools that support it
+						// (e.g. delegate_tasks kills sub-agents on parent cancel).
+						if ctxTool, ok := t.(interface{ SetContext(context.Context) }); ok {
+							ctxTool.SetContext(ctx)
+						}
 						res, err := t.Call(tcRef.Function.Arguments)
 						if err != nil {
 							output = fmt.Sprintf("error: %s", err.Error())