spine-framework 0.1.0

package/dist/cli/commands/doctor.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @module cli/commands/doctor
+ * @audience installer
+ * @layer cli
+ * @stability stable
+ *
+ * `spine doctor` command — comprehensive system validation for agentic IDE setup.
+ * Checks environment, database, migrations, integrity, and custom code.
+ *
+ * **Commands:**
+ * | Subcommand        | Description                                           |
+ * |-------------------|-------------------------------------------------------|
+ * | `doctor`          | Run all checks and report status                      |
+ * | `doctor --json`   | Output structured JSON for agent consumption          |
+ * | `doctor --fix`    | Attempt automatic remediation where possible          |
+ *
+ * **Checks performed:**
+ * 1. Environment variables (SUPABASE_URL, SERVICE_ROLE_KEY)
+ * 2. Database connectivity and latency
+ * 3. Migration status (local vs applied)
+ * 4. Core integrity (manifest hash verification)
+ * 5. Custom code TypeScript compilation
+ * 6. Test suite status (last run results)
+ *
+ * **Exit codes:**
+ * - 0: All checks passed (healthy)
+ * - 1: One or more checks failed
+ * - 2: Check passed but warnings present (degraded)
+ *
+ * **Usage:**
+ * ```bash
+ * spine doctor
+ * spine doctor --json
+ * spine doctor --fix
+ * ```
+ *
+ * @seeAlso cli/context.ts (buildCliContext)
+ * @seeAlso functions/system.ts (health endpoint)
+ */
+import type { Command } from 'commander';
+export declare function registerDoctorCommands(program: Command): void;
+//# sourceMappingURL=doctor.d.ts.map

package/dist/cli/commands/doctor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../../.framework/cli/commands/doctor.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AA0QxC,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,QAsItD"}

package/dist/cli/commands/generate.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @module cli/commands/generate
+ * @audience installer
+ * @layer cli
+ * @stability stable
+ *
+ * `spine generate` command — code scaffolding for extending Spine safely.
+ * Generates type definitions, handlers, and UI pages in v2-custom/ only.
+ *
+ * **Commands:**
+ * | Subcommand              | Description                                           |
+ * |-------------------------|-------------------------------------------------------|
+ * | `generate type <slug>`  | Create new type with handler and UI stubs             |
+ * | `generate function <name>` | Create new Netlify function stub                   |
+ *
+ * **What gets generated for `type`:**
+ * 1. Type record in database (item type by default)
+ * 2. Handler stub: `v2-custom/functions/{slug}.ts`
+ * 3. UI page stub: `v2-custom/src/pages/{slug}/index.tsx`
+ *
+ * **What gets generated for `function`:**
+ * 1. Netlify function stub: `v2-custom/functions/{name}.ts`
+ * 2. Basic handler structure with middleware imports
+ *
+ * **Usage:**
+ * ```bash
+ * spine generate type ticket-v2
+ * spine generate function webhook-handler
+ * ```
+ *
+ * @seeAlso functions/types.ts (type CRUD API)
+ * @seeAlso functions/_shared/middleware.ts (handler structure)
+ */
+import type { Command } from 'commander';
+export declare function registerGenerateCommands(program: Command): void;
+//# sourceMappingURL=generate.d.ts.map

package/dist/cli/commands/generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../../.framework/cli/commands/generate.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAuQxC,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,OAAO,QAiCxD"}

package/dist/cli/commands/init.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @module cli/commands/init
+ * @audience installer
+ * @layer cli
+ * @stability stable
+ *
+ * `spine-framework init` — Bootstrap a fresh Spine installation.
+ *
+ * Runs the foundation schema (000_foundation.sql) and seed data (001_seed.sql)
+ * against the configured Supabase project, then scaffolds the custom/ workspace
+ * if it doesn't already exist.
+ *
+ * **Usage:**
+ * ```bash
+ * # Fresh install (agent provides credentials from Supabase dashboard)
+ * spine-framework init --url https://xyz.supabase.co --anon-key eyJ... --service-role-key eyJ...
+ *
+ * # Already have .env configured
+ * spine-framework init
+ *
+ * # DB only, no filesystem changes
+ * spine-framework init --skip-scaffold
+ * ```
+ *
+ * When --url/--anon-key/--service-role-key are provided, init writes .env before
+ * running migrations — so it works on a completely fresh checkout with no prior config.
+ */
+import type { Command } from 'commander';
+export declare function registerInitCommands(program: Command): void;
+//# sourceMappingURL=init.d.ts.map

