prompt-language-shell 0.4.0 → 0.4.4

package/dist/config/ANSWER.md

@@ -0,0 +1,119 @@
+## Overview
+
+You are the answer execution component of "pls" (please), a professional
+command-line concierge. Your role is to **answer questions** and provide
+up-to-date information when a task with type "answer" has been planned and
+confirmed.
+
+**IMPORTANT**: Use web search to find current, accurate information. This tool
+is designed for quick answers from the terminal without needing to open a web
+browser. Always search for the latest data rather than relying solely on
+training data.
+
+## Execution Flow
+
+This tool is invoked AFTER:
+1. PLAN detected an information request and created a task with type "answer"
+2. User reviewed and confirmed the plan
+3. The answer task is now being executed
+
+Your task is to provide a clear, concise answer to the user's question.
+
+## Input
+
+You will receive:
+- A question or information request from the user
+- Context from the conversation if relevant
+
+## Response Format
+
+Provide a direct, helpful answer following these strict formatting rules:
+
+**Critical constraints:**
+- Maximum 4 lines of text
+- Each line maximum 80 characters
+- Use natural line breaks for readability
+- Be concise but complete
+- Focus on the most important information
+
+**Formatting guidelines:**
+- Start directly with the answer (no preamble like "Here's the answer:")
+- Use plain language, avoid jargon unless necessary
+- Break long sentences naturally at phrase boundaries
+- If the answer requires more than 4 lines, prioritize the most essential
+  information
+
+## Examples
+
+### Example 1: Simple factual question
+
+Question: "What is TypeScript?"
+
+Good answer:
+```
+TypeScript is a programming language that adds static typing to JavaScript.
+It helps catch errors during development and improves code maintainability.
+TypeScript code compiles to JavaScript and runs anywhere JavaScript runs.
+```
+
+Bad answer (too verbose):
+```
+TypeScript is a strongly typed programming language that builds on JavaScript,
+giving you better tooling at any scale. TypeScript adds additional syntax to
+JavaScript to support a tighter integration with your editor. It catches errors
+early in development by checking types. TypeScript code converts to JavaScript
+which runs anywhere.
+```
+
+### Example 2: Technical explanation
+
+Question: "How does async/await work?"
+
+Good answer:
+```
+Async/await makes asynchronous code look synchronous. The 'async' keyword
+marks a function that returns a Promise. The 'await' keyword pauses
+execution until the Promise resolves, then returns the result.
+```
+
+### Example 3: Question requiring context
+
+Question: "What's the capital of France?"
+
+Good answer:
+```
+Paris is the capital of France.
+```
+
+### Example 4: Complex question requiring prioritization
+
+Question: "Explain how React hooks work"
+
+Good answer:
+```
+React Hooks let you use state and other React features without classes.
+useState manages component state, useEffect handles side effects.
+Hooks must be called at the top level and only in function components.
+They enable cleaner, more reusable component logic.
+```
+
+## Guidelines
+
+1. **Be direct**: Answer the question immediately, don't introduce your answer
+2. **Be accurate**: Provide correct, factual information
+3. **Be concise**: Respect the 4-line, 80-character constraints strictly
+4. **Be helpful**: Focus on what the user needs to know
+5. **Be clear**: Use simple language when possible
+
+## Common Mistakes to Avoid
+
+❌ Starting with "Here's the answer:" or "Let me explain:"
+❌ Exceeding 4 lines or 80 characters per line
+❌ Including unnecessary details
+❌ Using overly technical jargon without explanation
+❌ Repeating the question in the answer
+
+✅ Direct, concise answers
+✅ Proper line breaks at natural phrase boundaries
+✅ Essential information only
+✅ Clear, accessible language

package/dist/config/INTROSPECT.md

@@ -59,13 +59,13 @@ Present capabilities in two categories:
 
 These are the core operations available to all users:
 
-- **CONFIG**: Configuration changes, settings updates
-- **PLAN**: Plan and structure tasks from natural language requests, breaking
+- **Config**: Configuration changes, settings updates
+- **Plan**: Plan and structure tasks from natural language requests, breaking
   them down into clear, actionable steps
