Refound Spinner as an austere frontier ledger

1 files changed, 812 insertions, 1202 deletions

diff --git a/crates/fidget-spinner-cli/src/main.rs b/crates/fidget-spinner-cli/src/main.rs
index f56e751..9de2515 100644
--- a/crates/fidget-spinner-cli/src/main.rs
+++ b/crates/fidget-spinner-cli/src/main.rs
@@ -4,27 +4,28 @@ mod ui;
 
 use std::collections::{BTreeMap, BTreeSet};
 use std::fs;
+use std::io;
 use std::net::SocketAddr;
 use std::path::{Path, PathBuf};
 
 use camino::{Utf8Path, Utf8PathBuf};
 use clap::{Args, Parser, Subcommand, ValueEnum};
 use fidget_spinner_core::{
-    AnnotationVisibility, CommandRecipe, DiagnosticSeverity, ExecutionBackend, FieldPresence,
-    FieldRole, FieldValueType, FrontierContract, FrontierNote, FrontierVerdict, InferencePolicy,
-    MetricSpec, MetricUnit, MetricValue, NodeAnnotation, NodeClass, NodePayload, NonEmptyText,
-    OptimizationObjective, ProjectFieldSpec, TagName,
+    ArtifactKind, CommandRecipe, ExecutionBackend, ExperimentAnalysis, ExperimentStatus,
+    FieldValueType, FrontierVerdict, MetricUnit, MetricVisibility, NonEmptyText,
+    OptimizationObjective, RunDimensionValue, Slug, TagName,
 };
 use fidget_spinner_store_sqlite::{
-    CloseExperimentRequest, CreateFrontierRequest, CreateNodeRequest, DefineMetricRequest,
-    DefineRunDimensionRequest, EdgeAttachment, EdgeAttachmentDirection, ExperimentAnalysisDraft,
-    ListNodesQuery, MetricBestQuery, MetricFieldSource, MetricKeyQuery, MetricRankOrder,
-    OpenExperimentRequest, ProjectStore, RemoveSchemaFieldRequest, STORE_DIR_NAME, StoreError,
-    UpsertSchemaFieldRequest,
+    AttachmentSelector, CloseExperimentRequest, CreateArtifactRequest, CreateFrontierRequest,
+    CreateHypothesisRequest, DefineMetricRequest, DefineRunDimensionRequest,
+    ExperimentOutcomePatch, FrontierRoadmapItemDraft, ListArtifactsQuery, ListExperimentsQuery,
+    ListHypothesesQuery, MetricBestQuery, MetricKeysQuery, MetricRankOrder, MetricScope,
+    OpenExperimentRequest, ProjectStore, STORE_DIR_NAME, StoreError, TextPatch,
+    UpdateArtifactRequest, UpdateExperimentRequest, UpdateFrontierBriefRequest,
+    UpdateHypothesisRequest, VertexSelector,
 };
 use serde::Serialize;
-use serde_json::{Map, Value, json};
-use uuid::Uuid;
+use serde_json::Value;
 
 #[derive(Parser)]
 #[command(
