docs: lead with fn init in the toolkit README and main README

Wave 8 of the portable-functions toolkit. Updates user-facing docs
so that `fn init` is the first thing a new user sees, not the last.

- docs/portable-functions-toolkit.md: replace the "Customer repo
  experience" section with a "Quick start" that begins with
  `fn init send-welcome --no-tty` rather than assuming the user has
  hand-authored a handler.json. Add the full CLI surface table
  including `init` and its flags. Note the genomic-via-pgpm-init
  alignment so users who know `pgpm init` carry their knowledge over.
- README.md: lead with the in-another-repo flow. The brasilia-as-
  dogfood instructions stay below as the second quick-start. New
  paragraph at top points at the toolkit guide.

The starter-kit / pgpm init scaffold-the-whole-project flow is
deliberately left as future work — the addendum in the plan file
documents it but it lands in its own follow-on.

Author: Anmol1696

README.md

@@ -2,7 +2,22 @@
 
 Functions playground for Constructive — isolated workspace for building, testing, and deploying Knative-style HTTP functions.
 
-## Quick Start
+This repo is also the source of the **Portable Functions Toolkit**: a set of `@constructive-io/fn-*` npm packages that any external repo can `pnpm add` to get the same code-gen + Docker + k8s pipeline against its own `functions/` directory. See [docs/portable-functions-toolkit.md](docs/portable-functions-toolkit.md) for the full toolkit guide.
+
+## Quick start (in another repo)
+
+```bash
+pnpm add -D @constructive-io/fn-cli
+pnpm add @constructive-io/fn-runtime
+
+pnpm fn init send-welcome --no-tty           # scaffold functions/send-welcome/
+pnpm fn generate                             # stamp out generated/<name>/ packages
+pnpm install                                 # link the new workspaces
+pnpm fn build                                # compile
+pnpm fn dev                                  # run functions as local Node processes
+```
+
+## Quick start (this repo, dogfood)
 
 ```bash
 # Install dependencies

docs/portable-functions-toolkit.md

@@ -19,31 +19,54 @@ knative-job-fn (fn-app)         (low-level Express middleware)
 | `@constructive-io/knative-job-fn` | Low-level Express middleware for Knative job request/response shape. fn-runtime depends on it. |
 | `@constructive-io/fn-generator` | Programmatic builders that emit Dockerfiles, k8s YAML, configmaps, skaffold profiles, manifest registry. Pure functions; idempotent file I/O at the boundary. |
 | `@constructive-io/fn-client` | Importable `FnClient` API — config loading, manifest reading, `pnpm build`, child-process orchestration for `dev`. |
-| `@constructive-io/fn-cli` | The `fn` executable. Subcommands: `generate`, `build`, `dev`, `manifest`, `verify`. |
+| `@constructive-io/fn-cli` | The `fn` executable. Subcommands: `init`, `generate`, `build`, `dev`, `manifest`, `verify`. |
 
-## Customer repo experience
+## Quick start
+
+```bash
+# In a fresh project
+pnpm add -D @constructive-io/fn-cli
+pnpm add @constructive-io/fn-runtime
+
+# Scaffold a function
+pnpm fn init send-welcome --no-tty --description "Welcome email sender"
+# → functions/send-welcome/{handler.json, handler.ts}
+
+# Stamp out the workspace package, build, run
+pnpm fn generate
+pnpm install                           # link the just-created generated/* workspaces
+pnpm fn build
+pnpm fn dev                            # functions run as local Node processes
+```
+
+`fn init` uses [`genomic`](https://www.npmjs.com/package/genomic) under the hood — the same template engine `pgpm init` uses — so the prompt conventions and `--no-tty` flag-mapping match the rest of the Constructive ecosystem. Two handler types ship today: `--type=node-graphql` (default) and `--type=python`.
+
+## Repo layout the toolkit expects
 
 ```
 my-app/
 ├── functions/
 │   └── send-welcome/
 │       ├── handler.json   # {"name":"send-welcome","version":"0.1.0","type":"node-graphql"}
 │       └── handler.ts     # default-exported FunctionHandler
-├── fn.config.json         # FnConfig (typed via fn-types)
+├── fn.config.json         # FnConfig (typed via fn-types) — optional
 └── package.json
 ```
 
-```bash
-pnpm add -D @constructive-io/fn-cli
-pnpm add @constructive-io/fn-runtime
+## CLI surface
 
-pnpm fn generate                       # write generated/<name>/ + manifest + skaffold
-pnpm fn build                          # pnpm -r build
-pnpm fn manifest                       # cat generated/functions-manifest.json
-pnpm fn verify                         # check manifest matches functions/
-pnpm fn dev                            # spawn each function as a Node child
+```bash
+fn init <name> [--type=node-graphql|python] [--description=<d>] [--force] [--no-tty]
+fn generate [--only=<name>] [--packages-only]
+fn build [--only=<name>]
+fn dev [--only=<name>]
+fn manifest                            # print on-disk functions-manifest.json
+fn verify                              # check manifest matches functions/
+fn --version                           # print fn-cli version
 ```
 
+Common flags: `--root=<dir>`, `--config=<file>`.
+
 ## Job-service registry (when running the `jobs-bundle` preset)
 
 The job-service no longer hardcodes function names. It loads its registry at startup from one of three sources, in priority order: