@geraldmaron/construct 1.0.0 → 1.0.2

package/lib/mcp/tools/telemetry.mjs

@@ -0,0 +1,315 @@
+/**
+ * lib/mcp/tools/telemetry.mjs — Telemetry MCP tools: trace/score, session usage, efficiency snapshot.
+ *
+ * Exposes cxTrace, cxScore, sessionUsage, and efficiencySnapshot.
+ * Requires ROOT_DIR injected via opts. Telemetry credentials must be in env.
+ */
+import { join, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { readFileSync, existsSync } from 'node:fs';
+import { isAvailable as telemetryAvailable } from '../../telemetry/backends/remote.mjs';
+import { summarizePromptComposition } from '../../prompt-composer.js';
+import { enrichMetadataWithPrompt } from '../../prompt-metadata.mjs';
+import { readCurrentModels, resolveExecutionContractModelMetadata, selectModelTierForWorkCategory } from '../../model-router.mjs';
+import { routeRequest } from '../../orchestration-policy.mjs';
+import { loadWorkflow } from '../../workflow-state.mjs';
+import { buildStatus } from '../../status.mjs';
+import { readEfficiencyLog, buildCompactEfficiencyDigest } from '../../efficiency.mjs';
+import { addObservation } from '../../observation-store.mjs';
+// Local mock ingest client for fallback when ingestion service is unavailable
+import { loadConstructEnv } from '../../env-config.mjs';
+
+// Load config.env once at module init so config.env values win over shell env
+// (shell env may have stale/truncated credentials from earlier sessions)
+const CONF_ENV = loadConstructEnv({ warn: false });
+
+function readJSON(filePath) {
+  if (!existsSync(filePath)) return null;
+  try {
+    return JSON.parse(readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+import { execSync as _execSync } from 'node:child_process';
+
+// Mock ingest client for fallback to direct API when the real client is not available.
+
+function getOrCreateIngestClient() {
+  return {
+    available: false,
+    trace: () => {}
+  };
+}
+
+function resolveReleaseTag(cwd) {
+  try {
+    return _execSync('git rev-parse --short HEAD', { stdio: 'pipe', cwd, timeout: 2000 }).toString().trim() || undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function telemetryHeaders() {
+  const key = CONF_ENV.CONSTRUCT_TELEMETRY_PUBLIC_KEY ?? process.env.CONSTRUCT_TELEMETRY_PUBLIC_KEY;
+  const secret = CONF_ENV.CONSTRUCT_TELEMETRY_SECRET_KEY ?? process.env.CONSTRUCT_TELEMETRY_SECRET_KEY;
+  if (!key || !secret) throw new Error('CONSTRUCT_TELEMETRY_PUBLIC_KEY and CONSTRUCT_TELEMETRY_SECRET_KEY must be set.');
+  return {
+    Authorization: `Basic ${Buffer.from(`${key}:${secret}`).toString('base64')}`,
+    'Content-Type': 'application/json',
+  };
+}
+
+function telemetryBaseUrl() {
+  return (CONF_ENV.CONSTRUCT_TELEMETRY_URL ?? process.env.CONSTRUCT_TELEMETRY_URL ?? '').replace(/\/$/, '');
+}
+
+function resolveSessionContext() {
+  const cwd = process.cwd();
+  let workflowId;
+  let workflowPhase;
+  let workflowOwner;
+  try {
+    const wf = loadWorkflow(cwd);
+    if (wf) {
+      workflowId = wf.id;
+      workflowPhase = wf.phase;
+      const active = (wf.tasks || []).find((t) => t.status === 'in-progress' || t.status === 'in_progress');
+      if (active) workflowOwner = active.owner;
+    }
+  } catch { /* best effort */ }
+  const sessionId = process.env.CLAUDE_SESSION_ID
+    || process.env.CX_SESSION_ID
+    || process.env.OPENCODE_SESSION_ID
+    || workflowId;
+  const userId = process.env.USER || process.env.USERNAME || process.env.LOGNAME;
+  return { cwd, sessionId, userId, release: resolveReleaseTag(cwd), workflowPhase, workflowOwner, workflowId };
+}
+
+export async function cxTrace(args, { ROOT_DIR }) {
+  const ctx = resolveSessionContext();
+  const registry = readJSON(join(ROOT_DIR, 'agents', 'registry.json')) ?? {};
+  const registryModels = registry.models ?? {};
+  const currentModels = readCurrentModels(join(ROOT_DIR, '.env'), registryModels, process.env);
+  const route = typeof args.input === 'string' ? routeRequest({ request: args.input }) : null;
+  const executionContractModel = resolveExecutionContractModelMetadata({
+    envValues: currentModels,
+    registryModels,
+    requestedTier: selectModelTierForWorkCategory(route?.workCategory),
+    workCategory: route?.workCategory || null,
+  });
+  const runtimePromptMetadata = summarizePromptComposition(args.name, {
+    rootDir: ROOT_DIR,
+    request: typeof args.input === 'string' ? args.input : '',
+    route,
+    registryModels,
+    envValues: currentModels,
+    executionContractModel,
+    hostConstraints: {
+      runtime: 'mcp',
+      providerAgnostic: true,
+      telemetryBackend: 'telemetry',
+    },
+  });
+  const metadata = enrichMetadataWithPrompt(args.name, {
+    ...(args.metadata && typeof args.metadata === 'object' ? args.metadata : {}),
+    ...runtimePromptMetadata,
+    // Extract model metadata from executionContractModel for backward compatibility
+    ...(runtimePromptMetadata.executionContractModel ? {
+      selectedTier: runtimePromptMetadata.executionContractModel.selectedTier,
+      selectedModel: runtimePromptMetadata.executionContractModel.selectedModel,
+      selectedModelSource: runtimePromptMetadata.executionContractModel.selectedModelSource,
+      tiers: runtimePromptMetadata.executionContractModel.tiers,
+    } : {}),
+    workflowId: ctx.workflowId,
+    workflowPhase: ctx.workflowPhase,
+    workflowOwner: ctx.workflowOwner,
+  }, { rootDir: ROOT_DIR });
+  const traceId = args.id ?? crypto.randomUUID();
+  try {
+    const available = await telemetryAvailable();
+    if (!available) return { ok: false, error: 'Telemetry credentials not configured', id: traceId };
+    const teamId = args.metadata?.teamId ?? metadata.teamId;
+    const workCategoryValue = route?.workCategory ?? (typeof args.input === 'string' ? classifyWorkCategory({ request: args.input }) : null);
+    const body = {
+      id: traceId,
+      name: args.name,
+      // Ensure workCategory is set, falling back to direct classification if needed
+      workCategory: workCategoryValue,
+      
+      metadata: {
+        ...metadata,
+        agentName: args.name,
+        goal: typeof args.input === 'string' ? args.input : JSON.stringify(args.input ?? ''),
+        teamId,
+        traceSource: 'mcp',
+        workCategory: workCategoryValue,
+        ...(args.output ? { hasOutput: true } : {}),
+      },
+      tags: [args.name, teamId].filter(Boolean),
+      userId: ctx.userId,
+      sessionId: args.session_id || ctx.sessionId,
+      input: args.input,
+      output: args.output, // Include output if provided — most callers pass it later via cx_score, but some pass it eagerly
+      timestamp: args.timestamp ?? new Date().toISOString(),
+      release: ctx.release,
+    };
+
+     // Add version to metadata for test compatibility
+     body.metadata.version = 'v1';
+     
+    // Use ingestion batch for creation (handles large payloads better than direct API)
+        const ingestClient = getOrCreateIngestClient();
+        if (ingestClient?.available) {
+       ingestClient.trace(body);
+       return { ok: true, id: traceId };
+     }
+
+     // Fallback: direct API call
+     const res = await fetch(`${telemetryBaseUrl()}/api/public/traces`, {
+       method: 'POST',
+       headers: telemetryHeaders(),
+       body: JSON.stringify(body),
+     });
+     if (!res.ok) {
+       const text = await res.text().catch(() => '');
+       return { ok: false, error: `Telemetry API error ${res.status}: ${text}`, id: traceId };
+     }
+     return { ok: true, id: traceId };
+  } catch (err) {
+    return { ok: false, error: err.message, id: traceId };
+  }
+}
+
+/**
+ * Update an existing trace with output and metadata.
+ * Call this when a trace was created early but the result is only known later.
+ * Uses the telemetry PATCH endpoint directly since trace updates are infrequent.
+ */
+export async function cxTraceUpdate(args) {
+  const traceId = args.trace_id ?? '';
+  const output = args.output;
+  const metadata = args.metadata;
+
+  try {
+    const available = await telemetryAvailable();
+    if (!available) return { ok: false, error: 'Telemetry credentials not configured' };
+
+    const res = await fetch(`${telemetryBaseUrl()}/api/public/traces/${traceId}`, {
+      method: 'PATCH',
+      headers: telemetryHeaders(),
+      body: JSON.stringify({
+        output,
+        metadata: {
+          ...(metadata && typeof metadata === 'object' ? metadata : {}),
+          traceUpdatedAt: new Date().toISOString(),
+        },
+      }),
+    });
+
+    if (!res.ok) {
+      const text = await res.text().catch(() => '');
+      return { ok: false, error: `Telemetry PATCH error ${res.status}: ${text}` };
+    }
+
+    // Also record as observation for local learning
+    if (output || metadata) {
+      const rootDir = homedir();
+      addObservation(rootDir, {
+        role: 'construct',
+        category: 'insight',
+        summary: `Trace ${traceId.slice(0, 8)} updated with output`,
+        content: `traceId: ${traceId}\nhasOutput: ${Boolean(output)}\nmetadata: ${metadata ? Object.keys(metadata).join(', ') : 'none'}`,
+        tags: ['trace-update', 'telemetry'],
+        confidence: 0.9,
+        source: 'cx_trace_update',
+      });
+    }
+
+    return { ok: true, traceId };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+// Quality score thresholds for observation recording
+const SCORE_POOR_THRESHOLD = 0.5;    // below this → record anti-pattern
+const SCORE_GOOD_THRESHOLD = 0.85;   // at or above this → record positive pattern
+
+export async function cxScore(args) {
+  const traceId = args.trace_id ?? '';
+  try {
+    const available = await telemetryAvailable();
+    if (!available) return { ok: false, error: 'Telemetry credentials not configured' };
+    const body = {
+      id: crypto.randomUUID(),
+      traceId,
+      name: args.name ?? 'quality',
+      value: args.value,
+      dataType: 'NUMERIC',
+      comment: args.comment,
+    };
+    const res = await fetch(`${telemetryBaseUrl()}/api/public/scores`, {
+      method: 'POST',
+      headers: telemetryHeaders(),
+      body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => '');
+      return { ok: false, error: `Telemetry API error ${res.status}: ${text}` };
+    }
+
+    // Feed score back into the local observation store so future agents learn from it.
+    // Low scores generate anti-pattern observations; high scores reinforce positive patterns.
+    const numericValue = Number(args.value);
+    if (Number.isFinite(numericValue)) {
+      const rootDir = homedir();
+      const agentName = args.name && args.name !== 'quality' ? args.name : null;
+      const comment = args.comment ? String(args.comment) : '';
+
+      if (numericValue < SCORE_POOR_THRESHOLD) {
+        addObservation(rootDir, {
+          role: agentName ?? 'construct',
+          category: 'anti-pattern',
+          summary: `Low quality score (${numericValue.toFixed(2)}) on trace ${traceId.slice(0, 8)}${comment ? `: ${comment}` : ''}`,
+          content: `Trace: ${traceId}\nScore: ${numericValue}\nComment: ${comment || 'none'}\nAgent: ${agentName ?? 'unknown'}\nRecorded at: ${new Date().toISOString()}`,
+          tags: ['quality-score', 'low-score', agentName].filter(Boolean),
+          confidence: 0.8,
+          source: 'cx_score',
+        });
+      } else if (numericValue >= SCORE_GOOD_THRESHOLD) {
+        addObservation(rootDir, {
+          role: agentName ?? 'construct',
+          category: 'pattern',
+          summary: `High quality score (${numericValue.toFixed(2)}) on trace ${traceId.slice(0, 8)}${comment ? `: ${comment}` : ''}`,
+          content: `Trace: ${traceId}\nScore: ${numericValue}\nComment: ${comment || 'none'}\nAgent: ${agentName ?? 'unknown'}\nRecorded at: ${new Date().toISOString()}`,
+          tags: ['quality-score', 'high-score', agentName].filter(Boolean),
+          confidence: 0.75,
+          source: 'cx_score',
+        });
+      }
+    }
+
+    return { ok: true, traceId };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+export async function sessionUsage(args, { ROOT_DIR }) {
+  const cwd = args.cwd ? resolve(String(args.cwd)) : process.cwd();
+  const homeDir = args.home_dir ? resolve(args.home_dir) : homedir();
+  const status = await buildStatus({ rootDir: ROOT_DIR, cwd, homeDir, env: process.env });
+  return {
+    cwd,
+    sessionUsage: status.sessionUsage,
+  };
+}
+
+export function efficiencySnapshot(args) {
+  const homeDir = args.home_dir ? resolve(String(args.home_dir)) : homedir();
+  const stats = readEfficiencyLog(homeDir);
+  const digest = buildCompactEfficiencyDigest(stats);
+  return digest || { status: 'unavailable', summary: 'No read-efficiency data recorded yet' };
+}

package/lib/mcp/tools/workflow.mjs

@@ -0,0 +1,112 @@
+/**
+ * lib/mcp/tools/workflow.mjs — Workflow MCP tools: status, init, add/update tasks, validate, and import plan.
+ *
+ * All functions are synchronous. Wraps lib/workflow-state.mjs.
+ * workflowStatus is located in project.mjs because it also builds publicHealth context.
+ */
+import { resolve } from 'node:path';
+import {
+  addTask,
+  addTaskFromIntent,
+  addTasksFromPlan,
+  createNeedsMainInputPacket,
+  initWorkflow,
+  loadWorkflow,
+  summarizeWorkflow,
+  updateTask,
+  validateWorkflowState,
+} from '../../workflow-state.mjs';
+
+export function workflowInit(args) {
+  const cwd = args.cwd ? resolve(args.cwd) : process.cwd();
+  const title = args.title || 'Untitled workflow';
+  const { workflow, created } = initWorkflow(cwd, title, args.spec_ref ?? null);
+  return { cwd, created, workflow, summary: summarizeWorkflow(workflow) };
+}
+
+export function workflowAddTask(args) {
+  const cwd = args.cwd ? resolve(args.cwd) : process.cwd();
+  if (args.request) {
+    const workflow = addTaskFromIntent(cwd, args.request, {
+      key: args.key,
+      title: args.title,
+      phase: args.phase,
+      owner: args.owner,
+      files: args.files,
+      readFirst: args.readFirst,
+      doNotChange: args.doNotChange,
+      acceptanceCriteria: args.acceptanceCriteria,
+      verification: args.verification,
+      overlays: args.overlays,
+      challengeRequired: args.challengeRequired,
+      challengeStatus: args.challengeStatus,
+      tokenBudget: args.tokenBudget,
+      status: args.status,
+    });
+    if (!workflow) return { ok: true, skipped: true, reason: 'immediate-track' };
+    return { cwd, workflow, summary: summarizeWorkflow(workflow), source: 'intent' };
+  }
+  const workflow = addTask(cwd, {
+    key: args.key,
+    title: args.title,
+    phase: args.phase,
+    owner: args.owner,
+    files: args.files,
+    readFirst: args.readFirst,
+    doNotChange: args.doNotChange,
+    acceptanceCriteria: args.acceptanceCriteria,
+    verification: args.verification,
+    dependsOn: args.dependsOn,
+    overlays: args.overlays,
+    challengeRequired: args.challengeRequired,
+    challengeStatus: args.challengeStatus,
+  });
+  return { cwd, workflow, summary: summarizeWorkflow(workflow), source: 'manual' };
+}
+
+export function workflowUpdateTask(args) {
+  const cwd = args.cwd ? resolve(args.cwd) : process.cwd();
+  const workflow = updateTask(cwd, args.key, {
+    status: args.status,
+    owner: args.owner,
+    phase: args.phase,
+    note: args.note,
+    verification: args.verification,
+    overlays: args.overlays,
+    challengeRequired: args.challengeRequired,
+    challengeStatus: args.challengeStatus,
+  });
+  return { cwd, workflow, summary: summarizeWorkflow(workflow) };
+}
+
+export function workflowNeedsMainInput(args) {
+  const cwd = args.cwd ? resolve(args.cwd) : process.cwd();
+  const packet = createNeedsMainInputPacket(args);
+  const workflow = updateTask(cwd, args.taskKey, {
+    status: 'blocked_needs_user',
+    note: `${packet.worker}: ${packet.blocker} | question: ${packet.question}`,
+  });
+  return { cwd, packet, workflow, summary: summarizeWorkflow(workflow) };
+}
+
+export function workflowValidate(args) {
+  const cwd = args.cwd ? resolve(args.cwd) : process.cwd();
+  const workflow = loadWorkflow(cwd);
+  const result = validateWorkflowState(workflow);
+  return { cwd, ...result };
+}
+
+export function workflowImportPlan(args) {
+  const cwd = args.cwd ? resolve(args.cwd) : process.cwd();
+  const markdown = args.markdown ?? '';
+  const { workflow, count } = addTasksFromPlan(cwd, markdown, {
+    phase: args.phase,
+    owner: args.owner,
+    readFirst: Array.isArray(args.readFirst) ? args.readFirst : undefined,
+    doNotChange: Array.isArray(args.doNotChange) ? args.doNotChange : undefined,
+    acceptanceCriteria: Array.isArray(args.acceptanceCriteria) ? args.acceptanceCriteria : undefined,
+    workflowTitle: args.title,
+    specRef: args.spec_ref,
+  });
+  return { cwd, count, workflow, summary: summarizeWorkflow(workflow) };
+}

package/lib/mcp-catalog.json

@@ -14,6 +14,11 @@
       ],
       "env": {},
       "requiredEnv": [],
+      "hostSupport": {
+        "claude": { "mode": "managed" },
+        "opencode": { "mode": "managed" },
+        "codex": { "mode": "managed" }
+      },
       "usedBy": [
         "cx-docs-researcher",
         "cx-engineer",
@@ -34,6 +39,11 @@
       ],
       "env": {},
       "requiredEnv": [],
+      "hostSupport": {
+        "claude": { "mode": "managed" },
+        "opencode": { "mode": "managed" },
+        "codex": { "mode": "managed" }
+      },
       "usedBy": [
         "construct",
         "cx-architect",
@@ -45,7 +55,7 @@
       "id": "memory",
       "name": "Memory",
       "category": "optional",
-      "description": "Persistent cross-session knowledge graph. Agents remember decisions and findings across sessions.",
+      "description": "cass-memory over HTTP. Persistent cross-session and cross-agent memory for decisions, findings, and handoffs.",
       "type": "url",
       "url": "http://127.0.0.1:8765/",
       "env": {},
@@ -54,12 +64,18 @@
         "auto",
         "manual"
       ],
+      "hostSupport": {
+        "claude": { "mode": "unsupported", "label": "construct-mcp (project .mcp.json)" },
+        "opencode": { "mode": "unsupported", "label": "construct-mcp (stdio)" },
+        "codex": { "mode": "unsupported", "label": "construct-mcp / local observation tools" }
+      },
+      "setupNote": "Claude Code and Codex reject the cass-memory HTTP endpoint because `cm serve` skips the MCP `initialize` handshake. On Claude, memory tools (memory_search, memory_add_observations, memory_recent, memory_create_entities) are exposed through the project-local construct-mcp stdio server in .mcp.json. OpenCode does not support the cass-memory HTTP endpoint (SSE transport fails with 405) — use construct-mcp stdio server instead, which wraps memory tools correctly.",
       "usedBy": [
         "construct",
         "cx-docs-keeper",
         "cx-researcher"
       ],
-      "degradedMessage": "No cross-session memory. Each session starts fresh with no prior context."
+      "degradedMessage": "No cass-memory service. Each session starts fresh with no prior context or shared cross-agent memory."
     },
     {
       "id": "playwright",
@@ -74,6 +90,11 @@
       ],
       "env": {},
       "requiredEnv": [],
+      "hostSupport": {
+        "claude": { "mode": "managed" },
+        "opencode": { "mode": "managed" },
+        "codex": { "mode": "managed" }
+      },
       "usedBy": [
         "construct",
         "cx-qa",
@@ -84,6 +105,7 @@
     {
       "id": "github",
       "name": "GitHub",
+      "aliases": ["github-mcp", "github-mcp-server"],
       "category": "optional",
       "description": "GitHub API: issues, PRs, code search, repository operations.",
       "type": "url",
@@ -99,8 +121,13 @@
         "auto",
         "manual"
       ],
+      "hostSupport": {
+        "claude": { "mode": "managed" },
+        "opencode": { "mode": "managed" },
+        "codex": { "mode": "plugin", "plugin": "github@openai-curated", "label": "Codex Plugin" }
+      },
       "setupUrl": null,
-      "setupNote": "Run 'gh auth login' to authenticate via browser, then re-run 'construct mcp add github'. The token is sourced from the gh CLI automatically.",
+      "setupNote": "Run 'gh auth login' to authenticate via browser, then re-run 'construct mcp add github'. Construct wires Claude Code and OpenCode directly. In Codex, use the built-in GitHub plugin/app path instead of a standalone GitHub MCP server.",
       "usedBy": [
         "construct",
         "cx-engineer",
@@ -112,6 +139,7 @@
     {
       "id": "atlassian",
       "name": "Atlassian (Jira + Confluence)",
+      "aliases": ["atlassian-mcp-server", "atlassian-mcp"],
       "category": "integration",
       "description": "Jira issue tracking and Confluence wiki access via Atlassian's official remote MCP server. OAuth is handled by each MCP client.",
       "type": "url",
@@ -121,6 +149,11 @@
       "setupModes": [
         "auto"
       ],
+      "hostSupport": {
+        "claude": { "mode": "managed" },
+        "opencode": { "mode": "managed" },
+        "codex": { "mode": "managed" }
+      },
       "setupNote": "Uses Atlassian's official remote MCP server with OAuth 2.1. Browser auth prompt appears on first use. Requires a Rovo license on your Atlassian account.",
       "usedBy": [
         "cx-product-manager",
@@ -133,6 +166,7 @@
     {
       "id": "linear",
       "name": "Linear",
+      "aliases": ["linear-mcp", "linear-mcp-server"],
       "category": "integration",
       "description": "Linear issue tracking — create issues, update status, search projects.",
       "package": "@linear/mcp-server",
@@ -150,6 +184,11 @@
       "setupModes": [
         "manual"
       ],
+      "hostSupport": {
+        "claude": { "mode": "managed" },
+        "opencode": { "mode": "managed" },
+        "codex": { "mode": "managed" }
+      },
       "setupUrl": "https://linear.app/settings/api",
       "setupNote": "Generate a personal API key at linear.app/settings/api.",
       "usedBy": [
@@ -162,6 +201,7 @@
     {
       "id": "slack",
       "name": "Slack",
+      "aliases": ["slack-mcp", "slack-mcp-server"],
       "category": "integration",
       "description": "Slack messaging — send messages, read channels, search conversations.",
       "package": "@modelcontextprotocol/server-slack",
@@ -181,6 +221,11 @@
       "setupModes": [
         "manual"
       ],
+      "hostSupport": {
+        "claude": { "mode": "managed" },
+        "opencode": { "mode": "managed" },
+        "codex": { "mode": "managed" }
+      },
       "setupUrl": "https://api.slack.com/apps",
       "setupNote": "Create a Slack app at api.slack.com/apps. Add Bot Token Scopes: channels:read, chat:write, channels:history.",
       "usedBy": [
@@ -193,6 +238,7 @@
     {
       "id": "notion",
       "name": "Notion",
+      "aliases": ["notion-mcp", "claude_ai_Notion"],
       "category": "integration",
       "description": "Notion workspace access — read/write pages, databases, and comments.",
       "package": "@anthropic-ai/notion-mcp",
@@ -210,6 +256,11 @@
       "setupModes": [
         "manual"
       ],
+      "hostSupport": {
+        "claude": { "mode": "managed" },
+        "opencode": { "mode": "managed" },
+        "codex": { "mode": "managed" }
+      },
       "setupUrl": "https://www.notion.so/profile/integrations",
       "setupNote": "Create an integration at notion.so/profile/integrations. Share target pages/databases with the integration.",
       "usedBy": [