vgxness 0.1.0

package/dist/memory/sqlite/migrations/006_run_operation_attempts.sql

@@ -0,0 +1,32 @@
+CREATE TABLE IF NOT EXISTS run_operation_attempts (
+  id TEXT PRIMARY KEY,
+  run_id TEXT NOT NULL REFERENCES runs(id) ON DELETE CASCADE,
+  approval_id TEXT REFERENCES run_approvals(id) ON DELETE CASCADE,
+  decision_event_id TEXT NOT NULL REFERENCES run_events(id) ON DELETE CASCADE,
+  pending_execution_event_id TEXT REFERENCES run_events(id) ON DELETE CASCADE,
+  category TEXT NOT NULL,
+  operation TEXT NOT NULL,
+  operation_json TEXT NOT NULL,
+  executor_name TEXT NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('reserved', 'succeeded', 'failed', 'abandoned')),
+  result_event_id TEXT REFERENCES run_events(id) ON DELETE SET NULL,
+  output_json TEXT,
+  error_json TEXT,
+  reserved_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  completed_at TEXT,
+  CHECK (
+    (status = 'reserved' AND completed_at IS NULL)
+    OR (status IN ('succeeded', 'failed', 'abandoned') AND completed_at IS NOT NULL)
+  )
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS run_operation_attempts_approval_once_idx
+  ON run_operation_attempts(approval_id)
+  WHERE approval_id IS NOT NULL;
+
+CREATE INDEX IF NOT EXISTS run_operation_attempts_run_reserved_idx
+  ON run_operation_attempts(run_id, reserved_at DESC);
+
+CREATE INDEX IF NOT EXISTS run_operation_attempts_decision_event_idx
+  ON run_operation_attempts(decision_event_id);

package/dist/memory/sqlite/migrations/007_abandoned_operation_attempts.sql

@@ -0,0 +1,46 @@
+CREATE TABLE IF NOT EXISTS run_operation_attempts_v2 (
+  id TEXT PRIMARY KEY,
+  run_id TEXT NOT NULL REFERENCES runs(id) ON DELETE CASCADE,
+  approval_id TEXT REFERENCES run_approvals(id) ON DELETE CASCADE,
+  decision_event_id TEXT NOT NULL REFERENCES run_events(id) ON DELETE CASCADE,
+  pending_execution_event_id TEXT REFERENCES run_events(id) ON DELETE CASCADE,
+  category TEXT NOT NULL,
+  operation TEXT NOT NULL,
+  operation_json TEXT NOT NULL,
+  executor_name TEXT NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('reserved', 'succeeded', 'failed', 'abandoned')),
+  result_event_id TEXT REFERENCES run_events(id) ON DELETE SET NULL,
+  output_json TEXT,
+  error_json TEXT,
+  reserved_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  completed_at TEXT,
+  CHECK (
+    (status = 'reserved' AND completed_at IS NULL)
+    OR (status IN ('succeeded', 'failed', 'abandoned') AND completed_at IS NOT NULL)
+  )
+);
+
+INSERT OR IGNORE INTO run_operation_attempts_v2(
+  id, run_id, approval_id, decision_event_id, pending_execution_event_id,
+  category, operation, operation_json, executor_name, status, result_event_id,
+  output_json, error_json, reserved_at, updated_at, completed_at
+)
+SELECT
+  id, run_id, approval_id, decision_event_id, pending_execution_event_id,
+  category, operation, operation_json, executor_name, status, result_event_id,
+  output_json, error_json, reserved_at, updated_at, completed_at
+FROM run_operation_attempts;
+
+DROP TABLE run_operation_attempts;
+ALTER TABLE run_operation_attempts_v2 RENAME TO run_operation_attempts;
+
+CREATE UNIQUE INDEX IF NOT EXISTS run_operation_attempts_approval_once_idx
+  ON run_operation_attempts(approval_id)
+  WHERE approval_id IS NOT NULL;
+
+CREATE INDEX IF NOT EXISTS run_operation_attempts_run_reserved_idx
+  ON run_operation_attempts(run_id, reserved_at DESC);
+
+CREATE INDEX IF NOT EXISTS run_operation_attempts_decision_event_idx
+  ON run_operation_attempts(decision_event_id);

package/dist/memory/sqlite/migrations/008_run_execution_plan_events.sql

