fix(secrets): fall back to passthrough on unknown scheme

A literal value with a colon before any '/' or space (e.g. a Postgres
password 'p@ss:w0rd') was parsed as the scheme 'p@ss', matched no backend,
and errored instead of resolving. Now an unclaimed scheme falls through to
the passthrough backend; the error only fires when no passthrough exists.
This also aligns with 'profile show' masking, which treats the same value
as a literal. Regression tests added.

Also narrows the .claude/settings.json secrets deny-glob from ./secrets/**
to /secrets/** so it protects a root ./secrets/ credentials dir without
blocking the internal/secrets/ Go source package.

Author: nixrajput

.claude/settings.json

@@ -36,14 +36,14 @@
     "deny": [
       "Read(./.env)",
       "Read(./.env.*)",
-      "Read(./secrets/**)",
+      "Read(/secrets/**)",
       "Read(./config/credentials.json)",
       "Read(./**/*.key)",
       "Read(./**/*.pem)",
       "Read(./**/*.crt)",
       "Write(./.env)",
       "Write(./.env.*)",
-      "Write(./secrets/**)",
+      "Write(/secrets/**)",
       "Write(./config/credentials.json)",
       "Write(./**/*.key)",
       "Write(./**/*.pem)",

internal/secrets/resolver.go

@@ -42,6 +42,15 @@ func (r *Resolver) Resolve(ref string) (string, error) {
 			return b.Resolve(ref)
 		}
 	}
+	// No backend claims this scheme. Fall back to the passthrough ("") backend
+	// rather than erroring: a literal value can legitimately contain a colon
+	// before any "/" or space (e.g. a Postgres password "p@ss:w0rd"), which
+	// parseScheme would otherwise read as the unknown scheme "p@ss".
+	for _, b := range r.backends {
+		if b.Scheme() == "" {
+			return b.Resolve(ref)
+		}
+	}
 	return "", &errs.Error{
 		Op:    "secrets.resolve",
 		Code:  errs.CodeUser,

internal/secrets/resolver_test.go

@@ -38,10 +38,40 @@ func TestResolver_EnvMissing_ReturnsErrSecretUnresolved(t *testing.T) {
 	}
 }
 
-func TestResolver_UnknownScheme_ErrorMentionsBackends(t *testing.T) {
+// With a passthrough backend present, an unknown scheme falls back to the
+// literal value rather than erroring — there's no way to tell "meant the vault
+// backend" from "literal value that looks like vault:foo", so passthrough wins.
+func TestResolver_UnknownScheme_FallsBackToPassthrough(t *testing.T) {
 	r := NewResolver(Passthrough{}, Env{})
+	got, err := r.Resolve("vault:foo")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if got != "vault:foo" {
+		t.Fatalf("got %q; want literal 'vault:foo' via passthrough", got)
+	}
+}
+
+// Without a passthrough backend, an unknown scheme still errors (and the error
+// names the available backends).
+func TestResolver_UnknownScheme_NoPassthrough_Errors(t *testing.T) {
+	r := NewResolver(Env{})
 	_, err := r.Resolve("vault:foo")
 	if err == nil {
-		t.Fatal("expected error for unknown scheme")
+		t.Fatal("expected error for unknown scheme when no passthrough backend")
+	}
+}
+
+// TestResolver_LiteralWithColon is the regression: a literal password
+// containing a colon (valid in Postgres) must resolve as-is, not be misread as
+// the unknown scheme before the colon.
+func TestResolver_LiteralWithColon(t *testing.T) {
+	r := NewResolver(Env{}, Passthrough{})
+	got, err := r.Resolve("p@ss:w0rd")
+	if err != nil {
+		t.Fatalf("literal with colon errored: %v", err)
+	}
+	if got != "p@ss:w0rd" {
+		t.Fatalf("got %q; want literal 'p@ss:w0rd'", got)
 	}
 }