package/dist/cli/commands/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../.framework/cli/commands/init.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAgOxC,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,QAkBpD"}

package/dist/cli/commands/install-app.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @module cli/commands/install-app
+ * @audience installer
+ * @layer cli
+ * @stability stable
+ *
+ * `spine-framework install-app <slug>` — Install an app into the current Spine instance.
+ *
+ * Reads seed/*.json files from the app package directory and upserts their
+ * contents into the database. Also registers the app in `app_installations`.
+ *
+ * **Seed file conventions:**
+ * - `types.json` → upsert into `types` table
+ * - `link-types.json` → upsert into `link_types` table
+ * - `triggers.json` → upsert into `triggers` table
+ * - `accounts.json` → upsert into `accounts` table
+ * - `pipelines.json` → upsert into `pipelines` table
+ *
+ * All upserts keyed on `(app_id, slug)` — idempotent and safe to re-run.
+ *
+ * **Usage:**
+ * ```bash
+ * spine-framework install-app cortex
+ * spine-framework install-app customer-portal
+ * spine-framework install-app cortex --account <account-id>
+ * ```
+ */
+import type { Command } from 'commander';
+export declare function registerInstallAppCommands(program: Command): void;
+//# sourceMappingURL=install-app.d.ts.map

package/dist/cli/commands/install-app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"install-app.d.ts","sourceRoot":"","sources":["../../../.framework/cli/commands/install-app.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAyVxC,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,OAAO,QAgB1D"}

package/dist/cli/commands/items.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @module cli/commands/items
+ * @audience installer
+ * @layer cli
+ * @stability stable
+ *
+ * `spine items` command group. Direct CRUD access to the `items` table via
+ * `adminDb` (service-role, bypasses RLS). Use only in controlled environments;
+ * does NOT enforce field-level permissions or RLS for the principal.
+ *
+ * **Commands:**
+ * | Subcommand                                     | Description                    |
+ * |------------------------------------------------|--------------------------------|
+ * | `items list [--type <slug>] [--account <id>]`  | List items, filtered by type   |
+ * | `items get <id>`                               | Fetch a single item by UUID    |
+ * | `items create --type <slug> --data <json>`     | Insert a new item              |
+ * | `items update <id> --data <json>`              | Patch item data fields         |
+ * | `items delete <id> [--hard]`                   | Soft-delete or hard-delete     |
+ *
+ * **Authorization note:** All commands use `adminDb` — no RLS enforcement.
+ * Account scoping is applied as a filter only; it does not restrict access.
+ *
+ * **Usage:**
+ * ```bash
+ * spine items list --type support_ticket --account <id> --limit 50
+ * spine items get <uuid>
+ * spine items create --type support_ticket --title "Bug report" --data '{"priority":"high"}'
+ * spine items update <uuid> --data '{"status":"resolved"}'
+ * spine items delete <uuid>
+ * spine items delete <uuid> --hard
+ * ```
+ *
+ * @seeAlso cli/context.ts (buildCliContext)
+ * @seeAlso functions/admin-data.ts (API equivalent with RLS)
+ */
+import type { Command } from 'commander';
+/**
+ * Registers the `items` subcommand group on the root Commander program.
+ *
+ * @param program - The root `spine` Commander instance
+ * @sideEffects Adds `items list/get/create/update/delete` subcommands to `program`
+ * @calledBy cli/index.ts
+ */
+export declare function registerItemCommands(program: Command): void;
+//# sourceMappingURL=items.d.ts.map

package/dist/cli/commands/items.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"items.d.ts","sourceRoot":"","sources":["../../../.framework/cli/commands/items.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAIxC;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,QA4MpD"}

