trucontext 0.5.1 → 0.7.0

package/bin/cli.js

@@ -18,6 +18,7 @@ import { entitiesListCommand, entitiesGetCommand, entitiesCreateCommand, entitie
 import { recipesListCommand, recipesGetCommand, recipesCreateCommand, recipesDeleteCommand } from '../src/commands/recipes.js';
 import { relationshipTypesListCommand } from '../src/commands/relationship-types.js';
 import { docsListCommand, docsShowCommand } from '../src/commands/docs.js';
+import { registerRootsCommand } from '../src/commands/roots.js';
 
 program
   .name('trucontext')
@@ -65,7 +66,8 @@ program.command('ingest <source>')
 // Query
 program.command('query <question>')
   .description('Query the knowledge graph')
-  .option('-c, --context <id>', 'Scope to a context')
+  .option('-r, --root <id>', 'Root node ID (or use: trucontext roots use <id>)')
+  .option('-c, --context <id>', 'Further scope within the root ego network')
   .option('-m, --mode <mode>', 'Query mode: answer (default) or context', 'answer')
   .option('-l, --limit <n>', 'Max results', '20')
   .action(queryCommand);
@@ -73,7 +75,8 @@ program.command('query <question>')
 // Recall
 program.command('recall <query>')
   .description('Semantic memory recall')
-  .option('-c, --context <id>', 'Scope to a context')
+  .option('-r, --root <id>', 'Root node ID (or use: trucontext roots use <id>)')
+  .option('-c, --context <id>', 'Further scope within the root ego network')
   .option('-l, --limit <n>', 'Max seed results', '10')
   .option('-d, --depth <n>', 'Graph expansion depth', '2')
   .action(recallCommand);
@@ -130,6 +133,9 @@ entities.command('edges <entityId>')
   .description('List edges for an entity')
   .action(entitiesEdgesCommand);
 
+// Root Nodes
+registerRootsCommand(program);
+
 // Recipes
 const recipes = program.command('recipes').description('Manage recipes').action(function() { this.help(); });
 recipes.command('list')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trucontext",
-  "version": "0.5.1",
+  "version": "0.7.0",
   "description": "TruContext CLI — contextual memory for AI applications",
   "type": "module",
   "bin": {

package/src/commands/entities.js

@@ -1,5 +1,6 @@
 import chalk from 'chalk';
-import { dataPlane } from '../client.js';
+import { controlPlane } from '../client.js';
+import { getActiveApp } from '../config.js';
 
 // Fields stored on the node but not user-declared properties
 const SYSTEM_FIELDS = new Set([
@@ -38,15 +39,16 @@ function displayEntity(e) {
 
 export async function entitiesListCommand(options) {
   try {
+    const appId = getActiveApp();
     const params = new URLSearchParams();
     if (options.type) params.set('type', options.type);
     if (options.context) params.set('context_id', options.context);
     if (options.scope) params.set('scope', options.scope);
     if (options.limit) params.set('limit', options.limit);
     const qs = params.toString();
-    const path = `/v1/entities${qs ? `?${qs}` : ''}`;
+    const path = `/apps/${appId}/entities${qs ? `?${qs}` : ''}`;
 
-    const res = await dataPlane('GET', path);
+    const res = await controlPlane('GET', path);
     const entities = Array.isArray(res.data) ? res.data : (res.data?.entities || []);
 
     if (entities.length === 0) {
@@ -66,13 +68,14 @@ export async function entitiesListCommand(options) {
 
 export async function entitiesGetCommand(entityId) {
   try {
-    const res = await dataPlane('GET', `/v1/entities/${entityId}`);
+    const appId = getActiveApp();
+    const res = await controlPlane('GET', `/apps/${appId}/entities/${entityId}`);
     const e = res.data || res;
     displayEntity(e);
 
     // Show edges if available
     try {
-      const edgeRes = await dataPlane('GET', `/v1/entities/${entityId}/edges`);
+      const edgeRes = await controlPlane('GET', `/apps/${appId}/entities/${entityId}/edges`);
       const edges = edgeRes.data?.edges || edgeRes.data || [];
       if (edges.length > 0) {
         console.log(chalk.dim(`\n  Edges (${edges.length}):`));
@@ -101,6 +104,7 @@ export async function entitiesCreateCommand(options) {
       process.exit(1);
     }
 
+    const appId = getActiveApp();
     const body = {
       entityId: options.id,
       type: options.type,
@@ -133,7 +137,7 @@ export async function entitiesCreateCommand(options) {
       });
     }
 
-    const res = await dataPlane('POST', '/v1/entities', body);
+    const res = await controlPlane('POST', `/apps/${appId}/entities`, body);
     const e = res.data || res;
     console.log(chalk.green(`Created: ${chalk.bold(e.entityId || options.id)}`));
   } catch (err) {
@@ -144,6 +148,7 @@ export async function entitiesCreateCommand(options) {
 
 export async function entitiesUpdateCommand(entityId, options) {
   try {
+    const appId = getActiveApp();
     const body = {};
 
     if (options.properties) {
@@ -173,7 +178,7 @@ export async function entitiesUpdateCommand(entityId, options) {
       });
     }
 
-    await dataPlane('PUT', `/v1/entities/${entityId}`, body);
+    await controlPlane('PUT', `/apps/${appId}/entities/${entityId}`, body);
     console.log(chalk.green(`Updated: ${entityId}`));
   } catch (err) {
     console.error(chalk.red(`Failed: ${err.message}`));
@@ -183,7 +188,8 @@ export async function entitiesUpdateCommand(entityId, options) {
 
 export async function entitiesDeleteCommand(entityId) {
   try {
-    await dataPlane('DELETE', `/v1/entities/${entityId}`);
+    const appId = getActiveApp();
+    await controlPlane('DELETE', `/apps/${appId}/entities/${entityId}`);
     console.log(chalk.green(`Deleted: ${entityId}`));
   } catch (err) {
     console.error(chalk.red(`Failed: ${err.message}`));
@@ -193,7 +199,8 @@ export async function entitiesDeleteCommand(entityId) {
 
 export async function entitiesEdgesCommand(entityId) {
   try {
-    const res = await dataPlane('GET', `/v1/entities/${entityId}/edges`);
+    const appId = getActiveApp();
+    const res = await controlPlane('GET', `/apps/${appId}/entities/${entityId}/edges`);
     const edges = res.data?.edges || res.data || [];
 
     if (edges.length === 0) {

package/src/commands/ingest.js

@@ -1,10 +1,12 @@
 import chalk from 'chalk';
 import { readFileSync, existsSync } from 'fs';
 import { basename } from 'path';
-import { dataPlane } from '../client.js';
+import { controlPlane } from '../client.js';
+import { getActiveApp } from '../config.js';
 
 export async function ingestCommand(source, options) {
   try {
+    const appId = getActiveApp();
     let body;
 
     if (existsSync(source)) {
@@ -32,25 +34,30 @@ export async function ingestCommand(source, options) {
     if (options.confidence !== undefined) body.confidence = parseFloat(options.confidence);
     if (options.temporal !== undefined) body.temporal = options.temporal;
 
-    // Build contexts array from --context flags: "entity-id:RELATIONSHIP"
-    if (options.context?.length > 0) {
-      body.contexts = options.context.map(entry => {
-        const colonIdx = entry.indexOf(':');
-        if (colonIdx === -1) {
-          return { context_id: entry, relationship: 'ABOUT' };
-        }
-        return {
-          context_id: entry.slice(0, colonIdx),
-          relationship: entry.slice(colonIdx + 1),
-        };
-      });
+    // Build contexts array from --context flags: "entity-id:RELATIONSHIP" (required)
+    if (!options.context || options.context.length === 0) {
+      console.error(chalk.red('At least one context is required.'));
+      console.error(chalk.dim('Use: --context entity-id:RELATIONSHIP (e.g., --context dustin:ABOUT)'));
+      process.exit(1);
     }
 
-    const res = await dataPlane('POST', '/v1/ingest', body);
+    body.contexts = options.context.map(entry => {
+      const colonIdx = entry.indexOf(':');
+      if (colonIdx === -1) {
+        return { context_id: entry, relationship: 'ABOUT' };
+      }
+      return {
+        context_id: entry.slice(0, colonIdx),
+        relationship: entry.slice(colonIdx + 1),
+      };
+    });
+
+    const res = await controlPlane('POST', `/apps/${appId}/ingest`, body);
+    const data = res.data || res;
     console.log(chalk.green('Accepted'));
-    console.log(chalk.dim(`Content ID: ${res.contentId}`));
-    if (res.status === 'upload_required') {
-      console.log(chalk.yellow(`Large file — upload to: ${res.uploadUrl}`));
+    console.log(chalk.dim(`Content ID: ${data.contentId}`));
+    if (data.status === 'upload_required') {
+      console.log(chalk.yellow(`Large file — upload to: ${data.uploadUrl}`));
     }
   } catch (err) {
     console.error(chalk.red(`Ingest failed: ${err.message}`));

package/src/commands/init.js

@@ -71,8 +71,62 @@ export async function initCommand(name, options) {
       console.log(chalk.cyan('  trucontext schema generate -d "your description"'));
     }
 
-    console.log(chalk.dim(`\nReady to go:`));
-    console.log(chalk.cyan('  trucontext ingest <file>'));
+    // Step 7: Create first root node
+    console.log(chalk.bold('\nCreate Your First Root Node'));
+    console.log(chalk.dim('Root nodes are the intelligence boundaries of your graph.\n'));
+
+    const rootId = await input({ message: 'Root node ID (e.g., my-agent, dustin):' });
+    const rootType = await select({
+      message: 'Root node type:',
+      choices: [
+        { name: 'Person', value: 'Person' },
+        { name: 'Agent', value: 'Agent' },
+        { name: 'Organization', value: 'Organization' },
+        { name: 'Business', value: 'Business' },
+        { name: 'Product', value: 'Product' },
+        { name: 'Project', value: 'Project' },
+      ],
+    });
+
+    const rootRecipe = await select({
+      message: 'Recipe (how should the system think about this node\'s data?):',
+      choices: [
+        { name: 'Personal Assistant Memory', value: 'recipe:personal-assistant-memory' },
+        { name: 'Meeting Memory', value: 'recipe:meeting-memory' },
+        { name: 'Customer Voice', value: 'recipe:customer-voice' },
+        { name: 'Competitive Intelligence', value: 'recipe:competitive-intelligence' },
+        { name: 'AI Agent Self-Reflection', value: 'recipe:ai-agent-self-reflection' },
+        { name: 'Organizational Context', value: 'recipe:organizational-context' },
+        { name: 'Decision Archive', value: 'recipe:decision-archive' },
+        { name: 'Curiosity Loop', value: 'recipe:curiosity-loop' },
+      ],
+    });
+
+    const rootName = await input({ message: 'Display name (e.g., Dustin Henderson):' });
+
+    try {
+      await controlPlane('POST', `/apps/${app.appId}/roots`, {
+        entityId: rootId,
+        type: rootType,
+        recipe_id: rootRecipe,
+        dreamers: 'all',
+        properties: rootName ? { name: rootName } : {},
+      });
+
+      const { saveConfig, getConfig } = await import('../config.js');
+      const config = getConfig();
+      config.activeRoot = rootId;
+      saveConfig(config);
+
+      console.log(chalk.green(`Root node created: ${rootId}`));
+      console.log(chalk.green(`Active root set: ${rootId}\n`));
+    } catch (rootErr) {
+      console.error(chalk.yellow(`Root creation failed: ${rootErr.response?.data?.error || rootErr.message}`));
+      console.log(chalk.dim('You can create one later: trucontext roots create --id <id> --type <type> --recipe <recipe>\n'));
+    }
+
+    console.log(chalk.dim('Ready to go:'));
+    console.log(chalk.cyan('  trucontext ingest "content" --context ' + rootId + ':ABOUT'));
     console.log(chalk.cyan('  trucontext query "your question"'));
   } catch (err) {
     console.error(chalk.red(`Failed: ${err.message}`));

package/src/commands/query.js

@@ -1,10 +1,21 @@
 import chalk from 'chalk';
-import { dataPlane } from '../client.js';
+import { controlPlane } from '../client.js';
+import { getConfig, getActiveApp } from '../config.js';
 
 export async function queryCommand(question, options) {
   try {
+    const appId = getActiveApp();
+
+    // root_id is required — from --root flag or active root
+    const rootId = options.root || getConfig().activeRoot;
+    if (!rootId) {
+      console.error(chalk.red('Root node required. Use --root <id> or set active root: trucontext roots use <id>'));
+      process.exit(1);
+    }
+
     const body = {
       mode: options.mode === 'context' ? 'CONTEXT' : 'ANSWER',
+      root_id: rootId,
       max_results: options.limit ? parseInt(options.limit, 10) : 20,
     };
 
@@ -16,34 +27,35 @@ export async function queryCommand(question, options) {
 
     if (options.context) body.context_id = options.context;
 
-    const res = await dataPlane('POST', '/v1/query', body);
+    const res = await controlPlane('POST', `/apps/${appId}/mind/query`, body);
+    const data = res.data || res;
 
     // Print answer
-    if (res.answer?.summary) {
+    if (data.answer?.summary) {
       console.log(chalk.bold('\nAnswer:'));
-      console.log(res.answer.summary);
-      if (res.answer.confidence) {
-        console.log(chalk.dim(`\nConfidence: ${(res.answer.confidence * 100).toFixed(0)}%`));
+      console.log(data.answer.summary);
+      if (data.answer.confidence) {
+        console.log(chalk.dim(`\nConfidence: ${(data.answer.confidence * 100).toFixed(0)}%`));
       }
     }
 
     // Print concepts
-    if (res.concepts?.length > 0) {
+    if (data.concepts?.length > 0) {
       console.log(chalk.bold('\nConcepts:'));
-      for (const c of res.concepts.slice(0, 5)) {
+      for (const c of data.concepts.slice(0, 5)) {
         console.log(`  ${c.label} ${chalk.dim(`(${c.evidence_count} evidence)`)}`);
       }
     }
 
     // Print people
-    if (res.people?.length > 0) {
+    if (data.people?.length > 0) {
       console.log(chalk.bold('\nPeople:'));
-      for (const p of res.people.slice(0, 5)) {
+      for (const p of data.people.slice(0, 5)) {
         console.log(`  ${p.name} ${chalk.dim(p.relationship || '')}`);
       }
     }
 
-    console.log(chalk.dim(`\n${res.latency_ms}ms`));
+    console.log(chalk.dim(`\n${data.latency_ms}ms`));
   } catch (err) {
     console.error(chalk.red(`Query failed: ${err.message}`));
     process.exit(1);

package/src/commands/recall.js

@@ -1,28 +1,40 @@
 import chalk from 'chalk';
-import { dataPlane } from '../client.js';
+import { controlPlane } from '../client.js';
+import { getConfig, getActiveApp } from '../config.js';
 
 export async function recallCommand(query, options) {
   try {
+    const appId = getActiveApp();
+
+    // root_id is required — from --root flag or active root
+    const rootId = options.root || getConfig().activeRoot;
+    if (!rootId) {
+      console.error(chalk.red('Root node required. Use --root <id> or set active root: trucontext roots use <id>'));
+      process.exit(1);
+    }
+
     const body = {
       query,
+      root_id: rootId,
       maxResults: options.limit ? parseInt(options.limit, 10) : 10,
       expansionDepth: options.depth ? parseInt(options.depth, 10) : 2,
     };
 
     if (options.context) body.context_id = options.context;
 
-    const res = await dataPlane('POST', '/v1/recall', body);
+    const res = await controlPlane('POST', `/apps/${appId}/recall`, body);
+    const data = res.data || res;
 
     // Print synthesis
-    if (res.synthesis?.summary) {
+    if (data.synthesis?.summary) {
       console.log(chalk.bold('\nSynthesis:'));
-      console.log(res.synthesis.summary);
+      console.log(data.synthesis.summary);
     }
 
     // Print seeds
-    if (res.seeds?.length > 0) {
-      console.log(chalk.bold(`\nSeeds (${res.seeds.length}):`));
-      for (const s of res.seeds) {
+    if (data.seeds?.length > 0) {
+      console.log(chalk.bold(`\nSeeds (${data.seeds.length}):`));
+      for (const s of data.seeds) {
         const label = s.snippet || s.label || s.id;
         const score = (s.score * 100).toFixed(0);
         console.log(`  ${chalk.dim(`${score}%`)} ${label.slice(0, 100)}`);
@@ -30,11 +42,11 @@ export async function recallCommand(query, options) {
     }
 
     // Print graph context summary
-    if (res.context) {
-      console.log(chalk.dim(`\nGraph: ${res.context.nodes?.length || 0} nodes, ${res.context.edges?.length || 0} edges`));
+    if (data.context) {
+      console.log(chalk.dim(`\nGraph: ${data.context.nodes?.length || 0} nodes, ${data.context.edges?.length || 0} edges`));
     }
 
-    console.log(chalk.dim(`${res.latency_ms}ms`));
+    console.log(chalk.dim(`${data.latency_ms}ms`));
   } catch (err) {
     console.error(chalk.red(`Recall failed: ${err.message}`));
     process.exit(1);

package/src/commands/roots.js

@@ -0,0 +1,201 @@
+// roots.js — Root Node commands
+//
+// Root nodes are the intelligence boundaries of the graph. They define ego networks,
+// carry recipes, and control which dreams run. Queries require a root_id.
+
+import chalk from 'chalk';
+import { controlPlane } from '../client.js';
+import { getConfig, saveConfig, getActiveApp } from '../config.js';
+
+export function registerRootsCommand(program) {
+  const roots = program
+    .command('roots')
+    .description('Manage root nodes — intelligence boundaries of the graph')
+    .action(function() { this.help(); });
+
+  // CREATE
+  roots
+    .command('create')
+    .description('Create a root node')
+    .requiredOption('--id <entityId>', 'Unique identifier for the root node')
+    .requiredOption('--type <type>', 'Node type (e.g., Person, Agent, Organization)')
+    .requiredOption('--recipe <recipeId>', 'Recipe ID (e.g., recipe:personal-assistant-memory)')
+    .option('--dreamers <list>', 'Dreamers: "all" or comma-separated (e.g., decay,curiosity)', 'all')
+    .option('--hop-depth <n>', 'Max traversal depth for ego network (default: unlimited)', parseInt)
+    .option('--do-not-follow', 'Mark as structural root — do not traverse into from other roots')
+    .option('--properties <json>', 'JSON properties object')
+    .option('-c, --context <entry>', 'Link to other roots: entity-id:RELATIONSHIP (repeatable)', (val, prev) => [...prev, val], [])
+    .action(async (opts) => {
+      try {
+        const body = {
+          entityId: opts.id,
+          type: opts.type,
+          recipe_id: opts.recipe,
+          dreamers: opts.dreamers === 'all' ? 'all' : opts.dreamers.split(',').map(s => s.trim()),
+          hop_depth: opts.hopDepth || null,
+          do_not_follow: opts.doNotFollow || false,
+        };
+
+        if (opts.properties) {
+          try { body.properties = JSON.parse(opts.properties); } catch {
+            console.error(chalk.red('Error: --properties must be valid JSON'));
+            process.exit(1);
+          }
+        }
+
+        if (opts.context && opts.context.length > 0) {
+          body.contexts = opts.context.map(c => {
+            const [id, rel] = c.split(':');
+            if (!id || !rel) {
+              console.error(chalk.red(`Error: Invalid context format "${c}". Use entity-id:RELATIONSHIP`));
+              process.exit(1);
+            }
+            return { context_id: id, relationship: rel };
+          });
+        }
+
+        const appId = getActiveApp();
+        const res = await controlPlane('POST', `/apps/${appId}/roots`, body);
+        const r = res.data;
+        console.log(chalk.green(`Root node created: ${r.entityId}`));
+        console.log(`  Type: ${r.type}`);
+        console.log(`  Recipe: ${r.recipe_id}`);
+        console.log(`  Dreamers: ${Array.isArray(r.dreamers) ? r.dreamers.join(', ') : r.dreamers}`);
+        console.log(`  Hop depth: ${r.hop_depth || 'unlimited'}`);
+      } catch (err) {
+        console.error(chalk.red('Failed:'), err.response?.data?.error || err.response?.data?.details || err.message);
+        process.exit(1);
+      }
+    });
+
+  // LIST
+  roots
+    .command('list')
+    .description('List all root nodes for the active app')
+    .action(async () => {
+      try {
+        const appId = getActiveApp();
+        const res = await controlPlane('GET', `/apps/${appId}/roots`);
+        const rootNodes = res.data?.roots || [];
+        if (rootNodes.length === 0) {
+          console.log('No root nodes. Create one with: trucontext roots create');
+          return;
+        }
+
+        const config = getConfig();
+        for (const r of rootNodes) {
+          const active = config.activeRoot === r.entityId ? chalk.cyan(' (active)') : '';
+          const dreamers = Array.isArray(r.dreamers) ? r.dreamers.join(', ') : r.dreamers;
+          console.log(`${chalk.bold(r.properties?.name || r.entityId)}${active}`);
+          console.log(`  ${r.entityId} — ${r.type} — recipe: ${r.recipe_id || 'none'} — dreamers: ${dreamers}`);
+        }
+      } catch (err) {
+        console.error(chalk.red('Failed:'), err.response?.data?.error || err.message);
+        process.exit(1);
+      }
+    });
+
+  // SHOW
+  roots
+    .command('show <rootId>')
+    .description('Show details of a root node')
+    .action(async (rootId) => {
+      try {
+        const appId = getActiveApp();
+        const res = await controlPlane('GET', `/apps/${appId}/roots/${rootId}`);
+        const r = res.data;
+        console.log(chalk.bold(`Root: ${r.entityId}`));
+        console.log(`  Type: ${r.type}`);
+        console.log(`  Recipe: ${r.recipe_id || 'none'}`);
+        console.log(`  Dreamers: ${Array.isArray(r.dreamers) ? r.dreamers.join(', ') : r.dreamers}`);
+        console.log(`  Hop depth: ${r.hop_depth || 'unlimited'}`);
+        console.log(`  Do not follow: ${r.do_not_follow}`);
+
+        if (r.linkedRoots && r.linkedRoots.length > 0) {
+          console.log(`  Linked roots:`);
+          for (const lr of r.linkedRoots) {
+            console.log(`    → ${lr.entityId} (${lr.type}) via ${lr.relationship}`);
+          }
+        }
+      } catch (err) {
+        console.error(chalk.red('Failed:'), err.response?.data?.error || err.message);
+        process.exit(1);
+      }
+    });
+
+  // UPDATE
+  roots
+    .command('update <rootId>')
+    .description('Update a root node')
+    .option('--recipe <recipeId>', 'New recipe ID')
+    .option('--dreamers <list>', 'New dreamers: "all" or comma-separated')
+    .option('--hop-depth <n>', 'New hop depth', parseInt)
+    .option('--do-not-follow', 'Set do-not-follow flag')
+    .option('--no-do-not-follow', 'Clear do-not-follow flag')
+    .option('--properties <json>', 'JSON properties to update')
+    .action(async (rootId, opts) => {
+      try {
+        const body = {};
+        if (opts.recipe) body.recipe_id = opts.recipe;
+        if (opts.dreamers) body.dreamers = opts.dreamers === 'all' ? 'all' : opts.dreamers.split(',').map(s => s.trim());
+        if (opts.hopDepth !== undefined) body.hop_depth = opts.hopDepth;
+        if (opts.doNotFollow !== undefined) body.do_not_follow = opts.doNotFollow;
+        if (opts.properties) {
+          try { body.properties = JSON.parse(opts.properties); } catch {
+            console.error(chalk.red('Error: --properties must be valid JSON'));
+            process.exit(1);
+          }
+        }
+
+        const appId = getActiveApp();
+        await controlPlane('PUT', `/apps/${appId}/roots/${rootId}`, body);
+        console.log(chalk.green(`Updated: ${rootId}`));
+      } catch (err) {
+        console.error(chalk.red('Failed:'), err.response?.data?.error || err.message);
+        process.exit(1);
+      }
+    });
+
+  // DELETE (demote)
+  roots
+    .command('delete <rootId>')
+    .description('Demote a root node to a regular entity (does not delete the node)')
+    .action(async (rootId) => {
+      try {
+        const appId = getActiveApp();
+        await controlPlane('DELETE', `/apps/${appId}/roots/${rootId}`);
+        console.log(chalk.green(`Demoted: ${rootId} (no longer a root node)`));
+
+        const config = getConfig();
+        if (config.activeRoot === rootId) {
+          config.activeRoot = undefined;
+          saveConfig(config);
+        }
+      } catch (err) {
+        console.error(chalk.red('Failed:'), err.response?.data?.error || err.message);
+        process.exit(1);
+      }
+    });
+
+  // USE — set active root for queries
+  roots
+    .command('use <rootId>')
+    .description('Set the active root node for queries and recall')
+    .action(async (rootId) => {
+      try {
+        const appId = getActiveApp();
+        await controlPlane('GET', `/apps/${appId}/roots/${rootId}`);
+        const config = getConfig();
+        config.activeRoot = rootId;
+        saveConfig(config);
+        console.log(chalk.green(`Active root: ${rootId}`));
+      } catch (err) {
+        if (err.response?.status === 404) {
+          console.error(chalk.red(`Root node '${rootId}' not found. Run: trucontext roots list`));
+        } else {
+          console.error(chalk.red('Failed:'), err.response?.data?.error || err.message);
+        }
+        process.exit(1);
+      }
+    });
+}