@@ -0,0 +1,105 @@
+CREATE TABLE run_events_with_execution_plan (
+  id TEXT PRIMARY KEY,
+  run_id TEXT NOT NULL REFERENCES runs(id) ON DELETE CASCADE,
+  sequence INTEGER NOT NULL,
+  kind TEXT NOT NULL CHECK (kind IN ('timeline', 'evidence', 'memory-operation', 'artifact-reference', 'tool-call', 'permission-decision', 'execution-plan', 'operation-execution', 'approval', 'verification')),
+  title TEXT NOT NULL,
+  payload_json TEXT NOT NULL,
+  related_type TEXT,
+  related_id TEXT,
+  created_at TEXT NOT NULL,
+  UNIQUE(run_id, sequence)
+);
+
+INSERT INTO run_events_with_execution_plan(id, run_id, sequence, kind, title, payload_json, related_type, related_id, created_at)
+SELECT id, run_id, sequence, kind, title, payload_json, related_type, related_id, created_at
+FROM run_events;
+
+CREATE TEMP TABLE run_approvals_008_backup AS
+SELECT * FROM run_approvals;
+
+CREATE TEMP TABLE run_operation_attempts_008_backup AS
+SELECT * FROM run_operation_attempts;
+
+DROP TABLE run_operation_attempts;
+DROP TABLE run_approvals;
+DROP TABLE run_events;
+ALTER TABLE run_events_with_execution_plan RENAME TO run_events;
+
+CREATE INDEX IF NOT EXISTS run_events_run_sequence_idx
+  ON run_events(run_id, sequence);
+
+CREATE INDEX IF NOT EXISTS run_events_related_idx
+  ON run_events(related_type, related_id);
+
+CREATE TABLE run_approvals (
+  id TEXT PRIMARY KEY,
+  run_id TEXT NOT NULL REFERENCES runs(id) ON DELETE CASCADE,
+  decision_event_id TEXT NOT NULL REFERENCES run_events(id) ON DELETE CASCADE,
+  status TEXT NOT NULL CHECK (status IN ('pending', 'approved', 'rejected', 'cancelled')),
+  requested_at TEXT NOT NULL,
+  resolved_at TEXT,
+  resolved_by TEXT,
+  resolution_reason TEXT,
+  CHECK (
+    (status = 'pending' AND resolved_at IS NULL AND resolved_by IS NULL AND resolution_reason IS NULL)
+    OR (status IN ('approved', 'rejected', 'cancelled') AND resolved_at IS NOT NULL AND resolved_by IS NOT NULL)
+  )
+);
+
+INSERT INTO run_approvals(id, run_id, decision_event_id, status, requested_at, resolved_at, resolved_by, resolution_reason)
+SELECT id, run_id, decision_event_id, status, requested_at, resolved_at, resolved_by, resolution_reason
+FROM run_approvals_008_backup;
+
+CREATE UNIQUE INDEX IF NOT EXISTS run_approvals_decision_event_idx
+  ON run_approvals(decision_event_id);
+
+CREATE INDEX IF NOT EXISTS run_approvals_run_status_idx
+  ON run_approvals(run_id, status, requested_at DESC);
+
+CREATE TABLE run_operation_attempts (
+  id TEXT PRIMARY KEY,
+  run_id TEXT NOT NULL REFERENCES runs(id) ON DELETE CASCADE,
+  approval_id TEXT REFERENCES run_approvals(id) ON DELETE CASCADE,
+  decision_event_id TEXT NOT NULL REFERENCES run_events(id) ON DELETE CASCADE,
+  pending_execution_event_id TEXT REFERENCES run_events(id) ON DELETE CASCADE,
+  category TEXT NOT NULL,
+  operation TEXT NOT NULL,
+  operation_json TEXT NOT NULL,
+  executor_name TEXT NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('reserved', 'succeeded', 'failed', 'abandoned')),
+  result_event_id TEXT REFERENCES run_events(id) ON DELETE SET NULL,
+  output_json TEXT,
+  error_json TEXT,
+  reserved_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  completed_at TEXT,
+  CHECK (
+    (status = 'reserved' AND completed_at IS NULL)
+    OR (status IN ('succeeded', 'failed', 'abandoned') AND completed_at IS NOT NULL)
+  )
+);
+
+INSERT INTO run_operation_attempts(
+  id, run_id, approval_id, decision_event_id, pending_execution_event_id,
+  category, operation, operation_json, executor_name, status, result_event_id,
+  output_json, error_json, reserved_at, updated_at, completed_at
+)
+SELECT
+  id, run_id, approval_id, decision_event_id, pending_execution_event_id,
+  category, operation, operation_json, executor_name, status, result_event_id,
+  output_json, error_json, reserved_at, updated_at, completed_at
+FROM run_operation_attempts_008_backup;
+
+CREATE UNIQUE INDEX IF NOT EXISTS run_operation_attempts_approval_once_idx
+  ON run_operation_attempts(approval_id)
+  WHERE approval_id IS NOT NULL;
+
+CREATE INDEX IF NOT EXISTS run_operation_attempts_run_reserved_idx
+  ON run_operation_attempts(run_id, reserved_at DESC);
+
+CREATE INDEX IF NOT EXISTS run_operation_attempts_decision_event_idx
+  ON run_operation_attempts(decision_event_id);
+
+DROP TABLE run_operation_attempts_008_backup;
+DROP TABLE run_approvals_008_backup;

