Add s.literal helper for single-value enum constraints

Adds s.literal(value, description?) as a more expressive alternative
to s.enum(value) when only one exact value is valid. The inferred
TypeScript type is the literal itself (e.g. s.literal("done") infers
as "done").

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: github-actions[bot]

skills/rig/rig.ts

@@ -31,6 +31,7 @@
  * s.object(props,desc?) ObjectSchema; s.optional(inner) marks field optional; s.nullable(inner) accepts inner|null; use for fixed-key shapes
  * s.record(valSchema,desc?) RecordSchema keyed by string; use for open-ended key→value maps
  * s.enum(...values|values,desc) EnumSchema
+ * s.literal(value,desc?) EnumSchema with a single value; clearer than s.enum for single-value constraints
  * s.unknown unconstrained JSON; call as value or s.unknown("description")
  * p`...` PromptBuilder template tag; interpolates PromptIntent|string|PromptBuilder
  * p.bash(cmd,opts?) PromptIntent bash execution declaration (not run in-process)
@@ -274,6 +275,18 @@ export const s = {
       ? { nullable: true, inner: schema, description }
       : { nullable: true, inner: schema });
   },
+  /**
+   * Schema for a single exact literal value. More expressive than `s.enum` when
+   * only one value is valid. The inferred TypeScript type is the literal itself.
+   *
+   * @example
+   * s.literal("done")               // accepts only "done"; infers as "done"
+   * s.literal(42)                   // accepts only 42; infers as 42
+   * s.literal(true, "must be true") // with description
+   */
+  literal<const T extends Json>(value: T, description?: string): EnumSchema<[T]> {
+    return markAsSchema(description !== undefined ? { enum: [value], description } : { enum: [value] });
+  },
   /** Converts a rig `Schema` to a plain JSON Schema object. */
   toJsonSchema,
 };

src/rig.test.ts

@@ -1022,6 +1022,12 @@ describe("toJsonSchema", () => {
     expect(toJsonSchema(s.enum(["x", "y"], "A choice"))).toEqual({ type: "string", enum: ["x", "y"], description: "A choice" });
   });
 
+  it("converts literal schemas", () => {
+    expect(toJsonSchema(s.literal("done"))).toEqual({ type: "string", enum: ["done"] });
+    expect(toJsonSchema(s.literal(42))).toEqual({ enum: [42] });
+    expect(toJsonSchema(s.literal(true, "must be true"))).toEqual({ enum: [true], description: "must be true" });
+  });
+
   it("adds type:string to all-string enums but not mixed enums", () => {
     expect(toJsonSchema(s.enum("low", "medium", "high"))).toEqual({ type: "string", enum: ["low", "medium", "high"] });
     expect(toJsonSchema(s.enum(1, 2, 3))).toEqual({ enum: [1, 2, 3] });
@@ -1180,3 +1186,34 @@ describe("s.null", () => {
     expect(result.ok).toBe(true);
   });
 });
+
+describe("s.literal", () => {
+  it("serializes a string literal to an all-string enum schema", () => {
+    expect(toJsonSchema(s.literal("done"))).toEqual({ type: "string", enum: ["done"] });
+  });
+
+  it("serializes a number literal to an enum schema without type:string", () => {
+    expect(toJsonSchema(s.literal(42))).toEqual({ enum: [42] });
+  });
+
+  it("accepts the exact literal value in validation", () => {
+    const result = analyzeResponse(JSON.stringify("done"), s.literal("done"), "test", 1);
+    expect(result.ok).toBe(true);
+  });
+
+  it("rejects a different value in validation", () => {
+    const result = analyzeResponse(JSON.stringify("pending"), s.literal("done"), "test", 1);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error.message).toContain('"done"');
+    }
+  });
+
+  it("supports an optional description", () => {
+    expect(toJsonSchema(s.literal("active", "must be active"))).toEqual({
+      type: "string",
+      enum: ["active"],
+      description: "must be active",
+    });
+  });
+});