geotechcli 0.4.76 → 0.4.78

package/dist/commands/ai.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ai.d.ts","sourceRoot":"","sources":["../../src/commands/ai.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAolDpC,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAmU5D;AAMD,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAwChE;AAMD,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAgDzD;AA4GD,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAuX3D;AAMD,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA0J1D;AAMD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAuF5D"}
+{"version":3,"file":"ai.d.ts","sourceRoot":"","sources":["../../src/commands/ai.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAw3DpC,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAmU5D;AAMD,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAwChE;AAMD,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAgDzD;AA4GD,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAuX3D;AAMD,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA0J1D;AAMD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAuF5D"}

package/dist/commands/ai.js

@@ -3,7 +3,7 @@ import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } fr
 import { join, relative, resolve } from 'node:path';
 import chalk from 'chalk';
 import ora from 'ora';
-import { buildLLMConfig, DEFAULT_LLM_VISION_MODEL, analyzeCoreBox, classifyRMRFromImage, classifySoilFromDescription, ingestBoreholeLogDocument, inspectPdfDocument, queryGBRDocument, interpretSensorImage, runAgent, runSwarm, AgentConversation, loadProject, getProjectAgentContext, addAgentSession, addArtifact, addNote, saveNamedDataset, saveDerivedParameter, setActiveAnalysisContext, generateReport, generateReportFromCaseFile, buildProjectWorkflowReport, renderReportAsPdf, renderReportAsDocx, buildSwarmSessionProjectRecord, persistSwarmCaseFile, persistCaseFileEvidence, analyzeWorkspace, resolveWorkspaceRoot, buildProjectWorkflowRouterPrompt, generateText, routeProjectWorkflowRequest, runProjectWorkflow, } from '@geotechcli/core';
+import { buildLLMConfig, DEFAULT_LLM_VISION_MODEL, analyzeCoreBox, classifyRMRFromImage, classifySoilFromDescription, ingestBoreholeLogDocument, inspectPdfDocument, queryGBRDocument, interpretSensorImage, runAgent, runSwarm, AgentConversation, loadProject, getProjectAgentContext, addAgentSession, addArtifact, addNote, saveNamedDataset, saveDerivedParameter, setActiveAnalysisContext, generateReport, generateReportFromCaseFile, buildProjectWorkflowReport, renderReportAsPdf, renderReportAsDocx, buildSwarmSessionProjectRecord, persistSwarmCaseFile, persistCaseFileEvidence, analyzeWorkspace, resolveWorkspaceRoot, buildProjectWorkflowRouterPrompt, generateText, routeProjectWorkflowRequest, runProjectWorkflow, analyzeSignalFile, } from '@geotechcli/core';
 import { heading, keyValue, renderJSON, renderRichText, success, error, warn, renderTable, info } from '../ui/terminal.js';
 import { addGlobalFlags, getGlobalFlags } from '../util/flags.js';
 import { estimateHostedBetaVisionBodyBytes, formatByteSize, HOSTED_BETA_REQUEST_LIMIT_BYTES, readVisionInput, readVisionPdfPageInputs, resolveStructuredOutputTarget, HOSTED_BETA_REQUEST_SAFE_BYTES, } from '../util/vision-output.js';
@@ -29,6 +29,8 @@ function summarizeWorkspaceManifestForAgent(manifest) {
             'Calculation/verifier pre-check:',
             `- Status: ${manifest.verifier.status}`,
             `- Findings: ${manifest.verifier.summary.blocking} blocking, ${manifest.verifier.summary.review} review, ${manifest.verifier.summary.info} info`,
+            `- Calculation routes: ${manifest.verifier.calculationReadiness.summary.ready} ready, ${manifest.verifier.calculationReadiness.summary.readyWithAssumptions} assumption-bound, ${manifest.verifier.calculationReadiness.summary.blocked} blocked`,
+            ...manifest.verifier.calculationReadiness.workflows.slice(0, 8).map((workflow) => `- ${workflow.workflow}: ${workflow.status}; missing=${workflow.missing.join(', ') || 'none'}; command=${workflow.commandTemplate}`),
             ...manifest.verifier.findings.slice(0, 8).map((finding) => `- ${finding.severity}/${finding.code}: ${finding.message}`),
         ].join('\n')
         : '';