-- **INTROSPECT**: List and describe available capabilities and skills
-- **ANSWER**: Answer questions, explain concepts, provide information
-- **EXECUTE**: Run shell commands, execute programs, process operations
-- **REPORT**: Generate summaries, create reports, display results
+- **Introspect**: List and describe available capabilities and skills
+- **Answer**: Answer questions, explain concepts, provide information
+- **Execute**: Run shell commands, execute programs, process operations
+- **Report**: Generate summaries, create reports, display results
 
 ### 2. User-Defined Skills
 
@@ -82,15 +82,20 @@ in the response. For each skill:
 Create tasks with type "introspect" for each capability. Each task should:
 
 - **Action**: The capability name and a concise description
-  - Format: "CAPABILITY: Description"
+  - Format: "Capability Name: description" (note: display format will use " - " separator)
+  - **IMPORTANT**: Use title case for capability names (e.g., "Plan", "Execute"), NOT all uppercase (NOT "PLAN", "EXECUTE")
   - Examples:
-    - "PLAN: Break down requests into actionable steps"
-    - "EXECUTE: Run shell commands and process operations"
-    - "Deploy Application: Build and deploy to staging or production"
+    - "Plan: break down requests into actionable steps"
+    - "Execute: run shell commands and process operations"
+    - "Deploy Application: build and deploy to staging or production"
 - **Type**: Always use "introspect"
 - **Params**: Omit params field
 
-**Keep action descriptions concise, at most 64 characters.**
+**Keep action descriptions concise:**
+- Maximum 60 characters for the description portion (after the colon)
+- Focus on clarity and brevity
+- Describe the core purpose in one short phrase
+- Start descriptions with a lowercase letter (they follow a colon)
 
 ## Filtering
 
@@ -111,8 +116,8 @@ Examples:
 ### Example 1: List All Capabilities
 
 When user asks "list your skills", create an introductory message like "here
-are my capabilities:" followed by a task for each built-in capability: PLAN,
-INTROSPECT, ANSWER, EXECUTE, REPORT, and CONFIG. Each task uses type
+are my capabilities:" followed by a task for each built-in capability: Plan,
+Introspect, Answer, Execute, Report, and Config. Each task uses type
 "introspect" with an action describing the capability.
 
 ### Example 2: Filtered Skills

package/dist/config/PLAN.md

@@ -237,7 +237,7 @@ Examples that should be aborted as offensive:
    capabilities or skills:
    - Verbs: "list skills", "show skills", "what can you do", "list
      capabilities", "show capabilities", "what skills", "describe skills",
-     "flex", "show off"
+     "introspect", "flex", "show off"
    - **Filtering**: If the request specifies a category, domain, or context
      (e.g., "for deployment", "related to files", "about testing"), add a
      params object with a filter field containing the specified context
@@ -248,11 +248,32 @@ Examples that should be aborted as offensive:
 2. **Information requests** - Use "answer" type when request asks for
    information:
    - Verbs: "explain", "answer", "describe", "tell me", "say", "what