@@ -41,53 +42,52 @@ struct Cli {
 enum Command {
     /// Initialize a project-local `.fidget_spinner/` store.
     Init(InitArgs),
-    /// Read the local project payload schema.
-    Schema {
+    /// Inspect project metadata and coarse counts.
+    Project {
         #[command(subcommand)]
-        command: SchemaCommand,
+        command: ProjectCommand,
     },
-    /// Create and inspect frontiers.
+    /// Manage the repo-local tag registry.
+    Tag {
+        #[command(subcommand)]
+        command: TagCommand,
+    },
+    /// Create and inspect frontier scopes.
     Frontier {
         #[command(subcommand)]
         command: FrontierCommand,
     },
-    /// Create, inspect, and mutate DAG nodes.
-    Node {
+    /// Record and inspect hypotheses.
+    Hypothesis {
         #[command(subcommand)]
-        command: NodeCommand,
+        command: HypothesisCommand,
     },
-    /// Record terse off-path notes.
-    Note(NoteCommand),
-    /// Record core-path hypotheses before experimental work begins.
-    Hypothesis(HypothesisCommand),
-    /// Manage the repo-local tag registry.
-    Tag {
+    /// Open, inspect, update, and close experiments.
+    Experiment {
         #[command(subcommand)]
-        command: TagCommand,
+        command: ExperimentCommand,
     },
-    /// Record imported sources and documentary context.
-    Source(SourceCommand),
-    /// Inspect rankable metrics across closed experiments.
+    /// Register external references and attach them to the ledger.
+    Artifact {
+        #[command(subcommand)]
+        command: ArtifactCommand,
+    },
+    /// Manage project-level metric definitions and rankings.
     Metric {
         #[command(subcommand)]
         command: MetricCommand,
     },
-    /// Define and inspect run dimensions used to slice experiment metrics.
+    /// Define the typed dimension vocabulary used to slice experiments.
     Dimension {
         #[command(subcommand)]
         command: DimensionCommand,
     },
-    /// Close a core-path experiment atomically.
-    Experiment {
-        #[command(subcommand)]
-        command: ExperimentCommand,
-    },
     /// Serve the hardened stdio MCP endpoint.
     Mcp {
         #[command(subcommand)]
         command: McpCommand,
     },
-    /// Serve the minimal local web navigator.
+    /// Serve the local navigator.
     Ui {
         #[command(subcommand)]
         command: UiCommand,
@@ -101,295 +101,148 @@ enum Command {
 
 #[derive(Args)]
 struct InitArgs {
-    /// Project root to initialize.
     #[arg(long, default_value = ".")]
     project: PathBuf,
-    /// Human-facing project name. Defaults to the directory name.
     #[arg(long)]
     name: Option<String>,
-    /// Payload schema namespace written into `.fidget_spinner/schema.json`.
-    #[arg(long, default_value = "local.project")]
-    namespace: String,
 }
 
 #[derive(Subcommand)]
-enum SchemaCommand {
-    /// Show the current project schema as JSON.
-    Show(ProjectArg),
-    /// Add or replace one project schema field definition.
-    UpsertField(SchemaFieldUpsertArgs),
-    /// Remove one project schema field definition.
-    RemoveField(SchemaFieldRemoveArgs),
+enum ProjectCommand {
+    Status(ProjectArg),
 }
 
 #[derive(Subcommand)]
-enum FrontierCommand {
-    /// Create a frontier and root contract node.
-    Init(FrontierInitArgs),
-    /// Show one frontier projection or list frontiers when omitted.
-    Status(FrontierStatusArgs),
-}
-
-#[derive(Args)]
-struct FrontierInitArgs {
-    #[command(flatten)]
-    project: ProjectArg,
-    #[arg(long)]
-    label: String,
-    #[arg(long)]
-    objective: String,
-    #[arg(long, default_value = "frontier contract")]
-    contract_title: String,
-    #[arg(long)]
-    contract_summary: Option<String>,
-    #[arg(long = "benchmark-suite")]
-    benchmark_suites: Vec<String>,
-    #[arg(long = "promotion-criterion")]
-    promotion_criteria: Vec<String>,
-    #[arg(long = "primary-metric-key")]
-    primary_metric_key: String,
-    #[arg(long = "primary-metric-unit", value_enum)]
-    primary_metric_unit: CliMetricUnit,
-    #[arg(long = "primary-metric-objective", value_enum)]
-    primary_metric_objective: CliOptimizationObjective,
-}
-
-#[derive(Args)]
-struct FrontierStatusArgs {
-    #[command(flatten)]
-    project: ProjectArg,
-    #[arg(long)]
-    frontier: Option<String>,
+enum TagCommand {
+    Add(TagAddArgs),
+    List(ProjectArg),
 }
 
 #[derive(Subcommand)]
-enum NodeCommand {
-    /// Create a generic DAG node.
-    Add(NodeAddArgs),
-    /// List recent nodes.
-    List(NodeListArgs),
-    /// Show one node in full.
-    Show(NodeShowArgs),
-    /// Attach an annotation to a node.
-    Annotate(NodeAnnotateArgs),
-    /// Archive a node without deleting it.
-    Archive(NodeArchiveArgs),
-}
-
-#[derive(Args)]
-struct NodeAddArgs {
-    #[command(flatten)]
-    project: ProjectArg,
-    #[arg(long, value_enum)]
-    class: CliNodeClass,
-    #[arg(long)]
-    frontier: Option<String>,
-    #[arg(long)]
-    title: String,
-    #[arg(long)]
-    /// Required for `note` and `source` nodes.
-    summary: Option<String>,
-    #[arg(long = "payload-json")]
-    /// JSON object payload. `note` and `source` nodes require a non-empty `body` string.
-    payload_json: Option<String>,
-    #[arg(long = "payload-file")]
-    payload_file: Option<PathBuf>,
-    #[command(flatten)]
-    tag_selection: ExplicitTagSelectionArgs,
-    #[arg(long = "field")]
-    fields: Vec<String>,
-    #[arg(long = "annotation")]
-    annotations: Vec<String>,
-    #[arg(long = "parent")]
-    parents: Vec<String>,
-}
-
-#[derive(Args)]
-struct NodeListArgs {
-    #[command(flatten)]
-    project: ProjectArg,
-    #[arg(long)]
-    frontier: Option<String>,
-    #[arg(long, value_enum)]
-    class: Option<CliNodeClass>,
-    #[arg(long = "tag")]
-    tags: Vec<String>,
-    #[arg(long)]
-    include_archived: bool,
-    #[arg(long, default_value_t = 20)]
-    limit: u32,
-}
-
-#[derive(Args, Default)]
-struct ExplicitTagSelectionArgs {
-    #[arg(long = "tag")]
-    tags: Vec<String>,
-    #[arg(long, conflicts_with = "tags")]
-    no_tags: bool,
-}
-
-#[derive(Args)]
-struct NodeShowArgs {
-    #[command(flatten)]
-    project: ProjectArg,
-    #[arg(long)]
-    node: String,
-}
-
-#[derive(Args)]
-struct NodeAnnotateArgs {
-    #[command(flatten)]
-    project: ProjectArg,
-    #[arg(long)]
-    node: String,
-    #[arg(long)]
-    body: String,
-    #[arg(long)]
-    label: Option<String>,
-    #[arg(long)]
-    visible: bool,
-}
-
-#[derive(Args)]
-struct NodeArchiveArgs {
-    #[command(flatten)]
-    project: ProjectArg,
-    #[arg(long)]
-    node: String,
+enum FrontierCommand {
+    Create(FrontierCreateArgs),
+    List(ProjectArg),
+    Read(FrontierSelectorArgs),
+    Open(FrontierSelectorArgs),
+    UpdateBrief(FrontierBriefUpdateArgs),
+    History(FrontierSelectorArgs),
 }
 
-#[derive(Args)]
-struct NoteCommand {
-    #[command(subcommand)]
-    command: NoteSubcommand,
+#[derive(Subcommand)]
+enum HypothesisCommand {
+    Record(HypothesisRecordArgs),
+    List(HypothesisListArgs),
+    Read(HypothesisSelectorArgs),
+    Update(HypothesisUpdateArgs),
+    History(HypothesisSelectorArgs),
 }
 
-#[derive(Args)]
-struct HypothesisCommand {
-    #[command(subcommand)]
-    command: HypothesisSubcommand,
+#[derive(Subcommand)]
+enum ExperimentCommand {
+    Open(ExperimentOpenArgs),
+    List(ExperimentListArgs),
+    Read(ExperimentSelectorArgs),
+    Update(ExperimentUpdateArgs),
+    Close(ExperimentCloseArgs),
+    History(ExperimentSelectorArgs),
 }
 
 #[derive(Subcommand)]
-enum NoteSubcommand {
-    /// Record a quick off-path note.
-    Quick(QuickNoteArgs),
+enum ArtifactCommand {
+    Record(ArtifactRecordArgs),
+    List(ArtifactListArgs),
+    Read(ArtifactSelectorArgs),
+    Update(ArtifactUpdateArgs),
+    History(ArtifactSelectorArgs),
 }
 
 #[derive(Subcommand)]
-enum HypothesisSubcommand {
-    /// Record a core-path hypothesis with low ceremony.
-    Add(QuickHypothesisArgs),
+enum MetricCommand {
+    Define(MetricDefineArgs),
+    Keys(MetricKeysArgs),
+    Best(MetricBestArgs),
 }
 
 #[derive(Subcommand)]
-enum TagCommand {
-    /// Register a new repo-local tag.
-    Add(TagAddArgs),
-    /// List registered repo-local tags.
+enum DimensionCommand {
+    Define(DimensionDefineArgs),
     List(ProjectArg),
 }
 
-#[derive(Args)]
-struct SourceCommand {
-    #[command(subcommand)]
-    command: SourceSubcommand,
+#[derive(Subcommand)]
+enum McpCommand {
+    Serve(McpServeArgs),
+    Worker(McpWorkerArgs),
 }
 
 #[derive(Subcommand)]
-enum SourceSubcommand {
-    /// Record imported source material or documentary context.
-    Add(QuickSourceArgs),
+enum UiCommand {
+    Serve(UiServeArgs),
 }
 
 #[derive(Subcommand)]
-enum MetricCommand {
-    /// Register a project-level metric definition.
-    Define(MetricDefineArgs),
-    /// List rankable numeric keys observed in completed experiments.
-    Keys(MetricKeysArgs),
-    /// Rank completed experiments by one numeric key.
-    Best(MetricBestArgs),
-    /// Re-run the idempotent legacy metric-plane normalization.
-    Migrate(ProjectArg),
+enum SkillCommand {
+    List,
+    Install(SkillInstallArgs),
+    Show(SkillShowArgs),
 }
 
-#[derive(Subcommand)]
-enum DimensionCommand {
-    /// Register a project-level run dimension definition.
-    Define(DimensionDefineArgs),
-    /// List run dimensions and sample values observed in completed runs.
-    List(ProjectArg),
+#[derive(Args, Clone)]
+struct ProjectArg {
+    #[arg(long, default_value = ".")]
+    project: PathBuf,
 }
 
 #[derive(Args)]
-struct MetricDefineArgs {
+struct TagAddArgs {
     #[command(flatten)]
     project: ProjectArg,
-    /// Metric key used in experiment closure and ranking.
     #[arg(long)]
-    key: String,
-    /// Canonical unit for this metric key.
-    #[arg(long, value_enum)]
-    unit: CliMetricUnit,
-    /// Optimization direction for this metric key.
-    #[arg(long, value_enum)]
-    objective: CliOptimizationObjective,
-    /// Optional human description shown in metric listings.
+    name: String,
     #[arg(long)]
-    description: Option<String>,
+    description: String,
 }
 
 #[derive(Args)]
-struct MetricKeysArgs {
+struct FrontierCreateArgs {
     #[command(flatten)]
     project: ProjectArg,
-    /// Restrict results to one frontier.
     #[arg(long)]
-    frontier: Option<String>,
-    /// Restrict results to one metric source.
-    #[arg(long, value_enum)]
-    source: Option<CliMetricSource>,
-    /// Exact run-dimension filter in the form `key=value`.
-    #[arg(long = "dimension")]
-    dimensions: Vec<String>,
+    label: String,
+    #[arg(long)]
+    objective: String,
+    #[arg(long)]
+    slug: Option<String>,
 }
 
 #[derive(Args)]
-struct DimensionDefineArgs {
+struct FrontierSelectorArgs {
     #[command(flatten)]
     project: ProjectArg,
-    /// Run-dimension key used to slice experiments.
     #[arg(long)]
-    key: String,
-    /// Canonical value type for this run dimension.
-    #[arg(long = "type", value_enum)]
-    value_type: CliFieldValueType,
-    /// Optional human description shown in dimension listings.
-    #[arg(long)]
-    description: Option<String>,
+    frontier: String,
 }
 
 #[derive(Args)]
-struct QuickNoteArgs {
+struct FrontierBriefUpdateArgs {
     #[command(flatten)]
     project: ProjectArg,
     #[arg(long)]
-    frontier: Option<String>,
+    frontier: String,
     #[arg(long)]
-    title: String,
+    expected_revision: Option<u64>,
     #[arg(long)]
-    summary: String,
+    situation: Option<String>,
     #[arg(long)]
-    body: String,
-    #[command(flatten)]
-    tag_selection: ExplicitTagSelectionArgs,
-    #[arg(long = "parent")]
-    parents: Vec<String>,
+    clear_situation: bool,
+    #[arg(long = "unknown")]
+    unknowns: Vec<String>,
+    #[arg(long = "roadmap")]
+    roadmap: Vec<String>,
 }
 
 #[derive(Args)]
-struct QuickHypothesisArgs {
+struct HypothesisRecordArgs {
     #[command(flatten)]
     project: ProjectArg,
     #[arg(long)]
@@ -400,255 +253,330 @@ struct QuickHypothesisArgs {
     summary: String,
     #[arg(long)]
     body: String,
+    #[arg(long)]
+    slug: Option<String>,
+    #[arg(long = "tag")]
+    tags: Vec<String>,
     #[arg(long = "parent")]
     parents: Vec<String>,
 }
 
 #[derive(Args)]
-struct TagAddArgs {
+struct HypothesisListArgs {
     #[command(flatten)]
     project: ProjectArg,
     #[arg(long)]
-    name: String,
+    frontier: Option<String>,
+    #[arg(long = "tag")]
+    tags: Vec<String>,
     #[arg(long)]
-    description: String,
+    include_archived: bool,
+    #[arg(long)]
+    limit: Option<u32>,
 }
 
 #[derive(Args)]
-struct QuickSourceArgs {
+struct HypothesisSelectorArgs {
     #[command(flatten)]
     project: ProjectArg,
     #[arg(long)]
-    frontier: Option<String>,
+    hypothesis: String,
+}
+
+#[derive(Args)]
+struct HypothesisUpdateArgs {
+    #[command(flatten)]
+    project: ProjectArg,
     #[arg(long)]
-    title: String,
+    hypothesis: String,
     #[arg(long)]
-    summary: String,
+    expected_revision: Option<u64>,
     #[arg(long)]
-    body: String,
+    title: Option<String>,
+    #[arg(long)]
+    summary: Option<String>,
+    #[arg(long)]
+    body: Option<String>,
+    #[arg(long = "tag")]
+    tags: Vec<String>,
+    #[arg(long = "replace-tags")]
+    replace_tags: bool,
+    #[arg(long = "parent")]
+    parents: Vec<String>,
+    #[arg(long = "replace-parents")]
+    replace_parents: bool,
+    #[arg(long, value_enum)]
+    state: Option<CliArchivePatch>,
+}
+
+#[derive(Args)]
+struct ExperimentOpenArgs {
     #[command(flatten)]
-    tag_selection: ExplicitTagSelectionArgs,
+    project: ProjectArg,
+    #[arg(long)]
+    hypothesis: String,
+    #[arg(long)]
+    title: String,
+    #[arg(long)]
+    summary: Option<String>,
+    #[arg(long)]
+    slug: Option<String>,
+    #[arg(long = "tag")]
+    tags: Vec<String>,
     #[arg(long = "parent")]
     parents: Vec<String>,
 }
 
 #[derive(Args)]
-struct SchemaFieldUpsertArgs {
+struct ExperimentListArgs {
     #[command(flatten)]
     project: ProjectArg,
     #[arg(long)]
-    name: String,
-    #[arg(long = "class", value_enum)]
-    classes: Vec<CliNodeClass>,
-    #[arg(long, value_enum)]
-    presence: CliFieldPresence,
-    #[arg(long, value_enum)]
-    severity: CliDiagnosticSeverity,
+    frontier: Option<String>,
+    #[arg(long)]
+    hypothesis: Option<String>,
     #[arg(long, value_enum)]
-    role: CliFieldRole,
-    #[arg(long = "inference", value_enum)]
-    inference_policy: CliInferencePolicy,
-    #[arg(long = "type", value_enum)]
-    value_type: Option<CliFieldValueType>,
+    status: Option<CliExperimentStatus>,
+    #[arg(long = "tag")]
+    tags: Vec<String>,
+    #[arg(long)]
+    include_archived: bool,
+    #[arg(long)]
+    limit: Option<u32>,
 }
 
 #[derive(Args)]
-struct SchemaFieldRemoveArgs {
+struct ExperimentSelectorArgs {
     #[command(flatten)]
     project: ProjectArg,
     #[arg(long)]
-    name: String,
-    #[arg(long = "class", value_enum)]
-    classes: Vec<CliNodeClass>,
+    experiment: String,
 }
 
 #[derive(Args)]
-struct MetricBestArgs {
+struct ExperimentUpdateArgs {
     #[command(flatten)]
     project: ProjectArg,
-    /// Metric key to rank on.
     #[arg(long)]
-    key: String,
-    /// Restrict results to one frontier.
+    experiment: String,
     #[arg(long)]
-    frontier: Option<String>,
-    /// Restrict results to one metric source.
-    #[arg(long, value_enum)]
-    source: Option<CliMetricSource>,
-    /// Explicit ordering for sources whose objective cannot be inferred.
+    expected_revision: Option<u64>,
+    #[arg(long)]
+    title: Option<String>,
+    #[arg(long)]
+    summary: Option<String>,
+    #[arg(long)]
+    clear_summary: bool,
+    #[arg(long = "tag")]
+    tags: Vec<String>,
+    #[arg(long = "replace-tags")]
+    replace_tags: bool,
+    #[arg(long = "parent")]
+    parents: Vec<String>,
+    #[arg(long = "replace-parents")]
+    replace_parents: bool,
     #[arg(long, value_enum)]
-    order: Option<CliMetricOrder>,
-    /// Exact run-dimension filter in the form `key=value`.
-    #[arg(long = "dimension")]
-    dimensions: Vec<String>,
-    /// Maximum number of ranked experiments to return.
-    #[arg(long, default_value_t = 10)]
-    limit: u32,
-}
-
-#[derive(Subcommand)]
-enum ExperimentCommand {
-    /// Open a stateful experiment against one hypothesis.
-    Open(ExperimentOpenArgs),
-    /// List open experiments, optionally narrowed to one frontier.
-    List(ExperimentListArgs),
-    /// Close a core-path experiment with run data, note, and verdict.
-    Close(Box<ExperimentCloseArgs>),
-}
-
-#[derive(Subcommand)]
-enum McpCommand {
-    /// Serve the public stdio MCP host. If `--project` is omitted, the host starts unbound.
-    Serve(McpServeArgs),
-    #[command(hide = true)]
-    Worker(McpWorkerArgs),
-}
-
-#[derive(Subcommand)]
-enum UiCommand {
-    /// Serve the local read-only navigator.
-    Serve(UiServeArgs),
+    state: Option<CliArchivePatch>,
+    #[arg(long = "outcome-json")]
+    outcome_json: Option<String>,
+    #[arg(long = "outcome-file")]
+    outcome_file: Option<PathBuf>,
 }
 
 #[derive(Args)]
 struct ExperimentCloseArgs {
     #[command(flatten)]
     project: ProjectArg,
-    #[arg(long = "experiment")]
-    experiment_id: String,
-    #[arg(long = "run-title")]
-    run_title: String,
-    #[arg(long = "run-summary")]
-    run_summary: Option<String>,
-    /// Repeat for each run dimension as `key=value`.
-    #[arg(long = "dimension")]
-    dimensions: Vec<String>,
-    #[arg(long = "backend", value_enum, default_value_t = CliExecutionBackend::Worktree)]
+    #[arg(long)]
+    experiment: String,
+    #[arg(long)]
+    expected_revision: Option<u64>,
+    #[arg(long, value_enum)]
     backend: CliExecutionBackend,
-    #[arg(long = "cwd")]
-    working_directory: Option<PathBuf>,
-    /// Repeat for each argv token passed to the recorded command.
     #[arg(long = "argv")]
     argv: Vec<String>,
-    /// Repeat for each environment override as `KEY=VALUE`.
+    #[arg(long)]
+    working_directory: Option<PathBuf>,
     #[arg(long = "env")]
     env: Vec<String>,
-    /// Primary metric in the form `key=value`; key must be preregistered.
+    #[arg(long = "dimension")]
+    dimensions: Vec<String>,
     #[arg(long = "primary-metric")]
     primary_metric: String,
-    /// Supporting metric in the form `key=value`; repeat as needed.
     #[arg(long = "metric")]
-    metrics: Vec<String>,
-    #[arg(long)]
-    note: String,
-    #[arg(long = "next-hypothesis")]
-    next_hypotheses: Vec<String>,
-    #[arg(long = "verdict", value_enum)]
+    supporting_metrics: Vec<String>,
+    #[arg(long, value_enum)]
     verdict: CliFrontierVerdict,
-    #[arg(long = "analysis-title")]
-    analysis_title: Option<String>,
-    #[arg(long = "analysis-summary")]
+    #[arg(long)]
+    rationale: String,
+    #[arg(long)]
     analysis_summary: Option<String>,
-    #[arg(long = "analysis-body")]
+    #[arg(long)]
     analysis_body: Option<String>,
-    #[arg(long = "decision-title")]
-    decision_title: String,
-    #[arg(long = "decision-rationale")]
-    decision_rationale: String,
 }
 
 #[derive(Args)]
-struct ExperimentOpenArgs {
+struct ArtifactRecordArgs {
     #[command(flatten)]
     project: ProjectArg,
     #[arg(long)]
-    frontier: String,
-    #[arg(long = "hypothesis-node")]
-    hypothesis_node: String,
+    kind: CliArtifactKind,
     #[arg(long)]
-    title: String,
+    label: String,
     #[arg(long)]
     summary: Option<String>,
+    #[arg(long)]
+    locator: String,
+    #[arg(long)]
+    media_type: Option<String>,
+    #[arg(long)]
+    slug: Option<String>,
+    #[arg(long = "attach")]
+    attachments: Vec<String>,
 }
 
 #[derive(Args)]
-struct ExperimentListArgs {
+struct ArtifactListArgs {
     #[command(flatten)]
     project: ProjectArg,
     #[arg(long)]
     frontier: Option<String>,
+    #[arg(long)]
+    kind: Option<CliArtifactKind>,
+    #[arg(long)]
+    attached_to: Option<String>,
+    #[arg(long)]
+    limit: Option<u32>,
 }
 
-#[derive(Subcommand)]
-enum SkillCommand {
-    /// List bundled skills.
-    List,
-    /// Install bundled skills into a Codex skill directory.
-    Install(SkillInstallArgs),
-    /// Print one bundled skill body.
-    Show(SkillShowArgs),
+#[derive(Args)]
+struct ArtifactSelectorArgs {
+    #[command(flatten)]
+    project: ProjectArg,
+    #[arg(long)]
+    artifact: String,
 }
 
 #[derive(Args)]
-struct SkillInstallArgs {
-    /// Bundled skill name. Defaults to all bundled skills.
+struct ArtifactUpdateArgs {
+    #[command(flatten)]
+    project: ProjectArg,
     #[arg(long)]
-    name: Option<String>,
-    /// Destination root. Defaults to `~/.codex/skills`.
+    artifact: String,
     #[arg(long)]
-    destination: Option<PathBuf>,
+    expected_revision: Option<u64>,
+    #[arg(long)]
+    kind: Option<CliArtifactKind>,
+    #[arg(long)]
+    label: Option<String>,
+    #[arg(long)]
+    summary: Option<String>,
+    #[arg(long)]
+    clear_summary: bool,
+    #[arg(long)]
+    locator: Option<String>,
+    #[arg(long)]
+    media_type: Option<String>,
+    #[arg(long)]
+    clear_media_type: bool,
+    #[arg(long = "attach")]
+    attachments: Vec<String>,
+    #[arg(long = "replace-attachments")]
+    replace_attachments: bool,
 }
 
 #[derive(Args)]
-struct SkillShowArgs {
-    /// Bundled skill name. Defaults to `fidget-spinner`.
+struct MetricDefineArgs {
+    #[command(flatten)]
+    project: ProjectArg,
     #[arg(long)]
-    name: Option<String>,
+    key: String,
+    #[arg(long, value_enum)]
+    unit: CliMetricUnit,
+    #[arg(long, value_enum)]
+    objective: CliOptimizationObjective,
+    #[arg(long, value_enum, default_value_t = CliMetricVisibility::Canonical)]
+    visibility: CliMetricVisibility,
+    #[arg(long)]
+    description: Option<String>,
 }
 
 #[derive(Args)]
-struct ProjectArg {
-    /// Project root or any nested path inside a project containing `.fidget_spinner/`.
-    #[arg(long, default_value = ".")]
-    project: PathBuf,
+struct MetricKeysArgs {
+    #[command(flatten)]
+    project: ProjectArg,
+    #[arg(long)]
+    frontier: Option<String>,
+    #[arg(long, value_enum, default_value_t = CliMetricScope::Live)]
+    scope: CliMetricScope,
+}
+
+#[derive(Args)]
+struct MetricBestArgs {
+    #[command(flatten)]
+    project: ProjectArg,
+    #[arg(long)]
+    frontier: Option<String>,
+    #[arg(long)]
+    hypothesis: Option<String>,
+    #[arg(long)]
+    key: String,
+    #[arg(long = "dimension")]
+    dimensions: Vec<String>,
+    #[arg(long)]
+    include_rejected: bool,
+    #[arg(long)]
+    limit: Option<u32>,
+    #[arg(long, value_enum)]
+    order: Option<CliMetricRankOrder>,
+}
+
+#[derive(Args)]
+struct DimensionDefineArgs {
+    #[command(flatten)]
+    project: ProjectArg,
+    #[arg(long)]
+    key: String,
+    #[arg(long, value_enum)]
+    value_type: CliFieldValueType,
+    #[arg(long)]
+    description: Option<String>,
 }
 
 #[derive(Args)]
 struct McpServeArgs {
-    /// Optional initial project binding. When omitted, the MCP starts unbound.
     #[arg(long)]
     project: Option<PathBuf>,
 }
 
 #[derive(Args)]
 struct McpWorkerArgs {
-    #[arg(long)]
+    #[arg(long, default_value = ".")]
     project: PathBuf,
 }
 
 #[derive(Args)]
 struct UiServeArgs {
-    /// Path to serve. Accepts a project root, `.fidget_spinner/`, descendants inside it,
-    /// or a parent directory containing one unique descendant project store.
-    #[arg(long = "path", alias = "project", default_value = ".")]
+    #[arg(long, default_value = ".")]
     path: PathBuf,
-    /// Bind address for the local navigator.
     #[arg(long, default_value = "127.0.0.1:8913")]
     bind: SocketAddr,
-    /// Maximum rows rendered in list views.
-    #[arg(long, default_value_t = 200)]
-    limit: u32,
+    #[arg(long)]
+    limit: Option<u32>,
 }
 
-#[derive(Clone, Copy, Debug, Eq, PartialEq, ValueEnum)]
-enum CliNodeClass {
-    Contract,
-    Hypothesis,
-    Run,
-    Analysis,
-    Decision,
-    Source,
-    Note,
+#[derive(Args)]
+struct SkillInstallArgs {
+    #[arg(long)]
+    name: Option<String>,
+    #[arg(long)]
+    destination: Option<PathBuf>,
+}
+
+#[derive(Args)]
+struct SkillShowArgs {
+    #[arg(long)]
+    name: Option<String>,
 }
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq, ValueEnum)]
@@ -668,23 +596,22 @@ enum CliOptimizationObjective {
 }
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq, ValueEnum)]
-enum CliExecutionBackend {
-    Local,
-    Worktree,
-    Ssh,
+enum CliMetricVisibility {
+    Canonical,
+    Minor,
+    Hidden,
+    Archived,
 }
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq, ValueEnum)]
-enum CliMetricSource {
-    RunMetric,
-    HypothesisPayload,
-    RunPayload,
-    AnalysisPayload,
-    DecisionPayload,
+enum CliMetricScope {
+    Live,
+    Visible,
+    All,
 }
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq, ValueEnum)]
-enum CliMetricOrder {
+enum CliMetricRankOrder {
     Asc,
     Desc,
 }
@@ -698,31 +625,23 @@ enum CliFieldValueType {
 }
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq, ValueEnum)]
-enum CliDiagnosticSeverity {
-    Error,
-    Warning,
-    Info,
-}
-
-#[derive(Clone, Copy, Debug, Eq, PartialEq, ValueEnum)]
-enum CliFieldPresence {
-    Required,
-    Recommended,
-    Optional,
+enum CliArtifactKind {
+    Document,
+    Link,
+    Log,
+    Table,
+    Plot,
+    Dump,
+    Binary,
+    Other,
 }
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq, ValueEnum)]
-enum CliFieldRole {
-    Index,
-    ProjectionGate,
-    RenderOnly,
-    Opaque,
-}
-
-#[derive(Clone, Copy, Debug, Eq, PartialEq, ValueEnum)]
-enum CliInferencePolicy {
-    ManualOnly,
-    ModelMayInfer,
+enum CliExecutionBackend {
+    Manual,
+    LocalProcess,
+    WorktreeProcess,
+    SshProcess,
 }
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq, ValueEnum)]
@@ -733,63 +652,89 @@ enum CliFrontierVerdict {
     Rejected,
 }
 
-fn main() {
-    if let Err(error) = run() {
-        eprintln!("error: {error}");
-        std::process::exit(1);
-    }
+#[derive(Clone, Copy, Debug, Eq, PartialEq, ValueEnum)]
+enum CliExperimentStatus {
+    Open,
+    Closed,
 }
 
-fn run() -> Result<(), StoreError> {
+#[derive(Clone, Copy, Debug, Eq, PartialEq, ValueEnum)]
+enum CliArchivePatch {
+    Archive,
+    Restore,
+}
+
+fn main() -> Result<(), StoreError> {
     let cli = Cli::parse();
     match cli.command {
         Command::Init(args) => run_init(args),
-        Command::Schema { command } => match command {
-            SchemaCommand::Show(project) => {
-                let store = open_store(&project.project)?;
-                print_json(store.schema())
-            }
-            SchemaCommand::UpsertField(args) => run_schema_field_upsert(args),
-            SchemaCommand::RemoveField(args) => run_schema_field_remove(args),
+        Command::Project { command } => match command {
+            ProjectCommand::Status(args) => print_json(&open_store(&args.project)?.status()?),
         },
-        Command::Frontier { command } => match command {
-            FrontierCommand::Init(args) => run_frontier_init(args),
-            FrontierCommand::Status(args) => run_frontier_status(args),
-        },
-        Command::Node { command } => match command {
-            NodeCommand::Add(args) => run_node_add(args),
-            NodeCommand::List(args) => run_node_list(args),
-            NodeCommand::Show(args) => run_node_show(args),
-            NodeCommand::Annotate(args) => run_node_annotate(args),
-            NodeCommand::Archive(args) => run_node_archive(args),
+        Command::Tag { command } => match command {
+            TagCommand::Add(args) => run_tag_add(args),
+            TagCommand::List(args) => print_json(&open_store(&args.project)?.list_tags()?),
         },
-        Command::Note(command) => match command.command {
-            NoteSubcommand::Quick(args) => run_quick_note(args),
+        Command::Frontier { command } => match command {
+            FrontierCommand::Create(args) => run_frontier_create(args),
+            FrontierCommand::List(args) => {
+                print_json(&open_store(&args.project)?.list_frontiers()?)
+            }
+            FrontierCommand::Read(args) => {
+                print_json(&open_store(&args.project.project)?.read_frontier(&args.frontier)?)
+            }
+            FrontierCommand::Open(args) => {
+                print_json(&open_store(&args.project.project)?.frontier_open(&args.frontier)?)
+            }
+            FrontierCommand::UpdateBrief(args) => run_frontier_brief_update(args),
+            FrontierCommand::History(args) => {
+                print_json(&open_store(&args.project.project)?.frontier_history(&args.frontier)?)
+            }
         },
-        Command::Hypothesis(command) => match command.command {
-            HypothesisSubcommand::Add(args) => run_quick_hypothesis(args),
+        Command::Hypothesis { command } => match command {
+            HypothesisCommand::Record(args) => run_hypothesis_record(args),
+            HypothesisCommand::List(args) => run_hypothesis_list(args),
+            HypothesisCommand::Read(args) => {
+                print_json(&open_store(&args.project.project)?.read_hypothesis(&args.hypothesis)?)
+            }
+            HypothesisCommand::Update(args) => run_hypothesis_update(args),
+            HypothesisCommand::History(args) => print_json(
+                &open_store(&args.project.project)?.hypothesis_history(&args.hypothesis)?,
+            ),
         },
-        Command::Tag { command } => match command {
-            TagCommand::Add(args) => run_tag_add(args),
-            TagCommand::List(project) => run_tag_list(project),
+        Command::Experiment { command } => match command {
+            ExperimentCommand::Open(args) => run_experiment_open(args),
+            ExperimentCommand::List(args) => run_experiment_list(args),
+            ExperimentCommand::Read(args) => {
+                print_json(&open_store(&args.project.project)?.read_experiment(&args.experiment)?)
+            }
+            ExperimentCommand::Update(args) => run_experiment_update(args),
+            ExperimentCommand::Close(args) => run_experiment_close(args),
+            ExperimentCommand::History(args) => print_json(
+                &open_store(&args.project.project)?.experiment_history(&args.experiment)?,
+            ),
         },
-        Command::Source(command) => match command.command {
-            SourceSubcommand::Add(args) => run_quick_source(args),
+        Command::Artifact { command } => match command {
+            ArtifactCommand::Record(args) => run_artifact_record(args),
+            ArtifactCommand::List(args) => run_artifact_list(args),
+            ArtifactCommand::Read(args) => {
+                print_json(&open_store(&args.project.project)?.read_artifact(&args.artifact)?)
+            }
+            ArtifactCommand::Update(args) => run_artifact_update(args),
+            ArtifactCommand::History(args) => {
+                print_json(&open_store(&args.project.project)?.artifact_history(&args.artifact)?)
+            }
         },
         Command::Metric { command } => match command {
             MetricCommand::Define(args) => run_metric_define(args),
             MetricCommand::Keys(args) => run_metric_keys(args),
             MetricCommand::Best(args) => run_metric_best(args),
-            MetricCommand::Migrate(project) => run_metric_migrate(project),
         },
         Command::Dimension { command } => match command {
             DimensionCommand::Define(args) => run_dimension_define(args),
-            DimensionCommand::List(project) => run_dimension_list(project),
-        },
-        Command::Experiment { command } => match command {
-            ExperimentCommand::Open(args) => run_experiment_open(args),
-            ExperimentCommand::List(args) => run_experiment_list(args),
-            ExperimentCommand::Close(args) => run_experiment_close(*args),
+            DimensionCommand::List(args) => {
+                print_json(&open_store(&args.project)?.list_run_dimensions()?)
+            }
         },
         Command::Mcp { command } => match command {
             McpCommand::Serve(args) => mcp::serve(args.project),
@@ -811,385 +756,278 @@ fn run() -> Result<(), StoreError> {
 
 fn run_init(args: InitArgs) -> Result<(), StoreError> {
     let project_root = utf8_path(args.project);
-    let display_name = args
-        .name
-        .map(NonEmptyText::new)
-        .transpose()?
-        .unwrap_or(default_display_name_for_root(&project_root)?);
-    let namespace = NonEmptyText::new(args.namespace)?;
-    let store = ProjectStore::init(&project_root, display_name, namespace)?;
-    println!("initialized {}", store.state_root());
-    println!("project: {}", store.config().display_name);
-    println!("schema: {}", store.state_root().join("schema.json"));
-    maybe_print_gitignore_hint(&project_root)?;
-    Ok(())
+    let store = ProjectStore::init(
+        &project_root,
+        args.name
+            .map(NonEmptyText::new)
+            .transpose()?
+            .unwrap_or(default_display_name_for_root(&project_root)?),
+    )?;
+    print_json(&store.status()?)
 }
 
-fn run_frontier_init(args: FrontierInitArgs) -> Result<(), StoreError> {
+fn run_tag_add(args: TagAddArgs) -> Result<(), StoreError> {
     let mut store = open_store(&args.project.project)?;
-    let projection = store.create_frontier(CreateFrontierRequest {
-        label: NonEmptyText::new(args.label)?,
-        contract_title: NonEmptyText::new(args.contract_title)?,
-        contract_summary: args.contract_summary.map(NonEmptyText::new).transpose()?,
-        contract: FrontierContract {
-            objective: NonEmptyText::new(args.objective)?,
-            evaluation: fidget_spinner_core::EvaluationProtocol {
-                benchmark_suites: to_text_set(args.benchmark_suites)?,
-                primary_metric: MetricSpec {
-                    metric_key: NonEmptyText::new(args.primary_metric_key)?,
-                    unit: args.primary_metric_unit.into(),
-                    objective: args.primary_metric_objective.into(),
-                },
-                supporting_metrics: BTreeSet::new(),
-            },
-            promotion_criteria: to_text_vec(args.promotion_criteria)?,
-        },
-    })?;
-    print_json(&projection)
+    print_json(&store.register_tag(
+        TagName::new(args.name)?,
+        NonEmptyText::new(args.description)?,
+    )?)
 }
 
-fn run_frontier_status(args: FrontierStatusArgs) -> Result<(), StoreError> {
-    let store = open_store(&args.project.project)?;
-    if let Some(frontier) = args.frontier {
-        let projection = store.frontier_projection(parse_frontier_id(&frontier)?)?;
-        return print_json(&projection);
-    }
-    let frontiers = store.list_frontiers()?;
-    if frontiers.len() == 1 {
-        return print_json(&store.frontier_projection(frontiers[0].id)?);
-    }
-    print_json(&frontiers)
+fn run_frontier_create(args: FrontierCreateArgs) -> Result<(), StoreError> {
+    let mut store = open_store(&args.project.project)?;
+    print_json(&store.create_frontier(CreateFrontierRequest {
+        label: NonEmptyText::new(args.label)?,
+        objective: NonEmptyText::new(args.objective)?,
+        slug: args.slug.map(Slug::new).transpose()?,
+    })?)
 }
 
-fn run_schema_field_upsert(args: SchemaFieldUpsertArgs) -> Result<(), StoreError> {
-    let mut store = open_store(&args.project.project)?;
-    let field = store.upsert_schema_field(UpsertSchemaFieldRequest {
-        name: NonEmptyText::new(args.name)?,
-        node_classes: parse_node_class_set(args.classes),
-        presence: args.presence.into(),
-        severity: args.severity.into(),
-        role: args.role.into(),
-        inference_policy: args.inference_policy.into(),
-        value_type: args.value_type.map(Into::into),
-    })?;
-    print_json(&json!({
-        "schema": store.schema().schema_ref(),
-        "field": schema_field_json(&field),
-    }))
-}
-
-fn run_schema_field_remove(args: SchemaFieldRemoveArgs) -> Result<(), StoreError> {
+fn run_frontier_brief_update(args: FrontierBriefUpdateArgs) -> Result<(), StoreError> {
     let mut store = open_store(&args.project.project)?;
-    let removed_count = store.remove_schema_field(RemoveSchemaFieldRequest {
-        name: NonEmptyText::new(args.name)?,
-        node_classes: (!args.classes.is_empty()).then(|| parse_node_class_set(args.classes)),
-    })?;
-    print_json(&json!({
-        "schema": store.schema().schema_ref(),
-        "removed_count": removed_count,
-    }))
+    let roadmap = if args.roadmap.is_empty() {
+        None
+    } else {
+        Some(
+            args.roadmap
+                .into_iter()
+                .map(parse_roadmap_item)
+                .collect::<Result<Vec<_>, _>>()?,
+        )
+    };
+    let unknowns = if args.unknowns.is_empty() {
+        None
+    } else {
+        Some(to_non_empty_texts(args.unknowns)?)
+    };
+    print_json(&store.update_frontier_brief(UpdateFrontierBriefRequest {
+        frontier: args.frontier,
+        expected_revision: args.expected_revision,
+        situation: cli_text_patch(args.situation, args.clear_situation)?,
+        roadmap,
+        unknowns,
+    })?)
 }
 
-fn run_node_add(args: NodeAddArgs) -> Result<(), StoreError> {
+fn run_hypothesis_record(args: HypothesisRecordArgs) -> Result<(), StoreError> {
     let mut store = open_store(&args.project.project)?;
-    let class: NodeClass = args.class.into();
-    let frontier_id = args
-        .frontier
-        .as_deref()
-        .map(parse_frontier_id)
-        .transpose()?;
-    let tags = optional_cli_tags(args.tag_selection, class == NodeClass::Note)?;
-    let payload = load_payload(
-        store.schema().schema_ref(),
-        args.payload_json,
-        args.payload_file,
-        args.fields,
-    )?;
-    validate_cli_prose_payload(class, args.summary.as_deref(), &payload)?;
-    let annotations = args
-        .annotations
-        .into_iter()
-        .map(|body| Ok(NodeAnnotation::hidden(NonEmptyText::new(body)?)))
-        .collect::<Result<Vec<_>, StoreError>>()?;
-    let node = store.add_node(CreateNodeRequest {
-        class,
-        frontier_id,
+    print_json(&store.create_hypothesis(CreateHypothesisRequest {
+        frontier: args.frontier,
+        slug: args.slug.map(Slug::new).transpose()?,
         title: NonEmptyText::new(args.title)?,
-        summary: args.summary.map(NonEmptyText::new).transpose()?,
-        tags,
-        payload,
-        annotations,
-        attachments: lineage_attachments(args.parents)?,
-    })?;
-    print_json(&node)
+        summary: NonEmptyText::new(args.summary)?,
+        body: NonEmptyText::new(args.body)?,
+        tags: parse_tag_set(args.tags)?,
+        parents: parse_vertex_selectors(args.parents)?,
+    })?)
 }
 
-fn run_node_list(args: NodeListArgs) -> Result<(), StoreError> {
+fn run_hypothesis_list(args: HypothesisListArgs) -> Result<(), StoreError> {
     let store = open_store(&args.project.project)?;
-    let items = store.list_nodes(ListNodesQuery {
-        frontier_id: args
-            .frontier
-            .as_deref()
-            .map(parse_frontier_id)
-            .transpose()?,
-        class: args.class.map(Into::into),
+    print_json(&store.list_hypotheses(ListHypothesesQuery {
+        frontier: args.frontier,
         tags: parse_tag_set(args.tags)?,
         include_archived: args.include_archived,
         limit: args.limit,
-    })?;
-    print_json(&items)
-}
-
-fn run_node_show(args: NodeShowArgs) -> Result<(), StoreError> {
-    let store = open_store(&args.project.project)?;
-    let node_id = parse_node_id(&args.node)?;
-    let node = store
-        .get_node(node_id)?
-        .ok_or(StoreError::NodeNotFound(node_id))?;
-    print_json(&node)
+    })?)
 }
 
-fn run_node_annotate(args: NodeAnnotateArgs) -> Result<(), StoreError> {
+fn run_hypothesis_update(args: HypothesisUpdateArgs) -> Result<(), StoreError> {
     let mut store = open_store(&args.project.project)?;
-    let annotation = NodeAnnotation {
-        id: fidget_spinner_core::AnnotationId::fresh(),
-        visibility: if args.visible {
-            AnnotationVisibility::Visible
-        } else {
-            AnnotationVisibility::HiddenByDefault
-        },
-        label: args.label.map(NonEmptyText::new).transpose()?,
-        body: NonEmptyText::new(args.body)?,
-        created_at: time::OffsetDateTime::now_utc(),
+    let tags = if args.replace_tags {
+        Some(parse_tag_set(args.tags)?)
+    } else {
+        None
     };
-    store.annotate_node(parse_node_id(&args.node)?, annotation)?;
-    println!("annotated {}", args.node);
-    Ok(())
+    let parents = if args.replace_parents {
+        Some(parse_vertex_selectors(args.parents)?)
+    } else {
+        None
+    };
+    print_json(&store.update_hypothesis(UpdateHypothesisRequest {
+        hypothesis: args.hypothesis,
+        expected_revision: args.expected_revision,
+        title: args.title.map(NonEmptyText::new).transpose()?,
+        summary: args.summary.map(NonEmptyText::new).transpose()?,
+        body: args.body.map(NonEmptyText::new).transpose()?,
+        tags,
+        parents,
+        archived: archive_patch(args.state),
+    })?)
 }
 
-fn run_node_archive(args: NodeArchiveArgs) -> Result<(), StoreError> {
+fn run_experiment_open(args: ExperimentOpenArgs) -> Result<(), StoreError> {
     let mut store = open_store(&args.project.project)?;
-    store.archive_node(parse_node_id(&args.node)?)?;
-    println!("archived {}", args.node);
-    Ok(())
+    print_json(&store.open_experiment(OpenExperimentRequest {
+        hypothesis: args.hypothesis,
+        slug: args.slug.map(Slug::new).transpose()?,
+        title: NonEmptyText::new(args.title)?,
+        summary: args.summary.map(NonEmptyText::new).transpose()?,
+        tags: parse_tag_set(args.tags)?,
+        parents: parse_vertex_selectors(args.parents)?,
+    })?)
 }
 
-fn run_quick_note(args: QuickNoteArgs) -> Result<(), StoreError> {
+fn run_experiment_list(args: ExperimentListArgs) -> Result<(), StoreError> {
+    let store = open_store(&args.project.project)?;
+    print_json(&store.list_experiments(ListExperimentsQuery {
+        frontier: args.frontier,
+        hypothesis: args.hypothesis,
+        tags: parse_tag_set(args.tags)?,
+        include_archived: args.include_archived,
+        status: args.status.map(Into::into),
+        limit: args.limit,
+    })?)
+}
+
+fn run_experiment_update(args: ExperimentUpdateArgs) -> Result<(), StoreError> {
     let mut store = open_store(&args.project.project)?;
-    let payload = NodePayload::with_schema(
-        store.schema().schema_ref(),
-        json_object(json!({ "body": args.body }))?,
-    );
-    let node = store.add_node(CreateNodeRequest {
-        class: NodeClass::Note,
-        frontier_id: args
-            .frontier
-            .as_deref()
-            .map(parse_frontier_id)
-            .transpose()?,
-        title: NonEmptyText::new(args.title)?,
-        summary: Some(NonEmptyText::new(args.summary)?),
-        tags: Some(explicit_cli_tags(args.tag_selection)?),
-        payload,
-        annotations: Vec::new(),
-        attachments: lineage_attachments(args.parents)?,
-    })?;
-    print_json(&node)
+    let outcome =
+        load_optional_json::<ExperimentOutcomePatch>(args.outcome_json, args.outcome_file)?;
+    print_json(&store.update_experiment(UpdateExperimentRequest {
+        experiment: args.experiment,
+        expected_revision: args.expected_revision,
+        title: args.title.map(NonEmptyText::new).transpose()?,
+        summary: cli_text_patch(args.summary, args.clear_summary)?,
+        tags: if args.replace_tags {
+            Some(parse_tag_set(args.tags)?)
+        } else {
+            None
+        },
+        parents: if args.replace_parents {
+            Some(parse_vertex_selectors(args.parents)?)
+        } else {
+            None
+        },
+        archived: archive_patch(args.state),
+        outcome,
+    })?)
 }
 
-fn run_quick_hypothesis(args: QuickHypothesisArgs) -> Result<(), StoreError> {
+fn run_experiment_close(args: ExperimentCloseArgs) -> Result<(), StoreError> {
     let mut store = open_store(&args.project.project)?;
-    let payload = NodePayload::with_schema(
-        store.schema().schema_ref(),
-        json_object(json!({ "body": args.body }))?,
-    );
-    let node = store.add_node(CreateNodeRequest {
-        class: NodeClass::Hypothesis,
-        frontier_id: Some(parse_frontier_id(&args.frontier)?),
-        title: NonEmptyText::new(args.title)?,
-        summary: Some(NonEmptyText::new(args.summary)?),
-        tags: None,
-        payload,
-        annotations: Vec::new(),
-        attachments: lineage_attachments(args.parents)?,
-    })?;
-    print_json(&node)
+    let analysis = match (args.analysis_summary, args.analysis_body) {
+        (Some(summary), Some(body)) => Some(ExperimentAnalysis {
+            summary: NonEmptyText::new(summary)?,
+            body: NonEmptyText::new(body)?,
+        }),
+        (None, None) => None,
+        _ => {
+            return Err(invalid_input(
+                "analysis requires both --analysis-summary and --analysis-body",
+            ));
+        }
+    };
+    print_json(
+        &store.close_experiment(CloseExperimentRequest {
+            experiment: args.experiment,
+            expected_revision: args.expected_revision,
+            backend: args.backend.into(),
+            command: CommandRecipe::new(
+                args.working_directory.map(utf8_path),
+                to_non_empty_texts(args.argv)?,
+                parse_env(args.env),
+            )?,
+            dimensions: parse_dimension_assignments(args.dimensions)?,
+            primary_metric: parse_metric_value_assignment(&args.primary_metric)?,
+            supporting_metrics: args
+                .supporting_metrics
+                .into_iter()
+                .map(|raw| parse_metric_value_assignment(&raw))
+                .collect::<Result<Vec<_>, _>>()?,
+            verdict: args.verdict.into(),
+            rationale: NonEmptyText::new(args.rationale)?,
+            analysis,
+        })?,
+    )
 }
 
-fn run_tag_add(args: TagAddArgs) -> Result<(), StoreError> {
+fn run_artifact_record(args: ArtifactRecordArgs) -> Result<(), StoreError> {
     let mut store = open_store(&args.project.project)?;
-    let tag = store.add_tag(
-        TagName::new(args.name)?,
-        NonEmptyText::new(args.description)?,
-    )?;
-    print_json(&tag)
+    print_json(&store.create_artifact(CreateArtifactRequest {
+        slug: args.slug.map(Slug::new).transpose()?,
+        kind: args.kind.into(),
+        label: NonEmptyText::new(args.label)?,
+        summary: args.summary.map(NonEmptyText::new).transpose()?,
+        locator: NonEmptyText::new(args.locator)?,
+        media_type: args.media_type.map(NonEmptyText::new).transpose()?,
+        attachments: parse_attachment_selectors(args.attachments)?,
+    })?)
 }
 
-fn run_tag_list(args: ProjectArg) -> Result<(), StoreError> {
-    let store = open_store(&args.project)?;
-    print_json(&store.list_tags()?)
+fn run_artifact_list(args: ArtifactListArgs) -> Result<(), StoreError> {
+    let store = open_store(&args.project.project)?;
+    print_json(
+        &store.list_artifacts(ListArtifactsQuery {
+            frontier: args.frontier,
+            kind: args.kind.map(Into::into),
+            attached_to: args
+                .attached_to
+                .as_deref()
+                .map(parse_attachment_selector)
+                .transpose()?,
+            limit: args.limit,
+        })?,
+    )
 }
 
-fn run_quick_source(args: QuickSourceArgs) -> Result<(), StoreError> {
+fn run_artifact_update(args: ArtifactUpdateArgs) -> Result<(), StoreError> {
     let mut store = open_store(&args.project.project)?;
-    let payload = NodePayload::with_schema(
-        store.schema().schema_ref(),
-        json_object(json!({ "body": args.body }))?,
-    );
-    let node = store.add_node(CreateNodeRequest {
-        class: NodeClass::Source,
-        frontier_id: args
-            .frontier
-            .as_deref()
-            .map(parse_frontier_id)
-            .transpose()?,
-        title: NonEmptyText::new(args.title)?,
-        summary: Some(NonEmptyText::new(args.summary)?),
-        tags: optional_cli_tags(args.tag_selection, false)?,
-        payload,
-        annotations: Vec::new(),
-        attachments: lineage_attachments(args.parents)?,
-    })?;
-    print_json(&node)
+    print_json(&store.update_artifact(UpdateArtifactRequest {
+        artifact: args.artifact,
+        expected_revision: args.expected_revision,
+        kind: args.kind.map(Into::into),
+        label: args.label.map(NonEmptyText::new).transpose()?,
+        summary: cli_text_patch(args.summary, args.clear_summary)?,
+        locator: args.locator.map(NonEmptyText::new).transpose()?,
+        media_type: cli_text_patch(args.media_type, args.clear_media_type)?,
+        attachments: if args.replace_attachments {
+            Some(parse_attachment_selectors(args.attachments)?)
+        } else {
+            None
+        },
+    })?)
 }
 
 fn run_metric_define(args: MetricDefineArgs) -> Result<(), StoreError> {
     let mut store = open_store(&args.project.project)?;
-    let record = store.define_metric(DefineMetricRequest {
+    print_json(&store.define_metric(DefineMetricRequest {
         key: NonEmptyText::new(args.key)?,
         unit: args.unit.into(),
         objective: args.objective.into(),
+        visibility: args.visibility.into(),
         description: args.description.map(NonEmptyText::new).transpose()?,
-    })?;
-    print_json(&record)
+    })?)
 }
 
 fn run_metric_keys(args: MetricKeysArgs) -> Result<(), StoreError> {
     let store = open_store(&args.project.project)?;
-    print_json(
-        &store.list_metric_keys_filtered(MetricKeyQuery {
-            frontier_id: args
-                .frontier
-                .as_deref()
-                .map(parse_frontier_id)
-                .transpose()?,
-            source: args.source.map(Into::into),
-            dimensions: coerce_cli_dimension_filters(&store, args.dimensions)?,
-        })?,
-    )
+    print_json(&store.metric_keys(MetricKeysQuery {
+        frontier: args.frontier,
+        scope: args.scope.into(),
+    })?)
 }
 
 fn run_metric_best(args: MetricBestArgs) -> Result<(), StoreError> {
     let store = open_store(&args.project.project)?;
-    let entries = store.best_metrics(MetricBestQuery {
+    print_json(&store.metric_best(MetricBestQuery {
+        frontier: args.frontier,
+        hypothesis: args.hypothesis,
         key: NonEmptyText::new(args.key)?,
-        frontier_id: args
-            .frontier
-            .as_deref()
-            .map(parse_frontier_id)
-            .transpose()?,
-        source: args.source.map(Into::into),
-        dimensions: coerce_cli_dimension_filters(&store, args.dimensions)?,
-        order: args.order.map(Into::into),
+        dimensions: parse_dimension_assignments(args.dimensions)?,
+        include_rejected: args.include_rejected,
         limit: args.limit,
-    })?;
-    print_json(&entries)
-}
-
-fn run_metric_migrate(args: ProjectArg) -> Result<(), StoreError> {
-    let mut store = open_store(&args.project)?;
-    print_json(&store.migrate_metric_plane()?)
+        order: args.order.map(Into::into),
+    })?)
 }
 
 fn run_dimension_define(args: DimensionDefineArgs) -> Result<(), StoreError> {
     let mut store = open_store(&args.project.project)?;
-    let record = store.define_run_dimension(DefineRunDimensionRequest {
+    print_json(&store.define_run_dimension(DefineRunDimensionRequest {
         key: NonEmptyText::new(args.key)?,
         value_type: args.value_type.into(),
         description: args.description.map(NonEmptyText::new).transpose()?,
-    })?;
-    print_json(&record)
-}
-
-fn run_dimension_list(args: ProjectArg) -> Result<(), StoreError> {
-    let store = open_store(&args.project)?;
-    print_json(&store.list_run_dimensions()?)
-}
-
-fn run_experiment_open(args: ExperimentOpenArgs) -> Result<(), StoreError> {
-    let mut store = open_store(&args.project.project)?;
-    let summary = args.summary.map(NonEmptyText::new).transpose()?;
-    let experiment = store.open_experiment(OpenExperimentRequest {
-        frontier_id: parse_frontier_id(&args.frontier)?,
-        hypothesis_node_id: parse_node_id(&args.hypothesis_node)?,
-        title: NonEmptyText::new(args.title)?,
-        summary,
-    })?;
-    print_json(&experiment)
-}
-
-fn run_experiment_list(args: ExperimentListArgs) -> Result<(), StoreError> {
-    let store = open_store(&args.project.project)?;
-    let frontier_id = args
-        .frontier
-        .as_deref()
-        .map(parse_frontier_id)
-        .transpose()?;
-    print_json(&store.list_open_experiments(frontier_id)?)
-}
-
-fn run_experiment_close(args: ExperimentCloseArgs) -> Result<(), StoreError> {
-    let mut store = open_store(&args.project.project)?;
-    let command = CommandRecipe::new(
-        args.working_directory
-            .map(utf8_path)
-            .unwrap_or_else(|| store.project_root().to_path_buf()),
-        to_text_vec(args.argv)?,
-        parse_env(args.env),
-    )?;
-    let analysis = match (
-        args.analysis_title,
-        args.analysis_summary,
-        args.analysis_body,
-    ) {
-        (Some(title), Some(summary), Some(body)) => Some(ExperimentAnalysisDraft {
-            title: NonEmptyText::new(title)?,
-            summary: NonEmptyText::new(summary)?,
-            body: NonEmptyText::new(body)?,
-        }),
-        (None, None, None) => None,
-        _ => {
-            return Err(StoreError::Json(serde_json::Error::io(
-                std::io::Error::new(
-                    std::io::ErrorKind::InvalidInput,
-                    "analysis-title, analysis-summary, and analysis-body must be provided together",
-                ),
-            )));
-        }
-    };
-    let receipt = store.close_experiment(CloseExperimentRequest {
-        experiment_id: parse_experiment_id(&args.experiment_id)?,
-        run_title: NonEmptyText::new(args.run_title)?,
-        run_summary: args.run_summary.map(NonEmptyText::new).transpose()?,
-        backend: args.backend.into(),
-        dimensions: coerce_cli_dimension_filters(&store, args.dimensions)?,
-        command,
-        primary_metric: parse_metric_value(args.primary_metric)?,
-        supporting_metrics: args
-            .metrics
-            .into_iter()
-            .map(parse_metric_value)
-            .collect::<Result<Vec<_>, _>>()?,
-        note: FrontierNote {
-            summary: NonEmptyText::new(args.note)?,
-            next_hypotheses: to_text_vec(args.next_hypotheses)?,
-        },
-        verdict: args.verdict.into(),
-        analysis,
-        decision_title: NonEmptyText::new(args.decision_title)?,
-        decision_rationale: NonEmptyText::new(args.decision_rationale)?,
-    })?;
-    print_json(&receipt)
+    })?)
 }
 
 fn run_skill_install(args: SkillInstallArgs) -> Result<(), StoreError> {
@@ -1240,11 +1078,11 @@ fn install_skill(skill: bundled_skill::BundledSkill, destination: &Path) -> Resu
     Ok(())
 }
 
-fn open_store(path: &Path) -> Result<ProjectStore, StoreError> {
+pub(crate) fn open_store(path: &Path) -> Result<ProjectStore, StoreError> {
     ProjectStore::open(utf8_path(path.to_path_buf()))
 }
 
-fn resolve_ui_project_root(path: &Utf8Path) -> Result<Utf8PathBuf, StoreError> {
+pub(crate) fn resolve_ui_project_root(path: &Utf8Path) -> Result<Utf8PathBuf, StoreError> {
     if let Some(project_root) = fidget_spinner_store_sqlite::discover_project_root(path) {
         return Ok(project_root);
     }
@@ -1266,7 +1104,7 @@ fn resolve_ui_project_root(path: &Utf8Path) -> Result<Utf8PathBuf, StoreError> {
     }
 }
 
-fn open_or_init_store_for_binding(path: &Path) -> Result<ProjectStore, StoreError> {
+pub(crate) fn open_or_init_store_for_binding(path: &Path) -> Result<ProjectStore, StoreError> {
     let requested_root = utf8_path(path.to_path_buf());
     match ProjectStore::open(requested_root.clone()) {
         Ok(store) => Ok(store),
@@ -1275,17 +1113,13 @@ fn open_or_init_store_for_binding(path: &Path) -> Result<ProjectStore, StoreErro
             if !is_empty_directory(&project_root)? {
                 return Err(StoreError::MissingProjectStore(requested_root));
             }
-            ProjectStore::init(
-                &project_root,
-                default_display_name_for_root(&project_root)?,
-                default_namespace_for_root(&project_root)?,
-            )
+            ProjectStore::init(&project_root, default_display_name_for_root(&project_root)?)
         }
         Err(error) => Err(error),
     }
 }
 
-fn utf8_path(path: impl Into<PathBuf>) -> Utf8PathBuf {
+pub(crate) fn utf8_path(path: impl Into<PathBuf>) -> Utf8PathBuf {
     Utf8PathBuf::from(path.into().to_string_lossy().into_owned())
 }
 
@@ -1295,7 +1129,7 @@ fn binding_bootstrap_root(path: &Utf8Path) -> Result<Utf8PathBuf, StoreError> {
             .parent()
             .map_or_else(|| path.to_path_buf(), Utf8Path::to_path_buf)),
         Ok(_) => Ok(path.to_path_buf()),
-        Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(path.to_path_buf()),
+        Err(error) if error.kind() == io::ErrorKind::NotFound => Ok(path.to_path_buf()),
         Err(error) => Err(StoreError::from(error)),
     }
 }
@@ -1307,7 +1141,7 @@ fn is_empty_directory(path: &Utf8Path) -> Result<bool, StoreError> {
             Ok(entries.next().transpose()?.is_none())
         }
         Ok(_) => Ok(false),
-        Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(false),
+        Err(error) if error.kind() == io::ErrorKind::NotFound => Ok(false),
         Err(error) => Err(StoreError::from(error)),
     }
 }
@@ -1325,7 +1159,7 @@ fn collect_descendant_project_roots(
 ) -> Result<(), StoreError> {
     let metadata = match fs::metadata(path.as_std_path()) {
         Ok(metadata) => metadata,
-        Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(()),
+        Err(error) if error.kind() == io::ErrorKind::NotFound => return Ok(()),
         Err(error) => return Err(StoreError::from(error)),
     };
     if metadata.is_file() {
@@ -1362,45 +1196,6 @@ fn default_display_name_for_root(project_root: &Utf8Path) -> Result<NonEmptyText
     .map_err(StoreError::from)
 }
 
-fn default_namespace_for_root(project_root: &Utf8Path) -> Result<NonEmptyText, StoreError> {
-    let slug = slugify_namespace_component(project_root.file_name().unwrap_or("project"));
-    NonEmptyText::new(format!("local.{slug}")).map_err(StoreError::from)
-}
-
-fn slugify_namespace_component(raw: &str) -> String {
-    let mut slug = String::new();
-    let mut previous_was_separator = false;
-    for character in raw.chars().flat_map(char::to_lowercase) {
-        if character.is_ascii_alphanumeric() {
-            slug.push(character);
-            previous_was_separator = false;
-            continue;
-        }
-        if !previous_was_separator {
-            slug.push('_');
-            previous_was_separator = true;
-        }
-    }
-    let slug = slug.trim_matches('_').to_owned();
-    if slug.is_empty() {
-        "project".to_owned()
-    } else {
-        slug
-    }
-}
-
-fn to_text_vec(values: Vec<String>) -> Result<Vec<NonEmptyText>, StoreError> {
-    values
-        .into_iter()
-        .map(NonEmptyText::new)
-        .collect::<Result<Vec<_>, _>>()
-        .map_err(StoreError::from)
-}
-
-fn to_text_set(values: Vec<String>) -> Result<BTreeSet<NonEmptyText>, StoreError> {
-    to_text_vec(values).map(BTreeSet::from_iter)
-}
-
 fn parse_tag_set(values: Vec<String>) -> Result<BTreeSet<TagName>, StoreError> {
     values
         .into_iter()
@@ -1409,290 +1204,198 @@ fn parse_tag_set(values: Vec<String>) -> Result<BTreeSet<TagName>, StoreError> {
         .map_err(StoreError::from)
 }
 
-fn explicit_cli_tags(selection: ExplicitTagSelectionArgs) -> Result<BTreeSet<TagName>, StoreError> {
-    optional_cli_tags(selection, true)?.ok_or(StoreError::NoteTagsRequired)
-}
-
-fn optional_cli_tags(
-    selection: ExplicitTagSelectionArgs,
-    required: bool,
-) -> Result<Option<BTreeSet<TagName>>, StoreError> {
-    if selection.no_tags {
-        return Ok(Some(BTreeSet::new()));
-    }
-    if selection.tags.is_empty() {
-        return if required {
-            Err(StoreError::NoteTagsRequired)
-        } else {
-            Ok(None)
-        };
-    }
-    Ok(Some(parse_tag_set(selection.tags)?))
-}
-
-fn parse_env(values: Vec<String>) -> BTreeMap<String, String> {
+pub(crate) fn parse_vertex_selectors(
+    values: Vec<String>,
+) -> Result<Vec<VertexSelector>, StoreError> {
     values
         .into_iter()
-        .filter_map(|entry| {
-            let (key, value) = entry.split_once('=')?;
-            Some((key.to_owned(), value.to_owned()))
+        .map(|raw| {
+            let (kind, selector) = raw
+                .split_once(':')
+                .ok_or_else(|| invalid_input("expected parent selector in the form `hypothesis:<selector>` or `experiment:<selector>`"))?;
+            match kind {
+                "hypothesis" => Ok(VertexSelector::Hypothesis(selector.to_owned())),
+                "experiment" => Ok(VertexSelector::Experiment(selector.to_owned())),
+                _ => Err(invalid_input(format!("unknown parent kind `{kind}`"))),
+            }
         })
         .collect()
 }
 
-fn lineage_attachments(parents: Vec<String>) -> Result<Vec<EdgeAttachment>, StoreError> {
-    parents
+pub(crate) fn parse_attachment_selectors(
+    values: Vec<String>,
+) -> Result<Vec<AttachmentSelector>, StoreError> {
+    values
         .into_iter()
-        .map(|parent| {
-            Ok(EdgeAttachment {
-                node_id: parse_node_id(&parent)?,
-                kind: fidget_spinner_core::EdgeKind::Lineage,
-                direction: EdgeAttachmentDirection::ExistingToNew,
-            })
-        })
+        .map(|raw| parse_attachment_selector(&raw))
         .collect()
 }
 
-fn load_payload(
-    schema: fidget_spinner_core::PayloadSchemaRef,
-    payload_json: Option<String>,
-    payload_file: Option<PathBuf>,
-    fields: Vec<String>,
-) -> Result<NodePayload, StoreError> {
-    let mut map = Map::new();
-    if let Some(text) = payload_json {
-        map.extend(json_object(serde_json::from_str::<Value>(&text)?)?);
-    }
-    if let Some(path) = payload_file {
-        let text = fs::read_to_string(path)?;
-        map.extend(json_object(serde_json::from_str::<Value>(&text)?)?);
+pub(crate) fn parse_attachment_selector(raw: &str) -> Result<AttachmentSelector, StoreError> {
+    let (kind, selector) = raw
+        .split_once(':')
+        .ok_or_else(|| invalid_input("expected attachment selector in the form `frontier:<selector>`, `hypothesis:<selector>`, or `experiment:<selector>`"))?;
+    match kind {
+        "frontier" => Ok(AttachmentSelector::Frontier(selector.to_owned())),
+        "hypothesis" => Ok(AttachmentSelector::Hypothesis(selector.to_owned())),
+        "experiment" => Ok(AttachmentSelector::Experiment(selector.to_owned())),
+        _ => Err(invalid_input(format!("unknown attachment kind `{kind}`"))),
     }
-    for field in fields {
-        let Some((key, raw_value)) = field.split_once('=') else {
-            continue;
-        };
-        let value = serde_json::from_str::<Value>(raw_value).unwrap_or_else(|_| json!(raw_value));
-        let _ = map.insert(key.to_owned(), value);
-    }
-    Ok(NodePayload::with_schema(schema, map))
 }
 
-fn validate_cli_prose_payload(
-    class: NodeClass,
-    summary: Option<&str>,
-    payload: &NodePayload,
-) -> Result<(), StoreError> {
-    if !matches!(class, NodeClass::Note | NodeClass::Source) {
-        return Ok(());
-    }
-    if summary.is_none() {
-        return Err(StoreError::ProseSummaryRequired(class));
-    }
-    match payload.field("body") {
-        Some(Value::String(body)) if !body.trim().is_empty() => Ok(()),
-        _ => Err(StoreError::ProseBodyRequired(class)),
-    }
+fn parse_roadmap_item(raw: String) -> Result<FrontierRoadmapItemDraft, StoreError> {
+    let mut parts = raw.splitn(3, ':');
+    let rank = parts
+        .next()
+        .ok_or_else(|| invalid_input("roadmap items must look like `rank:hypothesis[:summary]`"))?
+        .parse::<u32>()
+        .map_err(|error| invalid_input(format!("invalid roadmap rank: {error}")))?;
+    let hypothesis = parts
+        .next()
+        .ok_or_else(|| invalid_input("roadmap items must include a hypothesis selector"))?
+        .to_owned();
+    let summary = parts
+        .next()
+        .map(NonEmptyText::new)
+        .transpose()
+        .map_err(StoreError::from)?;
+    Ok(FrontierRoadmapItemDraft {
+        rank,
+        hypothesis,
+        summary,
+    })
 }
 
-fn json_object(value: Value) -> Result<Map<String, Value>, StoreError> {
-    match value {
-        Value::Object(map) => Ok(map),
-        other => Err(invalid_input(format!(
-            "expected JSON object, got {other:?}"
-        ))),
-    }
+pub(crate) fn parse_env(values: Vec<String>) -> BTreeMap<String, String> {
+    values
+        .into_iter()
+        .filter_map(|entry| {
+            let (key, value) = entry.split_once('=')?;
+            Some((key.to_owned(), value.to_owned()))
+        })
+        .collect()
 }
 
-fn schema_field_json(field: &ProjectFieldSpec) -> Value {
-    json!({
-        "name": field.name,
-        "node_classes": field.node_classes.iter().map(ToString::to_string).collect::<Vec<_>>(),
-        "presence": field.presence.as_str(),
-        "severity": field.severity.as_str(),
-        "role": field.role.as_str(),
-        "inference_policy": field.inference_policy.as_str(),
-        "value_type": field.value_type.map(FieldValueType::as_str),
+fn parse_metric_value_assignment(
+    raw: &str,
+) -> Result<fidget_spinner_core::MetricValue, StoreError> {
+    let (key, value) = raw
+        .split_once('=')
+        .ok_or_else(|| invalid_input("expected metric assignment in the form `key=value`"))?;
+    let value = value
+        .parse::<f64>()
+        .map_err(|error| invalid_input(format!("invalid metric value `{value}`: {error}")))?;
+    Ok(fidget_spinner_core::MetricValue {
+        key: NonEmptyText::new(key.to_owned())?,
+        value,
     })
 }
 
-fn parse_node_class_set(classes: Vec<CliNodeClass>) -> BTreeSet<NodeClass> {
-    classes.into_iter().map(Into::into).collect()
-}
-
-fn run_git(project_root: &Utf8Path, args: &[&str]) -> Result<Option<String>, StoreError> {
-    let output = std::process::Command::new("git")
-        .arg("-C")
-        .arg(project_root.as_str())
-        .args(args)
-        .output()?;
-    if !output.status.success() {
-        return Ok(None);
-    }
-    let text = String::from_utf8_lossy(&output.stdout).trim().to_owned();
-    if text.is_empty() {
-        return Ok(None);
-    }
-    Ok(Some(text))
+pub(crate) fn parse_dimension_assignments(
+    values: Vec<String>,
+) -> Result<BTreeMap<NonEmptyText, RunDimensionValue>, StoreError> {
+    values
+        .into_iter()
+        .map(|entry| {
+            let (key, raw_value) = entry.split_once('=').ok_or_else(|| {
+                invalid_input("expected dimension assignment in the form `key=value`")
+            })?;
+            let json_value = serde_json::from_str::<Value>(raw_value)
+                .unwrap_or_else(|_| Value::String(raw_value.to_owned()));
+            Ok((
+                NonEmptyText::new(key.to_owned())?,
+                json_to_dimension_value(json_value)?,
+            ))
+        })
+        .collect()
 }
 
-fn maybe_print_gitignore_hint(project_root: &Utf8Path) -> Result<(), StoreError> {
-    if run_git(project_root, &["rev-parse", "--show-toplevel"])?.is_none() {
-        return Ok(());
-    }
-
-    let status = std::process::Command::new("git")
-        .arg("-C")
-        .arg(project_root.as_str())
-        .args(["check-ignore", "-q", ".fidget_spinner"])
-        .status()?;
-
-    match status.code() {
-        Some(0) => Ok(()),
-        Some(1) => {
-            println!(
-                "note: add `.fidget_spinner/` to `.gitignore` or `.git/info/exclude` if you do not want local state in `git status`"
-            );
-            Ok(())
+fn json_to_dimension_value(value: Value) -> Result<RunDimensionValue, StoreError> {
+    match value {
+        Value::String(raw) => {
+            if time::OffsetDateTime::parse(&raw, &time::format_description::well_known::Rfc3339)
+                .is_ok()
+            {
+                Ok(RunDimensionValue::Timestamp(NonEmptyText::new(raw)?))
+            } else {
+                Ok(RunDimensionValue::String(NonEmptyText::new(raw)?))
+            }
         }
-        _ => Ok(()),
+        Value::Number(number) => number
+            .as_f64()
+            .map(RunDimensionValue::Numeric)
+            .ok_or_else(|| invalid_input("numeric dimension values must fit into f64")),
+        Value::Bool(value) => Ok(RunDimensionValue::Boolean(value)),
+        _ => Err(invalid_input(
+            "dimension values must be string, number, boolean, or RFC3339 timestamp",
+        )),
     }
 }
 
-fn parse_metric_value(raw: String) -> Result<MetricValue, StoreError> {
-    let Some((key, value)) = raw.split_once('=') else {
-        return Err(invalid_input("metrics must look like key=value"));
-    };
-    Ok(MetricValue {
-        key: NonEmptyText::new(key)?,
-        value: value
-            .parse::<f64>()
-            .map_err(|error| invalid_input(format!("invalid metric value: {error}")))?,
-    })
-}
-
-fn coerce_cli_dimension_filters(
-    store: &ProjectStore,
-    raw_dimensions: Vec<String>,
-) -> Result<BTreeMap<NonEmptyText, fidget_spinner_core::RunDimensionValue>, StoreError> {
-    let definitions = store
-        .list_run_dimensions()?
-        .into_iter()
-        .map(|summary| (summary.key.to_string(), summary.value_type))
-        .collect::<BTreeMap<_, _>>();
-    let raw_dimensions = parse_dimension_assignments(raw_dimensions)?
-        .into_iter()
-        .map(|(key, raw_value)| {
-            let Some(value_type) = definitions.get(&key) else {
-                return Err(invalid_input(format!(
-                    "unknown run dimension `{key}`; register it first"
-                )));
-            };
-            Ok((key, parse_cli_dimension_value(*value_type, &raw_value)?))
-        })
-        .collect::<Result<BTreeMap<_, _>, StoreError>>()?;
-    store.coerce_run_dimensions(raw_dimensions)
-}
-
-fn parse_dimension_assignments(
-    raw_dimensions: Vec<String>,
-) -> Result<BTreeMap<String, String>, StoreError> {
-    raw_dimensions
+fn to_non_empty_texts(values: Vec<String>) -> Result<Vec<NonEmptyText>, StoreError> {
+    values
         .into_iter()
-        .map(|raw| {
-            let Some((key, value)) = raw.split_once('=') else {
-                return Err(invalid_input("dimensions must look like key=value"));
-            };
-            Ok((key.to_owned(), value.to_owned()))
-        })
-        .collect()
+        .map(NonEmptyText::new)
+        .collect::<Result<Vec<_>, _>>()
+        .map_err(StoreError::from)
 }
 
-fn parse_cli_dimension_value(value_type: FieldValueType, raw: &str) -> Result<Value, StoreError> {
-    match value_type {
-        FieldValueType::String | FieldValueType::Timestamp => Ok(Value::String(raw.to_owned())),
-        FieldValueType::Numeric => Ok(json!(raw.parse::<f64>().map_err(|error| {
-            invalid_input(format!("invalid numeric dimension value: {error}"))
-        })?)),
-        FieldValueType::Boolean => match raw {
-            "true" => Ok(Value::Bool(true)),
-            "false" => Ok(Value::Bool(false)),
-            other => Err(invalid_input(format!(
-                "invalid boolean dimension value `{other}`"
-            ))),
-        },
+fn load_optional_json<T: for<'de> serde::Deserialize<'de>>(
+    inline: Option<String>,
+    file: Option<PathBuf>,
+) -> Result<Option<T>, StoreError> {
+    match (inline, file) {
+        (Some(raw), None) => serde_json::from_str(&raw)
+            .map(Some)
+            .map_err(StoreError::from),
+        (None, Some(path)) => serde_json::from_slice(&fs::read(path)?)
+            .map(Some)
+            .map_err(StoreError::from),
+        (None, None) => Ok(None),
+        (Some(_), Some(_)) => Err(invalid_input(
+            "use only one of --outcome-json or --outcome-file",
+        )),
     }
 }
 
-fn parse_metric_unit(raw: &str) -> Result<MetricUnit, StoreError> {
-    match raw {
-        "seconds" => Ok(MetricUnit::Seconds),
-        "bytes" => Ok(MetricUnit::Bytes),
-        "count" => Ok(MetricUnit::Count),
-        "ratio" => Ok(MetricUnit::Ratio),
-        "custom" => Ok(MetricUnit::Custom),
-        other => Err(invalid_input(format!("unknown metric unit `{other}`"))),
+const fn archive_patch(state: Option<CliArchivePatch>) -> Option<bool> {
+    match state {
+        None => None,
+        Some(CliArchivePatch::Archive) => Some(true),
+        Some(CliArchivePatch::Restore) => Some(false),
     }
 }
 
-fn parse_optimization_objective(raw: &str) -> Result<OptimizationObjective, StoreError> {
-    match raw {
-        "minimize" => Ok(OptimizationObjective::Minimize),
-        "maximize" => Ok(OptimizationObjective::Maximize),
-        "target" => Ok(OptimizationObjective::Target),
-        other => Err(invalid_input(format!(
-            "unknown optimization objective `{other}`"
-        ))),
+fn cli_text_patch(
+    value: Option<String>,
+    clear: bool,
+) -> Result<Option<TextPatch<NonEmptyText>>, StoreError> {
+    if clear {
+        if value.is_some() {
+            return Err(invalid_input("cannot set and clear the same field"));
+        }
+        return Ok(Some(TextPatch::Clear));
     }
+    value
+        .map(NonEmptyText::new)
+        .transpose()
+        .map(|value| value.map(TextPatch::Set))
+        .map_err(StoreError::from)
 }
 
-fn parse_node_id(raw: &str) -> Result<fidget_spinner_core::NodeId, StoreError> {
-    Ok(fidget_spinner_core::NodeId::from_uuid(Uuid::parse_str(
-        raw,
-    )?))
-}
-
-fn parse_frontier_id(raw: &str) -> Result<fidget_spinner_core::FrontierId, StoreError> {
-    Ok(fidget_spinner_core::FrontierId::from_uuid(Uuid::parse_str(
-        raw,
-    )?))
+fn invalid_input(message: impl Into<String>) -> StoreError {
+    StoreError::InvalidInput(message.into())
 }
 
-fn parse_experiment_id(raw: &str) -> Result<fidget_spinner_core::ExperimentId, StoreError> {
-    Ok(fidget_spinner_core::ExperimentId::from_uuid(
-        Uuid::parse_str(raw)?,
-    ))
+pub(crate) fn to_pretty_json(value: &impl Serialize) -> Result<String, StoreError> {
+    serde_json::to_string_pretty(value).map_err(StoreError::from)
 }
 
-fn print_json<T: Serialize>(value: &T) -> Result<(), StoreError> {
+fn print_json(value: &impl Serialize) -> Result<(), StoreError> {
     println!("{}", to_pretty_json(value)?);
     Ok(())
 }
 
-fn to_pretty_json<T: Serialize>(value: &T) -> Result<String, StoreError> {
-    serde_json::to_string_pretty(value).map_err(StoreError::from)
-}
-
-fn invalid_input(message: impl Into<String>) -> StoreError {
-    StoreError::Json(serde_json::Error::io(std::io::Error::new(
-        std::io::ErrorKind::InvalidInput,
-        message.into(),
-    )))
-}
-
-impl From<CliNodeClass> for NodeClass {
-    fn from(value: CliNodeClass) -> Self {
-        match value {
-            CliNodeClass::Contract => Self::Contract,
-            CliNodeClass::Hypothesis => Self::Hypothesis,
-            CliNodeClass::Run => Self::Run,
-            CliNodeClass::Analysis => Self::Analysis,
-            CliNodeClass::Decision => Self::Decision,
-            CliNodeClass::Source => Self::Source,
-            CliNodeClass::Note => Self::Note,
-        }
-    }
-}
-
 impl From<CliMetricUnit> for MetricUnit {
     fn from(value: CliMetricUnit) -> Self {
         match value {
@@ -1715,33 +1418,32 @@ impl From<CliOptimizationObjective> for OptimizationObjective {
     }
 }
 
-impl From<CliExecutionBackend> for ExecutionBackend {
-    fn from(value: CliExecutionBackend) -> Self {
+impl From<CliMetricVisibility> for MetricVisibility {
+    fn from(value: CliMetricVisibility) -> Self {
         match value {
-            CliExecutionBackend::Local => Self::LocalProcess,
-            CliExecutionBackend::Worktree => Self::WorktreeProcess,
-            CliExecutionBackend::Ssh => Self::SshProcess,
+            CliMetricVisibility::Canonical => Self::Canonical,
+            CliMetricVisibility::Minor => Self::Minor,
+            CliMetricVisibility::Hidden => Self::Hidden,
+            CliMetricVisibility::Archived => Self::Archived,
         }
     }
 }
 
-impl From<CliMetricSource> for MetricFieldSource {
-    fn from(value: CliMetricSource) -> Self {
+impl From<CliMetricScope> for MetricScope {
+    fn from(value: CliMetricScope) -> Self {
         match value {
-            CliMetricSource::RunMetric => Self::RunMetric,
-            CliMetricSource::HypothesisPayload => Self::HypothesisPayload,
-            CliMetricSource::RunPayload => Self::RunPayload,
-            CliMetricSource::AnalysisPayload => Self::AnalysisPayload,
-            CliMetricSource::DecisionPayload => Self::DecisionPayload,
+            CliMetricScope::Live => Self::Live,
+            CliMetricScope::Visible => Self::Visible,
+            CliMetricScope::All => Self::All,
         }
     }
 }
 
-impl From<CliMetricOrder> for MetricRankOrder {
-    fn from(value: CliMetricOrder) -> Self {
+impl From<CliMetricRankOrder> for MetricRankOrder {
+    fn from(value: CliMetricRankOrder) -> Self {
         match value {
-            CliMetricOrder::Asc => Self::Asc,
-            CliMetricOrder::Desc => Self::Desc,
+            CliMetricRankOrder::Asc => Self::Asc,
+            CliMetricRankOrder::Desc => Self::Desc,
         }
     }
 }
@@ -1757,42 +1459,28 @@ impl From<CliFieldValueType> for FieldValueType {
     }
 }
 
-impl From<CliDiagnosticSeverity> for DiagnosticSeverity {
-    fn from(value: CliDiagnosticSeverity) -> Self {
-        match value {
-            CliDiagnosticSeverity::Error => Self::Error,
-            CliDiagnosticSeverity::Warning => Self::Warning,
-            CliDiagnosticSeverity::Info => Self::Info,
-        }
-    }
-}
-
-impl From<CliFieldPresence> for FieldPresence {
-    fn from(value: CliFieldPresence) -> Self {
-        match value {
-            CliFieldPresence::Required => Self::Required,
-            CliFieldPresence::Recommended => Self::Recommended,
-            CliFieldPresence::Optional => Self::Optional,
-        }
-    }
-}
-
-impl From<CliFieldRole> for FieldRole {
-    fn from(value: CliFieldRole) -> Self {
+impl From<CliArtifactKind> for ArtifactKind {
+    fn from(value: CliArtifactKind) -> Self {
         match value {
-            CliFieldRole::Index => Self::Index,
-            CliFieldRole::ProjectionGate => Self::ProjectionGate,
-            CliFieldRole::RenderOnly => Self::RenderOnly,
-            CliFieldRole::Opaque => Self::Opaque,
+            CliArtifactKind::Document => Self::Document,
+            CliArtifactKind::Link => Self::Link,
+            CliArtifactKind::Log => Self::Log,
+            CliArtifactKind::Table => Self::Table,
+            CliArtifactKind::Plot => Self::Plot,
+            CliArtifactKind::Dump => Self::Dump,
+            CliArtifactKind::Binary => Self::Binary,
+            CliArtifactKind::Other => Self::Other,
         }
     }
 }
 
-impl From<CliInferencePolicy> for InferencePolicy {
-    fn from(value: CliInferencePolicy) -> Self {
+impl From<CliExecutionBackend> for ExecutionBackend {
+    fn from(value: CliExecutionBackend) -> Self {
         match value {
-            CliInferencePolicy::ManualOnly => Self::ManualOnly,
-            CliInferencePolicy::ModelMayInfer => Self::ModelMayInfer,
+            CliExecutionBackend::Manual => Self::Manual,
+            CliExecutionBackend::LocalProcess => Self::LocalProcess,
+            CliExecutionBackend::WorktreeProcess => Self::WorktreeProcess,
+            CliExecutionBackend::SshProcess => Self::SshProcess,
         }
     }
 }
@@ -1808,89 +1496,11 @@ impl From<CliFrontierVerdict> for FrontierVerdict {
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use super::resolve_ui_project_root;
-    use std::fs;
-
-    use camino::Utf8PathBuf;
-    use fidget_spinner_core::NonEmptyText;
-    use fidget_spinner_store_sqlite::{
-        PROJECT_CONFIG_NAME, ProjectStore, STORE_DIR_NAME, StoreError,
-    };
-
-    fn temp_project_root(label: &str) -> Utf8PathBuf {
-        let mut path = std::env::temp_dir();
-        path.push(format!(
-            "fidget_spinner_cli_test_{}_{}",
-            label,
-            uuid::Uuid::now_v7()
-        ));
-        Utf8PathBuf::from(path.to_string_lossy().into_owned())
-    }
-
-    #[test]
-    fn ui_resolver_accepts_state_root_and_descendants() -> Result<(), StoreError> {
-        let project_root = temp_project_root("ui_resolve_state_root");
-        let _store = ProjectStore::init(
-            &project_root,
-            NonEmptyText::new("ui dogfood")?,
-            NonEmptyText::new("local.ui")?,
-        )?;
-        let state_root = project_root.join(STORE_DIR_NAME);
-        let config_path = state_root.join(PROJECT_CONFIG_NAME);
-
-        assert_eq!(resolve_ui_project_root(&state_root)?, project_root);
-        assert_eq!(resolve_ui_project_root(&config_path)?, project_root);
-        Ok(())
-    }
-
-    #[test]
-    fn ui_resolver_accepts_unique_descendant_store_from_parent() -> Result<(), StoreError> {
-        let parent_root = temp_project_root("ui_resolve_parent");
-        let nested_project = parent_root.join("nested/libgrid");
-        fs::create_dir_all(nested_project.as_std_path())?;
-        let _store = ProjectStore::init(
-            &nested_project,
-            NonEmptyText::new("nested ui dogfood")?,
-            NonEmptyText::new("local.nested.ui")?,
-        )?;
-
-        assert_eq!(resolve_ui_project_root(&parent_root)?, nested_project);
-        Ok(())
-    }
-
-    #[test]
-    fn ui_resolver_rejects_ambiguous_descendant_stores() -> Result<(), StoreError> {
-        let parent_root = temp_project_root("ui_resolve_ambiguous");
-        let alpha_project = parent_root.join("alpha");
-        let beta_project = parent_root.join("beta");
-        fs::create_dir_all(alpha_project.as_std_path())?;
-        fs::create_dir_all(beta_project.as_std_path())?;
-        let _alpha = ProjectStore::init(
-            &alpha_project,
-            NonEmptyText::new("alpha")?,
-            NonEmptyText::new("local.alpha")?,
-        )?;
-        let _beta = ProjectStore::init(
-            &beta_project,
-            NonEmptyText::new("beta")?,
-            NonEmptyText::new("local.beta")?,
-        )?;
-
-        let error = match resolve_ui_project_root(&parent_root) {
-            Ok(project_root) => {
-                return Err(StoreError::Io(std::io::Error::other(format!(
-                    "expected ambiguous descendant discovery failure, got {project_root}"
-                ))));
-            }
-            Err(error) => error,
-        };
-        assert!(
-            error
-                .to_string()
-                .contains("multiple descendant project stores")
-        );
-        Ok(())
+impl From<CliExperimentStatus> for ExperimentStatus {
+    fn from(value: CliExperimentStatus) -> Self {
+        match value {
+            CliExperimentStatus::Open => Self::Open,
+            CliExperimentStatus::Closed => Self::Closed,
+        }
     }
 }