Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

internal/config/trust.go:42

• LoadTrustStore's doc comment says it verifies the backing directory exists and returns a nil store when the directory is missing, but the implementation currently just returns NewTrustStore for any non-empty configDir. Either update the comment to match behavior or add an existence check (e.g., os.Stat on configDir) and return nil when the directory is absent, as documented.

// LoadTrustStore is a convenience that creates a TrustStore and verifies the
// backing directory exists. A missing file is fine (empty store); a missing
// directory is a no-op (returns nil store, no error).
func LoadTrustStore(configDir string) *TrustStore {
	if configDir == "" {
		return nil
	}
	return NewTrustStore(configDir)
}

internal/config/trust.go:115

• trustStore.load() ignores JSON unmarshal errors, which will silently treat a corrupted trusted-configs.json as an empty trust set. That’s safe but can be very confusing operationally (trust appears to “disappear”). Consider handling the unmarshal error explicitly (e.g., log a warning to stderr once, or have load/save return an error for the trust/untrust/list commands).

func (ts *TrustStore) load() trustFile {
	var tf trustFile
	data, err := os.ReadFile(ts.path) //nolint:gosec // G304: Path is from trusted config location
	if err != nil {
		return tf
	}
	_ = json.Unmarshal(data, &tf)
	return tf
}

internal/commands/config.go:504

• config trust returns/prints the resolved absolute path from resolveConfigTrustPath, but the trust store canonicalizes via EvalSymlinks. In symlinked directories this can make the returned path/summary differ from what --list shows (and what is actually stored), which is confusing for users and scripts. Consider returning the canonical/stored path in the OK response and summary for consistency.

			path, err := resolveConfigTrustPath(args)
			if err != nil {
				return err
			}

			ts := config.NewTrustStore(config.GlobalConfigDir())
			if err := ts.Trust(path); err != nil {
				return fmt.Errorf("failed to trust config: %w", err)
			}

			return app.OK(map[string]any{
				"path":   path,
				"status": "trusted",
			},
				output.WithSummary(fmt.Sprintf("Trusted: %s", path)),
				output.WithBreadcrumbs(

internal/config/trust_test.go:130

• The trust-path canonicalization behavior is central to the security model (symlink bypass prevention and deleted-file matching), but tests currently only cover a .. non-canonical path. Consider adding a test that creates a real symlinked directory path and verifies Trust/IsTrusted/Untrust work correctly through the symlink (including after deleting the config file), to ensure EvalSymlinks behavior stays correct across platforms.

func TestTrustStore_CanonicalPaths(t *testing.T) {
	dir := t.TempDir()
	ts := NewTrustStore(dir)

	// Create a file with a non-canonical path (extra ..)
	subDir := filepath.Join(dir, "sub")
	require.NoError(t, os.MkdirAll(subDir, 0755))
	configPath := filepath.Join(subDir, "config.json")
	require.NoError(t, os.WriteFile(configPath, []byte("{}"), 0644))

	// Trust using canonical path
	require.NoError(t, ts.Trust(configPath))

	// Check using non-canonical path (with ..)
	nonCanonical := filepath.Join(dir, "sub", "..", "sub", "config.json")
	assert.True(t, ts.IsTrusted(nonCanonical), "should match via canonical path")
}