package/dist/cli/commands/migrations.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @module cli/commands/migrations
+ * @audience installer
+ * @layer cli
+ * @stability stable
+ *
+ * `spine migrations` command group. Read-only inspection of the migration
+ * state. Does NOT apply or roll back migrations — use the Supabase CLI for
+ * that. These commands are intended for verifying the state of a deployed
+ * instance during setup or debugging.
+ *
+ * **Commands:**
+ * | Subcommand            | Description                                         |
+ * |-----------------------|-----------------------------------------------------|
+ * | `migrations list`     | Show all applied migrations from `schema_migrations`|
+ * | `migrations status`   | Diff local `.sql` files against applied migrations  |
+ *
+ * **Authorization:** Uses `adminDb` (service-role) with an explicit
+ * `.schema('public')` override to reach `schema_migrations`. Requires
+ * `SUPABASE_SERVICE_ROLE_KEY` with public schema access.
+ *
+ * **Usage:**
+ * ```bash
+ * spine migrations list
+ * spine migrations status
+ * spine migrations status --json
+ * ```
+ *
+ * @seeAlso v2-core/migrations/ (local .sql migration files)
+ * @seeAlso cli/context.ts (buildCliContext)
+ */
+import type { Command } from 'commander';
+/**
+ * Registers the `migrations` subcommand group on the root Commander program.
+ *
+ * @param program - The root `spine` Commander instance
+ * @sideEffects Adds `migrations list` and `migrations status` subcommands to `program`
+ * @calledBy cli/index.ts
+ */
+export declare function registerMigrationCommands(program: Command): void;
+//# sourceMappingURL=migrations.d.ts.map

package/dist/cli/commands/migrations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrations.d.ts","sourceRoot":"","sources":["../../../.framework/cli/commands/migrations.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAUxC;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,OAAO,QA0FzD"}

package/dist/cli/commands/pipelines.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @module cli/commands/pipelines
+ * @audience installer
+ * @layer cli
+ * @stability stable
+ *
+ * `spine pipelines` command group. Lists, inspects, and triggers pipeline
+ * execution directly from the terminal or an agentic IDE. `pipelines run`
+ * calls `runPipeline` — the same function used by API handlers and timers —
+ * so CLI executions are fully recorded in `pipeline_executions`.
+ *
+ * **Commands:**
+ * | Subcommand                            | Description                              |
+ * |---------------------------------------|------------------------------------------|
+ * | `pipelines list [--account] [--all]`  | List active (or all) pipelines           |
+ * | `pipelines get <id>`                  | Show pipeline details                    |
+ * | `pipelines run <id> [--data <json>]`  | Execute a pipeline and show stage output |
+ * | `pipelines executions <id>`           | List recent executions for a pipeline    |
+ *
+ * **Usage:**
+ * ```bash
+ * spine pipelines list --account <id>
+ * spine pipelines run <uuid> --data '{"key":"value"}' --json
+ * spine pipelines executions <uuid> --limit 20
+ * ```
+ *
+ * @seeAlso cli/context.ts (buildCliContext)
+ * @seeAlso functions/_shared/pipeline-runner.ts (runPipeline)
+ * @seeAlso functions/pipeline-executions.ts (API query endpoint)
+ */
+import type { Command } from 'commander';
+/**
+ * Registers the `pipelines` subcommand group on the root Commander program.
+ *
+ * @param program - The root `spine` Commander instance
+ * @sideEffects Adds `pipelines list/get/run/executions` subcommands to `program`
+ * @calledBy cli/index.ts
+ */
+export declare function registerPipelineCommands(program: Command): void;
+//# sourceMappingURL=pipelines.d.ts.map

package/dist/cli/commands/pipelines.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipelines.d.ts","sourceRoot":"","sources":["../../../.framework/cli/commands/pipelines.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAIxC;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,OAAO,QA0HxD"}

package/dist/cli/commands/status.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @module cli/commands/status
+ * @audience installer
+ * @layer cli
+ * @stability stable
+ *
+ * `spine-framework status` — Show the current state of the Spine installation.
+ *
+ * Displays:
+ * - Database connection status
+ * - Installed apps and their seed state
+ * - Migration history
+ * - Webhook handler registrations
+ *
+ * **Usage:**
+ * ```bash
+ * spine-framework status
+ * spine-framework status --json
+ * ```
+ */
+import type { Command } from 'commander';
+export declare function registerStatusCommands(program: Command): void;
+//# sourceMappingURL=status.d.ts.map