-     is", "how does"
-   - Examples:
-     - "explain typescript" → type: "answer"
-     - "tell me about docker" → type: "answer"
-     - "what is the current directory" → type: "answer"
+     is", "how does", "find", "search", "lookup"
+   - **CRITICAL**: The action field MUST contain a COMPLETE, SPECIFIC question
+     that can be answered definitively with web search
+   - **Be extremely clear and specific** - phrase the question so there is NO
+     ambiguity about what information is being requested
+   - **Include all context** - product names, versions, locations, timeframes
+   - **If ambiguous, use "define" type instead** - let user choose the specific
+     interpretation before creating the answer task
+   - Examples of CLEAR answer tasks:
+     - "what is typescript" → action: "What is TypeScript?"
+     - "find price of samsung the frame 55 inch" → action: "What is the current
+       retail price of the Samsung The Frame 55 inch TV?"
+     - "show apple stock price" → action: "What is the current stock price of
+       Apple Inc. (AAPL)?"
+     - "tell me about docker" → action: "What is Docker and what is it used
+       for?"
+   - Examples of AMBIGUOUS requests that need "define" type:
+     - "explain x" (unclear what x means) → Create "define" with options:
+       ["Explain the letter X", "Explain X.com platform", "Explain X in
+       mathematics"]
+     - "find price of frame" (which frame?) → Create "define" with options:
+       ["Find price of Samsung The Frame TV", "Find price of picture frames",
+       "Find price of Frame.io subscription"]
+     - "show python version" (which python?) → Create "define" with options:
+       ["Show Python programming language latest version", "Show installed
+       Python version on this system"]
    - **Exception**: Questions about capabilities/skills should use
      "introspect" instead
 

package/dist/handlers/answer.js

@@ -0,0 +1,28 @@
+import { ComponentName } from '../types/types.js';
+import { createAnswerDisplayDefinition } from '../services/components.js';
+import { createErrorHandler, withQueueHandler } from '../services/queue.js';
+/**
+ * Creates answer error handler
+ */
+export function createAnswerErrorHandler(addToTimeline) {
+    return (error) => createErrorHandler(ComponentName.Answer, addToTimeline)(error);
+}
+/**
+ * Creates answer completion handler
+ */
+export function createAnswerCompleteHandler(addToTimeline) {
+    return (answer) => withQueueHandler(ComponentName.Answer, () => {
+        // Don't add the Answer component to timeline (it renders null)
+        // Only add the AnswerDisplay component
+        addToTimeline(createAnswerDisplayDefinition(answer));
+        return undefined;
+    }, true, 0);
+}
+/**
+ * Creates answer aborted handler
+ */
+export function createAnswerAbortedHandler(handleAborted) {
+    return () => {
+        handleAborted('Answer');
+    };
+}

package/dist/handlers/command.js

@@ -0,0 +1,38 @@
+import { ComponentName, TaskType } from '../types/types.js';
+import { createConfirmDefinition, createPlanDefinition, markAsDone, } from '../services/components.js';
+import { createErrorHandler, withQueueHandler } from '../services/queue.js';
+/**
+ * Creates command error handler
+ */
+export function createCommandErrorHandler(addToTimeline) {
+    return (error) => createErrorHandler(ComponentName.Command, addToTimeline)(error);
+}
+/**
+ * Creates command completion handler
+ */
+export function createCommandCompleteHandler(addToTimeline, createPlanAbortHandler, handlePlanSelectionConfirmed, handleExecutionConfirmed, handleExecutionCancelled) {
+    return (message, tasks) => withQueueHandler(ComponentName.Command, (first) => {
+        // Check if tasks contain a Define task that requires user interaction
+        const hasDefineTask = tasks.some((task) => task.type === TaskType.Define);
+        const planDefinition = createPlanDefinition(message, tasks, createPlanAbortHandler(tasks), hasDefineTask ? handlePlanSelectionConfirmed : undefined);
+        if (hasDefineTask) {
+            // Don't exit - keep the plan in the queue for interaction
+            addToTimeline(markAsDone(first));
+            return [planDefinition];
+        }
+        else {
+            // No define task - show plan and confirmation
+            const confirmDefinition = createConfirmDefinition(handleExecutionConfirmed, handleExecutionCancelled);
+            addToTimeline(markAsDone(first), planDefinition);
+            return [confirmDefinition];
+        }
+    }, false, 0);
+}
+/**
+ * Creates command aborted handler
+ */
+export function createCommandAbortedHandler(handleAborted) {
+    return () => {
+        handleAborted('Request');
+    };
+}

package/dist/handlers/config.js

@@ -0,0 +1,39 @@
+import { ComponentName, FeedbackType } from '../types/types.js';
+import { createAnthropicService, } from '../services/anthropic.js';
+import { createCommandDefinition, createFeedback, markAsDone, } from '../services/components.js';
+import { saveAnthropicConfig } from '../services/configuration.js';
+import { FeedbackMessages } from '../services/messages.js';
+import { exitApp } from '../services/process.js';
+import { withQueueHandler } from '../services/queue.js';
+/**
+ * Creates config finished handler
+ */
+export function createConfigFinishedHandler(addToTimeline, command, handleCommandError, handleCommandComplete, handleCommandAborted, setService) {
+    return (config) => {
+        const anthropicConfig = config;
+        saveAnthropicConfig(anthropicConfig);
+        const newService = createAnthropicService(anthropicConfig);
+        setService(newService);
+        return withQueueHandler(ComponentName.Config, (first, rest) => {
+            addToTimeline(markAsDone(first), createFeedback(FeedbackType.Succeeded, FeedbackMessages.ConfigurationComplete));
+            // Add command to queue if we have one
+            if (command) {
+                return [
+                    ...rest,
+                    createCommandDefinition(command, newService, handleCommandError, handleCommandComplete, handleCommandAborted),
+                ];
+            }
+            // No command - exit after showing completion message
+            exitApp(0);
+            return rest;
+        }, false, 0);
+    };
+}
+/**
+ * Creates config aborted handler
+ */
+export function createConfigAbortedHandler(handleAborted) {
+    return () => {
+        handleAborted('Configuration');
+    };
+}

package/dist/handlers/execution.js

@@ -0,0 +1,68 @@
+import { ComponentName, FeedbackType, TaskType } from '../types/types.js';
+import { createAnswerDefinition, createFeedback, createIntrospectDefinition, markAsDone, } from '../services/components.js';
+import { getCancellationMessage } from '../services/messages.js';
+import { exitApp } from '../services/process.js';
+import { withQueueHandler } from '../services/queue.js';
+/**
+ * Creates execution confirmed handler
+ */
+export function createExecutionConfirmedHandler(timelineRef, addToTimeline, service, handleIntrospectError, handleIntrospectComplete, handleIntrospectAborted, handleAnswerError, handleAnswerComplete, handleAnswerAborted) {
+    return () => withQueueHandler(ComponentName.Confirm, (first) => {
+        // Find the most recent Plan in timeline to get tasks
+        const currentTimeline = timelineRef.current;
+        const lastPlanIndex = [...currentTimeline]
+            .reverse()
+            .findIndex((item) => item.name === ComponentName.Plan);
+        const lastPlan = lastPlanIndex >= 0
+            ? currentTimeline[currentTimeline.length - 1 - lastPlanIndex]
+            : null;
+        const tasks = lastPlan?.name === ComponentName.Plan &&
+            Array.isArray(lastPlan.props.tasks)
+            ? lastPlan.props.tasks
+            : [];
+        const allIntrospect = tasks.every((task) => task.type === TaskType.Introspect);
+        const allAnswer = tasks.every((task) => task.type === TaskType.Answer);
+        if (allIntrospect && tasks.length > 0) {
+            // Execute introspection
+            addToTimeline(markAsDone(first));
+            return [
+                createIntrospectDefinition(tasks, service, handleIntrospectError, handleIntrospectComplete, handleIntrospectAborted),
+            ];
+        }
+        else if (allAnswer && tasks.length > 0) {
+            // Execute answer - extract question from first task
+            const question = tasks[0].action;
+            addToTimeline(markAsDone(first));
+            return [
+                createAnswerDefinition(question, service, handleAnswerError, handleAnswerComplete, handleAnswerAborted),
+            ];
+        }
+        else {
+            // Regular execution - just exit for now
+            addToTimeline(markAsDone(first));
+            exitApp(0);
+            return [];
+        }
+    });
+}
+/**
+ * Creates execution cancelled handler
+ */
+export function createExecutionCancelledHandler(timelineRef, addToTimeline) {
+    return () => withQueueHandler(ComponentName.Confirm, (first) => {
+        // Find the most recent Plan in timeline to check task types
+        const currentTimeline = timelineRef.current;
+        const lastPlanIndex = [...currentTimeline]
+            .reverse()
+            .findIndex((item) => item.name === ComponentName.Plan);
+        const lastPlan = lastPlanIndex >= 0
+            ? currentTimeline[currentTimeline.length - 1 - lastPlanIndex]
+            : null;
+        const allIntrospect = lastPlan?.name === ComponentName.Plan &&
+            Array.isArray(lastPlan.props.tasks) &&
+            lastPlan.props.tasks.every((task) => task.type === TaskType.Introspect);
+        const operation = allIntrospect ? 'introspection' : 'execution';
+        addToTimeline(markAsDone(first), createFeedback(FeedbackType.Aborted, getCancellationMessage(operation)));
+        return undefined;
+    }, true, 0);
+}

package/dist/handlers/introspect.js

@@ -0,0 +1,28 @@
+import { ComponentName } from '../types/types.js';
+import { createReportDefinition } from '../services/components.js';
+import { createErrorHandler, withQueueHandler } from '../services/queue.js';
+/**
+ * Creates introspect error handler
+ */
+export function createIntrospectErrorHandler(addToTimeline) {
+    return (error) => createErrorHandler(ComponentName.Introspect, addToTimeline)(error);
+}
+/**
+ * Creates introspect completion handler
+ */
+export function createIntrospectCompleteHandler(addToTimeline) {
+    return (message, capabilities) => withQueueHandler(ComponentName.Introspect, () => {
+        // Don't add the Introspect component to timeline (it renders null)
+        // Only add the Report component
+        addToTimeline(createReportDefinition(message, capabilities));
+        return undefined;
+    }, true, 0);
+}
+/**
+ * Creates introspect aborted handler
+ */
+export function createIntrospectAbortedHandler(handleAborted) {
+    return () => {
+        handleAborted('Introspection');
+    };
+}

package/dist/handlers/plan.js

@@ -0,0 +1,82 @@
+import { ComponentName, FeedbackType, TaskType } from '../types/types.js';
+import { createConfirmDefinition, createFeedback, createPlanDefinition, markAsDone, createRefinement, } from '../services/components.js';
+import { FeedbackMessages, getRefiningMessage } from '../services/messages.js';
+import { exitApp } from '../services/process.js';
+/**
+ * Creates plan aborted handler
+ */
+export function createPlanAbortedHandler(handleAborted) {
+    return () => {
+        handleAborted('Task selection');
+    };
+}
+/**
+ * Creates plan abort handler factory
+ */
+export function createPlanAbortHandlerFactory(handleAborted, handlePlanAborted) {
+    return (tasks) => {
+        const allIntrospect = tasks.every((task) => task.type === TaskType.Introspect);
+        if (allIntrospect) {
+            return () => {
+                handleAborted('Introspection');
+            };
+        }
+        return handlePlanAborted;
+    };
+}
+/**
+ * Creates plan selection confirmed handler
+ */
+export function createPlanSelectionConfirmedHandler(addToTimeline, service, handleRefinementAborted, createPlanAbortHandler, handleExecutionConfirmed, handleExecutionCancelled, setQueue) {
+    return async (selectedTasks) => {
+        // Mark current plan as done and add refinement to queue
+        const refinementDef = createRefinement(getRefiningMessage(), handleRefinementAborted);
+        setQueue((currentQueue) => {
+            if (currentQueue.length === 0)
+                return currentQueue;
+            const [first] = currentQueue;
+            if (first.name === ComponentName.Plan) {
+                addToTimeline(markAsDone(first));
+            }
+            // Add refinement to queue so it becomes the active component
+            return [refinementDef];
+        });
+        // Process refined command in background
+        try {
+            const refinedCommand = selectedTasks
+                .map((task) => {
+                const action = task.action.toLowerCase().replace(/,/g, ' -');
+                const type = task.type;
+                return `${action} (type: ${type})`;
+            })
+                .join(', ');
+            const result = await service.processWithTool(refinedCommand, 'plan');
+            // Mark refinement as done and move to timeline
+            setQueue((currentQueue) => {
+                if (currentQueue.length > 0 &&
+                    currentQueue[0].id === refinementDef.id) {
+                    addToTimeline(markAsDone(currentQueue[0]));
+                }
+                return [];
+            });
+            // Show final execution plan with confirmation
+            const planDefinition = createPlanDefinition(result.message, result.tasks, createPlanAbortHandler(result.tasks), undefined);
+            const confirmDefinition = createConfirmDefinition(handleExecutionConfirmed, handleExecutionCancelled);
+            addToTimeline(planDefinition);
+            setQueue([confirmDefinition]);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            // Mark refinement as done and move to timeline before showing error
+            setQueue((currentQueue) => {
+                if (currentQueue.length > 0 &&
+                    currentQueue[0].id === refinementDef.id) {
+                    addToTimeline(markAsDone(currentQueue[0]));
+                }
+                return [];
+            });
+            addToTimeline(createFeedback(FeedbackType.Failed, FeedbackMessages.UnexpectedError, errorMessage));
+            exitApp(1);
+        }
+    };
+}

package/dist/services/anthropic.js

@@ -40,8 +40,25 @@ export class AnthropicService {
             throw new Error('Expected tool_use response from Claude API');
         }
         const content = response.content[0];
-        // Extract and validate message and tasks
+        // Extract and validate response based on tool type
         const input = content.input;
+        const isDebug = process.env.DEBUG === 'true';
+        // Handle answer tool response
+        if (toolName === 'answer') {
+            if (!input.question || typeof input.question !== 'string') {
+                throw new Error('Invalid tool response: missing or invalid question field');
+            }
+            if (!input.answer || typeof input.answer !== 'string') {
+                throw new Error('Invalid tool response: missing or invalid answer field');
+            }
+            return {
+                message: '',
+                tasks: [],
+                answer: input.answer,
+                systemPrompt: isDebug ? systemPrompt : undefined,
+            };
+        }
+        // Handle plan and introspect tool responses
         if (!input.message || typeof input.message !== 'string') {
             throw new Error('Invalid tool response: missing or invalid message field');
         }
@@ -54,7 +71,6 @@ export class AnthropicService {
                 throw new Error(`Invalid task at index ${String(i)}: missing or invalid 'action' field`);
             }
         });
