@@ -1,6 +1,6 @@
-manuscript/
-cast/
-.foundry-work/
+/manuscript/
+/cast/
+/.foundry-work/
 /foundry
 *.plugin
 .DS_Store
@@ -0,0 +1,260 @@
+package cast
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"sort"
+	"strings"
+)
+
+// PressResult describes how CLI generation was carried out.
+type PressResult struct {
+	Mode       string   `json:"mode"` // printing-press | scaffold
+	Spec       string   `json:"spec"`
+	OutDir     string   `json:"out_dir"`
+	Commands   []string `json:"commands,omitempty"`   // shell commands actually run
+	Operations []string `json:"operations,omitempty"` // operation ids in a scaffolded CLI
+	Notes      []string `json:"notes"`
+}
+
+// PressAvailable reports whether cli-printing-press is installed. The foundry
+// does not reimplement the press: it casts type and hands it over. The built-in
+// scaffold exists only as a fallback.
+func PressAvailable() bool {
+	_, err := exec.LookPath("cli-printing-press")
+	return err == nil
+}
+
+// Press generates a CLI from a spec. If cli-printing-press is on PATH it is
+// invoked with the cast spec. Otherwise a minimal, self-contained Go scaffold
+// is emitted so the operator still has something runnable.
+func Press(specPath, outDir, name string, dryRun bool) (PressResult, error) {
+	res := PressResult{Spec: specPath, OutDir: outDir}
+
+	if PressAvailable() {
+		res.Mode = "printing-press"
+		args := []string{"--spec", specPath, "--out", outDir}
+		if dryRun {
+			res.Commands = append(res.Commands, "cli-printing-press "+strings.Join(args, " "))
+			res.Notes = append(res.Notes, "dry run: nothing executed")
+			return res, nil
+		}
+		cmd := exec.Command("cli-printing-press", args...)
+		cmd.Stdout, cmd.Stderr = os.Stdout, os.Stderr
+		res.Commands = append(res.Commands, "cli-printing-press "+strings.Join(args, " "))
+		if err := cmd.Run(); err != nil {
+			res.Notes = append(res.Notes, fmt.Sprintf("printing press exited with error: %v", err))
+			return res, err
+		}
+		return res, nil
+	}
+
+	res.Mode = "scaffold"
+	res.Notes = append(res.Notes,
+		"cli-printing-press is not installed, so a minimal scaffold was emitted instead.",
+		"Install the press for the full treatment (SQLite sync, MCP server, agent-native flags): https://github.com/mvanhorn/cli-printing-press")
+	if dryRun {
+		return res, nil
+	}
+	ops, dir, err := scaffold(specPath, outDir, name)
+	res.Operations = ops
+	if dir != "" {
+		res.OutDir = dir
+	}
+	return res, err
+}
+
+type specDoc struct {
+	Info struct {
+		Title string `json:"title"`
+	} `json:"info"`
+	Servers []struct {
+		URL string `json:"url"`
+	} `json:"servers"`
+	Paths map[string]map[string]struct {
+		OperationID string `json:"operationId"`
+		Summary     string `json:"summary"`
+	} `json:"paths"`
+}
+
+// scaffold writes a small but real Go CLI: one subcommand per operation, with
+// --json output and bearer-token auth from the environment.
+func scaffold(specPath, outDir, name string) ([]string, string, error) {
+	b, err := os.ReadFile(specPath)
+	if err != nil {
+		return nil, "", err
+	}
+	var doc specDoc
+	if err := json.Unmarshal(b, &doc); err != nil {
+		return nil, "", fmt.Errorf("scaffold needs a JSON spec: %w", err)
+	}
+	if name == "" {
+		name = slug(doc.Info.Title)
+	}
+	if name == "" {
+		name = "target"
+	}
+
+	base := ""
+	if len(doc.Servers) > 0 {
+		base = doc.Servers[0].URL
+	}
+
+	type op struct{ id, method, path, summary string }
+	var ops []op
+	for p, methods := range doc.Paths {
+		for m, o := range methods {
+			id := o.OperationID
+			if id == "" {
+				id = slug(m + p)
+			}
+			ops = append(ops, op{id, strings.ToUpper(m), p, o.Summary})
+		}
+	}
+	sort.Slice(ops, func(i, j int) bool { return ops[i].id < ops[j].id })
+
+	dir := filepath.Join(outDir, name+"-cli")
+	if err := os.MkdirAll(dir, 0o755); err != nil {
+		return nil, "", err
+	}
+
+	var sb strings.Builder
+	sb.WriteString("// Code generated by Type Foundry from a reconstructed specification.\n")
+	sb.WriteString("// The spec was inferred from observed artifacts, not published by the vendor.\n")
+	sb.WriteString("// Treat every endpoint as unverified until you have exercised it yourself.\n\n")
+	sb.WriteString("package main\n\nimport (\n\t\"encoding/json\"\n\t\"flag\"\n\t\"fmt\"\n\t\"io\"\n\t\"net/http\"\n\t\"os\"\n\t\"strings\"\n\t\"time\"\n)\n\n")
+	fmt.Fprintf(&sb, "const baseURL = %q\n\n", base)
+	sb.WriteString(`type op struct {
+	Method  string
+	Path    string
+	Summary string
+}
+
+var ops = map[string]op{
+`)
+	for _, o := range ops {
+		fmt.Fprintf(&sb, "\t%q: {%q, %q, %q},\n", o.id, o.method, o.path, o.summary)
+	}
+	sb.WriteString("}\n\n")
+	sb.WriteString(`func main() {
+	jsonOut := flag.Bool("json", false, "emit raw JSON")
+	dryRun := flag.Bool("dry-run", false, "print the request without sending it")
+	flag.Parse()
+
+	if flag.NArg() == 0 {
+		fmt.Println("commands:")
+		for id, o := range ops {
+			fmt.Printf("  %-40s %s %s\n", id, o.Method, o.Path)
+		}
+		os.Exit(2)
+	}
+	o, ok := ops[flag.Arg(0)]
+	if !ok {
+		fmt.Fprintf(os.Stderr, "unknown command %q\n", flag.Arg(0))
+		os.Exit(2)
+	}
+
+	path := o.Path
+	for _, kv := range flag.Args()[1:] {
+		parts := strings.SplitN(kv, "=", 2)
+		if len(parts) == 2 {
+			path = strings.ReplaceAll(path, "{"+parts[0]+"}", parts[1])
+		}
+	}
+	url := baseURL + path
+
+	if *dryRun {
+		fmt.Printf("%s %s\n", o.Method, url)
+		return
+	}
+
+	req, err := http.NewRequest(o.Method, url, nil)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(3)
+	}
+	if tok := os.Getenv("FOUNDRY_TOKEN"); tok != "" {
+		req.Header.Set("Authorization", "Bearer "+tok)
+	}
+	req.Header.Set("Accept", "application/json")
+
+	client := &http.Client{Timeout: 30 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(4)
+	}
+	defer resp.Body.Close()
+	body, _ := io.ReadAll(resp.Body)
+
+	if resp.StatusCode >= 400 {
+		fmt.Fprintf(os.Stderr, "http %d\n%s\n", resp.StatusCode, body)
+		os.Exit(5)
+	}
+	if *jsonOut {
+		os.Stdout.Write(body)
+		return
+	}
+	var v interface{}
+	if json.Unmarshal(body, &v) == nil {
+		enc := json.NewEncoder(os.Stdout)
+		enc.SetIndent("", "  ")
+		_ = enc.Encode(v)
+		return
+	}
+	os.Stdout.Write(body)
+}
+`)
+
+	if err := os.WriteFile(filepath.Join(dir, "main.go"), []byte(sb.String()), 0o644); err != nil {
+		return nil, "", err
+	}
+	mod := fmt.Sprintf("module %s-cli\n\ngo 1.22\n", name)
+	if err := os.WriteFile(filepath.Join(dir, "go.mod"), []byte(mod), 0o644); err != nil {
+		return nil, "", err
+	}
+
+	readme := fmt.Sprintf(`# %s-cli
+
+Scaffolded by Type Foundry from a **reconstructed** specification.
+
+    go build -o %s-cli .
+    FOUNDRY_TOKEN=... ./%s-cli <operation> [param=value ...]
+    ./%s-cli --dry-run <operation>
+
+%d operations. The spec was inferred from observed artifacts and is not an
+official interface: endpoints may change without notice and none of it is
+endorsed by the vendor. Use against accounts you control.
+`, name, name, name, name, len(ops))
+	if err := os.WriteFile(filepath.Join(dir, "README.md"), []byte(readme), 0o644); err != nil {
+		return nil, "", err
+	}
+
+	out := make([]string, 0, len(ops))
+	for _, o := range ops {
+		out = append(out, o.id)
+	}
+	return out, dir, nil
+}
+
+func slug(s string) string {
+	s = strings.ToLower(s)
+	var b strings.Builder
+	prevDash := false
+	for _, r := range s {
+		switch {
+		case r >= 'a' && r <= 'z', r >= '0' && r <= '9':
+			b.WriteRune(r)
+			prevDash = false
+		default:
+			if !prevDash && b.Len() > 0 {
+				b.WriteByte('-')
+				prevDash = true
+			}
+		}
+	}
+	return strings.Trim(b.String(), "-")
+}
@@ -0,0 +1,126 @@
+package cast
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"time"
+)
+
+// FoundSpec describes a specification already present on disk. The foundry
+// looks for these before doing any work, so a spec cast in an earlier session
+// can be handed straight to the press without re-striking anything.
+type FoundSpec struct {
+	Path        string    `json:"path"`
+	Kind        string    `json:"kind"`  // openapi | swagger | graphql | postman | unknown
+	Title       string    `json:"title,omitempty"`
+	Version     string    `json:"version,omitempty"`
+	PathCount   int       `json:"path_count"`
+	ByFoundry   bool      `json:"by_foundry"` // did we cast this ourselves
+	ModifiedAt  time.Time `json:"modified_at"`
+	SizeBytes   int64     `json:"size_bytes"`
+}
+
+var specNames = map[string]bool{
+	"openapi.json": true, "openapi.yaml": true, "openapi.yml": true,
+	"swagger.json": true, "swagger.yaml": true, "swagger.yml": true,
+	"api.json": true, "spec.json": true, "schema.graphql": true,
+	"postman_collection.json": true,
+}
+
+// FindSpecs walks dirs (up to two levels) looking for existing specifications.
+// Results are sorted newest first so the most recent cast is the default.
+func FindSpecs(dirs ...string) []FoundSpec {
+	var out []FoundSpec
+	seen := map[string]bool{}
+
+	for _, dir := range dirs {
+		if dir == "" {
+			continue
+		}
+		root := filepath.Clean(dir)
+		_ = filepath.Walk(root, func(p string, fi os.FileInfo, err error) error {
+			if err != nil {
+				return nil
+			}
+			// Keep the walk shallow: two levels below the root.
+			if fi.IsDir() {
+				rel, _ := filepath.Rel(root, p)
+				if strings.Count(rel, string(os.PathSeparator)) >= 2 && rel != "." {
+					return filepath.SkipDir
+				}
+				base := filepath.Base(p)
+				if base == "node_modules" || base == ".git" || base == ".foundry-work" {
+					return filepath.SkipDir
+				}
+				return nil
+			}
+			name := strings.ToLower(filepath.Base(p))
+			if !specNames[name] && !strings.HasSuffix(name, ".openapi.json") {
+				return nil
+			}
+			abs, _ := filepath.Abs(p)
+			if seen[abs] {
+				return nil
+			}
+			seen[abs] = true
+			if fs := inspectSpec(p, fi); fs != nil {
+				out = append(out, *fs)
+			}
+			return nil
+		})
+	}
+
+	sort.Slice(out, func(i, j int) bool { return out[i].ModifiedAt.After(out[j].ModifiedAt) })
+	return out
+}
+
+func inspectSpec(path string, fi os.FileInfo) *FoundSpec {
+	fs := &FoundSpec{
+		Path:       path,
+		Kind:       "unknown",
+		ModifiedAt: fi.ModTime(),
+		SizeBytes:  fi.Size(),
+	}
+	if strings.HasSuffix(strings.ToLower(path), ".graphql") {
+		fs.Kind = "graphql"
+		return fs
+	}
+	b, err := os.ReadFile(path)
+	if err != nil {
+		return fs
+	}
+	var doc map[string]interface{}
+	if err := json.Unmarshal(b, &doc); err != nil {
+		// YAML specs are still worth reporting; we just cannot introspect them here.
+		if strings.HasSuffix(path, ".yaml") || strings.HasSuffix(path, ".yml") {
+			fs.Kind = "openapi"
+		}
+		return fs
+	}
+	switch {
+	case doc["openapi"] != nil:
+		fs.Kind = "openapi"
+	case doc["swagger"] != nil:
+		fs.Kind = "swagger"
+	case doc["info"] != nil && doc["item"] != nil:
+		fs.Kind = "postman"
+	}
+	if info, ok := doc["info"].(map[string]interface{}); ok {
+		if t, ok := info["title"].(string); ok {
+			fs.Title = t
+		}
+		if v, ok := info["version"].(string); ok {
+			fs.Version = v
+		}
+		if d, ok := info["description"].(string); ok && strings.Contains(d, "Type Foundry") {
+			fs.ByFoundry = true
+		}
+	}
+	if paths, ok := doc["paths"].(map[string]interface{}); ok {
+		fs.PathCount = len(paths)
+	}
+	return fs
+}