@xopcai/xopc 0.0.189 → 0.0.190

package/dist/src/storage/sqlite/user-context-repository.js

@@ -0,0 +1,383 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
+import { USER_CONTEXT_PRINCIPAL_ID } from "../../user-context/domain.js";
+import { randomUUID } from "node:crypto";
+//#region src/storage/sqlite/user-context-repository.ts
+const UNDERSTANDING_SELECT = `
+  SELECT u.*, v.statement, v.payload_json
+  FROM user_understandings u
+  JOIN user_understanding_versions v ON v.version_id = u.current_version_id
+`;
+function scopeFromRow(type, id) {
+	return id ? {
+		type,
+		id
+	} : { type };
+}
+function understandingFromRow(row) {
+	return {
+		id: row.understanding_id,
+		kind: row.kind,
+		canonicalKey: row.canonical_key,
+		status: row.status,
+		scope: scopeFromRow(row.scope_type, row.scope_id),
+		explicitness: row.explicitness,
+		durability: row.durability,
+		sensitivity: row.sensitivity,
+		disclosurePolicy: row.disclosure_policy,
+		confidence: row.confidence,
+		statement: row.statement,
+		payload: JSON.parse(row.payload_json),
+		versionId: row.current_version_id,
+		...row.valid_from === null ? {} : { validFrom: row.valid_from },
+		...row.valid_to === null ? {} : { validTo: row.valid_to },
+		...row.expires_at === null ? {} : { expiresAt: row.expires_at },
+		...row.review_at === null ? {} : { reviewAt: row.review_at },
+		...row.conflict_group_id ? { conflictGroupId: row.conflict_group_id } : {},
+		...row.supersedes_id ? { supersedesId: row.supersedes_id } : {},
+		createdAt: row.created_at,
+		updatedAt: row.updated_at
+	};
+}
+function ruleFromRow(row) {
+	return {
+		id: row.rule_id,
+		category: row.category,
+		status: row.status,
+		priority: row.priority,
+		scope: scopeFromRow(row.scope_type, row.scope_id),
+		conditions: JSON.parse(row.conditions_json),
+		statement: row.statement,
+		revisionId: row.current_revision_id,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at
+	};
+}
+function getUserProfile(principalId = USER_CONTEXT_PRINCIPAL_ID) {
+	const row = getSqliteDatabase().prepare("SELECT * FROM user_profiles WHERE principal_id = ?").get(principalId);
+	if (!row) return {
+		callName: "",
+		role: "",
+		primaryGoal: "",
+		pronouns: "",
+		timezone: "",
+		locale: "",
+		accessibility: {},
+		createdAt: 0,
+		updatedAt: 0
+	};
+	return {
+		callName: row.call_name,
+		role: row.role,
+		primaryGoal: row.primary_goal,
+		pronouns: row.pronouns,
+		timezone: row.timezone,
+		locale: row.locale,
+		accessibility: JSON.parse(row.accessibility_json),
+		createdAt: row.created_at,
+		updatedAt: row.updated_at
+	};
+}
+function updateUserProfile(patch, principalId = USER_CONTEXT_PRINCIPAL_ID) {
+	const current = getUserProfile(principalId);
+	const now = Date.now();
+	const next = {
+		...current,
+		...patch,
+		createdAt: current.createdAt || now,
+		updatedAt: now
+	};
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`
+      INSERT INTO user_profiles (
+        principal_id, call_name, role, primary_goal, pronouns, timezone, locale, accessibility_json, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(principal_id) DO UPDATE SET
+        call_name = excluded.call_name,
+        role = excluded.role,
+        primary_goal = excluded.primary_goal,
+        pronouns = excluded.pronouns,
+        timezone = excluded.timezone,
+        locale = excluded.locale,
+        accessibility_json = excluded.accessibility_json,
+        updated_at = excluded.updated_at
+    `).run(principalId, next.callName, next.role, next.primaryGoal, next.pronouns, next.timezone, next.locale, JSON.stringify(next.accessibility), next.createdAt, next.updatedAt);
+	});
+	return next;
+}
+function createUnderstanding(input, principalId = USER_CONTEXT_PRINCIPAL_ID) {
+	const id = randomUUID();
+	const versionId = randomUUID();
+	const now = Date.now();
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`INSERT INTO user_understandings (
+      understanding_id, principal_id, kind, canonical_key, status, scope_type, scope_id,
+      explicitness, durability, sensitivity, disclosure_policy, confidence, valid_from,
+      valid_to, expires_at, review_at, current_version_id, conflict_group_id, supersedes_id,
+      created_at, updated_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, principalId, input.kind, input.canonicalKey, input.status, input.scope.type, input.scope.id ?? null, input.explicitness, input.durability, input.sensitivity, input.disclosurePolicy, input.confidence, input.validFrom ?? null, input.validTo ?? null, input.expiresAt ?? null, input.reviewAt ?? null, versionId, input.conflictGroupId ?? null, input.supersedesId ?? null, now, now);
+		db.prepare(`INSERT INTO user_understanding_versions (
+      version_id, understanding_id, statement, payload_json, created_by, change_reason, created_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?)`).run(versionId, id, input.statement.trim(), JSON.stringify(input.payload ?? {}), input.createdBy, input.changeReason, now);
+		db.prepare("INSERT INTO user_understanding_fts (statement, understanding_id, version_id) VALUES (?, ?, ?)").run(input.statement.trim(), id, versionId);
+	});
+	return getUnderstanding(id);
+}
+function getUnderstanding(id) {
+	const row = getSqliteDatabase().prepare(`${UNDERSTANDING_SELECT} WHERE u.understanding_id = ?`).get(id);
+	return row ? understandingFromRow(row) : void 0;
+}
+function listUnderstandings(statuses, principalId = USER_CONTEXT_PRINCIPAL_ID) {
+	const db = getSqliteDatabase();
+	if (!statuses?.length) return db.prepare(`${UNDERSTANDING_SELECT} WHERE u.principal_id = ? ORDER BY u.updated_at DESC`).all(principalId).map(understandingFromRow);
+	const placeholders = statuses.map(() => "?").join(", ");
+	return db.prepare(`${UNDERSTANDING_SELECT} WHERE u.principal_id = ? AND u.status IN (${placeholders}) ORDER BY u.updated_at DESC`).all(principalId, ...statuses).map(understandingFromRow);
+}
+function reviseUnderstanding(id, statement, options) {
+	const current = getUnderstanding(id);
+	if (!current) throw new Error(`User understanding not found: ${id}`);
+	const versionId = randomUUID();
+	const now = Date.now();
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`INSERT INTO user_understanding_versions (
+      version_id, understanding_id, statement, payload_json, created_by, change_reason, created_at
+    ) VALUES (?, ?, ?, ?, 'user', ?, ?)`).run(versionId, id, statement.trim(), JSON.stringify(options.payload ?? current.payload), options.changeReason, now);
+		db.prepare(`UPDATE user_understandings
+      SET current_version_id = ?, canonical_key = ?, explicitness = ?, confidence = ?, updated_at = ?
+      WHERE understanding_id = ?`).run(versionId, options.canonicalKey ?? current.canonicalKey, options.explicitness ?? current.explicitness, options.confidence ?? current.confidence, now, id);
+		db.prepare("DELETE FROM user_understanding_fts WHERE understanding_id = ?").run(id);
+		db.prepare("INSERT INTO user_understanding_fts (statement, understanding_id, version_id) VALUES (?, ?, ?)").run(statement.trim(), id, versionId);
+	});
+	return getUnderstanding(id);
+}
+function setUnderstandingStatus(id, status, confirmation) {
+	const now = Date.now();
+	getSqliteDatabase().prepare(`UPDATE user_understandings
+    SET status = ?,
+        explicitness = COALESCE(?, explicitness),
+        confidence = COALESCE(?, confidence),
+        updated_at = ?
+    WHERE understanding_id = ?`).run(status, confirmation?.explicitness ?? null, confirmation?.confidence ?? null, now, id);
+	const result = getUnderstanding(id);
+	if (!result) throw new Error(`User understanding not found: ${id}`);
+	return result;
+}
+function rejectUnderstanding(id, reason) {
+	const current = getUnderstanding(id);
+	if (!current) throw new Error(`User understanding not found: ${id}`);
+	const now = Date.now();
+	runSqliteWriteTransaction((db) => {
+		db.prepare("UPDATE user_understandings SET status = 'rejected', updated_at = ? WHERE understanding_id = ?").run(now, id);
+		db.prepare(`INSERT INTO context_suppressions (
+      suppression_id, principal_id, canonical_key, scope_type, scope_id, reason, expires_at, created_at
+    ) VALUES (?, ?, ?, ?, ?, ?, NULL, ?)
+    ON CONFLICT DO UPDATE SET reason = excluded.reason, expires_at = NULL`).run(randomUUID(), USER_CONTEXT_PRINCIPAL_ID, current.canonicalKey, current.scope.type, current.scope.id ?? null, reason, now);
+	});
+	return getUnderstanding(id);
+}
+function deleteUnderstanding(id) {
+	return runSqliteWriteTransaction((db) => {
+		db.prepare("DELETE FROM user_understanding_fts WHERE understanding_id = ?").run(id);
+		return Number(db.prepare("DELETE FROM user_understandings WHERE understanding_id = ?").run(id).changes) > 0;
+	});
+}
+function isUnderstandingSuppressed(canonicalKey, scope, principalId = USER_CONTEXT_PRINCIPAL_ID) {
+	const row = getSqliteDatabase().prepare(`SELECT 1 FROM context_suppressions
+    WHERE principal_id = ? AND canonical_key = ? AND scope_type = ?
+      AND COALESCE(scope_id, '') = COALESCE(?, '')
+      AND (expires_at IS NULL OR expires_at > ?)`).get(principalId, canonicalKey, scope.type, scope.id ?? null, Date.now());
+	return Boolean(row);
+}
+function createCollaborationRule(input, principalId = USER_CONTEXT_PRINCIPAL_ID) {
+	const id = randomUUID();
+	const revisionId = randomUUID();
+	const now = Date.now();
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`INSERT INTO collaboration_rules (
+      rule_id, principal_id, category, status, priority, scope_type, scope_id,
+      conditions_json, current_revision_id, created_at, updated_at
+    ) VALUES (?, ?, ?, 'active', ?, ?, ?, ?, ?, ?, ?)`).run(id, principalId, input.category, input.priority, input.scope.type, input.scope.id ?? null, JSON.stringify(input.conditions), revisionId, now, now);
+		db.prepare(`INSERT INTO collaboration_rule_revisions (
+      revision_id, rule_id, statement, created_by, created_at
+    ) VALUES (?, ?, ?, 'user', ?)`).run(revisionId, id, input.statement.trim(), now);
+	});
+	return getCollaborationRule(id);
+}
+function getCollaborationRule(id) {
+	const row = getSqliteDatabase().prepare(`SELECT r.*, v.statement FROM collaboration_rules r
+    JOIN collaboration_rule_revisions v ON v.revision_id = r.current_revision_id
+    WHERE r.rule_id = ?`).get(id);
+	return row ? ruleFromRow(row) : void 0;
+}
+function listCollaborationRules(principalId = USER_CONTEXT_PRINCIPAL_ID) {
+	return getSqliteDatabase().prepare(`SELECT r.*, v.statement FROM collaboration_rules r
+    JOIN collaboration_rule_revisions v ON v.revision_id = r.current_revision_id
+    WHERE r.principal_id = ? ORDER BY r.priority ASC, r.updated_at DESC`).all(principalId).map(ruleFromRow);
+}
+function reviseCollaborationRule(id, statement) {
+	if (!getCollaborationRule(id)) throw new Error(`Collaboration rule not found: ${id}`);
+	const revisionId = randomUUID();
+	const now = Date.now();
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`INSERT INTO collaboration_rule_revisions (
+      revision_id, rule_id, statement, created_by, created_at
+    ) VALUES (?, ?, ?, 'user', ?)`).run(revisionId, id, statement.trim(), now);
+		db.prepare("UPDATE collaboration_rules SET current_revision_id = ?, updated_at = ? WHERE rule_id = ?").run(revisionId, now, id);
+	});
+	return getCollaborationRule(id);
+}
+function setCollaborationRuleStatus(id, status) {
+	getSqliteDatabase().prepare("UPDATE collaboration_rules SET status = ?, updated_at = ? WHERE rule_id = ?").run(status, Date.now(), id);
+	const result = getCollaborationRule(id);
+	if (!result) throw new Error(`Collaboration rule not found: ${id}`);
+	return result;
+}
+function deleteCollaborationRule(id) {
+	return Number(getSqliteDatabase().prepare("DELETE FROM collaboration_rules WHERE rule_id = ?").run(id).changes) > 0;
+}
+function createContextEvidence(input, principalId = USER_CONTEXT_PRINCIPAL_ID) {
+	const existing = getSqliteDatabase().prepare(`SELECT * FROM context_evidence
+    WHERE principal_id = ? AND source_type = ?
+      AND COALESCE(source_instance_id, '') = COALESCE(?, '') AND source_ref = ?`).get(principalId, input.sourceType, input.sourceInstanceId ?? null, input.sourceRef);
+	if (existing) return {
+		id: existing.evidence_id,
+		sourceType: existing.source_type,
+		...existing.source_instance_id ? { sourceInstanceId: existing.source_instance_id } : {},
+		sourceRef: existing.source_ref,
+		...existing.redacted_excerpt ? { redactedExcerpt: existing.redacted_excerpt } : {},
+		trustLevel: existing.trust_level,
+		observedAt: existing.observed_at,
+		createdAt: existing.created_at
+	};
+	const evidence = {
+		...input,
+		id: randomUUID(),
+		createdAt: Date.now()
+	};
+	getSqliteDatabase().prepare(`INSERT INTO context_evidence (
+    evidence_id, principal_id, source_type, source_instance_id, source_ref,
+    redacted_excerpt, trust_level, observed_at, created_at
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(evidence.id, principalId, evidence.sourceType, evidence.sourceInstanceId ?? null, evidence.sourceRef, evidence.redactedExcerpt ?? null, evidence.trustLevel, evidence.observedAt, evidence.createdAt);
+	return evidence;
+}
+function linkUnderstandingEvidence(versionId, evidenceId, relation, confidence) {
+	getSqliteDatabase().prepare(`INSERT INTO understanding_evidence_links (
+    version_id, evidence_id, relation, confidence
+  ) VALUES (?, ?, ?, ?)
+  ON CONFLICT(version_id, evidence_id, relation) DO UPDATE SET confidence = excluded.confidence`).run(versionId, evidenceId, relation, confidence);
+}
+function listUnderstandingEvidence(understandingId, relation) {
+	return getSqliteDatabase().prepare(`SELECT DISTINCT e.* FROM context_evidence e
+    JOIN understanding_evidence_links l ON l.evidence_id = e.evidence_id
+    JOIN user_understanding_versions v ON v.version_id = l.version_id
+    WHERE v.understanding_id = ? AND (? IS NULL OR l.relation = ?)
+    ORDER BY e.observed_at DESC`).all(understandingId, relation ?? null, relation ?? null).map((row) => ({
+		id: row.evidence_id,
+		sourceType: row.source_type,
+		...row.source_instance_id ? { sourceInstanceId: row.source_instance_id } : {},
+		sourceRef: row.source_ref,
+		...row.redacted_excerpt ? { redactedExcerpt: row.redacted_excerpt } : {},
+		trustLevel: row.trust_level,
+		observedAt: row.observed_at,
+		createdAt: row.created_at
+	}));
+}
+function recordContextRun(input) {
+	const existing = getSqliteDatabase().prepare("SELECT context_run_id FROM context_runs WHERE turn_id = ?").get(input.turnId);
+	const runId = existing?.context_run_id ?? randomUUID();
+	runSqliteWriteTransaction((db) => {
+		if (existing) {
+			db.prepare(`UPDATE context_runs SET principal_id = ?, session_key = ?, query = ?, budget = ?, duration_ms = ?
+        WHERE context_run_id = ?`).run(input.principalId ?? "local-owner", input.sessionKey, input.query, input.budget, input.durationMs, runId);
+			db.prepare("DELETE FROM context_run_items WHERE context_run_id = ?").run(runId);
+		} else db.prepare(`INSERT INTO context_runs (
+        context_run_id, principal_id, turn_id, session_key, query, budget, duration_ms, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(runId, input.principalId ?? "local-owner", input.turnId, input.sessionKey, input.query, input.budget, input.durationMs, Date.now());
+		const insert = db.prepare(`INSERT INTO context_run_items (
+      context_run_id, object_type, object_id, version_id, decision, reason, content_snapshot,
+      source_label, rank, score, injected_chars
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+		for (const item of input.items) insert.run(runId, item.objectType, item.objectId, item.versionId ?? null, item.decision, item.reason, item.content, item.sourceLabel, item.rank ?? null, item.score ?? null, item.injectedChars);
+	});
+	return runId;
+}
+function getTurnPersonalization(turnId) {
+	const db = getSqliteDatabase();
+	const run = db.prepare("SELECT context_run_id FROM context_runs WHERE turn_id = ?").get(turnId);
+	if (!run) return void 0;
+	const rows = db.prepare("SELECT * FROM context_run_items WHERE context_run_id = ? ORDER BY rank ASC, object_type ASC").all(run.context_run_id);
+	return {
+		runId: run.context_run_id,
+		items: rows.map((row) => ({
+			objectType: row.object_type,
+			objectId: row.object_id,
+			...row.version_id ? { versionId: row.version_id } : {},
+			decision: row.decision,
+			reason: row.reason,
+			content: row.content_snapshot,
+			sourceLabel: row.source_label,
+			...row.rank === null ? {} : { rank: row.rank },
+			...row.score === null ? {} : { score: row.score },
+			injectedChars: row.injected_chars
+		}))
+	};
+}
+function recordContextFeedback(input) {
+	if (Boolean(input.objectType) !== Boolean(input.objectId)) throw new Error("objectType and objectId must be provided together");
+	getSqliteDatabase().prepare(`INSERT INTO context_feedback (
+    feedback_id, turn_id, context_run_id, object_type, object_id, rating, reason, created_at
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  ON CONFLICT DO UPDATE SET rating = excluded.rating, reason = excluded.reason, created_at = excluded.created_at`).run(randomUUID(), input.turnId, input.runId, input.objectType ?? null, input.objectId ?? null, input.rating, input.reason ?? null, Date.now());
+}
+function hasContextConsent(understandingId, sessionKey) {
+	const now = Date.now();
+	return Boolean(getSqliteDatabase().prepare(`SELECT 1 FROM context_consents
+    WHERE understanding_id = ? AND status = 'granted'
+      AND (grant_scope = 'always' OR session_key = ?)
+      AND (expires_at IS NULL OR expires_at > ?)
+    LIMIT 1`).get(understandingId, sessionKey, now));
+}
+function consumeContextConsent(understandingId, sessionKey) {
+	const db = getSqliteDatabase();
+	const now = Date.now();
+	const granted = db.prepare(`SELECT consent_id, grant_scope FROM context_consents
+    WHERE understanding_id = ? AND status = 'granted'
+      AND (grant_scope = 'always' OR session_key = ?)
+      AND (expires_at IS NULL OR expires_at > ?)
+    ORDER BY CASE grant_scope WHEN 'once' THEN 0 WHEN 'session' THEN 1 ELSE 2 END
+    LIMIT 1`).get(understandingId, sessionKey, now);
+	if (granted) {
+		if (granted.grant_scope === "once") db.prepare("UPDATE context_consents SET status = 'consumed', updated_at = ? WHERE consent_id = ?").run(now, granted.consent_id);
+		return "granted";
+	}
+	return db.prepare(`SELECT 1 FROM context_consents
+    WHERE understanding_id = ? AND session_key = ? AND status = 'denied' LIMIT 1`).get(understandingId, sessionKey) ? "denied" : "missing";
+}
+function ensureContextConsent(understandingId, sessionKey, purpose) {
+	const db = getSqliteDatabase();
+	const existing = db.prepare(`SELECT consent_id, purpose FROM context_consents
+    WHERE understanding_id = ? AND session_key = ? AND status = 'pending'`).get(understandingId, sessionKey);
+	if (existing) return {
+		id: existing.consent_id,
+		understandingId,
+		purpose: existing.purpose
+	};
+	const id = randomUUID();
+	const now = Date.now();
+	db.prepare(`INSERT INTO context_consents (
+    consent_id, principal_id, understanding_id, session_key, purpose, status,
+    grant_scope, expires_at, created_at, updated_at
+  ) VALUES (?, ?, ?, ?, ?, 'pending', NULL, NULL, ?, ?)`).run(id, USER_CONTEXT_PRINCIPAL_ID, understandingId, sessionKey, purpose, now, now);
+	return {
+		id,
+		understandingId,
+		purpose
+	};
+}
+function decideContextConsent(id, decision) {
+	const expiresAt = decision === "once" ? Date.now() + 5 * 6e4 : null;
+	const result = getSqliteDatabase().prepare(`UPDATE context_consents
+    SET status = ?, grant_scope = ?, expires_at = ?, updated_at = ? WHERE consent_id = ?`).run(decision === "deny" ? "denied" : "granted", decision === "deny" ? null : decision, expiresAt, Date.now(), id);
+	return Number(result.changes) > 0;
+}
+//#endregion
+export { consumeContextConsent, createCollaborationRule, createContextEvidence, createUnderstanding, decideContextConsent, deleteCollaborationRule, deleteUnderstanding, ensureContextConsent, getCollaborationRule, getTurnPersonalization, getUnderstanding, getUserProfile, hasContextConsent, isUnderstandingSuppressed, linkUnderstandingEvidence, listCollaborationRules, listUnderstandingEvidence, listUnderstandings, recordContextFeedback, recordContextRun, rejectUnderstanding, reviseCollaborationRule, reviseUnderstanding, setCollaborationRuleStatus, setUnderstandingStatus, updateUserProfile };

package/dist/src/tui/tool-summary.js

@@ -28,7 +28,6 @@ function isReadStyleTool(toolName) {
 		"read",
 		"read_file",
 		"memory_get",
-		"get_code_snippet",
 		"prepare_diff"
 	].includes(base);
 }
@@ -39,13 +38,8 @@ function isSearchStyleTool(toolName) {
 		"grep",
 		"rg",
 		"ripgrep",
-		"search_code",
 		"file_search",
-		"list_files",
-		"search_graph",
-		"query_graph",
-		"trace_path",
-		"get_architecture"
+		"list_files"
 	].includes(base);
 }
 function isExecStyleTool(toolName) {

package/dist/src/tui/tui-startup-resources.js

@@ -1,6 +1,6 @@
 import { resolveStateDir } from "../config/paths-state.js";
 import { resolveEffectiveAgentProfileForSession } from "../config/agent-profile.js";
-import { init_paths, resolveAgentProfileDir, resolveBundledSkillsDir, resolveUserProfilePath } from "../config/paths.js";
+import { init_paths, resolveAgentProfileDir, resolveBundledSkillsDir } from "../config/paths.js";
 import { resolveBootstrapFilesSync } from "../agent/bootstrap/bootstrap-files.js";
 import { createSkillConfigManager, isSkillEnabled } from "../agent/skills/config.js";
 import { loadSkills } from "../agent/skills/index.js";
@@ -20,7 +20,6 @@ function collectTuiStartupResources(config, sessionKey, options = {}) {
 	const workspaceDir = profile.resolvedWorkspacePath || getWorkspacePath(config);
 	const context = uniqueSorted(resolveBootstrapFilesSync({
 		profileDir,
-		userProfilePath: resolveUserProfilePath(),
 		sessionKey
 	}).filter((file) => !file.missing).map((file) => file.name || basename(file.path)));
 	const skillsConfig = createSkillConfigManager(resolveStateDir()).load();