From 948aa4f8fdb1ec23282c17c4a7ec589a4b9b52ab Mon Sep 17 00:00:00 2001
From: Mehdi <mehdi@blagui.com>
Date: Mon, 7 Jul 2025 02:12:47 +0000
Subject: [PATCH 1/2] Update CSS

---
 .github/workflows/claude-test3.yml            |  27 --
 .vscode/settings.json                         |   2 +-
 src/components/common/CommandForm.tsx         |  25 +-
 src/components/panels/RunnerPanel.tsx         |  98 ++--
 src/components/panels/WorkflowsPanel.tsx      | 170 ++++---
 src/components/pipeline/PipelineControls.tsx  | 156 +++---
 src/components/pipeline/TaskList.tsx          |  25 +-
 src/components/views/CommandsView.tsx         |   2 +-
 src/services/ClaudeCodeService.ts             |   6 -
 src/services/PipelineService.ts               |   2 +-
 src/styles/base.css                           |   7 +-
 src/styles/components.css                     |  84 ++--
 src/styles/panels.css                         |  72 +--
 ...ommandExecutionSessionIsolationE2E.test.ts | 313 ++++++++++++
 .../e2e/ExecutionSessionIsolationE2E.test.ts  | 203 ++++++++
 tests/e2e/NewWorkflowButtonActionTest.test.ts | 140 ++++++
 tests/e2e/NewWorkflowButtonE2E.test.ts        | 366 +++++++++++++++
 tests/e2e/SaveWorkflowE2E.test.ts             | 444 ++++++++++++++++++
 tests/e2e/SessionIsolationE2E.test.ts         | 260 ++++++++++
 tests/fixtures/workflows/isolated-tasks.yml   |  27 ++
 .../fixtures/workflows/session-continuity.yml |  29 ++
 tests/unit/NewWorkflowButton.test.ts          |  65 +++
 tests/unit/services/CommandsService.test.ts   |   2 +-
 23 files changed, 2159 insertions(+), 366 deletions(-)
 delete mode 100644 .github/workflows/claude-test3.yml
 create mode 100644 tests/e2e/CommandExecutionSessionIsolationE2E.test.ts
 create mode 100644 tests/e2e/ExecutionSessionIsolationE2E.test.ts
 create mode 100644 tests/e2e/NewWorkflowButtonActionTest.test.ts
 create mode 100644 tests/e2e/NewWorkflowButtonE2E.test.ts
 create mode 100644 tests/e2e/SaveWorkflowE2E.test.ts
 create mode 100644 tests/e2e/SessionIsolationE2E.test.ts
 create mode 100644 tests/fixtures/workflows/isolated-tasks.yml
 create mode 100644 tests/fixtures/workflows/session-continuity.yml
 create mode 100644 tests/unit/NewWorkflowButton.test.ts

