docs(go): flesh out store + io + process landing pages

Replaces the "page in flight" stubs on the three core/go packages that
got the Result API + Windows compile path treatment this week.

go/store
  - Two-layer story: SQLite KV + DuckDB workspace
  - Service Register pattern with Result-returning constructors
  - Scoped namespaces + quota config
  - Canonical scoring tables + Parquet export
  - Windows compile status (CGO required, mingw or wails-cross)

go/io
  - Full Medium interface listing with every method
  - Three backends: sandboxed local, in-memory, mock
  - io.Copy example for backend-to-backend transfer
  - Service registration + io/* action dispatch
  - Windows compile note — core.Lstat + portable linkInfo

go/process
  - One-shot exec via Start / StartWithOptions
  - Long-lived Daemon with restart policy + log ring buffer
  - HealthServer for HTTP introspection
  - Service + Registry pattern for multi-process apps
  - Cross-platform helper triplet table: processSignal,
    processKillGroup, processSignalGroup, applyProcessGroup,
    exitWasSignaled — Unix vs Windows behaviour mapped explicitly

Cross-links the three pages to each other + to result/ so the navigation
flows naturally from primitive to package to consumer.

Co-Authored-By: Virgil <virgil@lethean.io>

Author: Snider

src/content/docs/go/io.mdx

@@ -12,7 +12,10 @@ head:
       content: 'dappco.re/go/io https://github.com/dappcore/go-io https://github.com/dappcore/go-io/tree/main{/dir} https://github.com/dappcore/go-io/blob/main{/dir}/{file}#L{line}'
 ---
 
-Universal IO — Medium transport, datanode, sigil, sqlite, S3. Built on the [`core/go`](/go/) primitives.
+One file-system interface, several backends. The `Medium` contract is what
+every other [`core/go`](/go/) package speaks when it needs to read, write,
+list, or watch a path — and the path is the same regardless of whether the
+storage is local disk, an in-memory mock, or a sandboxed root.
 
 ## Install
 
@@ -26,7 +29,94 @@ go get dappco.re/go/io@latest
 import "dappco.re/go/io"
 ```
 
-## Status
+## The Medium contract
 
-Page in flight — content fills in as the package converges. Source of truth
-today is the README and inline docstrings in the repo.
+```go
+type Medium interface {
+    Read(path string) (string, error)
+    Write(path, content string) error
+    WriteMode(path, content string, mode fs.FileMode) error
+    EnsureDir(path string) error
+    IsFile(path string) bool
+    Delete(path string) error
+    DeleteAll(path string) error
+    Rename(oldPath, newPath string) error
+    List(path string) ([]fs.DirEntry, error)
+    Stat(path string) (fs.FileInfo, error)
+    Open(path string) (fs.File, error)
+    Create(path string) (io.WriteCloser, error)
+}
+```
+
+Every method takes a string path. Permissions, locking, encoding choices —
+all live behind the backend. A consumer writes against `Medium` once and
+swaps backends at construction without code changes.
+
+## Backends
+
+| Backend | Construct | Use case |
+|---|---|---|
+| **Sandboxed local** | `io.NewSandboxed(root)` | Disk-backed with a chroot — paths can never escape `root` |
+| **In-memory** | `io.NewMemoryMedium()` | Ephemeral state, fixtures, fast unit tests |
+| **Mock** | `io.NewMockMedium()` | Tests that need to assert specific call patterns |
+
+```go
+disk, r := io.NewSandboxed("/srv/app")
+if !r.OK { return r }
+
+_ = disk.Write("config/app.yaml", "port: 8080")
+content, _ := disk.Read("config/app.yaml")
+
+// Same code, different backend
+mem := io.NewMemoryMedium()
+_ = mem.Write("config/app.yaml", "port: 8080")
+```
+
+## Copy across backends
+
+`io.Copy` moves payloads between any two Mediums with the same semantics
+regardless of where the bytes physically live:
+
+```go
+local, _  := io.NewSandboxed("/srv/app")
+backup, _ := io.NewSandboxed("/srv/backup")
+
+_ = io.Copy(local, "data/report.json", backup, "daily/report.json")
+```
+
+A unit test can mount a `MemoryMedium` in place of either side and the
+production code path stays unchanged.
+
+## Service registration
+
+The package follows the `core/go` Service pattern — register once on a
+`*core.Core` and every consumer with the Core handle can dispatch IO
+actions through `c.Action("io/...")`:
+
+```go
+c := core.New(core.Options{})
+if r := io.Register(c); !r.OK { return r }
+
+io.RegisterActions(c)  // Adds io/read, io/write, io/list, etc.
+```
+
+## Cross-platform compile
+
+The local backend is portable across Linux, macOS, and Windows. Symbolic
+link handling — historically Unix-only via `syscall.Stat_t` — is now
+abstracted behind `core.Lstat` plus a portable `linkInfo` helper so the
+same file builds clean for `GOOS=windows GOARCH=amd64 CGO_ENABLED=0`.
+See `medium_link.go` for the platform-neutral implementation that ships
+the Windows compile path.
+
+## Sibling packages
+
+- [`go/store`](/go/store/) — KV + workspace persistence; uses Medium when
+  the underlying store lives off-disk
+- [`go/process`](/go/process/) — process supervisor that watches files
+  through Medium
+- [`go/scm`](/go/scm/) — repo-sync actions that fan out across Mediums
+
+## Source
+
+[`github.com/dappcore/go-io`](https://github.com/dappcore/go-io) — full source, issues, and releases.

src/content/docs/go/process.mdx

@@ -12,7 +12,10 @@ head:
       content: 'dappco.re/go/process https://github.com/dappcore/go-process https://github.com/dappcore/go-process/tree/main{/dir} https://github.com/dappcore/go-process/blob/main{/dir}/{file}#L{line}'
 ---
 
-Process orchestration — exec, daemon, lifecycle, status. Built on the [`core/go`](/go/) primitives.
+Process supervisor primitives — start, stop, signal, wait, restart. The
+same call shape that runs a one-shot exec also drives long-lived daemons
+with health endpoints. Built on [`core/go`](/go/) so every operation
+returns a [`Result`](/go/result/).
 
 ## Install
 
@@ -26,7 +29,109 @@ go get dappco.re/go/process@latest
 import "dappco.re/go/process"
 ```
 
-## Status
+## One-shot exec
 
-Page in flight — content fills in as the package converges. Source of truth
-today is the README and inline docstrings in the repo.
+```go
+r := process.Start(ctx, "git", "rev-parse", "HEAD")
+if !r.OK { return r }
+sha := r.Value.(string)
+```
+
+For more control — environment, working directory, stdout/stderr capture
+— pass `RunOptions`:
+
+```go
+r := process.StartWithOptions(ctx, process.RunOptions{
+    Command: "ffmpeg",
+    Args:    []string{"-i", "in.mov", "out.mp4"},
+    Env:     map[string]string{"PATH": "/usr/local/bin:/usr/bin"},
+    Dir:     "/tmp/encode",
+    Capture: true,
+})
+if !r.OK { return r }
+out := r.Value.(*process.ExecResult)
+fmt.Println(out.Stdout)
+```
+
+## Long-lived daemon
+
+`Daemon` wraps a command with a supervisor loop — restart on exit, ring
+buffer for the last N stdout/stderr lines, optional health endpoint:
+
+```go
+d := process.NewDaemon(process.DaemonOptions{
+    Name:           "indexer",
+    Command:        "/usr/local/bin/indexer",
+    Args:           []string{"--watch", "/srv/data"},
+    RestartPolicy:  process.RestartAlways,
+    RestartBackoff: 5 * time.Second,
+    LogBufferSize:  1024,
+})
+
+if r := d.Start(ctx); !r.OK { return r }
+defer d.Stop(ctx)
+
+// Tail the recent logs at any time
+lines := d.RecentLogs(50)
+```
+
+For HTTP introspection:
+
+```go
+hs := process.NewHealthServer(":7100")
+hs.Attach(d)
+go hs.Listen(ctx)
+
+// GET /health  → JSON daemon status
+// GET /logs    → recent ring-buffer lines
+```
+
+## Service + Registry
+
+A `Registry` tracks every Daemon a Core registered so multi-process
+applications get a single view of who's alive. The Service factory plugs
+the registry directly into the Core lifecycle:
+
+```go
+c := core.New(core.Options{})
+
+svc := process.NewService(process.Options{
+    Dir: "/var/run/myapp",
+})
+
+if r := svc(c); !r.OK { return r }
+
+// Discover registered daemons
+running := process.NewRegistry("/var/run/myapp").List()
+```
+
+## Cross-platform compile
+
+Unix-only `syscall.Kill`, `syscall.SIGKILL`, `SysProcAttr{Setpgid: true}`,
+and `WaitStatus.Signaled()` have all moved behind a small platform-helper
+triplet — `platform.go` declares the shared signatures, `platform_unix.go`
+keeps the original POSIX semantics, and `platform_windows.go` provides
+the equivalent or best-effort behaviour:
+
+| Helper | Unix | Windows |
+|---|---|---|
+| `processSignal(pid, sig)` | `syscall.Kill(pid, sig)` | `os.FindProcess(pid).Signal(sig)` |
+| `processKillGroup(pid)` | `syscall.Kill(-pid, SIGKILL)` | best-effort leader-only kill |
+| `processSignalGroup(pid, sig)` | `syscall.Kill(-pid, sig)` | `Ok(nil)` stub — no Win32 equivalent |
+| `applyProcessGroup(cmd)` | `SysProcAttr{Setpgid: true}` | no-op |
+| `exitWasSignaled(state)` | `WaitStatus.Signaled()` | `false` |
+
+The Service compiles clean for `GOOS=windows GOARCH=amd64` and the smoke
+tests cover both targets. Full process-group semantics on Windows (Job
+Objects) are Phase 2; today's stubs are sufficient for tray-lifecycle
+and supervisor-restart cases.
+
+## Sibling packages
+
+- [`go/io`](/go/io/) — file-system Medium for daemon log persistence
+- [`go/store`](/go/store/) — persisted daemon registry state
+- [`go/log`](/go/log/) — structured logging that daemons emit through
+
+## Source
+
+[`github.com/dappcore/go-process`](https://github.com/dappcore/go-process) — full source, issues, and releases.

src/content/docs/go/store.mdx

@@ -12,7 +12,10 @@ head:
       content: 'dappco.re/go/store https://github.com/dappcore/go-store https://github.com/dappcore/go-store/tree/main{/dir} https://github.com/dappcore/go-store/blob/main{/dir}/{file}#L{line}'
 ---
 
-Persistent KV — SQLite + DuckDB, workspace buffer. Built on the [`core/go`](/go/) primitives.
+Two-layer persistence built on the [`core/go`](/go/) primitives. SQLite for
+durable key-value state, DuckDB for analytical and workspace queries — both
+fronted by a single Service so callers get one entry point and one
+[`Result`](/go/result/) shape.
 
 ## Install
 
@@ -26,7 +29,102 @@ go get dappco.re/go/store@latest
 import "dappco.re/go/store"
 ```
 
-## Status
+## Two backends, one Service
 
-Page in flight — content fills in as the package converges. Source of truth
-today is the README and inline docstrings in the repo.
+| Layer  | Backed by | Best for |
+|--------|-----------|----------|
+| **SQLite KV** | `modernc.org/sqlite` (pure Go) | Durable per-key state — config, sessions, cache, scoped namespaces with quotas |
+| **DuckDB workspace** | `marcboeker/go-duckdb` (CGO) | Analytical reads, Parquet import/export, scoring tables, ad-hoc joins over local data |
+
+The Service Register pattern is the canonical entry — register once on a
+`*core.Core` and the store is available through `c.Action("store/...")`.
+
+```go
+c := core.New(core.Options{})
+if r := store.Register(c); !r.OK { return r }
+
+// Now any code with the *core.Core can reach the store.
+```
+
+For per-call construction, the constructors all return `core.Result`:
+
+```go
+// SQLite KV at ~/.local/share/app/state.db
+r := store.New("~/.local/share/app/state.db")
+if !r.OK { return r }
+db := r.Value.(*store.Store)
+
+// DuckDB analytics workspace
+r := store.OpenDuckDB("workspace.duckdb")
+if !r.OK { return r }
+ws := r.Value.(*store.DuckDB)
+```
+
+## Scoped namespaces
+
+Cluster a slice of the KV under a namespace so one application can hand
+sub-namespaces to its modules without leaking keys:
+
+```go
+sessions := store.NewScoped(db, "sessions")
+sessions.Set("user-42", payload)   // stored at sessions/user-42 internally
+
+// With quota
+sub, r := store.NewScopedWithQuota(db, "uploads", store.QuotaConfig{
+    MaxKeys:  1000,
+    MaxBytes: 50 << 20, // 50 MiB
+})
+if !r.OK { return r }
+```
+
+## Analytical layer — DuckDB
+
+The DuckDB side ships canonical table names + helpers for the most common
+patterns:
+
+```go
+const (
+    TableCheckpointScores = "checkpoint_scores"
+    TableProbeResults     = "probe_results"
+)
+
+_ = ws.EnsureScoringTables()
+ws.Exec(core.Sprintf("SELECT * FROM %s WHERE score > ?", TableCheckpointScores), 0.8)
+```
+
+Parquet round-trip helpers cover the most common ETL shapes:
+
+```go
+r := store.ExportParquet(ws, "scores.parquet", "checkpoint_scores")
+if !r.OK { return r }
+rows := r.Value.(int)
+
+// Sharded export — splits by column value, writes one Parquet per shard.
+store.ExportSplitParquet(ws, "shards/", "probe_results", "model_id")
+```
+
+## Cross-platform compile
+
+SQLite is pure Go and compiles on every target with no special flags. The
+DuckDB layer is CGO and follows the same pattern as the rest of the
+[`core/go`](/go/) ecosystem — Windows support is live for `amd64` with a
+C toolchain (native `mingw` or the Wails `wails-cross` Docker image with
+Zig). The `windows/arm64` target requires the same toolchain via
+`CGO_ENABLED=1`.
+
+`marcboeker/go-duckdb` is the active driver path; `mapping`/`bindings`
+sub-modules are kept transitively. See [RFC.md](https://github.com/dappcore/go-store/blob/dev/RFC.md)
+for the current Windows compile checklist and consumer-side build flags.
+
+## Sibling packages
+
+- [`go/io`](/go/io/) — universal `Medium` transport that store consumes
+  when persistence lives on remote backends (S3, cube)
+- [`go/process`](/go/process/) — supervisor primitives that own the
+  process running the store
+- [`go/orm`](/go/orm/) — the typed query layer that fronts both backends
+  when consumers want models instead of raw SQL
+
+## Source
+
+[`github.com/dappcore/go-store`](https://github.com/dappcore/go-store) — full source, issues, and releases.