package/dist/cli/commands/status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../../.framework/cli/commands/status.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AA2JxC,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,QAmBtD"}

package/dist/cli/commands/system.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @module cli/commands/system
+ * @audience installer
+ * @layer cli
+ * @stability stable
+ *
+ * `spine system` command — CLI interface to system discovery endpoints.
+ * Queries the running Spine instance for manifest, health, and OpenAPI spec.
+ *
+ * **Commands:**
+ * | Subcommand              | Description                                           |
+ * |-------------------------|-------------------------------------------------------|
+ * | `system manifest`       | Fetch and display system manifest                     |
+ * | `system health`         | Fetch and display health check results                |
+ * | `system openapi`        | Fetch OpenAPI spec (outputs JSON)                     |
+ * | `system --json`         | Output as JSON for all subcommands                    |
+ *
+ * **Usage:**
+ * ```bash
+ * spine system manifest
+ * spine system health --json
+ * spine system openapi > openapi.json
+ * ```
+ *
+ * @seeAlso functions/system.ts (HTTP endpoints this CLI consumes)
+ */
+import type { Command } from 'commander';
+export declare function registerSystemCommands(program: Command): void;
+//# sourceMappingURL=system.d.ts.map

package/dist/cli/commands/system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../../.framework/cli/commands/system.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AA8CxC,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,QA6GtD"}

package/dist/cli/commands/test.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @module cli/commands/test
+ * @audience installer
+ * @layer cli
+ * @stability stable
+ *
+ * `spine test` command — unified test runner for all 4 test surfaces.
+ * Runs Vitest tests and persists results to Supabase via the custom reporter.
+ *
+ * **Commands:**
+ * | Subcommand              | Description                                           |
+ * |-------------------------|-------------------------------------------------------|
+ * | `test`                  | Run all test suites                                   |
+ * | `test unit`             | Run unit tests only                                   |
+ * | `test integration`      | Run integration tests only                            |
+ * | `test api`              | Run API tests only                                    |
+ * | `test ui`               | Run UI/Playwright tests only                          |
+ * | `test --json`           | Output structured JSON summary                        |
+ * | `test --watch`          | Run in watch mode (for unit/integration)              |
+ *
+ * **Test surfaces:**
+ * - **unit**: Fast tests, no DB (v2-core/tests/unit/)
+ * - **integration**: DB tests with fixtures (v2-core/tests/integration/)
+ * - **api**: HTTP fetch tests against localhost:8888 (v2-core/tests/api/)
+ * - **ui**: Playwright browser tests (v2-core/tests/ui/)
+ *
+ * **Results:**
+ * All test runs are persisted to `public.test_runs` and `public.test_results`
+ * via the custom Vitest reporter (v2-core/tests/reporter.ts).
+ *
+ * **Usage:**
+ * ```bash
+ * spine test
+ * spine test unit --watch
+ * spine test integration --json
+ * spine test api
+ * spine test ui
+ * ```
+ *
+ * @seeAlso tests/reporter.ts (custom Vitest reporter)
+ * @seeAlso functions/tests.ts (API endpoint for querying results)
+ * @seeAlso pages/admin/TestingDashboard.tsx (UI for viewing results)
+ */
+import type { Command } from 'commander';
+export declare function registerTestCommands(program: Command): void;
+//# sourceMappingURL=test.d.ts.map

package/dist/cli/commands/test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../../../.framework/cli/commands/test.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAwBxC,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,QA6FpD"}

package/dist/cli/commands/uninstall-app.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @module cli/commands/uninstall-app
+ * @audience installer
+ * @layer cli
+ * @stability stable
+ *
+ * `spine-framework uninstall-app <slug>` — Soft-uninstall an app.
+ *
+ * Deactivates the app's types, link types, and triggers in the database.
+ * Does NOT delete data (items, threads, etc.) — those remain for audit.
+ * Does NOT remove filesystem files — the app code stays in custom/apps/.
+ *
+ * To fully remove: manually delete the app directory after uninstall.
+ *
+ * **Usage:**
+ * ```bash
+ * spine-framework uninstall-app cortex
+ * spine-framework uninstall-app cortex --hard   # Also deactivate items
+ * ```
+ */
+import type { Command } from 'commander';
+export declare function registerUninstallAppCommands(program: Command): void;
+//# sourceMappingURL=uninstall-app.d.ts.map