@@ -79,6 +81,11 @@ const PROJECT_AGENT_TASKS = [
         label: 'Ground-model interpretation',
         prompt: 'Interpret the evidence-bound GroundModel from the attached workspace manifest. Summarize strata, groundwater, uncertainty, and what engineering workflows are ready.',
     },
+    {
+        task: 'calculation-readiness',
+        label: 'Calculation readiness and draft routing',
+        prompt: 'Summarize calculation readiness from the attached workspace manifest. Separate ready, assumption-bound, and blocked bearing, settlement, pile, liquefaction, slope, and FEM draft workflows. Recommend only validated deterministic GeotechCLI commands and missing user inputs.',
+    },
     {
         task: 'risk-analysis',
         label: 'Risk analysis',
@@ -94,6 +101,11 @@ const PROJECT_AGENT_TASKS = [
         label: 'Preliminary recommendations',
         prompt: 'Prepare preliminary geotechnical recommendations from the attached workspace manifest. Clearly mark what is evidence-backed, assumption-bound, or blocked by missing inputs.',
     },
+    {
+        task: 'signal-analysis',
+        label: 'Signal analysis',
+        prompt: 'Route monitoring, instrumentation, settlement, piezometer, inclinometer, vibration, and load-test files into deterministic geotech signal analyze commands. Summarize available sources, missing threshold assumptions, and review gates without inventing signal metrics.',
+    },
     {
         task: 'visualization',
         label: 'Visualizations and maps',
@@ -138,6 +150,46 @@ function normalizeProjectTask(value) {
         case 'interpretation':
         case 'ground-model-interpretation':
             return 'ground-model';
+        case 'calculation':
+        case 'calculations':
+        case 'calculation-readiness':
+        case 'calculation-routing':
+        case 'calc-readiness':
+        case 'design-readiness':
+        case 'bearing':
+        case 'bearing-capacity':
+        case 'settlement':
+        case 'pile':
+        case 'pile-capacity':
+        case 'liquefaction':
+        case 'slope':
+        case 'slope-stability':
+        case 'fem-readiness':
+        case 'fem-foundation':
+        case 'fem-foundation-settlement':
+        case 'fem-excavation':
+        case 'fem-excavation-deformation':
+        case 'fem-tunnel':
+        case 'fem-tunnel-settlement':
+        case 'fem-tunnel-volume-loss-settlement':
+        case 'fem-shaft':
+        case 'fem-shaft-deformation':
+        case 'fem-pile-group':
+        case 'fem-pile-group-elastic-interaction':
+        case 'fem-slope':
+        case 'fem-slope-embankment':
+        case 'fem-slope-embankment-deformation':
+        case 'fem-embankment':
+        case 'fem-retaining-wall':
+        case 'fem-retaining-wall-excavation-support':
+        case 'fem-excavation-support':
+        case 'fem-seepage':
+        case 'fem-seepage-groundwater-coupling':
+        case 'fem-groundwater-coupling':
+        case 'fem-staged-settlement':
+        case 'fem-staged-settlement-consolidation':
+        case 'fem-consolidation':
+            return 'calculation-readiness';
         case 'risk':
         case 'risk-analysis':
             return 'risk-analysis';
@@ -149,6 +201,24 @@ function normalizeProjectTask(value) {
         case 'recommendations':
         case 'foundation-recommendations':
             return 'recommendations';
+        case 'signal':
+        case 'signals':
+        case 'signal-analysis':
+        case 'signal-analytics':
+        case 'monitoring':
+        case 'monitoring-analysis':
+        case 'time-series':
+        case 'timeseries':
+        case 'instrumentation':
+        case 'piezometer':
+        case 'piezometers':
+        case 'inclinometer':
+        case 'inclinometers':
+        case 'vibration':
+        case 'load-test':
+        case 'load-tests':
+        case 'pile-load-test':
+            return 'signal-analysis';
         case 'viz':
         case 'visualize':
         case 'visualization':
@@ -162,7 +232,9 @@ function normalizeProjectTask(value) {
     }
 }
 function projectTaskPrompt(task, customPrompt) {
-    const taskDef = PROJECT_AGENT_TASKS.find((item) => item.task === task) ?? PROJECT_AGENT_TASKS[6];
+    const taskDef = PROJECT_AGENT_TASKS.find((item) => item.task === task)
+        ?? PROJECT_AGENT_TASKS.find((item) => item.task === 'custom-question')
+        ?? PROJECT_AGENT_TASKS[0];
     if (task === 'custom-question' && customPrompt?.trim()) {
         return `Project-aware custom question: ${customPrompt.trim()}`;
     }
@@ -198,9 +270,11 @@ function inferProjectIntent(rawPrompt, selectedTask) {
     };
     add('data-quality', /\b(?:data quality|inventory|missing data|quality report|duplicate)\b/);
     add('ground-model', /\b(?:ground model|interpret|strata|stratigraphy|lithology|hydrogeology)\b/);
+    add('calculation-readiness', /\b(?:calculation readiness|calculation route|calculation routing|design readiness|design route|bearing(?: capacity| calculation| readiness)?|settlement(?: calculation| readiness| design| route| workflow)|pile(?: capacity| calculation| readiness)?|liquefaction(?: calculation| readiness)?|slope(?: stability| calculation| readiness)?|fem(?: draft| readiness| foundation settlement| excavation deformation)?|ready for calculation|ready for design)\b/);
     add('risk-analysis', /\b(?:risk|hazard|limitation|uncertainty|mitigation)\b/);
     add('anomaly-detection', /\b(?:anomal\w*|conflict|outlier|inconsistent|inconsistency)\b/);
     add('recommendations', /\b(?:recommend|foundation option|advice|next action)\b/);
+    add('signal-analysis', /\b(?:signal analysis|signal analytics|monitoring analysis|time[-\s]?series|instrumentation|piezometer|pore pressure|inclinometer|vibration|accelerometer|settlement monitoring|monitoring trend|threshold|trigger level|load[-\s]?test)\b/);
     add('visualization', /\b(?:visual\w*|map|plot|chart|section|profile|strip log)\b/);
     const uniqueTasks = [...new Set(tasks)];
     if (uniqueTasks.length === 0) {
@@ -224,6 +298,9 @@ function projectReadinessFromManifest(manifest) {
     const hasGroundModel = Boolean(manifest.groundModel && manifest.groundModel.stats.evidenceRefs > 0);
     const hasCoordinates = Boolean(manifest.groundModel?.map?.points?.length);
     const hasVerifier = Boolean(manifest.verifier);
+    const signalSources = (manifest.summary.datasetTypes['monitoring-time-series'] ?? 0)
+        + (manifest.summary.datasetTypes['signal-record'] ?? 0)
+        + (manifest.summary.datasetTypes['pile-load-test'] ?? 0);
     const calculationWorkflows = manifest.verifier?.calculationReadiness.workflows ?? [];
     const readyWorkflowCount = calculationWorkflows.filter((workflow) => workflow.status !== 'blocked').length;
     const verifierMissing = calculationWorkflows.flatMap((workflow) => workflow.missing).slice(0, 8);
@@ -256,6 +333,15 @@ function projectReadinessFromManifest(manifest) {
                 : ['Risk analysis needs GroundModel verification output.'],
             missing: hasVerifier ? verifierMissing : ['GroundModel verifier output'],
         },
+        {
+            task: 'calculation-readiness',
+            label: 'Calculation readiness and draft routing',
+            status: readyWorkflowCount > 0 ? 'partially_ready' : hasVerifier ? 'blocked' : 'blocked',
+            reasons: hasVerifier
+                ? [`${readyWorkflowCount} calculation workflow(s) are ready or assumption-bound; ${calculationWorkflows.filter((workflow) => workflow.status === 'blocked').length} blocked.`]
+                : ['Calculation readiness needs GroundModel verifier output.'],
+            missing: hasVerifier ? verifierMissing : ['GroundModel verifier output'],
+        },
         {
             task: 'anomaly-detection',
             label: 'Anomaly detection / data conflicts',
@@ -274,6 +360,15 @@ function projectReadinessFromManifest(manifest) {
                 : ['No downstream calculation workflow is ready yet.'],
             missing: verifierMissing,
         },
+        {
+            task: 'signal-analysis',
+            label: 'Signal analysis',
+            status: signalSources > 0 ? 'partially_ready' : 'blocked',
+            reasons: signalSources > 0
+                ? [`${signalSources} monitoring/signal/load-test source(s) can be routed into deterministic signal analysis.`]
+                : ['Signal analysis needs settlement, piezometer, inclinometer, vibration, load-test, or time-series data.'],
+            missing: signalSources > 0 ? ['project-specific thresholds / trigger levels'] : ['monitoring/signal CSV, TSV, or XLSX files'],
+        },
         {
             task: 'visualization',
             label: 'Visualizations and maps',
@@ -490,6 +585,177 @@ function relativeArtifactPath(rootPath, filePath) {
     const rel = relative(rootPath, filePath);
     return rel && !rel.startsWith('..') ? rel : filePath;
 }
+const SIGNAL_WORKFLOW_DATASET_TYPES = new Set(['monitoring-time-series', 'signal-record', 'pile-load-test']);
+function detectSignalWorkflowSources(manifest) {
+    const sources = [];
+    const seen = new Set();
+    for (const file of manifest.files) {
+        const schemas = file.schemas ?? [];
+        const matchingSchemas = schemas.filter((schema) => SIGNAL_WORKFLOW_DATASET_TYPES.has(schema.datasetType));
+        if (matchingSchemas.length > 0) {
+            for (const schema of matchingSchemas) {
+                const key = `${file.absolutePath}#${schema.sheetName ?? ''}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                sources.push({
+                    file,
+                    label: schema.sheetName ? `${file.path}#${schema.sheetName}` : file.path,
+                    signalType: inferSignalWorkflowType(file, schema),
+                    sheetName: schema.sheetName,
+                });
+            }
+            continue;
+        }
+        if (SIGNAL_WORKFLOW_DATASET_TYPES.has(file.classification.datasetType)) {
+            const key = `${file.absolutePath}#`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            sources.push({
+                file,
+                label: file.path,
+                signalType: inferSignalWorkflowType(file),
+            });
+        }
+    }
+    return sources;
+}
+function inferSignalWorkflowType(file, schema) {
+    if (schema?.datasetType === 'pile-load-test' || file.classification.datasetType === 'pile-load-test')
+        return 'load-test';
+    const roles = new Set(schema?.columns.flatMap((column) => column.roles) ?? []);
+    if (roles.has('settlement'))
+        return 'settlement';
+    if (roles.has('pore_pressure'))
+        return 'piezometer';
+    if (roles.has('inclination'))
+        return 'inclinometer';
+    if (roles.has('vibration'))
+        return 'vibration';
+    const text = [file.path, file.classification.datasetType, ...file.classification.signals].join(' ').toLowerCase();
+    if (/\b(load[-_\s]?test|pile[-_\s]?load)\b/.test(text))
+        return 'load-test';
+    if (/\b(settlement|heave|subsidence)\b/.test(text))
+        return 'settlement';
+    if (/\b(piezometer|pore[-_\s]?pressure|groundwater|water[-_\s]?level)\b/.test(text))
+        return 'piezometer';
+    if (/\b(inclinometer|inclination|tilt|deflection)\b/.test(text))
+        return 'inclinometer';
+    if (/\b(vibration|accelerometer|seismic|fft|psd)\b/.test(text))
+        return 'vibration';
+    return 'unknown';
+}
+function signalArtifactSlug(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 64) || 'signal';
+}
+async function persistSignalAnalysisArtifacts(options) {
+    if (options.workflowRun.task !== 'signal-analysis')
+        return;
+    const sources = detectSignalWorkflowSources(options.manifest).slice(0, 12);
+    if (sources.length === 0)
+        return;
+    const signalDir = join(options.runDir, 'signals');
+    mkdirSync(signalDir, { recursive: true });
+    const indexEntries = [];
+    let successCount = 0;
+    let failureCount = 0;
+    for (const [index, source] of sources.entries()) {
+        const artifactPath = join(signalDir, `${String(index + 1).padStart(2, '0')}-${signalArtifactSlug(source.label)}.analysis.json`);
+        const analyzeOptions = {
+            ...(source.signalType !== 'unknown' ? { type: source.signalType } : {}),
+            ...(source.sheetName ? { sheetName: source.sheetName } : {}),
+            maxRows: 5000,
+        };
+        try {
+            const result = await analyzeSignalFile(source.file.absolutePath, analyzeOptions);
+            writeFileSync(artifactPath, JSON.stringify(result, null, 2), 'utf-8');
+            successCount += 1;
+            const relativePath = relativeArtifactPath(options.plan.workspace.rootPath, artifactPath);
+            const status = result.warnings.length > 0 ? 'review' : 'pass';
+            indexEntries.push({
+                source: source.file.path,
+                absolutePath: source.file.absolutePath,
+                sheetName: source.sheetName,
+                status,
+                signalType: result.signalType,
+                rowsAnalyzed: result.source.rowsAnalyzed,
+                rowsRejected: result.source.rowsRejected,
+                series: result.series.length,
+                thresholdFlags: result.thresholdFlags.length,
+                missingIntervals: result.missingIntervals.length,
+                warnings: result.warnings,
+                artifact: relativePath,
+            });
+            options.workflowRun.artifacts.push({
+                kind: 'json',
+                path: relativePath,
+                description: `Deterministic signal analysis for ${source.label}`,
+            });
+            options.workflowRun.trace.steps.push({
+                type: 'tool_call',
+                name: 'signal.analyze_file',
+                status,
+                detail: `Analyzed ${source.label} into ${relativePath}.`,
+            });
+            options.workflowRun.toolCalls.push({
+                type: 'tool_call',
+                tool: 'signal.analyze_file',
+                status,
+                summary: `Analyzed ${source.label}: ${result.source.rowsAnalyzed} rows, ${result.series.length} series, ${result.thresholdFlags.length} threshold flag(s), ${result.missingIntervals.length} missing interval(s).`,
+            });
+        }
+        catch (err) {
+            failureCount += 1;
+            const message = err instanceof Error ? err.message : String(err);
+            indexEntries.push({
+                source: source.file.path,
+                absolutePath: source.file.absolutePath,
+                sheetName: source.sheetName,
+                status: 'blocked',
+                signalType: source.signalType,
+                error: message,
+            });
+            options.workflowRun.trace.steps.push({
+                type: 'tool_call',
+                name: 'signal.analyze_file',
+                status: 'blocked',
+                detail: `Could not analyze ${source.label}: ${message}`,
+            });
+            options.workflowRun.toolCalls.push({
+                type: 'tool_call',
+                tool: 'signal.analyze_file',
+                status: 'blocked',
+                summary: `Could not analyze ${source.label}: ${message}`,
+            });
+        }
+    }
+    if (failureCount > 0) {
+        options.workflowRun.status = successCount > 0 && options.workflowRun.status !== 'blocked' ? 'review' : 'blocked';
+    }
+    const indexPath = join(signalDir, 'index.json');
+    const indexPayload = {
+        schemaVersion: 'geotech.signal-analysis-artifact-index.v1',
+        generatedAt: options.workflowRun.generatedAt,
+        runId: options.workflowRun.runId,
+        task: options.workflowRun.task,
+        sources: indexEntries,
+    };
+    writeFileSync(indexPath, JSON.stringify(indexPayload, null, 2), 'utf-8');
+    const relativeIndexPath = relativeArtifactPath(options.plan.workspace.rootPath, indexPath);
+    options.workflowRun.artifacts.push({
+        kind: 'json',
+        path: relativeIndexPath,
+        description: 'Deterministic signal analysis artifact index',
+    });
+    options.workflowRun.summary.push(`Signal analyses persisted: ${successCount}/${sources.length} source(s) under ${relativeArtifactPath(options.plan.workspace.rootPath, signalDir)}.`);
+    options.workflowRun.toolCalls.push({
+        type: 'tool_call',
+        tool: 'signal.analysis_artifacts',
+        status: failureCount > 0 ? 'review' : 'pass',
+        summary: `Persisted ${successCount}/${sources.length} deterministic signal analysis artifact(s).`,
+    });
+}
 async function requestProjectWorkflowRouteProposal(options) {
     const routePrompt = buildProjectWorkflowRouterPrompt({
         prompt: options.prompt,
@@ -573,7 +839,7 @@ function renderProjectAwarePlan(plan, flags) {
     }
     console.log('');
     warn('No model-heavy workflow has run yet. Choose a task with --task, or ask a project question with --workspace.');
-    console.log(chalk.gray('  Next actions: geotech agent --task data-quality | --task ground-model | --task risk-analysis | --task anomaly-detection | --task recommendations | --task visualization'));
+    console.log(chalk.gray('  Next actions: geotech agent --task data-quality | --task ground-model | --task calculation-readiness | --task risk-analysis | --task anomaly-detection | --task recommendations | --task signal-analysis | --task visualization'));
     success(`Project state written to ${relativeArtifactPath(plan.workspace.rootPath, join(plan.workspace.rootPath, '.geotech'))}`);
 }
 async function renderAndPersistProjectWorkflow(plan, manifest, task, flags) {
@@ -583,11 +849,12 @@ async function renderAndPersistProjectWorkflow(plan, manifest, task, flags) {
         runId: plan.runId,
         now: plan.project.generatedAt,
     });
-    const report = buildProjectWorkflowReport(workflowRun);
     const runDir = join(plan.workspace.rootPath, '.geotech', 'runs', plan.runId);
     const resultPath = join(runDir, 'workflow_result.json');
     const reportPath = join(runDir, 'workflow_report.md');
     const tracePath = join(runDir, 'workflow_trace.json');
+    await persistSignalAnalysisArtifacts({ plan, manifest, workflowRun, runDir });
+    const report = buildProjectWorkflowReport(workflowRun);
     writeFileSync(resultPath, JSON.stringify(workflowRun, null, 2), 'utf-8');
     writeFileSync(reportPath, report.fullMarkdown, 'utf-8');
     writeFileSync(tracePath, JSON.stringify(workflowRun.trace, null, 2), 'utf-8');
@@ -660,12 +927,13 @@ async function renderAndPersistProjectWorkflowRoute(plan, manifest, route, flags
             runId: workflowRunId,
             now: plan.project.generatedAt,
         });
-        const report = buildProjectWorkflowReport(workflowRun);
         const runDir = join(plan.workspace.rootPath, '.geotech', 'runs', workflowRun.runId);
         mkdirSync(runDir, { recursive: true });
         const resultPath = join(runDir, 'workflow_result.json');
         const reportPath = join(runDir, 'workflow_report.md');
         const tracePath = join(runDir, 'workflow_trace.json');
+        await persistSignalAnalysisArtifacts({ plan, manifest, workflowRun, runDir });
+        const report = buildProjectWorkflowReport(workflowRun);
         writeFileSync(resultPath, JSON.stringify(workflowRun, null, 2), 'utf-8');
         writeFileSync(reportPath, report.fullMarkdown, 'utf-8');
         writeFileSync(tracePath, JSON.stringify(workflowRun.trace, null, 2), 'utf-8');
@@ -1791,14 +2059,14 @@ function renderSwarmStep(step, json, quiet = false) {
 }
 export function registerAgentCommand(program) {
     const cmd = new Command('agent')
-        .description('Agentic AI - reasons about your problem and executes real calculations')
+        .description('Agentic AI - routes evidence into deterministic tools; FEM execution remains human-invoked and experimental')
         .argument('[task...]', 'Engineering task in natural language')
         .option('--swarm', 'Use the role-based multi-agent swarm planner and specialist review loop')
         .option('--skills', 'Enable installed skill tools for this session')
         .option('--project <id>', 'Load and persist context to a stored project')
         .option('--workspace <dir>', 'Scan a local workspace and attach its manifest summary to the agent task')
         .option('--no-workspace', 'Disable automatic project-aware workspace discovery')
-        .option('--task <task>', 'Run a project-aware task: data-quality, ground-model, risk-analysis, anomaly-detection, recommendations, visualization')
+        .option('--task <task>', 'Run a project-aware task: data-quality, ground-model, calculation-readiness, risk-analysis, anomaly-detection, recommendations, signal-analysis, visualization')
         .option('--route-with-model', 'Let the configured LLM propose a validated workflow route when deterministic routing needs selection')
         .option('--plan-only', 'Scan the workspace, write .geotech project state, and show workflow readiness without calling an LLM')
         .option('--refresh', 'Refresh the deterministic workspace manifest and .geotech project state')