fix: align --agent/--no-agent parsing with pflag semantics

agentFlagOverride treated --agent=false as forcing human mode and
--no-agent=false as forcing agent mode, and accepted yes/on/off tokens
that pflag rejects — contradicting both pflag and the function's own
'agrees with cobra's later parse' contract.

--agent and --no-agent are two independent pflag bool flags, so an
explicit false just leaves that flag unset rather than flipping to the
opposite mode. Track each flag's final value with last-write-wins, parse
values with strconv.ParseBool (exactly as pflag does), and resolve a
genuine --agent --no-agent conflict by most-recently-enabled-wins.
parseBoolish stays lenient but is now used only for the DCI_AGENT_MODE
env var.

Author: claude

main.go

@@ -585,44 +585,67 @@ func stdoutIsTTY() bool {
 	return term.IsTerminal(int(os.Stdout.Fd()))
 }
 
-// agentFlagOverride scans args for explicit --agent / --no-agent flags. Returns
-// +1 for agent mode, -1 for human mode, 0 if neither is present. The last
-// occurrence wins. Scanning stops at the "--" operand terminator. Both the bare
-// flag and any boolean value form cobra/pflag accepts (=true/false, =1/0, etc.)
-// are honored so this early scan agrees with cobra's later parse.
+// agentFlagOverride scans args for the explicit --agent / --no-agent flags and
+// returns +1 for agent mode, -1 for human mode, or 0 for no override. These are
+// two independent pflag bool flags, so this scan mirrors pflag's own semantics:
+// each flag's last occurrence wins, a bare flag means true, and the value (when
+// present) is parsed with strconv.ParseBool exactly as pflag does. Crucially, an
+// explicit false (--agent=false / --no-agent=0) just leaves that flag unset
+// rather than forcing the opposite mode — only a flag set to true is an
+// override. If both end up true, the most recently enabled one wins. Scanning
+// stops at the "--" operand terminator. Keeping this in step with pflag matters
+// because the result drives side effects (color, default output, User-Agent)
+// before cobra parses the flags itself.
 func agentFlagOverride(args []string) int {
-	res := 0
+	agent, noAgent := false, false
+	last := 0 // +1 if --agent was most recently enabled, -1 if --no-agent was
 	for _, a := range args {
 		if a == "--" {
 			break
 		}
 		name, val, hasVal := strings.Cut(a, "=")
-		var sign int
-		switch name {
-		case "--agent":
-			sign = 1
-		case "--no-agent":
-			sign = -1
-		default:
+		if name != "--agent" && name != "--no-agent" {
 			continue
 		}
+		enabled := true
 		if hasVal {
-			b, ok := parseBoolish(val)
-			if !ok {
+			b, err := strconv.ParseBool(val)
+			if err != nil {
 				continue // let cobra surface the parse error later
 			}
-			if !b {
-				sign = -sign // --agent=false / --no-agent=false
+			enabled = b
+		}
+		switch name {
+		case "--agent":
+			agent = enabled
+		case "--no-agent":
+			noAgent = enabled
+		}
+		if enabled {
+			if name == "--agent" {
+				last = 1
+			} else {
+				last = -1
 			}
 		}
-		res = sign
 	}
-	return res
+	switch {
+	case agent && noAgent:
+		return last // conflicting flags: most recently enabled wins
+	case agent:
+		return 1
+	case noAgent:
+		return -1
+	default:
+		return 0
+	}
 }
 
-// parseBoolish interprets the boolean tokens cobra/pflag accept (plus a few
-// common aliases), case-insensitively. Returns (value, true) for a recognized
-// token and (false, false) otherwise.
+// parseBoolish interprets a boolean-ish env var value (DCI_AGENT_MODE),
+// case-insensitively and forgivingly: it accepts the strconv.ParseBool tokens
+// plus common aliases (yes/no, on/off, y/n). Returns (value, true) for a
+// recognized token and (false, false) otherwise. It is intentionally more
+// lenient than the flag parsing, which mirrors pflag exactly.
 func parseBoolish(v string) (bool, bool) {
 	switch strings.ToLower(strings.TrimSpace(v)) {
 	case "1", "t", "true", "yes", "y", "on":

main_test.go

@@ -442,16 +442,28 @@ func TestAgentFlagOverride(t *testing.T) {
 		{name: "none", args: []string{"dci", "status"}, want: 0},
 		{name: "agent", args: []string{"dci", "--agent", "status"}, want: 1},
 		{name: "agent equals true", args: []string{"--agent=true"}, want: 1},
-		{name: "agent equals false", args: []string{"--agent=false"}, want: -1},
 		{name: "agent equals 1", args: []string{"--agent=1"}, want: 1},
-		{name: "agent equals 0", args: []string{"--agent=0"}, want: -1},
 		{name: "no-agent", args: []string{"--no-agent"}, want: -1},
-		{name: "no-agent equals false", args: []string{"--no-agent=false"}, want: 1},
 		{name: "no-agent equals 1", args: []string{"--no-agent=1"}, want: -1},
-		{name: "no-agent equals 0", args: []string{"--no-agent=0"}, want: 1},
 		{name: "agent uppercase TRUE", args: []string{"--agent=TRUE"}, want: 1},
+
+		// Explicit false leaves the flag unset (matching two independent pflag
+		// bool flags), so it does NOT force the opposite mode — it clears to 0.
+		{name: "agent equals false clears", args: []string{"--agent=false"}, want: 0},
+		{name: "agent equals 0 clears", args: []string{"--agent=0"}, want: 0},
+		{name: "no-agent equals false clears", args: []string{"--no-agent=false"}, want: 0},
+		{name: "no-agent equals 0 clears", args: []string{"--no-agent=0"}, want: 0},
+		{name: "agent then agent false clears", args: []string{"--agent", "--agent=false"}, want: 0},
+		{name: "no-agent then no-agent false clears", args: []string{"--no-agent", "--no-agent=false"}, want: 0},
+
+		// pflag uses strconv.ParseBool, which rejects yes/on/etc. (parseBoolish
+		// accepts them, but that's only for the DCI_AGENT_MODE env var).
+		{name: "agent yes rejected (not pflag bool)", args: []string{"--agent=yes"}, want: 0},
 		{name: "agent unrecognized value ignored", args: []string{"--agent=maybe"}, want: 0},
-		{name: "last wins", args: []string{"--agent", "--no-agent"}, want: -1},
+
+		// Conflicting flags both true: most recently enabled wins.
+		{name: "conflict no-agent last wins", args: []string{"--agent", "--no-agent"}, want: -1},
+		{name: "conflict agent last wins", args: []string{"--no-agent", "--agent"}, want: 1},
 		{name: "stop at terminator", args: []string{"--", "--agent"}, want: 0},
 	}