package/dist/cli/commands/uninstall-app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uninstall-app.d.ts","sourceRoot":"","sources":["../../../.framework/cli/commands/uninstall-app.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAgIxC,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,OAAO,QAe5D"}

package/dist/cli/context.d.ts

@@ -0,0 +1,88 @@
+/**
+ * @module cli/context
+ * @audience installer
+ * @layer cli
+ * @stability stable
+ *
+ * CLI context builder and output utilities. This is the CLI equivalent of
+ * `createHandler()` in `middleware.ts` — it resolves the principal, picks the
+ * correct Supabase client, and returns a `CoreContext` that every CLI command
+ * passes directly to core functions.
+ *
+ * **Environment variables read from `.xenv` or `process.env`:**
+ * | Variable                  | Required | Purpose                            |
+ * |---------------------------|----------|------------------------------------|
+ * | `SUPABASE_URL`            | yes      | Project API URL                    |
+ * | `SUPABASE_SERVICE_ROLE_KEY` | yes    | Service-role client (admin ops)    |
+ * | `SUPABASE_ANON_KEY`       | yes      | User-scoped client (JWT mode)      |
+ * | `SPINE_CLI_ACCOUNT_ID`    | no       | Default account scope              |
+ * | `SPINE_CLI_JWT`           | no       | Human principal (Supabase JWT)     |
+ * | `SPINE_CLI_API_KEY`       | no       | Machine principal (hashed key)     |
+ * | `SPINE_CLI_DEBUG`         | no       | Print stack traces on error        |
+ *
+ * **Principal resolution priority** (first match wins):
+ * 1. `SPINE_CLI_JWT` → human principal (RLS-scoped `getUserDb`)
+ * 2. `SPINE_CLI_API_KEY` → machine principal (`adminDb`)
+ * 3. Fallback → `SYSTEM_PRINCIPAL` (`adminDb` — admin ops only)
+ *
+ * @seeAlso functions/_shared/middleware.ts (createHandler — server-side equivalent)
+ * @seeAlso functions/_shared/principal.ts (Principal type and SYSTEM_PRINCIPAL)
+ * @seeAlso cli/index.ts (entry point that imports all commands)
+ */
+import { CoreContext } from '../functions/_shared/index.ts';
+/**
+ * Options passed from CLI command `.action()` callbacks to `buildCliContext`.
+ *
+ * @inputSpec account: string | undefined — UUID of the target account; overrides
+ *   `SPINE_CLI_ACCOUNT_ID` if both are present.
+ * @calledBy All `registerXxxCommands` functions before calling core functions
+ */
+export interface CliOptions {
+    account?: string;
+}
+/**
+ * @chunk-id    CLI_CONTEXT_BUILD_1_0_0
+ * @version     1.0.0
+ * @hash        501162983b1b24e9a15267ca7b8398b3733f540b2a65a96d8277ec3d780f2003
+ * @macro       CLI Context Builder
+ * @micro       Constructs CoreContext with principal resolution and Supabase client
+ * @inputs      opts: CliOptions — Optional overrides including account ID
+ * @outputs     CoreContext — Fully resolved context with principal, DB client, and request ID
+ * @depends-on  [loadEnv, adminDb, getUserDb, SYSTEM_PRINCIPAL]
+ * @depended-by [All CLI command handlers]
+ * @side-effects [DB queries, environment reads, crypto.randomUUID]
+ * @tags        cli, authentication, principal-resolution, context
+ */
+export declare function buildCliContext(opts?: CliOptions): Promise<CoreContext>;
+/**
+ * @chunk-id    CLI_CONTEXT_PRINT_RESULT_1_0_0
+ * @version     1.0.0
+ * @hash        06e492defa9012290a5c8b2d4fca27f01df11bdc194ffbdf4f4b4518aa683c2b
+ * @macro       CLI Output Formatter
+ * @micro       Pretty-prints query results as JSON or ASCII tables
+ * @inputs      data: any — Result data to display (array or single value)
+ * @inputs      opts: { json?: boolean } — Output format options
+ * @outputs     void — Console output only
+ * @depends-on  [console, JSON]
+ * @depended-by [All CLI command list/get handlers]
+ * @side-effects [console.log output]
+ * @tags        cli, output, formatting, tables, json
+ */
+export declare function printResult(data: any, opts?: {
+    json?: boolean;
+}): void;
+/**
+ * @chunk-id    CLI_CONTEXT_HANDLE_ERROR_1_0_0
+ * @version     1.0.0
+ * @hash        61aca7e4bce61b5b790e8f27ef3f505a6a6fe9a8cd6643e577f610d9dd15b1cd
+ * @macro       CLI Error Handler
+ * @micro       Prints formatted error and exits with proper debug information
+ * @inputs      err: any — Error object or string message
+ * @outputs     void — Process termination (exit code 1)
+ * @depends-on  [console, process]
+ * @depended-by [All CLI command action handlers]
+ * @side-effects [console.error output, process.exit]
+ * @tags        cli, error-handling, debug, process-exit
+ */
+export declare function handleError(err: any): void;
+//# sourceMappingURL=context.d.ts.map