package/dist/memory/sqlite/migrations/009_multiple_operation_attempts.sql

@@ -0,0 +1,73 @@
+CREATE TABLE run_operation_attempts_v3 (
+  id TEXT PRIMARY KEY,
+  run_id TEXT NOT NULL REFERENCES runs(id) ON DELETE CASCADE,
+  approval_id TEXT REFERENCES run_approvals(id) ON DELETE CASCADE,
+  attempt_sequence INTEGER NOT NULL CHECK (attempt_sequence >= 1),
+  decision_event_id TEXT NOT NULL REFERENCES run_events(id) ON DELETE CASCADE,
+  pending_execution_event_id TEXT REFERENCES run_events(id) ON DELETE CASCADE,
+  category TEXT NOT NULL,
+  operation TEXT NOT NULL,
+  operation_json TEXT NOT NULL,
+  executor_name TEXT NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('reserved', 'succeeded', 'failed', 'abandoned')),
+  result_event_id TEXT REFERENCES run_events(id) ON DELETE SET NULL,
+  output_json TEXT,
+  error_json TEXT,
+  reserved_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  completed_at TEXT,
+  CHECK (
+    (status = 'reserved' AND completed_at IS NULL)
+    OR (status IN ('succeeded', 'failed', 'abandoned') AND completed_at IS NOT NULL)
+  ),
+  UNIQUE(approval_id, attempt_sequence)
+);
+
+INSERT INTO run_operation_attempts_v3(
+  id, run_id, approval_id, attempt_sequence, decision_event_id, pending_execution_event_id,
+  category, operation, operation_json, executor_name, status, result_event_id,
+  output_json, error_json, reserved_at, updated_at, completed_at
+)
+SELECT
+  id,
+  run_id,
+  approval_id,
+  CASE
+    WHEN approval_id IS NULL THEN 1
+    ELSE ROW_NUMBER() OVER (PARTITION BY approval_id ORDER BY reserved_at ASC, id ASC)
+  END AS attempt_sequence,
+  decision_event_id,
+  pending_execution_event_id,
+  category,
+  operation,
+  operation_json,
+  executor_name,
+  status,
+  result_event_id,
+  output_json,
+  error_json,
+  reserved_at,
+  updated_at,
+  completed_at
+FROM run_operation_attempts;
+
+DROP TABLE run_operation_attempts;
+ALTER TABLE run_operation_attempts_v3 RENAME TO run_operation_attempts;
+
+CREATE UNIQUE INDEX IF NOT EXISTS run_operation_attempts_approval_sequence_idx
+  ON run_operation_attempts(approval_id, attempt_sequence)
+  WHERE approval_id IS NOT NULL;
+
+CREATE UNIQUE INDEX IF NOT EXISTS run_operation_attempts_approval_reserved_once_idx
+  ON run_operation_attempts(approval_id)
+  WHERE approval_id IS NOT NULL AND status = 'reserved';
+
+CREATE INDEX IF NOT EXISTS run_operation_attempts_run_reserved_idx
+  ON run_operation_attempts(run_id, reserved_at DESC);
+
+CREATE INDEX IF NOT EXISTS run_operation_attempts_decision_event_idx
+  ON run_operation_attempts(decision_event_id);
+
+CREATE INDEX IF NOT EXISTS run_operation_attempts_approval_order_idx
+  ON run_operation_attempts(approval_id, attempt_sequence ASC)
+  WHERE approval_id IS NOT NULL;

