Dashboards

Compliance-native operational views declared in YAML and rendered from the closed dashboard query catalog.

Dashboards answer operational compliance questions — open findings, remediation backlog, scanner activity, evidence gaps — for a workspace (and optionally one monitored process). They are file-backed config in your connected repository, not ad-hoc BI.

File location

.kiket/dashboards/*.yaml — one file per dashboard. The Process Twin home surface loads process-health by default when present.

Minimum dashboard

dashboard:
  key: process-health
  name: Process health
  description: Open findings, remediation pipeline, scanner activity, and evidence gaps for this workspace.
  scope: workspace
layout:
  columns: 12
widgets:
  - id: open_findings_by_severity
    type: chart
    title: Open findings by severity
    query_key: platform.open_findings_by_severity
    config:
      chart: bar
    position: { x: 0, y: 0, w: 3, h: 2 }
  - id: open_cases
    type: metric
    title: Open cases
    query_key: workspace.open_cases_count
    position: { x: 3, y: 0, w: 3, h: 1 }

Type	Purpose
`metric`	Single number with optional tone
`chart`	Bar, line, area, or pie chart (`config.chart`)
`list`	Compact rows (findings, evidence gaps) with `config.limit`
`table`	Tabular rows with pagination limit
`text`	Static markdown-safe copy from `config.body`
`embed`	Deferred in runtime v1 — validation fails until allowlisted embeds ship

Query catalog (closed)

Widgets bind to query_key values from a closed catalog — not free SQL or arbitrary JSONPath. Unknown keys fail editor validation and return errors from the batch executor.

`query_key`	Typical widget types	Data
`platform.open_findings_by_severity`	`metric`, `chart`	Unresolved findings by severity
`platform.findings_by_status`	`chart`, `table`	Findings grouped by triage status
`platform.remediation_pipeline`	`chart`, `list`	Remediation proof/completion pipeline
`platform.scanner_run_history`	`chart`, `table`	Findings observed per recent scanner run
`platform.findings_since_last_scan`	`list`	Findings first seen since last completed scan
`platform.latest_scanner_run`	`metric`, `text`	Most recent completed scanner run
`workspace.open_cases_count`	`metric`	Active operational cases (optional `processId` scope)
`workspace.evidence_gaps`	`list`, `table`	Open findings for missing required evidence

List the catalog at runtime:

GET /platform/dashboard-queries/catalog

Execute one or more queries in a single round trip:

POST /platform/dashboard-queries/execute

{
  "workspaceId": "<uuid>",
  "processId": "<uuid optional>",
  "queries": [
    { "queryKey": "platform.open_findings_by_severity" },
    { "queryKey": "workspace.evidence_gaps", "limit": 5 }
  ]
}

Resolve parsed YAML from a workspace-linked repository:

GET /platform/dashboard-queries/workspaces/{workspaceId}/dashboards/{dashboardKey}

Runtime routes

Surface	URL	Notes
Process Twin (default)	`/`	Loads `process-health` from repo YAML or built-in default
Workspace dashboard	`/workspaces/{workspaceId}/dashboards/{dashboardKey}`	Deep-linkable generic runtime view
Visual editor	`/editor?file=.kiket/dashboards/{key}.yaml`	Layout + query picker + live preview when a workspace is selected

Create a new dashboard

In the visual editor, use New → Dashboard (or click the ghost dashboards/ folder when empty). Kiket scaffolds .kiket/dashboards/{your-key}.yaml with workspace scope and one starter metric widget (workspace.open_cases_count). Add widgets in the editor, pick query_key values from the catalog, and use Live preview when a workspace is selected.

Validate dashboard YAML locally:

kiket validate --file .kiket/dashboards/process-health.yaml --local

Scope

scope: workspace (default) — aggregates across all monitored processes in the workspace.
scope: process with process_id — restrict widgets to one monitored process when the dashboard is mounted in a process-specific shell.

Layout

layout.columns defines the grid width (1–24). Each widget has position: { x, y, w, h } in column units. The editor visual canvas uses the same model.

Examples

Process health (flagship)

The default Process Twin surface loads process-health when the file exists in your connected repo. It binds all eight catalog queries across charts, metrics, and lists — see definitions/engineering-change/.kiket/dashboards/process-health.yaml in the definitions pack.

Open it at runtime:

/workspaces/{workspaceId}/dashboards/process-health

Starter dashboard (editor scaffold)

New → Dashboard in the visual editor produces a minimal workspace dashboard with one metric widget:

dashboard:
  key: team-ops
  name: Team operations overview
  description: Operational compliance dashboard for this workspace.
  scope: workspace
layout:
  columns: 12
widgets:
  - id: open_cases
    type: metric
    title: Open cases
    query_key: workspace.open_cases_count
    position: { x: 0, y: 0, w: 3, h: 1 }

Add widgets in the editor, pick query_key values from the catalog dropdown, and expand the grid from there.

Findings triage focus

A narrower dashboard for daily triage — severity, status, and new findings since the last scan:

dashboard:
  key: findings-triage
  name: Findings triage
  description: Severity mix, status pipeline, and deltas since the last completed scanner run.
  scope: workspace
layout:
  columns: 12
widgets:
  - id: severity
    type: chart
    title: Open findings by severity
    query_key: platform.open_findings_by_severity
    config:
      chart: bar
    position: { x: 0, y: 0, w: 4, h: 2 }
  - id: status
    type: chart
    title: Finding status
    query_key: platform.findings_by_status
    config:
      chart: bar
    position: { x: 4, y: 0, w: 4, h: 2 }
  - id: since_scan
    type: list
    title: Findings since last scan
    query_key: platform.findings_since_last_scan
    config:
      limit: 8
    position: { x: 8, y: 0, w: 4, h: 2 }

Deep links on list rows open the Findings Inbox for the selected finding.

Evidence gaps table

Use a table widget when reviewers need sortable rows instead of compact list cards:

dashboard:
  key: evidence-review
  name: Evidence review
  scope: workspace
layout:
  columns: 12
widgets:
  - id: gaps_table
    type: table
    title: Evidence gaps
    query_key: workspace.evidence_gaps
    config:
      limit: 20
    position: { x: 0, y: 0, w: 12, h: 3 }

Process-scoped dashboard

Restrict all widgets to one monitored process by setting scope on the dashboard and passing processId when executing queries (the runtime API accepts an optional processId on POST /platform/dashboard-queries/execute):

dashboard:
  key: change-approval-health
  name: Change approval health
  description: Health view for the production change approval process only.
  scope: process
  process_id: "<monitored-process-uuid>"
layout:
  columns: 12
widgets:
  - id: open_cases
    type: metric
    title: Open cases (process)
    query_key: workspace.open_cases_count
    position: { x: 0, y: 0, w: 3, h: 1 }
  - id: scanner_trend
    type: chart
    title: Scanner findings trend
    query_key: platform.scanner_run_history
    config:
      chart: line
    position: { x: 3, y: 0, w: 9, h: 2 }

Replace process_id with the UUID from Processes or GET /platform/processes. Process Twin remains workspace-wide; use this pattern when a dashboard is mounted in a process-specific shell.

Scanner status strip

Combine a metric and static guidance text for operators watching scanner runs:

dashboard:
  key: scanner-ops
  name: Scanner operations
  scope: workspace
layout:
  columns: 12
widgets:
  - id: last_run
    type: metric
    title: Last scanner run
    query_key: platform.latest_scanner_run
    position: { x: 0, y: 0, w: 4, h: 1 }
  - id: trend
    type: chart
    title: Findings per run
    query_key: platform.scanner_run_history
    config:
      chart: line
    position: { x: 4, y: 0, w: 8, h: 2 }
  - id: runbook
    type: text
    title: Runbook
    config:
      body: |
        Run a manual scanner pass after new evidence arrives.
        Triage new findings in the inbox before closing remediations.
    position: { x: 0, y: 1, w: 4, h: 2 }

text widgets do not bind a query_key; they render config.body as static copy.