package/dist/cli/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../.framework/cli/context.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAKH,OAAO,EAAE,WAAW,EAAmD,MAAM,+BAA+B,CAAA;AA0C5G;;;;;;GAMG;AACH,MAAM,WAAW,UAAU;IACzB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAKD;;;;;;;;;;;;GAYG;AACH,wBAAsB,eAAe,CAAC,IAAI,GAAE,UAAe,GAAG,OAAO,CAAC,WAAW,CAAC,CAgGjF;AAMD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,GAAG,EAAE,IAAI,GAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAA;CAAO,QAsBnE;AAID;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,GAAG,QAMnC"}

package/dist/cli/env-loader.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @module cli/env-loader
+ * @audience installer
+ * @layer cli
+ * @stability stable
+ *
+ * Side-effect module: loads `v2-core/.xenv` into `process.env` before any
+ * other CLI module is imported. Must be the first import in `cli/index.ts`
+ * so that `db.ts` (which reads env vars at module-load time) sees the values.
+ *
+ * @sideEffects Mutates process.env — only sets keys not already present
+ */
+export {};
+//# sourceMappingURL=env-loader.d.ts.map

package/dist/cli/env-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env-loader.d.ts","sourceRoot":"","sources":["../../.framework/cli/env-loader.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;GAWG"}

package/dist/cli/index.d.ts

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+/**
+ * @module cli/index
+ * @audience installer
+ * @layer cli
+ * @stability stable
+ *
+ * Spine CLI entry point (`npx spine-framework`). Registers all command groups via
+ * Commander and delegates each subcommand to the same core logic used by
+ * API handlers and direct imports. No business logic lives here — only
+ * command registration and top-level error handling.
+ *
+ * **Command groups registered:**
+ * | Group       | File                       |
+ * |-------------|----------------------------|
+ * | auth        | commands/auth.ts           |
+ * | pipelines   | commands/pipelines.ts      |
+ * | items       | commands/items.ts          |
+ * | agents      | commands/agents.ts         |
+ * | migrations  | commands/migrations.ts     |
+ * | init        | commands/init.ts           |
+ * | install-app | commands/install-app.ts    |
+ * | status      | commands/status.ts         |
+ * | uninstall   | commands/uninstall-app.ts  |
+ *
+ * **Usage:**
+ * ```bash
+ * npx spine-framework --help
+ * npx spine-framework auth whoami
+ * npx spine-framework pipelines run <id> --data '{"key":"value"}'
+ * npx spine-framework items list --type support_ticket
+ * npx spine-framework items get <id>
+ * npx spine-framework agents run <thread-id> --message "Hello"
+ * npx spine-framework migrations list
+ * ```
+ *
+ * @seeAlso cli/context.ts (buildCliContext — constructs CoreContext for every command)
+ * @seeAlso functions/_shared/index.ts (core functions exposed to CLI)
+ */
+import './env-loader.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../.framework/cli/index.ts"],"names":[],"mappings":";AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,OAAO,iBAAiB,CAAA"}