diff --git a/.github/workflows/claude-test3.yml b/.github/workflows/claude-test3.yml
deleted file mode 100644
index 3b677bd..0000000
--- a/.github/workflows/claude-test3.yml
+++ /dev/null
@@ -1,27 +0,0 @@
-name: test3
-'on':
-  workflow_dispatch:
-    inputs:
-      description:
-        description: Pipeline execution
-        required: false
-        type: string
-jobs:
-  pipeline:
-    name: Pipeline Execution
-    runs-on: ubuntu-latest
-    steps:
-      - id: task_1751746549772_mdctcbm2g
-        name: Task 1
-        uses: anthropics/claude-pipeline-action@v1
-        with:
-          prompt: hi
-          model: auto
-          allow_all_tools: true
-      - id: task_1751746550609_e0lnydxcc
-        name: Task 2
-        uses: anthropics/claude-pipeline-action@v1
-        with:
-          prompt: hi
-          model: auto
-          allow_all_tools: true
diff --git a/.vscode/settings.json b/.vscode/settings.json
index fe33ac2..8d1c75a 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -1,7 +1,7 @@
 {
   "claudeRunner.defaultRootPath": "/workspace",
   "claudeRunner.allowAllTools": true,
-  "claudeRunner.defaultModel": "auto",
+  "claudeRunner.defaultModel": "claude-sonnet-4-20250514",
   "sonarlint.connectedMode.project": {
     "connectionId": "claude-runner",
     "projectKey": "claude-runner"
diff --git a/src/components/common/CommandForm.tsx b/src/components/common/CommandForm.tsx
index ed1d888..9354932 100644
--- a/src/components/common/CommandForm.tsx
+++ b/src/components/common/CommandForm.tsx
@@ -25,17 +25,20 @@ const CommandForm: React.FC<CommandFormProps> = ({
   };
 
   return (
-    <div className="add-command-form">
-      <input
-        type="text"
-        placeholder={placeholder}
-        value={value}
-        onChange={(e) => onChange(e.target.value)}
-        onKeyPress={handleKeyPress}
-        disabled={disabled}
-        autoFocus
-      />
-      <div className="form-actions">
+    <div className="task-item">
+      <div className="input-group">
+        <input
+          type="text"
+          className="task-name-input"
+          placeholder={placeholder}
+          value={value}
+          onChange={(e) => onChange(e.target.value)}
+          onKeyPress={handleKeyPress}
+          disabled={disabled}
+          autoFocus
+        />
+      </div>
+      <div className="control-buttons">
         <Button
           variant="primary"
           onClick={onSubmit}
diff --git a/src/components/panels/RunnerPanel.tsx b/src/components/panels/RunnerPanel.tsx
index 4804836..c1e3fda 100644
--- a/src/components/panels/RunnerPanel.tsx
+++ b/src/components/panels/RunnerPanel.tsx
@@ -48,8 +48,19 @@ const RunnerPanel: React.FC<RunnerPanelProps> = ({ disabled }) => {
     }
   };
 
-  const canRunTasks =
-    tasks.some((task) => task.prompt.trim()) && !isTasksRunning;
+  const clearWorkflow = () => {
+    actions.pipelineClearAll();
+    setLoadedWorkflowName("");
+  };
+
+  const deleteWorkflow = (executionId: string) => {
+    actions.deleteWorkflowState(executionId);
+    clearWorkflow();
+  };
+
+  const hasWorkflowLoaded =
+    loadedWorkflowName || tasks.some((task) => task.prompt.trim());
+  const canRunTasks = hasWorkflowLoaded && !isTasksRunning;
 
   const isPipelineFinished =
     !isTasksRunning &&
@@ -57,11 +68,6 @@ const RunnerPanel: React.FC<RunnerPanelProps> = ({ disabled }) => {
     tasks.some((t) => t.prompt.trim().length > 0) &&
     tasks.some((t) => t.status === "completed" || t.status === "error");
 
-  const clearResults = () => {
-    actions.pipelineClearAll();
-    setLoadedWorkflowName("");
-  };
-
   return (
     <div className="runner-panel">
       <div className="workflow-selection">
@@ -100,49 +106,47 @@ const RunnerPanel: React.FC<RunnerPanelProps> = ({ disabled }) => {
 
       {loadedWorkflowName && (
         <div className="loaded-workflow">
-          <span>Current:</span>
+          Current:{" "}
           <strong>
             {loadedWorkflowName.split("/").pop()?.split("\\").pop()}
           </strong>
         </div>
       )}
 
-      <div className="execution-controls">
-        {!isTasksRunning && !isPaused && (
-          <button onClick={handleRunTasks} disabled={disabled || !canRunTasks}>
-            Run Workflow
-          </button>
-        )}
-
-        {isTasksRunning && !isPaused && (
-          <button onClick={() => actions.pausePipeline()} disabled={disabled}>
-            Pause
-          </button>
-        )}
-
-        {isPaused && pausedPipelines.length > 0 && (
-          <button
-            onClick={() =>
-              actions.resumePipeline(pausedPipelines[0].pipelineId)
-            }
-            disabled={disabled}
-          >
-            Resume
-          </button>
-        )}
-
-        {isTasksRunning && (
-          <button onClick={() => actions.cancelTask()} disabled={disabled}>
-            Cancel
-          </button>
-        )}
-
-        {isPipelineFinished && (
-          <button onClick={clearResults} disabled={disabled}>
-            Clear Results
-          </button>
-        )}
-      </div>
+      {!hasWorkflowLoaded && !isTasksRunning && !isPaused && (
+        <div className="workflow-message">Load workflow first</div>
+      )}
+
+      {(hasWorkflowLoaded || isTasksRunning || isPipelineFinished) && (
+        <div className="execution-controls">
+          {!isTasksRunning && !isPaused && hasWorkflowLoaded && (
+            <button
+              onClick={handleRunTasks}
+              disabled={disabled || !canRunTasks}
+            >
+              Run Workflow
+            </button>
+          )}
+
+          {isTasksRunning && !isPaused && (
+            <button onClick={() => actions.pausePipeline()} disabled={disabled}>
+              Pause
+            </button>
+          )}
+
+          {isTasksRunning && (
+            <button onClick={() => actions.cancelTask()} disabled={disabled}>
+              Cancel
+            </button>
+          )}
+
+          {isPipelineFinished && (
+            <button onClick={clearWorkflow} disabled={disabled}>
+              Clear Results
+            </button>
+          )}
+        </div>
+      )}
 
       {(pausedPipelines.length > 0 || resumableWorkflows.length > 0) && (
         <div className="resumable-section">
@@ -157,7 +161,7 @@ const RunnerPanel: React.FC<RunnerPanelProps> = ({ disabled }) => {
                 Resume
               </button>
               <button
-                onClick={() => actions.deleteWorkflowState(pipeline.pipelineId)}
+                onClick={() => deleteWorkflow(pipeline.pipelineId)}
                 disabled={disabled || isTasksRunning}
               >
                 Delete
@@ -174,9 +178,7 @@ const RunnerPanel: React.FC<RunnerPanelProps> = ({ disabled }) => {
                 Resume
               </button>
               <button
-                onClick={() =>
-                  actions.deleteWorkflowState(workflow.executionId)
-                }
+                onClick={() => deleteWorkflow(workflow.executionId)}
                 disabled={disabled || isTasksRunning}
               >
                 Delete
diff --git a/src/components/panels/WorkflowsPanel.tsx b/src/components/panels/WorkflowsPanel.tsx
index ff17d69..d3f7de1 100644
--- a/src/components/panels/WorkflowsPanel.tsx
+++ b/src/components/panels/WorkflowsPanel.tsx
@@ -19,7 +19,7 @@ const WorkflowsPanel: React.FC<WorkflowsPanelProps> = ({ disabled }) => {
     discoveredWorkflows,
   } = main;
 
-  const [showSaveDialog, setShowSaveDialog] = useState(false);
+  const [showSaveForm, setShowSaveForm] = useState(false);
   const [workflowName, setWorkflowName] = useState("");
   const [workflowDescription, setWorkflowDescription] = useState("");
   const [selectedWorkflow, setSelectedWorkflow] = useState("");
@@ -69,12 +69,18 @@ const WorkflowsPanel: React.FC<WorkflowsPanelProps> = ({ disabled }) => {
         workflowDescription.trim(),
         validTasks,
       );
-      setShowSaveDialog(false);
+      setShowSaveForm(false);
       setWorkflowName("");
       setWorkflowDescription("");
     }
   };
 
+  const handleCancelSave = () => {
+    setShowSaveForm(false);
+    setWorkflowName("");
+    setWorkflowDescription("");
+  };
+
   const handleLoadWorkflow = () => {
     if (selectedWorkflow) {
       if (
@@ -93,100 +99,118 @@ const WorkflowsPanel: React.FC<WorkflowsPanelProps> = ({ disabled }) => {
     actions.pipelineClearAll();
   };
 
-  const canSave = tasks.some((task) => task.prompt.trim());
+  const hasTasks = tasks.length > 0;
+  const hasValidTasks =
+    tasks.length > 0 && tasks.some((task) => task.prompt.trim());
 
   return (
     <div className="workflows-panel">
-      <div className="workflow-load-section">
-        <select
-          value={selectedWorkflow}
-          onChange={(e) => setSelectedWorkflow(e.target.value)}
-          disabled={disabled}
-        >
-          <option value="">Select a workflow to load...</option>
-          {availablePipelines.length > 0 && (
-            <optgroup label="Saved Workflows">
-              {availablePipelines.map((pipeline) => (
-                <option key={pipeline} value={pipeline}>
-                  {pipeline}
-                </option>
-              ))}
-            </optgroup>
-          )}
-          {discoveredWorkflows && discoveredWorkflows.length > 0 && (
-            <optgroup label="Workflow Files">
-              {discoveredWorkflows.map((workflow) => (
-                <option key={workflow.path} value={workflow.path}>
-                  {workflow.name}
-                </option>
-              ))}
-            </optgroup>
-          )}
-        </select>
-        <button
-          onClick={handleLoadWorkflow}
-          disabled={disabled || !selectedWorkflow}
-        >
-          Load
-        </button>
-      </div>
+      {(availablePipelines.length > 0 ||
+        (discoveredWorkflows && discoveredWorkflows.length > 0)) && (
+        <div className="workflow-load-section">
+          <select
+            value={selectedWorkflow}
+            onChange={(e) => setSelectedWorkflow(e.target.value)}
+            disabled={disabled}
+          >
+            <option value="">Select a workflow to load...</option>
+            {availablePipelines.length > 0 && (
+              <optgroup label="Saved Workflows">
+                {availablePipelines.map((pipeline) => (
+                  <option key={pipeline} value={pipeline}>
+                    {pipeline}
+                  </option>
+                ))}
+              </optgroup>
+            )}
+            {discoveredWorkflows && discoveredWorkflows.length > 0 && (
+              <optgroup label="Workflow Files">
+                {discoveredWorkflows.map((workflow) => (
+                  <option key={workflow.path} value={workflow.path}>
+                    {workflow.name}
+                  </option>
+                ))}
+              </optgroup>
+            )}
+          </select>
+          <button
+            onClick={handleLoadWorkflow}
+            disabled={disabled || !selectedWorkflow}
+          >
+            Load
+          </button>
+        </div>
+      )}
 
       <div className="workflow-actions">
-        <button onClick={addTask} disabled={disabled}>
-          Add Task
-        </button>
-        <button
-          onClick={() => setShowSaveDialog(true)}
-          disabled={disabled || !canSave}
-        >
-          Save Workflow
-        </button>
-        <button
-          onClick={clearWorkflow}
-          disabled={disabled || tasks.length === 0}
-        >
-          Clear All
-        </button>
+        {!hasTasks ? (
+          <button onClick={addTask} disabled={disabled}>
+            New Workflow
+          </button>
+        ) : (
+          <>
+            <button onClick={addTask} disabled={disabled}>
+              Add Task
+            </button>
+            <button
+              onClick={() => setShowSaveForm(true)}
+              disabled={disabled || !hasValidTasks}
+            >
+              Save Workflow
+            </button>
+            <button onClick={clearWorkflow} disabled={disabled}>
+              Clear All
+            </button>
+          </>
+        )}
       </div>
 
-      <TaskList
-        tasks={tasks}
-        isTasksRunning={false}
-        defaultModel={defaultModel}
-        availableModels={availableModels}
-        updateTask={updateTask}
-        removeTask={removeTask}
-      />
-
-      {showSaveDialog && (
-        <div className="dialog-backdrop">
-          <div className="dialog">
-            <h3>Save Workflow</h3>
+      {showSaveForm && (
+        <div className="task-item">
+          <div className="task-header">
+            <h4>Save Workflow</h4>
+          </div>
+          <div className="input-group">
             <input
               type="text"
+              className="task-name-input"
               placeholder="Workflow name"
               value={workflowName}
               onChange={(e) => setWorkflowName(e.target.value)}
               autoFocus
             />
+          </div>
+          <div className="input-group">
             <textarea
+              className="task-textarea"
               placeholder="Description (optional)"
               value={workflowDescription}
               onChange={(e) => setWorkflowDescription(e.target.value)}
               rows={3}
             />
-            <div className="dialog-actions">
-              <button
-                onClick={handleSaveWorkflow}
-                disabled={!workflowName.trim()}
-              >
-                Save
-              </button>
-              <button onClick={() => setShowSaveDialog(false)}>Cancel</button>
-            </div>
+          </div>
+          <div className="control-buttons">
+            <button
+              onClick={handleSaveWorkflow}
+              disabled={!workflowName.trim()}
+            >
+              Save
+            </button>
+            <button onClick={handleCancelSave}>Cancel</button>
           </div>
         </div>
       )}
+
+      {hasTasks && (
+        <TaskList
+          tasks={tasks}
+          isTasksRunning={false}
+          defaultModel={defaultModel}
+          availableModels={availableModels}
+          updateTask={updateTask}
+          removeTask={removeTask}
+        />
+      )}
     </div>
   );
 };
diff --git a/src/components/pipeline/PipelineControls.tsx b/src/components/pipeline/PipelineControls.tsx
index f8d0ef4..74ef5cf 100644
--- a/src/components/pipeline/PipelineControls.tsx
+++ b/src/components/pipeline/PipelineControls.tsx
@@ -6,7 +6,7 @@ interface PipelineControlsProps {
   canRunTasks: boolean;
   disabled: boolean;
   status?: string;
-  tasks?: Array<{ id: string; status: string }>;
+  tasks?: Array<{ id: string; status: string; prompt: string }>;
   currentTaskIndex?: number;
   addTask: () => void;
   cancelTask: () => void;
@@ -51,7 +51,7 @@ const PipelineControls: React.FC<PipelineControlsProps> = ({
   canRunTasks,
   disabled,
   status: _status,
-  tasks: _tasks,
+  tasks = [],
   currentTaskIndex: _currentTaskIndex,
   addTask,
   cancelTask,
@@ -80,34 +80,56 @@ const PipelineControls: React.FC<PipelineControlsProps> = ({
     handleRunTasks();
   }, [handleRunTasks]);
 
-  // Reset the runClicked flag when pipeline stops running
   React.useEffect(() => {
     if (!isTasksRunning && !isPaused) {
       setRunClicked(false);
     }
   }, [isTasksRunning, isPaused]);
 
-  // Memoize pipeline running state to prevent unnecessary re-renders
   const pipelineRunningMemo = React.useMemo(() => {
     return (isTasksRunning || isPaused) && !isPipelineFinished;
   }, [isTasksRunning, isPaused, isPipelineFinished]);
+
+  const hasTasks = tasks.length > 0;
+  const hasValidTasks =
+    tasks.length > 0 && tasks.some((task) => task.prompt.trim());
+
   return (
     <div className="task-controls">
-      {/* Add Task and Save Pipeline - same line at top */}
-      <div style={{ display: "flex", gap: "8px", marginBottom: "16px" }}>
-        <Button variant="secondary" onClick={addTask} disabled={isTasksRunning}>
-          Add Task
-        </Button>
-        <Button
-          variant="secondary"
-          onClick={() => setShowPipelineDialog(true)}
-          disabled={disabled || !canRunTasks}
-        >
-          Save as Pipeline
-        </Button>
-      </div>
+      {!hasTasks ? (
+        <div style={{ display: "flex", gap: "8px", marginBottom: "16px" }}>
+          <Button variant="primary" onClick={addTask} disabled={disabled}>
+            New Workflow
+          </Button>
+        </div>
+      ) : (
+        <div style={{ display: "flex", gap: "8px", marginBottom: "16px" }}>
+          <Button
+            variant="secondary"
+            onClick={addTask}
+            disabled={isTasksRunning}
+          >
+            Add Task
+          </Button>
+          <Button
+            variant="secondary"
+            onClick={() => setShowPipelineDialog(true)}
+            disabled={disabled || !hasValidTasks}
+          >
+            Save Workflow
+          </Button>
+          {isPipelineFinished && (
+            <Button
+              variant="secondary"
+              onClick={clearPipeline}
+              disabled={disabled || !clearPipeline}
+            >
+              Clear All
+            </Button>
+          )}
+        </div>
+      )}
 
-      {/* Load Pipeline - always visible */}
       {(availablePipelines.length > 0 ||
         (discoveredWorkflows && discoveredWorkflows.length > 0)) && (
         <div className="pipeline-controls" style={{ marginTop: "16px" }}>
@@ -116,10 +138,10 @@ const PipelineControls: React.FC<PipelineControlsProps> = ({
             onChange={(e) => setSelectedPipeline(e.target.value)}
             className="pipeline-select"
           >
-            <option value="">Select pipeline</option>
+            <option value="">Select a workflow to load...</option>
 
             {availablePipelines.length > 0 && (
-              <optgroup label="Saved Pipelines">
+              <optgroup label="Saved Workflows">
                 {availablePipelines.map((pipeline) => (
                   <option key={`pipeline-${pipeline}`} value={pipeline}>
                     {pipeline}
@@ -129,7 +151,7 @@ const PipelineControls: React.FC<PipelineControlsProps> = ({
             )}
 
             {discoveredWorkflows && discoveredWorkflows.length > 0 && (
-              <optgroup label="Workflows">
+              <optgroup label="Workflow Files">
                 {discoveredWorkflows.map((workflow) => (
                   <option
                     key={`workflow-${workflow.path}`}
@@ -152,9 +174,6 @@ const PipelineControls: React.FC<PipelineControlsProps> = ({
         </div>
       )}
 
-      {/* Removed redundant paused pipelines section - resume is handled by main Resume button */}
-
-      {/* Resumable Workflows Section */}
       {resumableWorkflows.length > 0 && (
         <div
           className="resumable-workflows-section"
@@ -197,65 +216,56 @@ const PipelineControls: React.FC<PipelineControlsProps> = ({
         </div>
       )}
 
-      {/* Run Pipeline / Pause / Cancel - separate section at bottom */}
-      <div
-        className="pipeline-execution-controls"
-        style={{ marginTop: "24px" }}
-      >
-        {pipelineRunningMemo ? (
-          <>
-            {isPaused ? (
-              <Button
-                variant="primary"
-                onClick={() => {
-                  const pipelineId =
-                    pausedPipelines?.[0]?.pipelineId || "current";
-                  onResumePipeline?.(pipelineId);
-                }}
-                disabled={disabled || !onResumePipeline}
-              >
-                Resume
-              </Button>
-            ) : (
-              <Button
-                variant="secondary"
-                onClick={onPausePipeline}
-                disabled={disabled || !onPausePipeline}
-              >
-                Pause
-              </Button>
-            )}
-            <Button
-              variant="secondary"
-              onClick={cancelTask}
-              disabled={disabled}
-              style={{ marginLeft: "8px" }}
-            >
-              Cancel Pipeline
-            </Button>
-          </>
-        ) : (
-          <>
-            {isPipelineFinished ? (
+      {hasTasks && hasValidTasks && (
+        <div
+          className="pipeline-execution-controls"
+          style={{ marginTop: "24px" }}
+        >
+          {pipelineRunningMemo ? (
+            <>
+              {isPaused ? (
+                <Button
+                  variant="primary"
+                  onClick={() => {
+                    const pipelineId =
+                      pausedPipelines?.[0]?.pipelineId || "current";
+                    onResumePipeline?.(pipelineId);
+                  }}
+                  disabled={disabled || !onResumePipeline}
+                >
+                  Resume
+                </Button>
+              ) : (
+                <Button
+                  variant="secondary"
+                  onClick={onPausePipeline}
+                  disabled={disabled || !onPausePipeline}
+                >
+                  Pause
+                </Button>
+              )}
               <Button
                 variant="secondary"
-                onClick={clearPipeline}
-                disabled={disabled || !clearPipeline}
+                onClick={cancelTask}
+                disabled={disabled}
+                style={{ marginLeft: "8px" }}
               >
-                Clear Pipeline
+                Cancel
               </Button>
-            ) : (
+            </>
+          ) : (
+            !isPipelineFinished && (
               <Button
                 variant="primary"
                 onClick={handleRunPipeline}
                 disabled={disabled || !canRunTasks || runClicked}
               >
-                Run Pipeline
+                Run Workflow
               </Button>
-            )}
-          </>
-        )}
-      </div>
+            )
+          )}
+        </div>
+      )}
     </div>
   );
 };
diff --git a/src/components/pipeline/TaskList.tsx b/src/components/pipeline/TaskList.tsx
index 476366b..4597e81 100644
--- a/src/components/pipeline/TaskList.tsx
+++ b/src/components/pipeline/TaskList.tsx
@@ -1,5 +1,4 @@
 import React from "react";
-import Button from "../common/Button";
 import { TaskItem } from "../../services/ClaudeCodeService";
 import { ConditionType } from "../../core/models/Task";
 
@@ -39,13 +38,12 @@ const TaskList: React.FC<TaskListProps> = ({
               disabled={isTasksRunning}
             />
             {tasks.length > 1 && (
-              <Button
-                variant="secondary"
+              <button
                 onClick={() => removeTask(task.id)}
                 disabled={isTasksRunning}
               >
                 Remove
-              </Button>
+              </button>
             )}
           </div>
 
@@ -86,7 +84,7 @@ const TaskList: React.FC<TaskListProps> = ({
                   updateTask(task.id, "resumeFromTaskId", e.target.value)
                 }
                 disabled={isTasksRunning}
-                className="condition-select-inline"
+                className="model-select condition-select-inline"
               >
                 <option value="">New session</option>
                 {tasks.slice(0, index).map((prevTask, idx) => (
@@ -101,16 +99,15 @@ const TaskList: React.FC<TaskListProps> = ({
           <div className="condition-controls">
             {(!task.check || task.check.trim() === "") &&
             (!task.condition || task.condition === "always") ? (
-              <Button
-                variant="secondary"
+              <button
                 onClick={() => {
                   updateTask(task.id, "check", "");
                   updateTask(task.id, "condition", "on_success");
                 }}
                 disabled={isTasksRunning}
               >
-                Add Condition Command
-              </Button>
+                + Add Condition Command
+              </button>
             ) : (
               <>
                 <div className="check-command-row">
@@ -122,20 +119,20 @@ const TaskList: React.FC<TaskListProps> = ({
                       updateTask(task.id, "check", e.target.value)
                     }
                     placeholder="Optional check command (e.g., make lint)"
-                    className="check-command-input-inline"
+                    className="task-name-input check-command-input-inline"
                     disabled={isTasksRunning}
                   />
-                  <Button
-                    variant="secondary"
+                  <button
                     onClick={() => {
                       updateTask(task.id, "check", "");
                       updateTask(task.id, "condition", "always");
                     }}
                     disabled={isTasksRunning}
                     className="remove-condition-btn"
+                    title="Remove condition"
                   >
                     ×
-                  </Button>
+                  </button>
                 </div>
                 <div className="condition-row-inline">
                   <label className="inline-label">Condition:</label>
@@ -149,7 +146,7 @@ const TaskList: React.FC<TaskListProps> = ({
                       )
                     }
                     disabled={isTasksRunning}
-                    className="condition-select-inline"
+                    className="model-select condition-select-inline"
                   >
                     <option value="always">Always</option>
                     <option value="on_success">On Success</option>
diff --git a/src/components/views/CommandsView.tsx b/src/components/views/CommandsView.tsx
index d266672..c7cb7a2 100644
--- a/src/components/views/CommandsView.tsx
+++ b/src/components/views/CommandsView.tsx
@@ -99,7 +99,7 @@ const CommandsView: React.FC = () => {
           title="Open Claude Code slash commands documentation"
         >
           <span className="button-icon">🌐</span>
-          Open Command Docs
+          Open Slash Commands Docs
         </Button>
       </div>
     </div>
diff --git a/src/services/ClaudeCodeService.ts b/src/services/ClaudeCodeService.ts
index 959f8bf..251b9ae 100644
--- a/src/services/ClaudeCodeService.ts
+++ b/src/services/ClaudeCodeService.ts
@@ -288,12 +288,6 @@ export class ClaudeCodeService {
           if (sourceTask?.sessionId) {
             taskOptions.resumeSessionId = sourceTask.sessionId;
           }
-        } else if (i > 0) {
-          // If no explicit resumeFromTaskId, continue from previous task if it completed successfully
-          const previousTask = tasks[i - 1];
-          if (previousTask.sessionId && previousTask.status === "completed") {
-            taskOptions.resumeSessionId = previousTask.sessionId;
-          }
         }
 
         // Use task-specific model if specified, otherwise use pipeline default
diff --git a/src/services/PipelineService.ts b/src/services/PipelineService.ts
index f46e20e..5c682ae 100644
--- a/src/services/PipelineService.ts
+++ b/src/services/PipelineService.ts
@@ -20,7 +20,7 @@ export class PipelineService {
   /**
    * Set the root path for workflow storage
    */
-  setRootPath(rootPath: string): void {
+  async setRootPath(rootPath: string): Promise<void> {
     this.rootPath = rootPath;
     this.updateWorkflowsDir();
     this.ensureDirectories();
diff --git a/src/styles/base.css b/src/styles/base.css
index 322633f..8a081b5 100644
--- a/src/styles/base.css
+++ b/src/styles/base.css
@@ -11,9 +11,10 @@
   --font-size-lg: calc(var(--vscode-font-size) + 1px);
   --border-radius-sm: 2px;
   --border-radius-md: 4px;
-  --input-styles: var(--vscode-font-family) var(--vscode-font-size)
-    var(--vscode-input-background) var(--vscode-input-foreground)
-    var(--vscode-input-border);
+  --input-padding: var(--spacing-xs) var(--spacing-sm);
+  --input-bg: var(--vscode-editor-background);
+  --input-fg: var(--vscode-input-foreground);
+  --input-border: var(--vscode-input-border);
   --focus-outline: 1px solid var(--vscode-focusBorder);
 }
 
diff --git a/src/styles/components.css b/src/styles/components.css
index 722cfc4..3b97a58 100644
--- a/src/styles/components.css
+++ b/src/styles/components.css
@@ -1,8 +1,42 @@
-/* Note: Button styles moved to CSS-in-JS in Button.tsx component */
+button {
+  font-family: var(--vscode-font-family);
+  font-size: var(--vscode-font-size);
+  padding: var(--input-padding);
+  background-color: var(--vscode-button-background);
+  color: var(--vscode-button-foreground);
+  border: 1px solid var(--vscode-button-background);
+  border-radius: var(--border-radius-sm);
+  cursor: pointer;
+  line-height: 1.2;
+  white-space: nowrap;
+  transition: background-color 0.2s ease;
+}
+
+button:hover:not(:disabled) {
+  background-color: var(--vscode-button-hoverBackground);
+}
+
+button:focus {
+  outline: var(--focus-outline);
+  outline-offset: -1px;
+}
 
-/* Note: Input styles moved to CSS-in-JS in Input.tsx component */
+button:disabled {
+  opacity: 0.6;
+  cursor: not-allowed;
+}
+
+button.secondary,
+.control-buttons button:last-child {
+  background-color: var(--vscode-button-secondaryBackground);
+  color: var(--vscode-button-secondaryForeground);
+  border-color: var(--vscode-button-secondaryBackground);
+}
+
+button.secondary:hover:not(:disabled) {
+  background-color: var(--vscode-list-hoverBackground);
+}
 
-/* Form groups - for backward compatibility */
 .input-group {
   display: flex;
   flex-direction: column;
@@ -26,26 +60,28 @@
   margin-top: var(--spacing-xs);
 }
 
-/* Inputs - VSCode Native (for non-component inputs) */
+input[type="text"],
+input[type="number"],
 textarea,
 select {
   font-family: var(--vscode-font-family);
   font-size: var(--vscode-font-size);
-  padding: var(--spacing-xs) var(--spacing-xs);
-  background-color: var(--vscode-input-background);
-  color: var(--vscode-input-foreground);
-  border: 1px solid var(--vscode-input-border);
+  padding: var(--input-padding);
+  background-color: var(--input-bg);
+  color: var(--input-fg);
+  border: 1px solid var(--input-border);
   border-radius: var(--border-radius-sm);
   line-height: 1.2;
 }
 
+input[type="text"]:focus,
+input[type="number"]:focus,
 textarea:focus,
 select:focus {
-  outline: 1px solid var(--vscode-focusBorder);
+  outline: var(--focus-outline);
   outline-offset: -1px;
 }
 
-/* Toggle switch - simplified */
 .toggle-container {
   display: flex;
   align-items: center;
@@ -82,14 +118,12 @@ select:focus {
   background-color: var(--vscode-button-foreground);
 }
 
-/* Tab Navigation - VSCode native */
 .tab-navigation {
   display: flex;
   border-bottom: 1px solid var(--vscode-tab-border);
   margin-bottom: var(--spacing-md);
 }
 
-/* Bottom Actions - Persistent button area */
 .bottom-actions {
   padding: var(--spacing-md) 0;
   border-top: 1px solid var(--vscode-tab-border);
@@ -129,9 +163,6 @@ select:focus {
   margin-top: var(--spacing-sm);
 }
 
-/* Note: Loading spinner styles moved to CSS-in-JS in Button.tsx component */
-
-/* Pause/Resume control styling */
 .pause-resume-controls {
   display: flex;
   align-items: center;
@@ -157,7 +188,6 @@ select:focus {
   }
 }
 
-/* Card Component */
 .card {
   margin-bottom: var(--spacing-md);
 }
@@ -173,7 +203,6 @@ select:focus {
   color: var(--vscode-foreground);
 }
 
-/* Chat Panel Specific */
 .chat-info {
   margin-bottom: var(--spacing-sm);
 }
@@ -208,22 +237,8 @@ select:focus {
   width: 100%;
   min-height: 120px;
   resize: vertical;
-  font-family: var(--vscode-font-family);
-  font-size: var(--vscode-font-size);
-  padding: var(--spacing-xs) var(--spacing-xs);
-  background-color: var(--vscode-input-background);
-  color: var(--vscode-input-foreground);
-  border: 1px solid var(--vscode-input-border);
-  border-radius: var(--border-radius-sm);
-  line-height: 1.2;
-}
-
-.prompt-textarea:focus {
-  outline: 1px solid var(--vscode-focusBorder);
-  outline-offset: -1px;
 }
 
-/* Button layout consistency */
 .button-group {
   display: flex;
   gap: var(--spacing-xs);
@@ -231,7 +246,6 @@ select:focus {
   flex-wrap: wrap;
 }
 
-/* Control buttons styling */
 .control-buttons {
   display: flex;
   gap: var(--spacing-xs);
@@ -240,13 +254,11 @@ select:focus {
   margin-bottom: var(--spacing-sm);
 }
 
-/* Ensure buttons don't wrap text inside */
 button {
   white-space: nowrap;
   min-width: fit-content;
 }
 
-/* Path Selector */
 .path-selector {
   margin-bottom: var(--spacing-sm);
 }
@@ -255,7 +267,6 @@ button {
   white-space: nowrap;
 }
 
-/* Model Selector */
 .model-selector {
   display: flex;
   align-items: center;
@@ -268,7 +279,6 @@ button {
   min-width: 80px;
 }
 
-/* Condition Configuration Controls */
 .condition-controls {
   margin-top: var(--spacing-sm);
   display: flex;
@@ -324,7 +334,6 @@ button {
   min-width: 120px;
 }
 
-/* ConditionalStepBuilder Component */
 .conditional-step-builder {
   padding: var(--spacing-md);
   border: 1px solid var(--vscode-input-border);
@@ -450,7 +459,6 @@ button {
   font-size: 0.85em;
 }
 
-/* Paused pipeline and workflow sections */
 .paused-pipelines-section,
 .resumable-workflows-section {
   border: 1px solid var(--vscode-input-border);
diff --git a/src/styles/panels.css b/src/styles/panels.css
index 120d20a..b4cb1a6 100644
--- a/src/styles/panels.css
+++ b/src/styles/panels.css
@@ -38,20 +38,6 @@
   margin-bottom: var(--spacing-sm);
 }
 
-.add-command-form {
-  padding: var(--spacing-sm);
-  background-color: var(--vscode-input-background);
-  border: 1px solid var(--vscode-input-border);
-  border-radius: var(--border-radius-sm);
-  margin-bottom: var(--spacing-sm);
-}
-
-.form-actions {
-  display: flex;
-  gap: var(--spacing-sm);
-  margin-top: var(--spacing-sm);
-}
-
 .scanning-status {
   text-align: center;
   padding: 20px;
@@ -139,11 +125,11 @@
 }
 
 .task-item {
-  border: 1px solid var(--vscode-panel-border);
-  border-radius: var(--border-radius-sm);
+  border: 1px solid var(--vscode-input-border);
+  border-radius: var(--border-radius-md);
   padding: var(--spacing-md);
   margin-bottom: var(--spacing-sm);
-  background-color: var(--vscode-editor-background);
+  background-color: var(--vscode-input-background);
   contain: layout style;
 }
 
@@ -167,23 +153,10 @@
 }
 
 .task-name-input {
-  font-family: var(--vscode-font-family);
-  font-size: var(--vscode-font-size);
-  padding: var(--spacing-xs) var(--spacing-xs);
-  background-color: var(--vscode-input-background);
-  color: var(--vscode-input-foreground);
-  border: 1px solid var(--vscode-input-border);
-  border-radius: var(--border-radius-sm);
-  line-height: 1.2;
   flex: 1;
   margin-right: var(--spacing-sm);
 }
 
-.task-name-input:focus {
-  outline: 1px solid var(--vscode-focusBorder);
-  outline-offset: -1px;
-}
-
 .task-model-group,
 .resume-config-group {
   display: flex;
@@ -201,41 +174,15 @@
 }
 
 .model-select {
-  font-family: var(--vscode-font-family);
-  font-size: var(--vscode-font-size);
-  padding: var(--spacing-xs) var(--spacing-xs);
-  background-color: var(--vscode-input-background);
-  color: var(--vscode-input-foreground);
-  border: 1px solid var(--vscode-input-border);
-  border-radius: var(--border-radius-sm);
-  line-height: 1.2;
   flex: 1;
 }
 
-.model-select:focus {
-  outline: 1px solid var(--vscode-focusBorder);
-  outline-offset: -1px;
-}
-
 .task-textarea {
-  font-family: var(--vscode-font-family);
-  font-size: var(--vscode-font-size);
-  padding: var(--spacing-xs) var(--spacing-xs);
-  background-color: var(--vscode-input-background);
-  color: var(--vscode-input-foreground);
-  border: 1px solid var(--vscode-input-border);
-  border-radius: var(--border-radius-sm);
-  line-height: 1.2;
   width: 100%;
   resize: vertical;
   min-height: 60px;
 }
 
-.task-textarea:focus {
-  outline: 1px solid var(--vscode-focusBorder);
-  outline-offset: -1px;
-}
-
 .checkbox-group {
   margin-top: var(--spacing-sm);
 }
@@ -551,23 +498,10 @@
 }
 
 .pipeline-select {
-  font-family: var(--vscode-font-family);
-  font-size: var(--vscode-font-size);
-  padding: var(--spacing-xs) var(--spacing-xs);
-  background-color: var(--vscode-input-background);
-  color: var(--vscode-input-foreground);
-  border: 1px solid var(--vscode-input-border);
-  border-radius: var(--border-radius-sm);
-  line-height: 1.2;
   flex: 1;
   margin-right: var(--spacing-xs);
 }
 
-.pipeline-select:focus {
-  outline: 1px solid var(--vscode-focusBorder);
-  outline-offset: -1px;
-}
-
 .pipeline-select optgroup {
   font-weight: 600;
   color: var(--vscode-descriptionForeground);
diff --git a/tests/e2e/CommandExecutionSessionIsolationE2E.test.ts b/tests/e2e/CommandExecutionSessionIsolationE2E.test.ts
new file mode 100644
index 0000000..6bca5ad
--- /dev/null
+++ b/tests/e2e/CommandExecutionSessionIsolationE2E.test.ts
@@ -0,0 +1,313 @@
+import { jest } from "@jest/globals";
+import * as fs from "fs/promises";
+import * as path from "path";
+import { ClaudeCodeService } from "../../src/services/ClaudeCodeService";
+import { WorkflowParser } from "../../src/services/WorkflowParser";
+import { PipelineService } from "../../src/services/PipelineService";
+import { ClaudeWorkflow } from "../../src/types/WorkflowTypes";
+
+describe("Command Execution Session Isolation E2E Test", () => {
+  let claudeCodeService: ClaudeCodeService;
+  let pipelineService: PipelineService;
+  let capturedCommands: string[][];
+  let fixturesPath: string;
+
+  beforeEach(async () => {
+    fixturesPath = path.join(__dirname, "..", "fixtures", "workflows");
+
+    // Mock configuration service
+    const mockConfigService = {
+      get: jest.fn().mockReturnValue("claude"),
+      getConfig: jest.fn().mockReturnValue({}),
+    };
+
+    const mockContext = {
+      extensionPath: "/test",
+      globalStorageUri: { fsPath: "/tmp/test-storage" },
+    };
+
+    claudeCodeService = new ClaudeCodeService(mockConfigService as any);
+    pipelineService = new PipelineService(mockContext as any);
+
+    // Mock ensureDirectories to avoid environment side effects
+    jest
+      .spyOn(PipelineService.prototype as any, "ensureDirectories")
+      .mockImplementation(() => Promise.resolve());
+
+    // THIS IS THE KEY: Capture all executeCommand calls to validate session arguments
+    capturedCommands = [];
+    jest
+      .spyOn(claudeCodeService as any, "executeCommand")
+      .mockImplementation(async (...args: any[]) => {
+        const commandArgs = args[0] as string[];
+        capturedCommands.push([...commandArgs]);
+
+        console.log(`🔍 CAPTURED COMMAND: ${commandArgs.join(" ")}`);
+
+        // Mock successful execution with deterministic session ID
+        const sessionId = `mock-session-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        return {
+          success: true,
+          output: JSON.stringify({
+            result: `Mock result for command: ${commandArgs.join(" ")}`,
+            session_id: sessionId,
+          }),
+          error: undefined,
+        };
+      });
+
+    jest.clearAllMocks();
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe("Session Isolation Validation via Command Arguments", () => {
+    test("should execute isolated tasks WITHOUT -r flag (using isolated-tasks.yml fixture)", async () => {
+      console.log("=== TESTING: Isolated Tasks (NO Session Continuity) ===");
+
+      // Load workflow from fixture
+      const workflowPath = path.join(fixturesPath, "isolated-tasks.yml");
+      const workflowContent = await fs.readFile(workflowPath, "utf-8");
+      const workflow: ClaudeWorkflow =
+        WorkflowParser.parseYaml(workflowContent);
+
+      console.log(`📄 Loaded workflow: ${workflow.name}`);
+      console.log(`📋 Steps: ${workflow.jobs.pipeline.steps.length}`);
+
+      // Verify fixture has NO resume_session
+      expect(
+        workflow.jobs.pipeline.steps[0]?.with?.resume_session,
+      ).toBeUndefined();
+      expect(
+        workflow.jobs.pipeline.steps[1]?.with?.resume_session,
+      ).toBeUndefined();
+      console.log("✅ Fixture validation: No resume_session fields found");
+
+      // Convert workflow to tasks
+      const tasks = pipelineService.workflowToTaskItems(workflow);
+      console.log(`🔧 Converted to ${tasks.length} tasks`);
+
+      // Verify no resumeFromTaskId in tasks
+      expect(tasks[0].resumeFromTaskId).toBeUndefined();
+      expect(tasks[1].resumeFromTaskId).toBeUndefined();
+      console.log("✅ Task validation: No resumeFromTaskId fields found");
+
+      const mockCallbacks = {
+        onProgress: jest.fn(),
+        onComplete: jest.fn(),
+        onError: jest.fn(),
+      };
+
+      // Execute the pipeline
+      console.log("🚀 Executing pipeline...");
+      await claudeCodeService.runTaskPipeline(
+        tasks,
+        "claude-sonnet-4-20250514",
+        "/test/workspace",
+        { outputFormat: "json" },
+        mockCallbacks.onProgress,
+        mockCallbacks.onComplete,
+        mockCallbacks.onError,
+      );
+
+      console.log("🔍 VALIDATION: Command Analysis");
+      console.log(`📊 Total commands captured: ${capturedCommands.length}`);
+
+      // CRITICAL VALIDATION: Verify NO -r flags in ANY commands
+      capturedCommands.forEach((cmd, index) => {
+        console.log(`Command ${index + 1}: ${cmd.join(" ")}`);
+        expect(cmd).not.toContain("-r");
+      });
+
+      // Verify we have exactly 2 commands (one per task)
+      expect(capturedCommands).toHaveLength(2);
+
+      // Verify first command structure
+      const task1Command = capturedCommands[0];
+      expect(task1Command[0]).toBe("claude");
+      expect(task1Command).toContain("-p");
+      expect(task1Command).toContain("'say a random number that is not 42'");
+      expect(task1Command).not.toContain("-r");
+      console.log("✅ Task 1: No session resume (-r flag absent)");
+
+      // Verify second command structure
+      const task2Command = capturedCommands[1];
+      expect(task2Command[0]).toBe("claude");
+      expect(task2Command).toContain("-p");
+      expect(task2Command).toContain("'what is the previous random number?'");
+      expect(task2Command).not.toContain("-r");
+      console.log("✅ Task 2: No session resume (-r flag absent)");
+
+      console.log(
+        "🎉 SESSION ISOLATION VALIDATED: Both tasks run independently",
+      );
+    });
+
+    test("should execute session continuity tasks WITH -r flag (using session-continuity.yml fixture)", async () => {
+      console.log("=== TESTING: Session Continuity (WITH Session Resume) ===");
+
+      // Load workflow from fixture
+      const workflowPath = path.join(fixturesPath, "session-continuity.yml");
+      const workflowContent = await fs.readFile(workflowPath, "utf-8");
+      const workflow: ClaudeWorkflow =
+        WorkflowParser.parseYaml(workflowContent);
+
+      console.log(`📄 Loaded workflow: ${workflow.name}`);
+      console.log(`📋 Steps: ${workflow.jobs.pipeline.steps.length}`);
+
+      // Verify fixture has correct resume_session setup
+      expect(
+        workflow.jobs.pipeline.steps[0]?.with?.resume_session,
+      ).toBeUndefined();
+      expect(workflow.jobs.pipeline.steps[0]?.with?.output_session).toBe(true);
+      expect(workflow.jobs.pipeline.steps[1]?.with?.resume_session).toBe(
+        "task_generate_number",
+      );
+      console.log(
+        "✅ Fixture validation: Correct resume_session configuration",
+      );
+
+      // Convert workflow to tasks
+      const tasks = pipelineService.workflowToTaskItems(workflow);
+      console.log(`🔧 Converted to ${tasks.length} tasks`);
+
+      // Verify resumeFromTaskId is set correctly
+      expect(tasks[0].resumeFromTaskId).toBeUndefined();
+      expect(tasks[1].resumeFromTaskId).toBe("task_generate_number");
+      console.log(
+        "✅ Task validation: resumeFromTaskId correctly set for task 2",
+      );
+
+      const mockCallbacks = {
+        onProgress: jest.fn(),
+        onComplete: jest.fn(),
+        onError: jest.fn(),
+      };
+
+      // Execute the pipeline
+      console.log("🚀 Executing pipeline...");
+      await claudeCodeService.runTaskPipeline(
+        tasks,
+        "claude-sonnet-4-20250514",
+        "/test/workspace",
+        { outputFormat: "json" },
+        mockCallbacks.onProgress,
+        mockCallbacks.onComplete,
+        mockCallbacks.onError,
+      );
+
+      console.log("🔍 VALIDATION: Command Analysis");
+      console.log(`📊 Total commands captured: ${capturedCommands.length}`);
+
+      // Verify we have exactly 2 commands
+      expect(capturedCommands).toHaveLength(2);
+
+      // Verify first command has NO -r flag
+      const task1Command = capturedCommands[0];
+      console.log(`Command 1: ${task1Command.join(" ")}`);
+      expect(task1Command[0]).toBe("claude");
+      expect(task1Command).toContain("-p");
+      expect(task1Command).toContain("'say a random number that is not 42'");
+      expect(task1Command).not.toContain("-r");
+      console.log("✅ Task 1: No session resume (-r flag absent)");
+
+      // CRITICAL: Verify second command HAS -r flag
+      const task2Command = capturedCommands[1];
+      console.log(`Command 2: ${task2Command.join(" ")}`);
+      expect(task2Command[0]).toBe("claude");
+      expect(task2Command).toContain("-p");
+      expect(task2Command).toContain("'what is the previous random number?'");
+      expect(task2Command).toContain("-r");
+
+      // Verify the session ID is present after -r flag
+      const resumeIndex = task2Command.indexOf("-r");
+      expect(resumeIndex).toBeGreaterThan(-1);
+      expect(task2Command[resumeIndex + 1]).toBeDefined();
+      expect(typeof task2Command[resumeIndex + 1]).toBe("string");
+      console.log(
+        `✅ Task 2: Session resume confirmed (-r ${task2Command[resumeIndex + 1]})`,
+      );
+
+      console.log(
+        "🎉 SESSION CONTINUITY VALIDATED: Task 2 resumes from Task 1",
+      );
+    });
+  });
+
+  describe("Edge Cases and Validation", () => {
+    test("should demonstrate the exact command difference between isolated vs continuity", async () => {
+      console.log("=== DEMONSTRATION: Command Difference Analysis ===");
+
+      // Test isolated workflow
+      console.log("🔬 Testing isolated workflow...");
+      const isolatedWorkflowPath = path.join(
+        fixturesPath,
+        "isolated-tasks.yml",
+      );
+      const isolatedContent = await fs.readFile(isolatedWorkflowPath, "utf-8");
+      const isolatedWorkflow = WorkflowParser.parseYaml(isolatedContent);
+      const isolatedTasks =
+        pipelineService.workflowToTaskItems(isolatedWorkflow);
+
+      capturedCommands = []; // Reset
+
+      await claudeCodeService.runTaskPipeline(
+        isolatedTasks,
+        "claude-sonnet-4-20250514",
+        "/test/workspace",
+        { outputFormat: "json" },
+        jest.fn(),
+        jest.fn(),
+        jest.fn(),
+      );
+
+      const isolatedCommands = [...capturedCommands];
+
+      // Test continuity workflow
+      console.log("🔬 Testing continuity workflow...");
+      const continuityWorkflowPath = path.join(
+        fixturesPath,
+        "session-continuity.yml",
+      );
+      const continuityContent = await fs.readFile(
+        continuityWorkflowPath,
+        "utf-8",
+      );
+      const continuityWorkflow = WorkflowParser.parseYaml(continuityContent);
+      const continuityTasks =
+        pipelineService.workflowToTaskItems(continuityWorkflow);
+
+      capturedCommands = []; // Reset
+
+      await claudeCodeService.runTaskPipeline(
+        continuityTasks,
+        "claude-sonnet-4-20250514",
+        "/test/workspace",
+        { outputFormat: "json" },
+        jest.fn(),
+        jest.fn(),
+        jest.fn(),
+      );
+
+      const continuityCommands = [...capturedCommands];
+
+      console.log("📊 COMMAND COMPARISON:");
+      console.log("🔸 ISOLATED Task 1:", isolatedCommands[0]?.join(" "));
+      console.log("🔸 ISOLATED Task 2:", isolatedCommands[1]?.join(" "));
+      console.log("🔹 CONTINUITY Task 1:", continuityCommands[0]?.join(" "));
+      console.log("🔹 CONTINUITY Task 2:", continuityCommands[1]?.join(" "));
+
+      // Validate the key differences
+      expect(isolatedCommands[0]).not.toContain("-r");
+      expect(isolatedCommands[1]).not.toContain("-r");
+      expect(continuityCommands[0]).not.toContain("-r");
+      expect(continuityCommands[1]).toContain("-r");
+
+      console.log("✅ VALIDATION COMPLETE: Command patterns verified");
+      console.log("   - Isolated: Neither task uses -r flag");
+      console.log("   - Continuity: Only task 2 uses -r flag");
+    });
+  });
+});
diff --git a/tests/e2e/ExecutionSessionIsolationE2E.test.ts b/tests/e2e/ExecutionSessionIsolationE2E.test.ts
new file mode 100644
index 0000000..6196d21
--- /dev/null
+++ b/tests/e2e/ExecutionSessionIsolationE2E.test.ts
@@ -0,0 +1,203 @@
+import { jest } from "@jest/globals";
+import { ClaudeCodeService } from "../../src/services/ClaudeCodeService";
+import { TaskItem, TaskOptions } from "../../src/core/models/Task";
+import { DEFAULT_MODEL } from "../../src/models/ClaudeModels";
+
+describe("Execution Session Isolation E2E Test", () => {
+  let claudeCodeService: ClaudeCodeService;
+  let capturedCommands: string[][];
+
+  function createTask(
+    name: string,
+    prompt: string,
+    resumeFromTaskId?: string,
+  ): TaskItem {
+    const task: TaskItem = {
+      id: `task_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+      name,
+      prompt,
+      status: "pending" as const,
+      model: DEFAULT_MODEL,
+    };
+
+    if (resumeFromTaskId) {
+      task.resumeFromTaskId = resumeFromTaskId;
+    }
+
+    return task;
+  }
+
+  beforeEach(async () => {
+    // Mock configuration service
+    const mockConfigService = {
+      get: jest.fn().mockReturnValue("claude"),
+      getConfig: jest.fn().mockReturnValue({}),
+    };
+
+    claudeCodeService = new ClaudeCodeService(mockConfigService as any);
+
+    // Capture all command executions
+    capturedCommands = [];
+    jest
+      .spyOn(claudeCodeService as any, "executeCommand")
+      .mockImplementation(async (...args: any[]) => {
+        const commandArgs = args[0] as string[];
+        capturedCommands.push([...commandArgs]);
+
+        // Mock successful execution with session ID
+        const sessionId = `mock-session-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        return {
+          success: true,
+          output: JSON.stringify({
+            result: `Mock output for: ${commandArgs[commandArgs.length - 1]}`,
+            session_id: sessionId,
+          }),
+          error: undefined,
+        };
+      });
+
+    jest.clearAllMocks();
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe("Session Isolation in Execution", () => {
+    test("should NOT pass session resume for independent tasks", async () => {
+      console.log("=== Testing Independent Task Execution ===");
+
+      const task1 = createTask("Task 1", "say a random number that is not 42");
+      const task2 = createTask("Task 2", "what is the previous random number?");
+
+      const tasks = [task1, task2];
+
+      const mockCallbacks = {
+        onProgress: jest.fn(),
+        onComplete: jest.fn(),
+        onError: jest.fn(),
+      };
+
+      await claudeCodeService.runTaskPipeline(
+        tasks,
+        DEFAULT_MODEL,
+        "/test/workspace",
+        { outputFormat: "json" },
+        mockCallbacks.onProgress,
+        mockCallbacks.onComplete,
+        mockCallbacks.onError,
+      );
+
+      console.log("Captured commands:");
+      capturedCommands.forEach((cmd, index) => {
+        console.log(`Task ${index + 1}:`, cmd.join(" "));
+      });
+
+      // Verify we have 2 commands (one per task)
+      expect(capturedCommands).toHaveLength(2);
+
+      // Task 1 should NOT have -r (resume) flag
+      const task1Command = capturedCommands[0];
+      expect(task1Command).not.toContain("-r");
+
+      // Task 2 should NOT have -r (resume) flag - THIS IS THE BUG
+      const task2Command = capturedCommands[1];
+      expect(task2Command).not.toContain("-r");
+
+      // Log if bug is present
+      if (task2Command.includes("-r")) {
+        const resumeIndex = task2Command.indexOf("-r");
+        console.log(
+          "BUG CONFIRMED: Task 2 has unexpected -r flag with session:",
+          task2Command[resumeIndex + 1],
+        );
+      }
+    });
+
+    test("should pass session resume ONLY when explicitly configured", async () => {
+      console.log("=== Testing Explicit Session Resume Execution ===");
+
+      const task1 = createTask("Task 1", "say a random number that is not 42");
+      const task2 = createTask(
+        "Task 2",
+        "what is the previous random number?",
+        task1.id,
+      );
+
+      const tasks = [task1, task2];
+
+      const mockCallbacks = {
+        onProgress: jest.fn(),
+        onComplete: jest.fn(),
+        onError: jest.fn(),
+      };
+
+      await claudeCodeService.runTaskPipeline(
+        tasks,
+        DEFAULT_MODEL,
+        "/test/workspace",
+        { outputFormat: "json" },
+        mockCallbacks.onProgress,
+        mockCallbacks.onComplete,
+        mockCallbacks.onError,
+      );
+
+      console.log("Captured commands for explicit resume:");
+      capturedCommands.forEach((cmd, index) => {
+        console.log(`Task ${index + 1}:`, cmd.join(" "));
+      });
+
+      // Verify we have 2 commands
+      expect(capturedCommands).toHaveLength(2);
+
+      // Task 1 should NOT have -r flag
+      const task1Command = capturedCommands[0];
+      expect(task1Command).not.toContain("-r");
+
+      // Task 2 SHOULD have -r flag (explicit resume)
+      const task2Command = capturedCommands[1];
+      expect(task2Command).toContain("-r");
+
+      // Verify the session ID is from task 1
+      const resumeIndex = task2Command.indexOf("-r");
+      expect(resumeIndex).toBeGreaterThan(-1);
+      expect(task2Command[resumeIndex + 1]).toBeDefined();
+    });
+
+    test("should validate buildTaskCommand behavior directly", () => {
+      console.log("=== Testing buildTaskCommand Directly ===");
+
+      // Test without resumeSessionId
+      const optionsWithoutResume: TaskOptions = {
+        outputFormat: "json",
+        allowAllTools: true,
+      };
+
+      const commandWithoutResume = (claudeCodeService as any).buildTaskCommand(
+        "test prompt",
+        DEFAULT_MODEL,
+        optionsWithoutResume,
+      );
+
+      console.log("Command without resume:", commandWithoutResume.join(" "));
+      expect(commandWithoutResume).not.toContain("-r");
+
+      // Test with resumeSessionId
+      const optionsWithResume: TaskOptions = {
+        outputFormat: "json",
+        allowAllTools: true,
+        resumeSessionId: "test-session-123",
+      };
+
+      const commandWithResume = (claudeCodeService as any).buildTaskCommand(
+        "test prompt",
+        DEFAULT_MODEL,
+        optionsWithResume,
+      );
+
+      console.log("Command with resume:", commandWithResume.join(" "));
+      expect(commandWithResume).toContain("-r");
+      expect(commandWithResume).toContain("test-session-123");
+    });
+  });
+});
diff --git a/tests/e2e/NewWorkflowButtonActionTest.test.ts b/tests/e2e/NewWorkflowButtonActionTest.test.ts
new file mode 100644
index 0000000..4aec792
--- /dev/null
+++ b/tests/e2e/NewWorkflowButtonActionTest.test.ts
@@ -0,0 +1,140 @@
+import { jest } from "@jest/globals";
+import { TaskItem } from "../../src/services/ClaudeCodeService";
+import { DEFAULT_MODEL } from "../../src/models/ClaudeModels";
+
+describe("New Workflow Button Action Test", () => {
+  let mockPipelineAddTask: jest.Mock;
+  let tasks: TaskItem[];
+
+  function generateTaskId(): string {
+    return `task_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  function createNewTask(): TaskItem {
+    const existingNumbers = tasks
+      .map((t) => {
+        const match = t.name?.match(/^Task (\d+)$/);
+        return match ? parseInt(match[1], 10) : 0;
+      })
+      .filter((n) => n > 0);
+
+    const nextNumber =
+      existingNumbers.length > 0
+        ? Math.max(...existingNumbers) + 1
+        : tasks.length + 1;
+
+    return {
+      id: generateTaskId(),
+      name: `Task ${nextNumber}`,
+      prompt: "",
+      status: "pending" as const,
+      model: DEFAULT_MODEL,
+    };
+  }
+
+  function simulateNewWorkflowButtonClick(): void {
+    console.log("🖱️ USER: Clicking 'New Workflow' button");
+
+    const newTask = createNewTask();
+    mockPipelineAddTask(newTask);
+    tasks.push(newTask);
+  }
+
+  beforeEach(() => {
+    tasks = [];
+    mockPipelineAddTask = jest.fn((task: TaskItem) => {
+      console.log(`✅ ACTION: pipelineAddTask called with task: ${task.name}`);
+    });
+
+    jest.clearAllMocks();
+  });
+
+  test("should call pipelineAddTask with correct task when New Workflow button is clicked", () => {
+    expect(tasks).toHaveLength(0);
+
+    simulateNewWorkflowButtonClick();
+
+    expect(mockPipelineAddTask).toHaveBeenCalledWith(
+      expect.objectContaining({
+        id: expect.stringMatching(/^task_\d+_[a-z0-9]+$/),
+        name: "Task 1",
+        prompt: "",
+        status: "pending",
+        model: DEFAULT_MODEL,
+      }),
+    );
+    expect(mockPipelineAddTask).toHaveBeenCalledTimes(1);
+    expect(tasks).toHaveLength(1);
+  });
+
+  test("should create task with correct sequential naming", () => {
+    simulateNewWorkflowButtonClick();
+    simulateNewWorkflowButtonClick();
+    simulateNewWorkflowButtonClick();
+
+    expect(tasks).toHaveLength(3);
+    expect(tasks[0].name).toBe("Task 1");
+    expect(tasks[1].name).toBe("Task 2");
+    expect(tasks[2].name).toBe("Task 3");
+
+    expect(mockPipelineAddTask).toHaveBeenCalledTimes(3);
+  });
+
+  test("should create tasks with unique IDs", () => {
+    const taskIds = new Set<string>();
+
+    for (let i = 0; i < 5; i++) {
+      simulateNewWorkflowButtonClick();
+      const taskId = tasks[i].id;
+
+      expect(taskIds.has(taskId)).toBe(false);
+      taskIds.add(taskId);
+      expect(taskId).toMatch(/^task_\d+_[a-z0-9]+$/);
+    }
+
+    expect(taskIds.size).toBe(5);
+  });
+
+  test("should use DEFAULT_MODEL for new tasks", () => {
+    simulateNewWorkflowButtonClick();
+
+    expect(tasks[0].model).toBe(DEFAULT_MODEL);
+    expect(typeof DEFAULT_MODEL).toBe("string");
+    expect(DEFAULT_MODEL.length).toBeGreaterThan(0);
+  });
+
+  test("should create pending tasks with empty prompts", () => {
+    simulateNewWorkflowButtonClick();
+
+    const task = tasks[0];
+    expect(task.status).toBe("pending");
+    expect(task.prompt).toBe("");
+    expect(typeof task.prompt).toBe("string");
+  });
+
+  test("should handle edge case numbering correctly", () => {
+    const existingTasks: TaskItem[] = [
+      {
+        id: generateTaskId(),
+        name: "Task 5",
+        prompt: "Existing task",
+        status: "pending",
+        model: DEFAULT_MODEL,
+      },
+      {
+        id: generateTaskId(),
+        name: "Custom Name",
+        prompt: "Non-numbered task",
+        status: "pending",
+        model: DEFAULT_MODEL,
+      },
+    ];
+
+    tasks.push(...existingTasks);
+
+    simulateNewWorkflowButtonClick();
+
+    expect(tasks).toHaveLength(3);
+    expect(tasks[2].name).toBe("Task 6");
+  });
+});
diff --git a/tests/e2e/NewWorkflowButtonE2E.test.ts b/tests/e2e/NewWorkflowButtonE2E.test.ts
new file mode 100644
index 0000000..5bb459a
--- /dev/null
+++ b/tests/e2e/NewWorkflowButtonE2E.test.ts
@@ -0,0 +1,366 @@
+import { jest } from "@jest/globals";
+import { PipelineService } from "../../src/services/PipelineService";
+import { TaskItem } from "../../src/services/ClaudeCodeService";
+import { DEFAULT_MODEL } from "../../src/models/ClaudeModels";
+
+interface NewWorkflowUIState {
+  hasTasks: boolean;
+  showNewWorkflowButton: boolean;
+  showWorkflowManagementButtons: boolean;
+  tasks: TaskItem[];
+}
+
+interface NewWorkflowActions {
+  pipelineAddTask: (task: TaskItem) => void;
+  pipelineClearAll: () => void;
+}
+
+describe("New Workflow Button E2E Tests", () => {
+  let uiState: NewWorkflowUIState;
+  let actions: NewWorkflowActions;
+  let tasks: TaskItem[];
+
+  function generateTaskId(): string {
+    return `task_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  function createNewTask(): TaskItem {
+    const existingNumbers = tasks
+      .map((t) => {
+        const match = t.name?.match(/^Task (\d+)$/);
+        return match ? parseInt(match[1], 10) : 0;
+      })
+      .filter((n) => n > 0);
+
+    const nextNumber =
+      existingNumbers.length > 0
+        ? Math.max(...existingNumbers) + 1
+        : tasks.length + 1;
+
+    return {
+      id: generateTaskId(),
+      name: `Task ${nextNumber}`,
+      prompt: "",
+      status: "pending" as const,
+      model: DEFAULT_MODEL,
+    };
+  }
+
+  function updateUIState(): void {
+    const hasTasks =
+      tasks.length > 0 && tasks.some((task) => task.prompt.trim());
+
+    uiState.hasTasks = hasTasks;
+    uiState.tasks = [...tasks];
+    uiState.showNewWorkflowButton = !hasTasks;
+    uiState.showWorkflowManagementButtons = hasTasks;
+  }
+
+  function simulateNewWorkflowClick(): void {
+    console.log(`🖱️  USER: Clicking "New Workflow" button`);
+
+    if (!uiState.showNewWorkflowButton) {
+      throw new Error("New Workflow button not visible to user!");
+    }
+
+    const newTask = createNewTask();
+    actions.pipelineAddTask(newTask);
+    tasks.push(newTask);
+    updateUIState();
+  }
+
+  function simulateClearAllClick(): void {
+    console.log(`🖱️  USER: Clicking "Clear All" button`);
+
+    if (!uiState.showWorkflowManagementButtons) {
+      throw new Error("Clear All button not visible to user!");
+    }
+
+    actions.pipelineClearAll();
+    tasks.length = 0;
+    updateUIState();
+  }
+
+  beforeEach(() => {
+    const mockContext = {
+      extensionPath: "/test",
+      globalStorageUri: { fsPath: "/tmp/test-storage" },
+    };
+
+    jest
+      .spyOn(PipelineService.prototype as any, "ensureDirectories")
+      .mockImplementation(() => Promise.resolve());
+
+    new PipelineService(mockContext as any);
+
+    tasks = [];
+
+    uiState = {
+      hasTasks: false,
+      showNewWorkflowButton: true,
+      showWorkflowManagementButtons: false,
+      tasks: [],
+    };
+
+    actions = {
+      pipelineAddTask: jest.fn((task: TaskItem) => {
+        console.log(
+          `✅ ACTION: pipelineAddTask called with task: ${task.name}`,
+        );
+      }),
+      pipelineClearAll: jest.fn(() => {
+        console.log(`✅ ACTION: pipelineClearAll called`);
+      }),
+    };
+
+    updateUIState();
+    jest.clearAllMocks();
+  });
+
+  describe("New Workflow Button Functionality", () => {
+    test("should show New Workflow button when no tasks exist", () => {
+      expect(uiState.showNewWorkflowButton).toBe(true);
+      expect(uiState.showWorkflowManagementButtons).toBe(false);
+      expect(uiState.hasTasks).toBe(false);
+      expect(tasks).toHaveLength(0);
+    });
+
+    test("should call pipelineAddTask when New Workflow button is clicked", () => {
+      simulateNewWorkflowClick();
+
+      expect(actions.pipelineAddTask).toHaveBeenCalledWith(
+        expect.objectContaining({
+          id: expect.stringMatching(/^task_\d+_[a-z0-9]+$/),
+          name: "Task 1",
+          prompt: "",
+          status: "pending",
+          model: DEFAULT_MODEL,
+        }),
+      );
+      expect(actions.pipelineAddTask).toHaveBeenCalledTimes(1);
+    });
+
+    test("should create first task with correct properties", () => {
+      simulateNewWorkflowClick();
+
+      expect(tasks).toHaveLength(1);
+      const task = tasks[0];
+
+      expect(task).toEqual(
+        expect.objectContaining({
+          id: expect.stringMatching(/^task_\d+_[a-z0-9]+$/),
+          name: "Task 1",
+          prompt: "",
+          status: "pending",
+          model: DEFAULT_MODEL,
+        }),
+      );
+    });
+
+    test("should hide New Workflow button after task creation (but before prompt)", () => {
+      simulateNewWorkflowClick();
+
+      expect(uiState.showNewWorkflowButton).toBe(false);
+      expect(uiState.showWorkflowManagementButtons).toBe(false);
+      expect(uiState.hasTasks).toBe(false);
+    });
+
+    test("should show workflow management buttons after adding task content", () => {
+      simulateNewWorkflowClick();
+
+      tasks[0].prompt = "Test task content";
+      updateUIState();
+
+      expect(uiState.showNewWorkflowButton).toBe(false);
+      expect(uiState.showWorkflowManagementButtons).toBe(true);
+      expect(uiState.hasTasks).toBe(true);
+    });
+  });
+
+  describe("Complete Workflow Creation Cycle", () => {
+    test("should handle full workflow creation and clearing cycle", () => {
+      console.log("=== STEP 1: Initial state ===");
+      expect(uiState.showNewWorkflowButton).toBe(true);
+      expect(tasks).toHaveLength(0);
+
+      console.log("=== STEP 2: Create new workflow ===");
+      simulateNewWorkflowClick();
+      expect(tasks).toHaveLength(1);
+      expect(uiState.showNewWorkflowButton).toBe(false);
+
+      console.log("=== STEP 3: Add content to task ===");
+      tasks[0].prompt = "My first workflow task";
+      updateUIState();
+      expect(uiState.showWorkflowManagementButtons).toBe(true);
+      expect(uiState.hasTasks).toBe(true);
+
+      console.log("=== STEP 4: Clear workflow ===");
+      simulateClearAllClick();
+      expect(actions.pipelineClearAll).toHaveBeenCalledTimes(1);
+      expect(tasks).toHaveLength(0);
+      expect(uiState.showNewWorkflowButton).toBe(true);
+      expect(uiState.showWorkflowManagementButtons).toBe(false);
+    });
+
+    test("should generate unique task IDs", () => {
+      const taskIds = new Set<string>();
+
+      for (let i = 0; i < 5; i++) {
+        simulateNewWorkflowClick();
+        const taskId = tasks[tasks.length - 1].id;
+
+        expect(taskIds.has(taskId)).toBe(false);
+        taskIds.add(taskId);
+        expect(taskId).toMatch(/^task_\d+_[a-z0-9]+$/);
+
+        tasks[tasks.length - 1].prompt = `Task ${i + 1} content`;
+        updateUIState();
+      }
+
+      expect(tasks).toHaveLength(5);
+      expect(taskIds.size).toBe(5);
+    });
+
+    test("should create tasks with sequential numbering", () => {
+      const taskNames: string[] = [];
+
+      for (let i = 0; i < 3; i++) {
+        simulateNewWorkflowClick();
+        taskNames.push(tasks[tasks.length - 1].name);
+
+        if (i < 2) {
+          tasks[tasks.length - 1].prompt = `Content ${i + 1}`;
+          updateUIState();
+        }
+      }
+
+      expect(taskNames).toEqual(["Task 1", "Task 2", "Task 3"]);
+    });
+  });
+
+  describe("Error Handling", () => {
+    test("should throw error when clicking invisible New Workflow button", () => {
+      tasks.push({
+        id: generateTaskId(),
+        name: "Task 1",
+        prompt: "Existing task",
+        status: "pending",
+        model: DEFAULT_MODEL,
+      });
+      updateUIState();
+
+      expect(() => simulateNewWorkflowClick()).toThrow(
+        "New Workflow button not visible to user!",
+      );
+    });
+
+    test("should throw error when clicking invisible Clear All button", () => {
+      expect(() => simulateClearAllClick()).toThrow(
+        "Clear All button not visible to user!",
+      );
+    });
+  });
+
+  describe("Real Component Integration", () => {
+    test("should use actual TaskItem interface structure", () => {
+      simulateNewWorkflowClick();
+
+      const task = tasks[0];
+
+      expect(task).toHaveProperty("id");
+      expect(task).toHaveProperty("name");
+      expect(task).toHaveProperty("prompt");
+      expect(task).toHaveProperty("status");
+      expect(task).toHaveProperty("model");
+
+      expect(typeof task.id).toBe("string");
+      expect(typeof task.name).toBe("string");
+      expect(typeof task.prompt).toBe("string");
+      expect(typeof task.status).toBe("string");
+      expect(typeof task.model).toBe("string");
+    });
+
+    test("should use DEFAULT_MODEL from actual configuration", () => {
+      simulateNewWorkflowClick();
+
+      expect(tasks[0].model).toBe(DEFAULT_MODEL);
+      expect(DEFAULT_MODEL).toBeTruthy();
+      expect(typeof DEFAULT_MODEL).toBe("string");
+    });
+
+    test("should call actual pipelineAddTask action", () => {
+      const addTaskSpy = actions.pipelineAddTask as jest.Mock;
+
+      simulateNewWorkflowClick();
+
+      expect(addTaskSpy).toHaveBeenCalled();
+      const calledWith = addTaskSpy.mock.calls[0][0];
+      expect(calledWith).toEqual(
+        expect.objectContaining({
+          id: expect.any(String),
+          name: expect.any(String),
+          prompt: expect.any(String),
+          status: "pending",
+          model: expect.any(String),
+        }),
+      );
+    });
+
+    test("should call actual pipelineClearAll action", () => {
+      simulateNewWorkflowClick();
+      tasks[0].prompt = "Content";
+      updateUIState();
+
+      const clearAllSpy = actions.pipelineClearAll as jest.Mock;
+
+      simulateClearAllClick();
+
+      expect(clearAllSpy).toHaveBeenCalledTimes(1);
+      expect(clearAllSpy).toHaveBeenCalledWith();
+    });
+  });
+
+  describe("UI State Consistency", () => {
+    test("should maintain correct button visibility throughout workflow lifecycle", () => {
+      const states: Array<{
+        step: string;
+        newBtn: boolean;
+        mgmtBtns: boolean;
+      }> = [];
+
+      function recordState(step: string) {
+        states.push({
+          step,
+          newBtn: uiState.showNewWorkflowButton,
+          mgmtBtns: uiState.showWorkflowManagementButtons,
+        });
+      }
+
+      recordState("initial");
+      expect(uiState.showNewWorkflowButton).toBe(true);
+
+      simulateNewWorkflowClick();
+      recordState("after new workflow");
+      expect(uiState.showNewWorkflowButton).toBe(false);
+
+      tasks[0].prompt = "Task content";
+      updateUIState();
+      recordState("after adding content");
+      expect(uiState.showWorkflowManagementButtons).toBe(true);
+
+      simulateClearAllClick();
+      recordState("after clear");
+      expect(uiState.showNewWorkflowButton).toBe(true);
+      expect(uiState.showWorkflowManagementButtons).toBe(false);
+
+      console.log("UI State transitions:", states);
+
+      expect(states).toEqual([
+        { step: "initial", newBtn: true, mgmtBtns: false },
+        { step: "after new workflow", newBtn: false, mgmtBtns: false },
+        { step: "after adding content", newBtn: false, mgmtBtns: true },
+        { step: "after clear", newBtn: true, mgmtBtns: false },
+      ]);
+    });
+  });
+});
diff --git a/tests/e2e/SaveWorkflowE2E.test.ts b/tests/e2e/SaveWorkflowE2E.test.ts
new file mode 100644
index 0000000..fa4bd2e
--- /dev/null
+++ b/tests/e2e/SaveWorkflowE2E.test.ts
@@ -0,0 +1,444 @@
+import { jest } from "@jest/globals";
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as os from "os";
+import { PipelineService } from "../../src/services/PipelineService";
+import { TaskItem } from "../../src/core/models/Task";
+import { DEFAULT_MODEL } from "../../src/models/ClaudeModels";
+import { ClaudeWorkflow } from "../../src/types/WorkflowTypes";
+import { WorkflowParser } from "../../src/services/WorkflowParser";
+
+describe("Save Workflow E2E Test", () => {
+  let pipelineService: PipelineService;
+  let testWorkflowsDir: string;
+  let testRootPath: string;
+  let tasks: TaskItem[];
+  let uiState: {
+    showSaveForm: boolean;
+    workflowName: string;
+    workflowDescription: string;
+    hasTasks: boolean;
+    hasValidTasks: boolean;
+  };
+
+  function createTask(name: string, prompt: string): TaskItem {
+    return {
+      id: `task_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+      name,
+      prompt,
+      status: "pending" as const,
+      model: DEFAULT_MODEL,
+    };
+  }
+
+  function simulateAddTask() {
+    const newTask = createTask("Task 1", "");
+    tasks.push(newTask);
+    updateUIState();
+  }
+
+  function simulateTaskContentEdit(taskIndex: number, prompt: string) {
+    tasks[taskIndex].prompt = prompt;
+    updateUIState();
+  }
+
+  function simulateSaveWorkflowClick() {
+    console.log("🖱️ USER: Clicking 'Save Workflow' button");
+    if (!uiState.hasValidTasks) {
+      throw new Error("Save Workflow button should be disabled!");
+    }
+    uiState.showSaveForm = true;
+  }
+
+  function simulateFormFill(name: string, description: string) {
+    console.log(
+      `📝 USER: Filling form - name: "${name}", description: "${description}"`,
+    );
+    uiState.workflowName = name;
+    uiState.workflowDescription = description;
+  }
+
+  async function simulateFormSaveClick() {
+    console.log("🖱️ USER: Clicking 'Save' button in form");
+
+    if (!uiState.workflowName.trim()) {
+      throw new Error("Save button should be disabled when name is empty!");
+    }
+
+    const validTasks = tasks.filter((task) => task.prompt.trim());
+
+    console.log(`💾 SYSTEM: Calling savePipeline with:`, {
+      name: uiState.workflowName.trim(),
+      description: uiState.workflowDescription.trim(),
+      taskCount: validTasks.length,
+    });
+
+    // Actually save the pipeline using the real service
+    await pipelineService.savePipeline(
+      uiState.workflowName.trim(),
+      uiState.workflowDescription.trim(),
+      validTasks,
+      DEFAULT_MODEL,
+      true, // allowAllTools
+    );
+
+    uiState.showSaveForm = false;
+    uiState.workflowName = "";
+    uiState.workflowDescription = "";
+  }
+
+  function updateUIState() {
+    uiState.hasTasks = tasks.length > 0;
+    uiState.hasValidTasks =
+      tasks.length > 0 && tasks.some((task) => task.prompt.trim());
+  }
+
+  beforeEach(async () => {
+    // Create temporary directory for test
+    testRootPath = await fs.mkdtemp(
+      path.join(os.tmpdir(), "claude-runner-test-"),
+    );
+    testWorkflowsDir = path.join(testRootPath, ".github", "workflows");
+
+    const mockContext = {
+      extensionPath: "/test",
+      globalStorageUri: { fsPath: "/tmp/test-storage" },
+    };
+
+    // Mock ensureDirectories to avoid environment side effects (per guidelines)
+    jest
+      .spyOn(PipelineService.prototype as any, "ensureDirectories")
+      .mockImplementation(() => Promise.resolve());
+
+    // Create real PipelineService and set test root path
+    pipelineService = new PipelineService(mockContext as any);
+    await pipelineService.setRootPath(testRootPath);
+
+    // Create the workflows directory manually for real file operations
+    await fs.mkdir(testWorkflowsDir, { recursive: true });
+
+    tasks = [];
+    uiState = {
+      showSaveForm: false,
+      workflowName: "",
+      workflowDescription: "",
+      hasTasks: false,
+      hasValidTasks: false,
+    };
+
+    jest.clearAllMocks();
+  });
+
+  afterEach(async () => {
+    // Clean up temporary directory
+    try {
+      await fs.rm(testRootPath, { recursive: true, force: true });
+    } catch (error) {
+      console.warn("Failed to clean up test directory:", error);
+    }
+  });
+
+  describe("Complete Save Workflow Journey", () => {
+    test("should save workflow when user completes full flow", async () => {
+      console.log("=== STEP 1: Initial state (no tasks) ===");
+      expect(uiState.hasTasks).toBe(false);
+      expect(uiState.hasValidTasks).toBe(false);
+
+      console.log("=== STEP 2: Add new task ===");
+      simulateAddTask();
+      expect(tasks).toHaveLength(1);
+      expect(uiState.hasTasks).toBe(true);
+      expect(uiState.hasValidTasks).toBe(false); // No content yet
+
+      console.log("=== STEP 3: Add content to task ===");
+      simulateTaskContentEdit(0, "Test workflow task prompt");
+      expect(uiState.hasValidTasks).toBe(true);
+
+      console.log("=== STEP 4: Click Save Workflow button ===");
+      simulateSaveWorkflowClick();
+      expect(uiState.showSaveForm).toBe(true);
+
+      console.log("=== STEP 5: Fill save form ===");
+      simulateFormFill("My Test Workflow", "A workflow for testing");
+      expect(uiState.workflowName).toBe("My Test Workflow");
+      expect(uiState.workflowDescription).toBe("A workflow for testing");
+
+      console.log("=== STEP 6: Click Save button in form ===");
+      await simulateFormSaveClick();
+
+      console.log("=== STEP 7: Verify file was actually saved ===");
+      const expectedFilename = "claude-my-test-workflow.yml";
+      const expectedFilePath = path.join(testWorkflowsDir, expectedFilename);
+
+      // Check file exists
+      const fileExists = await fs
+        .access(expectedFilePath)
+        .then(() => true)
+        .catch(() => false);
+      expect(fileExists).toBe(true);
+
+      // Read and verify file content
+      const fileContent = await fs.readFile(expectedFilePath, "utf-8");
+      const parsedWorkflow: ClaudeWorkflow =
+        WorkflowParser.parseYaml(fileContent);
+
+      expect(parsedWorkflow.name).toBe("My Test Workflow");
+      expect(
+        parsedWorkflow.on?.workflow_dispatch?.inputs?.description?.description,
+      ).toBe("A workflow for testing");
+      expect(parsedWorkflow.jobs.pipeline.steps).toHaveLength(1);
+      expect(parsedWorkflow.jobs.pipeline.steps[0]?.with?.prompt).toBe(
+        "Test workflow task prompt",
+      );
+      expect(parsedWorkflow.jobs.pipeline.steps[0]?.with?.model).toBe(
+        DEFAULT_MODEL,
+      );
+      expect(parsedWorkflow.jobs.pipeline.steps[0]?.with?.allow_all_tools).toBe(
+        true,
+      );
+
+      console.log("=== STEP 8: Verify form closed and cleared ===");
+      expect(uiState.showSaveForm).toBe(false);
+      expect(uiState.workflowName).toBe("");
+      expect(uiState.workflowDescription).toBe("");
+    });
+
+    test("should handle save with multiple tasks", async () => {
+      console.log("=== Creating workflow with multiple tasks ===");
+
+      simulateAddTask();
+      simulateTaskContentEdit(0, "First task prompt");
+
+      const secondTask = createTask("Task 2", "Second task prompt");
+      tasks.push(secondTask);
+      updateUIState();
+
+      const thirdTask = createTask("Task 3", ""); // Empty task
+      tasks.push(thirdTask);
+      updateUIState();
+
+      expect(tasks).toHaveLength(3);
+      expect(uiState.hasValidTasks).toBe(true);
+
+      simulateSaveWorkflowClick();
+      simulateFormFill("Multi Task Workflow", "Workflow with multiple tasks");
+      await simulateFormSaveClick();
+
+      const validTasks = tasks.filter((task) => task.prompt.trim());
+      expect(validTasks).toHaveLength(2); // Only tasks with content
+
+      // Verify file was created
+      const expectedFilename = "claude-multi-task-workflow.yml";
+      const expectedFilePath = path.join(testWorkflowsDir, expectedFilename);
+
+      const fileExists = await fs
+        .access(expectedFilePath)
+        .then(() => true)
+        .catch(() => false);
+      expect(fileExists).toBe(true);
+
+      // Read and verify file content
+      const fileContent = await fs.readFile(expectedFilePath, "utf-8");
+      const parsedWorkflow: ClaudeWorkflow =
+        WorkflowParser.parseYaml(fileContent);
+
+      expect(parsedWorkflow.name).toBe("Multi Task Workflow");
+      expect(parsedWorkflow.jobs.pipeline.steps).toHaveLength(2); // Only valid tasks
+      expect(parsedWorkflow.jobs.pipeline.steps[0]?.with?.prompt).toBe(
+        "First task prompt",
+      );
+      expect(parsedWorkflow.jobs.pipeline.steps[1]?.with?.prompt).toBe(
+        "Second task prompt",
+      );
+    });
+
+    test("should handle save with no description", async () => {
+      simulateAddTask();
+      simulateTaskContentEdit(0, "Task with no description");
+
+      simulateSaveWorkflowClick();
+      simulateFormFill("No Description Workflow", "");
+      await simulateFormSaveClick();
+
+      // Verify file was created
+      const expectedFilename = "claude-no-description-workflow.yml";
+      const expectedFilePath = path.join(testWorkflowsDir, expectedFilename);
+
+      const fileExists = await fs
+        .access(expectedFilePath)
+        .then(() => true)
+        .catch(() => false);
+      expect(fileExists).toBe(true);
+
+      // Read and verify file content
+      const fileContent = await fs.readFile(expectedFilePath, "utf-8");
+      const parsedWorkflow: ClaudeWorkflow =
+        WorkflowParser.parseYaml(fileContent);
+
+      expect(parsedWorkflow.name).toBe("No Description Workflow");
+      expect(
+        parsedWorkflow.on?.workflow_dispatch?.inputs?.description?.description,
+      ).toBe("Pipeline execution");
+    });
+
+    test("should trim whitespace from workflow name and description", async () => {
+      simulateAddTask();
+      simulateTaskContentEdit(0, "Test task");
+
+      simulateSaveWorkflowClick();
+      simulateFormFill("  Trimmed Workflow  ", "  Description with spaces  ");
+      await simulateFormSaveClick();
+
+      // Verify file was created with trimmed name
+      const expectedFilename = "claude-trimmed-workflow.yml";
+      const expectedFilePath = path.join(testWorkflowsDir, expectedFilename);
+
+      const fileExists = await fs
+        .access(expectedFilePath)
+        .then(() => true)
+        .catch(() => false);
+      expect(fileExists).toBe(true);
+
+      // Read and verify file content
+      const fileContent = await fs.readFile(expectedFilePath, "utf-8");
+      const parsedWorkflow: ClaudeWorkflow =
+        WorkflowParser.parseYaml(fileContent);
+
+      expect(parsedWorkflow.name).toBe("Trimmed Workflow");
+      expect(
+        parsedWorkflow.on?.workflow_dispatch?.inputs?.description?.description,
+      ).toBe("Description with spaces");
+    });
+  });
+
+  describe("Save Button State Management", () => {
+    test("should disable Save Workflow button when no valid tasks", () => {
+      simulateAddTask();
+      expect(uiState.hasValidTasks).toBe(false);
+
+      expect(() => simulateSaveWorkflowClick()).toThrow(
+        "Save Workflow button should be disabled!",
+      );
+    });
+
+    test("should disable form Save button when name is empty", async () => {
+      simulateAddTask();
+      simulateTaskContentEdit(0, "Test task");
+      simulateSaveWorkflowClick();
+
+      simulateFormFill("", "Description");
+
+      await expect(simulateFormSaveClick()).rejects.toThrow(
+        "Save button should be disabled when name is empty!",
+      );
+    });
+
+    test("should allow save with empty description but valid name", async () => {
+      simulateAddTask();
+      simulateTaskContentEdit(0, "Test task");
+      simulateSaveWorkflowClick();
+
+      simulateFormFill("Valid Name", "");
+
+      await expect(simulateFormSaveClick()).resolves.not.toThrow();
+
+      // Verify file was created
+      const expectedFilename = "claude-valid-name.yml";
+      const expectedFilePath = path.join(testWorkflowsDir, expectedFilename);
+
+      const fileExists = await fs
+        .access(expectedFilePath)
+        .then(() => true)
+        .catch(() => false);
+      expect(fileExists).toBe(true);
+    });
+  });
+
+  describe("Real Component Integration", () => {
+    test("should use actual TaskItem structure", () => {
+      simulateAddTask();
+
+      const task = tasks[0];
+      expect(task).toHaveProperty("id");
+      expect(task).toHaveProperty("name");
+      expect(task).toHaveProperty("prompt");
+      expect(task).toHaveProperty("status");
+      expect(task).toHaveProperty("model");
+
+      expect(typeof task.id).toBe("string");
+      expect(typeof task.name).toBe("string");
+      expect(typeof task.prompt).toBe("string");
+      expect(task.status).toBe("pending");
+      expect(task.model).toBe(DEFAULT_MODEL);
+    });
+
+    test("should filter tasks correctly for save", async () => {
+      const tasksWithMixedContent = [
+        createTask("Task 1", "Valid content"),
+        createTask("Task 2", ""),
+        createTask("Task 3", "   "), // Only whitespace
+        createTask("Task 4", "Another valid task"),
+      ];
+
+      tasks.push(...tasksWithMixedContent);
+      updateUIState();
+
+      simulateSaveWorkflowClick();
+      simulateFormFill("Test Workflow", "Test");
+      await simulateFormSaveClick();
+
+      // Verify only valid tasks were saved
+      const expectedFilename = "claude-test-workflow.yml";
+      const expectedFilePath = path.join(testWorkflowsDir, expectedFilename);
+
+      const fileContent = await fs.readFile(expectedFilePath, "utf-8");
+      const parsedWorkflow: ClaudeWorkflow =
+        WorkflowParser.parseYaml(fileContent);
+
+      expect(parsedWorkflow.jobs.pipeline.steps).toHaveLength(2);
+      expect(parsedWorkflow.jobs.pipeline.steps[0]?.with?.prompt).toBe(
+        "Valid content",
+      );
+      expect(parsedWorkflow.jobs.pipeline.steps[1]?.with?.prompt).toBe(
+        "Another valid task",
+      );
+    });
+  });
+
+  describe("Error Scenarios", () => {
+    test("should handle file system errors gracefully", async () => {
+      // Make the test directory read-only to simulate permission errors
+      await fs.mkdir(testWorkflowsDir, { recursive: true });
+      await fs.chmod(testWorkflowsDir, 0o444); // Read-only
+
+      simulateAddTask();
+      simulateTaskContentEdit(0, "Test task");
+      simulateSaveWorkflowClick();
+      simulateFormFill("Test Workflow", "Test");
+
+      await expect(simulateFormSaveClick()).rejects.toThrow();
+
+      // Reset permissions for cleanup
+      await fs.chmod(testWorkflowsDir, 0o755);
+    });
+
+    test("should handle invalid workflow name characters", async () => {
+      simulateAddTask();
+      simulateTaskContentEdit(0, "Test task");
+      simulateSaveWorkflowClick();
+      simulateFormFill("Test/Workflow\\With<>Special*Characters", "Test");
+      await simulateFormSaveClick();
+
+      // Verify file was created with sanitized name (matches PipelineService logic)
+      const expectedFilename =
+        "claude-test-workflow-with--special-characters.yml";
+      const expectedFilePath = path.join(testWorkflowsDir, expectedFilename);
+
+      const fileExists = await fs
+        .access(expectedFilePath)
+        .then(() => true)
+        .catch(() => false);
+      expect(fileExists).toBe(true);
+    });
+  });
+});
diff --git a/tests/e2e/SessionIsolationE2E.test.ts b/tests/e2e/SessionIsolationE2E.test.ts
new file mode 100644
index 0000000..22bcb1c
--- /dev/null
+++ b/tests/e2e/SessionIsolationE2E.test.ts
@@ -0,0 +1,260 @@
+import { jest } from "@jest/globals";
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as os from "os";
+import { PipelineService } from "../../src/services/PipelineService";
+import { TaskItem } from "../../src/core/models/Task";
+import { DEFAULT_MODEL } from "../../src/models/ClaudeModels";
+import { ClaudeWorkflow } from "../../src/types/WorkflowTypes";
+import { WorkflowParser } from "../../src/services/WorkflowParser";
+
+describe("Session Isolation E2E Test", () => {
+  let pipelineService: PipelineService;
+  let testWorkflowsDir: string;
+  let testRootPath: string;
+
+  beforeEach(async () => {
+    // Create temporary directory for test
+    testRootPath = await fs.mkdtemp(
+      path.join(os.tmpdir(), "claude-runner-session-test-"),
+    );
+    testWorkflowsDir = path.join(testRootPath, ".github", "workflows");
+
+    const mockContext = {
+      extensionPath: "/test",
+      globalStorageUri: { fsPath: "/tmp/test-storage" },
+    };
+
+    // Mock ensureDirectories to avoid environment side effects (per guidelines)
+    jest
+      .spyOn(PipelineService.prototype as any, "ensureDirectories")
+      .mockImplementation(() => Promise.resolve());
+
+    // Create real PipelineService and set test root path
+    pipelineService = new PipelineService(mockContext as any);
+    await pipelineService.setRootPath(testRootPath);
+
+    // Create the workflows directory manually for real file operations
+    await fs.mkdir(testWorkflowsDir, { recursive: true });
+
+    jest.clearAllMocks();
+  });
+
+  afterEach(async () => {
+    // Clean up temporary directory
+    try {
+      await fs.rm(testRootPath, { recursive: true, force: true });
+    } catch (error) {
+      console.warn("Failed to clean up test directory:", error);
+    }
+  });
+
+  function createTask(
+    name: string,
+    prompt: string,
+    resumeFromTaskId?: string,
+  ): TaskItem {
+    const task: TaskItem = {
+      id: `task_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+      name,
+      prompt,
+      status: "pending" as const,
+      model: DEFAULT_MODEL,
+    };
+
+    if (resumeFromTaskId) {
+      task.resumeFromTaskId = resumeFromTaskId;
+    }
+
+    return task;
+  }
+
+  describe("Session Isolation Validation", () => {
+    test("should NOT add resume_session when tasks are independent", async () => {
+      console.log("=== Testing Independent Tasks (No Session Sharing) ===");
+
+      const task1 = createTask("Task 1", "say a random number that is not 42");
+      const task2 = createTask("Task 2", "what is the previous random number?");
+
+      const tasks = [task1, task2];
+
+      await pipelineService.savePipeline(
+        "Session Isolation Test",
+        "Test that independent tasks don't share sessions",
+        tasks,
+        DEFAULT_MODEL,
+        true,
+      );
+
+      // Read and verify the workflow file
+      const expectedFilename = "claude-session-isolation-test.yml";
+      const expectedFilePath = path.join(testWorkflowsDir, expectedFilename);
+
+      const fileContent = await fs.readFile(expectedFilePath, "utf-8");
+      const parsedWorkflow: ClaudeWorkflow =
+        WorkflowParser.parseYaml(fileContent);
+
+      console.log(
+        "Generated workflow steps:",
+        JSON.stringify(parsedWorkflow.jobs.pipeline.steps, null, 2),
+      );
+
+      // Verify Task 1 has NO resume_session
+      expect(
+        parsedWorkflow.jobs.pipeline.steps[0]?.with?.resume_session,
+      ).toBeUndefined();
+
+      // Verify Task 2 has NO resume_session (this is the bug we're testing)
+      expect(
+        parsedWorkflow.jobs.pipeline.steps[1]?.with?.resume_session,
+      ).toBeUndefined();
+
+      // Verify Task 1 has NO output_session (since no task references it)
+      expect(
+        parsedWorkflow.jobs.pipeline.steps[0]?.with?.output_session,
+      ).toBeUndefined();
+    });
+
+    test("should add resume_session ONLY when explicitly configured", async () => {
+      console.log("=== Testing Explicit Session Resume ===");
+
+      const task1 = createTask("Task 1", "say a random number that is not 42");
+      const task2 = createTask(
+        "Task 2",
+        "what is the previous random number?",
+        task1.id,
+      );
+
+      const tasks = [task1, task2];
+
+      await pipelineService.savePipeline(
+        "Explicit Session Resume Test",
+        "Test that explicit session resume works correctly",
+        tasks,
+        DEFAULT_MODEL,
+        true,
+      );
+
+      // Read and verify the workflow file
+      const expectedFilename = "claude-explicit-session-resume-test.yml";
+      const expectedFilePath = path.join(testWorkflowsDir, expectedFilename);
+
+      const fileContent = await fs.readFile(expectedFilePath, "utf-8");
+      const parsedWorkflow: ClaudeWorkflow =
+        WorkflowParser.parseYaml(fileContent);
+
+      console.log(
+        "Generated workflow steps:",
+        JSON.stringify(parsedWorkflow.jobs.pipeline.steps, null, 2),
+      );
+
+      // Verify Task 1 has NO resume_session
+      expect(
+        parsedWorkflow.jobs.pipeline.steps[0]?.with?.resume_session,
+      ).toBeUndefined();
+
+      // Verify Task 1 HAS output_session (since Task 2 references it)
+      expect(parsedWorkflow.jobs.pipeline.steps[0]?.with?.output_session).toBe(
+        true,
+      );
+
+      // Verify Task 2 HAS resume_session pointing to Task 1
+      expect(parsedWorkflow.jobs.pipeline.steps[1]?.with?.resume_session).toBe(
+        task1.id,
+      );
+    });
+
+    test("should handle complex session chains correctly", async () => {
+      console.log("=== Testing Complex Session Chains ===");
+
+      const task1 = createTask("Task 1", "Generate a UUID");
+      const task2 = createTask("Task 2", "Say hello world"); // Independent
+      const task3 = createTask(
+        "Task 3",
+        "What was the UUID from earlier?",
+        task1.id,
+      ); // Resume from task1
+      const task4 = createTask("Task 4", "What was the greeting?", task2.id); // Resume from task2
+
+      const tasks = [task1, task2, task3, task4];
+
+      await pipelineService.savePipeline(
+        "Complex Session Chains Test",
+        "Test complex session chain handling",
+        tasks,
+        DEFAULT_MODEL,
+        true,
+      );
+
+      const expectedFilename = "claude-complex-session-chains-test.yml";
+      const expectedFilePath = path.join(testWorkflowsDir, expectedFilename);
+
+      const fileContent = await fs.readFile(expectedFilePath, "utf-8");
+      const parsedWorkflow: ClaudeWorkflow =
+        WorkflowParser.parseYaml(fileContent);
+
+      const steps = parsedWorkflow.jobs.pipeline.steps;
+
+      // Task 1: No resume, has output (task3 references it)
+      expect(steps[0]?.with?.resume_session).toBeUndefined();
+      expect(steps[0]?.with?.output_session).toBe(true);
+
+      // Task 2: No resume, has output (task4 references it)
+      expect(steps[1]?.with?.resume_session).toBeUndefined();
+      expect(steps[1]?.with?.output_session).toBe(true);
+
+      // Task 3: Resumes from task1, no output
+      expect(steps[2]?.with?.resume_session).toBe(task1.id);
+      expect(steps[2]?.with?.output_session).toBeUndefined();
+
+      // Task 4: Resumes from task2, no output
+      expect(steps[3]?.with?.resume_session).toBe(task2.id);
+      expect(steps[3]?.with?.output_session).toBeUndefined();
+    });
+  });
+
+  describe("Current Bug Demonstration", () => {
+    test("should demonstrate the current session sharing bug", async () => {
+      console.log("=== Demonstrating Current Bug ===");
+      console.log("This test shows how the system incorrectly shares sessions");
+
+      // Create the exact workflow from the bug report
+      const task1 = createTask("Task 1", "say a random number that is not 42");
+      const task2 = createTask("Task 2", "what is the previous random number?");
+
+      const tasks = [task1, task2];
+
+      await pipelineService.savePipeline(
+        "test-session",
+        "Pipeline execution",
+        tasks,
+        DEFAULT_MODEL,
+        true,
+      );
+
+      const expectedFilename = "claude-test-session.yml";
+      const expectedFilePath = path.join(testWorkflowsDir, expectedFilename);
+
+      const fileContent = await fs.readFile(expectedFilePath, "utf-8");
+      const parsedWorkflow: ClaudeWorkflow =
+        WorkflowParser.parseYaml(fileContent);
+
+      console.log("Bug demonstration - workflow content:");
+      console.log(fileContent);
+
+      // This should pass if the bug is fixed
+      // Currently this will fail because the system incorrectly creates session links
+      expect(
+        parsedWorkflow.jobs.pipeline.steps[1]?.with?.resume_session,
+      ).toBeUndefined();
+
+      // Log the actual behavior for debugging
+      if (parsedWorkflow.jobs.pipeline.steps[1]?.with?.resume_session) {
+        console.log(
+          "BUG CONFIRMED: Task 2 has unexpected resume_session:",
+          parsedWorkflow.jobs.pipeline.steps[1]?.with?.resume_session,
+        );
+      }
+    });
+  });
+});
diff --git a/tests/fixtures/workflows/isolated-tasks.yml b/tests/fixtures/workflows/isolated-tasks.yml
new file mode 100644
index 0000000..de4fba5
--- /dev/null
+++ b/tests/fixtures/workflows/isolated-tasks.yml
@@ -0,0 +1,27 @@
+name: isolated-tasks
+'on':
+  workflow_dispatch:
+    inputs:
+      description:
+        description: Test workflow with isolated tasks
+        required: false
+        type: string
+jobs:
+  pipeline:
+    name: Pipeline Execution
+    runs-on: ubuntu-latest
+    steps:
+      - id: task_generate_number
+        name: Generate Random Number
+        uses: anthropics/claude-pipeline-action@v1
+        with:
+          prompt: say a random number that is not 42
+          model: claude-sonnet-4-20250514
+          allow_all_tools: true
+      - id: task_ask_previous
+        name: Ask About Previous Number
+        uses: anthropics/claude-pipeline-action@v1
+        with:
+          prompt: what is the previous random number?
+          model: claude-sonnet-4-20250514
+          allow_all_tools: true
\ No newline at end of file
diff --git a/tests/fixtures/workflows/session-continuity.yml b/tests/fixtures/workflows/session-continuity.yml
new file mode 100644
index 0000000..cd63722
--- /dev/null
+++ b/tests/fixtures/workflows/session-continuity.yml
@@ -0,0 +1,29 @@
+name: session-continuity
+'on':
+  workflow_dispatch:
+    inputs:
+      description:
+        description: Test workflow with explicit session continuity
+        required: false
+        type: string
+jobs:
+  pipeline:
+    name: Pipeline Execution
+    runs-on: ubuntu-latest
+    steps:
+      - id: task_generate_number
+        name: Generate Random Number
+        uses: anthropics/claude-pipeline-action@v1
+        with:
+          prompt: say a random number that is not 42
+          model: claude-sonnet-4-20250514
+          allow_all_tools: true
+          output_session: true
+      - id: task_ask_previous
+        name: Ask About Previous Number
+        uses: anthropics/claude-pipeline-action@v1
+        with:
+          prompt: what is the previous random number?
+          model: claude-sonnet-4-20250514
+          allow_all_tools: true
+          resume_session: task_generate_number
\ No newline at end of file
diff --git a/tests/unit/NewWorkflowButton.test.ts b/tests/unit/NewWorkflowButton.test.ts
new file mode 100644
index 0000000..ef26670
--- /dev/null
+++ b/tests/unit/NewWorkflowButton.test.ts
@@ -0,0 +1,65 @@
+import { TaskItem } from "../../src/services/ClaudeCodeService";
+import { DEFAULT_MODEL } from "../../src/models/ClaudeModels";
+
+describe("New Workflow Button - Core Logic Test", () => {
+  test("should create new task with correct properties", () => {
+    const newTask: TaskItem = {
+      id: `task_${Date.now()}_test123`,
+      name: "Task 1",
+      prompt: "",
+      status: "pending",
+      model: DEFAULT_MODEL,
+    };
+
+    expect(newTask.name).toBe("Task 1");
+    expect(newTask.prompt).toBe("");
+    expect(newTask.status).toBe("pending");
+    expect(newTask.model).toBe(DEFAULT_MODEL);
+    expect(newTask.id).toContain("task_");
+  });
+
+  test("should use correct default model", () => {
+    expect(DEFAULT_MODEL).toBeTruthy();
+    expect(typeof DEFAULT_MODEL).toBe("string");
+    expect(DEFAULT_MODEL.length).toBeGreaterThan(0);
+  });
+
+  test("should handle task numbering logic", () => {
+    const tasks: TaskItem[] = [];
+
+    function getNextTaskNumber(existingTasks: TaskItem[]): number {
+      const existingNumbers = existingTasks
+        .map((t) => {
+          const match = t.name?.match(/^Task (\d+)$/);
+          return match ? parseInt(match[1], 10) : 0;
+        })
+        .filter((n) => n > 0);
+
+      return existingNumbers.length > 0
+        ? Math.max(...existingNumbers) + 1
+        : existingTasks.length + 1;
+    }
+
+    expect(getNextTaskNumber(tasks)).toBe(1);
+
+    tasks.push({
+      id: "test1",
+      name: "Task 1",
+      prompt: "",
+      status: "pending",
+      model: DEFAULT_MODEL,
+    });
+
+    expect(getNextTaskNumber(tasks)).toBe(2);
+
+    tasks.push({
+      id: "test2",
+      name: "Task 5",
+      prompt: "",
+      status: "pending",
+      model: DEFAULT_MODEL,
+    });
+
+    expect(getNextTaskNumber(tasks)).toBe(6);
+  });
+});
diff --git a/tests/unit/services/CommandsService.test.ts b/tests/unit/services/CommandsService.test.ts
index 3e31b5a..f32aaf4 100644
--- a/tests/unit/services/CommandsService.test.ts
+++ b/tests/unit/services/CommandsService.test.ts
@@ -273,7 +273,7 @@ describe("CommandsService", () => {
   });
 
   describe("openCommandFile", () => {
-    it("should open command file successfully", async () => {
+    it("should slash open commands file successfully", async () => {
       const filePath = "/test/command.md";
       mockVSCode.window.showTextDocument.mockResolvedValue(undefined);
 

From ac926eac08b3f7737d527fc59492603ab4e506e9 Mon Sep 17 00:00:00 2001
From: Mehdi <mehdi@blagui.com>
Date: Mon, 7 Jul 2025 02:18:47 +0000
Subject: [PATCH 2/2] update patch

---
 VERSION      | 2 +-
 package.json | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/VERSION b/VERSION
index 9325c3c..a2268e2 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.3.0
\ No newline at end of file
+0.3.1
\ No newline at end of file
diff --git a/package.json b/package.json
index 1a29bb3..7ef2659 100644
--- a/package.json
+++ b/package.json
@@ -2,7 +2,7 @@
   "name": "claude-runner",
   "displayName": "Claude Runner",
   "description": "Execute Claude Code commands directly from VS Code with an intuitive interface",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "publisher": "Codingworkflow",
   "private": false,
   "license": "GPL-3.0",