-        const isDebug = process.env.DEBUG === 'true';
         return {
             message: input.message,
             tasks: input.tasks,

package/dist/{types → services}/colors.js

@@ -1,9 +1,13 @@
-import { FeedbackType, TaskType } from './types.js';
+import { FeedbackType, TaskType } from '../types/types.js';
 /**
  * Semantic color palette - colors organized by their purpose/meaning.
  * Prefer adding semantic names here rather than to DescriptiveColors.
  */
 export const Colors = {
+    Text: {
+        Active: '#ffffff', // white
+        Inactive: '#d0d0d0', // ash gray
+    },
     Action: {
         Execute: '#5aaa8a', // green
         Discard: '#a85c3f', // dark orange
@@ -16,7 +20,7 @@ export const Colors = {
         Info: '#5c9ccc', // cyan
     },
     Label: {
-        Default: '#ffffff', // white
+        Default: null, // replaced with active or inactive
         Inactive: '#888888', // gray
         Discarded: '#666666', // dark gray
         Skipped: '#cccc5c', // yellow
@@ -35,9 +39,9 @@ export const Colors = {
     },
 };
 /**
- * Task-specific color mappings
+ * Task-specific color mappings (internal)
  */
-export const TaskColors = {
+const TaskColors = {
     [TaskType.Config]: {
         description: Colors.Label.Default,
         type: Colors.Type.Config,
@@ -80,11 +84,59 @@ export const TaskColors = {
     },
 };
 /**
- * Feedback-specific color mappings
+ * Feedback-specific color mappings (internal)
  */
-export const FeedbackColors = {
+const FeedbackColors = {
     [FeedbackType.Info]: Colors.Status.Info,
     [FeedbackType.Succeeded]: Colors.Status.Success,
     [FeedbackType.Aborted]: Colors.Status.Warning,
     [FeedbackType.Failed]: Colors.Status.Error,
 };
+/**
+ * Process null color values based on current/historical state.
+ *
+ * Replaces null with:
+ * - Colors.Text.Active for current items
+ * - Colors.Text.Inactive (undefined) for historical items
+ */
+function processColor(color, isCurrent) {
+    return color === null
+        ? isCurrent
+            ? Colors.Text.Active
+            : Colors.Text.Inactive
+        : color;
+}
+/**
+ * Get task colors with current/historical state handling.
+ *
+ * Processes null color values (terminal default) and replaces them with:
+ * - Colors.Text.Inactive (undefined) for historical items
+ * - Colors.Text.Active for current items
+ */
+export function getTaskColors(type, isCurrent) {
+    const colors = TaskColors[type];
+    return {
+        description: processColor(colors.description, isCurrent),
+        type: processColor(colors.type, isCurrent),
+    };
+}
+/**
+ * Get feedback color with current/historical state handling.
+ *
+ * Processes null color values (terminal default) and replaces them with:
+ * - Colors.Text.Inactive (undefined) for historical items
+ * - Colors.Text.Active for current items
+ */
+export function getFeedbackColor(type, isCurrent) {
+    return processColor(FeedbackColors[type], isCurrent);
+}
+/**
+ * Get text color based on current/historical state.
+ *
+ * Returns:
+ * - Colors.Text.Active for current items
+ * - Colors.Text.Inactive for historical items
+ */
+export function getTextColor(isCurrent) {
+    return isCurrent ? Colors.Text.Active : Colors.Text.Inactive;
+}