fix(skilldoc): make card check EOL-insensitive (Windows CI) + satisfy errcheck

Two CI failures on PR #56, both real:

- build (windows-latest): `skilldoc check` reported all 19 cards stale. Root cause:
  the fence freshness check compares the card's fence block byte-for-byte against a
  generated (LF) render, but Windows git checks the cards out with CRLF, so every
  comparison mismatched. Fix the root cause — normalize CRLF→LF on read (the
  generated fence is canonical LF) so the tool is insensitive to checkout settings —
  and add a .gitattributes pinning the cards to LF so the committed files stay
  canonical. ubuntu/macos were already green.
- lint (golangci-lint / errcheck): two unchecked fmt.Fprint* return values in
  main.go (the 'cards OK' line and the per-issue print loop). Propagate both errors.

New regression test TestRunCheck_CRLFCardIsClean. Local: go test green, golangci-lint
0 issues, check-cards OK.

Author: ysyneu

.gitattributes

@@ -0,0 +1,5 @@
+# Skill command-cards are compared byte-for-byte against a generated (LF) fence,
+# so they must stay LF on every platform regardless of git's autocrlf setting.
+# (The skilldoc tool also normalizes EOL on read; this keeps the committed files
+# canonical so Windows checkouts don't materialize them as CRLF.)
+skills/flashduty/**/*.md text eol=lf

internal/cmd/skilldoc/main.go

@@ -72,8 +72,8 @@ func checkCmd() *cobra.Command {
 			if n > 0 {
 				return fmt.Errorf("%d card issue(s) found", n)
 			}
-			fmt.Fprintln(cmd.OutOrStdout(), "skilldoc: cards OK")
-			return nil
+			_, err = fmt.Fprintln(cmd.OutOrStdout(), "skilldoc: cards OK")
+			return err
 		},
 	}
 }
@@ -90,7 +90,7 @@ func runGen(d skilldoc.Dump, base, group string) error {
 	if err != nil {
 		return fmt.Errorf("read card: %w", err)
 	}
-	body := string(raw)
+	body := normalizeEOL(string(raw))
 
 	start, end := skilldoc.FenceStart(group), skilldoc.FenceEnd(group)
 	si := strings.Index(body, start)
@@ -156,7 +156,9 @@ func runCheck(d skilldoc.Dump, base string, w io.Writer) (int, error) {
 		return issues[i].Kind < issues[j].Kind
 	})
 	for _, is := range issues {
-		fmt.Fprintf(w, "%s:%d  %s  %s\n", is.Doc, is.Line, is.Kind, is.Detail)
+		if _, err := fmt.Fprintf(w, "%s:%d  %s  %s\n", is.Doc, is.Line, is.Kind, is.Detail); err != nil {
+			return 0, err
+		}
 	}
 	return len(issues), nil
 }
@@ -191,7 +193,7 @@ func loadDocs(base string) ([]skilldoc.Doc, error) {
 		if err != nil {
 			rel = path
 		}
-		docs = append(docs, skilldoc.Doc{Path: rel, Body: string(raw)})
+		docs = append(docs, skilldoc.Doc{Path: rel, Body: normalizeEOL(string(raw))})
 		return nil
 	})
 	if err != nil {
@@ -200,6 +202,12 @@ func loadDocs(base string) ([]skilldoc.Doc, error) {
 	return docs, nil
 }
 
+// normalizeEOL collapses Windows CRLF to LF so the byte-exact fence comparison
+// and the line-based harvester are insensitive to how git checked the cards out
+// (Windows autocrlf would otherwise make every fence look stale). The generated
+// fence is always LF, so LF is the canonical form to compare against.
+func normalizeEOL(s string) string { return strings.ReplaceAll(s, "\r\n", "\n") }
+
 // cardBase resolves <repoRoot>/skills/flashduty by walking up from the cwd to
 // the directory containing go.mod.
 func cardBase() (string, error) {

internal/cmd/skilldoc/main_test.go

@@ -87,6 +87,28 @@ func TestRunCheck_CleanDirIsZero(t *testing.T) {
 	}
 }
 
+// A card checked out with Windows CRLF line endings must still validate clean:
+// the fence comparison and harvester normalize EOL, so freshness does not depend
+// on how git materialized the file (regression test for the Windows CI failure).
+func TestRunCheck_CRLFCardIsClean(t *testing.T) {
+	dir := t.TempDir()
+	d := fixtureDump()
+	body := "# status-page\n\n" +
+		"```bash\nfduty status-page change-create --type incident\n```\n\n" +
+		skilldoc.GenerateFence(d, "status-page") + "\n"
+	crlf := strings.ReplaceAll(body, "\n", "\r\n")
+	writeFile(t, filepath.Join(dir, "reference", "status-page.md"), crlf)
+
+	var out bytes.Buffer
+	n, err := runCheck(d, dir, &out)
+	if err != nil {
+		t.Fatalf("runCheck: %v", err)
+	}
+	if n != 0 {
+		t.Errorf("CRLF card should validate clean, got %d issue(s):\n%s", n, out.String())
+	}
+}
+
 func TestRunCheck_MissingDirIsZero(t *testing.T) {
 	d := fixtureDump()
 	var out bytes.Buffer