package/dist/memory/sqlite/migrations/010_skill_registry.sql

@@ -0,0 +1,66 @@
+CREATE TABLE IF NOT EXISTS skills (
+  id TEXT PRIMARY KEY,
+  project TEXT NOT NULL,
+  scope TEXT NOT NULL CHECK (scope IN ('project', 'personal')),
+  name TEXT NOT NULL,
+  description TEXT NOT NULL,
+  current_version_id TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  UNIQUE(project, scope, name),
+  FOREIGN KEY(current_version_id) REFERENCES skill_versions(id) ON DELETE SET NULL
+);
+
+CREATE TABLE IF NOT EXISTS skill_versions (
+  id TEXT PRIMARY KEY,
+  skill_id TEXT NOT NULL REFERENCES skills(id) ON DELETE CASCADE,
+  version TEXT NOT NULL,
+  source_kind TEXT NOT NULL CHECK (source_kind IN ('path', 'url', 'inline')),
+  source_path TEXT,
+  source_url TEXT,
+  source_inline_metadata_json TEXT,
+  compatibility_json TEXT NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('draft', 'active', 'deprecated', 'archived')),
+  created_at TEXT NOT NULL,
+  UNIQUE(skill_id, version),
+  CHECK (
+    (source_kind = 'path' AND source_path IS NOT NULL AND source_url IS NULL)
+    OR (source_kind = 'url' AND source_url IS NOT NULL AND source_path IS NULL)
+    OR (source_kind = 'inline' AND source_path IS NULL AND source_url IS NULL)
+  )
+);
+
+CREATE TABLE IF NOT EXISTS skill_attachments (
+  id TEXT PRIMARY KEY,
+  skill_id TEXT NOT NULL REFERENCES skills(id) ON DELETE CASCADE,
+  version_id TEXT REFERENCES skill_versions(id) ON DELETE SET NULL,
+  target_type TEXT NOT NULL CHECK (target_type IN ('agent', 'subagent', 'workflow-phase', 'provider-adapter')),
+  target_key TEXT NOT NULL,
+  metadata_json TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  UNIQUE(skill_id, target_type, target_key)
+);
+
+CREATE TABLE IF NOT EXISTS skill_usage_records (
+  id TEXT PRIMARY KEY,
+  skill_id TEXT NOT NULL REFERENCES skills(id) ON DELETE CASCADE,
+  version_id TEXT REFERENCES skill_versions(id) ON DELETE SET NULL,
+  run_id TEXT,
+  target_type TEXT CHECK (target_type IN ('agent', 'subagent', 'workflow-phase', 'provider-adapter')),
+  target_key TEXT,
+  outcome TEXT NOT NULL CHECK (outcome IN ('selected', 'injected', 'helped', 'failed', 'neutral')),
+  notes TEXT,
+  created_at TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS skills_project_scope_name_idx
+  ON skills(project, scope, name);
+
+CREATE INDEX IF NOT EXISTS skill_versions_skill_created_idx
+  ON skill_versions(skill_id, created_at DESC);
+
+CREATE INDEX IF NOT EXISTS skill_attachments_target_idx
+  ON skill_attachments(target_type, target_key);
+
+CREATE INDEX IF NOT EXISTS skill_usage_records_run_idx
+  ON skill_usage_records(run_id, created_at DESC);

package/dist/memory/sqlite/migrations/011_skill_usage_resolution_outcomes.sql

@@ -0,0 +1,21 @@
+CREATE TABLE IF NOT EXISTS skill_usage_records_next (
+  id TEXT PRIMARY KEY,
+  skill_id TEXT NOT NULL REFERENCES skills(id) ON DELETE CASCADE,
+  version_id TEXT REFERENCES skill_versions(id) ON DELETE SET NULL,
+  run_id TEXT,
+  target_type TEXT CHECK (target_type IN ('agent', 'subagent', 'workflow-phase', 'provider-adapter')),
+  target_key TEXT,
+  outcome TEXT NOT NULL CHECK (outcome IN ('selected', 'injected', 'helped', 'failed', 'neutral')),
+  notes TEXT,
+  created_at TEXT NOT NULL
+);
+
+INSERT INTO skill_usage_records_next(id, skill_id, version_id, run_id, target_type, target_key, outcome, notes, created_at)
+SELECT id, skill_id, version_id, run_id, target_type, target_key, outcome, notes, created_at
+FROM skill_usage_records;
+
+DROP TABLE skill_usage_records;
+ALTER TABLE skill_usage_records_next RENAME TO skill_usage_records;
+
+CREATE INDEX IF NOT EXISTS skill_usage_records_run_idx
+  ON skill_usage_records(run_id, created_at DESC);

package/dist/memory/sqlite/migrations/012_skill_improvement_proposals.sql

@@ -0,0 +1,37 @@
+CREATE TABLE IF NOT EXISTS skill_improvement_proposals (
+  id TEXT PRIMARY KEY,
+  skill_id TEXT NOT NULL REFERENCES skills(id) ON DELETE CASCADE,
+  base_version_id TEXT NOT NULL REFERENCES skill_versions(id) ON DELETE CASCADE,
+  proposed_version TEXT NOT NULL,
+  proposed_source_kind TEXT NOT NULL CHECK (proposed_source_kind IN ('path', 'url', 'inline')),
+  proposed_source_path TEXT,
+  proposed_source_url TEXT,
+  proposed_source_inline_metadata_json TEXT,
+  proposed_compatibility_json TEXT NOT NULL,
+  rationale TEXT NOT NULL,
+  source_signal_json TEXT NOT NULL,
+  diff_summary_json TEXT NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('draft', 'pending-approval', 'approved', 'rejected', 'cancelled', 'applied')),
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  submitted_at TEXT,
+  submitted_by TEXT,
+  resolved_at TEXT,
+  resolved_by TEXT,
+  resolution_reason TEXT,
+  applied_at TEXT,
+  applied_by TEXT,
+  apply_reason TEXT,
+  applied_version_id TEXT REFERENCES skill_versions(id) ON DELETE SET NULL,
+  CHECK (
+    (proposed_source_kind = 'path' AND proposed_source_path IS NOT NULL AND proposed_source_url IS NULL)
+    OR (proposed_source_kind = 'url' AND proposed_source_url IS NOT NULL AND proposed_source_path IS NULL)
+    OR (proposed_source_kind = 'inline' AND proposed_source_path IS NULL AND proposed_source_url IS NULL)
+  )
+);
+
+CREATE INDEX IF NOT EXISTS skill_improvement_proposals_skill_status_idx
+  ON skill_improvement_proposals(skill_id, status, created_at DESC);
+
+CREATE INDEX IF NOT EXISTS skill_improvement_proposals_base_version_idx
+  ON skill_improvement_proposals(base_version_id, created_at DESC);

package/dist/memory/sqlite/migrations/013_skill_evaluation_scenarios.sql

@@ -0,0 +1,43 @@
+CREATE TABLE IF NOT EXISTS skill_evaluation_scenarios (
+  id TEXT PRIMARY KEY,
+  skill_id TEXT NOT NULL REFERENCES skills(id) ON DELETE CASCADE,
+  name TEXT NOT NULL,
+  normalized_name TEXT NOT NULL,
+  criteria_json TEXT NOT NULL,
+  proposal_id TEXT REFERENCES skill_improvement_proposals(id) ON DELETE SET NULL,
+  proposal_context_key TEXT NOT NULL,
+  version_id TEXT REFERENCES skill_versions(id) ON DELETE SET NULL,
+  version_context_key TEXT NOT NULL,
+  created_by TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  UNIQUE(skill_id, normalized_name, proposal_context_key, version_context_key)
+);
+
+CREATE INDEX IF NOT EXISTS skill_evaluation_scenarios_skill_context_idx
+  ON skill_evaluation_scenarios(skill_id, proposal_context_key, version_context_key, normalized_name ASC);
+
+CREATE INDEX IF NOT EXISTS skill_evaluation_scenarios_proposal_idx
+  ON skill_evaluation_scenarios(proposal_id, normalized_name ASC);
+
+CREATE TABLE IF NOT EXISTS skill_evaluation_results (
+  id TEXT PRIMARY KEY,
+  scenario_id TEXT NOT NULL REFERENCES skill_evaluation_scenarios(id) ON DELETE CASCADE,
+  status TEXT NOT NULL CHECK (status IN ('passed', 'failed', 'needs-review', 'not-applicable')),
+  result_json TEXT NOT NULL,
+  observed_behavior TEXT NOT NULL,
+  evaluator TEXT NOT NULL,
+  proposal_id TEXT REFERENCES skill_improvement_proposals(id) ON DELETE SET NULL,
+  version_id TEXT REFERENCES skill_versions(id) ON DELETE SET NULL,
+  notes TEXT,
+  created_at TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS skill_evaluation_results_scenario_idx
+  ON skill_evaluation_results(scenario_id, created_at ASC, id ASC);
+
+CREATE INDEX IF NOT EXISTS skill_evaluation_results_proposal_idx
+  ON skill_evaluation_results(proposal_id, created_at ASC, id ASC);
+
+CREATE INDEX IF NOT EXISTS skill_evaluation_results_status_evaluator_idx
+  ON skill_evaluation_results(status, evaluator, created_at ASC, id ASC);

package/dist/memory/sqlite/migrations/014_manager_profile_overlays.sql

@@ -0,0 +1,14 @@
+CREATE TABLE IF NOT EXISTS manager_profile_overlays (
+  id TEXT PRIMARY KEY,
+  project TEXT NOT NULL,
+  scope TEXT NOT NULL CHECK (scope IN ('project', 'personal')),
+  manager_name TEXT NOT NULL,
+  instructions TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  UNIQUE(project, scope, manager_name),
+  CHECK (instructions IS NOT NULL AND length(trim(instructions)) > 0)
+);
+
+CREATE INDEX IF NOT EXISTS manager_profile_overlays_project_scope_idx
+  ON manager_profile_overlays(project, scope, manager_name);

package/dist/memory/storage-paths.js

@@ -0,0 +1,72 @@
+import { mkdirSync } from 'node:fs';
+import path, { dirname, resolve } from 'node:path';
+export function resolveMemoryDatabasePath(input) {
+    if (hasPathValue(input.explicitPath)) {
+        return { ok: true, value: { path: absolutePath(input.cwd, input.explicitPath), source: 'flag' } };
+    }
+    if (hasPathValue(input.env.VGXNESS_DB_PATH)) {
+        return { ok: true, value: { path: absolutePath(input.cwd, input.env.VGXNESS_DB_PATH), source: 'environment' } };
+    }
+    const globalPath = defaultGlobalMemoryDatabasePath({ env: input.env, platform: input.platform });
+    return globalPath.ok
+        ? { ok: true, value: { path: globalPath.value, source: 'global-default' } }
+        : globalPath;
+}
+export function defaultGlobalMemoryDatabasePath(input) {
+    const platform = input.platform ?? process.platform;
+    if (platform === 'darwin')
+        return homeRelativePath(input.env, ['Library', 'Application Support', 'vgxness', 'memory.sqlite']);
+    if (platform === 'win32')
+        return windowsAppDataPath(input.env);
+    return linuxDataPath(input.env);
+}
+export function prepareMemoryDatabasePath(databasePath) {
+    try {
+        mkdirSync(dirname(databasePath), { recursive: true });
+        return { ok: true, value: databasePath };
+    }
+    catch (cause) {
+        return {
+            ok: false,
+            error: {
+                code: 'store_unavailable',
+                message: `Unable to prepare local memory store directory at ${dirname(databasePath)}`,
+                cause,
+            },
+        };
+    }
+}
+function linuxDataPath(env) {
+    if (hasPathValue(env.XDG_DATA_HOME))
+        return { ok: true, value: path.join(env.XDG_DATA_HOME, 'vgxness', 'memory.sqlite') };
+    return homeRelativePath(env, ['.local', 'share', 'vgxness', 'memory.sqlite']);
+}
+function windowsAppDataPath(env) {
+    if (!hasPathValue(env.APPDATA))
+        return missingBase('APPDATA');
+    return { ok: true, value: path.win32.join(env.APPDATA, 'vgxness', 'memory.sqlite') };
+}
+function homeRelativePath(env, segments) {
+    const home = userHome(env);
+    if (!hasPathValue(home))
+        return missingBase('HOME');
+    return { ok: true, value: path.join(home, ...segments) };
+}
+function userHome(env) {
+    return env.HOME;
+}
+function missingBase(variable) {
+    return {
+        ok: false,
+        error: {
+            code: 'store_unavailable',
+            message: `Unable to resolve global memory store path because ${variable} is not set. Provide --db or VGXNESS_DB_PATH to select an explicit database.`,
+        },
+    };
+}
+function absolutePath(cwd, configuredPath) {
+    return path.isAbsolute(configuredPath) ? configuredPath : resolve(cwd, configuredPath);
+}
+function hasPathValue(value) {
+    return value !== undefined && value.trim().length > 0;
+}